text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Автоматически убираем фон у сфотографированного текста в Photoshop или ImageMagick
Хочу поделиться трюком, который немного помогает улучшить качество при печати в ч/б всякого рода конспектов, если их почему-то «оцифровали» фотоаппаратом вместо сканера.
Собственно главная проблема с такими фотографиями в отличие от сканов, это неравномерность яркости фона, порой настолько, что текст на таком тёмном фоне становится плохо читаем после печати на лазерном ч/б принтере. Как пример такой «неравномерности»:
Идея заключается в том чтобы выделить из страницы что-то похожее на её фон и «вычесть» его из неё самой, и тем самым уничтожить хотя бы часть фона и перепадов яркости.
Ближе к делу. Допустим у нас есть пара десятков, сфотографированных в похожих условиях страничек. Типа такой, но можно и хуже:
Открываем какую-нибудь из страниц в Photoshop и делаем копию основного слоя:
Инвертируем верхний слой:
размываем его с помощью Gaussian Blur
… очень важно правильно выбрать радиус размытия: с одной стороны он должен быть больше характерного размера букв, — нам нужно уничтожить все детали, с другой стороны слишком сильно размытый слой не сможет передать градиент фона, который мы пытаемся извести. Оптимальный радиус это где-то 1.5-3 размера высоты строки:
осталось только изменить метод наложения слоёв, лучше всего то, что надо делает Color Dodge:
всё, градиента больше нет:
можно слить слои вмести и подкрутить яркость и уровни по вкусу (тут всё сильно зависит от конкретных условий съёмки, тогда как предидущие шаги в высокой степени универсальны).
Теперь, попрактиковавшись, можно перейти к автоматизации процесса:
отменяем всё что сделали с картинкой и начинаем запись макроса:
под запись повторяем всё что делали в начале статьи — от клонирования слоя, до мёржа слоёв и подкрутки яркости.
Останавливаем запись макроса и идём в File => Automate => Batch…
Там выбираем откуда брать фотки страниц и куда их потом сохранять:
Процесс не шибко быстрый, зато полностью автоматизированный.
Надеюсь кому-нибудь пригодится, самому давно не актуально.
UPD: рекомендую после сведения слоев проходиться Unsharp Mask (я использовал параметры: радиус 5 пикселей / 150%) (с) [not\_ice](https://geektimes.ru/users/not_ice/)
UPD: тоже самое с помощью [ImageMagick](http://www.imagemagick.org/script/binary-releases.php#windows) можно сделать, например, вот такой командой
`convert.exe src.jpg ( +clone -negate -virtual-pixel edge -gaussian-blur 30x10 ) -background none -compose colordodge -flatten result.jpg`
Критика и улучшения приветствуются. | https://habr.com/ru/post/67976/ | null | ru | null |
# Импорт и преобразование словаря LinguaLeo в флэш-карты Anki
Постановка проблемы
-------------------
Те, кто учат английский язык наверняка знакомы с Anki — программой для запоминания слов, выражений и любой другой информации с помощью интервальных повторений.
Другой популярный сервис, не нуждающийся в представлении — LinguaLeo позволяет при чтении оригинального текста сразу отправлять незнакомые слова на изучение, сохраняя их в собственном словаре вместе с произношением, изображением, транскрипцией слова и контекстом в котором оно употребляется. Пару лет назад LinguaLeo внедрили систему интервальных повторений, но в отличии от Anki система повторений не такая мощная и не содержит в себе возможностей настройки.
Что если нам попытаться ~~скрестить ужа с ежом~~ использовать преимущества двух платформ? Взять сами слова из Лингва Лео вместе со всеми медиафайлами и информацией и использовать ресурсы Anki для их запоминания.
Обзор готовых решений
---------------------
Для задачи уже существуют несколько готовых решений, но все они не очень дружелюбны к пользователю и требуют множества дополнительных действий: нужно самостоятельно создавать модели записей, шаблоны карточек, добавлять css стили, отдельно закачивать медиа-файлы и т.д. и т.п.
Кроме того, все они выполнены либо в виде отдельной программы ([LinguaGet](http://tilivlad.blogspot.ru/search/label/Lingua.get)), либо в качестве дополнений к браузеру ([раз](https://chrome.google.com/webstore/detail/anki-leo-lingualeo-dictio/mpaohidlipnfnkbogpmanchjfjpdgcml?hl=ru), [два](https://chrome.google.com/webstore/detail/export-leo-lingualeo-dict/ljcmfepnkepjmnnokpdeinjefcipjbeo)), что тоже не очень удобно. В идеальной ситуации хотелось, чтобы пользователь мог получить новые карточки прямо из самой Anki.
Выбор инструментов
------------------
Anki 2.0 написана на Python 2.7 и поддерживает систему дополнений, являющихся отдельными модулями питона. Графический интерфейс стабильной версии использует PyQt 4.8.
Таким образом задачу можно описать одним предложением: *пишем дополнение на питоне, запускающееся прямо из Anki и не требующее от пользователя никаких действий кроме ввода логина и пароля от LinguaLeo.*
Решение
-------
Весь процесс можно разделить на три части:
1. Авторизация и получение словаря из LinguaLeo.
2. Преобразование полученных данных в карточки Anki.
3. Создание графического интерфейса.
### Импорт данных
LinguaLeo не содержит официального API, но покопавшись в коде дополнения для браузера можно найти два нужных адреса:
`userDictUrl = "http://lingualeo.com/userdict/json"
loginURL = "http://api.lingualeo.com/api/login"`
Процедура авторизации не представляет из себя ничего сложного и хорошо описана в этой [статье на Хабре](https://habrahabr.ru/post/276495/).
JSON словаря содержит по сто слов на каждой странице. Используя urlencode передаём в параметре filter значение all, а в параметре page номер нужной страницы, проходим по каждой из них и сохраняем наш словарь.
**Код модуля авторизации и импорта словаря**
```
import json
import urllib
import urllib2
from cookielib import CookieJar
class Lingualeo:
def __init__(self, email, password):
self.email = email
self.password = password
self.cj = CookieJar()
def auth(self):
url = "http://api.lingualeo.com/api/login"
values = {"email": self.email, "password": self.password}
return self.get_content(url, values)
def get_page(self, page_number):
url = 'http://lingualeo.com/ru/userdict/json'
values = {'filter': 'all', 'page': page_number}
return self.get_content(url, values)['userdict3']
def get_content(self, url, values):
data = urllib.urlencode(values)
opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(self.cj))
req = opener.open(url, data)
return json.loads(req.read())
def get_all_words(self):
"""
The JSON consists of list "userdict3" on each page
Inside of each userdict there is a list of periods with names
such as "October 2015". And inside of them lay our words.
Returns: type == list of dictionaries
"""
words = []
have_periods = True
page_number = 1
while have_periods:
periods = self.get_page(page_number)
if len(periods) > 0:
for period in periods:
words += period['words']
else:
have_periods = False
page_number += 1
return words
```
### Преобразование полученных данных в карточки Anki
Данные в Анки хранятся следующим образом: в коллекции содержатся модели, включающие css-стиль, список полей и html-шаблоны оформления карточек (лицевой и оборотной стороны).
В нашем случае полей будет пять: само слово, перевод, транскрипция, ссылка на файл с произношением, ссылка на файл с изображением.
Заполнив все поля мы получим запись. Из записи в свою очередь можно сделать две карточки: «английский — русский» и «русский — английский».
Карточки лежат в колодах (~~смерть Кощея в яйце, а яйцо в ларце~~).
Помимо вышеперечисленного нам потребуются функции, скачивающие аудио и изображения.
**Код модуля с утилитами по созданию моделей, записей и т.д.**
```
import os
from random import randint
from urllib2 import urlopen
from aqt import mw
from anki import notes
from lingualeo import styles
fields = ['en', 'transcription',
'ru', 'picture_name',
'sound_name', 'context']
def create_templates(collection):
template_eng = collection.models.newTemplate('en -> ru')
template_eng['qfmt'] = styles.en_question
template_eng['afmt'] = styles.en_answer
template_ru = collection.models.newTemplate('ru -> en')
template_ru['qfmt'] = styles.ru_question
template_ru['afmt'] = styles.ru_answer
return (template_eng, template_ru)
def create_new_model(collection, fields, model_css):
model = collection.models.new("LinguaLeo_model")
model['tags'].append("LinguaLeo")
model['css'] = model_css
for field in fields:
collection.models.addField(model, collection.models.newField(field))
template_eng, template_ru = create_templates(collection)
collection.models.addTemplate(model, template_eng)
collection.models.addTemplate(model, template_ru)
model['id'] = randint(100000, 1000000) # Essential for upgrade detection
collection.models.update(model)
return model
def is_model_exist(collection, fields):
name_exist = 'LinguaLeo_model' in collection.models.allNames()
if name_exist:
fields_ok = collection.models.fieldNames(collection.models.byName(
'LinguaLeo_model')) == fields
else:
fields_ok = False
return (name_exist and fields_ok)
def prepare_model(collection, fields, model_css):
"""
Returns a model for our future notes.
Creates a deck to keep them.
"""
if is_model_exist(collection, fields):
model = collection.models.byName('LinguaLeo_model')
else:
model = create_new_model(collection, fields, model_css)
# Create a deck "LinguaLeo" and write id to deck_id
model['did'] = collection.decks.id('LinguaLeo')
collection.models.setCurrent(model)
collection.models.save(model)
return model
def download_media_file(url):
destination_folder = mw.col.media.dir()
name = url.split('/')[-1]
abs_path = os.path.join(destination_folder, name)
resp = urlopen(url)
media_file = resp.read()
binfile = open(abs_path, "wb")
binfile.write(media_file)
binfile.close()
def send_to_download(word):
picture_url = word.get('picture_url')
if picture_url:
picture_url = 'http:' + picture_url
download_media_file(picture_url)
sound_url = word.get('sound_url')
if sound_url:
download_media_file(sound_url)
def fill_note(word, note):
note['en'] = word['word_value']
note['ru'] = word['user_translates'][0]['translate_value']
if word.get('transcription'):
note['transcription'] = '[' + word.get('transcription') + ']'
if word.get('context'):
note['context'] = word.get('context')
picture_url = word.get('picture_url')
if picture_url:
picture_name = picture_url.split('/')[-1]
note['picture_name'] = '' % picture_name
sound_url = word.get('sound_url')
if sound_url:
sound_name = sound_url.split('/')[-1]
note['sound_name'] = '[sound:%s]' % sound_name
return note
def add_word(word, model):
collection = mw.col
note = notes.Note(collection, model)
note = fill_note(word, note)
collection.addNote(note)
```
### Создание графического интерфейса
Так как наше дополнение стремится к минимализму, нам потребуется всего лишь:
* два поля ввода (логин и пароль от ЛингваЛео)
* один чек-бокс для возможности импортирования только неизученных слов
* две кнопки (импорта и отмены)
**Графический интерфейс**
```
class PluginWindow(QDialog):
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.initUI()
def initUI(self):
self.setWindowTitle('Import From LinguaLeo')
# Window Icon
if platform.system() == 'Windows':
path = os.path.join(os.path.dirname(__file__), 'favicon.ico')
loc = locale.getdefaultlocale()[1]
path = unicode(path, loc)
self.setWindowIcon(QIcon(path))
# Buttons and fields
self.importButton = QPushButton("Import", self)
self.cancelButton = QPushButton("Cancel", self)
self.importButton.clicked.connect(self.importButtonClicked)
self.cancelButton.clicked.connect(self.cancelButtonClicked)
loginLabel = QLabel('Your LinguaLeo Login:')
self.loginField = QLineEdit()
passLabel = QLabel('Your LinguaLeo Password:')
self.passField = QLineEdit()
self.passField.setEchoMode(QLineEdit.Password)
self.progressLabel = QLabel('Downloading Progress:')
self.progressBar = QProgressBar()
self.checkBox = QCheckBox()
self.checkBoxLabel = QLabel('Unstudied only?')
# Main layout - vertical box
vbox = QVBoxLayout()
# Form layout
fbox = QFormLayout()
fbox.setMargin(10)
fbox.addRow(loginLabel, self.loginField)
fbox.addRow(passLabel, self.passField)
fbox.addRow(self.progressLabel, self.progressBar)
fbox.addRow(self.checkBoxLabel, self.checkBox)
self.progressLabel.hide()
self.progressBar.hide()
# Horizontal layout for buttons
hbox = QHBoxLayout()
hbox.setMargin(10)
hbox.addStretch()
hbox.addWidget(self.importButton)
hbox.addWidget(self.cancelButton)
hbox.addStretch()
# Add form layout, then stretch and then buttons in main layout
vbox.addLayout(fbox)
vbox.addStretch(2)
vbox.addLayout(hbox)
# Set main layout
self.setLayout(vbox)
# Set focus for typing from the keyboard
# You have to do it after creating all widgets
self.loginField.setFocus()
self.show()
```
Приключение начинается, когда кроме обозначенного захочется создать прогресс-бар, чтобы пользователь не думал, что дополнение умерло в процессе загрузки.
Для работы прогресс бара без замораживания GUI нужно создать отдельный поток (используя QThread), где загружались бы все данные и создавались карточки, а в графический интерфейс отправлялся лишь счётчик хода работы. Здесь нас поджидает неприятность — информация в Анки хранится в базе данных SQlite и программа не позволяет изменять её извне главного треда. Решение: основная затратная задача — скачивание медиа-файлов и передача данных в прогресс-бар происходит во втором потоке, в то время как в главном заполняются поля и сохраняются записи. Таким образом, получаем работающую строку прогресса без замороженного интерфейса.
**Весь код модуля GUI**
```
# -*- coding: utf-8 -*-
import locale
import os
import platform
import socket
import urllib2
from anki import notes
from aqt import mw
from aqt.utils import showInfo
from PyQt4.QtGui import (QDialog, QIcon, QPushButton, QHBoxLayout,
QVBoxLayout, QLineEdit, QFormLayout,
QLabel, QProgressBar, QCheckBox)
from PyQt4.QtCore import QThread, SIGNAL
from lingualeo import connect
from lingualeo import utils
from lingualeo import styles
class PluginWindow(QDialog):
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.initUI()
def initUI(self):
self.setWindowTitle('Import From LinguaLeo')
# Window Icon
if platform.system() == 'Windows':
path = os.path.join(os.path.dirname(__file__), 'favicon.ico')
loc = locale.getdefaultlocale()[1]
path = unicode(path, loc)
self.setWindowIcon(QIcon(path))
# Buttons and fields
self.importButton = QPushButton("Import", self)
self.cancelButton = QPushButton("Cancel", self)
self.importButton.clicked.connect(self.importButtonClicked)
self.cancelButton.clicked.connect(self.cancelButtonClicked)
loginLabel = QLabel('Your LinguaLeo Login:')
self.loginField = QLineEdit()
passLabel = QLabel('Your LinguaLeo Password:')
self.passField = QLineEdit()
self.passField.setEchoMode(QLineEdit.Password)
self.progressLabel = QLabel('Downloading Progress:')
self.progressBar = QProgressBar()
self.checkBox = QCheckBox()
self.checkBoxLabel = QLabel('Unstudied only?')
# Main layout - vertical box
vbox = QVBoxLayout()
# Form layout
fbox = QFormLayout()
fbox.setMargin(10)
fbox.addRow(loginLabel, self.loginField)
fbox.addRow(passLabel, self.passField)
fbox.addRow(self.progressLabel, self.progressBar)
fbox.addRow(self.checkBoxLabel, self.checkBox)
self.progressLabel.hide()
self.progressBar.hide()
# Horizontal layout for buttons
hbox = QHBoxLayout()
hbox.setMargin(10)
hbox.addStretch()
hbox.addWidget(self.importButton)
hbox.addWidget(self.cancelButton)
hbox.addStretch()
# Add form layout, then stretch and then buttons in main layout
vbox.addLayout(fbox)
vbox.addStretch(2)
vbox.addLayout(hbox)
# Set main layout
self.setLayout(vbox)
# Set focus for typing from the keyboard
# You have to do it after creating all widgets
self.loginField.setFocus()
self.show()
def importButtonClicked(self):
login = self.loginField.text()
password = self.passField.text()
unstudied = self.checkBox.checkState()
self.importButton.setEnabled(False)
self.checkBox.setEnabled(False)
self.progressLabel.show()
self.progressBar.show()
self.progressBar.setValue(0)
self.threadclass = Download(login, password, unstudied)
self.threadclass.start()
self.connect(self.threadclass, SIGNAL('Length'), self.progressBar.setMaximum)
self.setModel()
self.connect(self.threadclass, SIGNAL('Word'), self.addWord)
self.connect(self.threadclass, SIGNAL('Counter'), self.progressBar.setValue)
self.connect(self.threadclass, SIGNAL('FinalCounter'), self.setFinalCount)
self.connect(self.threadclass, SIGNAL('Error'), self.setErrorMessage)
self.threadclass.finished.connect(self.downloadFinished)
def setModel(self):
self.model = utils.prepare_model(mw.col, utils.fields, styles.model_css)
def addWord(self, word):
"""
Note is an SQLite object in Anki so you need
to fill it out inside the main thread
"""
utils.add_word(word, self.model)
def cancelButtonClicked(self):
if hasattr(self, 'threadclass') and not self.threadclass.isFinished():
self.threadclass.terminate()
mw.reset()
self.close()
def setFinalCount(self, counter):
self.wordsFinalCount = counter
def setErrorMessage(self, msg):
self.errorMessage = msg
def downloadFinished(self):
if hasattr(self, 'wordsFinalCount'):
showInfo("You have %d new words" % self.wordsFinalCount)
if hasattr(self, 'errorMessage'):
showInfo(self.errorMessage)
mw.reset()
self.close()
class Download(QThread):
def __init__(self, login, password, unstudied, parent=None):
QThread.__init__(self, parent)
self.login = login
self.password = password
self.unstudied = unstudied
def run(self):
words = self.get_words_to_add()
if words:
self.emit(SIGNAL('Length'), len(words))
self.add_separately(words)
def get_words_to_add(self):
leo = connect.Lingualeo(self.login, self.password)
try:
status = leo.auth()
words = leo.get_all_words()
except urllib2.URLError:
self.msg = "Can't download words. Check your internet connection."
except ValueError:
try:
self.msg = status['error_msg']
except:
self.msg = "There's been an unexpected error. Sorry about that!"
if hasattr(self, 'msg'):
self.emit(SIGNAL('Error'), self.msg)
return None
if self.unstudied:
words = [word for word in words if word.get('progress_percent') < 100]
return words
def add_separately(self, words):
"""
Divides downloading and filling note to different threads
because you cannot create SQLite objects outside the main
thread in Anki. Also you cannot download files in the main
thread because it will freeze GUI
"""
counter = 0
problem_words = []
for word in words:
self.emit(SIGNAL('Word'), word)
try:
utils.send_to_download(word)
except (urllib2.URLError, socket.error):
problem_words.append(word.get('word_value'))
counter += 1
self.emit(SIGNAL('Counter'), counter)
self.emit(SIGNAL('FinalCounter'), counter)
if problem_words:
self.problem_words_msg(problem_words)
def problem_words_msg(self, problem_words):
error_msg = ("We weren't able to download media for these "
"words because of broken links in LinguaLeo "
"or problems with an internet connection: ")
for problem_word in problem_words[:-1]:
error_msg += problem_word + ', '
error_msg += problem_words[-1] + '.'
self.emit(SIGNAL('Error'), error_msg)
```
Добавляем обработку ошибок и на этом всё. Дополнение готово к работе.
В планах переписать плагин на третий питон для новой, пока ещё бета-версии Анки и использовать асинхронную загрузку медиа-файлов для ускорения работы.
Исходный код на [BitBucket](https://bitbucket.org/alex-altay/lingualeoanki).
Страница плагина [на форуме дополнений Anki](https://ankiweb.net/shared/info/1411073333). | https://habr.com/ru/post/345864/ | null | ru | null |
# Версионирование API в ASP.Net Core
Поддерживая существующие уже какое-то время Web API проекты, мы нередко сталкиваемся с проблемой устаревания логики методов контроллеров и необходимостью ее изменения в соответствии с новыми требованиями. Но, как правило, на момент возникновения такой необходимости, уже существует определенное число сервисов, использующих текущую реализацию наших API, и не нуждающихся в ее модернизации. Более того, такие сервисы могут легко «сломаться» при изменении используемых ими API.
Для решения такого рода проблем в ASP.Net Core существует механизм версионирования API – когда контроллеры и их методы могут существовать одновременно в разных версиях. В таком случае, те сервисы, которым достаточно существующего состояния используемых ими API, могут продолжать использовать определенные версии этих API, а для сервисов, которые требуют модернизации логики контроллеров, мы можем создавать новые параллельные версии, и все эти версии могут работать в нашем проекте одновременно.
1. В Visual Studio создаем новый проект ASP.NET Core Web API:
2. В новый проект добавляем NuGet пакет: Microsoft.AspNetCore.Mvc.Versioning
Для этого в SolutionExplorer (Обозреватель решений) правой кнопкой мыши жмем по названию рабочего проекта и выбираем *Manage NuGet Packages… (Управление пакетами Nuget).*
Далее переходим на крайнюю левую вкладку *Browse,*и в строку поиска вводим название устанавливаемого пакета NuGet.
В левом окне выбираем нужный нам пакет, а в правом жмем кнопку *Install*.
3. В метод ConfigureServices класса Startup.cs добавляем строку "services.AddApiVersioning();":
```
public void ConfigureServices(IServiceCollection services)
{
// другой код
services.AddControllers();
services.AddApiVersioning();
// другой код
}
```
4. В папке ‘Controllers’ создаем новую папку “V2”.
5. В созданную папку добавляем новый API контроллер:
И называем его WeatherForecastController, так же, как и созданный по умолчанию контроллер.
В новый контроллер добавляем логику уже существующего контроллера, и немного
изменяем ее. Также добавляем к контроллеру атрибут [ApiVersion("2.0")]
и в атрибуте Route изменяем маршрут:
```
[Route("api/v{version:apiVersion}/[controller]")]
[ApiController]
[ApiVersion("2.0")]
public class WeatherForecastController : ControllerBase
{
private static readonly string[] Summaries = new[]
{
"Сильный мороз", "Мороз", "Холодно", "Прохладно", "Свежо", "Тепло", "Духота", "Жара", "Сильная жара"
};
[HttpGet]
public IEnumerable Get()
{
var rng = new Random();
return Enumerable.Range(1, 5).Select(index => new WeatherForecast
{
Date = DateTime.Now.AddDays(index),
TemperatureC = rng.Next(-40, 40),
Summary = Summaries[rng.Next(Summaries.Length)]
})
.ToArray();
}
}
```
Маршрут нового контроллера теперь будет: "/api/v2/WeatherForecast".
6. К автоматически созданному с проектом контроллеру добавим атрибут [ApiVersion("1.0")]:
```
[ApiController]
[Route("[controller]")]
[ApiVersion("1.0")]
public class WeatherForecastController : ControllerBase
{
// созданная по умолчанию логика
}
```
Таким образом, мы имеем две версии по сути одного контроллера – 1 и 2.
Маршрут вызова первого контроллера остается прежним, но теперь мы обязаны сообщить маршрутизатору нужную нам версию.
Передать версию контроллера можно несколькими способами:
* в параметрах запроса: https://localhost:44335/WeatherForecast**?api-version=1.0**
* в HTTP заголовках запроса. Для этого нужно видоизменить метод AddApiVersioning в методе ConfigureServices класса Startup.cs:
```
services.AddApiVersioning(config =>
{
config.ApiVersionReader = new HeaderApiVersionReader("api-version");
});
```
и добавить в запрос соответствующий заголовок:
* в URL запроса: <https://localhost:44335/api/v2/WeatherForecast>
7. Вызовем метод первого контроллера. Для этого воспользуемся способом передачи версии через параметры запроса.
Запустим наш проект, и в браузере или инструменте для работы с API (Postman, Insomnia и т.д.) введем Url: “https://localhost:44335/WeatherForecast?api-version=1.0”. Разумеется, порт нужно указывать соответствующий вашему приложению.
Получим результат:
```
[
{
"date":"2022-02-06T00:22:54.6248567+06:00",
"temperatureC":-13,
"temperatureF":9,
"summary":"Scorching"
},
{
"date":"2022-02-07T00:22:54.6261864+06:00",
"temperatureC":24,
"temperatureF":75,
"summary":"Freezing"
},
{
"date":"2022-02-08T00:22:54.6261919+06:00",
"temperatureC":-12,
"temperatureF":11,
"summary":"Freezing"
},
{
"date":"2022-02-09T00:22:54.6261927+06:00",
"temperatureC":40,
"temperatureF":103,
"summary":"Sweltering"
},
{
"date":"2022-02-10T00:22:54.6261931+06:00",
"temperatureC":27,
"temperatureF":80,
"summary":"Balmy"
}
]
```
8. Вызовем метод второго контроллера. Для этого воспользуемся способом передачи версии в Url запроса, так как мы задали его с помощью атрибута [Route("api/v{version:apiVersion}/[controller]")] и должны теперь ему следовать.
Запустим наш проект, и в браузере или инструменте для работы с API (Postman, Insomnia и т.д.) введем Url: “<https://localhost:44335/api/v2/WeatherForecast>”.
Получим результат:
```
[
{
"date":"2022-02-06T00:32:43.5572436+06:00",
"temperatureC":27,
"temperatureF":80,
"summary":"Жара"
},
{
"date":"2022-02-07T00:32:43.5577678+06:00",
"temperatureC":14,
"temperatureF":57,
"summary":"Сильная жара"
},
{
"date":"2022-02-08T00:32:43.5577702+06:00",
"temperatureC":15,
"temperatureF":58,
"summary":"Тепло"
},
{
"date":"2022-02-09T00:32:43.5577706+06:00",
"temperatureC":0,
"temperatureF":32,
"summary":"Духота"
},
{
"date":"2022-02-10T00:32:43.5577707+06:00",
"temperatureC":-14,
"temperatureF":7,
"summary":"Тепло"
}
]
```
9. Вызов первого контроллера по его первоначальному маршруту без указания версии - <https://localhost:44335/WeatherForecast>
Предположим, что первый контроллер уже используется несколькими другими проектами (сервисами) в его первоначальном виде, каким он был до добавления в проект версионирования, и никто не собирается рефакторить эти проекты и менять Url для вызова. Они по-прежнему обращаются к нашему API по маршруту “<https://localhost:44335/WeatherForecast>”.
В таком случае, мы задаем версию по умолчанию, и если версия в запросе не будет указана, то запрос направляется на заданную версию.
Для этого изменим метод AddApiVersioning в методе ConfigureServices класса Startup.cs:
```
services.AddApiVersioning(config =>
{
config.DefaultApiVersion = new ApiVersion(1, 0);
config.AssumeDefaultVersionWhenUnspecified = true;
});
```
В данном случае, все запросы, в которых не указана версия, будут направляться на контроллер первой версии. Теперь мы можем вызывать первый контроллер по его первоначальному маршруту, он будет работать.
10. Мы можем отметить первую версию как устаревшую, немного изменив атрибут версии: [ApiVersion("1.0", Deprecated = true)]
11. С помощью атрибута MapToApiVersion мы имеем возможность управлять версиями на уровне методов:
```
[MapToApiVersion("3.0")]
[HttpGet]
public int DoSomething()
{
// логика метода
}
```
PS: Данный туториал рассчитан в первую очередь на уже знакомую с предназначением описываемой технологии аудиторию и представляет из себя краткое руководство по быстрому применению базового функционала этой технологии в своих проектах. Туториал не претендует на полное и исчерпывающее пособие по затронутой тематике и не является рекламой. Идея написания этой, и серии подобных статей, была подсказана студентами, не владеющими в должной мере английским языком и испытывающими определенные трудности при поиске такого рода информации на просторах рунета. | https://habr.com/ru/post/649827/ | null | ru | null |
# Handy.CMS 3.1 build 2001
[](http://handycms.ru)
Вышел новый билд системы управления сайтом Handy.CMS. Среди значительных изменений: добавлена возможность создания тем для сайтов. Кроме того, в данный билд добавлен [первый бесплатный дизайн для Handy.CMS](https://habrastorage.org/getpro/geektimes/post_images/830/c4c/800/830c4c80055f7c44630aa063bedc3415.jpg)\*. Другие изменения системы под катом.
#### Дистрибутив Handy.CMS 3.1 beta
***билд 2001 от 13.08.09***
##### Основные изменения:
**1. Добавлена возможность работы с различными темами дизайна для сайта**
Теперь Вы можете выбрать дизайн сайта, который будет использоваться в системе, указав название папки темы в **config.ini**, переменная **theme**.
Все темы располагаются внутри папки **/templates**. Для переключения темы достаточно изменить ее название в конфигурационном файле и перезагрузить страницу в броузере.
В шаблонах переменная, обозначающая путь к теме, называется `{$theme}`.
**Внимание!** Для корректной смены темы без потери прикрепленных к страницам блоков, необходимо использовать одинаковые названия шаблонов страниц и меток в шаблонах (это замечание не относится к дополнительным или модульным шаблонам). В противном случае, при смене темы, блоки, прикрепленные к меткам шаблона, отсутствующим в шаблоне новой темы, а также блоки, прикрепленные к шаблонам, отсутствующим в новой теме, будут удалены.
Естественно сам контент не удаляется, удаляются только ссылки на него (привязка контента к страницам). В этом случае Вам будет необходимо заново прикрепить нужный блок к страницам (**Страница -> Наполнение**).
**2. Добавлен первый бесплатный шаблон для Handy.CMS**
С введением тем для сайта мы пришли к решению создания бесплатных тем для пользователей Handy.CMS
Все темы будут иметь префикс handy. В будущем мы планируем постепенно увеличивать количество бесплатных шаблонов.
В данную сборку добавлена первая тема, которую Вы можете использовать абсолютно бесплатно\* с системой Handy.CMS.
**3. Исправлено удаление служебных модульных страниц и контента**
Ранее, в некоторых случаях, связанный служебный контент некоторых видов модулей не удалялся или удалялся не полностью.
**4. Добавлены подписи к навигационной панели**
Добавлены подписи к иконкам модулей, а также иконкам правой верхней части административного интерфейса.
**5. Добавлен вывод информации о билде и релизной дате**
Информацию о дате билда (его актуальности) можно получить через функцию `handyCore::getBuildDate()`, о номере билда — через `handyCore::getBuild().`
**6. Добавлена возможность использования общего сообщения для незаполненных страниц**
Каждая метка системы может выводить сообщение, в случае если страница не заполнена.
Иерархия вывода следующая:
* Сообщение не выводится, если не стоит опция "**Использовать текст из сообщения по-умолчанию**" для метки.
* При установленной опции:
+ Выводится сообщение метки, если оно заполнено;
+ Выводится общее сообщение из настроек модуля, если не задано сообщение для данной метки шаблона (**Настройки системы -> Список модулей -> Кнопка «Настройки»**).
**7. Исправлена работа модуля «Дополнительные меню»**
**8. Исправлена работа модуля преобразования пользовательских макросов**
**9. Исправлен вывод меток шаблона**
Теперь метки отображаются в наполнении в том порядке, в котором идут в шаблоне.
**10. Добавлена функция перевода русского текста в транслит**
Использование:
`$tratslited_text = handyCore::loadExtension ('lib.utils' ) -> textToTranslite($russian_text);`
**11. В визуальном редакторе Innova добавлено автоматическое переименование названий файлов, загружаемых на русском языке**
При загрузке файла, в случае если его название содержит кириллические буквы, они будут автоматически заменены системой на аналогичные латинские.
**12. Исправлен путь к выводимому на сайт изображению в модуле «Группы новостей», виде «Последние новости»**
**13. Добавлена обработка вывода дополнительных блоков к параметрическим страницам**
Пример: в случае, если Вы захотите загрузить на страницу «Новости», содержащую вывод списка новостей, какой-либо дополнительный контекстный блок, он будет отображаться на формируемых модулем системных страницах. Например, при делении списка новостей на несколько страниц: **/news/pages/2** и т.п.
\* Использование темы разрешается только с системой Handy.CMS. | https://habr.com/ru/post/67504/ | null | ru | null |
# Приведение внешнего вида Ubuntu к Windows 7
Существует такой пакет, который поможет автоматически настроить внешний вид Вашего Linux-дистрибутива, похожим на внешний вид операционной системы Windows 7. Он называется Win2-7 Pack (для среды Gnome) и [Vistar7](http://kde-look.org/content/show.php/Vistar7+-+Windows+7+Transformation+Pack?content=104232) (для KDE). Новый внешний вид программ сохраняется даже и в запускаемых в Wine приложениях. В пакете, в качестве web-браузера, используется Firefox, в котором есть [плагин](https://addons.mozilla.org/es-ES/firefox/addon/4988/), позволяющий браузеру выглядеть, как Internet Explorer с эффектами Aero. Также пакет заменяет приветствие, иконки, анимацию, обои, курсоры, шрифты и многое другое.
Недавно вышла версия пакета под номером 5.8.
Для того, чтобы скачать, зайдите на эту [страницу](http://gnome-look.org/content/show.php/Win2-7+Pack?content=113264) или выполните в терминале следующие команды:
`**wget** lite.fr.nf./r-f` — скачать пакет (45,3 Мб)
`**unlzma** Win2-7Pack-filename.tar.lzma
**tar** -xvf Win2-7Pack.tar
**cd** Win2-7Pack_v5.8_Multilang_Aero`
И потом, чтобы установить, запускаем скрипт — `./GUIInstall.sh`
Кстати, чтобы деинсталлировать, запускаем такой скрипт — `./GUIUninstall.sh`
И скриншот для представления действий пакета:
 | https://habr.com/ru/post/102991/ | null | ru | null |
# Решение японских кроссвордов на Haskell
Японский кроссворд — головоломка, в которой по набору чисел нужно воссоздать исходное черно-белое изображение. Каждой строке и каждому столбцу пикселей соответствует свой набор, каждое число в котором, в свою очередь, соответствует длине блока подряд идущих черных пикселей. Между такими блоками должен быть хотя бы один белый пиксель, но точное их число неизвестно. Журналы, целиком посвященные этим головоломкам, есть в большинстве газетных киосков, так что, думаю, почти все с ними хоть раз да встречались, и потому [более подробное описание](http://ru.wikipedia.org/wiki/%D0%AF%D0%BF%D0%BE%D0%BD%D1%81%D0%BA%D0%B8%D0%B9_%D0%BA%D1%80%D0%BE%D1%81%D1%81%D0%B2%D0%BE%D1%80%D0%B4) здесь можно не приводить.
В какой-то момент мне захотелось «научить компьютер» решать японские кроссворды так, как решаю их я сам. Никакой высокой цели, just for fun. Потом уже были добавлены способы, которые сам я применять не могу в силу ограниченных возможностей человеческого мозга, но, справедливости ради, со всеми кроссвордами из журналов программа справляется и без них.
Итак, задача простая: решить кроссворд, а если решений много, то найти их все. Решение написано на Haskell'е, и, хотя код достаточно существенно дополняет словесное описание, даже без знания языка общую суть понять можно. Если хочется пощупать результат вживую, на [странице пректа](http://code.google.com/p/jc-solver/) можно скачать исходники (бинарных сборок не выкладывал). Решения экспортируются в Binary PBM, из него же можно извлекать условия.
Несмотря на то, что я пытался писать максимально понятно, это не в полной мере мне удалось. Под катом очень много букв и кода и почти нет картинок.
#### BitMask
В основе всей программы лежит свой велосипед для битовой маски. Он не слишком быстр, но обладает свойством, которое было для меня важно в процессе отладки: падает при операциях, не имеющих смысла, а именно при любой операции над масками разной длины. Я приведу здесь лишь сигнатуры функций и картинку, поясняющую принцип их работы; реализация весьма примитивна и непосредственно к решению отношения не имеет.
```
bmCreate :: Int -> BitMask
bmLength :: BitMask -> Int
bmSize :: BitMask -> Int
bmIsEmpty :: BitMask -> Bool
bmNot :: BitMask -> BitMask
bmAnd :: BitMask -> BitMask -> BitMask
bmOr :: BitMask -> BitMask -> BitMask
bmIntersection :: [BitMask] -> BitMask
bmUnion :: [BitMask] -> BitMask
bmSplit :: BitMask -> [BitMask]
bmByOne :: BitMask -> [BitMask]
bmExpand :: BitMask -> BitMask
bmFillGaps :: BitMask -> BitMask
bmLeftIncursion :: Int -> BitMask -> BitMask
bmRightIncursion :: Int -> BitMask -> BitMask
bmTranspose :: [BitMask] -> [BitMask]
```
Думаю, что такое графическое описание исчерпывающе для всех функций, кроме, пожалуй, `bmLeftIncursion` и `bmRightIncursion`. Зачем они нужны, будет ясно позже, принцип же их работы следующий: `bmLeftIncursion` находит самый левый заполненный бит и создает маску, в которой заполнены все биты до него, а также столько бит начиная с него, сколько было указано при вызове функции; вторая функция работает аналогично.
#### Структура
Так как решение кроссворда происходит по линиям, то тип, соответствующий всему полю, представляет собой набор всех горизонтальных и вертикальных линий, хоть это и приводит к дублированию всех клеток кроссворда.
```
data Field = Field {
flHorLines :: [Line],
flVerLines :: [Line]
} deriving Eq
```
Каждая линия хранит информацию о клетках и блоках (блок соответствует числу в условии).
```
data Line = Line {
lnMask :: LineMask,
lnBlocks :: [Block]
} deriving Eq
```
Информация о клетках хранится в виде двух битовых масок одинаковой длины, представляющих закрашенные и заблокированные клетки.
```
data LineMask = LineMask {
lmFilledMask :: BitMask,
lmBlockedMask :: BitMask
} deriving Eq
```
Блок же, помимо непосредственно числа, содержит маску, которая соответствует той области линии, в которой данный блок может находиться.
```
data Block = Block {
blScopeMask :: BitMask,
blNumber :: Int
} deriving Eq
```
В начале решения маски закрашенных и заблокированных клеток пусты, а маска блока, наоборот, полностью заполнена. Это значит, что все клетки пусты, а каждый блок может находиться в любой части линии. Процесс решения сводится к тому, чтобы сузить область каждого блока до размеров, равных его числу, и соответствующим образом заполнить маски.
##### Завершенность и синхронизация
Все вышеперечисленные типы (кроме `BitMask`) являются экземплярами двух классов: `Completable` и `Syncable`.
Единственная функция класса `Completable` показывет «завершенность» объекта. Поле считается завершенным, если завершены все его линии. Линия завершена, если завершены все ее блоки; завершенности маски при этом требовать излишне (она следует из завершенности блоков; почему, опять же, будет ясно чуть позже). Для завершения блока, как уже упоминалось выше, необходимо, чтобы размер его области совпадал с его числом.
```
class Completable a where
clIsCompleted :: a -> Bool
instance Completable Field where
clIsCompleted fl = all clIsCompleted (flHorLines fl) && all clIsCompleted (flVerLines fl)
instance Completable Line where
clIsCompleted ln = all clIsCompleted (lnBlocks ln)
instance Completable Block where
clIsCompleted bl = bmSize (blScopeMask bl) == blNumber bl
```
Класс `Syncable` предоставляет функции, которые позволяют свести воедино разные ветки решений. `snAverage` выделяет из двух веток только общее, а `snSync` — то, что проявилось хотя бы в одной ветке (можно считать их обобщениями функций `bmAnd` и `bmOr` соответственно). `snAverageAll` и `snSyncAll` делают абсолютно то же самое, но работают не с двумя объектами, а со списками объектов.
```
class Syncable a where
snSync :: a -> a -> Maybe a
sn1 `snSync` sn2 = snSyncAll [sn1, sn2]
snAverage :: a -> a -> Maybe a
sn1 `snAverage` sn2 = snAverageAll [sn1, sn2]
snSyncAll :: [a] -> Maybe a
snSyncAll [] = Nothing
snSyncAll sns = foldr1 (wrap snSync) (map return sns)
snAverageAll :: [a] -> Maybe a
snAverageAll [] = Nothing
snAverageAll sns = foldr1 (wrap snAverage) (map return sns)
wrap :: Monad m => (a -> b -> m c) -> m a -> m b -> m c
wrap f mx my = do
x <- mx
y <- my
f x y
```
##### Согласованность
Из описания функций класса `Syncable` видно, что их результатом является объект, обернутый в монаду `Maybe`. На самом деле, так проявляется важное понятие согласованности, которое тоже определено для всех вышеперечисленных типов, но в отдельный класс не вынесено из соображений инкапсуляции. Как пример, одна и та же клетка не может быть одновременная закрашенной и заблокированной; если какая-либо операция может привести к такой ситуации, то она помечена монадой `Maybe` (как правило, имеет тип `type TransformFunction a = a -> Maybe a`), и, если она к этой ситуации приводит, то результатом ее будет `Nothing`, потому что ни один объект в программе не может существовать в несогласованном состоянии. Так как `Nothing`, в свою очередь, не может являться составной частью других объектов, несогласованным станет все поле, что будет означать отсутствие решений.
Согласованность поля обеспечивается синхронизацией горизонтальных и вертикальных линий. Таким образом, если клетка находится в каком-то состоянии (закрашена, заблокирована или пуста) в горизонтальной линии, то она находится точно в том же состоянии в соответствующей вертикальной линии, и наоборот.
```
flEnsureConsistency :: TransformFunction Field
flEnsureConsistency fl = do
let lnsHor = flHorLines fl
let lnsVer = flVerLines fl
lnsHor' <- zipWithM lnSyncWithLineMask (lmTranspose $ map lnMask lnsVer) lnsHor
lnsVer' <- zipWithM lnSyncWithLineMask (lmTranspose $ map lnMask lnsHor) lnsVer
return $ Field lnsHor' lnsVer'
lnSyncWithLineMask :: LineMask -> TransformFunction Line
lnSyncWithLineMask lm ln = do
lm' <- lm `snSync` lnMask ln
return ln { lnMask = lm' }
```
О согласованности линии поговорим позже, так как она имеет непосредственное отношение к процессу решения.
Согласованность блока обеспечивается нетривиально: для нее необходимо исключить из области блока те непрерывные части, которые не могут его вместить. Таким образом, если из области блока с числом 3 и исходной областью  исключить маску  (например, по причине того, что эта клетка оказалась заблокирована), то конечным итогом этой операции будет блок с областью , а вовсе не .
```
blEnsureConsistency :: TransformFunction Block
blEnsureConsistency bl = do
let bms = filter ((blNumber bl <=) . bmSize) $ bmSplit $ blScopeMask bl
guard $ not $ null bms
return bl { blScopeMask = bmUnion bms }
```
Для маски согласованность очевидна и уже описывалась выше: нельзя одновременно закрасить и заблокировать одну и ту же клетку.
```
lmEnsureConsistency :: TransformFunction LineMask
lmEnsureConsistency lm = do
guard $ bmIsEmpty $ lmFilledMask lm `bmAnd` lmBlockedMask lm
return lm
```
##### Преобразования
Операции преобразования масок и блоков весьма ограничены, так как в процессе решения клетки можно только закрашивать и блокировать (передумать, взять ластик и стереть уже нельзя), а область блока можно лишь сужать.
```
lmFill :: BitMask -> TransformFunction LineMask
lmFill bm lm = lmEnsureConsistency lm { lmFilledMask = lmFilledMask lm `bmOr` bm }
lmBlock :: BitMask -> TransformFunction LineMask
lmBlock bm lm = lmEnsureConsistency lm { lmBlockedMask = lmBlockedMask lm `bmOr` bm }
blExclude :: BitMask -> TransformFunction Block
blExclude bm bl = blEnsureConsistency $ bl { blScopeMask = blScopeMask bl `bmAnd` bmNot bm }
blKeep :: BitMask -> TransformFunction Block
blKeep bm bl = blEnsureConsistency $ bl { blScopeMask = blScopeMask bl `bmAnd` bm }
```
#### Решение
Процесс решения будем рассматривать отдельными частями, пока они, наконец, не сложатся в общую картину.
##### Согласованность линии
Для начала восстановим пробел, оставленный в разделе про согласованность, и объявим, что линия считается согласованной, если ее маска заполнена в соответствии с ее блоками. За этой фразой скрываются два пункта. Во-первых, должны быть заблокированы те клетки, которые не попадают в область ни к одному блоку (если линия не содержит ни одного блока, то, соответственно, таковыми являются все клетки).
```
lnUpdateBlocked :: [Block] -> TransformFunction LineMask
lnUpdateBlocked [] lm = lmBlock (bmNot $ lmBlockedMask lm) lm
lnUpdateBlocked bls lm = lmBlock (bmNot $ bmUnion $ map blScopeMask bls) lm
```
Во-вторых, по каждому блоку при помощи функции `blToFillMask` можно получить маску, которую неоходимо закрасить. Она является пересечением двух масок, получающихся, если «загнать» блок в самую левую и самую правую части своей области.
```
blMinimumLeftMask :: Block -> BitMask
blMinimumLeftMask bl = bmLeftIncursion (blNumber bl) (blScopeMask bl)
blMinimumRightMask :: Block -> BitMask
blMinimumRightMask bl = bmRightIncursion (blNumber bl) (blScopeMask bl)
blToFillMask :: Block -> BitMask
blToFillMask bl = blMinimumLeftMask bl `bmAnd` blMinimumRightMask bl
lnUpdateFilled :: [Block] -> TransformFunction LineMask
lnUpdateFilled [] = return
lnUpdateFilled bls = lmFill (bmUnion $ map blToFillMask bls)
```
*(Примечание: здесь мы, наконец, использовали функции `bmLeftIncursion` и `bmRightIncursion`. Строго говоря, если бы они применялись только для этой цели, то, скорее всего, выглядели бы немного по-другому, а именно не заполняли бы битовую маску до самого первого заполненного бита исходной маски.)*
Таким образом, о чем уже упоминалось ранее, условие согласованности для линии гарантирует, что ее маска всегда будет завершена, если завершены все ее блоки.
```
lnEnsureConsistency :: TransformFunction Line
lnEnsureConsistency ln = do
let bls = lnBlocks ln
lm <- lnUpdateBlocked bls >=> lnUpdateFilled bls $ lnMask ln
return $ ln { lnMask = lm }
```
##### Простое преобразование линии
Решение в рамках линии по сути сводится к двум преобразованиям.
Первое преобразование, фактически, является обратным к условию согласованности: оно гарантирует, что блоки будут завершены, если завершена маска. Для этого используется три действия.
1. Все заблокированные клетки должны быть исключены из областей всех блоков.
```
lnRemoveBlocked :: LineMask -> TransformFunction [Block]
lnRemoveBlocked = mapM . blExclude . lmBlockedMask
```
2. Если блок не может вместить какую-либо непрерывную закрашенную часть маски (то есть если она вылезает за область блока или имеет размер, больший, чем его число), то она должна быть исключена из области блока.
```
lnRemoveFilled :: LineMask -> TransformFunction [Block]
lnRemoveFilled lm = mapM (\ bl -> foldM f bl $ bmSplit $ lmFilledMask lm) where
f bl bm = if blCanContainMask bm bl then return bl else blExclude (bmExpand bm) bl
blCanContainMask :: BitMask -> Block -> Bool
blCanContainMask bm bl =
let bm' = bmFillGaps bm
in bmSize bm' <= blNumber bl && bmIsEmpty (bm' `bmAnd` bmNot (blScopeMask bl))
```
3. Из области каждого блока должны быть исключены `blMinimumLeftMask` его левого соседа и `blMinimumRightMask` правого соседа (вот тут уже они нужны именно в том виде, в котором описаны выше). Если быть точным, то исключаются эти маски, расширенные на одну клетку, так как между блоками должна быть хотя бы одна пустая клетка.
```
lnExcludeNeighbours :: TransformFunction [Block]
lnExcludeNeighbours bls = sequence $
scanr1 (flip $ wrap $ blExclude . bmExpand . blMinimumRightMask) $
scanl1 (wrap $ blExclude . bmExpand . blMinimumLeftMask) $
map return bls
```
Вместе эти действия образуют следующую функцию (функция `slLoop` будет описана позже):
```
lnSimpleTransform :: TransformFunction Line
lnSimpleTransform ln = do
let lm = lnMask ln
bls <- lnRemoveBlocked lm >=> slLoop (lnRemoveFilled lm >=> lnExcludeNeighbours) $ lnBlocks ln
lnEnsureConsistency ln { lnBlocks = bls }
```
##### Второе преобразование линии
Если взять самый левый из всех блоков, которые в принципе могут содержать некоторую закрашенную часть маски, то его крайнее правое положение будет ограничено этой самой маской, ведь если он сдвинется еще правее, то эту закрашенную область уже некому будет «отдать». Те же соображения верны и для самого правого из таких блоков.
```
lnExtremeOwners :: BitMask -> TransformFunction [Block]
lnExtremeOwners bm bls = do
bls' <- fmap reverse $ maybe (return bls) (f bmLeftIncursion bls) (h bls)
fmap reverse $ maybe (return bls') (f bmRightIncursion bls') (h bls')
where
f g = varyNth (\ bl -> blKeep (g (blNumber bl) bm) bl)
h = findIndex (blCanContainMask bm)
varyNth :: Monad m => (a -> m a) -> [a] -> Int -> m [a]
varyNth f xs idx = do
let (xs1, x : xs2) = splitAt idx xs
x' <- f x
return $ xs1 ++ x' : xs2
```
Применяя это рассуждение к каждой непрерывной части маски, получаем второе преобразование линии:
```
lnTransformByExtremeOwners :: TransformFunction Line
lnTransformByExtremeOwners ln = do
bls <- foldM (flip lnExtremeOwners) (lnBlocks ln) $ bmSplit $ lmFilledMask $ lnMask ln
lnEnsureConsistency ln { lnBlocks = bls }
```
##### Преобразования поля
Поле каких-то особых собственных преобразований не имеет, единственный вариант для него — взять некоторое готовое преобразование и применить его ко всем своим линиям.
```
flTransformByLines :: TransformFunction Line -> TransformFunction Field
flTransformByLines f fl = do
lnsHor <- mapM f (flHorLines fl)
fl' <- flEnsureConsistency fl { flHorLines = lnsHor }
lnsVer <- mapM f (flVerLines fl')
flEnsureConsistency fl' { flVerLines = lnsVer }
```
##### Ветвления
Так как решение японских кроссвордов — NP-полная задача, то без ветвлений обойтись не удастся. Ветвление определим функцией типа `type ForkFunction a = a -> [[a]]`, где внутренний список включает в себя взаимоисключающие варианты, а внешний — различные способы эти варианты произвести.
Простейший способ — ветвление по клеткам: каждая пустая клетка порождает один элемент внешнего списка, являющийся в свою очередь списком из двух элементов, в одном из которых эта клетка закрашена, а в другом заблокирована.
```
lnForkByCells :: ForkFunction Line
lnForkByCells ln = do
let lm = lnMask ln
bm <- bmByOne $ lmEmptyMask lm
return $ do
lm' <- [fromJust $ lmBlock bm lm, fromJust $ lmFill bm lm]
maybeToList $ lnEnsureConsistency ln { lnMask = lm' }
flForkByCells :: ForkFunction Field
flForkByCells fl = do
let lnsHor = flHorLines fl
let lnsVer = flVerLines fl
idx <- findIndices (not . clIsCompleted) lnsHor
let (lns1, ln : lns2) = splitAt idx lnsHor
lns <- lnForkByCells ln
return $ do
ln' <- lns
maybeToList $ flEnsureConsistency $ Field (lns1 ++ ln' : lns2) lnsVer
```
Для линии также доступен другой способ ветвления: для каждой непрерывной закрашенной части маски (внешний список) можно рассматривать набор блоков, которые могут ее содержать (внутренний список), как варианты, определяющие ветки.
```
lnForkByOwners :: ForkFunction Line
lnForkByOwners ln = do
let bls = lnBlocks ln
bm <- bmSplit $ lmFilledMask $ lnMask ln
case findIndices (blCanContainMask bm) bls of
[_] -> []
idxs -> return $ do
idx <- idxs
maybeToList $ do
bls' <- varyNth (g bm) bls idx
lnEnsureConsistency ln { lnBlocks = bls' }
where g bm bl = blKeep ((bmAnd `on` ($ bm) . ($ blNumber bl)) bmLeftIncursion bmRightIncursion) bl
```
##### Обобщенные функции
Большую часть преобразований имеет смысл применять итерационно. При этом можно просто применять преобразование до тех пор, пока оно хоть что-то меняет, а можно (в случае, когда лишнее применение может занять значительное время) предварительно проверять объект на завершенность.
```
slLoop :: Eq a => TransformFunction a -> TransformFunction a
slLoop f x = do
x' <- f x
if x == x' then return x else slLoop f x'
slSmartLoop :: (Completable a, Eq a) => TransformFunction a -> TransformFunction a
slSmartLoop f x
| clIsCompleted x = return x
| otherwise = do
x' <- f x
if x == x' then return x else slLoop f x'
```
Результаты ветвления можно обрабатывать независимо от конкретного типа данных и способа ветвления. Для этого, применив некоторый способ ветвления, а затем применив к каждому получившемуся объекту какую-либо трансформацию, по каждому набору взаимоисключающих веток необходимо взять среднее значение, после чего синхронизировать эти усредненные объекты, полученные различными точками ветвления. Не буду описывать подробно, но для этой операции также доступен оптимизированный вариант, связанный с проверкой на завершенность.
```
slForkAndSyncAll :: (Syncable a) => ForkFunction a -> TransformFunction a -> TransformFunction a
slForkAndSyncAll f g x = do
xs <- mapM (snAverageAll . mapMaybe g) $ f x
snSyncAll (x : xs)
slForkAndSmartSync :: (Syncable a, Completable a, Eq a) => ForkFunction a -> TransformFunction a -> TransformFunction a
slForkAndSmartSync f g x = foldr h (return x) (f x) where
h xs mx = do
x' <- mx
if clIsCompleted x' then mx else case mapMaybe (snSync x') xs of
[] -> Nothing
xs' -> case filter (/= x') xs' of
[] -> return x'
xs'' -> snAverageAll . mapMaybe g $ xs''
```
Наконец, если уже ничего не помогает, можно уходить в рекурсию. Только таким способом можно получить все решения, если их несколько.
```
slAllSolutions :: (Completable a) => ForkFunction a -> TransformFunction a -> a -> [a]
slAllSolutions f g x = do
x' <- maybeToList $ g x
if clIsCompleted x' then return x' else case f x' of
(xs : _) -> do
x'' <- xs
slAllSolutions f g x''
[] -> []
```
##### Fina venko
Все. Имеющихся инструментов достаточно, чтобы получить решатель в несколько простых шагов.
1. Скомбинируем два преобразования линии.
```
lineTransform = slSmartLoop $ lnSimpleTransform >=> lnTransformByExtremeOwners
```
2. Обработаем специфичное для линии ветвление.
```
lineTransform' = slForkAndSyncAll lnForkByOwners lineTransform
```
3. Составим из этих двух преобразований преобразование поля.
```
fieldTransform = slSmartLoop $ slSmartLoop (flTransformByLines lineTransform) >=> flTransformByLines lineTransform'
```
4. Обработаем результаты ветвления поля по клеткам.
```
fieldTransform' = slForkAndSmartSync flForkByCells fieldTransform
```
5. Объединим предыдущие два преобразования.
```
fieldTransform'' = slSmartLoop $ fieldTransform >=> fieldTransform'
```
6. И, наконец, добавим рекурсию.
```
solve = slAllSolutions flForkByCells fieldTransform''
```
#### Послесловие
Программа работает довольно быстро на кроссвордах, имеющих единственное решение: примерно из тысячи имеющихся у меня кроссвордов на моем ноутбуке лишь два (включая вынесеный в предисловие) решаются больше минуты, практически все укладываются в 10 секунд, и при этом ни один не потребовал рекурсии.
Теоретически, при некоторой доработке программу можно использовать для автоматической оценки сложности кроссвордов (так как методы решения в целом аналогичны применяемым человеком) и доказательства единственности решения; экспорт в LaTeX имеется, и даже, возможно, скоро появится в SVN'е. Так что при желании можно организовать домашний выпуск журналов :) | https://habr.com/ru/post/151819/ | null | ru | null |
# Python на службе у конструктора. Укрощаем API Kompas 3D
Работая в конструкторском отделе, я столкнулся с задачей — рассчитать трудоёмкость разработки конструкторской документации. Если брать за основу документ: [«Типовые нормативы времени на разработку конструкторской документации. ШИФР 13.01.01" (утв. Минтрудом России 07.03.2014 N 003)»](http://www.consultant.ru/document/cons_doc_LAW_199653/), то для расчета трудоёмкости чертежа детали нам необходимы следующие данные:
* Формат чертежа и количество листов
* Масштаб
* Количество размеров на чертеже (включая знаки шероховатости и выносные линии)
* Количество технических требований
Из имеющихся инструментов на предприятии имеем: Kompas 3D v14 и Python 3.5.
В интернете не так много статей о написании программ с использованием API Kompas 3D, и ещё меньше информации о том, как это сделать на Python. Попробую рассказать по шагам, как решалась поставленная задача и на какие грабли приходилось наступать. Статья рассчитана на людей, владеющих основами программирования и знакомых с языком Python. Итак, приступим.
Подготовительная операция:
--------------------------
Убедитесь, что на вашем компьютере установлена программа Kompas 3D, версии не ниже 14 и Python 3. Вам также необходимо установить [pywin3](http://sourceforge.net/projects/pywin32/) (Python for Windows extensions).
Подключение к Kompas 3D:
------------------------
Система Kompas 3D имеет две версии API: API5, которая предоставляет интерфейс KompasObject, и API7, предоставляющая интерфейс IKompasAPIObject. API версии 5 и 7 во многом дублируют свой функционал, но, со слов разработчиков, в 7-ой версии более выражен объектно-ориентированный подход. В данной статье акцент сделан на 7-ю версию.
Функция подключения выглядит следующим образом:
```
import pythoncom
from win32com.client import Dispatch, gencache
# Подключение к API7 программы Kompas 3D
def get_kompas_api7():
module = gencache.EnsureModule("{69AC2981-37C0-4379-84FD-5DD2F3C0A520}", 0, 1, 0)
api = module.IKompasAPIObject(
Dispatch("Kompas.Application.7")._oleobj_.QueryInterface(module.IKompasAPIObject.CLSID,
pythoncom.IID_IDispatch))
const = gencache.EnsureModule("{75C9F5D0-B5B8-4526-8681-9903C567D2ED}", 0, 1, 0).constants
return module, api, const
```
Чуть подробнее о модуле win32com [здесь](http://docs.activestate.com/activepython/3.4/pywin32/html/com/win32com/HTML/GeneratedSupport.html).
Теперь, чтобы подключиться к интерфейсу, нам понадобиться следующий код:
```
module7, api7, const7 = get_kompas_api7() # Подключаемся к API7
app7 = api7.Application # Получаем основной интерфейс
app7.Visible = True # Показываем окно пользователю (если скрыто)
app7.HideMessage = const7.ksHideMessageNo # Отвечаем НЕТ на любые вопросы программы
print(app7.ApplicationName(FullName=True)) # Печатаем название программы
```
Для более глубокого понимания API заглянем в SDK. На моём компьютере она находится по адресу: *C:\Program Files\ASCON\KOMPAS-3D V16\SDK\SDK.chm*. Здесь можно подробнее узнать, например, о методе HideMessage:
После выполнения нашего кода вернём всё на свои места: если Kompas 3D был запущен нами (в процессе работы скрипта), мы его и закроем. Самый простой способ определить, запущен ли процесс, — использовать стандартный модуль subprocess:
```
import subprocess
# Функция проверяет, запущена ли программа Kompas 3D
def is_running():
proc_list = subprocess.Popen('tasklist /NH /FI "IMAGENAME eq KOMPAS*"',
shell=False,
stdout=subprocess.PIPE).communicate()[0]
return True if proc_list else False
```
Данная функция проверяет, запущен ли процесс «KOMPAS» [стандартными методами Windows](https://technet.microsoft.com/en-us/library/bb491010.aspx#mainSection). Обратите внимание, что разные версии программы Kompas 3D могут иметь разные наименования процессов!
Считаем количество листов и их формат:
--------------------------------------
Тут всё просто: у нашего документа doc7 имеется интерфейс коллекции листов оформления LayoutSheets. Каждый лист обладает свойством формата и кратности. Для Компаса, начиная с 15 версии, интерфейс LayoutSheets доступен не только для файлов чертежей, но и для спецификаций и текстовых документов.
```
# Посчитаем количество листов каждого из формата
def amount_sheet(doc7):
sheets = {"A0": 0, "A1": 0, "A2": 0, "A3": 0, "A4": 0, "A5": 0}
for sheet in range(doc7.LayoutSheets.Count):
format = doc7.LayoutSheets.Item(sheet).Format # sheet - номер листа, отсчёт начинается от 0
sheets["A" + str(format.Format)] += 1 * format.FormatMultiplicity
return sheets
```
Посмотрим на процесс изучения SDK для поиска интересующих нас функций:
Читаем основную надпись:
------------------------
Здесь нам поможет всё тот же LayoutSheets:
```
# Прочитаем масштаб из штампа, ячейка №6
def stamp_scale(doc7):
stamp = doc7.LayoutSheets.Item(0).Stamp # Item(0) указывает на штамп первого листа
return stamp.Text(6).Str
```
На самом деле ячейка №6 для листа с другим оформлением может содержать не масштаб, а совсем иную информацию. Посмотрим, как в Kompas 3D определяются стили оформления чертежа:
Таким образом, важно проверять, какому файлу и номеру оформления соответствует лист чертежа. Также стоит помнить, что документ может содержать титульный лист! Поэтому придётся усложнить код. Применим [регулярные выражения](https://habrahabr.ru/post/115825/), т.к. текст в ячейке может являться ссылкой:
```
import os
import re
# Прочитаем основную надпись чертежа
def stamp(doc7):
for sheet in range(doc7.LayoutSheets.Count):
style_filename = os.path.basename(doc7.LayoutSheets.Item(sheet).LayoutLibraryFileName)
style_number = int(doc7.LayoutSheets.Item(sheet).LayoutStyleNumber)
if style_filename in ['graphic.lyt', 'Graphic.lyt'] and style_number == 1:
stamp = doc7.LayoutSheets.Item(sheet).Stamp
return {"Scale": re.search(r"\d+:\d+", stamp.Text(6).Str).group(),
"Designer": stamp.Text(110).Str}
return {"Scale": 'Неопределенный стиль оформления',
"Designer": 'Неопределенный стиль оформления'}
```
Остался последний вопрос: как узнать нужный номер ячейки? Для этих целей удобно создать файл чертежа, в котором интересующие нас ячейки будут заполнены, а после — прочитать все возможные варианты с помощью следующей функции:
```
# Просмотр всех ячеек
def parse_stamp(doc7, number_sheet):
stamp = doc7.LayoutSheets.Item(number_sheet).Stamp
for i in range(10000):
if stamp.Text(i).Str:
print('Номер ячейки = %-5d Значение = %s' % (i, stamp.Text(i).Str))
```
Считаем количество пунктов технических требований:
--------------------------------------------------
Согласно SDK, нам всего-то нужно получить интерфейс TechnicalDemand от IDrawingDocument, а
IDrawingDocument можно получить от iDocuments с помощью замечательного метода с говорящим названием IUnknown::QueryInterface. И только в SDK 16 версии Kompas 3D появилось разъяснение, как это сделать:
С такими разъяснениями легко написать следующее:
```
# Подсчет технических требований, в том случае, если включена автоматическая нумерация
def count_TT(doc7, module7):
doc2D_s = doc7._oleobj_.QueryInterface(module7.NamesToIIDMap['IDrawingDocument'],
pythoncom.IID_IDispatch)
doc2D = module7.IDrawingDocument(doc2D_s)
text_TT = doc2D.TechnicalDemand.Text
count_tt = 0 # Количество пунктов технических требований
for i in range(text_TT.Count): # Проходим по каждой строчке технических требований
if text_TT.TextLines[i].Numbering == 1: # и проверяем, есть ли у строки нумерация
count_tt += 1
# Если нет нумерации, но есть текст
if not count_tt and text_TT.TextLines[0]:
count_tt += 1
return count_tt
```
Стоит отметить, что данный код полагается на автоматическую нумерацию технических требований. Так что, если автоматическая нумерация не применялась или технические требования набраны с использованием простого инструмента «Текст», код будет сложнее. Оставляю решение данной задачи на читателя.
Считаем количество размеров на чертеже:
---------------------------------------
При подсчёте размеров, надо иметь в виду, что необходимо посчитать их на каждом из видов чертежа:
```
# Подсчёт размеров на чертеже, для каждого вида по отдельности
def count_dimension(doc7, module7):
IKompasDocument2D = doc7._oleobj_.QueryInterface(module7.NamesToIIDMap['IKompasDocument2D'],
pythoncom.IID_IDispatch)
doc2D = module7.IKompasDocument2D(IKompasDocument2D)
views = doc2D.ViewsAndLayersManager.Views
count_dim = 0
for i in range(views.Count):
ISymbols2DContainer = views.View(i)._oleobj_.QueryInterface(module7.NamesToIIDMap['ISymbols2DContainer'],
pythoncom.IID_IDispatch)
dimensions = module7.ISymbols2DContainer(ISymbols2DContainer)
# Складываем все необходимые размеры
count_dim += dimensions.AngleDimensions.Count + \
dimensions.ArcDimensions.Count + \
dimensions.Bases.Count + \
dimensions.BreakLineDimensions.Count + \
dimensions.BreakRadialDimensions.Count + \
dimensions.DiametralDimensions.Count + \
dimensions.Leaders.Count + \
dimensions.LineDimensions.Count + \
dimensions.RadialDimensions.Count + \
dimensions.RemoteElements.Count + \
dimensions.Roughs.Count + \
dimensions.Tolerances.Count
return count_dim
```
Основная функция скрипта
------------------------
В результате проделанной работы мы получили следующее:
```
def parse_design_documents(paths):
is_run = is_running() # Установим флаг, который нам говорит,
# запущена ли программа до запуска нашего скрипта
module7, api7, const7 = get_kompas_api7() # Подключаемся к программе
app7 = api7.Application # Получаем основной интерфейс программы
app7.Visible = True # Показываем окно пользователю (если скрыто)
app7.HideMessage = const7.ksHideMessageNo # Отвечаем НЕТ на любые вопросы программы
table = [] # Создаём таблицу параметров
for path in paths:
doc7 = app7.Documents.Open(PathName=path,
Visible=True,
ReadOnly=True) # Откроем файл в видимом режиме без права его изменять
row = amount_sheet(doc7) # Посчитаем кол-во листов каждого формат
row.update(stamp(doc7)) # Читаем основную надпись
row.update({
"Filename": doc7.Name, # Имя файла
"CountTD": count_demand(doc7, module7), # Количество пунктов технических требований
"CountDim": count_dimension(doc7, module7), # Количество размеров на чертеже
})
table.append(row) # Добавляем строку параметров в таблицу
doc7.Close(const7.kdDoNotSaveChanges) # Закроем файл без изменения
if not is_run: app7.Quit() # Выходим из программы
return table
```
Диалоговое окно выбора файлов
-----------------------------
Для удобного использования нашего скрипта воспользуемся возможностями стандартного модуля tkinter и выведем диалоговое окно выбора файлов:
```
from tkinter import Tk
from tkinter.filedialog import askopenfilenames
if __name__ == "__main__":
root = Tk()
root.withdraw() # Скрываем основное окно и сразу окно выбора файлов
filenames = askopenfilenames(title="Выберете чертежи деталей",
filetypes=[('Kompas 3D', '*.cdw'),])
print_to_excel(parse_design_documents(filenames))
root.destroy() # Уничтожаем основное окно
root.mainloop()
```
Отчётность
----------
Чтобы не рисовать в tkintere интерфейс пользователя, предлагаю воспользоваться хорошей программой Excel, куда и выведем результат нашего труда:
```
def print_to_excel(result):
excel = Dispatch("Excel.Application") # Подключаемся к Excel
excel.Visible = True # Делаем окно видимым
wb = excel.Workbooks.Add() # Добавляем новую книгу
sheet = wb.ActiveSheet # Получаем ссылку на активный лист
# Создаём заголовок таблицы
sheet.Range("A1:J1").value = ["Имя файла", "Разработчик",
"Кол-во размеров", "Кол-во пунктов ТТ",
"А0", "А1", "А2", "А3", "А4", "Масштаб"]
# Заполняем таблицу
for i, row in enumerate(result):
sheet.Range("A%d:J%d" % i+2).value = [row['Filename'],
row['Designer'],
row['CountDim'],
row['CountTD'],
row['A0'],
row['A1'],
row['A2'],
row['A3'],
row['A4'],
"".join(('="', row['Scale'], '"'))]
```
Если не полениться и правильно подготовить Excel файл, то результат работы нашего скрипта можно сразу представить в наглядном виде:
На графике изображено участие каждого сотрудника отдела в выпуске документации на изделие.
Заключение
----------
Используя скрипт для чертежа, созданного специально для данной статьи, мы получим следующие результаты:
* Количество размеров: 25 штук
* Количество пунктов технических требований: 3 штуки
* Масштаб: 1:1
* Количество листов: 1, формата А3
Трудозатраты, согласно упомянутому в начале статьи документу, составили: 1 час 20 минут. Как ни странно, примерно столько и было потрачено времени на разработку чертежа.
Конечно, для внедрения подобных норм на предприятии нужны более серьёзные исследования и совершенно другие объёмы конструкторской документации. Данная же статья поможет упростить работу с API Kompas 3D при решении аналогичных задач.
Буду рад любым вашим замечаниями и предложениями к статье.
Исходный код
------------
* [GitHub](https://github.com/Weltraum/Article-Python-in-aid-of-the-designer.-Tames-API-Kompas-3D.)
Ресурсы в помощь:
-----------------
1. SDK (*C:\Program Files\ASCON\KOMPAS-3D V16\SDK\SDK.chm*)
2. [forum.ascon.ru](http://forum.ascon.ru) | https://habr.com/ru/post/323078/ | null | ru | null |
# Не умер ли ещё PHP (и ещё 11 вопросов, которые не стыдно задавать в 2022)
Уже который год во всех слаках, дискордах, телеграмах и форумах главный вопрос о любом языке программирования звучит так — стоит его учить В ЭТОМ ГОДУ, или лучше уже не надо? Взять какой-нибудь PHP — его же вечно хоронят, и всё никак.
Есть и много других вопросов. Например:
— Что выбрать — PHP, Python, Go или Node.js? Или Visual Basic? Или С? Может, Brainfuck?
— Почему все говорят про Python? Он крутой? Круче, чем всё?
— Бэкенд — это про логику и алгоритмы? Матан нужен? А чувство прекрасного?
— У фронтендеров React, Vue и миллионы других фреймворков, о которых все слышали, а что у бэкендеров? Терпение?
— Придётся ли устанавливать Linux, чтобы работать с бэкендом?
— Почему о фронтендерах все говорят, а о бэкендерах нет? Это потому что у них зарплата 20 тысяч?
Как хорошо, что спрашивать не стыдно, а отвечать — бесплатно. Поэтому мы попробуем ответить, а вы присоединяйтесь к обсуждению, потому что в таком деле у всех свои ответы.
### Что вообще такое бэкенд, зачем им заниматься?
Если упростить, то любой сайт — это код, файлы, базы данных и картинки. Всё это лежит не на компьютере у разработчика сайта, а на сервере — отдельном компьютере, к которому может подключаться много пользователей.
Бэкенд-разработчик отвечает за то, что лежит на сервере — делает так, чтобы файлы сохранялись и читались, базы данных работали, как следует, байтики передавались, а в браузере у пользователей показывалось то, что они хотят увидеть, а не какие-нибудь сепульки.
Например, бэкенд-разработчик может сделать так, чтобы ваше письмо дошло, куда надо, а приложенный по пути годовой отчёт в эксельке не потерялся. Или чтобы аватарка в соцсети была на месте и все лайки в инстаграме остались там, где вы их поставили, а не переехали на страницу к другому человеку. Потому что представьте, какая это была бы катастрофа.
Горизонт в этой иллюстрации завален из-за майнеровИ вот бэкендеры спасают нас от этого.
Есть и более «обычные задачи» — все формы регистрации, запись к врачам и даже этот блог работает с помощью бэкендеров. Блог, например, написан на PHP. Этот текст ещё минуту назад лежал в базе данных, а когда вы открыли эту страницу, загрузился оттуда, и теперь вы можете его читать.
Чудеса? Чудеса.
### Что выбрать — PHP, Python, Go или Node.js?
Смотря для чего. На PHP работает подавляющая часть сайтов, но другие языки могут быть моднее. Вообще, конечно, любой язык можно приспособить под любую задачу — наверняка есть работа и для бэкенд-разработчиков на Python, если в какой-нибудь компании так принято.
Можно писать сайты на C, делать бэкенд на Visual Basic и игры в Экселе, но зачем?
Node.js — другой хороший и модный вариант бэкенда, а ещё с ним проще стать фулстеком. Потому что можно выучить JavaScript и писать сразу и фронтенд, и бэкенд, и получать больше денег.
### Почему все говорят про Python? Он крутой?
Python очень приятный, его легко выучить и развлекаться. Но в бэкенд-разработке он используется не слишком часто. Он лучше подходит для других задач — аналитики, работы с нейросетями, вычислениями и статистикой. Там есть всё или почти всё, что для этого нужно.
Перевод от xkcd.ru### PHP умирает?
*(глубокий выдох)*
Нет, не умирает. Он, может быть, менее модный, чем был когда-то, но на нём всё ещё работают 80% сайтов в интернете. Четыре из пяти, представьте себе. Работа для PHP-разработчиков никуда не денется, потому что никуда не денутся 50 с лишним миллионов сайтов, внутри которых бьется пиэйчпишное сердце *(ух как завернул).*
### PHP сложный?
Не сильно сложнее, чем другие популярные языки. А раньше его простота вообще приводила к тому, что на нём было слишком *просто* написать плохой код (поэтому его так много). С выходом PHP 8 такого стало меньше.
Для сравнения сложности, вот минимальный код, который понадобится, чтобы вывести строчку «Hello, world» на разных языках.
```
// PHP
php echo 'Hello, world'; ?
// Python
print("Hello, World!")
// Ruby
puts "Hello World"
// Go
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
```
*Уважаемые разработчики на PHP, Python, Ruby и Go с годом практики и больше. Мне нужна была наглядная иллюстрация, поэтому сделайте, пожалуйста, вид, что не видели этого сравнения.*
А ещё у PHP замечательная [документация](https://www.php.net/docs.php), в которой есть примеры использования всего на свете и комментарии от пользователей, у которых есть свои варианты кода на каждый случай жизни.
### Бэкенд — это про логику и алгоритмы?
В каком-то смысле.
Если фронтендерам алгоритмы обычно [нужны не раньше третьего-четвёртого года](https://htmlacademy.ru/blog/education/what/algorithm?utm_source=habr&utm_medium=special&utm_campaign=live21012022) работы за деньги, то бэкендерам хорошо бы сразу понимать, где можно оптимизировать код. Всё-таки к серверу может быть и миллион запросов в секунду, и там каждый байт на счету.
### У фронтендеров есть React и Vue, а у бэкендеров?
Не переживайте, у бэкендеров тоже есть свои фреймворки. Django, Laravel, [Yii 2](https://htmlacademy.ru/intensive/php2?utm_source=habr&utm_medium=special&utm_campaign=live21012022), Ruby on Rails, Flask, CakePHP, Spring Boot, тысячи их. Все они созданы, чтобы облегчить разработку и сделать её понятнее.
Осталось не забывать главное правило — выучите язык перед тем, как учить фреймворк, а не после. Потому что учить сначала фреймворк это как строить дом, начиная с третьего этажа.
> 4.02. Алекс доказывает, что он не виноват. Просто 12 этажей Сидорова на 4 метра выше и на 5 метров шире, чем 12 этажей Петровича. Выяснилось, что они строили из разных панелей. Но Алекс все равно ламер, поскольку его крыша не подходит по размеру ни одному из вариантов. Его шахта лифта, кстати, тоже.
>
>
Помните же [классику](https://xakep.ru/2001/06/19/12860/)?
### Где мне пригодятся эти знания?
В принципе знание языков программирования и основ работы бэкенда пригодится [в большой или маленькой компании](https://htmlacademy.ru/blog/education/what/studio-vs-enterprise?utm_source=habr&utm_medium=special&utm_campaign=live21012022), которая делает сайты.
А знание, как написать «Hello, World» поможет в экспериментах. Можете, например, попробовать [тренажёр по PHP](https://htmlacademy.ru/courses/337?utm_source=habr&utm_medium=special&utm_campaign=live21012022) — вы там сделаете целую страничку интернет-магазина своими руками. Вообще, хорошо сначала попробовать, прежде чем бросаться с головой в новое дело. Вдруг вам вообще не понравится?
### Деньги-то вообще есть? Или работать за 20 тысяч?
Как правило, у всех есть знакомый JavaScript-разработчик (а если у вас его нет, то это вы). Обычно знакомый JavaScript-разработчик зарабатывает больше ста тысяч, работает в какой-нибудь компании, у которой есть свои курьеры с доставкой еды, и хвастается, что можно не ездить в офис.
И это, на секундочку, фронтенд.
А теперь посмотрите [статистику](https://habr.com/ru/article/569026/) от Хабр Карьеры. 140 тыс — средняя зарплата бэкендеров в 2021, это даже больше, чем во фронтенде, хотя казалось бы.
Конечно, не у всех есть знакомый бэкендер, но если вы им станете, то все только спасибо скажут. Сможете круглые сутки переустанавливать винду всем родственникам (шутка).
### Придётся ли устанавливать Linux, чтобы писать бэкенд?
Бэкендерам обычно нужно понимать, как устроены Линукс, терминал, файловая система, права доступа, и как это всё заставить работать, потому что на Линуксе работают сервера (см. вопрос номер 1).
Ладно, это уже устаревший комикс. ИзвинитеНо правда в том, что к серверам обычно подключаются удалённо, а писать код и гуглить на StackOverflow можно хоть на ноутбуке с Windows — было бы желание, а все инструменты уже есть.
### Как взломать базу паролей на бэкенде на PHP
Не знаю, почему об этом постоянно спрашивают. Взламывать пароли вообще плохо, не занимайтесь таким.
### Почему о фронтендерах все говорят, а о бэкендерах нет?
Если вы следите за русскоязычным твиттером или регулярно просмотриваете топ Хабра, то знаете как минимум нескольких фронтендеров, которые постоянно выгорают, но продолжают зарабатывать миллиарды в наносекунду. Они ездят на конференции, пишут статьи, и поэтому их заметно.
Так вот, смысл в том, что бэкенд-разработчиков ровно настолько же много, нужно просто за ними специально послеживать. Не будем советовать конкретных — при должном желании вы найдёте нескольких и самостоятельно.
Смысл в том, что говорят о тех, кого видно. Если вы [сделаете себе карьеру](https://htmlacademy.ru/blog/education/collections/learning-path?utm_source=habr&utm_medium=special&utm_campaign=live21012022) и будете выступать на конференциях и писать в Твиттер о том, как устали делать однотипные лендинги и гонять туда-сюда джейсончики, то и о вас заговорят. Ну или можно просто переводить всё подряд на Хабр, и о вас тоже заговорят.
А можно быть просто хорошим разработчиком и делать проекты, которые помогают компании — это тоже путь. И без разницы, фронтенд это, бэкенд или мобилка. Главное — делать хорошо.
А с мифами о PHP разберёмся [в прямом эфире](https://htmlacademy.ru/events/live-php-is-alive) 28 февраля в 19:00. Лёша Симоненко из Академии и Алексей Солодкий, руководитель PHP-разработки из BelkaCar, обстоятельно поговорят о современном PHP и ответят на все вопросы из чата. | https://habr.com/ru/post/652277/ | null | ru | null |
# Google закрывает Cloud Print через 10 лет в статусе бета-версии
На прошлой неделе компания Google опубликовала [объявление](https://support.google.com/chrome/a/answer/9633006) о запланированном закрытии сервиса [Cloud Print](https://www.google.com/cloudprint/learn/). Письма со сроками закрытия проекта также [поступили](https://www.reddit.com/r/google/comments/dzoxye/google_is_terminating_google_cloud_print/) администраторам G Suite.
Сервис Cloud Print закроется 31 декабря 2020 года. С 1 января 2021 года все устройства на любых операционных системах больше не смогут отсылать документы на печать через Google Cloud Print.
Как следует из названия, Cloud Print — это функция удалённой печати через принтер либо в той же локальной сети, либо через Интернет. Для работы с сервисом нужно связать аккаунт Google и принтер, если есть поддержка облачных функций, или дать облаку доступ к локальному принтеру через страницу `chrome://devices` браузера Chrome. Некоторые продвинутые пользователи [настраивают](https://habr.com/en/post/149520/) сервер печати без Chrome. Затем печать ведётся удалённо через браузер или мобильные приложения.
[Целевая аудитория](https://www.theregister.co.uk/2019/11/22/google_cloud_print_axed_2020/) Google Cloud Print — это небольшие офисы, мелкий бизнес и школы. За 13 месяцев всем пользователям придётся найти, на что мигрировать.
Google cчитает, что [нативная печать](https://www.blog.google/products/chrome-enterprise/chrome-enterprise-now-offers-native-print-management/) в операционной системе Chrome OS в состоянии заменить закрываемый сервис. До закрытия Cloud Print Google обещает добавить в Chrome OS поддержку сервера печати [CUPS](https://ru.wikipedia.org/wiki/Common_UNIX_Printing_System) и политик подключения к нему. Также за эти 13 месяцев будет завершена разработка стандартов API для доступа к метаданным печати, отсылки документов на печать и удалённого управления принтерами.
Для других платформ в Google рекомендуют искать замену в лице встроенных функций печати этих систем.
*Google знакомит пользователей с Cloud Print, 2011 год*
Сервис Cloud Print [открылся](https://habr.com/en/post/112454/) в 2010 году, но с пометкой «бета». За 10 лет он так и не вышел в статус релиза, хотя имел активных пользователей. К примеру, некто TechnoProfesor 23 ноября [опубликовал инструкцию](https://www.instructables.com/id/Printing-From-ESP8266-NodeMCU/) по настройке управления принтером через Cloud Print с помощью дешёвого чипа-микроконтроллера ESP8266.
Google получила дурную репутацию компании, которая не любит поддерживать работу старых сервисов — [даже тех, у которых есть крупное ядро пользователей](https://habr.com/ru/post/185330/). На сайте [Killed by Google](https://killedbygoogle.com/) собран 191 закрытый сервис компании.
Google Cloud Print — не единственная жертва ноября. Если верить инсайду издания Motherboard, Chronicle, бывший стартап безопасности Alphabet, рискует быть закрыт: его сотрудникам [не понравилась](https://www.vice.com/en_us/article/9kej3e/chronicle-is-dead-and-google-killed-it) реорганизация со слиянием в Google. | https://habr.com/ru/post/477270/ | null | ru | null |
# 16 инструментов React, которые пригодятся разработчикам интерфейсов
Для создания пользовательских интерфейсов существует большое количество инструментов (ваш К.О., не благодарите). Один из наиболее эффективных — React. Наверное, на Хабре нет нужды рассказывать о том, что это такое и зачем.
Сегодня мы решили опубликовать подборку классных вспомогательных элементов для разработчиков, которые используют React. Вероятно, подборка не исчерпывающая, но зато позволит дополнить инструментарий. Если вы используете еще что-то, чего нет в подборке, делитесь в комментариях, а мы скажем дружно спасибо и добавим классные предложения в подборку. *Предупреждение — под катом довольно много гифок, у кого платный трафик — осторожнее, ребята.*
Итак, бросаемся в омут с головой, не откладывая на потом:
### [React Datasheet](https://nadbm.github.io/react-datasheet)
Похожий на Excel инструмент, который можно встраивать в свои приложения на React. Позволяет использовать математические формулы (основа — math.js). В ячейки таблицы можно добавлять выпадающие меню и кнопки.
### [React Native for Web](https://github.com/necolas/react-native-web)
Ну а этот компонент позволяет добавлять индикаторы активности, кнопки, прогресс бары (индикаторы выполнения), переключатели и многое, многое другое.
### [Reactide](http://reactide.io)
Reactide описывают как первый специализированный IDE-инструмент для разработки приложений c React. И действительно — это кросс-платформенное десктопное приложение, позволяющее быстро рендерить проекты без серверной конфигурации, что снижает сложность разработки и экономит время.
### [Storybook](https://storybook.js.org/)
Этот инструмент является одним из наиболее мощных и известных. С его помощью собираются компоненты. Разработчики говорят о нем как об интерактивном компоненте разработки пользовательского интерфейса. Он поддерживает React, React-native, Vue и Angular. Инструмент дает возможность просматривать все компоненты проекта. В комплекте — большое количество дополнений для разработки документов, компонентов, тестирования.
### [React Styleguidist](https://github.com/styleguidist/react-styleguidist)
Styleguidist представляет собой среду для разработки компонентов с dev-сервером (с возможностью горячего ребута) и отличной документацией. Инструмент предоставляет возможность посмотреть на примеры использования различных компонентов.
### [Catalog](https://catalog.style/)
Ну а здесь у нас — инструмент, который позволяет создавать ливстайл руководства для цифровых продуктов. Он дает возможность объединить документацию и активы с актуальными компонентами. Его стоит использовать, когда есть необходимость показать визуальные элементы системы.
### [React Studio](https://reactstudio.com)
Это дизайнерский инструмент, позволяющий получить на выходе качественный react-проект без кодинга. Приложение совместимо со Sketch, что еще добавит радости и удовольствия разработчику. Если вы не кодер — однозначно стоит глянуть.
### [React Cosmos](https://github.com/react-cosmos/react-cosmos)
Cosmos сканирует весь проект и разделяет его на компоненты, позволяя рендерить их в любых комбинационных сочетаниях props, context, state. Это необходимо в том случае, если проект уже запущен, но необходимо добавить новые функции к компонентам. При этом разработчик получает возможность отслеживать изменения в реальном времени.
### [ORY Editor](https://github.com/ory/editor)
Основанный на React и Redux мобильный редактор контента. Его можно добавить в любой момент в функционал разрабатываемого сайта. Изначально инструмент был создан для крупной открытой образовательной платформы из Германии. Ну а немцы славятся своей аккуратностью, инструмент получился просто отличным.
### [React Sight](https://github.com/React-Sight/React-Sight)
Отличный инструмент для визуализации, который позволяет очень быстро настроить все, что необходимо разработчику.
### [Reselect Devtools](https://github.com/skortchmark9/reselect-tools)
И еще один инструмент визуализации, который используется для отслеживания слоев кэширования. Никаких проблем и забот — все отображается весьма наглядным образом.
### [Redux DevTools Profiler Monitor](https://github.com/pbomb/redux-devtools-profiler-monitor)
Отличный инструмент, позволяющий запускать и останавливать работу профиля Javascript. Создан инструмент на базе Redux.
### [Periscope](https://github.com/shea-hawkins/periscope)
Мониторинг событий Redux на основе временной шкалы.
### [redux-promise-middleware-times](https://github.com/lemonleon/redux-promise-middleware-times)
`import { createStore, applyMiddleware } from 'redux';
import thunk from 'redux-thunk';
import promiseMiddleware from 'redux-promise-middleware';
import logTimes from 'redux-promise-middleware-times';
const store = createStore(thunk, promiseMiddleware(), logTimes());`
Крохотный аддон к redux-promise-middleware. Он записывает время, в течение которого выполняется определенное событие.
### [React Monocle](https://github.com/team-gryff/react-monocle)
Мощный инструмент для визуализации, который показывает отдельные компоненты, их состояние, статус Redux и совмещает это в понятной схеме.
### [Hygen](https://github.com/jondot/hygen)
Фреймворк генератора кода, который можно использовать практически в любом проекте для уменьшения размера шаблона. Такой фреймворк весьма ко двору для тех, кто работает с React и Redux. Количество шаблонов здесь может быть очень большим, ведь они создаются едва ли не на каждом этапе работы.
В целом, мы считаем, что эта далеко не полная подборка может стать неплохим подспорьем в нелегком труде разработчика интерфейса. Ну а чтобы работа стала еще более эффективной, можно пройти пару-тройку курсов Skillbox.
[](https://skillbox.ru/javascript/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=jsdev&utm_content=articles&utm_term=16react) | https://habr.com/ru/post/416005/ | null | ru | null |
# Создание рождественской анимации с помощью Wolfram Language
Перевод блога [O Tannenbaum](http://community.wolfram.com/groups/-/m/t/1248938) Майкла Тротта, директора Wolfram|Alpha.
---
В этом ноутбуке описывается, как создать анимацию украшенной елки, которая перемещает свои ветви синхронизированно с голосами музыки немецкой песни [*O Tannenbaum*](https://en.wikipedia.org/wiki/O_Tannenbaum) 16-го века (английская версия — *O Christmas Tree*). Одна выделенная ветвь дерева будет действовать как дирижер, а свеча будет дирижёрской палочкой. Это делает анимацию интересной во всех куплетах. Мы также добавим немного снега и несколько веселых движений дерева во второй половине песни. Чтобы увидеть окончательный дизайн, просмотрите это [видео на YouTube](https://youtu.be/huKA0kjEcXw):
Я реализую анимацию с помощью следующих этапов:
1. Построить елку с изогнутыми ветвями, где ветви можно перемещать плавно вверх, вниз, влево и вправо.
2. Добавить украшения (цветные шарики, пятиконечные звезды) и свечи разного цвета к ветвям. Позволить украшениям перемещаться относительно окончаниям веток.
3. Преобразовать 4 голоса музыки в 2D-движение на основе частот звука. Смоделировать движения дирижера синхронизированными с музыкой.
4. Моделировать движения украшений в виде вынужденного сферического маятника. Учет трения орнаментов с использованием диссипативной функции Рэлея.
5. Добавить снег для белого рождества.
6. Создать анимацию веток по отношению к музыке.
Особая благодарность моему коллеге Эндрю Штайхачеру за выбор и анализ музыки, чтобы получить данные для движения дерева (ниже раздел «От музыки к движениям»). И благодаря Эми Янг для превращения анимационных кадров и музыки в один видеоклип.
### Создание елки
#### Параметры дерева
Размеры дерева, общая форма дерева и количество ветвей. Названия переменных делают их смысл очевидным.
```
(* radial branch count *)
radialBranchCount = 3;
(* vertical branch count *)
verticalBranchCount = 5;
(* tree height *)
treeHeight = 12;
(* tree width *)
treeWidth = 6;
(* plot points for the B-spline surfaces forming the branches *)
{μ, ν} = {6, 8};
```
Цвета ствола и ветвей.
```
stemColor = Directive[Darker[Brown], Lighting -> "Neutral", Specularity[Brown, 20]];
branchTopColor = RGBColor[0., 0.6, 0.6];
branchBottomColor = RGBColor[0., 0.4, 0.4];
branchSideColor = RGBColor[0.4, 0.8, 0.];
```
#### Построение движущейся ветки дерева
Каждая ветвь имеет поперечное сечение прямоугольника с изменяющейся размерностью (в зависимости от расстояния от ствола). Кончик ветки должен слегка указывать вверх, чтобы иметь знакомый вид елки. В его самом широком размере ветвь лежит близко к конусу (стволу). Переменная τ определяет вверх-вниз и переменная σ лево-право положения кончика ветки. Я строю ветку с четырех поверхностей B-сплайна (сверху, снизу, слева, справа), чтобы иметь гладкий вид с небольшим количеством точек, определяющих поверхность.
```
branchTopBottom[
tp_, {hb_, ht_}, {φ1_, φ2_}, {rb_, rt_},
R_, {σ_, τ_}] :=
Module[{A = -0.6, β = 1/2, φm, Pm, dirR,
dirφ, r, P1, P, \[ScriptN], \[ScriptP], x,
y, ω, ℛ, ξ, \[ScriptH]s, \[ScriptH]},
φm = Mean[{φ1, φ2}];
Pm = R {Cos[φm], Sin[φm]};
dirR = 1. {Cos[φm], Sin[φm]};
dirφ = Reverse[dirR] {-1, 1};
r = If[tp == "top", rt, rb];
(* move cross section radially away from the stem and contract it *)
Table[P1 = {r Cos[φ], r Sin[φ]};
Table[P = P1 + s/ν (Pm - P1);
\[ScriptN] = dirφ.P; \[ScriptP] = dirR.P;
{x,
y} = \[ScriptN] Cos[
s/ν Pi/2]^2 dirφ + \[ScriptP] dirR;
ω = σ*
1. s/ν Abs[φ2 - φ1]/
radialBranchCount;
ℛ = {{Cos[ω],
Sin[ω]}, {-Sin[ω], Cos[ω]}};
{x, y} = ℛ.{x, y};
ξ = R s/ν;
\[ScriptH]s = {ht,
hb} + {ξ (A R (R - ξ) - (hb - ht) (β -
1) ξ), (ht - hb) ξ^2 β}/R^2;
\[ScriptH] =
If[tp == "top", \[ScriptH]s[[1]], \[ScriptH]s[[2]]] ;
{x, y, \[ScriptH] + τ s/ν (ht - hb)},
{s, 0, ν}],
{φ, φ1, φ2, (φ2 - φ1)/μ}] // N
]
```
Радиус на высоте h представляет собой только линейную интерполяцию максимального радиуса ствола и радиуса 0 в верхней части.
```
stemRadius[h_, H_] := (H - h)/H
```
Стороны ветки — это только соединительные элементы между верхней и нижней поверхностями.
```
branchOnStem[{{hb_, ht_}, {φ1_, φ2_},
R_}, {τ_, σ_}] :=
Module[{tBranch, bBranch, sideBranches},
{bBranch, tBranch} =
Table[branchTopBottom[p, {hb, ht}, {φ1, φ2},
stemRadius[{hb, ht}, treeHeight],
R, {τ, σ}], {p, {"top", "bottom"}}];
sideBranches =
Table[BSplineSurface[{tBranch[[j]],
bBranch[[j]]}], {j, {1, -1}}];
{branchTopColor, BSplineSurface[tBranch],
branchBottomColor, BSplineSurface[bBranch],
branchSideColor, sideBranches}
]
```
Для последующего использования давайте определим функцию только для позиции конца ветки.
```
branchOnStemEndPoint[ {{hb_, ht_}, {φ1_, φ2_},
R_}, {σ_, τ_}] :=
Module[{A = -0.6, β = 1/2, Pm, dirR, dirφ,
P, \[ScriptN], \[ScriptP], x,
y, ω, ξ, \[ScriptH]s, \[ScriptH],
φ = φ1, φm =
Mean[{φ1, φ2}]},
Pm = R {Cos[φm], Sin[φm]};
dirR = {Cos[φm], Sin[φm]};
{x, y} = dirR.Pm dirR;
ω =
1. σ Abs[φ2 - φ1]/radialBranchCount;
{x, y} = {{Cos[ω], Sin[ω]}, {-Sin[ω],
Cos[ω]}}.{x, y};
\[ScriptH]s = {ht, hb} + (ht - hb) {β - 1., 1};
{x, y, \[ScriptH]s[[1]] + τ (ht - hb)} ]
```
Интерактивная демонстрация, позволяющая ветке и ее окончанию двигаться как функция от {σ, τ}.
```
Manipulate[
Graphics3D[{branchOnStem[{{0, 1}, {Pi/2 - 1/2, Pi/2 + 1/2},
1 + ρ}, στ],
Red,
Sphere[branchOnStemEndPoint[{{0, 1}, {Pi/2 - 1/2, Pi/2 + 1/2},
1 + ρ}, στ], 0.05]},
PlotRange -> {{-2, 2}, {0, 4}, {-1, 2}},
ViewPoint -> {3.17, 0.85, 0.79}],
{{ρ, 1.6, "branch length"}, 0, 2, ImageSize -> Small},
{{στ, {0, 0},
"branch\nleft/right\nup/down"}, {-1, -1}, {1, 1}},
ControlPlacement -> Left, SaveDefinitions -> True]
```
#### Добавление ветвей к стволу
Ствол — это всего лишь конус, вершиной которого является вершина дерева.
```
stem = Cone[{{0, 0, 0}, {0, 0, treeHeight}}, 1];
```
Размеры ветвей уменьшаются с высотой, становясь геометрически меньше. Общее количество всех уровней ветвей равно высоте дерева минус часть шага внизу.
```
heightList1 =
Module[{α = 0.8, hs, sol},
hs = Prepend[Table[C α^k, {k, 0, verticalBranchCount - 1}],
0];
sol = Solve[Total[hs] == 10, C, Reals];
Accumulate[hs /. sol[[1]]]]
```
> {0, 2.97477, 5.35459, 7.25845, 8.78153, 10.}
```
treeWidthOfHeight[h_] := treeWidth (treeHeight - h)/treeHeight
```
Ветви плотно прилегают к стволу, без промежутков между ними.
```
Graphics3D[{{stemColor, stem},
{Darker[Green],
Table[Table[
branchOnStem[{2 +
heightList1[[{j, j + 1}]], {k , k + 1} 2 Pi/
radialBranchCount ,
treeWidthOfHeight[Mean[heightList1[[{j, j + 1}]]]]}, {0,
0}], {k, 0, 1}] ,
{j, 1, verticalBranchCount}]}},
ViewPoint -> {2.48, -2.28, 0.28}]
```
```
Graphics3D[{{stemColor, stem},
{Darker[Green],
Table[Table[
branchOnStem[{2 +
heightList1[[{j, j + 1}]], {k , k + 1} 2 Pi/
radialBranchCount ,
treeWidthOfHeight[Mean[heightList1[[{j, j + 1}]]]]}, {0,
0}], {k, 0, radialBranchCount - 1}] ,
{j, 1, verticalBranchCount}]}},
ViewPoint -> {2.48, -2.28, 0.28}]
```
Можно переместить ветки, чтобы получить более реалистичную форму дерева. Это то дерево, которое я буду использовать в последующем. Изменить параметры дерева и использовать другое дерево довольно просто.
```
heightList2 = {2/3, 1/3}.# & /@ Partition[heightList1, 2, 1];
Graphics3D[{{Darker[Brown], stem},
{EdgeForm[],
Table[
Table[branchOnStem[ {2 +
heightList1[[{j, j + 1}]], {k , k + 1} 2 Pi/
radialBranchCount ,
treeWidthOfHeight[Mean[heightList1[[{j, j + 1}]]]]}, {0,
0}], {k, 0, radialBranchCount - 1}] ,
{j, 1, verticalBranchCount}],
Table[Table[
branchOnStem[{2 +
heightList2[[{j, j + 1}]], {k , k + 1} 2 Pi/
radialBranchCount + Pi/radialBranchCount,
treeWidthOfHeight[Mean[heightList2[[{j, j + 1}]]]]}, {0,
0}], {k, 0, radialBranchCount - 1}] ,
{j, 1, verticalBranchCount - 1}]}},
ViewPoint -> {2.48, -2.28, 0.28}]
```
Можно было бы легко сделать деревья еще плотнее с большим количеством ветвей.
```
Graphics3D[{{Darker[Brown], stem},
{EdgeForm[],
Table[Table[branchOnStem[ {2 + heightList1[[{j, j + 1}]],
{k , k + 1} 2 Pi/(2 radialBranchCount) ,
treeWidthOfHeight[Mean[heightList1[[{j, j + 1}]]]]}, {0,
0}], {k, 0, (2 radialBranchCount) - 1}] , {j, 1,
verticalBranchCount}],
Table[Table[branchOnStem[{2 + heightList2[[{j, j + 1}]],
{k , k + 1} 2 Pi/(2 radialBranchCount) +
Pi/(2 radialBranchCount),
treeWidthOfHeight[Mean[heightList2[[{j, j + 1}]]]]}, {0,
0}], {k, 0, 2 radialBranchCount - 1}] ,
{j, 1, verticalBranchCount - 1}]}},
ViewPoint -> {2.48, -2.28, 0.28}]
```
### Украшение дерева
Теперь давайте построим несколько украшений, чтобы построить красиво наряженную елку. Я добавлю блестящие шарики, пятиконечные звезды и свечи. Я рекомендую оригинальные шары Тюрингии Лауша для вашей елки. (Вы можете найти их [здесь](https://www.krebslauscha.de/christmas-ornaments/about_us/history/))
#### Украшения, свечи и верхушка
#### Цветные шары
На каждом дереве должны быть какие-то блестящие стеклянные сферы, игрушки.
```
coloredBall[p_, size_, color_, {ϕ_, θ_}] :=
Module[{\[ScriptD] = {Cos[ϕ] Sin[θ],
Sin[ϕ] Sin[θ], -Cos[θ]}},
{EdgeForm[], GrayLevel[0.4], Specularity[Yellow, 20],
Cylinder[{p, p + 1.5 size \[ScriptD]}, 0.02 size ],
color, Specularity[Yellow, 10],
Sphere[p + (1.5 size + 0.6 size) \[ScriptD] , 0.6 size]
}]
Graphics3D[{coloredBall[{1, 2, 3}, 1, Red, {0, 0}],
coloredBall[{3, 2, 3}, 1, Darker[Blue], {1, 0.2}]}, Axes -> True]
```
```
branchOnStemWithBall[{{hb_, ht_}, {φ1_, φ2_},
R_}, {σ_, τ_}, color_, {ϕ_, θ_}] :=
{branchOnStem[{{hb, ht}, {φ1, φ2},
R}, {σ, τ}] ,
coloredBall[
branchOnStemEndPoint[{{hb, ht}, {φ1, φ2},
R}, {σ, τ}], 0.45 (ht - hb)/2,
color, {ϕ, θ}]}
```
Вот ветка с игрушкой. Переменные {σ, τ} позволяют изменить положение шара относительно кончика ветки.
```
Manipulate[
Graphics3D[{branchOnStemWithBall[{{0, 1}, {Pi/2 - 1/2, Pi/2 + 1/2},
1 + ρ}, στ, Red, ϕθ]},
PlotRange -> {{-2, 2}, {0, 4}, {-2, 2}},
ViewPoint -> {3.17, 0.85, 0.79}],
{{ρ, 1.6, "branch length"}, 0, 2, ImageSize -> Small},
{{στ, {0.6, 0.26},
"branch\nleft/right\nup/down"}, {-1, -1}, {1, 1}},
{{ϕθ, {2.57, 1.88}, "ball angles"}, {0, -Pi}, {Pi, Pi}},
ControlPlacement -> Left, SaveDefinitions -> True]
```
Вот дерево с шарами весящими в основном прямо вниз. Я буду использовать случайные цвета для шаров.
```
Graphics3D[{{Darker[Brown],
stem}, {Table[
Table[branchOnStemWithBall[{2 +
heightList1[[{j, j + 1}]], {k , k + 1} 2 Pi/
radialBranchCount ,
treeWidthOfHeight[Mean[heightList1[[{j, j + 1}]]]]}, {0, 0},
RandomColor[], {0, 0}], {k, 0,
radialBranchCount - 1}] ,
{j, 1, verticalBranchCount}]
}}, ViewPoint -> {2.48, -2.28, 0.28}, Axes -> True]
```
Дерево с шарами в случайных направлениях. Если позже ветви будут перемещены, то мы вычислим естественные движения (что означает решение соответствующих уравнений движения) шаров.
```
Graphics3D[{{Darker[Brown],
stem}, {Table[
Table[branchOnStemWithBall[{2 +
heightList1[[{j, j + 1}]], {k , k + 1} 2 Pi/
radialBranchCount ,
treeWidthOfHeight[Mean[heightList1[[{j, j + 1}]]]]}, {0, 0},
RandomColor[], {RandomReal[{-Pi, Pi}],
RandomReal[{0, Pi}]}], {k, 0, radialBranchCount - 1}] ,
{j, 1, verticalBranchCount}]}},
ViewPoint -> {2.48, -2.28, 0.28}, Axes -> True]
```
#### Пятиконечные звезды
Сейчас построим несколько пятиконечных звезд. Поскольку этот орнамент не имеет вращательной симметрии, я допущу угол ориентации относительно нити на которой он висит.
```
coloredFiveStar[p_, size_, dir_,
color_, α_, {ϕ_, θ_}] :=
Module[{\[ScriptD] = {Cos[ϕ] Sin[θ],
Sin[ϕ] Sin[θ], -Cos[θ]}, points, P1, P2, d1,
d2, d3, dP, dP2},
d2 = Normalize[dir - dir.\[ScriptD] \[ScriptD]];
d3 = Cross[\[ScriptD], d2];
{EdgeForm[], GrayLevel[0.4], Specularity[Pink, 20],
Cylinder[{p, p + (1.5 size + 0.6 size) \[ScriptD]}, 0.02 size ],
color, Specularity[Hue[.125], 5],
dP = Sin[α] d2 + Cos[α] d3;
dP2 = Cross[\[ScriptD], dP];
points =
Table[p + (1.5 size + 0.6 size) \[ScriptD] +
size If[EvenQ[j], 1, 1/2] *
(Cos[j 2 Pi/10 ] \[ScriptD] +
Sin[j 2 Pi/10] dP), {j, 0, 10}];
P1 = p + (1.5 size + 0.6 size) \[ScriptD] + size/3 dP2;
P2 = p + (1.5 size + 0.6 size) \[ScriptD] - size/3 dP2;
{P1, P2} = (p + (1.5 size + 0.6 size) \[ScriptD] + # size/
3 dP2) & /@ {+1, -1};
Polygon[
Join @@ (Function[a,
Append[#, a] & /@ Partition[points, 2, 1]] /@ {P1, P2})]
}]
Graphics3D[{coloredFiveStar[{1, 2, 3}, 0.2, {0, -1, 0}, Darker[Red],
0, {0, 0}],
coloredFiveStar[{1.5, 2, 3}, 0.2, {0, -1, 0}, Darker[Purple],
Pi/3, {1, 0.4}]}]
```
```
branchOnStemWithFiveStar[{{hb_, ht_}, {φ1_, φ2_},
R_}, {σ_, τ_},
color_, α_, {ϕ_, θ_}] :=
Module[{dir =
Append[Normalize[
Mean[{{Cos[φ1],
Sin[φ1]}, {Cos[φ2],
Sin[φ2]}}]], 0]},
{branchOnStem[{{hb, ht}, {φ1, φ2},
R}, {σ, τ}] ,
coloredFiveStar[
branchOnStemEndPoint[{{hb, ht}, {φ1, φ2},
R}, {σ, τ}], 0.4 (ht - hb)/2, dir,
color, α, {ϕ, θ}]} ]
```
Елка украшена пятиконечными звездами.
```
Graphics3D[{{Darker[Brown],
stem}, {Table[
Table[branchOnStemWithFiveStar[{2 +
heightList1[[{j, j + 1}]], {k , k + 1} 2 Pi/
radialBranchCount ,
treeWidthOfHeight[Mean[heightList1[[{j, j + 1}]]]]}, {0, 0},
RandomColor[],
RandomReal[{-Pi, Pi}], {RandomReal[{-Pi, Pi}],
RandomReal[0.1 {-1, 1}]}], {k, 0, radialBranchCount - 1}] ,
{j, 1, verticalBranchCount}]
}}, ViewPoint -> {2.48, -2.28, 0.28}, Axes -> True]
```
#### Свечи
Построим их начиная с ножки, которая прикрепляется к окончаниям веток, с воскоподобным телом, почерневшем фитилем и огнем. Чтобы облегчить анимацию и избежать пожара, я буду использовать электрические свечи, чтобы пламя не изменялось, когда двигаются ветви.
```
flamePoints =
Table[{0.2 Sin[Pi z]^2 Cos[φ],
0.2 Sin[Pi z]^2 Sin[φ], z}, {z, 0, 1,
1/1/12}, {φ, Pi/2, 5/2 Pi, 2 Pi/24}]
litCandle[p_, size_, color_] :=
{EdgeForm[], color,
Cylinder[{p + {0, 0, size 0.001}, p + {0, 0, size 0.5}}, size 0.04],
GrayLevel[0.1], Specularity[Orange, 20],
Cylinder[{p, p + {0, 0, size 0.05}}, size 0.06],
Black, Glow[Black],
Cylinder[{ p + {0, 0, size 0.5}, p + {0, 0, size 0.5 + 0.05 size}},
size 0.008],
Glow[Orange], Specularity[Hue[.125], 5],
BSplineSurface[
Map[(p + {0, 0, size 0.5} + 0.3 size #) &, flamePoints, {2}],
SplineClosed -> {True, False}]
}
```
Белая и красная свечи.
```
Graphics3D[{litCandle[{0, 0, 0}, 1,
Directive[White, Glow[GrayLevel[0.3]], Specularity[Yellow, 20]]],
litCandle[{0.5, 0, 0}, 1,
Directive[Red, Glow[GrayLevel[0.1]], Specularity[Yellow, 20]]]}]
```
Позже я буду использовать удлиненную ветку со свечой, чтобы она была дирижером, поэтому я позволю свечи наклониться от ветви.
```
branchOnStemWithCandle[{{hb_, ht_}, {φ1_, φ2_},
R_}, {σ_, τ_}, color_, α_] :=
{branchOnStem[{{hb, ht}, {φ1, φ2},
R}, {σ, τ}] ,
If[α == 0,
litCandle[
branchOnStemEndPoint[{{hb, ht}, {φ1, φ2},
0.98 R}, {σ, τ}], 0.66 (ht - hb) , color],
Module[{P =
branchOnStemEndPoint[{{hb, ht}, {φ1, φ2},
0.98 R}, {σ, τ}], dir},
dir = Append[Reverse[Take[P, 2]] {-1, 1}, 0];
Rotate[
litCandle[
branchOnStemEndPoint[{{hb, ht}, {φ1, φ2},
0.98 R}, {σ, τ}], 0.66 (ht - hb) ,
color], α, dir, P]]]}
Manipulate[
Graphics3D[{branchOnStemWithCandle[{{0, 1}, {Pi/2 - 1/2, Pi/2 + 1/2},
1 + ρ}, στ, Red, α]},
PlotRange -> {{-2, 2}, {0, 4}, {-2, 2}},
ViewPoint -> {3.17, 0.85, 0.79}],
{{ρ, 1.6, "branch length"}, 0, 2, ImageSize -> Small},
{{στ, {0, 0},
"branch\nleft/right\nup/down"}, {-1, -1}, {1, 1}},
{{α, Pi/4, "candle angle"}, -Pi, Pi},
ControlPlacement -> Left, SaveDefinitions -> True]
```
И вот ель со свечой на каждой ветке.
```
Graphics3D[{{Darker[Brown],
stem}, {Table[
Table[branchOnStemWithCandle[{2 +
heightList1[[{j, j + 1}]], {k , k + 1} 2 Pi/
radialBranchCount ,
treeWidthOfHeight[Mean[heightList1[[{j, j + 1}]]]]}, {0, 0},
White, 0], {k, 0,
radialBranchCount - 1}] ,
{j, 1, verticalBranchCount}]
}}, ViewPoint -> {2.48, -2.28, 0.28}, Axes -> True]
```
#### Верхушка елки
Для полной радости я добавляю вращающийся спайки на верху.
```
spikey = Cases[
N@Entity["Polyhedron", "RhombicHexecontahedron"][
"Image"], _GraphicsComplex, ∞][[1]];
top = {Gray, Specularity[Red, 25],
Cone[{{0, 0, 0.9 treeHeight}, {0, 0, 1.08 treeHeight}},
treeWidth/240],
Orange, EdgeForm[Darker[Orange]], Specularity[Hue[.125], 5],
MapAt[((0.24 # + {0, 0, 1.08 treeHeight}) & /@ #) &, spikey, 1]
}
Graphics3D[{{Darker[Brown], stem},
{Table[
Table[branchOnStem[{2 +
heightList1[[{j, j + 1}]], {k , k + 1} 2 Pi/
radialBranchCount ,
treeWidthOfHeight[Mean[heightList1[[{j, j + 1}]]]]}, {0,
0} ], {k, 0, radialBranchCount - 1}] ,
{j, 1, verticalBranchCount}],
top}}, ViewPoint -> {2.48, -2.28, 0.28}, Axes -> True]
```
#### Украшение дерева
Мы выделим одну ветку в качестве дирижера. Оставшиеся ветки мы случайным образом разделим на четыре группы и украсим их игрушками двух цветов, пятиконечными звездами и свечами.
Теперь давайте добавим украшение или свечу на каждую ветку дерева. Я буду использовать вышеупомянутое дерево с 27 ветками. Я начинаю ветки по высоте на стебле и азимутальным углом.
```
allBranches =
Flatten[Riffle[
Table[Table[{2 +
heightList1[[{j, j + 1}]], {k , k + 1} 2. Pi/
radialBranchCount ,
treeWidthOfHeight[Mean[heightList1[[{j, j + 1}]]]]}, {k, 0,
radialBranchCount - 1}] ,
{j, 1, verticalBranchCount}],
Table[Table[{2 +
heightList2[[{j, j + 1}]], {k , k + 1} 2. Pi/
radialBranchCount + Pi/radialBranchCount,
treeWidthOfHeight[Mean[heightList2[[{j, j + 1}]]]]}, {k, 0,
radialBranchCount - 1}] ,
{j, 1, verticalBranchCount - 1}]], 1]
Length[allBranches]
```
> 27
Раскрасим ветки по порядку, начиная с красного внизу и до фиолетового на верху.
```
Graphics3D[{{Darker[Brown], stem},
MapIndexed[(branchOnStem[#1, {0, 0}] /. _RGBColor :>
Hue[#2[[1]]/36]) &, allBranches],
top}, ViewPoint -> {2, 1, -0.2}]
```
Разделим все ветки на 4 группы для голосов и одну для роли дирижера.
```
conductorBranch = 7;
SeedRandom[12];
voiceBranches = (Last /@ #) & /@
GroupBy[{RandomChoice[{1, 2, 3, 4}], #} & /@
Delete[Range[27], {conductorBranch}], First]
```
> <|1 -> {1, 4, 5, 6, 12, 18, 20}, 3 -> {2, 8, 10, 11, 14, 22, 23, 25}, 2 -> {3, 13, 15, 16, 21, 26}, 4 -> {9, 17, 19, 24, 27}|>
```
voiceBranches = <|1 -> {2, 9, 14, 17, 19, 24, 27},
2 -> {3, 13, 15, 16, 21, 26}, 3 -> {1, 4, 5, 12, 18, 20},
4 -> {6, 8, 10, 11, 22, 23, 25}|>
```
> <|1 -> {2, 9, 14, 17, 19, 24, 27}, 2 -> {3, 13, 15, 16, 21, 26}, 3 -> {1, 4, 5, 12, 18, 20}, 4 -> {6, 8, 10, 11, 22, 23, 25}|>
Вот иллюстрация веток, окрашенных в соответствии с тем, какой голос они представляют.
```
Graphics3D[{{Darker[Brown], stem},
branchOnStem[#1, {0, 0}] & /@
allBranches[[voiceBranches[[1]]]] /. _RGBColor :> Yellow,
branchOnStem[#1, {0, 0}] & /@
allBranches[[voiceBranches[[2]]]] /. _RGBColor :> White,
branchOnStem[#1, {0, 0}] & /@
allBranches[[voiceBranches[[3]]]] /. _RGBColor :> LightBlue,
branchOnStem[#1, {0, 0}] & /@
allBranches[[voiceBranches[[4]]]] /. _RGBColor :> Pink,
branchOnStem[
allBranches[[conductorBranch]] {1, 1, 1.5}, {0,
0}] /. _RGBColor :> Red,
top}, ViewPoint -> {2, 1, -0.2}]
```
Завершенное дерево с расположением окончания веток в качестве параметров. Также позволим украшениям на кончиках веток сидеть под наклоном и быть разноцветными.
```
christmasTree[{{σ1_, τ1_}, {σ2_, τ2_}, {σ3_, τ3_}, {σ4_, τ4_}, {σc_, τc_}},
{{ϕ1_, θ1_}, {ϕ2_, θ2_}, {ϕ3_, θ3_}},
{colBall1_, colBall2_, col5Star_},
conductorEnhancementFactor : fc_,
conductorCandleAngle : ωc_, topRotationAngle : ω_] :=
{{Darker[Brown], stem},
branchOnStemWithBall[#, {σ1, τ1},
colBall1, {ϕ1, θ1}] & /@
allBranches[[voiceBranches[[1]]]],
branchOnStemWithBall[#, {σ2, τ2},
colBall2, {ϕ2, θ2}] & /@
allBranches[[voiceBranches[[2]]]],
branchOnStemWithFiveStar[#, {σ3, τ3}, col5Star,
Pi/4, {ϕ3, θ3}] & /@
allBranches[[voiceBranches[[3]]]],
branchOnStemWithCandle[#, {σ4, τ4},
Directive[White, Glow[GrayLevel[0.3]], Specularity[Yellow, 20]],
0] & /@ allBranches[[voiceBranches[[4]]]],
branchOnStemWithCandle[
allBranches[[conductorBranch]] {1, 1,
1 + fc}, {σc, τc},
Directive[Red, Glow[GrayLevel[0.1]],
Specularity[Yellow, 20]], ωc],
Rotate[top, ω, {0, 0, 1}]
};
```
Начальное положение всех ветвей и удлиненной ветки дирижера, где ее свеча наклонена.
```
Graphics3D[christmasTree[{{0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}},
{{0, 0}, {0,0}, {0, 0}}, {Red, Darker[Yellow], Pink}, 0.8, Pi/4, 0],
ImageSize -> 600, ViewPoint -> {3.06, 1.28, 0.27},
PlotRange -> {{-7, 7}, {-7, 7}, {0, 15}}]
```
Три ели со всеми параметрами, выбранными случайным образом.
```
SeedRandom[1]
Table[Graphics3D[christmasTree[RandomReal[1.5 {-1, 1}, {5, 2}],
Table[{RandomReal[{-Pi, Pi}], RandomReal[{0, Pi}]}, 3],
RandomColor[3],
RandomReal[], RandomReal[Pi/2], 0], ImageSize -> 200,
ViewPoint -> {3.06, 1.28, 0.27},
PlotRange -> {{-7, 7}, {-7, 7}, {-2, 15}}], {3}] // Row
```
Следующие интерактивные демонстрации позволяют перемещать ветки, перемещать украшения вокруг окончаний веток и окрашивать украшения по вашему усмотрению.
```
Manipulate[
Graphics3D[
christmasTree[{στ1, στ2, στ3, στ4, στc},
{ϕθ1, ϕθ2, ϕθ3}, {col1, col2, col3},
l, ωc, ω],
ImageSize -> 400,
ViewPoint -> {2.61, 1.99, 0.80},
PlotRange -> {{-7, 7}, {-7, 7}, {-2, 15}}],
"conductor",
{{l, 0.6, "branch length"}, 0, 1, ImageSize -> Small},
{{ωc, Pi/4, "candle angle"}, 0, Pi, ImageSize -> Small},
{{στc, {0, 0}, "movement"}, {-1, -1}, {1, 1},
ImageSize -> Small},
Delimiter,
"voice 1 (balls)",
Grid[{{"movement", "ornament"},
{Control[{{στ1, {0, 0}, ""}, {-1, -1}, {1, 1},
ImageSize -> Small}],
Control[{{ϕθ1, {0, 0}, ""}, {-Pi, 0}, {Pi, Pi},
ImageSize -> Small}]}}],
{{col1, Red, ""}, Red, ImageSize -> Tiny},
Delimiter,
"voice 2 (balls)",
Grid[{{"movement", "ornament"},
{Control[{{στ2, {0, 0}, ""}, {-1, -1}, {1, 1},
ImageSize -> Small}],
Control[{{ϕθ2, {0, 0}, ""}, {-Pi, 0}, {Pi, Pi},
ImageSize -> Small}]}}],
{{col2, Darker[Yellow], ""}, Red, ImageSize -> Tiny},
Delimiter,
"voice 3 (5-star)",
Grid[{{"movement", "ornament"},
{Control[{{στ3, {0, 0}, ""}, {-1, -1}, {1, 1},
ImageSize -> Small}],
Control[{{ϕθ3, {0, 0}, ""}, {-Pi, 0}, {Pi, Pi},
ImageSize -> Small}]}}],
{{col3, Pink, ""}, Red, ImageSize -> Tiny},
Delimiter,
"voice 4 (white candles)",
Control[{{στ4, {0, 0}, "movement"}, {-1, -1}, {1, 1},
ImageSize -> Small}],
Delimiter,
Delimiter,
{{ω, 0, "top rotation"}, 0, 1, ImageSize -> Small},
ControlPlacement -> Left, SaveDefinitions -> True]
```
### От музыки к движению
Итак, теперь, когда я закончил изготовлением параметризованной рождественской елки с подвижными ветками и украшениями, я должен заняться соотношением музыки к движениям веток (и, в свою очередь, украшений).
#### Получите 4 голоса как звук
Используйте MIDI-файл песни.
```
{ohTannenBaum // Head, ohTannenBaum // ByteCount}
```
> {Sound, 287816}
Извлеките 4 голоса.
```
voices = AssociationThread[{"Soprano", "Alto", "Tenor", "Bass"},
ImportString[
ExportString[ohTannenBaum, "MIDI"], {"MIDI", "SoundNotes"}]];
Sound[Take[#, 10]] & /@ voices
```
#### Голос в частоту
```
frequencyRules = <|"A1" -> 55., "A2" -> 110., "A3" -> 220.,
"A4" -> 440., "B1" -> 61.74, "B2" -> 123.5, "B3" -> 246.9,
"B4" -> 493.9, "C2" -> 65.41, "C3" -> 130.8, "C4" -> 261.6,
"C5" -> 523.3, "D2" -> 73.42, "D#4" -> 311.13, "D4" -> 293.7,
"D5" -> 587.3, "E2" -> 82.41, "E4" -> 329.6, "E5" -> 659.3,
"F#2" -> 92.50, "F#4" -> 370.0, "G2" -> 98.00, "G#4" -> 415.3,
"G4" -> 392.0|>;
{minf, maxf} = MinMax[frequencyRules]
```
> {55., 659.3}
Временной график первого голоса.
```
pw[t_] = Piecewise[{frequencyRules[#1], #2[[1]] <= t <= #2[[2]]} & @@@
voices[[1]]];
Plot[pw[t], {t, 0, 100}, PlotRange -> {200, All}, Filling -> Axis,
PlotLabel -> "Soprano",
Frame -> True, FrameLabel -> {"time in sec", "frequency in Hz"},
AxesOrigin -> {0, 200}]
```
Для представления частот в движениях я сглажу кривые.
```
spline = BSplineFunction[Table[{t, pw[t]}, {t, 0, 100, 0.5}],
SplineDegree -> 2]
```
```
ParametricPlot[spline[t], {t, 0, 100}, AspectRatio -> 0.5,
PlotPoints -> 1000]
```
```
tMax = 100;
Do[
With[{j = j},
pwf[j][t_] =
Piecewise[{frequencyRules[#1], #2[[1]] <= t <= #2[[2]]} & @@@
voices[[j]]];
splineFunction[j] =
BSplineFunction[Table[{t, pwf[j][t]}, {t, 0, 100, 0.5}],
SplineDegree -> 2];
voiceFunction[j][t_Real] :=
If[0 < t < tMax, splineFunction[j][t/tMax][[2]]/maxf, 0]],
{j, 4}]
```
Частоты четырех голосов.
```
Plot[Evaluate[Reverse@Table[pwf[j][t], {j, 4}]], {t, 0, 100},
Frame -> True, FrameLabel -> {"time in sec", "frequency in Hz"},
AspectRatio -> 0.3]
```
Сглаженные масштабированные частоты четырех голосов.
```
Plot[Evaluate[Table[voiceFunction[j][t], {j, 4}]], {t, 0, 100},
Frame -> True, FrameLabel -> {"time in sec", "scaled frequency"},
AspectRatio -> 0.3]
```
Вот график (сглаженных) первых трех голосов в 3D.
```
ParametricPlot3D[{voiceFunction[1][t], voiceFunction[2][t],
voiceFunction[3][t]}, {t, 0, 100}, AspectRatio -> Automatic,
PlotPoints -> 1000, BoxRatios -> {1, 1, 1}]
```
```
Show[% /. Line[pts_] :> Tube[pts, 0.002],
Method -> {"TubePoints" -> 4}]
```
### Получить закономерность колебания
Привязка к определенным фразам для создания всех отбиваний такта.
```
{firstBeat, secondBeat, lastBeat} =
voices["Soprano"][[{1, 2, -1}, 2, 1]]
```
> {1.33522, 2.00568, 98.7727}
```
anchorDataOChristmasTree = SequenceCases[
voices["Soprano"],
(* pattern for "O Christmas Tree, O Christmas Tree..." *)
{
SoundNote["D4", {pickupStart_, _}, "Trumpet", ___],
SoundNote["G4", {beatOne_, _}, "Trumpet", ___],
SoundNote["G4", {_, _}, "Trumpet", ___],
SoundNote["G4", {beatTwo_, _}, "Trumpet", ___],
SoundNote["A4", {beatThree_, _}, "Trumpet", ___],
SoundNote["B4", {beatFour_, _}, "Trumpet", ___],
SoundNote["B4", {_, _}, "Trumpet", ___],
SoundNote["B4", {beatFive_, _}, "Trumpet", ___]
} :> <|
"PhraseName" -> "O Christmas Tree",
"PickupBeat" -> pickupStart,
"TargetMeasureBeats" -> {beatOne, beatTwo, beatThree},
"BeatLength" ->
Mean@Differences[{pickupStart, beatOne, beatTwo, beatThree,
beatFour, beatFive}]
|>
];
anchorDataYourBoughsSoGreen = SequenceCases[
voices["Soprano"],
(* "Your boughs so green in summertime..." *)
{
SoundNote["D5", {pickupBeatAnd_, _}, "Trumpet", ___],
SoundNote["D5", {beatOne_, _}, "Trumpet", ___],
SoundNote["B4", {_, _}, "Trumpet", ___],
SoundNote["E5", {beatTwo_, _}, "Trumpet", ___],
SoundNote["D5", {beatThreeAnd_, _}, "Trumpet", ___],
SoundNote["D5", {beatFour_, _}, "Trumpet", ___],
SoundNote["C5", {_, _}, "Trumpet", ___],
SoundNote["C5", {beatFive_, _}, "Trumpet", ___]
} :> With[
{
(* the offbeat nature of this phrase requires some manual work
to get things lined up in terms of actual beats *)
pickupBeatStart = pickupBeatAnd - (beatOne - pickupBeatAnd),
beatThree = beatThreeAnd - (beatFour - beatThreeAnd)
},
<|
"PhraseName" -> "Your boughs so green in summertime",
"PickupBeat" -> pickupBeatStart,
"TargetMeasureBeats" -> {beatOne, beatTwo, beatThree},
"BeatLength" ->
Mean@Differences[{pickupBeatStart, beatOne, beatTwo, beatThree,
beatFour, beatFive}]
|>
]
];
anchorData0 =
Join[anchorDataOChristmasTree, anchorDataYourBoughsSoGreen] //
SortBy[#PickupBeat &];
meanBeatLength = Mean[anchorData0[[All, "BeatLength"]]];
(* add enough beats to fill the end of the song, which ends on beat 2 *)
anchorData =
Append[anchorData0, <|
"TargetMeasureBeats" -> (lastBeat + {-1, 0, 1}*
Last[anchorData0]["BeatLength"]),
"BeatLength" -> Last[anchorData0]["BeatLength"]|>];
anchorData =
Append[anchorData, <|
"TargetMeasureBeats" -> (lastBeat + ({-1, 0, 1} + 3)*
Last[anchorData]["BeatLength"]),
"BeatLength" -> Last[anchorData]["BeatLength"]|>];
```
Интерполируйте ритм между и во время фраз:
```
interpolateAnchor = Apply[
Function[{currentAnchor, nextAnchor},
With[
{targetMeasureLastBeat =
Last[currentAnchor["TargetMeasureBeats"]],
nextMeasureFirstBeat =
First[nextAnchor["TargetMeasureBeats"]]},
DeleteDuplicates@Join[
currentAnchor["TargetMeasureBeats"],
Range[targetMeasureLastBeat,
nextMeasureFirstBeat - currentAnchor["BeatLength"]/4.,
Mean[{currentAnchor["BeatLength"], nextAnchor["BeatLength"]}]]]
]]];
measureBeats = Flatten@BlockMap[interpolateAnchor, anchorData, 2, 1];
measureBeats // Length
```
> 144
Ритм незначительно меняется, и, если не принимать во внимание вышеописанный метод привязки, это может привести к фазированию между движением и звуком:
```
Histogram[Differences[measureBeats], PlotTheme -> "Detailed", PlotRange -> Full]
```
```
(* add pickup beat at start *)
swayControlPoints =
Prepend[Join @@ (Partition[measureBeats, 3, 3, 1, {}] //
MapIndexed[
Function[{times, index}, {#, (-1)^(Mod[index[[1]], 2] + 1)} & /@
times]]), {firstBeat, -1}];
swayControlPointPlot =
ListPlot[swayControlPoints, Joined -> True, Mesh -> All,
AspectRatio -> 1/6, PlotStyle ->
{Darker[Purple]}, PlotTheme -> "Detailed",
MeshStyle -> PointSize[0.008], ImageSize -> 600,
Epilog -> {Darker[Green], Thick,
InfiniteLine[{{#, -1}, {#, 1}}] & /@ {firstBeat, secondBeat,
lastBeat}}];
sway = BSplineFunction[
Join[{{0, 0}},
Select[swayControlPoints, #[[1]] < tMax &], {{100, 0}}],
SplineDegree -> 3];
sh = Show[{swayControlPointPlot,
ParametricPlot[sway[t], {t, 0, tMax}, PlotPoints -> 2500]}]
```
```
{Show[sh, PlotRange -> {{0, 10}, All}], Show[sh, PlotRange -> {{90, 105}, All}]}
```
Теперь небольшое отступление: Интерполяция с B-сплайнами дает приятные гладкие кривые. В отличие от Interpolation, фактические данные не находятся на результирующей кривой. Это выглядит красиво и гладко, и это то, что мы хотим для визуальных целей этой анимации. Но интерполяция — для пары точек. Это означает, что для данного аргумента (между 0 и 1) функции B-сплайна мы не получаем линейную интерполяцию по первому аргументу. В место этого, нужно инвертировать интерполяцию, чтобы получить время как функцию переменной параметра интерполяции. Принимая во внимание этот эффект, важно правильно согласовать музыку с движениями веток.
```
swayTimeCoordinate = Interpolation[Table[{t, sway[t/100][[1]]}, {t, 0, 100, 0.1}], InterpolationOrder -> 1]
```
Этот график показывает разницу между интерполяцией и измененным параметром функции B-сплайна.
```
Plot[swayTimeCoordinate[t] - t, {t, 0, 100}]
```
```
swayOfTime[t_] := sway[swayTimeCoordinate[t]/100][[2]]
Plot[swayOfTime[t], {t, 0, 10}]
```
Визуализируйте фразы и их отношение к движению с помощью всплывающей подсказки и цветных прямоугольников:
```
phraseGraphics = BlockMap[
Apply[
Function[{currentAnchor, nextAnchor},
With[
{phraseStart = currentAnchor["PickupBeat"],
phraseEnd =
nextAnchor["PickupBeat"] - currentAnchor["BeatLength"]},
{Switch[currentAnchor["PhraseName"],
"O Christmas Tree", Opacity[0.25, Gray],
"Your boughs so green in summertime",
Opacity[0.25, Darker@Green],
_, Black],
Tooltip[
Polygon[
{{phraseStart, -10}, {phraseStart, 10}, {phraseEnd,
10}, {phraseEnd, -10}}],
Grid[{{currentAnchor["PhraseName"], SpanFromLeft},
{"Phrase Start:", phraseStart}, {"Phrase End:", phraseEnd}
}]]}]]],
Append[anchorData0, <|"PickupBeat" -> lastBeat + meanBeatLength|>],
2, 1];
Show[swayControlPointPlot,
ParametricPlot[sway[t], {t, 0, Last[measureBeats]},
ImageSize -> Full, PlotPoints -> 800, AspectRatio -> 1/8,
PlotTheme -> "Detailed", PlotRangePadding -> Scaled[.02]],
Prolog -> phraseGraphics]
```
#### Движения дирижера
Дирижер выполняет простое периодическое движение, синхронизированное с музыкой.
```
threePatternPoints = {{0, -1}, {-1, -0}, {0, 1}};
threePatternBackground = ListPlot[
MapIndexed[
Callout[#1, StringTemplate["Beat #`` @ ``"][First@#2, #1], Left] &,
threePatternPoints],
PlotTheme -> "Minimal", Axes -> False, AspectRatio -> 1,
PlotStyle -> Directive[Black, PointSize[0.025]],
PlotRange -> {{-2, 0.75}, {-1.5, 1.5}}];
conductorControlTimes = swayControlPoints[[All, 1]];
(* basic conductor control points for interpolation *)
conductorControlPoints =
MapIndexed[{conductorControlTimes[[First[#2]]], #1} &,
Join @@ ConstantArray[RotateRight[threePatternPoints, 1],
Floor@(Length[conductorControlTimes]/3)]];
(* the shape is okay, but not perfect *)
conductor = Interpolation[conductorControlPoints];
(* adding pauses before/after the beat improves the shape of the
curves and makes the beats more obvious *)
conductorControlPointsWithPauses =
Join @@
({# - {meanBeatLength/8., -0.15*
Normalize[
Mean[threePatternPoints] - #[[
2]]]}, #, # + {meanBeatLength/8.,
0.15*Normalize[
Mean[threePatternPoints] - #[[
2]]]}} & /@
conductorControlPoints);
```
На этот раз я использую Interpolation.
```
conductorWithPauses =
Interpolation[conductorControlPointsWithPauses,
InterpolationOrder -> 5];
```
Вот результирующая форма дирижерской палочки.
```
Manipulate[
Show[threePatternBackground,
ParametricPlot[
conductorWithPauses[t], {t,
Max[firstBeat,(*tmax-2*meanBeatLength*)0], tmax},
PerformanceGoal -> "Quality"],
Epilog -> {Red, PointSize[Large], Point[conductorWithPauses[tmax]]},
ImageSize -> Large], {{tmax, lastBeat, "t"}, firstBeat + 0.0001,
lastBeat, Appearance -> "Labeled"},
SaveDefinitions -> True]
```
#### Движения веток по отношению к голосам
Существуют различные способы перевода звука в движения ветвей. Мы дадим два варианта: один связанный с частотой звуков, а другой — на основе нот.
**Вариант 1**
Первый перевод с голоса на 2D движения: вертикальное движение: сглаженная частота горизонтального движения голоса: различие текущей сглаженной частоты голоса до чуть более ранней частоты
```
δDelay = 0.3;
voiceστ[j_][time_] :=
If[0 < time < tMax,(* smoothing factor *)
Sin[Pi time/tMax]^0.25 {voiceFunction[j][1. time] -
voiceFunction[j][time - δDelay],
voiceFunction[j][1. time]}, {0, 0}]
ParametricPlot[voiceστ[1][t], {t, 0, tMax},
AspectRatio -> 1, PlotRange -> All, Frame -> True, Axes -> False,
PlotStyle -> Thickness[0.002]]
```
**Вариант 2**
Первый перевод с голоса на 2D движения: вертикальное движение: заметим изменение горизонтального движения: качание
```
value = -1;
interpolateDance[{{t1_, t2_}, {t3_, t4_}}, t_] :=
With[{y1 = value, y2 = value = -value},
{{y1, t1 < t < t2}, {((y1 - y2) t - (t3 y1 - t2 y2))/(t2 - t3),
t2 < t < t3}}];
dancingPositionPiecewise[notes : {__SoundNote}] :=
With[{noteTimes =
Cases[notes,
SoundNote[_, times : {startTime_, endTime_}, ___] :> times]},
value = -1;
Quiet[Piecewise[
DeleteDuplicatesBy[
Join @@ BlockMap[interpolateDance[#, t] &, noteTimes, 2, 1],
Last], 0]
]];
tEnd = Max[voices[[All, All, 2]]];
dancingPositions = dancingPositionPiecewise /@ voices;
Plot[Evaluate[KeyValueMap[Legended[#2, #1] &, dancingPositions]], {t,
0, 50},
PlotRangePadding -> Scaled[.05], PlotRange -> {All, {-1, 1}},
ImageSize -> Large, PlotTheme -> "Detailed", PlotLegends -> None]
```
```
dancingPositionPiecewiseList = Normal[dancingPositions][[All, 2]];
bsp = BSplineFunction[
Table[Evaluate[{t, dancingPositionPiecewiseList[[2]]}], {t, 0, 100,
0.2}]]
```
```
ParametricPlot[bsp[t], {t, 0, 1}, AspectRatio -> 1/4,
PlotPoints -> 2000]
```
```
Do[voiceIF[j] =
BSplineFunction[
Table[Evaluate[{t, dancingPositionPiecewiseList[[j]]}], {t, 0, 100,
0.2}]],
{j, 4}]
Do[With[{j = j},
voiceTimeCoordinate[j] =
Interpolation[Table[{t, voiceIF[j][t/100][[1]]}, {t, 0, 100, 0.1}],
InterpolationOrder -> 1]],
{j, 4}]
```
Окончательные движения концов веток с квадратом σ-τ [-1,1] \* [- 1,1].
```
Clear[voiceστ];
voiceστ[j_][time_] :=
If[0 < time < tMax,(* smoothing factor *) Sin[Pi time/tMax]^0.25*
{sway[swayTimeCoordinate[time]/tMax][[2]],
voiceIF[j][voiceTimeCoordinate[j][time]/tMax][[2]]}, {0, 0}]
Table[ListPlot[Table[ voiceστ[j][t], {t, 0, 105, 0.01}],
Joined -> True, AspectRatio -> 1,
PlotStyle -> Thickness[0.002]], {j, 4}]
```
### Моделирование движений украшений
Теперь настало время (наконец) немного поработать с физикой. Украшения (шарик, пятиконечная звезда) я буду моделировать как вынужденный сферический маятник с трением. Форсирование реализуется через положение кончиков веток, которое, в свою очередь, происходит от voiceστ [j] [time].
#### Вынужденный сферический маятник
Сформируем Лагранжиан вынужденного сферического маятника в сферических координатах.
```
Clear[r, ρ, R, X, Y, Z]
R[t_] := {X[t], Y[t], Z[t]}
r[t_] := R[t] +
L {Cos[ϕ[t]] Sin[θ[t]],
Sin[ϕ[t]] Sin[θ[t]], -Cos[θ[t]]}
ℒ = 1/2 r'[t].r'[t] - g r[t][[3]]
```
> -g (-L Cos[θ[t]] + Z[t]) + 1/2 ((Derivative[1][Z][t] + L Sin[θ[t]] Derivative[1][θ][t])^2 + (Derivative[ 1][Y][t] + L Cos[θ[t]] Sin[ϕ[t]] Derivative[1][θ][t] + L Cos[ϕ[t]] Sin[θ[t]] Derivative[1][ϕ][ t])^2 + (Derivative[1][X][t] + L Cos[θ[t]] Cos[ϕ[t]] Derivative[1][θ][t] — L Sin[θ[t]] Sin[ϕ[t]] Derivative[1][ϕ][t])^2)
Добавим функцию диссипации Рэлея ℱ для учета трения.
```
ℱ = 1/2 (\[ScriptF]ϕ ϕ'[t]^2 + \[ScriptF]θ θ'[t]^2);
eoms = {D[D[ℒ, ϕ'[t]], t] -
D[ℒ, ϕ[t]] == -D[ℱ, ϕ'[t]],
D[D[ℒ, θ'[t]], t] -
D[ℒ, θ[t]] == -D[ℱ, θ'[
t]]} // Simplify
```
> {([ScriptF]ϕ + L^2 Sin[2 θ[t]] Derivative[1][θ][t]) Derivative[ 1][ϕ][t] + L Sin[θ[t]] (-Sinϕ[t]t] + Cos[ϕ[t][t] + L Sinθ[t][t]) == 0, [ScriptF]θ Derivative[1][θ][t] + L (g Sin[θ[t]] — L Cos[θ[t]] Sin[θ[t]] Derivative[1][ϕ][t]^2 + Cos[θ[t]] Cosϕ[t]t] + Cos[θ[t]] Sin[ϕ[t]t] + Sin[θ[t][t] + L (θ^′′)[t]) == 0}
Пример, показывающий, что колебания быстро затухают с соответствующими значениями параметра [ScriptF] φ, [ScriptF] θ.
```
paramRules = { g -> 10,
L -> 1, \[ScriptF]ϕ -> 1, \[ScriptF]θ -> 1};
In[126]:= X[t_] := If[2 Pi < t < 4 Pi, 8 Cos[t], 8];
Y[t_] := If[2 Pi < t < 4 Pi, 4 Sin[t], 0];
Z[t_] := 0;
nds = NDSolve[{eoms /. paramRules, ϕ[0] == 1, ϕ'[0] ==
0, θ[0] == 0.001, θ'[0] == 0},
{ϕ, θ}, {t, 0, 20}, PrecisionGoal -> 3, AccuracyGoal -> 3]
```
```
Plot[Evaluate[{\[Phi][t], \[Theta][t]} /. nds[[1]]], {t, 0,
nds[[1, 2, 2, 1, 1, 2]]}, PlotRange -> All]
```
```
Graphics3D[
Table[With[{P = r[t] - R[t] /. nds[[1]] /. paramRules}, {Black,
Sphere[{0, 0, 0}, 0.02], Gray, Cylinder[{{0, 0, 0}, P}, 0.005],
Darker[Blue], Sphere[P, 0.02]}],
{t, 0, 20, 0.05}], PlotRange -> All]
```
#### Рассчитать движения украшений
Получите направление δ и τ точек окончаний веток, интерполированных как функцию времени.
```
branchToVoice =
Association[
Flatten[Function[{v, bs}, (# -> v) & /@ bs] @@@
Normal[voiceBranches]]]
```
> <|2 -> 1, 9 -> 1, 14 -> 1, 17 -> 1, 19 -> 1, 24 -> 1, 27 -> 1, 3 -> 2, 13 -> 2, 15 -> 2, 16 -> 2, 21 -> 2, 26 -> 2, 1 -> 3, 4 -> 3, 5 -> 3,
>
> 12 -> 3, 18 -> 3, 20 -> 3, 6 -> 4, 8 -> 4, 10 -> 4, 11 -> 4, 22 -> 4, 23 -> 4, 25 -> 4|>
```
tValues = Table[1. t , {t, -5, 110, 0.1}];
Do[στValues =
Table[voiceστ[j][t] , {t, -5, 110, 0.1}];
ifσ[j] =
Interpolation[
Transpose[{tValues, στValues[[All, 1]]}]];
ifτ[j] =
Interpolation[
Transpose[{tValues, στValues[[All, 2]]}]],
{j, 4}]
```
Вычислите движение украшений, смоделированных как сферический маятник. Чтобы получить некоторые изменения в передвижениях, я использую небольшие случайные отклонения от вертикали в качестве начальных условий для украшений (моделирование некоторых случайных движений теплового воздуха).
Для временного диапазона во второй половине я использую другую амплитуду (соответствующую более громкой музыке) для амплитуд усиления.
```
changeTimeList = {17.6, 42.2, 66.8, 83.1};
loudness[t_] :=
With[{λ1 = 0.2, λ2 = 0.8, δt = 1.5},
Which[t <= changeTimeList[[3]] - δt, λ1,
changeTimeList[[3]] - δt <= t <=
changeTimeList[[3]] + δt,
λ1 + (λ2 -
1 λ1) (1 -
Cos[Pi (t - (changeTimeList[[
3]] - δt))/(2 δt)])/2,
changeTimeList[[3]] + δt <= t <=
changeTimeList[[4]] - δt , λ2,
changeTimeList[[4]] - δt <= t <=
changeTimeList[[4]] + δt,
λ1 + (λ2 -
1 λ1) (1 +
Cos[Pi (t - (changeTimeList[[
4]] - δt))/(2 δt)])/2,
t >= changeTimeList[[3]] + 1.5, λ1]
]
Plot[loudness[t], {t, 1, 100}, AxesOrigin -> {0, 0}, PlotRange -> All]
```
```
Off[General::stop];
SeedRandom[111];
Monitor[
Do[
branchEnd[j, {σ_, τ_}] =
branchOnStemEndPoint[ allBranches[[j]], {τ, σ}];
If[j =!= conductorBranch,
With[{v = branchToVoice[j]},
tipPosition[t_] =
branchEnd[j, loudness[t] {ifσ[v][t], ifτ[v][t]}]];
{X[t_], Y[t_], Z[t_] } = tipPosition[t];
paramRules = { g -> 20,
L -> 1, \[ScriptF]ϕ -> 1, \[ScriptF]θ -> 1};
While[ Check[
pendulumϕθ[j][t_] =
NDSolveValue[{eoms /. paramRules,
ϕ[0] == RandomReal[{-Pi, Pi}], ϕ'[0] ==
0.01 RandomReal[{-1, 1}],
θ[0] == 0.01 RandomReal[{-1, 1}], θ'[0] ==
0.01 RandomReal[{-1, 1}]},
{ϕ[t], θ[t]}, {t, 0, 105}, PrecisionGoal -> 4,
AccuracyGoal -> 4,
MaxStepSize -> 0.01, MaxSteps -> 100000, Method -> "BDF"];
False, True]] // Quiet],
{j, Length[allBranches]}], j]
```
Вот сферические координатные углы для случайно выбранного украшения. Мы видим увеличение амплитуды колебаний при включении громкой музыки.
```
Plot[pendulum\[Phi]\[Theta][51][t][[2]], {t, 0, 105},
AspectRatio -> 1/4, PlotRange -> All]
```
### Танцующая рождественская елка
Добавим несколько цветов для пятиконечных звездочек.
```
SeedRandom[11];
Do[randomColor[j] = RandomColor[];
randomAngle[j] = RandomReal[{-Pi/2, Pi/2}],
{j, Length[allBranches]}]
```
Быстрое вертикальное начало и медленное окончание движений дирижера.
```
conductorστ[t_] :=
Piecewise[
{{{0, 0},
t <= firstBeat/
2}, {(t - firstBeat/2)/(firstBeat/2) conductorControlPointsWithPauses[[
1, 2]], firstBeat/2 < t <= firstBeat}, {conductorWithPauses[t],
firstBeat < t <=
lastBeat}, {(tMax - t)/(tMax -
lastBeat) conductorControlPointsWithPauses[[-1, 2]],
lastBeat < t < tMax},
{{0, 0}, t >= tMax}}]
```
Начало движения дирижера.
```
ListPlot[{Table[{t, conductorστ[t][[1]]}, {t, -1, 3, 0.01}],
Table[{t, conductorστ[t][[2]]}, {t, -1, 3, 0.01}]},
PlotRange -> All, Joined -> True]
```
```
With[{animationType = 2},
scalefactors[1][t_] :=
Switch[animationType, 1, {0.8, 1} , 2, loudness[t]];
scalefactors[2][t_] :=
Switch[animationType, 1, {1, 1} , 2, loudness[t]];
scalefactors[3][t_] :=
Switch[animationType, 1, {1, 1} , 2, loudness[t]];
scalefactors[4][t_] :=
Switch[animationType, 1, {1, 1} , 2, loudness[t]]
]
christmasTreeWithSwingingOrnaments[t_,
conductorEnhancementFactor : fc_,
conductorCandleAngle : ωc_, topRotationAngle : ω_,
opts___] :=
Graphics3D[{{Darker[Brown], stem},
(* first voice *)
branchOnStemWithBall[allBranches[[#]],
scalefactors[1][t] voiceστ[1][t],
Darker[Yellow, -0.1],
If[t < 0, {0, 0}, pendulumϕθ[#][t]]] & /@
voiceBranches[[1]],
(* second voice *)
branchOnStemWithBall[allBranches[[#]],
scalefactors[2] [t] voiceστ[2][t],
Blend[{Red, Pink}],
If[t < 0, {0, 0}, pendulumϕθ[#][t]]] & /@
voiceBranches[[2]],
(* third voice *)
branchOnStemWithFiveStar[allBranches[[#]],
scalefactors[3][t] voiceστ[3][t], randomColor[#],
Pi/4, If[t < 0, {0, 0}, pendulumϕθ[#][t]]] & /@
voiceBranches[[3]],
(* fourth voice *)
branchOnStemWithCandle[#,
scalefactors[4][t] voiceστ[4][t],
Directive[White, Glow[GrayLevel[0.3]], Specularity[Yellow, 20]],
0] & /@ allBranches[[voiceBranches[[4]]]],
(* conductor *)
branchOnStemWithCandle[
allBranches[[conductorBranch]] {1, 1, 1 + fc},
conductorστ[t],
Directive[Red, Glow[GrayLevel[0.1]],
Specularity[Yellow, 20]], ωc],
Rotate[top, ω, {0, 0, 1}]
}, opts, ViewPoint -> {2.8, 1.79, 0.1},
PlotRange -> {{-8, 8}, {-8, 8}, {-2, 15}},
Background -> RGBColor[0.998, 1., 0.867] ]
```
Используйте низкую точку зрения, поскольку деревья обычно выше людей.
```
Show[christmasTreeWithSwingingOrnaments[70, 0.5, 0.8, 2],
PlotRange -> All, Boxed -> False]
```
### Пусть идет снег!
Немного снега является обязательным для классического (белого) Рождества. Итак, давайте построим несколько 3D-снежинок, а затем заставим их падать. Вместо того, чтобы решать PDE (http://psoup.math.wisc.edu/papers/h3l.pdf), мы будем использовать клеточные автоматы на гексагональных сетках для создания некоторых форм, похожих на снежинки, с гексагональной симметрией.
#### Снежинки (2D)
Давайте возьмем какой-то код из демонстрации Эд Пегга «[Снежинки-подобные шаблоны](http://demonstrations.wolfram.com/SnowflakeLikePatterns/)». Я просто импортирую ноутбук и программно извлекаю соответствующие ячейки, которые определяют переменные hex и snowflake.
```
ReleaseHold /@ (MakeExpression[#[[1]], StandardForm] & /@
Take[Cases[
Import["http://demonstrations.wolfram.com/downloadauthornb.cgi?\
name=SnowflakeLikePatterns"], Cell[_, "Input", ___], ∞], 2]);
makeSnowflake[rule_, steps_] :=
Polygon[hex[#] & /@ Select[Position[Reverse[CellularAutomaton[
{snowflakes[[
rule]], {2, {{0, 2, 2}, {2, 1, 2}, {2, 2, 0}}}, {1,
1}}, {{{1}},
0}, {{{steps}}, {-steps, steps}, {-steps, steps}}]],
0], -steps - 1 < -#[[1]] + #[[2]] < steps + 1 &]]
SeedRandom[33];
Table[Graphics[{Darker[Blue],
makeSnowflake[RandomInteger[{1, 3888}],
RandomInteger[{10, 60}]]}], {4}]
```
Поскольку некоторые снежинки не работают, я выбираю те, которые интересны. Меня интересуют только снежинки, которые достаточно сложны.
```
denseFlakeQ[mr_MeshRegion] :=
With[{c = RegionCentroid[mr], pts = MeshCoordinates[mr]},
( Divide @@ MinMax[EuclideanDistance[c, #] & /@ pts]) < 1/3]
randomSnowflakes[] :=
Module[{sf},
While[(sf = Module[{},
TimeConstrained[
hexagons =
makeSnowflake[RandomInteger[{1, 3888}],
RandomInteger[{10, 60}]];
(Select[ConnectedMeshComponents[DiscretizeRegion[hexagons]],
(Area[#] > 120 && Perimeter[#]/Area[#] < 2 &&
denseFlakeQ[#]) &] /.
\
_ConnectedMeshComponents :> {}) // Quiet, 20, {}]]) === {}]; sf]
randomSnowflakes[n_] :=
Take[NestWhile[Join[#, randomSnowflakes[]] &, {}, Length[#] < n &], n]
SeedRandom[22];
randomSnowflakes[4]
```
```
normalizeFlake[mr_MeshRegion] :=
Module[{coords, center, coords1, size, coords2},
coords = MeshCoordinates[mr];
center = Mean[coords];
coords1 = (# - center) & /@ coords;
size = Max[Norm /@ coords1];
coords2 = coords1/size;
GraphicsComplex[coords2, {EdgeForm[], MeshCells[mr, 2]}]]
```
Вот пять снежинок для дальнейшего использования.
#### Снежинки (3D)
Я добавляю эффект 2D снежинкам, дающий плоским телам иллюзию трёхмерности путём добавления к ним дополнительных поверхностей, чтобы получить 3D снежинки.
```
make3DFlake[flake2D_] :=
Module[{grc, reg, boundary, h, bc, rb, polys, pts},
grc = flake2D[[1]];
reg = MeshRegion @@ (grc /. _EdgeForm :> Nothing);
boundary = (MeshPrimitives[#, 1] &@RegionBoundary[reg])[[All, 1]];
h = RandomReal[{0.05, 0.15}];
bc =
Join[#1, Reverse[#2]] & @@@
Transpose[{Map[Append[#, 0] &, boundary, {-2}],
Map[Append[#, h] &, boundary, {-2}]}];
rb = RegionBoundary[reg];
boundary = (MeshCells[#, 1] &@rb)[[All, 1]];
polys =
Polygon[Join[#1, Reverse[#2]] & @@@
Transpose[{boundary, boundary + Max[boundary]}]];
pts =
Join[Append[#, 0] & /@ MeshCoordinates[rb],
Append[#, h] & /@ MeshCoordinates[rb]];
{GraphicsComplex[Developer`ToPackedArray[pts], polys],
MapAt[Developer`ToPackedArray[Append[#, 0]] & /@ # &, flake2D[[1]],
1],
MapAt[Developer`ToPackedArray[Append[#, h]] & /@ # &, flake2D[[1]],
1]}
]
listOfSnowflakes3D = make3DFlake /@ listOfSnowflakes;
Graphics3D[{EdgeForm[], #}, Boxed -> False,
Method -> {"ShrinkWrap" -> True}, ImageSize -> 120,
Lighting -> {{"Ambient", Hue[.58, .5, 1]}, {"Directional",
GrayLevel[.3], ImageScaled[{1, 1, 0}]}}] & /@ listOfSnowflakes3D
```
#### Модель падающего листа
Простая двумерная модель падающих листов была сделана [Танабе и Канеко](https://doi.org/10.1103/PhysRevLett.73.1372) в 1994 году. Поэтому, чтобы получить некоторую интуицию о возможных формах падения, мы реализуем модель как интерактивную демонстрацию.
```
Manipulate[
Module[{eqs, nds, tmax, g = 10, α, sign, V, x, y, u,
v, θ, ω, kpar = kperp/f, ρ = 10^ρexp},
α = ArcTan[u[t], v[t]];
sign = Piecewise[{{1, (v[t] < 0 &&
0 <= α + θ[t] <= Pi) || (v[t] >
0 && -Pi <= α + θ[t] <= 0)}}, -1];
V = Sqrt[u[t]^2 + v[t]^2];
eqs =
{D[x[t], t] == u[t],
D[y[t], t] == v[t],
D[u[t],
t] == -(kperp Sin[θ[t]]^2 + kpar Cos[θ[t]]^2) u[
t] +
(kperp - kpar) Sin[θ[
t]] Cos[θ[t]] v[t] -
sign Pi ρ V^2 Cos[α + θ[t]] Cos[α],
D[v[t],
t] == -(kperp Cos[θ[t]]^2 + kpar Sin[θ[t]]^2) v[
t] +
(kperp - kpar) Sin[θ[
t]] Cos[θ[t]] u[t] +
sign Pi ρ V^2 Cos[α + θ[
t]] Sin[α] - g,
D[ω[t],
t] == -kperp ω[
t] - (3 Pi ρ V^2/l) Cos[α + θ[
t]] Sin[α + θ[t]],
D[θ[t], t] == ω[t]} /. kpar -> kperp/f;
nds = NDSolve[
Join[eqs, {x[0] == 0, y[0] == 0, u[0] == 0,
v[0] == 0.01, ω[0] == 0, θ[0] == θ0}],
{x, y, u, v, θ, ω}, {t, 0,
T}, MaxSteps -> 2000] // Quiet;
tmax = nds[[1, 2, 2, 1, 1, 2]];
Graphics[{Thickness[0.002], Gray,
Table[Evaluate[
Line[{{x[t], y[t]} - l/2 {Cos[θ[t]], Sin[θ[t]]},
{x[t],
y[t]} + l/2 {Cos[θ[t]], Sin[θ[t]]}}] /.
nds[[1]]],
{t, 0, tmax, tmax/n}],
Blue,
Line[Table[
Evaluate[{x[t], y[t]} /. nds[[1]]], {t, 0, tmax, tmax/200}]]},
AspectRatio -> ar, Frame -> True,
PlotRange -> All]],
"system parameters",
{{kperp, 5.1, Subscript["k", "∟"]}, 0.01, 10,
Appearance -> "Labeled"},
{{f, 145,
Row[{Subscript["k", "∟"], "/",
Subscript["k", "∥"]}]}, 0.01, 200,
Appearance -> "Labeled"},
{{ρexp, -0.45, Log["ρ"]}, -3, 1, Appearance -> "Labeled"},
{{l, 0.63}, 0.01, 10, Appearance -> "Labeled"} ,
Delimiter,
"fall parameters",
{{θ0, 1, Subscript["θ", "0"]}, -Pi, Pi,
Appearance -> "Labeled"},
{{T, 2, "falling time"}, 0, 10, Appearance -> "Labeled"} ,
Delimiter,
"plot",
{{ar, 1, "aspect ratio"}, {1, Automatic}},
{{n, 200, "snapshots"}, 2, 500, 1}]
```
Я буду моделировать процесс падения феноменологически и эвристически, а не через решение дифференциальных уравнений. Со значениями плотности снежинок и воздуха вместе с их отношением толщина / площадь они падают в основном прямо вниз, с небольшими боковыми движениями и внутренними вращениями.
#### Падение снежинок
Моделируем внутренние вращения вокруг центра масс, а также некоторые небольшие боковые движения.
```
randomParametrizedRotationMatrix[n_, τ_] := Function @@ {τ,
Module[{phi, s, c},
Do[phi[i] =
Sum[RandomReal[{-1, 1}] Sin[
RandomReal[{0, n}] τ + 2 Pi RandomReal[]], {n}];
{c[i], s[i]} = {Cos[phi[i]], Sin[phi[i]]}, {i, 3}];
{{c[1], s[1], 0}, {-s[1], c[1], 0}, {0, 0, 1}}.
{{c[2], 0, s[2]}, {0, 1, 0}, {-s[2], 0, c[2]}}.
{{1, 0, 0}, {0, c[3], s[3]}, {0, -s[3], c[3]}}]};
randomParametrizedPathFunction := Function[t,
Evaluate[{RandomReal[{-5, 5}] +
Sum[RandomReal[{-1, 1}]/# Cos[2 Pi # t] &[
RandomReal[{1, 4}]], {k, 5}],
RandomReal[{-5, 5}] +
Sum[RandomReal[{-1, 1}]/# Cos[2 Pi # t] &[
RandomReal[{1, 4}]], {k, 5}],
RandomReal[{2, 12}] - RandomReal[{1.5, 2.5}] t}]]
SeedRandom[55];
Do[rotMat[j] = randomParametrizedRotationMatrix[3, τ];
trans[j] = randomParametrizedPathFunction;
snowflakeColor[
j] = {{"Ambient",
Hue[RandomReal[{0.55, 0.6}], RandomReal[{0.48, 0.52}],
RandomReal[{0.95, 1}]]}, {"Directional",
GrayLevel[RandomReal[{0.28, 0.32}]],
ImageScaled[{1, 1, 0}]}}, {j, Length[listOfSnowflakes]}]
fallingSnowflake[flake_, {t_, ℛ_}] :=
flake /. GraphicsComplex[cs_, rest__] :>
GraphicsComplex[(ℛ.# + t) & /@ cs, rest]
Manipulate[
Graphics3D[{EdgeForm[],
Table[{Lighting -> snowflakeColor[k],
fallingSnowflake[
listOfSnowflakes3D[[k]], {trans[k][t], rotMat[k][t]}]}, {k,
Length[listOfSnowflakes3D]}] },
PlotRange -> 6, ViewPoint -> {0, -10, 0}, ImageSize -> 400],
{{t, 3.2}, -5, 20}]
```
Для полной анимации использовалось несколько сотен снежинок.
### Создание анимационных кадров
Теперь запустите анимацию, вытянув ветвь дирижера, а также поверните верхнюю часть во время воспроизведения музыки. Затем мы послушаем и рассмотрим один стих. После, мы двинемся один раз вокруг дерева и добавим немного снегопада. И затем приходит интересная часть, где дерево качает вокруг своими украшениями, потом успокаивается и убирает свою ветвь дирижера. Я генерирую 24 кадра для каждой секунды звука.
```
conductorBranchMaxfactor = 0.5;
conductorBranchLength[t_] :=
conductorBranchMaxfactor*
Which[t < -3, 0, -3 < t <= 0, (t + 3)/3., 0 <= t <= tMax, 1,
tMax < t < tMax + 3, (1 - (t - tMax)/3), True, 0];
topRotation[t_] :=
Which[t < -3 || t > tMax + 3, 0,
True, (1. - Cos[(t + 3)/(tMax + 6)]) 20 2 Pi];
viewPoint[t_] :=
With[{vp = {2.8, 1.79, 0.1}},
Which[t < changeTimeList[[1]] || t > changeTimeList[[2]], vp,
changeTimeList[[1]] <= t <= changeTimeList[[2]],
Module[{t0 = changeTimeList[[1]],
Δt =
changeTimeList[[2]] - changeTimeList[[1]], ωvp},
ωvp = -Pi (1 -
Cos[ Pi (t - t0)/Δt]); {{Cos[ωvp],
Sin[ωvp], 0}, {-Sin[ωvp], Cos[ωvp],
0}, {0, 0, 1}}.vp +
{0, 0, 2 Sin[Pi (t - t0)/Δt]^4 }]]]
ParametricPlot3D[
viewPoint[t], {t, changeTimeList[[1]], changeTimeList[[2]]},
BoxRatios -> {1, 1, 1}]
```
```
animationFrame[t_] :=
Show[christmasTreeWithSwingingOrnaments[t, conductorBranchLength[t],
1.4 conductorBranchLength[t], topRotation[t]],
Background -> None, Boxed -> False, SphericalRegion -> True,
ViewPoint -> viewPoint[t]]
```
Последний тест перед запуском экспорта кадров, который займет несколько часов:
```
animationFrame[35]
```
```
framesPerSecond = 24;
animationFrameDirectory =
"/Users/mtrott/Desktop/ConductingChristmasTreeAnimationFrames/";
Monitor[
Do[
With[{t = -3 + 1/framesPerSecond (frame - 1)}, gr = animationFrame[t];
Export[animationFrameDirectory <> IntegerString[frame, 10, 4] <> ".png", gr,
ImageSize -> 1800, Background -> None]
],
{frame, 1, framesPerSecond (100 + 2 3)}],
Row[{frame, " | ", Round[MemoryInUse[]/1024^2], "\[ThinSpace]MB" }]
]
```
Теперь используйте свое любимое программное обеспечение для редактирования фильмов (например, Adobe After Effects) и поместите движущееся дерево, звук и снегопад вместе.
По вопросам приобретения лицензий обращайтесь info-russia@wolfram.com
[Бесплатная триал версия Mathematica](https://www.wolfram.com/mathematica/trial/)
[Бесплатный триал Wolfram|One](https://account.wolfram.com/access/wolfram-one/trial) | https://habr.com/ru/post/345358/ | null | ru | null |
# «Оцифровываем» каптчу единого реестра сайтов, защищающего людей от информации
Совсем недавно открылся портал [Единого государственного реестра сайтов](http://zapret-info.gov.ru/). Отдельно от всего прочего мне приглянулась очень слабая каптча, и я решил её побороть.
Подобными вещами я уже занимался, правда, не в таком масштабе. Если вам интересно, как получить КПД распознавания в 57% используя только GNU/**Bash**, **imagemagick** и **Tesseract**-ocr, добро пожаловать под кат.
Нижеследующая инструкция может быть легко модифицирована под любые другие подобные слабые каптчи.
Вступление
==========
Распознавание самих картинок каптч можно разделить ровно на два этапа:
* Подготовка картинки. Для этого я буду использовать imagemagick
* Распознавание символов. В этом случае я выбрал Tesseract, но на более простых каптчах (без поворотов, без разрывов) можно использовать ocrad, к примеру.
Получение картинок и отправление результатов легко совершается при помощи curl (или wget, но с ним я не подружился).
Подготовка картинок
-------------------
В ImageMagick есть встроенный язык Fx для создания спец-эффектов. Так как на каптче реестра буквы всегда черные, самый простой вариант скрипта, убирающий всё нечерное, будет выглядеть так:
```
convert file.png -colorspace cmyk -fx 'k * (k >= 1.0)' file.ppm
```
Выполнение занимает десятую секунды, что допустимо. Но качество картинки — нет, так что нужно пройтись по ней еще раз. Можно положиться на то, что если буква была задета линией, то в таком месте должны быть закрашенные пиксели-соседи сразу с двух противоположных сторон:
```
convert file.ppm -colorspace cmyk -fx 'k || (p[-1].k && p[+1].k) || (p[0,-1].k && p[0,+1].k)' out.ppm
```
Чем мы жертвуем еще половиной секунды. Как окажется позже, это увеличит процент успеха с 1% до 22% (на 100 контрольных картинках).
Распознавание символов
----------------------
Тут всё еще проще. Травим tesseract на картинку, забираем результат из файла. При желании, можно научить его шрифту каптчи как отдельному языку, но овчинка выделки не стоит.
```
tesseract out.ppm result -psm 8 nobatch digits 2>/dev/null
res=$(cat result.txt | sed -e 's/[^0-9]//g')
```
Отработка в реальных условиях
=============================
Как я уже сказал выше, такая комбинация дала правильный ответ на 22 из 100 тестовых картинок. Но тесты — не интересно, и я решил проверить скорость работы в реальных условиях.
**Главный скрипт**
```
#!/bin/bash
c=$(curl -c cook.txt http://zapret-info.gov.ru/ | iconv -f cp1251 | grep capcha | sed -e 's/"/\n/g' | grep services)
url="http://zapret-info.gov.ru$c"
r=work01
#get
curl -b cook.txt "$url" > "$r.png"
#prepare
convert $r.png -colorspace cmyk -fx 'k * (k >= 1.0)' $r.png
convert $r.png -colorspace cmyk -fx 'k || (p[-1].k && p[+1].k) || (p[0,-1].k && p[0,+1].k)' $r.png
#exterminate
tesseract $r.png $r -psm 8 nobatch digits
res=`cat $r.txt | sed -e 's/[^0-9]//g'`
#check
if [ "$(echo $res | wc -c)" -ne 9 ]; then
echo fail && exit
fi
#send
code=$(echo $c | sed -e 's/[^0-9]//g')
fin=`curl -b cook.txt -d "act=search&secretcodeId=$code&searchstring=ya.ru&secretcodestatus=$res" 'http://zapret-info.gov.ru/'| iconv -f cp1251`
if echo "$fin" | grep -q 'не значится'; then
echo succ
else
echo tesfail
fi
rm $r.png $r.txt cook.txt
```
**Обертка**
```
#!/bin/bash
score=0
all=0
while [ "$score" -lt 41 ]; do
r=`bash per.sh 2>/dev/null`
[ "$r" = 'succ' ] && let score++
let all++
echo "$score/$all; $r"
done
```
**Строка запуска**
```
time bash tt.sh | tee -a log.txt
```
Результаты, статистика
======================
Вышеуказанный набор скриптов производит 41 успешную проверку на наличие ya.ru в реестре. Небольшая статистика по нему:
```
Успешно подобрано: 41
Всего каптч: 218
Время работы: 5 минут 4 секунды (5m4.178s)
КПД: 19%
КПД с учетом заведомо неправильных решений, которые не отправлялись на проверку: 57%
Максимальный КПД во время работы: 33%
Минимальный КПД во время работы: 12%
```
Пути улучшения
==============
* Одну картинку можно получить множество раз, получая разные каптчи с одним текстом. Это можно использовать.
* Используя нормальные и проверенные способы можно получить очень хороший КПД.
* Или просто научить Tesseract шрифту каптчи. Сам шрифт похож на Arial, но тессеракт постоянно путает 3 и 8, 1 и 7.
* Оптимизировать получение информации: значительная часть времени работы скрипта уходит на получение страниц и картинок с сервера. | https://habr.com/ru/post/157145/ | null | ru | null |
# Long Polling для Android
Прочитав [статью](http://habrahabr.ru/company/cackle/blog/167895/), стал внедрять в web проекты Long Polling. На nginx крутится серверная часть, на javascript клиенты слушают каналы. Прежде всего это было очень полезно для личных сообщений на сайте.
Потом в поддержку web проектов стали разрабатываться приложения под Android. Встал вопрос: как реализовать многопользовательский проект, в котором равнозначно участвовали бы как браузерные клиенты, так и мобильные приложения. Так как Long Polling уже был внедрён в браузерные версии, решено было написать java модуль и для Android.
Задачи написать полностью аналог js библиотеке не было, поэтому я начал писать модуль под частный, но наиболее популярный, случай.
#### Серверная часть
Итак начну с сервера.
##### Nginx
Используется [nginx-push-stream-module](https://github.com/wandenberg/nginx-push-stream-module)
В настройках nginx:
```
# Директива для сбора статистики
location /channels-stats {
push_stream_channels_statistics;
push_stream_channels_path $arg_id;
}
# Директива для публикации сообщений
location /pub {
push_stream_publisher admin;
push_stream_channels_path $arg_id;
push_stream_store_messages on; # Сохранять пропущенные сообщения, чтобы доставить их, когда клиент начнёт слушать канал
}
# Директива для прослушивания сообщений
location ~ ^/lp/(.*) {
push_stream_subscriber long-polling;
push_stream_channels_path $1;
push_stream_message_template "{\"id\":~id~,\"channel\":\"~channel~\",\"tag\":\"~tag~\",\"time\":\"~time~\",\"text\":~text~}";
push_stream_longpolling_connection_ttl 30s;
}
```
В конфиге описаны три директивы: для отправки, приёма сообщений, а так же для получения статистики.
##### PHP
Сообщения публикуются сервером. Вот пример функции на php:
```
/*
* $cids - ID канала, либо массив, у которого каждый элемент - ID канала
* $text - сообщение, которое необходимо отправить
*/
public static function push($cids, $text)
{
$text = json_encode($text);
$c = curl_init();
$url = 'http://example.com/pub?id=';
curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
curl_setopt($c, CURLOPT_POST, true);
$results = array();
if (!is_array($cids)) {
$cids = array($cids);
}
$cids = array_unique($cids);
foreach ($cids as $v) {
curl_setopt($c, CURLOPT_URL, $url . $v);
curl_setopt($c, CURLOPT_POSTFIELDS, $text);
$results[] = curl_exec($c);
}
curl_close($c);
}
```
Здесь тоже всё просто: передаём канал(ы) и сообщение, которое хотим отправить. Ввиду того, что обычный plain текст никому не интересен, и существует замечательный формат json, отправлять можно сразу объекты.
Долго обдумывалась концепция формирования названия каналов. Нужно предусмотреть возможность отправления разнотипных сообщений всем клиентам, или только одному, или нескольким, но отфильтрованных по какому то признаку.
В итоге был разработан следующий формат, состоящий из трёх параметров:
```
[id пользователя]_[название сервиса]_[id сервиса]
```
Если мы хотим отправить сообщение всем пользователям, то используем канал:
```
0_main_0
```
если пользователю с id=777:
```
777_main_0
```
если изменилась стоимость заказа с id=777 в общем для всех списке, то:
```
0_orderPriceChanged_777
```
Получилось очень гибко.
Хотя впоследствии, немного поразмыслив, пришёл к выводу, что клиентов лучше не нагружать прослушкой всех каналов, а перенести эту нагрузку на сервер, который будет формировать и отправлять сообщение каждому пользователю.
А для разделения типов сообщения можно использовать параметр, например act:
```
const ACT_NEW_MESSAGE = 1;
LongPolling::push($uid."_main_0", array(
"act" => ACT_NEW_MESSAGE,
"content" => "Hello, user ".$uid."!",
));
```
#### Клиентская часть
Про серверную часть вроде всё. Приступим к java!
Класс я разместил на [gihub](https://github.com/jonasasx/LongPolling).
В своей библиотеке я использовал библиотеку [android-async-http](https://github.com/loopj/android-async-http), осуществляющую удобные асинхронные http запросы. В примере я добавил скомпилированный jar файл.
Интерфейс у класса достаточно простой.
Для начала надо создать callback объект, в методы которого будут приходить ответы. Так как мы используем в сообщениях преимущественно объекты, то в качестве callback класса был выбран JsonHttpResponseHandler:
```
private final static int ACT_NEW_ORDER = 1;
private final static int ACT_DEL_ORDER = 2;
private final static int ACT_ATTRIBUTES_CHANGED = 3;
private final static int ACT_MESSAGE = 4;
private final JsonHttpResponseHandler handler = new JsonHttpResponseHandler() {
@Override
public void onSuccess(int statusCode, Header[] headers, JSONObject response) {
try {
JSONObject json = response.getJSONObject("text");
switch (json.getInt("act")) {
case ACT_NEW_ORDER:
...
break;
case ACT_DEL_ORDER:
...
break;
case ACT_ATTRIBUTES_CHANGED:
...
break;
case ACT_MESSAGE:
...
break;
default:
break;
}
} catch (JSONException e) {
e.printStackTrace();
}
}
};
```
В этом примере слушаются сообщения о появлении нового заказа, удалении заказа, изменении атрибутов пользователя и новом личном сообщении.
Дальше инициализируем LongPolling объект (допустим мы это делаем в Activity):
```
private LongPolling lp;
private int uid = 1;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_balance);
lp = new LongPolling(getApplicationContext(), "http://example.com/lp/", Integer.toString(uid) + "_main_0", handler);
}
```
Если Long Polling нам нужен только в Activity, то необходимо прописать:
```
public void onResume() {
super.onResume();
lp.connect();
}
public void onPause() {
super.onPause();
lp.disconnect();
}
```
Если же сообщения нужно принимать во всём приложении (а это как правило), то объект можно инициализировать в классе приложения (Application) или в сервисе (Service).
Тогда сразу после инициализации нужно начать прослушивание
```
lp = new LongPolling(getApplicationContext(), "http://example.com/lp/", Integer.toString(uid) + "_main_0", handler);
lp.connect();
```
И, дабы не угнетать аккумулятор пользователя, надо зарегистрировать BroadcastReceiver на события появления/исчезновения подключения к интернет:
AndroidManifest.xml
```
xml version="1.0" encoding="utf-8"?
...
...
```
и InternetStateReceiver
```
public class InternetStateReceiver extends BroadcastReceiver {
public void onReceive(Context context, Intent intent) {
final ConnectivityManager connMgr = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
final android.net.NetworkInfo wifi = connMgr.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
final android.net.NetworkInfo mobile = connMgr.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
if (wifi != null && wifi.isAvailable() || mobile != null && mobile.isAvailable()) {
application.getInstance().lp.connect();
} else {
application.getInstance().lp.disconnect();
}
}
}
```
#### Статистика
Ну и в качестве плюшки, было б интересно посмотреть статистику реального времени, благо мы вовремя предусмотрели это.
Допустим, нас интересует количество пользователей онлайн.
Для этого мы получаем XML/json информацию по url:
```
http://example.com/channels-stats?id=ALL
```
и видим следующее:
```
xml version="1.0" encoding="UTF-8" ?
example.com
2014-03-22T00:03:37
2
0
818530
4\_main\_0
0
0
1
23\_main\_0
0
0
1
```
В теге subscribers мы видим количество слушателей каждого канала. Но так как в данном случае у каждого пользователя свой канал, на PHP составим список пользователей онлайн:
```
const STATISTICS_URL = 'http://example.com/channels-stats?id=ALL';
public static function getOnlineIds()
{
$str = file_get_contents(self::STATISTICS_URL);
if (!$str)
return;
$json = json_decode($str);
if (empty($json -> infos))
return;
$ids = array();
foreach ($json->infos as $v) {
if ($v -> subscribers > 0 && substr_count($v -> channel, '_main_0') > 0) {
$ids[] = str_replace('_main_0', '', $v -> channel);
}
}
return $ids;
}
```
Вот мы и получили id пользователей в сети. Но есть одно НО. В момент, когда клиент переподключается к серверу, в статистике его не будет, это необходимо учитывать.
#### Заключение
Ну вот, вроде, обо всём рассказал. Теперь можно рассылать сообщения пользователям и в браузер, где их примет JavaScript, и в приложение на Android, используя один и тот же отправщик. И вдобавок можем выводить, к примеру на сайте, точное количество пользователей онлайн.
Буду рад услышать критику и предложения.
##### Ссылки
1. <https://github.com/jonasasx/LongPolling> — собственно результат работы
2. <https://github.com/wandenberg/nginx-push-stream-module> — nxing модуль
3. <https://github.com/loopj/android-async-http> — библиотека асинхронных http запросов для Android | https://habr.com/ru/post/216713/ | null | ru | null |
# Управление Arduino через интернет с помощью ПК — опыт новичка
Всем привет. В этой статье расскажу о том, как мне удалось реализовать управление Arduino через интернет с помощью подключенного к интернету ПК. В общем случае данный способ можно использовать для любого микроконтроллера, например PIC. Способ довольно дубовый, есть куда модернизироваться и есть много более продвинутых схем, но в простейшем случае этого хватит.
Вместо вступления
-----------------
Хочется сразу сказать, что в этой статье я не буду очень сильно углубляться в тонкости программирования, предполагается, что читающий имеет хотя-бы минимальные азы. Расскажу в целом как использовались ресурсы и о интересных моментах.
Предпосылки к созданию данного способа у меня возникли во время создания моего электромобиля: [Жмяк сюда!](https://habr.com/ru/post/473708/) Скажу сразу, что создавалось это всё больше из спортивного интереса, нежели для серьёзных практических работ, но тем не менее оно работает и может пригодится кому-либо.
На чем строится вся система и как реализовано в железе
------------------------------------------------------
Схема работы следующая: с сервера считываем файл, в котором лежат данные с помощью программы, запущенной на ПК/ноутбуке. Эта программа через USB отсылает данные на контроллер. Контроллер принимает данные и по ним выполняет действия. Схема с сервером привлекательна тем, что управлять схемой можно без приложения, просто зайдя на сайт с любого смартфона/планшета/пк/ноутбука в любой точке планеты, где есть доступ к интернету.
*PS. Про серверную часть рассказано ниже.*
В этой статье я буду управлять Arduino MEGA 2560 (китайским аналогом), но «за кулисами» схема спокойно сработала и с PIC16F877А, единственное что пришлось использовать — переходник USB-TTL:
Понятное дело программа для PIC несколько отличается от программы для Ардуино, ввиду разных типов МК, но принцип один и тот-же:
Принимаем через COM-порт данные, сравниваем их с внутренней таблицей команд и выполняем соответственное действие.
Схема изначально мне показалась очень простой, но было одно НО — небыло программы, которая читала бы файлик в интернете и отсылала данные в COM-порт. Соответственно такую программу пришлось написать.
Программа писалась на VB6. Для чтения файла с сервера используется компонент VB6: Microsoft Internet Transfer Control 6.0. С его помощью просто читается текстовый файл на сервере в строковую переменную. После чтения эта строка отсылается в COM-порт с помощью компонента VB6: Microsoft Comm Control 6.0. Весь процесс чтения файла и отсылания строки читается в цикле с использования таймера. Интервал срабатывания таймера можно менять в конфиге программы, либо прямо во время работы. Кроме этого можно выбрать режим работы порта, его номер, режим работы интернет соединения и ссылку на читаемый файл.
Хочется сделать замечание, что при больших размерах файла и маленьких промежутках программа подвисает, но продолжает работать. Размер буфера моей программы 512 байт. Учитывая, что у моего МК буфер меньше, этого хватает.
Важный момент. Программа в МК не умеет парсить данные, она умеет читать только какой символ был передан на вход через последовательный порт. Без ошибок у меня получилось принимать латиницу (26 символов A-Z и 10 цифр 0-9). Итого 36 команд, если алгоритм доработать и ввести парсинг данных в МК, то передавать можно любые данные. Так же есть возможность «допилинга» ПО для двустороннего обмена данными.
Выбор сервера и серверная часть
-------------------------------
Для серверной части подойдет любой сервер с поддержкой PHP, хоть запущенный на личном ПК, лишь бы был статический IP, но я лично использую арендованный Jino. Серверная часть в моём примере состоит из двух файлов: HTML странички с формой с кнопками ВКЛ/ВЫКЛ светодиода и PHP скрипта, который меняет содержимое TXT файла из которого программа, запущенная на ПК читает данные.
Программное обеспечение
-----------------------
Код HTML. Форма с 2 кнопками, вкл/выкл светодиод на плате:
```
Управление светодиодом
Светодиод:
```
Код PHP, здесь мы пишем в файл команду А, если светодиод должен гореть, и В если должен потухнуть:
```
php
$cm = fopen("command.txt", "w");
switch ($_POST['sv']) {
case "On":
fwrite($cm,"a");
break;
case "Off":
fwrite($cm,"b");
break;
}
fclose($cm);
?
```
Теперь собственно код для Arduino:
```
int val; // освобождаем память в контроллере для переменой
void setup() {
Serial.begin(9600); // подключаем последовательный порт
pinMode(13, OUTPUT); // объявляем пин 13 как выход
}
void loop() {
// проверяем, поступают ли какие-то команды
if (Serial.available()) {
val = Serial.read(); // переменная val равна полученной команде
if (val == 'a') {digitalWrite(13, HIGH);} // при a включаем светодиод
if (val == 'b') {digitalWrite(13, LOW);} // при b выключаем светодиод
}}
```
Сама программа для чтения информации на сервере с пересылкой в COM-порт и её исходный код лежат в архиве по ссылке: [Яндекс-Диск](https://yadi.sk/d/XOs8J3joC-2ICQ) Программа скомпилирована в несколько вариантов кода, возможно будут какие-либо различия в работе, но не должно быть. При первом запуске EXEшника генерируется файл справки и конфиг-файл. Данные из этого файла считываются при запуске программы, если он существует. Если файл не существует (например при первом запуске программы), то config-файл создается с дефолтными значениями.
Результаты работы
-----------------
Вместо заключения
-----------------
В данном примере я реализовал простой «дубовый» алгоритм, который работает. Есть конечно куда развиваться дальше, но тем не менее уже в таком виде можно отсылать 36 команд. Если реализовать парсинг входящих данных в микроконтроллере, то можно передавать любые данные. Для моих задач 36 команд хватит с головой, да и к тому-же это опыт новичка :) | https://habr.com/ru/post/491616/ | null | ru | null |
# Как эффективнее использовать kubectl: подробное руководство
Если вы работаете с Kubernetes, то, вероятно, kubectl — одна из самых используемых вами утилит. А всякий раз, когда вы тратите много времени на работу с определенным инструментом, стоит хорошо его изучить и научиться эффективно использовать.
Команда [Kubernetes aaS от Mail.ru](https://mcs.mail.ru/containers/) перевела статью Даниэля Вейбеля, в которой вы найдете советы и приемы для эффективной работы с kubectl. Также она поможет глубже понять работу Kubernetes.
По словам автора, цель статьи — сделать вашу ежедневную работу с Kubernetes не только более эффективной, но и более приятной!
Введение: что такое kubectl
---------------------------
Перед тем как учиться использовать kubectl более эффективно, нужно получить базовое понимание того, что это такое и как работает.
С точки зрения пользователя, kubectl — панель управления, которая позволяет выполнять операции Kubernetes.
С технической точки зрения, kubectl — клиент Kubernetes API.
Kubernetes API — это HTTP REST API. Этот API — настоящий пользовательский интерфейс Kubernetes, через который он полностью контролируется. Это означает, что каждая операция Kubernetes представляется как конечная точка API и может быть выполнена HTTP-запросом к этой конечной точке.
Следовательно, основная задача kubectl — выполнять HTTP-запросы к API Kubernetes:
Kubernetes — полностью ресурсно-ориентированная система. Это означает, что он поддерживает внутреннее состояние ресурсов, и все операции Kubernetes являются операциями CRUD.
Вы полностью контролируете Kubernetes, управляя этими ресурсами, и Kubernetes выясняет, что делать, основываясь на текущем состоянии ресурсов. По этой причине ссылка на API Kubernetes организована в виде списка типов ресурсов со связанными с ними операциями.
**Давайте рассмотрим пример**.
Предположим, вы хотите создать ресурс ReplicaSet. Чтобы это сделать, вы описываете ReplicaSet в файле по имени `replicaset.yaml`, затем запускаете команду:
```
$ kubectl create -f replicaset.yaml
```
В результате будет создан ресурс ReplicaSet. Но что происходит за кулисами?
В Kubernetes есть операция создания ReplicaSet. Как и любая другая операция, она предоставляется в качестве конечной точки API. Конкретная конечная точка API для этой операции выглядит так:
```
POST /apis/apps/v1/namespaces/{namespace}/replicasets
```
Конечные точки API всех операций Kubernetes можно найти в [справочнике API](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.13) (включая [указанную выше конечную точку](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.13/#create-replicaset-v1-apps)). Чтобы сделать фактический запрос к конечной точке, надо предварительно добавить URL-адрес сервера API к путям конечной точки, которые перечислены в справочнике по API.
Следовательно, когда вы выполняете указанную выше команду, kubectl отправляет HTTP-запрос POST к вышеуказанной конечной точке API. Определение ReplicaSet, которое вы указали в файле `replicaset.yaml`, передается в теле запроса.
Именно так работает kubectl для всех команд, которые взаимодействуют с кластером Kubernetes. Во всех этих случаях kubectl просто отправляет HTTP-запросы к соответствующим конечным точкам API Kubernetes.
*Обратите внимание, что можно полностью управлять Kubernetes с помощью такой утилиты как `curl`, вручную отправляя HTTP-запросы в API Kubernetes. Kubectl просто упрощает использование API Kubernetes.*
Это основы того, что такое kubectl и как он работает. Но есть еще кое-что об API Kubernetes, что должен знать каждый пользователь kubectl. Давайте кратко окунемся во внутренний мир Kubernetes.
### Внутренний мир Kubernetes
Kubernetes состоит из набора независимых компонентов, которые выполняются как отдельные процессы на узлах кластера. Некоторые компоненты работают на главных узлах, другие — на рабочих узлах, каждый компонент выполняет свою специальную задачу.
Вот наиболее важные компоненты на главных нодах:
1. **Хранилище** — хранит определения ресурсов ([обычно это etcd](https://mcs.mail.ru/blog/zapuskaem-etcd-klaster-dlya-kubernetes)).
2. **API сервер** — предоставляет API и управляет хранилищем.
3. **Диспетчер контроллеров** — гарантирует, что статусы ресурсов соответствуют спецификациям.
4. **Планировщик** — планирует поды на рабочих узлах.
И вот один самый важный компонент на рабочих нодах:
1. **Kubelet** — управляет запуском контейнеров на рабочей ноде.
Чтобы понять, как эти компоненты работают вместе, рассмотрим пример.
Предположим, вы только что выполнили `kubectl create -f replicaset.yaml`, после чего kubectl сделал HTTP-запрос POST к [конечной точке API-интерфейса ReplicaSet](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.13/#create-replicaset-v1-apps) (передавая определение ресурса ReplicaSet).
**Что происходит в кластере?**
1. После выполнения `kubectl create -f replicaset.yaml` API-сервер сохраняет определение вашего ресурса ReplicaSet в хранилище:
2. Далее запускается контроллер ReplicaSet в диспетчере контроллеров, который обслуживает создание, изменение и удаление ресурсов ReplicaSet:
3. Контроллер ReplicaSet создает определение пода для каждой реплики ReplicaSet (в соответствии с шаблоном пода в определении ReplicaSet) и сохраняет их в хранилище:
4. Запускается планировщик, отслеживающий поды, которые еще не были назначены ни одной рабочей ноде:
5. Планировщик выбирает подходящую рабочую ноду для каждого пода и добавляет эту информацию в определение пода в хранилище:
6. На рабочей ноде, которой назначен под, запускается Kubelet, он отслеживает поды, назначенные этой ноде:
7. Kubelet считывает определение пода из хранилища и дает команды среде выполнения контейнеров, например Docker, на запуск контейнеров на ноде:
**Ниже текстовый вариант этого описания.**
Запрос API к конечной точке создания ReplicaSet обрабатывается сервером API. Сервер API аутентифицирует запрос и сохраняет определение ресурса ReplicaSet в хранилище.
Это событие запускает контроллер ReplicaSet, который является подпроцессом диспетчера контроллеров. Контроллер ReplicaSet следит за созданием, обновлением и удалением ресурсов ReplicaSet в хранилище и получает уведомление о событии, когда это происходит.
Задача контроллера ReplicaSet — убедиться, что существует нужное количество подов реплики ReplicaSet. В нашем примере подов пока не существует, поэтому контроллер ReplicaSet создает эти определения подов (в соответствии с шаблоном пода в определении ReplicaSet) и сохраняет их в хранилище.
Создание новых подов запускает планировщик, отслеживающий определения подов, которые еще не запланированы для рабочих нод. Планировщик выбирает подходящую рабочую ноду для каждого пода и обновляет определения пода в хранилище.
*Обратите внимание, что до этого момента нигде в кластере не выполнялся код рабочей нагрузки. Всё, что было сделано до сих пор,* *—* *это создание и обновление ресурсов в хранилище на главном узле.*
Последнее событие запускает Kubelet, которые следят за подами, запланированными для их рабочих нод. Kubelet рабочей ноды, для которой установлены ваши поды ReplicaSet, должен дать указание среде выполнения контейнеров, например Docker, загрузить требуемые образы контейнеров и запустить их.
В этот момент, наконец, ваше приложение ReplicaSet запущено!
### Роль API Kubernetes
Как вы увидели в предыдущем примере, компоненты Kubernetes (за исключением сервера API и хранилища) смотрят за изменением ресурсов в хранилище и изменяют информацию о ресурсах в хранилище.
Конечно, эти компоненты не взаимодействуют с хранилищем напрямую, а только через Kubernetes API.
**Рассмотрим следующие примеры**:
1. Контроллер ReplicaSet использует конечную точку API [list ReplicaSets](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.13/#list-replicaset-v1-apps) c параметром `watch` для наблюдения за изменениями ресурсов ReplicaSet.
2. Контроллер ReplicaSet использует конечную точку API [create Pod](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.13/#create-pod-v1-core) (создать под) для создания подов.
3. Планировщик использует конечную точку API [patch Pod](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.13/#patch-pod-v1-core) (изменить под) для обновления подов с информацией о выбранной рабочей ноде.
Как вы видите, это то же самое API, к которому обращается kubectl. Использование одного и того же API для работы внутренних компонентов и внешних пользователей является фундаментальной концепцией дизайна Kubernetes.
Теперь можно обобщить, как работает Kubernetes:
1. Хранилище сохраняет состояние, то есть ресурсы Kubernetes.
2. API сервер предоставляет интерфейс к хранилищу в виде Kubernetes API.
3. Все остальные компоненты и пользователи Kubernetes читают, наблюдают и манипулируют состоянием (ресурсами) Kubernetes через API.
Знание этих концепций поможет лучше понять kubectl и использовать его по максимуму.
Теперь давайте рассмотрим ряд конкретных советов и приемов, которые помогут повысить производительность работы с kubectl.
1. Ускорение ввода при помощи дополнения команд
-----------------------------------------------
Один из наиболее полезных, но часто упускаемых из виду приемов, позволяющих повысить производительность работы с kubectl, — дополнение команд.
Дополнение команд позволяет автоматически заполнять отдельные части команд kubectl клавишей Tab. Это работает для подкоманд, опций и аргументов, в том числе таких сложных, как имена ресурсов.
Посмотрите, как работает дополнение команд kubectl:
Дополнение команд работает для командных оболочек Bash и Zsh.
[Официальное руководство](https://kubernetes.io/docs/tasks/tools/install-kubectl/#enabling-shell-autocompletion) содержит детальные инструкции по настройке автодополнения, но ниже мы приведем краткую выдержку.
### Как работает дополнение команд
Дополнение команд — функция оболочки, которая работает с помощью скрипта дополнения. Скрипт дополнения — сценарий оболочки, который определяет поведение дополнения для конкретной команды.
Kubectl автоматически генерирует и выводит скрипты дополнения для Bash и Zsh с помощью следующих команд:
```
$ kubectl completion bash
```
Или:
```
$ kubectl completion zsh
```
Теоретически — достаточно подключить вывод этих команд в соответствующую командную оболочку, чтобы kubectl смог дополнять команды.
На практике — способ подключения отличается для Bash (включая различия между Linux и MacOS) и Zsh. Ниже мы рассмотрим все эти варианты.
#### Bash в Linux
Скрипт дополнения для Bash зависит от пакета bash-completion, поэтому сначала необходимо установить его:
```
$ sudo apt-get install bash-completion
```
Или:
```
$ yum install bash-completion
```
Вы можете протестировать, что пакет установлен успешно с помощью следующей команды:
```
$ type _init_completion
```
Если при этом выводится код функции оболочки, то bash-completion правильно установлен. Если команда выдает ошибку «Не найдено», необходимо добавить следующую строку в ваш файл `~ / .bashrc`:
```
$ source /usr/share/bash-completion/bash_completion
```
Нужно ли добавлять эту строку в файл `~ / .bashrc` или нет, зависит от менеджера пакетов, который вы использовали для установки bash-completion. Для APT это необходимо, для YUM нет.
После установки bash-completion нужно настроить все так, чтобы скрипт дополнения kubectl был включен во всех сеансах оболочки.
Один из способов сделать это — добавить следующую строку в файл `~ / .bashrc`:
```
source <(kubectl completion bash)
```
Другой способ — добавить скрипт дополнения kubectl в каталог `/etc/bash_completion.d` (создайте его, если он не существует):
```
$ kubectl completion bash >/etc/bash_completion.d/kubectl
```
Все скрипты дополнения в каталоге `/etc/bash_completion.d` автоматически включаются в bash-completion.
Оба варианта одинаково применимы.
После перезагрузки командной оболочки автодополнение команд kubectl будет работать.
#### Bash в MacOS
В MacOS настройка несколько сложнее. Дело в том, что по умолчанию в MacOS стоит Bash версии 3.2, а скрипт автодополнения kubectl требует версии Bash не ниже 4.1 и не работает в Bash 3.2.
Применение устаревшей версии Bash в MacOS связано с вопросами лицензирования. Bash версии 4 распространяется под лицензией GPLv3, которую не поддерживает Apple.
Для настройки автодополнения kubectl в MacOS нужно установить более свежую версию Bash. Вы также можете установить обновленный Bash как командную оболочку по умолчанию, что убережет в будущем от массы проблем. Это несложно, детали приведены в статье «[Обновление Bash в MacOS](https://itnext.io/upgrading-bash-on-macos-7138bd1066ba)».
Перед тем как продолжить, убедитесь, что вы используете свежую версию Bash (проверьте вывод `bash --version`).
Скрипт автодополнения в Bash зависит от проекта [bash-completion](https://github.com/scop/bash-completion), поэтому вначале нужно установить его.
Вы можете установить bash-completion при помощи [Homebrew](https://brew.sh/):
```
$ brew install bash-completion@2
```
Здесь `@2` обозначает bash-completion версии 2. Автодополнение kubectl требует bash-completion v2, а bash-completion v2 требует версии Bash минимум 4.1.
Вывод команды `brew-install` содержит секцию Caveats, в которой указано, что нужно добавить в файл `~/.bash_profile`:
```
export BASH_COMPLETION_COMPAT_DIR=/usr/local/etc/bash_completion.d
[[ -r "/usr/local/etc/profile.d/bash_completion.sh" ]] && .
"/usr/local/etc/profile.d/bash_completion.sh"
```
Однако я рекомендую добавлять эти строки не в `~/.bash_profile`, а в `~/.bashrc`. В этом случае автодополнение будет доступно не только в основной, но и в дочерних командных оболочках.
После перезагрузки командной оболочки можете проверить корректность установки при помощи следующей команды:
```
$ type _init_completion
```
Если в выводе вы видите shell-функцию, то все настроено правильно.
Теперь нужно сделать так, чтобы автодополнение kubectl было включено во всех сеансах.
Один из способов — добавить следующую строку в ваш `~/.bashrc`:
```
source <(kubectl completion bash)
```
Второй способ — добавить скрипт автодополнения в папку `/usr/local/etc/bash_completion.d`:
```
$ kubectl completion bash
>/usr/local/etc/bash_completion.d/kubectl
```
Этот способ сработает, только если вы устанавливали bash-completion при помощи Homebrew. В этом случае bash-completion загружает все скрипты из этой директории.
Если вы устанавливали [kubectl при помощи Homebrew](https://kubernetes.io/docs/tasks/tools/install-kubectl/#install-with-homebrew-on-macos), то не нужно выполнять предыдущий этап, так как скрипт автодополнения будет автоматически размещен в папке `/usr/local/etc/bash_completion.d` во время установки. В этом случае автодополнение kubectl начнет работать сразу же, как только вы установите bash-completion.
В итоге все эти варианты эквивалентны.
#### Zsh
Скрипты автодополнения для Zsh не требуют никаких зависимостей. Всё, что нужно — это включить их при загрузке командной оболочки.
Вы можете сделать это, добавив строку в свой `~/.zshrc` файл:
```
source <(kubectl completion zsh)
```
Если вы получили ошибку `not found: compdef` после перезагрузки вашей оболочки, нужно включить встроенную функцию `compdef`. Ее можно включить, добавив в начало вашего файла `~/.zshrc` следующее:
```
autoload -Uz compinit
compinit
```
2. Быстрый просмотр спецификаций ресурсов
-----------------------------------------
Когда вы создаете определения ресурсов YAML, нужно знать поля и их значение для этих ресурсов. Одно из мест для поиска этой информации — в справочнике по API, который содержит полные спецификации всех ресурсов.
Однако переключаться на веб-браузер каждый раз, когда нужно что-то искать, неудобно. Поэтому kubectl предоставляет команду `kubectl explain`, которая показывает спецификации всех ресурсов прямо в вашем терминале.
Формат команды следующий:
```
$ kubectl explain resource[.field]...
```
Команда выведет спецификацию запрошенного ресурса или поля. Выведенная информация идентична той, что содержится в руководстве API.
По умолчанию `kubectl explain` показывает только первый уровень вложенности полей.
Посмотреть, как это выглядит [можно тут](https://learnk8s.io/a/64920e74ea5d8f9ad9483a4b2127630c.svg).
Можно отобразить все дерево, если добавить опцию `--recursive`:
```
$ kubectl explain deployment.spec --recursive
```
Если вы не знаете точно, какие именно ресурсы нужны, то можете отобразить их все следующей командой:
```
$ kubectl api-resources
```
Эта команда отображает имена ресурсов в форме множественного числа, например, `deployments` вместо `deployment`. Она также отображает краткое имя, например `deploy`, для тех ресурсов, у которых оно есть. Не беспокойтесь об этих различиях. Все эти варианты имен эквивалентны для kubectl. То есть вы можете использовать любой из них для `kubectl explain`.
Все нижеследующие команды равнозначны:
```
$ kubectl explain deployments.spec
# или
$ kubectl explain deployment.spec
# или
$ kubectl explain deploy.spec
```
3. Используйте пользовательский формат вывода столбцов
------------------------------------------------------
По умолчанию формат вывода команды `kubectl get`:
```
$ kubectl get pods
NAME READY STATUS RESTARTS AGE
engine-544b6b6467-22qr6 1/1 Running 0 78d
engine-544b6b6467-lw5t8 1/1 Running 0 78d
engine-544b6b6467-tvgmg 1/1 Running 0 78d
web-ui-6db964458-8pdw4 1/1 Running 0 78d
```
Такой формат удобен, но он содержит ограниченное количество информации. По сравнению с полным форматом определения ресурса, тут выводится всего несколько полей.
В этом случае можно использовать пользовательский формат вывода столбцов. Он позволяет определять, какие данные выводить. Вы можете вывести любое поле ресурса отдельным столбцом.
Использование пользовательского формата определяется с помощью опций:
```
-o custom-columns=:[,:]...
```
Вы можете определить каждый столбец вывода парой `:`, где — название столбца, а — выражение, определяющее поле ресурса.
Давайте посмотрим на простой пример:
```
$ kubectl get pods -o custom-columns='NAME:metadata.name'
NAME
engine-544b6b6467-22qr6
engine-544b6b6467-lw5t8
engine-544b6b6467-tvgmg
web-ui-6db964458-8pdw4
```
Вывод содержит один столбец с именами подов.
Выражение в опции выбирает имена подов из поля `metadata.name`. Это потому что имя пода определяется в дочернем поле name поля `metadata` в ресурсном описании пода. Детальнее можно ознакомиться в [руководстве API](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.13/#pod-v1-core) либо набрать команду `kubectl explain pod.metadata.name`.
Теперь допустим, что вы хотите добавить дополнительный столбец к выводу, например, показывая ноду, на которой работает каждый под. Для этого вы можете просто добавить соответствующую спецификацию столбца в опцию пользовательских столбцов:
```
$ kubectl get pods \
-o custom-columns='NAME:metadata.name,NODE:spec.nodeName'
NAME NODE
engine-544b6b6467-22qr6 ip-10-0-80-67.ec2.internal
engine-544b6b6467-lw5t8 ip-10-0-36-80.ec2.internal
engine-544b6b6467-tvgmg ip-10-0-118-34.ec2.internal
web-ui-6db964458-8pdw4 ip-10-0-118-34.ec2.internal
```
Выражение выбирает имя ноды из `spec.nodeName` — когда под назначается ноде, ее имя прописывается в поле `spec.nodeName` ресурсной спецификации пода. Более подробную информацию можно посмотреть в выводе `kubectl explain pod.spec.nodeName`.
*Учтите, что поля ресурсов Kubernetes чувствительны к регистру.*
Вы можете посмотреть любое поле ресурса в виде столбца. Просто просмотрите спецификацию ресурса и попробуйте ее с любыми полями, которые вам нравятся.
Но сначала давайте подробнее рассмотрим выражения выбора полей.
### Выражения JSONPath
Выражения для выбора полей ресурсов базируются на [JSONPath](https://goessner.net/articles/JsonPath/index.html).
JSONPath — это язык для выборки данных из JSON-документов. Выбор одного поля — самый простой случай использования JSONPath. У него гораздо [больше возможностей](https://goessner.net/articles/JsonPath/index.html#e3), включая селекторы, фильтры и так далее.
Kubectl explain поддерживает ограниченное количество возможностей JSONPath. Ниже описаны возможности и примеры их использования:
```
# Выбрать все элементы списка
$ kubectl get pods -o custom-columns='DATA:spec.containers[*].image'
# Выбрать специфический элемент списка
$ kubectl get pods -o custom-columns='DATA:spec.containers[0].image'
# Выбрать элементы списка, попадающие под фильтр
$ kubectl get pods -o custom-columns='DATA:spec.containers[?(@.image!="nginx")].image'
# Выбрать все поля по указанному пути, независимо от их имени
$ kubectl get pods -o custom-columns='DATA:metadata.*'
# Выбрать все поля с указанным именем, вне зависимости от их расположения
$ kubectl get pods -o custom-columns='DATA:..image'
```
Особое значение имеет оператор []. Многие поля ресурсов Kubernetes являются списками, и этот оператор позволяет выбирать элементы этих списков. Он часто используется с подстановочным знаком как [\*], чтобы выбрать все элементы списка.
### Примеры применения
Возможности использования пользовательского формата вывода столбцов безграничны, так как вы можете отобразить любое поле или комбинацию полей ресурса в выводе. Вот несколько примеров приложений, но не стесняйтесь исследовать их самостоятельно и находить полезные для вас применения.
1. **Отображение образов контейнеров для подов:**
```
$ kubectl get pods \
-o custom-columns='NAME:metadata.name,IMAGES:spec.containers[*].image'
NAME IMAGES
engine-544b6b6467-22qr6 rabbitmq:3.7.8-management,nginx
engine-544b6b6467-lw5t8 rabbitmq:3.7.8-management,nginx
engine-544b6b6467-tvgmg rabbitmq:3.7.8-management,nginx
web-ui-6db964458-8pdw4 wordpress
```
Эта команда отображает имена образов контейнеров для каждого пода.
Помните, что под может содержать несколько контейнеров, тогда имена образов будут выведены в одной строке через запятую.
2. **Отображение зон доступности нод:**
```
$ kubectl get nodes \
-o
custom-columns='NAME:metadata.name,ZONE:metadata.labels.failure-domain\.beta\.kubernetes\.io/zone'
NAME ZONE
ip-10-0-118-34.ec2.internal us-east-1b
ip-10-0-36-80.ec2.internal us-east-1a
ip-10-0-80-67.ec2.internal us-east-1b
```
Эта команда удобна, если ваш кластер размещен в публичном облаке. Она отображает зону доступности для каждой ноды.
*Зона доступности — это облачная концепция, ограничивающая зону репликации географическим регионом.*
Зоны доступности для каждой ноды получаются через специальную метку — [`failure-domain.beta.kubernetes.io/zone`](https://kubernetes.io/docs/reference/kubernetes-api/labels-annotations-taints/#failure-domainbetakubernetesiozone). Если кластер запущен в публичном облаке, эта метка создается автоматически и заполняется именами зон доступности для каждой ноды.
Метки не являются частью спецификации ресурсов Kubernetes, так что вы не найдете информации о них в [руководстве API](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.13/). Однако их можно увидеть (как и любые другие метки), если запросить информацию о нодах в формате YAML или JSON:
```
$ kubectl get nodes -o yaml
# или
$ kubectl get nodes -o json
```
Это отличный способ узнать больше о ресурсах, в дополнение к изучению ресурсных спецификаций.
4. Легкое переключение между кластерами и пространствами имен
-------------------------------------------------------------
Когда kubectl выполняет запрос к Kubernetes API, перед этим он читает файл kubeconfig, чтобы получить все необходимые параметры для коннекта.
*По умолчанию файл kubeconfig — это `~/.kube/config`. Обычно этот файл создается или обновляется особой командой.*
Когда вы работаете с несколькими кластерами, ваш файл kubeconfig содержит параметры подключения ко всем этим кластерам. Вам нужен способ указать команде kubectl, с каким именно кластером вы работаете.
Внутри кластера вы можете создать несколько пространств имен — разновидность виртуального кластера внутри физического кластера. Kubectl определяет, какое пространство имен использовать также по данным файла kubeconfig. Значит, вам также нужен способ указать команде kubectl, с каким пространством имен работать.
В этой главе мы расскажем, как это работает и как добиться эффективной работы.
*Обратите внимание, что у вас может быть несколько файлов kubeconfig, перечисленных в переменной среды KUBECONFIG. В этом случае все эти файлы будут объединены в одну общую конфигурацию во время выполнения. Вы также можете изменить применяемый по умолчанию файл kubeconfig, запуская kubectl с параметром `--kubeconfig`. Смотрите [*официальную документацию*](https://kubernetes.io/docs/tasks/access-application-cluster/configure-access-multiple-clusters/).*
### Файлы kubeconfig
Давайте посмотрим, что же именно содержит файл kubeconfig:
Как вы видите, файл kubeconfig содержит набор контекстов. Контекст состоит из трех элементов:
* Cluster — URL API сервера кластера.
* User — учетные данные аутентификации пользователя в кластере.
* Namespace — пространство имен, используемое при присоединении к кластеру.
*На практике часто используют один контекст на кластер в своем файле kubeconfig. Тем не менее у вас может быть несколько контекстов на кластер, различающихся по пользователю или пространству имен. Однако такая конфигурация с несколькими контекстами встречается нечасто, так что обычно существует взаимно-однозначное сопоставление между кластерами и контекстами.*
В любой момент времени один из контекстов является текущим:
Когда kubectl читает конфигурационный файл, то всегда берется информация из текущего контекста. В примере выше kubectl будет коннектиться к кластеру Hare.
Соответственно, чтобы переключиться на другой кластер, нужно изменить текущий контекст в файле kubeconfig:
Теперь kubectl будет коннектиться к кластеру Fox.
Чтобы переключиться на другое пространство имен в том же самом кластере, нужно изменить значение элемента namespace для текущего контекста:
В вышеприведенном примере kubectl будет использовать пространство имен Prod кластера Fox (ранее было установлено пространство имен Test).
*Обратите внимание, что kubectl также предоставляет параметры `--cluster`, `--user`, `--namespace` и `--context`, которые позволяют перезаписывать отдельные элементы и сам текущий контекст, независимо от того, что установлено в файле kubeconfig. Смотрите `kubectl options`.*
Теоретически вы можете вручную менять параметры в файле kubeconfig. Но это неудобно. Для упрощения этих операций существуют разнообразные утилиты, которые позволяют менять параметры в автоматическом режиме.
### Используйте kubectx
Очень популярная утилита для переключения между кластерами и пространствами имен.
Утилита предоставляет команды `kubectx` и `kubens` для изменения текущего контекста и пространства имен соответственно.
*Как уже упоминалось, изменение текущего контекста означает изменение кластера, если у вас есть только один контекст на кластер.*
Вот пример выполнения этих команд:
По сути, эти команды просто редактируют файл kubeconfig, как было описано выше.
Чтобы установить `kubectx`, следуйте инструкциям на [Github.](https://github.com/ahmetb/kubectx/#installation)
Обе команды поддерживают автодополнение имен контекстов и пространств имен, что позволяет не вводить их полностью. Инструкции по настройке автодополнения [тут](https://github.com/ahmetb/kubectx/#installation).
Другой полезной функцией `kubectx` является [интерактивный режим](https://github.com/ahmetb/kubectx/#interactive-mode). Он работает совместно с утилитой [fzf](https://github.com/junegunn/fzf), которую необходимо устанавливать отдельно. Установка fzf автоматически делает доступным интерактивный режим в `kubectx`. В интерактивном режиме вы можете выбирать контекст и пространство имен через интерактивный интерфейс свободного поиска, предоставленный fzf.
### Использование алиасов командной оболочки
Вам не нужны отдельные инструменты для изменения текущего контекста и пространства имен, потому что kubectl также предоставляет команды для этого. Так, команда `kubectl config` предоставляет подкоманды для редактирования файлов kubeconfig.
Вот некоторые из них:
* `kubectl config get-contexts`: вывести все контексты;
* `kubectl config current-context`: получить текущий контекст;
* `kubectl config use-context`: изменить текущий контекст;
* `kubectl config set-context`: изменить элемент контекста.
Однако использовать эти команды напрямую не очень удобно, потому что они длинные. Можно сделать для них алиасы командной оболочки, которые легко выполнить.
Я создал набор алиасов на основе этих команд, которые предоставляют функциональность, аналогичную kubectx. Здесь вы можете увидеть их действие:
*Обратите внимание, что алиасы используют fzf для предоставления интерактивного интерфейса свободного поиска (как в интерактивном режиме kubectx). Это означает, что вам нужно [*установить fzf*](https://github.com/junegunn/fzf#installation), чтобы использовать эти алиасы.*
Вот сами определения алиасов:
```
# Получить текущий контекст
alias krc='kubectl config current-context'
# Список всех контекстов
alias klc='kubectl config get-contexts -o name | sed "s/^/ /;\|^ $(krc)$|s/ /*/"'
# Изменить текущий контекст
alias kcc='kubectl config use-context "$(klc | fzf -e | sed "s/^..//")"'
# Получить текущее пространство имен
alias krn='kubectl config get-contexts --no-headers "$(krc)" | awk "{print \$5}" | sed "s/^$/default/"'
# Список всех пространств имен
alias kln='kubectl get -o name ns | sed "s|^.*/| |;\|^ $(krn)$|s/ /*/"'
# Изменить текущее пространство имен
alias kcn='kubectl config set-context --current --namespace "$(kln | fzf -e | sed "s/^..//")"'
```
Чтобы установить эти алиасы, нужно добавить приведенные выше определения в ваш файл `~/.bashrc` или `~/.zshrc` и перезагрузить вашу оболочку.
### Использование плагинов
Kubectl позволяет загружать плагины, которые исполняются так же, как основные команды. Можно, например, установить плагин kubectl-foo и запускать его, выполняя команду `kubectl foo`.
Было бы удобно менять контекст и пространство имен таким способом, например, запускать `kubectl ctx` для смены контекста и `kubectl ns` для смены пространства имен.
Я написал два плагина, которые делают это:
* [kubectl-ctx](https://github.com/weibeld/kubectl-ctx)
* [kubectl-ns](https://github.com/weibeld/kubectl-ns)
Работа плагинов базируется на алиасах из предыдущего раздела.
Вот как они работают:
*Обратите внимание, что плагины используют fzf для предоставления интерактивного интерфейса свободного поиска (как в интерактивном режиме kubectx). Это означает, что вам нужно* [*установить fzf*](https://github.com/junegunn/fzf#installation)*, чтобы использовать эти алиасы.*
Чтобы установить плагины, нужно загрузить сценарии оболочки с именами [kubectl-ctx](https://raw.githubusercontent.com/weibeld/kubectl-ctx/master/kubectl-ctx) и [kubectl-ns](https://raw.githubusercontent.com/weibeld/kubectl-ns/master/kubectl-ns) в любой каталог в вашей переменной PATH и сделать их исполняемыми, например, с помощью `chmod +x`. Сразу после этого вы сможете использовать `kubectl ctx` и `kubectl ns`.
5. Сокращение ввода с автоалиасами
----------------------------------
Алиасы командной оболочки — хорошая возможность ускорить ввод. Проект [kubectl-aliases](https://github.com/ahmetb/kubectl-aliases) содержит около 800 сокращений для основных команд kubectl.
Вы можете удивиться — как запомнить 800 алиасов? Но не нужно помнить их все, ведь они строятся по простой схеме, которая приведена ниже:
Например:
1. kgpooyaml — kubectl get pods oyaml
2. ksysgsvcw — kubectl -n kube-system get svc w
3. ksysrmcm — kubectl -n kube-system rm cm
4. kgdepallsl — kubectl get deployment all sl
Как вы видите, алиасы состоят из компонентов, каждый из которых обозначает определенный элемент команды kubectl. Каждый алиас может иметь один компонент для базовой команды, операции и ресурса и несколько компонентов для параметров. Вы просто «заполняете» эти компоненты слева направо в соответствии с приведенной выше схемой.
*Tекущая подробная схема находится на* [*GitHub*](https://github.com/ahmetb/kubectl-aliases#syntax-explanation)*. Там вы также можете найти* [*полный список псевдонимов*](https://github.com/ahmetb/kubectl-aliases/blob/master/.kubectl_aliases)*.*
Например, алиас kgpooyamlall равноценен команде `kubectl get pods -o yaml --all-namespaces`.
Относительный порядок опций неважен: команда `kgpooyamlall` эквивалентна команде `kgpoalloyaml`.
Вы можете не использовать все компоненты как алиасы. Например `k`, `kg`, `klo`, `ksys`, `kgpo` также можно использовать. Более того, в командной строке можно комбинировать алиасы и обычные команды или опции:
Например:
1. Вместо `kubectl proxy` можно написать `k proxy`.
2. Вместо `kubectl get roles` можно написать `kg roles` (в настоящее время не существует алиаса для ресурса Roles).
3. Чтобы получить данные по конкретному поду, можно использовать команду `kgpo my-pod — kubectl get pod my-pod`.
Учтите, что некоторые алиасы требуют аргумент в командной строке. Например, алиас `kgpol` означает `kubectl get pods -l`. Опция `-l` требует аргумент — спецификацию метки. Если вы используете алиас, то он будет выглядеть как `kgpol app=ui`.
*Из-за того, что часть алиасов требует аргументы, алиасы а, f и l нужно использовать последними.*
В общем, как только вы освоите эту схему, то сможете интуитивно вывести алиасы из команд, которые хотите выполнить, и сэкономить много времени на вводе.
### Инсталляция
Чтобы инсталлировать kubectl-aliases, нужно скачать файл [.kubectl\_aliases](https://raw.githubusercontent.com/ahmetb/kubectl-aliases/master/.kubectl_aliases) с GitHub и включить его в файл `~/.bashrc` или `~/.zshrc`:
```
source ~/.kubectl_aliases
```
### Автодополнение
Как мы уже говорили, вы часто добавляете дополнительные слова к алиасу в командной строке. Например:
```
$ kgpooyaml test-pod-d4b77b989
```
Если вы используете автодополнение команды kubectl, то, вероятно, использовали автодополнение для таких вещей, как имена ресурсов. Но можно ли сделать это, когда используются алиасы?
Это очень важный вопрос, потому что, если автодополнение не работает, вы лишитесь части преимуществ алиасов.
Ответ зависит от того, какую командную оболочку вы используете:
1. Для Zsh автодополнение для алиасов работает «из коробки».
2. Для Bash, к сожалению, необходимы некоторые действия, чтобы заставить работать автодополнение.
### Включение автодополнения для алиасов в Bash
Проблема с Bash состоит в том, что он пытается дополнить (всякий раз, когда вы нажимаете Tab) алиас, а не команду, на которую ссылается алиас (как, например, делает Zsh). Поскольку у вас нет скриптов дополнения для всех 800 псевдонимов, автодополнение не работает.
Проект [complete-alias](https://github.com/cykerway/complete-alias) предоставляет общее решение этой проблемы. Он подключается к механизму дополнения для алиасов, внутри дополняет алиас до команды и возвращает варианты дополнения для дополненной команды. Это означает, что дополнение для алиаса ведет себя точно так же, как для полной команды.
Далее я сначала объясню, как установить complete-alias, а затем — как его настроить, чтобы включить дополнение для всех псевдонимов kubectl.
#### Установка complete-alias
Прежде всего, complete-alias зависит от [bash-completion](https://github.com/scop/bash-completion). Поэтому перед установкой complete-alias необходимо убедиться, что bash-completion установлен. Инструкции по установке были даны ранее для Linux и MacOS.
***Важное примечание для пользователей MacOS**: как и скрипт автодополнения kubectl, сomplete-alias не работает с Bash 3.2, который по умолчанию используется в MacOS. В частности, complete-alias зависит от bash-completion v2 (`brew install bash-completion@2`), для которого требуется как минимум Bash 4.1. Это означает, что для использования complete-alias в MacOS нужно установить более новую версию Bash.*
Вам нужно скачать скрипт [bash\_completion.sh](https://raw.githubusercontent.com/cykerway/complete-alias/master/bash_completion.sh) из [репозитория GitHub](https://github.com/cykerway/complete-alias) и включить его в своем файле `~/.bashrc`:
```
source ~/bash_completion.sh
```
После перезагрузки командной оболочки complete-alias будет полностью установлен.
#### Включение автодополнения для алиасов kubectl
Технически complete-alias предоставляет функцию оболочки `_complete_alias`. Эта функция проверяет алиас и возвращает подсказки дополнения для команды алиаса.
Для связывания функции с определенным алиасом нужно использовать встроенный механизм Bash [complete](https://www.gnu.org/software/bash/manual/html_node/Programmable-Completion-Builtins.html#Programmable-Completion-Builtins), чтобы установить `_complete_alias` как функцию дополнения алиаса.
В качестве примера возьмем алиас k, обозначающий команду kubectl. Чтобы установить `_complete_alias` в качестве функции дополнения для этого алиаса, вы должны выполнить следующую команду:
```
$ complete -F _complete_alias k
```
Результатом этого является то, что всякий раз, когда вы автодополняете алиас k, вызывается функция `_complete_alias`, которая проверяет алиас и возвращает подсказки дополнения для команды `kubectl`.
В качестве второго примера давайте возьмем алиас `kg`, который обозначает `kubectl get`:
```
$ complete -F _complete_alias kg
```
Точно так же, как и в предыдущем примере, когда вы автодополняете kg, вы получаете те же самые подсказки дополнения, которые получили бы для `kubectl get`.
*Обратите внимание, что так можно использовать complete-alias для любого алиаса в вашей системе.*
Следовательно, чтобы включить автодополнение для всех алиасов kubectl, нужно выполнить указанную выше команду для каждого из них. Следующий фрагмент делает именно это при условии, что вы установили kubectl-aliases в `~/.kubectl-aliases`:
```
for _a in $(sed '/^alias /!d;s/^alias //;s/=.*$//' ~/.kubectl_aliases);
do
complete -F _complete_alias "$_a"
done
```
Этот кусок кода нужно поместить в ваш `~/.bashrc`, перезагрузить командную оболочку и для всех 800 алиасов kubectl станет доступным автодополнение.
6. Расширение kubectl при помощи плагинов
-----------------------------------------
Начиная с [версии 1.12](https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG-1.12.md#sig-cli-1), kubectl поддерживает [механизм плагинов](https://kubernetes.io/docs/tasks/extend-kubectl/kubectl-plugins/), которые позволяют расширять его функции дополнительными командами.
*Если вы знакомы с* [*механизмами плагинов Git*](https://adamcod.es/2013/07/12/how-to-create-git-plugin.html)*, то плагины kubectl построены по такому же принципу.*
В этой главе мы расскажем, как устанавливать плагины, где их искать и как создавать собственные плагины.
### Инсталляция плагинов
Плагины kubectl распространяются в виде простых исполняемых файлов с именем вида `kubectl-x`. Префикс `kubectl-` является обязательным, далее следует новая подкоманда kubectl, которая позволяет вызывать плагин.
Например, плагин hello будет распространяться в виде файла с именем `kubectl-hello`.
Чтобы установить плагин, нужно скопировать файл `kubectl-x` в любой каталог в вашей переменной PATH и сделать его исполняемым, например с помощью `chmod +x`. Сразу после этого вы можете вызвать плагин с помощью `kubectl x`.
Вы можете использовать следующую команду для вывода списка всех плагинов, которые в настоящее время установлены в вашей системе:
```
$ kubectl plugin list
```
Эта команда также отображает предупреждения, если у вас есть несколько плагинов с одинаковыми именами, или если есть файл плагинов, который не является исполняемым.
### Поиск и инсталляция плагинов при помощи Krew
Плагины Kubectl пригодны для совместного или повторного использования подобно программным пакетам. Но где можно найти плагины, которыми поделились другие?
[Проект Krew](https://github.com/kubernetes-sigs/krew) направлен на предоставление унифицированного решения для совместного использования, поиска, установки и управления плагинами kubectl. Проект называет себя «менеджером пакетов для плагинов kubectl» (Krew похож на [Brew](https://brew.sh/)).
Krew — это список плагинов kubectl, которые вы можете выбирать и устанавливать. При этом Krew — тоже плагин для kubectl.
Это значит, что установка Krew работает, по сути, как установка любого другого плагина kubectl. Вы можете найти подробные инструкции на [странице GitHub](https://github.com/GoogleContainerTools/krew/#installation).
Наиболее важные команды Krew:
```
# Поиск в списке плагинов
$ kubectl krew search []
# Посмотреть информацию о плагине
$ kubectl krew info
# Установить плагин
$ kubectl krew install
# Обновить все плагины до последней версии
$ kubectl krew upgrade
# Посмотреть все плагины, установленные через Krew
$ kubectl krew list
# Деинсталлировать плагин
$ kubectl krew remove
```
Учтите, что инсталляция плагинов при помощи Krew не мешает инсталляции плагинов стандартным способом, описанным выше.
*Обратите внимание, что команда `kubectl krew list` отображает только те плагины, которые были установлены с помощью Krew, тогда как команда `kubectl plugin list` перечисляет все плагины, то есть те, которые установлены с помощью Krew, и те, которые установлены другими способами.*
### Поиск плагинов в других местах
Krew — молодой проект, на данный момент в его [списке](https://github.com/GoogleContainerTools/krew-index/) всего около 30 плагинов. Если вы не можете найти то, что нужно, можно найти плагины в другом месте, например на GitHub.
Я рекомендую смотреть раздел GitHub [kubectl-plugins](https://github.com/topics/kubectl-plugins). Там вы найдете несколько десятков доступных плагинов, которые стоит посмотреть.
### Написание собственных плагинов
Вы можете сами [создавать плагины](https://kubernetes.io/docs/tasks/extend-kubectl/kubectl-plugins/#writing-kubectl-plugins) — это нетрудно. Вам нужно создать исполняемый файл, который делает то, что нужно, назвать его в виде `kubectl-x` и установить, как было описано выше.
Файл может быть bash-скриптом, python-скриптом или скомпилированным go-приложением — это неважно. Единственное условие — чтобы он мог напрямую выполняться в операционной системе.
Давайте создадим пример плагина прямо сейчас. В предыдущем разделе вы использовали команду kubectl для вывода списка контейнеров для каждого пода. Можно легко превратить эту команду в плагин, который вы можете вызвать, например с помощью `kubectl img`.
Создайте файл `kubectl-img` следующего содержания:
```
#!/bin/bash
kubectl get pods -o custom-columns='NAME:metadata.name,IMAGES:spec.containers[*].image'
```
Теперь сделайте файл исполняемым с помощью `chmod +x kubectl-img` и переместите его в любой каталог в вашем PATH. Сразу после этого вы можете использовать плагин `kubectl img`.
Как уже упоминалось, плагины kubectl могут быть написаны на любом языке программирования или сценариев. Если вы используете сценарии командной оболочки, то преимущество в возможности легко вызывать kubectl из плагина. Однако вы можете писать более сложные плагины на реальных языках программирования, используя [клиентскую библиотеку Kubernetes](https://kubernetes.io/docs/reference/using-api/client-libraries/). Если вы используете Go, то также можете использовать [библиотеку cli-runtime](https://github.com/kubernetes/cli-runtime), которая существует специально для написания плагинов kubectl.
### Как поделиться своими плагинами
Если вы считаете, что ваши плагины могут быть полезны для других, не стесняйтесь делиться им на GitHub. Обязательно добавьте их в тему [kubectl-plugins](https://github.com/topics/kubectl-plugins).
Вы также можете запросить добавление вашего плагина в [список Krew](https://github.com/GoogleContainerTools/krew-index/). Инструкции о том, как это сделать, есть в [репозитории GitHub](https://github.com/GoogleContainerTools/krew/blob/master/docs/DEVELOPER_GUIDE.md).
### Автодополнение команд
В настоящее время плагины не поддерживают автодополнение. То есть вы должны вводить полное имя плагина и полные имена аргументов.
В репозитории GitHub kubectl для этой функции есть [открытый запрос](https://github.com/kubernetes/kubectl/issues/585). Таким образом, возможно, что эта функция будет реализована когда-нибудь в будущем.
Удачи!!!
**Что еще почитать по теме**:
1. [Три уровня автомасштабирования в Kubernetes и как их эффективно использовать](https://mcs.mail.ru/blog/tri-urovnya-avtomasshtabirovaniya-v-kubernetes-kak-ikh-effektivno-ispolzovat).
2. [90+ полезных инструментов для Kubernetes](https://mcs.mail.ru/blog/poleznye-instrumenty-dlya-kubernetes).
3. [Наш канал Вокруг Kubernetes в Телеграме](https://tele.click/k8s_mail). | https://habr.com/ru/post/502828/ | null | ru | null |
# Восстановление PDP 11/04. Ленточная станция TU60
*Продолжение перевода статьи по восстановлению одной старой интересной машинки. В [первой](http://habrahabr.ru/post/243551/) части наладили основной блок плат. Много тяжелых картинок. Курсивом мои комментарии.*
### Стриммер TU60 и контроллер TA11
В 70х DEC создали простую замену для перфолент, которая базировалась на разновидности простых аудио-кассет. TU60 вмещает два блока стриммеров. 50метровая лента могла хранить до 100Кб:
Вся логика привода содержится в 2х шестиконтактных платах (*про это я писал ранее, унификация это хорошо*):
На виде сверху можно заметить платы с аналоговой логикой, которая управляет моторчиками и считывает данные с магнитных головок. В отличии от обычных аудиокассет, приводы в TU60 не используют натяжной барабан для контроля скорости прохода ленты. Вместо него используются два независимых мотора. Один для перемотки кассеты и для того, чтобы держать её в натяжении. Второй, управляемый сервой, служит для протяжки ленты вперед (*на самом деле, это адская схема. Когда кассета проигрывается либо просто находится на паузе, то первый мотор тоже включен. Скажем, один из них пытается мотать назад на 100 оборотов, а второй — вперёд на 110. И тогда более сильный побеждает, но, само собой, магнитной ленте это не очень нравится, поэтому даже не рекомендуется долго держать включенной данную станцию.*). Скорость вращения второго мотора постоянна (*не совсем корректно сказано, она постоянна при считывании ленты, но серва же! И скорость меняется в зависимости от задач. К примеру, при простое ленты, этот мотор в паре с первым, реверсным, мотором обеспечивает натяжение, то есть его скорость ниже чем при протяжке*), битрейт на ленте — тоже, поэтому плотность информации меняется на протяжении всей длины ленты. Для кодирования данных TU60 использует манчестерский код.
Модуль контроллера TA11 представлен четырехконтактной Unibus-платой M7892 (*про разные названия одной платы я тоже писал в прошлой статье*):
Контроллер предоставляет простой интерфейс из двух регистров: коммандно-статусный (*несмотря на частую практику, отдавать на чтение регистр в одном формате, а принимать на запись в другом, здесь всё не так. Это целостный регистр, но в котором одни поля — read-only, другие — write-only, но есть и смешанные read-write.*), доступный по адресу 0177500, и буфер данных, расположенный на 0177502. Плата не просто посредник между TU60 и PDP-11, но так же содержит дополнительную логику — цепь работы с прерываниями и декодер адресов (*он нужен для того, чтобы ловить обращения к регистрам*).
Когда я начал играться с этим устройством, я сразу же столкнулся с проблемой. Кнопка перемотки, вроде бы, работала нормально. Но затем, внезапно, она сломалась. Было видно, что треугольная штуковина, которая соединяла ось мотора и кассету, спадала с оси. Согласно чертежам, здесь должен быть установочный винт #2-56 1/8" (*дюймовый размер*). Но его не было! И неясно было, как он мог пропасть. Второй привод имел ту же самую проблему (такого рода установочные винты крайне трудно найти в Швеции, ибо используем метрическую систему). Я вгляделся в схему более внимательно, и заметил на другой нижней треугольной сцепке надпись «loctite» вместо «установочный винт» (*Loctite производит клей и прочую химию*). Возможно, они просто использовали Loctite для обоих сцепок? В любом случае, я купил клей и, знаете что, это сработало просто отлично!
Тем не менее, диагностический тест ZTAA от Maindec не проходил. Первая проблема, которую я обнаружил, заключалась в DEC8881 драйвере, расположенном на управляющей плате, который не давал пройти сигналам EOT и BOT. Я заменил его на 7439, который я купил в Китае где-то за $3/штука. Занятно то, что когда я отпаял DEC8881, снизу он был маркирован как 7439! После этого диагностика стала проходить на втором стриммере, но не на первом. Не работала протяжка вперед, совсем. Шаг за шагом, я отследил неисправный драйвер с открытым коллектором 75452. Наконец-то, оба привода прошли ZTAA. Но не ZTAB…
Для того чтобы выяснить, что происходит при записи данных на кассету, я написал небольшую программу на ассемблере, которая непрерывно писала последовательность байт от 0 до 255 на протяжении всей ленты. Программа работала, поэтому я модифицировал её так же для чтения данных с ленты. Подключив логический анализатор к буферу данных, я получил постоянный поток байт 00, 01, 02,… FD, FE, FF, 00, 01. Чтение и запись работали!
### Запускаем CAPS-11
Я получил образы лент с операционной системой CAPS-11. Загрузочная кассета содержала файл CTLOAD.SYS, который обеспечивал начальную загрузку самой ОС CAPS-11. Ну, может «операционная система» слишком громко сказано, CAPS-11 довольно простой парсер командной строки с функциями загрузки и сохранения файлов на кассету. Сама система находилась в файле CAPS11.S8K, и была слинкована для работы в окружении с 8 килословами памяти (*память в PDP измерялась в словах процессора. Кстати, под это неплохо ложилась восьмеричная система, которая использовалась для задания чисел, главным образом, адресов.*). Загрузочный процесс этой ОС достаточно сложен. Загрузочная область (расположенная по адресу 01000) называется CBOOT. Она пропускает первые 32 байта файла CTLOAD.SYS (который должен быть первым на ленте). Затем читает следующие 128 байт в память по адресу 0. Эта часть CTLOAD.SYS называется PRELDR. PRELDR выясняет размер доступной памяти и догружает весь CTLOAD.SYS в память по наивысшему возможному адресу. Догружаемый блок содержит CABLDR и CBOOT (зеркало). CABLDR это Cassette Absolute Loader, но, несмотря на название, формат читаемых файлов абсолютно тот же, что и для перфолент. Отсюда следует, что CAPS11.S8K имеет формат перфолент, и может быть легко загружен через PDP11GUI (*про эту программу читать в прошлой статье*). Однако, так как CABLDR использует регистр переключателя, который предоставляет программерская консоль, для определения того что и как загружать (*в этом регистре, к примеру, можно было задать адрес перебазирования системы и грузить её по пользовательскому адресу*), и, так как её у меня нет, то CABLDR останавливает машину с исключением несуществующей памяти.
Использование PDP11GUI с начальным адресом 021510, позволяет увидеть приглашение CAPS-11. Система из начала 70х запущена в 2014. 40 лет:
Несомненно, что TU60 работает не очень хорошо.
### Запуск C-кода на голой системе
Для того чтобы разобраться с проблемой TU60, нужно чтобы этот аппарат мог просто повторять записанную последовательность операций в нужном порядке. Увы, но работа с диагностиками в XXDP довольно непредсказуема. Они могут печатать один и тот же код ошибки как для операций чтения, так и для операций записи. По крайней мере, я не могу точно определить, что идёт не так. Кроме того, при использовании логического анализатора, я могу проводить одинаковые замеры снова и снова, лишь немного меняя тестовые точки для исследования. Я решил, что лучший способ двигаться дальше, это написать свою собственную простую тестовую программку. До этого я писал крохотный код на ассемблере, который читал и писал данные на ленту. Но уже, даже с небольшим возрастанием объема кода, требовалось всё больше усилий на отладку, ибо я не очень опытный программист на ассемблере для PDP-11. Я люблю C.
Что нужно для написания программ на Си? Конечно же, кросс-компилятор! Страница [Diane Neisus](http://www.diane-neisius.de/pdp11/index_E.html) вдохновила меня. Я скачал Binutils 2.24 вместе с GCC 4.8.2 и скомпилировал их.
Binutils:
```
src/configure --target=pdp11-aout --disable-nls
make all
sudo make install
```
GCC:
```
src/configure --target=pdp11-aout --disable-nls --without-headers --enable-languages=c
make all-gcc
sudo make install-gcc
```
Затем мне нужен был файл с точкой входа для CRT — crt0.s. Я просто написал минимальный вариант который работал:
```
.text
.globl _main, ___main, _start
_start:
mov $400,sp
jsr pc, _main
halt
___main:
rts pc
```
Так как форматированный вывод строк довольно полезная штука, я поискал и нашёл [крохотную реализацию printf для встроенной разработки](http://www.sparetimelabs.com/tinyprintf/tinyprintf.php), которая вполне меня удовлетворяла. Компилируя библиотеку и пытаясь слинковать её, получил пачку сообщений о том, что множество функций не найдено — \_\_\_mulhi3, \_\_\_udivhi3 и другие. Функции использовались gcc вместо родных инструкций ассемблера PDP-11. Мне пришлось написать собственные версии этих простых функций, которые выполняли умножение, деление и взятие остатка.
Теперь, во время компиляции с использованием флага -m10, используемого для создания PDP-11/10 совместимого выходного файла, компилятор рушился при генерации кода для конвертации short в long. Единственное решение, которое я нашёл, это компилировать под PDP-11/40 и затем вручную заменить те инструкции, которые не поддерживаются PDP-11/04, вроде SXT или ASHC.
После этого я был готов написать настоящий Hello world:
```
pdp11-aout-gcc -m10 -Ttext 1000 -msoft-float -nostartfiles -nodefaultlibs -nostdlib crt0.s printf.c test.c divmulmod.s
pdp11-aout-objcopy -O binary a.out hello.dmp
```
Я сообщил линкеру, что нужно перебазировать код на адрес 0x1000 или 010000, а затем использовал objdump для конвертации объектника в чистый бинарный файл.
Сначала я пробовал этот файл запускать в эмуляторе E11, прежде чем включал реальное железо. Но вот скриншот запуска через PDP11GUI на настоящей машине:
Превосходно! Форматированный вывод работает как надо. Умножение, деление и взятие остатка так же выдают верный результат (Ну, на самом деле, не совсем. Оказалось, что функция взятия остатка содержит баг, который я должен был исправить). Теперь у меня был простой способ писать мои собственные тестовые программы на Си, которые нагружали бы мой старенький TU60. В конце концов, я думаю, что я могу написать программу, которая читает файлы через последовательный порт и пересылает их TU60, таким образом создавая загрузочные кассеты. В любом случая, я должен пропатчить CABLDR внутри CTLOAD.SYS, чтобы он не пытался читать регистр переключателя, что безусловно приводит к выбросу исключения. (Машина не имеет программерской консоли).
### TU60EXERCISER
Я потратил несколько часов для написания маленькой программы, которую я назвал [TU60EXERCISER](https://dl.dropboxusercontent.com/u/96935524/Datormusuem/TU60EXCERCISER_SA10000.DMP):
Теперь я могу проводить любые операции над приводом более простым путём, чем использование стандартных ZTA\*\* программ. Тестирование READ команды выявило проблему на драйвере с открытым коллектором DEC8881 (*это очередной DEC8881, а не тот который заменили ранее*), которую я не заметил раньше, когда подключал логический анализатор напрямую к буферу данных TU60. Проблема заключалась в том, что CRC генерация либо, наоборот, проверка CRC сбоят. Я всегда получал ошибку CRC при чтении данных, даже когда они читались верно.
Исходник TU60EXERCISER'a можно найти [здесь](https://github.com/MattisLind/tu60tools).
### Поиск ошибок в логике работы с CRC
Ниже расположены четыре фото, показывающие, что происходит, когда мы записываем символы «AB» на ленту, а 16-битная контрольная сумма генерируется. LSB данных пишется первым, и выставляется сигнал WRITED в активно-низкий уровень.
Ключ к разгадке в том, что CRC генерируется сдвиговым регистром с обратной связью с входным сигналом проходящим через XOR-вентили для битов 15, 13 и 0.
Ошибка очевидна? Я не сразу её заметил, но спустя несколько часов я изучил фото снова и нашёл её!
Бит 5 застревает на высоком уровне. Но не всегда, как могут поправить меня остроглазые товарищи. В начале все биты в нуле. Правильно, но весь сдвиговый регистр находится в сброшенном состоянии из-за того, что ему подали сигнал очистки (*на 8271, как и у многих других, есть пин очистки состояния*). В этом случае выход верен, но, при последовательном входе данных в сдвиговый регистр, он выдаёт неверный результат. Он всегда сдвигается единичкой. Элемент реализуется чипом Signetics N8271, аналогичным Texas Instruments SN74179.
Я заказал новый из Болгарии (!).
### Один шаг вперёд и два (три?) назад
Меня ждало несколько неудач. После того, как я, наконец-то, получил 74179 из Болгарии и впаял его, а моя программа TU60EXERCISER, с соответствующей настройкой эмулятора, протестирована в E11, кассеты начали сбоить. Проявлялось это в том, что трение между головкой и лентой было настолько большим, что стриммер не мог перематывать их корректно. Кроме того, это приводило к ситуации, когда привод не мог ничего записать или считать из-за того, что движение ленты было прерывистым.
Выяснилось, что это общая [проблема](http://library.stanford.edu/blogs/digital-library-blog/2013/08/playback-squeaky-cassettes-stanford-media-preservation-lab) старых кассет. У меня не было под рукой Deoxit D5 (*специальный лубрикант для электро-механических соединений, использовался в статье по ссылке*). Я попробовал силиконовый спрей от CRC, но он не дал какого-либо заметного эффекта.
Поэтому нужно искать новые кассеты. Я попытался сконвертировать стандартные аудиокассеты с помощью паяльника. В каком-то роде это работало, но почему-то иногда не детектировалось того, что перемотка достигла начала ленты. Стриммер просто продолжал перематывать на высокой скорости.
Но потом я, всё же, нашёл парня с Ebay из Германии, который продал мне 10 кассет Verbatim из термополимера по 1 евро каждая.
Когда они пришли, я сразу же бросился тестировать их, но тут оказалось, что компьютер больше не выдаёт мне командную строку эмулятора консоли. Что случилось? Подключив логический анализатор, я обнаружил, что машина останавливается после попытки исполнить инструкцию «mov» на 83-ей строке.
```
77 165046 005503 adc r3 ; R3=000000 C=1
78 165050 000303 swab r3 ; R3=000000 C=0
79 165052 001377 bne . ; br . if FAIL
80
81 ; -----------------------------------------
82
83 165054 012702 165000 T2: mov #data0,r2 ; R2=165000
84 165060 011203 mov (r2),r3 ; R2=165000 R3=165000
```
Подключение щупов к шине микро-адреса показало, что, после шага выборки, процессор прыгает на микро-инструкцию по адресу 60 вместо 62 (обработчик режима source mode 2(*при декодировании инструкций есть 8 режимов адресации операнда, а-ля регистр, непосредственное значение, etc. Здесь почему-то считался режим 0, вместо режима 2. Сам режим кодируется непосредственно в инструкции.*)). Похоже что E88 не работает, так как её выход всегда 1, независимо от входа. Но, возможно, что также есть проблема с E77, так как она управляет шиной микро-адреса. В любом случае, у меня нет ни 7427, ни 74H01. Приятель-коллекционер из Швеции выслал мне 7427 для проверки.
Но, пока этот чип в пути, я могу использовать запасную процессорную плату для тестирования, дабы не терять времени.
Я начал проверку новых кассет, используя ZTAA-диагностику, которая прошла на отлично. Тогда я запустил ZTAB, которая тоже должна быть успешной, поскольку я исправил проверку CRC. Я запустил проверку и отошёл на полчаса. Когда я вернулся, звук, издаваемый стриммером, был другим, необычным, а консоль пестрела бесконечным ворохом ошибок. Второй привод вращался очень медленно. Выяснилось, что резина или пластик на шпинделе превратились в некий аморфный клей.
Я искал какую-либо замену этой резинке, но не смог ничего найти, что подошло бы тютелька-в-тютельку. Я пробовал два слоя велосипедной камеры шины. Я не был уверен, что такой тип резины достаточно мягок. Но, в любом случае, я должен был использовать хороший клей, для того чтобы приклеить резину на колесико шпинделя, потому что на плохом клею резинка достаточно быстро отлетала. Вторая проблема заключалась в том, что толщина велосипедной камеры непостоянна на всём вырезанном круге. Это может помешать, а может и нет. Сейчас посмотрим.
Я ходил и спрашивал сантехников, есть ли у них что-нибудь подходящее, но, к сожалению, они не смогли мне помочь.
### Новая резиновая накладка на шпинделе
Кстати, в тот момент мне пришёл 7427 для замены чипа на позиции E88, и процессор заработал! Через шведский форум по электронике я связался с человеком, который отправил мне резинку для шпинделя. Я смог снять старую, и приклеить новую на супер-клей.
Теперь большинство диагностик проходят на обоих приводах, за исключением ZTAE, который же не проверяет ничего особенного?
**Скрытый текст**
```
@
007574 006574 006774 170617
@DD
CLEARING MEMORY
CHMDDA0 XXDP+ DD MONITOR 8K
BOOTED VIA UNIT 0
ENTER DATE (DD-MMM-YY):
RESTART ADDR:033726
50 HZ? N Y
LSI? N
THIS IS XXDP+. TYPE "H" OR "H/L" FOR DETAILS
.D
ENTRY# FILNAM.EXT DATE LENGTH START
000001 HMDDA1.SYS 22-MAR-80 17 000050
000002 HDDDA1.SYS 22-MAR-80 3 000071
000003 HUDIA0.SYS 22-MAR-80 6 000074
000004 UPD1 .BIN 22-MAR-80 12 000102
000005 UPD2 .BIN 22-MAR-80 16 000116
000006 HELP .TXT 22-MAR-80 26 000136
000007 HSAAA0.SYS 22-MAR-80 24 000170
000010 SETUP .BIN 22-MAR-80 26 000220
000011 GKAAA0.BIC 1-MAR-89 14 000252
000012 GKABC0.BIC 1-MAR-89 15 000270
000013 ZTAAC0.BIN 11-AUG-76 16 000307
000014 ZTABC0.BIN 11-AUG-76 17 000327
000015 ZTACC0.BIN 11-AUG-76 13 000350
000016 ZTADC0.BIN 11-AUG-76 16 000365
000017 ZTAEB0.BIN 11-AUG-76 13 000405
000020 ZTAFC0.BIN 11-AUG-76 2 000422
000021 ZTAHA0.BIN 11-AUG-76 6 000424
000022 ZKLAE0.BIC 11-AUG-76 14 000432
000023 ZDLAF1.BIN 12-MAR-77 17 000450
000024 ZDLBB0.BIN 11-AUG-76 16 000471
000025 ZDLCA0.BIC 11-AUG-76 19 000511
000026 ZDLDA1.BIC 29-JAN-77 19 000534
000027 ZDLOC0.BIN 17-AUG-76 4 000557
000030 ZKWKA1.BIC 29-JAN-77 27 000563
.R ZTABC0
MAINDEC-11-DZTAB-C
SWR = 000000 NEW =
TESTING DRIVE A
|
END PASS
TESTING DRIVE B
`
END PASS
TESTING DRIVE A
`
DATA PROBLEM
PC TACS EXPECT RCV'D
010470 000004 000377 000122
x
END PASS
TESTING DRIVE B
`
END PASS
TESTING DRIVE A
`
000000 177500 001056 016632
@DD
CLEARING MEMORY
CHMDDA0 XXDP+ DD MONITOR 8K
BOOTED VIA UNIT 0
ENTER DATE (DD-MMM-YY):
RESTART ADDR:033726
50 HZ? N Y
LSI? N
THIS IS XXDP+. TYPE "H" OR "H/L" FOR DETAILS
.R ZTAEB0
MAINDEC-11-DZTAE-B
SWR = 000000 NEW =
DRIVE A AND DRIVE B WILL BE TESTED
*** FORMAT *** DRIVE A
001612 000000 001056 011646
@DD
CLEARING MEMORY
CHMDDA0 XXDP+ DD MONITOR 8K
BOOTED VIA UNIT 0
ENTER DATE (DD-MMM-YY):
RESTART ADDR:033726
50 HZ? N Y
LSI? N
THIS IS XXDP+. TYPE "H" OR "H/L" FOR DETAILS
.R ZTADC0
MAINDEC-11-DZTAD-C
SWR = 000000 NEW =
TESTING DRIVE A AND DRIVE B
WRITE-FILE-GAP
IMPROPER FLAG OCCURRED
TEST ERROR
PC PC TACS TADB
005636 010562 120140 000017
END PASS
TESTING DRIVE B AND DRIVE A
READ
SHORT RECORD
TEST ERROR BYTES
PC PC TACS TADB LEFT
004742 011204 140144 000350 000006
BUFFER COMPARE
BAD DATA READ
TEST ERROR EXPT'D RCV'D BYTE
PC PC TACS DATA DATA NUMBER
004746 010512 140144 000314 000357 000001
END PASS
TESTING DRIVE A AND DRIVE B
END PASS
TESTING DRIVE B AND DRIVE A
END PASS
TESTING DRIVE A AND DRIVE B
END PASS
TESTING DRIVE B AND DRIVE A
END PASS
TESTING DRIVE A AND DRIVE B
END PASS
TESTING DRIVE B AND DRIVE A
```
Следующий вопрос заключался в выборе подходящего носителя. У меня были только 2 оригинальные кассеты от DEC'a. Позже я получил несколько NCR-кассет от парня из Морокко. Видимо, они хранились в пустыне долгое время, потому что вся смазка испарилась. Verbatim-кассеты от парня из Германии выглядят довольно неплохо. Хотя у меня и были проблемы с прижимным устройством, сделанного из чего-то типа пены, которая со временем изнашивается. Наконец, у меня есть Maxell-кассеты, которые сбоят практически беспрестанно. Похоже, что лента не может выдерживать натяжение, создаваемое приводом, она рвётся после всего нескольких перемоток (*о чём я, кстати, писал ранее*).
Я так же пробовал конвертировать обычные аудио-кассеты, но с переменным успехом. Какие-то работали, какие-то — нет.
Следующий этап — записать CAPS-11 на кассету и запустить! Нужно лишь немного доработать [TU60EXERCISER](https://github.com/MattisLind/tu60tools).
### Наконец-то загрузка с кассеты
После нескольких раундов отладки TU60EXERCISER (сейчас переименовано в to60tools), я, в конце концов, получил вариант, который позволял записывать данные на ленту. Теперь, интересно, загрузится ли PDP-11 с кассеты?
После набора «CT» в эмуляторе консоли, стриммер сначала завращал кассету на короткий миг, но затем просто остановился. Я начал перечитывать мануал для CAPS-11 и заметил следующее:
> PRELDR должен быть первой записью в первом файле на системной кассете. Этот предзагрузчик является небольшой программой, написанной в соответствии с «CBOOT Loader Format», которая достаточно продвинутая для того, чтобы определить размер памяти и загрузить последующие программы в верхние адреса памяти. CBOOT линкует, загружает в память по адресу 0 и запускает её автоматически. Карта памяти CAPS-11, на данном этапе загрузке, изображена в Figure E-3 как Memory Map #2.
>
>
Опирается ли PRELDR на то, что CBOOT, судя по схеме, расположен по адресу 01000? Я, конечно же, загружаюсь с ППЗУ.
**EDIT:** настоящий источник проблемы найден благодаря приятелю-коллекционеру: CBOOT помещает TA11 CSR (*командно-статусный регистр контроллера стриммера*) в R0 (*пользовательский регистр процессора*), в то время как M9312 CT (*M9312 — эмулятор консоли, CT — команда этого эмулятора, но в то же время это название микросхемы ППЗУ, которая содержит код загрузки с ленты. Команда лишь запускает код этого ППЗУ, но он автоматически пытается грузиться и при старте системы.*) при загрузке заносит TA11 CSR в R1 (и номер стриммера в R0). PRELDR ожидает увидеть именно в R0 значение регистра TA11. Я должен пропатчить PRELDR для того, чтобы он мог грузиться непосредственно с CT-ПЗУ.
Я использовал E11 для сборки CBOOT из исходников и записал результат в файл [CBOOT.BIN](https://dl.dropboxusercontent.com/u/96935524/Datormusuem/CBOOT.BIN). После этого я загрузил его в память через pdp11gui и запустил с адреса 01000. Да! Кассета начала проигрываться в течении примерно полуминуты, и затем появился единственный символ ".". Я запустил CAPS-11!
```
.DI
--
CTLOAP SYS 19-FEB-14
CAPS11 S8K 25-NOV-13
DEMO PAL 25-NOV-13
EDIT SLG 25-NOV-13
LINK SRU 25-NOV-13
ODT SLG 25-NOV-13
PAL SRU 25-NOV-13
PIP SRU 25-NOV-13
?NO SENTINEL FILE
?SYNTAX ERROR
.
```
Моя программа, для записи на ленту, не писала замыкающий файл, который должен быть последним на ленте. Тем не менее, сработало и так! CTLOAP.SYS — пропатченная версия CTLOAD.SYS, из который были удалены все обращения к регистру переключателя для того, чтобы программа заработала и на машинах только с операторской консолью.
### Археология старых кассет
Для начала, я пропатчил CTLOAD.SYS для загрузки напрямую с CT ППЗУ на M9312, что крайне удобно. Никакой больше ругани при наборе команд или при заливке файла (*9600bps, грустно всё это*) начального загрузчика. Просто включить тумблер INIT, и стриммер начинает работу. Отлично. Выяснилось, что не только PRELDR нуждается в модификации, но нужно еще добавить инструкцию BR (*безусловный короткий переход, -128..+127*) для того чтобы, пропустить инициализацию регистра R0 в недрах CABLDR. [Здесь](https://dl.dropboxusercontent.com/u/96935524/Datormusuem/CTLOAT.SYS) патченная версия, если кому нужно.
После загрузки CAPS-11, меня заинтересовало, что же на самом деле хранится на тех двух старых DEC-кассетах. Фото одной из них есть выше, она промаркирована как «S LMS 2 KOP». «KOP» может значить «KOPIA», КОПИЯ. Но, кроме этого, я не могу разобрать, что остальные символы значат. Она содержит какие-то файлы:
```
010000 051415 177714 000002
@CT
CAPS-11 V01-02
.DA 27-MAR-14
.DI CT1:
27-MAR-14
CTLOAD SYS 07-JAN-75
CAPS11 S8K 07-JAN-75
PIP SRU 07-JAN-75
EDIT SLG 07-JAN-75
LINK SRU 07-JAN-75
ODT SLG 07-JAN-75
PAL SRU 07-JAN-75
BASIC LDA 07-JAN-75
.
```
В системе CAPS-11 кассета датирована январём 1975-го года. Файлы почти 40-летней давности. Я сделал копию и использовал свой пропатчанный загрузчик для её запуска. Она запустилась. Но не было никакой командной строки. Возможно, что софт был сконфигурирован под другую версию железе, отличную от моей.
Было бы занятно извлечь содержимое кассеты. Я продолжил работу над [tu60tools](https://github.com/MattisLind/tu60tools). Опять же, долгая отладка при запуске на голом железе. Здесь нет никаких приятных глазу трассировок стека, когда возникает проблема с указателями. Наконец-то, TU60read была готова для чтения файлов с кассеты, и, вроде бы, даже работала. По крайней мере, она корректно считала файл, который я записал на кассету. Я использовал её для кассеты-копии, сделанной ранее, и получил следующие файлы:
[CTLOAD.SYS](https://dl.dropboxusercontent.com/u/96935524/Datormusuem/LMS/CTLOAD.SYS)
[CAPS11.S8K](https://dl.dropboxusercontent.com/u/96935524/Datormusuem/LMS/CAPS11.S8K)
[PIP.SRU](https://dl.dropboxusercontent.com/u/96935524/Datormusuem/LMS/PIP.SRU)
[EDIT.SLG](https://dl.dropboxusercontent.com/u/96935524/Datormusuem/LMS/EDIT.SLG)
[LINK.SRU](https://dl.dropboxusercontent.com/u/96935524/Datormusuem/LMS/LINK.SRU)
[ODT.SLG](https://dl.dropboxusercontent.com/u/96935524/Datormusuem/LMS/ODT.SLG)
[PAL.SRU](https://dl.dropboxusercontent.com/u/96935524/Datormusuem/LMS/PAL.SRU)
[BASIC.LDA](https://dl.dropboxusercontent.com/u/96935524/Datormusuem/LMS/BASIC.LDA)
Я изучил бинарник CTLOAD.SYS. Он занимает 896 байт (7 блоков) вместо 1024. Но выглядит он полноценно. Дизассемблирование показывает, что большая часть кода идентична CTLOAD.SYS, идущем с CAPS-11.
BASIC.LDA похож на копию перфоленты с BASIC'ом. Запустив strings над этим бинарником, получил «PDP-11 BASIC, VERSION 007A». Аналогично для «CAPS11.S8K» даёт «CAPS-11 V01-02». Поэтому, я думаю, что эта кассета лишь немного отличается от оригинала.
После этого я попробовал сделать такое же исследование второй кассеты, но файловая система на ней была повреждена. Мне удалось откопать только этот кусок кода для PDP-8:
**Скрытый текст**
```
TO +1 IF HIGH TEST
DCA TEST
TAD TABNO
AND P777
DCA TABNO /SAVE TABLE NUMBER
TAD LTAB
DCA TCORE /SET CORE ADDRESS
CLL
CIF
JMS I TABLE /READ LIMIT TABLES
TABNO, 0
TCORE, 0
CLA CLL
CDF
TAD I BAND1 /FETCH
NUMBER OF
DCA B1 /CHANNELS FROM MEM0
TAD I BAND2
DCA B2
JMS I RSETDF
IAC
JMS COMWRD /FETCH BATCH TRAIN NO
SPA CLA /RELOCATE OUTER BAND?
JMP INNER /NO - INNER
DCA CHNO /YES - SET 1:ST CHANNEL NUMBER
TAD B1 /FETCH CHANNEL COUNTER
JMP BOTH
INNER, TAD B1 /CALCULATE FIRST CHANNEL NO
CIA
DCA CHNO
TAD B2 /FETCH CHANNEL COUNTER
BOTH, DCA CHCNT /SAVE COUNTER ON PAGE ZERO
TAD P5
JMS COMWRD /FETCH CHANNEL NUMBER
SNA /ZERO?
JMP ALL /YES - TEST ALL ON ONE BAND
TAD M1 /NO - SAVE CORRECT
DCA CHNO /CHANNELNUMBER
TAD M1
DCA CHCNT /SET COUNTER TO -1
SKP
SINGLE, CLA IAC /SET AC TO 11
ALL, TAD P10 /SET AC TO 10
JMP I RELO /RELOCATE
ACLEAR, DCA I TEMP /CLEAR RCLEAR IN COMMAND BUFFER
ISZ TADDR /SET POINTER TO CORRECT
CDF /ADD TERM IN TBTAB
DCA I TADDR /ZERO ADD TERM
JMS I RSETDF /RESET DATA FIELD
NOP
CMA
DCA QCPFEL
JMS I DCWAIT
TAD QCP /INDICATE READY
CIF
CLL
JMS I MONDSC /RETURN TO QCP
HLT /SECURITY HALT
COMWRD, 0 /ADD TERM IN AC
TAD COMAND
DCA TEMP /ADDR IN COMAND BUFFER
TAD I TEMP /FETCH COMAND WORD
JMP I COMWRD /TO AC AND RETURN
/CONSTANTS:
BAND1, 66 /PAGE0, MEM0
BAND2, 67 / " "
B1, 0
B2, 0
TEMP, 0
P3, 3
P4, 4
P5, 5
P10, 10
P50, 50
P51, 51
P52, 52
P54, 54
P55, 55
P77, 77
P777, 777
P3777, 3777
P6000, 6000
M1, -1
M2, -2
M2001D, -3721
QCP, 4023 /AUT
OSTART QCP
$
```
Ладно. Теперь, когда машина запускает как надо, я приступлю к заключительной стадии этого проекта восстановления PDP-11: оживить LA30 Decwriter и запустить его совместно с PDP-11.
*В [третьей](http://habrahabr.ru/post/243555/) части статьи чиним терминал LA30 Decwriter.* | https://habr.com/ru/post/243553/ | null | ru | null |
# Java 10 General Availability
> [Ссылка для скачивания](http://jdk.java.net/10/)
Последнюю половину года мы подробно обсуждали здесь новшества Java 10 и знаем их наизусть.
Но было бы странно, если самая главная Java-новость за полгода не появилась бы в этом хабе.
Как говорится, просто оставлю это здесь. Вперёд к приключениям!
Действительно вышла в срок?
===========================
Да, действительно. Релиз сделали из 46 билда, и собрали день назад, глядите:
```
$ java -version
openjdk version "10" 2018-03-20
OpenJDK Runtime Environment 18.3 (build 10+46)
OpenJDK 64-Bit Server VM 18.3 (build 10+46, mixed mode)
```
А в IDE работает, или всё красным перечёркнуто?
===============================================
Работает в свежей IntelliJ IDEA. Но придётся поставить бета-версию (например, `ideaIU-181.4203.400`), потому что на стабильной `2017.3.5` не поддерживается этот language level.
Долгий путь к релизу
====================
На самом деле, нет. Это самый быстрый полноценный релиз в истории!
Раньше [план публиковался на странице проекта](http://openjdk.java.net/projects/jdk/10/), но больше он нам не понадобится. Все этапы успешно выполнены.
* 2017/12/14 [Первая фаза замедления](http://openjdk.java.net/projects/jdk8/milestones#Rampdown_start)
* 2018/01/11 [All Tests Run](http://openjdk.java.net/projects/jdk8/milestones#All_Tests_Run)
* 2018/01/18 [Вторая фаза замедления](http://openjdk.java.net/projects/jdk8/milestones#Rampdown_phase_2)
* 2018/02/08 [Первый Release Candidate](http://openjdk.java.net/projects/jdk9/#Initial_Release_Candidate)
* 2018/02/22 [Окончательный Release Candidate](http://openjdk.java.net/projects/jdk8/milestones#Final_Release_Candidate)
* 2018/03/20 [General Availability](http://openjdk.java.net/projects/jdk8/milestones#General_Availability)
И что, всё хорошо?
==================
В основном, да. В этом релизе разработчики фокусировались на починке только тех багов, которые являются *совершенно критичными* для успеха Java 10. Все задачи, относящиеся к другим релизам Java, даже с высшим приоритетом, отложены.
Но какой же релиз без хорошего факапа? Тагир Валеев ([lany](https://habr.com/ru/users/lany/)) через считаные часы опубликовал [в своём твиттере](https://twitter.com/tagir_valeev/status/976293600681115648) новость об эпическом новом баге в компиляторе.
> Within a day after [#Java10](https://twitter.com/hashtag/Java10?src=hash&ref_src=twsrc%5Etfw) release a compiler bug was found which crashes compiler on very simple class. Better to wait for java 10.0.1?.. [pic.twitter.com/YJT5MqSbtm](https://t.co/YJT5MqSbtm)
>
> — Tagir Valeev (@tagir\_valeev) [March 21, 2018](https://twitter.com/tagir_valeev/status/976293600681115648?ref_src=twsrc%5Etfw)
Баг уже [обсуждают в рассылке](http://mail.openjdk.java.net/pipermail/compiler-dev/2018-March/011757.html) и [ведётся работа по его починке](https://bugs.openjdk.java.net/browse/JDK-8199910).
Вот этот код, можно вставить и проверить:
```
public class Main {
void m() {
var s = java.util.List.of("a", 1);
}
}
```
Проблема проявляется только только при включённом флаге `-g`, который говорит о необходимости генерации отладочной информации. В IDE он включён по-умолчанию, так что мимо ошибки не пройти :-)
Изменения, которые появились в этом релизе
==========================================
> **[JEP 286](http://openjdk.java.net/jeps/286): [Local-Variable Type Inference](https://medium.com/@afinlay/java-10-sneak-peek-local-variable-type-inference-var-3022016e1a2b).**
Локальный вывод типов с помощью `var`. Неоднозначная фича. Регулярно [вызывает бурления](http://mail.openjdk.java.net/pipermail/platform-jep-discuss/2016-December/000066.html) в рассылке.
Пример кода:
```
var list = new ArrayList(); // infers ArrayList
var stream = list.stream(); // infers Stream
```
**Бородатый анекдот в тему.**
Заходит джавист в столовую и говорит: дайте, пожалуйста, Борщ борщ нью Борщ!
> **[JEP 296](http://openjdk.java.net/jeps/296): Консолидация леса исходников JDK в едином репозитории.**
Широкой общественности обычно не интересно, разве что ты собираешь OpenJDK из исходников. Интересней то, что чем меньше хаоса в проекте, тем более качественный получается продукт.
> **[JEP 304](http://openjdk.java.net/jeps/304): [Garbage-Collector Interface](https://dzone.com/articles/whats-planned-for-jdk-10).**
Улучшение изоляции основных исходников от GC путём создания хорошего чистого интерфейса для GC. В последнее время стало весьма популярным писать свои GC: на подходе у нас Shenandoah, ZGC, Epsilon. Чтобы поддержать эти благие начинания, разработчикам OpenJDK пришлось конкретно разгрести свалку в коде, чтобы не только максимально упроситить создание новых GC, но и дать возможность быстро отключать ненужные GC из сборки. Один из основных критериев успеха — отсутствие просадки по перфомансу после всех этих рефакторингов.
> **[JEP 307](http://openjdk.java.net/jeps/307): [Parallel Full GC for G1](https://bugs.openjdk.java.net/browse/JDK-8186571).**
[CMS выбросили на мороз](http://openjdk.java.net/jeps/291), и всё интересное в общеупотребительной (не низкопаузной) сборке мусора теперь происходит в G1. Читаем ["Release Note: JEP 307: Parallel Full GC for G1"](https://bugs.openjdk.java.net/browse/JDK-8189726): «Коллектор G1 создан для того, чтобы обходиться без full GC, но когда параллельная сборка не может утилизировать память достаточно быстро, происходит возвращение к full GC. Старая реализация full GC в G1 использовала однопоточный алгоритм mark-sweep-compact. После реализации JEP-307, full GC параллелизовался и стал использовать то же количество параллельных тредов-воркеров, как в young и mixed». (Напоминаю, что young GC обрабатывает только регионы young/survivor, mixed — ещё и old, full — весь хип, young/tenured).
> **[JEP 310](http://openjdk.java.net/jeps/310): Application Class-Data Sharing**.
Чтобы ускорить запуск и уменьшить количество используемой памяти, предлагается расширить существующую фичу под названием Class-Data Sharing («CDS») возможностью упаковки классов в общий архив.
Если совсем коротко, то вот так архив вначале создаётся, а потом используется при запуске:
```
java -Xshare:dump -XX:+UseAppCDS -XX:SharedClassListFile=hello.lst -XX:SharedArchiveFile=hello.jsa -cp hello.jar
java -Xshare:on -XX:+UseAppCDS -XX:SharedArchiveFile=hello.jsa -cp hello.jar HelloWorld
```
> **[JEP 312](http://openjdk.java.net/jeps/312): [Thread-Local Handshakes](https://stackoverflow.com/questions/47222819/explanation-of-the-thread-local-handshakes)**.
Возможность выполнять колбэк на тредах, не делая глобальный для JVM сейфпоинт. Фича позволяет дешёво останавливать одиночные треды, а не только «всё или ничего». Это низкоуровневая системная фича, вручную ей воспользоваться нельзя, но можно радоваться автомагически возросшей производительности программ.
> **[JEP 313](http://openjdk.java.net/jeps/313): Remove the Native-Header Generation Tool.**
Утилита `javah` больше не нужна, потому что [нативные заголовки теперь может делать javac](https://bugs.openjdk.java.net/browse/JDK-7150368) (начиная с JDK8, на самом деле).
`javah` была утилитой, генерирующей сишные заголовочные файлы и исходники, необходимые для использования нативных методов. Сгенерированные ей файлы предназначены для использования в программах, написанных на Си, чтобы обращаться к экземплярам джавовых объектов из неуправляемого нативного кода. В .h-файле определяется структура, которая выглядит примерно как класс, которым мы собираемся управлять. Поля структуры — переменные экземпляра класса. Тем не мнее, в JNI использование подобных стабов не является обязательным.
> **[JEP 314](http://openjdk.java.net/jeps/314): [Additional Unicode Language-Tag Extensions](https://bugs.openjdk.java.net/browse/JDK-8177568)**.
Поддержка новых расширений Unicode: [cu (currency type)](https://www.unicode.org/repos/cldr/tags/latest/common/bcp47/currency.xml), [fw (first day of week)](https://www.unicode.org/repos/cldr/tags/latest/common/bcp47/calendar.xml), [rg (region override)](https://www.unicode.org/reports/tr35/tr35.html#RegionOverride), [tz (time zone)](https://www.unicode.org/repos/cldr/tags/latest/common/bcp47/timezone.xml).
> **[JEP 316](http://openjdk.java.net/jeps/316): [Heap Allocation on Alternative Memory Devices](https://bugs.openjdk.java.net/browse/JDK-8190308).**
HotSpot VM теперь может выделять хиповую память на других девайсах, например, на NV-DIMM. Некоторые операционки уже умеют выделять не-DRAM память, помещая её на файловую систему, например, [NTFS DAX](https://channel9.msdn.com/events/build/2016/p470) и [ext4 DAX](https://lwn.net/Articles/618064). Добавляется опция ` -XX:AllocateHeapAt=.
> **[JEP 317](http://openjdk.java.net/jeps/317): [Experimental Java-Based JIT Compiler](https://stackoverflow.com/questions/48252830/does-java-9-include-graal)**.
[Graal](https://github.com/oracle/graal), можно использовать как основной JIT-компилятор. Объяснять, что такое Graal — очень долго, поэтому вкратце. Под брендом Graal сейчас объединено несколько направлений: Graal Compiler, SubstrateVM, Truffle, различные языки для него ("Graal polyglot runtime"). В данном случае имеется в виду именно Compiler. На некоторых тестах, типа Scala DaCapo, грааль позволяет получить почти двухкратную производительность по сравнению с C2! Чтобы получить подобные чудесные результаты, необходимо иметь очень-очень много динамического кода и очевидно, наибольшую пользу тут извлекут программисты на Scala, Groovy, JavaScript, и т.п. Работает это чудо пока что только на 64-битных Linux и macOS.
> **[JEP 319](http://openjdk.java.net/jeps/319): [Root Certificates](https://bugs.java.com/view_bug.do?bug_id=JDK-8191486).**
В JDK [имеется кейстор](https://docs.oracle.com/javase/9/tools/keytool.htm#GUID-5990A2E4-78E3-47B7-AE75-6D1826259549__CACERTS) `cacerts`, который нужен для хранения корневых сертификатов. Но в OpenJDK он пока пустой. Поэтому ништяки типа TLS в OpenJDK по-умолчанию не работают. Теперь этот `cacerts` будет правильно сконфигурирован и заполнен, и ништяки начнут работать. Кроме того, это сгладит разницу между OpenJDK и Oracle JDK.
> **[JEP 322](http://openjdk.java.net/jeps/322): [Time-Based Release Versioning](https://medium.com/@bazlur_rahman/next-version-isnt-going-to-be-18-please-check-the-jep-322-http-openjdk-java-net-jeps-322-f93e81ac1dff).**
*Feature releases* будут добавлять новые фичи. *Update releases* будут только чинить баги.
Ну и конечно же,
```
$ java -version
openjdk version "10" 2018-03-20
OpenJDK Runtime Environment 18.3 (build 10+46)
OpenJDK 64-Bit Server VM 18.3 (build 10+46, mixed mode)
```
Не всё есть в JEP
=================
В багтрекере и рассылке можно увидеть большое количество изменений, которые не получили такую широкую огласку, как основные JEP.
По этому поводу Тагир Валеев ([lany](https://habr.com/ru/users/lany/)) недавно написал очень [хорошую статью](https://habrahabr.ru/post/349868/). Дублировать её содержимое нет смысла, нужно пройти по ссылке и прочитать.
Что дальше?
===========
Необходимо взять JDK 10 и начать миграцию на него своего кода!
[Ссылка на загрузку](http://jdk.java.net/10/).
> Минутка рекламы. Как вы, наверное, знаете, мы делаем конференции. Ближайшая конференция по Java — [JPoint 2018](https://jpoint.ru/). Она пройдет 6-7 апреля 2018 года в Москве. В докладах [часто упоминаются](https://jpoint.ru/talks/4uhryig3nu82wa6gwioq4q/) вопросы перехода на новые версии Java. Какие доклады там бывают — можно посмотреть в [нашем архиве на YouTube](https://www.youtube.com/user/JUGRuVideo) или [прочитать в хаброблоге](https://habrahabr.ru/company/jugru/blog/351078/). Кроме того, можно будет вживую пообщаться с докладчиками и лучшими экспертами по Java-платформе в специальных дискуссионных зонах после каждого доклада. Короче, заходите, мы вас ждём. | https://habr.com/ru/post/351694/ | null | ru | null |
# Знакомство с OCR библиотекой tessnet2 (язык C#)
Буквально на днях у меня появилась необходимость распознать простой текст на картинке и совсем не было желания реализовывать свой алгоритм, т.к. знаком с теорией и знаю, что это не такое простое дело, поэтому сразу решил изучить сначала рынок готовых библиотек. Буквально несколько запросов в гугл и я понял, что ничего более подходящего мне как библиотека tessnet2 невозможно найти. Постоянно читаю хабр и знаю, что тут есть уйма статей посвященных теории OCR и очень удивился, что нет ничего о библиотеке tessnet2.
#### tessnet2 основана на Tesseract OCR
Движок Tesseract OCR был одним из 3-х лучших движков представленных в 1995 году на UNLV Accuracy test. В период между 1995 годом и 2006 годом он был немного доработан, но, вероятно, это один из наиболее точных OCR движков, который доступен с открытым исходным кодом. Код, который доступен будет читать бинарные, серые или цветное изображение и выводить текст. Чтение TIFF построено так, что будут читаться несжатые TIFF изображения или могут быть добавлены Libtiff для чтения сжатых изображений.
Как использовать **Tessnet2**:
1. Загружаем [библиотеку](http://www.pixel-technology.com/freeware/tessnet2/bin.zip), добавляем ссылку (reference) на **Tessnet2.dll** в .NET проекте.
2. Загружаем нужный нам язык (лично мне необходим английский) ([tesseract-2.00.eng.tar.gz](http://code.google.com/p/tesseract-ocr/downloads/detail?name=tesseract-2.00.eng.tar.gz&can=2&q=)) и складываем в папку tessdata. Папка tessdata обязательно должна быть рядом с исполняемым файлом нашего приложения.
Для того, чтобы прочитать текст с картинки достаточно такого текста:
> `Bitmap image = new Bitmap("eurotext.tif");
>
> tessnet2.Tesseract ocr = new tessnet2.Tesseract();
>
> ocr.SetVariable("tessedit\_char\_whitelist", "0123456789"); // If digit only
>
> ocr.Init(@"c:\temp", " eng ", false); // To use correct tessdata
>
> List result = ocr.DoOCR(image, Rectangle.Empty);
>
> foreach (tessnet2.Word word in result)
>
> Console.WriteLine("{0} : {1}", word.Confidence, word.Text);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Я был очень рад результату, поэтому сразу вспомнил о том, что несколько месяцев назад прикручивал сервис для разгадывания каптч для одного проекта, сразу скажу, что ничего хорошего из этого не вышло, там нужна была скорость, но её не удалось там получить, т.к. подобные сервисы не способны её обеспечить, да и результат как правило плачевный, оно и понятно, т.к. платят там от 1 доллара за 1000 правильно введённых каптч, что мягко сказать ужасно. Поэтому эксперимента ради я решил поиграть с данной библиотекой на том примере.
Исходными данными для нас будет являться каптча, на которой нужно произвести простейшие действия над двумя числами и получить ответ. Звучит довольно просто, но вот проблема ещё в том, что все символы разных цветов и имеется динамический фон, порой даже мне (человеку) сложно понять сходу, что там написано.
Сразу привожу результаты работы программы, после чего я расскажу как это всё работает:
На скриншотах чётко видно, что библиотека не может ничего разгадать из-за кучи линий, порой мешает и фон, который был убран не целиком. Поэтому я разработал свой небольшой алгоритм для чистки картинки, ничего в нём грандиозного нет, я просто отступаю несколько пикселей от края и пробегаю по прямоугольнику и собираю там цвета, также собираю цвета после первой цифры и перед знаком равно (последнее это больше хак, но т.к. статья посвящена другому, то оставил так). Всё что мне надо сделать потом – это закрасить все цвета, которые попали ко мне в коллекцию и не являются белым цветом.
Из всех алгоритмов наиболее полезным может быть только алгоритм закрашивания области на Bitmap`е:
> `void FloodFill(Bitmap bitmap, int x, int y, Color color)
>
> {
>
> BitmapData data = bitmap.LockBits(
>
> new Rectangle(0, 0, bitmap.Width, bitmap.Height),
>
> ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
>
> int[] bits = new int[data.Stride / 4 \* data.Height];
>
> Marshal.Copy(data.Scan0, bits, 0, bits.Length);
>
>
>
> LinkedList check = new LinkedList();
>
> int floodTo = color.ToArgb();
>
> int floodFrom = bits[x + y \* data.Stride / 4];
>
> bits[x + y \* data.Stride / 4] = floodTo;
>
>
>
> if (floodFrom != floodTo)
>
> {
>
> check.AddLast(new Point(x, y));
>
> while (check.Count > 0)
>
> {
>
> Point cur = check.First.Value;
>
> check.RemoveFirst();
>
>
>
> foreach (Point off in new Point[] {
>
> new Point(0, -1), new Point(0, 1),
>
> new Point(-1, 0), new Point(1, 0)})
>
> {
>
> Point next = new Point(cur.X + off.X, cur.Y + off.Y);
>
> if (next.X >= 0 && next.Y >= 0 &&
>
> next.X < data.Width &&
>
> next.Y < data.Height)
>
> {
>
> if (bits[next.X + next.Y \* data.Stride / 4] == floodFrom)
>
> {
>
> check.AddLast(next);
>
> bits[next.X + next.Y \* data.Stride / 4] = floodTo;
>
> }
>
> }
>
> }
>
> }
>
> }
>
>
>
> Marshal.Copy(bits, 0, data.Scan0, bits.Length);
>
> bitmap.UnlockBits(data);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Для тех кому интересно самому поэкспериментировать прикрепляю [исходный код](http://narod.yandex.ru/disk/4325337001/FillBitmap.rar).
#### Итог
Мы познакомились с довольно интересной библиотекой tessnet2, проверили её работу в реальных условиях, добились довольно неплохих результатов разгадывания для сложных картинок (каптч), конечно ошибки есть, но их количество ничтожно мало, тем более для данного вида каптч можно добавить проверку с помощью регулярного выражения и Вы точно будете знать, что разгаданный текст соответствует нужному формату. | https://habr.com/ru/post/112599/ | null | ru | null |
# Swift Package Manager
Вместе с релизом в open source языка Swift 3 декабря 2015 года Apple представила децентрализованный менеджер зависимостей [Swift Package Manager](https://github.com/apple/swift-package-manager).
К публичной версии приложили руку небезызвестные [Max Howell](https://github.com/mxcl), создатель Homebrew, и [Matt Thompson](https://github.com/mattt), написавший [AFNetworking](https://github.com/AFNetworking/AFNetworking). SwiftPM призван автоматизировать процесс установки зависимостей, а также дальнейшее тестирование и сборку проекта на языке Swift на всех доступных операционных системах, однако пока его поддерживают только macOS и [Linux](https://swift.org/download/#releases). Если интересно, идите под кат.
Минимальные требования – Swift 3.0. Чтобы открыть файл проекта потребуется Xcode 8.0 или выше. SwiftPM позволяет работать с проектами без xcodeproj-файла, поэтому Xcode на OS X не обязателен, а на Linux его и так нет.
Стоит развеять сомнения – проект еще в активной разработке. Использование UIKit, AppKit и других фреймворков iOS и OS X SDK как зависимостей недоступно, так как SwiftPM подключает зависимости в виде исходного кода, который потом собирает. Таким образом, использование SwiftPM на iOS, watchOS и tvOS возможно, но только с использованием Foundation и зависимостей сторонних библиотек из открытого доступа. Один единственный import UIKit делает вашу библиотеку непригодной для распространения через SwiftPM.
Все примеры в статье написаны с использованием версии 4.0.0-dev, свою версию можете проверить с помощью команды в терминале
```
swift package —version
```
Идеология Swift Package Manager
-------------------------------
Для работы над проектом больше не нужен файл \*.xcodproj — теперь его можно использовать как вспомогательный инструмент. Какие файлы участвуют в сборке модуля, зависит от их расположения на диске — для SwiftPM важны имена директорий и их иерархия внутри проекта. Первоначальная структура директории проекта выглядит следующим образом:
* Sources – исходные файлы для сборки пакета, разбитые внутри по директориям продуктов – для каждого продукта отдельная папка.
* Tests – тесты для разрабатываемого продукта, разбивка на папки аналогично папке Sources.
* Package.swift – файл с описанием пакета.
* README.md – файл документации к пакету.
Внутри папок Sources и Tests SwiftPM рекурсивно ищет все \*.swift-файлы и ассоциирует их с корневой папкой. Чуть позже мы создадим подпапки с файлами.
Основные компоненты
-------------------
Теперь давайте разберемся с основными компонентами в SwiftPM:
* **Модуль** (Module) – набор \*.swift–файлов, выполняющий определенную задачу. Один модуль может использовать функционал другого модуля, который он подключает как зависимость. Проект может быть собран на основании единственного модуля. Разделение исходного кода на модули позволяет выделить в отдельный модуль функцию, которую можно будет использовать повторно при сборке другого проекта. Например, модуль сетевых запросов или модуль работы с базой данных. Модуль использует порог инкапсуляции уровня internal и представляет собой библиотеку (library), которая может быть подключена к проекту. Модуль может быть подключен как из того же самого пакета (представлен в виде другого таргета), так и из другого пакета (представлен в виде другого продукта).
* **Продукт** (Product) – результат сборки таргета (target) проекта. Это может быть библиотека (library) или исполняемый файл (executable). Продукт включает себя исходный код, который относится непосредственно к этому продукту, а также исходный код модулей, от которых он зависит.
* **Пакет** (Package) – набор \*.swift–файлов и manifest-файла Package.swift, который определяет имя пакета и набор исходных файлов. Пакет содержит один или несколько модулей.
* **Зависимость** (Dependency) – модуль, необходимый для исходного кода в пакете. У зависимости должен быть путь (относительный локальный или удаленный на git-репозиторий), версия, перечень зависимостей. SwiftPM должен иметь доступ к исходному коду зависимости для их компиляции и подключения к основному модулю. В качестве зависимости таргета может выступать таргет из того же пакета или из пакета-зависимости.
Получаем, что зависимости выстраиваются в граф – у каждой зависимости могут быть свои собственные и так далее. Разрешение графа зависимостей – основная задача менеджера зависимостей.
Замечу, что все исходные файлы должны быть написаны на языке Swift, возможности использовать язык Objective-C – нет.
Каждый пакет должен быть самодостаточным и изолированным. Его отладка производится не посредством запуска (run), а с помощью логических тестов (test).
Далее рассмотрим простой пример с подключением к проекту зависимости Alamofire.
Разработка тестового проекта
----------------------------
Перейдем через терминал в папку, где будет лежать наш проект, создадим для него директорию и перейдем в нее.
```
mkdir IPInfoExample
cd IPInfoExample/
```
Далее инициализируем пакет с помощью команды
```
swift package init
```
В результате создается следующая иерархия исходных файлов
```
├── Package.swift
├── README.md
├── Sources
│ └── IPInfoExample
│ └── main.swift
└── Tests
└── IPInfoExampleTests
├ LinuxMain.swift
└── IPInfoExampleTests
└── IPInfoExampleTests.swift
```
В условиях отсутствия индекса файла проекта \*.xcodeproj менеджеру зависимостей нужно знать, какие исходные файлы должны участвовать в процессе сборки и в какие таргеты их включать. Поэтому SwiftPM определяет строгую иерархию папок и перечень файлов:
* Package-файл;
* README-файл;
* Папка Sources с исходными файлами – отдельная папка для каждого таргета;
* Папка Tests – отдельная папка для каждого тестового таргета.
Уже сейчас можем выполнить команды
```
swift build
swift test
```
для сборки пакета или для запуска теста Hello, world!
### Добавление исходных файлов
Создадим файл Application.swift и положим его в папку IPInfoExample.
```
public struct Application {}
```
Выполняем swift build и видим, что в модуле уже компилируется 2 файла.
```
Compile Swift Module 'IPInfoExample' (2 sources)
```
Создадим директорию Model в папке IPInfoExample, создадим файл IPInfo.swift, а файл IPInfoExample.swift удалим за ненадобностью.
```
//Используем протокол Codable для маппинга JSON в объект
public struct IPInfo: Codable {
let ip: String
let city: String
let region: String
let country: String
}
```
После этого выполним команду swift build для проверки.
### Добавление зависимостей
Откроем файл Package.swift, содержание полно описывает ваш пакет: имя пакета, зависимости, таргет. Добавим зависимость Alamofire.
```
// swift-tools-version:4.0
import PackageDescription // Модуль, в котором находится описание пакета
let package = Package(
name: "IPInfoExample", // Имя нашего пакета
products: [
.library(
name: "IPInfoExample",
targets: ["IPInfoExample"]),
],
dependencies: [
// подключаем зависимость-пакет Alamofire, указываем ссылку на GitHub
.package(url: "https://github.com/Alamofire/Alamofire.git", from: "4.0.0")
],
targets: [
.target(
name: "IPInfoExample",
// указываем целевой продукт – библиотеку, которая зависима
// от библиотеки Alamofire
dependencies: ["Alamofire"]),
.testTarget(
name: "IPInfoExampleTests",
dependencies: ["IPInfoExample"]),
]
)
```
Далее снова swift build, и наши зависимости скачиваются, создается файл Package.resolved c описанием установленной зависимости (аналогично Podfile.lock).
В случае если в вашем пакете только один продукт, можно использовать одинаковые имена для имени пакета, продукта и таргета. У нас это IPInfoExample. Таким образом, описание пакета можно сократить, опустив параметр products. Если заглянуть в описание пакета Alamofire, увидим, что там не описаны таргеты. По умолчанию создаются один таргет с именем пакета и файлами исходного кода из папки Sources и один таргет с файлом-описанием пакета (PackageDescription). Тестовый таргет при использовании SwiftPM не задействуется, поэтому папка с тестами исключается.
```
import PackageDescription
let package = Package(name: "Alamofire", dependencies : [], exclude: [“Tests"])
```
Чтобы удостовериться в правильности создания модулей, таргетов, продукта, можем выполнить команду
```
swift package describe
```
В результате для Alamofire получим следующий лог:
```
Name: Alamofire
Path: /Users/ivanvavilov/Documents/Xcode/Alamofire
Modules:
Name: Alamofire
C99name: Alamofire
Type: library
Module type: SwiftTarget
Path: /Users/ivanvavilov/Documents/Xcode/Alamofire/Source
Sources: AFError.swift, Alamofire.swift, DispatchQueue+Alamofire.swift, MultipartFormData.swift, NetworkReachabilityManager.swift, Notifications.swift, ParameterEncoding.swift, Request.swift, Response.swift, ResponseSerialization.swift, Result.swift, ServerTrustPolicy.swift, SessionDelegate.swift, SessionManager.swift, TaskDelegate.swift, Timeline.swift, Validation.swift
```
Если у пакета несколько продуктов, то в качестве зависимости мы указываем пакет зависимости, а уже в зависимости таргета указываем зависимость от модуля пакета. Например, так подключен SourceKitten в нашей библиотеке [Synopsis](https://github.com/RedMadRobot/synopsis).
```
import PackageDescription
let package = Package(
name: "Synopsis",
products: [
Product.library(
name: "Synopsis",
targets: ["Synopsis"]
),
],
dependencies: [
Package.Dependency.package(
// зависимость от пакета SourceKitten
url: "https://github.com/jpsim/SourceKitten",
from: "0.18.0"
),
],
targets: [
Target.target(
name: "Synopsis",
// зависимость от библиотеки SourceKittenFramework
dependencies: ["SourceKittenFramework"]
),
Target.testTarget(
name: "SynopsisTests",
dependencies: ["Synopsis"]
),
]
)
```
[Так](https://github.com/jpsim/SourceKitten/blob/master/Package.swift) выглядит описание пакета SourceKitten. В пакете описаны 2 продукта
```
.executable(name: "sourcekitten", targets: ["sourcekitten"]),
.library(name: "SourceKittenFramework", targets: ["SourceKittenFramework"])
```
Synopsis использует продукт-библиотеку SourceKittenFramework.
### Создание файла проекта
Мы можем создать файл проекта для своего удобства, выполнив команду
```
swift package generate-xcodeproj
```
и в результате получим в корневой папке проекта файл IPInfoExample.xcodeproj.
Открываем его, видим все исходники в папке Sources, в том числе с подпапкой Model, и исходники зависимостей в папке Dependencies.
Важно отметить, что данный шаг является опциональным при разработке продукта и не влияет на механизм работы SwiftPM. Заметьте, что все исходные файлы располагаются так же, как и на диске.
### Проверка подключенной зависимости
Проверим, корректно ли подключилась зависимость. В примере делаем асинхронный запрос к сервису ipinfo для получения данных о текущем ip-адресе. JSON ответа декодируем в модельный объект – структуру IPInfo. Для простоты примера не будем обрабатывать ошибку маппинга JSON или ошибку сервера.
```
// импортируем библиотеку так же, как при использовании cocoapods или carthage
import Alamofire
import Foundation
public typealias IPInfoCompletion = (IPInfo?) -> Void
public struct Application {
public static func obtainIPInfo(completion: @escaping IPInfoCompletion) {
Alamofire
.request("https://ipinfo.io/json")
.responseData { result in
var info: IPInfo?
if let data = result.data {
// Маппинг JSON в модельный объект
info = try? JSONDecoder().decode(IPInfo.self, from: data)
}
completion(info)
}
}
}
```
Далее можем воспользоваться командой build в Xcode, а можем выполнить команду swift build в терминале.
### Проект с исполняемым файлом
Выше описан пример для инициализации проекта библиотеки. SwiftPM позволяет работать с проектом исполняемого файла. Для этого при инициализации используем команду
```
swift package init —type executable.
```
Привести текущий проект к такому виду также можно, создав файл main.swift в директории Sources/IPInfoExample. При запуске исполняемого файла main.swift является точкой входа.
Напишем в него одну строчку
```
print("Hello, world!”)
```
А затем выполним команду swift run, в консоль выведется заветное предложение.
Синтаксис описания пакета
-------------------------
Описание пакета в общем виде выглядит следующим образом:
```
Package(
name: String,
pkgConfig: String? = nil,
providers: [SystemPackageProvider]? = nil,
products: [Product] = [],
dependencies: [Dependency] = [],
targets: [Target] = [],
swiftLanguageVersions: [Int]? = nil
)
```
* **name** – имя пакета. Единственный обязательный аргумент для пакета.
* **pkgConfig** – используется для пакетов модулей, установленных в системе (System Module Packages), определяет имя [pkg-config-файла](https://en.wikipedia.org/wiki/Pkg-config).
* **providers** – используется для пакетов системных модулей, описывает подсказки для установки недостающих зависимостей через сторонние менеджеры зависимостей – brew, apt и т.д.
```
import PackageDescription
let package = Package(
name: "CGtk3",
pkgConfig: "gtk+-3.0",
providers: [
.brew(["gtk+3"]),
.apt(["gtk3"])
]
)
```
* **products** – описание результата сборки таргета проекта – исполняемый файл или библиотека (статическая или динамическая).
```
let package = Package(
name: "Paper",
products: [
.executable(name: "tool", targets: ["tool"]),
.library(name: "Paper", targets: ["Paper"]),
.library(name: "PaperStatic", type: .static, targets: ["Paper"]),
.library(name: "PaperDynamic", type: .dynamic, targets: ["Paper"])
],
targets: [
.target(name: "tool")
.target(name: "Paper")
]
)
```
Выше в пакете описано 4 продукта: исполняемый файл из таргета tool, библиотека Paper (SwiftPM выберет тип автоматически), статическая библиотека PaperStatic, динамическая PaperDynamic из одного таргета Paper.
* Dependencies – описание зависимостей. Необходимо указать путь (локальный или удаленный) и версию.
Управление версиями в SwiftPM происходит через git-тэги. Само версионирование можно настроить достаточно гибко: зафиксировать версию языка, git-ветки, минимальную мажорную, минорную версию пакета или хэш коммита. Опционально к тэгам добавляется суффикс вида @swift-3, таким образом можно поддерживать старые версии. Например, с версиями вида 1.0@swift-3, 2.0, 2.1 для SwiftPM версии 3 будет доступна только версия 1.0, для последней версии 4 – 2.0 и 2.1.
Также есть возможность указать поддержку версии SwiftPM для manifest-файла, указав суффикс в имени package@swift-3.swift. Указание версии можно заменить на ветку или хэш коммита.
```
// 1.0.0 ..< 2.0.0
.package(url: "/SwiftyJSON", from: "1.0.0"),
// 1.2.0 ..< 2.0.0
.package(url: "/SwiftyJSON", from: "1.2.0"),
// 1.5.8 ..< 2.0.0
.package(url: "/SwiftyJSON", from: "1.5.8"),
// 1.5.8 ..< 2.0.0
.package(url: "/SwiftyJSON", .upToNextMajor(from: "1.5.8")),
// 1.5.8 ..< 1.6.0
.package(url: "/SwiftyJSON", .upToNextMinor(from: "1.5.8")),
// 1.5.8
.package(url: "/SwiftyJSON", .exact("1.5.8")),
// Ограничение версии интервалом.
.package(url: "/SwiftyJSON", "1.2.3"..<"1.2.6"),
// Ветка или хэш коммита.
.package(url: "/SwiftyJSON", .branch("develop")),
.package(url: "/SwiftyJSON", .revision("e74b07278b926c9ec6f9643455ea00d1ce04a021"))
```
* targets – описание таргетов. В примере объявляем 2 таргета, второй – для тестов первого, в зависимостях указываем тестируемый.
```
let package = Package(
name: "FooBar",
targets: [
.target(name: "Foo", dependencies: []),
.testTarget(name: "Bar", dependencies: ["Foo"])
]
)
```
* swiftLanguageVersions – описание поддерживаемой версии языка. Если установлена версия [3], компиляторы swift 3 и 4 выберут версию 3, если версия [3, 4] компилятор swift 3 выберет третью версию, компилятор swift 4 — четвертую.
### Индекс команд
```
swift package init //инициализация проекта библиотеки
swift package init --type executable //инициализация проекта исполняемого файла
swift package --version //текущая версия SwiftPM
swift package update //обновить зависимости
swift package show-dependencies //вывод графа зависимостей
swift package describe // вывод описания пакета
```
### Ресурсы
* [Пример Тестового проекта](https://github.com/vani2/IPInfoExample)
* [Swift.org – Package Manager](https://swift.org/package-manager/)
* [Swift Package Manager – Usage](https://github.com/apple/swift-package-manager/blob/master/Documentation/Usage.md) | https://habr.com/ru/post/348004/ | null | ru | null |
# SOAP-сервер на Rails 3.x (WashOut)
Поддержка SOAP (как сервера) в Rails ухудшалась от версии к версии. В версии 1.x рельсы комплектовались [AWS](http://aws.rubyonrails.org). В версии 2.x AWS распался на несколько форков, которые поддерживали энтузиасты. До версии 3.х, в стабильно работающем исполнении, AWS не дожил. Идеологически подобное отношение к SOAP может нравиться или не нравиться, но в реальной жизни мы окружены великим и ужасным Enterpris'ом. И поддержка двустороннего SOAP'а может понадобиться в любой интеграции: от 1С, до автоматизированных банковских систем.
Вместо поддержки еще большего количества (мертворожденных?) форков AWS для 3-ей версии, мы написали [WashOut](https://github.com/roundlake/wash_out).
Гем поддерживает respond\_to, ориентируясь на mime-тип SOAP, который сам и регистрирует. То есть вы можете сделать контроллер, который одинаково хорошо выдает html, json и еще и отвечает на SOAP. При этом WashOut поддерживает все стандартные фичи Rails, такие как before\_filter.
Как заставить это работать?
---------------------------
### Подключить Gem
Добавьте `gem 'wash_out'` в ваш Gemfile.
### Расширить нужные контроллеры
Чтобы не засорять адресное пространство, WashOut не подмешивается в ApplicationController. Поэтому для каждого контроллера, где вы хотите использовать SOAP, модуль надо подключить самостоятельно.
```
# app/controllers/api_controller.rb
class ApiController < ApplicationController
include WashOut::SOAP
```
### Описать WSDL
Параметры каждого метода описываются отдельно, с помощью метода [soap\_action](http://rubydoc.info/gems/wash_out/WashOut/SOAP/ClassMethods#soap_action-instance_method).
```
soap_action "concat",
:args => { :a => :string, :b => :string },
:return => :string
def concat
render :soap => (params[:a] + params[:b])
end
```
Пример с генерацией ошибки SOAP и измененным именем метода.
```
soap_action "AddCircle",
:args => { :circle => { :center => { :x => :integer,
:y => :integer },
:radius => :double } },
:return => [],
:to => :add_circle
def add_circle
circle = params[:circle]
raise SOAPError, "radius is too small" if circle[:radius] < 3.0
Circle.new(circle[:center][:x], circle[:center][:y], circle[:radius])
render :soap => nil
end
```
### Добавить роутинг
Роутинг также прописывается для каждого контроллера (в нашем примере это ApiController)
```
# config/routes.rb
HelloWorld::Application.routes.draw do
wash_out :api
end
```
### PROFIT!
WSDL этого контроллера находится по адресу /api/wsdl (или /your\_controller/wsdl). Все остальные методы и пути SOAP найдет уже из него.
Чтобы протестировать, что это работает, можно использовать гем Savon:
```
require 'savon'
client = Savon::Client.new("http://localhost:3000/api/wsdl")
client.wsdl.soap_actions # => [:concat, :AddCircle]
client.request(:concat) do
soap.body = { :a => "123", :b => "abc" }
end[:value] # => "123abc"
```
We want you for OSS army!
-------------------------
В случае возникновения проблем и/или идей по развитию, мы ждем ваших [Issues](https://github.com/roundlake/wash_out/issues) и [Pull-реквестов](https://github.com/roundlake/wash_out/pulls) на Github.
Спасибо. | https://habr.com/ru/post/135614/ | null | ru | null |
# Veeam Backup: миленькие хитрости
В преддверии Нового года я подумал: а не сделать ли скромный, но очень полезный подарок нашим читателям, рассказав про функции, на которые системные администраторы-пользователи Veeam Backup & Replication обычно не обращают внимания, а про некоторые из них даже и не знают? Так родилась эта статья — о том, как использовать Veeam Backup нестандартным способом.
Начну, пожалуй, с известного многим VeeamZIP.
VeeamZIP
========
[VeeamZIP](http://habrahabr.ru/company/veeam/blog/191828/) — бесплатный инструмент для создания резервных копий.
В бесплатном Veeam Backup Free Edition возможно забэкапить только одну ВМ за один проход VeeamZIP, в платной же версии Veeam Backup & Replication у VeeamZIP нет никаких ограничений. В результате работы VeeamZIP получается файл, в котором находится полная копия забэкапленной ВМ. Запускается операция VeeamZIP вручную из интерфейса (на закладке **Virtual Machines** — см. скриншот ниже), командлетой PowerShell ([Help](http://helpcenter.veeam.com/backup/80/powershell/start-vbrzip.html), [рассказ на хабре](http://habrahabr.ru/company/veeam/blog/257579/)) или из vSphere Web Client (если установлен [плагин](http://helpcenter.veeam.com/backup/80/em/em_vmware_web_veeamzip.html) с Veeam Backup Enterprise Manager).
Основное предназначение VeeamZIP: однократное создание независимой переносимой резервной копии.
Когда может понадобиться:
1. Архивация старых ВМ; тестовый или выводимый из эксплуатации сервис. В этом случае делаем VeeamZIP-файл и удаляем ВМ в продакшене.
2. Передача/отправка ВМ разработчику, чтобы потестировать у себя на стенде; требуется полная копия для последующей настройки репликации (seeding); нужно передать подготовленные ВМ в филиалы либо сдать «в ремонт» подрядчикам/на обследование безопасникам и т. д., и т. п.
3. Сохранение различных вариантов ВМ, например, различных версий ПО (как в анекдоте: «Вот скелет Александра Македонского, когда ему было пять лет… А вот скелет уже семилетнего Македонского...»).
4. Создание внеплановой копии перед изменениями, если не подходит Quick Backup — например, в задании указано хранить 3 ежедневные точки восстановления, а вам нужно, чтобы копия сохранилась на больший срок.
5. Придумайте свой вариант.
*Приятный бонус:* вы можете задать срок хранения резервной копии на диске. Если вы ее никуда не забираете, то Veeam Backup ее сам удалит.
Quick Migration
===============
Возможность Quick Migration доступна в бесплатной версии. В платном Veeam Backup & Replication она применяется для миграции ВМ, после операции восстановления путем запуска непосредственно из резервной копии — [Instant VM Recovery](http://habrahabr.ru/company/veeam/blog/166221/), в случае если, например, VMware Storage vMotion невозможен. Запустить эту операцию также можно со вкладки **Virtual Machines**.
Но ведь никто не запрещает использовать эту функцию для обычного переноса ВМ в рабочей среде! Спору нет, Storage vMotion хорош тем, что переносит диски ВМ без остановки их работы, но он негативно влияет на производительность основной СХД в момент переноса. А Quick Migration работает аналогично репликации в Veeam Backup & Replication, и влияние на СХД существенно меньше [помечу себе, что надо проверить, срабатывает ли при этой операции I/O Control], но при этом ВМ будет некоторое время недоступна (будет иметь место даунтайм на момент ввода ВМ в паузу, переноса посторонних блоков и вывода машины из паузы). Так что здесь у вас есть выбор: либо штатный ресурсоемкий svMotion без остановки, либо Veeam Quick Migration с меньшим влиянием на продуктив, но приостановкой в работе.
А вообще, закладка Virtual Machines — весьма полезный раздел.
Закладка Virtual Machines
=========================
Здесь вы легко можете находить нужные ВМ и, кликая по правой кнопке мыши, добавлять их в существующие задания или создавать с ними новые. Это зачастую проще и нагляднее, чем каждый раз открывать задание на редактирование и добавлять новые ВМ для бэкапа через его свойства.
Соскучились по FastSCP?
=======================
Кто помнит про Veeam FastSCP для VMware? Когда-то это был единственный хороший способ копировать данные на датасторы, например, если это ISO-шники или готовые ВМ, образы дисков. Консольный scp копировал очень медленно, а FastSCP был действительно быстрым и бесплатным. Затем его упразднили в пользу бесплатной редакции Veeam Backup. Но! Функция копирования был и остается в Veeam Backup & Replication.
Итак, идем в консоли на закладку **Files** (Вы её вообще открываете, скажите честно? Нет? Ну и зря!). Там мы сможем найти нужные файлы на любом из зарегистрированных в консоли Veeam серверов: VMware, Linux, Windows (включая хосты Hyper-V, конечно) — и копировать их куда угодно в пределах этих же зарегистрированных серверов через Copy-Paste или Drag'n'Drop. (Заметьте, и с Linux на Windows, и обратно тоже можно.)
Помимо этого, можно копировать и по расписанию — с помощью задания File Copy Job. Хотя отложенного однократного исполнения в явном виде нет, можно это решить обходным маневром — через командную строку и планировщик Windows:
1. Создаете задание на копирование File Copy Job без включения расписания на исполнение.
2. На последнем экране мастера копируете командную строку для исполнения задания.
*Полезно:* такие же строчки есть и для других типов заданий.
3. Идете в планировщик Windows и создаете новое задание на однократное исполнение, указываете нужное время и вставляете скопированную строчку из п. 2.
Сам процесс копирования, если говорить про Windows/Linux, происходит изнутри ОС. Так что смело добавляйте физические хосты в консоль Veeam Backup & Replication, когда вам необходимо из/в них тоже что-то копировать.
Копирование происходит как есть, т. е. без сжатия и дедупликации. Хотите сжимать файлы для архивации? Наверное, тогда лучше всего подойдут ленты. У них есть встроенная архивация, а у Veeam Backup & Replication есть интеграция с лентами и свой тип задания File to Tape Job.
И еще про закладку Files
========================
На этой закладке есть встроенный текстовый редактор!
И он понимает текстовые файлы в Unix формате:
Так что если вам нужно отредактировать vmx-файл (конфигурация ВМ на платформе VMware) или любой другой конфигурационный файл внутри Linux (да и Windows тоже), то можете смело воспользоваться этим инструментом. По команде «Сохранить» файл будет сохранен там же, откуда он и был открыт (то есть вовсе не надо копировать его себе на диск, чем-то редактировать и потом заливать обратно).
Трюки с vPower
==============
Напомню тем, кто не знает, а тем, кто забыл — расскажу.
vPower — это технология Veeam, предназначенная для получения доступа к данным ВМ, находящихся в резервной копии, без необходимости полного извлечения (разархивирования и регидрации всех данных обратно). На ней построена возможность Veeam Instant VM Recovery для быстрого восстановления доступа к засбоившей ВМ, а также другие возможности, включая виртуальные лаборатории, восстановление файлов «других ОС» (не Windows) и т. д.
Для платформы VMware vSphere используется свой встроенный NFS-сервер (vPower NFS). Принцип его работы следующий. Veeam Backup & Replication регистрирует на хосте ESXi новое хранилище NFS. Затем при восстановлении ВМ извлекает из резервной копии мелкие файлы ВМ — vmx, nvram и другие. При этом вместо файлов дисков (vmdk) создаются файлы-ссылки на них. Далее Veeam Backup регистрирует ВМ в vSphere и дает команду на её загрузку (при включенной соответствующей опции). Когда гипервизор обращается к файлу-диску ВМ за блоком данных, Veeam Backup & Replication извлекает нужный блок из резервной копии и отдает его гипервизору. Так загружается и затем работает ВМ из резервной копии.
А как ещё этим можно воспользоваться, если не для запуска ВМ? Ну, например, для презентации диска забэкапленной ВМ другой машине. В таком варианте использования нужно помнить о нескольких моментах:
1. Во время восстановления (обязательно делайте восстановление в новое местоположение, вы же не хотите затереть существующую ВМ!) НЕ включайте опции **Connect VM to network** (подключение к сети) и **Power on VM automatically** (автоматическое включение ВМ).
2. После окончания процесса восстановления текущее состояние в логе будет обозначено как *Waiting for user to start migration*.
3. В консоли vSphere к нужной работающей ВМ запускаете добавление нового диска.
4. Выбираете существующий.
5. Находите нужный диск презентованной из резервной копии ВМ на датасторе [VeeamBackup\_<имя\_сервера>].
6. И подтверждаете его добавление.
7. Внутри ВМ инициализируете, при необходимости, и пользуйтесь этим диском.
8. Profit!
Еще несколько важных замечаний:
* Восстановление желательно производить на том хосте, где находится целевая ВМ, к которой вы хотите присоединить диск. Иначе вы можете не увидеть vPower NFS-хранилище — в случае, если на хост никогда не производилось восстановление.
* Не пытайтесь прицепить диск к той же ВМ, с которой запущен этот vPower NFS-сервис (т. е. к репозиторию Veeam) — получите ошибку.
* Если вы что-нибудь запишете на такой диск, в резервную копию данные не попадут. Новые данные сохранятся на диске, если вы не отмените Instant VM Recovery. После миграции таких дисков данные сохраняются в нем окончательно.
* Storage vMotion для ВМ, к которой прицеплен такой диск, поможет перенести этот диск на основную рабочую СХД (в этом случае он смигрирует вместе с новыми данным).
* И не забудьте потом разрегистрировать изначально «восстанавливаемую» ВМ (т. е. сделать **Stop publishing** для Instant VM Recovery).
Таким хитрым способом можно быстро восстановить доступ к диску и применять его вместо восстановления отдельного диска vmdk с подключением к другой ВМ. Вы же знаете, что в Veeam Backup есть и такой способ восстановления (восстановить и подключить как новый SCSI диск), правда же?
Что еще можно сделать с vPower NFS? Идем дальше!
Вот вам шара
============
Обычно добавление VeeamBackup NFS производится 1 раз на каждый хост ESXi при проведении вышеописанных операций. При повторных операциях перепроверяется, что данное подключение существует, и если вы вручную удалите это подключение (unmount datastore), Veeam Backup & Replication подключит его заново. (Эти диски Veeam Backup сам, по своей доброй воле не удаляет — чтобы сократить время при следующем процессе.) Отключать его, в принципе, не имеет большого смысла, а уж будучи подключенным, он может помочь в других делах. Так, его можно использовать как (внезапно!) NFS шару :) Например, можно туда положить ISO-шник или мигрировать ВМ между хостами ESXi, не связанными общим хранилищем.
*Удобно:* перенастройте папку для vPower NFS на удобное, доступное для вас место на сервере репозитория (расположение по умолчанию — в `%ProgramData%`).
Тогда в эту папку будет проще что-то положить со стороны Windows-машины. А можно и еще расшарить папку — для удобного доступа извне.(Вот тут возникла идея: проверить, как VMware Workstation будет работать с таким диском.)
Подключим NFS ко всем хостам — это можно сделать вручную, запустив процесс восстановления Instant VM Recovery на каждом хосте, а затем отменив восстановление (лично мне это не очень удобно, особенно при большом количестве хостов). Другой вариант — в консоли VMware на каждом хосте добавить NFS с данными сервера, как показано здесь (но это также делается вручную):
Можно сделать то же самое через командлет `New-Datastore` (из [powercli](https://www.vmware.com/support/developer/PowerCLI/PowerCLI41/html/New-Datastore.html)). Например, вот так:
```
Get-VMHost | New-Datastore -Nfs -Name VeeamBackup_vbr.domain.local -Path "/VeeamBackup_vbr.domain.local" -NfsHost vbr.domain.local
```
Ну, а если вы хотите удалить все NFS-датасторы, оставшиеся от Veeam Backup & Replication, то для этой цели есть [скрипт](http://foonet.be/2015/12/04/auto-unmount-veeam-vpower-nfs-datastore/).
И вместо заключения — предновогоднее пожелание
==============================================
Иногда мы даже не задумываемся, что ПО, которым мы пользуемся каждый день, обладает возможностями, на которые мы не обращаем внимания — а они могут помочь нам в других, не совсем «своих» повседневных задачах.
Всем известно, что в системном администрировании большую часть времени отнимают рутинные задачи. Подумайте над тем, как автоматизировать их с помощью тех средств, которые у вас уже есть под рукой, и вы наверняка найдете, как использовать имеющиеся программы по их не совсем прямому назначению. Think, так сказать, different… | https://habr.com/ru/post/273757/ | null | ru | null |
# О стримах и таблицах в Kafka и Stream Processing, часть 1
*\* Michael G. Noll — активный контрибьютор в Open Source проекты, в том числе в Apache Kafka и Apache Storm.
Статья будет полезна в первую очередь тем, кто только знакомится с Apache Kafka и/или потоковой обработкой [Stream Processing].*
В этой статье, возможно, в первой из мини-серии, я хочу объяснить концепции Стримов *[Streams]* и Таблиц *[Tables]* в потоковой обработке и, в частности, в **Apache Kafka**. Надеюсь, у вас появится лучшее теоретическое представление и идеи, которые помогут вам решать ваши текущие и будущие задачи лучше и/или быстрее.
Содержание:
\* Мотивация
\* Стримы и Таблицы простым языком
\* Иллюстрированные примеры
\* Стримы и Таблицы в Kafka простым языком
\* Пристальный взгляд на Kafka Streams, KSQL и аналоги в Scala
\* Таблицы стоят на плечах гигантов (на стримах)
\* Turning the Database Inside-Out
\* Заключение
Мотивация, или почему это должно заботить?
------------------------------------------
В своей повседневной работе я общаюсь со многими пользователями Apache Kafka и теми, кто занимается потоковой обработкой с помощью Kafka через [Kafka Streams](https://kafka.apache.org/documentation/streams/) и [KSQL](https://github.com/confluentinc/ksql) (потоковый SQL для Kafka). У некоторых пользователей уже есть опыт потоковой обработки или использования Kafka, у некоторых есть опыт использования РСУБД, таких как Oracle или MySQL, у некоторых нет ни того, ни другого опыта.
Часто задаваемый вопрос: «В чём разница между Стримами и Таблицами?» В этой статье я хочу дать оба ответа: как короткий (TL;DR), так и длинный, чтобы вы могли получить более глубокое понимание. Некоторые из приведённых ниже объяснений будут немного упрощены, потому что это упрощает понимание и запоминание (например, как более простая модель притяжения Ньютона вполне достаточна для большинства повседневных ситуаций, что избавляет нас от необходимости переходить сразу к релятивистской модели Эйнштейна, к счастью, потоковая обработка не настолько сложна).
Другой распространённый вопрос: «Хорошо, но почему это должно меня волновать? Как это поможет мне в моей повседневной работе?» Короче говоря, по многим причинам! Как только вы начнёте использовать потоковую обработку, вы вскоре осознаете, что на практике в большинстве случаев требуются и стримы, и таблицы. Таблицы, как я объясню позже, представляют состояние. Всякий раз, когда вы выполняете любую обработку с состоянием *[stateful processing]*, как объединения *[joins]* (например, обогащение данных *[[data enrichment](https://www.techopedia.com/definition/28037/data-enrichment)]* в реальном времени путём объединения потока фактов с «размерными» таблицами *[[dimension tables](https://en.wikipedia.org/wiki/Dimension_(data_warehouse)#Dimension_table)]* ) или агрегации *[aggregations]* (например, вычисление в реальном времени среднего значения для ключевых бизнес-показателей за 5 минут), тогда таблицы вводят потоковую картину *[streaming picture]*. В противном случае, это означает, что вы вынуждены будете делать это сами *[a lot of DIY pain]*.
Даже пресловутый пример WordCount, вероятно ваш первый «Hello World» из этой области, попадает в категорию «с состоянием»: это пример обработки с состоянием, где мы агрегируем поток строк в непрерывно обновляемую таблицу/мапу для подсчёта слов. Таким образом, независимо от того, реализуете вы простой стриминг WordCount или что-то более сложное, как выявление мошенничества *[fraud detection]*, вы хотите простое в использовании решение для потоковой обработки с основными структурами данных и всем необходим внутри (подсказка: стримы и таблицы). Вы, конечно же, не захотите строить сложную и ненужную архитектуру, где требуется соединять технологию (только лишь) потоковой обработки с удалённым хранилищем, таким как Cassandra или MySQL, и возможно, с добавлением Hadoop/HDFS для обеспечения отказоустойчивости обработки *[fault-tolerance processing]* (три вещи — слишком много).
Стримы и Таблицы простым языком
-------------------------------
Вот лучшая аналогия, которую я смог придумать:
* **Стрим** в Kafka — это полная история всех случившихся событий (или только бизнес-событий) в мире с начала времён по сегодняшний день. Он представляет прошлое и настоящее. По мере того, как мы переходим из сегодняшнего дня в завтрашний, новые события постоянно добавляются к мировой истории.
* **Таблица** в Kafka — это состояние мира на сегодняшний день. Она представляет настощее. Это совокупность *[aggregation]* всех событий в мире, которая постоянно изменяется по мере того, как мы переходим из сегодняшнего в завтрашний.
И как аперитив к будущему посту: если у вас есть доступ ко всей истории событий в мире (стрим), тогда вы можете восстановить состояние мира на любой момент времени, то есть таблицу в произвольное время `t` в потоке, где `t` не ограничивается только `t=сейчас`. Другими словами, мы можем создавать «снимки» *[snapshots]* состояния мира (таблицу) на любой момент времени `t`, например, 2560 г. до н.э., когда была построена Великая Пирамида в Гизе, или 1993 год, когда был основан Европейский Союз.
Иллюстрированные примеры
------------------------
В первом примере показан **стрим** с геоположениями пользователей, которые агрегируются в таблицу, фиксирующую текущее (последнее) положение каждого пользователя. Как я объясню позже, это также оказывается для таблиц семантикой по умолчанию, когда вы читаете топик *[Topic]* Kafka непосредственно в таблицу.
Второй пример использования демонстрирует один и тот же **поток** обновлений геолокаций пользователей, но теперь стрим агрегируется в **таблицу**, которая фиксирует количество посещённых мест каждым пользователем. Поскольку функция агрегации отличается (здесь: подсчёт количества), содержимое таблицы так же отличается. Точнее, другие значения по ключу.
Стримы и Таблицы в Kafka простым языком
---------------------------------------
Прежде чем мы погрузимся в детали, давайте начнём с простого.
**Топик** в Kafka — неограниченная последовательность key-value пар. Ключи и значения — обычные массивы байтов, т.е. .
**Стрим** — топик со схемой *[schema]*. Ключи и значения больше не массивы байтов, а имеют определённый типы.
> Пример: топик читается как стрим геоположений пользователей.
**Таблица** — таблица в обычном смысле этого слова (я чувствую радость тех из вас, кто уже знаком с РСУБД и только знакомится с Kafka). Но глядя через призму потоковой обработки, видим, что таблица также является агрегированным стримом (вы действительно не ожидали, что мы остановимся на определении «таблица — это таблица», не так ли?).
> Пример: стрим с обновлениями геоданных агрегируется в таблицу, которая отслеживает последнее положение пользователя. На этапе агрегации обновляются *[UPSERT]* значения в таблице по ключу из входного стрима. Мы видели это в первом проиллюстрированном примере выше.
> Пример: стрим агрегируется в таблицу, которая отслеживает количество посещённых местоположений для каждого пользователя. На этапе агрегации непрерывно подсчитываются (и обновляются) значения по ключам в таблице. Мы видели это во втором проиллюстрированном примере выше.
Итого:
Топики, стримы и таблицы обладают следующими свойствами в Kafka:
| Тип | Есть партиции | Не ограничен | Есть порядок | Изменчив | Уникальность ключа | Схема |
| --- | --- | --- | --- | --- | --- | --- |
| Topic | Да | Да | Да | Нет | Нет | Нет |
| Stream | Да | Да | Да | Нет | Нет | Да |
| Table | Да | Да | Нет | Да | Да | Да |
Давайте посмотрим, как топики, стримы и таблицы соотносятся с Kafka Streams API и KSQL, а также проведём аналогии с языками программирования (в аналогиях проигнорировано, к примеру, что топики / стримы / таблицы могут быть партицированы):
| Тип | Kafka Streams | KSQL | Java | Scala | Python |
| --- | --- | --- | --- | --- | --- |
| Topic | - | - | `List / Stream` | `List / Stream [(Array[Byte], Array[Byte])]` | `[]` |
| Stream | `KStream` | `STREAM` | `List / Stream` | `List / Stream [(K, V)]` | `[]` |
| Table | `KTable` | `TABLE` | `HashMap` | `mutable.Map[K, V]` | `{}` |
Но это резюме на таком уровне может оказаться малополезным для вас. Итак, давайте рассмотрим поближе.
Пристальный взгляд на Kafka Streams, KSQL и аналоги в Scala
-----------------------------------------------------------
Я начну каждый из следующих разделов с аналогией в Scala (представьте, что потоковая обработка осуществляется на одной машине) и Scala REPL, чтобы вы могли скопировать код и поиграться с ним самостоятельно, затем я объясню, как то же самое сделать в Kafka Streams и KSQL (гибкую, масштабируемую и отказоустойчивую потоковую обработку на распределённых машинах). Как я уже упоминал в начале я немного упрощаю объяснения ниже. Например, я не буду рассматривать влияние партицирования в Kafka.
> **Если вы не знаете Scala:** Не смущайтесь! Вам не нужно понимать Scala-аналоги во всех деталях. Достаточно обратить внимание на то, какие операции (например, `map()`) соединяются вместе, чем они являются (например, `reduceLeft()` представляет собой агрегацию), и как «цепочка» стримов соотносится с «цепочкой» таблиц.
### Топики
Топик в Kafka состоит из сообщений «ключ-значение». Топик не зависит от формата сериализации или «типа» сообщений: ключи и значения в сообщениях трактуются как обычные массивы байтов `byte[]`. Другими словами, с этой точки зрения у нас нет никого представления, что внутри данных.
В Kafka Streams и KSQL нет понятия «топик». Они только знают о стримах и таблицах. Поэтому я покажу здесь только аналог топика в Scala.
```
// Scala analogy
scala> val topic: Seq[(Array[Byte], Array[Byte])] = Seq((Array(97, 108, 105, 99, 101),Array(80, 97, 114, 105, 115)), (Array(98, 111, 98),Array(83, 121, 100, 110, 101, 121)), (Array(97, 108, 105, 99, 101),Array(82, 111, 109, 101)), (Array(98, 111, 98),Array(76, 105, 109, 97)), (Array(97, 108, 105, 99, 101),Array(66, 101, 114, 108, 105, 110)))
```
### Стримы
Теперь мы читаем топик в стрим, добавляя информацию о схеме (схему на чтение *[schema-on-read]*). Другими словами, мы превращаем сырой, нетипизированный топик в «типизированный топик» или стрим.
> **Схема на чтение vs Схема на запись *[schema-on-write]*:** Kafka и её топики не зависят от формата сериализации ваших данных. Поэтому вы должны указать схему, когда захотите прочитать данные в стрим или таблицу. Это называется схемой на чтение. У схемы на чтение есть как плюсы, так и минусы. К счастью, вы можете выбрать промежуточное звено между схемой на чтение и схемой на запись, определив контракт для ваших данных — подобно тому, как вы, вероятно, определяете контракты API в ваших приложениях и сервисах. Это может быть достигнуто путём выбора структурированного, но расширяемого формата данных, такого как [Apache Avro](https://avro.apache.org/) с разворачиванием реестра для ваших Avro-схем, например [Confluent Schema Registry](https://github.com/confluentinc/schema-registry). И да, и Kafka Streams, и KSQL поддерживают Avro, если вам интересно.
В Scala это достигается с помощью операции `map()` ниже. В этом примере мы получаем стрим из пар . Обратите внимание, как мы теперь можем заглянуть внутрь данных.
```
// Scala analogy
scala> val stream = topic
| .map { case (k: Array[Byte], v: Array[Byte]) => new String(k) -> new String(v) }
// => stream: Seq[(String, String)] =
// List((alice,Paris), (bob,Sydney), (alice,Rome), (bob,Lima), (alice,Berlin))
```
В Kafka Streams вы читаете топик в `KStream` через `StreamsBuilder#stream()`. Здесь вы должны определить желаемую схему с помощью параметра `Consumed.with()` при чтении данных из топика:
```
StreamsBuilder builder = new StreamsBuilder();
KStream stream =
builder.stream("input-topic", Consumed.with(Serdes.String(), Serdes.String()));
```
В KSQL вы должны сделать что-то вроде следующего, чтобы прочитать топик как `STREAM`. Здесь вы определяете желаемую схему, указав имена и типы колонкам при чтении данных из топика:
```
CREATE STREAM myStream (username VARCHAR, location VARCHAR)
WITH (KAFKA_TOPIC='input-topic', VALUE_FORMAT='...')
```
### Таблицы
Теперь мы читает этот же топик в таблицу. Во-первых, нам нужно добавить информацию о схеме (схему на чтение). Во-вторых, вы должны преобразовать стрим в таблицу. Семантика таблицы в Kafka гласит, что итоговая таблица должна отображать каждый ключ сообщений из топика в последнее значение для этого ключа.
Давайте сначала используем первый пример, где итоговая таблица отслеживает последнее местоположение каждого пользователя:
В Scala:
```
// Scala analogy
scala> val table = topic
| .map { case (k: Array[Byte], v: Array[Byte]) => new String(k) -> new String(v) }
| .groupBy(_._1)
| .map { case (k, v) => (k, v.reduceLeft( (aggV, newV) => newV)._2) }
// => table: scala.collection.immutable.Map[String,String] =
// Map(alice -> Berlin, bob -> Lima)
```
Добавление информации о схеме достигается использованием первой операции `map()` — точно так же, как в примере со стримом выше. Преобразование стрима в таблицу *[stream-to-table]* осуществляется с помощью этапа агрегации (подробнее об этом будет позже), который в этом случае представляет собой операцию (без состояния) UPSERT на таблице: это шаг `groupBy().map()`, который содержит операцию `reduceLeft()` по каждому ключу. Агрегация означает, что для каждого ключа мы сжимаем множество значений в одно. Обратите внимание, что эта конкретная агрегация `reduceLeft()` без состояния — предыдущее значение aggV не используется при вычислении нового значения для заданного ключа.
Что интересно касательно отношения между стримами и таблицами, так это то, что команда выше создаёт таблицу, эквивалентную короткому варианту ниже (помните о [ссылочной прозрачности](https://en.wikipedia.org/wiki/Referential_transparency) *[referential transparency]*), где мы строим таблицу напрямую из стрима, что позволяет нам пропустить задание схемы / типа, потому что стрим уже типизирован. Мы можем увидеть, что таблица является выводом *[derivation]*, агрегацией стрима:
```
// Scala analogy, simplified
scala> val table = stream
| .groupBy(_._1)
| .map { case (k, v) => (k, v.reduceLeft( (aggV, newV) => newV)._2) }
// => table: scala.collection.immutable.Map[String,String] =
// Map(alice -> Berlin, bob -> Lima)
```
В Kafka Streams вы обычно используете `StreamsBuilder#table()` для чтения топика Kafka в `KTable` простым однострочником:
```
KTable table = builder.table("input-topic", Consumed.with(Serdes.String(), Serdes.String()));
```
Но для наглядности вы также можете прочитать топик сперва в `KStream`, а затем выполнить такой же этап агрегации, как показано выше, чтобы превратить `KStream` в `KTable`.
```
KStream stream = ...;
KTable table = stream
.groupByKey()
.reduce((aggV, newV) -> newV);
```
В KSQL вы должны сделать что-то вроде следующего, чтобы прочитать топик как `TABLE`. Здесь вы должны определить желаемую схему, указав при чтении из топика имена и типы для колонок:
```
CREATE TABLE myTable (username VARCHAR, location VARCHAR)
WITH (KAFKA_TOPIC='input-topic', KEY='username', VALUE_FORMAT='...')
```
Что это означит? Это означает, что таблица на самом деле является агрегированным стримом *[aggregated stream]*, как мы уже говорили в самом начале. Мы видели это непосредственно в специальном случае выше, когда таблица создавалась напрямую из топика. Однако, на самом деле это общий случай.
Таблицы стоят на плечах гигантов (на стримах)
---------------------------------------------
Концептуально, только стрим является конструкцией данных первого порядка в Kafka. С другой стороны, таблица либо (1) выводится из существующего стрима посредством поключевой *[per-key]* агрегации, либо (2) выводится из существующей таблицы, которая всегда разворачивается до агрегированного стрима (мы могли бы назвать последние таблицы «прото-стримами» *[«ur-stream»]*).
> Таблицы часто также описываются как материализованное представление *[materialized view]* стрима. Представление стрима — это не что иное, как агрегация в этом контексте.
Из двух случаем более интересным для обсуждения является (1), поэтому давайте сосредоточимся на этом. И это, вероятно, означает, что мне нужно сперва выяснить, как работают агрегации в Kafka.
### Агрегации в Kafka
Агрегации — это одна из разновидностей потоковой обработки. К другим типам, например, относятся фильтрация *[filters]* и объединения *[joins]*.
Как мы выяснили ранее, данные в Kafka представлены в виде пар ключ-значение. Далее, первое свойство агрегаций в Kafka заключается в том, что все они вычисляются по ключу. Вот почему мы должны сгруппировать `KStream` до этапа агрегации в Kafka Streams через `groupBy()` или `groupByKey()`. По этой же причине нам пришлось использовать `groupBy()` в примерах на Scala выше.
> **Партицирование *[partition]* и ключи сообщений:** Не менее важный аспект Kafka, который я игнорирую в этой статье, состоит в том, что топики, стримы и таблицы партицированы. Фактически, данные обрабатываются и агрегируются по ключу по партициям. По умолчанию, сообщения / записи распределяются по партициям на основании их ключей, поэтому на практике упрощение «агрегация по ключу» вместо технически более сложного и более правильного «агрегация по ключу по партиции» вполне допустимо. Но если вы используете кастомный алгоритм партицирования *[custom partitioning assigners]*, тогда вы должны учитывать это в свой логике обработки.
Второе свойство агрегаций в Kafka заключается в том, что агрегации непрерывно обновляются как только новые данные поступают во входящие стримы. Вместе со свойством вычисления по ключу это требует наличия таблицы или, более точно, это требует изменяемую таблицу *[mutable table]* в качестве результата и, следовательно, типа возвращаемых агрегаций. Предыдущие значения (результаты агрегаций) для ключа постоянно перезаписываются новыми значениями. И в Kafka Streams и в KSQL агрегации всегда возвращают таблицу.
Вернёмся к нашему второму примеру, в котором мы хотим подсчитать по нашему потоку количество посещённых каждым пользователем мест:
Подсчёт *[counting]* — это тип агрегации. Чтобы подсчитать значения, нам нужно только заменить этап агрегации из предыдущего раздела `.reduce((aggV, newV) -> newV)` на `.map { case (k, v) => (k, v.length) }`. Обратите внимание, что возвращаемый тип является таблицей / мапой (и, пожалуйста, проигнорируйте то, что в коде на Scala, `map` неизменна *[immutable map]*, потому что в Scala по умолчанию используются неизменяемые `map`).
```
// Scala analogy
scala> val visitedLocationsPerUser = stream
| .groupBy(_._1)
| .map { case (k, v) => (k, v.length) }
// => visitedLocationsPerUser: scala.collection.immutable.Map[String,Int] =
// Map(alice -> 3, bob -> 2)
```
Код на Kafka Streams, эквивалентный примеру на Scala выше:
```
KTable visitedLocationsPerUser = stream
.groupByKey()
.count();
```
В KSQL:
```
CREATE TABLE visitedLocationsPerUser AS
SELECT username, COUNT(*)
FROM myStream
GROUP BY username;
```
### Таблицы — агрегированные стримы (input stream → table)
Как мы видели выше, таблицы — это агрегации их входных стримов или, короче говоря, таблицы — это агрегированные стримы. Всякий раз, когда вы выполняете агрегацию в Kafka Streams или KSQL, результатом всегда является таблица.
Особенность этапа агрегирования определяет, является ли таблица напрямую получаемой из стрима через семантику UPSERT без состояния (таблица отображает ключи в их последнее значение в стриме, который является агрегацией при чтении топика Kafka напрямую в таблицу), через подсчёт количества увиденных значений для каждого ключа с сохранением состояния *[stateful counting]* (см. наш последний пример), или более сложные агрегации, такие как суммирование, усреднение и так далее. При использовании Kafka Streams и KSQL у вас есть много вариантов для агрегирования, включая оконные агрегации *[windowed aggregations]* с «переворачивающимися» окнами [tumbling windows], «прыгающими» окнами [hopping windows] и «сессионными» окнами [session windows].
### В таблицах есть стримы изменений (table → output stream)
Хотя таблицах является агрегацией входного стрима, она также имеет свой стрим вывода! Подобно записи данных об изменении (CDC) в базах данных, каждое изменение в таблице в Kafka заносится во внутренний стрим изменений называемый changelog stream таблицы. Много вычислений в Kafka Streams и KSQL фактически выполняются на *changelog stream*. Это позволяет Kafka Streams и KSQL, например, правильно перерабатывать исторические данные в соответствии с семантикой обработки времени события *[event-time processing semantics]* — помните, что поток представляет и настоящее, и прошлое, тогда как таблица может представлять только настоящее (или, более точно, фиксированный момент времни *[snapshot in time]*).
> **Примечание:** В Kafka Streams вы можете явно преобразовывать таблицу в стрим изменений *[changelog stream]* через `KTable#toStream()`.
Вот первый пример, но уже с *changelog stream*:
Обратите внимание, что *changelog stream* таблицы является копией входного стрима этой таблицы. Это связано с природой соответствующей функции агрегации (UPSERT). И если вам интересно: «Подождите, разве это не 1 к 1 копирование, расходующее место на диске?» — Под капотом Kafka Streams и KSQL выполняется оптимизация, чтобы свести к минимуму ненужные копирования данных и локальный / сетевой IO. Я игнорирую эти оптимизации на диаграмме выше для лучшей иллюстрации того, что в принципе происходит.
И, наконец, второй пример использования, включающий *changelog stream*. Здесь стрим изменений таблицы отличается, потому что здесь другая функция агрегации, которая выполняет поключевой *[per-key]* подсчёт.
Но эти внутренние *changelog stream*'ы также имеют архитектурное и эксплуатационное влияние. Стримы изменений непрерывно бэкапятся и сохраняются как топики в Kafka, и тема самым являются частью магии, которая обеспечивает эластичность *[elasticity]* и отказоустойчивость в Kafka Streams и KSQL. Это связано с тем, что они позволяют перемещать задачи по обработке между машинам / виртуалками / контейнерами без потери данных и на протяжении всех операций, независимо от того, обработка с состоянием *[stateful]* или без *[stateless]*. Таблица является частью состояния *[state]* вашего приложения (Kafka Streams) или запроса (KSQL), поэтому для Kafka является обязательным возможность переноса не только кода обработки (что легко), но и состояния обработки, включая таблицы, между машинами быстрым и надёжным способом (что намного сложнее). Всякий раз, когда таблица должна быть перемещена с клиентской машины A на машину B, то на новом назначении B таблица реконструируется из её *changelog stream* в Kafka (на стороне сервера) точно такое же состояние, какое было на машине A. Мы можем увидеть это на последней диаграмме выше, где «таблица подсчётов» *[«counting table»]* может быть легко востановлена из её *changelog stream* без необходимости переработки входного стрима.
### Двойственность Стрим-Таблица
Термин [stream-table duality](https://docs.confluent.io/current/streams/concepts.html#duality-of-streams-and-tables) относится к вышеуказанной взаимосвязи между стримами и таблицами. Это означает, например, что вы можете превратить стрим в таблицу, эту таблицу в другой стрим, полученный стрим в ещё одну таблицу и так далее. Для получения дополнительной информации см. пост в блоге Confluent: [Введение в Kafka Streams: Stream Processing Made Simple](https://www.confluent.io/blog/introducing-kafka-streams-stream-processing-made-simple/).
Turning the Database Inside-Out
-------------------------------
В дополнение к тому, что мы рассмотрели в предыдущих разделах, вы, возможно, сталкивались со статьёй [Turning the Database Inside-Out](https://www.confluent.io/blog/turning-the-database-inside-out-with-apache-samza/), и теперь вам может быть интересно взглянуть на это целиком? Поскольку я не хочу сейчас вдаваться в детали, позвольте мне кратко сопоставить мир Kafka и потоковой обработки с миром баз данных. Будьте бдительны: далее серьёзные упрощения *[black-and-white simplifications]*.
В базах данных, таблица — конструкция первого порядка. Это то, с чем вы работаете. «Стримы» также существуют в базах данных, например, в виде [binlog в MySQL](https://dev.mysql.com/doc/refman/5.7/en/binary-log.html) или [GoldenGate в Oracle](http://www.oracle.com/technetwork/middleware/goldengate/overview/index.html), но они, как правило, скрыты от вас в том смысле, что вы не можете взаимодействовать с ними напрямую. База данных знает о настоящем, но она не знает о прошлом (если вам нужно прошлое, восстановите данные с ваших ленточных бэкапов *[backup tapes]*, которые, ха-ха, как раз аппаратные стримы).
В Kafka и потоковой обработке, стрим — конструкция первого порядка. Таблицы — производные от стримов *[derivations of streams]*, как мы видели раньше. Стрим знает о настоящем, так и о прошлом. Как пример, [New York Times хранит все опубликованные статьи](https://open.nytimes.com/publishing-with-apache-kafka-at-the-new-york-times-7f0e3b7d2077) — 160 лет журналистики с 1850-х — в Kafka, источнике достоверных данных *[source of truth]*.
Если коротко: база данных мыслит сперва таблицей, а потом — стримом. Kafka мыслит сперва стримом, а потом — таблицей. Тем не менее, Kafka-сообщество осознало, что в большинстве случаем практического использования стриминга требуются и стримы, и таблицы — даже в пресловутом, но простом WordCount, в котором агрегируется стрим текстовых строк в таблицу со счётчиками слов, как и в нашем втором примере использования выше. Следовательно, Kafka помогает нам соединить миры потоковой обработки и баз данных, предоставляя нативную поддержку стримов и таблиц через Kafka Streams и KSQL, чтобы избавить нас от множества проблем (и предупреждений пейджера). Мы могли бы назвать Kafka и тип стриминговой платформы, которой она является, [поточно-реляционной](https://yokota.blog/2018/03/05/stream-relational-processing-platforms/) *[stream-relational]*, а не только стриминговой [stream-only].
> База данных мыслит сперва таблицей, а потом — стримом. Kafka мыслит сперва стримом, а потом — таблицей.
Заключение
----------
Надеюсь, вы найдёте эти объяснения полезными для того, чтобы лучше понять стримы и таблицы в Kafka и потоковой обработки в целом. Теперь, когда мы закончили с деталями, вы можете вернуться в начало статьи и перечитать ещё раз разделы «Стримы и Таблицы простым языком» и «Стримы и Таблицы в Kafka простым языком».
Если в этой статье вам было интересно попробовать поточно-реляционную обработку с помощью Kafka, Kafka Streams и KSQL, вы можете продолжить изучение:
* Изучение того, как использовать [KSQL](https://github.com/confluentinc/ksql), стриминговый SQL-движок для Kafka, для обработки данных в Kafka без написания какого-либо кода. Это то, что я рекомендовал бы в качестве отправной точки, особенно если вы новичок в Kafka или потоковой обработке, поскольку вы должны приступить к работе в считанные минуты. Также есть замечательная демка с KSQL clickstream (включая вариант с Docker), где вы можете поиграться с Kafka, KSQL, Elasticsearch и Grafana для создания и настройки *real-time dashboard*.
* Изучение того, как создавать Java или Scala приложения для потоковой обработки с использованием [Kafka Streams API](https://kafka.apache.org/documentation/streams/).
* И да, вы, конечно, можете объединить их, например вы можете начать обработку ваших данных с использованием KSQL, затем продолжить работу с Kafka Streams, а затем опять вернуться к KSQL.
Независимо от того, используете вы Kafka Streams или KSQL, благодаря Kafka вы получите гибкую, масштабируемую и отказоустойчивую распределённую потоковую обработку, которая работает повсюду (контейнеры, виртуалки, машины, локально, у заказчика, в облаках, ваш вариант). Просто скажу, если это не очевидно. :-)
Напоследок, я назвал эту статью «Стримы и Таблицы, Часть 1». И хотя у меня уже есть идеи для второй части, я буду благодарен за вопросы и предложения по тому, что я мог быть рассмотреть в следующий раз. О чём вы хотите узнать больше? Дайте мне знать в комментариях или напишите мне по электронной почте!
*Если вы заметили неточность в переводе — напишите, пожалуйста, в личном сообщении или оставьте комментарий.* | https://habr.com/ru/post/353204/ | null | ru | null |
# Модули ввода-вывода ADAM-6200
Модули удаленного ввода-вывода предназначены для связи с периферийными устройствами различных типов. Это важнейший элемент построения промышленных систем. Они могут как принимать сигналы от других устройств, так и посылать управляющие сигналы на устройства, интегрируясь с центральными системами управления SCADA по протоколам **MODBUS TCP, MQTT, HTTP**, и т.д.
Устройства ввода-вывода предыдущих поколений, используемые в промышленности, обычно подключались с помощью последовательных интерфейсов RS-232/485, что затрудняло масштабируемость таких систем. Серия модулей [ADAM-6200](https://www.advantech.ru/products/ethernet-i-o-modules-with-daisy-chain-adam-6200/sub_7447e150-338d-402d-b5a1-c9ce6d98816e?utm_source=habr&utm_medium=cpc&utm_campaign=ADAM-6200&utm_content=all) отличается возможностью подключения по Ethernet, а также встроенным коммутаторов на 2 Ethernet-порта, что позволяет подключать устройства последовательно в цепочку.
Кроме передачи сигналов модули [ADAM-6200](https://www.advantech.ru/products/ethernet-i-o-modules-with-daisy-chain-adam-6200/sub_7447e150-338d-402d-b5a1-c9ce6d98816e?utm_source=habr&utm_medium=cpc&utm_campaign=ADAM-6200&utm_content=all) могут выполнять роль программируемых логических контроллеров, для решения простых задач автоматизации. Благодаря поддержке языка условно-графической логики, программировать их можно даже без знания языков программирования.
В статье разбираются характеристики устройств, сферы применения и дополнительные функции защиты от сбоев.
Технические характеристики
--------------------------
Серия [ADAM-6200](https://www.advantech.ru/products/ethernet-i-o-modules-with-daisy-chain-adam-6200/sub_7447e150-338d-402d-b5a1-c9ce6d98816e?utm_source=habr&utm_medium=cpc&utm_campaign=ADAM-6200&utm_content=all) представлена различными моделями под любые промышленные нужды. Устройства могут соединяться для совместной автономной работы (peer-to-peer), что позволяет получить любую комбинацию необходимых портов.
* **[ADAM-6217](https://www.advantech.ru/products/7447e150-338d-402d-b5a1-c9ce6d98816e/adam-6217/mod_6128934b-8b01-48e2-b566-47342804075f?utm_source=habr&utm_medium=cpc&utm_campaign=ADAM-6200&utm_content=adam-6217)** — 8 каналов аналоговых входов
* **[ADAM-6224](https://www.advantech.ru/products/7447e150-338d-402d-b5a1-c9ce6d98816e/adam-6224/mod_8e33d21a-7b6c-4175-9029-cfbdaa15b723?utm_source=habr&utm_medium=cpc&utm_campaign=ADAM-6200&utm_content=adam-6224)** — 4 канала аналоговых выхода
* **[ADAM-6250](https://www.advantech.ru/products/7447e150-338d-402d-b5a1-c9ce6d98816e/adam-6250/mod_da940b26-501f-413e-bfbc-732fd7496782?utm_source=habr&utm_medium=cpc&utm_campaign=ADAM-6200&utm_content=adam-6250)** — 15 каналов цифровых входов-выходов
* **[ADAM-6251](https://www.advantech.ru/products/7447e150-338d-402d-b5a1-c9ce6d98816e/adam-6251/mod_98139b28-a181-4c45-83c9-01db52c3db7f?utm_source=habr&utm_medium=cpc&utm_campaign=ADAM-6200&utm_content=adam-6251)** — 16 каналов цифровых входов
* **[ADAM-6256](https://www.advantech.ru/products/7447e150-338d-402d-b5a1-c9ce6d98816e/adam-6256/mod_b93c3e30-a8ed-475c-a927-4a7b6c8ffa84?utm_source=habr&utm_medium=cpc&utm_campaign=ADAM-6200&utm_content=adam-6256)** — 16 каналов цифровых выходов
* **[ADAM-6260](https://www.advantech.ru/products/7447e150-338d-402d-b5a1-c9ce6d98816e/adam-6260/mod_ff6d4ca6-7fd1-4f8b-9609-271a4bd2d135?utm_source=habr&utm_medium=cpc&utm_campaign=ADAM-6200&utm_content=adam-6260)** — 6 каналов реле
* **[ADAM-6266](https://www.advantech.ru/products/7447e150-338d-402d-b5a1-c9ce6d98816e/adam-6266/mod_b239f2aa-3498-4ac2-8ecb-e6c7b319f903?utm_source=habr&utm_medium=cpc&utm_campaign=ADAM-6200&utm_content=adam-6266)** — 4 канала реле
### Поддерживаемые протоколы
* **Modbus TCP** — промышленный стандарт для подключения устройств по IP. Все устройства серии поддерживают этот протокол.
* **MQTT** — современный протокол интернета вещей, часто применяется для подключения к облачным система вроде Microsoft IoT hub и подобным. Сообщения внутри MQTT передаются в формате **JSON**.
* **HTTP REST API** — веб-интерфейс и REST API позволяют легко интегрировать устройства в существующие решения на базе любой платформы: NodeJS, PHP, Python, и т.д.
* **SNMP** — используется для конфигурирования сетевых настроек и сбора статистики.
HTTP REST API
-------------
Универсальность HTTP API позволяет легко интегрировать устройства [ADAM-6200](https://www.advantech.ru/products/ethernet-i-o-modules-with-daisy-chain-adam-6200/sub_7447e150-338d-402d-b5a1-c9ce6d98816e?utm_source=habr&utm_medium=cpc&utm_campaign=ADAM-6200&utm_content=all) в любую существующую платформу, без необходимости поддержки специфических промышленных протоколов.
Для примера разберем запрос получения состояния аналогового входа:
**Запрос значений аналогового входа**
```
# Формат запроса: /analoginput/Номер_канал/параметр
curl http://10.0.0.1/analoginput/0/range
```
**Ответ**
Можно видеть текущее значение тока, равное 7mA
```
xml version="1.0" ?
0
7
4~20 mA
20
4
mA
```
Программирование с помощью условно-графической логики
-----------------------------------------------------
Простые задачи автоматизации, где не требуется большая вычислительная мощность, можно запрограммировать прямо на контроллерах ADAM, с помощью условно-графической логики (Graphic Condition Logic). Например, активировать сирену в случае аварии, перекрыть вентиль в случае срабатывания датчика, и т.д. Среда GCL почти не требует навыков программирования и позволяет создать полноценный скрипт автоматизации с помощью курсора мышки.
Разработка скриптов GCL в программе **Adam/Apax .NET Utility**. В качестве условий могут использоваться состояния цифровых или аналоговых входов, счетчик дискретного сигнала, внутренний таймер, и т.д. Правила могут ссылаться друг на друга и образовывать более сложные условия. Подробнее о среде разработки GCL можно прочесть в [документации](http://advdownload.advantech.com/productfile/Downloadfile3/1-1T7O65Q/ADAM-6200_User_Manual_Ed_4.pdf).
Среда разработки условно-графической логики
Последовательное подключение (Daisy Chain)
------------------------------------------
Устройства серии [ADAM-6200](https://www.advantech.ru/products/ethernet-i-o-modules-with-daisy-chain-adam-6200/sub_7447e150-338d-402d-b5a1-c9ce6d98816e?utm_source=habr&utm_medium=cpc&utm_campaign=ADAM-6200&utm_content=all) имеют на борту два ethernet-порта, что позволяет подключать их последовательно, «гирляндой». Это значительно упрощает топологию сети и позволяет обойтись без дополнительных коммутаторов при построении удаленных участков сети.
В отличие от соединения с помощью интерфейсов RS-232/485, подключение по ethernet позволяет легко интегрировать контроллеры в любые IP-сети, а также соединять удаленные объекты через интернет с помощью VPN-тоннелей, без необходимости использовать дополнительные конвертеры интерфейсов.
Защита от обрыва питания (Auto-Bypass)
--------------------------------------
Функция Auto-Bypass автоматически активируется при потере питания на промежуточном устройстве в цепочке. В этом режиме устройство выступает в роли пассивного соединения, как если бы кабель был соединен напрямую. В этом случае действуют ограничения для UTP-соединений, поэтому важно учитывать общую длину кабеля между двух соседних точек и не превышать 50 метров с каждой из сторон, так как максимальная длина пассивного соединения — 100 метров. Время автономной работы функции составляет до 4 дней.
Благодаря Auto-Bypass, связь не обрывается даже при обесточивании промежуточного устройства
Заключения
----------
Универсальные модули ввода-вывода [ADAM-6200](https://www.advantech.ru/products/ethernet-i-o-modules-with-daisy-chain-adam-6200/sub_7447e150-338d-402d-b5a1-c9ce6d98816e?utm_source=habr&utm_medium=cpc&utm_campaign=ADAM-6200&utm_content=all) имеют широкую поддержку протоколов: Modbus TCP, MQTT, HTTP REST, и могут легко интегрироваться как в классические SCADA системы, так и в любые современные программные продукты.
Поддержка программ на языке GCL позволяет решать простые задачи автоматизации без использования дополнительных устройств. Возможность Peer-to-peer-взаимодействия обеспечивает обмен данными напрямую между устройствами, без использования промежуточных серверов обработки данных.
Возможность последовательного соединения устройств в цепочку позволяет легко строить большие отрезки сети без дополнительного оборудования, а функция Auto-Bypass защищает от обрыва линии из-за выхода из строя устройств в цепи.
Приглашаем на партнерский форум Advantech
-----------------------------------------
Форум Advantech станет уникальной площадкой для обсуждения локальных и глобальных тенденций в области Интернета вещей. Здесь вы сможете обменяться опытом использования новых технологических решений и продуктов, найти новых клиентов и партнеров. У вас будет шанс увидеть продукцию, которую мы описывали в статьях и не только. У нас выступят лидеры отрасли и представители ключевых партнеров – NVidia, Intel и другие компании, которые принимают активное участие в развитии промышленного Интернета вещей на ближайшие годы.
Мы будем рады увидеть на мероприятии всех специалистов в сфере промышленной автоматизации и Интернета вещей. [Успейте зарегистрироваться](https://iotsummit.advantech.com/ru-ru/ccpc/3a42b097-ccf6-4163-b3a4-6814b6620fc8?utm_source=habr&utm_medium=cpc&utm_campaign=ccpc_ru). | https://habr.com/ru/post/468627/ | null | ru | null |
# Сколько углекислого газа «генерируют» биткоины
Не секрет, что для майнинга биткоинов требуются большие вычислительные мощности. Достаточно посмотреть [фоторепортаж с майнерской фермы](http://www.thecoinsman.com/2014/08/bitcoin/inside-one-worlds-largest-bitcoin-mines/), которая чем-то напоминает дата-центр, только в дешёвом исполнении. При этом сложность вычислений постоянно растёт. Фермы потребляют немало электричества. Интересно, наносит ли биткоин ущерб окружающей среде?
Автор программы [BitcoinEmissions](https://github.com/peenuty/BitcoinEmissions) написал код, чтобы вычислить точное значение выбросов CO2 на генерацию 1 BTC. Опубликованный код подходит для Wolfram Mathematica 9.
**Код**
```
(* https://en.wikipedia.org/wiki/Electricity_generation# Environmental_concerns 40% of world is coal which is 1000.*)
EnergyEfficiencyDefault := 500
(* https://en.bitcoin.it/wiki/Mining_hardware_comparison Based on some recent asic machines.*)
HashEnergyEfficiencyDefault := 2000
JoulesIn1kWh:= 3600000
GramsInKilogram := 1000
(* 25 BTC per 10 minutes. http://tradeblock.com/research/bitcoin-101/how-are-bitcoins-created/*)
BTCPerSecond :=25 /(60 * 10)
FKgOfCO2PerJoule[EEff_]:= (EEff / GramsInKilogram ) / JoulesIn1kWh
FHashPerSecond[HRate_] := HRate*1000000000
FHashPerBTC[HRate_] := FHashPerSecond[HRate] / BTCPerSecond
FHashPerJoule[HEff_] := HEff * 1000000
FJoulesPerBTC[HEff_, HRate_] := FHashPerBTC[HRate] / FHashPerJoule[HEff]
FKgCO2PerBTC[EEff_,HEff_,HRate_]:= FKgOfCO2PerJoule[EEff] * FJoulesPerBTC[HEff, HRate]
ChartDataLocation := "/Users/rgill/Downloads/chart-data.csv"
(* Get chart data from http://blockchain.info/charts/hash-rate *)
HistoricalHashRate = Import[ChartDataLocation, "DateStringFormat"-> {"Day", "/", "Month", "/", "Year", " ", "Time"}];
HistoricalHashRateWithAbsoluteTime=Table[{AbsoluteTime[HistoricalHashRate[[i,1]]],HistoricalHashRate[[i,2]]},{i,Length[HistoricalHashRate]}];
(* We couldn't get an expoential function to fit properly :( . We used this HACK instead.*)
Model:=Fit[HistoricalHashRateWithAbsoluteTime, {1,x, x^2, x^3, x^4, x^5, x^6, x^7},x]
(* This shows our fitted function of historial hash rates against the real data.
Show[
ListPlot[newdata],
Plot[Model, {x,3.58 * 10 ^ 9,3.805* 10 ^ 9}, PlotStyle->Red],
PlotRange -> {{3.58 * 10 ^ 9,3.635* 10 ^ 9},{0,100000000}}
]
*)
HashRateAtT[year_, month_, day_] := Model /. {x -> {AbsoluteTime[{year,month,day, 0,0,0}]}}
Manipulate[
FKgCO2PerBTC[EnergyEfficiency,HashEnergyEfficiency,HashRateAtT[Year, Month, 1]]"kg of CO2 per BTC",
{EnergyEfficiency,0,1000},{HashEnergyEfficiency,0,5000},{Year,2010,2025, 1},{Month,1,12, 1},
Initialization:>(EnergyEfficiency:=EnergyEfficiencyDefault;HashEnergyEfficiency:=HashEnergyEfficiencyDefault; Year:=2014; Month := 1)]
Out[528]= Manipulate[FKgCO2PerBTC[EnergyEfficiency, HashEnergyEfficiency, HashRateAtT[Year, Month, 1]]*"kg of CO2 per BTC", {{EnergyEfficiency, 500}, 0, 1000},
{{HashEnergyEfficiency, 2000}, 0, 5000}, {{Year, 2014}, 2010, 2025, 1}, {{Month, 5}, 1, 12, 1},
Initialization :> (EnergyEfficiency := EnergyEfficiencyDefault; HashEnergyEfficiency := HashEnergyEfficiencyDefault; Year := 2014; Month := 1)]
```
При расчёте сделано несколько предположений:
1. При генерации 1 kWhe высвобождается 500 граммов CO2 ([источник](https://en.wikipedia.org/wiki/Electricity_generation#Environmental_concerns), примечание: оценка спорная и вызывает критику экспертов).
2. Средняя эффективность биткоин-майнеров в системе составляет 200 Mhash/J ([источник](https://en.bitcoin.it/wiki/Mining_hardware_comparison)).
3. Хэшрейт растёт экспоненциально (для прогноза сложности вычислений в будущем).
Вычисления показывают, что на 1 мая 2014 года каждый новый биткоин высвобождал около 103 кг CO2. С учётом экспоненциального роста сложности к 1 мая 2015 года этот показатель предположительно вырастет до ≈1602 кг CO2.
Теперь посчитаем, сколько деревьев нужно посадить, чтобы компенсировать влияние Bitcoin на природу.
В среднем, одно лиственное дерево в течение своей жизни потребляет [около тонны CO2](http://www.carbonfootprint.com/plantingtrees.html). Это значит, что на сегодняшний день для «компенсации» каждого биткоина нужно посадить полтора дерева.
1 BTC генерируется примерно каждые 24 секунды (1 блок с 25 BTC выходит каждые 10 минут). Так что нужно садить новое дерево примерно каждые 16 секунд, то есть 5400 деревьев в день.
Естественно, сразу же хочется сравнить «вред» для окружающей среды Bitcoin с аналогичным показателем для обычных финансовых систем и финансовых бирж. Ведь для производства монет и купюр в физическом виде напрямую расходуются природные ресурсы нашей планеты — бумага и металлы. У биткоина отсутствует этот недостаток.
Кроме того, для работы фондовых бирж расходуются явно избыточные ресурсы, которые тоже наносят вред природе. Например, прокладываются новые каналы связи, в том числе подводные. Единственное предназначение этих каналов — на несколько миллисекунд сократить пинг между биржами, чтобы ускорить арбитраж сделок.
А если посчитать, сколько ресурсов ушло на строительство самих зданий банков, денежных хранилищ, физическую транспортировку денег, то ущерб для окружающей среды наверняка превысит показатели Bitcoin. | https://habr.com/ru/post/376541/ | null | ru | null |
# Анализ потокобезопасности в С++
Писать многопоточные приложения нелегко. Некоторые средства статического анализа кода позволяют помочь разработчикам, давая возможность чётко определить политики поведения потоков и обеспечить автоматическую проверку выполнения этих политик. Благодаря этому появляется возможность отлавливать состояния гонки потоков или их взаимной блокировки. Эта статья описывает инструмент анализа потокобезопасности С++ кода, встроенный в компилятор Clang. Его можно включить с помощью опции командной строки −Wthread−safety. Данный подход широко распространён в компании Google — полученные от его применения преимущества привели к повсеместному добровольному использованию данной технологии различными командами. Вопреки популярному мнению, необходимость в дополнительных аннотациях кода не стала бременем, а наоборот, дала свои плоды выражающиеся в упрощении поддержки и развития кода.
##### Предисловие
Писать многопоточные приложения нелегко, поскольку разработчикам приходится представлять себе все многочисленные варианты взаимодействия потоков и использования ими ресурсов. Опыт показывает, что программистам не помешал бы для этого некоторый инструментарий. Многие библиотеки и фреймворки налагают на программиста некоторые требования по потокобезопасности при их использовании, однако далеко не всегда эти требования чётко указаны. И даже в тех случаях, когда всё хорошо задокументировано — это всего лишь выраженная в тексте документации просьба, а не строгая автоматическая проверка.
Средства статического анализа кода помогают разработчикам определить политики потокобезопасности и проверять их при сборке проекта. Примером таких политик могут быть утверждения «мьютекс **mu** всегда должен использоваться при доступе к переменной **accountBalance**» или «метод **draw**() должен вызываться только из GUI-потока». Формальное определение политик даёт два основных преимущества:
1. Компилятор может показывать предупреждения в случае обнаружения нарушений политик. Нахождение ошибки на этапе компиляции значительно дешевле, чем отладка упавших юнит-тестов или, что ещё хуже, появление «плавающих» багов в продакшн-коде.
2. Явно выраженные в коде спецификации потокобезопасности играют роль документации. Подобная документация очень важна для библиотек и SDK, поскольку программистам нужно знать, как их корректно использовать. Данную информацию, конечно, можно поместить в комментарии, однако практика показывает, что подобные комментарии имеют свойство устаревать, поскольку при обновлении кода они не всегда меняются синхронно.
Данная статья рассказывает о применении данного подхода в Clang, хотя изначально он был разработан для GCC, однако версия для GCC более не поддерживается. В Clang данная возможность реализована как предупреждение компилятора. В Google на данный момент вся кодовая база C++ компилируется с включенным по умолчанию анализом потокобезопасности.
Работает всё это следующим образом: в дополнению к типу переменной (**int**, **float**, и т.д.) программист может опционально определить как доступ к данной переменной должен контролироваться в многопоточной среде. Clnag использует для этого аннотации. Аннотации могут быть написаны либо в GNU-стиле атрибутов (то есть **attribute ((...))**) или в стиле атрибутов С++11 (то есть **[[...]]** ). Для переносимости атрибуты обычно спрятаны внутри макроса, который определён только если код компилируется с помощью Clang. Примеры в данной статье предполагают использования данного макроса. Настоящие имена атрибутов могут быть найдены в документации к Clang.
Код в примере ниже демонстрирует базовый случай применения технологии, на примере классического банковского аккаунта. Аттрибут **GUARDED\_BY** требует использования мьютекса **mu** для чтения или записи баланса, что даст гарантию атомарности операций по его изменению. Аналогично, макрос **REQUIRES** требует от того, кто вызовет метод **withdrawImpl**, перед его вызовом заблокировать мьютекс **mu** — лишь после этого операция по изменению баланса в теле метода будет считаться безопасной.
В примере метод **depositImpl**() не имеет атрибута **REQUIRES** и не блокирует мьютекс **mu** перед изменением баланса, а значит компиляция данного кода покажет предупреждение о потенциальной ошибке в этом методе. Анализ потокобезопасности не проверяет, был ли мьютекс использован в методе, который вызвал **depositImpl**(), так что атрибут **REQUIRES** должен быть определён явно. Также мы получим предупреждение о потенциальной ошибке в методе **transferFrom**(), поскольку он должен использовать мьютекс **b.mu**, а использует **this->mu**. Анализ понимает, что это два разных мьютекса в двух разных объектах. И, наконец, ещё одно предупреждение ждёт нас в методе **withdraw**(), где мы забываем разблокировать мьютекс **mu** после изменения баланса. Каждой операции блокирования мьютекса должна соответствовать операция разблокирования; анализ также корректно определяет двойные блокировки и двойные разблокировки. Функция может, при необходимости, осуществить блокировку без разблокировки (или разблокировку без блокировки), но такое поведение должно быть аннотированно специальным образом.
Пример кода:
```
#include ” mutex.h ”
class BankAcct {
Mutex mu;
int balance GUARDED BY(mu);
void depositImpl(int amount) {
// WARNING! Must lock mu.
balance += amount;
}
void withd rawImpl(int amount) REQUIRES (mu) {
// OK. Caller must have locked mu.
balance −= amount;
}
public:
void withdraw(int amount) {
mu.lock();
// OK. We’ve locked mu.
withdrawImpl(amount);
// WARNING! Failed to unlock mu.
}
void transferFrom(BankAcct& b, int amount) {
mu.lock();
// WARNING! Must lock b.mu.
b.withdrawImpl(amount);
// OK. depositImpl() has no requirements.
depositImpl(amount);
mu.unlock();
}
};
```
Анализ потокобезопасности был изначально спроектирован для случаев, подобных вышеуказанному. Но требования использования мьютексов при доступе к определённым объектам — не единственное, что необходимо проверять для обеспечения надёжности. Другой часто распространённый сценарий — это назначение потокам определённых ролей, например «рабочий поток», «GUI-поток». Те же концепции, о которых мы говорили касаемо мьютексов, могут быть применены и к ролям потоков. В примере ниже мы видим некоторый класс **Widget**, который может быть использован из двух потоков. В одном из потоков происходит обработка событий (например, кликов мышью), а в другом — рендеринг. При этом метод **draw**() должен вызываться только из потока рендеринга, и никогда не задерживать работу потока, обрабатывающего пользовательские действия. Анализ предупредит, если метод **draw**() вызовется не из того потока. Далее в статье будет идти речь о мьютексах, но аналогичные примеры можно привести и для ролей потоков.
```
#include ”ThreadRole.h”
ThreadRole Input_Thread;
ThreadRole GUI_Thread ;
class Widget {
public :
virtual void onClick() REQUIRES (Input_Thread);
virtual void draw() REQUIRES (GUI_Thread);
};
class Button : public Widget {
public :
void onClick() override {
depressed = true;
draw(); // WARNING!
}
};
```
##### Базовые концепции
Анализ потокобезопасности в Clang построен на расчёте возможностей. Для чтения или записи определённой области памяти поток должен обладать возможностью (или правами) на это. Эту возможность можно представить себе как некий ключ или токен, который поток должен предоставить чтобы получить права на чтение или запись. Возможность может быть «уникальной» или «разделяемой». «Уникальная»" возможность не может быть скопирована, то есть только один поток может иметь к ней доступ в каждый момент времени. «Разделяемая» возможность может иметь несколько дубликатов, принадлежащих разным потокам. Анализ использует подход «один писатель\много читателей», то есть для записи в определённую область памяти поток должен обладать «уникальной» возможностью, а вот для чтения этой же области у потока может быть как «уникальная», так и одна из «разделяемых» возможностей. Другими словами, много потоков могут читать область памяти одновременно, поскольку они могут разделять возможность, но только один поток в каждый момент времени может писать. Более того, поток не может писать в то время как другой поток читает данную область памяти, поскольку возможность не может быть одновременно «разделяемой» и «уникальной».
Данный подход позволяет убедиться, что программа свободна от состояния гонки, где «состояние гонки» определяется как попытка нескольких потоков получить доступ к одной и той же области памяти, при этом как минимум один из потоков пытается осуществить запись. Поскольку операция записи требует от потока наличия «уникальной» возможности, ни один другой поток не получит доступа к этой памяти в то же самое время.
###### Уникальность и линейная логика
Линейная логика это формальная теория, которая может быть использована, например, для выражения логических утверждений вроде «Вы не можете иметь целый торт и в то же время уже его съесть». Уникальная, или линейная, переменная может быть использована ровно один раз. Её нельзя скопировать, использовать несколько раз или забыть использовать. Уникальный объект может быть создан в одной точке программы, а затем позже использован. Функции, имеющие доступ к объекту, но не использующие его, могут лишь передать его дальше. Например, если бы std::stringstream был линейным типом, программы писались бы следующим образом:
```
std::string stream ss; // produce ss
auto& ss2 = ss << ”Hello” ; // consume ss
auto& ss3 = ss2 << ”World. ” ; // consume ss2
return ss3.str() ; // consume ss3
```
Обратите внимание на то, что каждая переменная потока использовалсь ровно один раз. Линейная система типов не знает о том, что **ss** и **ss2** ссылаются на одни и те же данные, вызов << концептуально использует один поток и создаёт другой с новым именем. Попытка использовать **ss** ещё раз приведёт к ошибке. Аналогично ошибкой будет вернуть что-то, не использовав вызов **ss3.str()**, поскольку тогда **ss3** останется созданным, но неиспользованным.
###### Именование возможностей
Передача уникальных возможностей в явном виде, похожем на примеры выше, была бы невероятно безблагодатным занятием, поскольку каждая операция чтения и каждая операция записи требовали бы новых имён. Вместо этого, Clang в своём механизме анализа потокобезопасности отслеживает возможности как анонимные объекты, передаваемые неявно. Полученная в итоге система типов формально эквивалентна линейной логике, но более проста в практическом программировании.
Каждая возможность ассоциирована с именованным С++ объектом, который определяет возможность и предоставляет операции по её созданию и использованию. Сам по себе С++ объект не уникален. Например, если **mu** это мьютекс, то **mu.lock()** создаёт уникальную анонимную возможность типа **Cap**. Аналогично, **mu.unlock()** неявно принимает и использует возможность типа **Cap**. Операции, которые читают или пишут данные, защищаемые мьютексом **mu**, следуют протоколу передачи возможностей: они принимают и используют неявный параметр типа **Cap** и создают неявный результат того же типа **Cap**.
##### Аннотации потокобезопасности
В этом разделе коротко описываются все основные аннотации, которые поддерживаются статическим анализом потокобезопасности в Clang.
###### GUARDED\_BY(...) и PT\_GUARDED\_BY(...)
**GUARDED\_BY** — это аттрибут, которые вешается на член класса. Он показывает, что доступ к данному члену класса защищается некоторой возможностью. Операции чтения требуют как минимум «разделяемой» возможности, операции записи требуют «уникальной»" возможности. **PT\_GUARDED\_BY** работает аналогично, с тем лишь отличием, что предназначается для указателей и умных указателей.
```
Mutex mu;
int *p2 PT_GUARDED BY(mu) ;
void test() {
*p2 = 42; / / Warning !
p2 = new int; / / OK (no GUARDED_BY) .
}
```
###### REQUIRES(...) и REQUIRES\_SHARED(...)
**REQUIRES** — это атрибут функции. Он требует от вызывающего потока наличия «уникальной» возможности. Можно указать более одной возможности. **REQUIRES\_SHARED** работает аналогично, но требуемая возможность может быть как «уникальной», так и «разделяемой». Формально **REQUIRES** определяет поведение функции таким образом, что она принимает возможность в виде неявного аргумента и возвращает её в виде неявного результата.
```
Mutex mu;
int a GUARDED_BY(mu);
void foo() REQUIRES (mu) {
a = 0; // OK.
}
void test() {
foo(); // Warning ! Requi res mu.
}
```
###### ACQUIRE(...) и RELEASE(...)
Аттрибует **ACQUIRE** показывает, что функция создаёт «уникальную» возможность (или возможности), например, получая её от какого-то потока. Вызывающий эту функцию поток не должен передавать ей возможность, но получит её от функции, когда она вернёт результат. Атрибут **RELEASE** указывает, что функция использует «уникальную» возможность (например, отдавая её другому потоку). Вызывающий поток должен передать функции эту возможность, но не получит её обратно, когда функция вернёт результат.
###### ACQUIRE\_SHARED и RELEASE\_SHARED
Эти аттрибуты работают аналогично описанным выше, но создают и используют «разделяемые» возможности.
###### CAPABILITY(...)
Аттрибует **CAPABILITY** может быть применён к структуре, классу или **typedef**. Он показывает, что объект этого класса может быть использован для идентификации возможностей. Например, класс мьютекса в библиотеках Google определяется следующим образом:
```
class CAPABILITY (”mutex”) Mutex {
public :
void lock() ACQUIRE (this);
void readerLock() ACQUIRE_SHARED(this);
void unlock() RELEASE(this);
void readerUnlock() RELEASE_SHARED(this);
};
```
Мьютексы это обычные С++ объекты. Однако, каждый мьютекс имеет ассоциированную с ним возможность. Методы **lock()** и **unlock()** создают и освобождают данную возможность. Заметьте, что Clang не делает попыток проверить, действительно ли данные методы выполняют соответствующие операции с мьютексом. Аннотации применяются лишь к интерфейсу класса мьютекса и выражают то, как различные его методы создают и используют возможности.
###### TRY\_ACQUIRE(b, ...) и TRY\_ACQUIRE\_SHARED(b, ...)
Эти аттрибуты функции или метода пробуют получить указанную возможность и возвращают **true** или **false** в зависимости от результата.
###### NO\_THREAD\_SAFETY\_ANALYSIS
Данный аттрибут отключает статический анализ потокобезопасности для указанной функции. Это может быть полезно либо тогда, когда функция по определению не должна быть потокобезопасной, либо в случаях, когда логика функции столь сложна, что что статический анализ ошибается.
##### Негативные требования
Все описанные выше требования были «позитивными», т.е. оговаривалось, какая возможность должна присутствовать на момент вызова некоторой функции. Есть, однако, и «негативные» требования, описывающие каких возможностей в этот моет не должно быть. Позитивные требования позволяют избежать состояния гонки, в то время как негативные — помогают бороться с дедлоками. Многие реализации мьютексов не реэнтарабельны, поскольку сделать их реэнтерабельными возможно лишь ценой существенного падения производительности. Для таких мьютексов попытка второй раз вызвать операцию lock() приведёт к дедлоку. Для избежания дедлока мы можем в явном виде указать, что используемая в данный момент возможность не должна быть удерживаемой кем-то в данный момент. Данная «негативная возможность» выражается в виде оператора "!":
```
Mutex mu;
int a GUARDED_BY(mu);
void clear() REQUIRES (!mu) {
mu.lock();
a = 0;
mu.unlock();
}
void reset() {
mu.lock();
// Warning ! Caller cannot hold ’mu’ .
clear();
mu.unlock();
}
```
#### Результаты и выводы
Анализ потокобезопасности С++ кода в данный момент широко используется в продуктах Google. Он включён по умолчанию, для каждой сборки каждого модуля. Более 20 000 файлов С++ кода имеют корректные аннотации согласно приведённым выше правилам, общее количество аннотаций достигает 140 000 и растёт с каждым днём. Использование данных аннотаций является в Google добровольным, и, соответственно, широкое распространение технологии является признаком того, что инженеры Google искренне считают её полезной.
Поскольку состояния гонки и взаимоблокировки — очень коварные вещи, Google использует и статический анализ кода, и средства динамического анализа, такие как Thread Sanitizer. Обнаружилось, что данные инструменты хорошо дополняют друг друга. Динамический анализ не требует аннотаций и, соответственно, может применяться шире. Он, однако, может детектировать проблемы лишь в тех путях выполнения кода, которые реально выполнялись по ходу анализа, а значит эффективность динамического анализа прямо зависит от тестового покрытия кода. Статический анализ не так гибок, но покрывает все возможные варианты исполнения кода. Кроме того, статический анализ выявляет проблемы ещё на этапе компиляции, что значительно эффективнее.
Несмотря на то, что необходимость ручного написания аннотаций может показаться недостатком, мы обнаружили, что аннотации значительно упрощают поддержку и развитие кода. Аннотации особенно широко применяются в библиотеках и API, поскольку там они служат также машинно-верифицируемой документацией. Разработчики и пользователи библиотек чаще всего относятся к разным командам, а значит тот, кто будет использовать библиотеку в реальном проекте не обязательно будет полностью понимать принятый в ней протокол управления многопоточностью. Документация может отсутствовать или быть устаревшей, а значит легко допустить ошибку. С использованием аннотаций протокол упраления средствами синхронизации становится частью API и компилятор будет предупреждать об ошибках в его использовании.
Аннотации также доказали свою эффективность для контроля внутренних ограничений ПО по мере его развития. Например, изначальный дизайн некоторого потокобезопасного класса требовал использования мьютекса каждый раз при доступе к его приватным данным. Со временем в команду разработчиков приходили новые люди, которые будучи не в курсе данного требования (или при случайном рефакторинге) могли изменить данное поведение. При анализе истории изменений кода мы несколько раз находили места, где инженер добавил новый метод в класс, забыв использовать нужный мьютекс при доступе к защищённым данным. После этого он же (или другой человек) был вынужден мучительно и долго отлаживать состояние гонки и исправлять баг. В случае, когда ограничения были выражены в виде аннотаций, такая проблема была бы выявлена при первой же компиляции кода.
Нужно признать, что использование аннотаций имеет свою цену поддержки. Мы обнаружили, что около 50% предупреждений компилятора были спровоцированы не ошибками в коде, а ошибками вроде забытой, устаревшей или неверно использованной аннотацией (вроде отсутствия **REQUIRES** на методах **get\set**). В этом плане аннотации потокобезопасности похожи на использование квалификатора const. Как смотреть на эти ошибки зависит от вашей точки зрения. В Google они считаются ошибками в документации. Поскольку API читается часто и многими инженерами — очень важно поддерживать публичные интерфейсы в актуальном состоянии. Если исключить случаи явно неверного использования аннотаций, оставшееся количество ложно-позитивных срабатываний достаточно низкое — менее 5%. Такие случаи в основном связаны с использованием доступа к одной и той же области памяти через разные указатели, условном использовании мьютексов, доступом к внутренним данным из конструктора объекта, где синхронизация ещё не нужна. | https://habr.com/ru/post/304176/ | null | ru | null |
# Как разобрать URL в JavaScript?
Доброго времени суток, друзья!
Представляю Вашему вниманию перевод заметки [«How to Parse URL in JavaScript: hostname, pathname, query, hash»](https://dmitripavlutin.com/parse-url-javascript/) автора Dmitri Pavlutin.
Унифицированный указатель ресурса или, сокращенно, URL — это ссылка на веб-ресурс (веб-страницу, изображение, файл). URL определяет местонахождения ресурса и способ его получения — протокол (http, ftp, mailto).
Например, вот URL данной статьи:
```
https://dmitripavlutin.com/parse-url-javascript
```
Часто возникает необходимость получить определенные элементы URL. Это может быть название хоста (hostname, `dmitripavlutin.com`) или путь (pathname, `/parse-url-javascript`).
Удобным способом получить отдельные компоненты URL является конструктор `URL()`.
В этой статье мы поговорим о структуре и основных компонентах URL.
### 1. Структура URL
Изображение лучше тысячи слов. На представленном изображении Вы можете видеть основные компоненты URL:
### 2. Конструктор URL()
Конструктор `URL()` — это функция, позволяющая разбирать (парсить) компоненты URL:
```
const url = new URL(relativeOrAbsolute [, absoluteBase])
```
Аргумент `relativeOrAbsolute` может быть абсолютным или относительным URL. Если первый аргумент — относительная ссылка, то второй аргумент, `absoluteBase`, является обязательным и представляет собой абсолютный URL — основу для первого аргумента.
Например, инициализируем `URL()` с абсолютным URL:
```
const url = new URL('http://example.com/path/index.html')
url.href // 'http://example.com/path/index.html'
```
Теперь скомбинируем относительный и абсолютный URL:
```
const url = new URL('/path/index.html', 'http://example.com')
url.href // 'http://example.com/path/index.html'
```
Свойство `href` экземпляра `URL()` возвращает переданную URL-строку.
После создания экземпляра `URL()`, Вы можете получить доступ к компонентам URL. Для справки, вот интерфейс экземпляра `URL()`:
```
interface URL {
href: USVString;
protocol: USVString;
username: USVString;
password: USVString;
host: USVString;
hostname: USVString;
port: USVString;
pathname: USVString;
search: USVString;
hash: USVString;
readonly origin: USVString;
readonly searchParams: URLSearchParams;
toJSON(): USVString;
}
```
Здесь тип `USVString` означает, что JavaScript должен возвращать строку.
### 3. Строка запроса (query string)
Свойство `url.search` позволяет получить строку запроса URL, начинающуюся с префикса `?`:
```
const url = new URL(
'http://example.com/path/index.html?message=hello&who=world'
)
url.search // '?message=hello&who=world'
```
Если строка запроса отсутствует, `url.search` возвращает пустую строку (''):
```
const url1 = new URL('http://example.com/path/index.html')
const url2 = new URL('http://example.com/path/index.html?')
url1.search // ''
url2.search // ''
```
##### 3.1. Разбор (парсинг) строки запроса
Вместо получения исходной строки запроса, мы можем получать ее параметры.
Легкий способ это сделать предоставляет свойство `url.searchParams`. Значением данного свойства является экземпляр интерфейса URLSeachParams.
Объект `URLSearchParams` предоставляет множество методов для работы с параметрами строки запроса (`get(param), has(param)` и т.д.).
Давайте рассмотрим пример:
```
const url = new Url(
'http://example.com/path/index.html?message=hello&who=world'
)
url.searchParams.get('message') // 'hello'
url.searchParams.get('missing') // null
```
`url.searchParams.get('message')` возвращает значение параметра `message` строки запроса.
Доступ к несуществующему параметру `url.searchParams.get('missing')` возвращает `null`.
### 4. Название хоста (hostname)
Значением свойства `url.hostname` является название хоста URL:
```
const url = new URL('http://example.com/path/index.html')
url.hostname // 'example.com'
```
### 5. Путь (pathname)
Свойство `url.pathname` содержит путь URL:
```
const url = new URL('http://example.com/path/index.html?param=value')
url.pathname // '/path/index.html'
```
Если URL не имеет пути, `url.pathname` возвращает символ `/`:
```
const url = new URL('http://example.com/');
url.pathname; // '/'
```
### 6. Хеш (hash)
Наконец, хеш может быть получен через свойство `url.hash`:
```
const url = new URL('http://example.com/path/index.html#bottom')
url.hash // '#bottom'
```
Если хеш отсутствует, `url.hash` возвращает пустую строку (''):
```
const url = new URL('http://example.com/path/index.html')
url.hash // ''
```
### 7. Проверка (валидация) URL
При вызове конструктора `new URL()` не только создается экземпляр, но также осуществляется проверка переданного URL. Если URL не является валидным, выбрасывается `TypeError`.
Например, `http ://example.com` не валидный URL, поскольку после `http` имеется пробел.
Попробуем использовать этот URL:
```
try {
const url = new URL('http ://example.com')
} catch (error) {
error // TypeError, "Failed to construct URL: Invalid URL"
}
```
Поскольку `'http ://example.com'` неправильный URL, как и ожидалось, `new URL('http ://example.com')` выбрасывает `TypeError`.
### 8. Работа с URL
Такие свойства, как `search, hostname, pathname, hash` доступны для записи.
Например, давайте изменим название хоста существующего URL с `red.com` на `blue.io`:
```
const url = new URL('http://red.com/path/index.html')
url.href // 'http://red.com/path/index.html'
url.hostname = 'blue.io'
url.href // 'http://blue.io/path/index.html'
```
Свойства `origin, searchParams` доступны только для чтения.
### 9. Заключение
Конструктор `URL()` является очень удобным способом разбора (парсинга) и проверки (валидации) URL в JavaScript.
`new URL(relativeOrAbsolute, [, absoluteBase]` в качестве первого параметра принимает абсолютный или относительный URL. Если первый параметр является относительным URL, вторым параметром должен быть абсолютный URL — основа для первого аргумента.
После создания экземпляра `URL()`, Вы можете получить доступ к основным компонентам URL:
* `url.search` — исходная строка запроса
* `url.searchParams` — экземпляр `URLSearchParams` для получения параметров строки запроса
* `url.hostname` — название хоста
* `url.pathname` — путь
* `url.hash` — значение хеша | https://habr.com/ru/post/510742/ | null | ru | null |
# Создание React VR-приложения, работающего в реальном времени
Библиотека React VR позволяет писать для веба приложения виртуальной реальности с использованием JavaScript и React поверх [WebVR API](https://webvr.info/). Эта спецификация поддерживается последними (в некоторых случаях — экспериментальными) версиями браузеров Chrome, Firefox и Edge. И для этого вам не нужны очки VR.
[WebVR Experiments](https://webvrexperiments.com/) — это сайт-витрина, демонстрирующий возможности WebVR. Моё внимание привлёк проект [The Musical Forest](https://forest.webvrexperiments.com/), созданный замечательным человеком из Google Creative Lab, который использовал [A-Frame](https://aframe.io/), веб-фреймворк для WebVR, разработанный командой [Mozilla VR](https://mozvr.com/).
В Musical Forest благодаря WebSockets пользователи могут в реальном времени играть вместе музыку, нажимая на геометрические фигуры. Но из-за имеющихся возможностей и используемых технологий приложение получилось достаточно сложным ([исходный код](https://github.com/googlecreativelab/webvr-musicalforest)). Так почему бы не создать аналогичное приложение, работающее в реальном времени, на React VR с многопользовательской поддержкой на базе Pusher?
Вот как выглядит React VR/Pusher-версия:
Пользователь может ввести в URL идентификатор канала. При нажатии на трёхмерную фигуру проигрывается звук и публикуется Pusher-событие, которые получают другие пользователи в том же канале, и слышат тот же звук.
Для публикации событий возьмём Node.js-бэкенд, поэтому вам нужно иметь какой-то опыт работы с JavaScript и React. Если вы плохо знакомы с React VR и используемыми в VR концепциями, то для начала изучите [этот материал](https://www.pluralsight.com/guides/front-end-javascript/getting-started-with-react-vr).
Ссылки на скачивание (чтобы просто попробовать):
→ [React VR-проект](https://github.com/eh3rrera/reactvr_musical).
→ [Node.js-бэкенд](https://github.com/eh3rrera/server_pusher_reactvr_musical).
Настраиваем VR-проект
---------------------
Начнём с установки (или обновления) инструмента React VR CLI:
```
npm install -g react-vr-cli
```
Создадим новый React VR-проект:
```
react-vr init musical-exp-react-vr-pusher
```
Идём в созданную им директорию и исполняем команду для запуска сервера разработки:
```
cd musical-exp-react-vr-pusher
npm start
```
В браузере идём по адресу <http://localhost:8081/vr/>. Должно появиться такое:
Если вы используете совместимый браузер (вроде [Firefox Nightly](https://www.mozilla.org/en-US/firefox/channel/desktop/) под Windows), то должны увидеть ещё и кнопку *View in VR*, позволяющую просматривать приложение в очках VR:
Перейдём к программированию.
Создаём фон
-----------
Для фона возьмём эквидистантное изображение ([equirectangular image](https://www.flickr.com/groups/equirectangular/)). Главной особенностью таких изображений является то, что ширина должна быть ровно вдвое больше высоты. Так что откройте любимый графический редактор и создайте изображение 4096×2048 с градиентной заливкой. Цвет — на ваш вкус.
Внутри директории static\_assets в корне приложения создаём новую папку images, и сохраняем туда картинку. Теперь откроем файл index.vr.js и заменим содержимое метода render на:
```
render() {
return (
);
}
```
Перезагрузим страницу (или активируем [горячую перезагрузку](https://facebook.github.io/react-vr/docs/dev-tools.html#hot-reloading)), и увидим это:
Для эмулирования дерева воспользуемся [Cylinder](https://facebook.github.io/react-vr/docs/cylinder.html). По факту нам их потребуется сотня, чтобы получился лес вокруг пользователя. В оригинальной Musical Forest в файле [js/components/background-objects.js](https://github.com/googlecreativelab/webvr-musicalforest/blob/master/js/components/background-objects.js) можно найти алгоритм, генерирующий деревья. Если адаптировать код под React-компонент нашего проекта, получим:
```
import React from 'react';
import {
View,
Cylinder,
} from 'react-vr';
export default ({trees, perimeter, colors}) => {
const DEG2RAD = Math.PI / 180;
return (
{Array.apply(null, {length: trees}).map((obj, index) => {
const theta = DEG2RAD \* (index / trees) \* 360;
const randomSeed = Math.random();
const treeDistance = randomSeed \* 5 + perimeter;
const treeColor = Math.floor(randomSeed \* 3);
const x = Math.cos(theta) \* treeDistance;
const z = Math.sin(theta) \* treeDistance;
return (
);
})}
);
}
```
Функциональный компонент берёт три параметра:
* `trees` — количество деревьев, которое должно получиться в лесу;
* `perimeter` — значение, позволяющее управлять дальностью отрисовки деревьев от пользователя;
* `colors` — массив значений [цветов](https://facebook.github.io/react-vr/docs/colors.html) деревьев.
С помощью `Array.apply(null, {length: trees})` можно создать массив пустых значений, к которому применим map-функцию, чтобы отрисовать массив цилиндров случайных цветов, прозрачности и позиций внутри компонента [View](https://facebook.github.io/react-vr/docs/view.html).
Можно сохранить код в файле Forest.js внутри директории компонента и использовать его внутри index.vr.js:
```
...
import Forest from './components/Forest';
export default class musical_exp_react_vr_pusher extends React.Component {
render() {
return (
);
}
};
...
```
В браузере увидим [это](https://blog.pusher.com/wp-content/uploads/2017/05/building-a-realtime-react-vr-app-trees.gif). Отлично, фон готов, создадим 3D-объекты, которые будут создавать звуки.
Создаём 3D-формы
----------------
Нужно создать шесть 3D-форм, при касании каждая будет проигрывать шесть разных звуков. Также пригодится маленькая анимация, когда курсор помещается и убирается с объекта.
Для создания форм нам нужны [VrButton](https://facebook.github.io/react-vr/docs/vrbutton.html), [Animated.View](https://facebook.github.io/react-vr/docs/animated.html), [Box](https://facebook.github.io/react-vr/docs/box.html), [Cylinder](https://facebook.github.io/react-vr/docs/cylinder.html) и [Sphere](https://facebook.github.io/react-vr/docs/sphere.html). Но поскольку все формы будут отличаться, просто инкапсулируем в компонент, это будет то же самое. Сохраните следующий код в файл components/SoundShape.js:
```
import React from 'react';
import {
VrButton,
Animated,
} from 'react-vr';
export default class SoundShape extends React.Component {
constructor(props) {
super(props);
this.state = {
bounceValue: new Animated.Value(0),
};
}
animateEnter() {
Animated.spring(
this.state.bounceValue,
{
toValue: 1,
friction: 4,
}
).start();
}
animateExit() {
Animated.timing(
this.state.bounceValue,
{
toValue: 0,
duration: 50,
}
).start();
}
render() {
return (
this.animateEnter()}
onExit={()=>this.animateExit()}
>
{this.props.children}
);
}
};
```
Когда курсор попадает в область кнопки, `Animated.spring` меняет значение `this.state.bounceValue` с 0 на 1 и показывает эффект подпрыгивания. Когда курсор уходит из области кнопки, `Animated.timing` меняет значение `this.state.bounceValue` с 1 на 0 в течение 50 миллисекунд. Чтобы это работало, обернём `VrButton` в компонент `Animated.View`, который будет менять rotateX-преобразование View при каждом изменении состояния.
В index.vr.js можно добавить `SpotLight` (можете выбрать любой другой тип источника света и изменить его свойства) и использовать компонент `SoundShape`, тем самым сделав цилиндр:
```
...
import {
AppRegistry,
asset,
Pano,
SpotLight,
View,
Cylinder,
} from 'react-vr';
import Forest from './components/Forest';
import SoundShape from './components/SoundShape';
export default class musical_exp_react_vr_pusher extends React.Component {
render() {
return (
...
);
}
};
...
```
Конечно, можно менять свойства 3D-форм, и даже заменять их на [3D-модели](https://facebook.github.io/react-vr/docs/model.html).
Теперь добавим пирамиду (цилиндр с нулевым радиусом op radius и четырьмя сегментами):
```
```
Куб:
```
```
Параллелепипед:
```
```
Сфера:
```
```
И треугольная призма:
```
```
После импорта сохраняем файл и обновляем браузер. Должно получиться такое:
Теперь добавим звуки!
Добавляем звук
--------------
Помимо прочего, React VR поддерживает wav, mp3 и ogg-файлы. Полный список есть [здесь](https://github.com/facebook/react-vr/blob/master/ReactVR/js/Audio/getSupportedFormats.js).
Можно взять сэмплы с [Freesound](https://www.freesound.org/) или другого подобного сайта. Скачайте, какие вам нравятся, и поместите в директорию static\_assets/sounds. Для нашего проекта возьмём звуки шести животных, [птицу](https://www.freesound.org/people/funkymuskrat/sounds/217050/), [другую птицу](https://www.freesound.org/people/dobroide/sounds/34162/), [ещё одну птицу](https://www.freesound.org/people/dobroide/sounds/59367/), [кошку](https://www.freesound.org/people/NoiseCollector/sounds/4911/), [собаку](https://www.freesound.org/people/NoiseCollector/sounds/4911/) и [сверчка](https://www.freesound.org/people/Adam_N/sounds/164482/) (последний файл пришлось пересохранить, чтобы уменьшить битрейт, иначе React VR его не проигрывал).
React VR предоставляет три опции проигрывания звука:
* [VrSoundEffects](https://github.com/facebook/react-vr/blob/master/Libraries/Utilities/VrSoundEffects.js)
* Событие [onClickSound](https://facebook.github.io/react-vr/docs/vrbutton.html#onclicksound) кнопки VrButton.
* Компонент [Sound](https://facebook.github.io/react-vr/docs/sound.html).
Однако 3D/объёмный звук поддерживает только компонент `Sound`, так что баланс левого и правого каналов будет меняться при перемещении слушателя по сцене или при повороте головы. Добавим его в компонент `SoundShape`, как и событие `onClick` в `VrButton`:
```
...
import {
...
Sound,
} from 'react-vr';
export default class SoundShape extends React.Component {
...
render() {
return (
this.props.onClick()}
...
>
...
);
}
}
```
Для управления проигрыванием воспользуемся [MediaPlayerState](https://facebook.github.io/react-vr/docs/mediaplayerstate.html). Они будут передаваться как свойства компонента.
С помощью информации из index.vr.js определим массив:
```
...
import {
...
MediaPlayerState,
} from 'react-vr';
...
export default class musical_exp_react_vr_pusher extends React.Component {
constructor(props) {
super(props);
this.config = [
{sound: asset('sounds/bird.wav'), playerState: new MediaPlayerState({})},
{sound: asset('sounds/bird2.wav'), playerState: new MediaPlayerState({})},
{sound: asset('sounds/bird3.wav'), playerState: new MediaPlayerState({})},
{sound: asset('sounds/cat.wav'), playerState: new MediaPlayerState({})},
{sound: asset('sounds/cricket.wav'), playerState: new MediaPlayerState({})},
{sound: asset('sounds/dog.wav'), playerState: new MediaPlayerState({})},
];
}
...
}
And a method to play a sound using the MediaPlayerState object when the right index is passed:
...
export default class musical_exp_react_vr_pusher extends React.Component {
...
onShapeClicked(index) {
this.config[index].playerState.play();
}
...
}
```
Осталось только передать всю эту информацию в компонент SoundShape. Сгруппируем наши 3D-формы в массив и воспользуемся map-функцией для генерирования компонентов:
```
...
export default class musical_exp_react_vr_pusher extends React.Component {
...
render() {
const shapes = [
,
,
,
,
,
];
return (
...
{shapes.map((shape, index) => {
return (
this.onShapeClicked(index)}
sound={this.config[index].sound}
playerState={this.config[index].playerState}>
{shape}
);
})}
);
}
...
}
```
Перезапустите браузер и попробуйте понажимать на объекты, вы услышите разные звуки.
С помощью Pusher добавим в React VR-приложение многопользовательскую поддержку в реальном времени.
Настраиваем Pusher
------------------
Создадим бесплатный аккаунт на <https://pusher.com/signup>. Когда вы создаёте приложение, вас попросят кое-что сконфигурировать:
Введите название, выберите в качестве фронтенда React, а в качестве бэкенда — Node.js. Пример кода для начала:
Не переживайте, вас не заставляют придерживаться конкретного набора технологий, вы всегда сможете их изменить. С Pusher можно использовать любые комбинации библиотек.
Копируем ID кластера (идёт после названия приложения, в этом примере — mt1), ID приложения, ключ и секретную информацию, они нам понадобятся. Всё это можно найти также во вкладке *App Keys*.
Публикуем событие
-----------------
React VR работает как [Web Worker](https://www.w3schools.com/HTML/html5_webworkers.asp) (подробнее об архитектуре React VR в [видео](https://www.youtube.com/watch?v=KHx-32m50c4)), так что нам надо включить скрипт Pusher-воркера в index.vr.js:
```
...
importScripts('https://js.pusher.com/4.1/pusher.worker.min.js');
export default class musical_exp_react_vr_pusher extends React.Component {
...
}
```
Есть два условия, которые надо соблюсти. Во-первых, надо иметь возможность передавать идентификатор посредством URL (вроде <http://localhost:8081/vr/?channel=1234>), чтобы пользователи могли выбирать, в какие каналы заходить и делиться ими с друзьями.
Для этого нам надо считывать URL. К счастью, React VR идёт с [нативным модулем](https://facebook.github.io/react-vr/docs/native-modules.html) [Location](https://github.com/facebook/react-vr/blob/master/ReactVR/js/Modules/Location.js), который делает свойства объекта window.location доступными для контекста React.
Теперь нужно обратиться к серверу, который опубликует Pusher-событие, чтобы все подключённые клиенты тоже могли его проиграть. Но нам не нужно, чтобы клиент, сгенерировавший событие, тоже получил его, потому что в этом случае звук будет проигрываться дважды. Да и какой смысл ждать события для проигрывания звука, если это можно сделать немедленно, как только пользователь кликнул на объект.
Каждому Pusher-соединению присваивается уникальный ID сокета. Чтобы получатели не принимали события в Pusher, нужно передавать серверу `socket_id` клиента, которого нужно исключить при срабатывании события (подробнее об этом [здесь](https://pusher.com/docs/server_api_guide/server_excluding_recipients)).
Таким образом, немного адаптировав функцию `getParameterByName` для [чтения параметров URL](http://stackoverflow.com/a/901144/3593852) и сохранив `socketId` при успешном подключении к Pusher, мы можем соблюсти оба требования:
```
...
import {
...
NativeModules,
} from 'react-vr';
...
const Location = NativeModules.Location;
export default class musical_exp_react_vr_pusher extends React.Component {
componentWillMount() {
const pusher = new Pusher('', {
cluster: '',
encrypted: true,
});
this.socketId = null;
pusher.connection.bind('connected', () => {
this.socketId = pusher.connection.socket\_id;
});
this.channelName = 'channel-' + this.getChannelId();
const channel = pusher.subscribe(this.channelName);
channel.bind('sound\_played', (data) => {
this.config[data.index].playerState.play();
});
}
getChannelId() {
let channel = this.getParameterByName('channel', Location.href);
if(!channel) {
channel = 0;
}
return channel;
}
getParameterByName(name, url) {
const regex = new RegExp("[?&]" + name + "(=([^&#]\*)|&|#|$)");
const results = regex.exec(url);
if (!results) return null;
if (!results[2]) return '';
return decodeURIComponent(results[2].replace(/\+/g, " "));
}
...
}
```
Если в URL нет параметров канал, то по умолчанию присваивается ID 0. Этот ID будет добавляться к Pusher-каналу, чтобы сделать его уникальным.
Наконец, нам нужно вызвать endpoint на серверной стороне, которая опубликует событие, передав ID сокета клиента и канал, в котором будут публиковаться события:
```
...
export default class musical_exp_react_vr_pusher extends React.Component {
...
onShapeClicked(index) {
this.config[index].playerState.play();
fetch('http:///pusher/trigger', {
method: 'POST',
headers: {
'Accept': 'application/json',
'Content-Type': 'application/json',
},
body: JSON.stringify({
index: index,
socketId: this.socketId,
channelName: this.channelName,
})
});
}
...
}
```
Вот и весь код для React-части. Теперь разберёмся с сервером.
Создаём Node.js-бэкенд
----------------------
С помощью команды генерируем файл package.json:
`npm init -y`
Добавляем зависимости:
```
npm install --save body-parser express pusher
```
И сохраняем в файл этот код:
```
const express = require('express');
const bodyParser = require('body-parser');
const Pusher = require('pusher');
const app = express();
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
/*
Эти заголовки необходимы, потому что сервер разработки React VR запущен на другом порту. Когда финальный проект будет опубликован, нужда в middleware может отпасть
*/
app.use((req, res, next) => {
res.header("Access-Control-Allow-Origin", "*")
res.header("Access-Control-Allow-Headers",
"Origin, X-Requested-With, Content-Type, Accept")
next();
});
const pusher = new Pusher({
appId: '',
key: '',
secret: '',
cluster: '',
encrypted: true,
});
app.post('/pusher/trigger', function(req, res) {
pusher.trigger(req.body.channelName,
'sound\_played',
{ index: req.body.index },
req.body.socketId );
res.send('ok');
});
const port = process.env.PORT || 5000;
app.listen(port, () => console.log(`Running on port ${port}`));
```
Как видите, мы настроили Express-сервер, Pusher-объект и route/pusher/trigger, который просто запускает событие с индексом звука для проигрывания и socketID для исключения получателя события.
Всё готово. Давайте тестировать.
Тестируем
---------
Выполним Node.js-бэкенд с помощью команды:
`node server.js`
Обновим серверный URL в index.vr.js (с использованием вашего IP вместо localhost) и в двух браузерных окнах откроем адрес вроде <http://localhost:8081/vr/?channel=1234>. При клике на 3D-форму вы услышите дважды проигранный звук (это куда веселее делать с друзьями на разных компьютерах):
Заключение
----------
React VR — превосходная библиотека, позволяющая легко создавать VR-проекты, особенно если вы уже знаете React/React Native. Если присовокупить к этому Pusher, то получится мощный комплекс разработки веб-приложений нового поколения.
Вы можете собрать production-релиз этого проекта для развёртывания на любом веб-сервере: <https://facebook.github.io/react-vr/docs/publishing.html>.
Также можете изменить цвета, формы, звуки, добавить больше функций из оригинальной [Musical Forest](https://github.com/googlecreativelab/webvr-musicalforest).
Скачать код проекта можно из репозитория [GitHub](https://github.com/eh3rrera/reactvr_musical). | https://habr.com/ru/post/331816/ | null | ru | null |
# Реализация итераторов в C# (часть 1)
От переводчика:
*Не так давно мой менее опытный коллега спросил меня о том, для чего используется yield return в C#. Я не очень часто пишу свои итераторы, поэтому, отвечая ему, я сомневался в своих словах. Справившись в MSDN, я укрепился в сказанном, но у меня возник вопрос: “А во что же всё таки компилируется эта инструкция?” К тому моменту, я уже был знаком с переводимой статьёй, однако всё, что в ней сказано, давно “выветрилось”. Статья старая, но мне думается, что она может быть полезна для определённой группы разработчиков, привыкшей читать русскоязычные статьи и документы.*
Ссылка на продолжение: [реализация итераторов в C# (часть 2)](http://habrahabr.ru/blogs/net/136864/)
Как и анонимные методы, итераторы в C# являются сложным синтаксическим сахаром. Вы можете реализовать их полностью самостоятельно (в конце концов, в ранних версиях C# вам приходилось делать это), но использовать компилятор намного удобнее. Идея, стоящая за итераторами заключается в том, что они принимают функцию с yield return выражениями (и, возможно, yield break выражениями) и конвертируют её в конечный автомат. Когда вызывается yield return, состояние функции сохраняется, и при повторном обращении к итератору для получения очередного объекта это состояние восстанавливается. Главное в итераторах то, что все локальные переменные итератора (в том числе параметры итератора как предварительно инициализировнные локальные переменные, включая скрытый параметр this) становятся переменными-членами (далее полями) вспомогательного класса. Помимо этого вспомогательный класс содержит поле state, которое следит, где произошло прерывание исполнения, и поле current, хранящее самый последний из уже перечисленных объектов.
```
class MyClass {
int limit = 0;
public MyClass(int limit) { this.limit = limit; }
public IEnumerable CountFrom(int start)
{
for (int i = start; i <= limit; i++)
yield return i;
}
}
```
Метод CountFrom создаёт перечислитель целых чисел, который производит целые числа от start до limit включительно с шагом 1. Компилятор неявно конвертирует этот перечислитель во что-то вроде этого:
```
class MyClass_Enumerator : IEnumerable {
int state$0 = 0; // внутренний член
int current$0; // внутренний член
MyClass this$0; // неявный параметр CountFrom
int start; // явный параметр CountFrom
int i; // локальная переменная метода CountFrom
public int Current {
get { return current$0; }
}
public bool MoveNext()
{
switch (state$0) {
case 0: goto resume$0;
case 1: goto resume$1;
case 2: return false;
}
resume$0:;
for (i = start; i <= this$0.limit; i++) {
current$0 = i;
state$0 = 1;
return true;
resume$1:;
}
state$0 = 2;
return false;
}
// ... прочее счетоводство, неважное здесь ...
}
public IEnumerable CountFrom(int start)
{
MyClass\_Enumerator e = new MyClass\_Enumerator();
e.this$0 = this;
e.start = start;
return e;
}
```
Перечисляющий класс автоматически генерируется компилятором и, как было обещано, он содержит поля для состояния и текущего объекта, плюс по одному полю на каждую локальную переменную. Свойство Current просто возвращает текущий объект. Вся же настоящая работа происходит в методе MoveNext.
Для генерации метода MoveNext компилятор берёт написанный вами код и производит несколько трансформаций:
* Все ссылки на переменные должны быть скорректированы, поскольку код перенёсся во вспомогательный класс.
* this становится this$0, поскольку внутри сгенерированной функции this указывает на автоматически сгенерированный класс вместо оригинального.
* m становится this$0.m, если m является членом исходного класса (нестатическим полем, свойством или методом). В действительности, это правило излишне в сочетании с предыдущим, т.к. запись имени члена класса без префикса m это просто сокращение для this.m.
* v становится this.v, если v это параметр или локальная переменная. Это правило также излишне, т.к. запись v равносильна this.v, но я обращаюсь явно, чтобы вы обратили внимание, что хранилище переменной изменилось.
Помимо этого компилятору приходится иметь дело со всеми инструкциями yield return.
Каждое выраженик yield return x преобразуется в
```
current$0 = x;
state$0 = n;
return true;
resume$n:;
```
где n это возрастающее число, начинающееся с единицы 1.
Кроме этого есть выражения yield break.
Каждое выражение yield break преобразуется в
```
state$0 = n2;
return false;
```
где n2 — число, на единицу большее, чем наибольший номер из всех состояний, использующихся в выражениях yield return. Не забывайте, что в конце каждой функции подразумевается вызов yield break.
Наконец, компилятор вставляет большой диспетчер состояний в самом начале функции.
```
switch (state$0) {
case 0: goto resume$0;
case 1: goto resume$1;
case 2: goto resume$2;
// ...
case n: goto resume$n;
case n2: return false;
}
```
по одному case-выражению создаётся для каждого состояния, плюс на начальное и конечное состояние n2. | https://habr.com/ru/post/136828/ | null | ru | null |
# Для этого не нужна ARIA
В веб-разработке написание семантического HTML важно для доступности, а также дает некоторые приятные побочные эффекты, такие как поддержка режима «чтения» в браузере, SEO, graceful degradation и возможность экспорта.
Реализуя семантический HTML, мы также значительно уменьшаем потребность в ARIA (Accessible Rich Internet Applications). ARIA - это большой набор HTML атрибутов, который обеспечивает доступность для пользователей использующих screen reader, за счет лучшей поддержки семантики, которая не предоставляется или плохо поддерживается с помощью базовой HTML разметки.
Местами, использование ARIA, определённо необходимо. Но в целом, сокращение использования ARIA, по иронии судьбы, значительно повышает доступность. Это связано с несколькими причинами, в том числе:
1. ARIA очень часто реализована неправильно. Это хорошо известно в области, но для получения данных обратитесь к [отчету WebAIM Million](https://webaim.org/projects/million/#aria), в котором говорится, что “На главных страницах с присутствием ARIA было обнаружено в среднем на 70% больше ошибок, чем на страницах без ARIA”.
2. ARIA может не очень хорошо поддерживаться (даже если правильно реализовано) браузером и/или screen reader'ом, что, к сожалению, случается очень часто.
3. ARIA не магия (как, похоже, думают некоторые профессиональные веб-разработчики). Интерфейсы по-прежнему должны быть доступными, инклюзивными и пригодными для использования.
4. ARIA предоставляет только семантику. Оно не предоставляет никакой функциональности. Он не обеспечивает никакого взаимодействия с клавиатурой, которое часто ожидают от определенных шаблонов ARIA (например, панель вкладок). Оно не решает проблемы доступности вне семантики вспомогательных технологий (таких как альтернативный текст, цветовой контраст, порядок чтения, четкие надписи, подписи к рисункам и т.д.).
Следующие примеры продемонстрируют, как правильно использовать HTML так, чтобы ARIA не требовалась. При этом приведённые методы помогут разработчикам следовать [первому правилу ARIA](https://www.w3.org/TR/using-aria/#rule1) (по возможности сначала использовать HTML), а также обеспечат более надежный код и, скорее всего, более доступный интерфейс для пользователя.
Примеры использования
---------------------
Приведенные ниже примеры представляют собой лишь выборку проблем и включают подписи элементов форм, кнопки, ссылки и изображения. Я считаю их распространенными проблемами, и на самом деле я столкнулся со всеми из них “в дикой природе” (на живых веб-сайтах) за последние пару недель. За плохой версией следует хорошая, а затем примечание. В демонстрационных целях фрагменты кода значительно упрощены по сравнению с веб-страницами, на которых они были найдены.
Помните, что исправление избыточности ARIA может показаться тривиальным на первый взгляд, но может иметь большое значение в:
1. снижение сложности кода — меньше кода!
2. уменьшение проблем с поддержкой — например, использование одного текстового контента вместо дублирования (кроме того, меньше кода!)
3. уменьшение ошибок доступности вызванных вычислением значений браузером — например, разработчик может не понимать как [высчитывается доступное имя](https://www.w3.org/WAI/ARIA/apg/practices/names-and-descriptions/#name_calculation), что может быть немного сложным.
Теперь давайте перейдем к примерам!
### Подписи в формах
#### Пример 1
Плохо: не нужный атрибут `aria-label`
```
...
Pickup
```
Хорошо: используйте текст внутри метки (неявная ассоциация)
```
...
Pickup
```
**Примечание:** Удалите `aria-label` , чтобы выиграть! `label`, обернутый вокруг `input`, в достаточной степени обеспечивает доступное имя для поля ввода.
**Предупреждение:** этот пример реализует неявную маркировку поля ввода, которая может иметь проблемы с некоторыми вспомогательными технологиями, такими как Dragon NaturallySpeaking. Рекомендуется использовать явную ассоциацию, как в примере 2.
#### Пример 2
Плохо: необоснованное использование `aria-labelledby`
```
Sort By:
Relevance
Most Recent
Value
```
Хорошо: используйте атрибуты `for` и `id` для явной связи
```
Sort By:
Relevance
Most Recent
Value
```
**Примечание:** Используйте базовый HTML (а не ARIA), чтобы выиграть! Атрибуты `for` и `id` предоставляют доступное имя для полей ввода.
### Изображения в кнопках
Плохо: ненужный `aria-label` и ненужная роль
```
```
Хорошо
```
```
**Примечание:** Удалите два атрибута ARIA (и дублирующийся текст), чтобы выиграть! Атрибут `alt` предоставляет доступное имя для кнопки.
### Текст в ссылках
Плохо: перезапись существующего контента
```
[100 W Main St
Strangeville, OH 48000](/foobar...)
```
Хорошо: используйте существующий встроенный текст
```
[100 W Main St
Strangeville, OH 48000](/foobar...)
```
**Примечание:** Здесь не нужно переусердствовать, `aria-label` перезаписывает текст адреса в качестве имени ссылки, поэтому текст адреса недоступен пользователям screen reader'ов. Достаточно обернуть в ссылку текст адреса.
### Изображения в ссылках
Плохо: ненужный атрибут `aria-label`
```
[](/foo)
```
Хорошо: используйте только альтернативный текст изображения
```
[](/foo)
```
**Примечание:** Удалите атрибут `aria-label` и используйте базовый HTML, чтобы выиграть! Атрибут `alt` используется в качестве контента ссылки.
### Декоративные изображения
Плохо: атрибут `role` используется для обозначение декоративного изображения
```
```
Хорошо: используйте пустое значение для атрибута `alt`
```
```
**Примечание:** Удалите атрибут `role` (и удалите содержимое `alt`), чтобы выиграть! Пустой атрибут `alt` означает, что это декоративное изображение.
### Скрипты
Плохо: `aria-hidden` на тэге скрипта | https://habr.com/ru/post/706674/ | null | ru | null |
# Проектируем DataGrid на React так, чтобы сэкономить Boilerplate
Привет, Хабр! Некоторое время назад мне довелось участвовать в разработке админ-панели для видеоигры с уклоном на совместные соревнования. Так как финансирование осуществлялось [за счет гранта](https://near.org/grants/), был ограничен бюджет.
Возникла потребность спроектировать архитектуру приложения так, чтобы единовременно **написав заготовки** списочных форм и форм элемента списка, их **мог массово клепать разработчик уровня Junior-**. При этом, после выхода на самоокупаемость, уже написанный код потребуется оставить не тратя время и деньги на рефакторинг.
Админ-панель важна, так как с её помощью осуществляется [KYC](https://en.wikipedia.org/wiki/Know_your_customer) и бан читеров. Однако, для бизнеса это не основной продукт, поэтому, хотелось бы сэкономить деньги.
Анализ рынка
------------
Разберем существующие решения на рынке, а именно [DevExtreme React Grid](https://devexpress.github.io/devextreme-reactive/react/grid/demos/featured/integrated-data-shaping/), [ReactVirtualized Grid](https://github.com/bvaughn/react-virtualized/blob/master/docs/Grid.md), [KendoReact Data Grid](https://www.telerik.com/kendo-react-ui/components/grid/), [MUI DataGridPro](https://mui.com/x/react-data-grid/#commercial-version). Все они перекладывают ответственность за пагинацию, сортировки и фильтры на состояние компонента или приложения.
```
import * as React from 'react';
// import ...
const defaultTheme = createTheme();
const useStylesAntDesign = makeStyles(
(theme) => ({
// CSS-in-JS
}),
{ defaultTheme },
);
const useStyles = makeStyles(
(theme) => ({
// CSS-in-JS
}),
{ defaultTheme },
);
function SettingsPanel(props) {
const { onApply, type, size, theme } = props;
const [sizeState, setSize] = React.useState(size);
const [typeState, setType] = React.useState(type);
const [selectedPaginationValue, setSelectedPaginationValue] = React.useState(-1);
const [activeTheme, setActiveTheme] = React.useState(theme);
const handleSizeChange = React.useCallback((event) => {
setSize(Number(event.target.value));
}, []);
const handleDatasetChange = React.useCallback((event) => {
setType(event.target.value);
}, []);
const handlePaginationChange = React.useCallback((event) => {
setSelectedPaginationValue(event.target.value);
}, []);
const handleThemeChange = React.useCallback((event) => {
setActiveTheme(event.target.value);
}, []);
const handleApplyChanges = React.useCallback(() => {
onApply({
size: sizeState,
type: typeState,
pagesize: selectedPaginationValue,
theme: activeTheme,
});
}, [sizeState, typeState, selectedPaginationValue, activeTheme, onApply]);
return (
Dataset
Employee
Commodity
Rows
100
{Number(1000).toLocaleString()}
{Number(10000).toLocaleString()}
{Number(100000).toLocaleString()}
Page Size
off
auto
25
100
{Number(1000).toLocaleString()}
Theme
Default Theme
Ant Design
Apply
);
}
SettingsPanel.propTypes = {
onApply: PropTypes.func.isRequired,
size: PropTypes.number.isRequired,
theme: PropTypes.oneOf(['ant', 'default']).isRequired,
type: PropTypes.oneOf(['Commodity', 'Employee']).isRequired,
};
export default function FullFeaturedDemo() {
const classes = useStyles();
const antDesignClasses = useStylesAntDesign();
const [isAntDesign, setIsAntDesign] = React.useState(false);
const [type, setType] = React.useState('Commodity');
const [size, setSize] = React.useState(100);
const { loading, data, setRowLength, loadNewData } = useDemoData({
dataSet: type,
rowLength: size,
maxColumns: 40,
editable: true,
});
const [pagination, setPagination] = React.useState({
pagination: false,
autoPageSize: false,
pageSize: undefined,
});
const getActiveTheme = () => {
return isAntDesign ? 'ant' : 'default';
};
const handleApplyClick = (settings) => {
if (size !== settings.size) {
setSize(settings.size);
}
if (type !== settings.type) {
setType(settings.type);
}
if (getActiveTheme() !== settings.theme) {
setIsAntDesign(!isAntDesign);
}
if (size !== settings.size || type !== settings.type) {
setRowLength(settings.size);
loadNewData();
}
const newPaginationSettings = {
pagination: settings.pagesize !== -1,
autoPageSize: settings.pagesize === 0,
pageSize: settings.pagesize > 0 ? settings.pagesize : undefined,
};
setPagination((currentPaginationSettings) => {
if (
currentPaginationSettings.pagination === newPaginationSettings.pagination &&
currentPaginationSettings.autoPageSize ===
newPaginationSettings.autoPageSize &&
currentPaginationSettings.pageSize === newPaginationSettings.pageSize
) {
return currentPaginationSettings;
}
return newPaginationSettings;
});
};
return (
);
}
```
Посмотреть полный пример DataGridPro [можно тут](https://codesandbox.io/s/nasty-mui-datagridpro-sample-uchw3m). Подобный подход неизбежно ведет к повышению стоимости кадра, так как копипаста сортировок, фильтров и пагинации ляжет на проект мертвым грузом legacy.
Тезисы о проблемах кода выше
----------------------------
1. Так как это разные `useState`, изменение `type`, `size` и `pagination` вызовет промежуточный рендеринг, когда значение первого состояния изменилось, но эффект для обновления второго не отработал. Что если для запроса на сервер нужно получить актуальное значение всех трех состояний единовременно (см кнопку *Apply*)?
2. Компонент `SettingsPanel` будет использован в приложении ровно один раз для фильтров именно на этой странице. Спорно, но по моему, это скорее функция, которая вернет `JSX.Element`, а не компонент.
3. Что если мы хотим сделать пагинацию с фильтрами и сортировками на стороне backend? Как показать пользователю индикатор загрузки и блокировать приложение при status-500, через копипасту?
Решение проблемы
----------------
1. Нужно убрать копипасту состояний и вынести запрос на получение данных в чистую функцию, которая получает на вход `filterData`, `limit`, `offset` и т.д., возвращает либо массив, либо промис с массивом элементов для списочной формы;
2. Нужно сделать конфиг для фильтров, чтобы соблюдать фирменный стиль и исключить копипасту компонента `SettingsPanel`. Или передавать компонент через пропсы, в таком случае, заранее согласовать контракт;
3. Нужно придумать функцию высшего порядка, которая до исполнения оригинальной функции получения данных (*пункт 1*) включит индикатор загрузки, выключит его в блоке `finally` и, по необходимости, оповестит пользователя о status-500.
Дополнительно
-------------
Не хватает кнопок для управления строками. Например, что если мы хотим пригласить выбранных трейдеров на конференцию? Нужно добавить колонку "Статус приглашения" в таблицу и сделать кнопку "Пригласить". Однако, если приглашение уже отправлено, соответствующую кнопку для трейдера следует отключить.
MUI DataGridProА ещё, желательно дать возможность отправлять приглашения нескольким трейдерам исходя из выбранных строк, логика отключения этой кнопки требует мемоизации данных при переключении страницы в списке.
### Чистая функция для получения списка элементов
Для того, чтобы отделить бизнес-логику прикладного программиста от системной логики грида, я бы рекомендовал передать в пропсы компонента списочной формы чистую функцию со следующим прототипом:
```
import { List } from 'react-declarative';
type RowId = string | number;
interface IRowData {
id: RowId;
}
type HandlerPagination = {
limit: number;
offset: number;
};
type HandlerSortModel = {
field: keyof RowData;
sort: 'asc' | 'desc';
}[];
type HandlerChips =
Record;
type HandlerResult = {
rows: RowData[];
total: number | null;
};
type Handler = (
filterData: FilterData,
pagination: ListHandlerPagination,
sort: ListHandlerSortModel,
chips: ListHandlerChips,
search: string,
) => Promise> | HandlerResult;
const handler: Handler = (filterData, pagination, sort, chips, search) => {
...
};
...
```
Функция `handler` получает следующие пять параметров:
1. **filterData** - содержимое компонента SettingsPanel, условно. Расширенные фильтры, например, с ComboBox, слайдерами и т.д.;
2. **pagination** - объект с двумя свойствами: `limit` и `offset`свойствами. Передаются на бек для пагинации, позволяют сделать следующее `rows.slice(offset, limit + offset)`;
3. **sort** - массив с сортировками колонок. Сортировка может `asc` (ascending - по возрастанию) или `desc` (descending - по убыванию);
4. **chips** - объект с булевскими флагами для фильтрации списка. Например, среди списка сотрудников мы хотим выбрать только оформленных как самозанятых;
5. **search -** строка с глобальным поиском, пытаемся распарсить нативный язык пользователя как делает гугл.
Функцию handler можно собрать через [Factory](https://en.wikipedia.org/wiki/Factory_method_pattern), которую можно положить в хук:
```
import mock from './person_list.json';
...
const handler = useArrayPaginator(mock);
```
Хук `useArrayPaginator` будет иметь следующую реализацию, что позволит на лету поменять обработки каждого из пяти аргументов `handler`. К слову, так же на вход можно передать промис, который вернет массив элементов без сортировок, пагинации и т.д.
```
import ...
const EMPTY_RESPONSE = {
rows: [],
total: null,
};
type ArrayPaginatorHandler =
RowData[] | ((
data: FilterData,
pagination: ListHandlerPagination,
sort: ListHandlerSortModel,
chips: ListHandlerChips,
search: string,
) => Promise> | ListHandlerResult);
export interface IArrayPaginatorParams<
FilterData = any,
RowData extends IRowData = any
> {
filterHandler?: (rows: RowData[], filterData: FilterData) => RowData[];
chipsHandler?: (rows: RowData[], chips: HandlerChips) => RowData[];
sortHandler?: (rows: RowData[], sort: HandlerSortModel) => RowData[];
paginationHandler?: (rows: RowData[], pagination: HandlerPagination) => RowData[];
searchHandler?: (rows: RowData[], search: string) => RowData[];
withPagination?: boolean;
withFilters?: boolean;
withChips?: boolean;
withSort?: boolean;
withTotal?: boolean;
withSearch?: boolean;
onError?: (e: Error) => void;
onLoadStart?: () => void;
onLoadEnd?: (isOk: boolean) => void;
}
export const useArrayPaginator = <
FilterData = any,
RowData extends IRowData = any
>(
rowsHandler: ArrayPaginatorHandler, {
filterHandler = (rows, filterData) => {
Object.entries(filterData).forEach(([key, value]) => {
if (value) {
const templateValue = String(value).toLocaleLowerCase();
rows = rows.filter((row) => {
const rowValue = String(row[key as keyof RowData])
.toLowerCase();
return rowValue.includes(templateValue);
});
}
});
return rows;
},
chipsHandler = (rows, chips) => {
if (!Object.values(chips).reduce((acm, cur) => acm || cur, false)) {
return rows;
}
const tmp: RowData[][] = [];
Object.entries(chips).forEach(([chip, enabled]) => {
if (enabled) {
tmp.push(rows.filter((row) => row[chip]));
}
});
return tmp.flat();
},
sortHandler = (rows, sort) => {
sort.forEach(({
field,
sort,
}) => {
rows = rows.sort((a, b) => {
if (sort === 'asc') {
return compareFn(a[field], b[field]);
} else if (sort === 'desc') {
return compareFn(b[field], a[field]);
}
});
});
return rows;
},
searchHandler = (rows, search) => {
if (rows.length > 0 && search) {
return rows.filter((row) => {
return String(row["title"]).toLowerCase()
.includes(search.toLowerCase());
});
} else {
return rows;
}
},
paginationHandler = (rows, {
limit,
offset,
}) => {
if (rows.length > limit) {
return rows.slice(offset, limit + offset);
} else {
return rows;
}
},
withPagination = true,
withFilters = true,
withChips = true,
withSort = true,
withTotal = true,
withSearch = true,
onError,
onLoadStart,
onLoadEnd,
}: IArrayPaginatorParams = {}) => {
const resolveRows = useMemo(() => async (
filterData: FilterData,
pagination: ListHandlerPagination,
sort: ListHandlerSortModel,
chips: ListHandlerChips,
search: string,
) => {
if (typeof rowsHandler === 'function') {
return await rowsHandler(
filterData,
pagination,
sort,
chips,
search
);
} else {
return rowsHandler;
}
}, []);
const handler: Handler = useMemo(() =>
async (filterData, pagination, sort, chips, search) => {
let isOk = true;
try {
onLoadStart && onLoadStart();
const data = await resolveRows(
filterData,
pagination,
sort,
chips,
search
);
let rows = Array.isArray(data) ? data : data.rows;
if (withFilters) {
rows = filterHandler(rows.slice(0), filterData);
}
if (withChips) {
rows = chipsHandler(rows.slice(0), chips);
}
if (withSort) {
rows = sortHandler(rows.slice(0), sort);
}
if (withSearch) {
rows = searchHandler(rows.slice(0), search);
}
if (withPagination) {
rows = paginationHandler(rows.slice(0), pagination);
}
const total = Array.isArray(data)
? data.length
: (data.total || null);
return {
rows,
total: withTotal ? total : null,
};
} catch (e) {
isOk = false;
if (onError) {
onError(e as Error);
return { ...EMPTY\_RESPONSE };
} else {
throw e;
}
} finally {
onLoadEnd && onLoadEnd(isOk);
}
}, []);
return handler;
};
export default useArrayPaginator;
```
Мы можем обернуть хук `useArrayPaginator` в свой собственный, который перехватит коллбеки `onLoadStart`, `onLoadEnd`, `onError` и покажет пользователю анимацию загрузки. По аналогии легко написать `useApiPaginator`, который соберет запрос к [json:api](https://www.npmjs.com/package/nestjs-paginate).
Объявление колонок
------------------
Для того, чтобы отображать колонки, необходимо сделать конфиг. При необходимости, можно написать несколько движков отображения, с/без виртуализации, с бесконечным скроллингом или страницами, мобильной версией...
```
import { IColumn, List } from 'react-declatative';
const columns: IColumn[] = [
{
type: ColumnType.Component,
headerName: 'Avatar',
width: () => 65,
phoneOrder: 1,
minHeight: 60,
element: ({ avatar }) => (
),
},
{
type: ColumnType.Compute,
primary: true,
field: 'name',
headerName: 'Name',
width: (fullWidth) => Math.max(fullWidth \* 0.1, 135),
compute: ({ firstName, lastName }) => `${firstName} ${lastName}`,
},
...
{
type: ColumnType.Action,
headerName: 'Actions',
width: () => 50,
},
];
...
return (
);
```
Десктопное отображение гридаПримечательно, что подобный интерфейс позволяет не только задать ширину колонки так, чтобы перенос текста менял высоту строки или включал горизонтальный скроллинг, но и сделать полноценную адаптивку для списочной формы.
Мобильное отображение гридаДля каждой строки опционально можно указать меню три точки. Туда можно положить ссылку на форму элемента списка или генерацию отчета для одного элемента.
```
import { IListRowAction, List } from 'react-declatative';
const rowActions: IListRowAction[] = [
{
label: 'Export to excel',
action: 'excel-export',
isVisible: (person) => person.features.includes('excel-export'),
},
{
label: 'Remove draft',
action: 'remove-draft',
isDisabled: (person) => !person.features.includes('remove-draft'),
icon: Delete,
},
];
return (
);
```
Элементы трех точек для строки списочной формы можно отключать используя коллбек `isDisabled` и скрывать используя коллбек `isVisible` . Оба коллбека получают на вход элемент строки и возвращают `boolean | Promise`...
Действия над несколькими строками
---------------------------------
Операции, которыми используются редко можно вынести в глобальное меню "три точки" в [FAB](https://mui.com/material-ui/api/fab) в правом верхнем углу формы. Туда можно положить экспорт в Excel для выбранных нескольких элементов списка или кнопку обновления содержимого страницы.
```
import { IListAction, List } from 'react-declarative';
const actions: IListAction[] = [
{
type: ActionType.Add,
label: 'Create item'
},
{
type: ActionType.Fab,
label: 'Settings',
},
{
type: ActionType.Menu,
options: [
{
action: 'update-now',
},
{
action: 'resort-action',
},
{
action: 'excel-export',
label: 'Export to excel',
isDisabled: async (rows) => {
return rows.every(({ features }) =>
features.includes('excel-export')
);
},
},
{
action: 'disabled-action',
isDisabled: async (rows) => {
await sleep(5\_000)
return true
},
label: 'Disabled',
},
{
action: 'hidden-action',
isVisible: (rows) => false,
label: 'Hidden',
},
],
}
];
return (
);
```
Однако, если пользователь исполняет одно и то же действие часто, лучше сделать кнопку на виду для минимизации количества кликов. Дополнительно, следует оставить флажок, который позволяет применить действие ко всему списку, не выгружая со стороны backend id-шники.
```
import { IListOperation, List } from 'react-declarative';
const operations: IListOperation[] = [
{
action: 'operation-one',
label: 'Operation one',
},
{
action: 'operation-two',
label: 'Operation two',
isAvailable: async (rows, isAll) => {
console.log({ rows, isAll })
return true;
}
},
{
action: 'operation-three',
label: 'Operation three',
},
];
return (
);
```
В отличие от элементов глобального меню в трех точках такую кнопку нельзя скрыть, поэтому, сделаем коллбек `isAvailable`. Он так же возвращает `boolean | Promise`, однако, получает два параметра: выбранные элементы списка и флаг `isAll`. Позволяет не грузить с backend массив id-шников, упомянуто выше.
Обработка ввода пользователя
----------------------------
После выбора элемента контекстного меню или клика по кнопке операции, вызываются следующие коллбеки:
```
import { List } from 'react-declarative';
...
const handleAction = (action: string, rows: IPerson) => {
if (action === 'excel-export') {
...
} else if (...) {
...
};
const handleRowAction = (action: string, row: IPerson) => {
if (action === 'excel-export') {
...
} else if (...) {
...
};
const handleOperation = (action: string, rows: IPerson, isAll: boolean) => {
if (action === 'operation-one') {
...
} else if (...) {
...
};
return (
);
```
Дополнительно
-------------
Помимо глобального поиска (показывается при скрытых фильтрах) можно развернуть фильтры и указать несколько параметров. Может рендерится либо по JSON шаблону, [либо через слот](https://v4.mui.com/components/data-grid/components/#overriding-components) - передачи компонента с заранее объявленным интерфейсом пропсов через контекст.
```
import { IField, List } from 'react-declarative';
const filters: IField[] = [
{
type: FieldType.Text,
name: 'firstName',
title: 'First name',
},
{
type: FieldType.Text,
name: 'lastName',
title: 'Last name',
}
];
return (
);
```
Спасибо за внимание!
--------------------
Когда начинаешь подобную задачу, не знаешь с чего начать. Надеюсь, эти заметки будут вам полезны). | https://habr.com/ru/post/677070/ | null | ru | null |
# Книга «Глубокое обучение с fastai и PyTorch: минимум формул, минимум кода, максимум эффективности»
[](https://habr.com/ru/company/piter/blog/674960/) Привет, Хаброжители! Обычно на глубокое обучение смотрят с ужасом, считая, что только доктор математических наук или ботан, работающий в крутой айтишной корпорации, могут разобраться в этой теме. Отбросьте стереотипы: любой программист, знакомый с Python, может добиться впечатляющих результатов. Как? С помощью fastai — библиотеки, предоставляющей комфортный интерфейс для решения наиболее популярных задач. Создатели fastai доказали, что самые модные и актуальные приложения можно делать быстро и не засыпать над скучными теоретическими выкладками и зубодробительными формулами.
**Для кого эта книга**
Если вы новичок в области глубокого и машинного обучения, эта книга для вас. Но желательно уметь писать код на Python.
Если вы уверенно себя чувствуете в глубоком обучении, то все равно найдете в книге много полезного. Мы покажем, как добиваться высоких результатов, и познакомим вас с новейшими передовыми техниками. Вы увидите, что для этого не требуется глубокое знание математики. Нужны лишь здравый смысл и упорство.
**Об авторах**
**Джереми Ховард** — предприниматель, бизнес-стратег, разработчик и преподаватель. Основал исследовательский институт fast.ai, цель которого — сделать глубокое обучение максимально доступным каждому. Джереми — выдающийся ученый-исследователь Университета Сан-Франциско, член факультета в Университете сингулярности, обладатель звания молодого мирового лидера, присужденного на международном экономическом форуме.
Последняя организованная им компания Enlitic первой применила глубокое обучение в медицине и, согласно MIT Tech Review, была зачислена в топ-50 интеллектуальных компаний мира в 2015 и 2016 годах. Ранее Джереми занимал пост президента и главного научного консультанта в Kaggle, где на ведущих ролях принимал участие в международных соревнованиях по машинному обучению два года подряд. Стал основоположником двух успешных австралийских стартапов (FastMail и Optimal Decisions Group, которые были приобретены LexisNexis). До этого восемь лет занимался управленческим консультированием в компаниях McKinsey & Co и AT Kearney. Джереми инвестировал во многие стартапы, оказывал им содействие в качестве наставника и просто давал советы. Помимо этого, принимал участие во многих опенсорсных проектах.
Он частый гость известной австралийской утренней программы новостей, выступал на TED.com и выпустил учебники по науке о данных и веб-разработке.
**Сильвейн Гуггер** — инженер-исследователь в HuggingFace. Ранее в роли ученого-исследователя fast.ai работал над расширением доступности глубокого обучения путем разработки и совершенствования техник, позволяющих ускоренно обучать модели в условиях ограниченных ресурсов.
До этого на протяжении семи лет Сильвейн преподавал computer science и математику по программе CPGE во Франции. CPGE — это особый вид занятий, которые посещают отдельные студенты по завершении высшей школы для подготовки к вступительным экзаменам в ведущие инженерные и бизнес-институты. Помимо этого, Сильвейн написал несколько книг, посвященных всему преподаваемому им курсу обучения, которые были изданы Editions Dunod.
Окончил Высшую школу Нормаль (Париж, Франция), где изучал математику. Более того, Сильвейн получил в этой области степень магистра от IX Парижского университета (Орсе, Франция).
### Категориальные вложения
В таблицах некоторые столбцы могут содержать численные данные, такие как «age» (возраст), в то время как в остальных будут строчные значения, например «sex» (пол). Численные данные можно передавать модели непосредственно (при желании можно их предварительно обработать), но столбцы в другом формате необходимо сначала преобразовать в числа. Поскольку значения в этих столбцах соответствуют разным категориям, мы зачастую называем такой тип переменных категориальными. Переменные первого типа называются непрерывными.
> Термин: Непрерывные и категориальные переменные
>
> Непрерывные переменные — это численные данные, такие как «age», которые допускается передавать напрямую в модель, так как их можно складывать и умножать непосредственно. Категориальные переменные содержат ряд дискретных уровней, таких как movie ID, для которых сложение и умножение бессмысленно (даже если они сохранены в виде чисел)
В конце 2015 года на Kaggle компанией Rossman проводилось соревнование по прогнозированию продаж (https://oreil.ly/U85\_1). Участникам соревнования был предоставлен обширный набор данных по различным магазинам в Германии. Задачей же было попытаться спрогнозировать продажи в течение определенного количества дней. Основная цель — помочь компании организовать рациональное управление запасами, удовлетворяя потребительский спрос без лишней загрузки складских резервов. В официальной обучающей выборке предоставлялся большой объем информации по магазинам. Помимо прочего, участникам разрешалось использовать дополнительные данные при условии, что эти данные будут открытыми и доступными для всех участников.
Один из золотых медалистов в одном из первых известных примеров эталонной табличной модели применил глубокое обучение. Его метод задействовал намного меньше инженерии признаков, основанной на знании предметной области, чем методы других золотых медалистов. Этот подход описан в работе Entity Embeddings of Categorical Variables (https://oreil.ly/VmgoU) («Вложения категориальных переменных в виде сущностей»). В онлайн-главе на сайте книги (https://book.fast.ai/) мы показываем, как повторить его с нуля и достичь такой же точности, какая приводится в работе. В аннотации к этому труду его авторы Чен Го (Cheng Guo) и Феликс Бекхан (Felix Bekhahn) пишут:
Вложение сущностей не только уменьшает потребление памяти и ускоряет нейронные сети в сравнении с быстрым кодированием, но, что более важно, путем отображения схожих значений, близких друг к другу в пространстве вложений, оно раскрывает внутренние свойства категориальных переменных… [Это] особенно полезно для датасетов с большим количеством признаков с высокой кардинальностью, где другие методы склонны приводить к переобучению… Поскольку вложение сущностей определяет меру расстояния для категориальных переменных, его можно использовать для визуализации категориальных данных и для кластеризации данных.
Мы уже отмечали все эти моменты, когда создавали модель коллаборативной фильтрации.
Теперь же становится очевидно, что эти открытия выходят далеко за ее рамки.
В данной работе также указывается, что (как мы говорили в предыдущей главе) слой вложений в точности равнозначен размещению стандартного линейного слоя после каждого вводного слоя, закодированного быстро. Авторы для демонстрации этой равнозначности использовали схему, приведенную на рис. 9.1. Имейте в виду, что термин dense layer означает то же, что «линейный слой», а one-hot encoding layer (слои в быстрой кодировке) представляют собой вводы.
Это открытие важно, потому что мы уже знаем, как обучать линейные слои, а значит, это показывает, что с точки зрения архитектуры и алгоритма обучения слой вложений — это просто другой слой. Мы также видели это на практике в предыдущей главе, когда создавали нейронную сеть коллаборативной фильтрации, которая выглядит в точности как эта схема.
Точно так же, как мы анализировали веса вложений для оценок фильмов, авторы работы проанализировали веса вложений для их модели прогнозирования продаж. При этом они обнаружили весьма удивительный факт, который отражает их второе ключевое открытие: вложение преобразует категориальные переменные во вводы, которые являются непрерывными и в то же время несут смысл.
Изображения на рис. 9.2 отражают эти идеи. Они основаны на подходах, использованных в этой работе, а также на некоторой добавленной нами аналитике.
Слева показан график матрицы вложений для возможных значений категории State. Возможные значения категориальной переменной мы называем «уровнями» (или «категориями», или «классами»), поэтому здесь один уровень — это «Berlin», следующий — «Hamburg» и т. д. Справа приведена карта Германии. Фактические местоположения германских земель не являлись частью предоставленных данных, тем не менее модель сама выучила, где они должны находиться, взяв за основу одни только данные о продажах в магазинах.
Помните ли вы наш разговор о расстоянии между вложениями? Авторы рассматриваемой работы нарисовали график расстояний между вложениями магазинов, сопоставив их с фактическими географическими расстояниями между этими магазинами (рис. 9.3), и обнаружили таким образом очень близкое соответствие!
Мы даже пробовали отобразить на графике вложения для дней недели и месяцев, выяснив, что те дни и месяцы, которые находятся близко друг к другу в календаре, также оказались близки и во вложениях. Это показано на рис. 9.4.
В обоих этих примерах выделяется то, что мы передаем модели конкретно категориальные данные о дискретных сущностях (например, земли Германии или дни недели), после чего модель изучает вложение для этих сущностей, которое определяет непрерывное обозначение расстояния между ними. Поскольку расстояние между вложениями было выучено на основе реальных паттернов в данных, оно склонно соответствовать нашему представлению.
Помимо этого, непрерывность вложений ценна сама по себе, потому что модели лучше понимают именно непрерывные переменные. Это неудивительно, учитывая, что модели построены из множества непрерывных весов параметров и непрерывных значений активаций, которые обновляются посредством градиентного спуска (алгоритм обучения для нахождения минимумов непрерывных функций).
Еще одно преимущество в том, что мы можем легко совмещать непрерывные значения вложений с истинными непрерывными входными данными: мы просто конкатенируем эти переменные и передаем результат в первый линейный слой. Другими словами, сырые категориальные данные преобразуются слоем вложений перед тем, как он взаимодействует с сырыми непрерывными входными данными. Именно так fastai, а также Го и Бекхан обрабатывают табличные модели, содержащие непрерывные и категориальные переменные.
К примерам использования этого подхода с конкатенацией можно отнести то, как Google формирует свои рекомендации в Google Play, что объясняется в работе Wide & Deep Learning for Recommender Systems (https://oreil.ly/wsnvQ) («Широкое и глубокое обучение для рекомендательных систем»). Эта система показана на рис. 9.5.
Интересно, что команда Google совместила оба подхода, которые мы видели в предыдущей главе: скалярное произведение (которое они называют перекрестным произведением) и подходы с нейронными сетями.
Давайте сделаем небольшую паузу. До этого момента решением для всех задач моделирования было обучение модели глубокого обучения. И в самом деле, это очень хорошее правило для сложных неструктурированных данных вроде изображений, звуков, текста естественного языка и т. д. Глубокое обучение также отлично работает для коллаборативной фильтрации. Но для анализа табличных данных оно не всегда является наилучшей отправной точкой.
#### За гранью глубокого обучения
Большинство курсов по ML буквально закидывают вас десятками алгоритмов — они дают краткое объяснение стоящих за ними математических принципов и приводят игрушечный пример. Вы теряетесь и не понимаете, как именно их нужно применять.
Но мы рады сообщить, что современное машинное обучение можно сузить до двух ключевых техник, которые применимы практически повсеместно. Недавние исследования показали, что огромное множество датасетов можно наилучшим образом смоделировать с помощью всего двух методов.
— Ансамблей деревьев решений (то есть случайных лесов и градиентного бустинга), используемых в основном для структурированных данных (какие можно встретить в таблицах баз данных большинства компаний).
— Многослойных нейронных сетей, обученных с помощью SGD (то есть неглубокого и/или глубокого обучения) и используемых в основном для неструктурированных данных (аудио, изображения и естественный язык).
Несмотря на то что глубокое обучение практически всегда показывает себя лучше в отношении неструктурированных данных, эти два подхода склонны давать схожие результаты для многих видов структурированных данных. Тем не менее ансамбли деревьев решений, как правило, обучаются быстрее, зачастую легче интерпретируются, не нуждаются в специальном GPU-оборудовании и обычно требуют меньше настроек гиперпараметров. К тому же популярность они завоевали намного раньше техник глубокого обучения, поэтому имеют более зрелую экосистему инструментов и документации.
Более существен тот факт, что важнейший этап процесса, а именно интерпретация модели табличных данных, в ансамблях деревьев решений намного проще. Для этого существуют инструменты и методы, позволяющие получать ответы на актуальные вопросы: какие столбцы датасета оказались наиболее важными для прогнозов? Как они связаны с зависимыми переменными? Как они взаимодействуют друг с другом? Какие конкретные признаки были наиболее важны для конкретных наблюдений?
Следовательно, ансамбли деревьев решений — это наш первый подход для анализа нового табличного датасета.
Исключением из этого правила будут случаи, когда датасет отвечает одному из следующих условий.
— Наличие важных категориальных переменных с высокой кардинальностью (кардинальность подразумевает число дискретных уровней, представляющих категории, то есть категориальная переменная с высокой кардинальностью — это нечто вроде почтового индекса, который может иметь тысячи возможных уровней).
— Присутствуют столбцы, содержащие данные, которые будет легче понять с помощью нейронной сети, например простой текст.
На практике, когда мы имеем дело с датасетами, отвечающими этим условиям, то всегда пробуем и метод ансамблей деревьев решений, и глубокое обучение, проверяя, какой сработает лучше. Глубокое обучение наверняка окажется более полезным в нашем примере совместной фильтрации, так как в нем есть не менее двух категориальных переменных с высокой кардинальностью: пользователи и фильмы. Но на практике все выходит не столь однозначно, и зачастую будет присутствовать смесь из категориальных переменных как с высокой, так и с низкой кардинальностью вместе с непрерывными переменными.
Так или иначе очевидно, что нам нужно добавить в наш арсенал моделирования ансамбли деревьев решений.
До этого момента мы использовали PyTorch и fastai почти для всех сложных задач. Но эти библиотеки главным образом спроектированы для алгоритмов, которые выполняют много операций матричного умножения и получения производных (как раз то, что относится к глубокому обучению). Деревья решений на эти операции совсем не опираются, поэтому PyTorch здесь не особо пригодится.
Вместо этого мы будем в основном опираться на библиотеку под названием scikit-learn (также известную как sklearn). Scikit-learn — это популярная библиотека для создания моделей ML, использующая подходы, не относящиеся к глубокому обучению. Дополнительно нам понадобится выполнять обработку табличных данных и запросы, для чего мы используем библиотеку Pandas. И наконец, нам также потребуется NumPy, так как это основная числовая библиотека программирования, на которую опирается и sklearn, и Pandas.
У нас не хватает времени на подробное знакомство со всеми этими библиотеками, поэтому мы просто будем затрагивать самые основные элементы каждой из них. Для более подробного ознакомления мы настоятельно рекомендуем книгу Уэса Маккинни (Wes McKinney) Python for Data Analysis (http://shop.oreilly.com/product/0636920050896.do) («Python для аналитики данных») (O’Reilly). Маккинни является создателем Pandas, так что вы можете быть уверены в точности изложенной в его книге информации.
Перейдем к сбору нужных данных.
#### Датасет
Датасет, который мы будем использовать в этой главе, взят из соревнования Kaggle по созданию справочника цен (Голубой книги) на подержанные бульдозеры. Целью соревнования было спрогнозировать стоимость продажи конкретной единицы спецтехники на аукционе, исходя из ее износа, типа и комплектации. Представленные для рассмотрения данные взяты из опубликованных результатов аукционов и включают в себя информацию о состоянии спецтехники, а также ее комплектации.
Это очень распространенный тип датасета и задачи прогнозирования, аналогичные которым вы можете встретить и в своем проекте или организации. Рассматриваемый набор данных доступен для загрузки на Kaggle, сайте, проводящем соревнования в области data science.
#### Соревнования Kaggle
Kaggle — это замечательный ресурс для целеустремленных специалистов по данным и всех тех, кто ищет возможность отточить свои навыки в машинном обучении. Ничто так не поможет повысить мастерство, как решение практических задач с одновременным получением обратной связи.
Kaggle предоставляет:
— интересные датасеты;
— обратную связь по вашим результатам;
— таблицу лидеров, по которой можно оценить хорошие результаты: достижимые и топовый эталонный уровень;
— публикации в блоге от победителей соревнований, дающих полезные советы и рассказывающих об эффективных техниках.
До сих пор все наши датасеты были доступны для скачивания через интегрированную систему датасетов fastai. Текущий набор данных доступен только на Kaggle. Поэтому вам понадобится зарегистрироваться на их сайте, перейти на страницу соревнования (https://oreil.ly/B9wfd), щелкнуть на Rules, а затем на I Understand and Accept. (Несмотря на то что данное соревнование завершилось и участвовать вы в нем не будете, вам все равно нужно принять правила для получения доступа к загрузке данных.)
Самый простой способ скачивания датасетов Kaggle — это использовать Kaggle API. Вы можете установить его с помощью команды pip, выполнив в ячейке блокнота следующую инструкцию:
```
!pip install kaggle
```
Для использования API Kaggle вам понадобится ключ API, который можно получить, щелкнув на картинке профиля на сайте, выбрав My Account, а затем щелкнув на Create New API Token, — в результате на ваш ПК будет сохранен файл kaggle.json. Далее нужно скопировать этот ключ на GPU-сервер. Для этого откройте скачанный файл, скопируйте содержимое и вставьте его в одиночные кавычки в следующей ячейке блокнота этой главы (например, creds = '{«username»:«xxx»,«key»:«xxx»}'):
```
creds = ''
```
Затем выполните эту ячейку (выполнение потребуется только один раз):
```
cred_path = Path('~/.kaggle/kaggle.json').expanduser()
if not cred_path.exists():
cred_path.parent.mkdir(exist_ok=True)
cred_path.write(creds)
cred_path.chmod(0o600)
```
Теперь вы можете скачивать датасеты, для этого осталось только выбрать нужный путь их сохранения:
```
path = URLs.path('bluebook')
path
Path('/home/sgugger/.fastai/archive/bluebook')
```
После чего можете использовать Kaggle API для скачивания и распаковки датасета:
```
if not path.exists():
path.mkdir()
api.competition_download_cli('bluebook-for-bulldozers', path=path)
file_extract(path/'bluebook-for-bulldozers.zip')
path.ls(file_type='text')
(#7) [Path('Valid.csv'),Path('Machine_Appendix.csv'),Path('ValidSolution.csv'),Path('TrainAndValid.csv'),Path('random_forest_benchmark_test.csv'),Path('Test.csv'),Path('median_benchmark.csv')]
```
Теперь, когда мы загрузили датасет, изучим его!
#### Знакомство с данными
На странице Data (https://oreil.ly/oSrBi) сайта Kaggle дается общая информация по датасету и указывается, что основные его поля, расположенные в train.csv, это:
— SalesID — уникальный идентификатор продажи;
— MachineID — уникальный идентификатор машины. Машина может быть продана несколько раз;
— saleprice — цена, по которой машина ушла с аукциона (указано только в train.csv);
— saledate — дата продажи.
При любом виде работы, связанной с исследованием данных, важно непосредственно изучить эти данные, убедившись, что вы понимаете их формат, как они сохранены, какие типы значений содержат и т. д. Имейте в виду, что даже если вы прочли описание, фактические данные могут оказаться не такими, как вы ожидаете. Мы начнем с чтения обучающей выборки в Pandas DataFrame. Обычно рекомендуется сразу установить параметр low\_memory=False и не менять его до тех пор, пока Pandas реально не исчерпает ресурс памяти и не выдаст ошибку. Этот параметр, который по умолчанию установлен как True, дает Pandas команду при определении типа данных каждого столбца просматривать только несколько его строк за раз. Это может привести к тому, что Pandas в разных строках будет использовать разные типы данных, что, в свою очередь, приведет либо к ошибкам обработки данных, либо к последующим проблемам при обучении модели.
Загрузим наши данные и взглянем на столбцы:
```
df = pd.read_csv(path/'TrainAndValid.csv', low_memory=False)
df.columns
Index(['SalesID', 'SalePrice', 'MachineID', 'ModelID', 'datasource',
'auctioneerID', 'YearMade', 'MachineHoursCurrentMeter', 'UsageBand',
'saledate', 'fiModelDesc', 'fiBaseModel', 'fiSecondaryDesc',
'fiModelSeries', 'fiModelDescriptor', 'ProductSize',
'fiProductClassDesc', 'state', 'ProductGroup', 'ProductGroupDesc',
'Drive_System', 'Enclosure', 'Forks', 'Pad_Type', 'Ride_Control',
'Stick', 'Transmission', 'Turbocharged', 'Blade_Extension',
'Blade_Width', 'Enclosure_Type', 'Engine_Horsepower', 'Hydraulics',
'Pushblock', 'Ripper', 'Scarifier', 'Tip_Control', 'Tire_Size',
'Coupler', 'Coupler_System', 'Grouser_Tracks', 'Hydraulics_Flow',
'Track_Type', 'Undercarriage_Pad_Width', 'Stick_Length', 'Thumb',
'Pattern_Changer', 'Grouser_Type', 'Backhoe_Mounting', 'Blade_Type',
'Travel_Controls', 'Differential_Type', 'Steering_Controls'],
dtype='object')
```
Многовато столбцов! Лучше просмотреть весь датасет, чтобы понять, какая информация находится в каждом из них. Вскоре мы увидим, как «сосредоточиться» на самых интересных.
Правильным будет начать с обработки порядковых столбцов. Порядковые столбцы — это те, которые содержат строки или аналогичные данные, имеющие естественный порядок. Например, вот уровни ProductSize:
```
df['ProductSize'].unique()
array([nan, 'Medium', 'Small', 'Large / Medium', 'Mini', 'Large', 'Compact'],
dtype=object)
```
О подходящем порядке этих уровней можно сообщить Pandas так:
```
sizes = 'Large','Large / Medium','Medium','Small','Mini','Compact'
df['ProductSize'] = df['ProductSize'].astype('category')
df['ProductSize'].cat.set_categories(sizes, ordered=True, inplace=True)
```
Самым важным столбцом данных является зависимая переменная: та, которую мы будем прогнозировать. Вспомните, что метрика модели — это функция, отражающая качество прогнозов. Само собой разумеется, что ее выбор является значительной частью настройки проекта. Во многих случаях выбор удачной метрики станет больше напоминать процесс проектирования — будет недостаточно подобрать уже существующую переменную. Вам нужно внимательно подумать о том, какая метрика или набор метрик реально измеряют важный для вас показатель эффективности модели. Если эту метрику не представляет никакая переменная, то следует оценить возможность ее создания из доступных переменных.
Как бы то ни было, но в данном случае выбор метрики уже предписан Kaggle: мы берем среднеквадратичную логарифмическую ошибку (RMLSE) между фактическими и спрогнозированными ценами аукциона. Вычисляется же она достаточно простым способом: мы получаем логарифм цен, для значения которого m\_rmse и дает нам то, что в итоге нужно:
```
dep_var = 'SalePrice'
df[dep_var] = np.log(df[dep_var])
```
Теперь мы подготовились к изучению нашего первого алгоритма машинного обучения для табличных данных: деревьев решений.
Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/product/glubokoe-obuchenie-s-fastai-i-pytorch-minimum-formul-minimum-koda-maksimum-effektivnosti?_gs_cttl=120&gs_direct_link=1&gsaid=42817&gsmid=29789&gstid=c):
» [Оглавление](https://www.piter.com/product/glubokoe-obuchenie-s-fastai-i-pytorch-minimum-formul-minimum-koda-maksimum-effektivnosti#Oglavlenie-1)
» [Отрывок](https://www.piter.com/product/glubokoe-obuchenie-s-fastai-i-pytorch-minimum-formul-minimum-koda-maksimum-effektivnosti#Otryvok-1)
По факту оплаты бумажной версии книги на e-mail высылается электронная книга.
Для Хаброжителей скидка 30% по купону — **PyTorch** | https://habr.com/ru/post/674960/ | null | ru | null |
# Когда исчезнут JavaScript-фреймворки?
Автор материала, перевод которого мы сегодня публикуем, веб-разработчик, говорит, что он старается регулярно пересматривать набор инструментов, которыми пользуется. Делает он это для того, чтобы понять, может ли он без некоторых из них обойтись, решая свои обычные задачи. Недавно он решил провести эксперимент и создать сложное фронтенд-приложение без использования JavaScript-фреймворков.
[](https://habr.com/ru/company/ruvds/blog/439824/)Что такое «фреймворк»?
----------------------
Если попытаться дать определение JavaScript-фреймворка, не вдаваясь в детали, то окажется, что это — инструмент, который можно использовать для разработки сложных веб-приложений, в частности — одностраничных приложений (Single Page Application, SPA).
В былые времена такие приложения создавали, полагаясь на возможности чистого JavaScript и библиотеки jQuery. Но, с ростом сложности фронтенд-приложений, начали появляться и соответствующие инструменты, облегчающие жизнь программистов. Например — это React, Angular и Vue.
Фреймворки, которые популярны в наши дни, обладают некоторыми схожими общими чертами. Так, большинство фронтенд-фреймворков и библиотек, условно говоря, от Vue до React, дают в распоряжение разработчика некую комбинацию следующих возможностей:
* Синхронизация состояния и визуального представления приложения.
* Маршрутизация.
* Система шаблонов.
* Компоненты, подходящие для повторного использования.
Необходимы ли фреймворки современному разработчику?
---------------------------------------------------
Ответ на вопрос, вынесенный в заголовок этого раздела, зависит от того, как относиться к идее «необходимости» фреймворков. Уверен, многие могут сказать о том, что фронтенд-фреймворки не являются необходимыми в наборе инструментов веб-разработчика, и никогда необходимыми не были. Хотя бесспорно то, что это — весьма полезные инструменты.
Собственно говоря, наш вопрос можно переформулировать так: «Являются ли фреймворки чем-то вроде «современной библиотеки jQuery»? Можно ли решать задачи, на решение которых они направлены, другими средствами, например такими, которые появились в распоряжении программистов в ходе развития браузерных API»?
*jQuery*
На самом деле, на этот вопрос ответить непросто, но можно сказать, что развитие JavaScript, технологий работы с веб-компонентами и инструментов для сборки проектов сделало разработку SPA без использования фреймворков простой как никогда.
Для того чтобы исследовать эту идею, я разработал одностраничное приложение, используя только JavaScript, стандартные веб-компоненты и бандлер Parcel. В процессе работы я столкнулся с некоторыми проблемами и сложностями, глядя на которые особенно чётко начинаешь видеть сильные стороны современных JS-фреймворков.
В то же время, как только я справился с первоначальными препятствиями, я удивился тому, как легко создать одностраничное приложение на чистом JavaScript.
Обзор экспериментального приложения
-----------------------------------
Приложение, о котором идёт речь, устроено довольно просто. Оно представляет собой электронный сборник рецептов и позволяет пользователю создавать, просматривать и редактировать рецепты. Пользователь, кроме того, может отмечать рецепты, указывая на то, что они ему нравятся, а также может фильтровать и удалять записи.
*Домашняя страница приложения*
*Страница создания записи о рецепте*
Веб-компоненты
--------------
Создание веб-компонентов — занятие несложное. В частности, речь идёт о создании класса, расширяющего `HTMLElement` (или `HTMLParagraphElement`, и так далее) и о последующем использовании этого класса для описания собственного элемента.
Кроме того, при работе с веб-компонентами можно использовать хуки их жизненного цикла, такие, как `connectedCallback`, `disconnectedCallback`, `attributeChangedCallback`.
Вот код компонента `recipe-item`, который предназначен для вывода рецептов в списке.
```
import template from './recipe.html'
import DATA_SERVICE from '../../utils/data'
export default class Recipe extends HTMLElement {
constructor () {
// подключаем теневую DOM, инициализируем приватное свойство recipe и DATA_SERVICE()
super()
this._shadowRoot = this.attachShadow({ mode: 'open' })
this._recipe = null
this.ds = new DATA_SERVICE()
}
connectedCallback () {
// устанавливаем в качестве html-содержимого импортированный шаблон
this._shadowRoot.innerHTML = template
// прикрепляем метод delete к соответствующей кнопке
this._shadowRoot
.querySelector('.delete')
.addEventListener('click', () => this._delete())
}
_render (title) {
// задаём заголовок рецепта и текст кнопки, позволяющей отметить рецепт
this._shadowRoot.querySelector('.recipe-title').innerHTML = title
this._shadowRoot.querySelector('.favorite').innerHTML = this._recipe
.favorite
? 'Unfavorite'
: 'Favorite'
}
_delete () {
// удаление рецепта или вывод сообщения об ошибке
try {
await this.ds.deleteRecipe(this._recipe.id)
} catch (e) {
console.error(e)
alert(
'Sorry, there was a problem deleting the recipe. Please, try again.'
)
}
}
get recipe () {
// геттер для рецепта
return this._recipe
}
set recipe (recipe = {}) {
// сеттер для рецепта, вызывающий метод render
this._recipe = recipe
this._render(this._recipe.title)
}
}
window.customElements.define('recipe-item', Recipe)
```
Маршрутизация
-------------
Схема маршрутизации этого приложения также довольно проста. При возникновении события, имеющего отношение к навигации, приложение выводит соответствующий компонент.
Изначально я, для организации навигации в приложении, использовал npm-пакет Vanilla JS Router. Но, с использованием [API History](https://developer.mozilla.org/en-US/docs/Web/API/History), совсем несложно реализовать собственный маршрутизатор, на который придётся что-то около 100 строк кода. Обратите внимание на то, что в этом примере не реализовано что-то действительно сложное, наподобие средств ограничения доступа к определённым маршрутам (route guard).
```
import './components/error/error'
import content404 from './components/404/404.html'
import DATA_SERVICE from './utils/data'
const ds = new DATA_SERVICE()
// получаем элемент, содержащий SPA
const $el = document.getElementById('app')
// объявляем маршруты
const home = async () => {
await import('./components/recipe/recipe')
await import('./components/recipe-list/recipe-list')
await import('./components/modal/modal.js')
$el.innerHTML = ``
}
const create = async () => {
await import('./components/create-recipe/create-recipe')
$el.innerHTML = ``
}
const edit = async () => {
await import('./components/edit-recipe/edit-recipe')
$el.innerHTML = ``
}
const error404 = async () => {
$el.innerHTML = content404
}
// установление соответствия маршрутов и путей
// получение рецепта по id для создания маршрута редактирования рецепта
const routes = {
'/': home,
'/create': create,
'/error': error404,
'/edit': async function (params) {
const id = params.get('id')
const recipe = await ds.getRecipe(id)
await edit()
$el.querySelector('edit-recipe').recipe = recipe
}
}
// по событию onpopstate получить параметры из URL и передать их маршруту
// если нужного маршрута найти не удаётся - использовать маршрут /error
window.onpopstate = async () => {
const url = new URL(
window.location.pathname + window.location.search,
window.location.origin
)
if (routes[window.location.pathname]) {
await routes[window.location.pathname](url.searchParams)
} else routes['/error']()
}
// добавление маршрута в историю браузера
let onNavItemClick = async pathName => {
const url = new URL(pathName, window.location.origin)
const params = url.searchParams
if (routes[url.pathname]) {
window.history.pushState({}, pathName, window.location.origin + pathName)
await routes[url.pathname](params)
} else {
window.history.pushState({}, '404', window.location.origin + '/404')
routes['/error']()
}
}
// установка подходящего маршрута при загрузке и перезагрузке страницы
;(async () => {
const url = new URL(
window.location.pathname + window.location.search,
window.location.origin
)
if (routes[window.location.pathname]) {
await routes[window.location.pathname](url.searchParams)
} else routes['/error']()
})()
// экспорт маршрутов и метода onNavItemClick()
const router = {
onNavItemClick,
routes
}
export { router }
```
Здесь приведён краткий обзор основных строительных блоков приложения, так как его полное описание нам тут не требуется. На самом деле, в нём реализованы, помимо описанных возможностей, и другие — вроде бесконечного скроллинга и интерфейса для загрузки картинок на сайт путём их перетаскивания в соответствующее место страницы.
Сравнение разработки с использованием JS и фреймворков
------------------------------------------------------
После того, как приложение было создано, я немного поразмыслил над сильными и слабыми сторонами использованного при его разработке подхода. Предлагаю их рассмотреть, начав с минусов отказа от JS-фреймворков.
Минусы отказа от фреймворков
----------------------------
### ▍Проблемы стандартизации
Спецификации веб-компонентов, с одной стороны, существуют уже довольно давно, а с другой, всё ещё развиваются. Так, веб-компоненты были [представлены Алексом Расселом](https://en.wikipedia.org/wiki/Web_Components#cite_note-16) на мероприятии Fronteers Conference 2011. Однако серьёзная работа в направлении их поддержки и развития ведётся только в последние год или два. В результате в спецификациях всё ещё царит беспорядок. Например, технология HTML-импортов уже [неактуальна](https://caniuse.com/#feat=imports), хотя о ней пишут в документации и в различных публикациях.
### ▍Тестирование
Имеется не особенно много решений для тестирования стандартных веб-компонентов. Так, существуют некоторые многообещающие инструменты — вроде [skatejs ssr](https://github.com/skatejs/skatejs/tree/master/packages/ssr) или [web-component-tester](https://github.com/Polymer/tools/tree/master/packages/web-component-tester). Но эти инструменты предназначены для применения с соответствующими библиотеками. В результате у того, кто хочет пользоваться веб-компонентами, возникают определённые сложности.
### ▍Синхронизация интерфейса и состояния приложения
*Конструкции querySelector()*
При разработке веб-приложений очень важно, чтобы в распоряжении программиста была бы некая базовая система, автоматически синхронизирующая данные и их представление на странице. Именно такие системы и привлекают многих к Angular и к другим фреймворкам.
Если речь идёт о небольших проектах, то синхронизация состояния приложения с его визуальным представлением — задача не особенно сложная. Но в ходе роста проекта синхронизация способна быстро превратиться в проблему, разработчику, для поддержки приложения в работоспособном состоянии, придётся добавлять в него множество прослушивателей событий и команд выбора элементов.
### ▍Технология Shadow DOM
Я всё ещё сомневаюсь в технологии Shadow DOM. С одной стороны мне нравится идея инкапсуляции. Это — адекватный паттерн проектирования, упрощающий управление стилями и облегчающий работу программиста. Но, с другой стороны, его использование сопряжено со сложностями, в том случае, если нужно, чтобы что-то выходило бы за границы инкапсулированных сущностей. Например, это касается применения общих стилей. Вопрос о том, как их использовать правильно, всё ещё [открыт](https://www.smashingmagazine.com/2016/12/styling-web-components-using-a-shared-style-sheet/).
### ▍Работа с DOM
Фреймворки и библиотеки вроде Angular и React отчасти обязаны своей притягательностью тем, что они значительно упрощают работу с DOM. А именно, они отлично показывают себя при выводе и обновлении элементов. Вот что говорится об этом в [блоге Angular University](https://blog.angular-university.io/why-angular-angular-vs-jquery-a-beginner-friendly-explanation-on-the-advantages-of-angular-and-mvc/): «Angular напрямую генерирует структуры данных DOM, а не работает, создавая HTML-код и потом передавая его браузеру для последующей обработки».
Angular, например, в отличие от jQuery, напрямую генерирует структуры данных DOM. Делается это вместо того, чтобы передавать браузеру HTML-код, который, перед попаданием в DOM, должен быть разобран. Такой подход отличается более высокой производительностью, так как благодаря его использованию устраняется шаг разбора HTML-кода. Технология Virtual DOM также весьма полезна, так как она позволяет отказаться от повторного рендеринга всего содержимого страницы, выполняемого каждый раз при обновлении неких элементов.
Минусы отказа от фреймворков в пользу обычного JS мы рассмотрели. Теперь поговорим о плюсах.
Плюсы отказа от фреймворков
---------------------------
### ▍Размеры пакетов приложений
Пакет готового веб-приложения, разработанного на чистом JS, может оказаться (обратите внимание на слово «может») гораздо меньше, чем пакет аналогичного приложения, созданного с применением фреймворков. Например, пакет нашего готового экспериментального приложения, реализующего множество возможностей, в три раза меньше чем пакет пустого Angular-приложения.
*Пакет пустого Angular-приложения*
*Пакет приложения, разработанного без использования фреймворков*
### ▍Использование фреймворков и понимание технологий
Если вы разрабатывали веб-приложения исключительно с использованием неких фреймворков и их CLI, для того, чтобы создать приложение без вспомогательных инструментов, вам придётся очень постараться. Создание проектов без фреймворков позволяет изучить базовые технологии, инструменты и паттерны проектирования, которые лежат в основе современной веб-разработки. Эти знания, в любом случае, будете ли вы, приобретя их, пользоваться фреймворками, или не будете, окажутся полезными.
### ▍Производительность
То, что делается в недрах фреймворков и библиотек, позволяет получать замечательные результаты. Но за всё надо платить. В данном случае цена удобства — производительность. При этом, с ростом размера приложения, основанного на некоем фреймворке, может расти и нагрузка на систему, создаваемая вспомогательными механизмами, отвечающими за работу такого приложения. Систему нагружают ненужные операции по обновлению страниц, избыточные прослушиватели событий, глубокое сравнение объектов, без которого можно обойтись, неоправданно масштабные манипуляции с DOM. Избавиться от всего этого можно просто сделав всё своими силами.
Тут хочется отметить, что команды разработчиков React и Angular, очевидно, знают о подобных проблемах. Поэтому они уделяют немалое внимание оптимизации своих проектов. Например, речь идёт о чём-то вроде использования в React метода `shouldUpdate()` или о стратегии обнаружения изменений `onPush` в Angular.
### ▍Простота решений и проблема использования чужого кода
Использование в собственных проектах чужого кода — это всегда риск. Если речь идёт о хорошо протестированных и многократно испытанных на практике фреймворках, то этот риск снижается. Но он существует всегда. Если вы можете позволить себе писать код самостоятельно, идёт ли речь о независимом программисте, или о команде, вы можете снизить этот риск. К тому же, так вы будете превосходно ориентироваться в коде собственных проектов.
Некоторые заметки и интересные наблюдения
-----------------------------------------
Мне очень понравилось работать с Parcel. Когда я искал выходы из сложных ситуаций, я чувствовал себя ограниченным немного сильнее, чем при работе с Webpack, но я выяснил, что, по большей части, [заявление](https://parceljs.org/) о том, что Parcel не нуждается в настройке, отражает истинное положение дел.
Ранее я был склонен считать React, Vue и Angular средствами для решения одних и тех же задач. Поэтому я называл их все «фреймворками». Однако теперь мне ясно, почему React правильнее называть «библиотекой», а Vue — «прогрессивным фреймворком».
Почему я не воспользовался Stencil или Polymer? Дело в том, что я, при работе над рассматриваемым здесь проектом, стремился к тому, чтобы не использовать какие-либо пакеты, библиотеки или фреймворки. Правда, это не относится к средствам сборки проектов. Мне хотелось на собственном опыте увидеть то, что способны предложить современному разработчику чистые веб-стандарты.
Я уверен, что существует множество подходов к разработке SPA или фронтенд-приложений без использования фреймворков или библиотек. Здесь я рассказал о том, как испробовал один из них, но он ни в коем случае не ограничивает возможности тех, кто хочет создавать приложения с минимальным использованием чужого кода.
Базовые технологии или фреймворки?
----------------------------------
В деле принятия решения о том, нужен или нет в некоем проекте какой-нибудь фреймворк, можно применить один отличный способ, который я называю «метод переломного момента». Речь идёт о том, что, в ходе роста и развития приложения, наступает момент, когда разработчик обнаруживает себя создающим собственный фреймворк, направленный на то, чтобы обеспечить возможность повторного использования неких функциональных возможностей и структур. Например, такое может произойти в том случае, если у вас имеется множество форм, и вы хотите создать код для их реактивной проверки, подходящий для повторного использования.
Если ваш проект дорос до такого уровня, то вам нужно будет решить — стоит ли вкладывать время в создание системы, реализующей те же возможности, что и некий фреймворк или некая библиотека. Такие вот «переломные моменты» могут возникать на разных этапах жизни проекта. Это зависит от количества времени, которое есть у программиста или команды, и от объёма финансирования разработки. Но надо отметить, что фреймворки, если применять их правильно и уместно, отлично показывают себя в деле разработки веб-проектов.
Таким образом, можно говорить о том, что, с течением времени, большую часть того, что делают с помощью фреймворков, вероятно, легче будет сделать с помощью более мелких библиотек или вообще без вспомогательных инструментов. Например — взгляните на моё приложение. В то же время, если большие фреймворки смогут гибко реагировать на происходящее, они смогут измениться, адаптироваться и не потерять актуальности в будущем. Если нет — то они, с развитием базовых веб-технологий, могут, как сегодня jQuery, лишиться большей части своей привлекательности.
Итоги
-----
В итоге можно сказать, что современному веб-разработчику доступен многообещающий подход к созданию сложных приложений без использования фреймворков. Однако спецификации технологий наподобие веб-компонентов всё ещё находятся в процессе развития, и для их серьёзного практического применения нужно ещё кое с чем разобраться. При этом фреймворки всё ещё представляют собой системы, обладающие множеством замечательных возможностей, которые могут сделать разработку веб-приложений гораздо более стабильным процессом, нежели разработка без их использования.
Сегодня плюсы использования фреймворков в веб-разработке часто перевешивают их недостатки. Однако если фреймворки не начнут решать новые проблемы и не будут продолжать эволюционировать, они, в конце концов, имеют все шансы стать достоянием прошлого.
**Уважаемые читатели!** Разрабатывали ли вы веб-приложения, стремясь к минимальному использованию чужого кода? | https://habr.com/ru/post/439824/ | null | ru | null |
# Рендеринг изоповерхностей с использованием алгоритма рейкастинга
В данной статье хочу рассказать вам про Isosurface rendering или рендеринг изоповерхностей.
По долгу работы я постоянно использую документацию лишь на английском или немецком языке. Поэтому в тексте я буду часто использовать для всяких терминов английский вариант слова.
Итак, что такое [Isosurface](http://en.wikipedia.org/wiki/Isosurface) — это, как говорит нам Википедия, 3х-мерный вариант изолинии, которая в свою очередь «представляет собой линию, в каждой точке которой измеряемая величина сохраняет одинаковое значение». На словах это может быть не совсем понятно — посмотрим лучше на картинки.
 
На данных изображениях показаны поверхности с разным значением «измеряемое величины» — плотности (density). На первом значение меньше, чем на втором.
Для начала краткая теория.
Я занимаюсь обработкой медицинских изображений. Данные, получаемые из медицинских аппаратов в основном содержат так называемое raw или grayscale изображение — от 8 бит (256 оттенков) до 16 бит (65536 оттенков серого цвета). Так как на деле 16 бит — это очень много, часто используется сокращенный вариант — 12 бит, то есть используется часть от старшего байта, это дает нам 4096 оттенков серого цвета.
Далее для преобразования серого изображения в цветное можно использовать так называемые LUT — look up table. Эта таблица представляет собой набор строк, каждая из которых содержит RGBA значение. Для 12 бит эта таблица содержит 4096 строк. И когда мы встречаем воксель со значением, например, 542, мы соответственно берем из 542 строки этой таблицы указанные там значения RGBA.
Данные таблицы составляются квалифицированными медиками/инженерами, которые знают как коррелировать значение плотности с RGBA. Использование альфа-канала, то есть прозрачности, позволяет создать таблицы, применение которых позволит нам отобразить только кости, или только вены, или артерии — остальное будет прозрачным. То есть, меняя на лету LUT, мы получаем каждый раз новое отображение одного и того же объекта.
Основным способом рендеринга данных изображений является [Volume ray casting](http://en.wikipedia.org/wiki/Volume_ray_casting) (что-то похожее на русском — [Объемный рендеринг](http://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%8A%D1%91%D0%BC%D0%BD%D1%8B%D0%B9_%D1%80%D0%B5%D0%BD%D0%B4%D0%B5%D1%80%D0%B8%D0%BD%D0%B3)). Слишком подробно его я тут описывать не буду. Но понимание его работы нам важно для понимания процесса рендеринга изоповерхностей.
Алгоритм ray casting состоит в том, что мы лучами пронизываем наш объект. Луч исходит из нашего глаза (камеры), проходит через каждую точку экрана (каждый пиксель), и пересекается с нашим объектом в определенном вокселе (если есть пересечение). На этом луч не останавливается, а идет дальше, пересекая дальнейшие воксели и определенным образом аккумулируя информацию из каждой точки. Критериев остановки луча может быть несколько, наиболее распространенный — когда альфа аккумулируемого значения близко к 1 (на практике используется значение a>0.95), либо, например, если мы вышли за границы изображения. То есть по сути во время трейсинга мы отбрасываем прозрачные воксели и определенным образом акумулируем значения полупрозрачных, пока не дойдем до цельного объекта, который дальше не пропускает наш луч в силу своей непрозрачности. Полученное в результате значение и используется для отрисовки на экране.
Возвращаясь в основной теме, хочу сказать, что рендеринг изоповерхностей отличается главным образом точкой останова. В нашем случае, как только мы находим воксель со значением, которое больше или равно изначально заданному значению плотности, мы прекращаем ray casting для текущего луча и переходим к следующему. Так как во всех точках значения должны быть равными, все изоповерхности рисуются обычно одинаково закрашенными. Одно значение — соответственно один цвет.
Данный алгоритм можно реализовать на CPU (и в принципе первые реализации были именно такие), но работать он будет очень медленно. Намного быстрее обрабатывается все на GPU с использованием фрагментного [шейдера](http://ru.wikipedia.org/wiki/%D0%A8%D0%B5%D0%B9%D0%B4%D0%B5%D1%80) ([GLSL](http://en.wikipedia.org/wiki/OpenGL_Shading_Language)). Необходимые параметры передаются извне — граничное значение, цвет, скорость прохода и т.д. Ниже представлен код самого простого фрагментного шейдера, который рендерит изоповерхность. Так как для изоповерхности не важны все предыдущие или последующие воксели, здесь происходит не аккумулирование значений, а просто используется только одно граничное значение цвета — isoColor.
> `1.
> 2. **uniform** **sampler3D** volume;
> 3. **uniform** **float** sampleRate;
> 4. **uniform** **float** isoValue;
> 5. **uniform** **vec4** isoColor;
> 6.
> 7. **varying** **vec4** texCoord0;
> 8.
> 9. **void** main()
> 10. {
> 11. floast steps = 1.0 / sampleRate;
> 12. **vec4** outputColor = **vec4**(0.,0.,0.,0.);
> 13. **float** isoThr;
> 14.
> 15. *// get ray position and ray direction*
> 16. **vec4** vPosition = gl\_ModelViewMatrixInverse[3];
> 17. **vec3** rayPosition = texCoord0.xyz;
> 18. **vec3** vecDif = rayPosition - vPosition.xyz;
> 19. **vec3** rayDirection = sampleRate \* **normalize**(vecDif);
> 20.
> 21. *// for all samples along the ray*
> 22. **while** (steps)
> 23. {
> 24. steps--;
> 25. *// get trilinear interpolated value from 3d texture*
> 26. **float** value = **texture3D**(volume, rayPosition);
> 27. isoThr = value-isoValue;
> 28.
> 29. *// check if we get isosurface line*
> 30. **if** (isoThr < 0)
> 31. {
> 32. *// march to the next sample*
> 33. rayPosition = rayPosition + rayDirection;
> 34.
> 35. *// get next density*
> 36. **continue**;
> 37. }
> 38.
> 39. *// else we do color transformation*
> 40. outputColor = isoColor;
> 41. outputColor.rgb = outputColor.rgb \* outputColor.a;
> 42.
> 43. #ifdef SHADER
> 44. *// do shading*
> 45. #endif
> 46.
> 47. **break**;
> 48. }
> 49. gl\_FragColor.rgba = outputColor;
> 50. }
> 51.`
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
###### Текст подготовлен в [Редакторе Блогов](http://www.softcoder.ru/blogeditor/) от © SoftCoder.ru
Одним из главных параметров ray casting является шаг трассировки — с какой скоростью луч проходит через наш объект. Если у нас рендерится куб размерностью X\*Y\*Z, то идеальной скоростью будет 1/MAX(X,Y,Z). То есть прирост должен быть не больше 1 вокселя для того, чтобы ничего не пропустить. Но с другой стороны часто не нужна такая степень детализации, которая к тому же влияет на производительность.
 
На представленных картинках мы видим изображения, отрендеренные с разным sampleRate. В первом случае использовался как раз таки идеальный 1/MAX(X,Y,Z) — изображение получилось плавным, без видимых переходов, так как мы не пропустили ни одного вокселя, НО! FPS при этом равняется всего лишь 13 кадров в секунду.
Для второго варианта использовался sampleRate в два раза больше — то есть мы обрабатывали каждый второй воксель, и при этом уже видны круги, которые образуются из-за погрешности в вычислении нахождения первого вокселя изоповерхности. Но FPS при этом повысилась до 37 кадров.
Как увеличить скорость прохода алгоритма и при этом не потерять в качестве я постараюсь рассмотреть в следующей статье. | https://habr.com/ru/post/123632/ | null | ru | null |
# Android M и инструменты для разработчиков
Привет, Хабрахабр! В прошлом году мы впервые предоставили разработчикам тестовую версию Android L и получили множество полезных отзывов, которые касались Material Design, а также новых платформ Android Auto, TV и Wear. Вчера на конференции Google I/O мы объявили о повторении нашего удачного опыта: встречайте [тестовую версию Android M](http://developer.android.com/preview/index.html).
Разработчики остались довольны ранним доступом к новой версии Android в прошлом году: он позволил обновить и оптимизировать приложения для новой версии операционной системы, в которой было введено много нового (в том числе и полностью переосмыслен дизайн и гайдлайны по проектированию интерфейса). Мы хотим и дальше предоставлять разработчикам возможность качественно подготовиться к релизу новой версии ОС: как вы и просили, мы обеспечим более четкий график обновлений SDK и тестовой версии Android M.
Главное в Android M: совершенствование основ
============================================
Android L принёс с собой абсолютно новый пользовательский интерфейс, новую среду исполнения программ ART, увеличил скорость работы и отзывчивость интерфейса. В Android M мы сосредоточились на улучшении базового пользовательского опыта: устранили различные ошибки и внесли крупные изменения в основные элементы платформы.
**Разрешения для приложений**
Мы решили дать пользователям больше возможностей контролировать доступ приложений к ресурсам смартфона. Теперь запросы будут появляться прямо во время работы приложения, в соответствующем контексте, и пользователи смогут выбрать, давать разрешение или нет. Кроме того, пользователи смогут легко управлять правами установленных приложений через системное меню настроек. Это изменение упрощает процесс установки и способствует ускорению обновлений, так как вмешательства пользователей при изменении списка разрешений больше не потребуется.
Количество устройств на Android M будет увеличиваться, и данное изменение потребует от разработчиков создавать приложения таким образом, чтобы запросы на доступ появлялись, когда это требуется, и учитывать, что некоторые разрешения на доступ не будут получены.
**Наводим мосты**
App Links — это новый способ “наводить мосты” между различными Android-приложениями. У разработчиков и раньше была возможность обрабатывать URL внутри приложений. В новом Android M можно добавить атрибут autoVerify в манифест приложения, чтобы пользователи могли без дополнительных запросов переходить по определённым ссылкам прямо в оригинальное приложение, минуя этап открытия браузера и окно выбора с продолжением в нативном приложении. App links, а также [индексирование приложений для Google Поиска](https://developers.google.com/app-indexing/) упрощает переход и возвращение между используемыми приложениями.
**Энергосбережение**
Android становится умнее, и это касается в том числе и систем управления питанием. Новая система “глубокого сна” («Doze») позволит вашим устройствам работать ещё дольше. Для оптимизации энергопотребления Android M будет обращаться к датчикам движения, определять, когда устройство не используется и переходить в режим максимального энергосбережения. При этом оповещения и важные сообщения по-прежнему будут приходить. Разработчикам же следует подготовиться к нововведениям и режиму “глубокого сна”: например, при разработке мессенджера можно использовать сообщения с высоким приоритетом, чтобы получить ответ от вашего приложения даже в режиме “глубокого сна”.
Мы также рады сообщить о некоторых более крупных нововведениях.
**Google Now в одно касание (Now on tap)**
Новая система взаимодействия с помощником Google Now позволит ещё проще получать подсказки. Предположим, вам пришло сообщение от приятеля, в котором он приглашает вас посетить новый ресторан. Вы сможете обратиться к Google Now, не переключаясь между приложениями. Проанализировав текст сообщения, сервис найдёт меню ресторана и отзывы о нём, поможет забронировать столик, проложит маршрут и предоставит ссылки на подходящие приложения.
С Now в одно касание находить нужную информацию и выполнять различные действия можно очень быстро. Чтобы предоставить пользователям возможность работать с приложением через Google Now, от разработчика потребуется внедрить [индексацию приложений для Google поиска](https://developers.google.com/app-indexing/?utm_campaign=io15&utm_source=dac&utm_medium=blog).
**Android Pay и отпечатки пальцев**
Для внедрения платёжной системы [Android Pay](http://officialandroid.blogspot.com/2015/05/pay-your-way-with-android.html?utm_campaign=io15&utm_source=dac&utm_medium=blog) требовалось два компонента, работающих на уровне системы: NFC, внедренный версии Android 2.3, и эмуляция банковских карт, которая появилась в версии Android 4.4. Вчера мы представили Fingerprints API — еще один компонент безопасной и простой системы, который позволяет работать с биометрическими данными на уровне ОС.
Вместе Android M и Android Pay позволяют пользователям подтверждать покупки (как в розничных сетях, так и в Google Play) одним прикосновением к сканеру отпечатков пальцев. С добавлением поддержки отпечатков на системном уровне в Android M пользователи смогут обезопасить себя от несанкционированных покупок, разблокировать телефон и отдельные приложения; а разработчики — использовать универсальные системные API для работы с биометрической авторизацией в своих приложениях, причём работать это будет на всех поддерживаемых системой устройствах и сканерах.
На этом список нововведений Android M не заканчивается. Узнать подробнее обо всех изменениях и улучшениях новой версии Android можно по [этой ссылке](http://developer.android.com/preview/index.html).
Инструменты для разработчиков Android
=====================================
Было бы странно выпустить тестовую версию Android M с новыми функциями, но не предоставить соответствующие инструменты для разработки, поддерживающие новые возможности. Поэтому мы рады представить Android Studio 1.3. Теперь разработчики смогут адаптировать свои приложения к новейшим API, которые поддерживает Android M.
**Ранний доступ к Android Studio 1.3**
В новую версию [Android Studio](https://developer.android.com/sdk/index.html) мы добавили функцию, о которой давно просили разработчики Android NDK и игр: возможность изменять и отлаживать код на языке C или C++.
NDK-плагин Android Studio создан на базе платформы JetBrains Clion и позволяет проводить рефакторинг и компиляцию кода C и C++ а также работать с Java-кодом вашего приложения. Поддержка этих языков программирования включена в единую среду разработки, бесплатную для разработчиков приложений Android. Установите Android Studio 1.3 через канал обновлений Canary сегодня и поделитесь с нами своим мнением.
**Android Design Support Library**
Разрабатывать приложения по принципам Material Design стало ещё проще! Новая библиотека Android Design Support Library содержит набор основных компонентов, обратно совместимых с API 7, например, плавающую кнопку действий, строку состояния, панель навигации, панели инструментов. Не тратьте время на изобретение велосипеда, добавьте их в свое приложение, чтобы оно соответствовало оформлению системы.
**Обновление Google Play Services**
Google Play Services версии 7.5 содержит в себе много новых возможностей, начиная с хранилища паролей Smart Lock, а также новых API для Google Cast и Google Cloud Messaging, и заканчивая доступом к API Карт Google на устройства Android Wear.
One more thing
==============
Мобильность стала синонимом повседневности: проверить почту по пути на работу, поделиться фотографией прямо в парке, устроить видеоконференцию, находясь в автомобиле — сейчас этим никого не удивишь. Тем не менее, у подобных приложений осталась одна проблема, которая в большинстве случаев просто не решается разработчиками ввиду её сложности и огромных трудозатрат. Как вы поняли, речь идёт о прекращении работы из-за потери интернет-соединения или необходимости повторной загрузки большого объёма данных при повторном открытии приложения.
Сегодня мы с радостью представляем вам набор функций для SDK на [Android](https://www.firebase.com/docs/android/guide/offline-capabilities.html) и [iOS](https://www.firebase.com/docs/ios/guide/offline-capabilities.html), позволяющих вам создавать приложения, которые работают оффлайн без проблем. Встречайте **Firebase Offline**!
**Работа с Firebase Offline**
Новый SDK поддерживает сохранение ваших синхронизируемых данных на локальный диск. Таким образом, они становятся доступны вашему приложению сразу после его запуска. Включить режим синхронизации можно с помощью всего одной строчки кода:
```
// Android
Firebase.getDefaultConfig().setPersistenceEnabled(true);
// Obj-C
[Firebase defaultConfig].persistenceEnabled = YES;
// Swift
Firebase.defaultConfig().persistenceEnabled = true
```
C помощью новых инструментов вы сможете сами определить, какие данные требуется загружать заранее и сохранять для работы без интернет-соединения. Для этого используется функция keepSynced:
```
// Android
ref.keepSynced(true);
//Obj-C
[query keepSynced:YES];
```
**Разработано специально для мобильных сетей**
Для обмена информацией между клиентом и сервером в базе данных Firebase вместо классической системы «запрос-ответ» используется синхронизация. Все операции по чтению и записи сначала выполняются в локальной версии базы данных, хранящейся на устройстве; затем происходит взаимный обмен информацией между серверами. Всё это позволяет Firebase компенсировать нестабильное соединение: локальные операции записи комбинируются с локальными операциями по чтению перед тем, как их подтвердит сервер.
Но и это ещё не всё. Приятным бонусом такого дизайна является более качественная оффлайн-работа приложения в целом. Поскольку все данные сперва проходят через локальную версию базы данных, SDK «выбирает» наиболее оптимальный источник: сеть или локальный диск. Позже, когда сеть становится доступной, SDK автоматически отправляет локальные изменения на сервер и получает от него последние обновления.
**Firebase: всё уже проверено и работает**
С самого начала мы создавали Firebase для поддержки работы приложений в режиме оффлайн — команде потребовалось несколько лет, чтобы завершить начатое. С 2013 года компания Citrix проводит бета-тестирование функции офлайн-поддержки для своего приложения Talkboard на базе iOS. При работе в таком режиме действия пользователя в приложении сохраняются на устройстве, а при подключении к Интернету синхронизируются с серверами. Например, вы нарисовали что-то на «холсте» в Talkboard, и даже если вы в этот момент не были подключены к Сети, рисунок не потеряется, а будет сохранен и передан на сервер как только подключение возобновится.
Ключ на старт
=============
Android M для разработчиков включает в себя обновленный SDK с инструментами и образами системы, предназначенными для тестирования на официальном эмуляторе Android, а также на устройствах Nexus 5, Nexus 6, Nexus 9 и Nexus Player. Мы расширили программу тестирования, так что у вас будет больше времени на подготовку к окончательному запуску Android M этой осенью. Ваши отзывы помогут нам обновлять образы системы чаще. Чем раньше вы поделитесь с нами вашими впечатлениями, тем эффективнее пройдет тестирование!
Чтобы начать работу с тестовой версией Android M и подготовить свои приложения к окончательному запуску, следуйте этим инструкциям:
1. Установите тестовую версию Android Studio 1.3+;
2. Посетите [сайт Android M для разработчиков](http://developer.android.com/preview/index.html);
3. Ознакомьтесь с [новыми API](http://developer.android.com/preview/api-overview.html) и [Изменениями в разрешениях для приложений](http://developer.android.com/preview/behavior-changes.html);
4. Посетите [справочную библиотеку дизайна Android](http://developer.android.com/tools/support-library/features.html#design) и ознакомьтесь с [API сервисов Google Play](https://developers.google.com/android/guides/);
5. Получите образы системы для тестирования через SDK Manager или [скачайте образы системы для устройств Nexus](http://developer.android.com/preview/setup-sdk.html);
6. Протестируйте свои приложения на устройстве Nexus или эмуляторе;
7. Поделитесь с нами своими впечатлениями.
Начать работу с новым оффлайн-сервисом Firebase тоже очень просто: зайдите в раздел с руководствами по режиму офлайн для [iOS](https://www.firebase.com/docs/ios/guide/offline-capabilities.html) или [Android](https://www.firebase.com/docs/android/guide/offline-capabilities.html), там всё подробно рассказано, к тому же есть отличный [пример](https://github.com/firebase/AndroidDrawing) с оффлайн-рисованием на устройствах iOS и Android. **Мы будем рады вашим отзывам! Напишите нам в [Google Группы](https://groups.google.com/forum/#!forum/firebase-talk) или упомяните [@Firebase](https://twitter.com/firebase) в Twitter.
Мы ждём ваших отзывов
=====================**Ранний доступ к Android L позволил нам получить бесценную информацию, исправить многие недочёты, а также подготовиться к выпуску новой версии Android тысячам разработчиков по всему миру. Устанавливайте SDK, тестируйте работу Android M и приложений, встраивайте новые функции, а главное — делитесь информацией. Полный список ресурсов для общения разработчиков можно найти [здесь](http://developer.android.com/support.html). Нам важно каждое мнение, каждый отчёт об ошибке, каждое замечание и предложение. Совместными усилиями мы сможем сделать Android M ещё лучше. | https://habr.com/ru/post/259123/ | null | ru | null |
# Разбираемся со считыванием и записью магнитных домофонных ключей
Приветствую всех!
Мы уже давно привыкли, что самыми распространёнными типами домофонных ключей являются Touch Memory (iButton) и EM-Marine. Набирают популярность Mifare и различные проприетарные решения в формате Touch Memory. Но, конечно, так было далеко не всегда.
Итак, в сегодняшней статье поговорим о той эпохе, когда возможность размагничивания ключей от подъезда была не городской легендой, а суровой реальностью. Узнаем, как работали такие домофоны, как устроены подъездные домофонные сети, как считывать и записывать такие ключи. Традиционно будет много интересного.
❯ Суть такова
--------------
На заре электронных систем контроля доступа существовало немало разновидностей ключей от них. Некоторые из них реально поражали своим исполнением: какие-то были до гениального просты и надёжны (на то время, конечно), какие-то — до невозможности отвратительны.
Вот, например, Eltis ЦП100КМ (насчёт модели не уверен) с оптическими ключами. Помимо них такой принцип использовался в устройствах компании Метаком. Принцип действия, думаю, понятен.
**Немного оффтопика**
В далёком детстве, когда мне было около шести лет, я собрал модель электронного замка. Считывание производилось при помощи четырёх светодиодов и четырёх фототранзисторов, а ключом была картонка с проколотыми в нужных местах дырочками. Лишь спустя годы я узнал, что домофоны с оптическим ключом реально существовали и серийно выпускались.
Домофон «Вика-Д3» с резистивным ключом. Внутри ключа находился резисторный делитель, соответственно, домофон просто измерял напряжение. Недостатки такого метода очевидны: даже простое загрязнение контактов приведёт к глюкам или полной невозможности открыть дверь.
Идея с такими ключами тоже неожиданно взлетела (видимо, из-за дешевизны) и получила распространение в немалом числе моделей. Были даже ключи в формате Touch Memory с резисторами внутри.
Ну что же, время перейти к главному предмету сегодняшнего обзора — к домофонам с магнитным ключом. Мне всегда было интересно, как это работает, какой объём данных вмещает ключ, как он считывается… И вот у меня появилась возможность рассмотреть данный артефакт поподробнее.
❯ Немного об истории домофонов в Челябинске
--------------------------------------------
Возможно, жители некоторых регионов в жизни не видели домофонов с такими ключами. И, признаться, на это есть причины. Подавляющее большинство таких устройств выпускалось челябинской компанией "[Факториал](http://factorial.ru/kontakty/)". Несмотря на то, что они ставили своё оборудование в немалом числе других городов, подавляющее большинство аппаратов эксплуатировались именно у нас на Урале. Будучи основанной в далёком 1998 году, компания существует и поныне, продолжая выпускать свои панели вызова, правда, на этот раз уже с ключами Mifare. Тем не менее, новые «магнитные» экземпляры до сих пор продаются, видимо, для замены отслуживших своё собратьев. С другой стороны, достаточно популярных в Москве и Питере Eltis, Raikmann, Laskomex в Челябинске вообще нет.
Помимо «Факториала» другими двумя типичными представителями челябинских домофонов являются различные вариации Cyfral CCD-2094 и Метаком МК-20. Устройства достаточно старые (большая их часть не менялась с самого момента установки в начале нулевых), но до сих пор успешно выполняют свою главную функцию — защищать подъезд от попадания туда бомжей, закладчиков, «внеплановых проверок счётчиков», псевдо-газовщиков, мошенников-впаривателей и прочих мутных личностей. Разумеется, ранее указанными моделями список не ограничивается, но других в сравнении с ранее представленными на порядок меньше.
Посмотрим на типичных их представителей.
Cyfral CCD-2094 с ключом Touch Memory.
Он же, но с ключом EM-Marine. Вместо контактов для Touch Memory просто пластмассовая затычка, за которой расположена антенна.
Метаком МК-20.
А вот и «Факториал». Аналогичная панелька показана на КДПВ.
Более старая версия этого блока.
«Факториал» с ключом Touch Memory.
«Факториал» с ключом Mifare.
[… Внутри тоже RFID чип от Texas Instruments. При этом при каждом открывании двери данные в ключе перезаписываются, таким образом невозможно увеличить количество ключей. Копия будет работать, но после первого открывания перестанет работать оригинал, так как данные в ключе меняются. Этим хитрым апгрейдом факториал разом сделал бизнес копирования домофонных ключей невозможным.](https://serkov.su/blog/?p=1899)
(из блога [spiritus\_sancti](https://habr.com/ru/users/spiritus_sancti/))
Последние несколько лет (в рамках системы «Безопасный город» и тому подобных госпроектов) старые домофоны активно меняются на устройства от Beward, в простонародье «домофон Интерсвязь», «домофон Дом.ру» или просто «умный домофон». Конкретно этот — от «Интерсвязи», на дисплее бегущая строка в виде адреса дома и названия этого провайдера. [Иногда это приводит к забавным результатам...](https://74.ru/text/business/2019/12/12/66395179/)
«Факториал» тоже не отстаёт.
❯ Обзор оборудования
--------------------
Так получилось, что мне достались две панели вызова: Cyfral CCD 2094/tc и Факториал. Первая интересна своим годом выпуска (один из первых CCD 2094), вторая — магнитным ключом.
Рассмотрим первый экземпляр. В качестве ключа используется обычный Touch Memory. Стандартные для домофона цифровые кнопки, вызов и сброс. Индикатор семисегментный, на пять разрядов. На самом деле их шесть, на один разряд не используется и скрыт с глаз долой металлом корпуса, окошко прорезано только для пяти. Под названием модели красуется гордое «MICROPROCESSOR CONTROL», словно там стоит не простенький микроконтроллер, а аж какой-нибудь MC68000. Интересно, на чём ещё вообще может работать такое устройство? На [реле](https://habr.com/ru/post/402629/) или [пневмонике](https://habr.com/ru/post/374309/) что ли? Не на дискретной логике же…
Обратная сторона. Когда-то тут была крышка, но до меня она не дожила. Плата достаточно простая, выполнена на базе микроконтроллера семейства 8051 (судя по всему, это AT89S52). Чуть ниже EEPROMка, куда записываются ключи и параметры. Рядом с ней два контакта, обозначенные как «1» и «2». Их замыкание позволяет ввести домофон в тестовый режим, что может понадобиться для сброса настроек.
На отдельной платке с микроконтроллером AT90S1200 реализован считыватель ключей Touch Memory. Виден припаянный к ней варистор, призванный защищать электронику домофона от статики ~~и вандалов с электрошокером~~.
Также на основной плате имеются несколько подстроечных резисторов: чувствительность микрофона, громкость, баланс.
Кнопки самые обычные тактовые (хотя правильно называть их тактильными). Предусмотрена защита от продавливания: при слишком сильном нажатии кнопка упирается в крепёжную пластину и дальше на шток не воздействует.
По своей монументальности панель близка к клавиатурам уличных банкоматов. Корпус конкретно моего экземпляра представляет собой металлическую пластину толщиной в десять миллиметров.
Рассказывать о программной части данного артефакта не вижу особого смысла: в этом плане он не так уж и отличается от более новых CCD 2094, информации по которым на просторах много.
Перейдём к «Факториалу». Эту панельку я показывал чуть ранее, и вот точно такая же попала ко мне в состоянии практически новой. Она очень поздняя, сделана тогда, когда вовсю выпускались таковые с ключами Mifare. Дизайн сильно отличается, впрочем, для рядового пользователя разницы никакой. Вместо контактов Touch Memory щель для ключа, над кнопками расположены три светодиода подсветки. Панель сделана из всё того же благородного металла силумина.
Обратная сторона. Электроника закрыта крышкой из листовой стали. В ней сделаны несколько прорезей: для кнопки входа в сервисный режим, для регулятора громкости, для считывателя ключа, ещё парочка для каких-то технологических разъёмов.
Снизу выходит жгут проводов, среди них два коричневых — питание (~15 В), два зелёных — электромагнит, далее жёлтый — кнопка выхода, синий — земля, белый — линия (LN), красный — управление коммутатором (LU). Увы, нормальной документации на «Факториалы» толком и нет. Скорее всего, связано это с тем, что ставят такие панельки представители данной компании, а не сторонние фирмы.
Снимем крышку. Отчётливо видны плата, динамик, считыватель ключей. На плате конденсаторы, диодный мостик, линейный стабилизатор LM7805. Рядом с ним мощный транзистор, управляющий электромагнитом двери. Видно пустующее посадочное место под EEPROMку, судя по всему, в этой модификации данные пишутся в память МК.
Кстати, вот на такой винт был посажен один из углов крышки… мда уж, весело.
Обратная сторона платы. Управляет всем устройством контроллер ATMega64. Внизу платы нераспаянная область. Моя модификация довольно поздняя, одна из последних с магнитным ключом. Предположу, что там могло находится нечто по типу MFRC522…
Снимем плату с кнопками. Они тут обычные тактильные, поверхностного монтажа. От попадания на плату воды защищает резинка. Кнопки тоже имеют защиту от продавливания.
Для защиты от конденсата обе платы покрыты лаком.
Снимем плату считывателя ключей. Тут всё крайне простенько. Ключ считывается тремя датчиками Холла. Красный светодиод подсвечивает щель для вставки. В качестве датчиков используются SS495A. В отличие от магнитных карт, таймаута на прокатывание ключа нет, так что можно вставлять его хоть по миллиметру в минуту, прочитан он всё равно будет.
Обратная сторона. Кроме резистора и конденсатора тут ничего нет…
**Про программирование этих панелей**
Для входа в режим программирования необходимо нажать и удерживать любую цифровую кнопку, пока на дисплее не загорится **PrL**. После этого экран погаснет, и нужно будет набрать пароль (как и в линуксовой консоли, вводимые цифры на экране не отображаются). По умолчанию это *123456*, но в вашем домофоне он наверняка заменён. Также можно нажать и удерживать в течение секунды кнопку на плате, для которой специально сделано отверстие в крышке.
Если с паролем вы не прогадали, на дисплее загорится **ПР**. Далее необходимо выбрать нужную нам функцию (подменю) и нажать «Вызов». По сути интерес представляют следующие функции:
* Включение и отключение абонентов. Если абонент отключён, при попытке его вызова на дисплее загорится **PAY**. Для возвращения его к жизни в режиме программирования набираем «12», затем «Вызов», затем номер квартиры, затем «1», затем «Вызов».
* Программирование ключей. В режиме программирования нажимаем «8», затем «Вызов», вводим номер ячейки и вставляем ключ.
* Номер первой квартиры и их общее число в подъезде. Эти параметры необходимы для корректной работы коммутатора. Вводятся в подменю 1 и 2.
* Узнать текущий пароль. Подменю 0.
* Открыть дверь. Нажать «4», затем «Вызов».
❯ 180180
---------
На просторах обнаружилась вот такая картинка. Увы, ни один из кодов к моей панели не подошёл. Единственный работоспособный вариант — удерживать любую цифровую клавишу несколько секунд, ввести пароль режима программирования, жмякнуть «4», затем «Вызов». Но по регламенту «Факториала» код при установке панели всегда меняют, а за время, которое вам понадобится для подбора комбинации шести цифр (если на каждую комбинацию уходит около десяти секунд), дверь успеет открыться не один раз, так что при незнании мастер-пароля можно считать эти коды бесполезными.
❯ Связь
-------
Вообще, к теме ключей и тому подобного это не имеет ни малейшего отношения. Но, раз уж затронули тему домофонов, стоит рассказать и про это.
Тут я намеренно не буду затрагивать IP-домофоны, расскажу о традиционных аналоговых моделях, которые до сих пор широко распространены и до сих пор вполне себе устанавливаются.
По адресации существует два типа трубок: координатные и цифровые. Первые подключаются к специальному коммутатору, вторые — параллельно по двухпроводной линии.
Вот так вот выглядит коммутатор, по принципу работы чем-то напоминающий АТС. Ничего примечательного в нём нет: просто белая коробочка, к которой идут проводки. Два тонких серых — питание (~15 В), синий — земля, красный — управление, белый — линия, назначение зелёного, жёлтого и коричневого мне неизвестно.
Схема его достаточно простая, всего лишь несколько счётчиков и немного микросхем дискретной логики. От него отходит два шлейфа, один на старший разряд номера квартиры, второй — на младший. Таким образом, по шестнадцати проводам можно подключить шестьдесят четыре квартиры. Работает он тоже очень просто — при совершении звонка домофон отправляет нужное число импульсов на управляющий вход (LU), а коммутатор подключает нужную пару проводов к линии (LN). Некоторые модели оснащены выводом переноса, что позволяет подключить ещё один такой блок, если ёмкости этого не хватает, где-то же используется ещё один провод LU от домофона. Хотя каждый производитель домофонов традиционно выпускает свой вариант такого блока (равно как и трубки), большая часть из них совместима между собой, так как все они работают по одинаковому принципу.
Цифровые трубки подключаются всего по двум проводам, что при немногим большей стоимости устройства существенно снижает затраты на прокладку шлейфов по подъезду. Внутри трубки находится всё тот же счётчик, а домофон перед вызовом посылает в линию нужное число импульсов. Номер абонента задаётся на плате перемычками (то есть если их поменять, то можно ответить от лица другой квартиры).
Трубка. В моём случае Цифрал КМ-2НО. По сути ничем от других аналоговых «коммутаторных» трубок не отличается. Всё те же кнопка открытия двери и выключатель, всё тот же ничем не примечательный дизайн.
Сзади два контакта, подключать необходимо с соблюдением полярности. В отличие от стационарного телефона, диодного моста в трубке нет, лишь один-единственный диод, защищающий её от скоропостижного сдыхания при подключении с неправильной полярностью.
Корпус на защёлках и легко разбирается. Самой частой неисправностью является пропадание контакта: разваливается кнопка открытия двери (как это случилось у меня), переламывается кабель, глючит концевик наличия трубки на подставке. Провода очень тонкие, волосяные жилки из неизвестного сплава легко сминаются и рвутся.
Обратная сторона платы.
Сама трубка не так уж и сильно отличается от обычного телефона, если не считать отсутствия номеронабирателя и звонка (роль которого выполняет постоянно подключённый к линии динамик). Кнопка открывания двери просто отключает голосовую часть, что позволяет домофону отследить этот момент по резкому падению тока в линии. Выключатель реализован по-разному: где-то он подключает в цепь динамика добавочное сопротивление, заставляя его звонить очень тихо, где-то просто отсоединяет всю трубку (а блок вызова определяет это по обрыву линии и не производит соединение).
Для проверки блока вызова трубку можно подключить и без коммутатора: плюс в LN, минус на землю.
❯ Ключи
--------
А вот и сами магнитные ключи. Ключ представляет собой пластину из некого пластика, в который при производстве замешан порошок ферромагнетика. Размеры такие: ширина — семнадцать миллиметров, длина — пятьдесят девять миллиметров, толщина — два миллиметра.
Сам ключ содержит восемнадцать магнитных точек (три ряда по шесть в каждом), каждая из которых может быть намагничена положительно или отрицательно (или не быть намагничена вообще. Но на практике промежуточное состояние не используется). Помнится, товарищ [spiritus\_sancti](https://habr.com/ru/users/spiritus_sancti/) выкладывал когда-то в историях своего Instagram фотографию такого ключа с приложенной пластиной для визуализации магнитного поля, где отчётливо были видны эти точки. Увы, нигде больше это фото не засветилось. Ближайшая к ручке тройка точек на «Факториале» не используется. При этом центральный ряд используется не для кодирования информации, а для контроля вставки ключа. На всех ключах он содержит последовательность "+-+-+", то есть готовность к считыванию следующей пары бит можно определять сменой сигнала на среднем датчике. Таким образом, для кодирования ключа используются десять бит, то есть всего существует 1024 различных варианта. Разумеется, в ситуации, когда в городе такие домофоны ставили целыми кварталами, коллизии неизбежны (иногда даже в пределах микрорайона): в годы моего обладания таким ключом помню, как однажды открыл им подъезд в соседнем районе (просто увидел такой же домофон и «по приколу» решил попробовать вставить ключ, который неожиданно подошёл).
Старые панели вызова имели память всего на пять ключей, так что чаще всего у всего подъезда они были с одинаковым кодом.
❯ Собираем считыватель сами
---------------------------
Разумеется, хочется попробовать воссоздать что-то подобное.
Для начала посмотрим, как работает такой считыватель у домофона. Для этого у него есть специальный диагностический режим, для входа в который необходимо активировать функцию записи ключей и ввести номер 99 (или 9). После этого на дисплее загорятся три нижних сегмента, каждый из которых символизирует свой датчик Холла.
В нормальных условиях они должны просто гореть. При вставке ключа можно заметить, что в разных его положениях мы получаем разные коды. Если же на экране шум или же какой-то из датчиков залип в другом положении, проверяйте питание. Эти панельки очень чувствительны к его просадкам.
Ну что же, время собирать свой вариант. Для сборки самого простого считывателя нам понадобится три биполярных датчика Холла (например, всё те же широко распространённые SS495A), три двухцветных светодиода, шесть резисторов, самый дешёвый китайский клон Arduino Nano. Да, знаю, что *адурино* — не всегда хорошо, но в данном случае — самый лёгкий вариант. Схема настолько проста, что не вижу смысла её выкладывать, чуть позже подробно её опишу.
Почти все датчики имеют одинаковую распиновку: со стороны скошенной части первый вывод — плюс, второй — минус, третий — сигнал. Три датчика подключаются к трём аналоговым входам Arduino. Обратите внимание, что униполярные датчики (типа того же SS41F) не подойдут.
Для начала проверим, можно ли вообще считывать ключи при помощи Arduino и датчика Холла. Припаиваем к датчику проводки, подключаем (плюс — 5 В, минус — земля, выход — A0), заливаем AnalogReadSerial из стандартных примеров. Вообще, для биполярного датчика необходимо соответствующее двухполярное питание, однако в нашем случае им можно пренебречь. Просто вместо Uпит., нуля и -Uпит. у нас на выходе будет Uпит., 1/2 Uпит. и ноль. Берём мощный магнит и проверяем правильность подключения: при поднесении одного полюса показания должны упасть до нуля, другого — до высшего уровня. При отсутствии рядом магнита они должны держаться на уровне пятисот.
Теперь берём ключ и прикладываем его к датчику. Мда, какой-то слабенький размах получается, всего десять-двадцать единиц в обе стороны. Теперь понятно, откуда такие жёсткие требования к питанию «Факториала». Но оно даже работает, положительные и отрицательные точки на ключе датчик видит. А раз так, попробуем собрать свой считыватель.
Внезапно появилось желание сделать получше, так что схему собрал на монтажной (вообще-то она макетная, но знали бы вы, сколько девайсов отправилось «в продакшн» в таком исполнении...) плате.
Отмыв лужи спиртоканифоли и проверив работоспособность, пишем программу для данного девайса. Она в итоге получилась такая:
```
#define S1_P_LED 4
#define S2_P_LED 5
#define S3_P_LED 6
#define S1_N_LED 7
#define S2_N_LED 8
#define S3_N_LED 9
#define SENSOR_THRESHOLD 10
int sensor1Zero, sensor2Zero, sensor3Zero;
void setInitialValues() {
sensor1Zero = analogRead(A0);
sensor2Zero = analogRead(A1);
sensor3Zero = analogRead(A2);
}
void setup() {
setInitialValues();
digitalWrite(4, HIGH);
digitalWrite(7, HIGH);
for (int i = 4; i <= 9; i++) pinMode(i, OUTPUT);
Serial.begin(115200);
Serial.println("Magnetic doorphone key reader");
Serial.println("Press any key to get the dump or put the tag on the sensors to read the polarity");
}
void getSensorValues(int8_t * firstSensor, int8_t * secondSensor, int8_t * thirdSensor) {
if (analogRead(A0) < sensor1Zero - SENSOR_THRESHOLD) {
digitalWrite(S1_P_LED, LOW);
digitalWrite(S1_N_LED, HIGH);
*firstSensor = -1;
}
else if (analogRead(A0) > sensor1Zero + SENSOR_THRESHOLD) {
digitalWrite(S1_P_LED, HIGH);
digitalWrite(S1_N_LED, LOW);
*firstSensor = 1;
}
else {
digitalWrite(S1_P_LED, HIGH);
digitalWrite(S1_N_LED, HIGH);
*firstSensor = 0;
}
if (analogRead(A1) < sensor2Zero - SENSOR_THRESHOLD) {
digitalWrite(S2_P_LED, LOW);
digitalWrite(S2_N_LED, HIGH);
*secondSensor = -1;
}
else if (analogRead(A1) > sensor2Zero + SENSOR_THRESHOLD) {
digitalWrite(S2_P_LED, HIGH);
digitalWrite(S2_N_LED, LOW);
*secondSensor = 1;
}
else {
digitalWrite(S2_P_LED, HIGH);
digitalWrite(S2_N_LED, HIGH);
*secondSensor = 0;
}
if (analogRead(A2) < sensor3Zero - SENSOR_THRESHOLD) {
digitalWrite(S3_P_LED, LOW);
digitalWrite(S3_N_LED, HIGH);
*thirdSensor = -1;
}
else if (analogRead(A2) > sensor3Zero + SENSOR_THRESHOLD) {
digitalWrite(S3_P_LED, HIGH);
digitalWrite(S3_N_LED, LOW);
*thirdSensor = 1;
}
else {
digitalWrite(S3_P_LED, HIGH);
digitalWrite(S3_N_LED, HIGH);
*thirdSensor = 0;
}
}
void processKey() {
Serial.println("Waiting for key...");
int8_t n1, n2, n3;
int8_t point1, point2, point3;
for (int i = 0; i < 5; i++) {
while (1) {
getSensorValues(&n1, &n2, &n3);
if ((n1 != 0) && (n2 != 0) && (n3 != 0)) {
point1 = n1;
point2 = n2;
point3 = n3;
break;
}
}
if (point1 == 1) Serial.print('+');
else Serial.print('-');
if (point2 == 1) Serial.print('+');
else Serial.print('-');
if (point3 == 1) Serial.print('+');
else Serial.print('-');
Serial.println();
while (1) {
getSensorValues(&n1, &n2, &n3);
if ((n2 != point2) && (n2 != 0)) break;
}
}
Serial.println("Press any key to read another tag");
}
void loop() {
int8_t n1, n2, n3;
getSensorValues(&n1, &n2, &n3);
if (Serial.available()) {
Serial.read();
processKey();
}
}
```
Принцип работы программы достаточно простой. К трём аналоговым входам МК подключены три датчика Холла (аналогично тому, как это делалось в первом опыте). При запуске считываются их значения в момент, когда магнитного поля рядом нет. Вообще, было бы неплохо добавить тут какой-нибудь медианный фильтр, но оно нормально работает и без него. Далее в цикле вызывается функция опроса трёх датчиков. В ней считывается значение каждого из них, после чего определяется полярность, которая попутно отображается на светодиодах: четвёртый, пятый и шестой выводы — красные светодиоды, седьмой, восьмой и девятый — зелёные. При обнаружении положительно намагниченной точки загорается красный, отрицательно — зелёный. При отсутствии намагничивания горит оранжевый (включены оба кристалла в двухцветном светодиоде). Значение **SENSOR\_THRESHOLD** в начале программы обозначает, на какое число единиц может отклониться значение с АЦП, чтобы оно перестало считаться отсутствием магнитного поля.
Также реализовал тот же алгоритм, что и в оригинальных «Факториалах»: при получении какого-то байта запускается функция считывания ключа и отправки данных в последовательный порт. В ней в цикле считываются коды очередной тройки точек, если они ненулевые, то их значения отправляются в порт, а МК переходит в другой цикл, где ждёт, пока значение средней точки не будет отличаться от предыдущего (и при этом будет ненулевым).
Настройка девайса достаточно простая: заливаем прошивку, берём какой-нибудь ключ и три раза пытаемся его считывать. Если получается отсебятина, подкручиваем **SENSOR\_THRESHOLD** и пробуем снова.
У меня уверенного чтения удалось добиться при таковом значении, равном десяти. Если на всей площади ключа ничего не видно, значит, у вас либо не те датчики, либо ключ-болванка без записи.
❯ Программатор
--------------
Итак, со считыванием разобрались. Как же обстоят дела с программированием?
Каким образом записывались ключи при их производстве, мне неведомо (вполне возможно, что существовали устройства для массовой прошивки ключей на один и тот же код). Зато выяснилось, что вполне себе выпускались устройства для их копирования (причём, прямо так скажем, по неадекватной для такой продукции цене).
А вот заготовки для них были совершенно чистыми, без какого-либо намагничивания, отчего для начала использования их надо было программировать.
Вот для примера один из самых распространённых «копировщиков». Принцип до невозможности простой: датчики Холла считывают магнитные точки, а затем этот паттерн набивается на заготовку при помощи штифта с неодимовыми магнитами на концах.
Вот так аппарат выглядит в работе. Выглядит, признаться, не особо впечатляюще. Поэтому продемонстрируем куда более соответствующий эпохе девайс.
У меня есть вот такой программатор, судя по всему, ровесник самой компании «Факториал». Экземпляр явно кустарного производства запросто способен оказаться героем какой-нибудь темы «Что это такое?». В самом деле: тяжёлый металлический корпус без каких-либо обозначений, две неоновые лампочки, тумблер и какая-то кнопка уже заставляют задуматься над предназначением. А непонятный шаблон слева вообще способен поставить в ступор обывателя.
Собственно, область для прикладывания ключа. Хорошо виден металлический штырёк, соединённый с сердечником электромагнита внутри. Именно он и производит намагничивание точки на ключе. Приклеенный шаблон облегчает позиционирование ключа для записи последовательно всех точек сразу. Размер шаблона такой: длина — тридцать миллиметров, ширина соответствует ширине ключа.
Примерно так это выглядит в процессе намагничивания.
А вот и все элементы управления. Девайс имеет световую (горящая в момент записи лампочка) и звуковую (характерное «уууу» работающего электромагнита) индикацию работы. Тумблером необходимо выбрать необходимую полярность намагничивания, далее коротким нажатием кнопки производится «прожиг». Разумеется, помимо программирования ключей девайс также отлично справляется и с намагничиванием мелких металлических деталей. Но тут важно не переусердствовать: если слишком долго держать кнопку, электромагнит может перегреться и сдохнуть.
А вот и внутренности. Программатор соответствует всем представлениям о суровой челябинской электронике: большая масса, корпус из толстого металла, практически все комплектующие отечественные. Из импортного — держатель предохранителя, мощный диодный мостик и индикаторные лампы. Реверсивное включение реализовано при помощи тумблера с двумя переключающими контактными группами. Электромагнит подключается напрямую в электросеть без гальванической развязки.
В отсутствии программатора записать ключ можно обычным неодимовым магнитом подходящих размеров, полярность которого можно определить всё тем же датчиком Холла.
❯ Коды ключей
-------------
При программировании ключей домофон вначале покажет код ключа, который уже записан. А если указать нулевую ячейку, показываться будет код именно того ключа, который в данный момент вставлен. Соответствие битов номера и точек на ключе тут такое:
```
9 7 5 3 1
+ - + - +
8 6 4 2 0
```
На ключе это выглядит так. Учтите, что тут указано зеркальное отображение точек, такое, какое видно при прокатывании ключа мимо датчиков Холла в считывателе или домофоне или при записи его на электрическом программаторе. В реальности же точки находятся на обратной стороне.
А вот и приближённое к реальному расположение магнитных точек на ключе.
При этом, как несложно догадаться, "+" символизирует единицу, а "-" — ноль. То есть, например, паттерн ключа кодом 208 будет выглядеть так:
```
- + - - -
+ - + - +
- + + - -
```
Таким образом, максимально возможный код ключа — 1023, который выглядит так:
```
+ + + + +
+ - + - +
+ + + + +
```
Никак не намагниченные точки (например, на болванке) распознаются как единицы, то есть ключ ниже будет тоже иметь код 1023. Впрочем, на это не следует опираться, так как сигнал в таком случае может плавать, отчего читающийся при одних условиях ключ не будет распознан при других.
```
X X X X X
+ - + - +
X X X X X
```
Последовательность точек в среднем ряду фиксирована, если там будет что-то другое, ключ не прочитается.
По-быстрому написал программу для перевода кода в паттерн:
```
#include
#include
using namespace std;
int main()
{
int keyCode = 0;
cout << "Enter the code" << endl;
cin >> keyCode;
cout << "Key pattern:" << endl;
for(int i = 9; i >= 1; i -= 2) {
if(keyCode & (1 << i)) cout << '+';
else cout << '-';
cout << ' ';
}
cout << endl << "+ - + - +" << endl;
for(int i = 8; i >= 0; i -= 2) {
if(keyCode & (1 << i)) cout << '+';
else cout << '-';
cout << ' ';
}
return 0;
}
```
❯ Размагничивание
-----------------
Ну что же, время проверить слух о том, что ключи домофона могут размагнититься. В отличие от магнитных карт, которые держат даже слабое воздействие неодимового магнита, эти метки являются низкокоэрцитивными. Прикладывания даже хиленького пластикового магнита от холодильника хватило, чтобы ключ перестал читаться, что уж говорить о ферритовых или неодимовых.
Это значит, лишить себя возможности попасть в подъезд можно чем угодно: ношением связки ключей в клатче с магнитным замком, наличием у себя брелочка, содержащего в себе магнит, или просто поднесением ключей к источнику магнитного поля. Не забываем и о том, что данные не имеют ни коррекции ошибок, ни контрольной суммы: достаточно протухнуть даже одному биту, и дверь уже не открыть. В [посте про магнитные карты](https://habr.com/ru/company/timeweb/blog/701206/) я упоминал, что некая Mottura делала ключи с неодимовыми магнитами, ну так вот, наличие такого у вас на связке — практически гарантированный *epic fail*.
iButton, EM-Marine, Mifare лишены данного недостатка и к магнитным полям невосприимчивы. Конечно, их всё же можно убить статикой (хотя тут тоже надо постараться) или, например, поднесением к деактиватору противокражных меток, что стоят практически везде, где торгуют более-менее дорогим товаром, но всё же такие ситуации бывают намного реже.
❯ Легенда об FF
---------------
Среди электронщиков существовала легенда, что ключ с номером из одних 0xFF может открыть домофон. Мол, в некоторых моделях не было счётчика общего количества ключей, отчего домофон проходил до конца памяти и, найдя пустую область, открывал дверь.
Ни на одной из имеющихся у меня панелей баг не проявляется, количество ключей везде прописывается. Возможно, это когда-то работало на более старых версиях прошивки. У «Факториала» всё ещё интереснее: в пустых ячейках прописан код 2047, однако ключа с таким кодом попросту не существует.
На каких устройствах такой баг есть, мне неведомо (впрочем, есть сведения, что такая уязвимость имелась на некоторых панелях вызова «Метаком», которые на прикладывание болванки реагировали как на мастер-ключ). Упомянутые в начале статьи домофоны с оптическим ключом (по некоторым данным) открывались просто вставленной в слот бумажкой, подозреваю, что тут была та же уязвимость. Знающие о таком косяке монтажники специально забивали всю оставшуюся память мастер-ключами.
❯ Вот как-то так
----------------
В интернете нет почти никакой информации по домофонах с магнитными ключами. Тем не менее, тема оказалась весьма интересной.
В наши дни подобные артефакты постепенно уходят в историю. Даже в родном Челябинске остаётся всё меньше подъездов, где остались такие панельки. Взамен ненадёжных магнитных ключей приходят более продвинутые аналоги.
Тем не менее, надеюсь, что кого-то, как и меня, это тоже заинтересует, а кто-то просто узнает, как же это работало. Такие дела.
❯ Ссылки
--------
* [Схема трубки, типичного коммутатора, а также целого модельного ряда блоков вызова «Цифрала»](http://www.cyfral.ru/index.php?option=content&task=view&id=85&Itemid=54##16)
* [Примерно то же самое для «Метакома». Принципиальных схем нет, увы.](https://metakom.ru/dokumentatsiya/schems/)
* [Пост про RFID, где упоминался и «Факториал»](https://serkov.su/blog/?p=1899)
* [Тот самый чудо-программатор](https://el-id.ru/ru/8009-dmf-5.html)
* [Ещё про ключи](http://rones.su/techno/doorphone_keys_faq.html)
* [А вот и мой программатор. Получается, не такой уж он и кустарный?](https://ikey.ru/forum/topic/1302-%D0%B4%D0%BE%D0%BC%D0%BE%D1%84%D0%BE%D0%BD%D0%BD%D1%8B%D0%B5-%D0%BA%D0%BB%D1%8E%D1%87%D0%B8-%D1%84%D0%B0%D0%BA%D1%82%D0%BE%D1%80%D0%B8%D0%B0%D0%BB/)
[](https://timeweb.cloud//vds-vps?utm_source=habr&utm_medium=banner&utm_campaign=vds-promo-6-rub) | https://habr.com/ru/post/710596/ | null | ru | null |
# Рисуем тайлы с данными для GoogleMap на PHP
##### Преамбула
В настоящее время очень популярно заниматься визуализацией каких-либо данных на картах. Да прочем и не только визуализацией, применений множество: игры, гео-сервисы, визуализация, статистика и многое-многое другое. С одной стороны, применение canvas это хорошо и современно, с другой же — количество объектов может превышать все мыслимые и немыслимые пределы, что ведет к уменьшению скорости работы пользователя с такими сервисами, тысячи полигонов на canvas «тормозят клиента», браузеры «жрут» память в огромных количествах и т.п. Это не говоря уже о том, что хоть и редко, но необходима поддержка «старых» браузеров, не поддерживающих canvas/html5.
##### Простой пример
Представьте что-то подобное этой картинке, уменьшите масштаб и увеличьте тем самым количество полигонов в «кадре» до 5 000. Офисный компьютер двух- или трех-летней давности может и умереть на отрисовке такой карты. Бороться с этим можно просто добавив оверлей слой на карту со своими тайлами.
##### Исходные данные
Предположим, что у нас имеется таблица в MySQL базе данных, в которой описаны некие блоки, представленные координатами вершин полигона. В нашем примере, на картинке выше, это отрисованные вручную контуры кварталов города Екатеринбурга. Для каждого полигона есть дистанция от центра города, ее мы будем использовать для раскрашивания блоков, как пример визуализации каких-то данных (вариантов масса: плотность населения, загрязнение окружающей среды и т.п.)
##### Код
Код я постарался задокументировать как можно подробнее, чтоб было понятно новичкам. Код далеко не идеальный, написан за час, и претендует только для иллюстрации того, как это можно заставить работать.
```
php
// Подключаемся к базе данных, в нашем случае в файле mysql.php
// находится ООП-обертка для работы с mysql,
// которая сразу возвращяет объект $db.
require('mysql.php');
// Путь к папке с тайлами
$tiles_path = '/some/path/to/web/site/root/poly-tiles/';
// На всякий случай проверим если ли папка, в случае отсутствия создадим ее.
if (!file_exists($tiles_path)) {
mkdir($tiles_path, 0755);
}
// Забъем в массив все необходимые уровни зума на карте,
// для которых мы будем генерить наши тайлы
$zooms = array(12,13,14,15,16);
// Запрос на получение данных из БД, наши полигоны хранятся в ввиде кооринат
// вершин в колонке 'vertices', разделенные символом '|'
$query = 'SELECT * FROM map_blocks';
// Выполним запрос и выгребем все данные, тут использовата простая ООП обертка для БД
$result = $db-query($query);
// Переберем все блоки
while ($block = $db->fetch_array($result,1)) {
// Сохраним все наши блоки в массив с id блоков в качестве ключей
$blocks[$block['blockid']] = $block;
// Выдернем все вершины для блока и разделим их в список
$verticles = explode('|',$block['vertices']);
// Для каждой вершины блока выполним действия:
foreach ($verticles as $verticle) {
// Разделим на широту и долготу
$v_coord = explode(',',$verticle);
// и заполним ими два массива, делаем это здесь,
// чтоб не захламлять этим кодом функцию генерации
// и не повторять это для каждого зума
$lats[] = $v_coord[0];
$long[] = $v_coord[1];
}
}
// Теперь у нас есть массив с блоками и списки всех широт и долгот их вершин, работаем дальше
// Для каждого уровня зума:
foreach ($zooms as $zoom) {
// Создадим папку по имени уровня зума (вынесено в функцию для удобства)
make_zoom_dir ($zoom);
// Сгенерим для этого уровня зума большую картинку (описание внутри функции)
$bigimg = gen_map ($zoom,$blocks,$lats,$long);
// Сохраним на всякий случай в папку нужного зума как отдельное изображение
imagepng($bigimg,$tiles_path.$zoom.'/all.png');
// Ну и наконец, порежем это большое изображение на отдельные тайлы (описание внутри функции)
tile_map ($zoom,$bigimg,$blocks,$lats,$long);
}
// просто выход, делать больше нечего
exit;
/**
* gen_map
*
* Функция создает изображение с блоками для указанного зума.
*
* @param integer $zoom Уровень зума
* @param array $blocks Массив с блоками
* @param array $lats Массив с широтами
* @param array $long Массив с долготами
* @return gd_image $image Большое изображение с нашими блоками
*/
function gen_map ($zoom,$blocks,$lats,$long) {
// Вычислим координаты в зону которых помещаются ВСЕ наши блоки
$x['min'] = min($long);
$y['min'] = max($lats);
$x['max'] = max($long);
$y['max'] = min($lats);
// Получим номера тайлов для этих границ (getTile вернет x & y)
$tiles['tl'] = getTile ($zoom,$y['min'],$x['min']);
$tiles['rb'] = getTile ($zoom,$y['max'],$x['max']);
// Получим размер нашего изображение в количестве тайлов +1 (чтобы точно все влезло)
$picsize_blocks['x'] = $tiles['rb']['x'] - $tiles['tl']['x'] + 1;
$picsize_blocks['y'] = $tiles['rb']['y'] - $tiles['tl']['y'] + 1;
// Посчитаем размер нашего изображения в пикселах
$pict_w = $picsize_blocks['x'] * 256;
$pict_h = $picsize_blocks['y'] * 256;
// Так как номера тайлов считаются от 180/85 градусов долготы и широты,
// то посчитаем сдвиг от начала координат в пикселах
$world_shift['x'] = $tiles['tl']['x'] * 256;
$world_shift['y'] = $tiles['tl']['y'] * 256;
// Создаем GD-image нужного размера
$image = imagecreatetruecolor($pict_w, $pict_h);
// Делаем белый прозрачный цвет для подложки
$bg = imagecolorallocatealpha($image, 255, 255, 255, 0);
// Делаем его прозрачным в изображении
imagecolortransparent($image, $bg);
// Добавляем черный цвет
$black = imagecolorallocate($image, 0, 0, 0);
// Делаем набор цветов, будем красить блоки в зависимости расстояния от центра города
$color1 = imagecolorallocatealpha($image, 255, 0, 0, 50);
$color2 = imagecolorallocatealpha($image, 204, 0, 51, 50);
$color3 = imagecolorallocatealpha($image, 153, 0, 102, 50);
$color4 = imagecolorallocatealpha($image, 102, 0, 153, 50);
$color5 = imagecolorallocatealpha($image, 51, 0, 204, 50);
$color6 = imagecolorallocatealpha($image, 0, 0, 255, 50);
// Красим изображение в белый продрачный цвет подложки
imagefilledrectangle($image, 0, 0, $pict_w-1, $pict_h-1, $bg);
// Обрабатываем блоки:
foreach ($blocks as $block_id=>$block_data) {
// Выдергиваем из элемента массива строку с вершинами блока
$vertices = $block_data['vertices'];
// Раздергиваем в список координат вершин
$verticles_data = explode('|',$vertices);
// Для каждого набора вершин:
foreach ($verticles_data as $vert) {
// Раздергиваем координаты вершины на широту и долготу
$b_coord = explode(',',$vert);
// Вычисляем координаты в пикселах для глобального начала координат, для текущего зума
$vx = lonToX($b_coord[1], $zoom);
$vy = latToY($b_coord[0], $zoom);
// Заполняем массив вершин блоков в ключ 'verts' вычитая сдвиг
$vershiny[$block_id]['verts'][] = $vx - $world_shift['x'];
$vershiny[$block_id]['verts'][] = $vy - $world_shift['y'];
}
// Заполняем количество вершин блока в ключе 'vcount'
// (это может понадобиться если вершины всего две - то можно рисовать линию,
// сдесь мы это не использовали потому, что линий у нас нет). Кроме того,
// для функции рисования полигона необходимо количество вершин.
$vershiny[$block_id]['vcount'] = intval(count($vershiny[$block_id]['verts'])/2);
}
// И наконец то рисуем блоки полигонами закрашенными нужным цветом
// На самом деле вы можете в зависимости от каких-то параметров блока менять цвета и т.п.
foreach ($vershiny as $block_id=>$b_data) {
// Неоптимальный выбор с пачкой if, сделано для быстроты.
$block_dist = $blocks[$block_id]['distance'];
if ( $block_dist >= 0 && $block_dist < 1000 ) {
imagefilledpolygon($image, $b_data['verts'], $b_data['vcount'], $color1);
}
if ( $block_dist >= 1000 && $block_dist < 2000 ) {
imagefilledpolygon($image, $b_data['verts'], $b_data['vcount'], $color2);
}
if ( $block_dist >= 2000 && $block_dist < 4000 ) {
imagefilledpolygon($image, $b_data['verts'], $b_data['vcount'], $color3);
}
if ( $block_dist >= 4000 && $block_dist < 7000 ) {
imagefilledpolygon($image, $b_data['verts'], $b_data['vcount'], $color4);
}
if ( $block_dist >= 7000 && $block_dist < 10000 ) {
imagefilledpolygon($image, $b_data['verts'], $b_data['vcount'], $color5);
}
if ( $block_dist >= 10000 && $block_dist < 15000) {
imagefilledpolygon($image, $b_data['verts'], $b_data['vcount'], $color6);
}
if ( $block_dist >= 15000) {
imagefilledpolygon($image, $b_data['verts'], $b_data['vcount'], $black);
}
}
// Возвращаем большую отрисованную картинку
return $image;
}
/**
* tile_map
*
* Функция режет большую картинку на тайлы
*
* @param integer $zoom Уровень зума
* @param gd_image $img Боьшая картинка, которую надо порезать
* @param array $blocks Массив с блоками
* @param array $lats Массив с широтами
* @param array $long Массив с долготами
*/
function tile_map ($zoom,$img,$blocks,$lats,$long) {
global $tiles_path;
// Вычислим координаты в зону которых помещаются ВСЕ наши блоки
$x['min'] = min($long);
$y['min'] = max($lats);
$x['max'] = max($long);
$y['max'] = min($lats);
// Получим номера тайлов для этих границ (getTile вернет x & y)
$tiles['tl'] = getTile ($zoom,$y['min'],$x['min']);
$tiles['rb'] = getTile ($zoom,$y['max'],$x['max']);
// Обычный вложенный цыкл по двум осям:
// Бежим по горизонтали
for($x = $tiles['tl']['x']; $x<=$tiles['rb']['x']; $x++) {
// Бежим по вертикали
for($y = $tiles['tl']['y']; $y <= $tiles['rb']['y']; $y++) {
// Вычисляем позицию в тайлах
$from_position_x = $x - $tiles['tl']['x'];
$from_position_y = $y - $tiles['tl']['y'];
// Вычисляем позицию в пикселах
$from_x = $from_position_x * 256;
$from_y = $from_position_y * 256;
// Создаем GD-image тайл
$tile = imagecreatetruecolor(256, 256);
// Делаем белый прозрачный цвет для подложки
$bg = imagecolorallocatealpha($tile, 255, 255, 255, 0);
// Копируем с наложением из большой картинки нужный кусок
// (для сохранения прозрачности)
imagecopymerge($tile,$img,0,0,$from_x,$from_y,256,256,100);
// Добавляем белый цвет
$white = imagecolorclosest ($tile, 255,255,255);
// Добавляем черный цвет
$black = imagecolorclosest ($tile, 0,0,0);
// Делаем цвет подложки прозрачным
imagecolortransparent($tile, $bg);
// Можно сделать так же белый и черный, приведено как пример
imagecolortransparent($tile, $white);
imagecolortransparent($tile, $black);
// Создаем в папке нужного уровня зума папку для X тайлов
make_zoom_x_dir ($zoom,$x);
// Генерируем имя тайла
// оно будет что-то вроде: {$tiles_path}/{$zoom_dir}/{$x}/{$x}x{$t}.png
$tile_name = make_tile_name ($zoom,$x,$y);
// Это некоторая отладка, чтоб видеть прогресс генерации
echo "Zoom: $zoom, $x x $y -> $tile_name\n";
// Сохраняем тайл в файл
imagepng($tile,$tile_name);
// И уничтожаем GD-image тайла, чтоб не память не жрать :-)
imagedestroy($tile);
}
}
// И уничтожаем GD-image большой картинки, чтоб не память тоже не жрать :-)
imagedestroy($img);
}
/**
* make_tile_name
*
* Функция возвращает имя файла для тайла в нужном уровне зума
* и порядковыми номерами тайла в x & y
*
* @param integer $zoom Уровень зума
* @param integer $x Номер тайла X
* @param integer $y Номер тайла Y
* @return string Полный путь к файлу тайла
*/
function make_tile_name ($zoom,$x,$y) {
global $tiles_path;
return $tiles_path.$zoom.'/'.$x.'/'.$y.'.png';
}
/**
* make_zoom_dir
*
* Функция создает папку для необходимого уровня зума
*
* @param integer $zoom Уровень зума
*/
function make_zoom_dir ($zoom) {
global $tiles_path;
if (!file_exists($tiles_path.$zoom)) {
mkdir($tiles_path.$zoom, 0755);
}
}
/**
* make_zoom_x_dir
*
* Функция создает папку для необходимого уровня зума и X тайлов
*
* @param integer $zoom Уровень зума
* @param integer $x Номер тайла X
*/
function make_zoom_x_dir ($zoom,$x) {
global $tiles_path;
if (!file_exists($tiles_path.$zoom.'/'.$x.'/')) {
mkdir($tiles_path.$zoom.'/'.$x.'/', 0755);
}
}
/**
* lonToX
*
* Returns longitude in pixels at a certain zoom level
*
* @param float $lon longitude
* @param integer $zoom Уровень зума
*/
function lonToX($lon, $zoom) {
$offset = 256 << ($zoom-1);
$x = round($offset + ($offset * $lon / 180));
return $x;
}
/**
* lonToX
*
* Returns latitude in pixels at a certain zoom level
*
* @param float $lat latitude
* @param integer $zoom Уровень зума
*/
function latToY($lat, $zoom) {
$offset = 256 << ($zoom-1);
$y = round($offset - $offset/pi() * log((1 + sin($lat * pi() / 180)) / (1 - sin($lat * pi() / 180))) / 2);
return $y;
}
/**
* getTile
*
* Returns tile x & y numbers at a certain zoom level, latitude & longitude
*
* @param integer $zoom Уровень зума
* @param float $lat latitude
* @param float $lon longitude
*/
function getTile ($zoom,$lat,$lon) {
$tile['x'] = floor((($lon + 180) / 360) * pow(2, $zoom));
$tile['y'] = floor((1 - log(tan(deg2rad($lat)) + 1 / cos(deg2rad($lat))) / pi()) /2 * pow(2, $zoom));
return $tile;
}
/**
* tilenums2latlon
*
* Convert tile coordinates pair to latitude, longitude.
*
* @param int $_xtile X coordinate of the tile.
* @param int $_ytile Y coordinate of the tile.
* @param itn $_zoom Zoom level.
* @return Point Returns latitude and longitude as a {@link Point} object.
*/
function tilenums2latlon($_xtile, $_ytile, $_zoom)
{
$factor = pow(2.0, floatval($_zoom));
$coord['lon'] = ($_xtile * 360 / $factor) - 180.0;
$lat = atan(sinh(M_PI * (1 - 2 * $_ytile / $factor)));
$coord['lat'] = degrees($lat);
return $coord;
}
/**
* Utility function. Transforms degree value to radian one.
*
* @param float $_degrees Degree value.
* @return float Radian value.
*/
function radians($_degrees)
{
return M_PI * $_degrees / 180;
}
/**
* Utility function. Converts radians to degrees.
*
* @param float $_radians Radian value.
* @return float Degree value.
*/
function degrees($_radians)
{
return $_radians * 180 / M_PI;
}
?>
```
##### Как это работает
1. Вычисляем границы зоны, в которую поместятся все наши данные
2. Генерим большую картинку для каждого уровня зума
3. Рисуем в ней наши данные
4. Разрезаем ее на мелкие кусочки 256х256
5. Раскладываем их по папочкам
Далее все просто, создаем в Google Map API дополнительный Map Type
```
var BWPolygonsOptions = {
getTileUrl: function(ll, z) {
var X = ll.x % (1 << z); // wrap
return "http://some.host.com/poly-tiles/" + z + "/" + X + "/" + ll.y + ".png";
},
tileSize: new google.maps.Size(256, 256),
isPng: true,
minZoom: 12,
maxZoom: 16,
name: "BWPolygons",
alt: "BWPolygons"
};
var BWPolygonsMapType = new google.maps.ImageMapType(BWPolygonsOptions);
```
И внедряем как оверлей слой
```
map.overlayMapTypes.insertAt(0, BWPolygonsMapType);
```
Хорошо разбирающиеся в Google Map API могут обвешивать этот слой по желанию выключателями и другими украшениями, мы же остановимся на этом.
##### Демо
Результат работы [здесь](http://croud.ru/map-demo/).
##### Скорость
Для примера использовалось **2 873** блоков, находящихся в пределах границ города Екатеринбурга.
Количество тайлов для зумов с 12 по 16 — **5 118**.
Время работы данного скрипта **1 минута 11 секунд**.
Генерация производилась на сервере HP Proliant DL 360 G5 (1 Intel Xeon E5420 @ 2.50GHz, 4 Gb RAM)
С блогом определиться затруднился, выставил в PHP, желающие перенести в более подходящий — велком. | https://habr.com/ru/post/146107/ | null | ru | null |
# ExConsole — экстренная консоль для Python
Пост обещает быть сверхкратким.
**ExConsole** позволяет встроить интерактивную консоль-отладчик в Python-приложение. Консоль вызывается при фатальном исключении либо по приему SIGQUIT (он же Ctrl-\).
Пример использования:
```
import exconsole
exconsole.register()
do_dangerous_stuff()
```
Пример работы с консолью:
```
Activating emergency console
----------------------------
Caused by:
ZeroDivisionError
integer division or modulo by zero
Stack frames:
[ 0] example.py:17
[ 1] example.py:15
Tester().test()
[ 2] example.py:9
self.inner()
[ 3] example.py:6
self.divide(2, 0)
> [ 4] example.py:3
return a / b
On frame 4
Source:
def divide(self, a, b):
>> return a / b
Press Ctrl-D to leave console
Type "_help()"" for built-in commands
>>> print a,b
2 0
>>> _f(3)
On frame 3
Source:
def inner(self):
>> self.divide(2, 0)
>>> print self
<__main__.Tester instance at 0x7f67c9a0e440>
```
Консоль поддерживает перемещение по фреймам стека и работу с местными переменными, а также позволяет выйти и продолжить выполнение приложения.
Встроенные команды:
* **\_s()** — вывод стека
* **\_f(index)** — перемещение в другой фрейм
* **\_exc** — объект пойманного исключения (если оно было)
Поддерживается Python 2.6+ и 3.
Пакеты для Debian и CentOS доступны в [репозитории Ajenti](http://docs.ajenti.org/man/install/general.html)
Ссылки: [Github](https://github.com/Eugeny/exconsole) [PyPI](https://pypi.python.org/pypi/python-exconsole) | https://habr.com/ru/post/190924/ | null | ru | null |
# Создание агента расширения SNMP
Добрый день. Речь пойдет об использовании протокола SNMP, но немного не в том ключе, как все привыкли. Википедия сообщает, что данный «протокол обычно используется в системах сетевого управления для контроля подключенных к сети устройств на предмет условий, которые требуют внимания администратора». Такими устройства зачастую являются маршрутизаторы, хабы, коммутаторы, мосты, принтеры и, естественно, сами компьютеры. Для реализации функции контроля на каждом таком устройстве присутствует агент SNMP, в непосредственные обязанности которого входит сбор информации и передача ее менеджеру по запросу.
Изначально, данная функция реализована в виде службы SNMP, которая берет на себя всю черновую работу, касающуюся деталей протокола. Вся доступная агенту информация находится в базах управляющей информации (MIB), где каждому параметру устройства поставлен в соответствие уникальный идентификатор, называемый OID'ом. Таким образом, чтобы прочитать необходимое значение параметра сетевого устройства, менеджеру необходимо сделать запрос, в котором указать OID данного параметра. Агент, получив запрос, находит в MIB данный параметр и возвращает менеджеру значение. Все очень просто.
Если же нам необходимо расширить базовую функциональность агента, то необходимо написать агента расширения с требуемыми возможностями. Физически, агент расширения представляет из себя dll, которая экспортирует как минимум 3 функции:
* SnmpExtensionInit
* SnmpExtensionQuery
* SnmpExtensionTrap
Работу агента расширения поясню на рисунке:
Допустим, что наш агент расширения установлен на обычном компьютере. При загрузке ОС происходит вызов SnmpExtensionInit, в результате чего агент осуществляет подготовку к работе. Во-первых, он указывает «зону своей ответственности», т.е. диапазон OID'ов, при запросе к которым следует вызывать именно этого агента. Кроме этого, могут выполняться другие подготовительные мероприятия, например, загрузка в память значений параметров, подлежащих мониторингу со стороны менеджера и т.п.
После отправки менеджером запроса, служба SNMP устанавливает, что данный запрос попадает «под ответственность» нашего агента и «дергает» соответствующую dll'ку. И наш агент, в соответствии с запросом, производит либо чтение параметра, либо запись нового значения.
Для регистрации агента в системе, необходимо создать строковый параметр в разделе HKLM->System->CurrentControlSet->services->SNMP->Parameters->ExtensionAgents со следующим по порядку номером.
Значением данного параметра будет путь в реестре к строковому параметру Pathname, который должен находиться в разделе Software. Например, «Software\Test\SnmpExtAgent\CurrentVersion». Т.е. нам нужно создать в Software 3 раздела: Test,SnmpExtAgent и CurrentVersion. Затем, создаем строковый параметр Pathname, значением которого будет путь до нашей dll'ки.
Естественно, у нас на компьютере должна быть установлена служба SNMP. Если ее нет, то идем в Установка и удаление программ"->«Установка компонентов Windows». Там ставим галочку в «Средства управления и наблюдения» и устанавливаем. В Win XP понадобиться установочный диск, в Win 7 обходится без него.
Далее, идем в Мой компьютер->Управление->Службы. Находим заветную строчку «Служба SNMP» и в свойствах, на вкладке «Безопасность» создаем сообщество public с правами READ WRITE. Перезапускаем службу, агент готов к работе.
Теперь немного кода.
Функция **SnmpExtensionInit**:
```
BOOL SNMP_FUNC_TYPE SnmpExtensionInit( DWORD dwUptimeReference,
HANDLE *phSubagentTrapEvent,
AsnObjectIdentifier *pFirstSupportedRegion)
{
*pFirstSupportedRegion = MIB_OidPrefix; // это и есть наша "зона ответственности"
*phSubagentTrapEvent = g_hSimulateTrap;//эта строчка относится к использованию ловушек
// инициализируем два строковых и один целочисленный параметр
g_szAbout = (char*)malloc(sizeof(char)*64);
strcpy(g_szAbout,"Author : Ramanan.T");
g_szName = (char*)malloc(sizeof(char)*64);
strcpy(g_szName,"Your Name");
g_asnIntAge = 0;
g_dwStartTime = GetTickCount();
return SNMPAPI_NOERROR;
}
```
Функция **SnmpExtensionQuery**:
```
BOOL SNMP_FUNC_TYPE SnmpExtensionQuery( BYTE bPduType,
SnmpVarBindList *pVarBindList,
AsnInteger32 *pErrorStatus,
AsnInteger32 *pErrorIndex)
{
int nRet = 0;
AsnObjectName;
*pErrorStatus = SNMP_ERRORSTATUS_NOERROR;
*pErrorIndex = 0;
for(UINT i=0;ilen;i++)
{
\*pErrorStatus = SNMP\_ERRORSTATUS\_NOERROR;
// Перебираем типы запросов
switch(bPduType)
{
case SNMP\_PDU\_GET: //запрос GET
\*pErrorStatus = GetRequest(&pVarBindList->list[i]);
if(\*pErrorStatus != SNMP\_ERRORSTATUS\_NOERROR)
\*pErrorIndex++;
break;
case SNMP\_PDU\_GETNEXT: //запрос GETNEXT
\*pErrorStatus = GetNextRequest(&pVarBindList->list[i]);
if(\*pErrorStatus != SNMP\_ERRORSTATUS\_NOERROR)
\*pErrorIndex++;
break;
case SNMP\_PDU\_SET: //запрос SET
\*pErrorStatus = SetRequest(&pVarBindList->list[i]);
if(\*pErrorStatus != SNMP\_ERRORSTATUS\_NOERROR)
\*pErrorIndex++;
break;
default:
\*pErrorStatus = SNMP\_ERRORSTATUS\_NOSUCHNAME;
\*pErrorIndex++;
};
}
return SNMPAPI\_NOERROR;
}
```
Видим, что посредством структуры [**pVarBindList**](http://msdn.microsoft.com/en-us/library/windows/desktop/aa378936(v=vs.85).aspx) к нам приходит OID требуемого параметра и в функциях **GetRequest** и **GetNextRequest** в эту же структуру мы запишем значения этих параметров.
Итак, что же получается в итоге. Мы можем написать dll, которая будет вызываться системой в случае получения запросов по сети. А вот что мы уже будем делать внутри этой самой **SnmpExtensionQuery** — дело наше. То есть, мы, получив запрос от менеджера имеем возможность выполнять произвольные действия. Учитывая, что служба SNMP есть практически на всех компьютерах, получаем достаточно широкие возможности управления техническими средствами, работающими под управлением компьютеров, т.е. любыми.
Спасибо за внимание.
Ссылки:
1. [www.codeproject.com/Articles/9024/How-to-develop-a-SNMP-extension-agent-DLL](http://www.codeproject.com/Articles/9024/How-to-develop-a-SNMP-extension-agent-DLL) | https://habr.com/ru/post/147365/ | null | ru | null |
# Избавляемся от дублей пакетов в бандлах
Существует много webpack пакетов находящих дубли в бандле, самый популярный из них [duplicate-package-checker-webpack-plugin](https://www.npmjs.com/package/duplicate-package-checker-webpack-plugin), но он требует пересборки проекта, а так как стояла задача автоматизировать подбор оптимальной версии пакетов, то и вовсе получилось свое альтернативное решение.
Ну или моя история как получилось уменьшить бандл на 15%, за несколько секунд.
Как и во многих крупных компаниях у которых есть огромная кодовая база, много единой логики, как следствие используем общие компоненты, публикуемые в свой npm репозиторий. Публикуются они через [lerna](https://github.com/lerna/lerna), соответственно перед каждой установкой или обновлением общих компонентов возникает вопрос, какую версию устанавливать. lerna перепаблишивает все компоненты, которые используют публикуемый компонент (если версия до этого последняя была). Соответственно, всегда есть версии нескольких компонентов, которые лучше подходят друг к другу, так как не конкурируют зависимостями.
Из open source проектов подобным образом паблишиться [nivo](https://github.com/plouc/nivo), вот [их конфиг lerna](https://github.com/plouc/nivo/blob/master/lerna.json).
**Как появляются тогда дубли зависимостей? И как их устранять?**
Предположим, у вас есть простой проект со следующим `package.json`:
```
{
"name": "demo-project",
"version": "1.0.0",
"dependencies": {
"@nivo/bar": "0.54.0",
"@nivo/core": "0.53.0",
"@nivo/pie": "0.54.0",
"@nivo/stream": "0.54.0"
}
}
```
Посмотрим, где используется `@nivo/core`:
```
npm list @nivo/core
```
Видим 4 копии `@nivo/core` (3 экземпляра `0.54.0` и 1 — `0.53.0`). Но если мы поменяем минорную версию `@nivo/core` на `0.54.0`, дубли устранятся.
Текущий пример прост, но на практике, естественно зависимостей у каждого пакета больше, и еще нужно рассмотреть подзависимости дальше, что увеличивает сложность задачи.
И как-то очередной раз увидев огромный размер бандла, мне надоело вручную устранять дубли пакетов.
Вообще правильно сразу обновлять пакеты до последней версии, но времени как всегда нет, чтобы менять мажорные версии, а в слепую подбирать перебором подходящий пакет долго и сложно. Ведь нужно обновить версию зависимости в `package.json`, установить новые зависимости, и после проверить исчезли ли дубли в билде, если нет — повторить, долго, в среднем минуты 3-4 на итерацию.
Все это монотонно и требует внимательности, поэтому решил автоматизировать.
Хотелось бы узнать дубликаты без переустанавки зависимостей, и пересборки проекта, в идеале cli приложение выводящее варианты оптимизаций за 10 секунд и все существующие дубли в проекте.
**Устранение дублей** можно поделить на несколько подзадач, рассмотрим их по порядку.
**Первая задача.** Нужно смоделировать будущее дерево зависимостей бандла только по package.json, учитывая стандартный dedupe, быстро, не более чем за 100ms.
Решил использовать [package-json](https://www.npmjs.com/package/package-json) для получения информации по пакетам и [semver](https://www.npmjs.com/package/semver) для сравнения различных версий.
В итоге получился npm пакет [dependencies-tree-builder](https://github.com/itwillwork/dependencies-tree-builder), шустро моделирующий дерево зависимостей бандла только по package.json.
Выделил в отдельный компонент, ибо может быть кто-нибудь переиспользует его в комбинаторных задач с package.json.
**Вторая задача.** Комбинаторная задача, эффективный перебор вариантов изменения зависимостей, и сравнение нескольких вариантов деревьев, ну и естественно выбор оптимального.
Надо было как-то сравнивать качественно получившейся деревья, и пришлось позаимствовать идею энтропии, как количественное измерение беспорядка, взял сумму экземпляров дублей (из примера выше она равна 3).
Было бы здорово еще учитывать веса пакетов (в КБ), но к сожалению, пакета который бы быстро работал с весами я не нашел, а те что есть работают примерно по пол минуты на пакет, к примеру [package-size](https://www.npmjs.com/package/package-size). Так как работают по следующему принципу: создают проект с единственной зависимостью, устанавливают зависимости, после измеряется суммарный вес папки. В итоге, другого критерия, как количество экземпляров дублей не придумал.
Чтобы понять какой пакет нужно изменить, рассматриваются причины дублей, конкретнее источник и эффект. Перебором устраняются дубли эффектов, насколько это возможно, а так как эффекты устраняются, то и дубли в последствии тоже.
**В итоге**, получилось небольшое cli приложение [ostap](https://github.com/itwillwork/ostap), рекомендующее оптимальные версии для уменьшения количества экземпляров дублей в бандле.
Запускается просто указанием на package.json вашего проекта.
```
ostap ./package.json
```
Еще можно использовать для быстрого просмотра всех будущих дублей без пересборки проекта меняя лишь версии в package.json.
```
ostap ./package.json -s
```
По итогу, в моем проекте суммарный вес бандлов снизился на 15%.
В [репозитории](https://github.com/itwillwork/ostap#quick-start) есть раздел quick start.
Если используете route-splitting, может показаться, что какие-то бандлы увеличились в весе, но возможно изменилось распределение компонентов. То есть вместо копий зависимостей на каждой странице, единственная версия перешла в общий бандл для всех страниц, поэтому нужно оценивать суммарный вес бандлов по всем страницам.
Надеюсь, статья была полезной. И кому-то информация сэкономит время. Спасибо.
Еще раз ссылочки для удобства:
* Пакет моделирующий дерево зависимостей бандла по package.json
[GitHub](https://github.com/itwillwork/dependencies-tree-builder);
* Оптимизатор зависимостей для устранения дублей в бандле
[GitHub](https://github.com/itwillwork/ostap).
Если есть интересные идеи пишите в issue на github'е, обсудим. | https://habr.com/ru/post/445878/ | null | ru | null |
# Защита от DDOS атак средствами BGP
Сервера, размещенные в сети администрируемой мной AS, часто подвергаются различным DDOS атакам. Целью атакующих могут быть, как отдельные ресурсы размещенные на серверах, сами сервера и вся площадка в целом. С каждым месяцем количество, сложность и мощность атак возрастает. Атаки в 300-400Мб/с выросли до 70-80Гб/с. В этой ситуации не все атаки могут быть отражены тюнингом серверов, а крупные атаки могут помешать работе и всей площадки в целом. Бороться с такими атаками необходимо силами всей команды хостинга. Сетевые администраторы также должны иметь средства борьбы с такими атаками на сетевом уровне. О таких средствах и пойдет речь под катом.
В статье будет рассматриваться основной метод защиты от DDOS атак средствами динамической маршрутизации: — метод Blackhole («черной дыры»).
Этот метод позволяет полностью прекратить поток трафика на атакуемый сервер и снять нагрузку с каналов AS и провайдера. В условиях предоставления услуг виртуального хостинга высокой доступности этот метод является крайней мерой, но остается эффективным средством для борьбы с крупными DDOS атаками, когда другими средствами справиться не удается.
Поясним несколько терминов, которые будут встречаться в статье:
**BGP (Border Gateway Protocol)** — основной протокол динамической маршрутизации в глобальной сети интернет. Позволяет маршрутизаторам обмениваться таблицами маршрутизации. Предоставляет гибкие средства для управления трафиком.
**BGP community** — атрибут протокола динамической маршрутизации BGP, позволяющий устанавливать определенные метки на передаваемые маршруты. Атрибут позволяет создавать и устанавливать пользовательские значения (установлен только рекомендуемый формат community) и на их основании гибко настраивать фильтры маршрутизатора.
**peering** — установленная сессия BGP для обмена маршрутами.
**Анонсирование сети** — в терминологии протоколов динамической маршрутизации, отправка маршрутов из локальной таблицы маршрутизации соседнему маршрутизатору.
**AS (Autonomous System)** — набор IP-сетей, управляемых одним оператором по установленным [правилам](http://tools.ietf.org/html/rfc1930) глобальной сети Интернет.
**eBGP (External Border Gateway Protocol)** — тип обмена маршрутами по протоколу BGP между маршрутизаторами разных AS.
**iBGP (Internal Border Gateway Protocol)** — тип обмена маршрутами по протоколу BGP между маршрутизаторами внутри AS.
**policy-statement** — в рамках конфигурации маршрутизаторов Juniper представляет собой набор правил, определяющих условия фильтрации маршрутов, получаемых или передаваемых по протоколам динамической маршрутизации.
**DDOS (Distributed Denial of Service)** — распределённая атака типа «отказ в обслуживании». Атака, для которой используется сеть компьютеров по всему миру зараженных вредоносным программным обеспечением (ботнет), осуществляющих генерацию трафика или атаку на жертву.
**UDP Amplification** — разновидность DDOS атаки, для реализации которой используются сторонние сервера с открытыми UDP портами и службами SNMP, NTP, DNS. Как правило этот вид атаки направлен на пропускную способность канала жертвы.
**ISP (Internet Service Provider)** — организация, предоставляющая услуги доступа к сети Интернет, попросту — провайдер.
#### BGP blackhole
Blackhole позволяет управлять трафиком на уровне провайдера, до попадания в нашу AS. Он эффективен для борьбы с крупными атаками на пропускную способность канала (чаще всего [DNS Amplification](http://habrahabr.ru/post/51574/)). В [классической схеме](http://tools.ietf.org/html/rfc3882) метод предполагает выставление next-hop для анонсируемого маршрута на ip адрес из приватной сети. Так как у магистральных провайдеров маршруты до приватных сетей, по большей части, должны быть направлены в Null0 (Cisco терминология, в Juniper — discard) пакеты с адресом назначения из этой сети буду автоматически отбрасываться — попадать в «черную дыру» еще в сети провайдера. К сожалению, в реальных сетях магистральных провайдеров не всегда установлены маршруты приватных сетей в Null0, так как сами провайдеры используют эти адреса для маршрутизации или попросту не следуют рекомендациям RFC. Для установки blackhole, чаще всего, используются расширенные возможности управления маршрутами BGP — BGP community. Метод реализуется путем создания специальной группы (community) для маршрутов, трафик которых необходимо направить в «черную дыру». В момент начала атаки у сетевого администратора атакуемой AS будет возможность передать маршрут с длинной маски /32 подкрепив его этим community, тем самым сообщив маршрутизаторам ISP о том, что пакеты до этого ip адреса должны отбрасываться. Фильтрация пакетов на стороне ISP может осуществляться как с помощью ACL так и с помощью Null интерфейса, но наиболее правильных подход предполагает рекурсивный blackhole. Схематически метод рекурсивного blackhole показан ниже:
Атакующие из AS3 и AS4 производят атаку на веб-сервер с ip адресом 1.1.1.1 который находится в AS2. Сетевой администратор AS2 устанавливает в blackhole адрес сервера передавая маршрут к его ip адресу с community 666. Маршрутизатор ISP получая маршрут /32 с установленным blackhole community начинает отбрасывать все пакеты направленные на адрес ip 1.1.1.1. Кроме того, чтобы снять нагрузку с собственных каналов, ISP (AS1) передает этот маршрут далее своим провайдерам устанавливая на него blackhole community предоставленные ими (на схеме это community 3:666 и 4:666). Такой метод защиты гораздо эффективнее простой фильтрации пакетов на маршрутизаторе AS2, так как снимает нагрузку с каналов между AS1 и AS2, а также eBGP каналов провайдера AS1. Отбрасывание пакетов направленных на ip адрес 1.1.1.1 происходит на маршрутизаторах провайдеров к которым непосредственно подключены атакующие. Если атакующий подключен к другой AS (не принадлежит AS провайдера), то каждый из провайдеров AS3 и AS4 может анонсировать маршрут с blackhole community дальше своим провайдерам, а те в свою очередь своим и т.д. Таким образом все сети магистральных провайдеров будут разгружены от DDOS трафика.
#### практика BGP blackhole
Статья была бы не полной без примера практической реализации. Метод практического применения показан на примере маршрутизаторов Juniper, но может быть реализован на оборудовании любого вендора.
##### Настройка провайдерской стороны
Сначала необходимо создать определенный community для обозначения префиксов установленных в blackhole:
```
set policy-options community TEST_blackhole members 1:666
```
где 1 — это номер AS провайдера (позволяет community оставаться уникальным даже при передаче по сетям других ISP), 666 — уникальный номер community (может быть любым, но рекомендуется использовать 666). Далее создаем Policy для импорта префиксов от нашего пира, выбираем из них префиксы с community blackhole и заворачиваем их в Null (в Juniper это discard):
```
[edit policy-options policy-statement Blackhole-import]
term to-blackhole {
from community TEST_blackhole;
then {
community add ISP-community; # Добавляем blackhole community вышестоящего ISP чтобы пакеты отбрасывались еще выше
next-hop discard;
accept;
}
}
```
Назначаем этот policy-statement на eBGP сессию для импортируемых (получаемых) префиксов от клиентов.
##### Настройка клиентской стороны
Аналогичным образом, сначала, создается community для обозначения префиксов установленных в blackhole:
```
set policy-options community TEST_blackhole members 1:666
```
Значения те же самые как и на стороне провайдера, с той лишь разницей, что номер AS должен соответствовать AS провайдера, то есть, кто выдает community тот и устанавливает его обозначение. Далее создаем policy-statement для добавления community к префиксам которые надо передавать маршрутизатору ISP.
```
policy-statement Blackhole-export {
term blackhole {
from {
protocol static;
tag 666;
}
then {
community set TEST_blackhole;
accept;
}
}
then reject;
}
```
Префиксы выбираются из static маршрутов. Так как маршрутизатор изначально знает только о сетях больше /32, специфичный префикс нужно создавать отдельно. Как видно из правила from, этот policy-statement будет выбирать все статические маршруты с тегом 666 (номер тега может быть любым). Назначаем этот policy-statement в качестве фильтра export на eBGP сессию к нашему провайдеру. Теперь, если есть необходимость поставить адрес сервера в blackhole создаем статический маршрут /32 на нашем маршрутизаторе.
Например, для установки в blackhole адреса указанного на схеме надо выполнить команду:
```
set routing-options static route 1.1.1.1/32 discard tag 666
```
где 1.1.1.1 — это ip адрес устанавливаемый в blackhole.
#### Заключение
Описанный метод позволяет бороться с атаками, которые мешают корректной работе всей площадки. Такие атаки могут достигать сотен Гигабит/сек и с ними не всегда может справиться даже магистральный провайдер. Атрибут BGP community широко используется магистральными провайдерами для классификации трафика и оперативного управления. Многие ISP предоставляют целый набор community, которые позволяют не только устанавливать определенные адреса в blackhole, но и управлять трафиком поступающим в их AS, то есть управлять трафиком еще на каналах провайдера. Анализ community провайдеров позволяет сетевому администратору разработать схему борьбы с DDOS атаками, а иногда и автоматизировать процесс ликвидации атак. | https://habr.com/ru/post/211176/ | null | ru | null |
# Сам себе туннельный брокер или нативный IPv6 на компе при помощи OpenVPN
Я — большой сторонник использования IPv6, стараюсь его использовать где это только возможно. Недавно подумав я решил, что на большинстве своих виртуалок переведу ssh на ipv6-only, биндить буду на рандомно выбранный при конфигурации адрес, который потом пропишу в ДНСах для своего удобства. Но возник вопрос с доступом с моего ноутбука к тем кого таким образом настрою. Понятно, что всегда можно ходить через сервер, где у меня IPv6, конечно же есть, обычно я так и делаю, но случаи бывают разные.
Почесав немного голову я понял, что я же могу взять какую-нибудь /112 из /64 даваемой хостером и раздать по OpenVPN своему ноуту и прочим личным машинам, тем самым получив настоящий ipv6, а не адрес от брокеров.
Решил, значит надо делать. Выбрал для этого виртуалку от vultr, на которой у меня ничего изначально не было и которая предназначена была для тестов и взялся за настройку.
Vultr выдает виртуалкам сети /64, в нашем примере пусть это будет сеть 2001:NNNN:NNNN:NNNN::/64, из нее мы возьмем «маленький» кусочек /112, который и будем раздавать своим компам, пусть это будет 2001:NNNN:NNNN:NNNN:80::/112. Процедуру генерации ключей для OpenVPN я описывать не буду, она достаточно подробно описана в других руководствах, рассмотрю только конфиг и скрипты, которые будут использоваться для наших целей.
В файле /etc/openvpn/variables мы пропишем сеть и маску которые будем использовать, отсюда у нас это дело заберут скрипты:
```
# Subnet
prefix=2001:NNNN:NNNN:NNNN:80::
# netmask
prefixlen=112
```
Конфиг openvpn-сервера:
```
# Listen port
port 8149
# Protocol
proto udp
# IP tunnel
dev tap0
# Master certificate
ca ca.crt
# Server certificate
cert server.crt
# Server private key
key server.key
# Diffie-Hellman parameters
dh dh2048.pem
# Allow clients to communicate with each other
client-to-client
# Client config dir
client-config-dir /etc/openvpn/ccd
# Run client-specific script on connection and disconnection
script-security 2
client-connect "/usr/bin/sudo -u root /etc/openvpn/server-clientconnect.sh"
client-disconnect "/usr/bin/sudo -u root /etc/openvpn/server-clientdisconnect.sh"
# Server mode and client subnets
server 10.18.0.0 255.255.255.0
server-ipv6 2001:NNNN:NNNN:NNNN:80::/112
topology subnet
# IPv6 routes
push "route-ipv6 2001:NNNN:NNNN:NNNN::/64"
push "route-ipv6 2000::/3"
persist-key
persist-tun
# Ping every 10s. Timeout of 120s.
keepalive 10 120
# Enable compression
comp-lzo
# User and group
user vpn
group vpn
# Log a short status
status openvpn-status.log
verb 4
sndbuf 0
rcvbuf 0
```
В конфиге у нас прописаны скрипты, которые будут запускаться при подключении и отключении клиента:
server-clientconnect.sh
```
#!/bin/sh
# Check client variables
if [ -z "$ifconfig_pool_remote_ip" ] || [ -z "$common_name" ]; then
echo "Missing environment variable."
exit 1
fi
# Load server variables
. /etc/openvpn/variables
ipv6=""
# Find out if there is a specific config with fixed IPv6 for this client
if [ -f "/etc/openvpn/ccd/$common_name" ]; then
# Get fixed IPv6 from client config file
ipv6=$(sed -nr 's/^.*ifconfig-ipv6-push[ \t]+([0-9a-fA-F\\:]+).*$/\1/p' "/etc/openvpn/ccd/$common_name")
fi
# Get IPv6 from IPv4
if [ -z "$ipv6" ]; then
ipp=$(echo "$ifconfig_pool_remote_ip" | cut -d. -f4)
if ! [ "$ipp" -ge 2 -a "$ipp" -le 254 ] 2>/dev/null; then
echo "Invalid IPv4 part."
exit 1
fi
hexipp=$(printf '%x' $ipp)
ipv6="$prefix$hexipp"
fi
# Create proxy rule
/sbin/ip -6 neigh add proxy $ipv6 dev eth0
```
и server-clientdisconnect.sh
```
#!/bin/sh
# Check client variables
if [ -z "$ifconfig_pool_remote_ip" ] || [ -z "$common_name" ]; then
echo "Missing environment variable."
exit 1
fi
# Load server variables
. /etc/openvpn/variables
ipv6=""
# Find out if there is a specific config with fixed IPv6 for this client
if [ -f "/etc/openvpn/ccd/$common_name" ]; then
# Get fixed IPv6 from client config file
ipv6=$(sed -nr 's/^.*ifconfig-ipv6-push[ \t]+([0-9a-fA-F\\:]+).*$/\1/p' "/etc/openvpn/ccd/$common_name")
fi
# Get IPv6 from IPv4
if [ -z "$ipv6" ]; then
ipp=$(echo "$ifconfig_pool_remote_ip" | cut -d. -f4)
if ! [ "$ipp" -ge 2 -a "$ipp" -le 254 ] 2>/dev/null; then
echo "Invalid IPv4 part."
exit 1
fi
hexipp=$(printf '%x' $ipp)
ipv6="$prefix$hexipp"
fi
# Delete proxy rule
/sbin/ip -6 neigh del proxy $ipv6 dev eth0
```
Как можно было увидеть в конфиге сервера запускать мы его будем под пользоателем vpn, а потому нам надо добавить пользователя
# useradd vpn
и разрешить этому пользователю sudo на наши скрипты добавив в /etc/sudoers(не правьте его руками открывая напрямую в редакторе, вызывайте visudo, что бы перед сохранением проверить корректность файла!):
```
Defaults:vpn env_keep += "ifconfig_pool_remote_ip common_name"
vpn ALL=NOPASSWD: /etc/openvpn/server-clientconnect.sh
vpn ALL=NOPASSWD: /etc/openvpn/server-clientdisconnect.sh
```
Теперь включим ndp(Neighbor Discovery Protocol), который нам необходим для того, что бы наши хосты находили по IPv6 друг друга и что бы они были доступны из интернета по своим адресам, добавив в /etc/sysctl.conf(или в отдельный файл в /etc/sysctl.d/, по вашему желанию) строки:
```
net.ipv6.conf.all.forwarding=1
net.ipv6.conf.all.proxy_ndp = 1
```
и выполнив
# sysctl -p
Настроим адреса для отдельной машины создав файл с именем хоста который будет подключаться(имя должно совпадать с именем использовавшемся при создании сертификата для машины), пусть это будет abyrvalg-laptop в /etc/openvpn/ccd
/etc/openvpn/ccd/abyrvalg-laptop
```
ifconfig-push 10.18.0.101 255.255.255.0
ifconfig-ipv6-push 2001:NNNN:NNNN:NNNN:80::1001/112 2001:NNNN:NNNN:NNNN:80::1
```
Первым из IPv6-адресов указан адрес который будет выдаваться хосту, второй адрес его гейта.
Сервер готов, давайте напишем конфиг для клиента:
abyrvalg-laptop.conf
```
# Client mode
client
# IPv6 tunnel
dev tap
# TCP protocol
proto udp
# Address/Port of VPN server
remote SERVER_IP 8149
# Don't bind to local port/address
nobind
# Don't need to re-read keys and re-create tun at restart
persist-key
persist-tun
# User/Group
;user nobody
;group nobody
# Remote peer must have a signed certificate
remote-cert-tls server
ns-cert-type server
# Enable compression
comp-lzo
ca ca.crt
cert abyrvalg-laptop.crt
key abyrvalg-laptop.key
sndbuf 0
rcvbuf 0
```
И попробуем в ручном режиме запустить сервер и клиента для тестов. Я исхожу из того, что конфиг-файл сервера и файлы сертификатов лежат у вас в /etc/openvpn на сервере и конфиг-файл для клиента вместе с сертификатами лежат в /etc/openvpn на клиенте, конфиги при этом именуются server.conf на сервере и ipv6.conf на клиенте
На сервере делаем:
```
# cd /etc/openvpn
# openvpn ./server.conf
```
на клиенте
```
# cd /etc/openvpn
# openvpn ./ipv6.conf
```
Если все сделано правильно, то на клиенте команда ip -6 a s dev tap0 покажет нам что-то типа
```
48: tap0: mtu 1500 state UNKNOWN qlen 100
inet6 2001:NNNN:NNNN:NNNN:80::1001/112 scope global
```
и ping6 -c 4 ipv6.google.com
покажет:
```
PING ipv6.google.com(lr-in-x8a.1e100.net) 56 data bytes
64 bytes from lr-in-x8a.1e100.net: icmp_seq=1 ttl=46 time=110 ms
64 bytes from lr-in-x8a.1e100.net: icmp_seq=2 ttl=46 time=113 ms
64 bytes from lr-in-x8a.1e100.net: icmp_seq=3 ttl=46 time=110 ms
64 bytes from lr-in-x8a.1e100.net: icmp_seq=4 ttl=46 time=110 ms
--- ipv6.google.com ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3001ms
rtt min/avg/max/mdev = 110.586/111.367/113.285/1.183 ms
```
Вуаля! У нас теперь на нашем ноутбуке или стационарнике есть нормальный IPv6, без туннельных брокеров.
Для добавления старта openvpn при загрузке на ваших системах используйте штатные средства, в зависимости от дистрибутива они могут различаться.
При настройке и написании использована [данная](https://techblog.synagila.com/2016/02/24/build-a-openvpn-server-on-ubuntu-to-provide-a-ipv6-tunnel-over-ipv4/) статья, там же вы можете посмотреть на примеры генерации ключей для OpenVPN, если до этого их не генерировали. В отличии от оригинальной статьи я использую udp, а не tcp и tap, а не tun-девайсы. | https://habr.com/ru/post/321486/ | null | ru | null |
# Чистые и детерминированные функции
*Перевод [статьи Джастина Этеридж](http://www.codethinked.com/pure-and-deterministic-functions) (Justin Etheredge), в которой автор объясняет тонкую разницу между детерминированными и чистыми функциями.*
Вчера я читал [блог Мэтта Подвизоки](http://codebetter.com/matthewpodwysocki) (Matt Podwysocki) (этот блог, кстати, потрясающий, идите и подпишитесь), и у него есть пост [«Recursing into Recursion – Memoization»](http://codebetter.com/matthewpodwysocki/2008/08/01/recursing-into-recursion-memoization). Отличный пост, если вы хотите познакомиться с мемоизацией. У меня уже был [пост об обобщенной функции мемоизации](http://www.codethinked.com/lambdas-and-closures-and-currying-oh-my-part-7) некоторое время назад, поэтому мы будем говорить не о мемоизации. То, что возбудило во мне интерес, было в конце статьи Мэтта:
> Не забывайте, что корректная мемоизация требует, чтобы функция, которую вы пишете, была чистой. Это означает, что для одних и тех же входных данных будут вычисляться и возвращаться одни и те же результаты.
Моя первая мысль была «Эй, Мэтт, чистота подразумевает, что функция не имеет побочных эффектов, а детерминированность означает, что функция всегда возвращает одни и те же результаты для данных наборов параметров». Затем, как у любого хорошего программиста, моей второй мыслью было «На самом деле, возможно, я не прав». Поэтому я пошел и изучил этот вопрос, и не удивительно, что я ошибался.
Вот описание чистой функции из википедии:
> 1. Функция всегда вычисляет одинаковое результирующее значение для одних и тех же наборов аргументов. Результирующее значение функции не может зависеть от любой скрытой информации или [состояния](http://en.wikipedia.org/wiki/Program_state), которое может изменяться по мере выполнения программы, не может зависеть от любых внешних входных данных от устройств [ввода/вывода](http://en.wikipedia.org/wiki/Input/output).
> 2. Вычисление результата не должно вызывать любые семантически наблюдаемые [побочные эффекты](http://en.wikipedia.org/wiki/Side_effect_%28computer_science%29), такие как мутацию изменяемых объектов, или вывод в устройства ввода/вывода.
>
А вот определение детерминированного алгоритма Национальным Институтом стандартов и технологий (США):
> Алгоритм, поведение которого можно полностью предсказать по входным данным.
>
>
Поэтому чистые функции на самом деле являются подмножеством детерминированных функций. Все чистые функции являются детерминированными, но не все детерминированные функции являются чистыми. Например, мы могли бы иметь функцию, которая принимает определенный набор параметров и возвращает детерминированный результат и еще записывает значения на диск или выводит на консоль. По определению такая функция не будет чистой, хоть и будет детерминированной.
Например:
Детерминированная и чистая:
```
public int Add(int val1, int val2)
{
return val1 + val2;
}
```
Детерминированная, но не чистая:
```
public int Add(int val1, int val2)
{
Console.WriteLine(val1 + " " + val2);
return val1 + val2;
}
```
Детерминированные функции так же не могут использовать внешнее состояние, потому что оно повлияет на их функционирование. Большинство определений детерминированных функций говорит, что вы можете определить результат по входным данным.
Как Мэтт отметил в своем посте, для мемоизации очень важно, чтобы функция была детерминированной. Это очевидно: из-за того, что мы имеем множество входных данных и затем мы кешируем множество результатов, мы надеемся на то, что функция будет возвращать те же результаты после каждого вызова с этими входными данными, иначе своей мемоизацией мы поменяем поведение функции.
Чистота функций важна по многим причинам, но в первую очередь, потому что она позволяет нам легче рассуждать о поведении функции. Если функция чистая и не имеет побочных эффектов, то мы можем с большей уверенностью рассуждать о производительности этой функции, поскольку нам нужно будет рассматривать меньше переменных. Так же вы не можете эффективно заставить функцию с побочными эффектами выполняться параллельно без сложного анализа её поведения. Чистая функция не должна зависеть от чего бы то ни было, кроме значений переданных ей. Такая функция не меняет никакого разделенного состояния и поэтому может выполняться параллельно без использования блокировок.
Если вы не знали до этого, что представляют собой чистые функции, надеюсь теперь у вас есть хорошее представление. Так же я надеюсь, что если у вас были какие-то заблуждения на их счет, как у меня, теперь всё прояснилось.
Действительно здорово узнать что-то новое, но еще лучше узнать о том, что ваши знания были неверны. | https://habr.com/ru/post/149086/ | null | ru | null |
# BMW и диагностика по Ethernet: протокол HSFZ
Введение
--------
Разработчики автомобильных систем диагностики уже давно присматриваются к стандартам с большей скоростью передачи данных, чем классический CAN. С каждым новым поколением растет количество электронных блоков в автомобилях, их сложность и размер памяти. Без использования высокоскоростных способов передачи данных, тщательная диагностика и обновление прошивок могут затянуться на несколько часов, снижая эффективность работ по обслуживанию.
Одна из возможных опций - применение Ethernet. В BMW подумали так же и разработали собственный протокол для решения этой задачи.
Чтобы заранее устранить возможную путаницу, обозначим *два важных "не"*
* применяется не Automotive Ethernet, а самый обычный, "бытовой" Ethernet;
* применяется не стандартный DoIP (Diagnostics over Internet Protocol), а проприетарный протокол BMW HSFZ (High Speed Fahrzeugzugang).
Чем может быть интересен HSFZ? Во-первых, своей "проприетарщиной" и отличиями от DoIP, а во-вторых, он появился раньше DoIP на несколько лет. Первая версия DoIP (ISO 13400-2) вышла в 2012 году, к этому времени на рынке уже вовсю продавались некоторые модели F-серии, с поддержкой диагностики по Ethernet.
### Кратко про стек
Упрощенно стек протоколов используемых для диагностики представлен ниже:
Основным протоколом является UDS (Unified Diagnostic Services), который совершает всю прикладную работу - устанавливает диагностическую сессию, читает и записывает значения, запрашивает и стирает ошибки. UDS-сообщения могут быть очень длинными и превышать крошечный лимит в 8 байт, предлагаемый CAN. ISO-TP разбивает крупное сообщение на маленькие порции, годные для передачи по CAN.
Так устроены системы диагностики по CAN. При работе по Ethernet уже не нужно бороться с ограничениями по размеру, но добавляются задачи по обнаружению и идентификации автомобиля, так как Ethernet предполагает возможность подключения сразу нескольких автомобилей к одной сети. Транспортировкой UDS-сообщений занимаются протоколы HSFZ и DoIP, являясь альтернативами друг-другу.
Железо
------
### Осмотр подопытного
Для экспериментов на разборке был приобретен ~~битый BMW~~ модуль ZGM (Central Gateway Module) от BMW 7-ой серии (F01):
ZGMы бывают нескольких видов, зависят от конкретных моделей и комплектаций, могут отличаться друг от друга материалом корпуса, наличием и количеством интерфейсов. Поддерживаемых интерфейсов действительно много: Ethernet, High-Speed CAN, Fault-Tolerant CAN, FlexRay, MOST25.
Скинем металлический панцирь и посмотрим на плату:
| # | Chip | Manufacturer | Description |
| --- | --- | --- | --- |
| 1 | LA4032V | Lattice | CPLD |
| 2 | OS81050AQ | Oasis | MOST25 Network Interface Controller |
| 3 | KSZ8893MQL | Micrel | 10/100 Ethernet Switch |
| 4 | MPC5567MVR132 | NXP | 32-bit MCU |
| 5 | CY7C1011DV33 | Cypress | CMOS Static RAM |
| 6 | 25LC256E | Microchip | Serial EEPROM |
| 7 | MEGA48-15AT1 | AVR | 8-Bit MCU |
| 8 | 91056B | ELMOS | Flexray Transceiver (up to 10 Mbit/s) |
Заглянем и на обратную сторону:
| # | Chip | Manufacturer | Description |
| --- | --- | --- | --- |
| 1 | CY7C1011DV33 | Cypress | CMOS Static RAM |
| 2 | TJA1041AT | NXP | HS CAN transceiver (up to 1 Mbit/s) |
| 3 | TJA1055 | NXP | FT CAN transceiver (up to 125 kbit/s) |
### Проводка и подключение
Эта тема много где расписана подробно, но чтобы сделать статью удобнее для восприятия, этот материал тоже включен. Как было сказано в начале, для сборки переходника достаточно пяти проводов и одного резистора:
Выводы **3**, **11**, **12** и **13** используются для передачи данных. На выводе **16** постоянно присутствует напряжение 12В, вывод **8** - это активация работы Ethernet и пока на нем не будет напряжения подключиться не получится. Резистор 510 Ом соединяет выводы 8 и 16, номинал можно подобрать и другой, в пределах разумного.
Протокол и обмен данными
------------------------
Протокол HSFZ занимает два порта: **6811/UDP** и **6801/TCP**. Соответственно, работа тоже разбивается на два этапа:
1. 6811/UDP: обнаружение и идентификация автомобиля;
2. 6801/TCP: обмен полезными данными (диагностика, кодирование, программирование).
### Формат пакета
Порт 6811/UDP задействуется только на первом этапе работы. Формат пакета в этом случае следующий:
Все очень просто, есть всего три поля: длина полезной нагрузки, тип пакета и сама полезная нагрузка, например ASCII-строка с VIN-номером внутри.
На втором этапе используется уже порт 6801/TCP, но формат от этого меняется не сильно:
Поле полезной нагрузки теперь содержит адрес источника, адрес назначения и само UDS-сообщение.
Таблица с возможными типами пакетов:
| Packet Type | Port | Description |
| --- | --- | --- |
| `0x0001` | 6801/TCP | message |
| `0x0002` | 6801/TCP | echo |
| `0x0011` | 6811/UDP | discovery |
### Правила адресации
Анализ формата пакета показал, что для адресации источника и назначения достаточно по одному байту. Упрощенная схема автомобиля с подключенным диагностическим оборудованием и адресами:
Получается, если отправить сообщение от Ethernet Diag до блока FRM (Footwell Module), то поле src примет значение `0xf4`, а поле dst - `0x72`.
Диагностику блоков можно производить и по CAN и по Ethernet, в зависимости от этого будет меняться адрес источника. Нельзя одновременно применять оба способа, так как может возникнуть коллизия.
У блока ZGM неспроста указано два адреса. `0x10` используется для работы внешней диагностики с ZGM, например, при чтении ошибок блока. С `0xf0`ситуация чуть хитрее: ZGM ставит это значение в качестве src, когда сам ведет себя как диагностическое оборудование, без подключения внешней диагностики. Так, ZGM может представиться как `0xf0` и отправить диагностический запрос модулю CAS (Car Access System) `0x40`, принуждая его ответить VIN-номер:
```
| ID | DLC | Data |
| 6f0 | 5 | 40 03 22 f1 90 |
```
При передаче по CAN важно аккуратно использовать поле ID, сообщения с меньшим значением ID имеют больший приоритет. Поэтому исходное значение src`0xf0` "сдвигается" на`0x600` и превращается в `0x6f0`, чтобы не мешать общению важных блоков автомобиля. Адрес назначения dst `0x40` просто лежит первым байтом сообщения.
Адрес `0xdf` - широковещательный и применяется когда нужно работать сразу со всеми блоками. Например, рассылать UDS-сообщение "Tester Present".
Таблица с несколькими адресами (полный список гораздо больше) и расшифровкой аббревиатур:
| Address | Description |
| --- | --- |
| `0x10` | ZGM diag (Central Gateway Module) |
| `0x18` | DME (Digital Motor Electronics) |
| `0x40` | CAS (Car Access System) |
| `0x72` | FRM (Footwell Module) |
| `0xDF` | broadcast |
| `0xF0` | ZGM internal (Central Gateway Module) |
| `0xF1` | CAN diag |
| `0xF4` | ETH diag |
### Обнаружение автомобиля
В условиях автомастерской возможно обслуживание сразу нескольких автомобилей, что подразумевает их одновременное подключение к локальной сети. Чтобы избежать конфликта IP-адресов, ZGM умеет получать адрес динамически по DHCP, а не использует один статический.
Если автомобиль не обнаружил DHCP-сервер, то он присвоит себе IP-адрес из диапазона APIPA (`169.254.xxx.xxx`).
Возникает вопрос: как однозначно сопоставить IP-адрес с VIN-номером автомобиля? На помощь приходит первая часть протокола HSFZ, работающая поверх UDP. При подключении к сети ZGM самостоятельно отправляет 3 одинаковых идентификационных сообщения с интервалом в 500 мс. Если диагностическое ПО проспало сообщение, его можно получить заново с помощью поискового запроса (тип пакета = `0x0011`):
```
0000 00 00 00 00 00 11 ......
```
На что в ответ придет идентификационное сообщение:
```
0000 00 00 00 32 00 11 44 49 41 47 41 44 52 31 30 42 ...2..DIAGADR10B
0010 4d 57 4d 41 43 30 30 30 30 30 30 30 30 30 30 30 MWMAC00000000000
0020 30 42 4d 57 56 49 4e 58 34 58 4b 43 38 31 31 38 0BMWVINX4XKC8118
0030 30 43 30 30 30 30 30 30 0C000000
```
Разберем полезную нагрузку на составляющие:
* `DIAG ADR 10`: диагностический адрес ZGM;
* `BMW MAC 000000000000`: MAC-адрес ZGM;
* `BMW VIN X4XKC81180C000000`: VIN-номер автомобиля.
Не совсем понятно для чего указывается марка автомобиля, возможно для отличия от других марок концерна, например Rolls-Royce или Mini.
Простой Python-скрипт для обнаружения автомобиля
```
import socket
bytesToSend = b"\x00\x00\x00\x00\x00\x11"
serverAddressPort = ("169.254.255.255", 6811)
bufferSize = 1024
UDPClientSocket = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)
UDPClientSocket.sendto(bytesToSend, serverAddressPort)
msg, addr = UDPClientSocket.recvfrom(bufferSize)
print(msg)
print(addr)
```
### Обмен полезными данными
Автомобиль обнаружен и идентифицирован, можно приступить к обмену полезными данными (диагностика, кодирование, программирование).
Рассмотрим как это работает на примере одного и того же запроса и сравним, как происходит обмен по Ethernet и по CAN. Пусть необходимо обратиться к блоку FRM (`0x72`) и прочитать DID `0xf150`. UDS-запрос такого вида будет выглядеть так: `0x22 0xf1 0x50`, где `0x22` - это операция чтения.
Начнем с Ethernet:
Сразу бросается в глаза наличие "эхо" пакета, который ZGM отправляет после получения запроса. Далее UDS-запрос оборачивается в ISO-TP и попадает в CAN-шину, где его принимает FRM, подготавливает ответ и отправляет обратно. Теперь FRM становится источником, а ETH DIAG - назначением, поэтому поля src и dst обмениваются значениями. Ответ доходит по Ethernet до ETH DIAG, где прикладное ПО приступает к его разборке и анализу.
Для CAN схема выглядит попроще:
CAN DIAG отправляет UDS-запрос, обернутый в ISO-TP. Поскольку запрос и адреса выглядят легитимно, ZGM ведет себя абсолютно прозрачно и передает его дальше. После получения запроса блок FRM подготавливает ответ и отправляет его обратно CAN DIAG, поменяв местами адреса.
### Обработка ошибок
Любой минимально приемлемый протокол должен уметь сообщать о возможных ошибках. HSFZ в этом случае не исключение, так что давайте попробуем его поломать. У нас в распоряжении несколько болевых точек:
* формат пакета;
* тип пакета;
* адреса источника (src) и назначения (dst);
* размер полезной нагрузки.
В ответ на каждый некорректный запрос ZGM возвращает код ошибки в поле типа пакета; значения ошибок начинаются с `0x40`. Скриптами на Python и перебором было проверено большое количество возможных комбинаций, ниже будут показаны только самые наглядные.
Пойдем по-порядку. Начнем с **формата пакета** и а) отправим пакет вообще без адресов, б) отправим пакет без адреса назначения. Результатом будет ошибка `0x42`:
```
# no src & no dst -> error (0x42)
| payload len | type | src | dst | payload
TX: | 00 00 00 00 | 00 01 | | |
RX: | 00 00 00 00 | 00 42 | | |
# src = 0xf4 & no dst -> error (0x42)
| payload len | type | src | dst | payload
TX: | 00 00 00 01 | 00 01 | f4 | |
RX: | 00 00 00 00 | 00 42 | | |
```
Следующий на очереди - **тип пакета**. Возьмем абсолютно нормальный пакет и подсунем максимально возможное значение типа `0xffff`, что даст ошибку `0x41`:
```
# packet type = 0x01 -> echo (0x02)
| payload len | type | src | dst | payload
TX: | 00 00 00 05 | 00 01 | f4 | 10 | 22 f1 80
RX: | 00 00 00 05 | 00 02 | f4 | 10 | 22 f1 80
# packet type = 0xffff -> error (0x41)
| payload len | type | src | dst | payload
TX: | 00 00 00 05 | ff ff | f4 | 10 | 22 f1 80
RX: | 00 00 00 00 | 00 41 | | |
```
Перейдем к адресам и начнем с **src**. Если перебрать все возможные значения, то можно увидеть, что для всех src неравных `0xf4` и `0xf5` ZGM вернет ошибку `0x40`:
```
# src = 0x00 -> error (0x40)
| payload len | type | src | dst | payload
TX: | 00 00 00 02 | 00 01 | 00 | 00 |
RX: | 00 00 00 02 | 00 40 | ff | 00 |
...
# src = 0xf4 -> echo (0x02)
| payload len | type | src | dst | payload
TX: | 00 00 00 02 | 00 01 | f4 | 00 |
RX: | 00 00 00 02 | 00 02 | f4 | 00 |
# src = 0xf5 -> echo (0x02)
| payload len | type | src | dst | payload
TX: | 00 00 00 02 | 00 01 | f5 | 00 |
RX: | 00 00 00 02 | 00 02 | f5 | 00 |
...
# src = 0xff -> error (0x40)
| payload len | type | src | dst | payload
TX: | 00 00 00 02 | 00 01 | ff | 00 |
RX: | 00 00 00 02 | 00 40 | ff | ff |
```
Так обнаружился еще один валидный адрес источника `0xf5` , возможно он применяется в других сценариях диагностики.
Перебираем значения для **dst** и обнаруживаем, что не все адреса могут быть приняты, а также новый тип ошибки - `0x43`:
```
# dst = 0x03 -> echo (0x02)
| payload len | type | src | dst | payload
TX: | 00 00 00 02 | 00 01 | f4 | 03 |
RX: | 00 00 00 02 | 00 02 | f4 | 03 |
# dst = 0x04 -> error (0x43)
| payload len | type | src | dst | payload
TX: | 00 00 00 02 | 00 01 | f4 | 04 |
RX: | 00 00 00 02 | 00 43 | f4 | 04 |
```
Ради любопытства была составлена таблица валидных значений dst, при которых ZGM соглашается пропускать сообщения через себя:
Осталось доломать **размер полезной нагрузки**. Просто начинаем с нулевого значения и последовательно инкрементируем его до первого отказа и ошибки `0x44`:
```
# dst = 0x10 (ZGM), payload length = 0x1003 -> error (0x44)
| payload len | type | src | dst | payload
TX: | 00 00 10 03 | 00 01 | f4 | 10 |
RX: | 00 00 00 00 | 00 44 | | |
```
Внимание, минутка *духоты*. Максимальный размер равен 0x1002 = 4098 байт. Ну это понятно, 2 байта - это адреса src и dst, а на сами данные остается 4096 байт. Но ведь ZGM еще должен переварить все это и отправить по CAN, используя ISO-TP в качестве транспорта. Максимальный размер для классической версии ISO-TP равен 4095 байт.
2 + 4095 != 4098. Откуда еще один байт?
Поломав над этим голову и уже заподозрив BMW в допущении off-by-one ошибки, я решил повторить эксперимент, но с другим адресом dst `0x72`, то есть модулем FRM, который подключен к шине K2:
```
# DST = 0x72, payload length = 0x1002 -> error (0x44)
| payload len | type | src | dst | payload
TX: | 00 00 10 02 | 00 01 | f4 | 72 |
RX: | 00 00 00 00 | 00 44 | | |
```
Вот и отгадка - максимальный размер стал равен 0x1001 = 4097 байт и теперь все сходится. Получается размер зависит от адреса назначения, для ZGM он был на один байт больше поскольку он подсоединен к диагностике напрямую. В этом случае 4096 байт - это просто размер входного буфера для ZGM, никак не связанный с ограничениями ISO-TP.
Итоговая таблица с предполагаемыми типами ошибок (все они относятся к порту 6801/TCP):
| Тип ошибки | Описание |
| --- | --- |
| `0x40` | Неправильный адрес источника |
| `0x41` | Неправильный тип пакета (пакет полный, но такой тип не поддерживается) |
| `0x42` | Ошибка формата пакета (например, не хватает адресов) |
| `0x43` | Неправильный адрес назначения |
| `0x44` | Превышен максимальный размер полезной нагрузки |
Вдогонку отмечу, что во время пыток ZGM иногда начинал упорно отвечать ошибкой `0xff` на все пакеты, но полноценно воспроизвести условия при которых это происходит не удалось. Помогал сброс питания, после которого все возвращалось в норму.
Заключение
----------
Автомобильная электроника и методы диагностики всегда тяжело поддавались стандартизации и унификации, тем более между разными производителями. Протокол HSFZ, появившийся раньше DoIP и применяемый до сих пор - очень любопытный этому пример, который было интересно расковырять. | https://habr.com/ru/post/688580/ | null | ru | null |
# Пишем настоящий Pointer Analysis для LLVM. Часть 1: Введение или первое свидание с миром анализа программ
[](https://habrahabr.ru/company/solarsecurity/blog/317002/#habracut) Привет, Хабр!
Эта статья станет вступительной в моем небольшом цикле заметок, посвященном такой технике анализа программ, как pointer analysis. Алгоритмы pointer analysis позволяют с заданной точностью определить на какие участки памяти переменная или некоторое выражение может указывать. Без знания информации об указателях анализ программ, активно использующих указатели (то есть программ на любом современном языке программирования — C, C++, C#, Java, Python и других), практически невозможен. Поэтому в любом мало-мальски оптимизируещем компиляторе или [серьезном статическом анализаторе кода](http://solarsecurity.ru/products/solar_inCode/) применяются техники pointer analysis для достижения точных результатов.
В данном цикле статей мы сосредоточимся на написании эффективного межпроцедурного алгоритма pointer analysis, рассмотрим основные современные подходы к задаче, ну и, конечно же, напишем свой очень серьезный алгоритм pointer analysis для замечательного языка внутреннего представления программ LLVM. Всех интересующихся прошу под кат, будем анализировать программы и многое другое!
### Алгоритмы оптимизации и анализа программ
Представьте на секунду, что вы пишете компилятор для вашего любимого языка программирования. Позади написание лексических и синтаксических анализаторов, уже построено синтаксическое дерево модуля трансляции и исходная программа записана в терминах некоторого внутреннего представления (например, в виде байткода JVM или LLVM). Что дальше? Можно, например, попробовать интерпретировать полученное представление на некоторой виртуальной машине или транслировать это представление дальше, уже в машинный код. А можно сначала попробовать оптимизировать это представление, а потом уже заняться скучной трансляцией, верно? К тому же, программа будет работать быстрее!
Какие оптимизации мы можем применить? Рассмотрим, например, такой фрагмент кода.
```
k = 2;
if (complexComputationsOMG()) {
a = k + 2;
} else {
a = k * 2;
}
if (1 < a) {
callUrEx();
}
k = complexComputationsAgain();
print(a);
exit();
```
Обратите внимание на то, что переменная `a` принимает значение, равное `4`, вне зависимости от того, какое значение вернула функция `complexComputationsOMG`, а это значит, что вызов этой функции из представления программы можно смело убрать (исходя из предположения, что все функции у нас чистые, в частности, не обладают побочными эффектами). Более того, раз в точке программы, в которой осуществляется сравнение переменной `a` с единицей, переменная `a` всегда принимает значение `4`, то вызов `callUrEx` можно осуществлять безусловно, то есть избавиться от ненужного ветвления.
Кроме того, значение переменной `k`, присваемое в строчке `k = complexComputationsAgain()` нигде не используется, поэтому эту функцию можно и не вызывать! Вот что у нас получается после всех преобразований.
```
callUrEx();
print(4);
exit();
```
По-моему, неплохо! Все что нам осталось — научить наш оптимизатор осуществлять такие преобразования кода автоматически. Тут нам на помощь и приходит все многообразие алгоритмов dataflow analysis, и собственнолично очень крутой дядька [Gary Kildall](https://en.wikipedia.org/wiki/Gary_Kildall), который в своей монументальной рукописи «A unified approach to global program optimization» представил универсальный фреймворк для анализа программ, точнее так называемых dataflow problems.
Описательно, алгоритм итеративного решения dataflow problems, звучит очень просто. Все что нам нужно — определить набор свойств переменных, которые мы хотим отслеживать в процессе анализа (например, возможные значения переменных), функции интерпретации таких наборов для каждого [базового блока](https://en.wikipedia.org/wiki/Basic_block) и правила, по которым мы эти свойства будем распространять между базовыми блоками (например, пересечение множеств). В процессе итеративного алгоритма мы вычисляем значения этих свойств переменных в различных точках графа потока управления ([Control Flow Graph, CFG](https://en.wikipedia.org/wiki/Control_flow_graph)), обычно в начале и конце каждого базового блока. Итеративно распространяя указанные свойства, мы должны в конечном итоге достигнуть неподвижной точки (fixpoint), в которой алгоритм заканчивает свою работу.
Разумеется, лучше один раз увидеть, чем сто раз услышать, поэтому подкрепим слова примером. Рассмотрим следующий фрагмент кода и попробуем отследить возможные значения переменных в различных точках программы.
```
b = 3;
y = 5;
while (...) {
y = b * 2;
}
if (b < 4) {
println("Here we go!");
}
```
Во врезке ниже решается классическая задача анализа программ, а именно — распространение констант (constant propagation) для рассматриваемого фрагмента кода.
**Итеративный алгоритм constant propagation**В начале все множества возможных значений переменных пусты.
Интерпретируя входной блок `B1`, получаем, что на выходе этого блока `b=3` и `y=5`. Функция `f1` (аналогичные функции определяются для остальных блоков) — функция интерпретации блока.
Блок входа в цикл в `while` `B2` имеет двух предков — входной блок `B1` и блок `B3`. Поскольку блок `B3` пока не содержит возможных значений переменных, на текущем этапе алгоритма считаем, что на входе и выходе блока `B2` `b=3` и `y=5`. Функция `U` — правило распространения множеств свойств переменных (обычно — точная нижняя грань частично упорядоченного множества, а точнее — [полной решетки](https://en.wikipedia.org/wiki/Complete_lattice)).
На выходе у базового блока `B3` — `b=3` и `y=6`.
Поскольку информация о возможных значениях переменных была изменена (по сравнению с начальным состоянием, то есть как бы 0-й итерацией алгоритма), запускаем следующую итерацию алгоритма. Новая итерация повторяет предыдущую за исключением шага вычисления входного набора блока `B2`.
Как видим, на этот раз мы вынуждены как бы «пересечь» выходные наборы блоков `B1` и `B3`. У этих наборов есть общая часть `b=3` которую мы оставим и разнящиеся части `y=5` и `y=6`, которые мы вынуждены отбросить.
Поскольку продолжая вычисления далее мы не получаем никаких новых значений, работу алгоритма можно считать завершенной. Это и означает, что мы достигли неподвижной точки.
В своей работе Gary Kildall показал, что такой итеративный алгоритм всегда будет заканчивать свою работу и, более того, давать самый полный из возможных результатов, в случае если соблюдены следующие условия:
1. домен отслеживаемых свойств переменных представляет собой полную решетку;
2. функции интерпретации блока обладает свойством дистрибутивности на решетке;
3. для «встречи» базовых блоков-предшедственников используется оператор точной нижней грани (то есть функция meet частично упорядоченного множества).
**Анекдот из мира большой науки**Самое забавное, что пример, который использовал Килдалл в своей работе (constant propagation) не удовлетворяет требованиям, которые он же и предъявляет к dataflow problem — функции интерпретации для constant propagation не обладают свойством дистрибутивности на решетке, а являются всего лишь монотонными.
Таким образом, для оптимизации программ мы можем применять всю мощь алгоритмов dataflow analysis, используя, например, итеративный алгоритм. Возвращаясь к нашему первому примеру, мы использовали constant propagation и liveness analysis (live variable analysis) для осуществления оптимизации dead code elimination.
Более того, алгоритмы dataflow analysis могут использоваться при осуществлении статического анализа кода в контексте информационной безопасности. Например, в процессе поиска уязвимостей класса SQL-injection, мы можем отмечать специальным флагом все переменные, на которые каким-либо образом может повлиять злоумышленник (например, параметры HTTP-запроса и т.п.). Если окажется, что переменная, помеченная таким флагом, участвует в формировании SQL-запроса без надлежащей обработки — мы, скорее всего, нашли серьезную дыру в безопасности приложения! Останется лишь [показать сообщение о возможной уязвимости](https://habrahabr.ru/company/solarsecurity/blog/312056/) и ~~красиво уйти в горизонт~~ предоставить пользователю рекомендации по диагностике и устранению такой уязвимости.
### Умножаем скорбь
> Иван кивает на Петра, а Петр на Ивана
Подводя итоги предыдущего пункта, алгоритмы dataflow analysis — хлеб насущный (и масло!) любого компиляторщика. Так причем здесь, собственно, pointer analysis, и зачем он, собственно, нужен?
Спешу испортить вам настроение следующим примером.
```
x = 1;
*p = 3;
if (x < 3) {
killTheCat();
}
```
Вполне очевидно, что не зная, куда указывает переменная `p`, мы не можем с уверенностью заявить, чему будет равняться значение выражения `x < 3` в условном операторе `if`. Ответ на этот вопрос мы можем дать лишь выяснив контекст, в котором данный фрагмент кода появляется. Например, `p` может быть глобальной переменной из другого модуля (которая в языках программирования семейства C может указывать на что угодно и когда угодно) или локальной переменной, указывающей куда-то в кучу. Даже зная контекст, нам все еще необходимо знать множество локаций (абстрактных ячеек памяти), на которые эта переменная может указывать. Если, например, перед указанным фрагментом кода переменная `p` инициализировалась как `p = new int`, тогда мы должны удалить из оптимизированной программы условный переход и вызвать метод `killTheCat` безусловно.
Раз так, ни одной оптимизации мы применить к этому коду не сможем, пока не найдем какой-либо способ раз и навсегда выяснить, куда могут указывать переменные в анализируемой программе!
Думаю, сейчас уже стало очевидным, что без применения алгоритмов pointer analysis нам не обойтись (и по какой причине вообще возникла необходимость решать эту сложную, а точнее, алгоритмически неразрешимую задачу). Pointer analysis — это метод статического анализа кода, который определяет информацию о значениях указателей или выражений, имеющих тип указатель. В зависимости от решаемых задач, pointer analysis может определять информацию для каждой точки программы или для программы целиком (flow-sensitivity) или в зависимости от контекста вызова функции (context-sensitivity). Более подробно о типах pointer analysis я расскажу в одной из следующих статей цикла.
Результат анализа обычно представляется в виде отображения из множества указателей во множество наборов локаций, на которые эти указатели могут ссылаться. То есть, проще говоря, каждому указателю `p` сопоставляется множество объектов, на которые он может указывать. Например, во фрагменте кода, приведенном ниже, результатом анализа будет отображение `p -> {a, b}, q -> {p}`.
```
int a, b, c, *p, **q;
p = &a
q = &p
*q = &b
```
Важно отметить, что отображение, вычисляемое pointer analysis, должно отвечать критерию безопасности, то есть быть максимально консервативным. В противном случае, мы можем просто испортить семантику исходной программы своими оптимизациями. Например, безопасным приближением результата pointer analysis для фрагмента программы выше, может быть `p -> {a, b, c}, q -> {unknown}`. Значение `unknown` используется для того, чтобы показать, что указатель может ссылаться на все доступные объекты программы.
Например, в рассматриваемом ниже фрагменте кода, разыменование переменной `p` потенциально может изменить значение любого объекта программы!
```
extern int *offensiveFoo();
p = offensiveFoo();
*p = 77;
```
Мы ничего не знаем про функцию `offensiveFoo`, поскольку она была импортирована из другого модуля трансляции, а потому вынуждены предположить, что `p` может указывать совершенно на что угодно!
В дальнейшем будем считать, что все рассматриваемые функции и глобальные переменные принадлежат анализируемому модулю трансляции, за исключением случаев, когда обратное явно обговорено словами.
### Poor Man's Pointer Analysis
 Впервые столкнувшись с проблемой алиасинга указателей, я, не долго думая, решил попробовать решить задачу используя уже известный итеративный алгоритм на решетке (тогда я и понятия не имел, что решаю задачу ту же задачу, что и решают алгоритмы pointer analysis). Действительно, что нам мешает отслеживать объекты, на которые могут ссылаться указатели как набор свойств этих указателей? Давайте попробуем отследить работу алгоритма на простом примере. Правила распространения множеств объектов пусть соответствуют «естественной» семантике программы (например, если `p = &a`, то `p -> {a}`), а распространять эти наборы между базовыми блоками мы будем простым объединением множеств (например, если `q -> {a, b}` и `q -> {c}` подаются на вход некоторому базовому блоку, то входным набором для такого блока будет `q -> {a, b, c}`).
Рассмотрим работу алгоритма на простом примере.
```
x = &a
a = &z
if (...) {
x = &b
} else {
c = &x
}
```
Дождемся пока итеративный алгоритм закончит работу и посмотрим на результаты.
Работает! Не смотря на простоту алгоритма, представленный подход имеет право на жизнь. Скажу больше, именно так (разумеется, со значительными улучшениями) решали задачу алиасинга указателей до появления работы Андерсена «Program Analysis and Specialization for the C Programming Language». Кстати, именно этой работе и будет посвящена следующая статья цикла!
Основные недостатки описанного подхода — плохая масштабируемость и слишком консервативные результаты, поскольку при анализе реальных программ нужно обязательно учитывать вызовы других функций (то есть анализ должен быть межпроцедурным) и, зачастую, контекст вызова функции. Существенный же плюс такого подхода в том, что информация об указателях доступна для каждой точки программы (то есть алгоритм flow-sensitive), тогда как алгоритмы Андерсена и его последователей вычисляют результат для программы целиком (flow-insensitive).
### Вместо заключения
На этом завершается первый кусочек моего цикла заметок об алгоритмах pointer analysis. В следующий раз напишем простой и эффективный межпроцедурный pointer analysis алгоритм для LLVM!
Всем большое спасибо за уделенное статье время! | https://habr.com/ru/post/317002/ | null | ru | null |
# Почему программное обеспечение не всегда товар и откуда в IT прибыль
С XVI века складывалась нынешняя система производства в которой мы живём. Эта система находит своё отражение во всех сферах, но именно в IT получает новое продолжение, новое рождение. Это статья о том, почему программное обеспечение формирует новый ландшафт экономических отношений и почему в IT много денег. Но что ещё более важно, надеюсь внимательный читатель задумается, в какой компании он работает и в какую хотел бы пойти работать, что в условиях мирового экономического кризиса всё более актуально.
Описание программного обеспечения как товара
============================================
Программное обеспечение распространяется несколькими моделями. Чаще всего, модель распространения смешанная, специализируется под каждый конечный случай. Но для целей анализа следует рассмотреть крайние, противолежащие случаи.
С одной стороны, в виде специализированного для заказчика продукта, которой компания-разработчик делает покупателю согласно сделке, в идеале подкреплённого технической документацией. Нередко такие договоры связаны с разработкой специфичного продукта для определённой компании или государственными заказами. Такой труд из одного контракта в другой требует повторного приложения труда — вновь и вновь разработчики будут заниматься написанием новых продуктов, отдельных для каждого отдельного заказчика. Такой труд я бы назвал ***нереплицируемым***, а соответствующий продукт труда называется [**товаром**](https://ru.wikipedia.org/wiki/%D0%A2%D0%BE%D0%B2%D0%B0%D1%80 "вещь, которая участвует в свободном обмене на другие вещи; продукт, произведённый для продажи"), в классическом определении.
С другой стороны, существует продажа программного обеспечения как копии одного и того же продукта. Таким образом мы покупаем игры, офисные пакеты, IDE и так далее. В этой модели продукт производится лишь раз, а затем воспроизводится простым копированием и соответствующий труд назову ***реплицируемым***, а соответствующий продукт я называю ***виртуальным товаром***.
Как и было сказано выше, для рассмотрения интересны крайние случаи. Промежуточные же формы не должны быть интересны потому, что раскладываются по содержанию на более атомарные составляющие, которые в свою очередь и представляют собой эти крайние случаи. Например, известна модель продажи продукта или его фичей за некоторую стоимость, и специализация на поддержке — легко видеть, как можно разложить продукт на два крайних случая.
Далее предлагаю рассмотреть эти противоположности в отдельности и разобраться откуда возникает прибыль.
Прибыль нереплицируемых продуктов — товаров
-------------------------------------------
Разрабатывая программное обеспечение для конкретного заказчика, компания-исполнитель полностью встраивается в производственные цепочки покупателя товара/услуги, что соответствует форме производственных отношений в которой мы пребываем.
Во-первых, стоимость производимых работ будет ограничена. С одной стороны, заказчик не станет платить за работу больше, чем сможет сэкономить посредством поставленного продукта. То есть заказчик потратит на продукт не больше чем может потратить на свой персонал, который делает ту же работу какими-либо другими способами. Выпуская продукт для заказчика, исполнитель будто бы "встраивается" в структуру организации заказчика, в экономическом плане. С другой стороны, подготовленный заказчик, который приходит с чётко прописанной документацией, так или иначе знаком с количеством эквивалентной работы, необходимой для производства данного набора функционала. Эту информацию можно получить или в качестве консультации, или рассмотрев несколько коммерческих предложений. А в случае гос.закупок, существуют специальные институты, контролирующие такие расходы (и если происходит завышение суммы, то часть этой стоимости — не рыночные методы конкуренции).
Во-вторых, способ производства направлен на снижение усилий и повышение прибыли. Разработчики собираются для работы над продуктом под управлением нанимателя. Его интерес предоставить результирующий товар, удовлетворяющий всем пожеланиям клиента, но с минимальными расходами и максимальной прибылью, что в свою очередь толкает его на деспотичную форму управления. Для рядового работника это будет означать, что его рабочее время контролируется максимально тщательно управляющими и надсмотрщиками, переработки поощряются (особенно на словах, реже оплатой и премиями), инновациям не находится время если их нет в договоре, а разработка происходит по факту через водопад. Не будет своих фреймворков и библиотек в рабочее время — прибыль нужна здесь и сейчас.
Если воспользоваться формулой трудовой стоимости товара, то получается следующее: стоимость конечного продукта *W* состоит из суммы затрат на производство *С* (офис, компьютеры, ПО для работы, налоговая нагрузка и т.п.), из затрат на оплату труда рабочих *V*, и из прибыли владельцев компании *S*. При этом общая прибыль на рынке ограничена минимальным доступным предложением на рынке — ведь заказчик при равных условиях обратится к тому исполнителю, который сделает работу дешевле.
Из этой формулы видно, что для получения большей прибыли может быть два способа ее увеличения.
Во-первых, снижение затрат выплат работникам напрямую или посредством длины рабочего дня. Согласно сложившемуся рынку, труд разработчика имеет определённую среднюю стоимость и, пока на рынке есть спрос на рабочую силу программистов, занижать зарплату несколько затруднительно. Другое дело — длина рабочего дня. Часть дня, сотрудник работает в счёт своей зарплаты, другую часть в пользу прибыли работодателя. Оставаясь на неоплачиваемые переработки, вы работаете на сверхприбыль компании и её собственников в частности. Без этих переработок проект не провалится, бизнес исполнителя не исчезнет — снизится только [норма прибыли](https://ru.wikipedia.org/wiki/%D0%9D%D0%BE%D1%80%D0%BC%D0%B0_%D0%BF%D1%80%D0%B8%D0%B1%D1%8B%D0%BB%D0%B8 "процентное отношением прибыли за некоторый период к авансированному перед началом этого периода капиталу") (она же по сути [доходность](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%BD%D1%82%D0%B0%D0%B1%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D1%81%D1%82%D1%8C)), которая на зарплату не влияет. Увеличение длительности рабочего дня, на самом деле, не единственный способ борьбы за высокою рентабельность. Любое средство повышение производительности труда, при котором работник в единицу времени производит продукт подходит. К удлинению рабочего дня тут присоединяется интенсивность, посредством поштучной оплаты в форме KPI или под неустанным присмотром менеджеров и надсмотрщиков — офицеров и унтерофицеров, жизненно необходимых для почти всех продуктов, производимых промышленным способом.
Во-вторых, на прибыль влияет внедрение новых технологий (средств труда), ещё не освоенных на рынке и дающих то конкурентное преимущество, что на единицу времени позволит производить большее количество работы. Это приводит к тому, что на итоговую работу над проектом нужно будет потратить меньше денег и авансировать меньший капитал в виде зарплаты программистам. Речь идёт о всевозможных библиотеках и фреймворках, которые позволяют значительно ускорить разработку. Однако, как уже сказано выше, противоречия собственников компании не позволят вести разработку над новыми технологическими решениями. Зачастую, компании разрабатывающее такое ПО, склонны впитывать [инновации](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D0%BD%D0%BE%D0%B2%D0%B0%D1%86%D0%B8%D1%8F) посредством найма людей на работу, которые уже имеют подобный опыт работы с некоторой новой технологией.
В рассмотренном способе производства и есть сущность капитализма — произвести новый товар, но при этом сэкономить на работниках, увеличивая им рабочий день, давая им те средства (тулинг, IDE, frameworkи и т.п.), которые увеличат производительность работы.
Прибыль реплицируемых продуктов — виртуальных товаров
-----------------------------------------------------
Программное обеспечение, которое продаётся поштучно множественным копированием, резко отличается от обычных товаров. Капиталистический способ производства требует, что бы капиталист купил один товар, применил к нему определённый труд, увеличивающий полезность и стоимость, а потом, если повезёт на рынке, продал товар с прибылью. Крайне развитие машин и их всеобщее распространение, приводит к метаморфозе средств труда, превращая ЭВМ (и не только) в индидвидуальное средство потребления). Эта метамарфоза, в свою очередь явилась причиной образования уникальной формы нетоварного продукта, а точнее товара без товарной стоимости — **виртуального товара**. Отдельная копия продукта не содержит в себе стоимости вложенного труда. Воспроизводсто товара производится простым копированием — крайне дешёвой операцией в современном мире. Таким образом, компания-производитель программного обеспечения делает продукт один раз, но стоимость получает многократно, если количество переходит в качество. Тем самым реплицируемый продукт становится выражением новой формы производства.
Конечно, производитель программного обеспечения преследует туже основную цель, что и любой другой капиталист — заработать денег (время пока именно такое, хоть всегда под лозунгами "мы изменим мир"). Но средство достижения этого результата разительно отличаются от предыдущей модели, ведь в ход здесь идёт новый вид капитала — [венчурный](https://ru.wikipedia.org/wiki/%D0%92%D0%B5%D0%BD%D1%87%D1%83%D1%80%D0%BD%D1%8B%D0%B9_%D0%BA%D0%B0%D0%BF%D0%B8%D1%82%D0%B0%D0%BB "долгосрочные инвестиции, вложенные в рискованные ценные бумаги или предприятия, в ожидании высокой прибыли"). Инвесторы (и следует оговорится, что ими могут быть разработчики в гараже, авансирующие своё время) решают, что определённый продукт найдёт своё употребление на рынке, то есть найдутся такие покупатели, для которых данное программное обеспечение представляется полезным (имеет [потребительную стоимость](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D1%82%D1%80%D0%B5%D0%B1%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D1%81%D1%82%D0%BE%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D1%8C)).
Устанавливаемая цена в этом случае теряет свой смысл по сравнению с обычным товаром, потому что продукт можно неограниченно множить без затрат на производство, таким образом, теряется связь цены и стоимости. В случае производства вируального товара, прибыль будет прямо зависеть от назначенной **мультиплицируемой стоимости** *m*, которую оплатили *k* покупателей, и обратно от затрат на разработку `C+V`, что соответствует формуле . Прибыль от такого продукта зависит от количества продаж. Таким образом, когда колличество продаж переходит в качество, прибавочная стоимость в произведённом товаре находит своё отрицание в мультиплицируемой стоимости виртуального товара.
Отличительной чертой *мультиплицируемой стоимости* по сравнению с прибавочной, является источник прибыли. В первом случае прибыль происходит из обмена, в то время как во втором — из процесса производства товара.
Для увеличения продаж, производитель должен выбрать такую часть рынка, в которой нет других альтернатив, а продукт может нести пользу, т.е. потребительную стоимость. Задача тем самым может принимать самые идеалистические оттенки и, зачастую, часто бывает названа миссией.
### Форма кооперации
При производстве реплицируемых продуктов, удовлетворяется одно из противоречий между трудом и капиталом. т.к. чаще всего прибыль в меньшей степени зависит от расходов и в большей от количества продаж, целесообразность экономии снижается. Значительно более необходима теперь работа над повышением полезности. Работа разработчиков становится более творческой и во многом требует, чтобы сам работник разделял ценности производимых им работ. В погоне за такого рода единением, компания может пойти на значительные уступки, ориентируя своих сотрудников, словно домены метала при намагничивании. Если для капиталистического производства характерно общественное производство и частное присвоение, повременная и поштучная формы оплаты труда, то тут всё несколько иначе. Компании начинают формировать премиальные фонды пропорциональные прибыли и даже распределяют свопы на доли. Последнее — очень значительное проявление кооперации, основанное теперь не на зарплате, а на общей цели, и, как результат, меритократическое поощрение.
Новая структура организации, ориентированность на результат руководства и работников, меняет вектор управления с деспотичного, на человеко-ориентированного, т.к. творчество человека во многом является составляющей успеха. На этом механизм управления не останавливается, чтобы получить максимально раннюю информацию о целесообразности инвестиций (потребительной стоимости авансированного капитала), индустрии выгодно применять итеративно-инкрементальные подходы, известные как ***Agile***. Такой подход позволяет снизить риски венчурных инвестиций и, в отличие от обычного товара, получить представление о стоимости товара до момента продажи. Повышая от итерации к итерации полезность продукта, производитель тем самым может увеличить назначаемую мультиплицируемую стоимость товара. Итеративная разработка минимизирует описанные выше противоречия оценки стоимости продута со стороны производителей и покупателей.
Итеративная разработка реплицируемых продуктов пораждает ещё один интересный эффект. Труд, содержащийся в работе слонен образовывать основной капитал, увеличивая количественно [органическое строение капитала](https://ru.wikipedia.org/wiki/%D0%9E%D1%80%D0%B3%D0%B0%D0%BD%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BA%D0%B0%D0%BF%D0%B8%D1%82%D0%B0%D0%BB%D0%B0 "близкое понятие - капиталоёмкость"). Я уже писал об этом [ранее](https://habr.com/ru/post/484932/ "Двойственная природа требований к программному обеспечению"), имея в виду архитектуру приложений, однако самоувеличение строения капитала носит более широкий характер. Не только ключевые показатели архитектуры многократно могут использоваться, но, что ещё более важно, ещё и центральная бизнес-возможности, или базовый функционал продукта. На основании такого продукта делаются дополнительные функции из итерацию в итерацию. Подробное рассмотрение данной формы кооперации будет рассмотрено [отдельно](https://habr.com/ru/post/501350/).
### Норма прибыли
Для данноого способа производства норма прибыли будет иметь следующий вид: `[НП] = m*k/(C+V)`, тогда как для капиталистического товара она представляется следующим образом: `[НП] = M/(C+V+M)`. Как [известно](https://ru.wikipedia.org/wiki/%D0%9A%D0%B0%D0%BF%D0%B8%D1%82%D0%B0%D0%BB_(%D0%9C%D0%B0%D1%80%D0%BA%D1%81) "Критика пролитической экономии, т.1, гл. XVI"), норма прибыли представляется ложным законом, т.к. не может быть равна 100%. Но для виртуального товара в общем, или реплицируемого программного обеспечение в частности, соотношение `(100% + x)/100%` представляется достижимым, при условии новой формы кооперации, в которой результаты труда в равных или не равных долях распределяется между работниками. Данный метаморфоз [нормы прибыли](https://ru.wikipedia.org/wiki/%D0%9D%D0%BE%D1%80%D0%BC%D0%B0_%D0%BF%D1%80%D0%B8%D0%B1%D1%8B%D0%BB%D0%B8 "замечу, что у Маркса такого понятия нет в указанном источнике, у него это представленно как классическое понятие о норме прибавочной стоимости, что сейчас принято называть нормой прибыли") говорит ещё раз о том, что в данном случае мы точно имеем не капиталистическую форму производства.
### Размер назначаемой мультиплицируемой стоимости продукта
Интересно проанализировать, какова назначенная мультиплицируемую стоимость продукта. Дело в том, что по-большому счёту, эта цифра носит идеальный характер. Заранее бизнес не знает сколько именно копий он продаст, а значит, нельзя наверняка установить норму прибыли, которая в данном случае будет иметь следующую форму: `[НП] = m*k/(C+V)`. Компания, инвестирующая (авансирующая) капитал в производство реплицируемого продукта, должна ориентироваться на предполагаемое минимальное количество покупок, чтобы покрыть свои расходы и тем самым установить стоимость продукта. *Мнимая величина количества продаж и назначаемой мультиплицируемой стоимости — противоречие данной формы производства между производством и обменом, выступающая как невозможность планирования мультиплицируемой стоимости копии продукта*. Зачастую, некоторые производители решают эту проблему, продавая подписку на предзаказ игр, например, тем самым планируя в каких пределах необходимо нести расходы на производство.
С другой стороны, покупатель будет волен выбрать, насколько купленная копия продукта будет для него полезна. В итоге, покупатель потратится при том условии, что для него потребительная стоимость будет не больше чем назначенная мультиплицируемуя стоимость продукта. Если продукт должен автоматизировать что-то в вашей жизни (например, программа для подсчёта калорий или электронные таблицы), то стоимость продукта должна быть не выше той экономии времени, которую она привносит. Это по сути, то же самое противоречие, что и со стороны производителя, но в несколько иной форме. Если производителю необходимо понимать количество покупателей, то *покупателю нужно оценить продукт, ознакомившись с тем что он из себя представляет, и, если признаёт в продукте полезность эквивалентную установленной стоимости, оплатить*. Это противоречие заставляет производителей делать триал-версии, пробники, платный функционал, т.п.
### \*\*\*
Выше я попытался выделить внутренние закономерности развития подобных компаний, которые проявляются во внешнем движении капиталов, заставляя решать цели конечных покупателей через последовательное производство скооперировавшихся работников.
Представленный способ производства не будет ограничиваться программным обеспечением. Уже значительное время, такой способ прибыли характерен для многих и многих продуктов развлекательного жанра — фильмы и сериалы, игры, книги и прочее. Со временем тоже самое коснётся, например, [биотехнологий](https://habr.com/ru/hub/biotech/) и [аддитивных технологий](https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B4%D0%B8%D1%82%D0%B8%D0%B2%D0%BD%D1%8B%D0%B5_%D1%82%D0%B5%D1%85%D0%BD%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D0%B8 "3D-печать"), а возможным это станет тогда, когда распространение этих технологий станет соизмеримо с существенным развитием и всеобщим распространением ЭВМ (и диалектика развития ЭВМ безусловно заслуживает внимания). Всеобщее распространение автоматизированных машин и есть самая прямая предпосылка формирования новой экономической формации.
Данное представление о реплицируемой стоимости виртуально товара, ни в коем случае не восстаёт против трудовой теории стоимости, а является её скромным современным дополнением.
Под конец
=========
Нам приводят Кремниевую долину как икону капитализма. На деле же, в IT индустрии денег так много потому, что это новый принципиально другой вид производства — нетоварный. Капитализм, с его участием государства такому производству только оковы, которые будут рано или поздно сброшены в ходе исторического развития.
Стартапы — ростки новой жизни, которые всё ещё похожи в момент рождения на корпорации, но в то же самое время могут быть чем-то большим и лучшим. Корпорации же более реакционны, так как их капиталы становятся магнитом для денег, и это мешает нормальному развитию, сковывает их в выборе и действиях, оставляя снова единственную цель — прибыль. И предельно хуже слияние корпораций с финансовым капиталом, то ли в виде венчурного капиталиста, то ли в виде бизнес-ангела, то ли через банальное кредитование. Такие паразиты не остановятся ни перед чем что бы поскорее обменять результаты живого труда, на мёртвые деньги.
Производство реплицируемого продукта принципиально отличается от тех товаров что делались веками до того. Это столь эффективно и выгодно, что крупный бизнес и государства изо всех сил будут пытаться сдерживать подобное развитие. С помощью патентного права и юридических препонов, с помощью запрета угрожающих технологий, таких как Blockchain, с помощью гипервливаний денежных средств. Однако движение истории не остановить.
Источники
=========
* **Капитал: критика политической экономии. Том I** | Карл Маркс | ISBN 978-5-699-95085-0
* **Четвертая промышленная революция** | Шваб Клаус | ISBN 978-5-699-90556-0
* **Четвертая промышленная революция** | Блуммарт Тью, Ван ден Брук Стефан, Колтоф Эрик | ISBN 978-5-9614-1536-0
* **Head First Agile. Гибкое управление проектами** | Стиллмен Эндрю, Грин Дженифер | ISBN 978-5-4461-0992-0 | https://habr.com/ru/post/500800/ | null | ru | null |
# Управление несколькими сервоприводами с высокой точностью на МК ATmega16
Недавно ко мне обратились знакомые из макетной мастерской и предложили поработать над весьма интересным проектом. Им необходимо было выполнить макет, в котором бы двигались детали нескольких машин (кран, экскаватор, разрушитель). Логика несложная, но особенность в том, что они должны были двигаться со скоростью, гораздо ниже, чем скорость самих приводов, а это возможно реализовать только проходом через промежуточные точки. В этой статье я хочу познакомить вас с интересным методом точного управления большим количеством сервоприводов.
В моем случае предполагалось использовать четыре привода. Для этого проекта я изготовил небольшую плату:
Сама плата простая – микроконтроллер Atmega16A-AU, стабилизатор для контроллера, два стабилизатора на приводы и PLS-разъем для подключения приводов. В моем случае на приводы нагрузки почти не было (сервы двигали бумажными деталями) поэтому для приводов хватило одного линейного стабилизатора на небольшом радиаторе.
По управлению приводами я нашел две наиболее интересные статьи у [alex-exe](http://alex-exe.ru/radio/robotics/servo-pc/) и [di halt'а](http://easyelectronics.ru/upravlenie-mnozhestvom-servomashinok.html). Но в обоих методах есть определенные недостатки. В первом случае: необходимо слишком часто вызывать прерывание, что труднопредсказуемо замедляет выполнение основного цикла и не позволяет получить высокую точность позиционирования. При его реализации привод достаточно сильно дергается, точность установки – около 1 градуса. Собственно, вот видео:
Метод DI HALT’а предполагет формирование по возрастанию, то есть необходимо дополнительно обсчитывать сигналы.
В связи с этим я хочу предложить еще один метод, который позволяет избежать обе эти трудности.
Принцип управления сервопривода прост: необходимо с периодом 15-20мс отправлять импульсы с длительностью 0,8-2,3мс. Длительность импульса определяет положение сервопривода. Предлагаемый метод предполагает формирование импульсов на ножках МК одного за другим, как показано на рисунке.
Для реализации такого метода достаточно всего одного таймера. Я настроил таймер на увеличение каждую микросекунду. Весь период сигнала – 18000мкс, время на формирование одного импульса – 4500мкс. Прерывание по таймеру при управлении четырьмя сервами вызывается восемь раз. Отсюда вытекает ограничение метода: не получится на один таймер повесить больше 8-ми приводов (за 20мс можно сформировать максимум 8 импульсов длительностью 2,3мс).
Переменные angle1-angle4 это углы в нормированных единицах, меняющиеся в основном цикле программы. Для изменения угла от 0 до 180 градусов они должны меняться от 800 до 2200. Все управление происходит в обработчике прерываний. При первом срабатывании таймера в единицу выставляется нога ответственная за первый привод. Тут же в регистр OCR1A записывается значение угла для этого привода. При следующем срабатывании нога устанавливается в 0 и в регистр OCR1A записывается количество тактов, которое осталось до конца периода управления одним приводом (у меня он выставлен 4500). Затем все то же самое проделывается с ногой, ответственной за второй привод. Таким образом, каждые 4,5мс на одной ноге за другой появляется импульс необходимой длительности, причем с точность до 1мкс! То есть точность установки угла будет меньше 10-ти минут и ограничена характеристиками самого привода. Итак, сам код:
```
ISR(TIMER1_COMPA_vect)
{
if (takt == 0)
{
PORTC |= 0b00000001;
OCR1A = angle1;
}
if (takt == 1)
{
PORTC = PORTC & 0b11111110;
OCR1A = cycle - angle1;
}
if (takt == 2)
{
PORTC |= 0b00000010;
OCR1A = angle2;
}
if (takt == 3)
{
PORTC = PORTC & 0b11111101;
OCR1A = cycle - angle2;
}
if (takt == 4)
{
PORTC |= 0b00000100;
OCR1A = angle3;
}
if (takt == 5)
{
PORTC = PORTC & 0b11111011;
OCR1A = cycle - angle3;
}
if (takt == 6)
{
PORTC |= 0b00001000;
OCR1A = angle4;
}
if (takt == 7)
{
PORTC = PORTC & 0b11110111;
OCR1A = cycle - angle4;
}
takt = takt + 1;
if (takt == 9) takt = 0;
}
```
Текст всей программы приводить не буду, скажу только что углы в основном цикле могут формироваться любым образом – хоть по данным с UART, хоть с ADC. Я же фактически руками забил куда ехать, где и сколько постоять и т.д. Также у меня еще был тумблер. Во включенном положении сервы двигаются по программе, а при выключении возвращаются в свое исходное положение. При необходимости все исходники проекта могу выслать на почту.
Вот видео работы четырех приводов:
Обратите внимание на привод в левом нижнем углу – движения практически не заметно! Этот привод управляет стрелой крана. Добавлю еще про сами приводы. Мне в руки попало четыре разных привода – два аналоговых и два цифровых. Примечательно, что оба аналоговых привода могли работать нормально только пару минут, а потом начинать произвольно дергаться, зажиматься в крайних положениях и т.д., хотя оба привода рабочие – проверял сервотестером. Цифровые приводы выполняли все четко и стабильно по несколько часов подряд (а может и суток). Нареканий от заказчика я не слышал. Для стрелы крана я использовал привод Hi-Tech, который изменял свою позицию с минимальным шагом.
И напоследок – фото макета. Видео, к сожалению, выложить не могу.
**UPD:**
Основная статья теперь хранится [здесь](http://www.customelectronics.ru/servo-control/). | https://habr.com/ru/post/147940/ | null | ru | null |
# Почему (сегодня) return 444 не всегда полезен
В web-сервере Nginx есть замечательный код ответа 444, который «закрывает» соединение без отправки данных. Данный функционал весьма полезен при фильтрации паразитного трафика — если мы уверены, что клиент по каким-то критериям не является валидным, то нет необходимости его уведомлять, например, 403-м ответом. Эффективнее просто прекратить передачу данных, что, зачастую, позволяет существенно снизить нагрузку на сервер.
Рекомендации использовать такие ответы можно встретить повсеместно в инструкциях по блокировках переходов по ссылкам с популярных сайтов и реферального спама, защите от DDoS и т.п.
И, в общем-то, на протяжении многих лет эти советы можно было использовать почти не глядя, но… современные браузеры не стоят на месте и периодически преподносят нам новые сюрпризы.
**Обязательная программа**Сервер:
```
$ uname -orm
FreeBSD 11.1-STABLE amd64
```
```
$ nginx -v
nginx version: nginx/1.15.0
```
Клиент:
```
>ver
Microsoft Windows [Version 10.0.15063]
```
Google Chrome 67.0.3396.99 (Официальная сборка), (64 бит)
Firefox Quantum 61.0 (64-бит)
Я взял для опытов только браузеры Chrome и Firefox. Не потому, что остальные безгрешны, просто в этих двух описанное ниже поведение было достаточно стабильным.
Итак, у нас есть сайт и мы хотим ограничить доступ к location без всяких условий и не передавая никаких данных:
```
server {
...
location = /code/444 {
return 444;
}
...
}
```
Ожидание:
* браузер отправит **один** запрос;
* сервер получит **один** запрос, закроет соединение и запишет в лог **одну** строку с кодом *444*;
* не получив данных браузер отобразит ошибку и прекратит общение с сервером.
Для большей наглядности отобразим наше ожидание строкой лога Nginx:
```
18.12.12.29 - - [28/Jun/2018:11:50:10 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36"
```
Реальность Chrome:
```
18.12.12.29 - - [28/Jun/2018:11:50:10 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36"
18.12.12.29 - - [28/Jun/2018:11:50:10 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36"
18.12.12.29 - - [28/Jun/2018:11:50:15 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36"
18.12.12.29 - - [28/Jun/2018:11:52:04 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36"
```
Chrome отправил запрос, не получил ответа, тут же отправил ещё один запрос, после чего стал периодически проверять сайт на доступность.
Реальность Firefox:
```
18.12.12.29 - - [28/Jun/2018:12:34:38 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:34:38 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:34:38 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:34:38 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:34:38 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:34:39 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:34:39 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:34:39 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:34:39 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:34:39 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:34:39 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:34:40 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:34:40 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:34:40 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:34:40 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:34:40 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:34:41 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:34:41 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:34:41 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:34:41 +0000] "GET /code/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
```
Firefox решил не мелочиться и сразу же отправил 20 запросов (иногда делает 10). Но потом уже не совершает «проверок».
При этом в отладчике он отчитывается как за один запрос:
**Заголовок спойлера**
Тем самым, ожидая получить один запрос от клиента, на деле мы получаем 3-20 запросов. Кроме совсем ненужных нам обращений есть риск скормить такой лог, например, анти-DDoS скрипту и заблокировать данный ip. И казалось бы полбеды, ведь мы и так ему «отдавали» 444, то есть нам его не жалко, но может случиться и наоборот — мы покажем клиенту то чего не вообще планировали.
Модифицируем конфиг:
```
map $http_referer $code_if {
"~*https://habr.com/post/415565/" 1;
"http://tison.ru/ref" 1;
default 0;
}
...
server {
...
location = /code/444 {
return 444;
}
...
location = /codeif/444 {
if ( $code_if = 1 ) { return 444; }
add_header "Content-Type" "text/html; charset=UTF-8" always;
return 200 "Expected code 444";
}
...
}
```
Здесь мы запретили отдачу контента всем клиентам имеющим реферер "
`https://habr.com/post/415565/`" при переходе на страничку [tison.ru/codeif/444](http://tison.ru/codeif/444)
Ожидание:
Зная уже описанные выше особенности, мы допустим, что браузеры сделают более одного запроса, но 200-го ответа от сервера они не получат.
В виде лога, опять же, ожидаем одну или несколько строк вида:
```
18.12.12.29 - - [28/Jun/2018:12:52:02 +0000] "GET /codeif/444 HTTP/1.1" 444 0 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36"
```
При отладке в консоли всё работает ожидаемо. Сервер закрыл соединение и никакого контента мы не получили:
```
$ curl --referer "https://habr.com/post/415565/" tison.ru/codeif/444
curl: (52) Empty reply from server
```
Ну и браузерная реальность.
Chrome:
```
18.12.12.29 - - [28/Jun/2018:12:58:12 +0000] "GET /codeif/444 HTTP/1.1" 444 0 "http://tison.ru/ref" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36"
18.12.12.29 - - [28/Jun/2018:12:58:12 +0000] "GET /codeif/444 HTTP/1.1" 444 0 "http://tison.ru/ref" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36"
18.12.12.29 - - [28/Jun/2018:12:58:13 +0000] "GET /codeif/444 HTTP/1.1" 200 17 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36"
```
Firefox:
```
18.12.12.29 - - [28/Jun/2018:12:56:29 +0000] "GET /codeif/444 HTTP/1.1" 444 0 "http://tison.ru/ref" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:56:29 +0000] "GET /codeif/444 HTTP/1.1" 444 0 "http://tison.ru/ref" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:56:29 +0000] "GET /codeif/444 HTTP/1.1" 444 0 "http://tison.ru/ref" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:56:29 +0000] "GET /codeif/444 HTTP/1.1" 444 0 "http://tison.ru/ref" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:56:30 +0000] "GET /codeif/444 HTTP/1.1" 444 0 "http://tison.ru/ref" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:56:30 +0000] "GET /codeif/444 HTTP/1.1" 444 0 "http://tison.ru/ref" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:56:30 +0000] "GET /codeif/444 HTTP/1.1" 444 0 "http://tison.ru/ref" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:56:30 +0000] "GET /codeif/444 HTTP/1.1" 444 0 "http://tison.ru/ref" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:56:30 +0000] "GET /codeif/444 HTTP/1.1" 444 0 "http://tison.ru/ref" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:56:30 +0000] "GET /codeif/444 HTTP/1.1" 444 0 "http://tison.ru/ref" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:56:31 +0000] "GET /codeif/444 HTTP/1.1" 200 17 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
18.12.12.29 - - [28/Jun/2018:12:56:31 +0000] "GET /favicon.ico HTTP/1.1" 200 6782 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0"
```
Сделав несколько «честных» запросов запросов оба браузера отбросили реферер и спокойно отобразили блокируемую страницу. Firefox, правда, делает это не всегда. На моих тестах ~ в 15% запросов, что ещё больше «помогает» в анализе.
Такое поведение наблюдается уже достаточно давно, но когда именно Chrome и Firefox перешли на данный режим работы сказать не могу. Как впрочем и сколько времени этот режим будет действовать.
Поэтому сегодня использование *return 444* не всегда приведёт к ожидаемым результатам. Ну а завтра, с нетерпением будем ждать, чем нас ещё порадуют разработчики браузеров. | https://habr.com/ru/post/415565/ | null | ru | null |
# Background Dating — в поисках людей, с которыми интересно говорить
Итак, я давно хотел написать сайт знакомств, но при этом совершенно не хотелось, чтобы он был таким же, как и сотни других. В итоге стало ясно, что это должен быть не совсем сайт знакомств, а скорее некое место, где можно находить интересных людей. С другой стороны, не хотелось ограничиваться какой-то конкретной категорией людей, поэтому вариант создания тематического сайта не рассматривался. В итоге получилось то, что вы можете видеть [по ссылке](http://backgrounddating.com/). Сразу можно обратить внимание на то, что не предлагается заполнять какие-либо анкетные данные. Не потому, что их нужно заполнить после регистрации, а потому что анкет на сайте нет.
Анкет нет потому, что они имеют слишком большие ограничения. Обычно предлагается задать некий стандартизованный набор параметров, с такими же стандартизованными вариантами ответа. Но как только хочется указать что-то ещё или ответить как-то иначе, сталкиваешься с тем, что такую возможность не предусмотрели (или работает это не так, как хотелось бы).
Под хабракатом я расскажу о том, что есть на этом сайте вместо анкет, а также, конечно, напишу о некоторых технических деталях (куда же без этого).
А вот, кстати, и описание в «рекламном» стиле:
*Вы давно хотели найти себе девушку, которая умеет программировать на Brainfuck? Или вам важно, чтобы она была сторонницей адаптивной и семантической вёрстки? А может, вы хотите познакомиться с той, кто может легко рассказать об отличиях микроядра от монолитного, но при этом ещё является танцовщицей?*
Теперь у вас появилась такая возможность — если, конечно, она уже зарегистрировалась на Background Dating. :)
Вместо анкет на сайте есть ключевые фразы. Каждая ключевая фраза — это короткое утверждение от первого лица.
Вот несколько примеров:
* Программирую на Lisp
* Играю в Dungeons and Dragons
* Хожу в клуб Place
* Пишу на Хабрахабр
* Занимаюсь сетевой безопасностью
У каждого пользователя может быть сколько угодно ключевых фраз, и любую ключевую фразу можно использовать при поиске. Также у пользователей есть возможность искать сразу по нескольким интересующим ключевым фразам — в этом случае в результатах выдаются только те люди, которые добавили у себя все указанные ключевые фразы (соответственно, если результат поиска оказывается пустым, значит, можно попробовать убрать часть заданных ключевых фраз из запроса).
При вводе ключевых фраз работает автоподстановка, соответственно, если что-то похожее кто-то из пользователей уже добавлял, то предлагается выбрать одну из ключевых фраз в списке.
Поскольку ключевые фразы могут быть о чём угодно, находить можно, соответственно, самых разных людей. Если вдруг интересен человек, который, например, чётко знает, зачем используется декантер, то можно попробовать найти и таких.
Таким образом при достаточном количестве людей у каждого пользователя появляется возможность знакомиться с теми, кто представляет для него наибольший интерес, и чей background ему наиболее симпатизирует.
Работает сайт, кстати, на Django (язык Python). Для передачи данных о личных сообщениях используются [Web Sockets](https://developer.mozilla.org/en-US/docs/WebSockets) ([RFC 6455](http://tools.ietf.org/html/rfc6455)). При свёрнутых вкладках (исключение — чат) соединение с сервером временно закрывается, чтобы не нагружать интернет-канал — это реализовано через [HTML5 Visibility API](http://www.w3.org/TR/page-visibility/), а именно с помощью [Visibility.js](http://thechangelog.com/post/29416591924/visibility-js-a-wrapper-for-the-page-visibility-api) небезызвестного [iskin](http://habrahabr.ru/users/iskin/).
С серверной стороны поддержка веб-сокетов реализована с помощью асинхронного неблокирующего сервера Tornado. Если кто-то захочет, готов поделиться исходниками и информацией о том, как это деплоить — там, в принципе, ничего сложного. Для того, чтобы передавать сообщения между Django и Tornado (а также хранить некоторые данные) используется Redis, в котором есть отличная поддержка [pub/sub](http://redis.io/topics/pubsub). В Django используется стандартный клиент redis-py, а в Tornado асинхронный клиент [brükva](https://github.com/evilkost/brukva).
Для валидации файла (фотографии) на клиентской стороне используется [File API](http://www.w3.org/TR/FileAPI/). Разрешение фотографии, правда, не проверяется — это [можно сделать](http://benno.id.au/blog/2009/12/30/html5-fileapi-jpegmeta), но я пока что решил не усложнять, тем более, что на сервере всё перепроверяется. Зато проверяются тип и размер файла, что тоже неплохо. Однако меня удивил один интересный факт — дело в том, что по спецификации File API атрибут type объекта, представляющего файл, должен содержать MIME-тип файла, согласно [RFC 2046](http://tools.ietf.org/html/rfc2046), но браузеры при этом используют не фактический тип файла, а генерируют его на основе имеющегося расширения.
Иными словами, возьмём MP3-файл, скажем, file.mp3. Посмотрим MIME с помощью команды file:
```
$ file --mime-type file.mp3
file.mp3: audio/mpeg
```
Теперь уберём расширение, и попробуем ещё раз:
```
$ file --mime-type file
file: audio/mpeg
```
То же самое. Попробуем другое расширение.
```
$ file --mime-type file.jpg
file.jpg: audio/mpeg
```
Аналогично.
А вот у веб-браузеров другое мнение — в первом случае files[0].type содержит строку audio/mpeg (что и ожидается), во втором пустую строку, а в третьем случае уже image/jpeg. Опять же, это не критично, потому что перепроверяется на сервере, но всё равно немного удивляет. Кстати, если очень хочется сделать, чтобы тип файла проверялся «по-настоящему», то это [можно](http://www.htmlgoodies.com/html5/tutorials/determine-an-images-type-using-the-javascript-filereader.html) сделать вручную, через FileReader. Возможно, потом ещё сделаю.
Ещё одна отличная технология, которую я решил здесь использовать — это [Web Storage](http://www.w3.org/TR/webstorage/). Сначала технология Web Storage была частью спецификации HTML5, но потом была описана в отдельной спецификации. С помощью неё на сайте происходит сохранение данных формы регистрации в локальном хранилище браузера (localStorage) — прямо при заполнении пользователем. То есть если пользователь, например, уже указал какие-то ключевые фразы, и собирался регистрироваться, а потом вдруг случайно закрыл вкладку (или браузер, или у него вообще выключился компьютер), то когда он снова зайдёт на сайт, ему не придётся снова добавлять эти ключевые фразы — они автоматически будут загружены из локального хранилища и появятся в форме.
Также на сайте используется адаптивная вёрстка, и поэтому им можно пользоваться с мобильников, планшетов и нетбуков — главное, чтобы там был современный браузер (кстати, браузер по умолчанию в Android 4.2, к сожалению, пока не всё поддерживает, но с другой стороны под Android есть Firefox, Opera Mobile и Chrome, где всё отлично).
Если кому-то будут интересны какие-либо ещё технические подробности (например, серверная валидация и crop фотографий, или хочется обсудить авторизацию по email в Django и изменения в версии 1.5), могу рассказать о них, например, в личной переписке.
И, конечно, если есть какие-то идеи о том, как можно сделать использование сайта лучше/проще/удобнее, буду очень рад услышать их в комментариях. У меня, кстати, есть некоторые идеи того, что, скорее всего, будет довольно интересно добавить, и, если кто-то хочет, могу о них заранее рассказать. Опять же, если у кого-то есть желание присоединиться к разработке (на данный момент над этим сайтом работаю только я) — пишите.
Всем приятного дня и интересных знакомств. :) | https://habr.com/ru/post/159693/ | null | ru | null |
# Simplify.js — JavaScript-библиотека для упрощения ломаных линий
Рад представить вашему вниманию еще одну крохотную, но полезную open-source-утилиту своего авторства — [Simplify.js](http://mourner.github.com/simplify-js/).
[Simplify.js](http://mourner.github.com/simplify-js/) — очень быстрая реализация упрощения ломаных линий на JavaScript. Изначально написав ее для [Leaflet](http://leaflet.cloudmade.com) (библиотеки для интерактивных карт), после небольшого эксперимента по оптимизации захотелось выпустить ее в качестве отдельной библиотеки без зависимостей, которую можно использовать как в браузере, так и на серверных платформах, таких, как Node.js, и применять и для 2D, и для 3D-точек.
Подобное упрощение позволяет на несколько порядков уменьшить количество точек в ломаной линии (например, представляющей длинный маршрут на карте или график), при этом максимально сохранив ее очертания (с заданной точностью). Соответственно резко уменьшается занимаемый линией размер памяти и время, требуемое для ее обработки.
Благодаря этому можно, например, рисовать кривые из десятков и даже сотен тысяч точек в браузере с помощью SVG или Canvas без особых тормозов. Убедиться в этом можно, посмотрев [демонстрацию на сайте](http://mourner.github.com/simplify-js/) и соответствущий [тест на JSPerf](http://jsperf.com/simplify-js-70k-points-polyline-on-a-canvas).
Использование тривиально:
```
var points = [{x: 23, y: 53}, …];
…
var simplified = simplify(points, 1.0);
```
Simplify.js использует [алгоритм Дугласа-Пекера](http://ru.wikipedia.com/wiki/Алгоритм_Рамера-Дугласа-Пекера), применяемый к массиву точек, предварительно отсеянному на основе близости точек друг к другу (что за счёт незначительной потери точности ускоряет применение алгоритма примерно в десять раз), не использует дорогих операций, таких, как копирование и сортировка массивов, и применяет типизированные массивы в браузерах, которые это поддерживают.
Сайт библиотеки: [mourner.github.com/simplify-js](http://mourner.github.com/simplify-js/)
Код на GitHub: [github.com/mourner/simplify-js](https://github.com/mourner/simplify-js/)
Пакет NPM: simplify-js
Лицензия: BSD
Если придумаете, как это оптимизировать еще сильнее — буду рад видеть ваши pull-запросы. Спасибо! | https://habr.com/ru/post/137852/ | null | ru | null |
# Как я получил ключ к Diablo III Beta
В YouTube роликах [ThisIsHorosho](http://www.youtube.com/user/ThisIsHorosho) с недавних пор стали появляться ключи к Diablo III Beta. В 7-ми минутном ролике на секунду показывается ключ, кто его первый активирует, то и выигрывает. Вот так на стоп кадре выглядит ключ:
Вы подумали о том же, о чем и я?
Всего 10 ключей.
**Ключ 1**
О первом ключе я не знал и, наверное, никто не знал. Кому-то повезло.
**Ключ 2**
Ко второму видео был готов самый простой бот, который раз в 10 секунд обновляет страницу с добавленным видео и, если появилось новое видео, то модальное окно в виде алерта сообщает об этом. Выяснилось, что через 4 часа youtube обнаруживает бота и просит его ввести recaptcha, а потом еще каждый час просит ее вводить. Очень не удобно, но я не особо хотел тратить время и писать по-нормальному, так как ожидал, что второй ключ появится как-нибудь по-другому, ну например, хотя бы зелеными буквами. Второй ключ я проморгал, но когда я увидел те же серые цифры и буквы, тем же шрифтом, того же размера, на том же белом фоне и даже размером в те же три строчки, я решил сделать нормального бота.
**Ключ 3**
К третьему видео бот использовал youtube api, квота на кол-во запросов к которому позволяла сканирование раз в 5 секунд на протяжении 12 часов.
Алгоритм был простой:
1. Каждые 5 секунд делаем GET к <http://gdata.youtube.com/feeds/api/users/ThisIsHorosho/uploads?max-results=1&fields=openSearch:totalResults,entry/id> и получаем общее количество видео пользователя и ссылку на последнее видео.
2. Если количество видео изменилось, то из последней ссылки получаем videoId: 3J1CYzzZjNc
3. Делаем GET к <http://www.youtube.com/get_video_info?video_id=3J1CYzzZjNc> и получаем url encoded параметры
4. Берем параметр url\_encoded\_fmt\_stream\_map — это url encoded прямые ссылки на видео разных форматов и качества. Ссылка работает только для того IP, с которого пришел запрос. Пошаманив, можно получить красивую ссылку [http://o-o.preferred.lhr14s07.v2.lscache8.c.youtube.com/videoplayback?sparams=cp,id,ip,ipbits,itag,ratebypass,source,expire&fexp=906929,907720,904821&itag=18&ip=88.0.0.0&signature=BA6D9C66CA9DF74931C899ABC3816E6FFB3AF2B5.326CFD03BDE8430990DEE9E8DC62046FAC43C62B&sver=3&ratebypass=yes&source=youtube&expire=1332983106&key=yt1&ipbits=8&cp=U0hSR1lTUV9FUENOMl9RTVVCOmNpbEFrX1hXTllx&id=dc9d42633cd98cd7](#)
5. Бот, скачав ролик, приступает к анализу видео с помощью vlc библиотеки, которая понимает из коробки mp4,flv,webm.
6. Сканируя кадры через 1 секунду, находим и сохраняем те, на которых предположительно находится серийный номер. Сканируем в 4 потока, каждый свою 1/4 часть видео.
7. Пользователю, т.е. мне, остается только посмотреть найденные скриншоты и ввести ключ
Итак, выскочил алерт, сообщающий о выходе нового видео, я залогинился к battle.net, через 10 секунд скачалось видео, еще через 10 появился скриншот с серийным номером:
Я его ввел и… он оказался уже использованым. Анализ ошибок показал, что данные через youtube api обновляются с задержкой до 5 минут! Когда бот обнаружил новое видео, уже было слишком поздно. Кому-то из других ботов или пользователей жмущих F5 повезло.
**Ключ 4**
К четвертому видео, бот был доработан: сейчас он использует порядка 100 прокси серверов (по 1 потоку на каждый прокси сервер), которые сканируют каждые 5 секунд gdata. Тесты показали, что около 20 прокси просто мгновенно сообщают о выходе нового видео, остальные подтягиваются в течении минуты, это было отлично. В отличии от gdata прямые ссылки появляются сразу для любого IP, поэтому тут без прокси бот просто качает видео в 20 потоков (работало даже в 1000 потоков, youtube оказывается позволяет). Скорость закачки возросла. Алгоритм сканирования был доработан: бот вначале в 4 потока сканирует вторую часть ролика (во всех предыдущих видео серийный ключ появлялся в конце ролика), а потом в 4 потока первую часть. Для надежности шаг сканирования был уменьшен до 500 мс, другие параметры так же были немного ослаблены.
Итак, выскочил алерт, сообщающий о выходе нового видео. Не успел я зайти в battle.net как уже скачалось видео (10 секунд) и появился скриншот с серийным номером:
Я порадовался, что учел возможность его появления в две строчки. Трясущимися руками я его кое-как написал и активировал! На все ушло секунд 20. Очень повезло со сканированием, алгоритм практически сразу показал серийный номер при том, что полное сканирование продолжалось 30 секунд. В этом ролике, как оказалось, было два ключа, которые показались последовательно, я ввел второй. Поздравляю того, кто активировал первый!
**Осталось еще 5 ключей**
Можно доработать алгоритм: запускать сканирование вместе с началом старта скачивания, алгоритм усложнится, но выигрышь будет секунд 10. Можно еще сделать распознование серийного номера и его автоматический ввод в battle.net. Тогда ключик можно будет ввести даже за 5 секунд.
Все писалось на Java, используя HttpComponents (http-протокол) и VLCj (обработка видео)
P.S. Diablo III клевая
**UPDATE**
Интересно было писать самого бота, поэтому затраченные 20 часов я расцениваю как время потраченное на развлечение, а не как 20 часов, за которые можно было бы заработать гораздо больше денег, чем стоит сам ключ. В свободное время я отдыхаю или изучаю что-то новое, а не работаю, а тут приятное с полезным. Игру еще не прошел.
**Алгоритм**
Алгоритм определения серийника я специально сразу не стал указывать по двум причинам. Узнав абсолютно точный алгоритм, авторы ThisIsHorosho быстро сделают ключ нераспознаваемым, и я окажу медвежью услугу тем, кто тоже пишет бота. Хотя допускаю, что таких людей нет, но как то же, судя по комментариям, за 3 минуты вводят серийники, неужели жмут F5 во время ожидания…
Ну раз много вопросов по алгоритму… Главное, алгоритм должен быть очень быстрый. По скриншоту с серийным номером сразу видна основная идея.
1. Берем картинку из кадра и сохраняем ее с размером 640x320, VLCj позволяет сохранять картинки с любым разрешением, даже, если видео имеет другое. Все точки, близкие к цвету текста делаем черными, все остальное белое. В итоге получаем черно белые картинки. Пару таких картинок вставлены в эту статью.
2. Для каждого скриншота считаем статистику белых и черных точек. Фоном объявляем те, где количество белых точек больше 92%, в тестах хватало и 94%, но это с запасом. На кадрах с фоном ищем серийник.
3. Из кадра с краев отступаем по 30 пикселей, так как серийник появляется ближе к центру, а с края — никогда. Оставшееся поле разбиваем на квадраты 20x20, в каждом из которых считаем количество черных точек
4. Квадраты с количеством черных точек от 10% до 60% объявляем квадратами с буквами — это уже с учетом того, что буква может только на половину попасть в квадрат и с некоторым запасом.
5. Кадры, на которых есть непрерывная последовательность из как минимум 6 квадратов с буквами по горизонтали и в 3 квадрата по вертикали, объявляем кадрами с серийным номером. Сохраняем их в папку.
В итоге, появляются только картинки с текстом похожим на серийный номер:
На практике их не много появляется, так что найти из них нужный не составляет труда.
**Работа с VLCj**
Работа с VLCj очень простая. Вначале я прочитал документацию [www.capricasoftware.co.uk/vlcj/tutorial1.php](http://www.capricasoftware.co.uk/vlcj/tutorial1.php), потом немного поигрался с классом MediaPlayer, но он как-то глючил, в общем я остановился на вызове прямых функций из библиотеки LibVlc — оно и быстрее и безглючнее.
Вначале создаем библиотеку
`LibVlc libvlc = LibVlcFactory.factory().create();`
Потом создаем массив из 8 штук AnalyzerThread (типа Runnable) (каждому 1/8 часть времени видео), которые передаем в Executors.newFixedThreadPool(4) в таком порядке: 4, 5, 6, 7, 0, 1, 2, 3. Т.е. вначале будет сканироваться вторая часть видео, а потом первая. В каждом AnalyzerThread такой код:
```
System.out.println("Run section " + num);
libvlc_media_player_t p_mi = null;
libvlc_media_t media = null;
try
{
// prepare
//libvlc_instance_t instance = libvlc.libvlc_new(0, new String[0]);
libvlc_instance_t instance = libvlc.libvlc_new(2, new String[]{"--vout", "dummy"});
p_mi = libvlc.libvlc_media_player_new(instance);
libvlc.libvlc_audio_toggle_mute(p_mi);
media = libvlc.libvlc_media_new_path(instance, fileName);
libvlc.libvlc_media_player_set_media(p_mi, media);
libvlc.libvlc_media_player_play(p_mi);
Thread.sleep(msPlayerWait);
libvlc.libvlc_media_player_pause(p_mi);
// start snapshoting
int block = blockFrom;
for (long msTime = msFrom; msTime <= msTo; msTime += msInBlock, block++)
{
String path = snapshotPath + File.separator + "snap-" + String.format("%03d.png", block);
libvlc.libvlc_media_player_set_time(p_mi, msTime);
int r = libvlc.libvlc_video_take_snapshot(p_mi, 0, path, picWidth, picHeight);
if (r != 0)
System.out.println("SNAPSHOT FAILED: block=" + block + ", returnCode=" + r);
else
analyzeImage(path);
}
} finally
{
if (p_mi != null)
libvlc.libvlc_media_player_stop(p_mi);
if (media != null)
libvlc.libvlc_media_release(media);
if (p_mi != null)
libvlc.libvlc_media_player_release(p_mi);
System.out.println("Close section " + num);
}
```
Функция analyzeImage как раз определяет, находится ли на скриншоте ключик или нет, если находится, то сохраняет его в специальную папку. | https://habr.com/ru/post/140938/ | null | ru | null |
# Рабочий метод разрыва конкретного активного соединения из командной строки linux (drop/kill/cut/close ESTABLISHED connection)
Иногда бывает необходимо принудительно разорвать активное соединение. Самый распространенный способ:
`**netstat -na
kill PID**`
Проблема в том, что один воркер может одновременно обслуживать несколько соединений, поэтому правильнее будет убить соединение а не воркер. Для этого на многих форумах рекомендуют использовать **[tcpkilll](http://www.google.ru/#q=tcpkill)**, **[cutter](http://www.google.ru/#q=cutter+tcp)** или **[awk+hping3](http://flug.org.ua/lists/debian-russian/4376/)**. Однако, хоть эти утилиты и находятся в официальных репозиториях, мне не удалось заставить их разрывать соединения.
После продолжительных поисков был обнаружен perl скрипт **[killcx](http://spamcleaner.org/en/misc/killcx.html)**, разрывающий соединение по удаленному хосту и порту.
`**killcx 94.133.119.242:4403**`
`[PARENT] checking connection with [94.133.119.242:4403]
[PARENT] found connection with [78.220.184.126:80] (ESTABLISHED)
[PARENT] forking child
[CHILD] interface not defined, will use [eth0]
[CHILD] setting up filter to sniff ACK on [eth0] for 5 seconds
[CHILD] hooked ACK from [77.220.184.126:80]
[CHILD] found AckNum [3091573605] and SeqNum [3105164779]
[CHILD] sending spoofed RST to [78.220.184.126:80] with SeqNum [3091573605]
[CHILD] sending RST to remote host as well with SeqNum [3105164779]
[CHILD] all done, sending USR1 signal to parent [13723] and exiting
[PARENT] received child signal, checking results...
=> success : connection has been closed !`
Для его работы требуется целый набор библиотек.
`**apt-get install \
libpcap0.8 \
libpcap-dev \
libnet-pcap-perl \
libyaml-perl \
libyaml-dev \
libyaml-0-1 \
-y
PERL\_MM\_USE\_DEFAULT=1
cpan -i \
Net::RawIP \
NetPacket::Ethernet
wget http://citylan.dl.sourceforge.net/project/killcx/killcx/1.0.2/killcx-1.0.2.tgz
tar xvfz killcx-1.0.2.tgz
cd killcx-1.0.2/
cp killcx /usr/bin/**` | https://habr.com/ru/post/105441/ | null | ru | null |
# Знакомство с Node-RED и потоковое программирование в Yandex IoT Core
В этой статье я хочу разобрать один из самых популярных опенсорс-инструментов, [Node-RED](https://nodered.org), с точки зрения создания простых прототипов приложений с минимумом программирования. Проверим гипотезу о простоте и удобстве таких средств, а также рассмотрим взаимодействие Node-RED с облачной платформой на примере Yandex.Cloud.
Написано уже немало статей на тему того, как средства визуального программирования помогают строить приложения интернета вещей, управлять устройствами и автоматизировать дом ([управление освещением](https://habr.com/ru/post/396985/), автоматизация квартиры — [часть 1](https://habr.com/ru/company/tinkoff/blog/487984/) и [часть 2](https://habr.com/ru/company/tinkoff/blog/489774/)). Но мало кто упоминает о другом полезном свойстве подобных иструментов. Это быстрое прототипирование, то есть эмуляция самих устройств без использования микроконтроллеров и визуализация результатов их работы без глубоких познаний в программировании или веб-дизайне.
Есть ряд ограничений, связанных с хранением данных клиентов в облачных дата-центрах других государств. Поэтому у пользователей зарубежных ресурсов все чаще появляется устойчивое желание использовать гибридные подходы, применять локализованные облачные сервисы, расположенные на территории России. В таких случаях для реализации сценариев интернета вещей вполне оправдано объединение открытых технологий IBM с готовым облачным сервисом Яндекса.
Кратко о Node-RED, его истории, создателях и сообществе
-------------------------------------------------------
Как гласит первоисточник, [Node-RED](https://nodered.org/about/) — это инструмент потокового программирования, первоначально разработанный командой [IBM Emerging Technology Services](https://emerging-technology.co.uk/) и в настоящее время являющийся частью [JS Foundation](https://openjsf.org/).
В качестве ключевой составляющей Node-RED выступает парадигма [потокового программирования](https://en.wikipedia.org/wiki/Flow-based_programming), которое было изобретено в 70-х Джеем Полом Моррисоном. Потоковое программирование — это способ описания поведения приложения в виде сети черных ящиков или «узлов», как они называются в Node-RED. Каждый узел имеет четкую цель — к нему поступают некоторые данные, он что-то делает с этими данными, а затем передает их на следующий узел. Сеть отвечает за поток данных между узлами.
Эта модель отлично подходит для того, чтобы представить ее визуально: так она становится более доступной для широкого круга пользователей. Если кто-то пытается разобраться в проблеме, он может разбить задачу на отдельные шаги, взглянуть на поток и понять, что он делает, без необходимости разбираться в отдельных строках кода в каждом узле.
Node-RED работает в среде исполнения Node.js, а для создания или редактирования потока («Flow») используется браузер. В браузере вы можете создавать свое приложение путем перетаскивания необходимых узлов («Node») из палитры в рабочую область и соединять их вместе. Одним кликом по кнопке «Deploy» приложение разворачивается в среде исполнения и запускается.
Палитра узлов может быть легко расширена путем установки новых узлов, созданных сообществом, а созданные вами потоки могут быть легко переданы в виде файлов JSON.
Node-RED начал свою жизнь в начале 2013 года как совместный проект [Ника О'Лири](https://github.com/knolleary) и [Дэйва Конвея-Джонса](https://github.com/dceejay) из группы IBM Emerging Technology Services.
Проект стартовал как подтверждение концепции визуализации и манипулирования мэппингами между топиками сообщений в протоколе Message Queuing Telemetry Transport (MQTT). Node-RED быстро стал более универсальным инструментом, который можно было легко расширять в любом направлении.
[Исходный код проекта](https://github.com/node-red/node-red) был открыт в сентябре 2013 года. С тех пор он разрабатывался в открытом виде, кульминацией развития стало признание Node-RED одним из фундаментальных проектов JS Foundation в октябре 2016 года.
Почему проект называется Node-RED?
----------------------------------
Со слов авторов:
> Название было веселой игрой слов, звучащих как «Code Red».
>
> Это название приклеилось к проекту и стало существенным шагом вперед по сравнению с тем, как он назывался в первые несколько дней.
>
> Часть «Node» отражает суть модели потокового программирования (поток/узел) и основную среду выполнения Node.JS.
>
> Окончательного решения о том, что же означает часть «RED», принято так и не было.
>
> Одно из предложений — «Rapid Event Developer» (быстрый разработчик событий), но мы никогда не чувствовали себя обязанными что-либо формализовать.
>
> Мы придерживаемся названия Node-RED."
Node-RED предоставляется по лицензии Apache 2.0. Важно понимать и осознавать [условия](https://github.com/node-red/node-red/blob/master/LICENSE) лицензии — по [этой ссылке](https://tldrlegal.com/license/apache-license-2.0-(apache-2.0)) есть краткая выдержка с основными свойствами.
Лицензия разрешает коммерческое использование, но при этом накладывает и ряд ограничений. Вот основные из них: при использовании торговой марки Node-RED (принадлежащей OpenJS Foundation) нельзя ее искажать; кроме того, есть ограничение ответственности (Liability/Warranty) — участники проекта не могут быть привлечены к ответственности в случае причинения убытков в процессе некорректного использования их продукта.
Постановка задачи — интеграция Node-RED c Yandex IoT Core
---------------------------------------------------------
Сначала хочу отметить: вся эта затея сугубо самообразовательная и подкреплена только непреодолимой тягой энтузиастов к познанинию нового. Например, хотелось изучить возможности облачных сред и сервисов Яндекса, которые могут быть безвозмездно получены для тестирования своих гениальных идей. Ну а чтобы была польза для дела, было решено посмотреть, насколько совместимы реализованные в проекте Node-RED узлы (из коробки на уровне MQTT) с интерфейсами сервиса IoT Core.
Задача выглядит просто:
* Развернуть и настроить виртуальную машину в облаке
* Установить и запустить в нужной конфигурации Node-RED
* Создать и должным образом настроить сервис IoT Core
* Эмулировать IoT-устройство в Node-RED с набором параметров
* Подключить созданное устройство к облачной IoT-платформе
* Отправлять сообщения в облако и получать корректные ответы
* Визуализировать результаты в виде прототипа приложения
Чтобы было повеселее, предположим, есть гениальная идея — создать уникальное приложение «Подключаемых автомобилей», которое требует быстрой апробации некоторых концепций. Пусть создание прототипа будет первым шагом на этом пути.
Создание облачной среды и установка Node-RED
--------------------------------------------
### Создание ВМ
Для создания виртуальной машины, на которой мы далее запустим Node-RED, зайдем в [Yandex.Cloud](https://cloud.yandex.ru/) и перейдем в [Консоль](https://console.cloud.yandex.ru/). В сервисе *Compute Cloud* нажимаем **Создать ВМ**.
Задаем машине любое разрешенное имя и в качестве операционной системы выбираем CentOS. Для запуска Node-RED подходит любая из приведенных ОС, но в статье мы рассмотрим порядок работы только с CentOS.
Выполнение тестового сценария не требует больших ресурсов, поэтому выставляем все на минимум. Этот ход также позволит сэкономить ресурсы пробного периода, если вы решили развернуть Node-RED только для ознакомления.
Работа с ВМ будет осуществляться через SSH, поэтому пусть у машины будет автоматически выделенный публичный адрес.
Для подключения к машине по SSH необходимо указать публичный ключ. Сгенерируем SSH-ключи командой `ssh-keygen -t rsa -b 2048` в терминале, потребуется придумать ключевую фразу.
Теперь требуемый ключ хранится в `~/.ssh/is_rsa.pub`, копируем его в поле *SSH-ключ* и нажимаем **Создать ВМ**.
### Подключение к ВМ
После завершения подготовки ВМ в сервисе *Compute Cloud* появится наша машина с заполненным полем *Публичный IPv4*.
Также нам необходим логин, который мы указывали на предыдущем шаге в разделе *Доступ*. Выполним подключение к машине по SSH командой `$ ssh @`. При подключении потребуется ввести ключевую фразу, которую мы указали на этапе генерации ключей.
```
$ ssh @
Enter passphrase for key '/Users//.ssh/id\_rsa':
Last login: Wed Jul 15 08:42:53 2020 from
[@node-red ~]$
```
### Установка Node-RED
Теперь мы можем установить Node-RED. Самый удобный способ для новой, пустой системы — [Linux installers for Node-RED](https://github.com/node-red/linux-installers) из репозитория проекта. Так как мы используем *CentOS 8*, нам необходима вторая команда для ОС, основанных на RPM:
```
$ bash <(curl -sL https://raw.githubusercontent.com/node-red/linux-installers/master/rpm/update-nodejs-and-nodered)
...
Stop Node-RED
Install Node.js LTS Node v10.19.0 Npm 6.13.4
Install Node-RED core 1.1.2
Add shortcut commands
Update systemd script
Update public zone firewall rule
Any errors will be logged to /var/log/nodered-install.log
All done.
You can now start Node-RED with the command node-red-start
Then point your browser to localhost:1880 or http://{your_pi_ip-address}:1880
...
```
Скрипт установит LTS-версию Node.js, базовую версию Node-RED, создаст скрипт автозапуска для systemd и по желанию создаст правила для порта 1880 в файрволе. Для проверки успешности установки можно запустить команду:
```
$ node-red-start
```
**Примечание:** для выхода из Node-RED нажмите Ctrl+C.
Как активировать автозапуск и старт службы с помощью systemctl:
```
$ sudo systemctl enable --now nodered.service
```
После этого по адресу `http://{ip вашей машины}:1880` в браузере будет доступен Node-RED.
Подготовка и настройка сервиса Yandex IoT Core
----------------------------------------------
Возвращаемся в [Консоль](https://console.cloud.yandex.ru/), выбираем *IoT Core* и нажимаем **Создать реестр**. Указываем любое подходящее имя. Далее определимся со способом авторизации.
IoT Core поддерживает два способа: с помощью сертификатов и по логину-паролю. Для нашего тестового сценария намного быстрее использовать последний, поэтому заполним поле *Пароль*. Длина пароля — минимум 14 символов.
После создания переходим в реестр во вкладку *Устройства* слева и нажимаем **Добавить устройство**.
Аналогично реестру задаем имя и пароль.
Теперь в пункте *Обзор* реестра появился его *ID* и пароль (в скрытом виде), которые мы указали при создании реестра. То же самое с устройством: на странице устройства есть его *ID*.
Пример создания простого приложения в Node-RED
----------------------------------------------
Перейдем в `http://{ip вашей машины}:1880`. Импортируем готовый пример, где нам потребуется лишь указать данные реестра и устройства.
В меню в правом верхнем углу Node-RED нажмем *Import*. Flow в формате *.json* берем [отсюда](https://github.com/Wo1kowsky/node-red-iot-core/blob/master/sample_device.json) и либо копируем содержимое в поле, либо скачиваем файл и нажимаем *select a file to import*.
В новой вкладке появится flow *testing connection*.
Рассмотрим добавленные узлы. *Send data* — узел типа *Inject*, предназначен для ручного или автоматического запуска flow.
*Device payload* — узел-функция, позволяет выполнять JavaScript для обработки данных, проходящих через этот узел.
*device* — *mqtt-out*-узел с настраиваемым MQTT-подключением, предназначен для публикации данных в топик.
Два раза кликаем по узлу *device*.
Нам необходимо заменить на ID нашего реестра в IoT Core. Далее редактируем данные в *Server*. Во вкладке *Security* указываем username — это ID созданного нами устройства, а password — пароль, придуманный на этапе создания устройства. Затем нажимаем *Update*, далее *Done*.
Протестируем соединение: в правом верхнем углу нажмем *Deploy*. Под узлом *device* появится подпись *connected*.
Импортируем [flow с dashboard](https://github.com/Wo1kowsky/node-red-iot-core/blob/master/sample_dashboard.json) таким же образом. После импорта будет показано сообщение о недостающих компонентах, загрузим их. В меню в правом верхнем углу перейдем в *Manage palette*. В появившемся окне во вкладке *Install* в поисковом поле напишем `node-red-dashboard` и установим самый первый из найденных пакетов. Таким же образом установим `node-red-contrib-web-worldmap`.
Flow получился намного интереснее предыдущего, видны новые узлы.
Так, *registry* — *mqtt-in*-узел, принимает сообщения из указанного в настройках топика и передает их следующим узлам.
Измеряемые данные приходят в строке, поэтому применяется узел разбора сообщений *json*. Он может конвертировать JSON-объект в его JS-представление и обратно.
*Parsing JSON* и *JSON* возвращают полученные измерения уже в виде отдельных объектов, которые далее передаются узлам, отвечающим за элементы *Dashboard*.
Теперь необходимо настроить узел *registry*. Аналогично первому flow записываем наш ID реестра и переходим в настройки сервера *iot-core-subscription*.
Во вкладке *Security* добавляем данные реестра, сохраняем изменения и нажимаем *Deploy*.
Если все поля заполнены верно, то после развертывания под узлом registry тоже появится подпись *connected*.
Последння вкладка в окне справа (с иконкой столбчатой диаграммы) отвечает за *Dashboard*. Перейти в Dashboard можно по кнопке:
Каждые три секунды устройство из flow *testing connection* генерирует данные, отправляет их в топик нашего реестра, а flow *Smart Utilities*, в свою очередь, подписывается на этот топик и обновляет *Dashboard* в соответствии с данными, приходящими из IoT Core.
В качестве результатов и краткого заключения
--------------------------------------------
Node-RED действительно может скачать любой желающий, безвозмездно. При первом знакомстве он вызывает вопросы в плане логики работы и прививает свою непередаваемую любовь к узлу "debug" и вкладке "debug messages". Но когда осмотришься и разберешься, то все встает на свои места и становится очень просто выполнять любые действия. Совсем без познаний в программировании обойтись не получится — требуется хоть какое-то представление о том, что такое переменные, условия, циклы, массивы, JSON сообщения и как осуществлять их разбор. Однако узлы из раздела "Network", такие как "mqtt in/out", заработали с сервисом Yandex IoT Core вообще без проблем при условии правильной конфигурации.
Я умышленно не стал слишком детально описывать, как создается само приложение, поскольку есть исходник потока в JSON. Да и сама идея проекта Node-RED предполагает, что любой желающий может «взглянуть на поток и понять, что он делает, без необходимости разбираться в отдельных строках кода на каждом узле». Но в код лучше заглянуть.
Ссылки на полезные материалы
----------------------------
* [Node-RED на GitHub](https://github.com/node-red/)
* [Документация проекта Node-RED (eng)](https://nodered.org/docs/)
* [Книга рецептов (eng)](https://cookbook.nodered.org/)
* [Как начать работать с Node-RED (eng) в разных облачных средах](https://nodered.org/docs/getting-started/)
* [Node-RED гостит у папы (eng)](https://developer.ibm.com/components/node-red/)
* [Рецепты по Node-RED в IBM (eng)](https://developer.ibm.com/recipes/tag/node-red/)
* [Видео от создателей c русскими субтитрами](https://youtu.be/vYreeoCoQPI)
***Отдельное спасибо за помощь при создании статьи:***
* [Максиму Волкову](https://github.com/Wo1kowsky) (ИТ Архитектор, IBM)
* Константину Гальцеву ([НТЦ IBM в России](https://www.ibm.com/ru/rstl/index.html))
* [Виталию Бондаренко](https://habr.com/ru/users/evitbon/) (ИТ Архитектор, IBM) | https://habr.com/ru/post/519600/ | null | ru | null |
# Тишина должна быть в библиотеке! Как мы рефачили библиотеку для работы с API и создали свой Repository
Всем привет! Меня зовут Игорь Сорокин. В этой статье я поделюсь историей о том, куда нас завёл очередной рефакторинг, как мы оттуда выбрались, попутно разработав слой хранения данных. Также приведу практические примеры реализации, покажу подход, который удалось разработать, и расскажу об особенностях, с которыми мы столкнулись. Но обо всём по порядку.
Статья будет полезна, если вы задумались о внедрении базы данных в своё приложение или уже используете её, но без единого подхода. Если же вы не используете базу данных, то, скорее всего, вы счастливый человек.
Предыстория
-----------
Исторически так сложилось, что для работы с сетью и сохранения ответов в базу данных в Юле использовался RestKit — мощная библиотека с большим функционалом, написанная ещё на старом добром Objective-C. Она позволяет делать api-запросы, декодить JSON в NSManagedObject сущности и тут же сохранять их в CoreData. Однако библиотека неумолимо постарела, а её поддержка и вовсе остановлена. Да и ребята в iOS-команде неохотно ею пользовались.
Так, однажды на пятничной встрече в офисе за круглым столом и со вкусной пиццей, мы вместе с командой платформы окончательно решили выпилить RestKit и заменить его на Alamofire. Почему именно Alamofire? Все просто: это современная библиотека, написанная на Swift. У неё большое комьюнити и хорошая поддержка. К тому же, большинство iOS-разработчиков с ней знакомы. Одним словом, profit!
Написать новый api-клиент — задача несложная, но перед нами встал вопрос: как быть с сохранением ответов в базу? Работа с CoreData была размазана по всему проекту, отсутствовал единый подход, и это порождало некоторые проблемы: запутанность кода, сложности онбординга, трудности с многопоточностью.
Мы решили, что если уж переписывать api-менеджеры, то качественно! Так, перед нами встала новая задача — спроектировать слой хранения данных. Вот какие особенности реализации мы учли в целях:
* **цель №1:** описать общий интерфейс так, чтобы при необходимости можно было заменить CoreData на другое хранилище;
* **цель №2:** скрыть детали реализации — разработчик должен оперировать доменными моделями, а не сущностями и контекстами;
* **цель №3:** иметь возможность в одну и ту же сущность сохранять разные модели.
Мы запаслись терпением, пиццей и смузи, и пошли работать…
Проектирование интерфейса
-------------------------
Отталкиваясь от наших целей, мы накидали желаемый интерфейс и назвали это Repository. Ниже представлены его методы:
```
class Repository {
func persist(\_ model: Model,
mapper: PersistMapper,
completion: ((Result) -> Void)?) where PersistMapper: PersistableMapper,
PersistMapper.FromModel == Model,
PersistMapper.ToModel == DBEntity { ... }
func persist(\_ models: [Model],
mapper: PersistMapper,
completion: ((Result<[DomainModel], Error>) -> Void)?) where PersistMapper: PersistableMapper,
PersistMapper.FromModel == Model,
PersistMapper.ToModel == DBEntity { ... }
func fetch(searchQuery: Query, completion: @escaping (Result<[DomainModel], Error>) -> Void) where Query: SortedDatabaseQuery, Query.DBEntity == DBEntity { ... }
func fetchAll(completion: @escaping (Result<[DomainModel], Error>) -> Void) { ... }
func removeAll(matching query: Query, completion: ((Result) -> Void)?) where Query: DatabaseQuery, Query.DBEntity == DBEntity { ... }
func removeAll(completion: ((Result) -> Void)?) { ... }
func count(matching query: Query) -> Int where Query: DatabaseQuery, Query.DBEntity == DBEntity { ... }
func count() -> Int { ... }
func first(matching query: Query) -> DomainModel? where Query: SortedDatabaseQuery, Query.DBEntity == DBEntity { ... }
func first() -> DomainModel? { ... }
}
```
Так как Repository дженериковый, мы решили использовать абстрактный класс, чтобы избежать танцев с бубнами при размывании типов. DomainModel — тип доменной модели, с которой работает репозиторий, а DBEntity — сущность, которая ассоциируется с доменной моделью. Repository содержит основные CRUD-методы, такие как сохранение/обновление, выборка, удаление, а также метод для запроса на количество элементов.
Руководствовались мы правилом инверсии зависимостей, поскольку именно оно позволит в будущем легко заменить одну реализацию на другую. А при проектировании не завязывались на деталях CoreData, а старались писать абстрактный интерфейс.
В общем виде работу с репозиторием мы представляли так:
Проектирование интерфейсаСохранение
----------
Итак, как вы помните, важной целью репозитория для нас является возможность сохранять разные модели. Значит, помимо моделей нужно передать маппер, умеющий конвертировать их в нужные сущности. Мы специально вынесли логику конвертации в отдельный объект, потому что не хотели раздувать модели и сущности. Маппер описан специальным протоколом PersistableMapper.
```
protocol PersistableMapper {
associatedtype FromModel
associatedtype ToModel
func createEntity(from model: FromModel) -> ToModel
func updateEntity(_ entity: inout ToModel, from model: FromModel)
func keyPathsForPrimaryKeys() -> [PrimaryKeysPaths]
}
```
PersistableMapper содержит два дженериковых типа:
1. FromModel — модель, которую нужно конвертировать;
2. ToModel — сущность, в которую нужно конвертировать.
Для конвертации мы добавили два метода:
1. updateEntity(:from:) — для обновления полей, когда в базе уже есть нужная сущность;
2. createEntity(from:) — для создания сущности и заполнения её данными.
Помимо этого, протокол требует реализовать метод keyPathsForPrimaryKeys(), который возвращает массив PrimaryKeysPaths. Это структура, содержащая PartialKeyPath для модели и сущности. По сути, это первичные ключи, по которым мы будем понимать, есть ли у нас соответствующая сущность в базе или нет. Если значения **всех** первичных ключей равны, то считается, что модель и сущность описывают один и тот же объект.
Фильтрация и сортировка
-----------------------
Для выборки и удаления нужно было придумать способ фильтрования и сортировки элементов. Мы не хотели напрямую передавать NSPredicate и NSSortDescriptor, поскольку есть вероятность ошибиться — например, передать NSPredicate, предназначенный для другой сущности. Поэтому решили добавить новый уровень абстракции. Создали специальные протоколы: DatabaseQuery — для выборки, SortedDatabaseQuery — для выборки и сортировки.
```
protocol SortedDatabaseQuery: DatabaseQuery {
var sortDescriptors: [NSSortDescriptor] { get }
}
protocol DatabaseQuery {
associatedtype DBEntity
var predicate: NSPredicate? { get }
}
```
Данные протоколы дженериковые — чтобы знать, для какой сущности предназначен Query-объект. Благодаря этому не получится передать Query, созданную для работы с одной сущностью, в Repository, работающий с другой. Это своеобразная защита, и мы получим ошибку на этапе компиляции.
На следующем этапе нужно было реализовать новый протокол, используя CoreData.
Реализация репозитория
----------------------
Так как сущностью CoreData является NSManagedObject, а мы хотим получать от репозитория доменные модели, то понадобился ещё один маппер, задачей которого будет конвертация сущности в доменные модели. Так родился протокол DomainModelCoreDataMapper.
```
protocol DomainModelCoreDataMapper {
associatedtype DomainModel
associatedtype DBEntity: NSManagedObject
func model(from entity: DBEntity) -> DomainModel?
}
```
Заметьте, что помимо метода конвертации, у протокола есть требование, что DBEntity должен быть NSManagedObject.
CoreDataRepository тоже дженериковый, но в отличие от Repository ему нужно указать не тип модели и сущности, а сразу маппер, который реализует протокол DomainModelCoreDataMapper, за счёт чего сущность всегда будет NSManagedObject или его наследником.
```
final class CoreDataRepository: Repository {
typealias DomainModel = DomainModelMapper.DomainModel
typealias EntityMO = DomainModelMapper.DBEntity
init(domainModelMapper: DomainModelMapper, contextProvider: CoreDataContextProvider) {
self.contextProvider = contextProvider
self.domainModelMapper = domainModelMapper
}
...
}
```
При создании также передаётся протокол CoreDataContextProvider. Его реализует YoulaCoreDataContextProvider. Это синглтон-объект, предоставляющий настроенный контекст для CoreDataRepository.
При сохранении модели мы должны проверить, есть ли такая сущность в базе. Если нет, то создать её. В рамках CoreData эту обязанность мы возложили на PersistableMapper, так как он знает первичные ключи и способ обновления сущности. Кроме того, мы могли бы добавить вложенный маппер, чтобы иметь возможность обновлять связи (relations) сущности. Наше расширение выглядит так:
```
extension PersistableMapper where ToModel: NSManagedObject {
typealias Model = FromModel
typealias DBEntity = ToModel
// Вспомогательные методы для получения значений по PartialKeyPath
private func modelPrimaryKey(_ model: Model, primaryKeyPath: PartialKeyPath) -> Any {
return model[keyPath: primaryKeyPath]
}
private func entityPrimaryKey(\_ entity: DBEntity, primaryKeyPath: PartialKeyPath) -> Any {
return entity[keyPath: primaryKeyPath]
}
// Реализуем обязательный метод протокола
func createEntity(from model: FromModel) -> ToModel {
return DBEntity(entity: DBEntity.entity(), insertInto: nil)
}
// Вспомогательные методы для создания/нахождения сущности и обновления полей
//
// Алгоритм:
// Запрашиваем/создаем сущность
// Если создаем сущность через метод createEntity(from:), то ее нужно вставить в контекст
// Обновляем поля с помощью метода протокола updateEntity(:from:)
// Возвращаем сущность
@discardableResult
func entity(from model: Model, in context: NSManagedObjectContext) -> DBEntity { ... }
@discardableResult
func entities(from models: [Model], in context: NSManagedObjectContext) -> [DBEntity] { ... }
}
```
Теперь можно приступить к реализации методов репозитория. В качестве примера я привёл реализацию сохранения и выборки. Остальные методы реализованы похожим образом:
```
private func persistModel(\_ model: Model,
mapper: PersistMapper,
completion: ((Result) -> Void)?) where DomainModelMapper.DBEntity == PersistMapper.ToModel,
Model == PersistMapper.FromModel,
PersistMapper: PersistableMapper {
// Получаем worker context
let context = contextProvider.workerContext()
context.perform { [weak self] in
guard let self = self else {
return
}
// Маппер найдет в базе нужную сущность, если такой нет, то создаст ее
// Заполнит ее значениями из model
// Вернет NSManagedObject
let entity = mapper.entity(from: model, in: context)
// Конвертируем полученную сущность в доменную модель
guard let domainModel = self.domainModelMapper.model(from: entity) else {
// Вызываем completion на main потоке с ошибкой маппинга
DispatchQueue.main.asyncCompletion(completion: completion, with: .failure(CoreDataError.modelMapping))
return
}
// сохраняем контекст
self.safelySaveToPersistentStore(context: context, completion: { error in
if let error = error {
completion?(.failure(error))
} else {
completion?(.success(domainModel))
}
})
}
}
private func fetchModels(predicate: NSPredicate?,
sortDescriptors: [NSSortDescriptor]?,
completion: @escaping (Result<[DomainModel], Error>) -> Void) {
// Получаем worker context
let context = contextProvider.workerContext()
context.perform { [weak self] in
guard let self = self else {
return
}
// Создаем NSFetchRequest
let entityName = EntityMO.entity().name ?? ""
let fetchRequest = NSFetchRequest(entityName: entityName)
fetchRequest.sortDescriptors = sortDescriptors
fetchRequest.predicate = predicate
do {
// Получаем все сущности
let entities = try context.fetch(fetchRequest)
var domainModels: [DomainModel] = []
// Конвертируем сущности в доменные модели
for entity in entities {
guard let domainModel = self.domainModelMapper.model(from: entity) else {
// Вызываем completion на main потоке с ошибкой маппинга
DispatchQueue.main.asyncCompletion(completion: completion, with: .failure(CoreDataError.modelMapping))
return
}
domainModels.append(domainModel)
}
// Вызываем completion на main потоке с переданным результатом
DispatchQueue.main.asyncCompletion(completion: completion, with: .success(domainModels))
} catch {
DispatchQueue.main.asyncCompletion(completion: completion, with: .failure(error))
}
}
}
```
Попробуем?
----------
Посмотрим, что у нас получилось. Допустим, перед нами стоит задача: сделать запрос на пользователя и сохранить его в базу. Вместо использования CoreData напрямую попробуем использовать репозиторий. Для начала проверим, какие модели у нас есть.
```
// Модель ответа с сервера
struct UserResponse: Decodable {
let identifier: String
let name: String
let type: String
let image: ImageResponse
let isOnline: Bool
}
// Доменная модель
struct User {
let identifier: String
let name: String
let type: UserType
let image: Image
let isOnline: Bool
}
// Сущность в CoreData
final class UserMO: NSManagedObject {
@NSManaged var identifier: String?
@NSManaged var name: String?
@NSManaged var type: String?
@NSManaged var image: ImageMO?
@NSManaged var isOnline: NSNumber?
}
```
Для сохранения моделей нужно реализовать Persistable-мапперы. Реализуем маппер из UserResponse в UserMO. Маппер из User в UserMO будет выглядеть аналогично:
```
struct UserResponsePersistableMapper: PersistableMapper {
typealias FromModel = UserResponse
typealias ToModel = UserMO
// Вложенный маппер, отвечающий за конвертацию ImageResponse в ImageMO
private let imageResponseMapper = ImageResponsePersistableMapper()
func updateEntity(_ entity: inout UserMO, from model: UserResponse) {
// Обновляем поля
entity.name = model.name
entity.type = model.type
entity.isOnline = model.isOnline as NSNumber
guard let context = entity.managedObjectContext else {
return
}
// Для обновления связи используем метод из нашего расширения
entity.image = imageResponseMapper.entity(from: model.image, in: context)
}
func keyPathsForPrimaryKeys() -> [PrimaryKeysPaths] {
// Указываем первичные ключи
return [PrimaryKeysPaths(modelKeyPath: \UserResponse.identifier,
entityKeyPath: \UserMO.identifier)]
}
}
```
Также нужно написать CoreDataMapper для конвертации UserMO в доменный User.
```
final class UserCoreDataMapper: DomainModelCoreDataMapper {
typealias DomainModel = User
typealias DBEntity = UserMO
// Вложенный маппер, отвечающий за конвертацию ImageMO в Image
private let imageMapper = ImageCoreDataMapper()
func model(from entity: UserMO) -> User? {
guard
let identifier = entity.identifier,
let name = entity.name,
let type = UserType(rawValue: entity.type ?? ""),
let imageEntity = entity.image,
let image = imageMapper.model(from: imageEntity),
let isOnline = entity.isOnline?.boolValue
else {
return nil
}
return User(identifier: identifier,
name: name,
type: type,
image: image,
isOnline: isOnline)
}
}
```
Модели готовы, мапперы написаны. Пристегнитесь, мы взлетаем! 🚀
```
final class ProfileInteractor: ProfileInteractorInput {
// Репозиторий для работы с базой
private let userRepository: Repository
// Сервис для работы с апи
private let userService: UserServiceDescription
// id пользователя, с которым работаем
private let userId: String
init(userId: String) {
self.userId = userId
// В качестве хранилища используем CoreData
userRepository = CoreDataRepository(domainModelMapper: UserCoreDataMapper(), contextProvider: YoulaCoreDataContextProvider.default)
userService = UserService()
}
func obtainUser(id: String, completion: @escaping (Result) -> Void) {
// Запрашиваем пользователя с сервера
userService.obtainUser(id: id, completion: { [weak self] result in
switch result {
case .success(let userResponse):
// Пользователь получен (UserResponse)
// Можем сохранить UserResponse, главное передать маппер, который умеет это делать
// На выходе репозиторий вернет доменную модель (User), поэтому результат мы сразу возвращаем в completion
self?.userRepository.persist(userResponse, mapper: UserResponsePersistableMapper(), completion: completion)
case .failure(let error):
completion(.failure(error))
}
})
}
func updateUserName(\_ newName: String) {
// Создаем объект для фильтрации
// Объект содержит NSPredicate и массив NSSortDescriptor
let query = UserIdQuery(id: userId)
// Запрашиваем первого пользователя
guard var user = userRepository.first(matching: query) else {
return
}
// Меняем имя
user.name = newName
// Сохраняем обновленного пользователя, передаем соответствующий маппер
userRepository.persist(user, mapper: UserPersistableMapper(), completion: nil)
}
private struct UserIdQuery: SortedDatabaseQuery {
typealias DBEntity = UserMO
let id: String
var predicate: NSPredicate? {
return NSPredicate(format: "%K == %@", #keyPath(DBEntity.identifier), id)
}
var sortDescriptors: [NSSortDescriptor] {
return []
}
}
}
```
Круто! Но это не конец
----------------------
Казалось бы, всё готово! Но мы столкнулись ещё с одним челленджем. На один и тот же запрос наш бэкенд может возвращать разный набор полей. Нужно было добиться следующей логики: если поле пришло в ответе, то его следует перезаписать в сущности при сохранении, если же не пришло, то поле в сущности не трогать, поскольку там могло быть значение, которое приходило в других ответах.
Для декодинга мы собирались использовать Codable, но с ним решить эту проблему невозможно, так как поле, которое пришло со значением null, и поле, которое не пришло вообще, в модели будут представлены как nil. Поэтому при сохранении в базу мы не сможем узнать, надо обновлять поле или нет.
Немного покумекав, мы сделали специальный Property Wrapper, а чтобы его можно было использовать при декодинге, расширили KeyedDecodingContainer. Благодаря враперу можно обращаться к полю как к обычному опциональному полю, а если потребуется дополнительная информация, то обратиться к projectedValue через нотацию — $.
```
@propertyWrapper
public struct DetailedResponse {
public enum Response {
// поле не пришло
case notCome
// поле пришло, но null
case null
// поле пришло со значением
case value(Value)
}
public let wrappedValue: Value?
public let projectedValue: Response
public init(response: Response) {
self.projectedValue = response
if case let .value(value) = response {
self.wrappedValue = value
} else {
self.wrappedValue = nil
}
}
}
public extension KeyedDecodingContainer {
func decodeDetailResponse(\_ type: T.Type, forKey key: KeyedDecodingContainer.Key) throws -> DetailedResponse where T: Decodable {
guard contains(key) else {
return DetailedResponse(response: .notCome)
}
if let result = try decodeIfPresent(type, forKey: key) {
return DetailedResponse(response: .value(result))
} else {
return DetailedResponse(response: .null)
}
}
}
```
Разработчикам остаётся пометить нужное поле как [@DetailedResponse](/users/DetailedResponse) и реализовать инициализатор Decodable. А в маппере при сохранении можно опираться на projectedValue, которое предоставит информацию о том, пришло поле или нет.
Предположим, что поле isOnline в модели нашего юзера иногда может не приходить. В этом случае наш декодинг надо переделать следующим образом:
```
struct UserResponse: Decodable {
let identifier: String
let name: String
let type: String
let image: ImageResponse
// Помечаем враппером
@DetailedResponse var isOnline: Bool?
enum CodingKeys: String, CodingKey { ... }
init(from decoder: Decoder) throws {
let container = try decoder.container(keyedBy: CodingKeys.self)
identifier = try container.decode(String.self, forKey: .identifier)
name = try container.decode(String.self, forKey: .name)
type = try container.decode(String.self, forKey: .type)
image = try container.decode(ImageResponse.self, forKey: .image)
// Декодим с помощью специального метода
_isOnline = try container.decodeDetailResponse(Bool.self, forKey: .isOnline)
}
struct User {
let identifier: String
let name: String
let type: UserType
let image: Image
// Теперь поле опциональное
let isOnline: Bool?
}
```
При сохранении смотрим на projectedValue.
```
struct UserResponsePersistableMapper: PersistableMapper {
typealias FromModel = UserResponse
typealias ToModel = UserMO
private let imageResponseMapper = ImageResponsePersistableMapper()
func updateEntity(_ entity: inout UserMO, from model: UserResponse) {
entity.name = model.name
entity.type = model.type
// Свичимся по DetailedResponse.Response
switch model.$isOnline {
case .notCome:
break
case .null:
entity.isOnline = nil
case .value(let newIsOnline):
entity.isOnline = newIsOnline as NSNumber
}
guard let context = entity.managedObjectContext else {
return
}
entity.image = imageResponseMapper.entity(from: model.image, in: context)
}
func keyPathsForPrimaryKeys() -> [PrimaryKeysPaths] {
return [PrimaryKeysPaths(modelKeyPath: \UserResponse.identifier,
entityKeyPath: \UserMO.identifier)]
}
}
```
Вместо итога
------------
На данный момент мы зарефакторили более половины менеджеров с использованием новых подходов: api-сервисы на Alamofire + репозиторий. И уже видим улучшения, ради которых это всё затевали. А именно:
1. постепенно уменьшаем зависимость от RestKit и скоро сможем его выпилить;
2. писать и понимать код стало проще, выработался единый подход для работы с базой;
3. нет нужды заморачиваться с деталями CoreData — можно оперировать доменными моделями.
Велком в комменты — обсудить нашу реализацию, поделиться болью или предложить рекомендации.
PS: При разработке вдохновлялись статьей<https://habr.com/ru/post/542752/> | https://habr.com/ru/post/678120/ | null | ru | null |
# Вышла asyncpg — клиентская библиотека PostgreSQL для Python/asyncio
На конференции EuroPython 2016 Юрий Селиванов (автор async/await-синтаксиса и автор [uvloop](https://habrahabr.ru/post/282972/)) представил новую высокопроизводительную библиотеку для асинхронного доступа к PostgreSQL — [asyncpg](https://github.com/MagicStack/asyncpg). Тесты демонстрируют в среднем в два раза большую скорость, чем у psycopg2 (и её асинхронного варианта — aiopg).
Причина высоких показателей в том, что asyncpg реализует бинарный протокол PostgreSQL нативно, без использования абстракций, вроде DB-API. Кроме того, это позволило получить простую в использовании реализацию:
* **prepared statements**
* **scrollable cursors**
* **partial iteration** результатов запроса
* автоматического кодирования и декодирования [составных типов](https://www.postgresql.org/docs/9.5/static/rowtypes.html), [массивов](https://www.postgresql.org/docs/9.5/static/arrays.html) и их сочетания
* интуитивно понятной поддержки [пользовательских типов](https://www.postgresql.org/docs/9.5/static/xtypes.html)
### Установка
asyncpg доступна на PyPI. Используйте для установки pip:
```
$ pip install asyncpg
```
### Пример использования
```
import asyncio
import asyncpg
async def run():
conn = await asyncpg.connect(user='user', password='password',
database='database', host='127.0.0.1')
values = await conn.fetch('''SELECT * FROM mytable''')
await conn.close()
loop = asyncio.get_event_loop()
loop.run_until_complete(run())
```
**P. S.** Некоторые термины, такие как «prepared statement», я оставил без перевода, а также взял на себя смелость использовать в тексте англицизмы, так как считаю, что дотошный перевод технических текстов может искажать изначальный смысл или затруднять его понимание. Прошу меня за это простить. | https://habr.com/ru/post/306196/ | null | ru | null |
# Агрегаты
> *Этот материал является* [*кросс-постом*](https://azhidkov.pro/posts/22/04/220401-aggregates/) *из моего блога*
>
> *Следить за обновлениями блога можно в моём канале:* [*Эргономичный код*](https://t.me/ergonomic_code)
>
>
Введение
--------
Я считаю, что именно агрегаты из Domain-Driven Design лежат в основе поддерживаемых информационных систем. Однако эта концепция малоизвестна за пределами DDD-сообщества и довольно сложна для понимания, поэтому я решил написать очередной пост посвящённый агрегатам. В основном для чтобы структурировать собственное понимание агрегатов и создать "методичку" для своих команд, но и широкой общественности, я надеюсь, этот пост тоже может быть полезен.
Что такое агрегат? (TLDR)
-------------------------
Агрегат - это кластер сущностей и объектов-значений, объединённых общими инвариантами. Любое взаимодействие с агрегатом осуществляется через одну и только одну из его сущностей, называемую корнем агрегата.
Для того чтобы обеспечить соблюдение инвариантов, агрегат должен удовлетворять следующим требованиям:
1. Выступать единицей персистанса (все сущности всегда загружаются и сохраняются вместе). "Точкой входа" персистанса (загружаемым и сохраняемым объектом) является корень агрегата.
2. Все модификации состояния агрегата должны осуществляться через корень.
3. Все сущности должны входить только в один агрегат.
В объектно-ориентированном коде агрегат всегда материализуется минимум в два класса - корень агрегата и репозиторий агрегата. Внутри агрегата связи реализуются ссылками непосредственно на объекты. Между агрегатами связи реализуются через идентификаторы корней агрегатов.
Например, отчёт с непересекающимися отчётными периодами и составителем моделируется двумя агрегатами, которые на Котлине будут выглядеть так:
```
// Агрегат составителя отчёта
data class Author(
val id: Long,
val name: String
)
interface AuthorsRepo {
fun save(user: Author): Author
fun findById(id: Long): Author?
}
// Агрегат отчёта
data class ReportingPeriod(
val from: LocalDate,
val to: LocalDate
) {
init {
require(from <= to) { "$from > $to" }
}
}
data class Report(
val id: Long,
val reportingPeriods: List,
val authorId: Long
) {
init {
reportingPeriods.sortedBy { it.from }
.windowed(2, partialWindows = false)
.find { it[0].to >= it[1].from }
?.let { throw IllegalArgumentException("Report cannot have intersecting intervals: ${it[0]} and ${it[1]}") }
}
}
interface ReportsRepo {
fun save(user: Report): Report
fun findById(id: Long): Report?
}
```
Почему агрегата именно два, а не один или три? Ответ на этот вопрос лежит в принципах декомпозиции модели информации системы.
Принципы декомпозиции модели информации на агрегаты
---------------------------------------------------
При проектировании агрегатов (как и всех других элементов ПО) следует руководствоваться принципом высокой связанности/низкой сцепленности. В случае агрегатов этот принцип выражается в соблюдении следующих ограничений:
1. Агрегаты не должны иметь циклических связей.
2. Агрегаты должны определять область жизни всех сущностей, в них входящих. Эта область определяется областью жизни корня агрегата. Некорневые сущности не могут появляться раньше корня и продолжать существовать после его удаления.
3. Агрегаты должны обеспечивать соблюдение инвариантов. Агрегаты предоставляют такое API, которое не позволит клиенту перевести модель в невалидное состояние.
4. Агрегаты должны обеспечивать возможность реализовать все операции системы так, чтобы в одной транзакции менялся (или удалялся) один агрегат. Притом речь идёт именно об изменении (в том числе в виде удаления) существующих агрегатов - создавать и читать можно сколько угодно агрегатов.
5. Агрегаты должны быть минимального необходимого размера. Имеется в виду и количество типов сущностей в агрегате, и количество экземпляров сущностей и их размер в байтах.
6. Агрегаты должны храниться целиком в одной системе хранения данных на одном узле. Разные агрегаты одной системы могут храниться на разных узлах или в разных хранилищах.
7. Агрегаты могут ссылаться на другие агрегаты только через идентификаторы корней. Внутри агрегата сущности могут свободно ссылаться друг на друга.
Так вот, почему агрегатов всё-таки именно два? Потому что отчёты и составители ценны сами по себе и имеют независимые жизненные циклы. А периоды не имеют смысла без отчёта и инвариант отсутствия пересечения определяется на кластере объектов отчёта и его отчётных периодов.
Методика декомпозиции модели информации на агрегаты
---------------------------------------------------
Я предпочитаю идти от обратного и на первом этапе считать каждую сущность отдельным агрегатом, а потом искать причины для объединения сущностей в агрегаты. Поэтому первой версией разбиения информации на агрегаты является сама ER-диаграмма.
Затем я ищу инварианты системы. Самый простой и часто встречаемый инвариант - область жизни одной сущности (А) не должна выходить за пределы области жизни другой сущности (Б). В этом случае сущности А и Б нужно объединить в агрегат с Б в качестве корня.
Но самые важные инварианты определяются конкретными людьми в конкретном контексте и для их выявления не существует универсального алгоритма на базе технических вводных. Чтобы выявить самые важные инварианты я обращаюсь к экспертам - заказчикам, пользователям, владельцам продукта, руководителям проектов,
аналитикам и т.д. Зачастую эксперты самостоятельно не могут сформулировать инварианты, и им необходимо помочь, предлагая свои версии и задавая наводящие вопросы (например, "могут ли пересекаться отчётные периоды?"). Конкретные техники и способы помощи экспертам подробно расписаны в книгах по [DDD](#books).
Действительно важные инварианты бизнес так или иначе озвучит - важно их услышать. Если не услышите в процессе разработки, то точно услышите, когда инвариант будет нарушен в промышленной эксплуатации с последствиями для бизнеса:)
Получив список инвариантов, я выбираю те, что затрагивают несколько типов или экземпляров сущностей. Сущности, которые участвуют в обеспечении одного инварианта, объединяю в агрегаты. Если речь идёт о разных типах, то в агрегат я объеднияю сами эти сущности. Если речь идёт о разных экземплярах одной сущности, то я присоединяю их списком к одной из существующих или специально созданной для этого сущности.
Затем я проверяю получившиеся агрегаты на соответствие принципам.
**Принцип акцикличных агрегатов** я сейчас нарушаю крайне редко, а нарушения сразу же видны на ER-диаграмме. При разбиении циклов я пользуюсь принципом стабильных зависимостей и удаляю ссылку из более "стабильного" агрегата. Стабильность определяется по значимости для бизнеса, вероятности изменений в будущем и количеству входящих связей. Значимость для бизнеса и вероятность изменений определяются посредством гадания на кофейной гуще.
Что такое диаграмма эффектов?Диаграмма эффектов - это моё изобретение, предназначенное для помощи в декомпозиции модели информации на агрегаты и в декомпозиции системы на модули. Сейчас диаграмма эффектов толком не описана - есть микропост с ранним описанием [подхода к декомпозиции](https://azhidkov.pro/posts/21/03/250326-project-decomposiotion/) в котором есть пара ссылок на открытые статьи с описанием похожих диаграмм и [черновик поста о диаграмме эффектов](https://azhidkov.pro/drafts/aggregates/effects-diagram/).
Чтобы проверить **принцип изменения одного агрегата в одной транзакции**, я строю диаграмму эффектов для того чтобы увидеть операции, которые меняют несколько агрегатов. С такими агрегатами можно поступить по-разному:
1. Если агрегаты всегда меняются вместе и размер позволяет - объединить их в один.
2. Если в одной операции смешались разные ответственности и есть возможность - разбить операцию на две.
3. Если в одной операции смешались разные ответственности, но разбиение операции невозможно или ухудшает дизайн - разбить изменения агрегатов на разные транзакции.
1. В первую очередь стоит посмотреть на вариант с использованием шины событий. В этом случае в первой транзакции остаётся изменение первого агрегата и генерация события, а в изменения остальных агрегатов уходят в транзакции обработчиков события.
2. Если разбиение через события приводит к появлению каскада событий, то можно просто разбить операцию на несколько транзакций.
4. Если я уверен, что операция имеет высокую связанность, а конкуренция за агрегат низкая (он меняется редко или только одним пользователем) - оставить всё как есть.
Если выполнять декомпозицию по описанной выше методике, то агрегаты с большим количеством видов сущностей у меня ни разу не появлялись. Поэтому для проверки **принципа малых агрегатов** остаётся удостоверится в отсутствии "больших" атрибутов и связей "один к действительно многому".
"Большие" тексты и массивы байт (картинки) я всегда выношу в отдельные агрегаты, даже когда это приводит к нарушениям принципов общей области жизни и изменения одного агрегата в одной транзакции. "Большой" - понятие относительное, и я выделяю атрибуты, если математическое ожидание их размера превышает ~4 килобайта.
"Действительно многие" связи я также всегда выношу в отдельные агрегаты вопреки
остальным принципам. "Действительно многие" - тоже понятие относительное, и я выношу связи, когда математическое ожидание количества связанных объектов превышает ~20 штук.
Для проверки всех остальных принципов у меня нет устоявшихся инструментария и эвристик и их нарушение я ищу "методом вдумчивого взгляда".
Процесс "проверить-подрихтовать-обновить диаграммы" я повторяю до тех пор, пока не получу результат, проходящий проверку.
Частые ошибки проектирования агрегатов
--------------------------------------
### Моделирование лишних связей
Самой распространённой ошибкой является добавление лишних ссылок между объектами. Предельный случай этой ошибки - модель связного графа объектов.
Но и в контексте проектирования агрегатов можно внести в модель лишние связи. Чаще всего причинами внесения лишних связей являются:
1. удобство навигации - связь добавляется, чтобы была возможность добраться до объекта А, имея на руках объект Б.
2. отражение реальности - связь добавляется потому, что "в реальности" сущности связаны.
3. отражение модели данных - связь добавляется потому, что в логической схеме реляционной БД есть соответствующий атрибут и внешний ключ.
4. отражение пользовательского интерфейса - связь добавляется потому, что в UI в форме ввода или вывода данных, участвуют данные разных сущностей.
Но напомню, что единственной причиной добавления ссылки на объект является вхождение объекта в агрегат, а единственной причиной включения объекта в агрегат является его участие в обеспечении инварианта. Поэтому если связь не требуется для обеспечения инварианта, то её включение необходимо дважды обдумать. Потому что лишние связи ведут к повышению сцепленности дизайна и как следствие усложнению системы и деградации производительности.
#### Анемичная доменная модель
Ещё одной распространённой ошибкой является анемичная доменная модель. Анемичная доменная модель характеризуется в первую очередь сущностями, у которых все свойства доступны для чтения и записи через геттеры и сеттеры. При этом всё поведение сущности ограничивается геттерами и сеттерами. Эта ошибка ведёт к утери возможности обеспечить соблюдение инвариантов.
Кроме того, последствием анемичной модели становится погребение существенных для агрегата трансформаций в методах сервисов приложения. Что влечёт за собой жёсткую сцепку трансформаций и ввода-вывода. Из-за чего:
1. Усложняется задача тестирования трансформаций.
2. Снижается переиспользуемость трансформаций.
3. Усложняется задача понимания кода из-за смешения разных уровней абстракции в сервисе приложения.
Давайте сравним решения одной и той же задачи с помощью анемичной и "полнокровной" доменных моделей.
В качестве задачи возьмём систему хранения информации о торговле на бирже крипто-валют. В центре этой системы находятся "торги по символу" - торги между парой крипто-валют.
Требования к системе следующие:
1. Каждый пользователь по каждой паре может вести торги с использованием "грида" - по сути, набора значений параметров алгоритма торговли.
2. В каждый момент времени для каждого символа пользователя может быть активен только один из гридов символа.
3. Гриды уникально идентифицируются своим именем.
4. Для каждого грида хранится статистика по торгам с его участием (в примере - только доход).
5. Статистика может меняться только у активного грида.
6. Каждый пользователь может вести торги одновременно по нулю и более символов.
Так же есть ограничение на API системы: обновление информации осуществляется посредством отправки клиентом списка активных в данный момент пар и их гридов.
Реализация этой задачи с анемичной доменной моделью будет выглядеть примерно так:
```
data class Grid(
var name: String,
var profit: BigDecimal
)
data class SymbolTrading(
var symbol: String,
var grids: MutableList,
var activeGrid: Grid?
)
data class CustomerTradings(
var customerId: Long,
var tradings: MutableList
)
data class ActiveSymbol(
var symbol: String,
var gridName: String
)
fun fetchCustomerSymbols(id: Long): CustomerTradings = TODO()
fun saveCustomerSymbols(customerSymbols: CustomerTradings): Unit = TODO()
fun updateCustomerSymbols(customerId: Long, activeSymbols: List) {
activeSymbols.map { activeSymbol ->
val trading = customerSymbols.tradings.find { it.symbol == activeSymbol.symbol }
if (trading != null) { // (2)
trading.activeGrid = trading.grids.find { it.name == activeSymbol.gridName } ?: Grid(activeSymbol.gridName, BigDecimal(0))
} else {
val activeGrid = Grid(activeSymbol.gridName, BigDecimal(0))
customerSymbols.tradings.add(
SymbolTrading(activeSymbol.symbol, mutableListOf(activeGrid), activeGrid)
)
}
}
saveCustomerSymbols(customerSymbols) // (1)
}
```
Такую реализацию будет относительно сложно протестировать - надо будет либо сетапить и проверять состояние БД, либо использовать моки и делать тесты хрупким и зависящим от деталей реализации.
Также здесь в одном методе смешаны и работа с БД (1) и бизнес-правила (2).
Эти две проблемы можно решить посредством вынесения бизнес-правил в утилитарный метод. Однако это не решит основную проблему - с таким подходом невозможно защитить инварианты. Ничего не остановит клиентский код от удаления активного грида из `trading.grids`. Как и от изменения статистики по неактивному гриду.
Для того чтобы защитить инварианты, необходимо большую часть логики перенести в доменную модель. Также необходимо исключить возможность неконтролируемых операций записи.
Если оставаться в парадигме изменяемой модели данных, то это можно сделать путём сокращения области видимости сеттеров до внутренней (`internal`) в случае Котлина. Но тогда придётся выделять агрегаты в разные модули, что очень не удобно.
В том числе (но не только) по этому, я рекомендую пойти простым путём: сделать сущности неизменяемыми, с закрытым конструктором и опубликованным фабричным методом вместо него, который будет гарантировать соблюдение инвариантов.
```
typealias Symbol = String
typealias GridName = String
data class Grid(
val name: GridName,
val profit: BigDecimal = BigDecimal(0)
)
data class SymbolTrading private constructor(
val symbol: Symbol,
val grids: Map,
val activeGrid: GridName
) {
init {
require(activeGrid in grids) { "Active grid ($activeGrid) should be within symbol's grids ($grids)" }
}
companion object {
fun new(symbol: Symbol, gridName: GridName) =
SymbolTrading(symbol, mapOf(gridName to Grid(gridName)), gridName)
}
fun activateGrid(gridName: String): SymbolTrading =
if (gridName in grids) SymbolTrading(symbol, grids, gridName)
else SymbolTrading(symbol, grids + (gridName to Grid(gridName)), gridName)
}
data class CustomerSymbols(
val customerId: Long,
val tradings: Map
) {
fun activateSymbols(activeSymbols: List): CustomerSymbols {
val updatedTradings = activeSymbols.map {
tradings[it.symbol]?.activateGrid(it.gridName)
?: SymbolTrading.new(it.symbol, it.gridName)
}
return CustomerSymbols(customerId, tradings + updatedTradings.associateBy { it.symbol })
}
}
data class ActiveSymbol(
val symbol: String,
val gridName: String
)
fun fetchCustomerSymbols(id: Long): CustomerSymbols = TODO()
fun saveCustomerSymbols(customerSymbols: CustomerSymbols): Unit = TODO()
fun updateCustomerSymbols(customerId: Long, activeSymbols: List) {
val customerSymbols = fetchCustomerSymbols(customerId)
val updatedCustomerSymbols = customerSymbols.activateSymbols(activeSymbols)
saveCustomerSymbols(updatedCustomerSymbols)
}
```
Такая реализация гарантирует, что любые модификации в данных должны будут пройти через `CustomerSymbols`. А так как `CustomerSymbols` является единицей работы с БД, это гарантирует, что в БД не попадут никакие данные в обход кода контроля инвариантов в модели.
"Полнокровная" модель явно очерчивает список доступных операций и повышает их
видимость - все операции над агрегатом находится рядом с агрегатом, а не разбросаны по сервисам и утилитарным методам.
Наконец, вся бизнес логика, которую надо покрыть полноценным набором тестов, ушла в чистую доменную модель которую очень легко тестировать. А код с эффектами - `updateCustomerSymbols` - стал тривиальным и его достаточно протестировать одним интеграционным, е2е или сценарным тестом.
Всё вместе - гарантия соблюдения инвариантов, упрощение анализа операций записи и упрощение тестирования - позволяет существенно уменьшить количество ошибок и регрессий и, как следствие, сократить стоимость разработки в длительной перспективе.
FAQ
---
### Как программировать связи?
Связи внутри агрегата программируются свойствами со ссылками на объекты (a), а между агрегатами - свойствами с идентификаторами корней агрегатов (b):
```
data class Report(
val reportingPeriods: List, // (a)
val authorId: Long // (b)
)
```
### Как защитить инварианты?
Для того чтобы гарантировать сохранность своих инвариантов, агрегат должен не позволять внешним клиентам менять состояние напрямую. Для достижения этого необходимо следовать принципу "Tell Don’t Ask". В случае агрегатов это означает предоставление корнем агрегата API внесения изменений вместо API получения изменяемых объектов внутренних сущностей.
При этом для получения информации об агрегате есть несколько подходов:
1. Использовать неизменяемые классы для моделирования сущностей агрегатов. Объекты таких классов можно безопасно передавать клиентам, поэтому агрегат может предоставить прямой доступ к своим частям.
1. Плюсы: минимум дополнительного кода, хорошо масштабируется по количеству методов запроса информации.
2. Минусы: повышает сцепленность между клиентами и агрегатом.
2. Предоставлять API в том числе для получения информации только на уровне корня агрегата. В этом случае внутренние сущности вообще не попадают в публичное API агрегата.
1. Плюсы: полностью скрывает устройство агрегата и минимизирует связанность между клиентами и агрегатом.
2. Минусы: плохо масштабируется по количеству методов запроса информации.
3. Использовать копии изменяемых объектов. Этот подход похож на первый, тем что даёт клиентам доступ к частям агрегата, но клиентам выдаются не сами объекты частей, а их копии.
1. Плюсы: может быть использован в случае, когда нет возможности сделать объекты неизменяемыми.
2. Минусы: те же, что и у первого подхода, и необходимость в дополнительном коде копирования объектов в каждом геттере и, как следствие, большей нагрузки на сборщика мусора.
4. Использовать "read-only" представления. Похож на третий подход, но вместо копий предполагается возвращать "read-only" представления изменяемых сущностей.
1. Плюсы: нет необходимости в коде копирования объектов и снижение нагрузки на сборщика мусора.
2. Минусы: требует описания дополнительных интерфейсов для представлений и не очень надёжен - никто не запретит клиенту привести объект к изменяемому типу или поменять его через механизм рефлексии.
Я сам использую преимущественно первый подход, подключая второй в случаях, когда вижу необходимость в сокрытии структуры агрегата.
### Как реализовать выборку данных для UI?
Существует несколько походов, и у каждого из них свои плюсы и минусы.
1. Сборка DTO из агрегатов. Заключается в том, чтобы вытащить нужные агрегаты из репозиториев и собрать из них DTO.
1. Плюсы - минимальная сцепленность модулей, минимум дополнительного кода
2. Минусы - потенциальные проблемы с производительностью из-за нескольких запросов в БД и больше ручной работы по добавлению зависимостей на репозитории и чтению данных из них.
2. Сборка DPO из агрегатов. По сути то же, что и первый вариант, только клиенту выдаётся Data Payload Object (DPO), вместо DTO. DPO - это набор агрегатов, из которого клиент сам строит нужные ему структуры.
1. Плюсы - минимальная сцепленность модулей, не нужен код для маппинга агрегатов в клиентские структуры.
2. Минусы - клиенту будут возвращаться лишние данные, что может плохо сказаться на эффективности и безопасности системы.
3. Отдельные модели для записи и чтения. В дополнение к модели для записи (агрегаты), создаётся дополнительная денормализованная модель для чтения.
1. Плюсы - эффективная работа с БД и создание DTO средствами ORM.
2. Минусы - неявная сцепленность модуля генерации DTO с деталями реализации всех модулей агрегатов, в два раза больше кода для описания модели данных.
4. Сборка DTO в СУБД. Современные СУБД (PostgreSQL, в частности) имеют встроенные средства для формирования JSON и позволяют собрать финальную DTO непосредственно SQL-запросом.
1. Плюсы - самая эффективная работа с БД.
2. Минусы - завязка на диалект определённой СУБД, менее удобный инструментарий для работы с SQL-запросами (чем с кодом на Kotlin, например), примитивные средства переиспользования кода и создания абстракций в самом SQL.
Варианты 1-3 подробно рассмотрены в [книгах по DDD](#books), вариант 4 хорошо описан в посте Лукаса Едера [Stop Mapping Stuff in Your Middleware. Use SQL’s XML or JSON Operators Instead](https://blog.jooq.org/stop-mapping-stuff-in-your-middleware-use-sqls-xml-or-json-operators-instead/)
Я сейчас в качестве варианта по умолчанию использую первый, а третий или четвёртый задействую в "горячем" коде. Второй вариант я пока что ни разу не использовал.
### Зачем объединять сущности в агрегаты?
Для того чтобы обеспечить выполнение инварианта, затрагивающего несколько
сущностей. Частым примером такого инварианта являются слабые сущности - сущности
область жизни которых ограничена областью жизни другой сущности.
### Почему агрегаты должны быть маленькими?
Из соображений производительности. Так как агрегаты являются единицей персистанса, большие агрегаты приведут к передаче больших объёмов данных по сети. И так как агрегаты являются единицей согласованности, большие агрегаты приведут к "большим" транзакциям (по количеству затронутых объектов и длительности), что повлечёт за собой большое количество конфликтующих транзакций. Это, в свою очередь, станет причиной либо ошибкам согласованности, либо большим накладным расходам на синхронизацию транзакций.
### Когда не стоит объединять сущности в агрегаты?
Тогда, когда это приведёт к большим агрегатам. Например, пользователя, его фото и его комментарии лучше разделить по разным агрегатам, не смотря на то, что фото и комментарии являются слабыми сущностями. Фото - просто в силу большого размера. Комментарии - в силу их неограниченного роста.
### Когда можно включать в агрегат много видов сущностей?
Агрегат может включать много видов сущностей, при соблюдении двух условий:
1. Агрегат преимущественно изменяется одним пользователем - исключает проблемы с синхронизацией.
2. Агрегат остаётся ограниченным по размеру в байтах - исключает проблемы с производительностью.
### Почему в транзакции можно менять только один агрегат?
Во-первых - по определению. Агрегат определяет границы согласованности.
Во-вторых, потому что много маленьких агрегатов - это де-факто один большой агрегат со всеми вытекающими проблемами с синхронизацией и производительностью.
В-третьих, агрегаты могут храниться на разных машинах. А по определению агрегата это значит, что придётся иметь дело с распределёнными транзакциями. С которыми я бы предпочёл иметь дело в последнюю очередь.
### Как обеспечить выполнение принципа "модификация одного агрегата в одной транзакции"?
В первую очередь, необходимо понять действительно ли эти модификации
должны быть строго согласованы, или можно обойтись согласованностью в
конечном итоге. Для этого автор Implementing Domain-Driven Design предлагает следующий алгоритм:
1. если обеспечение согласованности изменений является ответственностью пользователя, инициировавшего выполнение операции - то модификации должны быть строго согласованы.
2. иначе - можно обойтись согласованностью в конечном итоге.
Если получилось что, модификации должны быть строго согласованы, то это значит, что вы "открыли" новый инвариант, и новый агрегат для его обеспечения. Если при этом агрегат становится большим - надо взвешивать плюсы и минусы и либо оставлять большой агрегат, либо возвращаться на этап проектирования агрегатов и операций системы и искать новое решение. Возможно несколько потенциальных решений:
1. "Закрыть" этот неудобный инвариант и перейти к согласованности в конечном итоге.
2. Убрать из агрегата "лишние" сущности, которые были включены в него по причинам отличным от обеспечения инварианта.
3. Разбить большой агрегат, новым способом, который обеспечит соблюдение всех инвариантов. Возможно для этого придётся отказаться от некоторых инвариантов.
Если же модификации могут быть согласованными в конечном итоге, то операцию необходимо разбить на две. Для этого надо разбить код на два транзакционных метода в слое сервисов приложения. Затем либо оба этих метода публикуются для клиентов, либо они связываются через публикацию доменного события первым методом и его обработку вторым.
Заключение
----------
Агрегаты - действительно сложная тема:
> Clustering Entities (5) and Value Objects (6) into an Aggregate with a carefully crafted consistency boundary may at first seem like quick work, but among all DDD tactical guidance, this pattern is one of the least well understood.
>
> — Vaughn Vernon, Implementing Domain-Driven Design
>
>
и её невозможно полностью понять, прочитав один пост.
Но я постарался собрать в этом посте необходимый минимум информации для того, чтобы спроектировать первый агрегат.
Дальнейшее чтение по теме
-------------------------
* [idddd] [An In-Depth Understanding of Aggregation in Domain-Driven Design](https://www.alibabacloud.com/blog/an-in-depth-understanding-of-aggregation-in-domain-driven-design_598034)
* [ddd] [Domain-Driven Design: Tackling Complexity in the Heart of Software](https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215)
* [dddmf] [Domain Modeling Made Functional: Tackle Software Complexity with Domain-Driven Design and F#](https://pragprog.com/titles/swdddf/domain-modeling-made-functional/)
* [dddd] [Domain-Driven Design Distilled](https://www.oreilly.com/library/view/domain-driven-design-distilled/9780134434964/)
* [pppofddd] [Patterns, Principles, and Practises of Domain-Driven Design](https://www.oreilly.com/library/view/patterns-principles-and/9781118714706/)
* [iddd] [Implementing Domain-Driven Design](https://www.amazon.com/Implementing-Domain-Driven-Design-Vaughn-Vernon/dp/0321834577/ref=pd_sbs_1/141-8150406-3569707?pd_rd_w=esaTU&pf_rd_p=3676f086-9496-4fd7-8490-77cf7f43f846&pf_rd_r=C3ZFNR15H4FV4HF5NM1B&pd_rd_r=15e71ee5-1ea0-496e-baee-6e3137eba574&pd_rd_wg=49plh&pd_rd_i=0321834577&psc=1) | https://habr.com/ru/post/660599/ | null | ru | null |
# Python & оптимизация времени и памяти
Введение
--------
Зачастую скорость выполнения python оставляет желать лучшего. Некоторые отказываются от использования python именно по этой причине, но существует несколько способов оптимизировать код python как по времени, так и по используемой памяти.
Хотелось бы поделиться несколькими методами, которые помогают в реальных задачах. Я пользуюсь win10 x64.
Экономим память силами Python
-----------------------------
В качестве примера рассмотрим вполне реальный пример. Пусть у нас имеется некоторый магазин в котором есть список товаров. Вот нам понадобилось поработать с этими товарами. Самый хороший вариант, когда все товары хранятся в БД, но вдруг что-то пошло не так, и мы решили загрузить все товары в память, дабы обработать их. И тут встает резонный вопрос, а хватит ли нам памяти для работы с таким количеством товаров?
Давайте первым делом создадим некий класс, отвечающий за наш магазин. У него будет лишь 2 поля: name и listGoods, которые отвечают за название магазина и список товаров соответственно.
```
class ShopClass:
def __init__(self, name=""):
self.name = name
self.listGoods = []
```
Теперь мы хотим наполнить магазин товарами (а именно заполнить поле listGoods). Для этого создадим класс, отвечающий за информацию об одном товаре (я использую dataclass’ы для таких примеров).
```
# если ругается на dataclass, то делайте
# pip install dataclasses
# затем в коде вызывайте импорт
# from dataclasses import dataclass
@dataclass
class DataGoods:
name:str
price:int
unit:str
```
Далее необходимо заполнить наш магазин товарами. Для чистоты эксперимента я создам по 200 одинаковых товаров в 3х категориях:
```
shop = ShopClass("MyShop")
for _ in range(200):
shop.listGoods.extend([
DataGoods("телефон", 20000, "RUB"),
DataGoods("телевизор", 45000, "RUB"),
DataGoods("тостер", 2000, "RUB")
])
```
Теперь пришло время измерить память, которую занимает наш магазин в оперативке (для измерения памяти я использую модуль pympler):
```
from pympler import asizeof
print("Размер магазина:", asizeof.asizeof(shop))
>>> Размер магазина: 106648
```
Получается, что наш магазин в оперативке занял почти 106Кб. Да, это не так много, но если учесть, что я сохранил лишь 600 товаров, заполнив в них только информацию о наименовании, цене и валюте, в реальной задаче придется хранить в несколько раз больше полей. Например, можно хранить артикул, производителя, количество товара на складе, страну производителя, цвет модели, вес и много других параметров. Все эти данные могут раздуть ваш магазин с нескольких килобайт до нескольких сотен мегабайт (и это при условии, что данные еще даже не начинали обрабатываться).
Теперь перейдем к решению данной проблемы. Python создает новый объект таким образом, что под него выделяется очень много информации, о которой мы даже не догадываемся. Надо понимать, что python создает объект \_\_dict\_\_ внутри класса для того, чтобы можно было добавлять новые атрибуты и удалять уже имеющиеся без особых усилий и последствий. Посмотрим, как можно динамически добавлять новые атрибуты в класс.
```
shop = ShopClass("MyShop")
print(shop.__dict__)
>>> {'name': 'MyShop', 'listGoods': []}
shop.city = "Москва"
print(shop.__dict__)
>>> {'name': 'MyShop', 'listGoods': [], 'city': 'Москва'}
```
Однако в нашем примере это абсолютно не играет никакой роли. Мы уже заранее знаем, какие атрибуты должны быть у нас. В python’e есть магический атрибут \_\_slots\_\_, который позволяет отказаться от \_\_dict\_\_. Отказ от \_\_dict\_\_ приведет к тому, что для новых классов не будет создаваться словарь со всеми атрибутами и хранимым в них данными, по итогу объем занимаемой памяти должен будет уменьшиться. Изменим немного наши классы:
```
class ShopClass:
__slots__ = ("name", "listGoods")
def __init__(self, name=""):
self.name = name
self.listGoods = []
@dataclass
class DataGoods:
__slots__ = ("name", "price", "unit")
name:str
price:int
unit:str
```
И протестируем по памяти наш магазин.
```
from pympler import asizeof
print("Размер магазина:", asizeof.asizeof(shop))
>>> Размер магазина: 43904
```
Как видно, объем, занимаемый магазином, уменьшился почти в 2.4 раза (значение может варьироваться в зависимости от операционной системы, версии Python, значений и других факторов). У нас получилось оптимизировать занимаемый объем памяти, добавив всего пару строчек кода. Но у такого подхода есть и минусы, например, если вы захотите добавить новый атрибут, вы получите ошибку:
```
shop = ShopClass("MyShop")
shop.city = "Москва"
>>> AttributeError: 'ShopClass' object has no attribute 'city'
```
На этом преимущества использования слотов не заканчиваются, из-за того, что мы избавились от атрибута \_\_dict\_\_ теперь ptyhon'у нет необходимости заполнять словарь каждого класса, что влияет и на скорость работы алгоритма. Протестируем наш код при помощи модуля timeit, первый раз протестируем наш код на отключенных \_\_slots\_\_ (включенном\_\_dict\_\_):
```
import timeit
code = """
class ShopClass:
#__slots__ = ("name", "listGoods")
def __init__(self, name=""):
self.name = name
self.listGoods = []
@dataclass
class DataGoods:
#__slots__ = ("name", "price", "unit")
name:str
price:int
unit:str
shop = ShopClass("MyShop")
for _ in range(200):
shop.listGoods.extend([
DataGoods("телефон", 20000, "RUB"),
DataGoods("телевизор", 45000, "RUB"),
DataGoods("тостер", 2000, "RUB")
])
"""
print(timeit.timeit(code, number=60000))
>>> 33.4812513
```
Теперь включим \_\_slots\_\_ (#\_\_slots\_\_ = ("name", "price", "unit") -> \_\_slots\_\_ = ("name", "price", "unit") и # \_\_slots\_\_ = ("name", "listGoods") -> \_\_slots\_\_ = ("name", "listGoods")):
```
# включили __slots__ в коде выше
print(timeit.timeit(code, number=60000))
>>> 28.535005599999998
```
Результат оказался более чем удовлетворительным, получилось ускорить код примерно на 15% (тестирование проводилось несколько раз, результат был всегда примерно одинаковый).
Таким образом, у нас получилось не только уменьшить объем памяти, занимаемой программой, но и ускорить наш код.
Пытаемся ускорить код
---------------------
Способов ускорить python существует несколько, начиная от использования встроенных фишек язык (например, описанных в прошлой главе), заканчивая написанием расширений на C/C++ и других языках.
Я расскажу лишь о тех способах, которые не займут у вас много времени на изучение и позволят в короткий срок начать пользоваться этим функционалом.
#### Cython
На мой взгляд Cython является отличным решением, если вы хотите писать код на Python, но при этом вам важна скорость выполнения кода. Реализуем код для подсчета сумм стоимости всех телевизоров, телефонов и тостеров на чистом Python и рассчитаем время, которое было затрачено (будем создавать 20.000.000 товаров):
```
import time
class ShopClass:
__slots__ = ("name", "listGoods")
def __init__(self, name=""):
self.name = name
self.listGoods = []
@dataclass
class DataGoods:
__slots__ = ("name", "price", "unit")
name: str
price: int
unit: str
shop = ShopClass("MyShop")
t = time.time()
for _ in range(200*100000):
shop.listGoods.extend([
DataGoods("телефон", 20000, "RUB"),
DataGoods("телевизор", 45000, "RUB"),
DataGoods("тостер", 2000, "RUB")
])
print("СОЗДАЕМ ТОВАРЫ НА PYTHON:", time.time()-t)
>>> СОЗДАЕМ ТОВАРЫ НА PYTHON: 44.49887752532959
telephoneSum, televizorSum, tosterSum = 0, 0, 0
t = time.time()
for goods in shop.listGoods:
if goods.name == "телефон":
telephoneSum += goods.price
elif goods.name == "телевизор":
televizorSum += goods.price
elif goods.name == "тостер":
tosterSum += goods.price
print("ВРЕМЯ НА ПОДСЧЁТ СУММ PYTHON:", time.time() - t)
>>> ВРЕМЯ НА ПОДСЧЁТ СУММ PYTHON: 13.135360717773438
```
Как мы видим, время обработки весьма неутешительно. Теперь приступим к использованию cython. Для начала ставим библиотеку cython\_npm (см. [официальный гитхаб](https://github.com/minhtuan221/cython-npm)): *pip install cython-npm*. Теперь создадим новую папку в нашем проекте, назовем её cython\_code и в ней создадим файл cython\_data.pyx (программы cython пишутся с расширением .pyx).
Перепишем класс магазина под cython:
```
cdef class CythonShopClass:
cdef str name
cdef list listGoods
def __init__(self, str name):
self.name = name
self.listGoods = []
```
В cython необходимо строго типизировать каждую переменную, которую вы используете в коде (это не обязательно, но если этого не делать, то уменьшения по времени не будет). Для этого необходимо писать cdef <тип данных> <название переменной> в каждом классе или методе. Реализуем остальной код на cython. Функцию my\_def() реализуем без cdef, а с привычным нам def, так как её мы будем вызывать из основного python файла. Также в начале нашего файла .pyx необходимо прописать версию языка (# cython: language\_level=3).
```
# cython: language_level=3
# на забывает вставить код класса магазина
cdef class CythonDataGoods:
cdef str name
cdef int price
cdef str unit
def __init__(self, str name, int price, str unit):
self.name = name
self.price = price
self.unit = unit
cdef int c_testFunc():
cdef CythonShopClass shop
cdef CythonDataGoods goods
cdef int i, t, telephoneSum, televizorSum, tosterSum
size, i, telephoneSum, televizorSum, tosterSum = 0, 0, 0, 0, 0
shop = CythonShopClass("MyShop")
t = time.time()
for i in range(200*100000):
shop.listGoods.extend([
CythonDataGoods("телефон", 20000, "RUB"),
CythonDataGoods("телевизор", 45000, "RUB"),
CythonDataGoods("тостер", 2000, "RUB")
])
print("СОЗДАЕМ ТОВАРЫ НА CYTHON:", time.time()-t)
t = time.time()
for goods in shop.listGoods:
if goods.name == "телефон":
telephoneSum += goods.price
elif goods.name == "телевизор":
televizorSum += goods.price
elif goods.name == "тостер":
tosterSum += goods.price
print("ВРЕМЯ НА ПОДСЧЁТ СУММ CYTHON:", time.time() - t)
return 0
def my_def():
data = c_testFunc()
return data
```
Теперь в main.py нашего проекта сделаем вызов cython кода. Для этого делаем сначала импорт всех установленных библиотек:
```
from cython_npm.cythoncompile import export
from cython_npm.cythoncompile import install
import time
```
И делаем сразу же компиляцию нашего cython и его импорт в основной python код
```
export('cython_code/cython_data.pyx')
import cython_code.cython_data as cython_data
```
Теперь необходимо вызвать код cython
```
if __name__ == "__main__":
a = cython_data.my_def()
```
Запускаем. Обратим внимание, что было выведено в консоли. В cython, где мы делали вывод времени на создание товаров, мы получили:
```
>>> СОЗДАЕМ ТОВАРЫ НА CYTHON: 4.082242012023926
```
А там где был вывод после подсчета сумм получили:
```
>>> ВРЕМЯ НА ПОДСЧЁТ СУММ CYTHON: 1.0513946056365967
```
Как мы видим, скорость создания товаров сократилась с 44 до 4 секунд, то есть мы ускорили данную часть кода почти в 11 раз. При подсчете сумм время сократилось с 13 секунд до 1 секунды, примерно в 13 раз.
Таким образом, использование cython - это один самых простых способов для того, чтобы ускорить свою программу в несколько раз, он также подойдет для тех, кто придерживается типизации данных в коде. Стоит также отметить, что время прироста скорости зависит от задачи, при решении некоторых задач cython может ускорить ваш код до 100 раз.
#### Магия Python
Конечно, использование сторонних надстроек или модулей для ускорения - это хорошо, но также стоит оптимизировать свои алгоритмы. Например, ускорим часть кода, где идет добавление новых товаров в список магазина. Для этого напишем лямбда функцию, которая будет возвращать список параметров, которые нужны для нового товара. Также будем пользоваться генератором списков:
```
shop = ShopClass("MyShop")
t = time.time()
getGoods = lambda index: {0: ("телефон", 20000, "RUB"),
1: ("телевизор", 45000, "RUB"),
2:("тостер", 2000, "RUB")}.get(index)
shop.listGoods = [DataGoods(*getGoods(i%3)) for i in range(200*100000)]
print("СОЗДАЕМ ТОВАРЫ НА PYTHON:", time.time()-t)
>>> СОЗДАЕМ ТОВАРЫ НА PYTHON: 19.719463109970093
```
Скорость увеличилась примерно в 2 раза, при этом мы пользовались силами самого python. Генераторы в python - очень удобная вещь, они позволяют не только ускорить ваш код, но и оптимизировать его по используемой памяти.
#### PyPy
Бывает так, что нет возможности переписать код на cython или другой язык, потому что уже имеется достаточно большая кодовая база (или по другой причине), а скорость выполнения программы хочется увеличить. Рассмотрим код из прошлого примера, где мы использовали лямбда функции и генератор списков. Тут на помощь может прийти PyPy, это интерпретатор языка python, использующий JIT компилятор. Однако PyPy поддерживает не все сторонние библиотеки, если вы используете в коде таковые, то изучите подробнее документацию. Выполнить python код при помощи PyPy очень легко.
Для начала качаем PyPy с [официального сайта](https://www.pypy.org/download.html). Распаковываем в любую папку, открываем cmd и заходим в папку, где теперь лежит файл pypy3.exe, в эту же папку положим наш код с программой. Теперь в cmd пропишем следующую команду:
Таким образом, 19 секунд python’овского кода из прошлого примера у нас получилось сократить до 4.5 секунд вообще без переписывания кода, то есть почти в 4 раза.
Вывод
-----
Мы рассмотрели несколько вариантов оптимизации кода по времени и памяти. На зло всем хейтерам, которые говорят, что python медленный, мы смогли достичь ускорения кода в десятки раз.
Были рассмотрены не все возможные варианты ускорения кода. В некоторых случаях можно использовать Numba, NumPy, Nim или multiprocessing. Все зависит от того, какую задачу вы решаете. Некоторые задачи будет проще решать на других языках, так как python не способен решить всё на этом свете.
Прежде чем приступить к выбору функционала для оптимизации кода необходимо провести внутреннюю оптимизацию кода на чистом python, по максимуму избавиться от циклов в циклах в циклах в цикле, очищать руками память и удалять ненужные элементы по ходу выполнения кода. Не стоит ожидать, что переписав ваш код на другой язык - это решит все ваши проблемы, учитесь искать узкие места в коде и оптимизировать их алгоритмически или при помощи фишек самого языка. | https://habr.com/ru/post/551150/ | null | ru | null |
# Как правильно использовать доступный объем хранилища
Мы давно пользуемся облачными сервисами: почта, хранилища, соцсети, мессенджеры. Все они работают удаленно — отправляем сообщения и файлы, а хранятся и обрабатываются они на удаленных серверах. Также работает и облачный гейминг: пользователь подключается к сервису, выбирает игру и запускает. Для игрока это удобно, потому что игры запускаются почти мгновенно, не занимают память, и не нужен мощный игровой компьютер.
Для облачного сервиса все иначе — у него возникают проблемы хранения данных. Каждая игра может весить десятки или сотни гигабайт, например, «Ведьмак 3» занимает 50 Гбайт, а «Call of Duty: Black Ops III» — 113. При этом игроки не будут пользоваться сервисом с 2-3 играми, как минимум нужно несколько десятков. Кроме хранения сотен игр, сервису нужно решать, какой объем хранилища выделять на одного игрока, и масштабироваться, когда их будут тысячи.
Хранить ли все это на своих серверах: сколько их нужно, где ставить дата-центры, как «на лету» синхронизировать данные между несколькими дата-центрами? Покупать «облака»? Использовать виртуальные машины? Можно ли хранить данные пользователей со сжатием в 5 раз и предоставлять их в real-time? Как исключить любое влияние пользователей друг на друга при последовательном использовании одной и той же виртуальной машины?
Все эти задачи успешно удалось решить в Playkey.net — облачной игровой платформе. **Владимир Рябов** ([Graymansama](https://habr.com/ru/users/graymansama/)) — руководитель отдела системного администрирования — подробно расскажет о технологии ZFS для FreeBSD, которая в этом помогла, и ее свежем форке ZOL (ZFS on Linux).
Тысяча серверов компании расположены в удаленных дата-центрах в Москве, в Лондоне и Франкфурте. В сервисе больше 250 игр, в которые играют 100 тысяч игроков в месяц.
Сервис работает так: игра запускается на серверах компании, от пользователя получается поток контролов от клавиатуры, мышки или геймпада, а в ответ отправляется видеопоток. Это позволяет играть в современные топовые игры на компьютерах со слабым железом, ноутбуках с интегрированным видео или на Mac, под которые эти игры вообще не выпускают.
Игры надо хранить и обновлять
-----------------------------
Основные данные для облачного игрового сервиса — это дистрибутивы игр, которые могут переваливать за сотню Гбайт, и пользовательские сохранения.
Когда мы были маленькие, у нас был всего десяток серверов и скромный каталог на 50 игр. Все данные мы хранили локально на серверах, обновлялись вручную, все устраивало. Но пришло время расти и мы отправились **в облака AWS**.
С AWS у нас появилось несколько сотен серверов, но архитектура не изменилась. Это также были серверы, но теперь уже виртуальные, с локальными дисками, на которых лежали дистрибутивы игр. Однако обновляться вручную на сотне серверов уже не получится.
Мы стали искать решение. Сначала попробовали обновляться через **rsync**. Но оказалось, что это крайне медленно, а на основную ноду идет слишком большая нагрузка. Но даже не это самое страшное: когда у нас был низкий онлайн, мы отключали часть виртуалок, чтобы не платить за них, и при обновлении данные не заливались на выключенные серверы. Все они оставались без обновлений.
Решением стали торренты — программа **BTSync**. Она позволяет синхронизировать папку на большом количестве нод без явного указания центральной ноды.
Проблемы роста
--------------
Какое-то время все это замечательно работало. Но сервис развивался, игр и серверов становилось больше. Количество локальных хранилищ тоже увеличивалось, нам приходилось платить все больше. В облаках это дорого, особенно за SSD. В один момент даже обычная индексация папки для начала её синхронизации стала занимать больше часа, а все серверы могли обновляться несколько дней.
BTSync создала еще одну проблему с избыточным сетевым трафиком. На тот момент в Amazon он был платный даже между внутренними виртуалками. Если классический лаунчер игры вносит небольшие изменения в большие файлы, то BTSync сразу же считает, что весь файл изменился, и начинает полностью перекачивать его на все ноды. В результате обновление даже на 15 Мбайт могло породить десятки Гбайт трафика синхронизации.
Ситуация стала критична, когда хранилище подросло до 1 ТБайта. Как раз вышла новая игра World of Warships. В ее дистрибутиве было несколько сотен тысяч мелких файлов. BTSync никак не могла ее переварить и раздать на все остальные серверы — это тормозило раздачу остальных игр.
Все эти факторы создали две проблемы:
* плодить локальные хранилища дорого, неудобно и трудно актуализировать;
* облака оказались очень дорогими.
Мы решили вернуться обратно к концепции своих физических серверов.
Своя система хранения данных
----------------------------
Прежде чем переходить к физическим серверам, нам нужно избавиться от локальных хранилищ. Для этого требуется своя **система хранения данных — СХД**. Это система, которая хранит все дистрибутивы и централизованно раздает на все серверы.
Кажется, что задача простая — ее уже неоднократно решали. Но с играми есть нюансы. Например, большинство игр просто отказывается работать, если им дать доступ только на чтение. Даже при обычном штатном запуске они любят что-нибудь записать в свои файлы, а без этого отказываются работать. Наоборот, если большому количеству пользователей дать доступ к одному набору дистрибутивов, они начинают бить друг другу файлы при конкурентном доступе.
Мы подумали над проблемой, проверили несколько вариантов решения, и пришли к **ZFS — Zettabyte File System на FreeBSD**.
ZFS на FreeBSD
--------------
Это не совсем обычная файловая система. Классические системы изначально устанавливаются на одно устройство, а для работы с несколькими дисками уже требуют менеджер томов.
> ZFS изначально строится на виртуальных пулах.
Они называются **zpool** и состоят из групп дисков или RAID-массивов. Весь объем этих дисков доступен для любой файловой системы в рамках zpool. Все потому, что ZFS изначально разрабатывалась как система, которая будет работать с большими объемами данных.
### Как ZFS помогла решить наши проблемы
В этой системе есть замечательный **механизм создания снимков и клонов**. Они создаются **моментально**, и весят всего несколько Кбайт. Когда мы вносим изменения в один из клонов, он увеличивается на объем этих изменений. При этом данные в остальных клонах не меняются и остаются уникальными. Это позволяет раздать диск объемом **10 Тбайт** с монопольным доступом конечному пользователю, затратив всего несколько Кбайт.
Если клоны растут в процессе внесения изменений на игровой сессии, то не займут ли они столько же места, сколько все игры? Нет, мы выяснили, что даже в достаточно длинных игровых сессиях набор изменений редко превышает 100-200 Мбайт — это не критично. Поэтому, мы можем выдать полноценный доступ к полноценному жесткому диску большого объема нескольким сотням пользователей одновременно, потратив всего лишь 10 Тбайт с хвостиком.
### Как работает ZFS
Описание кажется сложным, но работает ZFS достаточно просто. Разберем его работу на простом примере — создадим `zpool data` из доступных дисков `zpool create data /dev/da /dev/db /dev/dc`.
*Примечание. На продакшн так делать не надо, потому что если хотя бы один диск умрет, весь пул уйдет в небытие вместе с ним. Лучше используйте группы RAID.*
Создаем файловую систему `zfs create data/games`, а в ней блочное устройство с названием `data/games/disk` объемом 10 Тбайт. Устройство доступно по адресу `/dev/zvol/data/games/disk` как обычный диск — с ним можно проводить те же манипуляции.
Дальше начинается самое интересное. Отдаем этот диск по **iSCSI** нашему мастеру обновлений — обычной виртуальной машине под управлением Windows. Подключаем диск, и ставим на него игры просто из Steam, как на обычном домашнем компьютере.
Заполняем диск играми. Теперь осталось раздать эти данные на **200 серверов** для конечных пользователей.
* Создадим моментальный снимок этого диска и назовем его первой версией — `zfs snapshot data/games/disk@ver1`. **Создаем его клон** `zfs clone data/games/disk@ver1 data/games/disk-vm1`, который уйдет в первую виртуальную машину.
* Отдаем клон по iSCSI и **KVM запускает виртуалку с этим диском**. Она загружается, уходит в пул доступных серверов для пользователей, и ожидает игрока.
* Когда пользовательская сессия завершена, забираем с этой виртуалки все пользовательские сохранения и **складываем их на отдельный сервер**. Саму виртуальную **машину выключаем и уничтожаем клон** — `zfs destroy data/games/disk-vm1`.
* Возвращаемся к первому шагу, снова создаем клон и запускаем виртуальную машину.
Это позволяет предоставить каждому следующему пользователю **всегда чистую машину**, на которой нет никаких изменений от предыдущего игрока. Диск после каждой пользовательской сессии удаляется, а место, которое он занимал на СХД, освобождается. Аналогичные операции мы также проводим и с системным диском, и со всеми нашими виртуалками.
Недавно на YouTube наткнулся на видео, где довольный пользователь во время игровой сессии форматировал наши жесткие диски на серверах, и очень радовался тому, что все сломал. Да пожалуйста, лишь бы платил — может играть и баловаться. В любом случае, следующий пользователь получит всегда чистую работоспособную виртуалку, что бы ни сделал предыдущий.
По этой схеме игры раздаются всего на 200 серверов. Цифру 200 мы вычислили экспериментальным путем: это то количество серверов, при котором не возникают критические нагрузки на диски СХД. Все потому, что **у игр достаточно специфический профиль нагрузки**: они много читают на этапе запуска или на этапе загрузки уровня, а в процессе игры, наоборот, практически не используют диск. Если у вас профиль нагрузки отличается, то и цифра будет другая.
В старой схеме на одновременное обслуживание 200 пользователей нам потребовалось бы 2000 Тбайт локального хранилища. Сейчас мы можем потратить чуть больше 10 Тбайт под основной набор данных, и в запасе еще есть 0,5 Тбайта под пользовательские изменения. Хотя ZFS и любит, когда у нее в пуле остается хотя бы 15% свободного места, мне кажется, что мы существенно сэкономили.
### Что если у нас несколько дата-центров?
Этот механизм будет работать только внутри одного дата-центра, где серверы с системой хранения данных соединены хотя бы 10 гигабитными интерфейсами. Что делать, если ДЦ несколько? Как обновлять основной диск с играми (датасет) между ними?
Для этого у ZFS есть свое решение — **механизм Send/Receive**. Команда на выполнение очень простая:
```
zfs send -v data/games/disk@ver1 | ssh myzfsuser@myserverip zfs receive data/games/disk
```
Механизм позволяет передать с одной СХД на другую моментальный снимок с основной системы. В первый раз придется отправить на пустую СХД все 10 Тбайт данных, которые записаны на master-ноде. Но при следующих обновлениях мы будем отправлять только изменения с момента создания предыдущего моментального снимка.
В результате получаем:
* **Все изменения вносятся централизованно на одной СХД**. Дальше они разъезжаются по всем остальным дата-центрам в любом количество, а данные на всех нодах всегда идентичны.
* **Механизму Send/Receive не страшен обрыв связи**. Данные к основному датасету не применяются до тех пор, пока они полностью не передадутся наslave-ноду. При обрыве связи повредить данные невозможно, и достаточно лишь повторить процедуру отправки.
* **Любая нода легко может стать master-нодой** во время аварии всего за несколько минут, так как данные на всех нодах всегда идентичны.
### Дедупликация и бэкапы
В ZFS есть еще одна полезная функция — **дедупликация**. Эта функция помогает **не хранить два одинаковых блока данных**. Вместо этого хранится только первый блок, а на месте второго хранится ссылка на первый. Два одинаковых файла будут занимать место как один, а при совпадении на 90%, будут заполнять 110% от изначального объема.
Функция нам очень помогла в хранении пользовательских сохранений. В одной игре у разных пользователей сохранения похожи, многие файлы совпадают. За счет применения дедупликации мы можем хранить в пять раз больше данных. Наш коэффициент дедупликации 5,22. Физически у нас занято 4,43 Тбайта, умножаем на коэффициент, и получаем, что практически 23 Тбайта реальных данных. Это хорошо экономит место, позволяя не хранить дубли.
| | | | | |
| --- | --- | --- | --- | --- |
| NAME | SIZE | ALLOC | FREE | DEDUP |
| data | 7,16 Tбайт | 4,43 Tбайт | 2,73 Tбайт | 5.22x |
**Моментальные снимки хорошо подходят для бэкапа**. Мы используем эту технологию на наших файловых хранилищах. Например, если каждый день в течение месяца сохранять по одному снимку, можно в любой момент развернуть клон на любой день этого месяца и вытащить потерянные или поврежденные файлы. Это позволяет не откатывать все хранилище или разворачивать его полную копию.
**Мы используем клоны для помощи нашим разработчикам**. Например, они хотят испытать потенциально опасную миграцию на боевой базе. Разворачивать классический бэкап базы, которая подбирается к 1 Тбайту, не быстро. Поэтому мы просто снимаем клон с диска базы и добавляем его мгновенно в новый инстанс. Теперь разработчики могут совершенно спокойно там все протестировать.
### ZFS API
Конечно, все это надо автоматизировать. Зачем лезть на серверы, работать руками, писать скрипты, если это можно отдать программистам? Поэтому мы написали свое простенькое [Web API](https://github.com/drook/zfsapi).
В него мы завернули все стандартные функции ZFS, отрезали доступ к тем, которые потенциально опасны и могут сломать всю СХД, и отдали все это программистам. Теперь **все операции с дисками строго централизованы** и выполняются кодом, а мы **всегда знаем статус каждого диска**. Все работает замечательно.
ZoL — ZFS on Linux
------------------
Мы централизовали систему и задумались, а так ли это хорошо? Ведь теперь для любого расширения нам сразу же надо покупать несколько стоек серверов: они завязаны на СХД, и дробить систему нерационально. Что делать, когда мы решим развернуть небольшой демо-стенд, чтобы показать технологию партнерам в других странах?
Подумав, мы пришли к старой идее — **использовать локальные диски**, но только уже со всем опытом и знаниями, которые получили. Если развернуть идею глобальнее, то почему бы не дать нашим пользователям возможность не только пользоваться нашими серверами, но и сдавать в аренду свои компьютеры?
В этом нам сильно помог относительно свежий форк **ZFS on Linux — ZoL**.
> Теперь каждый сервер сам себе СХД.
Только он хранит не по 10 Тбайт данных, как в случае централизованной инсталляции, а лишь 1-2 дистрибутива тех игр, которые обслуживает. Для этого достаточно одного SSD-диска. Все это прекрасно работает: каждый следующий пользователь получает всегда чистую виртуалку, как и на боевой инсталляции.
Однако тут мы столкнулись с двумя проблемами.
### Как обновлять?
**Обновлять централизованно по SSH, как мы делаем в дата-центрах не получится**. Пользователи могут быть подключены к локальной сети или просто выключены, в отличие от СХД, да и поднимать столько SSH-соединений со своей стороны не хочется.
Мы столкнулись с теми же проблемами, что и при использовании rsync. Однако торренты поверх ZFS уже не получить. Мы внимательно подумали, как работает механизм Send: он отправляет все изменившиеся блоки данных на конечную СХД, где Receive применяет их к текущему датасету. Почему бы не записать данные в файл, вместо того, чтобы отправлять их до конечного пользователя?
В результате получилось то, что мы называем **diff**. Это файл, в который последовательно записаны все измененные блоки между двумя последними моментальными снимками. Мы выкладываем этот diff на CDN, и по HTTP отдаем всем нашим пользователям: он включил машину, увидел, что есть обновления, выкачал и применил к локальному датасету, используя Receive.
### Что делать с драйверами?
У централизованных серверов конфигурация одинакова, а **у конечных пользователей всегда разные компьютеры и видеокарты**. Даже если мы максимально заполним дистрибутив ОС всеми возможными драйверами, при первом запуске она все равно захочет поставить эти драйвера, потом обязательно перезагрузится, а потом, возможно, еще раз. Так как мы каждый раз предоставляем чистый клон, то вся эта карусель будет происходить после каждой пользовательской сессии — это плохо.
Мы хотели провести какой-то инициализационный запуск: дождаться, пока Windows загрузится, установит все драйвера, выполнит все, что ей хочется, и уже потом оперировать с этим диском. Но проблема в том, что если внести изменения в основной датасет, сломаются обновления, так как данные на источнике и на приемнике будут различаться, и diff просто не применится.
Однако ZFS гибкая система и позволила нам сделать небольшой костыль.
* Как обычно создаем моментальный снимок: `zfs snapshot data/games/os@init`.
* Создаем его клон — `zfs clone data/games/os@init data/games/os-init` — и запускаем в режиме инициализации.
* Ждем пока установятся все драйвера и все перезагрузится.
* Выключаем виртуальную машину и снова создаем снимок. Но на этот раз уже не с изначального датасета, а с инициализационного клона: `zfs snapshot data/games/os-init@ver1`.
* Создаем клон снимка уже со всеми установленными драйверами. Он больше не будет перезагружаться: `zfs clone data/games/os-init@ver1 data/games/os-vm1`.
* Дальше работаем по классической связке.
Сейчас эта система находится на этапе альфа-тестирования. Мы проверяем ее на реальных пользователях без знаний Linux, но у них получается все это развернуть у себя. Наша конечная цель — чтобы любой пользователь мог просто воткнуть загрузочную флешку в свой компьютер, подключить дополнительный SSD-диск и сдать его в аренду на нашей облачной платформе.
Мы обсудили только малую часть функциональности ZFS. Эта система умеет гораздо больше интересного и разного, но о ZFS мало кто знает — пользователи не стремятся рассказывать о ней. Надеюсь, что после этой статьи в ZFS-community появятся новые пользователи.
> Подпишитесь на [телеграм-канал](https://t.me/DevOpsConfChannel) или [рассылку](http://eepurl.com/bN_0E1), чтобы узнавать о новых статьях и видео с конференции [DevOpsConf](https://devopsconf.io/). В рассылке кроме того собираем новости готовящихся конференций и рассказываем, например, что интересного для DevOps-фанатов будет на [Saint HighLoad++](https://www.highload.ru/spb/2020). | https://habr.com/ru/post/480622/ | null | ru | null |
# Как загрузить последний Office с сайта Microsoft без всякого App-V
На прошлой неделе я написал заметку [«Как загрузить виртуальный корпоративный Office 2013 с сайта Microsoft»](http://habrahabr.ru/post/245295/), где описал, как при помощи [Office Deployment Tool](http://www.microsoft.com/en-us/download/details.aspx?id=36778) загрузить последнюю корпоративную версию Office 2013 и сконвертировать её в формат виртуального пакета APP-V 5.0. Очевидно, что виртуализация приложений интересна для массового развертывания, для сценариев ферм терминального доступа, и для энтузиастов, часто обновляющих ОС на домашнем ПК, — например, устанавливая регулярные сборки Windows 10 по программе Windows Insider, и не желающих переустанавливать вручную все приложения. Для более простого пользователя существует совсем тривиальный сценарий установки Microsoft Office всё тем же Deployment Tool в режиме Click2Run. Отличий от способа, описанного в прошлой заметке два. Во-первых, не нужна конвертация пакета в формат APP-V, (соответственно, не нужен сам APP-V и махинации в PowerShell) – прямо после загрузки пакета мы его одной командой приготовим к Click2Run использованию. Второе отличие будет более печальным – для режима работы Click2Run доступны лишь Retail версии Office 2013, — следовательно, продукт потребуется активировать вручную. Рассмотрим процесс по шагам.
Для начала всё так же загружаем [Office Deployment Tool](http://www.microsoft.com/en-us/download/details.aspx?id=36778) и распаковываем его. Равно как и в случае с корпоративными версиями, где я хотел вдобавок к Office Professional Plus иметь Visio Pro и Project Pro, а также возможность работы с русским и английским интерфейсом продукта, я попробую получить полный список продуктов в Retail изданиях. Увы, Office Professional Plus доступен лишь для корпоративных (Volume) заказчиков и подписчиков Office 365, загрузить Retail версию Click2Run невозможно, — её просто не существует. Однако, доступна версия Office Professional, которая отличается отсутствием Lync и InfoPath. Для примера я загружу Lync и InfoPath отдельно в Retail исполнении, добавив их в файл конфигурации. Туда же я добавлю и SharePoint Designer, который доступен лишь в Retail издании для Click2Run загрузки. Я буду также исходить из рекомендации Microsoft использовать в десктоп конфигурациях 32-бит версию офисных продуктов. Основное отличие файла *configuration.xml* от предыдущего будет в идентификаторах продукта ***Product ID***, отвечающих за выбор издания. Помним, что корпоративные версии предназначены для использования с APP-V, и лишь Retail версии можно использовать без него в режиме Click2Run. В вашем примере можно удалить ненужные продукты, оставить один язык, или сменить разрядность офисных продуктов с 32 на 64 редактированием примера файла ниже.
```
```
Сохранив файл *configuration.xml*, я запускаю процесс загрузки пакета, выполнив команду:
```
setup.exe /download configuration.xml
```
Обращу внимание, что неделю назад, когда я загружал этой же командой корпоративную версию Office 2013, я получил сборку *15.0.4667.1002* из [November 2014 Office Update Release](http://blogs.technet.com/b/office_sustained_engineering/archive/2014/11/11/october-2014-office-update.aspx), а сегодня уже загружается *15.0.4675.1002* из декабрьского обновления (на момент написания заметки еще нет ссылок). Естественно, если сегодня пошагово выполнить шаги по загрузке корпоративной версии, которые я описал в заметке “[Как загрузить виртуальный корпоративный Office 2013 с сайта Microsoft](http://habrahabr.ru/post/245295/)”, Вы также получите обновлённую сборку.
Так как мы загрузили Retail версию пакета, то Office Deployment Tool поможет нам установить Click2Run для использования без дальнейших действий, просто выполнив команду:
```
setup.exe /configure configuration.xml
```
Процесс выполняется несколько минут, показывая нам прогресс исполнения:
Заметим, что английский язык надписи у меня возникает из-за английского же языка интерфейса моей Windows 10. Сами программы уже доступны, хотя мастер еще выполняется.
В меню я уже могу их выбирать и запускать:
Так как версия Retail, требуется активация либо введением серийного номера, либо указанием учетной записи с подпиской Office365, иначе продукт перейдёт в ограниченный режим работы.
Вводите свой серийный номер и активируйте продукт. Тем, у кого ключей меньше чем компьютеров помнят рекомендацию об отключении сети и активации офиса по телефону.
Так как я в конфигурационном файле указывал два языка и большое количество приложений, то и список установленного ПО у меня внушителен, — вы сможете его уменьшить, редактируя configuration.xml перед загрузкой и установкой.
Думаю, что данный способ установки Office удобен в первую очередь тем, кто хочет получить сразу последнюю версию продукта, без установки десятков обновлений после, а также установить разом массу продуктов на требуемых языках без поиска и загрузки отдельных дистрибутивов. Более подробно об установке Office 2013 средствами Deployment Tool я расскажу на вебкасте посвященном виртуализации Office и новинкам Microsoft Application Virtualization 5.0 SP3. Заинтересованным предлагаю зарегистрироваться для участия по [ссылке](http://stars-s.ru/default.asp?tmpl=news&d_no=238633), там буду готов оперативно ответить на вопросы по этой теме. | https://habr.com/ru/post/245677/ | null | ru | null |
# Остекляем Opera 10.50 в Windows Vista/7
Одним из главных новшеств Opera 10.50 под Windows стала полная поддержка эффектов Aero, в том числе и стеклянного интерфейса Aero Glass. Однако, распространилось это далеко не на все элементы браузера. Дизайнеры Opera сумели хорошо выдержать баланс между стеклом и классической графикой, но ведь есть и те, кому хочется, чтобы интерфейс его любимой программы был полностью стеклянным ;)
[](http://dl.dropbox.com/u/836287/Epic/OperaGlass/Z1Glass.png)
Встречайте: Z1-Glass за авторством [Z1-AV69](http://my.opera.com/Z1-AV69/blog/).
##### Собственно скин Z1-Glass, который остекляет все панели инструментов.
[my.opera.com/community/customize/skins/info/?id=9281](http://my.opera.com/community/customize/skins/info/?id=9281)
**Установка:**
Устанавливается автоматически при скачивании, после установки можно переключаться между ним и другими скинами в настройках браузера.
##### Скин может быть использован с несколькими вариантами адресной панели.
[my.opera.com/Z1-AV69/blog/2010/02/11/3-different-addressfield-options-in-z1-glass-1-52](http://my.opera.com/Z1-AV69/blog/2010/02/11/3-different-addressfield-options-in-z1-glass-1-52)
**Установка:**
1. Найти архив со скином Z1-Glass (стандартное расположение: *%appdata%\Opera\Opera\skin\*) и извлечь из него файл skin.ini, который придётся немного подредактировать;
2. Начиная с 20 строки находится инструкция на английском языке. Если всё понятно из неё — выполняем и переходим сразу к пункту 4. Если нет — читаем дальше;
3. Начиная с 35 строки находится секция *[Dropdown Addressfield Skin]*. Она содержит 3 различных строки, определяющих фоновое изображение панели. Для выбора какого-либо варианта соответственно 2 строки должны быть закомментированы, а одна (нужная) оставлена.
Варианты:
* Стандартный:
> `Tile Center = border/addressfield.png
>
> #Tile Center= border/addressfield_alternate.png
>
> #Tile Center= border/addressfield_classic.png`
* Комбинированный:
> `#Tile Center = border/addressfield.png
>
> Tile Center = border/addressfield_alternate.png
>
> #Tile Center= border/addressfield_classic.png`
Для комбинированного варианта потребуется также альтернативная конфигурация адресной панели. Готовую панель можно [скачать](http://files.myopera.com/Z1-AV69/files/Glass/options/combined_addressfield_toolbar.ini), после чего сохранить в *%appdata%\Opera\Opera\toolbar\* и включить в настройках оперы;
* Классический:
> `#Tile Center= border/addressfield.png
>
> #Tile Center= border/addressfield_alternate.png
>
> Tile Center= border/addressfield_classic.png`
4. Сохранить изменения в skin.ini и запаковать его обратно в архив;
5. Перезапустить браузер.
~~##### Помимо этого существует возможность остеклить и быстрый набор aka Speed Dial.
[my.opera.com/Z1-AV69/blog/2010/02/04/transparent-background-when-viewing-pictures-with-z1-glass](http://my.opera.com/Z1-AV69/blog/2010/02/04/transparent-background-when-viewing-pictures-with-z1-glass)
**Установка:**
1. [Скачать файл стиля](http://files.myopera.com/Z1-AV69/files/setups/image.css);
2. В *opera:config#Image%20Style* указать новый файл вместо стандартного;
3. В настройках быстрого набора отключить использование фонового изображения;
4. Перезапустить браузер.~~
Хабраюзер [alergi](https://habrahabr.ru/users/alergi/) подсказывает, что никаких специальных действий (помимо установки скина) для остекления Speed Dial не требуется.
То, что в прошлый раз оно у меня не заработало — спишем, пожалуй, на кривизну рук ;)
Модифицированный же image.css предназначен для несколько других целей.
На итоговый вид браузера можно посмотреть в шапке топика (картинка кликабельна), либо на скриншотах в [блоге автора](http://my.opera.com/Z1-AV69/blog/). А ещё лучше всё-таки попробовать самому ;)
[](http://twitter.com/lordveider) | https://habr.com/ru/post/85213/ | null | ru | null |
# Синхронные и асинхронные стектрейсы: опыт использования в Facebook
Здесь мы подробно поговорим о том, каковы технические отличия между реализацией асинхронных стектрейсов по сравнению с реализацией традиционных стектрейсов, а также с какими сложностями можно столкнуться, реализуя такие асинхронные стектрейсы поверх корутин C++.
Обычные синхронные стектрейсы
-----------------------------
При работе с обычными стеками, когда вы вызываете функцию, компилятор генерирует специальный код, и этот код автоматически поддерживает связный список кадров стека, а сам этот список является представлением стека вызовов. В начале каждого кадра находится структура, которая (как минимум, в архитектурах Intel) выглядит примерно так:
```
struct stack_frame {
stack_frame* nextFrame;
void* returnAddress;
};
```
Обычно такая структура заполняется специализированными ассемблерными инструкциями. Например, в x86\_64 вызывающая сторона выполняет инструкцию *call*, которая забрасывает возвращаемый адрес в стек, а затем перепрыгивает к входной точке функции. Затем первая инструкция вызываемой стороны забрасывает в стек регистр *ebp* (который обычно содержит указатель на актуальную структуру *stack\_frame*), а после этого копирует регистр *esp* (тот, что содержит указатель на структуру *stack\_frame*, которую мы только что заполнили) в регистр *ebp*.
Например:
```
caller:
...
call callee # Забрасывает в стек адрес следующей инструкции,
# заполняя член 'returnAddress' структуры 'stack_frame'.
# Затем перепрыгивает к адресу 'callee'.
mov rsp[-16], rax # Где-нибудь сохраняем результат
...
callee:
push rbp # Забрасывает rbp (указатель на stack_frame) в стек (заполняет член 'nextFrame')
mov rbp, rsp # Обновляет rbp, чтобы он указывал на новый stack_frame
sub rsp, 16 # Резервирует дополнительные 16 байт в пространстве стека
...
mov rax, 42 # Устанавливает возвращаемое значение в 42
leave # Копирует rbp -> rsp, выталкивает rbp из стека
ret # Выталкивает возвращаемый адрес с вершины стека и перепрыгивает к нему
```
Когда отладчик или профилировщик захватывает стектрейс для заданного потока, он получает указатель на первый кадр стека из регистра *ebp*, относящегося к этому потоку, а затем начинает обход этого связного списка, пока не достигнет корня стека. Все возвращаемые адреса, встречаемые по пути, он при этом записывает в буфер.
Другие инструменты профилирования, которые затем вступают в дело, могут транслировать адреса в имена функций и/или номера файл+строка при помощи символизатора, использующего отладочную информацию о бинарном файле. Эта информация может логироваться или выводиться на экран, в зависимости от того, как будет полезнее при работе с конкретным инструментом.
Как правило, эти кадры стека находятся в единой непрерывной области памяти, а структура данных выглядит примерно так:
Если бы мы хотели обойти асинхронный, а не нормальный стектрейс, то все равно начали бы путь с обычных кадров стека, как и в нормальном стектрейсе. Корутина может вызывать нормальные функции, и нам требуется включить кадры с этими нормальными функциями в стектрейс. Правда, как только мы дойдем до кадра, соответствующего самой верхней корутине (в данном случае *coro\_function\_1*) мы не собираемся переходить по ссылке '*nextFrame*' к методу *coroutine\_handle::resume*, как это бы произошло при обходе нормального стека. Вместо этого нам нужна ссылка на ожидающую корутину. В этот момент истории нормального и асинхронного стектрейсов расходятся. Проход по асинхронному стектрейсу требует ответить на несколько вопросов:
* Как определить, какие из кадров стека соответствуют асинхронным кадрам?
* Как найти адрес следующего асинхронного кадра?
* Как и где нам выделять пространство для хранения данных, относящихся к асинхронным кадрам?
Прежде, чем реализовать что-либо из этого, мы должны подробнее разобраться в том, как структурируются корутины.
В чем «стеки» корутин отличаются от нормальных стеков?
------------------------------------------------------
Когда вы вызываете корутину на C++, программа выделяет хранилище для кадра корутины. Как правило, пространство для этой цели мы получаем из кучи, но в некоторых случаях компилятор вправе и ничего не брать из кучи, обойдясь оптимизациями – например, встраивая операцию выделения в кадр вызывающей стороны.
Компилятор использует хранилище кадров корутин для хранения всего того состояния, которое должно остаться в неприкосновенности на тот период, пока работа корутины приостановлена – и быть доступна к моменту, когда работа корутины возобновится. Обычно в данном случае предусматривается хранилище для параметров функций, локальных переменных, временных файлов и всего прочего состояния, которое компилятор сочтет необходимым сохранить – например, в какой момент времени была приостановлена работа корутины.
Также кадр корутины включает место для хранения специального объекта, *промиса корутины*, который управляет ее поведением. Компилятор понижает вашу корутину до последовательности вызовов к методам в определенных ключевых точках объекта промиса корутины. Кроме того, в теле корутины содержится некоторый дополнительный код, написанный программистом. Промис корутины управляет поведением корутины, реализуя желаемое поведение в этих методах. Подробнее о том, как как устроен тип промиса, рассказано в статье [Understanding the promise type](https://lewissbaker.github.io/2018/09/05/understanding-the-promise-type?fbclid=IwAR0cFspq3Aqy2j_QiIWqsMYfGu0RrOgiTJV4vS2weXKMUVg35pIvkSDCkOs).
Тип промиса определяется в зависимости от сигнатуры функции корутины, и в большинстве случаев тип корутины зависит исключительно от ее возвращаемого типа. Благодаря этому корутины, возвращающие заданный тип (напр., *folly::coro::Task*) могут хранить на каждый кадр корутины дополнительную информацию: для этого члены данных добавляются к типу промиса.
При clang-подобной реализации компоновка кадра корутины для заданной функции корутины выглядит примерно так:
```
struct __foo_frame {
using promise_type = typename std::coroutine_traits::promise\_type;
void(\*resumeFn)(void\*); // coroutine\_handle::resume() function-pointer
void(\*destroyFn)(void\*); // coroutine\_handle::destroy() function-pointer
promise\_type promise; // объект промиса корутины
int suspendPoint; // отслеживает, в какой точке была приостановлена работа корутины
char extra[458]; // дополнительное пространство для хранения локальных переменных, параметров,
// временных файлов, утекших регистров, т.д.
};
```
При приостановке корутины все состояние, нужное для вызова этой корутины, сохраняется в кадре корутины, и соответствующего кадра стека для этого нет. Однако, когда корутина возобновляется в заданном потоке, в результате в стеке именно этого потока активируется кадр стека для данной корутины (как и в случае с нормальной функцией). Именно этот кадр стека используется для хранения всех временных данных, срок жизни которых не достигает точки, в которой была приостановлена работа.
Если тело корутины выполняется непосредственно в данный момент, то указатель на актуальный кадр корутины обычно содержится в регистре. Это позволяет быстро ссылаться на состояние внутри кадра корутины. Однако, в некоторых случаях этот адрес также может утекать в кадр стека, особенно, когда корутина вызывает другую функцию.
Следовательно, когда корутина активна и вызвала другую функцию, компоновка памяти будет выглядеть примерно так:
В особенности отметим, что обход асинхронной версии стека приводит к тому, что нам приходится отклониться в память кучи, последовав по *framePointer* в *coro\_function\_1*. В отличие от указателя на актуальный кадр стека, который, как обычно предполагается, должен храниться в регистре rbp, не предусмотрено стандартного местоположения для указателя, который направлен на кадр корутины. Это по-своему сказывается на навигации от кадра стека к данным соответствующего асинхронного кадра.
Сцепление асинхронных кадров стека
----------------------------------
Чтобы иметь возможность составить стектрейс, который представлял бы цепочку асинхронных вызовов, а не цепочку нормальных синхронных вызовов, мы должны быть в состоянии обойти цепочку кадров корутины, записывая возвращаемый адрес/адрес продолжения каждой корутины по пути.
Первый элемент загадки, разгадываемой в данном случае – это сохранение состояния, которое понадобится нам для обхода асинхронных кадров стека по асинхронному стектрейсу. Для каждого асинхронного кадра стека нам потребуется определить адрес следующего такого кадра, а также возвращаемый адрес актуального кадра стека.
Одно из ограничений, которое здесь нужно учитывать – в том, что код, который будет обходить стектрейс, не обязательно будет иметь доступ к отладочной информации по программе. Например, инструментам профилирования может потребоваться выбрать только смещения функций, а символизировать их позже, как это делается для синхронных стектрейсов. Мы должны иметь возможность обходить асинхронный стек, не прибегая к дополнительным сложным структурам данных, поскольку из-за таких структур обход стека может получиться излишне затратным. Например, профилировочные инструменты, построенные на основе [Linux eBPF](https://www.piter.com/collection/all/product/bpf-dlya-monitoringa-linux), должны иметь возможность выполняться за определенный конечный отрезок времени.
Технически, содержится достаточно информации в типе *folly::coro::TaskPromise*, относящемся к задаче *folly::coro::Task*, ее достаточно, чтобы перейти к следующему кадру, поскольку в этом типе уже хранится *coroutine\_handle* для продолжения, а кадр корутины для этого продолжения уже кодирует информацию о том, какая точка приостановки работы какой корутины записаны в членах *resumeFn* и *suspendPoint*. Однако, мы сталкиваемся с определенными проблемами, если попытаемся использовать эту информацию напрямую при обходе асинхронного стектрейса.
Представление цепочки асинхронных кадров стека
----------------------------------------------
Если у нас есть указатель на кадр корутины, сохраненный в *coroutine\_handle*, то, теоретически, зная, какова компоновка объекта промиса, мы можем вычислить адрес члена '*продолжение*' в составе промиса, где содержится адрес следующего кадра корутины – для этого просто прибавим постоянное значение смещения к указателю на кадр корутины.
Один из подходов, который нам может потребоваться – такой, чтобы промисы всех типов хранили *coroutine\_handle* с продолжением в качестве первого члена данных:
```
template
struct TaskPromise {
std::coroutine\_handle continuation;
Try result;
...
};
struct \_\_some\_coroutine\_frame {
void(\*resumeFn)(void\*);
void(\*destroyFn)(void\*);
TaskPromise promise;
int suspendPoint;
};
```
Затем, даже если конкретный тип промиса нам не известен, мы все равно будем знать, что его первый член данных – это *coroutine\_handle*, и что промис ставится сразу же после двух указателей функций. С точки зрения отладчика, обходящего асинхронный стектрейс, можно предположить, что кадры корутин выглядят так:
```
struct coroutine_frame {
void(*resumeFn)(void*);
void(*destroyFn)(void*);
coroutine_frame* nextFrame;
};
```
К сожалению, этот подход сбоит, когда тип промиса чрезмерно выровнен (overaligned) (то есть, его выравнивание превышает 2 указателя: 32 байт или более на 64-разрядных платформах). Такое может произойти, если тип *folly::coro::Task* инстанцирован для чрезмерно выровненного типа, например, *T*, тогда матричный тип оптимизируется для использования с инструкциями SIMD.
В таких случаях компилятор вставляет заполнение между указателями функции и объектом промиса в структуре, так, чтобы добиться правильного выравнивания промиса. Из-за такой вариативности в компоновке становится гораздо сложнее определить, какое именно смещение позволит найти адрес следующего кадра корутины, поскольку это значение зависит от типа. Отладчику необходима информация о том, какова компоновка типа промиса, чтобы иметь возможность вычислить смещение.
Теоретически, можно было бы посмотреть значения указателей *resumeFn/destroyFn*, чтобы выяснить тип промиса, соответствующий телу корутины в таблице трансляции. Но это либо потребовало бы либо обращаться к отладочной информации, либо модифицировать компилятор, так, чтобы он кодировал эту информацию в составе бинарного файла. Невозможно рассчитывать, что отладочная информация всегда будет доступна, а модификация компилятора – это гораздо более крупный проект. Возможны и другие подходы, например, изменить интерфейс ABI кадров корутин, чтобы заполнение не делалось, но для этого также потребуется вносить изменения в компилятор, и получившаяся реализация будет зависеть от компилятора.
Вместо этого мы решили вставлять новую структуру данных `*folly::AsyncStackFrame*` в качестве одного из членов промиса корутины, создавая таким образом интрузивный связный список асинхронных кадров. Таким образом, структура приобретает следующий вид:
```
namespace folly {
struct AsyncStackFrame {
AsyncStackFrame* parentFrame;
// другие члены...
};
}
```
И этот код можно добавить в качестве члена к объектам промисов, связанным с корутинами:
```
namespace folly::coro {
class TaskPromiseBase {
...
private:
std::coroutine_handle<> continuation_;
AsyncStackFrame asyncFrame_;
...
};
```
Всякий раз, запуская дочернюю корутину при помощи *co\_awaiting*, мы можем перехватить *AsyncStackFrame* этой дочерней корутины так, чтобы член *parentFrame* указывал на объект *AsyncStackFrame* родительской корутины.
При использовании отдельной структуры данных мы приобретаем значительную гибкость в том, как нам удается представлять асинхронные стектрейсы. Такой подход изолирует структуры данных от любых зависимостей, которые могут быть связаны с внутренним устройством компилятора, а в будущем также позволяет нам многократно использовать объекты *AsyncStackFrame* в асинхронных операциях, не связанных с корутинами. Это обходится нам сравнительно небольшими издержками, касающимися памяти и времени выполнения, поскольку теперь нам фактически приходится хранить и поддерживать два указателя на родительскую корутину. В будущем это решение может быть пересмотрено, если нам понадобится выжать из программы дополнительную производительность – для этого нам потребуется внести в компилятор изменения, которые упоминались ранее.
Итак, мы нашли способ, позволяющий представить цепочку асинхронных кадров. В таком виде отладчик может обходить данную цепочку, и ему не требуется ничего знать о типе конкретного промиса. | https://habr.com/ru/post/649725/ | null | ru | null |
# Средние highload паттерны на Go
Привет, Хабр! Меня зовут Агаджанян Давид и ранее я опубликовал статью [«простые highload паттерны на Go»](https://habr.com/ru/post/682618/), в которой были рассмотрены простые подходы увеличения пропускной способности отдельно взятого экземпляра приложения без хардкора. Мне импонируют простые подходы, так как **over engineering** подходы требуются в исключительных проектах, и то чаще всего только в отдельно взятых подсистемах, в остальном можно воспользоваться давно известными **лучшими практиками**. Статья ориентирована на начинающих разработчиков и может служить отправной точкой для дальнейшего изучения. В этой статье подходы ориентированы на масштабирование приложения при верхнеуровневом рассмотрении. Подходы универсальны, приписка языка **Go** только потому, что сама реализация приложения на нем. Для наглядности, примеры будут упрощены, а чтобы было интереснее наблюдать, проведем замеры производительности. Ну и конечно же делитесь своим опытом масштабирования, буду рад взять на заметку.
> Правильный замер производительности как отдельная наука, необходимо создать правильную среду и снизить погрешности до минимума, в этой статье будут использованы стандартные инструменты и в качестве выходных значений будут использоваться усредненные с десятков запусков
>
>
Stateless horizontal scaling
----------------------------
one instanceЕсть приложение, которое крутится в бою и вполне себе успешно выполняет свою работу. Постепенно трафик растет, пользователи становятся ненасытнее и все активнее пользуются приложением. И вот настигает пик, при котором **CPU/RAM** физически уже не хватает и требуется принять меры. Решение простое и очень эффективное - создать реплики приложения
**Пример**: есть приложение, которое в реальном времени производит сложные **CPU** расчеты. Трафик приложения растет, **CPU** железки подходит к пределу, а само приложение и так уже оптимизировано насколько хватило компетенций команды разработки. Расти и покупать более дорогостоящее оборудование уже не целесообразно
**Концепт**: поставить несколько обычных железок и реплицировать на них приложение, поставив перед ними **load balancer**
multiple instances with load balancer**Реализация**: примеры кода ниже, но они также доступны в [github](https://github.com/agadzhanyan/highload-patterns/tree/main/scale-stateless)
Попробуем провести замеры производительности одного сервиса и затем нескольких сервисов с балансировщиком нагрузки перед ними
Для простоты имитации ограничения железки и наглядности воспользуемся инструментом [docker](https://www.docker.com/) и [docker-compose](https://docs.docker.com/compose/)
Возможность ограничения по **CPU** в **docker-compose** была добавлена в версии ["2.2"](https://docs.docker.com/compose/compose-file/compose-file-v2/#cpu-and-other-resources). Подробнее про ограничения по ресурсам можно найти в [этой](https://docs.docker.com/compose/compose-file/compose-file-v3/#resources) документации
Смотрим пример
```
version: "3.9"
services:
redis:
image: redis:alpine
deploy:
resources:
limits:
cpus: '0.50' <- то, что нам нужно
memory: 50M
reservations:
cpus: '0.25'
memory: 20M
```
> In this general example, the `redis` service is constrained to use no more than 50M of memory and `0.50` (50% of a single core) of available processing time (CPU), and has `20M` of memory and `0.25` CPU time reserved (as always available to it).
>
>
Документация говорит, что **0.5** означает, что контейнер получит не более **50%** доступного процессорного времени одного ядра. Для наглядности ограничим наше приложение **20%**
Так как приложение на **Go**, необходим **Dockerfile**, с помощью которого оно будет заворачиваться в контейнер
```
# возьмем один из самых свежих образов Go
FROM golang:1.19.0-alpine3.16
# alpine образ беден на стандартные инструменты, добавим их отдельной командой
RUN apk update && apk upgrade && \
apk add --no-cache bash git openssh
# задаем директорию приложения в контейнере
WORKDIR /app
# скачиваем в контейнер зависимости приложения
COPY go.mod ./
RUN go mod download
# копируем файлы текущей директории в контейнер
COPY . .
# билдим приложение
RUN go build -o main .
# так как приложение читает 8890 порт, откроем его внешнему миру
EXPOSE 8890
# команда запуска приложения в контейнере
CMD ["./main"]
```
Приложение, которое выполняет CPU работу
```
package main
import (
"encoding/json"
"math/rand"
"net/http"
)
func main() {
http.HandleFunc("/handle", func(writer http.ResponseWriter, request *http.Request) {
// cpu intensive work
for i := 0; i <= 1000; i++ {
_, _ = json.Marshal(randSeq(10))
}
writer.Header().Add("Content-Type", "application/json")
writer.Write([]byte("done!"))
})
_ = http.ListenAndServe(":8890", nil)
}
var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
// random string generator
func randSeq(n int) string {
b := make([]rune, n)
for i := range b {
b[i] = letters[rand.Intn(len(letters))]
}
return string(b)
}
```
Теперь сформируем docker-compose
```
version: '3.9'
services:
app:
build:
context: ../
dockerfile: Dockerfile
ports:
- "8870:8890"
restart: unless-stopped
networks:
- backend
deploy:
resources:
limits:
cpus: '0.2'
memory: 500M
networks:
backend:
```
Так как **docker-compose.yml** находится по пути **./one-instance/docker-compose.yml**, а **Dockerfile** на уровень выше, то необходимо задать контекст **../**
Запустим приложение командой
```
docker-compose up --build --force-recreate
```
В консоли будет примерно следующий лог
```
davidagadzhanyan@MacBook-Pro one-instance % docker-compose up --build --force-recreate
WARNING: Found orphan containers (one-instance_app1_1) for this project. If you removed or renamed this service in your compose file, you can run this command with the --remove-orphans flag to clean it up.
Building app
[+] Building 2.6s (12/12) FINISHED
=> [internal] load build definition from Dockerfile 0.0s
=> => transferring dockerfile: 37B 0.0s
=> [internal] load .dockerignore 0.0s
=> => transferring context: 2B 0.0s
=> [internal] load metadata for docker.io/library/golang:1.19.0-alpine3.16 1.5s
=> [1/7] FROM docker.io/library/golang:1.19.0-alpine3.16@sha256:0eb08c89ab1b0c638a9fe2780f7ae3ab18f6ecda2c76b908e09eb8073912045d 0.0s
=> [internal] load build context 0.0s
=> => transferring context: 1.38kB 0.0s
=> CACHED [2/7] RUN apk update && apk upgrade && apk add --no-cache bash git openssh 0.0s
=> CACHED [3/7] WORKDIR /app 0.0s
=> CACHED [4/7] COPY go.mod ./ 0.0s
=> CACHED [5/7] RUN go mod download 0.0s
=> [6/7] COPY . . 0.0s
=> [7/7] RUN go build -o main . 0.8s
=> exporting to image 0.1s
=> => exporting layers 0.1s
=> => writing image sha256:0166bc8bb315e491a69964bc68ff7a125dc0a8dd9c5865c3970fb2bc428a5ba0 0.0s
=> => naming to docker.io/library/one-instance_app 0.0s
Use 'docker scan' to run Snyk tests against images to find vulnerabilities and learn how to fix them
Recreating one-instance_app_1 ... done
Attaching to one-instance_app_1
```
Нас интересуют две последние строчки, которые говорят о том, что приложение успешно запущено.
Теперь проведем нагрузочное тестирование с помощью утилиты [wrk](https://github.com/wg/wrk).Для чистоты проведем его в среде докера. Находим образ с этой утилитой в [хабе](https://hub.docker.com/r/skandyla/wrk).
Для того чтобы запущенный контейнер **wrk** смог достучаться до приложения, при запуске присоединим его к сети **backend.**
Докер имеет свои правила формирования названия сети. Найти точное название сети можно выполнив команду.
```
docker network ls
```
Результатом команды будет список созданных докером сетей.
```
NETWORK ID NAME DRIVER SCOPE
657a365c5cdd one-instance_backend bridge local
```
Видно название сети **one-instance\_backend**
Отлично, теперь проведем нагрузочное тестирование при одном потоке и одном соединении повторим при трех.
```
docker run --network=one-instance_backend \
--rm skandyla/wrk -t1 -c1 -d5s http://app:8890/handle
docker run --network=one-instance_backend \
--rm skandyla/wrk -t3 -c3 -d5s http://app:8890/handle
```
Видим следующие результаты
```
Running 5s test @ http://app:8890/handle
1 threads and 1 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 22.55ms 28.32ms 91.44ms 78.73%
Req/Sec 169.56 47.70 410.00 78.00%
854 requests in 5.05s, 93.41KB read
Requests/sec: 169.08
Transfer/sec: 18.49KB
Running 5s test @ http://app:8890/handle
3 threads and 3 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 45.85ms 42.16ms 195.06ms 31.70%
Req/Sec 25.06 15.04 99.00 70.75%
377 requests in 5.06s, 41.23KB read
Requests/sec: 74.56
Transfer/sec: 8.16KB
```
Теперь создадим **три реплики приложения**, поставим перед ними **nginx** для балансировки нагрузки и проведем аналогичное нагрузочное тестирование.
Сформируем конфиг **nginx** и используем дефолтный способ балансировки **round robin** (поочередная отправка запросов серверам).
> Подробнее про другие способы балансировки можно почитать в [документации](https://docs.nginx.com/nginx/admin-guide/load-balancer/http-load-balancer/)
>
>
```
upstream app {
server app1:8890;
server app2:8890;
server app3:8890;
}
server {
listen 8891;
location / {
proxy_pass http://app;
}
}
```
Создадим новый docker-compose.yml
```
version: '3.9'
services:
app1:
build:
context: ..
dockerfile: Dockerfile
ports:
- "8881:8890"
restart: unless-stopped
networks:
- backend
deploy:
resources:
limits:
cpus: '0.2'
memory: 500M
app2:
build:
context: ..
dockerfile: Dockerfile
ports:
- "8882:8890"
restart: unless-stopped
networks:
- backend
deploy:
resources:
limits:
cpus: '0.2'
memory: 500M
app3:
build:
context: ..
dockerfile: Dockerfile
ports:
- "8883:8890"
restart: unless-stopped
networks:
- backend
deploy:
resources:
limits:
cpus: '0.2'
memory: 500M
ngnix-server:
image: nginx:latest
ports:
- "8891:8891"
volumes:
- /Users/davidagadzhanyan/go/src/highload-patterns/scale-stateless/multiple-with-lb/nginx.conf:/etc/nginx/conf.d/default.conf
networks:
- backend
networks:
backend:
networks:
backend:
```
> Обратите внимание, что для монтирования одного файла, необходимо указывать абсолютный путь к нему
>
>
Проведем нагрузочное тестирование еще раз командами
```
docker run --network=multiple-with-lb_backend
\ --rm skandyla/wrk -t1 -c1 -d5s http://ngnix-server:8891/handle
docker run --network=multiple-with-lb_backend
\ --rm skandyla/wrk -t3 -c3 -d5s http://ngnix-server:8891/handle
```
Видим следующий лог
```
Running 5s test @ http://ngnix-server:8891/handle
1 threads and 1 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 9.09ms 13.99ms 68.66ms 82.25%
Req/Sec 451.82 93.72 1.02k 92.00%
2251 requests in 5.00s, 347.31KB read
Requests/sec: 450.16
Transfer/sec: 69.46KB
Running 5s test @ http://ngnix-server:8891/handle
3 threads and 3 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 22.41ms 26.86ms 95.08ms 78.73%
Req/Sec 109.03 33.69 250.00 76.00%
1631 requests in 5.01s, 251.66KB read
Requests/sec: 325.80
Transfer/sec: 50.27KB
```
Соберем воедино и сравним результаты
| | | |
| --- | --- | --- |
| | **RPS** | **Latency** |
| one instance (1t, 1c) | 169 | 22.55ms |
| one instance (3t, 3c) | 74 | 45.85ms |
| three instances + lb (1t, 1c) | 450 | 9.09ms |
| three instances + lb (3t, 3c) | 325 | 22.41ms |
Как ожидалось, путем горизонтального масштабирования удалось кратно увеличить как пропускную способность **RPS**, так и уменьшить **latency.**
> Подробнее про балансировку можно почитать [system-design-primer](https://github.com/donnemartin/system-design-primer#load-balancer)
>
>
**Плюсы**
* Один из плюсов, о котором ранее не говорилось, теперь сервис становится надежнее, так как в случае падения одной из реплик, есть другие, которые будут продолжать выполнять полезную работу. Теперь сервис не является единой точкой отказа.
* Вторым плюсом является то, что поверх контейнеров можно создать механизм, который мог бы сам автоматически добавлять/удалять реплики в зависимости от текущей нагрузки. Этим и другими полезными механизмами оркестрации занимается **kubernetes** и другие его соотечественники вроде **Docker Swarm** и другие.
**Минусы**
* Подходит только для **stateless** приложений, которые не хранят состояния пользователей, то есть запрос может быть обработан любой репликой.
* Избавившись от единой точки отказа в виде одного экземпляра приложения, появляется единая точка отказа в виде балансировщика **nginx**,но никто не мешает и его отреплицировать и использовать более высокоуровневую балансировку.
Sync to async
-------------
sync processingЕсть приложение, в котором активно растет трафик и помимо основных, оно выполняет еще и вспомогательные функции, которые с ростом трафика начинают влиять на пользовательский опыт. Так почему не выполнять вспомогательные функции асинхронно?
**Пример**: есть приложение, в котором фиксируются пользовательские события кликов и любых других действий. Количество необходимых для фиксирования событий постепенно растет, как и количество пользователей. В какой-то момент эта механика начинает сказываться на времени выполнения запроса пользователя
**Концепт**: вынести фиксацию событий в асинхронный режим через отправку сообщений в шину данных и затем разгружать эту очередь отдельным сервисом
async processing**Реализация**: примеры кода ниже, но они также доступны в [github](https://github.com/agadzhanyan/highload-patterns/tree/main/sync-to-async)
Сымитируем прямой поход в сервис логов, проведем нагрузочное тестирование, затем добавим обработку через шину данных и сравним результаты
Код приложения, которое будет выполнять CPU работу и отправлять запрос в сервис логов
```
package main
import (
"bytes"
"encoding/json"
"io"
"math/rand"
"net/http"
)
func main() {
http.HandleFunc("/handle", func(writer http.ResponseWriter, request *http.Request) {
// cpu intensive work
for i := 0; i <= 1000; i++ {
_, _ = json.Marshal(randSeq(10))
}
// send log
resp, err := http.DefaultClient.Post(
"http://logs:8890/sendEvent",
"application/json",
bytes.NewReader([]byte(randSeq(100))),
)
if err != nil {
writer.Header().Add("Content-Type", "application/json")
writer.Write([]byte("failed!" + err.Error()))
return
}
body, err := io.ReadAll(resp.Body)
if err != nil {
writer.Header().Add("Content-Type", "application/json")
writer.Write([]byte("failed!" + err.Error()))
return
}
writer.Header().Add("Content-Type", "application/json")
writer.Write([]byte("done!" + string(body)))
})
_ = http.ListenAndServe(":8890", nil)
}
var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
// Random string generator
func randSeq(n int) string {
b := make([]rune, n)
for i := range b {
b[i] = letters[rand.Intn(len(letters))]
}
return string(b)
}
```
Код приложения, которое для имитации CPU работы будет конвертировать строку в json
```
package main
import (
"encoding/json"
"math/rand"
"net/http"
)
func main() {
http.HandleFunc("/sendEvent", func(writer http.ResponseWriter, request *http.Request) {
// cpu intensive work
for i := 0; i <= 1000; i++ {
_, _ = json.Marshal(randSeq(50))
}
writer.Header().Add("Content-Type", "application/json")
writer.Write([]byte("event is saved!"))
})
_ = http.ListenAndServe(":8890", nil)
}
var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
// Random string generator
func randSeq(n int) string {
b := make([]rune, n)
for i := range b {
b[i] = letters[rand.Intn(len(letters))]
}
return string(b)
}
```
Соберем docker-compose.yml
```
version: '3.9'
services:
app:
build:
context: ./app
dockerfile: ../../Dockerfile
ports:
- "8861:8890"
restart: unless-stopped
networks:
- backend
deploy:
resources:
limits:
cpus: '0.2'
memory: 500M
logs:
build:
context: ./log
dockerfile: ../../Dockerfile
ports:
- "8862:8890"
restart: unless-stopped
networks:
- backend
deploy:
resources:
limits:
cpus: '0.2'
memory: 500M
networks:
backend:
```
Запустим приложения командой
```
docker-compose up --build --force-recreate
```
Увидим примерно такой лог
```
davidagadzhanyan@MacBook-Pro sync % docker-compose up --build --force-recreate
Building app
[+] Building 2.8s (12/12) FINISHED
=> [internal] load build definition from Dockerfile 0.0s
=> => transferring dockerfile: 37B 0.0s
=> [internal] load .dockerignore 0.0s
=> => transferring context: 2B 0.0s
=> [internal] load metadata for docker.io/library/golang:1.19.0-alpine3.16 1.6s
=> [1/7] FROM docker.io/library/golang:1.19.0-alpine3.16@sha256:0eb08c89ab1b0c638a9fe2780f7ae3ab18f6ecda2c76b908e09eb8073912045d 0.0s
=> [internal] load build context 0.0s
=> => transferring context: 1.86kB 0.0s
=> CACHED [2/7] RUN apk update && apk upgrade && apk add --no-cache bash git openssh 0.0s
=> CACHED [3/7] WORKDIR /app 0.0s
=> [4/7] COPY go.mod ./ 0.0s
=> [5/7] RUN go mod download 0.2s
=> [6/7] COPY . . 0.0s
=> [7/7] RUN go build -o main . 0.7s
=> exporting to image 0.1s
=> => exporting layers 0.1s
=> => writing image sha256:fc18d50b8af7c9775b9911c32d4c230fcd78025f0f5505e7ddab8d464d77fef9 0.0s
=> => naming to docker.io/library/sync_app 0.0s
Use 'docker scan' to run Snyk tests against images to find vulnerabilities and learn how to fix them
Building logs
[+] Building 1.4s (12/12) FINISHED
=> [internal] load build definition from Dockerfile 0.0s
=> => transferring dockerfile: 37B 0.0s
=> [internal] load .dockerignore 0.0s
=> => transferring context: 2B 0.0s
=> [internal] load metadata for docker.io/library/golang:1.19.0-alpine3.16 0.3s
=> [internal] load build context 0.0s
=> => transferring context: 140B 0.0s
=> [1/7] FROM docker.io/library/golang:1.19.0-alpine3.16@sha256:0eb08c89ab1b0c638a9fe2780f7ae3ab18f6ecda2c76b908e09eb8073912045d 0.0s
=> CACHED [2/7] RUN apk update && apk upgrade && apk add --no-cache bash git openssh 0.0s
=> CACHED [3/7] WORKDIR /app 0.0s
=> [4/7] COPY go.mod ./ 0.0s
=> [5/7] RUN go mod download 0.2s
=> [6/7] COPY . . 0.0s
=> [7/7] RUN go build -o main . 0.7s
=> exporting to image 0.1s
=> => exporting layers 0.1s
=> => writing image sha256:9e13068dcf77077505181c536b68b6e182e7df7f4abff2eb52f20f6e23981d8c 0.0s
=> => naming to docker.io/library/sync_logs 0.0s
Use 'docker scan' to run Snyk tests against images to find vulnerabilities and learn how to fix them
Recreating sync_logs_1 ... done
Recreating sync_app_1 ... done
Attaching to sync_logs_1, sync_app_1
```
Запустим нагрузочное тестирование командами
```
docker run --network=sync_backend \
--rm skandyla/wrk -t1 -c1 -d5s http://app:8890/handle
docker run --network=sync_backend \
--rm skandyla/wrk -t3 -c3 -d5s http://app:8890/handle
```
И увидим результаты
```
Running 5s test @ http://app:8890/handle
1 threads and 1 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 28.20ms 29.85ms 90.45ms 77.06%
Req/Sec 56.42 13.52 117.00 66.00%
283 requests in 5.02s, 35.38KB read
Requests/sec: 56.35
Transfer/sec: 7.04KB
Running 5s test @ http://app:8890/handle
3 threads and 3 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 105.07ms 64.37ms 204.37ms 54.17%
Req/Sec 10.07 4.48 20.00 65.49%
144 requests in 5.05s, 18.00KB read
Requests/sec: 28.53
Transfer/sec: 3.57KB
```
Видим, что пропускная способность **56rps** и **28rps** при задержке **28ms** и **105ms.**
Теперь вынесем обработку сервиса логов в асинхронный режим. В качестве шины данных используем **Apache Kafka**.Основное приложение будет писать сообщения в кафку, а сервис логов будет вычитывать эти сообщения.
> В этой статье мы не будем останавливаться на технических деталях **Apache Kafka**, почитать про нее подробнее можно в [официальной документации](https://kafka.apache.org/documentation/)
>
> Также вместе с **Apache** **Kafka** часто используется **Apache** **Zookeeper** для мониторинга/синхронизации брокеров/топиков/сообщений
>
>
Добавим оба этих инструмента в docker-compose.yml
```
version: '3.9'
services:
app:
build:
context: ./app
dockerfile: ../../Dockerfile
ports:
- "8851:8890"
restart: always
networks:
- backend
depends_on:
- zookeeper
- broker
deploy:
resources:
limits:
cpus: '0.2'
memory: 500M
logs:
build:
context: ./log
dockerfile: ../../Dockerfile
ports:
- "8852:8890"
restart: always
networks:
- backend
depends_on:
- zookeeper
- broker
deploy:
resources:
limits:
cpus: '0.2'
memory: 500M
zookeeper:
image: confluentinc/cp-zookeeper:7.0.1
container_name: zookeeper
restart: always
networks:
- backend
environment:
ZOOKEEPER_CLIENT_PORT: 2181
ZOOKEEPER_TICK_TIME: 2000
broker:
image: confluentinc/cp-kafka:7.0.1
container_name: broker
restart: always
ports:
- "9092:9092"
networks:
- backend
depends_on:
- zookeeper
environment:
KAFKA_BROKER_ID: 1
KAFKA_ZOOKEEPER_CONNECT: 'zookeeper:2181'
KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_INTERNAL:PLAINTEXT
KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092,PLAINTEXT_INTERNAL://broker:29092
KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
networks:
backend:
```
Основное приложение, которое будет писать сообщения в кафку
```
package main
import (
"context"
"encoding/json"
"log"
"math/rand"
"net/http"
"os"
"github.com/segmentio/kafka-go"
)
func main() {
log.SetOutput(os.Stdout)
// kafka topic
topic := "my-topic"
partition := 0
// create kafka connection
conn, err := kafka.DialLeader(context.Background(), "tcp", "broker:29092", topic, partition)
if err != nil {
log.Fatal("failed to dial leader:", err)
}
http.HandleFunc("/handle", func(writer http.ResponseWriter, request *http.Request) {
// cpu intensive work
for i := 0; i <= 1000; i++ {
_, _ = json.Marshal(randSeq(10))
}
// produce event to kafka
_, err := conn.WriteMessages(
kafka.Message{Value: []byte(randSeq(100))},
)
if err != nil {
log.Println(err)
}
writer.Header().Add("Content-Type", "application/json")
writer.Write([]byte("done!"))
})
_ = http.ListenAndServe(":8890", nil)
}
var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
// Random string generator
func randSeq(n int) string {
b := make([]rune, n)
for i := range b {
b[i] = letters[rand.Intn(len(letters))]
}
return string(b)
}
```
Приложение, которое будет вычитывать сообщения из кафки
```
package main
import (
"context"
"encoding/json"
"log"
"math/rand"
"os"
"github.com/segmentio/kafka-go"
)
func main() {
log.SetOutput(os.Stdout)
// kafka topic
topic := "my-topic"
partition := 0
// create kafka connection
r := kafka.NewReader(kafka.ReaderConfig{
Brokers: []string{"broker:29092"},
Topic: topic,
Partition: partition,
})
for {
// read message from kafka
m, err := r.ReadMessage(context.Background())
if err != nil {
log.Println(err)
break
}
// cpu intensive work
for i := 0; i <= 1000; i++ {
_, _ = json.Marshal(randSeq(50))
}
log.Print(m.Offset, string(m.Key), string(m.Value))
}
}
var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
// Random string generator
func randSeq(n int) string {
b := make([]rune, n)
for i := range b {
b[i] = letters[rand.Intn(len(letters))]
}
return string(b)
}
```
Запустим нагрузочное тестирование командами
```
docker run --network=async_backend \
--rm skandyla/wrk -t1 -c1 -d5s http://app:8890/handle
docker run --network=async_backend \
--rm skandyla/wrk -t3 -c3 -d5s http://app:8890/handle
```
Видим следующий лог
```
Running 5s test @ http://app:8890/handle
1 threads and 1 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 21.24ms 26.03ms 89.19ms 78.94%
Req/Sec 121.16 36.59 316.00 86.00%
610 requests in 5.05s, 66.72KB read
Requests/sec: 120.80
Transfer/sec: 13.21KB
Running 5s test @ http://app:8890/handle
3 threads and 3 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 40.31ms 37.91ms 103.10ms 68.19%
Req/Sec 29.21 13.37 90.00 83.33%
441 requests in 5.03s, 48.23KB read
Requests/sec: 87.66
Transfer/sec: 9.59KB
```
Соберем воедино результаты и сравним
| | | |
| --- | --- | --- |
| | **RPS** | **Latency** |
| sync (1t, 1c) | 56 | 28.20ms |
| sync (3t, 3c) | 28 | 105.07ms |
| async (1t, 1c) | 120 | 21.24ms |
| async (3t, 3c) | 87 | 40.31ms |
Видим, что асинхронная обработка увеличила **RPS** и при этом сократила **latency**, так как теперь не нужно ждать выполнения запроса внешним сервисом.
> Подробнее про асинхронную обработку можно почитать [system-design-primer](https://github.com/donnemartin/system-design-primer#asynchronism)
>
>
**Плюсы**
* Очевидный плюс в том, что теперь сложная работа выполняется асинхронно, тем самым увеличивается пропускная способность приложения
* Можно в зависимости от накопленного количества сообщений в очереди добавлять/удалять реплики приложения-потребителя
**Минусы**
* Для асинхронного выполнения подойдут тяжелые операции, не требующие мгновенной реакции
* Появляется еще одна точка отказа в виде шины данных, которую необходимо поддерживать
SQL to NoSQL
------------
(no) sqlЕсть приложение, в котором есть одно хранилище под все и, как правило, это какая-нибудь реляционная база данных. Уезжать из него очень не хочется, но пользовательский трафик растет с такой скоростью, что поддержание одного такого хранилища обходится дорого. Что же делать?
**Пример**: допустим есть приложение и в качестве хранилища данных используется **postgres**. Количество пользовательских событий/данных/логов стремительно растет. Таблица с этими данными разбухает и запись в нее замедляется, как и чтение из нее. Сначала мы дробим данные на таблицы по месяцам вроде **activities\_01072022**, **activities\_01082022**, но и этот подход нас перестает устраивать, так как выгрузить полную историю пользователей требует большого количества джойнов по таблицам. Впереди ждет еще больше данных, ожидается, что сервис по праву будет как **write-heavy**, так и **read-heavy**. Вынесем эти события в эффективное для таких задач **nosql** хранилище данных.
**Концепт**: как большинство крупных систем, данные делятся примерно на два типа. Первые - это те, которые критически важно держать в согласованности, любые операции над ними требуют **ACID** свойств базы данных. Пример таких данных - финансовые операции/транзакции/бонусные счета. К таким базам относятся **mysql**, **postgres** и другие. С другой стороны, существуют **nosql** базы данных, которые за счет ограничений дают эффективность при выполнении специальных типов задач. Например, **redis** хорошо подходит для кеширования данных, так как они находятся в **RAM** и за счет этого он имеет высокую пропускную способность с низким **latency**. Не будем зацикливаться на отдельных хранилищах, как и в программировании в целом, хранилища также имеют свою кухню со своими блюдами, где все зависит от потребностей.
**Реализация**: примеры кода ниже, но они также доступны в [github](https://github.com/agadzhanyan/highload-patterns/tree/main/sql-to-nosql).
В качестве примера возьмем приложение, которое будет на запрос пользователя генерировать данные и записывать их в хранилище, В качестве демонстрации разницы в пропускной способности возьмем коробочные **postgres** и **cassandra.**
Go приложение с postgres
```
package main
import (
"database/sql"
"encoding/json"
"log"
"math/rand"
"net/http"
"os"
"time"
"github.com/google/uuid"
_ "github.com/lib/pq"
)
func main() {
log.SetOutput(os.Stdout)
connStr := "host=postgres user=postgres password=postgres dbname=postgres sslmode=disable"
db, err := sql.Open("postgres", connStr)
if err != nil {
log.Fatal(err)
}
http.HandleFunc("/handle", func(writer http.ResponseWriter, request *http.Request) {
uid := uuid.New().String()
blob, _ := json.Marshal(randSeq(100))
err := db.QueryRowContext(
request.Context(),
`INSERT INTO activities(id, user_id, timestamp, data) VALUES($1, $2, $3, $4)`,
uid,
uuid.New().String(),
time.Now(),
string(blob),
).Err()
if err != nil {
writer.Header().Add("Content-Type", "application/json")
writer.Write([]byte("failed!" + err.Error()))
return
}
writer.Header().Add("Content-Type", "application/json")
writer.Write([]byte("saved! " + uid))
})
_ = http.ListenAndServe(":8890", nil)
}
var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
// Random string generator
func randSeq(n int) string {
b := make([]rune, n)
for i := range b {
b[i] = letters[rand.Intn(len(letters))]
}
return string(b)
}
```
Сформированный docker-compose.yml
```
version: '3.9'
services:
app:
build:
context: .
dockerfile: ../Dockerfile
ports:
- "8831:8890"
restart: always
networks:
- backend
depends_on:
- postgres
deploy:
resources:
limits:
cpus: '1'
memory: 2000M
postgres:
image: postgres:14.0
volumes:
- /Users/davidagadzhanyan/go/src/highload-patterns/sql-to-nosql/sql/schema.sql:/docker-entrypoint-initdb.d/10-init.sql
networks:
- backend
environment:
POSTGRES_DB: "postgres"
POSTGRES_USER: "postgres"
POSTGRES_PASSWORD: "postgres"
ports:
- "5432:5432"
deploy:
resources:
limits:
cpus: '1'
memory: 2000M
networks:
backend:
```
Таблица, в которую будем писать данные
```
create table if not exists activities
(
id varchar primary key,
user_id varchar,
timestamp timestamp,
data jsonb
);
```
Аналогичное приложение с cassandra
```
package main
import (
"encoding/json"
"log"
"math/rand"
"net/http"
"os"
"time"
"github.com/gocql/gocql"
)
func main() {
log.SetOutput(os.Stdout)
cluster := gocql.NewCluster("cassandra")
cluster.Keyspace = "app"
cluster.Consistency = gocql.Quorum
cluster.Authenticator = gocql.PasswordAuthenticator{
Username: "cassandra",
Password: "cassandra",
}
session, err := cluster.CreateSession()
if err != nil {
log.Fatal(err)
}
defer session.Close()
http.HandleFunc("/handle", func(writer http.ResponseWriter, request *http.Request) {
uid := gocql.UUIDFromTime(time.Now())
blob, _ := json.Marshal(randSeq(100))
if err := session.Query(
`INSERT INTO activities (id, user_id, timestamp, data) VALUES (?, ?, ?, ?)`,
uid,
gocql.UUIDFromTime(time.Now()),
time.Now().Unix(),
blob,
).Exec(); err != nil {
writer.Header().Add("Content-Type", "application/json")
writer.Write([]byte("failed!" + err.Error()))
return
}
writer.Header().Add("Content-Type", "application/json")
writer.Write([]byte("saved! " + uid.String()))
})
_ = http.ListenAndServe(":8890", nil)
}
var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
// Random string generator
func randSeq(n int) string {
b := make([]rune, n)
for i := range b {
b[i] = letters[rand.Intn(len(letters))]
}
return string(b)
}
```
Сформированный docker-compose.yml
```
version: '3.9'
services:
app:
build:
context: .
dockerfile: ../Dockerfile
ports:
- "8841:8890"
restart: always
networks:
- backend
depends_on:
- cassandra
deploy:
resources:
limits:
cpus: '1'
memory: 1000M
cassandra:
image: docker.io/bitnami/cassandra:4.0
networks:
- backend
environment:
- CASSANDRA_SEEDS=cassandra
- CASSANDRA_CLUSTER_NAME=cassandra-cluster
- MAX_HEAP_SIZE=1000M
- HEAP_NEWSIZE=1000M
- CASSANDRA_PASSWORD_SEEDER=yes
- CASSANDRA_PASSWORD=cassandra
ports:
- 9042:9042
volumes:
- cassandra_data:/bitnami
deploy:
resources:
limits:
cpus: '1'
memory: 1000M
#from netflix repo: https://github.com/Netflix/osstracker/blob/master/docker-compose.yml#L67
cassandra-load-keyspace:
container_name: cassandra-load-keyspace
image: cassandra:4.0
networks:
- backend
depends_on:
- cassandra
volumes:
- /Users/davidagadzhanyan/go/src/highload-patterns/sql-to-nosql/nosql/schema.cql:/schema.cql
command: /bin/bash -c "sleep 10 && echo loading cassandra keyspace && cqlsh cassandra -u cassandra -p cassandra -f /schema.cql"
deploy:
restart_policy:
condition: on-failure
delay: 5s
max_attempts: 3
window: 60s
networks:
backend:
volumes:
cassandra_data:
driver: local
```
Таблица, в которую будем писать данные
```
DROP KEYSPACE IF EXISTS app;
CREATE KEYSPACE app WITH replication = {
'class': 'SimpleStrategy',
'replication_factor': 1
};
USE app;
CREATE TABLE IF NOT EXISTS activities
(
id uuid,
user_id uuid,
timestamp timestamp,
data blob,
PRIMARY KEY ((id))
) WITH comment = 'Table with all activities';
```
Проведем нагрузочное тестирование **postgres** командами
```
docker run --network=sql_backend \
--rm skandyla/wrk -t1 -c1 -d5s http://app:8890/handle
docker run --network=sql_backend \
--rm skandyla/wrk -t12 -c12 -d5s http://app:8890/handle
```
Видим результат
```
Running 5s test @ http://app:8890/handle
1 threads and 1 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 2.50ms 2.91ms 31.13ms 88.86%
Req/Sec 524.24 143.19 760.00 80.00%
2611 requests in 5.01s, 385.02KB read
Requests/sec: 521.43
Transfer/sec: 76.89KB
Running 5s test @ http://app:8890/handle
12 threads and 12 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 42.74ms 40.28ms 199.19ms 78.80%
Req/Sec 27.36 16.36 90.00 56.57%
1623 requests in 5.02s, 239.33KB read
Requests/sec: 323.08
Transfer/sec: 47.64KB
```
Проведем нагрузочное тестирование **cassandra** командами
```
docker run --network=nosql_backend \
--rm skandyla/wrk -t1 -c1 -d5s http://app:8890/handle
docker run --network=nosql_backend \
--rm skandyla/wrk -t12 -c12 -d5s http://app:8890/handle
```
Видим результат
```
Running 5s test @ http://app:8890/handle
1 threads and 1 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 2.81ms 806.39us 14.13ms 91.44%
Req/Sec 357.46 53.13 505.00 82.00%
1782 requests in 5.01s, 262.78KB read
Socket errors: connect 0, read 0, write 0, timeout 1
Requests/sec: 355.75
Transfer/sec: 52.46KB
Running 5s test @ http://app:8890/handle
12 threads and 12 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 18.74ms 22.30ms 177.19ms 80.58%
Req/Sec 101.73 30.50 222.00 74.12%
6103 requests in 5.03s, 0.88MB read
Requests/sec: 1213.30
Transfer/sec: 178.91KB
```
Соберем воедино и сравним результаты
| | | |
| --- | --- | --- |
| | **RPS** | **Latency** |
| postgres (1t, 1c) | 521 | 2.50ms |
| postgres (12t, 12c) | 323 | 42.74ms |
| cassandra (1t, 1c) | 355 | 2.81ms |
| cassandra (12t, 12c) | 1213 | 18.74ms |
По результатам видим, что хоть и **postgres** выигрывает у **cassandra** на 1 потоке и 1 соединении, на более высоких уже сильно уступает.
> Конечно, пример лишь для наглядности, в действительности оба этих хранилища по своему интересны и имеют в корне разные подходы к хранению данных.
>
> Например, **postgres** - реляционная БД и хранит данных в виде строк, с **ACID** свойствами.
>
> **Cassandra** же относится к семейству колоночных, эффективно сжимает тонны однотипных данных. Она отлично подходит если вы пишете тоннами данные (можно почитать например [здесь](https://blog.knoldus.com/apache-cassandra-reads-and-writes/) каким образом удается добиться высокой пропускной способности при записи). Существует переписанный на C++ аналог **ScyllaDB**, [говорят](https://www.scylladb.com/2021/08/24/apache-cassandra-4-0-vs-scylla-4-4-comparing-performance/#:~:text=ScyllaDB%20has%202x%2D5x%20better,4x%20faster%20than%20Cassandra%204.0) она еще быстрее
>
> **Postgres** имеет инструменты для шардирования и **master-master** репликации, но тем не менее на поддержание согласованности уходит много дополнительных ресурсы и это сказывается на работе всего кластера. По теореме [CAP](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BE%D1%80%D0%B5%D0%BC%D0%B0_CAP) такая БД относится к CA, у нее отсутствует эффективность работы при расщеплении данных по разным нодам.
>
> **Cassandra** заточена под работу в режиме кластера и за счет [**consisting hashing**](https://cassandra.apache.org/doc/latest/cassandra/architecture/dynamo.html) + виртуальных нод практически безболезненно переживает добавление/удаление нод. Любая реплика может инициировать запись. По теореме CAP такие БД относятся к AP, то есть данные на нодах могут быть несогласованны.
>
>
### Итог
Мы по верхам прошлись по трем подходам к масштабированию приложений. Каждую из этих тем конечно же можно раскрыть гораздо глубже. Надеюсь, что это статья была полезна начинающим инженерам как отправная точка. Буду признателен любым конструктивным замечаниям. Спасибо! | https://habr.com/ru/post/684904/ | null | ru | null |
# Vertical Scaling in Java Cloud
Хочу поделится результатами внутренних тестов вертикального автоматического масштабирования памяти в [Jelastic](http://jelastic.com) — облачный хостинг для Java приложений.
В данном примере симитировано поведение web приложения, которое работает на базе Tomcat сервера. Измерения проводились при различных нагрузках. Нагрузка изменялась путем увеличения количества подключенных клиентов. Измерения показаний проводились через админку владельца приложения.
### Реализация на сервере
Каждому новому пользователю в сессию кладется массив байтов размером 10Мб.
```
Hello!
======
<%
byte[] data = (byte[]) session.getAttribute("test-data");
if (data == null) data = new byte[1024 \* 1024 \* 10];
request.getSession().setAttribute("test-data", data);
%>
Your session ID <%=session.getId()%>
Your session data size <%=data.length%> bytes
```
### Приход клиентов
На графике видно три волны клиентов — 100, 300 и 1000 соотв-но.
1. Первая волна 100 клиентов (в 1 поток одновременно) потребляет примерно ~ 1.3Gb. После чего идет таймаут сессий (10 минут) == все данные из сессий пользователей выгружаются и память возвращается в платформу.
2. Вторая волна 300 клиентов (в 10 потоков) ~ 3.5Gb. Опять после таймаута сессий память возвращается в платформу.
3. Третья волна 1000 клиентов (в 100 потоков) ~ 11Gb. После таймаута сессий память возвращается в платформу.
Как видно из скриншота, приложение берет от платформы только то, что ему реально нужно. Память которая уже не используется, возвращает обратно. Оплата будет осуществляться по факту потребления ресурсов.
### Настройки масштабирования
В правой колонке первый ряд указанно число 3/64 (current/limit) — потребление памяти в [cloudlet](http://jelastic.com/cloudlet) (минимальный неделимый кусок в 256Mb).
Приложение может масштабироваться в пределах от 1 до 64 cloudlets (от 256Mb до 16Gb). Настройки коэффициента масштабирования для данного приложения = x64 раз.
### Выводы
Хоть и мало вероятно чтобы веб-приложение загружало для каждого пользователя в память 10Mb данных, тем не менее тест отлично демонстрирует потенциальные возможности Jelastic. В нашем случае загрузка такого объема данных в сессию была сделана для ускорения процесса роста памяти и для уменьшения требуемого количества клиентов для хорошей прокачки памяти.
Для более реальных показателей — каждый, кто прочитал заголовок этого поста, участвует в тестировании на реальных условиях. Верхнее изображение загружает 200Кб в сессию каждого пользователя. Если тема интересна, результаты реального теста будут выложены попозже. Надеюсь установленных лимитов в 16Gb хватит на пользователей Хабра.
— **UPDATE**
### Результаты експеримента
1. Первый пик — это нагрузочное тестирование для данной статьи — заняло 11Gb памяти.
2. Второй пик — выход данной статьи на главную — заняло 2Gb памяти.
3. Хвост — остаточное явление, падение активности — заняло 0.6Gb памяти.
Из расчета того, что на каждого уникального посетителя в память загонялось 200кб памяти, одновременно в течении 10 минут на сервере присутствовало не более 5.000 человек в самый пиковый момент.
Результаты показывают что нагрузить сервере надо еще уметь :), эмуляция нагрузки куда сильнее качнула память чем реальность.
В обоих случаях отработал динамический скалинг по памяти, итоговая цена будет расчитываться относительно реально потребляемых ~~попугаев~~ клаудлетов. | https://habr.com/ru/post/118702/ | null | ru | null |
# От простых скриптов к клиент-серверному приложению на WCF своими руками: почему мне нравится работа в CM
Работа в команде Configuration Management связана с обеспечением функциональности билд-процессов — сборки продуктов компании, предварительной проверки кода, статистического анализа, ведения документации и многого другого. Помимо этого, мы постоянно работаем над оптимизацией различных процессов, и, что замечательно, мы практически свободны в выборе инструментов для этой интересной работы. Далее я подробно расскажу о том, как, обладая лишь разного уровня знаниями в C# и C++, я сделал функциональный WCF-сервис для работы с очередями фиксов. И почему решил, что это очень важно.
Автоматизация один раз или инструкция на 117 страниц снова и снова
------------------------------------------------------------------
Небольшое лирическое отступление, чтобы вы поняли, почему я так переживаю из-за автоматизации и оптимизации процессов.
До Veeam я работал в крупной международной компании — был тимлидом команды Configuration Management, занимался сборкой приложения и развертыванием его на тестовых окружениях. Программа успешно разрабатывалась, добавлялись новые функции, писалась документация, поддержкой которой я тоже занимался. Но меня всегда удивляло, почему у такой серьезной программы нет нормальной системы конфигурации параметров, которых были многие десятки, если не сотни.
Я общался на эту тему с разработчиками и получил ответ – заказчик не оплатил эту фичу, не согласовал ее стоимость, поэтому фича не была реализована. А по факту страдали QA и непосредственно мы, команда СМ. Конфигурация программы и ее предварительная настройка осуществлялась через множество файлов конфигурации, в каждом из которых были десятки параметров.
Каждый новый билд, каждая новая версия вносили свои изменения в конфигурацию. Старые файлы конфигурации нельзя было использовать, так как они часто были несовместимы с новой версией. В итоге каждый раз перед разворачиванием билда для теста или на рабочих машинах тестеров, приходилось тратить уйму времени на конфигурирование программы, исправление ошибок конфигурации, постоянные консультации с разработчиками по теме «а почему это теперь не так работает»? В общем, процесс был крайне не оптимизирован.
В помощь при настройке у нас была инструкция на 117 страниц шрифтом Arial размером 9. Читать приходилось очень-очень внимательно. Иногда казалось, что проще собрать ядро линукс с закрытыми глазами на выключенном компьютере.
Стало понятно, что без оптимизации здесь не обойтись. Я начал писать свой конфигуратор для программы с поддержкой профилей и возможностью менять параметры за несколько секунд, но проект подошел к своей финальной стадии, и я перешел на работу в другой проект. В нем мы анализировали множество логов одной биллинговой системы на предмет возможных багов в работе серверной части. От чудовищного объема ручной работы меня спасла автоматизация многих действий с помощью языка Python. Мне очень понравился этот скриптовый язык, и с его помощью мы сделали набор скриптов анализа на все случаи жизни. Те задачи, которые требовали несколько дней вдумчивого анализа по схеме «cat logfile123 | grep something\_special», занимали считанные минуты. Все стало здорово… и скучно.
Configuration Management — новые приключения
--------------------------------------------
В компанию Veeam я пришел как тимлид небольшой СM-команды. Множество процессов требовало автоматизации, оптимизации, переосмысления. Зато предоставлялась полная свобода в выборе инструментов! Разработчик обязан использовать определенный язык программирования, код-стайл, определенный набор библиотек. СМ же может вообще ничего не использовать для решения поставленной задачи, если у него хватит на это времени, смелости и терпения.
У Veeam, как и у многих других компаний, существует задача сборки апдейтов для продуктов. В апдейт входили сотни файлов, и менять надо было только те, которые изменились, учитывая еще ряд важных условий. Для этого создали объемный powershell скрипт, который умел лезть в TFS, делать выборку файлов, раскладывать их по нужным папочкам. Функциональность скрипта дополнялась, он постепенно стал огромным, требовал кучу времени на отладку и постоянно каких-то костылей в придачу. Надо было срочно что-то делать.
Что хотели разработчики
-----------------------
Вот к чему сводились основные жалобы:
* Невозможно поставить фиксы в очередь. Приходится постоянно проверять веб-страницу, чтобы увидеть, когда закончится сборка приватного фикса и можно будет запустить сборку своего.
* Нет нотификаций об ошибках — чтобы посмотреть ошибки в GUI приложения сборки, приходится заходить на сервер и смотреть множество объемных логов.
* Нет истории сборки приватных фиксов.
Нужно было разобраться с этими задачами и добавить приятных мелочей, от которых разработчики тоже бы не отказались.
Что такое приватные фиксы
-------------------------
Приватный фикс в контексте нашей разработки — это определенный набор исправлений в коде, который сохраняется в шелвсете (shelveset) Team Foundation Server для релизной ветки. Небольшое разъяснение для тех, кто не слишком знаком с терминологией TFS:
* check-in — набор локальных изменений в исходном коде, который вносится в код, хранящийся в TFS. Данный чекин может проверяться с помощью Continuous Integration/Gated Check-in процессов, позволяющих пропускать только корректный код и отклонять все чекины, нарушающие собираемость конечного проекта.
* shelveset — набор локальных изменений в исходном коде, который не вносится непосредственно в исходный код, находящийся в TFS, но доступен по его имени. Шелвсет может быть развернут на локальной машине разработчика или билд-системы для работы с измененным кодом, который не внесен в TFS. Также шелвсет может быть добавлен в TFS как чекин после разворачивания, когда все работы с ним будут завершены. К примеру, так работает гейтед-чекин. Сначала проверяется шелвсет на билдере. Если проверка проходит успешно, шелвсет превращается в чекин!
Вот что делает билдер приватных фиксов:
1. Получает название (номер) шелвсета и разворачивает его на билдере приватных фиксов. В итоге мы получаем исходный код релизного продукта плюс изменения/фиксы из шелвсета. Релизная ветка остается без изменений.
2. На билдере приватных фиксов собирается проект или ряд проектов, для которых был выполнен приватный фикс.
3. Набор скомпилированных бинарных файлов копируется в сетевой каталог приватного фикса. Каталог содержит в себя имя шелвсета, которое представляет собой последовательность чисел.
4. Исходный код на билдере приватных фиксов приводится к первоначальному виду.
Для удобства разработчиков используется веб-интерфейс, где можно указать продукт, для которого надо собрать приватный фикс, указать номер шелвсета, выбрать проекты, для которых требуется собрать приватный фикс, и добавить сборку фикса в очередь. На скриншоте ниже приведен финальный рабочий вариант веб-приложения, где отображается текущий статус билда, очередь приватных фиксов и история их сборки. В нашем примере рассматривается только организация очереди сборки приватных фиксов.
Что было у меня
---------------
* Билдер приватных фиксов, который собирал приватные фиксы из шелвсетов TFS с помощью запуска консольного приложения с заданными параметрами командной строки.
* Veeam.Builder.Agent – написанный в компании Veeam WCF-сервис, который запускает приложение с параметрами в консольном режиме под текущим пользователем и возвращает текущий статус работы приложения.
* IIS веб-сервис – приложение на Windows Forms, которое позволяло ввести имя шелвсета, заданные параметры и запустить процесс сборки приватного фикса.
* Весьма неглубокие знания в программировании — C++, немного C# в университете и написание небольших приложений для автоматизации, добавления новых функций в текущие билд-процессы и в качестве хобби.
* Опытные коллеги, Google и индийские статьи на MSDN — источники ответов на все вопросы.
Что будем делать
----------------
В этой статье я расскажу, как реализовал постановку сборки фиксов в очередь и последовательный их запуск на билдере. Вот из каких частей будет состоять решение:
* QBuilder.AppQueue – мой WCF-сервис, обеспечивающий работу с очередью сборки и вызывающий сервис Veeam.Builder.Agent для запуска программы сборки.
* dummybuild.exe – программа-заглушка, используемая для отладки и в качестве наглядного пособия. Нужна для визуализации передаваемых параметров.
* QBuilder.AppLauncher – WCF-сервис, который запускает приложения в консоли текущего пользователя и работает в интерактивном режиме. Это значительно упрощенный, написанный специально для этой статьи аналог программы Veeam.Builder.Agent. Оригинальный сервис умеет работать как windows-сервис и запускать приложения в консоли, что требует дополнительной работы с Windows API. Чтобы описать все ухищрения, потребовалась бы отдельная статья. Мой же пример работает как простой интерактивный консольный сервис и использует две функции — запуск процесса с параметрами и проверку его состояния.
Дополнительно создали новое удобное веб-приложение, которое умеет работать с несколькими билдерами и вести логи событий. Чтобы не перегружать статью, подробно рассказывать о нем мы тоже пока не будем. Кроме этого, в этой статье не приведена работа с TFS, с историей хранений собранных приватных фиксов и различные вспомогательные классы и функции.
Создание WCF-сервисов
---------------------
Есть много подробных статей, описывающих создание WCF-сервисов. Мне больше всех понравился [материал с сайта Microsoft](https://docs.microsoft.com/en-us/dotnet/framework/wcf/feature-details/how-to-host-a-wcf-service-in-a-managed-windows-service). Его я взял за основу при разработке. Чтобы облегчить знакомство с проектом, я дополнительно выложил [бинарники](https://drive.google.com/open?id=11rxZRWnBHHXzAQ23hjGIX4L4WOZNb7Ew). Начнем!
### Создаем сервис QBuilder.AppLauncher
Здесь у нас будет только первичная болванка сервиса. На данном этапе нам нужно убедиться, что сервис запускается и работает. Кроме этого, код идентичен как для QBuilder.AppLauncher, так и для QBuilder.AppQueue, поэтому этот процесс необходимо будет повторить два раза.
1. Создаем новое консольное приложение с именем QBuilder.AppLauncher
2. Переименовываем Program.cs в Service.cs
3. Переименовываем namespace в QBuilder.AppLauncher
4. Добавляем следующие референсы в проект:
a. System.ServiceModel.dll
b. System.ServiceProcess.dll
c. System.Configuration.Install.dll
5. Добавляем следующие определения в Service.cs
```
using System.ComponentModel;
using System.ServiceModel;
using System.ServiceProcess;
using System.Configuration;
using System.Configuration.Install;
```
В процессе дальнейшей сборки также понадобятся следующие определения:
```
using System.Reflection;
using System.Xml.Linq;
using System.Xml.XPath;
```
6. Определяем интерфейс IAppLauncher и добавляем функции для работы с очередью:
```
// Определяем сервис контракт
[ServiceContract(Namespace = "http://QBuilder.AppLauncher")]
public interface IAppLauncher
{
// Добавляем функцию для проверки работы сервиса
[OperationContract]
bool TestConnection();
}
```
7. В классе AppLauncherService имплементируем интерфейс и тестовую функцию TestConnection:
```
public class AppLauncherService : IAppLauncher
{
public bool TestConnection()
{
return true;
}
}
```
8. Создаем новый класс AppLauncherWindowsService, который наследует ServiceBase класс. Добавляем локальную переменную serviceHost – ссылку на ServiceHost. Определяем метод Main, который вызывает ServiceBase.Run(new AppLauncherWindowsService()):
```
public class AppLauncherWindowsService : ServiceBase
{
public ServiceHost serviceHost = null;
public AppLauncherWindowsService()
{
// Name the Windows Service
ServiceName = "QBuilder App Launcher";
}
public static void Main()
{
ServiceBase.Run(new AppLauncherWindowsService());
}
```
9. Переопределяем функцию OnStart(), создающую новый экземпляр ServiceHost:
```
protected override void OnStart(string[] args)
{
if (serviceHost != null)
{
serviceHost.Close();
}
// Create a ServiceHost for the CalculatorService type and
// provide the base address.
serviceHost = new ServiceHost(typeof(AppLauncherService));
// Open the ServiceHostBase to create listeners and start
// listening for messages.
serviceHost.Open();
}
```
10. Переопределяем функцию onStop, закрывающую экземпляр ServiceHost:
```
protected override void OnStop()
{
if (serviceHost != null)
{
serviceHost.Close();
serviceHost = null;
}
}
}
```
11. Создаем новый класс ProjectInstaller, наследуемый от Installer и отмеченный RunInstallerAttribute, который установлен в True. Это позволяет установить Windows-сервис с помощью программы installutil.exe:
```
[RunInstaller(true)]
public class ProjectInstaller : Installer
{
private ServiceProcessInstaller process;
private ServiceInstaller service;
public ProjectInstaller()
{
process = new ServiceProcessInstaller();
process.Account = ServiceAccount.LocalSystem;
service = new ServiceInstaller();
service.ServiceName = "QBuilder App Launcher";
Installers.Add(process);
Installers.Add(service);
}
}
```
12. Меняем содержимое файла app.config:
```
xml version="1.0" encoding="utf-8" ?
```
### Проверяем работоспособность сервиса
1. Компилируем сервис.
2. Устанавливаем его командой installutil.exe
1) Переходим в папку, где лежит скомпилированный файл сервиса
2) Запускаем команду установки:
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe
3. Заходим в оснастку services.msc, проверяем наличие сервиса «QBuilder App Launcher» и запускаем его.
4. Работоспособность сервиса проверяем с помощью программы WcfTestClient.exe, которая входит в поставку VisualStudio:
1) Запускаем WcfTestClient
2) Добавляем адрес сервиса: [http://localhost:8000/QBuilderAppLauncher/service](http://localhost:8000/QBuilderAppQueue/service)
3) Открывается интерфейс сервиса:
4) Вызываем тестовую функцию TestConnection, проверяем, что все работает и функция возвращает значение:
Теперь, когда получен рабочая болванка сервиса, добавляем необходимые нам функции.
### Зачем мне нужна тестовая функция, которая ничего не делает
Когда я начал изучать, как написать WCF-сервис с нуля, я прочитал кучу статей по этой теме. На столе у меня лежал десяток-другой распечатанных листов, по которым я разбирался, что и как. Признаюсь, сразу запустить сервис у меня не получилось. Я потратил кучу времени и пришел к выводу, что сделать болванку сервиса действительно важно. С ней вы будете уверены, что все работает и можно приступать к реализации необходимых функций. Подход может показаться расточительным, но он облегчит жизнь, если куча написанного кода не заработает как надо.
### Добавляем возможность запуска из консоли
Вернемся к приложению. На этапе отладки и в ряде других случаев требуется запуск сервиса в виде консольного приложения без регистрации в виде сервиса. Это очень полезная функция, позволяющая обойтись без утомительного использования дебаггеров. Именно в таком режиме работает сервис QBuilder.AppLauncher. Вот как ее реализовать:
1. Добавляем в класс AppLauncherWindowsService процедуру RunInteractive, обеспечивающую работу сервиса в консольном режиме:
```
static void RunInteractive(ServiceBase[] services)
{
Console.WriteLine("Service is running in interactive mode.");
Console.WriteLine();
var start = typeof(ServiceBase).GetMethod("OnStart", BindingFlags.Instance | BindingFlags.NonPublic);
foreach (var service in services)
{
Console.Write("Starting {0}...", service.ServiceName);
start.Invoke(service, new object[] { new string[] { } });
Console.Write("Started {0}", service.ServiceName);
}
Console.WriteLine();
Console.WriteLine("Press any key to stop the services and end the process...");
Console.ReadKey();
Console.WriteLine();
var stop = typeof(ServiceBase).GetMethod("OnStop", BindingFlags.Instance | BindingFlags.NonPublic);
foreach (var service in services)
{
Console.Write("Stopping {0}...", service.ServiceName);
stop.Invoke(service, null);
Console.WriteLine("Stopped {0}", service.ServiceName);
}
Console.WriteLine("All services stopped.");
}
```
2. Вносим изменения в процедуру Main – добавляем обработку параметров командной строки. При наличии параметра /console и открытой активной сессии пользователя – запускаем программу в интерактивном режиме. В ином случае – запускаем как сервис.
```
public static void Main(string[] args)
{
var services = new ServiceBase[]
{
new AppLauncherWindowsService()
};
// Добавляем возможность запуска сервиса в интерактивном режиме в виде консольного приложения, если есть параметр командной строки /console
if (args.Length == 1 && args[0] == "/console" && Environment.UserInteractive)
{
// Запускаем в виде интерактивного приложения
RunInteractive(services);
}
else
{
// Запускаем как сервис
ServiceBase.Run(services);
}
}
```
### Добавляем функции запуска приложения и проверки его статуса
Сервис сделан предельно простым, здесь нет никаких дополнительных проверок. Он умеет запускать приложения только в консольном варианте и от имени администратора. Он может запустить их и как сервис – но вы их не увидите, они будут крутиться в фоновом режиме и вы сможете увидеть их только через Task Manager. Все это можно реализовать, но это тема для отдельной статьи. Здесь для нас главное — наглядный рабочий пример.
1. Для начала добавляем глобальную переменную appProcess, хранящую в себе текущий запущенный процесс.
Добавляем ее в класс `public class AppLauncherService : IAppLauncher`:
```
public class AppLauncherService : IAppLauncher
{
Process appProcess;
```
2. Добавляем в этот же класс функцию, проверяющую статус запущенного процесса:
```
public bool IsStarted()
{
if (appProcess!=null)
{
if (appProcess.HasExited)
{
return false;
}
else
{
return true;
}
}
else
{
return false;
}
}
```
Функция возвращает false, если процесс не существует или уже не запущен, и true – если процесс активен.
3. Добавляем функцию запуска приложения:
```
public bool Start(string fileName, string arguments, string workingDirectory, string domain, string userName, int timeoutInMinutes)
{
ProcessStartInfo processStartInfo = new ProcessStartInfo();
processStartInfo.FileName = fileName;
processStartInfo.Arguments = arguments;
processStartInfo.Domain = domain;
processStartInfo.UserName = userName;
processStartInfo.CreateNoWindow = false;
processStartInfo.UseShellExecute = false;
try
{
if (appProcess!=null)
{
if (!appProcess.HasExited)
{
Console.WriteLine("Process is still running. Waiting...");
return false;
}
}
}
catch (Exception ex)
{
Console.WriteLine("Error while checking process: {0}", ex);
}
try
{
appProcess = new Process();
appProcess.StartInfo = processStartInfo;
appProcess.Start();
}
catch (Exception ex)
{
Console.WriteLine("Error while starting process: {0}",ex);
}
return true;
}
```
Функция запускает любое приложение с параметрами. Параметры Domain и Username в данном контексте не используются и могут быть пустыми, так как сервис запускает приложение из консольной сессии с правами администратора.
### Запуск сервиса QBuilder.AppLauncher
Как ранее описывалось, данный сервис работает в интерактивном режиме и позволяет запускать приложения в текущей сессии пользователя, проверяет, запущен ли процесс или уже завершен.
1. Для работы необходимы файлы QBuilder.AppLauncher.exe и QBuilder.AppLauncher.exe.config, которые находятся в архиве по ссылке выше. Там же расположен исходный код данного приложения для самостоятельной сборки.
2. Запускаем сервис с правами администратора.
3. Откроется консольное окно сервиса:
Любое нажатие клавиши в консоли сервиса закрывает его, будьте внимательны.
1. Для тестов запускаем wcftestclient.exe, входящий в поставку Visual Studio. Проверяем доступность сервиса по адресу <http://localhost:8000/QBuilderAppLauncher/service> или открываем ссылку в Internet Explorer.
Если все работает, переходим к следующему этапу.
### Создаем сервис QBuilder.AppQueue
А теперь перейдем к самому главному сервису, ради чего и писалась вся эта статья! Повторяем последовательность действий в главе «Создаем сервис QBuilder.AppLauncher» и в главе «Добавляем возможность запуска из консоли», заменяя в коде AppLauncher на AppQueue.
### Добавляем ссылку на сервис QBuilder.AppLauncher для использования в сервисе очереди
1. В Solution Explorer для нашего проекта выбираем Add Service Reference и указываем адрес: [localhost](http://localhost):8000/QBuilderAppLauncher/service
2. Выбираем имя namespace: AppLauncherService.
Теперь мы можем обращаться к интерфейсу сервиса из своей программы.
### Создаем структуру хранения элементов очереди
В namespace QBuilder.AppQueue добавляем класс QBuildRecord:
```
// Структура, где хранится элемент очереди
public class QBuildRecord
{
// ID билда
public string BuildId { get; set; }
// ID задачи
public string IssueId { get; set; }
// Название проблемы
public string IssueName { get; set; }
// Время начало билда
public DateTime StartDate { get; set; }
// Время завершения билда
public DateTime FinishDate { get; set; }
// Флаг сборки компонентов C#
public bool Build_CSharp { get; set; }
// Флаг сборки компонентов C++
public bool Build_Cpp { get; set; }
}
```
### Имплементируем класс работы с очередью CXmlQueue
Добавим в наш проект класс CXmlQueue.cs, где будет находиться ряд процедур работы с XML-файлом:
* Конструктор CXmlQueue — задает при инициализации имя файла, где хранится очередь.
* SetCurrentBuild — записывает информацию о текущем билде в XML-файл очереди. Это элемент, не входящий в очередь, в нем хранится информация о текущем запущенном процессе. Может быть пустым.
* GetCurrentBuild — получает параметры запущенного процесса из XML-файла очереди. Может быть пустым.
* ClearCurrentBuild — это очистка элемента currentbuild в XML-файле очереди, если процесс завершился.
* OpenXmlQueue – функция открытия XML-файла, где хранится очередь. Если файл отсутствует, то создается новый.
* GetLastQueueBuildNumber – каждый билд в очереди имеет свой уникальный последовательный номер. Данная функция возвращает его значение, которое хранится в root-атрибуте.
* IncrementLastQueueBuildNumber – увеличивает значение номера билда при постановке нового билда в очередь.
* GetCurrentQueue – возвращает список элементов QBuildRecord из XML-файла очереди.
В оригинальном коде все эти процедуры были размещены в основном классе, но для наглядности я сделал отдельный класс CXmlQueue. Класс создается в пространстве имен namespace QBuilder.AppQueue, проверьте, что указаны все необходимые определения:
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Linq;
using System.Xml.XPath;
using System.IO;
namespace QBuilder.AppQueue
{
. . .
}
```
Итак, имплементируем. Непосредственно класс CXmlQueue:
**Нажмите, чтобы раскрыть спойлер с кодом**
```
// Класс работы с очередью в XML файле
public class CXmlQueue
{
// Имя файла, где хранится очередь
string xmlBuildQueueFile;
public CXmlQueue(string _xmlQueueFile)
{
xmlBuildQueueFile = _xmlQueueFile;
}
public string GetQueueFileName()
{
return xmlBuildQueueFile;
}
// Функция, получающая параметры запущенного процесса из файла xml (отдельная запись в xml)
public QBuildRecord GetCurrentBuild()
{
QBuildRecord qBr;
XElement xRoot = OpenXmlQueue();
XElement xCurrentBuild = xRoot.XPathSelectElement("currentbuild");
if (xCurrentBuild != null)
{
qBr = new QBuildRecord();
qBr.BuildId = xCurrentBuild.Attribute("BuildId").Value;
qBr.IssueId = xCurrentBuild.Attribute("IssueId").Value;
qBr.StartDate = Convert.ToDateTime(xCurrentBuild.Attribute("StartDate").Value);
return qBr;
}
return null;
}
// Функция, устанавливающая параметры запущенного процесса из файла xml (отдельная запись в xml)
public void SetCurrentBuild(QBuildRecord qbr)
{
XElement xRoot = OpenXmlQueue();
XElement newXe = (new XElement(
"currentbuild",
new XAttribute("BuildId", qbr.BuildId),
new XAttribute("IssueId", qbr.IssueId),
new XAttribute("StartDate", DateTime.Now.ToString())
));
XElement xCurrentBuild = xRoot.XPathSelectElement("currentbuild");
if (xCurrentBuild != null)
{
xCurrentBuild.Remove(); // remove old value
}
xRoot.Add(newXe);
xRoot.Save(xmlBuildQueueFile);
}
// Функция, обнуляющая параметры запущенного процесса из файла xml, в случае, когда процесс закончился
public void ClearCurrentBuild()
{
XElement xRoot = OpenXmlQueue();
try
{
XElement xCurrentBuild = xRoot.XPathSelectElement("currentbuild");
if (xCurrentBuild != null)
{
Console.WriteLine("Clearing current build information.");
xCurrentBuild.Remove();
}
}
catch (Exception ex)
{
Console.WriteLine("XML queue doesn't have running build yet. Nothing to clear!");
}
xRoot.Save(xmlBuildQueueFile);
}
// Функция открытия XML очереди из файла и его создания в случае его отсутствия
public XElement OpenXmlQueue()
{
XElement xRoot;
if (File.Exists(xmlBuildQueueFile))
{
xRoot = XElement.Load(xmlBuildQueueFile, LoadOptions.None);
}
else
{
Console.WriteLine("Queue file {0} not found. Creating...", xmlBuildQueueFile);
XElement xE = new XElement("BuildsQueue", new XAttribute("BuildNumber", 0));
xE.Save(xmlBuildQueueFile);
xRoot = XElement.Load(xmlBuildQueueFile, LoadOptions.None);
}
return xRoot;
}
// Получение номера последнего элемента в очереди
public int GetLastQueueBuildNumber()
{
XElement xRoot = OpenXmlQueue();
if (xRoot.HasAttributes)
return int.Parse(xRoot.Attribute("BuildNumber").Value);
return 0;
}
// Увеличение номера последнего элемента в очереди в случае добавления новых элементов в очередь
public int IncrementLastQueueBuildNumber()
{
int buildIndex = GetLastQueueBuildNumber();
buildIndex++;
XElement xRoot = OpenXmlQueue();
xRoot.Attribute("BuildNumber").Value = buildIndex.ToString();
xRoot.Save(xmlBuildQueueFile);
return buildIndex;
}
// Выгрузка очереди из xml файла в виде списка QBuildRecord
public List GetCurrentQueue()
{
List qList = new List();
XElement xRoot = OpenXmlQueue();
if (xRoot.XPathSelectElements("build").Any())
{
List xBuilds = xRoot.XPathSelectElements("build").ToList();
foreach (XElement xe in xBuilds)
{
qList.Add(new QBuildRecord
{
BuildId = xe.Attribute("BuildId").Value,
IssueId = xe.Attribute("IssueId").Value,
IssueName = xe.Attribute("IssueName").Value,
StartDate = Convert.ToDateTime(xe.Attribute("StartDate").Value),
Build\_CSharp = bool.Parse(xe.Attribute("Build\_CSharp").Value),
Build\_Cpp = bool.Parse(xe.Attribute("Build\_Cpp").Value)
});
}
}
return qList;
}
}
```
Очередь в XML-файле выглядит следующим образом:
```
xml version="1.0" encoding="utf-8"?
```
Создайте файл BuildQueue.xml с данным содержимым и положите в каталог с исполняемым файлом. Данный файл будет использоваться в тестовой отладке для соответствия тестовых результатов.
### Добавляем класс AuxFunctions
В данном классе я размещаю вспомогательные функции. Сейчас здесь находится только одна функция, FormatParameters, которая выполняет форматирование параметров для передачи их в консольное приложение с целью запуска. Листинг файла AuxFunctions.cs:
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace QBuilder.AppQueue
{
class AuxFunctions
{
// Функция формирования параметров для запуска приложения
public static string FormatParameters(string fileName, IDictionary parameters)
{
if (String.IsNullOrWhiteSpace(fileName))
{
throw new ArgumentNullException("fileName");
}
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var macros = String.Join(" ", parameters.Select(parameter => String.Format("\"{0}={1}\"", parameter.Key, parameter.Value.Replace(@"""", @"\"""))));
return String.Format("{0} /b \"{1}\"", macros, fileName);
}
}
}
```
### Добавляем новые функции в интерфейс сервиса
Тестовую функцию TestConnection на данном этапе можно удалить. Для реализации работы очереди мне потребовался следующий набор функций:
* PushBuild(QBuildRecord): void. Это функция, добавляющая в XML-файл очереди новое значение с параметрами QBuildRecord
* TestPushBuild(): void. Это тестовая функция, добавляющая тестовые данные в очередь в XML-файле.
* PullBuild: QBuildRecord. Это функция, получающая значение QBuildRecord из XML-файла очереди. Он может быть пустым.
Интерфейс будет вот таким:
```
public interface IAppQueue
{
// Функция добавления в очередь
[OperationContract]
void PushBuild(QBuildRecord qBRecord);
// Тестовое добавление в очередь
[OperationContract]
void TestPushBuild();
// Функция получения элемента из очереди
[OperationContract]
QBuildRecord PullBuild();
}
```
### Имплементируем функции в классе AppQueueService: IAppQueue:
**Нажмите чтобы раскрыть спойлер с кодом**
```
public class AppQueueService : IAppQueue
{
// Сервис агента, запускающего консольные приложения
public AppLauncherClient buildAgent;
// Переменная, где хранится имя файла очереди
private string _xmlQueueFile;
public AppQueueService()
{
// Получаем значение файла очереди из конфиг файла. Это не самое лучшее решение, я знаю.
_xmlQueueFile = ConfigurationManager.AppSettings["QueueFileName"];
}
public QBuildRecord PullBuild()
{
QBuildRecord qBr;
CXmlQueue xmlQueue = new CXmlQueue(_xmlQueueFile);
XElement xRoot = xmlQueue.OpenXmlQueue();
if (xRoot.XPathSelectElements("build").Any())
{
qBr = new QBuildRecord();
XElement xe = xRoot.XPathSelectElements("build").FirstOrDefault();
qBr.BuildId = xe.Attribute("BuildId").Value;
qBr.IssueId = xe.Attribute("IssueId").Value;
qBr.IssueName = xe.Attribute("IssueName").Value;
qBr.StartDate = Convert.ToDateTime(xe.Attribute("StartDate").Value);
qBr.Build_CSharp = bool.Parse(xe.Attribute("Build_CSharp").Value);
qBr.Build_Cpp = bool.Parse(xe.Attribute("Build_Cpp").Value);
xe.Remove(); // Remove first element
xRoot.Save(xmlQueue.GetQueueFileName());
return qBr;
}
return null;
}
public void PushBuild(QBuildRecord qBRecord)
{
CXmlQueue xmlQueue = new CXmlQueue(_xmlQueueFile);
XElement xRoot = xmlQueue.OpenXmlQueue();
xRoot.Add(new XElement(
"build",
new XAttribute("BuildId", qBRecord.BuildId),
new XAttribute("IssueId", qBRecord.IssueId),
new XAttribute("IssueName", qBRecord.IssueName),
new XAttribute("StartDate", qBRecord.StartDate),
new XAttribute("Build_CSharp", qBRecord.Build_CSharp),
new XAttribute("Build_Cpp", qBRecord.Build_Cpp)
));
xRoot.Save(xmlQueue.GetQueueFileName());
}
public void TestPushBuild()
{
CXmlQueue xmlQueue = new CXmlQueue(_xmlQueueFile);
Console.WriteLine("Using queue file: {0}",xmlQueue.GetQueueFileName());
int buildIndex = xmlQueue.IncrementLastQueueBuildNumber();
Random rnd = new Random();
PushBuild
(new QBuildRecord
{
Build_CSharp = true,
Build_Cpp = true,
BuildId = buildIndex.ToString(),
StartDate = DateTime.Now,
IssueId = rnd.Next(100000).ToString(),
IssueName = "TestIssueName"
}
);
}
}
```
### Вносим изменения в класс AppQueueWindowsService: ServiceBase
Добавляем новые переменные в тело класса:
```
// Таймер, необходимый для обращения к очереди через определенный интервал
private System.Timers.Timer timer;
// Переменная, в которой информация о запущенном процессе
public QBuildRecord currentBuild;
//public QBuildRecord processingBuild;
// Переменная, где будет хранится статус клиентского сервиса
public bool clientStarted;
// Имя файла очереди
public string xmlBuildQueueFileName;
// Класс очереди
public CXmlQueue xmlQueue;
// Строковые переменные для запуска процесса в клиентском сервисе
public string btWorkingDir;
public string btLocalDomain;
public string btUserName;
public string buildToolPath;
public string btScriptPath;
public int agentTimeoutInMinutes;
// Очередь
public AppQueueService buildQueueService;
```
В конструктор AppQueueWindowsService() добавляем функции для чтения файла конфигурации, инициализации сервисов и классов очереди:
```
// Считываем параметры из файла конфигурации и задаем начальные параметры
try
{
xmlBuildQueueFileName = ConfigurationManager.AppSettings["QueueFileName"];
buildToolPath = ConfigurationManager.AppSettings["BuildToolPath"];
btWorkingDir = ConfigurationManager.AppSettings["BuildToolWorkDir"];
btLocalDomain = ConfigurationManager.AppSettings["LocalDomain"];
btUserName = ConfigurationManager.AppSettings["UserName"];
btScriptPath = ConfigurationManager.AppSettings["ScriptPath"];
agentTimeout= 30000;
// Инициализируем сервис очереди
buildQueueService = new AppQueueService();
// Инициализируем класс очереди
xmlQueue = new CXmlQueue(xmlBuildQueueFileName);
}
catch (Exception ex)
{
Console.WriteLine("Error while loading configuration: {0}", ex);
}
```
AgentTimeout — частота срабатывания таймера. Указывается в миллисекундах. Здесь мы задаем, что таймер должен срабатывать каждые 30 секунд. В оригинале данный параметр находится в файле конфигурации. Для статьи я его решил задавать в коде.
Добавляем в класс функцию проверки запущенного билд-процесса:
```
// Функция проверки запущенного приложения в агентском сервисе
public bool BuildIsStarted()
{
IAppLauncher builderAgent;
try
{
builderAgent = new AppLauncherClient();
return builderAgent.IsStarted();
}
catch (Exception ex)
{
return false;
}
}
```
Добавляем процедуру работы с таймером:
```
private void TimerTick(object sender, System.Timers.ElapsedEventArgs e)
{
try
{
// Если билд не запущен
if (!BuildIsStarted())
{
// Проверяем значение булевой переменой clientStarted, показывающей статус нашего приложения
if (clientStarted)
{
// Если приложение уже завершило работу, устанавливаем clientStarted в false и присваиваем дату завершения процесса
currentBuild.FinishDate = DateTime.Now;
clientStarted = false;
}
else
{
// Если приложение уже не работает и clientStarted=false (статус приложения) - очищаем информацию о текущем билде
xmlQueue.ClearCurrentBuild();
}
// Достаем из очереди информацию об очередном билде
currentBuild = buildQueueService.PullBuild();
// Если значение не нулевое, начинаем работу с билдом
if (currentBuild != null)
{
// Статус клиента меняем на true - клиент в работе
clientStarted = true;
// Присваиваем значение currentbuild - данная информация отображается в xml и используется в веб приложения для отображения информации о текущем билде
xmlQueue.SetCurrentBuild(currentBuild);
// Формируем список параметров командной строки
var parameters = new Dictionary(StringComparer.OrdinalIgnoreCase)
{
{"BUILD\_ID", currentBuild.BuildId},
{"ISSUE\_ID", currentBuild.IssueId},
{"ISSUE\_NAME", currentBuild.IssueName},
{"BUILD\_CSHARP", currentBuild.Build\_CSharp ? "1" : "0"},
{"BUILD\_CPP", currentBuild.Build\_Cpp ? "1" : "0"}
};
// Форматируем список параметров для нашей программы
var arguments = AuxFunctions.FormatParameters(btScriptPath, parameters);
try
{
// Запускаем нашу программу с параметрами командной строки через сервис AppLauncher
IAppLauncher builderAgent = new AppLauncherClient();
builderAgent.Start(buildToolPath, arguments, btWorkingDir, btLocalDomain, btUserName, agentTimeout);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
```
Вносим изменения в функцию OnStart, добавляем функцию работы с таймером:
```
// Переопределяем процедуру запуска сервиса OnStart
protected override void OnStart(string[] args)
{
if (serviceHost != null)
{
serviceHost.Close();
}
// Добавляем функционал работы с таймером
this.timer = new System.Timers.Timer(agentTimeout); // указывается в миллисекундах
this.timer.AutoReset = true;
this.timer.Elapsed += new System.Timers.ElapsedEventHandler(this.TimerTick);
this.timer.Start();
// Создаем ServiceHost для сервиса AppQueueService
serviceHost = new ServiceHost(typeof(AppQueueService));
// Открываем ServiceHostBase и ждем обращений к сервису
serviceHost.Open();
}
```
### Проверяем список используемых определений
Вот как он должен теперь выглядеть:
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using System.ServiceModel;
using System.ServiceProcess;
using System.Configuration;
using System.Configuration.Install;
using System.Reflection;
using System.Xml.Linq;
using System.Xml.XPath;
using QBuilder.AppQueue.AppLauncherService;
```
### Добавляем секцию конфигурации в App.config
В секцию добавляем следующий набор параметров:
```
```
Проверяем работу сервиса
------------------------
1. Распаковываем архив QBuilder.AppLauncher.zip. Он и другие нужные файлы доступны по [ссылке](https://drive.google.com/open?id=11rxZRWnBHHXzAQ23hjGIX4L4WOZNb7Ew).
2. Копируем файл dummybuild.exe из каталога внутри архива binaries в каталог, например, в c:\temp. Данная программа является тестовой заглушкой и просто отображает параметры командной строки, которые передает сервис запускаемому приложению. Если вы используете другой каталог, не забудьте изменить параметры BuildToolPath и BuildToolWorkDir в файле конфигурации.
3. Переходим в каталог \QBuilder.AppLauncher\binaries\QBuilder.AppLauncher\ и запускаем файл QBuilder.AppLauncher.exe в режиме администратора. Также вы можете собрать данный сервис из исходников.
4. Запускаем консольный вариант скомпилированного сервиса командой QBuilder.AppQueue.exe /console с правами администратора.
5. Проверяем, что сервис запустился и работает:
6. Запускаем и ждем. Если все работает успешно, то через 30 секунд появится следующее окно:
7. Открываем файл BuildQueue.xml и наблюдаем, как уменьшается очередь и меняется значение currentbuild:
```
xml version="1.0" encoding="utf-8"?
```
8. После каждого закрытия программы dummy имитируется завершение процесса, после которого запускается следующий элемент в очереди:
```
xml version="1.0" encoding="utf-8"?
```
Очередь работает!
Результаты
----------
Видавший виды powershell-скрипт был отправлен на свалку. Новое приложение полностью написано на C#. У нас появилась возможность использовать rulesets — правила, которые делали выборку файлов по специальным критериям и вставляли их только в определенные места в setup-скрипте. За счет новой системы хеширования решили проблему выборки файлов только по имени и по размеру — она возникала, когда при одинаковом имени и размере файлы отличались по контенту. Новая программа сборки апдейтов не рассматривает файлы как файлы — она их рассматривает как MD5-хеши и создает хеш-таблицу, в которой каждому набору файлов в определенном каталоге соответствовал свой уникальный хеш.
*Скриншот финального решения, которое мы используем в нашей работе*
Небольшие доработки в решение вносятся постоянно, но мы уже решили самую главную проблему — новый подход позволил полностью убрать человеческий фактор и избавить себя от кучи костылей. Система получилась настолько универсальной, что в ближайшее время будет использоваться для сборки хотфиксов, где меняется несколько файлов. Все это будет работать через веб-интерфейс с помощью другого приложения.
В ходе проекта я разобрался, как работать с XML, с файлами конфигурации, с файловой системой. Теперь же у меня есть свои наработки, которые я успешно использую в других проектах. Для наглядности статьи я убрал большое количество кода, которое может отвлечь от сути, и произвел серьезный рефакторинг.
Надеюсь, эта статья поможет вам в работе с WCF-сервисами, с таймерами в теле сервисов и реализации очередей через XML-файлы. Работу приложений и очереди вы можете посмотреть на видео:
**P.S.** Хочу выразить благодарность Виктору Бородичу, чьи советы очень помогли довести данную систему до рабочего вида. Виктор доказывает, что если посадить рядом опытных разработчиков и джуниоров, то качество кода у последних обязательно вырастет. | https://habr.com/ru/post/417701/ | null | ru | null |
# Кто есть кто в кампании за отмену Столлмана
Кампания "за отмену Столлмана", начавшаяся с [публикации в Medium](https://selamjie.medium.com/remove-richard-stallman-fec6ec210794) предоставляет нам множество интересных данных. Так как подписание [открытых писем за отмену](https://rms-open-letter.github.io/) и [в поддержку Столлмана](https://rms-support-letter.github.io/) осуществляется на гитхабе, мы можем проанализировать некоторые характеристики обеих сторон, используя статистические данные, которые доступны через API.
Этому помогает то, что на гитхабе затруднительно редактировать данные "задним числом" без потери новых подписей.
Следующие предположения можно проверить ("X" может быть как предложением отменить Столлмана, так и выражением его поддержки):
* Противники X чаще ассоциированы с крупными компаниями чем сторонники
* Сторонники X чаще и больше коммитят код и этим более полезны сообществу СПО.
* Противники X значимо реже коммитят в репозитории со свободными лицензиями.
* Противники X предпочитают Rust (или JS), сторонники предпочитают C (или C++, Python)
* Противники X в большей степени социально активны, у них есть аккаунты в соц. сетях, твиттере, они часто пишут.
* Противники X не коммитят код по выходным (работают только в рабочее время, не энтузиасты)
* Большинство противников X зарегистрированы на гитхабе менее полугода назад
Мы попытались проверить некоторые из этих предположений и приглашаем всех, кто заинтересовался, проверить остальные предположения и вносить (и проверять) любые другие.
Мы создали [репозиторий](https://github.com/imitron/rms-analytics/), в котором будет проходить работа. В нем же лежит эта статья, ее копия на Хабре будет актуализироваться по мере добавления пулл-реквестов. Присоединяйтесь к исследованию!
Далее будут детали.
Замечание о научной честности
-----------------------------
Любые гипотезы и любые проверяемые подтверждения будут приняты и добавлены в статью. Мы не считаем возможным скрывать данные, которые противоречат нашей позиции. Все интерпретации будут также добавлены. Мы приглашаем к совместной работе сторонников обеих позиций (да, это возможно). [Репозиторий для совместной работы](https://github.com/imitron/rms-analytics).
Кампания за отмену Столлмана управляется из одного центра
---------------------------------------------------------
Репозиторий противников Столлмана был создан 23 Mar 2021 10:42:36 AM PDT, сторонников - 23 Mar 2021 01:23:39 PM PDT. Видно, что репозиторий противников практически сразу начал активно набирать звезды. У репозитория сторонников был длительный период, когда звезды набирались медленно, но потом (видимо после публикации в соц сетях) процесс пошел много быстрее и количество звезд быстро обогнало противников.
Код
```
$ cat get-stars.sh
#!/bin/bash
set -ue
page=1
owner_repo=$1
while true; do
curl -s -H "Authorization: token $GITHUB_OAUTH_" \\
-H "Accept: application/vnd.github.v3.star+json" \\
""| \\
jq -r .[].starred\_at\_ | grep . || break
((page++)) || true
done
$ echo "epoch,con" >con.stars.csv
$ ./get-stars.sh 'rms-open-letter/rms-open-letter.github.io'|while read a; do date -d $a +%s; done|sort -n|cat -n|awk '{print $2","$1}' >>con.stars.csv
$ echo "epoch,pro" >pro.stars.csv
$ ./get-stars.sh 'rms-support-letter/rms-support-letter.github.io'|while read a; do date -d $a +%s; done|sort -n|cat -n|awk '{print $2","$1}' >>pro.stars.csv
$ join -t, -e '' -o auto -a1 -a2 con.stars.csv pro.stars.csv >joined.stars.csv
```
При этом спустя много дней репозиторий сторонников продолжает набирать звезды, в то время как у противников процесс сильно замедлился. Из этого можно сделать предположение, что процесс раскрутки инициативы противников был заранее интенсифицирован рассылкой писем и сообщений в социальных сетях, и замедлился как только доступная аудитория была выбрана и/или промоушн прекратился.
Инициатива сторонников, по-видимому, децентрализована. Этим можно объяснить медленный темп набора звезд в начале и то, что звезды до сих пор добавляются - новости расходятся от свежих вовлеченных участников.
Активность в репозиториях сторонников и противников Столлмана
-------------------------------------------------------------
На момент написания этой статьи было 1345 комиттеров противников и 5000+ коммиттеров сторонников. Скачиваем историю коммитов:
Код
```
$ cat get-commits.py
#!/usr/bin/env python
import os
import requests
import json
import sys
repo = sys.argv[1]
headers = {'Authorization': 'token {}'.format(os.environ["GITHUB_OAUTH"])}
commits = []
page = 0
while page < 300:
page += 1
data = requests.get('https://api.github.com/repos/{}/commits?per_page=100&page={}'.format(repo, page), headers=headers).json()
if len(data) == 0:
break
commits += data
print(json.dumps(commits, indent=4))
$ ./get-commits.py 'rms-open-letter/rms-open-letter.github.io' >con.commits.json
$ ./get-commits.py 'rms-support-letter/rms-support-letter.github.io' >pro.commits.json
```
Посмотрим на изменение количества коммитов от времени с начала кампаний:
Код
```
$ jq -r .[].commit.author.date pro.commits.json|sort -u|cat -n|awk '{print $2","$1}'|sed -e 's/T/ *' -e 's/Z/*' >pro.commits.csv
$ jq -r .[].commit.author.date con.commits.json|sort -u|cat -n|awk '{print $2","$1}'|sed -e 's/T/ *' -e 's/Z/*' >con.commits.csv
$ join -t, -e '' -o auto -a1 -a2 con.commits.csv pro.commits.csv >joined.commits.csv
```
Видно, что репозиторий сторонников гораздо активнее. Коммитов в репозиторий противников за последнее время практически не было. Репозиторий сторонников продолжает обновляться.
Противники Столлмана ведут кампанию в основном в рабочие дни
------------------------------------------------------------
Посмотрим на распределение коммитов по дням недели.
Код
```
$ jq -r .[].commit.author.date con.commits.json |./weekday-from-date.py >con.rms_commits.csv
$ jq -r .[].commit.author.date pro.commits.json |./weekday-from-date.py >pro.rms_commits.csv
$ join -t, con.rms_commits.csv pro.rms_commits.csv >joined.rms_commits.csv
```
Aктивность противников Столлмана сильно снижается на выходных, зато в среду мы видим пик. Это можно объяснить тем, что во многих компаниях среда это no meeting day.
Активность сторонников значительно менее вариативная. Коммиты совершаются во все дни недели
Противники Столлмана чаще имеют заполненные профили социальных сетей
--------------------------------------------------------------------
Скачиваем индивидуальные данные для каждого юзера, а также его последние 100 действий:
Код
```
$ jq -r .[].author.login con.commits.json|sort -u >con.logins
$ jq -r .[].author.login pro.commits.json|sort -u >pro.logins
$ cat get-user-events-data.sh
#!/bin/bash
set -ue
script_dir=$(dirname $(realpath $0))
get_data() {
local data_dir=$script_dir/$1 userdata events
for x in $(cat $1.logins); do
userdata=$data_dir/$x.userdata
[ -r $userdata ] && continue
curl -s -H "Authorization: token $GITHUB_OAUTH" "" >$userdata
sleep 1
events=$data\_dir/$x.events
[ -r $events ] && continue
curl -s -H "Authorization: token $GITHUB\_OAUTH" "" >$events
sleep 1
done
}
get\_data $1
$ ./get-user-events-data.sh con
$ ./get-user-events-data.sh pro
```
Пример данных юзера, выгруженных из гитхаба:
Код
```
{
"login": "zyxw59",
"id": 3157093,
"node_id": "MDQ6VXNlcjMxNTcwOTM=",
"avatar_url": "https://avatars.githubusercontent.com/u/3157093?v=4",
"gravatar_id": "",
"url": "https://api.github.com/users/zyxw59",
"html_url": "https://github.com/zyxw59",
"followers_url": "https://api.github.com/users/zyxw59/followers",
"following_url": "https://api.github.com/users/zyxw59/following{/other_user}",
"gists_url": "https://api.github.com/users/zyxw59/gists{/gist_id}",
"starred_url": "https://api.github.com/users/zyxw59/starred{/owner}{/repo}",
"subscriptions_url": "https://api.github.com/users/zyxw59/subscriptions",
"organizations_url": "https://api.github.com/users/zyxw59/orgs",
"repos_url": "https://api.github.com/users/zyxw59/repos",
"events_url": "https://api.github.com/users/zyxw59/events{/privacy}",
"received_events_url": "https://api.github.com/users/zyxw59/received_events",
"type": "User",
"site_admin": false,
"name": "Emily Crandall Fleischman",
"company": "Commure",
"blog": "",
"location": null,
"email": "emilycf@mit.edu",
"hireable": null,
"bio": null,
"twitter_username": null,
"public_repos": 24,
"public_gists": 0,
"followers": 2,
"following": 12,
"created_at": "2012-12-31T05:33:30Z",
"updated_at": "2021-03-14T01:53:51Z"
}
```
В таблице ниже приводится процент пользователей, у которых заполнены поля twitter\_username, company, bio и blog:
| | | |
| --- | --- | --- |
| поле | противник | сторонник |
| twitter\_username | 31% | 8% |
| company | 48% | 20% |
| bio | 53% | 31% |
| blog | 63% | 31% |
Противники Столлмана кажутся более социально активными. Возможно сторонники Столлмана реже участвуют в социальной активности (ведут блог, твиттер, страничку в социальных сетях.
Противники Столлмана активнее на гитхабе
----------------------------------------
Посмотрим на поля public\_repos, public\_gists, followers и following:
| | | |
| --- | --- | --- |
| поле | противник | стронник |
| | среднее | медиана | среднее | медиана |
| public\_repos | 62 | 34 | 21 | 9 |
| public\_gists | 18 | 4 | 4 | 0 |
| followers | 105 | 23 | 16 | 2 |
| following | 30 | 8 | 14 | 1 |
Противники Столлмана активнее сторонников на гитхабе. У них в среднем больше followers, публичных репозиториев, они также чаще фолловят другие репозитории. Также у противников соотношение followers / following больше 3, в то время как у сторонников оно составляет 1.1.
Противники Столлмана не коммитят в гитхаб на выходных
-----------------------------------------------------
Воспользуемся полем events\_url, чтобы скачать историю действий юзеров.
Теперь давайте посмотрим на действия юзеров. Данных скачано много и анализировать их можно множеством способов. Можно проверить активность юзеров по дням недели, чтобы проверить как эти данные коррелируют с активностью, специфичной для репозиториев "за" и "против" Столлмана.
Код
```
cat weekday-from-date.py
#!/usr/bin/env python
import datetime
import sys
out = [0] \* 7
total = 0
for line in sys.stdin.readlines():
weekday = datetime.datetime.strptime(line.strip(), '%Y-%m-%dT%H:%M:%SZ').weekday()
out[weekday] += 1
total += 1
for day, count in enumerate(out):
print("{},{}".format(day, count / total))
$ jq -r .[].createdat con/\*.events|./weekday-from-date.py >con.eventday.normalized.csv
$ jq -r .[].createdat pro/\*.events|./weekday-from-date.py >pro.eventday.normalized.csv
$ join -t, con.eventday.normalized.csv pro.eventday.normalized.csv
```
Видно, что тренд сохранился: активность противников резко снижается на выходных. Можно предполагать, что они используют гитхаб на работе и, возможно, работают над open source проектами за зарплату. Если это предположение верно, их мнение может быть обусловлено отбором, который проводят компании, нанимающие программистов для работы над open source проектами. | https://habr.com/ru/post/554724/ | null | ru | null |
# Создаем интернет-магазин на Nuxt.js 2 пошаговое руководство Часть 3
Как и обещал продолжаем.
В этой части:
* создадим блоки товаров "С этим товаром также покупают" и "Интересные товары"
* создадим иконку корзины с количеством товаров
* подключим модальное окно с товарами в корзине
* перепишем всю логику store
### Создадим блоки товаров типа: "С этим товаром также покупают"
Тут немножко поговорим об асинхронных запросах в Nuxt. Допустим мы хотим создать такой блок с товарами. Соответственно сервер должен уметь как-то генерировать список товаров и мы его загрузим, но вопрос куда?
Если мы создадим компонент типа **AlsoBuyList** то у него не будет метода **asyncData**, и мы не сможем его отрендерить на сервере. Если допустим для вас это не проблема, что в html который отдаёт сервер не будет этих блоков, то тогда вместо asyncData можно использовать **mounted** (или отложить загрузку до момента пока компонент будет в области видимости).
Но допустим мы хотим True SSR, тогда как вариант мы можем пользоваться методом asyncData родительской страницы. Это усложняет проект, так как где бы мы не хотели отрендерить список товаров, родитель должно контролировать эти списки и получать для них данные. Ужасно, медленно, неудобно, но мы получим труSSR.
Теперь поехали это делать.
Приводим наш Vuex к такому виду:
**index.js**
```
// function for Mock API
const sleep = m => new Promise(r => setTimeout(r, m))
const sampleSize = require('lodash.samplesize')
const categories = [
{
id: 'cats',
cTitle: 'Котики',
cName: 'Котики',
cSlug: 'cats',
cMetaDescription: 'Мета описание',
cDesc: 'Описание',
cImage: 'https://source.unsplash.com/300x300/?cat,cats',
products: []
},
{
id: 'dogs',
cTitle: 'Собачки',
cName: 'Собачки',
cSlug: 'dogs',
cMetaDescription: 'Мета описание',
cDesc: 'Описание',
cImage: 'https://source.unsplash.com/300x300/?dog,dogs',
products: []
},
{
id: 'wolfs',
cTitle: 'Волчки',
cName: 'Волчки',
cSlug: 'wolfs',
cMetaDescription: 'Мета описание',
cDesc: 'Описание',
cImage: 'https://source.unsplash.com/300x300/?wolf',
products: []
},
{
id: 'bulls',
cTitle: 'Бычки',
cName: 'Бычки',
cSlug: 'bulls',
cMetaDescription: 'Мета описание',
cDesc: 'Описание',
cImage: 'https://source.unsplash.com/300x300/?bull',
products: []
}
]
function getProductsByIds (products, productsImages, ids) {
const innerProducts = products.filter(p => p.id === ids.find(id => p.id === id))
if (!innerProducts) return null
return innerProducts.map(pr => {
return {
...pr,
images: productsImages.find(img => img.id === pr.id).urls,
category: categories.find(cat => cat.id === pr.category_id)
}
})
}
function getProduct (products, productsImages, productSlug) {
const innerProduct = products.find(p => p.pSlug === productSlug)
if (!innerProduct) return null
return {
...innerProduct,
images: productsImages.find(img => img.id === innerProduct.id).urls,
category: categories.find(cat => cat.id === innerProduct.category_id)
}
}
function addProductsToCategory (products, productsImages, category) {
const categoryInner = { ...category, products: [] }
products.map(p => {
if (p.category_id === category.id) {
categoryInner.products.push({
id: p.id,
pName: p.pName,
pSlug: p.pSlug,
pPrice: p.pPrice,
image: productsImages.find(img => img.id === p.id).urls
})
}
})
return categoryInner
}
function getBreadcrumbs (pageType, route, data) {
const crumbs = []
crumbs.push({
title: 'Главная',
url: '/'
})
switch (pageType) {
case 'category':
crumbs.push({
title: data.cName,
url: `/category/${data.cSlug}`
})
break
case 'product':
crumbs.push({
title: data.category.cName,
url: `/category/${data.category.cSlug}`
})
crumbs.push({
title: data.pName,
url: `/product/${data.pSlug}`
})
break
default:
break
}
return crumbs
}
export const state = () => ({
categoriesList: [],
currentCategory: {},
currentProduct: {
alsoBuyProducts: [],
interestingProducts: []
},
bredcrumbs: []
})
export const mutations = {
SET_CATEGORIES_LIST (state, categories) {
state.categoriesList = categories
},
SET_CURRENT_CATEGORY (state, category) {
state.currentCategory = category
},
SET_CURRENT_PRODUCT (state, product) {
state.currentProduct = product
},
SET_BREADCRUMBS (state, crumbs) {
state.bredcrumbs = crumbs
},
RESET_BREADCRUMBS (state) {
state.bredcrumbs = []
},
GET_PRODUCTS_BY_IDS () {}
}
export const actions = {
async getProductsListByIds ({ commit }) {
// simulate api work
const [products, productsImages] = await Promise.all(
[
this.$axios.$get('/mock/products.json'),
this.$axios.$get('/mock/products-images.json')
]
)
commit('GET_PRODUCTS_BY_IDS')
const idsArray = (sampleSize(products, 5)).map(p => p.id)
return getProductsByIds(products, productsImages, idsArray)
},
async setBreadcrumbs ({ commit }, data) {
await commit('SET_BREADCRUMBS', data)
},
async getCategoriesList ({ commit }) {
try {
await sleep(50)
await commit('SET_CATEGORIES_LIST', categories)
} catch (err) {
console.log(err)
throw new Error('Внутреняя ошибка сервера, сообщите администратору')
}
},
async getCurrentCategory ({ commit, dispatch }, { route }) {
await sleep(50)
const category = categories.find((cat) => cat.cSlug === route.params.CategorySlug)
// simulate api work
const [products, productsImages] = await Promise.all(
[
this.$axios.$get('/mock/products.json'),
this.$axios.$get('/mock/products-images.json')
]
)
const crubms = getBreadcrumbs('category', route, category)
await dispatch('setBreadcrumbs', crubms)
await commit('SET_CURRENT_CATEGORY', addProductsToCategory(products, productsImages, category))
},
async getCurrentProduct ({ commit, dispatch }, { route }) {
await sleep(50)
const productSlug = route.params.ProductSlug
// simulate api work
const [products, productsImages, alsoBuyProducts, interestingProducts] = await Promise.all(
[
this.$axios.$get('/mock/products.json'),
this.$axios.$get('/mock/products-images.json'),
dispatch('getProductsListByIds'),
dispatch('getProductsListByIds')
]
)
const product = getProduct(products, productsImages, productSlug)
const crubms = getBreadcrumbs('product', route, product)
await dispatch('setBreadcrumbs', crubms)
await commit('SET_CURRENT_PRODUCT', { ...product, alsoBuyProducts, interestingProducts })
}
}
```
**getProductsByIds** симуляция работы на api сервер
**getProductsListByIds** action который симулирует запрос к серверу. В данном случае он рандомно выбирает 5 товаров
```
await sleep(50)
const productSlug = route.params.ProductSlug
// simulate api work
const [products, productsImages, alsoBuyProducts, interestingProducts] = await Promise.all(
[
this.$axios.$get('/mock/products.json'),
this.$axios.$get('/mock/products-images.json'),
dispatch('getProductsListByIds'),
dispatch('getProductsListByIds')
]
)
const product = getProduct(products, productsImages, productSlug)
const crubms = getBreadcrumbs('product', route, product)
dispatch('setBreadcrumbs', crubms)
commit('SET_CURRENT_PRODUCT', { ...product, alsoBuyProducts, interestingProducts })
```
Этот код раньше у нас получал только инфу о товаре. Теперь же он будет получать инфу и про эти блоки **alsoBuyProducts** **interestingProducts** и класть её в товар.
Тут можно увидеть что мы батчим сразу и запросы к серверу и другие actions, которые делают запросы. Это лучше чем писать всё в стиле:
```
const products = await this.$axios.$get('/mock/products.json')
const productsImages = await this.$axios.$get('/mock/products-images.json')
const alsoBuyProducts = await dispatch('getProductsListByIds')
const interestingProducts = await dispatch('getProductsListByIds')
```
Так как в этом случае браузер будет выполнять их по очереди.
После этого на странице товара получаем такой объект из стора:
Дальше дело техники, на странице товара выводим
```
С этим товаром также покупают
-----------------------------
Возможно вам будет интересно
----------------------------
```
И создаём компонент **ProductsList**
**ProductsList.vue**
```
{{ product.pName }}
![]()
Цена {{ product.pPrice }}
import BuyButton from '~~/components/common/BuyButton'
export default {
components: {
BuyButton
},
props: {
products: {
type: Array,
default: () => []
}
}
}
.wrapper {
display: flex;
flex-wrap: wrap;
> div {
margin: 1em;
}
p {
max-width: 270px;
height: 35px;
}
}
.image {
width: 300px;
height: 300px;
object-fit: cover;
}
```
Он просто получает массив товаров и рендерит его. Получаем в результате:
Вы готовы к настоящему хардкору?
--------------------------------
Честно говоря, первый раз делаю корзину client-side only, поэтому простите мои ошибки (буду рад советам в комментариях). Но чисто с академической стороны (для демонстрации) думаю, терпимо.
Для реализации модалки с корзиной мне понадобилось изменить и создать в общей сложности 24 файла!
Схема будет примерно такая:
1. Храним в браузере id и количество товара и их порядковый номер, которые мы добавили в корзину.
2. Пишем action, который будет получать массив id товаров и отдавать мета-инфу о товарах (название, цену, картинки и тд.).
3. Пишем getter, который будет объеденять товар из корзины и мета-информацию.
4. Наш vuex store и localstorage по умолчанию уже синхронизован, поэтому мы нигде не будем делать запрос к api для получения корзины.
5. Пишем 100500 компонентов для рендера.
6. Так как сервер ничего не знает о корзине, всё что связано с данными из корзины мы оборачиваем в , чтобы не было ошибки что DOM не совпадает (на сервере и клиенте).
### Теперь о реализации
В модуле корзины будете 2 массива:
* Первый **products** с такой структурой { qty, productId, order }
* Второй **metaProducts** здесь будет информация о товарах полученная от api (название, цена, картинки и тд.)
Первый и второй массив сами по себе бесполезны для рендеринга, мы хотим получить 1 массив где в каждом объекте сразу будет вся нужная информация. Для этого отлично подойдёт getter. Гетеры это аналог computed в компонентах, реагируют на изменения данных на которые они полагаются.
Напишем такой геттер
```
getProductsInCart: state => {
const products = []
state.products.map(p => {
const metaProduct = state.metaProducts.find(mp => mp.id === p.productId)
if (metaProduct) {
products.push({ ...p, meta: metaProduct })
}
})
return products.sort((a, b) => a.order - b.order)
}
```
Он берёт первый массив и проходит по нему. Если во втором массиве есть соответствующая мета-информация, то мы заносим объект вида
```
{ ...p, meta: metaProduct }
```
где **p** это { qty, productId, order }, в **const products**
После обхода всех элементов мы получаем новый массив products, который сортируем по **order** и возвращаем.
Вы наверное задаётесь вопросом, зачем такой странный **merge**. Дело в том, что метаинформация подтягивается от api отдельным запросом, после каждого изменения первого массива **products**. А это означает, что возникает такая ситуация, когда в первом массиве уже есть товар, а метаинформация ещё не загружена. Это легко может привести к ошибкам рендера, так как функции разных компонентов ожидают получить товар и его мета-данные.
Таким образом, только, когда мета-данные будут получены от api, этот геттер сделает merge двух массивов. Это существенно облегчает последующий рендер.
### Пишем mutations
```
export const mutations = {
ADD_PRODUCT (state, productId) {
// if cart doesn't have product add it
if (!state.products.find(p => productId === p.productId)) {
state.products = [...state.products, { productId: productId, qty: 1, order: findMax(state.products, 'order') + 1 }]
}
},
REMOVE_PRODUCT (state, productId) {
state.products = Array.from(state.products.filter(prod => prod.productId !== productId))
},
SET_PRODUCT_QTY (state, { productId, qty }) {
state.products = [
...state.products.filter(prod => prod.productId !== productId),
{ ...state.products.find(prod => prod.productId === productId), qty }
]
},
SET_PRODUCTS_BY_IDS (state, products) {
state.metaProducts = products
}
}
```
**ADD\_PRODUCT** — убеждается, что товара ещё нет, добавляет его с **qty = 1** (то есть количество товара в корзине по умолчанию 1 шт.) и присваивает ему максимальный порядковый номер **+ 1**.
Где за поиск этого номера отвечает простая функция
```
const findMax = (array, field) => {
if (!array || array.lenght === 0) return 1
return Math.max(...array.map(o => o[field]), 0)
}
```
Которая получает массив для перебора и поле объекта, которое будет сравнивать с одноименными полями других объектов массива.
**REMOVE\_PRODUCT** — убирает товар
**SET\_PRODUCT\_QTY** — меняем количество товара в корзине
**SET\_PRODUCTS\_BY\_IDS** — присваивает мета-инфу
### Пишем actions
```
export const actions = {
async setProductsListByIds ({ commit, state }) {
// simulate api work
await sleep(50)
const [products, productsImages] = await Promise.all(
[
this.$axios.$get('/mock/products.json'),
this.$axios.$get('/mock/products-images.json')
]
)
const productsIds = state.products.map(p => p.productId)
await commit('SET_PRODUCTS_BY_IDS', mock.getProductsByIds(products, productsImages, productsIds))
},
async addProduct ({ commit, dispatch }, productId) {
// simulate api work
await sleep(50)
await commit('ADD_PRODUCT', productId)
await dispatch('setProductsListByIds')
},
async removeProduct ({ commit, dispatch }, productId) {
// simulate api work
await sleep(50)
await commit('REMOVE_PRODUCT', productId)
await dispatch('setProductsListByIds')
},
async setProductQuantity ({ commit, dispatch }, { productId, qty }) {
// simulate api work
await sleep(50)
await commit('SET_PRODUCT_QTY', { productId, qty })
await dispatch('setProductsListByIds')
}
}
```
После каждого изменения товара мы вызываем **await dispatch('setProductsListByIds')** то есть загружаем мета-информацию от api.
Причина почему после каждого в том, что теоретически на api сервере может быть сложная система цен, которая зависит от количества товара в корзине, суммы заказа, количества позиций и так далее. И даже не смотря на то, что сервер не хранить сейчас информацию о корзине, это небольшой так задел на будущее.
### Создаём модальное окно
Создаём новый плагин vue-modal.js
```
import Vue from 'vue'
import VModal from 'vue-js-modal'
export default async (context, inject) => {
Vue.use(VModal)
}
```
и подключаем его глобально на весь проект в **nuxt.config.js**
```
{ src: '~~/plugins/vue-modal.js', mode: 'client' },
```
#### Создаём компонент
**mode: 'client'** говорит о том, что нам не нужно его инициализировать на сервере
Создаём папку components/modals и файл CastomerCartModal.vue
**CastomerCartModal.vue**
```
Cart
Товаров пока нет, но это легко можно исправить :)
You've added
Previously added products
Total: {{ getAmount | round }}
Close
To checkout
import { mapGetters } from 'vuex'
import ProductsList from '~~/components/cart/ProductsList.vue'
import CloseOrDeleteButton from '~~/components/common/input/CloseOrDeleteButton.vue'
import round from '~~/mixins/round.js'
export default {
components: {
ProductsList,
CloseOrDeleteButton
},
mixins: [round],
data () {
return {
addedProduct: null,
defaults: {
addedProduct: null
}
}
},
computed: {
...mapGetters({
getProductsInCart: 'cart/getProductsInCart'
}),
getAddedProduct () {
const product = this.getProductsInCart.find(
prod => prod.productId === this.addedProduct
)
if (product) {
return [product]
} else {
return null
}
},
getAmount () {
let amount = 0
if (this.getProductsInCart && this.getProductsInCart.length > 0) {
this.getProductsInCart.forEach(product => {
amount +=
parseFloat(product.meta.pPrice) \*
parseInt(product.qty)
})
return amount
} else {
return 0
}
},
getProducts () {
if (this.addedProduct) {
return this.getProductsInCart.filter(
prod => prod.productId !== this.addedProduct
)
} else {
return this.getProductsInCart
}
}
},
watch: {
$route: function () {
this.$modal.hide('customer-cart')
},
getProductsInCart: function (newVal, oldVal) {
if (oldVal.length > 0) {
if (this.getProductsInCart.length === 0) {
this.$modal.hide('customer-cart')
}
}
}
},
methods: {
beforeOpen (event) {
if (!event.params) {
event.params = {}
}
if (event.params.addedProduct) {
this.addedProduct = event.params.addedProduct
} else {
this.addedProduct = this.defaults.addedProduct
}
}
}
}
.submit-error {
font-weight: 500;
color: #de0d0d;
// font-weight: 300;
font-size: 0.7em;
}
.modal-wrapper {
// border: 3px solid $accent-border-color;
background: #fff;
overflow-y: scroll;
// margin-top: 20px;
height: 100%;
display: flex;
flex-direction: column;
align-items: stretch;
}
.bottom {
flex-shrink: 0;
margin-bottom: 30px;
display: flex;
justify-content: flex-start;
// align-items: flex-start;
flex-direction: column;
margin-top: 16px;
@media screen and (min-width: 1024px) {
justify-content: space-between;
flex-direction: row;
align-items: flex-end;
padding-bottom: 50px;
}
.close-button {
display: none;
@media screen and (min-width: 1024px) {
display: block;
}
}
.amount-block {
.checkout-button {
margin-top: 5px;
width: 100%;
display: flex;
@media screen and (min-width: 640px) {
width: auto;
}
}
}
button.bttn-material-flat {
font-size: 1rem;
@media screen and (min-width: 1024px) {
font-size: 1.4rem;
}
}
}
p.added-product {
font-size: 1.6rem;
margin-bottom: 1rem;
}
.wrapper {
// height: 100%;
flex-grow: 1;
position: relative;
}
.header-block {
flex-shrink: 0;
// padding: 10px 20px;
margin-top: 20px;
// background: #f8fafb;
// font-size: 1.6rem;
position: relative;
margin-bottom: 1rem;
.close {
position: absolute;
right: 12px;
top: 0;
}
}
.pop-out-enter-active,
.pop-out-leave-active {
transition: all 0.5s;
}
.pop-out-enter,
.pop-out-leave-active {
opacity: 0;
transform: translateY(24px);
}
```
Теперь подробнее об этом компоненте.
Весь код обвёрнут в , чтобы Vue не пытался его рендерить на сервере.
#### modal
* **name="customer-cart"** имя модального окна должно быть уникальным, позволяет открывать/закрывать окно из любого компонента (так как мы ранее подключили этот плагин глобально)
* **:adaptive="true"** делает его ширину не 95%, а адаптивной в зависимости от содержимого и ширины экрана (но когда экран маленький, она будет 95%)
* **:scrollable="true"** лочить body запрещая тем самым скорлл страницы.
* **:pivot-y="0.5"** делаем окно по центру
* **:reset="true"** пересоздаём компонент каждый раз после закрытия (устраняет баги всякого рода)
* **classes="v--modal-customer-cart"** указываем свой стиль
* **@before-open="beforeOpen"** эта функция вызывается каждый раз перед открытием модалки (об этом чуть позже)
```
```
**CloseOrDeleteButton** это просто svg иконка (для удобства спрятана в отдельный компонент.
**[click](https://habr.com/ru/users/click/)="$modal.hide('customer-cart')"** по клику на кнопку закрыть, соответственно закрываем модальное окно по имени
```
You've added
Previously added products
```
**ProductsList** это компонент с товарами для корзины, который мы пока не создали.
Когда мы нажимаем на кнопку купить, товар, который мы только что добавили, стоит особнячком от всех с надписью **You've added**, а остальные товары идут потом после **Previously added products**. Но если мы просто нажали на иконку корзины (то есть не добавляли товар, а захотели просмотреть, то **getAddedProduct** будет **null** и соответственно без никаких лишних надписей мы воводим все товары.
**getAddedProduct** и **getProducts** — это простые обвёртки, которые в зависимости от свойства **addedProduct** меняют своё содержимое на уместное.
```
Total: {{ getAmount | round }}
```
Этот странный символ | (пайп) на самом деле говорит, что нужно вызвать функцию round (которая округляет число до двух знаков) и возвращает значение.
Эту функцию для удобства переиспользования мы выделим в миксин **mixins\round.js**
```
export default {
filters: {
round (num) {
return Math.round((num + Number.EPSILON) * 100) / 100
}
}
}
```
И подключим миксин для этого компонента
```
import round from '~~/mixins/round.js'
...
mixins: [round]
```
При открытии модального окна мы можем указать дополнительные параметры, например
```
this.$modal.show('customer-cart', { addedProduct: this.product.id })
```
Объект указанный вторым аргументом передаётся в метод **beforeOpen**
```
methods: {
beforeOpen (event) {
if (!event.params) {
event.params = {}
}
if (event.params.addedProduct) {
this.addedProduct = event.params.addedProduct
} else {
this.addedProduct = this.defaults.addedProduct
}
}
}
```
Где мы, если есть аргументы присваиваем их в **data()**
```
data () {
return {
addedProduct: null,
defaults: {
addedProduct: null
}
}
},
```
После открытия окна мы должны получить данные из store.
```
import { mapGetters } from 'vuex'
...
computed: {
...mapGetters({
getProductsInCart: 'cart/getProductsInCart'
}),
...
```
Где как и в случае с actions указываем имя модуля через слеш.
Из-за того что мы используем "хитрую" логику для вывода товаров (в зависимости от того, добавил пользователь товар только что или просто открыл посмотреть) мы не используем **getProductsInCart** напрямую, а пишем две обвёртки.
```
getAddedProduct () {
const product = this.getProductsInCart.find(
prod => prod.productId === this.addedProduct
)
if (product) {
return [product]
} else {
return null
}
},
getProducts () {
if (this.addedProduct) {
return this.getProductsInCart.filter(
prod => prod.productId !== this.addedProduct
)
} else {
return this.getProductsInCart
}
}
```
Если мы нажмём на какой-то товар, мы хотим чтобы модальное окно закрылось (при переходе на страницу этого товара). Реализуем это так:
```
watch: {
$route: function () {
this.$modal.hide('customer-cart')
}
```
То есть при смене объекта **route** закрываем модалку.
Также мы следим за количеством товаров в коризне, если пользователь удалил последний товар, то мы закрываем модалку.
```
watch: {
...
getProductsInCart: function (newVal, oldVal) {
if (oldVal.length > 0) {
if (this.getProductsInCart.length === 0) {
this.$modal.hide('customer-cart')
}
}
}
...
```
### Создаём ProductsList
В нём нужны такие функции:
* удаление товара
* изменения количества товара (с debounce то есть с умной задержкой, если пользователь начнёт тыкать по стрелке вверх)
* подсчет суммы
**ProductsList.vue**
```
![]()
{{ product.meta.pName }}
Price:
{{ product.meta.pPrice }}
Quantity:
Amount:
{{ (product.meta.pPrice \* product.qty) | round }}
import CloseOrDeleteButton from '~~/components/common/input/CloseOrDeleteButton.vue'
import round from '~~/mixins/round'
import { mapActions } from 'vuex'
import debounce from 'lodash.debounce'
export default {
components: {
CloseOrDeleteButton
},
mixins: [round],
props: {
productsFromCart: {
type: Array,
default: () => []
}
},
methods: {
...mapActions({
setProductQuantity: 'cart/setProductQuantity',
removeProduct: 'cart/removeProduct'
}),
onRemoveClickHandler (product) {
this.removeProduct(product.productId)
},
onQuantityChangeHandler: debounce(function onQuantityChangeHandler (e, product) {
const qty = e.target.value
this.setProductQuantity({ productId: product.productId, qty })
}, 400)
}
}
.input {
height: 20px;
}
.remove {
top: -15px;
position: absolute;
left: -30px;
z-index: 1;
}
.wrapper {
display: flex;
flex-wrap: wrap;
flex-direction: column;
.product {
position: relative;
margin: 1em;
display: flex;
flex-direction: row;
\* {
margin-right: 10px;
}
.pName {
width: 150px;
}
}
p {
max-width: 270px;
height: 35px;
}
}
.image {
width: 75px;
height: 75px;
object-fit: cover;
}
```
Здесь нам нужны 2 actions для удаления и изменения количества
```
...mapActions({
setProductQuantity: 'cart/setProductQuantity',
removeProduct: 'cart/removeProduct'
}),
```
При изменении количества мы вызываем
```
onQuantityChangeHandler: debounce(function onQuantityChangeHandler (e, product) {
const qty = e.target.value
this.setProductQuantity({ productId: product.productId, qty })
}, 400)
```
Которая получает текущее значение **e.target.value** и вызывает **setProductQuantity**. И конечно же всё обвернём в **debounce**, который я предварительно скачал из lodash
```
import debounce from 'lodash.debounce'
```
Так же тут мы подключаем миксин **round** для округления суммы и мой компонент **CloseOrDeleteButton**
Который выглядит так:
**CloseOrDeleteButton.vue**
```
import SvgClose from '~~/assets/svg/baseline-close-24px.svg?inline'
export default {
components: {
SvgClose
},
props: {
buttonType: {
type: String,
default: 'close'
}
}
}
.svg-icon-delete {
// background: #ddd;
fill: #ffb2a9;
border: 3px solid #ffb2a9;
transition: all .3s ease;
width: 20px;
height: 20px;
&:hover {
// background: #ddd;
fill: #fb3f4c;
border-color: #fb3f4c;
}
@media (--mobile) {
width: 20px;
height: 20px;
border-width: 3px;
}
}
.svg-icon-close {
background: hsl(0, 0%, 60%);
fill: #fff;
border: 8px solid hsl(0, 0%, 60%);
width: 20px;
height: 20px;
&:hover {
background: hsl(0, 0%, 33%);
fill: #fff;
border-color :hsl(0, 0%, 33%);
}
}
.svg-icon-block {
display: block;
cursor: pointer;
}
svg {
border-radius: 100%;
opacity: 0.7;
line-height: 0;
box-sizing: content-box;
// // noselect
// -webkit-user-select: none; /\* webkit (safari, chrome) browsers \*/
// -moz-user-select: none; /\* mozilla browsers \*/
// -khtml-user-select: none; /\* webkit (konqueror) browsers \*/
// -ms-user-select: none; /\* IE10+ \*/
}
```
Единственное, что тут примечательно — это то как мы импортируем svg
```
import SvgClose from '~~/assets/svg/baseline-close-24px.svg?inline'
```
**?inline** говорит, что мы хотим получить этот svg в виде компонента, что разворачивает его на сервере в html позволяя нам задавать стили (то есть например менять цвет этого svg).
### В итоге
Получаем модальное окно с товарами. Бонусом идёт синхронизация между вкладками (можно открыть 2 вкладки и менять модалку, всё синхронизируется за счет общего LocalStorage).
### Добавим иконку корзины
Создаём файл
**components\header\CartButton.vue**
```
{{ productsQuantity }}
import { mapState } from 'vuex'
import CartSvg from '~~/assets/svg/shopping-cart.svg?inline'
export default {
components: {
CartSvg
},
computed: {
...mapState({
products: state => state.cart.products
}),
productsQuantity () {
if (this.products) {
return this.products.length
} else return 0
}
},
methods: {
onClickHandler () {
this.$modal.show('customer-cart')
}
}
}
.block {
position: relative;
}
.cartButton {
position: relative;
display: flex;
flex-direction: row;
justify-content: center;
align-items: center;
width: 68px;
height: 72px;
text-align: center;
transition: all 0.3s ease-in-out;
}
.svg1 {
margin-right: 3px;
width: 40px;
fill: #000;
// noselect
-webkit-user-select: none; /\* webkit (safari, chrome) browsers \*/
-moz-user-select: none; /\* mozilla browsers \*/
-khtml-user-select: none; /\* webkit (konqueror) browsers \*/
-ms-user-select: none; /\* IE10+ \*/
}
.quantity {
position: absolute;
right: 5px;
top: 5px;
border-radius: 50px;
background-color: #fb3f4c;
width: 20px;
color: #fff;
height: 20px;
text-align: center;
line-height: 20px;
font-size: .8rem;
font-weight: 600;
// noselect
-webkit-user-select: none; /\* webkit (safari, chrome) browsers \*/
-moz-user-select: none; /\* mozilla browsers \*/
-khtml-user-select: none; /\* webkit (konqueror) browsers \*/
-ms-user-select: none; /\* IE10+ \*/
}
```
И подключаем его в наш Header.
Так как нам нужно только количество товара в корзине (без мета-информации) мы получаем товары не через геттер, а напрямую
```
...mapState({
products: state => state.cart.products
}),
```
Этот компонент, выводит количество товара в корзине и открывает нашу модалку при нажатии.
Выглядит он так
### Итоги
* **Код проекта**: на Github [тыц](https://github.com/AntonMoskalchenko/nuxt-ecommerce).
* **Потыкать** : [тыц](https://nuxt-ecommerce.herokuapp.com/).
* [1 часть](https://habr.com/ru/post/490496/)
* [2 часть](https://habr.com/ru/post/491018/)
* [3 часть](https://habr.com/ru/post/491190/)
Это третья часть моего незамысловатого примера использования Nuxt.
Мы создали блоки товаров, переделали всю логику работы с корзиной, добавили модалки.
Теперь это чудо всё больше похоже на интернет-магазин.
К сожалению в одной статье не получается уместить такой объем, который был задуман в предыдущей. Поэтому страницу оформления заказа (и всё остальное) будем делать уже в следующей части.
### Послесловие
Буду рад выслушать ваши пожелания что прикрутить к магазину, добавить показать, а так же вопросы и не забудьте поддержать плюсиками, если вам зашло.
Спасибо за чтение! | https://habr.com/ru/post/491190/ | null | ru | null |
# Nix как менеджер зависимостей для C++
В последнее время много разговоров идет о том, что для C++ нужен свой пакетный менеджер подобный pip, npm, maven, cargo и т.д. Все конкуренты имеют простой и стандартизированный механизм подключения нестандартной библиотеки. В C++ же все действуют как умеют: кто-то прописывает в README список пакетов для Ubuntu, CentOS и других дистрибутивов, кто-то использует git submodule и скрипты для их сборки, кто-то использует CMake ExternalProject, кто-то копирует все исходники в один гигантский репозиторий, кто-то делает образ Docker или Vagrant.
Чтобы решить проблему был даже создан стартап — [biicode](https://github.com/biicode/), но он обанкротился и его будущее неизвестно. Взамен появился [conan](https://conan.io/), дополняя зоопарк конкурентов — [nuget](http://nuget.org), [cget](https://github.com/pfultz2/cget), [hunter](https://github.com/ruslo/hunter), [cpm](https://cpm.rocks), [qpm](https://qpm.io), [cppget](http://cppget.org), [pacm](http://sourcey.com/pacm) и даже [gradle for c++](http://gradle.org/getting-started-native/).
Меня не устраивал ни один из перечисленных способов. Я было начал писать пакеты для Conan, но столкнулся с большим числом хаков, неразвитым API, отсутвием гайдлайнов и, как следствие, низкой вероятностью переиспользования чужих пакетов. И тут вспомнилось, что когда-то мне очень понравились идеи пакетного менеджера в [NixOS](http://nixos.org). И подумал — а зачем плодить пакетный менеджер специально для C++, если те же задачи решает обычный пакетный менеджер? Нужно только чтобы он был достаточно гибким и простым в части описания пакета. И Nix идеально подошел на эту роль.
Итак, что дал нам Nix:
* Возможность получить готовое к сборке проекта окружение одной командой — `nix-shell`;
* 7344 готовых и поддерживаемых пакетов из `nixpkgs`;
* Возможность создать производный пакет от пакета из репозитория (не копируя его код);
* Возможность указывать в зависимостях не только C/C++ библиотеки, но также необходимые инструменты (CMake, GCC), проекты из других экосистем (npm, pip), сервисы (redis);
* Возможность привязать окружение к коммиту. Это значит, что, например, ветка master может использовать boost 1.55, а devel — 1.60. При переходе от ветки к ветке Nix автоматически настроит окружение под нужную версию, причем это займет менее секунды (если сборка уже есть в кеше);
* Неинтрузивность — проект не зависит от Nix, его использование — личное дело каждого. Можно собрать все зависимости вручную (или вашим любимым пакетным менеджером), указав все правильные опции для cmake.
Что такое Nix
=============
Nix — это функциональный язык программирования, заточенный под нужды пакетного менеджера (неудивительно, что он получил популярность в сообществе Haskell). Сборка пакета — это вычисление функции в Nix. И как положено функциональному языку программирования — повторные вызовы функции с теми же аргументами порождают одинаковый результат (бинарный пакет). А это значит, что пакеты можно кешировать, что Nix и делает — все сборки хранятся в `/nix/store/$HASH-$PKGNAME`. Кроме того, можно проверить есть ли у кого-то другого в сети пакет с таким же хэшом, и если есть — скачать бинарный пакет у него.
Таким образом, "пакет" (здесь он называется derivation) в Nix — это функция, а "зависимости" — это аргументы этой функции. Что же такое репозиторий (`NixPkgs`)? Это тоже функция, у которой нет аргументов, которая возвращает множество пакетов. Получается ли, что для использования репозитория нужно собрать все 7344 пакета? Нет! Nix — ленивый язык, а это значит ничего не будет вычисляться, пока оно явно не потребуется. А "потребовать" пакет можно утилитами.
Минимальное окружение
=====================
Итак, прежде чем использовать Nix его нужно установить. Для этого можно либо использовать целый дистрибутив Linux (NixOS), либо установить [пакетный менеджер](https://nixos.org/nix/) отдельно для вашей любимой ОС (поддерживается Linux и MacOS). Все воздействия Nix будут ограничены каталогом `/nix` и файлами в домашнем каталоге (`~/.nix-channel`, `.nix-defexpr`, `.nix-profile`).
В `~/.nix-profile` хранятся симлинки на пакеты, которые запросил пользователь. Нам же нужно настроить окружение не для пользователя, а для проекта. Для этого используем утилиту `nix-shell`: она выполняет данное на вход выражение Nix и запускает bash шелл, в котором доступен результат (и только он). Проверяем:
```
bash-3.2$ nix-shell -p stdenv
[nix-shell:~]$
```
Здесь в качестве выражения мы используем пакет (`-p`) `stdenv`. `stdenv` — это минимальное окружение, которое содержит компилятор, make и другие самые необходимые вещи.
Окружение для сборки пакета
===========================
Если запустить `nix-shell` без аргументов, то выражение читается из файла `default.nix`. Создадим его:
```
{ pkgs ? import {} }:
let
stdenv = pkgs.stdenv;
in rec {
myProject = stdenv.mkDerivation {
name = "my-project";
};
}
```
Здесь мы написали функцию, которая на вход принимает репозиторий (а если параметр не задан — импортирует стандартный `nixpkgs`) и возвращает "пакет" окружения нашего проекта. Добавим в него свежие CMake, Boost и Google Test из репозитория NixOS:
```
# ...
myProject = stdenv.mkDerivation {
name = "my-project";
nativeBuildInputs = [
pkgs.cmake
];
buildInputs = [
pkgs.boost
pkgs.gtest
];
};
```
Здесь buildInputs — зависимости, которые необходимы для сборки. Зачем еще nativeBuildInputs? Все дело в том, что Nix поддерживает кросс-компиляцию. И здесь мы говорим, что пакеты buildInputs должны быть собраны target тулчейном, а nativeBuildInputs нужно собрать обычным host тулчейном. Есть еще `propagatedBuildInputs` — он добавляет зависимость всем пользователям пакета.
Теперь при следующем вызове `nix-shell`, Nix выкачает необходимые бинарные пакеты и установит переменные окружения так, чтобы библиотеки находились стандартными средствами, например, CMake:
```
find_package(Boost 1.60 REQUIRED
COMPONENTS system thread)
find_path(GTEST_INCLUDE_DIRS
NAMES gtest/gtest.h
PATH_SUFFIXES gtest)
```
Разработчику остается лишь запустить `cmake . && make`, о чем мы ему и сообщим при входе в `nix-shell`:
```
myProject = stdenv.mkDerivation {
# ...
shellHook = [''
echo Welcome to myproject!
echo Run \'mkdir build && cd build && cmake .. && make -j\' to build it.
''];
};
```
Собираем зависимость, которой нет в `nixpkgs`
=============================================
Теперь мы хотим добавить в наш проект [cppformat](http://cppformat.github.io/latest/index.html). Сначала ищем его в `nixpkgs`:
```
$ nix-env -qaP | grep cppformat
$ nix-env -qaP | grep cpp-format
```
Пусто. Придется писать собственное выражение. Благо это всего 10 строчек. Добавим их в "let":
```
# ...
let
stdenv = pkgs.stdenv;
fetchurl = pkgs.fetchurl;
cppformat = stdenv.mkDerivation rec {
version = "2.1.0";
name = "cppformat-${version}";
src = fetchurl {
url = "https://github.com/cppformat/cppformat/archive/${version}.tar.gz";
sha256 = "0h8rydgwbm5gwwblx7jzpb43a9ap0dk2d9dbrswnbfmw50v5s7an";
};
buildInputs = [ pkgs.cmake ];
enableParallelBuilding = true;
};
in rec {
# ...
buildInputs = [
# ...
cppformat
];
# ...
```
Теперь при последующем запуске `nix-shell`, Nix скачает исходники cppformat, соберет их используя cmake (он видит, что проект использует cmake, поэтому вместо стандартного "`./configure && make install`" будет использован "`cmake . && make install`") и закеширует результат сборки в `/nix/store`. Примечательно, что в отличие от утилит большинства других пакетных менеджеров:
* При неудаче в сборке исходники не будут выкачиваться повторно;
* Если мы изменили выражение — пакет перекомпилируется. Если потом решили откатить выражение назад, то автоматически будет использован старый пакет из кеша, даже если дата модификации файла изменилась (удобно при смене бранча/коммита).
Модифицируем пакет из репозитория
=================================
Иногда нужный пакет в репозитории есть, но собран не так, как нам хочется. Нужно собрать его определенную версию, наложить патч, использовать определенные флаги. Nix позволяет это сделать без необходимости копипастить код из репозитория:
```
cpp-netlib = pkgs.cpp-netlib.overrideDerivation(oldAttrs: {
postPatch = ''
substituteInPlace CMakeLists.txt \
--replace "CPPNETLIB_VERSION_PATCH 1" "CPPNETLIB_VERSION_PATCH 3"
'';
cmakeFlags = oldAttrs.cmakeFlags ++ [ "-DCMAKE_CXX_STANDARD=11" ];
src = fetchFromGitHub {
owner = "cpp-netlib";
repo = "cpp-netlib";
rev = "9bcbde758952813bf87c2ff6cc16679509a40e06"; # 0.11-devel
sha256 = "0abcb2x0wc992s5j99bjc01al49ax4jw7m9d0522nkd11nzmiacy";
};
});
```
Модифицируем пакет в репозитории
================================
Мы можем собрать производный пакет X' на основе оригинального X из репозитория и использовать его у себя. При этом если какой-то пакет Y в репозитории зависел от X, то он продолжит использовать его старую версию. Но что если нужно изменить пакет внутри репозитория, т.е. так, чтобы его стали использовать 100500 других пакетов? И для этого случая в Nix есть инструменты. Пересоберем буст из `nixpkgs`, используя GCC5 вместо стандартного GCC 4.9:
```
{ nixpkgs ? import {} }:
let
overrideCC = nixpkgs.overrideCC;
stdenv = if ! nixpkgs.stdenv.isLinux
then nixpkgs.stdenv
else overrideCC nixpkgs.stdenv nixpkgs.gcc5;
pkgs = nixpkgs.overridePackages (self: super: {
boost = super.boost.override { stdenv = stdenv; };
});
```
Здесь мы изменили имя аргумента с `pkgs` на `nixpkgs` и создаем производный репозиторий `pkgs`, в котором буст собран так, как мы хотим. Теперь все остальные пакеты зависящие от boost должны быть пересобраны чтобы задействовать нашу сборку. Разумеется, будут (рекурсивно) пересобраны лишь те пакеты, которые используются внутри нашего выражения — ведь Nix ленив.
Интеграция с сторонними пакетными менеджерами и платформами
===========================================================
Тут все опять просто — в Nix есть поддержка сборки пакетов для .NET, Emacs, Go, Haskell, Lua, Node, Perl, PHP, Python и Rust. Для некоторых из них интеграция заключается в том, что Nix может использовать пакеты прямо из нативного пакетного менеджера:
```
nativeBuildInputs = [ pkgs.cmake pkgs.pkgconfig nodePackages.uglify-js ];
```
Интегрируем Nix в YouCompleteMe
===============================
YouCompleteMe — пожалуй самый популярный движок автодополнения кода для C++, который не является частью IDE. Он вышел из Vim, но уже есть порты для Atom и, возможно, других редакторов. Если раньше разработчики должны были конфигурировать его самостоятельно под свою систему, то теперь мы можем сделать это универсально:
```
def ExportFromNix():
from subprocess import Popen, PIPE
import shlex
cmd = "nix-shell -Q --pure --readonly-mode --run 'echo $NIX_CFLAGS_COMPILE'";
proc = Popen(cmd, shell=True, stdout=PIPE)
out = proc.stdout.read().decode("utf-8")
return shlex.split(out)
flags += ExportFromNix()
```
Заключение
==========
Nix — одновременно гибкий, удобный и простой пакетный менеджер, который построен на принципах функционального программирования и претендует на роль пакетного менеджера для всего. Особенно он может быть удобен C/C++ программистам, т.к. позволяет заполнить пустующую у данного языка нишу. Используя его, можно патчить и добавлять библиотеки в проект не вызывая боль и ненавистить у коллег. А новичек, прибывший в команду, не будет тратить свои первые рабочие дни на сборку проекта. | https://habr.com/ru/post/281611/ | null | ru | null |
# Компиляция карт для Half-Life 1 на ТВ-приставке
Я уже не первый год занимаюсь моддингом легендарной Half-Life 1, и как-то совершенно спонтанно мне пришла в голову мысль, дескать, как было бы прикольно иметь возможность компилировать карты на какой-нибудь платформе, отличной от привычных всем x86 и amd64. Затем я вспомнил, что у меня дома есть ТВ-приставка на базе Android, которую в теории можно было бы приспособить для этих дел. Если возможность есть, значит обязательно нужно провести такой эксперимент!
Что имеем
---------
В наличии у меня была бюджетная ТВ-приставка GoldMaster I-905, совершенно ничем не примечательная. Имеет 16 гигабайт встроенной памяти, 2 гигабайта оперативной памяти. Базируется на процессоре Allwinner H313. Из интерфейсов: имеет два USB 2.0 порта, композитный видеовыход, HDMI порт. Доступ в сеть может быть обеспечен как через Wi-Fi, так и через Ethernet-порт (я использовал проводное подключение).
Запущенный neofetch на ТВ-приставке. Отображает основную информацию о системе. Также, нам нужны исходники компиляторов карт. За почти 30 лет существования игры, их вариаций появилось не так уж мало: оригинальные компиляторы от Valve, ZHLT, VHLT, P2ST, и т.д. Я же буду использовать компиляторы карт из моего проекта [PrimeXT](https://github.com/SNMetamorph/PrimeXT): они самые актуальные на данный момент, их будет проще всего собрать и запустить под какой-либо экзотической платформой, в отличии от всех остальных вариаций. Сама игра, а также все сопутствующие утилиты, включая компиляторы карт, написаны на C/C++. В PrimeXT используется система сборки CMake.
Подготовка
----------
После недолгого поиска информации, я выяснил, что для сборки C++ проектов прямиком на Android мне потребуется [Termux](https://termux.dev/en/). Его нужно скачать с репозитория [F-Droid](https://f-droid.org/ru/packages/com.termux/), поскольку версия, опубликованная на Google Play, [объявлена устаревшей](https://www.reddit.com/r/termux/comments/pkujfa/important_deprecation_notice_for_google_play/) и больше не поддерживается.
После установки Termux, на всякий случай обновим установленные пакеты:
```
pkg upgrade
```
Теперь установим пакеты, которые непосредственно понадобятся нам.
```
pkg install cmake git openssh
```
Для более удобной работы, я решил запустить на приставке SSH-сервер и подключиться к нему с моего компьютера. Для этого я использовал связку софта KiTTY + WinSCP. Разумеется, вместо этого можно использовать любой другой софт. А можно и обойтись вообще без SSH-сервера - просто вбивать все нужные команды в Termux ручками на устройстве. WinSCP я буду использовать для удобной работы с файлами на удалённом устройстве.
Теперь нужно запустить SSH-сервер: процедура весьма тривиальная.
Сначала, нам необходимо выставить пароль для подключения к серверу, а затем запустить соответствующую службу.
```
passwd
sshd
```
После чего, можно пробовать подключиться с компьютера к серверу. Обратите внимание, что в Termux для SSH-сервера используется порт **8022**, а не привычный 22. Имя пользователя можно вписать любое, а ввести пароль нужно указанный ранее. При удачном подключении отобразится шелл.
Сборка компиляторов
-------------------
После завершения всех подготовительных процедур, можно перейти непосредственно к сборке: первым делом нужно склонировать исходники в домашнюю директорию.
```
cd ~
git clone --recursive https://github.com/SNMetamorph/PrimeXT.git
cd PrimeXT
```
Затем, нужно создать и подготовить директорию, в которой будет происходить сборка.
```
cmake -E make_directory ./build
cd build
```
Теперь настал черёд сгенерировать кэш CMake и запустить сборку. Поскольку меня интересуют только компиляторы карт, я отключаю сборку игровых библиотек, лаунчера и остальных утилит. Также, чтобы компиляция проекта прошла быстрее, я выставлю сборку в 4 потока.
```
cmake .. -DBUILD_CLIENT=OFF -DBUILD_SERVER=OFF -DENABLE_PHYSX=OFF -DBUILD_GAME_LAUNCHER=OFF -DBUILD_PXMV=OFF -DBUILD_PXSV=OFF -DENABLE_STATIC_LINKING=OFF -DCMAKE_BUILD_TYPE=Release
cmake --build . --config Release --parallel 4
```
Кэш CMake сгенерировалсяПосле выполнения двух описанных выше команд, запустится процесс сборки.
Если сборка пройдёт успешно, это будет выглядеть так. В случае если возникнут какие-то ошибки, то лучше перезапустить сборку в одном потоке, так будет проще выяснить, в каком конкретно месте возникла ошибка компиляции. К слову, на этой приставке сборка в 4 потока заняла около четырёх минут, с учётом того что на фоне был запущен IPTV-плеер.
Сборка завершилась успешноКомпиляция карты
----------------
Для заключительного этапа нужно подготовить рабочую директорию, в которой будут находиться WAD-файлы с текстурами, *.rad* файл и исходник карты. В моем случае эта директория будет иметь название **gameres**.
```
mkdir ~/gameres
cd ~/gameres
```
Затем, внутри этой директории нужно создать файл **gameinfo.txt** со следующим содержанием:
```
basedir ""
gamedir "gameres"
```
Важный момент: в этом файле, значение параметра *gamedir* должно совпадать с названием рабочей директории. Далее, нужно положить используемые WAD-файлы в рабочую директорию, создать внутри неё поддиректорию с названием *maps,* и положить в поддиректорию *.rad* файл и исходник карты в виде *.map* файла. Все нужные файлы которые использовал я, доступны по [этой ссылке](https://snmetamorph.github.io/assets/crossfire_mirror_sources.7z).
Теперь можно попробовать скомпилировать карту, и остаётся лишь ждать.
```
cd ~/PrimeXT/build/Release/primext/devkit
./pxcsg ~/gameres/maps/crossfire_double1_v2.map
./pxbsp ~/gameres/maps/crossfire_double1_v2.bsp
./pxvis ~/gameres/maps/crossfire_double1_v2.bsp
./pxrad ~/gameres/maps/crossfire_double1_v2.bsp
```
Процесс компиляции карты состоит из четырёх этапов. При завершении каждого этапа, будет отображено затраченное на него время. В случае, если во время компиляции карты возникнут какие-то проблемы, то можно поглядеть файл с логами в поддиректории *maps.* Также, можно добавить компиляторам параметр запуска *-dev 5*, чтобы отображение процесса было более подробным.
Последний этап компиляции карты завершёнПроверка результатов
--------------------
После того как карта удачно скомпилировалась на ТВ-приставке, я решил пересобрать эту же карту на своем компьютере и после этого сравнить две этих карты. В идеале, никаких видимых различий быть не должно. Тестировать всё это дело я буду в моде PrimeXT, который в свою очередь базируется на движке Xash3D FWGS.
Карты действительно собраны на разной платформе и архитектуреВ движке есть команда *mapstats*, которая позволяет отобразить различную внутреннюю информацию о карте. Для нашей ситуации, это прямо то что нужно.
Статистика карты, скомпилированной на ТВ-приставке
```
Object names Objects/Maxobjs Memory / Maxmem Fullness
------------ --------------- --------------- --------
entities [variable] 64780/1048576 ( 6.2%)
planes 2179/65536 43580/1310720 ( 3.3%)
textures [variable] 4976/33554432 ( 0.0%)
vertexes 11219/65535 134628/786420 (17.1%)
visibility [variable] 199238/16777216 ( 1.2%)
nodes 5031/32767 120744/786408 (15.4%)
texinfo 1383/65535 55320/2621400 ( 2.1%)
faces 8467/65535 169340/1310700 (12.9%)
lightmaps [variable] 1745778/33554432 ( 5.2%)
clipnodes 12686/32767 101488/262136 (38.7%)
leafs 3260/32767 91280/917476 ( 9.9%)
markfaces 11552/65535 23104/131070 (17.6%)
edges 20150/1048576 80600/4194304 ( 1.9%)
surfedges 40037/2097152 160148/8388608 ( 1.9%)
models 142/1024 9088/65536 (13.9%)
deluxmaps [variable] 1745778/33554432 ( 5.2%)
=== Total BSP file data space used: 4.53 Mb ===
World size ( 5120 5824 3920 ) units
Supports transparency world water: No
Lighting: colored
World total leafs: 2318
original name: maps/crossfire_double1_v2_arm.bsp
internal name: desert
map compiler: PrimeXT Tools v.0.90 (Dec 15 2022 / 1397a04 / armv7l / android)
map editor: J.A.C.K. 1.1.2800 (vpHalfLife)
```
Статистика карты, скомпилированной на компьютере
```
Object names Objects/Maxobjs Memory / Maxmem Fullness
------------ --------------- --------------- --------
entities [variable] 64777/1048576 ( 6.2%)
planes 2179/65536 43580/1310720 ( 3.3%)
textures [variable] 4976/33554432 ( 0.0%)
vertexes 11210/65535 134520/786420 (17.1%)
visibility [variable] 198643/16777216 ( 1.2%)
nodes 5031/32767 120744/786408 (15.4%)
texinfo 1383/65535 55320/2621400 ( 2.1%)
faces 8465/65535 169300/1310700 (12.9%)
lightmaps [variable] 1744599/33554432 ( 5.2%)
clipnodes 12747/32767 101976/262136 (38.9%)
leafs 3258/32767 91224/917476 ( 9.9%)
markfaces 11512/65535 23024/131070 (17.6%)
edges 20138/1048576 80552/4194304 ( 1.9%)
surfedges 40013/2097152 160052/8388608 ( 1.9%)
models 142/1024 9088/65536 (13.9%)
deluxmaps [variable] 1744599/33554432 ( 5.2%)
=== Total BSP file data space used: 4.53 Mb ===
World size ( 5120 5824 3920 ) units
Supports transparency world water: No
Lighting: colored
World total leafs: 2316
original name: maps/crossfire_double1_v2.bsp
internal name: desert
map compiler: PrimeXT Tools v.0.90 (Dec 16 2022 / 1397a04 / amd64 / win32)
map editor: J.A.C.K. 1.1.2800 (vpHalfLife)
```
Как можно заметить, минимальные различия всё-таки имеются. Сложно сказать, в чём конкретно причина этих различий, но скорее всего они совсем некритичны. Далее, имеет смысл сравнить, есть ли какие-либо визуальные различия на самой карте.
Скриншоты карты, скомпилированной на компьютереСкриншоты карты, скомпилированной на ТВ-приставкеЛично я вообще никаких визуальных различий в освещении либо геометрии не заметил, что конечно хорошо. Эксперимент можно считать удачным.
Итог
----
Описанными выше процедурами вполне можно компилировать карты для Half-Life 1 на практически любых устройствах, которые базируются на ОС Android или Linux. Разве что, на слишком больших и детализированных картах у устройства может не хватить оперативной памяти для компиляции. Может ли всё это быть кому-то полезно? Вполне. Например, в случае если по какой-то причине не хочется нагружать основной ПК, либо же кроме смартфона нет вообще никаких устройств, а карту скомпилировать как-то надо. | https://habr.com/ru/post/707860/ | null | ru | null |
# Free Heroes of might and magic 2 – open-source проект, в котором хочется участвовать
Недавно в сети появилась новость о релизе новой версии проекта fheroes2. У нас в компании многие сотрудники являются поклонниками серии игр Heroes of Might and Magic, и естественно, мы не могли пройти мимо и в процессе ознакомления с проектом проверили его анализатором PVS-Studio.
### Знакомство с проектом
Free Heroes of Might and Magic II – реализация игрового движка Heroes of Might and Magic II с открытым исходным кодом. Для того чтобы поиграть в обновлённую версию, нужна оригинальная Heroes of Might and Magic II или хотя бы её демоверсия, которую можно скачать при помощи распространяемого вместе с исходным кодом [скрипта](https://github.com/ihhub/fheroes2/tree/master/script/demo) (в зависимости от операционной системы нужно выбрать соответствующую версию).
После успешной сборки проекта я решил немного поностальгировать и запустить игру. Для удобства я немного отредактировал файл fheroes2.cfg, проставив параметры:
```
heroes speed = 10
ai speed = 10
battle speed = 10
```
А также выставил своё разрешение в параметре *videomode*.
После всех манипуляций я запустил игру и увидел знакомый главный экран:
Если вы проставили не своё разрешение экрана или не хотите заморачиваться с конфигом, развернуть игру в полноэкранный режим можно при помощи клавиши f4.
Далее, я зашёл в standard game. Так как я выкачал демоверсию, доступна лишь одна карта – Broken Alliance.
Очень удобно, что окошки с картой, героями и настройками можно передвигать в нужные части экрана. ИИ, с которым, судя по отзывам, были проблемы в предыдущих версиях игры, теперь довольно шустро осваивает карту и неплохо дерётся. В общем, я ещё немного побегал и мне очень понравилось.
Последней доступной версией проекта на момент написания статьи была 0.8.4, в ней была улучшена работа игры на низкопроизводительных устройствах, добавлено большое количество геймплейных и косметических нововведений, о которых можно почитать [здесь](https://github.com/ihhub/fheroes2/releases/tag/0.8.4). Также моё внимание привлекла надпись: "устранено более ста багов по сравнению с предыдущей версией". Что ж, видимо, разработчики серьёзно следят за качеством исходного кода и, как видно по странице проекта на GitHub, уже используют статический анализатор Sonar Cxx на постоянной основе, а иногда проверяют проект анализатором Cppcheck.
Мне кажется, что, если астрологи объявят неделю статического анализа и разработчики добавят к списку своих утилит PVS-Studio, багов станет ещё меньше. Давайте же убедимся в этом, рассмотрев несколько найденных мной с его помощью проблемных фрагментов кода. Тем более что открытые проекты могут использовать анализатор PVS-Studio [бесплатно](https://www.viva64.com/ru/open-source-license/).
### Микрооптимизации
Начнём для разнообразия не с ошибок, а с фрагментов кода, которые можно немножко оптимизировать. Немножко потому, что настоящую оптимизацию нужно выполнять, используя профилировщики. Статические анализаторы не имеют данных, как часто выполняется тот или иной код, и поэтому не способны показать, где действительно узкое место. Поэтому мы, кстати, называем "микрооптимизациями" набор предупреждений PVS-Studio, касающихся увеличения скорости работы.
Мы не рассчитываем, что описанное здесь поможет хоть сколько-то заметно ускорить работу игры. Просто хотелось уделить внимание этому набору диагностик, который обычно не освещается в наших [серийных статьях](https://www.viva64.com/ru/inspections/) про проверки открытых проектов и поэтому остаётся в тени.
**Предупреждение N1**
[V823](https://www.viva64.com/ru/w/v823/) Decreased performance. Object may be created in-place in the 'list' container. Consider replacing methods: 'push\_back' -> 'emplace\_back'. tools.cpp 231
```
std::list StringSplit( const std::string & str, ....)
{
std::list list;
size\_t pos1 = 0;
size\_t pos2 = std::string::npos;
while ( pos1 < str.size()
&& std::string::npos != (pos2 = str.find(sep, pos1)))
{
list.push\_back( str.substr( pos1, pos2 - pos1 ) );
pos1 = pos2 + sep.size();
}
....
}
```
Анализатор подсказывает, что в данном случае было бы более эффективно использовать метод *emplace\_back*. В общем случае, простая замена метода *push\_back* на *emplace\_back* не даст ускорения производительности, если аргумент является rvalue. Однако, в нашем случае у класса *std::string* есть конструктор, создающий объект из двух итераторов (см. [конструктор N6](https://en.cppreference.com/w/cpp/string/basic_string/basic_string)). И именно он позволит нам устранить лишний вызов конструктора перемещения в сочетании с *emplace\_back*:
```
std::list StringSplit( const std::string & str, ....)
{
std::list list;
size\_t pos1 = 0;
size\_t pos2 = std::string::npos;
while ( pos1 < str.size()
&& std::string::npos != (pos2 = str.find(sep, pos1)))
{
list.emplace\_back(str.begin() + pos1, str.begin() + pos2);
pos1 = pos2 + sep.size();
}
....
}
```
Это полезно для улучшения производительности, так как данная операция выполняется в цикле. Хочется отметить, что данное предупреждение важно, ведь в ходе проверки было обнаружено более ста подобных сообщений. Вот некоторые из них:
* [V823](https://www.viva64.com/ru/w/v823/) Decreased performance. Object may be created in-place in the 'loop\_sounds' container. Consider replacing methods: 'push\_back' -> 'emplace\_back'. agg.cpp 461
* [V823](https://www.viva64.com/ru/w/v823/) Decreased performance. Object may be created in-place in the 'projectileOffset' container. Consider replacing methods: 'push\_back' -> 'emplace\_back'. bin\_info.cpp 183
* [V823](https://www.viva64.com/ru/w/v823/) Decreased performance. Object may be created in-place in the 'actions' container. Consider replacing methods: 'push\_back' -> 'emplace\_back'. ai\_normal\_battle.cpp 264
* [V823](https://www.viva64.com/ru/w/v823/) Decreased performance. Object may be created in-place in the 'actions' container. Consider replacing methods: 'push\_back' -> 'emplace\_back'. ai\_normal\_battle.cpp 288
* [V823](https://www.viva64.com/ru/w/v823/) Decreased performance. Object may be created in-place in the 'actions' container. Consider replacing methods: 'push\_back' -> 'emplace\_back'. ai\_normal\_battle.cpp 433
* и так далее
**Предупреждение N2**
[V814](https://www.viva64.com/ru/w/v814/) Decreased performance. The 'strlen' function was called multiple times inside the body of a loop. tools.cpp 216
```
void StringReplace( std::string & dst,
const char * pred,
const std::string & src )
{
size_t pos = std::string::npos;
while ( std::string::npos != ( pos = dst.find( pred ) ) )
{
dst.replace( pos, std::strlen( pred ), src );
}
}
```
В данном случае функция *strlen* вызывается на каждой итерации цикла, при этом размер строки *pred* не меняется. Код можно упростить самым банальным образом, вынеся вычисление длины строки за пределы цикла и обозначив его в виде константы.
```
void StringReplace( std::string & dst,
const char * pred,
const std::string & src )
{
size_t pos = std::string::npos;
const size_t predSize = std::strlen( pred);
while ( std::string::npos != ( pos = dst.find( pred ) ) )
{
dst.replace( pos, predSize, src );
}
}
```
**Предупреждение N3**
[V827](https://www.viva64.com/ru/w/v827/) Maximum size of the 'optionAreas' vector is known at compile time. Consider pre-allocating it by calling optionAreas.reserve(6) battle\_dialogs.cpp 217
```
void Battle::DialogBattleSettings( .... )
{
std::vector optionAreas;
optionAreas.push_back( fheroes2::Rect( pos_rt.x + 36,
pos_rt.y + 47,
panelWidth,
panelHeight ) );
optionAreas.push_back( fheroes2::Rect( pos_rt.x + 128,
pos_rt.y + 47,
panelWidth,
panelHeight ) );
optionAreas.push_back( fheroes2::Rect( pos_rt.x + 220,
pos_rt.y + 47,
panelWidth,
panelHeight ) );
optionAreas.push_back( fheroes2::Rect( pos_rt.x + 36,
pos_rt.y + 157,
panelWidth,
panelHeight ) );
optionAreas.push_back( fheroes2::Rect( pos_rt.x + 128,
pos_rt.y + 157,
panelWidth,
panelHeight ) );
optionAreas.push_back( fheroes2::Rect( pos_rt.x + 220,
pos_rt.y + 157,
panelWidth,
panelHeight ) );
}
```
Анализатор обнаружил *std::vector*, максимальный размер которого известен на этапе компиляции. Перед заполнением контейнера гораздо эффективнее было бы вызвать:
```
optionAreas.reserve(6);
```
В этом случае вызовы *push\_back* не приведут к реаллокации внутреннего буфера в векторе и перемещению элементов в новую область памяти. Ну или, как альтернатива, этот код можно переписать с использованием *std::array*.
**Предупреждения N4.0, 4.1...4.7**
* [V809](https://www.viva64.com/ru/w/v809/) Verifying that a pointer value is not NULL is not required. The 'if (armyBar)' check can be removed. kingdom\_overview.cpp 62
* [V809](https://www.viva64.com/ru/w/v809/) Verifying that a pointer value is not NULL is not required. The 'if (artifactsBar)' check can be removed. kingdom\_overview.cpp 64
* [V809](https://www.viva64.com/ru/w/v809/) Verifying that a pointer value is not NULL is not required. The 'if (secskillsBar)' check can be removed. kingdom\_overview.cpp 66
* [V809](https://www.viva64.com/ru/w/v809/) Verifying that a pointer value is not NULL is not required. The 'if (primskillsBar)' check can be removed. kingdom\_overview.cpp 68
* [V809](https://www.viva64.com/ru/w/v809/) Verifying that a pointer value is not NULL is not required. The 'if (armyBarGuard)' check can be removed. kingdom\_overview.cpp 279
* [V809](https://www.viva64.com/ru/w/v809/) Verifying that a pointer value is not NULL is not required. The 'if (armyBarGuest)' check can be removed. kingdom\_overview.cpp 281
* [V809](https://www.viva64.com/ru/w/v809/) Verifying that a pointer value is not NULL is not required. The 'if (dwellingsBar)' check can be removed. kingdom\_overview.cpp 283
Анализатор обнаружил несколько интересных функций *Clear*, код которых я приведу ниже, однако подобное поведение встречается и в других частях кода программы.
```
void Clear( void )
{
if ( armyBar )
delete armyBar;
if ( artifactsBar )
delete artifactsBar;
if ( secskillsBar )
delete secskillsBar;
if ( primskillsBar )
delete primskillsBar;
}
void Clear( void )
{
if ( armyBarGuard )
delete armyBarGuard;
if ( armyBarGuest )
delete armyBarGuest;
if ( dwellingsBar )
delete dwellingsBar;
}
```
В данном случае можно произвести рефакторинг кода, убрав из функций все проверки на нулевые указатели, ведь оператор *delete* корректно его обрабатывает. Возможно, это и не даст выигрыша в производительности (компилятор сам уберёт проверки), однако упростит код и сделает его более читабельным.
### General Analysis
**Предупреждение N5**
На данный фрагмент кода анализатор выдал 2 предупреждения:
* V654 The condition 'i < originalPalette.size()' of loop is always false. battle\_interface.cpp 3689
* V621 Consider inspecting the 'for' operator. It's possible that the loop will be executed incorrectly or won't be executed at all. battle\_interface.cpp 3689
```
void Battle::Interface::RedrawActionBloodLustSpell( Unit & target )
{
std::vector > originalPalette;
if ( target.Modes( SP_STONE ) )
{
originalPalette.push_back( PAL::GetPalette( PAL::GRAY ) );
}
else if ( target.Modes( CAP_MIRRORIMAGE ) )
{
originalPalette.push_back( PAL::GetPalette( PAL::MIRROR_IMAGE ) );
}
if ( !originalPalette.empty() )
{
for ( size_t i = 1; i < originalPalette.size(); ++i )
{
originalPalette[0] = PAL::CombinePalettes( originalPalette[0],
originalPalette[i] );
}
fheroes2::ApplyPalette( unitSprite, originalPalette[0] );
}
....
}
```
Как мы видим, здесь программист ошибся в алгоритме. По ходу выполнения функции вектор *originalPalette* увеличивается в размере на единицу или остаётся пустым. В *if* находящийся над циклом, мы войдём, только когда *originalPalette.size()* равен единице. Соответственно, переменная *i* никогда не будет меньше размера вектора, и из-за этого мы получаем фрагмент недостижимого кода.
**Предупреждение N6**
[V547](https://www.viva64.com/ru/w/v547/) Expression 'palette.empty()' is always true. image\_tool.cpp 32
```
const std::vector PALPAlette()
{
std::vector palette;
if (palette.empty()) //<=
{
palette.resize( 256 * 3 );
for ( size_t i = 0; i < palette.size(); ++i )
{
palette[i] = kb_pal[i] << 2;
}
}
return palette;
}
```
В данном случае, анализатор видит, что мы безусловно создаём пустой вектор, данная проверка избыточна, а значит, можно облегчить код, убрав её.
**Предупреждение N7**
[V668](https://www.viva64.com/ru/w/v668/) There is no sense in testing the 'listlog' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. battle\_interface.cpp 986
```
Battle::Interface::Interface(....)
{
....
listlog = new StatusListBox();
....
if ( listlog )
{
....
}
....
}
```
Анализатор обнаружил ситуацию, когда значение указателя, возвращаемого оператором *new*, сравнивается с нулём. Как правило, это значит, что программа при невозможности выделить память будет вести себя не так, как ожидает программист. Если оператор *new* не смог выделить память, то, согласно стандарту языка *С++,* генерируется исключение *std::bad\_alloc()* Значит, данная проверка избыточна.
Также было обнаружено ещё два подобных срабатывания:
* [V668](https://www.viva64.com/ru/w/v668/) There is no sense in testing the 'elem' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. battle\_arena.cpp 1079
* [V668](https://www.viva64.com/ru/w/v668/) There is no sense in testing the 'image' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. battle\_arena.cpp 1095
**Предупреждение N8**
[V595](https://www.viva64.com/ru/w/v595/) The '\_currentUnit' pointer was utilized before it was verified against nullptr. Check lines: 2336, 2358. battle\_interface.cpp 2336
```
void Battle::Interface::MouseLeftClickBoardAction( .... )
{
....
themes = GetSwordCursorDirection( Board::GetDirection( index,
_currentUnit->GetHeadIndex()));
....
if ( _currentUnit )
{
....
}
....
}
```
Указатель *\_currentUnit* сначала разыменовывается, а потом проверяется на *NULL*. Это может означать одну из двух очевидных вещей: возникнет неопределённое поведение, если указатель действительно нулевой, или указатель никогда не может иметь нулевое значение, и программа всегда работает корректно. Если подразумевается первый вариант, то проверку стоит произвести до разыменования. Во втором варианте можно опустить избыточную проверку.
### Заключение
Как по мне, проект сейчас очень близок к оригинальной версии игры. Код проекта довольно качественный, что неудивительно, ведь разработчики используют несколько статических анализаторов. Однако нет пределов совершенству, и ещё меньшего количества багов можно добиться, добавив к используемым решениям PVS-Studio, который, как уже упоминалась ранее, [бесплатен](https://www.viva64.com/ru/open-source-license/) для open-source проектов.
В заключение хочется сказать разработчикам спасибо, движок действительно крутой. Если же вы ищете хороший и интересный open-source проект, в котором можно поучаствовать, то fheroes2 – то, что вам нужно.
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Vladislav Stolyarov. [Free Heroes of Might and Magic II: Open-Source Project that You Want to Be Part of](https://habr.com/en/company/pvs-studio/blog/543868/). | https://habr.com/ru/post/543870/ | null | ru | null |
# Универсальное событие в Google Tag Manager
Если вы отслеживаете множество событий и то и дело добавляете новые, вам приходится выполнять серию одних и тех же операций:
1. Повесить событие на сайте.
2. Создать в GTM триггер.
3. Создать в GTM тэг отправки события в Google Analytics.
4. Создать в GTM тэг отправки события в Яндекс Метрику.
5. Если у вас собираются данные для ретаргетинга в Facebook и VK, то для каждого из них нужно создать в GTM еще по тэгу.
При этом количество сущностей в GTM растет и ориентироваться в них становится всё утомительней. (А еще GTM не резиновый и допустимое количество сущностей ограничено.)
Я придумал и внедрил решение, которое позволяет:
* сократить рутину, избавляя от шагов 2-5;
* не плодить тэги;
* упростить управление событиями.
Нужно только один раз настроить несколько сущностей в GTM и больше вообще его не трогать при добавлении новых событий! Подробности по порядку.
### Событие на сайте
В момент срабатывания нужного события передаем в dataLayer несколько параметров:
```
dataLayer.push(
{
'event':'universal_event',
'event_category':'GA_category',
'event_action':'GA_action',
'event_label':'GA_label',
'universal_event_systems':'google_analytics facebook metrika vkontakte',
'universal_event_name':'retargeting_event'
});
```
где
* **universal\_event** — идентификатор события для GTM;
* **GA\_category, GA\_action, GA\_label** — соответственно категория, действие и ярлык события для Google Analytics;
* **google\_analytics facebook metrika vkontakte** — системы, в которые будет передаваться событие. Можно указать одну или несколько через пробел или другой разделитель;
* **retargeting\_event** — идентификатор события для систем помимо Google Analytics.
### GTM: переменные
Создаем в GTM пять переменных типа ***Переменная уровня данных***: **event\_category, event\_action, event\_label, universal\_event\_name, universal\_event\_systems**.
### GTM: триггеры
Создаем триггеры типа ***Пользовательское событие***, активирующие тэги отправки события в нужные системы. Для каждой системы свой триггер, но отличаются они только проверкой переменной **universal\_event\_systems**. Все триггеры срабатывают по событию **universal\_event**.
### GTM: тэги
Создаем тэги отправки событий в системы. В тэг для GA подставляем наши переменные **event\_category, event\_action, event\_label**, а в тэгах других систем в код вставляем переменную **universal\_event\_name**.
### Готово!
Не забудьте протестить и опубликовать изменения в GTM.
Теперь при создании нового события на сайте вы можете просто передать в коде сайта в dataLayer нужную конфигурацию, а GTM даже не открывать.
Если используете и Метрику, также придется создать в ней цель типа ***javascript-событие***, указав в качестве идентификатора значение переменной **universal\_event\_name**. | https://habr.com/ru/post/501202/ | null | ru | null |
# Учебный курс по React, часть 7: встроенные стили
Сегодня, в следующей части курса по React, мы поговорим о встроенных стилях.
[](https://habr.com/company/ruvds/blog/435468/)
→ [Часть 1: обзор курса, причины популярности React, ReactDOM и JSX](https://habr.com/post/432636/)
→ [Часть 2: функциональные компоненты](https://habr.com/post/433400/)
→ [Часть 3: файлы компонентов, структура проектов](https://habr.com/post/433404/)
→ [Часть 4: родительские и дочерние компоненты](https://habr.com/company/ruvds/blog/434118/)
→ [Часть 5: начало работы над TODO-приложением, основы стилизации](https://habr.com/company/ruvds/blog/434120/)
→ [Часть 6: о некоторых особенностях курса, JSX и JavaScript](https://habr.com/company/ruvds/blog/435466/)
→ [Часть 7: встроенные стили](https://habr.com/company/ruvds/blog/435468/)
→ [Часть 8: продолжение работы над TODO-приложением, знакомство со свойствами компонентов](https://habr.com/company/ruvds/blog/435470/)
→ [Часть 9: свойства компонентов](https://habr.com/company/ruvds/blog/436032/)
→ [Часть 10: практикум по работе со свойствами компонентов и стилизации](https://habr.com/company/ruvds/blog/436890/)
→ [Часть 11: динамическое формирование разметки и метод массивов map](https://habr.com/company/ruvds/blog/436892/)
→ [Часть 12: практикум, третий этап работы над TODO-приложением](https://habr.com/company/ruvds/blog/437988/)
→ [Часть 13: компоненты, основанные на классах](https://habr.com/ru/company/ruvds/blog/437990/)
→ [Часть 14: практикум по компонентам, основанным на классах, состояние компонентов](https://habr.com/ru/company/ruvds/blog/438986/)
→ [Часть 15: практикумы по работе с состоянием компонентов](https://habr.com/ru/company/ruvds/blog/438988/)
→ [Часть 16: четвёртый этап работы над TODO-приложением, обработка событий](https://habr.com/ru/company/ruvds/blog/439982/)
→ [Часть 17: пятый этап работы над TODO-приложением, модификация состояния компонентов](https://habr.com/ru/company/ruvds/blog/439984/)
→ [Часть 18: шестой этап работы над TODO-приложением](https://habr.com/ru/company/ruvds/blog/440662/)
→ [Часть 19: методы жизненного цикла компонентов](https://habr.com/ru/company/ruvds/blog/441578/)
→ [Часть 20: первое занятие по условному рендерингу](https://habr.com/ru/company/ruvds/blog/441580/)
→ [Часть 21: второе занятие и практикум по условному рендерингу](https://habr.com/ru/company/ruvds/blog/443210/)
→ [Часть 22: седьмой этап работы над TODO-приложением, загрузка данных из внешних источников](https://habr.com/ru/company/ruvds/blog/443212/)
→ [Часть 23: первое занятие по работе с формами](https://habr.com/ru/company/ruvds/blog/443214/)
→ [Часть 24: второе занятие по работе с формами](https://habr.com/ru/company/ruvds/blog/444356/)
→ [Часть 25: практикум по работе с формами](https://habr.com/ru/company/ruvds/blog/446208/)
→ [Часть 26: архитектура приложений, паттерн Container/Component](https://habr.com/ru/company/ruvds/blog/446206/)
→ [Часть 27: курсовой проект](https://habr.com/ru/company/ruvds/blog/447136/)
Занятие 15. Встроенные стили
----------------------------
→ [Оригинал](https://scrimba.com/p/p7P5Hd/cbyv9hb)
В конце прошлого занятия мы создали компонент, который анализирует время суток и выводит соответствующее приветствие. Вот полный код файла `index.js`, реализующий этот функционал:
```
import React from "react"
import ReactDOM from "react-dom"
function App() {
const date = new Date()
const hours = date.getHours()
let timeOfDay
if (hours < 12) {
timeOfDay = "morning"
} else if (hours >= 12 && hours < 17) {
timeOfDay = "afternoon"
} else {
timeOfDay = "night"
}
return (
Good {timeOfDay}!
=================
)
}
ReactDOM.render(, document.getElementById("root"))
```
Теперь нам нужно стилизовать то, что этот код выводит на страницу. При этом мы собираемся использовать здесь подход, который отличается от рассмотренной ранее [стилизации](https://habr.com/company/ruvds/blog/434120/) элементов с применением CSS-классов. А именно, речь идёт о применении HTML-атрибута `style`. Посмотрим, что произойдёт, если воспользоваться такой конструкцией:
```
Good {timeOfDay}!
=================
```
На самом деле — ничего хорошего. Текст на страницу не попадёт, вместо этого будет выведено сообщение об ошибке. Суть его сводится к тому, что тут, при настройке стилей, ожидается не строковое значение, а объект, содержащий пары вида `ключ: значение`, где ключами являются имена CSS-свойств, а значениями — их значения.
Пытаясь пользоваться HTML-атрибутами в JSX-коде, мы не должны забывать о том, что то, с чем мы работаем, хотя и похоже на обычный HTML-код, им не является. В результате то, как тут будет выглядеть та или иная конструкция, может отличаться от того, что принято в HTML. В данном случае нам нужен обычный JavaScript-объект, содержащий описание стилей. Вооружившись этой идеей, перепишем вышеприведённый фрагмент кода так:
```
Good {timeOfDay}!
=================
```
Так, к сожалению, наш код тоже не заработает. В результате его выполнения снова выведется сообщение об ошибке, правда, не такое, как в прошлый раз. Оно теперь сообщает о том, что там, где система может ожидать фигурную скобку, она находит что-то другое. Для того чтобы решить эту проблему, нужно вспомнить о том, о чём мы говорили на предыдущем занятии. А именно — о том, что JavaScript-код, встраиваемый в JSX, должен быть заключён в фигурные скобки. Те фигурные скобки, которые уже имеются в нашем коде, используются для описания объектного литерала, а не для выделения JS-кода. Исправим это:
```
Good {timeOfDay}!
=================
```
Теперь компонент формирует на странице именно то, что нужно.
*Стилизованный текст, выводимый на страницу компонентом*
Что если мы решим продолжить стилизацию этого текста? Для этого нам нужно вспомнить о том, что стили мы описываем в JS-объекте, а это значит, что в этот объект надо добавить дополнительные пары вида `ключ: значение`. Например, попытаемся стилизовать таким образом фон текста, использовав CSS-свойство `background-color` и дополним код так:
```
Good {timeOfDay}!
=================
```
Такая конструкция приведёт к сообщению об ошибке. Дело тут в том, что стили мы описываем с помощью обычного JS-объекта, а в JavaScript переменные и имена свойств объектов ([идентификаторы](https://developer.mozilla.org/ru/docs/Web/JavaScript/Guide/Grammar_and_types#%D0%9F%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%BD%D1%8B%D0%B5)) не могут содержать символ «-», тире. На самом деле, это ограничение можно обойти, например, заключив имя свойства объекта в кавычки, но в нашем случае это к делу не относится. Мы в подобных ситуациях, когда имена свойств CSS содержат тире, этот символ убираем и делаем первую букву слова, следующего за ним, заглавной. Несложно заметить, что при таком подходе имена свойств CSS будут записываться в верблюжьем стиле — так же, как в JavaScript принято записывать имена переменных, состоящие из нескольких слов. Перепишем код:
```
Good {timeOfDay}!
=================
```
Посмотрим на результаты его работы.
*Стилизованный текст, выводимый на страницу компонентом*
В процессе стилизации текста код объекта со стилями становится всё длиннее. Работать с ним неудобно. Если попытаться разбить этот код на несколько строк, ничего хорошего тоже не получится. Поэтому мы вынесем описание объекта со стилями из JSX-кода, создав константу с именем `styles`, записав в неё объект и использовав её имя в JSX. В результате у нас получится следующее:
```
const styles = {
color: "#FF8C00",
backgroundColor: "#FF2D00"
}
return (
Good {timeOfDay}!
=================
)
```
Этот код работает в точности так же, как и вышеописанный, но такой подход оказывается очень удобным, когда возникает необходимость в добавлении в объект новых стилей. Это не приводит к разрастанию кода, возвращаемого компонентом.
Как видите, сейчас значения CSS-свойств задаются в объекте `styles` в виде строк. При работе с этим объектом стоит учесть некоторые особенности, которые, в частности, касаются свойств, значения которых задаются в виде чисел. Например, это свойство `fontSize` (выглядящее как `font-size` в CSS). Так, это свойство можно задать в виде обычного числа, а не строки, заключённой в кавычки. Например, вполне допустима такая конструкция:
```
const styles = {
color: "#FF8C00",
backgroundColor: "#FF2D00",
fontSize: 24
}
```
Здесь число `24` будет интерпретировано как размер шрифта, указываемый в пикселях. Если единицу измерения нужно указать в явном виде — нам снова нужно будет пользоваться строковыми значениями свойств. Например, следующий фрагмент кода аналогичен, в плане воздействия на размер шрифта, предыдущему, но единица измерения размера тут указана в явном виде:
```
const styles = {
color: "#FF8C00",
backgroundColor: "#FF2D00",
fontSize: "24px"
}
```
Здесь мы указали размер в пикселях, но при необходимости в подобных конструкциях можно использовать и другие единицы измерения.
Говоря о встроенных стилях нельзя не упомянуть и об ограничениях этого подхода. Так, если в стили нужно добавить [префиксы браузеров](https://react-cn.github.io/react/tips/inline-styles.html), это может оказаться немного более сложной задачей чем добавление других стилей. А вот что-то наподобие [псевдокласов](https://developer.mozilla.org/ru/docs/Web/CSS/%D0%9F%D1%81%D0%B5%D0%B2%D0%B4%D0%BE-%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D1%8B), таких как `:hover`, не поддерживается. Если вам это понадобится на данном этапе освоения React — лучше всего будет воспользоваться стилизацией элементов с использованием CSS-классов. А в будущем вам, вероятно, удобнее всего будет пользоваться для подобных целей специализированными библиотеками вроде [styled-components](https://github.com/styled-components/styled-components). Но сейчас мы ограничимся встроенными стилями и стилизацией элементов с помощью CSS-классов.
Возможно, после того, как вы узнали об этом ограничении встроенных стилей, вы зададитесь вопросом о том, зачем пользоваться ими, если CSS-классы позволяют добиться того же эффекта и обладают более обширными возможностями. Одна из причин использования встроенных стилей в React заключается в том, что такие стили можно формировать динамически. При этом то, каким будет тот или иной стиль, определяется средствами JavaScript-кода. Перепишем наш пример так, чтобы цвет текста менялся бы в зависимости от времени суток, в которое выводится сообщение.
Вот полный код компонента, в котором используется динамическое формирование стилей.
```
function App() {
const date = new Date()
const hours = date.getHours()
let timeOfDay
const styles = {
fontSize: 30
}
if (hours < 12) {
timeOfDay = "morning"
styles.color = "#04756F"
} else if (hours >= 12 && hours < 17) {
timeOfDay = "afternoon"
styles.color = "#2E0927"
} else {
timeOfDay = "night"
styles.color = "#D90000"
}
return (
Good {timeOfDay}!
=================
)
}
```
Обратите внимание на то, что объявление константы `styles` теперь находится перед блоком `if`. В объекте, определяющем стиль, установлен лишь размер шрифта надписи — `30` пикселей. Затем в объект добавляют свойство `color`, значение которого зависит от времени суток. Напомним, что речь идёт о совершенно обычном объекте JavaScript, а такие объекты поддерживают добавление и изменение свойств после их создания. После того, как стиль сформирован, он применяется при выводе текста. Для того чтобы быстро протестировать все ветви условного оператора, можно, при инициализации константы `date`, передать конструктору объекта типа `Date` желаемые дату и время. Например, это может выглядеть так:
```
const date = new Date(2018, 6, 31, 15)
```
Собственно говоря, смысл этого всего заключается в том, что динамические данные могут воздействовать на то, как выглядят элементы, формируемые компонентами. Это открывает перед разработчиком большие возможности.
Итоги
-----
Сегодня мы поговорили о встроенных стилях, об их возможностях и ограничениях. На следующем занятии мы продолжим работу над TODO-приложением, а также начнём знакомство со свойствами компонентов, с важнейшей концепцией React. Поэтому всем, кто занимается по этому курсу, рекомендовано, прежде чем продолжать учёбу, как следует всё повторить и поэкспериментировать со всем тем, что мы к данному моменту разобрали.
**Уважаемые читатели!** Если вы хорошо разбираетесь в React-разработке, просим рассказать о том, какими библиотеками для стилизации компонентов вы пользуетесь.
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/435468/ | null | ru | null |
# Фильтрация изображений методом свертки
Автором данного топика является хабраюзер [Popik](https://habrahabr.ru/users/popik/), который сам не может запостить этот топик в силу астральных причин.
Введение.
---------
 Вероятно, большинство хабросообщества не понаслышке знает о фильтрах обработки изображений, таких как размытие, повышение резкости, нахождение краев, тиснение и прочие. Некоторые работали с ними более тесно, некоторые использовали их как данность. Однако все ли знают, как именно происходит фильтрация изображения, и что общего между перечисленными фильтрами? В данном топике я постараюсь в общем виде описать алгоритм, по которому это все выполняется, а так же приведу его реализацию.
Немного теории.
---------------
Итак, фильтры, которые были перечислены, а так же множество других основаны на свертке. Что же такое свертка? Свертка (англ. convolution) — это операция, показывающая «схожесть» одной функции с отражённой и сдвинутой копией другой. Понятие свёртки обобщается для функций, определённых на группах, а также мер. Несколько сложноватое определение, не так ли? Те, кому интересна математическая теоретическая часть, могут заглянуть по ссылке на [Википедию](http://ru.wikipedia.org/wiki/Свёртка_(математический_анализ)), и, возможно, почерпнуть для себя что нибудь полезное.
Я же постараюсь дать свое определение-объяснение свертки «на пальцах» только для случая обработки изображений, которое может быть, не настолько умное и точное как в научной литературе, но как мне кажется, позволяющее понять суть данного процесса.
Итак, свертка – это операция вычисления нового значения выбранного пикселя, учитывающая значения окружающих его пикселей. Для вычисления значения используется матрица, называемая *ядром свертки*. Обычно ядро свертки является квадратной матрицей n\*n, где n — нечетное, однако ничто не мешает сделать матрицу прямоугольной. Во время вычисления нового значения выбранного пикселя ядро свертки как бы «прикладывается» своим центром (именно тут важна нечетность размера матрицы) к данному пикселю. Окружающие пиксели так же накрываются ядром. Далее высчитывается сумма, где слагаемыми являются произведения значений пикселей на значения ячейки ядра, накрывшей данный пиксель. Сумма делится на сумму всех элементов ядра свертки. Полученное значение как раз и является новым значением выбранного пикселя. Если применить свертку к каждому пикселю изображения, то в результате получится некий эффект, зависящий от выбранного ядра свертки.
На этом мы закончим с теорией, и перейдем к примерам и реализации данного алгоритма. Мозг еще жив? :)
Несколько примеров.
-------------------
Реализация алгоритма.
---------------------
Приведу лишь главную часть кода на C#, полный исходный код свертки и небольшую программку для наглядного тестирования можно будет скачать по ссылке в конце статьи. Оговорюсь заранее, что код не писался как нечто очень оптимальное, и поле для оптимизаций еще есть. Например повысить скорость можно использованием предвычисленных значений пикселей, но не в этом суть.
> `public static class Convolution
>
> {
>
> public static Bitmap Apply(Bitmap input, double[,] kernel)
>
> {
>
> //Получаем байты изображения
>
> byte[] inputBytes = BitmapBytes.GetBytes(input);
>
> byte[] outputBytes = new byte[inputBytes.Length];
>
>
>
> int width = input.Width;
>
> int height = input.Height;
>
>
>
> int kernelWidth = kernel.GetLength(0);
>
> int kernelHeight = kernel.GetLength(1);
>
>
>
> //Производим вычисления
>
> for (int x = 0; x < width; x++)
>
> {
>
> for (int y = 0; y < height; y++)
>
> {
>
> double rSum = 0, gSum = 0, bSum = 0, kSum = 0;
>
>
>
> for (int i = 0; i < kernelWidth; i++)
>
> {
>
> for (int j = 0; j < kernelHeight; j++)
>
> {
>
> int pixelPosX = x + (i - (kernelWidth / 2));
>
> int pixelPosY = y + (j - (kernelHeight / 2));
>
> if ((pixelPosX < 0) ||
>
> (pixelPosX >= width) ||
>
> (pixelPosY < 0) ||
>
> (pixelPosY >= height)) continue;
>
>
>
> byte r = inputBytes[3 \* (width \* pixelPosY + pixelPosX) + 0];
>
> byte g = inputBytes[3 \* (width \* pixelPosY + pixelPosX) + 1];
>
> byte b = inputBytes[3 \* (width \* pixelPosY + pixelPosX) + 2];
>
>
>
> double kernelVal = kernel[i, j];
>
>
>
> rSum += r \* kernelVal;
>
> gSum += g \* kernelVal;
>
> bSum += b \* kernelVal;
>
>
>
> kSum += kernelVal;
>
> }
>
> }
>
>
>
> if (kSum <= 0) kSum = 1;
>
>
>
> //Контролируем переполнения переменных
>
> rSum /= kSum;
>
> if (rSum < 0) rSum = 0;
>
> if (rSum > 255) rSum = 255;
>
>
>
> gSum /= kSum;
>
> if (gSum < 0) gSum = 0;
>
> if (gSum > 255) gSum = 255;
>
>
>
> bSum /= kSum;
>
> if (bSum < 0) bSum = 0;
>
> if (bSum > 255) bSum = 255;
>
>
>
> //Записываем значения в результирующее изображение
>
> outputBytes[3 \* (width \* y + x) + 0] = (byte)rSum;
>
> outputBytes[3 \* (width \* y + x) + 1] = (byte)gSum;
>
> outputBytes[3 \* (width \* y + x) + 2] = (byte)bSum;
>
> }
>
> }
>
> //Возвращаем отфильтрованное изображение
>
> return BitmapBytes.GetBitmap(outputBytes, width, height);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
[**Скачать программу пример**](http://d-popov.ru/code/Convolution.rar)
Вот и все. Надеюсь что данный материал был полезен и преподнес вам что-то новое. Если данная тема вас заинтересовала, то могу написать еще про базовые методы формирования ядер свертки, а так же про оптимизации данного алгоритма. Спасибо за внимание! | https://habr.com/ru/post/62738/ | null | ru | null |
# PortablePy: компьютер-раскладушка для MicroPython
Признаю: мне очень нравится та невероятная скорость, с которой загружаются домашние компьютеры 1980-х годов. Я какое-то время пытался оптимизировать время загрузки Raspberry Pi, но особенно далеко в этом деле не продвинулся. Я, кроме того, большой поклонник специализированных устройств, в которых аппаратное обеспечение используется для решения какой-то одной задачи. Такие системы тоже работают очень быстро. MicroPython — это очень интересная разработка, попадающая в сферу моих интересов. Это, с одной стороны — «язык высокого уровня», а с другой — программный комплекс, который без особых сложностей работает на весьма скромных аппаратных ресурсах.
[](https://habr.com/ru/company/ruvds/blog/537900/)
У меня, вдобавок, есть одна мечта. Заключается она в том, чтобы у меня была бы возможность писать программы на ходу, используя минималистичное специализированное устройство. Вот какие попытки добраться до этой мечты я уже делал:
* [StickPi](https://assadollahi.de/stickpi-a-raspberry-pi-zero-w-with-gpio-buttons-and-an-e-paper-display/): очень маленькое устройство, основанное на Raspberry Pi Zero с e-paper-дисплеем, но без клавиатуры и без батареи, к которому можно подключаться с компьютера по SSH.
* [PocketPi](https://assadollahi.de/pocketpi/): устройство, основанное на Raspberry Pi Zero, питающееся от батарей, оснащённое 4-дюймовым экраном [HyperPixel](https://shop.pimoroni.com/products/hyperpixel-4?variant=12569539706963) (800x480 пикселей) и миниатюрной клавиатурой.
* [PsionPi](https://assadollahi.de/psionpi/): мой свежий проект, основанный на Raspberry Pi 3a+, работающий от батарей, оснащённый клавиатурой от Psion 5 Series, в состав которого входит Arduino-контроллер клавиатуры и 7-дюймовый дисплей с разрешением 800x480.
* Ещё один [проект](https://www.youtube.com/watch?reload=9&v=7MtBNnwIpPg), подробностей о котором я пока не публиковал, представляющий собой устройство, в состав которого входит 5-дюймовый дисплей, Raspberry Pi 3 и миниатюрная клавиатура.
Собственно говоря, все эти проекты объединяет то, что в них используются разные варианты платы Raspberry Pi. Когда же вышел [Adafruit PyPortal Titano](https://learn.adafruit.com/adafruit-pyportal-titano), я тут же влюбился в это устройство, так как оно объединяет в себе много интересного «железа» и 3,5-дюймовый дисплей с разрешением 320x480, который я, кроме того, «примерял» к своему проекту PocketPi.
Я, кроме того, недавно узнал о существовании электронных компонентов производства [M5Stack](https://m5stack.com/), и об их миниатюрной и недорогой QWERTY-клавиатуре [CardKB Mini](https://m5stack.com/products/cardkb-mini-keyboard) с поддержкой I2C, которая меня прямо-таки «зацепила». Эта клавиатура использует Arduino для чтения данных с массива клавиш и для перевода информации о нажатии на клавиши в коды, которые можно передать во внешний мир. В результате это — моя третья клавиатура, в которой используется Arduino ([первая](https://assadollahi.de/my-first-working-mechanical-keyboard/) — это механическая клавиатура, вторая — клавиатура для моего недавнего проекта [PsionPi](https://assadollahi.de/psionpi/)). У Adafruit PyPortal Titano имеется поддержка I2C. Поэтому я решил попробовать «подружить» это устройство и CardKB Mini.
*Adafruit PyPortal Titano, CardKB Mini и источник питания*
Первым делом мне хотелось соединить устройства и посмотреть на то, как пользоваться клавиатурой для ввода текста без применения компьютера или USB-клавиатуры. Клавиатура видна по адресу `0x5f`, для наладки работы с ней нужно просто транслировать коды клавиш в буквы. Конечно, нужно привязать к соответствующим действиям разные специальные клавиши, вроде Delete, Backspace и Return. В результате получится нечто вроде минималистичного текстового редактора.
[Вот](https://youtu.be/V2-epYNLpMc) видеодемонстрация совместной работы Adafruit PyPortal Titano и CardKB Mini.
Теперь нужно было спроектировать корпус. Я никогда не занимался разработкой корпусов-раскладушек. Поэтому корпус мне хотелось сделать как можно более простым — просто чтобы узнать о том, будет ли мне удобно писать код на устройстве, находящемся в этом корпусе. Я начал с обычных монолитных корпусов и исследовал разные устройства.
*Карманный калькулятор Casio, моё устройство, Nokia E61*
Карманный калькулятор Casio с предыдущего рисунка, на самом деле, обладает корпусом-раскладушкой. А вот мой любимый [Nokia E61](https://en.wikipedia.org/wiki/Nokia_E61), в плане дизайна, гораздо ближе к тому, что получилось у меня. Размеры чёрного основания устройства составляют 125x100 мм, что хорошо, да и, в любом случае, сильнее уменьшить готовое устройство не получится. В общем-то, монолитный корпус надоел мне сразу же после того, как завершилась его печать…
С другой стороны, логичным развитием идеи разработки корпуса, в плане его форм-фактора, является движение в сторону корпуса-раскладушки. Когда я держал в руках старый Game Boy Advance SP, я чувствовал, что хочу слышать приятный звук закрывания такого корпуса, и что мне хочется, чтобы у меня был бы миниатюрный компьютер, напоминающий этот Game Boy.
*Модель корпуса в Tinkercad и Game Boy*
Теперь размер основания составлял 100x80 мм, да и шарнир получился хороший. Я, кроме того, добавил магниты по углам корпуса для того чтобы зафиксировать его части, но эти магниты оказались не очень сильными и занимали много ценного пространства.
В [этом](https://youtu.be/osU-jsOoGdk) видео показано сравнение Game Boy и моего корпуса-раскладушки.
Я, из интереса, попробовал разместить в новом корпусе экран из моего проекта PocketPi.
*Экран от PocketPi в новом корпусе*
Для того чтобы этой конструкцией можно было бы пользоваться, нужно поместить под экран Raspberry Pi Zero, подключить к экрану и к плате питание и соединить их друг с другом (не по WiFi).
Теперь пришло время заняться проектированием источника питания. В этот раз я решил не пользоваться платой Adafruit PowerBoost. Мне кажется, что она слишком дорогая, да и греется она очень сильно. У меня была пара подобных плат — более дешёвых, но и более крупных. Поэтому я решил попробовать воспользоваться ими. Для того чтобы сделать всю конструкцию тоньше и сэкономить место, я убрал USB-порт.
*Работа над системой питания*
Я, опять же, чтобы устройство было тоньше, убрал разъёмы с PyPortal и подключил питающий кабель напрямую, используя соответствующую [схему](https://learn.adafruit.com/assets/72170).
*Подключение питания к PyPortal*
И, наконец, я убрал разъём с клавиатуры и просто спаял компоненты моего компьютера.
*Компоненты компьютера, подключённые друг к другу*
Мне пришлось кое-что изменить в корпусе и сделать в нём отверстия для USB-C-разъёма PyPortal, для выключателя питания и Micro-USB-порта, используемого для зарядки устройства. Потом я разместил в корпусе подсистему питания.
*Размещение компонентов в корпусе*
Клавиатуру я закрепил с помощью двустороннего скотча.
*Готовое устройство*
[Тут](https://youtu.be/8W6p8-zu-yc) можно посмотреть на мой компьютер в деле. Я, после съёмки этого видео, доработал корпус, сделал так, чтобы он нормально закрывался бы, и убрал магнитные держатели, что позволило выделить больше места для внутренних компонентов. [Файлы](https://www.thingiverse.com/thing:4697279) для печати корпуса можно найти на Thingiverse.
Я написал на Python небольшую утилиту для работы с файлами и минималистичный редактор. Сейчас проблема заключается в невозможности записи данных во флэш-память платы при подключении её к компьютеру по USB-C. И мне ещё надо разобраться с тем, можно ли писать во флэш-память при работе устройства от батареи. Я продолжаю заниматься этим проектом, и, вполне возможно, ещё что-нибудь о нём расскажу.
Хотите сделать себе миниатюрный узкоспециализированный компьютер?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=ruvds&utm_content=router-hack#order) | https://habr.com/ru/post/537900/ | null | ru | null |
# Обрезаем фото в стиле «ВКонтакте»
В этом HOWTO я раскажу вам как обрезать фотографию до нужного вам размера и залить её на сервер с помощью Ruby on Rails.
Итак, для наших целей наиболее подходят 2 плагина:
[Prototype JavaScript Image Cropper UI](http://www.defusion.org.uk/demos/060519/cropper.php?demoType=preview&image=castle&formSubmit=Load+demo)
[jQuery image crop plugin](http://deepliquid.com/projects/Jcrop/demos.php)
Написаны они, как вы понимает на 2 разных библиотеках, и так как в моем проекте уже был установлен [JRails](http://ennerchi.com/projects/jrails) и второй плагин мне показался более продвинутым, я остановил свой выбор на нем. Но суть примера от этого не меняется.
Я не буду тратить время на рассказ о том, как сделать Hello world на RoR, поэтому просто создадим модель и контроллер:
> ````
>
> $ script/generate model upload description:string
> $ script/generate paperclip upload photo
> $ script/generate controller uploads
>
> ````
> ````
> #models/upload.rb
>
> class Upload < ActiveRecord::Base
>
> has_attached_file :photo,
> :styles => {
> :thumb => ["100x100", :jpg],
> :pagesize => ["500x400", :jpg],
> },
> :default_style => :pagesize
> end
> ````
Подключаем библиотеки:
> ````
>
> # views/layouts/application.html.erb
>
> <%= javascript_include_tag 'lib/jquery.min.js' %>
> <%= javascript_include_tag 'cropper/jquery.jcrop.js' %>
>
> ````
И делаем представление «Edit»:
> ````
>
> # view/uploads/edit.html.erb
>
>
> function showCoords( c ) {
> $( 'upload\_x1' ).val(c.x);
> $( 'upload\_y1' ).val(c.y);
> $( 'upload\_width' ).val(c.w);
> $( 'upload\_height' ).val(c.h);
> }
> $(function(){
> $('#jcrop\_target').Jcrop({
> onChange: showCoords,
> onSelect: showCoords
> });
> });
>
>
> Editing upload
> ==============
>
>
>
> <% form_for(@upload) do |f| %>
> <%= f.error_messages %>
>
>
> <%= f.label :description %>
>
> <%= f.text\_field :description %>
>
>
>
>
>
>
> <%= image\_tag @upload.photo.url, :id => 'cropimage' %>
>
>
>
> <%= f.label 'x1' %>
> <%= f.text\_field 'x1', :size => 6 %>
>
>
> <%= f.label 'y1' %>
> <%= f.text\_field 'y1', :size => 6 %>
>
>
> <%= f.label 'width' %>
> <%= f.text\_field 'width', :size => 6 %>
>
>
> <%= f.label 'height' %>
> <%= f.text\_field 'height', :size => 6 %>
>
>
>
>
>
>
> <%= f.submit "Update" %>
>
>
>
> <% end %>
>
> ````
Почти все, добавляем событие update:
> ````
>
> # controllers/uploads_controller.rb
>
> def update
> @upload = Upload.find params[:id]
> if @upload.update_attributes params[:upload]
> flash[:notice] = 'Upload was successfully updated.'
> redirect_to @upload
> else
> render :action => "edit"
> end
> end
>
> ````
И наконец вот она, основная магия:
> ````
>
> # models/upload/upload.rb
>
> require 'RMagick'
>
> attr_accessor :x1, :y1, :width, :height
>
> def update_attributes(att)
>
> scaled_img = Magick::ImageList.new(self.photo.path)
> orig_img = Magick::ImageList.new(self.photo.path(:original))
> scale = orig_img.columns.to_f / scaled_img.columns
>
> args = [ att[:x1], att[:y1], att[:width], att[:height] ]
> args = args.collect { |a| a.to_i * scale }
>
> orig_img.crop!(*args)
> orig_img.write(self.photo.path(:original))
>
> self.photo.reprocess!
> self.save
>
> super(att)
> end
>
> ````
Здесь мы рассчитываем коэффициент масштабирования. Далее мы готовим четыре аргумента для RMagick crop функции, которая ожидает X1, Y2, ширину и высоту. Изображение изменяется и записывается заменив собой оригинал.
Все, всем спасибо за внимание. [Здесь пример для prototype.](http://www.mfischer.com/2009/02/02/multiple-image-upload-and-crop-with-rails/) | https://habr.com/ru/post/62585/ | null | ru | null |
# C#: Внутреннее строение инициализаторов массивов
Наверняка почти каждому, кто имел дело с C#, известна подобная конструкция:
```
int[] ints = new int[3] { 1,2,3 };//А если уж вдруг и не была известна, то отныне и впредь уж точно
```
Вполне логично было-бы ожидать превращение этой конструкции в нечто подобное:
```
int[] ints = new int[3];
ints[0] = 1;
ints[1] = 2;
ints[2] = 3;
```
Увы и ах, на деле орех гораздо более морщинист, чем кажется с первого взгляда, и имеются некоторые тонкости, на которые будет указано позже. А до тех пор, наденем ношеную «IL freak» майку (у кого имеется) и погрузимся в недра реализации.
В конечном итоге, первая конструкция превратится компилятором в такую вот загогулину:
Что за диво в моём саду? Что это за **blablabla** ерундовина? Прежде чем я расскажу что к чему, давайте бросим наш взгляд на **Q**::**Main**, где я указал значение в вершине стека перед каждой строкой кода:
```
.method private hidebysig static void Main() cil managed
{
.entrypoint
// Code size 20 (0x14)
.maxstack 3
.locals init (int32[] V_0)
IL_0000: nop
// {}
IL_0001: ldc.i4.3
// {3}
IL_0002: newarr [mscorlib]System.Int32
// {∫[3]}
IL_0007: dup
// {∫[3], ∫[3]}
IL_0008: ldtoken field valuetype '{8C802ECE-B24C-4A20-AE34-9303FE2DD066}'/'\_\_StaticArrayInitTypeSize=12' '{8C802ECE-B24C-4A20-AE34-9303FE2DD066}'::'$$method0x6000001-1'
// {∫[3], ∫[3], #'$$method0x6000001-1'}
IL\_000d: call void [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array,
valuetype [mscorlib]System.RuntimeFieldHandle)
// {∫[3]}
IL\_0012: stloc.0
// {}
IL\_0013: ret
} // end of method Q::Main
```
Давайте теперь проведём построчный анализ:
*IL\_0001* и *IL\_0002* — создаётся новый массив типа **System.Int32** и размерностью 3.
На *IL\_0007* нам попадается первый сюрприз в виде дублированной ссылки на массив. Почему? Предположим, что на *IL\_0008* и *IL\_0009* происходит инициализация массива (совсем скоро к этому месту мы вернёмся). А теперь посмотрим на *IL\_0012*, где значение в вершине стека — опять массив — присвоен локальной переменной с индексом 0, т.е. переменной **ints**. А что если мы присвоим значение переменной **ints** на *IL\_0007*? А произойдёт вот что:
```
ldc.i4.3
newarr [mscorlib]System.Int32
stloc.0 //внимание сюда
ldloc.0 //и сюда
ldtoken field valuetype '{8C802ECE-B24C-4A20-AE34-9303FE2DD066}'/'\_\_StaticArrayInitTypeSize=12' '{8C802ECE-B24C-4A20-AE34-9303FE2DD066}'::'$$method0x6000001-1'
call void [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array,
valuetype [mscorlib]System.RuntimeFieldHandle)
```
Присвоение более не будет атомарным: с этого момента, внешний наблюдатель заметит массив в неинициализированном состоянии, без элементов. Именно этим и занимаются строки *IL\_0008* и *IL\_0009*. Т.о. приведённый в самом начале код не эквивалентен конструкции:
```
nt[] ints = new int[3];
ints[0] = 1;
ints[1] = 2;
ints[2] = 3;
```
А скорее представляет из себя нечто вроде этого:
```
int[] t = new int[3];
t[0] = 1;
t[1] = 2;
t[2] = 3;
int[] ints = t;
```
Хотя реализация избегает создания двух локальных переменных. Это двигает нас к двум заумным строчкам кода:
```
IL_0008: ldtoken field valuetype '{8C802ECE-B24C-4A20-AE34-9303FE2DD066}'/'\_\_StaticArrayInitTypeSize=12' '{8C802ECE-B24C-4A20-AE34-9303FE2DD066}'::'$$method0x6000001-1'
IL\_000d: call void [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle)
```
Но ничего сложного и/или страшного в этом нет. По сути, мы наблюдаем вызов [RuntimeHelpers.InitializeArray](http://msdn.microsoft.com/en-us/library/system.runtime.compilerservices.runtimehelpers.initializearray%28v=vs.110%29.aspx), который заполняет поле, токен которого помещён в стек на *IL\_0008*, массивом, ссылка на который находится в вершине стека после выполнения *IL\_0007*. Значение токена соотвествует картинке ниже:
На деле, выделенная линия являет собой статично поле в приватном и, очевидно, сгенерированном компилятором, классе с очевидно непроизносимым названием. Пара моментов, на которые следует обратить внимание. Во-первых, этот класс имеет вложенный класс, названный **\_\_StaticArrayInitTypeSize=12**. Он являет собой массив фактическим размером в 12 байт (по 4 байта на каждый элемент **System.Int32**, размер каждого равен 4 байта, итого 12). Во-вторых, следует заметить что тип наследует **System.ValueType** (я всерьёз надеюсь на то, что читатели знакомы с судьбой экземпляров значимых типов после их создания в стеке, так что не будем на этом застрять внимания — *прим. автора.*). Но каким образом тип получает те самые 12 байт? Очевидно что просто подсунуть имя недостаточно для того, чтобы clr выделила необходимое количество памяти, так что если вы посмотрите на реализацию через ILDASM вы увидите вот что:
```
.class private auto ansi '{8C802ECE-B24C-4A20-AE34-9303FE2DD066}'
extends [mscorlib]System.Object
{
.custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 )
.class explicit ansi sealed nested private '\_\_StaticArrayInitTypeSize=12'
extends [mscorlib]System.ValueType
{
.pack 1
.size 12 //внимание сюда и тут
} // end of class '\_\_StaticArrayInitTypeSize=12'
.field static assembly valuetype '{8C802ECE-B24C-4A20-AE34-9303FE2DD066}'/'\_\_StaticArrayInitTypeSize=12' '$$method0x6000001-1' at I\_00002050
} // end of class '{8C802ECE-B24C-4A20-AE34-9303FE2DD066}'
```
Директива **.size** как-бы говорит и нам, и clr о том, что необходимо выделить блок памяти в 12 байт в момент создания экземпляра этого типа. Если вам любопытно о роли директивы **.pack**, то суть проста: эта директива указывает выравнивание по указанной степени двойки (поддерживаются только значения от 2 до 128 (при значении 1 выравнивание, очевидно, отсутствует — *прим. перев*)). Необходимо для COM-совместимости. Вернёмся к полю:
```
.field static assembly valuetype '{8C802ECE-B24C-4A20-AE34-9303FE2DD066}'/'\_\_StaticArrayInitTypeSize=12' '$$method0x6000001-1' at I\_00002050
```
Тип довольно простой, несмотря на то, что имя довольно длинное из-за вложенности типов. В нашем случае, **'$$method0x6000001-1'** это имя поля. Но самое интересное начинается после "**at**". Это т.н. **data-label**, который, в свою очередь, является куском данных где-то в PE-файле на данном смещении. Непосредственно в ILADSM вы увидите нечто подобное:
```
.data cil I_00002050 = bytearray (
01 00 00 00 02 00 00 00 03 00 00 00)
```
Это и есть обьявление **data label**, которое является, как уже видно, последовательностью байт конечного массива в little-endian. Теперь мы должны понимать как работает [InitailizeArray](http://msdn.microsoft.com/en-us/library/system.runtime.compilerservices.runtimehelpers.initializearray%28v=vs.110%29.aspx):
```
call void [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle)
```
Передаётся экземпляр массива (мы уже создали его командами *IL\_0001*,*IL\_0002*) и указатель на поле, указанное после ключевого слова "**at**", в которое завёрнуты данные массива. Т.о. среда исполнения способна посчитать необходимое количество байт для чтения по заданному адресу, конструируя таким образом массив. В свою очередь, смысл значения **I\_00002050** не являет собой никакой загадки — это преобыкновеннейший [RVA](http://en.wikipedia.org/wiki/COFF#Relative_Virtual_Address). Вы можете в этом убедиться, используя dumpbin:
 Но есть не менее занятная деталь: компилятор переиспользует тип **\_\_StaticArrayInitTypeSize** когда массивы занимают одинаковое количество места в памяти. Т.о. листинг:
```
int[] ints = { 1, 2, 3, 4, 5, 6, 7, 8 };
long[] longs = { 1, 2, 3, 4 };
byte[] bytes = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32 };
```
Заставляет компилятор использовать один и тот-же тип, ибо все массивы в памяти занимают по 32 байта:
```
.field static assembly valuetype '{AA6C9D77-5FAD-47E0-8B55-1D8739074F1F}'/'\_\_StaticArrayInitTypeSize=32' '$$method0x6000001-1' at I\_00002050
.field static assembly valuetype '{AA6C9D77-5FAD-47E0-8B55-1D8739074F1F}'/'\_\_StaticArrayInitTypeSize=32' '$$method0x6000001-2' at I\_00002070
.field static assembly valuetype '{AA6C9D77-5FAD-47E0-8B55-1D8739074F1F}'/'\_\_StaticArrayInitTypeSize=32' '$$method0x6000001-3' at I\_00002090
.data cil I\_00002050 = bytearray (
01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00
05 00 00 00 06 00 00 00 07 00 00 00 08 00 00 00)
.data cil I\_00002070 = bytearray (
01 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00
03 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00)
.data cil I\_00002090 = bytearray (
01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10
11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20)
```
Так-же, для массивов размером в 1 и 2 элемента, будет генерировать такой IL код:
```
.method private hidebysig static void Main() cil managed
{
.entrypoint
// Code size 19 (0x13)
.maxstack 3
.locals init (int32[] V_0,
int32[] V_1)
IL_0000: nop
IL_0001: ldc.i4.2
IL_0002: newarr [mscorlib]System.Int32
IL_0007: stloc.1
//
// V_1[0] = 1
//
IL_0008: ldloc.1
IL_0009: ldc.i4.0
IL_000a: ldc.i4.1
IL_000b: stelem.i4
//
// V_1[1] = 2
//
IL_000c: ldloc.1
IL_000d: ldc.i4.1
IL_000e: ldc.i4.2
IL_000f: stelem.i4
//
// V_0 = V_1
//
IL_0010: ldloc.1
IL_0011: stloc.0
IL_0012: ret
} // end of method Q::Main
```
А вот, собственно, и тот самый фокус с двумя локальными переменными: одна из них является временной, в которую и помещаются значения по мере заполнения массива, после чего ссылка на массив передаётся основной переменной. Причины же такого подхода (с отдельным методом для заполнения массива) очевидны: в случае наивной реализации мы бы имели по 4 команды на каждый элемент, что увеличивало бы обьём кода построения массива линейно пропорционально размеру массива, вместо этого обьём кода константен.
p.s. В статье приведено поведение компиляторов C# 2.0 и 3.0 версий от Microsoft. Поведение кода, сгенерированного компиляторами других версий или компиляторов от сторонних разработчиков (например, Mono), может отличаться от приведённого в статье. | https://habr.com/ru/post/247047/ | null | ru | null |
# Рассуждения об asyncio.Semaphore
В Кремниевой долине есть очень особенный ресторан фаст-фуда, который всегда открыт. Там имеется один столик, за ним может разместиться лишь один посетитель, которому дадут совершенно фантастический гамбургер. Когда туда приходишь — ждёшь до тех пор, пока не настанет твоя очередь. Потом хозяин ресторана подведёт тебя к столику, и, это же Америка, тебе зададут, кажется, бесконечное количество вопросов о том, как приготовить и как подать твой гамбургер.
Сегодня, правда, мы не собираемся говорить о кулинарных изысках. Мы говорим о системе очередей, которую используют рестораны. Если вам повезло и вы прибыли в ресторан тогда, когда столик пуст, и когда никого в очереди нет, вы можете прямо сразу за него сеть. В противном случае хозяин даст вам специальный пейджер (из бескрайней кучи таких пейджеров!) и вы можете бродить вокруг ресторана до тех пор, пока этот пейджер не подаст сигнал. Дело хозяина ресторана — обеспечить, чтобы посетители попадали бы за столик в порядке их прибытия. Когда настанет ваша очередь, хозяин отправит сигнал на ваш пейджер, а вы вернётесь в ресторан, где сможете усесться за столик.
Если вы передумали — можете вернуть пейджер хозяину, а он, ни слова не сказав, спокойно его заберёт. Если ваш пейджер уже сработал, то хозяин, если на вас очередь не оканчивается, вызовет следующего посетителя. Посетители этого ресторана всегда вежливы, они, получив пейджер, не уходят украдкой, никого не предупредив. А хозяин всегда честен и не усадит за столик кого-то, кто стоит в очереди за вами, даже если вам, чтобы вернуться в ресторан после срабатывания пейджера, нужно некоторое время.
Вышеприведённое описание соответствует описанию класса [Lock](https://docs.python.org/3.12/library/asyncio-sync.html#asyncio.Lock), представляющего взаимно исключающую блокировку. Когда посетитель приходит в ресторан — это то же самое, что вызов `acquire()`, а уход из ресторана — это вызов `release()`. Если посетитель, после того, как стал в очередь, решил уйти — это отмена операции во время ожидания в `acquire()`. Решить уйти можно до срабатывания пейджера или после этого. То есть — отменить операцию можно до или после того, как блокировка активировала ваш вызов (но до возврата из `acquire()`).
Однажды ресторан расширится, наймёт ещё помощников шеф-повара, в нём поставят несколько новых столов. У ресторана, как и прежде, будет один хозяин, работа которого, на самом деле, не особо изменится. Но, так как одновременно в ресторане можно будет разместить несколько посетителей, теперь, вместо простой блокировки, придётся использовать семафор — класс [Semaphore](https://docs.python.org/3.12/library/asyncio-sync.html#asyncio.Semaphore).
Оказывается, реализация примитивов синхронизации — дело непростое. В случае с библиотекой `asyncio` это несколько неожиданно, так как единовременно может выполняться только одна задача, а переключение задач выполняется лишь в `await`. Но в прошлом году под сомнение были поставлены такие вещи, как [справедливость распределения ресурсов](https://github.com/python/cpython/issues/90155), обеспечиваемая `asyncio`, её [корректность](https://github.com/python/cpython/issues/90155#issuecomment-1247764412), [семантика](https://github.com/python/cpython/issues/97028) и [производительность](https://github.com/python/cpython/issues/97545). На самом деле, три последних жалобы появились в прошлом месяце. Мне, последнему, кто занимается задачами с метками [expert-asyncio](https://github.com/python/cpython/labels/expert-asyncio), приходится в спешке разбираться с тем, как лучше всего представить себе семафоры.
Метафора с рестораном оказалась очень полезной. Например, есть разница между количеством свободных столиков и количеством посетителей, которых можно безотлагательно за столики усадить. Эта разница равна количеству посетителей, пейджеры которых сработали, но которые ещё не подошли после этого к хозяину ресторана.
В деле справедливого распределения ресурсов есть одна особая проблема, которая проявляется, когда задача, освободившая семафор и немедленно пытающаяся снова его захватить, может дискриминировать другие задачи. Это — то же самое, как если бы посетитель ресторана встал из-за столика, вышел бы из ресторана, тут же вернулся бы и уселся бы за столик снова, не обращая внимания на очередь из других посетителей.
В библиотеке была ошибка, когда отменённый вызов `acquire()` мог оставить блокировку в неправильном состоянии. Это — как если бы хозяин ресторана пришёл бы в замешательство, когда посетитель со сработавшим пейджером возвращает пейджер, но отказывается садиться за столик.
Но ресторанная метафора не способна помочь во всех ситуациях. Дело в том, что при отмене `acquire()` в `asyncio` происходит сложная последовательность событий. В Python 3.11 мы начали нагружать операцию отмены дополнительными задачами из-за двух новых добавленных нами в систему асинхронных менеджеров контекста:
* Класс [TaskGroup](https://docs.python.org/3.12/library/asyncio-task.html#task-groups) используется для управления группами родственных задач. Если одна из задач даёт сбой, другие отменяются, а менеджер контекста ожидает выхода всех задач.
* Функция [timeout()](https://docs.python.org/3.12/library/asyncio-task.html#asyncio.timeout) применяется для управления тайм-аутами. Когда срабатывает тайм-аут — текущая задача отменяется.
Вот основные сложности, которые возникают при обработке отмен задач:
* В процессе ожидания завершения работы объекта класса [Future](https://docs.python.org/3.12/library/asyncio-future.html#asyncio.Future), представляющего собой конечный результат асинхронной операции, эта операция может быть отменена. После этого операция `await` завершается с ошибкой, вызывая исключение [CancelledError](https://docs.python.org/3.12/library/asyncio-exceptions.html#asyncio.CancelledError).
* Но когда объект `Future` находится в состоянии ожидания и вызывается `CancelledError`, нельзя предполагать, что операция этого объекта была отменена! Возможно и такое, что объект `Future` уже помечен как имеющий результат (то есть — его больше нельзя отменить), а задача была помечена как готовая к выполнению. Но другая (тоже готовая к выполнению) задача запускается первой и отменяет первую задачу. Выражаю благодарность пользователю Cyker Way за то, что указал на эту исключительную ситуацию.
Это помогает представить себе объект `Future` как нечто, пребывающее в одном из четырёх состояний:
* Ожидание.
* Завершение работы, имеется результат.
* Завершение работы, имеется исключение.
* Завершение работы, но это — следствие отмены операции.
Из состояния ожидания объект `Future` может перейти в одно из других состояний, после чего снова изменить состояние он не может (тут можно было бы вставить симпатичную картинку с диаграммой состояний :-) ).
Семафор управляет FIFO-очередью задач, ожидающих выполнения. Он не использует состояние, соответствующее выдаче исключения, но три других состояния использует:
* **Ожидание**: посетитель с пейджером, на который ещё не отправили сигнал о готовности блюда.
* **Владение результатом**: посетитель, на пейджер которого отправили уведомление.
* **Отмена**: посетитель, который вернул пейджер до того, как на него было отправлено уведомление.
Справедливое распределение ресурсов должен обеспечивать механизм, в соответствии с логикой которого новый объект `Future` всегда добавляют в конец очереди. Это происходит, когда вызов `acquire()` обнаруживает, что семафор заблокирован. При этом, когда очередь не пуста, при вызове `release()` самый левый (то есть — самый старый) объект `Future` всегда маркируют как объект, содержащий результат. Ошибка, касающаяся справедливого распределения ресурсов, произошла из-за того, что вызов `acquire()` работает по сокращённой схеме в том случае, если переменная семафора `level` (количество свободных столиков) является ненулевой. Этот вызов не должен так поступать в том случае, если в очереди ещё есть объекты `Future`. Другими словами — ошибка выражалась в том, что мы иногда усаживали только что прибывших посетителей за столики в ситуации, когда у нас были свободные столики, несмотря на то, что в это время кто-то уже ждал в очереди.
Как думаете — что вызывало ошибку, связанную с отменой операции? Речь идёт о сценарии, когда объект `Future` владеет результатом (посетитель, на пейджер которого поступил сигнал), но задача, ожидающая этот объект `Future`, отменяется (посетитель отказывается усесться за столик).
Я изо всех сил пытался представить себе состояние семафора, с его переменной `level` и FIFO-очередью объектов `Future`, пребывающих в состоянии ожидания. Ещё я пытался найти определение вызова `locked()`. Если бы переменная `level` была бы общедоступной, я попытался бы разобраться и с её семантикой. В итоге у меня получились следующие определения:
* `W` — список ожидающих объектов `Future`, или `[f для f в очереди, если не выполнен вызов f.done()]`.
* `R` — список объектов `Future`, владеющих результатом, или `[f для f в очереди, если выполнен вызов f.done() и не выполнен вызов f.cancelled()]`.
* `C` — список объектов `Future`, операции, соответствующие которым, отменены, или `[f для f в очереди, если выполнен вызов f.cancelled()]`.
А вот — некоторые конструкции, построенные на основе этих определений:
* `set(W + R + C) == set(queue)` — все объекты `Future`, которые либо ожидают в очереди, либо имеют результат, либо отменены.
* `level >= len(R)` — у нас должно быть как минимум столько свободных столиков, сколько имеется посетителей, на пейджеры которых отправлен сигнал о готовности заказа.
* `define locked() as (len(W) > 0 or len(R) > 0 or level == 0)` — мы можем немедленно усадить кого-то за столик при выполнении следующих условий:
1. нет посетителей, ожидающих срабатывания пейджера,
2. нет посетителей, на пейджеры которых уже отправлен сигнал о готовности заказа,
3. имеется по крайней мере один свободный столик.
В итоге — вот ссылка на [текущий код](https://github.com/python/cpython/blob/c70c8b69762f720377adaf22f2e5ec6496a7be53/Lib/asyncio/locks.py#L330) реализации класса `Semaphore`.
О, а приходите к нам работать? 🤗 💰Мы в [**wunderfund.io**](http://wunderfund.io/) занимаемся [высокочастотной алготорговлей](https://en.wikipedia.org/wiki/High-frequency_trading) с 2014 года. Высокочастотная торговля — это непрерывное соревнование лучших программистов и математиков всего мира. Присоединившись к нам, вы станете частью этой увлекательной схватки.
Мы предлагаем интересные и сложные задачи по анализу данных и low latency разработке для увлеченных исследователей и программистов. Гибкий график и никакой бюрократии, решения быстро принимаются и воплощаются в жизнь.
Сейчас мы ищем плюсовиков, питонистов, дата-инженеров и мл-рисерчеров.
[Присоединяйтесь к нашей команде.](http://wunderfund.io/#join_us) | https://habr.com/ru/post/692292/ | null | ru | null |
# Знакомство с HealthKit
В этой статье про HealthKit вы узнаете, как запрашивать разрешение на доступ к данным HealthKit, а также считывать и записывать данные в центральный репозиторий HealthKit. В статье используется Swift 4, iOS 11, Xcode 9 версии.
**HealthKit** — это API, которое было представлено в iOS 8. *HealthKit* служит как центральный репозиторий для всех данных, связанных со здоровьем, позволяя пользователям создавать биологический профиль и хранить данные о тренировках.
По ходу прочтения статьи о HealthKit, вы создадите простейшее приложение для отслеживания тренировок и узнаете:
* Как запросить разрешение и получить доступ к данным HealthKit
* Как читать данные HealthKit и отображать их в UITableView
* Как записать данные в центральный репозиторий HealthKit
Готовы начать знакомство с HealthKit? Читайте дальше!
**Примечание:** *Для работы по этому туториалу вам потребуется активная учетная запись iOS разработчика. Без этого вы не сможете включить HealthKit Capability и получить доступ к хранилищу HealthKit.*
### Начало
Стартовое приложения отслеживает сжигание калорий при выполнении программы тренировки. Для голливудских инсайдеров и светских людей должно быть очевидно, что я говорю о **Prancercise**.
[Загрузите стартовый проект и откройте его в Xcode](https://koenig-media.raywenderlich.com/uploads/2017/06/Prancercise-Tracker-Starter-2.zip).
Скомпилируйте и запустите приложение. Вы увидите “скелет” пользовательского интерфейса. В течении следующих двух статей вы постепенно будете добавлять функционал для этого приложения.
### Assigning a Team
**HealthKit** — это особый фреймворк. Приложение не сможет использовать его, если у вас нет активной учетной записи разработчика. После того, как у вас появится аккаунт разработчика, вы можете назначить свою команду.
Выберите **PrancerciseTracker** в Навигаторе проектов, а затем выберите **PrancerciseTracker target**. Перейдите на вкладку **General** и нажмите на поле **Team**.
Выберите команду, связанную с вашей учетной записью разработчика:
### Разрешения/Entitlements
HealthKit также имеет собственный набор прав, и вам нужно будет включить их, чтобы создавать приложения, которые используют фреймворк.
Откройте вкладку **Capabilities** в target редакторе и включите **HealthKit**, как показано на скриншоте ниже:
Подождите, пока Xcode настроит HealthKit для вас. Как правило, здесь нет проблем, но с некоторыми вы все же можете столкнуться, если забудете указать правильно Team и Bundle Identifier.
Теперь все готово. Вам просто нужно запросить у пользователя разрешение на использование HealthKit.
### Права доступа/Permissions
HealthKit работает с конфиденциальными и секретными данными. Не все чувствуют себя настолько комфортно, чтобы позволить установленным приложениям иметь доступ к этой информации.
Вот почему HealthKit обладает надежной системой конфиденциальности. HealthKit имеет доступ только к тем данным, которыми пользователи согласны поделиться. Чтобы создать профиль для пользователей вашего Prancercise Tracker, вам необходимо сначала получить разрешение на доступ к каждому типу данных.
### Обновление Описания использования
Во-первых, вам нужно описать, почему вы запрашиваете показатели здоровья у своих пользователей. **Xcode** дает вам возможность указать это в файле **Info.plist** вашего приложения.
Откройте **Info.plist**. Затем добавьте следующие ключи:
**Privacy** – **Health Share Usage Description**
**Privacy** – **Health Update Usage Description**
Эти ключи хранят текст, который будет отображаться при появлении экрана авторизации HeathKit. **Health Share Usage Description** относится к разделу данных, которые следует читать из HealthKit. **Health Update Usage Description** соответствует данным, которые записываются в HealthKit.
Вы можете «добавить» туда все, что захотите. Обычно это описание: «Мы будем использовать вашу информацию о здоровье, чтобы лучше отслеживать тренировки».
Имейте в виду, что если эти ключи не установлены, при попытке авторизации в HealthKit приложение “упадет”.
### Авторизация HealthKit
Откройте файл *HealthKitSetupAssistant.swift* внутри которого находится метод класса, который вы будете использовать для авторизации в HealthKit.
```
class func authorizeHealthKit(completion: @escaping (Bool, Error?) -> Swift.Void) {
}
```
Метод authorizeHealthKit(completion:) не принимает никаких параметров, и имеет **complition**, который возвращает логическое значение (**success** или **failure**) и опциональную ошибку в случае, если что-то пойдет не так. Если возвращаются ошибки, вы передадите их в complition в двух случаях:
1. HealthKit может быть недоступен на устройстве. Например если приложение запущено на iPad.
2. Некоторые типы данных могут быть недоступны в текущей версии HealthKit.
Давайте нарушим этот процесс. Чтобы авторизовать HealthKit, метод *authorizeHealthKit(completion:)* должен выполнить следующие четыре действия:
1. Проверить, доступен ли Healthkit на этом устройстве. Если это не так, вернуть в complition сбой и ошибку.
2. Подготовить типы данных о состоянии здоровья. Prancercise Tracker будет читать и записывать в HealthKit.
3. Организуйте эти данные в список типов, которые нужно считывать, и типы, которые нужно записать.
4. Запросить авторизацию. Если это действие будет успешным, значит все активности были правильными и завершились надлежащим образом.
### Проверка доступности HealthKit
Прежде всего нужно проверить наличие HealthKit на устройстве.
Вставьте следующий код в начало метода *authorizeHealthKit(completion:)*:
```
//1. Проверьте, доступен ли на этом устройстве HealthKit
guard HKHealthStore.isHealthDataAvailable() else {
completion(false, HealthkitSetupError.notAvailableOnDevice)
return
}
```
Вы будете очень часто взаимодействовать с **HKHealthStore**. Он представляет собой центральный репозиторий, в котором хранятся данные о здоровье пользователя. Метод *isHealthDataAvailable()* поможет вам понять, поддерживает ли текущее устройство пользователя данные c Heathkit.
Оператор guard запрещает приложению выполнять остальную часть метода *authorizeHealthKit(completion:)*, если HealthKit недоступен на устройстве. Когда это произойдет, вызовется completion блок с ошибкой **notAvailableOnDevice**. Вы можете просто вывести это в консоль или в главном контроллере обработать дальнейшие шаги в случае такой ошибки.
### Подготовка данных
Как только вы узнаете, что HealthKit доступен на устройстве пользователя, пришло время подготовить типы данных, которые будут считываться и записываться в HealthKit.
HealthKit работает с типом **HKObjectType**. Каждый тип, который входит в центральный репозиторий HealthKit или возвращается, является своего рода **HKObjectType**. Вы также увидите HKSampleType и **HKWorkoutType**. Оба они наследуються от **HKObjectType**, поэтому в основном это одно и то же.
Вставьте следующий фрагмент кода сразу после первого фрагмента кода:
```
//2. Подготовка типы данных, которые будут взаимодействовать с HealthKit
guard let dateOfBirth = HKObjectType.characteristicType(forIdentifier: .dateOfBirth),
let bloodType = HKObjectType.characteristicType(forIdentifier: .bloodType),
let biologicalSex = HKObjectType.characteristicType(forIdentifier: .biologicalSex),
let bodyMassIndex = HKObjectType.quantityType(forIdentifier: .bodyMassIndex),
let height = HKObjectType.quantityType(forIdentifier: .height),
let bodyMass = HKObjectType.quantityType(forIdentifier: .bodyMass),
let activeEnergy = HKObjectType.quantityType(forIdentifier: .activeEnergyBurned) else {
completion(false, HealthkitSetupError.dataTypeNotAvailable)
return
}
```
Вау, это бкакой большой **guard**! Это также отличный пример использования единого guard для извлечения нескольких опционалов.
Чтобы создать **HKObjectType** для данных характеристик, вам нужно использовать либо *HKObjectType.characteristicType(forIdentifier :)*, либо *HKObjectType.quantityType(forIdentifier :)*
Типы характеристик и типы количества представляют собой перечисления, определенные фреймворком. HealthKit загружается вместе с ними.
Вы также заметите, что если один признак или тип выборки недоступен, метод завершится с ошибкой. Это намеренно. Ваше приложение должно всегда точно знать, с какими типами HealthKit оно может работать, если таковые вообще существуют.
### Подготовка списка типов данных для чтения и записи
Теперь пришло время подготовить список типов данных для чтения и записи.
Вставьте этот третий код в метод *authorizeHealthKit(completion:)* сразу после второй части:
```
//3. Подготовьте список типов, которые HealthKit должен считывать и записывать
let healthKitTypesToWrite: Set = [bodyMassIndex, activeEnergy, HKObjectType.workoutType()]
let healthKitTypesToRead: Set = [dateOfBirth,
bloodType,
biologicalSex,
bodyMassIndex,
height,
bodyMass,
HKObjectType.workoutType()]
```
HealthKit ожидает набор объектов **HKSampleType**, которые представляют виды данных, которые может написать ваш пользователь, а также ожидает, что для вашего приложения будет отображаться набор объектов HKObjectType.
**HKObjectType.workoutType()** — особый тип **HKObjectType**. Он представляет собой любую тренировку.
### Авторизация HealthKit
Последняя часть — самая легкая. Вам просто нужно запросить авторизацию от HealthKit. Вставьте этот последний фрагмент кода:
```
//4. Запрос на авторизацию
HKHealthStore().requestAuthorization(toShare: healthKitTypesToWrite,
read: healthKitTypesToRead) { (success, error) in
completion(success, error)
}
```
Этот код запрашивает авторизацию от HealthKit, а затем вызывает completion. Они используют переменные успешного выполнения операций и ошибок, переданных из метода HKHealthStore’s *requestAuthorization(toShare: read: completion:)*.
Вы можете думать об этом как о перенаправлении. Вместо того, чтобы обрабатывать завершение внутри HealthKitSetupAssistant, вы передаете пакет на главный контроллер, который может показать предупреждение или предпринять некоторые другие действия.
В проекте уже есть кнопка Authorize HealthKit, и она вызывает метод *authorizeHealthKit()* в MasterViewController. Это идеальное место для вызова метода авторизации, который мы только что написали.
Откройте **MasterViewController.swift**, найдите метод *authorizeHealthKit(*) и вставьте этот код:
```
HealthKitSetupAssistant.authorizeHealthKit { (authorized, error) in
guard authorized else {
let baseMessage = "HealthKit Authorization Failed"
if let error = error {
print("\(baseMessage). Reason: \(error.localizedDescription)")
} else {
print(baseMessage)
}
return
}
print("HealthKit Successfully Authorized.")
}
```
Этот код использует метод *authorizeHealthKit(completion:)*, который вы только что внедрили. Когда он будет завершен, он выведет сообщение в консоль, чтобы сообщить, была ли авторизация успешной в HealthKit.
Запустите приложение. Нажмите Authorize HealthKit в главном окне, и вы увидите всплывающий экран авторизации:
Включите все переключатели, прокрутите экран, чтобы просмотреть их все, и нажмите **Allow**. В консоли вы должны увидеть такое сообщение:
```
HealthKit Successfully Authorized.
```
**Великолепно!** Приложение имеет доступ к центральному хранилищу HealthKit. Теперь пришло время начать отслеживать элементы.
### Характеристики и сэмплы
В этом разделе вы узнаете:
* Как читать биологические характеристики вашего пользователя.
* Как считать и записать разные типы образцов (вес, высота и т. д.)
Биологические характеристики, как правило, являются видами элементов, которые не меняются, как собственно ваша группа крови. Сэмплы представляют собой элементы, которые часто меняются, например, вес.
Чтобы правильно отслеживать эффективность режима тренировки **Prancercise**, приложение **Prancercise Tracker** должно получить сэмпл веса и роста пользователя. В совокупности эти сэмплы можно использовать для расчета индекса массы тела (ИМТ).
**Примечание:** *Индекс массы тела (ИМТ) является широко используемым показателем жира в организме, и он рассчитывается на основе веса и роста человека. Узнайте больше об этом [здесь](http://en.wikipedia.org/wiki/Body_mass_index).*
### Чтение характеристик
Приложение Prancercise Tracker не записывает биологические характеристики. Он получает их из HealthKit. Это означает, что эти характеристики необходимо сначала сохранить в центральном хранилище HeathKit.
Если вы еще этого не сделали, пришло время рассказать для **HeathKit** немного больше о себе.
Откройте приложение «Здоровье» на своем устройстве или в симуляторе. Выберите вкладку «Данные о здоровье». Затем нажмите значок профиля в верхнем правом углу, чтобы просмотреть свой профиль здоровья. Нажмите **Edit** и введите информацию дату рождения, пол, группу крови:
Теперь, когда **HealthKit** знает вашу дату рождения, пол и группу крови, пришло время прочитать эти характеристики в **Prancercise Tracker**.
Вернитесь к **Xcode** и откройте *ProfileDataStore.swift*. Класс **ProfileDataStore** представляет вашу точку доступа ко всем связанным со здоровьем данным для ваших пользователей.
Вставьте следующий метод в **ProfileDataStore**:
```
class func getAgeSexAndBloodType() throws -> (age: Int,
biologicalSex: HKBiologicalSex,
bloodType: HKBloodType) {
let healthKitStore = HKHealthStore()
do {
//1. This method throws an error if these data are not available.
let birthdayComponents = try healthKitStore.dateOfBirthComponents()
let biologicalSex = try healthKitStore.biologicalSex()
let bloodType = try healthKitStore.bloodType()
//2. Use Calendar to calculate age.
let today = Date()
let calendar = Calendar.current
let todayDateComponents = calendar.dateComponents([.year], from: today)
let thisYear = todayDateComponents.year!
let age = thisYear - birthdayComponents.year!
//3. Unwrap the wrappers to get the underlying enum values.
let unwrappedBiologicalSex = biologicalSex.biologicalSex
let unwrappedBloodType = bloodType.bloodType
return (age, unwrappedBiologicalSex, unwrappedBloodType)
}
}
```
Метод *getAgeSexAndBloodType()* обращается к **HKHealthStore**, запрашивает дату рождения пользователя, пол и группу крови. Он также вычисляет возраст пользователя, используя дату рождения.
1. Возможно, вы заметили, что этот метод может вызвать ошибку. Это происходит всякий раз, когда дата рождения, пол или группа крови не были сохранены в центральном хранилище HealthKit. Поскольку вы только что ввели эту информацию в свое приложение, не следует вызывать ошибки.
2. Используя класс **Calendar**, вы можете преобразовать любую дату в набор **Date Components**. Это действительно удобно, когда вы хотите получить год для даты. Этот код просто получает ваш год рождения, текущий год, а затем вычисляет разницу.
3. «Развернутые» переменные называются таким образом, чтобы было ясно, что вам нужно получить доступ к базовому перечислению из wrapper class (**HKBiologicalSexObject** и **HKBloodTypeObject**).
### Обновление пользовательского интерфейса
Если бы вы сейчас скомпилируете и зупустите приложение, вы не увидели никаких изменений в пользовательском интерфейсе, потому что вы еще не подключили к нему эту логику.
Откройте **ProfileViewController.swif**t и найдите метод *loadAndDisplayAgeSexAndBloodType(*)
Этот метод будет использовать ваш **ProfileDataStore** для загрузки биологических характеристик в пользовательский интерфейс.
Вставьте следующий код в метод *loadAndDisplayAgeSexAndBloodType()*:
```
do {
let userAgeSexAndBloodType = try ProfileDataStore.getAgeSexAndBloodType()
userHealthProfile.age = userAgeSexAndBloodType.age
userHealthProfile.biologicalSex = userAgeSexAndBloodType.biologicalSex
userHealthProfile.bloodType = userAgeSexAndBloodType.bloodType
updateLabels()
} catch let error {
self.displayAlert(for: error)
}
```
Этот блок кода загружает возраст, пол и группу крови в виде кортежа. Затем он устанавливает эти поля в локальном экземпляре модели UserHealthProfile. Наконец, он обновляет пользовательский интерфейс с новыми полями в **UserHealthProfile**, вызывая метод *updateLabels()*.
Поскольку метод **ProfileDataStore** *getAgeSexAndBloodType()* может выбросить ошибку, **ProfileViewController** должен обрабатывать ее. В этом случае вы просто берете ошибку и представляете ее как предупреждение.
Все это замечательно, но есть один улов. Метод *updateLabels()* еще ничего не делает. Это просто пустое объявление. На этот раз перейдем к пользовательскому интерфейсу.
Найдите метод *updateLabels()* и вставьте в него этот код:
```
if let age = userHealthProfile.age {
ageLabel.text = "\(age)"
}
if let biologicalSex = userHealthProfile.biologicalSex {
biologicalSexLabel.text = biologicalSex.stringRepresentation
}
if let bloodType = userHealthProfile.bloodType {
bloodTypeLabel.text = bloodType.stringRepresentation
}
```
Код довольно прост. Если пользователь установил возраст, он будет отформатирован в метку. То же самое касается биологического пола и группы крови. Переменная stringRepresentation преобразует перечисление в строку для целей отображения.
Скомпилируйте и запустите приложение. Перейдите на экран Profile&BMI. Нажмите кнопку Read HealthKit Data.
Если вы ранее ввели свою информацию в приложение, она должна появиться в ярлыках на этом экране. Если вы этого не сделали, появится сообщение об ошибке.
Здорово! Вы считываете и отображаете данные непосредственно из **HealthKit**.
### Сэмплы запросов
Теперь пришло время прочитать вес и рост пользователя. Они будут использоваться для расчета и отображения ИМТ в представлении профиля.
Биологические характеристики легкодоступны, потому что они почти никогда не меняются. Сэмплы требуют гораздо более сложного подхода. Они используют **HKQuery**, точнее **HKSampleQuery**.
Чтобы запросить сэмплы из HealthKit, вам понадобятся:
1. Указать тип сэмпла, который вы хотите запросить (вес, высота и т. д.),
2. Некоторые дополнительные параметры, которые помогают фильтровать и сортировать данные. Для этого вы можете передать опционал **NSPredicate** или массив **NSSortDescriptors**.
**Примечание:** *Если вы знакомы с CoreData, вы, вероятно, заметили некоторые сходства. **HKSampleQuery** очень похож на **NSFetchedRequest** для типа объекта, где вы указываете предикат и дескрипторы сортировки, а затем задаете контекст объекта для выполнения запроса, чтобы получить результаты.*
После того, как ваш запрос установлен, вы просто вызываете метод **HKHealthStore** *ExecuteQuery()* для получения результатов.
Для **Prancercise Tracker** вы создадите единую универсальную функцию, которая загружает самые последние сэмплы любого типа. Таким образом, вы можете использовать его как для веса, так и для роста.
Откройте **ProfileDataStore.swift** и вставьте следующий метод в класс, чуть ниже метода *getAgeSexAndBloodType()*:
```
class func getMostRecentSample(for sampleType: HKSampleType,
completion: @escaping (HKQuantitySample?, Error?) -> Swift.Void) {
//1. Используйте HKQuery для загрузки последних образцов.
let mostRecentPredicate = HKQuery.predicateForSamples(withStart: Date.distantPast,
end: Date(),
options: .strictEndDate)
let sortDescriptor = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: false)
let limit = 1
let sampleQuery = HKSampleQuery(sampleType: sampleType,
predicate: mostRecentPredicate,
limit: limit,
sortDescriptors: [sortDescriptor]) { (query, samples, error) in
//2. Всегда отправляйте в основной поток по завершении.
DispatchQueue.main.async {
guard let samples = samples,
let mostRecentSample = samples.first as? HKQuantitySample else {
completion(nil, error)
return
}
completion(mostRecentSample, nil)
}
}
HKHealthStore().execute(sampleQuery)
}
```
Этот метод использует тип выборки (высота, вес, ИМТ и т. д.). Затем он создает запрос для получения последнего сэмпла для этого типа. Если вы пройдете по типу сэмпла для роста, вы вернетесь к своей последней записи роста.
Здесь многое происходит. Я остановлюсь, чтобы объяснить несколько вещей.
1. В **HKQuery** есть несколько методов, которые могут помочь вам отфильтровать ваши примеры запросов HealthKit. В этом случае мы используем встроенный предикат даты.
2. Запрос образцов из HealthKit — это асинхронный процесс. Вот почему код в обработчике завершения встречается внутри блока Dispatch. Нужно, чтобы комплишн выполнялся на основном потоке. Если вы этого не сделаете, приложение выйдет из строя.
Если все будет хорошо, ваш запрос будет выполнен, и вы получите аккуратный сэмпл, возвращенный на **main** потоке, где **ProfileViewController** может поместить его содержимое в метку. Давайте сделаем эту часть сейчас.
### Отображение образцов в пользовательском интерфейсе
В предыдущем разделе вы загрузили данные из **HealthKit**. Сохраните их в качестве модели в **ProfileViewController**, а затем обновите содержимое в строках с использованием метода **ProfileViewController** *updateLabels()*
Все, что вам нужно сделать, это расширить этот процесс, добавив функцию, которая загружает сэмплы, обрабатывает их для пользовательского интерфейса, а затем вызывает *updateLabels()* для заполнения лейблов текстом.
Откройте файл **ProfileViewController.swift**, найдите метод *loadAndDisplayMostRecentHeight(*) и вставьте следующий код:
```
//1. Используйте HealthKit для создания типа сэмпла высоты
guard let heightSampleType = HKSampleType.quantityType(forIdentifier: .height) else {
print("Height Sample Type is no longer available in HealthKit")
return
}
ProfileDataStore.getMostRecentSample(for: heightSampleType) { (sample, error) in
guard let sample = sample else {
if let error = error {
self.displayAlert(for: error)
}
return
}
//2. Преобразуйте сэмпл высоты в метры, сохраните модель профиля,
// и обновите пользовательский интерфейс.
let heightInMeters = sample.quantity.doubleValue(for: HKUnit.meter())
self.userHealthProfile.heightInMeters = heightInMeters
self.updateLabels()
}
```
1. Этот метод начинается с создания типа сэмпла роста. Затем он передает этот тип сэмпла методу, который вы только что написали, который вернет самый последний сэмпл роста пользователя, записанный в HealthKit.
2. Как только сэмпл возвращается, рост преобразуется в метры и сохраняется в модель UserHealthProfile. Затем **UI** обновится.
**Примечание:** *Обычно вы хотите преобразовать сэмпл количества в стандартную единицу. Для этого в приведенном выше коде используется метод *doubleValue(for:)*, который позволяет вам передать в **HKUnit** соответствующие данные, которые вам необходимы (в данном случае метры).
Вы можете создавать различные типы **HKUnits**, используя некоторые распространенные методы класса, доступные через **HealthKit**. Чтобы получить счетчики, вы просто можете использовать метод meter() в **HKUnit**, и это будет то, что Вам необходимо.*
С ростом разобрались. Как насчет веса? Все достаточно похоже, но вам нужно будет заполнить метода *loadAndDisplayMostRecentWeight()* в **ProfileViewController**.
Вставьте следующий код в метод *loadAndDisplayMostRecentWeight()* :
```
guard let weightSampleType = HKSampleType.quantityType(forIdentifier: .bodyMass) else {
print("Body Mass Sample Type is no longer available in HealthKit")
return
}
ProfileDataStore.getMostRecentSample(for: weightSampleType) { (sample, error) in
guard let sample = sample else {
if let error = error {
self.displayAlert(for: error)
}
return
}
let weightInKilograms = sample.quantity.doubleValue(for: HKUnit.gramUnit(with: .kilo))
self.userHealthProfile.weightInKilograms = weightInKilograms
self.updateLabels()
}
```
Вы создаете тип сэмпла, который хотите получить, запрашиваете для него **HealthKit**, делаете некоторые преобразования единиц, сохраняете в своей модели и обновляете пользовательский интерфейс.
На данный момент может показать что дело сделано, но есть кое-что еще. Функция *updateLabels()* не знает о новых данных, которые вы сделали доступными для нее.
Давайте это исправим.
Добавьте следующие строки в функцию *updateLabels()*, чуть ниже части, где вы разворачиваете группу крови, чтобы отобразить ее на пользовательском интерфейсе:
```
if let weight = userHealthProfile.weightInKilograms {
let weightFormatter = MassFormatter()
weightFormatter.isForPersonMassUse = true
weightLabel.text = weightFormatter.string(fromKilograms: weight)
}
if let height = userHealthProfile.heightInMeters {
let heightFormatter = LengthFormatter()
heightFormatter.isForPersonHeightUse = true
heightLabel.text = heightFormatter.string(fromMeters: height)
}
if let bodyMassIndex = userHealthProfile.bodyMassIndex {
bodyMassIndexLabel.text = String(format: "%.02f", bodyMassIndex)
}
```
Следуя исходному шаблону в функции*updateLabels()*, она разворачивает индекс роста, веса и массы тела в вашей модели **UserHealthProfile**. Если они доступны, они генерируют соответствующие строки и присваивает их в labels на экране пользователя.
**MassFormatter** и **LengthFormatter** выполняют работу по преобразованию ваших величин в строки.
Индекс массы тела фактически не хранится в модели **UserHealthProfile**. Это вычисленное свойство, которое делает расчет для вас.
Выполните клик на свойстве **bodyMassIndex**, и вы увидите, что я имею в виду:
```
var bodyMassIndex: Double? {
guard let weightInKilograms = weightInKilograms,
let heightInMeters = heightInMeters,
heightInMeters > 0 else {
return nil
}
return (weightInKilograms/(heightInMeters*heightInMeters))
}
```
Индекс массы тела является не обязательным свойством, то есть он может возвращать nil, если не задали ни рост, ни вес (или если они установлены на некоторое число, которое не имеет никакого смысла). Фактический расчет — это просто вес, разделенный на рост в квадрате.
**Примечание:** *Скоро вы погрузните во всем этом, если вы не добавили данные в **HealthKit** для считывания приложением. Если вы еще этого не сделали, вам нужно создать сэмплы роста и веса, по крайней мере.*
*Откройте приложение «Здоровье» и перейдите на вкладку «Данные о здоровье». Там выберите параметр Body Measurements, затем выберите Weight, а затем Add Data Point, чтобы добавить новый сэмпл веса. Повторите процесс для роста.*
На этом этапе **Prancercise Tracker** должен иметь возможность прочитать недавний сэмпл веса и высоты вашего пользователя, а затем отобразить его в тексте.
Скомпилируйте и запустите приложения. Перейдите к **Profile&BMI**. Затем нажмите кнопку **Read HealthKit Data**.
Потрясающие! Вы только что прочитали свои первые сэмплы из хранилища **HealthKit** и использовали их для расчета ИМТ.
### Сохранение сэмплов
У **Prancercise Tracker** уже есть удобный калькулятор индекса массы тела. Давайте использовать его для записи сэмпла ИМТ вашего пользователя.
Откройте **ProfileDataStore.swift** и добавьте следующий метод:
```
class func saveBodyMassIndexSample(bodyMassIndex: Double, date: Date) {
//1. Убедитесь, что тип массы тела существует
guard let bodyMassIndexType = HKQuantityType.quantityType(forIdentifier: .bodyMassIndex) else {
fatalError("Body Mass Index Type is no longer available in HealthKit")
}
//2. Используйте граф HKUnit для создания массы тела
let bodyMassQuantity = HKQuantity(unit: HKUnit.count(), doubleValue: bodyMassIndex)
let bodyMassIndexSample = HKQuantitySample(type: bodyMassIndexType,
quantity: bodyMassQuantity,
start: date,
end: date)
//3. Сохраните то же самое в HealthKit
HKHealthStore().save(bodyMassIndexSample) { (success, error) in
if let error = error {
print("Error Saving BMI Sample: \(error.localizedDescription)")
} else {
print("Successfully saved BMI Sample")
}
}
}
```
Как и в случае с другими типами образцов, сначала необходимо убедиться, что тип сэмпла доступен в **HealthKit**.
1. В этом случае код проверяет, существует ли *quantity type* для индекса массы тела. Если это так, то он используется для создания сэмпла количества. Если нет, приложение прекращает работу.
2. Метод *count()* в **HKUnit** предназначен для специального случая, когда нет четкого блока для типа сэмпла, который вы храните. В какой-то момент в будущем может появится единица, присвоенная индексу массы тела, но на данный момент эта более общая единица работает очень хорошо.
3. **HKHealthStore** сохраняет сэмпл и позволяет узнать, был ли процесс успешным из последующего замкнутого выражения. Вы можете сделать больше с этим, но теперь приложение просто отображает информацию на консоли.
Почти готово. Подведем итог по пользовательскому интерфейсу.
Откройте **ProfileViewController.swif**, найдите метод *saveBodyMassIndexToHealthKit (*). Этот метод вызывается, когда пользователь нажимает на кнопку Save BMI в таблице.
Вставьте следующий код в метод:
```
guard let bodyMassIndex = userHealthProfile.bodyMassIndex else {
displayAlert(for: ProfileDataError.missingBodyMassIndex)
return
}
ProfileDataStore.saveBodyMassIndexSample(bodyMassIndex: bodyMassIndex, date: Date())
```
Вы помните, что индекс массы тела является вычисленным свойством, которое возвращает значение, когда сэмплы роста и веса загружены из **HealthKit**. Этот код пытается вычислить данное свойство, и если возможно, он будет передан в метод *savedBodyMassIndexSample(bodyMassIndex: date :)*, который вы только что написали.
Он также показывает удобное оповещение, если индекс массы тела не может быть вычислен по какой-либо причине.
Скомпилируйте и запустите приложение. Перейдите на экран **Profile&BMI**. Загрузите данные из **HeathKit**, затем нажмите кнопку Save BMI.
Посмотрите на консоль. Вы видите это?
```
Успешно сохраненный сэмпл BMI
```
Если да, поздравляю! Ваш сэмпл BMI теперь хранится в центральном хранилище **HealthKit**. Посмотрим, сможем ли мы его найти.
Откройте приложение «Здоровье», коснитесь вкладки «Данные о здоровье», нажмите « Измерения тела» в представлении таблицы, а затем нажмите «Индекс массы тела».
 | https://habr.com/ru/post/434978/ | null | ru | null |
# Google Cloud Storage c Java: изображения и другие файлы в облаках
В продолжение [серии статей](http://habrahabr.ru/post/268863/) о веб-разработке на Java на платформе Google App Engine / Google Cloud Endpoints рассмотрим сервис для облачного хранения файлов Google Cloud Storage.
В целом схема выглядит следующим образом: сервер на бэкэнде генерирует временную ссылку (адрес) для передачи файла в определенный контейнер (bucket) нашего хранилища, которая на фронтэнде вставляется в форму для передачи файла. Пользователь на указанный адрес посылает POST HTTP-request с одним или несколькими файлами в теле запроса, файлы принимаются и размещаются в хранилище, и HTTP-request вместе с данными о размещенных файлах принимается сервлетом, который обработав информацию о размещенных файлах, возвращает пользователю HTTP response: JSON или text/html, или в общем что пожелаем.
Файлы сохраняются в хранилище, у сервлета есть в распоряжении ключ который дает возможность доступа к файлу, в частности можно выдать файл пользователю с помощью другого сервлета либо создать «статичную» ссылку (https://).
Доступ к хранилищу также доступен через веб-интерфейс, и из командной строки с помощью утилиты [gsutil](https://cloud.google.com/storage/docs/gsutil).
В качестве примера будем интегрировать Google Cloud Storage с приложением на GAE: hello-habrahabr-api.appspot.com + hello-habrahabr-webapp.appspot.com использовавшимся в предыдущих [примерах](http://habrahabr.ru/post/268863/).
#### Подключение Google Cloud Storage к проекту на Google App Engine / Google Cloud Endpoints
Для начала заходим в консоль разработчика ( App Engine Developer console): [appengine.google.com/dashboard?&app\_id=hello-habrahabr-api](https://appengine.google.com/dashboard?&app_id=hello-habrahabr-api) (https://appengine.google.com/dashboard?&app\_id={проект ID})
Переходим в меню Application Settings > Cloud Integration и внизу страницы нажимаем 'Create':
Получаем сообщение «Cloud integration tasks have started».
Обратите внимание сейчас консоль разработчика Google существует в двух версия «старая» и «новая», функции постепенно переносятся из «старой» в «новую». Cloud Integration мы пока включаем из старой консоли разработчика (следует ожидать что эта функция скоро появиться и в новой консоли).
Перегружаем страницу, внизу в разделе Cloud Integration вместо кнопки 'Create' в видим сообщение «The project was created successfully. See the Basics section for more details.» А немного выше в разделе Basics видим ссылку на подключенный Google Cloud Storage Bucket, по умолчанию ему присваивается такое же имя как у проекта GAE, в моем случае hello-habrahabr-api.appspot.com:
Кликаем по ссылке, она ведет нас на адрес [console.developers.google.com/storage/browser](https://console.developers.google.com/storage/browser/){имя Bucket}/ D моем случае: [console.developers.google.com/storage/browser/hello-habrahabr-api.appspot.com](https://console.developers.google.com/storage/browser/hello-habrahabr-api.appspot.com/) (естественно требует авторизации) и мы попадаем в Storage browser:
Здесь мы можем создавать новые папки, загружать и удалять файлы, управлять правами доступа к файлам, в том числе мы можем сделать доступ к файлу публичным и получить постоянную ссылку на файл для веб (например если мы хотим использовать изображение или иной статический файл для веб-сайта), производить поиск и фильтрацию.
Cloud Storage предоставляет бесплатный bucket для каждого приложения на Google App Engine, но в этом случае веб-интерфейс Storage browser предоставляет только возможность просматривать содержимое bucket. Для того чтобы активировать все функции Storage browser и для создания дополнительных buckets надо включать биллинг и ввести данные своей кредитной карты (жмем на «Sign for free trial» и вводим данные кредитной карты, на 60 дней получаем бесплатный, вернее в пределах $300, пробный период).
#### Создание временной ссылки для загрузки файла
Необходимые импорты:
```
import com.google.appengine.api.blobstore.BlobstoreService;
import com.google.appengine.api.blobstore.BlobstoreServiceFactory;
import com.google.appengine.api.blobstore.UploadOptions;
```
Команда для создания ссылки:
```
String uploadUrl = BlobstoreServiceFactory.getBlobstoreService().createUploadUrl(
"/upload", // path to upload handler (servlet)
UploadOptions.Builder.withGoogleStorageBucketName("hello-habrahabr-api.appspot.com") // bucket name
)
```
Например, если мы создаем API на Cloud Endpoints, то API, возвращающий ссылку для загрузки файла будет выглядеть:
```
package com.appspot.hello_habrahabr_api;
import com.google.api.server.spi.config.Api;
import com.google.api.server.spi.config.ApiMethod;
import com.google.appengine.api.blobstore.BlobstoreServiceFactory;
import com.google.appengine.api.blobstore.UploadOptions;
import java.io.Serializable;
@Api(name = "uploadAPI",
version = "ver.1.0",
scopes = {Constants.EMAIL_SCOPE},
clientIds = {
Constants.WEB_CLIENT_ID,
Constants.API_EXPLORER_CLIENT_ID
},
description = "uploads API")
public class UploadAPI {
// add this class to of SystemServiceServlet in web.xml
/\* API methods can return JavaBean Objects only, so we use this as a wrapper for String \*/
class StringWrapperObject implements Serializable {
private String string;
public StringWrapperObject() {
}
public StringWrapperObject(String string) {
this.string = string;
}
public String getString() {
return string;
}
public void setString(String string) {
this.string = string;
}
} // end of StringWrapperObject class
@ApiMethod(
name = "getCsUploadURL",
path = "getCsUploadURL",
httpMethod = ApiMethod.HttpMethod.POST
)
@SuppressWarnings("unused")
public StringWrapperObject getCsUploadURL() {
String uploadURL = BlobstoreServiceFactory.getBlobstoreService().createUploadUrl(
"/cs-upload", // upload handler servlet address
UploadOptions.Builder.withGoogleStorageBucketName(
"hello-habrahabr-api.appspot.com" // Cloud Storage bucket name
)
);
return new StringWrapperObject(uploadURL);
}
}
```
Форма на фронтэнде:
```
File Upload Form
---
One File:
---
---
Multiple Files:
---
'use strict';
$(document).ready(function () {
var url = "https://hello-habrahabr-api.appspot.com/\_ah/api/uploadAPI/ver.1.0/getCsUploadURL";
$.ajax(url, {
method: "POST", // (default: 'GET')
async: false, // default: true
processData: true, // (default: true) (By default, data passed in to the 'data' option as an object)
success: function (data) {
console.log("responce received:");
console.log(data);
$("form").attr("action", data.string);
}
})
})
```
Та же форма в виде JSP:
```
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page import="com.google.appengine.api.blobstore.BlobstoreService" %>
<%@ page import="com.google.appengine.api.blobstore.BlobstoreServiceFactory" %>
<%@ page import="com.google.appengine.api.blobstore.UploadOptions" %>
<%
BlobstoreService blobstoreService = BlobstoreServiceFactory.getBlobstoreService();
%>
File Upload Form
---
One File:
---
"
method="post" enctype="multipart/form-data">
---
Multiple Files:
---
"
method="post" enctype="multipart/form-data">
```
Выдаваемая ссылка будет выглядеть примерно так:
`https://hello-habrahabr-api.appspot.com/_ah/upload/AMmfu6YJ0ci-sKP5k98sKaJEUjYwBFbkVfQ7iylXTJV52_gy5HIECKNG52IPUCJ9PB3wpL2wxgX82GkGkzetHt-6fuu4yzAzFFhD8HGOcD7eJ48KJLnKnb2EqbuoFEdyuc8r_FTR7779IIaf42rf_jhkl7Hju3GxWDmxh2WtmcPR2AbB9OWlQhYxBIWtZgBW9OsHO50pI21/ALBNUaYAAAAAVp2DRSZYST46t2kPmrGrrBoY3AFjyOiD/`
Но HTTP-response будет создаваться сервлетом находящимся у нас по адресу `/cs-upload`
#### Сервлет формирующий HTTP-response (upload handler)
Этот сервлет будет выглядеть следующим образом:
```
package com.appspot.hello_habrahabr_api;
import com.google.appengine.api.blobstore.BlobKey;
import com.google.appengine.api.blobstore.BlobstoreServiceFactory;
import com.google.appengine.api.blobstore.FileInfo;
import com.google.appengine.api.images.ImagesServiceFactory;
import com.google.appengine.api.images.ServingUrlOptions;
import com.google.appengine.repackaged.com.google.gson.Gson;
import com.google.appengine.repackaged.com.google.gson.GsonBuilder;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.logging.Logger;
public class CSUploadHandlerServlet extends HttpServlet {
private final static Logger LOG = Logger.getLogger(CSUploadHandlerServlet.class.getName());
private final static String HOST = "https://hello-habrahabr-api.appspot.com";
/* Object to be returned as JSON in HTTP-response (and can be stored in data base) */
class UploadedFileData {
FileInfo fileInfo;
String BlobKey;
String fileServeServletLink;
String servingUrlFromgsObjectName;
String servingUrlFromGsBlobKey;
} // end of uploadedFileData
@Override
public void doPost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
// Returns the FileInfo for any files that were uploaded, keyed by the upload form "name" field.
// This method should only be called from within a request served by the destination of a createUploadUrl call.
// https://cloud.google.com/appengine/docs/java/javadoc/com/google/appengine/api/blobstore/BlobstoreService#getFileInfos-HttpServletRequest-
java.util.Map> fileInfoListsMap = BlobstoreServiceFactory.getBlobstoreService().getFileInfos(req);
LOG.warning("[LOGGER]: " + new Gson().toJson(fileInfoListsMap));
ArrayList uploadedFilesDataList = new ArrayList<>();
for (java.util.List fileInfoList : fileInfoListsMap.values()) {
for (FileInfo fileInfo : fileInfoList) {
UploadedFileData uploadedFileData = new UploadedFileData();
uploadedFileData.fileInfo = fileInfo;
LOG.warning("uploadedFileData created:" + new Gson().toJson(uploadedFileData));
BlobKey blobKey = BlobstoreServiceFactory.getBlobstoreService().createGsBlobKey(fileInfo.getGsObjectName());
uploadedFileData.BlobKey = blobKey.getKeyString();
uploadedFileData.fileServeServletLink = HOST + "/serve?blob-key=" + blobKey.getKeyString();
// Use Images Java API to create serving URL
// works only for images (PNG, JPEG, GIF, TIFF, BMP, ICO, WEBP)
for (com.google.appengine.api.images.Image.Format type : com.google.appengine.api.images.Image.Format.values()) {
LOG.warning("com.google.appengine.api.images.Image.Format type: " + type.toString());
LOG.warning("fileInfo.getContentType(): " + fileInfo.getContentType());
if (fileInfo.getContentType().toLowerCase().contains(type.toString().toLowerCase())) {
uploadedFileData.servingUrlFromgsObjectName = ImagesServiceFactory.getImagesService().getServingUrl(ServingUrlOptions.Builder.withGoogleStorageFileName(fileInfo.getGsObjectName())); // should be the same as servingUrlFromGsBlobKey
uploadedFileData.servingUrlFromGsBlobKey = ImagesServiceFactory.getImagesService().getServingUrl(ServingUrlOptions.Builder.withBlobKey(blobKey)); // should be the same as servingUrlFromgsObjectName
}
}
uploadedFilesDataList.add(uploadedFileData);
}
}
res.setContentType("application/json");
res.setCharacterEncoding("UTF-8");
PrintWriter pw = res.getWriter(); //get the stream to write the data
Gson gson = new GsonBuilder().disableHtmlEscaping().create();
pw.println(
gson.toJson(uploadedFilesDataList)
);
LOG.warning("uploadedFilesDataMap" + new Gson().toJson(uploadedFilesDataList));
pw.close(); //closing the stream
} // doPost End
}
```
и будет выдавать в HTTP-response JSON такого вида:
**JSON**
```
[{
"fileInfo": {
"contentType": "image/svg+xml",
"creation": "Jan 18, 2016 7:16:18 PM",
"filename": "Sun_symbol.svg",
"size": 188,
"md5Hash": "YWZmM2UzMzk2ZDk2NTc0ZWM3NDI0YjYyMDMxZGIxYTM=",
"gsObjectName": "/gs/hello-habrahabr-api.appspot.com/L2FwcGhvc3RpbmdfcHJvZC9ibG9icy9BRW5CMlVxM3RWVU9nMWVxdmxfQ1dlSk5HaXIwNHpwamE3Y2FhVzlwRjF3dk4zQnFlU3JBMVkxaERGT2NRbXpLZ0pBOW0yTjZiaXhsZjFGWElmdFRNX1p2WXF4WTJnTlF1Zy42LWZnTzcybk1xNG03X1pw"
},
"BlobKey": "AMIfv968eMcYEHQml68MAl4NVtOQGKjXUWadeyP7njbaVhHXq_1xDAnRQgHeHrOv4RPLm-KdmqEHP5nb1zNuCFFszRxOVUV4Z97B9slNi7SSGWZ1qKbYcbJi2nl5Z7JX9g1xN4RclYpmLPLfh5k2jAULi6p9g84JSyh5uP3RDkNnPuXkBjxSuBTOWCVxOmpRS-xsB1YedYAgF6cRYLq0hVpm_bOY3Cbl3Ai0W-_req9jxcuPWkoguhHiZ2SSBRF9NlvgG_hCf3vouYtYS2O9DBbioeOL_p1Ck8gfvhQiiK6XpXM4S7vAYqYZCQKJ_9T4tswy075-e6NlsdtXGj9zhSxCy_GfSSBrnvbwcQUDA7lN_IYIfm0QWs-XgzBl9izizUeE46jOI-1O",
"fileServeServletLink": "https://hello-habrahabr-api.appspot.com/serve?blob-key=AMIfv968eMcYEHQml68MAl4NVtOQGKjXUWadeyP7njbaVhHXq_1xDAnRQgHeHrOv4RPLm-KdmqEHP5nb1zNuCFFszRxOVUV4Z97B9slNi7SSGWZ1qKbYcbJi2nl5Z7JX9g1xN4RclYpmLPLfh5k2jAULi6p9g84JSyh5uP3RDkNnPuXkBjxSuBTOWCVxOmpRS-xsB1YedYAgF6cRYLq0hVpm_bOY3Cbl3Ai0W-_req9jxcuPWkoguhHiZ2SSBRF9NlvgG_hCf3vouYtYS2O9DBbioeOL_p1Ck8gfvhQiiK6XpXM4S7vAYqYZCQKJ_9T4tswy075-e6NlsdtXGj9zhSxCy_GfSSBrnvbwcQUDA7lN_IYIfm0QWs-XgzBl9izizUeE46jOI-1O"
}, {
"fileInfo": {
"contentType": "image/jpeg",
"creation": "Jan 18, 2016 7:16:18 PM",
"filename": "world_map_04.jpg",
"size": 44680,
"md5Hash": "MzQyMzliZGQ4NmYyNmZiNzc3ZjAyMzBhNmM4NDVmNWE=",
"gsObjectName": "/gs/hello-habrahabr-api.appspot.com/L2FwcGhvc3RpbmdfcHJvZC9ibG9icy9BRW5CMlVxM3RWVU9nMWVxdmxfQ1dlSk5HaXIwNHpwamE3Y2FhVzlwRjF3dk4zQnFlU3JBMVkxaERGT2NRbXpLZ0pBOW0yTjZiaXhsZjFGWElmdFRNX1p2WXF4WTJnTlF1Zy5Ld1pSRTQ2M3J3ZWYxa3Bm"
},
"BlobKey": "AMIfv95nBw0rYnC39nCATxvyecFw0JEe64eTm-OhpsSsrR3Idv_rPbO2c6xTDx3q1xkulXfUyapqtEXdeQQur7FcppXa9rRcnlF7QnU8jur7a7AP3T5Ze_-bdD_F6F5mGP9Tteo7p7cN4UccqoYhnAyabAIsJBq3pZIwX2NlHhqcK_aelnu1tl3aszZU4cVmhLiZGE8hFvgDQyt-2oB4DurXUKTwGC56cZykCdYONO0EDETgkImiytbtk1iV_muyYZzfd7on3OS0LSmY8ls7QIcm1IMgl5jDPJANlsk_iWtnRJfEiYAC9pZ7DfhSPxTeYzko0b1TXrKuGjpG8cYMcxiA0Cmeya8y-7SCQuWQLlKCX8WFpIVOr26UguDaq8SFYplALbxgQUiB",
"fileServeServletLink": "https://hello-habrahabr-api.appspot.com/serve?blob-key=AMIfv95nBw0rYnC39nCATxvyecFw0JEe64eTm-OhpsSsrR3Idv_rPbO2c6xTDx3q1xkulXfUyapqtEXdeQQur7FcppXa9rRcnlF7QnU8jur7a7AP3T5Ze_-bdD_F6F5mGP9Tteo7p7cN4UccqoYhnAyabAIsJBq3pZIwX2NlHhqcK_aelnu1tl3aszZU4cVmhLiZGE8hFvgDQyt-2oB4DurXUKTwGC56cZykCdYONO0EDETgkImiytbtk1iV_muyYZzfd7on3OS0LSmY8ls7QIcm1IMgl5jDPJANlsk_iWtnRJfEiYAC9pZ7DfhSPxTeYzko0b1TXrKuGjpG8cYMcxiA0Cmeya8y-7SCQuWQLlKCX8WFpIVOr26UguDaq8SFYplALbxgQUiB",
"servingUrlFromgsObjectName": "http://lh3.googleusercontent.com/biRXwDZgclmYJa4hDUwOqBMK--VDNwj-9kZ27vzachWAGBunKVDelImXC9S5EZIhDm1T4xbyq8djFqNKkTzkSpcVkgbPO2ovxg",
"servingUrlFromGsBlobKey": "http://lh3.googleusercontent.com/biRXwDZgclmYJa4hDUwOqBMK--VDNwj-9kZ27vzachWAGBunKVDelImXC9S5EZIhDm1T4xbyq8djFqNKkTzkSpcVkgbPO2ovxg"
}]
```
То есть загруженный файл мы можем потом отдавать пользователю используя либо ссылку вида `http://lh3.googleusercontent.com/biRXwDZgclmYJa4hDUwOqBMK--VDNwj-9kZ27vzachWAGBunKVDelImXC9S5EZIhDm1T4xbyq8djFqNKkTzkSpcVkgbPO2ovxg` — если это файл изображения, либо (в любом случае) сервлет ссылка на который будет выглядеть как `https://hello-habrahabr-api.appspot.com/serve?blob-key=AMIfv95nBw0rYnC39nCATxvyecFw0JEe64eTm-OhpsSsrR3Idv_rPbO2c6xTDx3q1xkulXfUyapqtEXdeQQur7FcppXa9rRcnlF7QnU8jur7a7AP3T5Ze_-bdD_F6F5mGP9Tteo7p7cN4UccqoYhnAyabAIsJBq3pZIwX2NlHhqcK_aelnu1tl3aszZU4cVmhLiZGE8hFvgDQyt-2oB4DurXUKTwGC56cZykCdYONO0EDETgkImiytbtk1iV_muyYZzfd7on3OS0LSmY8ls7QIcm1IMgl5jDPJANlsk_iWtnRJfEiYAC9pZ7DfhSPxTeYzko0b1TXrKuGjpG8cYMcxiA0Cmeya8y-7SCQuWQLlKCX8WFpIVOr26UguDaq8SFYplALbxgQUiB`, где `serve` — путь к сервлету, `blob-key` — параметр с помощью которого мы сможем найти требуемый файл, в наиболее очевидном варианте его значением будет BlobKey.
Следует отметить что BlobKey не дает прямого доступа к файлу в обход сервлета, а сервлет может передавать или не передавать файл в зависимости от установленных нами критериев, в т.ч. мы можем использовать предоставляемою Google App Engine аутентификацию OAuth2.0, использовать дополнительные параметры в запросе и т.д.
Сервлет отдающий файл может выглядеть следующим образом:
```
package com.appspot.hello_habrahabr_api;
import com.google.appengine.api.blobstore.BlobKey;
import com.google.appengine.api.blobstore.BlobstoreService;
import com.google.appengine.api.blobstore.BlobstoreServiceFactory;
import com.google.appengine.api.users.User;
import com.google.appengine.api.users.UserService;
import com.google.appengine.api.users.UserServiceFactory;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.logging.Logger;
public class FileServeServlet extends HttpServlet {
private final static Logger LOG = Logger.getLogger(CSUploadHandlerServlet.class.getName());
private BlobstoreService blobstoreService = BlobstoreServiceFactory.getBlobstoreService();
// works both for Bloobstore and Cloud Storage
public void doGet(
HttpServletRequest req,
HttpServletResponse res
)
throws IOException {
// --- check user:
UserService userService = UserServiceFactory.getUserService();
User user = userService.getCurrentUser();
if (user == null) {
LOG.warning("[LOGGER] User not logged in");
} else {
LOG.warning("[LOGGER] user: " + user.getEmail());
}
// get parameter from url constructed with:
// "/serve?blob-key=" + blobKey.getKeyString()
BlobKey blobKey = new BlobKey(req.getParameter("blob-key"));
blobstoreService.serve(blobKey, res);
}
}
```
#### Images Java API
Как уже было показано выше, используя Images Java API мы можем с помощью
```
ImagesServiceFactory.getImagesService().getServingUrl(
ServingUrlOptions.Builder.withGoogleStorageFileName(fileInfo.getGsObjectName())
);
```
или с помощью
```
ImagesServiceFactory.getImagesService().getServingUrl(
ServingUrlOptions.Builder.withBlobKey(blobKey)
);
```
получить URL предоставляющий файл изображения. Такой метод загрузки файла работает быстрее чем с помощью сервлета, но соответственно мы имеем как бы ссылку на «статичный» файл и не можем обрабатывать запрос как в случае использования сервлета.
Но такая созданная ссылка на файл может быть, так же как создана, удалена с помощью метода [.deleteServingUrl(BlobKey blobKey)](https://cloud.google.com/appengine/docs/java/javadoc/com/google/appengine/api/images/ImagesService#deleteServingUrl-com.google.appengine.api.blobstore.BlobKey-) Сам файл при этом из хранилища не удаляется, и на него может быть создана новая ссылка. Т.е. мы можем делать такие ссылки «одноразовыми» создавая и удаляя их в случае необходимости.
Кроме того к ссылкам на изображения созданным с помощью getServingUr() можно добавлять параметры изменяющие изображение, в формате `http://[image-url]=s200-fh-p-b10-c0xFFFF0000`:
s640 — генерирует изображение размером в 640 пикселей на самой большой грани
s0 — оригинальный размер изображения (по умолчанию выдаваемое изображение уменьшается!)
w100 — генерирует изображение шириной 100 пикселей
h100 — генерирует изображение высотой 100 пикселей
c — обрезает изображение до заданных размеров (s200, например)
p — «умное» обрезание изображения, старается обрезать до лица (работает не очень успешно)
pp — альтернативный метод сделать то же что в предыдущем пункте (работает аналогично)
cc — генерирует круглое изображение
fv — переворачивает вертикально
fh — переворачивает горизонтально
r{90} — поворачивает на указанное число градусов по часовой стрелке
rj — выдает изображение в формате JPG
rp — выдает изображение в формате PNG
rw — выдает изображение в формате WebP
rg — выдает изображение в формате GIF
b10 — добавляет рамку указанной ширины (в данном случае 10px)
c0xffff0000 — устанавливает цвет рамки (в данном случае красный)
d — добавляет header запускающий загрузку в браузере
h — выводит HTML страницу содержащую изображение
Например, из исходного изображения:
с параметрами: `=w100-h100-cc` — можно сгенерировать круглый аватар;
с параметрами: `=s200-b3-c0xffff0000` — thumbnail размером максимальной грани в 200px с красной рамкой шириной 3px:
В отличии от использования CSS, в данном случае, с сервера будет загружаться изображение уже уменьшенное до нужных размеров.
Больше параметров, см. на [stackoverflow.com/questions/25148567/list-of-all-the-app-engine-images-service-get-serving-url-uri-options](http://stackoverflow.com/questions/25148567/list-of-all-the-app-engine-images-service-get-serving-url-uri-options)
#### Доступ к хранилищу из командной строки (утилита [gsutil](https://cloud.google.com/storage/docs/gsutil))
gsutil написана на Python (требует Python 2.6.x или 2.7.x) и работает из командной строки on Linux/Unix, Mac OS, и Windows (XP и выше).
Инструкции по инсталляции: [cloud.google.com/storage/docs/gsutil\_install](https://cloud.google.com/storage/docs/gsutil_install)
После инсталляции запускаем:
```
gcloud auth login
```
и авторизуемся (аналогично изложенному на [habrahabr.ru/post/268863](http://habrahabr.ru/post/268863/))
gsutil представляет доступ к контейнерам хранилища с использованием команд похожих на привычны команды консоли Linux/Unix, файлы в хранилище обозначаются «путем» вида gs://{имя контейнера}, например gs://hello-habrahabr-api.appspot.com
Так, чтобы вывести информацию о файлах в контейнере, вводим команду
```
gsutil ls gs://hello-habrahabr-api.appspot.com
```
для всех файлов во всех контейнерах доступных текущему пользователю (Google account):
```
gsutil ls gs://*
```
для вывода командой ls более подробной информации указываем параметр `-l`, для полной информации о файлах указываем параметр `-L`:
Соответственно можно использовать команды `cp`, `mv`, `rm` в качестве адресов файлов в контейнере используя `gs://{имя контейнера} /{имя файла в контейнере}` и обычные пути для файлов на локальной ОС, также поддерживаются wildcard characters (`gs://*`) Подробнее о командах gsutil: [cloud.google.com/storage/docs/gsutil](https://cloud.google.com/storage/docs/gsutil)
Таким образом, используя возможности gsutil можно организовывать и автоматизировать работу с файлами в хранилище.
#### Ссылки
* [What is Google Cloud Storage?](https://cloud.google.com/storage/docs/overview)
* [Java Client for Google Cloud Storage](https://cloud.google.com/appengine/docs/java/googlecloudstorageclient/)
* [Images Java API Overview](https://cloud.google.com/appengine/docs/java/images/)
* [Blobstore Java API Overview](https://cloud.google.com/appengine/docs/java/blobstore/) | https://habr.com/ru/post/275211/ | null | ru | null |
# Sync vs Async на примере Firebird
В этой публикации я поставил перед собой несколько целей:
* Сравнить разные стили программирования работы с БД Firebird в NodeJS;
* Найти наиболее производительный вариант;
* Получить в результате руководство к действию тем, кто начинает использовать Firebird в NodeJS.
Дальше много кода…
Тестовая задача выглядит очень просто:
вернуть результат запроса
```
select * from rdb$relations
```
в формате JSON. На моей тестовой базе это будет ответ размером порядка 19 кб.
Напишем различные варианты реализации этой задачи и, используя Apache Benchmark, найдем оптимальный вариант. Тестировать производительность будем такой командой:
*```
ab -n 10000 -c 5 http://localhost:1337/
```*
Я не буду приводить весь вывод бенчмарка, чтобы не перегружать статью. Показателя среднего количества обработанных запросов в секунду(RPS) будет достаточно, чтобы сделать выводы в большинстве случаев.
Итак, начнем с самого простого варианта, когда все вызовы к библиотеке доступа являются синхронными:
```
var cfg = require("../config").cfg;
var fb = require('../../firebird');
var util = require('util');
var http = require('http');
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/plain'});
var con = fb.createConnection();
con.connectSync(cfg.db, cfg.user, cfg.password, cfg.role);
var rs = con.querySync('select * from rdb$relations');
var rows = rs.fetchSync("all",true);
con.disconnect();
res.write('[');
rows.forEach(function(r){
res.write(JSON.stringify(r)+',');
});
res.end(']');
}).listen(1337, "127.0.0.1");
console.log('Server running at http://127.0.0.1:1337/');
```
**Total transferred: 199310000 bytes
HTML transferred: 198670000 bytes
Requests per second: 52.47 [#/sec] (mean)**
Я оставил количество переданных байт, чтобы убедиться, что все варианты скриптов генерируют одинаковый результат.
Библиотека доступа к Firebird позволяет заменить все вызовы на асинхронные. Вот как это будет выглядеть:
```
var cfg = require("../config").cfg;
var fb = require('../../firebird');
var util = require('util');
var http = require('http');
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/plain'});
var con = fb.createConnection();
con.connect(cfg.db, cfg.user, cfg.password, cfg.role,function(){
con.query('select * from rdb$relations',function(err,rs){
res.write('[');
rs.fetch("all",true,function(r){
res.write(JSON.stringify(r)+',');
}, function(err){
con.disconnect();
res.end(']');
});
});
});
}).listen(1337, "127.0.0.1");
console.log('Server running at http://127.0.0.1:1337/');
```
**Total transferred: 199310000 bytes
HTML transferred: 198670000 bytes
Requests per second: 129.26 [#/sec] (mean)**
Простая замена синхронных вызовов на асинхронные дала прирост производительности до
129 запросов в секунду против 52. Асинхронный подход позволяет выполнять запросы параллельно, установив отдельное подключения для каждого клиента. Кроме того, в синхронном варианте весь результат запроса сначала записывается в память, а потом отдается клиенту. В асинхронном же строки результата отдаются клиенту по мере выборки из базы «на лету».
Однако, в этом коде еще есть неоптимальные моменты, которые могут быть оптимизированы. Например, это то, что каждое подключение клиента создает новое соединение с БД. Как крайний случай, попробуем обойтись единственным подключением. Вначале для синхронного варианта:
```
var cfg = require("../config").cfg;
var fb = require('../../firebird');
var util = require('util');
var http = require('http');
var con = fb.createConnection();
con.connectSync(cfg.db, cfg.user, cfg.password, cfg.role);
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/plain'});
if(!con.inTransaction) con.startTransactionSync();
var rs = con.querySync('select * from rdb$relations');
var rows = rs.fetchSync("all",true);
res.write('[');
rows.forEach(function(r){
res.write(JSON.stringify(r)+',');
});
res.end(']');
con.commitSync();
}).listen(1337, "127.0.0.1");
console.log('Server running at http://127.0.0.1:1337/');
```
**Total transferred: 199310000 bytes
HTML transferred: 198670000 bytes
Requests per second: 159.55 [#/sec] (mean)**
Как видно, этот вариант быстрее предыдущего асинхронного. Установление подключения к БД — довольно затратная по времени операция. Повторное использование подключения — известная и давно применяемая техника. Стоит брать на вооружение.
Теперь попробуем добавить асинхронности. Следующий код является заведомо неоптимальным — использование единственного подключения и асинхронность не позволят нам выполнять запросы параллельно. Тем не менее для чистоты эксперимента…
```
var cfg = require("../config").cfg;
var fb = require('../../firebird');
var util = require('util');
var http = require('http');
var con = fb.createConnection();
con.connectSync(cfg.db, cfg.user, cfg.password, cfg.role),
busy = false,
next = [];
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/plain'});
function doReq(){
con.query('select * from rdb$relations',function(err,rs){
res.write('[');
rs.fetch("all",true,function(r){
res.write(JSON.stringify(r)+',');
}, function(err){
res.end(']');
con.commit(function(){
busy = false;
var n = next.pop();
if(n) n();
});
});
});
}
function process(){
busy = true;
if(!con.inTransaction) con.startTransaction(doReq);
else doReq();
}
if(busy) next.push(function(){
process();
});
else process();
}).listen(1337, "127.0.0.1");
console.log('Server running at http://127.0.0.1:1337/');
```
**Total transferred: 199310000 bytes
HTML transferred: 198670000 bytes
Requests per second: 129.85 [#/sec] (mean)**
Асинхронный вариант выглядит довольно громоздким. И дает всего 129 запросов в секунду. Проблема в том, что использование единственного подключения не дает выигрыша при асинхронной выборке, поскольку клиентская библиотека Firebird не поддерживает асинхронные вызовы by design. Модуль Firebird для NodeJS запускает все асинхронные вызовы в параллельных потоках с использованием встроенного в libuv пула. Нельзя использовать единственное подключение для выполнения параллельных запросов. Поэтому код содержит проверки на занятость соединения и организует очередь вызовов. Видимо, организация очереди оказалась в данном случае замедляющим фактором. Ведь синхронный вариант оказался быстрее. Но использовать отдельное соединение с БД для каждого клиента тоже не всегда оптимально. Логичным решением было бы использование пула соединений.
```
var cfg = require("../config").cfg;
var fb = require('../../firebird');
var util = require('util');
var events = require('events');
var http = require('http');
function ConnectionPool()
{
events.EventEmitter.call(this);
this.conns = [];
this.busy = [];
this.MaxConns = 5;
this.newConn = function(){
var c = fb.createConnection();
c.connectSync(cfg.db, cfg.user, cfg.password, cfg.role);
this.conns.push(c);
};
this.get = function(cb)
{
var self = this;
var c = this.conns.pop();
if(c) {
this.busy.push(c);
cb(c);
}
else
if((this.busy.length) >= this.MaxConns){
this.once('release',function(){
self.get(cb);
});
}
else {
this.newConn();
this.get(cb);
}
};
this.release = function(con){
for(var i=0;i
```
**Total transferred: 199310000 bytes
HTML transferred: 198670000 bytes
Requests per second: 187.82 [#/sec] (mean)**
Кода получилось много, но и выигрыш в производительности очевиден. Тем более код организации пула соединений можно вынести в отдельный модуль для повторного использования, а код работы с БД останется простым и компактным.
Но можно пойти дальше. Когда множество клиентов используют один и тот же запрос, Firebird позволяет подготовить ресурсы для запроса и использовать его много раз, без необходимости повторять операции по выделению ресурсов и парсингу запроса. Так что, более оптимальным видится использование пула подготовленных запросов:
```
var cfg = require("../config").cfg;
var fb = require('../../firebird');
var util = require('util');
var events = require('events');
var http = require('http');
function StatementPool()
{
events.EventEmitter.call(this);
this.conns = [];
this.busy = [];
this.MaxConns = 5;
this.newConn = function(){
var c ={
conn: fb.createConnection()
};
c.conn.connectSync(cfg.db, cfg.user, cfg.password, cfg.role);
c.stmt = c.conn.prepareSync('select * from rdb$relations');
this.conns.push(c);
};
this.get = function(cb)
{
var self = this;
var c = this.conns.pop();
if(c) {
this.busy.push(c);
cb(c);
}
else
if((this.busy.length) >=this.MaxConns){
this.once('release',function(){
self.get(cb);
});
}
else {
this.newConn();
this.get(cb);
}
};
this.release = function(con){
for(var i=0;i
```
**Total transferred: 199310000 bytes
HTML transferred: 198670000 bytes
Requests per second: 214.37 [#/sec] (mean)**
Несмотря на бОльший объем кода, такой вариант дает более 210 запросов в секунду.
Использование нескольких соединений одновременно, подготовленных запросов и асинхронных вызовов дает выигрыш по крайней мере в 4 раза по сравнению с полностью синхронным вариантом. Однако эта цифра верна лишь для моего тестового окружения. Надо также понимать, что сама по себе асинхронность в NodeJS не позволяет увеличить производительность сервера БД, она лишь помогает его нагрузить по полной. В данном случае серверу БД было выделено 256Мб памяти и 1 ядро процессора — этим я объясняю в целом небольшие показатели RPS. Впрочем, нагрузка по памяти и так не превышала 3%. Также асинхронный подход позволяет параллельно обрабатывать другие запросы, не касающиеся запросов к БД. Таких запросов в данных тестах не было. Наиболее влияющим фактором на количество RPS стал размер выборки запроса. Так, при ограничении выборки 10 записями (около 1кб в результирующем JSON) и выделении серверу БД 4 ядер процессора, удалось получить порядка 1000 RPS, но и синхронный вариант в этом случае выдавал около 200 RPS. Стоит учесть, что асинхронный вариант, выполняя 1000 запросов к БД в секунду, способен при этом параллельно рисовать из них HTML по шаблонам, в то время как синхронный нет.
Все тестовые скрипты являются частью модуля доступа к [Firebird для NodeJS](http://habrahabr.ru/post/133633/)
И доступны на [GitHub](https://github.com/xdenser/node-firebird-libfbclient/tree/master/tests/perf). | https://habr.com/ru/post/139708/ | null | ru | null |
# Миграция PostgreSQL в Kubernetes
Все больше компаний внедряют Kubernetes как из интереса к передовым технологиям, так и в рамках стратегии по трансформации бизнеса. Когда дело касается переноса приложений в контейнеры и инфраструктуру Kubernetes, перед разработчиками и специалистами по эксплуатации встают непростые задачи, если приложения изначально не ориентированы на облако.
Миграция баз данных всегда сопряжена с рисками и простоями для бизнеса. Сегодня я продемонстрирую, насколько легко можно перенести базу данных PostgreSQL в Kubernetes с минимальными простоями. В этом мне поможет [дистрибутив Percona для PostgreSQL Operator](https://www.percona.com/doc/kubernetes-operator-for-postgresql/index.html).
### Цель
Для выполнения миграции я буду использовать следующую конфигурацию:
1. База данных PostgreSQL, развернутая локально или где-то в облаке. Эту базу данных будем называть источником.
2. Кластер [Google Kubernetes Engine](https://cloud.google.com/kubernetes-engine) (GKE), на котором будет развернуто решение Percona Operator для управления целевым кластером PostgreSQL и подом [pgBackRest](https://pgbackrest.org/).
3. Резервные копии и журналы предзаписи PostgreSQL загружаются в какой-либо бакет объектного хранилища (в моем случае — GCS).
4. Данные из бакета считываются с помощью пода pgBackRest.
5. Этот же под непрерывно восстанавливает данные в кластер PostgreSQL в Kubernetes.
Данные должны непрерывно синхронизироваться. По завершении процесса я хочу отключить локальный экземпляр PostgreSQL и оставить только кластер в GKE.
### Миграция
**Предварительные требования**
Чтобы воссоздать у себя такую конфигурацию, вам понадобятся:
* PostgreSQL версии 12 или 13 (нет разницы, где запущена СУБД);
* установленный пакет pgBackRest;
* Google Cloud Storage или любой другой S3-бакет (в моем случае — GCS);
* кластер Kubernetes.
**Настройка источника**
В моем случае это [дистрибутив Percona для PostgreSQL](https://www.percona.com/software/postgresql-distribution) версии 13, установленный на несколько серверов с Linux.
1. Настройте [pgBackrest](https://github.com/spron-in/blog-data/blob/master/postgres-to-kubernetes/pgbackrest.conf).
```
# cat /etc/pgbackrest.conf
[global]
log-level-console=info
log-level-file=debug
start-fast=y
[db]
pg1-path=/var/lib/postgresql/13/main
repo1-type=gcs
repo1-gcs-bucket=sp-test-1
repo1-gcs-key=/tmp/gcs.key
repo1-path=/on-prem-pg
```
* Значением параметра pg1-path должен быть путь к каталогу данных PostgreSQL.
* В параметре repo1-type указано GCS, так как мы хотим сохранять резервные копии в этом хранилище.
* В файле /tmp/gcs.key находится ключ, который можно получить через пользовательский интерфейс Google Cloud. Подробнее об этом читайте [здесь](https://cloud.google.com/iam/docs/creating-managing-service-account-keys).
* Резервные копии будут сохраняться в папке on-prem-pg в бакете sp-test-1.
2. Включите в файле конфигурации `postgresql.conf` архивирование через `pgBackrest`.
```
archive_mode = on
archive_command = 'pgbackrest --stanza=db archive-push %p'
```
После изменения конфигурации потребуется перезапуск.
3. Operator требует, чтобы в каталоге данных также находился файл с именем `postgresql.conf`. Будет достаточно пустого файла:
```
touch /var/lib/postgresql/13/main/postgresql.conf
```
4. На источнике необходимо создать пользователя `primaryuser`, чтобы обеспечить корректную настройку репликации через Operator.
```
# create user primaryuser with encrypted password '' replication;
```
### Настройка целевого кластера
1. Разверните дистрибутив Percona для PostgreSQL Operator на Kubernetes. Этот процесс подробно описан в [документации](https://www.percona.com/doc/kubernetes-operator-for-postgresql/kubernetes.html).
```
# create the namespace
kubectl create namespace pgo
# clone the git repository
git clone -b v0.2.0 https://github.com/percona/percona-postgresql-operator/
cd percona-postgresql-operator
# deploy the operator
kubectl apply -f deploy/operator.yaml
```
2. Измените главный манифест настраиваемого ресурса — `deploy/cr.yaml`.
* Я не стал изменять имя кластера и оставил `cluster1`.
* Кластер будет функционировать в режиме ожидания, то есть он будет синхронизировать данные из бакета GCS. Задайте для параметра `spec.standby` значение `true`.
* Настройте GCS. Раздел `spec.backup` должен выглядеть примерно так (параметры `bucket` и `repoPath` имеют те же значения, что и в вышеприведенной конфигурации `pgBackrest`):
```
backup:
...
repoPath: "/on-prem-pg"
...
storages:
my-s3:
type: gcs
endpointUrl: https://storage.googleapis.com
region: us-central1-a
uriStyle: path
verifyTLS: false
bucket: sp-test-1
storageTypes: [
"gcs"
]
```
* Я хочу, чтобы в моем кластере PostgreSQL была как минимум одна реплика. Для этого параметру `spec.pgReplicas.hotStandby.size` нужно присвоить значение 1.
3. Для Operator необходимо обеспечить возможность аутентификации в GCS. Для этого нужно создать секретный объект под названием `<ИМЯКЛАСТЕРА>-backrest-repo-config`, который будет содержать ключ `gcs-key`. Это должен быть тот же самый ключ, который мы использовали на источнике. См. пример секрета [здесь](https://github.com/spron-in/blog-data/blob/master/postgres-to-kubernetes/gcs.yaml).
```
kubectl apply -f gcs.yaml
```
4. Создайте пользователей путем создания секретных объектов: `postgres` и `primaryuser` (тот же пользователь, которого мы создали на источнике). См. примеры секретов для пользователей [здесь](https://github.com/spron-in/blog-data/blob/master/postgres-to-kubernetes/users.yaml). Пароли должны быть такими же, как на источнике.
```
kubectl apply -f users.yaml
```
5. Теперь развернем кластер на Kubernetes, применив манифест cr.yaml:
```
kubectl apply -f deploy/cr.yaml
```
### Проверка работоспособности и устранение неполадок
Если все сделано правильно, вы увидите в логах основного пода следующее:
```
kubectl -n pgo logs -f --tail=20 cluster1-5dfb96f77d-7m2rs
2021-07-30 10:41:08,286 INFO: Reaped pid=548, exit status=0
2021-07-30 10:41:08,298 INFO: establishing a new patroni connection to the postgres cluster
2021-07-30 10:41:08,359 INFO: initialized a new cluster
Fri Jul 30 10:41:09 UTC 2021 INFO: PGHA_INIT is 'true', waiting to initialize as primary
Fri Jul 30 10:41:09 UTC 2021 INFO: Node cluster1-5dfb96f77d-7m2rs fully initialized for cluster cluster1 and is ready for use
2021-07-30 10:41:18,781 INFO: Lock owner: cluster1-5dfb96f77d-7m2rs; I am cluster1-5dfb96f77d-7m2rs 2021-07-30 10:41:18,810 INFO: no action. i am the standby leader with the lock 2021-07-30 10:41:28,781 INFO: Lock owner: cluster1-5dfb96f77d-7m2rs; I am cluster1-5dfb96f77d-7m2rs 2021-07-30 10:41:28,832 INFO: no action. i am the standby leader with the lock
```
Измените какие-нибудь данные на источнике и убедитесь, что они корректно синхронизируются с целевым кластером.
### Типичные проблемы
Следующее сообщение об ошибке говорит о том, что вы забыли создать файл `postgresql.conf` в каталоге данных:
```
FileNotFoundError: [Errno 2] No such file or directory: '/pgdata/cluster1/postgresql.conf' -> '/pgdata/cluster1/postgresql.base.conf'
```
Если забыть создать пользователя `primaryuser`, в логах появится следующее:
```
psycopg2.OperationalError: FATAL: password authentication failed for user "primaryuser"
```
Из-за неправильных или отсутствующих параметров доступа к объектному хранилищу возникает следующая ошибка:
```
WARN: repo1: [CryptoError] unable to load info file '/on-prem-pg/backup/db/backup.info' or '/on-prem-pg/backup/db/backup.info.copy': CryptoError: raised from remote-0 protocol on 'cluster1-backrest-shared-repo': unable to read PEM: [218529960] wrong tag HINT: is or was the repo encrypted? CryptoError: raised from remote-0 protocol on 'cluster1-backrest-shared-repo': unable to read PEM: [218595386] nested asn1 error
HINT: is or was the repo encrypted?
HINT: backup.info cannot be opened and is required to perform a backup.
HINT: has a stanza-create been performed?
ERROR: [075]: no backup set found to restore
Fri Jul 30 10:54:00 UTC 2021 ERROR: pgBackRest standby Creation: pgBackRest restore failed when creating standby
```
### Переключение
Все выглядит хорошо — пора сделать переключение. В этой статье я затрагиваю лишь те аспекты, которые непосредственно связаны с базой данных, однако не нужно забывать о необходимости перенастроить приложение, чтобы оно ссылалось на нужный кластер PostgreSQL. Перед переключением приложение рекомендуется остановить.
1. Остановите исходный кластер PostgreSQL, чтобы исключить вероятность записи данных во время переключения:
```
systemctl stop postgresql
```
2. Сделайте целевой кластер основным. Для этого удалите параметр `spec.backup.repoPath` и измените значение параметра `spec.standby` на `false` в файле `deploy/cr.yaml`. Затем примените изменения:
```
kubectl apply -f deploy/cr.yaml
```
PostgreSQL автоматически перезапустится, а в логах появится следующее:
```
2021-07-30 11:16:20,020 INFO: updated leader lock during promote
2021-07-30 11:16:20,025 INFO: Changed archive_mode from on to True (restart might be required)
2021-07-30 11:16:20,025 INFO: Changed max_wal_senders from 10 to 6 (restart might be required)
2021-07-30 11:16:20,027 INFO: Reloading PostgreSQL configuration.
server signaled
2021-07-30 11:16:21,037 INFO: Lock owner: cluster1-5dfb96f77d-n4c79; I am cluster1-5dfb96f77d-n4c79
2021-07-30 11:16:21,132 INFO: no action. i am the leader with the lock
```
### Заключение
Развертывание кластеров баз данных и управление ими — непростая задача. Недавно выпущенный дистрибутив Percona для PostgreSQL Operator позволяет автоматизировать операции по настройке и вводу в эксплуатацию PostgreSQL на Kubernetes, превращая это мероприятие в слаженный процесс без лишней головной боли.
В настоящее время Kubernetes становится стандартным механизмом управления инфраструктурой. В связи с этим разработчики и специалисты по эксплуатации часто сталкиваются с задачей миграции, которая обычно превращается в сложный проект. В этой статье продемонстрировано, что миграция базы данных может быть нетрудным мероприятием, которое осуществляется с минимальным временем простоя.
Рекомендуем испробовать решение Operator: см. [репозиторий на GitHub](https://github.com/percona/percona-postgresql-operator/) и [документацию](https://www.percona.com/doc/kubernetes-operator-for-postgresql/index.html).
Нашли баг или хотите предложить новую возможность для разработки? Отправьте запрос в [JIRA](https://jira.percona.com/browse/K8SPG).
Общие вопросы можно задавать на [форуме сообщества](https://forums.percona.com/c/postgresql/percona-kubernetes-operator-for-postgresql/68).
Если вы разработчик и хотите внести вклад в проект, ознакомьтесь с инструкцией [CONTRIBUTING.md](https://github.com/percona/percona-postgresql-operator/blob/main/CONTRIBUTING.md) и отправляйте pull-запросы.
В дистрибутиве Percona для PostgreSQL объединены наилучшие компоненты с открытым исходным кодом, необходимые для развертывания СУБД в корпоративной среде. Все компоненты протестированы с точки зрения взаимной совместимости.
---
> Материал подготовлен в рамках курса [**«PostgreSQL»**](https://otus.pw/3jF9/). Если вам интересно узнать подробнее о формате обучения и программе, познакомиться с преподавателем курса — приглашаем на день открытых дверей онлайн. Регистрация [здесь.](https://otus.pw/aOxb/)
>
> | https://habr.com/ru/post/576730/ | null | ru | null |
# Никто не знает, как работает каскад
Перед началом чтения пройдите простой тест — каким будет значение свойства `background-color` в первом и во втором варианте, и почему именно так?
Правильный ответ. В 1 варианте — `transparent`, во 2 варианте — `red`. [Проверить вживую](https://htmlacademy.ru/demos/85) в интерактивной демонстрации.
### Почему так?
Может показаться, что в обоих случаях на этапе каскада победит последнее CSS-правило. Но нет.
Во втором случае объявление `background-color: 20px` вообще невалидное, поэтому оно отбросится ещё на этапе фильтрации. А на вход алгоритма каскадной сортировки попадёт только одно объявление – `background-color: red`. Оно же и победит.
В первом случае всё ещё интереснее.
Сначала оба объявления пройдут через этап фильтрации. Затем они поборются друг с другом на этапе каскада и победит объявление `background-color: var(--not-a-color)`.
На этапе определения вычисленного значения браузер заглянет внутрь переменной `--not-a-color` , а там окажется `20px`. Это невалидный цвет фона, поэтому придётся его отбросить и запустить алгоритм выбора значений по умолчанию.
Наследуемое значение получить не выйдет, ведь `background-color` не наследуется, поэтому будет использовано начальное значение свойства из спецификации — `transparent`**.**
### Как браузер разбирает CSS
Существует частое заблуждение в том, что при обработке CSS в браузере выполняется только каскадирование и наследование. На самом деле процесс получения и обработки значений шире. Вот примерная схема:
Давайте подробнее разберёмся, из чего состоит процесс обработки значений.
### Обработка значений
Обработка значений — процесс, после которого свойства всех элементов на странице получают конкретные значения. Он происходит после того, как парсер разделит весь код на токены и выделит среди них объявления. Напомним, что объявлениями называют пары свойство: значение. Например, `font-style: italic`.
Обработку значений можно разделить на четыре этапа:
* фильтрация,
* каскад,
* получение значений по умолчанию,
* вычисления.
При обработке значения появляются, изменяются, а иногда даже отбрасываются. Каждая ступень «эволюции» значений имеет свои особенности и своё название:
#### Фильтрация
Первый этап обработки значений — фильтрация объявлений *(Авито, извините).* В процессе фильтрации браузер отбирает валидные и уместные объявления, а также сопоставляет их с элементами из HTML.
На основе разобранных и отфильтрованных объявлений браузер составляет для каждого элемента список всех его объявленных (declared) значений. Таких значений может быть сколько угодно: ноль, одно или несколько.
```
p {
color: #101010;
}
.warning {
color: #22ff22;
}
p.warning {
font-size: 24px;
color: #744ce5;
}
```
Тогда у элемента будет три объявленных значения свойства color, одно значение свойства `font-size` и ни одного объявленного значения свойства `font-weight`.
#### Каскад
На следующем этапе для каждого объявленного свойства с помощью алгоритма каскада вычисляется каскадированное (cascaded) значение.
При каскадировании учитывается:
* происхождение — стили самого браузера, стили разработчика и пользователя учитываются с разным приоритетом;
* важность — стили бывают «важные» (`!important`) или «обычные»;
* контекст — стили могут быть изолированы в отдельном контексте «теневого» DOM-дерева;
* специфичность — селекторы (по тегу, классу и так далее) имеют разный вес;
* порядок появления в коде — стили применяются по очереди и последующие переопределяют предыдущие.
Важно запомнить, что **каскадированных значений у свойства может быть не больше одного.**
Например, у элемента `,` о котором говорилось выше, останется только одно значение свойства `color` — это `#744ce5`. Два других объявленных значения будут отброшены.
#### Получение значений по умолчанию
Разработчики при написании стилей редко указывают абсолютно все свойства элемента. Поэтому и в объявленные, и в каскадированные значения попадает меньше значений, чем нужно браузеру для отрисовки страницы.
Недостающую информацию браузер получает с помощью значений по умолчанию. К ним относятся унаследованные (inherited) и начальные (initial) значения.
Узнать, наследуется ли свойство, и его начальное значение, можно из его описания:
Каскадированные, унаследованные и начальные значения попадают в список определённых (specified) значений. В результате абсолютно всем свойствам каждого элемента на странице присваивается какое-то значение.
#### Вычисления
До этого момента браузер только собирал значения, но никаких вычислений не происходило. Однако без них не обойтись, если в объявлениях используются формулы, относительные адреса и единицы измерения.
Этап вычислений можно разделить на три подэтапа: получение вычисленных, используемых и действительных значений.
**Получение вычисленных значений**
Первый этап расчётов происходит ещё до создания раскладки страницы. Поэтому некоторые значения — например, ширина элемента, если она зависит от размера вьюпорта — так и остаются невычисленными. Однако там, где это возможно, браузер находит вычисленные (computed) значения.
Что может быть вычисленным значением свойства, можно узнать из его описания:
Разберём пример:
```
p {
font-size: 16px;
line-height: 1.2em;
padding: calc(3em + 20px);
background-image: url("image.jpg");
width: 50%;
}
```
После первого этапа вычислений значения превратятся в следующие:
```
p {
font-size: 16px; /* Ничего вычислять не нужно */
line-height: 19.2px;
padding: 68px;
background-image: url("http://www.example.com/image.jpg");
width: 50%; /* Невозможно вычислить на этом этапе */
}
```
Как и определённое, вычисленное значение существует для абсолютно всех свойств элемента. И именно оно передаётся по наследству потомкам.
Даже если сам элемент не использует какое-то значение, оно может наследоваться и влиять на отрисовку. Так, например, свойство text-transform не применяется к блочным боксам, но наследуется и влияет на вложенные в них строчные боксы.
```
div {
text-transform: uppercase;
}
Текст
```
В описании свойств в спецификации указано, к каким элементам они применяются:
Кстати, по историческим причинам метод [getComputedStyle](https://www.w3.org/TR/cssom-1/#dom-window-getcomputedstyle) не всегда возвращает именно вычисленное значение. Иногда это будет используемое значение (см. ниже).
**Получение используемых значений**
Получив все возможные вычисленные значения, браузер создаёт раскладку страницы и начинает следующий этап вычислений. Теперь разрешаются те значения, которые зависят от вьюпорта, а также размеров, пропорций и относительного расположения элементов на странице.
Кроме того, отбрасываются значения, которые для конкретного элемента не имеют смысла. Например, `grid-template-columns` для элемента, который не является грид-контейнером.
В результате остаются и вычисляются все значения, которые нужны для отрисовки страницы. Такие значения называют используемыми (used).
**Получение действительных значений**
Вооружённый используемыми значениями, браузер готов начать отрисовку страницы… но тут в игру вступают внешние факторы и ограничения. Не всё, что указано и вычислено, может быть отрисовано. В результате действительные (actual) значения могут отличаться от используемых.
Например, так происходит с дробным значением `border-width`. Как правило, браузеры округляют используемое значение, и в действительности ширина рамки оказывается кратной целому пикселю.
```
div {
border-width: 13.2px; /* Действительное значение — 13px */
}
```
Другой пример — действительный размер текста может отличаться от используемого, если желаемый шрифт по какой-то причине недоступен и задано свойство `font-size-adjust`.
```
.rule {
font-family: "Futura", "Verdana", sans-serif;
font-size: 20px; /* Если первый шрифт не загрузится,
то действительное значение — 41px */
font-size-adjust: 1;
}
```
После получения действительных значений обработка заканчивается, и браузер отрисовывает страницу.
Мы собрали таблицу с примерами того, как во время обработки могут меняться значения различных свойств.
### Как работает каскад
1. Сначала браузер анализирует и фильтрует значения, чтобы получить список объявленных значений.
2. Затем включается алгоритм каскада, и в результате для каждого свойства остаётся только одно каскадированное значение.
3. Если какое-то значение не было объявлено, оно получается с помощью наследования или начальных значений. Таким образом каждый элемент получает полный набор определённых значений.
4. Затем наступает первый этап вычислений, и браузер преобразует определённые значения в вычисленные. Именно они передаются по наследству потомкам элемента.
5. На втором этапе вычислений браузер разрешает те значения, которые зависят от устройства пользователя и относительного расположения элементов на странице, а также отбрасывает те значения, которые не нужны для отрисовки. В результате получаются используемые значения.
6. В конце концов к веб-странице применяются некоторые ограничения, и используемые значения становятся действительными.
*Эта статья — попытка описать то, как браузеры понимают и разбирают CSS, и почему важно понимать, как это работает. А ещё это фрагмент* [*курса «Анатомия каскада»*](https://l.htmlacademy.ru/anatomy-of-cascade-early-bird?utm_source=habr&utm_medium=special&utm_campaign=cascade251121)*, на котором мы разбираем вообще все тонкости каскада: обработку и фильтрацию значений, наследование и стили по умолчанию. И всё это приправлено тестами и демками, чтобы сразу пробовать всё на практике.*
Финальный тест, чтобы закрепить пройденное. Можете обсудить свои варианты в комментариях.
Какого цвета будет ссылка в обоих случаях?
Первый случайВторой случай | https://habr.com/ru/post/590779/ | null | ru | null |
# Поднимаем IDS/NMS: Mikrotik и Suricata c web-интерфейсом
У меня, видимо, такая карма: как ни возьмусь за реализацию какого-нибудь сервиса на опенсорсе, так обязательно найду кучу мануалов, каждый по отдельности из которых в моем конкретном случае не сработает, готовое решение толком не заведется или не понравится, случится еще какая-нибудь неудобоваримость, и в итоге приходится самому пробиваться к результату.
В этот раз все мануалы были на ELK5 или еще старше, а мне не очень хотелось ставить софтину пред-предыдущих версий. Мне хотелось взять софтину с наиболее перспективными сроками поддержки: желательно самое свежее из стабильного.
В итоге, чтобы в дальнейшем иметь возможность повторить совершенный подвиг без повтора всех мучений, приходится писать такие пошаговые шпаргалки, которыми и делюсь с вами.
Итак, сегодня Mikrotik (RouterOS), Suricata 4.1, Elasticsearch+Filebeat+Kibana 6.5.
### Вместо вступления
Условия:
* Mikrotik на i386 в виртуальной машине на хосте А. Все интерфейсы на Mikrotik'е раскиданы по VLAN'ам, хост имеет один физический сетевой интерфейс.
* Свободные ресурсы для IDS/IPS/NMS на хосте Б с единственным физическим сетевым интерфейсом.
* 20-мегабитный канал наружу.
* Желание получать аналитику о проходящем через внешний интерфейс Mikrotik'а трафике.
* Бюджет в хрен рублей и фиг копеек.
* Некоторое количество свободного от хлопот времени.
Я не стану рассказывать здесь, что такое IDS/IPS/NMS, зачем оно нужно и какое оно бывает. Все это знают и без меня, а кто не знает, тот нагуглит.
Так же я не стану обосновывать свой выбор между Snort и Suricata в пользу последнего. Это дело вкуса.
Зато поверхностно объясню, как это работает:
Suricata неким образом получает трафик. Вариантов три: а) пропускать его через себя в inline-режиме, б) получать копию трафика с порта коммутатора и в) анализировать дампы с трафиком. Полученный трафик Suricata подвергает анализу и на основе проведенного анализа выдает данные о том, что же она там в этом трафике нашла.
Данные Suricata может выдавать в JSON'е. Соответственно, имея структурированные данные, их можно скормить какой-нибудь системе для обработки, систематизации, анализа и визуализации.
Для анализа и визуализации данных, на сколько я понял, не являясь специалистом в этой области, прекрасно подходит ELK-стек. ELK-стек первоначально состоял из Elasticsearch, Logstash, Kibana. Сейчас к нему добавился Beat (семейство программ-интерфейсов, выступающих посредником между источником данных и Logstash'ем или Elasticsearch'ем). Забегая вперед, скажу, что обошлось без Logstash'а, поскольку Beat прекрасно отдает данные напрямую в Elasticsearch, а Elasticsearch отлично их кушает. Скушанные данные Elasticsearch передает Kibana — веб-интерфейсу для всего ELK-стека. Kibana, используя шаблоны, переданные ему Filebeat'ом, предоставляет пользователю визуализацию данных, так называемые Dashboard'ы. Учитывая тот факт, что Elasticsearch, Logstash, Beat и Kibana плод трудов одного производителя, все это хозяйство неплохо увязывается друг с другом, и процесс связывания неплохо документирован (по опенсорсным меркам, конечно).
Таким образом, исходя из вышесказанного, задачу можно описать так: получить копию трафика с порта маршрутизатора, передать ее в Suricata, получить от Suricata данные в JSON-формате, передать их в Filebeat, чтобы тот, в свою очередь, передал их в Elasticsearch и помог Kibana создать их визуальное отображение.
### Mikrotik RouterOS
Если бы маршрутизатор Mikrotik у меня был аппаратный, то вопрос зеркалирования порта (port mirroring) не стоял бы вообще. Все решилось бы включением зеркалирования трафика, проходящего через внешний интерфейс, на любой свободный порт самого Mikrotik'а. Если бы не было свободного порта на Mikrotik'е, можно было бы включить зеркалирование порта на коммутаторе. Но в моем случае Mikrotik вообще не имел физических портов, а порт на коммутаторе получал трафик со всего хоста, на котором, кроме Mikrotik'а, было еще несколько виртуальных машин.
И тут я в очередной раз мысленно сказал: «Спасибо, Mikrotik!». Спасибо за встроенный в RouterOS сниффер. По традиции обходимся без скриншотов, одними лишь консольными командами.
Открываем терминал в WinBox'е и включаем сниффер:
`/tool sniffer set filter-interface=if-out filter-stream=yes streaming-enabled=yes streaming-server=192.168.1.253
/tool sniffer start`
Указываете вместо *if-out* имя интерфейса, трафик с которого планируете перехватывать, и вместо *192.168.1.253* — IP-адрес машины, куда по протоколу [TZSP](https://en.wikipedia.org/wiki/TZSP) будет отправляться перехваченный трафик.
С Mikrotik'ом все.
### Suricata
Вообще, я не очень линуксоголовый, поэтому больше всего люблю попсовые дистрибутивы. Ну, разве что больше люблю более аскетичный Debian. Вот и начал с него. Ну и, разумеется, в силу нелинуксоголовости ставить хотел бинарники и из репозитория. Сборка — это мне всегда лениво. Так вот, если будет возможность выбрать Debian, — не выбирайте. Я сейчас не вспомню, в каком именно месте у меня был затык в установке всего хозяйства под Debian'ом, но он был. И вся дальнейшая история об установке всего под Ubunta.
Была создана 4-ядерная виртуальная машина с 4 гигами оперативки, скачан и установлен на нее [Ubuntu Server 18.04.1 LTS (x64)](https://mirror.yandex.ru/ubuntu-releases/18.04.1/ubuntu-18.04.1-live-server-amd64.iso)
> **Соглашение**: все дальнейшие действия выполняются от имени superuser, поэтому или логиньтесь под root, или к каждой команде добавляйте *sudo*.
Поскольку на каждом этапе я делал снапшоты, а потом неоднократно к ним откатывался, в конце я прикурил изрядных глюков с рассинхроном времени в виртуалке с реальным временем.
Поэтому сразу выставляем правильный часовой пояс и синхронизацию по NTP:
`systemctl start systemd-timesyncd
systemctl status systemd-timesyncd
dpkg-reconfigure tzdata`
Для того, чтобы при установке Suricata не было проблем с зависимостями, добавляем репозитории *universe* в ***/etc/apt/sources.list***:
`nano /etc/apt/sources.list`
> …
>
> deb [archive.ubuntu.com/ubuntu](http://archive.ubuntu.com/ubuntu/) bionic main universe
>
> deb [archive.ubuntu.com/ubuntu](http://archive.ubuntu.com/ubuntu/) bionic-security main universe
>
> deb [archive.ubuntu.com/ubuntu](http://archive.ubuntu.com/ubuntu/) bionic-updates main universe
Так же добавляем репозиторий, откуда будем брать Suricata:
`add-apt-repository ppa:oisf/suricata-stable`
Обновляем базу пакетов:
`apt-get update`
Устанавливаем Suricata:
`apt-get install -y suricata`
Следующий этап — установка правил для Suricata и их апдейта:
`apt-get install -y python-pip
pip install pyyaml
pip install https://github.com/OISF/suricata-update/archive/master.zip`
Запускаем обновление самого *suricata-update*:
`pip install --pre --upgrade suricata-update`
Запуск без дополнительного конфигурирования поставит нам Emerging Threats Open ruleset:
`suricata-update`
Чтобы посмотреть список источников, выполняем:
`suricata-update list-sources`
Обновление источников правил:
`suricata-update update-sources`
Посмотрим, что там наобновлялось в источниках, выполним повторно:
`suricata-update list-sources`
Включаем все бесплатные источники:
`suricata-update enable-source ptresearch/attackdetection
suricata-update enable-source oisf/trafficid
suricata-update enable-source sslbl/ssl-fp-blacklist`
И еще раз обновляем правила:
`suricata-update`
Suricata установлена.
Теперь надо получить трафик.
### Trafr
Trafr — это приложение, написанное Mikrotik'ом для конвертации TZSP-трафика в pcap. Приложение 32-битное, поэтому для его запуска понадобится включить поддержку 32-битных приложений в 64-битной Ubunta:
`dpkg --add-architecture i386
apt-get update && apt-get install -y libc6:i386`
Скачиваем и распаковываем ***trafr***:
`wget http://www.mikrotik.com/download/trafr.tgz
tar xzf trafr.tgz`
Проверяем, что трафик ловится:
`./trafr -s`
У меня после такого запуска в консоли виртуальной машины сломался символьный вывод в графическом режиме, пришлось перезагружаться. При удаленном подключении через ssh в PuTTY никаких проблем не было.
Если на экране видите беспорядочное мельтешение, значит трафик прилетает, и ***trafr*** его ловит. Раз так, переносим ***trafr*** на ПМЖ и запускаем его с передачей пойманного трафика через конвейер сразу в Suricata:
`mv trafr /usr/local/bin/
/usr/local/bin/trafr -s | suricata -c /etc/suricata/suricata.yaml -r /dev/stdin`
Сейчас проверяем, что трафик поступает в Suricata, для этого в соседнем терминале выполняем:
`tail -f /var/log/suricata/fast.log`
Должны увидеть шустрый скролл осмысленного текста — лог получения трафика сурикатой.
Так же не лишним будет убедиться, что Suricata трафик не только получает, но и анализирует:
`tail -f /var/log/suricata/eve.json`
Это как раз тот самый выход событий из Suricata в JSON-формате, который мы будем скармливать Filebeat'у.
### Elasticsearch+Filebeat+Kibana 6.5
Устанавливаем PGP-ключ, необходимый для пользования репозиторием Elastic и устанавливаем необходимые зависимости:
`wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -
echo "deb https://artifacts.elastic.co/packages/6.x/apt stable main" | sudo tee -a /etc/apt/sources.list.d/elastic-6.x.list
apt-get update && apt-get install -y openjdk-8-jre apt-transport-https wget nginx`
Обратите внимание, что Java версии 8. Все, что выше 8 — не поддерживается. Поэтому, если успели ранее установить более свежую Java, сносите ее и ставьте 8.
Убеждаемся, что Java установилась как надо:
`java -version`
Получим примерно такой вывод:
> java version «1.8.0\_191»
>
> Java(TM) SE Runtime Environment (build 1.8.0\_191-b12)
>
> Java HotSpot(TM) 64-Bit Server VM (build 25.191-b12, mixed mode)
Создаем пользователя и пароль для доступа к Kibana. Вместо *admin* выберите что-то, что вам больше по вкусу:
`echo "admin:`openssl passwd -apr1`" | sudo tee -a /etc/nginx/htpasswd.users`
Поскольку ELK будет крутиться на localhost, настраиваем reverse proxy в nginx:
`nano /etc/nginx/sites-available/kibana`
> server {
>
> listen 80;
>
>
>
> server\_name suricata.server;
>
>
>
> auth\_basic «Restricted Access»;
>
> auth\_basic\_user\_file /etc/nginx/htpasswd.users;
>
>
>
> location / {
>
> proxy\_pass [localhost](http://localhost):5601;
>
> proxy\_http\_version 1.1;
>
> proxy\_set\_header Upgrade $http\_upgrade;
>
> proxy\_set\_header Connection 'upgrade';
>
> proxy\_set\_header Host $host;
>
> proxy\_cache\_bypass $http\_upgrade;
>
> }
>
> }
`rm /etc/nginx/sites-enabled/default
ln -s /etc/nginx/sites-available/kibana /etc/nginx/sites-enabled/kibana`
Перезапускаем nginx:
`systemctl restart nginx`
Ставим Elasticsearch:
`apt-get install -y elasticsearch`
Включаем автозапуск при загрузке ОС:
`systemctl daemon-reload
systemctl enable elasticsearch.service`
Запускаем:
`systemctl start elasticsearch.service`
Проверяем, поднялось ли:
`curl -X GET "localhost:9200/"`
В зависимости от производительности вашей железки, запуск ES может занять какое-то время. Если получаем *connection refused*, то просто повторяем запрос и ждем, пока в ответ не получим что-то вроде:
> {
>
> «name»: «lcZuxxm»,
>
> «cluster\_name»: «elasticsearch»,
>
> «cluster\_uuid»: «kmJHqJnlQe2Rk7F-CRi4EA»,
>
> «version»: {
>
> «number»: «6.5.1»,
>
> «build\_flavor»: «default»,
>
> «build\_type»: «deb»,
>
> «build\_hash»: «8c58350»,
>
> «build\_date»: «2018-11-16T02:22:42.182257Z»,
>
> «build\_snapshot»: false,
>
> «lucene\_version»: «7.5.0»,
>
> «minimum\_wire\_compatibility\_version»: «5.6.0»,
>
> «minimum\_index\_compatibility\_version»: «5.0.0»
>
> },
>
> «tagline»: «You Know, for Search»
>
> }
Ставим Kibana:
`apt-get install -y kibana`
Включаем автозапуск при загрузке ОС:
`systemctl daemon-reload
systemctl enable kibana.service`
Запускаем:
`systemctl start kibana.service`
Теперь можно перейти на [192.168.1.253](http://192.168.1.253) (естественно, IP-адрес тот, что назначили вашей машине с сурикатой). Должна открыться титульная страница Kibana
Ставим Filebeat:
`apt-get install -y filebeat`
Включаем автозапуск при загрузке ОС:
`systemctl daemon-reload
systemctl enable filebeat`
Включаем модуль Suricata, входящий в набор модулей Filebeat:
`filebeat modules enable suricata`
Устанавливаем плагины для Suricata в Elasticsearch:
`~~/usr/share/elasticsearch/bin/elasticsearch-plugin install ingest-geoip
/usr/share/elasticsearch/bin/elasticsearch-plugin install ingest-user-agent~~`
**Смотрите UPD от 22 мая 2019 года.**
Перезапускаем Elasticsearch:
`systemctl restart elasticsearch.service`
Выполняем первоначальную настройку Filebeat, заодно выполнится загрузка шаблонов в Kibana:
`filebeat setup -e`
Проверяем, что Filebeat нашел */var/log/suricata/eve.json* и обрабатывает его, для этого запускаем Filebeat в режиме вывода на экран данных с маркером *publish*:
`filebeat -e -d "publish"`
Первым пойдет json-форматированный вывод самого Filebeat'а, потом простой текстовый вывод его логов, и только спустя некоторое время вывод из Suricata, поэтому выждите и убедитесь, что все работает. После этого прервите Filebeat и вернитесь в bash.
Включаем автозапуск при загрузке ОС:
`systemctl daemon-reload
systemctl enable filebeat.service`
Запускаем Filebeat:
`systemctl start filebeat.service`
Переходим в Kibana, выбираем в меню слева Dashboard, выбираем индекс ***filebeat-\****. Снова выбираем Dashboard, в списке выбираем **[Suricata] Alert Overview** и должны получить что-то вроде такого:
### Факультативно
Не забудьте logrotate, а не то каким бы емким ни был жесткий диск, Suricata его забьет очень быстро:
`nano /etc/logrotate.d/suricata`
> /var/log/suricata/\*.log /var/log/suricata/\*.json
>
> {
>
> weekly
>
> rotate 3
>
> missingok
>
> nocompress
>
> create
>
> sharedscripts
>
> postrotate
>
> /bin/kill -HUP `cat /var/run/suricata.pid 2>/dev/null` 2>/dev/null || true
>
> endscript
>
> }
>
>
Кроме того, ходили слухи, что у кого-то регулярно сниффер в Mikrotik'е при статусе *running* перестает отдавать трафик. Тогда пишем скрипт для перезапуска сниффера и запускаем его по расписанию:
`/tool sniffer stop
:delay 30s
/tool sniffer start`
### Заключение
Признаться, я не вполне доволен стабильностью приведенной выше связки. А именно: стоит перезагрузиться, и начинаются чудеса. Один раз у меня перестали обрабатываться правила все, кроме пары. Пришлось все переустанавливать. Во второй раз Elasticsearch вообще перестал получать данные от Filebeat, и пришлось откатываться к снапшоту состояния до перезагрузки.
Эти проблемы пока не решил.
Кроме того, в планах реализовать IPS на базе переданных в Mikrotik IP-адресов злодеев, выявленных Suricata.
**UPD**: Обвинения в нестабильности снимаются. Мой вывод о прекращении обработки правил был ошибочен. На самом деле, причина пустоты в Dashboard'е после перезагрузки связана с тем, что Filebeat'у и Elasticsearch'у требуется весьма заметное время, чтобы пропарсить многогигабайтный json-файл от сурикаты. Если открыть Dashboard с событиями за период, включающий в себя дату создания файла *eve.json*, то можно увидеть, как растут столбцы диаграммы по мере обработки файла. Вместе с обработанными событиями появляются и алерты в соответствующем Dashboard'е. Кроме того, сниффер в RouterOS на x86 не повис ни разу.
**UPD от 22 мая 2019г**: Начиная с версии Elasticsearch 6.7 плагины ingest-geoip и ingest-user-agent преобразованы в модули. Соответственно, пункт с их установкой пропускаем.
Так же, при обновлении получите ошибку запуска Elasticsearch. В логах будете видеть ошибку:
> expected database [GeoLite2-ASN.mmdb] to not exist in [/etc/elasticsearch/ingest-geoip]
Для восстановления работоспособности выполняем:
`/usr/share/elasticsearch/bin/elasticsearch-plugin remove --purge ingest-geoip` | https://habr.com/ru/post/431600/ | null | ru | null |
# Чтение данных с весов Mettler Toledo PS60
Не так давно выиграл проект на Elance — сделать простое WinForms приложение на Visual Basic, которое будет отображать данные с весов Mettler Toledo PS60.
К счастью, данные весы являются HID-устройством, подключаемом по USB.
В этом посте я опишу как работать с подобными HID устройствами в Visual Basic (да и вообще в .Net)
Поискал немного гуглом, нашел несколько интересных ссылок.
В основном, рекомендуют использовать библиотеку [«Mike O’Brien’s USB HID library»](https://github.com/mikeobrien/HidLibrary).
Вот статья, в которой с использованием этой библиотеки читают данные с похожих весов:
[nicholas.piasecki.name/blog/2008/11/reading-a-stamps-com-usb-scale-from-c-sharp](http://nicholas.piasecki.name/blog/2008/11/reading-a-stamps-com-usb-scale-from-c-sharp/)
Что мне не понравилось — это угадывание формата данных. К тому же, поделившись ссылкой с заказчиком, получил ответ, что вся библиотека ему не нужна и вообще он бы предпочел чтобы я решил проблему самостоятельно.
Хорошо, вооружаемся MSDN а также спецификацией на весы:
«64067860 PS scales Operation and Technical Manual.pdf» — легко ищется гуглом.
Чтение данных с HID устройства, если не требуются какие-то особенные сложности (попробую позже написать про чтение ACS NFC SmartCard Reader), довольно просто:
1) нужно получить DevicePath нужного нам устройства, вот такого вида:
(\?\usb#vid\_04a9&pid\_1097#207946#{28d78fad-5a12-11d1-ae5b-0000f803a8c2})
2) открываем этот DevicePath с помощью самой обычной функции CreateFile с доступом GENERIC\_READ
```
NativeMethods.CreateFile(DeviceInterfaceDetailData.DevicePath, NativeMethods.GENERIC_READ, NativeMethods.FILE_SHARE_READ + NativeMethods.FILE_SHARE_WRITE, security, NativeMethods.OPEN_EXISTING, 0, 0)
```
3) Читаем с помощью ReadFile
```
res = NativeMethods.ReadFile(ioHandle, bufPtr, 10, bytesRead, IntPtr.Zero)
```
Как получить DevicePath. Задача несложная. Нужно получить список всех устройств, найти весы, и считать структуру HIDD\_ATTRIBUTES при помощи функции HidD\_GetAttributes(hidHandle, deviceAttributes)
По шагам:
1) Получаем Guid класса устройств
```
NativeMethods.HidD_GetHidGuid(hidClass)
```
2) Создаем Enumerator для класса устройств
```
DeviceInfoSet = NativeMethods.SetupDiGetClassDevs(hidClass, IntPtr.Zero, 0, NativeMethods.DIGCF_PRESENT + NativeMethods.DIGCF_DEVICEINTERFACE)
```
3) Идем по списку устройств
```
Do While NativeMethods.SetupDiEnumDeviceInfo(DeviceInfoSet, deviceIndex, DeviceInfoData)
```
4) Вложенным циклом идем по списку интерфейсов устройства
```
Do While NativeMethods.SetupDiEnumDeviceInterfaces(DeviceInfoSet, DeviceInfoData, hidClass, deviceIfaceIndex, DeviceInterfaceData)
```
5) Получаем DevicePath
```
success = NativeMethods.SetupDiGetDeviceInterfaceDetailBuffer(DeviceInfoSet, DeviceInterfaceData, IntPtr.Zero, 0, RequiredSize, IntPtr.Zero) ' Obtain buffer size
success = NativeMethods.SetupDiGetDeviceInterfaceDetail(DeviceInfoSet, DeviceInterfaceData, DeviceInterfaceDetailData, RequiredSize, RequiredSize, DeviceInfoData) ' Get device information using previously recieved buffer size
```
Здесь небольшое ухищрение с передачей null для того, чтобы получить правильный размер буфера для данных. Половина задачи сделана — у нас есть DevicePath.
6) Теперь нужно понять, то ли это устройство.
```
NativeMethods.CreateFile(DeviceInterfaceDetailData.DevicePath, NativeMethods.ACCESS_NONE, NativeMethods.FILE_SHARE_READ + NativeMethods.FILE_SHARE_WRITE, security, NativeMethods.OPEN_EXISTING, 0, 0)
```
Открываем устройство с ACCESS\_NONE (нам нужно только pid&vid, для этого нет нужды открывать устройство на чтение, большинство устройств нам этого не позволят и здесь будет исключение)
7) И читаем атрибуты
```
Dim deviceAttributes As NativeMethods.HIDD_ATTRIBUTES
deviceAttributes.cbSize = Marshal.SizeOf(deviceAttributes)
NativeMethods.HidD_GetAttributes(hidHandle, deviceAttributes)
```
8) Теперь только сравним deviceAttributes.VendorID и deviceAttributes.ProductID с константами и если это то что нужно — можно выходить из циклов
Теперь собственно к весам. При чтении данных они выдают нам 6 байт, с которыми нужно разобраться.
Согласно спецификации, первый байт посылки — это report id.
Второй — статус измерения. Бывает: ошибка, стабильный вес, меньше нуля, колебания, и т.п. Полный список — в коде и в спецификации.
Третий — единицы измерения. Это понятно — милиграммы, граммы, килограммы, и т.д. Хоть тройская унция.
Три следующих байта — это собственно вес.
Первый байт веса — степень десятки, следующие два — собственно значение.
Таким образом, чтобы получить значение веса, нужно сделать нехитрую операцию:
(b[5]\*256+b[4])\*10^b[3]
Вот так — все довольно просто.
Исходный код:
**NativeMethods.vb**
```
Public Class NativeMethods
Public Const DIGCF_PRESENT = &H2
Public Const DIGCF_DEVICEINTERFACE = &H10
Public Const FILE_FLAG_OVERLAPPED = &H40000000
Public Const FILE_SHARE_READ = 1
Public Const FILE_SHARE_WRITE = 2
Public Const GENERIC_READ = &H80000000
Public Const GENERIC_WRITE = &H40000000
Public Const ACCESS_NONE = 0
Public Const INVALID_HANDLE_VALUE = -1
Public Const OPEN_EXISTING = 3
\_
Public Structure SP\_DEVICE\_INTERFACE\_DETAIL\_DATA
Public cbSize As UInt32
\_
Public DevicePath As String
End Structure
Public Structure SP\_DEVICE\_INTERFACE\_DATA
Public cbSize As Integer
Public InterfaceClassGuid As System.Guid
Public Flags As Integer
Public Reserved As UIntPtr
End Structure
Public Structure SP\_DEVINFO\_DATA
Public cbSize As Integer
Public ClassGuid As System.Guid
Public DevInst As Integer
Public Reserved As UIntPtr
End Structure
Public Const HIDP\_INPUT = 0
Public Const HIDP\_OUTPUT = 1
Public Const HIDP\_FEATURE = 2
Public Structure HIDD\_ATTRIBUTES
Public cbSize As Integer
Public VendorID As UShort
Public ProductID As UShort
Public VersionNumber As Short
End Structure
Public Structure SECURITY\_ATTRIBUTES
Public nLength As Integer
Public lpSecurityDescriptor As IntPtr
Public bInheritHandle As Boolean
End Structure
Public Declare Auto Function CreateFile Lib "kernel32.dll" (lpFileName As String, dwDesiredAccess As Integer, dwShareMode As Integer, ByRef lpSecurityAttributes As SECURITY\_ATTRIBUTES, dwCreationDisposition As Integer, dwFlagsAndAttributes As Integer, hTemplateFile As Integer) As IntPtr
Public Declare Auto Function ReadFile Lib "kernel32.dll" (ByVal hFile As IntPtr, ByVal Buffer As IntPtr, ByVal nNumberOfBytesToRead As Integer, ByRef lpNumberOfBytesRead As Integer, ByVal Overlapped As IntPtr) As Integer
Public Declare Auto Function CloseHandle Lib "kernel32.dll" (hObject As IntPtr) As Boolean
Public Declare Auto Function SetupDiGetClassDevs Lib "setupapi.dll" (ByRef ClassGuid As System.Guid, ByVal Enumerator As Integer, ByVal hwndParent As IntPtr, ByVal Flags As Integer) As IntPtr
Public Declare Auto Function SetupDiDestroyDeviceInfoList Lib "setupapi.dll" (deviceInfoSet As IntPtr) As Boolean
Public Declare Auto Function SetupDiEnumDeviceInfo Lib "setupapi.dll" (ByVal DeviceInfoSet As Integer, ByVal MemberIndex As Integer, ByRef DeviceInfoData As SP\_DEVINFO\_DATA) As Boolean
Public Declare Auto Function SetupDiEnumDeviceInterfaces Lib "setupapi.dll" (ByVal DeviceInfoSet As IntPtr, ByRef DeviceInfoData As SP\_DEVINFO\_DATA, ByRef InterfaceClassGuid As System.Guid, ByVal MemberIndex As UInteger, ByRef DeviceInterfaceData As SP\_DEVICE\_INTERFACE\_DATA) As Boolean
Public Declare Auto Function SetupDiGetDeviceInterfaceDetailBuffer Lib "setupapi.dll" Alias "SetupDiGetDeviceInterfaceDetail" (ByVal DeviceInfoSet As IntPtr, ByRef DeviceInterfaceData As SP\_DEVICE\_INTERFACE\_DATA, ByVal DeviceInterfaceDetailData As IntPtr, ByVal DeviceInterfaceDetailDataSize As Integer, ByRef RequiredSize As Integer, ByRef DeviceInfoData As IntPtr) As Boolean
Public Declare Auto Function SetupDiGetDeviceInterfaceDetail Lib "setupapi.dll" (ByVal DeviceInfoSet As IntPtr, ByRef DeviceInterfaceData As SP\_DEVICE\_INTERFACE\_DATA, ByRef DeviceInterfaceDetailData As SP\_DEVICE\_INTERFACE\_DETAIL\_DATA, ByVal DeviceInterfaceDetailDataSize As Integer, ByRef RequiredSize As Integer, ByRef DeviceInfoData As SP\_DEVINFO\_DATA) As Boolean
Public Declare Auto Sub HidD\_GetHidGuid Lib "hid.dll" Alias "HidD\_GetHidGuid" (ByRef hidGuid As Guid)
Public Declare Auto Function HidD\_GetAttributes Lib "hid.dll" (hidDeviceObject As IntPtr, ByRef attributes As HIDD\_ATTRIBUTES) As Boolean
End Class
```
**ScaleReader.vb**
```
Public Class ScaleReader
Private Const VendorId = &HEB8 ' 0EB8 = Toledo, see http://usb-ids.gowdy.us/read/UD/
Private Const ProductId = &HF000 ' F000 = PS60
' Scale status enumeration
Public Enum ScaleStatus
Fault
StableAtZero
InMotion
WeightStable
UnderZero
OverWeight
RequiresCalibration
RequiresRezeroing
RequiresGEO
Unknown
End Enum
' Scale weighing unit
Public Enum WeightUnit
UnitMilligram
UnitGram
UnitKilogram
UnitCarats
UnitTaels
UnitGrains
UnitPennyweights
UnitMetricTon
UnitAvoirTon
UnitTroyOunce
UnitOunce
UnitPound
UnitUnknown
End Enum
' Scale measure report
Public Structure ScaleReport
Public ReportId As UShort ' Scale report id
Public Status As ScaleStatus ' Scale status
Public Unit As WeightUnit ' Weighing unit
Public Scaling As SByte ' Scaling, power of 10
Public WeightLsb As UShort ' Least-significant byte of weight value
Public WeightMsb As UShort ' Most-significant byte of weight value
Public ErrorCode As Integer ' Error code
' Calculates weight from LSB, MSB and scaling
Public Function GetWeight() As Double
GetWeight = (WeightMsb * 256 + WeightLsb) * (10 ^ Scaling)
End Function
End Structure
Private ioHandle As IntPtr ' handle to read from device
' Opens device with desired access rights
Private Function OpenDeviceIO(devicePath As String, deviceAccess As Integer) As IntPtr
Dim security As NativeMethods.SECURITY_ATTRIBUTES
security.lpSecurityDescriptor = IntPtr.Zero
security.bInheritHandle = True
security.nLength = Marshal.SizeOf(security)
OpenDeviceIO = NativeMethods.CreateFile(devicePath, deviceAccess, NativeMethods.FILE_SHARE_READ + NativeMethods.FILE_SHARE_WRITE, security, NativeMethods.OPEN_EXISTING, 0, 0)
End Function
' Close previously opened device
Private Sub CloseDeviceIO(handle As IntPtr)
NativeMethods.CloseHandle(handle)
End Sub
' Disconnect from scale
Public Sub Disconnect()
CloseDeviceIO(ioHandle)
End Sub
' Find Toledo PS60 scale and open to read weight values
Public Function Connect() As Boolean
Dim hidClass As Guid
NativeMethods.HidD_GetHidGuid(hidClass) ' Obtain hid device class Guid to enumerate all hid devices
Dim DeviceInfoSet As IntPtr
Dim DeviceInfoData As NativeMethods.SP_DEVINFO_DATA
Dim DeviceInterfaceData As NativeMethods.SP_DEVICE_INTERFACE_DATA
Dim DeviceInterfaceDetailData As NativeMethods.SP_DEVICE_INTERFACE_DETAIL_DATA = Nothing
Dim RequiredSize As Integer
Dim success As Boolean
DeviceInfoSet = NativeMethods.SetupDiGetClassDevs(hidClass, IntPtr.Zero, 0, NativeMethods.DIGCF_PRESENT + NativeMethods.DIGCF_DEVICEINTERFACE) ' Open hid device enumeration
DeviceInterfaceData.cbSize = Marshal.SizeOf(DeviceInterfaceData)
DeviceInterfaceDetailData.cbSize = 6
DeviceInfoData.cbSize = Marshal.SizeOf(DeviceInfoData)
Dim deviceIndex As Integer ' Current deviec index
deviceIndex = 0
Do While NativeMethods.SetupDiEnumDeviceInfo(DeviceInfoSet, deviceIndex, DeviceInfoData) ' Loop through all hid devices
Dim deviceIfaceIndex As Integer ' Device interface index
deviceIfaceIndex = 0
Do While NativeMethods.SetupDiEnumDeviceInterfaces(DeviceInfoSet, DeviceInfoData, hidClass, deviceIfaceIndex, DeviceInterfaceData) ' Loop through all interfaces of current device
success = NativeMethods.SetupDiGetDeviceInterfaceDetailBuffer(DeviceInfoSet, DeviceInterfaceData, IntPtr.Zero, 0, RequiredSize, IntPtr.Zero) ' Obtain buffer size
success = NativeMethods.SetupDiGetDeviceInterfaceDetail(DeviceInfoSet, DeviceInterfaceData, DeviceInterfaceDetailData, RequiredSize, RequiredSize, DeviceInfoData) ' Get device information using previously recieved buffer size
Dim hidHandle As IntPtr
hidHandle = OpenDeviceIO(DeviceInterfaceDetailData.DevicePath, NativeMethods.ACCESS_NONE) ' Open device with no access rights to get pid&vid
If hidHandle <> NativeMethods.INVALID_HANDLE_VALUE Then
Dim deviceAttributes As NativeMethods.HIDD_ATTRIBUTES
deviceAttributes.cbSize = Marshal.SizeOf(deviceAttributes)
success = NativeMethods.HidD_GetAttributes(hidHandle, deviceAttributes) ' Read device attributes, including PID, VID and Version
If success And deviceAttributes.VendorID = VendorId And deviceAttributes.ProductID = ProductId Then ' If it matches Toledo PS60
CloseDeviceIO(hidHandle) ' Close device
ioHandle = OpenDeviceIO(DeviceInterfaceDetailData.DevicePath, NativeMethods.GENERIC_READ) ' And reopen with access rights to read reports
NativeMethods.SetupDiDestroyDeviceInfoList(DeviceInfoSet) ' Close enumeration
Connect = True
Exit Function
End If
CloseDeviceIO(hidHandle)
End If
deviceIfaceIndex = deviceIfaceIndex + 1
Loop
deviceIndex = deviceIndex + 1
Loop
NativeMethods.SetupDiDestroyDeviceInfoList(DeviceInfoSet) ' Close enumeration
Connect = False
End Function
' Reads current weight from scale
Public Function ReadValue() As ScaleReport
Dim bytesRead As Integer
Dim buffer(10) As Byte
Dim bufPtr As IntPtr
bufPtr = Marshal.AllocHGlobal(10) ' Allocate 10 bytes for report
ReadValue = Nothing
Dim res As Integer
res = NativeMethods.ReadFile(ioHandle, bufPtr, 10, bytesRead, IntPtr.Zero) ' Read 10 bytes from scale
If res > 0 Then ' 0=Failure, any positive is success
Marshal.Copy(bufPtr, buffer, 0, 10) ' Copy unmamanged buffer to managed byte array
If bytesRead < 6 Then ' Report must be 6 bytes or greater (for compatibility)
ReadValue.Status = ScaleStatus.Fault
Marshal.FreeHGlobal(bufPtr)
Exit Function
End If
Dim rep As ScaleReport
rep.ReportId = buffer(0) ' byte #0 is report id
Select Case buffer(1) ' byte #1 is scale status
Case &H1
rep.Status = ScaleStatus.Fault
Case &H2
rep.Status = ScaleStatus.StableAtZero
Case &H3
rep.Status = ScaleStatus.InMotion
Case &H4
rep.Status = ScaleStatus.WeightStable
Case &H5
rep.Status = ScaleStatus.UnderZero
Case &H6
rep.Status = ScaleStatus.OverWeight
Case &H7
rep.Status = ScaleStatus.RequiresCalibration
Case &H8
rep.Status = ScaleStatus.RequiresRezeroing
Case &H9
rep.Status = ScaleStatus.RequiresGEO
Case Else
rep.Status = ScaleStatus.Unknown
End Select
Select Case buffer(2) ' byte #2 is scale unit
Case &H1
rep.Unit = WeightUnit.UnitMilligram
Case &H2
rep.Unit = WeightUnit.UnitGram
Case &H3
rep.Unit = WeightUnit.UnitKilogram
Case &H4
rep.Unit = WeightUnit.UnitCarats
Case &H5
rep.Unit = WeightUnit.UnitTaels
Case &H6
rep.Unit = WeightUnit.UnitGrains
Case &H7
rep.Unit = WeightUnit.UnitPennyweights
Case &H8
rep.Unit = WeightUnit.UnitMetricTon
Case &H9
rep.Unit = WeightUnit.UnitAvoirTon
Case &HA
rep.Unit = WeightUnit.UnitTroyOunce
Case &HB
rep.Unit = WeightUnit.UnitOunce
Case &HC
rep.Unit = WeightUnit.UnitPound
Case Else
rep.Unit = WeightUnit.UnitUnknown
End Select
rep.Scaling = IIf(buffer(3) < 128, buffer(3), buffer(3) - 256) ' byte #3 is scaling
rep.WeightLsb = buffer(4) ' byte #4 is LSB
rep.WeightMsb = buffer(5) ' byte #5 is MSB
ReadValue = rep
Else
Dim err = Marshal.GetLastWin32Error
ReadValue.Status = ScaleStatus.Fault
ReadValue.ErrorCode = err
End If
Marshal.FreeHGlobal(bufPtr)
End Function
End Class
``` | https://habr.com/ru/post/205462/ | null | ru | null |
# Основы моделирования в openEMS
В [прошлой части](http://habrahabr.ru/post/255317/) было рассказано как установить и настроить open-source электромагнитный симулятор [openEMS](http://openems.de/) . Теперь можно переходить к моделированию. Как производить моделирование ЭМВ при помощи openEMS и Octave будет рассказано в этой статье.
Мы будем моделировать процесс распространения электромагнитной волны (ЭМВ) между двумя параллельными металлическим пластинами.
Конфигурация объекта показана на рисунке. Предполагается прямоугольный источник ЭМВ, от которого ЭМВ распространяется в обе стороны.
Под катом приведён построчный разбор скрипта для моделирования такого объекта.
Как было сказано в предыдущей части, все симуляции в openEMS являются скриптами Octave/Matlab. Запускаем Octave/Matlab и вводим следующие команды. Сначала инициализируем пространство. Мы создаём специальный объект FDTD, который описывает пространство конечной разности во временной области:
```
FDTD = InitFDTD('NrTS',100,'EndCriteria',0,'OverSampling',50);
```
Параметры функции — это 100 точек расчёта по времени от нуля. Шаг расчёта по времени выбирается автоматически на основе частоты Найквиста и частоты источника ЭМВ. Попробуйте задать другое количество точек, например 1000.
Теперь устанавливаем источник ЭМВ частотой 10 МГц. Здесь параметры функции понятны из названия.
```
FDTD = SetSinusExcite(FDTD,10e6);
```
Для любого моделирования ЭМВ нужны граничные условия. Граничные условия описывают свойства материала, которым ограничено пространств в направлении каждой из трёх осей координат X,Y,Z. Порядок следования граничных условий в параметрах функции следующий X+, X-, Y+, Y-, Z+, Z- У нас пространство по оси Y в положительном направлении ограничено идеально проводящей поверхностью (PEC — Perfect Electric Conductor), в отрицательном направлении по Y — также проводящей поверхностью. PMC — это идеальный
магнитопроводник. MUR — это абсолютно поглощающий диэлектрик. Он приблизительно соответствует материалу стенок безэховой камеры.
```
FDTD = SetBoundaryCond(FDTD,{'PMC' 'PMC' 'PEC' 'PEC' 'MUR' 'MUR'});
```
Ещё доступен специальный многослойный материал (PML\_x) для граничных условий. Он может иметь от 6 до 20 слоёв (например PML\_8, PML\_10). Этот материал тоже действует как поглощающий диэлектрик.
После того как заданы граничные условия инициализируем пространство CSX, в котором будет задана геометрия нашей системы.
```
CSX = InitCSX();
```
Теперь нужно создать сетку. Расчёт распространения ЭМВ будет выполняться внутри пространства, ограниченного сеткой. Сначала задаём размерность сетки по координатам (X\*Y\*Z=20х20\*40 метров).
```
mesh.x = -10:10;
mesh.y = -10:10;
mesh.z = -10:30;
```
Теперь создаём собственно сетку в прямоугольных координатах при помощи функции
DefineRectGrid() и применяем её к геометрии (шаг сетки равен 1 метру):
```
CSX = DefineRectGrid(CSX,1,mesh);
```
Далее создаём источник ЭМВ. Задаём амплитуду ЭМВ и направление вектора ЭМВ. Для этого служит функция AddExcitation.
```
CSX = AddExcitation(CSX,'excitation',0,[0 1 0]);
```
Первый и второй параметры функции — это имя CSX-пространства и имя источника ЭМВ соответственно. Третий параметр функции — это тип поля. Доступны следующие типы:
* 0 — электрическое поле (Е), жёсткое возбуждение
* 1 — электрическое поле (Е), жёсткое возбуждение
* 2 — магнитное поле (Н), мягкое возбуждение
* 3 — магнитное поле (Р), жёсткое возбуждение
* 10 — плоская ЭМВ
Отличие жёсткого и мягкого возбуждения состоит в том, что при жёстком возбуждении амплитуда ЭМВ в данной точке пространства устанавливается принудительно заданному значению, а при мягком возбуждении рассчитывается суперпозиция полей, то есть ЭМВ накладывается на имеющиеся в данной точке пространства поля.
Четвёртый параметр — это вектор, компоненты которого задают амплитуду ЭМВ по трём направлениям X,Y,Z.
Таким образом мы задали возбуждение электрическим полем амплитудой 1 В/м в направлении оси Y.
Теперь создаём площадку (AddBox) с которой будем распространяться ЭМВ. Эта площадка и является собственно источником ЭМВ.
```
CSX = AddBox(CSX,'excitation',0,[-10 -10 0],[10 10 0]);
```
На этом описание геометрии завершено. После того как мы описали геометрию, нужно создать сечение, в котором мы будем наблюдать распространение ЭМВ. Это делается при помощи функций AddDump() и AddBox().
```
CSX = AddDump(CSX,'Et');
CSX = AddBox(CSX,'Et',0,[-10 0 -10],[10 0 30]);
```
Теперь подготавливаем временный каталог для хранения результатов расчётов и просматриваем геометрию при помощи CSXCAD.
```
mkdir('tmp');
WriteOpenEMS('/tmp/tmp.xml',FDTD,CSX);
CSXGeomPlot('/tmp/tmp.xml');
invoking AppCSXCAD, exit to continue script...
QCSXCAD - disabling editing
```
Всё, модель нашей структуры готова. Можно запускать симулятор. Если всё нормально, то мы увидим следующий отчёт:
```
RunOpenEMS('tmp','/tmp/tmp.xml','');
----------------------------------------------------------------------
| openEMS 64bit -- version v0.0.32-14-g63adb58
| (C) 2010-2013 Thorsten Liebig GPL license
----------------------------------------------------------------------
Used external libraries:
CSXCAD -- Version: v0.5.2-15-gcb5b3cf
hdf5 -- Version: 1.8.13
compiled against: HDF5 library version: 1.8.13
tinyxml -- compiled against: 2.6.2
fparser
boost -- compiled against: 1\_54
vtk -- Version: 5.10.1
compiled against: 5.10.1
Create FDTD operator (compressed SSE + multi-threading)
FDTD simulation size: 21x21x41 --> 18081 FDTD cells
FDTD timestep is: 1.92583e-09 s; Nyquist rate: 25 timesteps @1.03851e+07 Hz
Excitation signal length is: 100 timesteps (1.92583e-07s)
Max. number of timesteps: 100 ( --> 1 \* Excitation signal length)
Create FDTD engine (compressed SSE + multi-threading)
Running FDTD engine... this may take a while... grab a cup of coffee?!?
Time for 100 iterations with 18081 cells : 0.1624 sec
Speed: 11.1336 MCells/s
```
Симуляция завершена, и можно просмотреть результат. Запускаем Paraview. Затем выбираем File->Open и идём во временный каталог, где хранятся результаты симуляции. Там открываем файл Et\_.vtr. Этот файл содержит информацию о результате расчёта процесса распространения ЭМВ во времени. Вот, что нужно открывать, путь к файлу у вас будет другой:
Теперь видим в окне Paraview плоскость, которая является сечением в котором мы смотрим амплитуду ЭМВ.
Чтобы визуализировать амплитуду ЭМВ, нужно в выпадающем списке Coloring выбрать E-field (по умолчанию там стоит SolidColor) и затем отобразить цветовую легенду (нажать Show). Теперь мы видим амплитуду ЭМВ в момент времени t=0. В начальный момент времени амплитуда ЭМВ тоже равна нулю во всём пространстве, поэтому вся плоскость будет закрашена в один цвет. Чтобы посмотреть распределение ЭМВ нужно установить время отличное от нуля и нажать кнопку Rescale. Теперь на плоскости отобразится распределение амплитуды ЭМВ.
Можно также запустить анимацию и просмотреть процесс распространения ЭМВ во времени. Как и следовало ожидать ЭМВ распространяется в обоих направлениях от плоскости-источника.
В результате мы смоделировали во временной области процесс распространения ЭМВ в некоторой области пространства. В заключении скрипт Octave/Matlab целиком:
```
FDTD = InitFDTD('NrTS',1000,'EndCriteria',0,'OverSampling',1);
FDTD = SetSinusExcite(FDTD,10e6);
FDTD = SetBoundaryCond(FDTD,{'PMC' 'PMC' 'PEC' 'PEC' 'MUR' 'MUR'});
CSX = InitCSX();
mesh.x = -10:10;
mesh.y = -10:10;
mesh.z = -10:30;
CSX = DefineRectGrid(CSX,1,mesh);
CSX = AddExcitation(CSX,'excitation',0,[0 1 0]);
CSX = AddBox(CSX,'excitation',0,[-10 -10 0],[10 10 0]);
CSX = AddDump(CSX,'Et');
CSX = AddBox(CSX,'Et',0,[-10 0 -10],[10 0 30]);
mkdir('tmp');
WriteOpenEMS('/tmp/tmp.xml',FDTD,CSX);
CSXGeomPlot('/tmp/tmp.xml');
RunOpenEMS('tmp','/tmp/tmp.xml','');
```
Ссылка на предыдущую статью по openEMS: [habrahabr.ru/post/255317](http://habrahabr.ru/post/255317/)
Сайт проекта openEMS: [openems.de](http://openems.de/) | https://habr.com/ru/post/258489/ | null | ru | null |
# Крохотные образы Docker, которые верили в себя*
[отсылка к американской детской сказке "Маленький паровозик, который верил в себя " ("The Little Engine That Could") — прим. пер.]\*
**Как автомагически создавать крохотные docker-образы для своих нужд**
### Необычная одержимость
Последние пару месяцев я был одержим навязчивой идеей: насколько можно уменьшить образ Docker, так чтобы при этом приложение работало?
Понимаю, идея странная.
Прежде чем углубиться в детали и технические дебри, я бы хотел пояснить, чем эта проблема так меня зацепила, и как она касается вас.
### Почему размер имеет значение
Сокращая содержимое образа Docker, мы тем самым сокращаем список уязвимостей. Дополнительно мы делаем образы чище, ведь они содержат только то, что нужно для запуска приложений.
Есть еще одно небольшое преимущество — образы скачиваются чуточку быстрее, но, как по мне, это не столь важно.
> Обратите внимание: Если вас заботит размер, образы Alpine сами по себе малы и наверняка подойдут вам.
### Distroless-образы
[Проект Distroless](https://github.com/GoogleContainerTools/distroless) предлагает подборку базовых "distroless"-образов, они не содержат менеджеров пакетов, оболочек и прочих утилит, которые вы привыкли видеть в командной строке. В результате использовать менеджеры пакетов вроде `pip` и `apt` не получится:
```
FROM gcr.io/distroless/python3
RUN pip3 install numpy
```
*Dockerfile, использующий distroless-образ Python 3*
```
Sending build context to Docker daemon 2.048kB
Step 1/2 : FROM gcr.io/distroless/python3
---> 556d570d5c53
Step 2/2 : RUN pip3 install numpy
---> Running in dbfe5623f125
/bin/sh: 1: pip3: not found
```
*Pip в образе нет*
Обычно такая проблема решается путем многоэтапной сборки:
```
FROM python:3 as builder
RUN pip3 install numpy
FROM gcr.io/distroless/python3
COPY --from=builder /usr/local/lib/python3.7/site-packages /usr/local/lib/python3.5/
```
*Многоэтапная сборка*
В результате получается образ размером 130МВ. Не так уж и плохо! Для сравнения: образ Python по умолчанию весит 929МВ, а "похудевший" (`3,7-slim`) — 179МВ, образ alpine (`3,7-alpine`) — 98,6MB, тогда как базовый distroless-образ, использованный в примере, — 50,9МВ.
Можно справедливо указать на то, что в предыдущем примере мы копируем целый каталог `/usr/local/lib/python3.7/site-packages`, в котором могут лежать ненужные нам зависимости. Хотя ясно, что разница в размерах всех существующих базовых образов Python колеблется.
> На момент написания этих строк Google distroless поддерживает не так много образов: Java и Python — еще на стадии эксперимента, а Python существует только для 2,7 и 3,5.
### Крохотные образы
Вернемся к моему помешательству на создании небольших образов.
Вообще я хотел посмотреть, как устроены distroless-образы. Проект distroless использует Google'овский инструмент сборки `bazel`. Однако, чтобы установить Bazel и написать собственные образы, пришлось попотеть (а если быть до конца честным, то заново изобретать колесо — это весело и познавательно). Хотелось упростить создание уменьшенных образов: акт создания образа должен быть предельно простым, *банальным*. Чтобы никаких тебе файлов конфигурации, только одна строка в консоли: `просто собрать образ для <приложение>`.
Итак, если хотите создавать собственные образы, то знайте: есть такой уникальный образ docker, `scratch`. Scratch — это "пустой" образ, в нем нет файлов, хотя он и весит по умолчанию — ого! — 77 байт.
```
FROM scratch
```
*Образ scratch*
Идея образа scratch в том, что можно скопировать в него любые зависимости с машины-хоста и либо использовать их внутри Dockerfile (это как скопировать их в `apt` и установить с нуля), либо позднее, когда образ Docker материализован. Это позволяет полностью контролировать содержимое контейнера Docker, и, таким образом, полностью же контролировать размер образа.
А теперь нам нужно как-то собрать эти зависимости. Существующие инструменты вроде `apt` позволяют скачивать пакеты, но они привязаны к текущей машине и, в конце концов, не поддерживают Windows или MacOS.
И вот я взялся собрать собственный инструмент, который автоматически собирал бы базовый образ наименьшего возможного размера и чтобы тот еще запускал любое приложение. Использовал я пакеты Ubuntu/Debian, делал выборку (получая пакеты прямиком из репозиториев) и рекурсивно находил их зависимости. Программа должна была автоматически скачивать новейшую устойчивую версию пакета, максимально снижая риски для безопасности.
Интрумент я назвал `fetchy`, потому что он… находит и приносит… что нужно [*от англ. "fetch", "приносить" — прим. пер.*]. Инструмент работает через интерфейс командной строки, но в то же время предлагает и API.
Для того, чтобы собрать образ при помощи `fetchy` (возьмем на этот раз образ Python), вам надо лишь использовать CLI вот так: `fetchy dockerize python`. У вас могут запросить целевую операционную систему и кодовое имя, поскольку `fetchy` пока использует только пакеты на базе Debian и Ubuntu.
Теперь можно выбирать, какие зависимости совсем не нужны (в нашем контексте) и исключить их. Например, Python зависит от perl, хотя прекрасно работает без установленного Perl.
### Результаты
Образ Python, созданный с помощью команды `fetchy dockerize python3.5` весит всего 35МВ (я более чем уверен, что в будущем его можно будет облегчить еще больше). Выходит, с distroless-образа удалось "сбрить" еще 15МВ.
Все собранные на данный момент образы посмотреть можно [здесь](https://hub.docker.com/r/fetchy/).
Проект — [тут](https://github.com/ThomasKluiters/fetchy).
Если вам не хватает функций, просто создайте заявку — буду рад помочь :) Даже больше, я в данный момент работаю над интеграцией в fetchy других пакетных менеджеров, так чтобы надобность в многоэтапных сборках отпала. | https://habr.com/ru/post/469947/ | null | ru | null |
# Немного о внутренностях WebKit
Задался я с задачей, ознакомится с тем как работает в том или ином виде основа всех современных браузеров — WebKit, как происходит процесс загрузки ресурсов, и что с этим всем, собственно, можно сделать. Документации по вопросу, в принципе, достаточно:
\* структурированная, но не покрывающая и 10 й части от [Apple](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/DisplayWebContent/DisplayWebContent.html);
\* [разбросаные статьи в вики](http://trac.webkit.org/wiki), разные по степени детализации и степени покрытия.
Целью данной статьи является не общий взгляд на систему сверху, а как раз точечный и детальный разбор одного из процессов, происходящих в системе. Который, по моему мнению, иногда дает лучшее представление о системе в целом, нежели абстрактный взгляд. А может быть просто будет маленьким кирпичиком, который понадобится разработчику для составления из разрозненной мозайки информации своего представления о системе.
##### Структура
* WebKit1 — внешнее апи, дефакто для каждого порта свое;
* WebKit2 — новая его версия, с ним я не работал;
* JavascriptCore — JavaScript движок;
* WTF — Web Template Framework;
* ThirdParty — набор сторонних библиотек, вчасности leveldb;
* WebCore — базисный функционал WebKit. Как раз про него и большая часть текста. Весь функционал загружен в namespace WebCore. Состоит из подпроектов:
+ loader — WebCore::FrameLoader, WebCore::DocumentLoader,WebCore::DocumentWriter — это оттуда, в общем, все что связано с коммуникацией Document <-> внешний мир — это там;
+ dom — Document Object Model. WebCore::Document;
+ html — WebCore::HTMLDocument — наследник WebCore::Document,WebCore::PluginDocument,WebCore::HTMLElement, его наследники — WebCore::HTMLAnchorElement и так далее. Имплементация докмументной модели HTML.
+ page — WebCore::Frame,WebCore::History,WebCore::ContextMenu — все, что связано с UI или просто с высокоуровневой коммуникацией (History браузера, например);
+ platform — Специфические реализации функционала для разных портов;
+ rendering, css, svg, storage, plugins, inspector — названия говорят сами за себя. Детально не рассматриваются.
##### Процесс загрузки документа, *loader*
**programm1.c**
```
mainWidget = new QWebView(parent);
// mainWidget->setHtml("HEIL");
mainWidget->page()->mainFrame()->setHtml( "HEIL",QUrl() );
```
```
QWebFrame::setHtml() → QWebFrameAdapter::setHtml // qt/qtwebkit/Source/WebKit/qt/WebCoreSupport/QWebFrameAdapter.cpp:284
...
→ WebCore::FrameLoader::load // frame->loader()->load(WebCore::FrameLoadRequest(frame, request, substituteData));
// "request" description
WebCore::FrameLoadRequest(
WebCore::Frame
WebCore::ResourceRequest // Request Description - пустой урл
WebCore::SubstituteData // Data description - qt/qtwebkit/Source/WebCore/loader/SubstituteData.h
// data - WTF::RefPtr
// mime-type - "text/html"
// encoding - "utf-8"
// failingURL
)
) → FrameLoaderClientQt::createDocumentLoader() // RefPtr loader = m\_client->createDocumentLoader(request,substitute\_data) // WebCore::FrameLoaderClient()
→ FrameLoader::load(DocumentLoader\* newDocumentLoader) // FrameLoader::load(loader.get())
newDocumentLoader.m\_frame = 0 ;
→ FrameLoader::loadWithDocumentLoader(newDocumentLoader, type, 0) → FrameLoader::loadWithDocumentLoader(DocumentLoader\* loader, FrameLoadType type, PassRefPtr prpFormState)
...
setPolicyDocumentLoader(loader); // Не только проверка полиси но устанавливает m\_frame в loader.
→ loader→setFrame(m\_frame);
→ m\_writer.setFrame(frame);
...
// Check policies and with callback jump to callContinueLoadAfterNavigationPolicy via static jumper
FrameLoader::callContinueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr formState, bool shouldContinue )
→
// Контент загружаемой страницы: m\_policyDocumentLoader.get()->substituteData().content()->data();
setProvisionalDocumentLoader(m\_policyDocumentLoader.get()); // m\_provisionalDocumentLoader = m\_policyDocumentLoader.get();
FrameLoader::continueLoadAfterWillSubmitForm
// RefPtr m\_provisionalDocumentLoader;
m\_provisionalDocumentLoader→startLoadingMainResource
// DocumentLoader::m\_mainResource - CachedResourceHandle
// DocumentLoader::ResourceRequest m\_request;
// Контент загружаемой страницы m\_substituteData.content()->data()
→ handleSubstituteDataLoadSoon
→ handleSubstituteDataLoadNow
WebCore::ResourceResponse response(url, m\_substituteData.mimeType(), m\_substituteData.content()→size(), m\_substituteData.textEncoding(), "");
→ DocumentLoader::responseReceived(0, response) // responseReceived(CachedResource\* resource, const ResourceResponse& response)
m\_response = response;
// m\_m\_identifierForLoadWithoutResourceLoader=1
// notifier() через него осуществлается посылка евентов в View классы.
→ frameLoader()→notifier()→dispatchDidReceiveResponse(this, m\_identifierForLoadWithoutResourceLoader, m\_response, 0);
→ DocumentLoader::continueAfterContentPolicy(PolicyUse); // PolicyUse is enum val enum PolicyAction {PolicyUse,PolicyDownload,PolicyIgnore};
// m\_response.isHTTP()=0 isLoadingMainResource()=1 isStopping()=0
...
→ DocumentLoader::dataReceived(0, m\_substituteData.content()→data(), m\_substituteData.content()→size());
→ frameLoader()→notifier()→dispatchDidReceiveData(this, m\_identifierForLoadWithoutResourceLoader, data, length, -1);
→ DocumentLoader::commitLoad(const char\* data, int length) // data – our html data
→ frameLoader→client()→committedLoad(this, data, length); // FrameLoaderClient::committedLoad
→ FrameLoaderClientQt::committedLoad
→ void DocumentLoader::commitData(const char\* bytes, size\_t length) // loader->commitData(data, length) – Святой грааль работы с DocumentWriter, в documentLoader уже сконструирован m\_frame.
m\_writer.begin(documentURL(), false);
m\_writer.setDocumentWasLoadedAsPartOfNavigation();
→ void m\_writer.addData(bytes, length); // DocumentWriter::addData
...
→ finishLoading(0)
```
«Коллстек» выше — это цепочка вызовов от setHtml до коммуникации с Document. Если интересует процесс расстановки полиси и разнообразные виды загрузки данных, то копать надо там. Я выкинул часть переходов, оставив на мой взгляд только те, которые отражают какую-либо смысловую операцию.
Процесс, который нас интересует в «коллстеке» выше — начало записи в документ и что для этого нужно. Посмотрев, как именно готовится DocumentWriter в DocumentLoader::commitData, можно programm1.cpp «упростить» (не в смысле кода, а в смысле приближения ее «к земле»).
**programm2.c**
```
QWebPage *page = mainWidget->page();
QWebFrame *qtWebFrame = mainWidget->page()->mainFrame();
QWebFramePrivate *qtWebFramePrivate = qtWebFrame->d;
WebCore::Frame *frame = qtWebFramePrivate->frame;
WebCore::DocumentWriter m_writer(frame);
m_writer.setFrame(frame);
m_writer.begin(url, false);
m_writer.setDocumentWasLoadedAsPartOfNavigation();
m_writer.setEncoding("utf-8", true);
m_writer.addData(html ,strlen(html) );
m_writer.end();
```
Таким же образом надо опуститься ниже — до парсинга (семейство классов WebCore::DocumentParser). Полностью от прослойки Writer избавится не получится: вызов appendBytes содержит в себе writer, плюс Writer отвечает за создание интерфейса декодирования и коммуникацию с `View: DocumentWriter::reportDataReceived` — вызвает `m_frame->document()->recalcStyle(Node::Force).`
```
void DecodedDataDocumentParser::appendBytes(DocumentWriter* writer, const char* data, size_t length) {
...
String decoded = writer->createDecoderIfNeeded()->decode(data, length);
...
writer->reportDataReceived();
...
}
```
Вчленив шаги инициализации из DocumentWriter::begin получим programm3.cpp:
**programm3.cpp**
```
const char *html = "HEIL**IGO**document.write(1234);";
size_t htmlen = strlen(html);
RefPtr document = WebCore::DOMImplementation::createDocument("text/html", frame, url, false);
document->createDOMWindow();
frame->setDocument(document);
document->implicitOpen();
frame->script()->updatePlatformScriptObjects();
RefPtr parser = document->parser();
WebCore::DocumentWriter writer(frame);
m\_parser->appendBytes(&writer,html ,htmlen);
m\_parser->finish();
```
##### PS
На этом мое путешествие в WebKit приостанавливается. Надеюсь, что для кого-либо этот текст понизит точку вхождения в проект.
В последнем разделе собраны рецепты быстрого развертывания окружения для экспериментов.
###### Компиляция
За основу был взят пакет *qt-everywhere-opensource-src-5.3.1*. Оттуда брать все не обязательно — достаточно qtbase i qtwebkit. При сборке я столкнулся со следующей проблемой: статическая сборка с включенным -debug (*./configure -static -debug*) флагом создает неподемные библиотеки, которые слинковать мне в рабочий пример так и не удалось на 8ГБ машине. Ну и даже если дождаться, линковки — вариант, ждать по несколько минут перекомпиляции простейших примеров не очень подходит. Без symbol info линковка занимает пару секунд, сам *libWebkit.a* ~ 54Mb.
С shared бибилиотекой есть другая проблема: qt — не экспортирует API webkita, а прячет его за своим. Лечится это "*-fvisibility=default*" вместо *hidden*. Для хака этого достаточно — в библиотеке нет перекрывающихся имен, для нормального же проекта надо долго и нудно перелопачивать определения экспортированных функций, используя директивы *WTF\_EXPORT*. Про [экспортинг есть информация тут](https://trac.webkit.org/wiki/ExportingSymbols), но мне не помогло.
Необходимо также раскрыть доступ к *WebCore* миру у *QWebFrame* (*qtwebkit/Source/WebKit/qt/WidgetApi/qwebframe.h*) — имплементация спрятана за приватной переменной `QWebFramePrivate* QWebFrame::d` — ее надо сделать паблик. Тогда к WebCore::Frame достучатся можно будет через
`WebCore::Frame *frame = [ QWebView ]->page()->mainFrame()->d->frame;`
Для тестов, я, все-таки, рекомендую динамическую сборку, иначе ни gdb ни просто линковка удовольствия вам не доставят. Вот мои приблизительные настройки:
*cd ./qtbase
./configure -opensource -confirm-license -release -nomake tools -nomake examples -no-compile-examples -no-opengl -no-openvg -no-egl -no-eglfs -no-sql-sqlite2 -D QT\_NO\_GRAPHICSVIEW -D QT\_NO\_GRAPHICSEFFECT -D QT\_NO\_STYLESHEET -D QT\_NO\_STYLE\_CDE -D QT\_NO\_STYLE\_CLEANLOOKS -D QT\_NO\_STYLE\_MOTIF -D QT\_NO\_STYLE\_PLASTIQUE -no-qml-debug -no-alsa -no-cups -no-dbus -no-directfb -no-evdev -no-glib -no-gtkstyle -no-kms -no-libudev -no-linuxfb -no-mtdev -no-nis -no-pulseaudio -no-sm -no-xinerama -no-xinput2 -no-xkb -no-xrender -openssl -openssl-linked -icu -fontconfig -system-freetype -system-libpng -system-libjpeg -system-zlib -qt-pcre -qt-harfbuzz -qt-sql-sqlite -qt-xcb -debug
make -j 8
cd ../qtwebkit
../qtbase/bin/qmake WEBKIT\_CONFIG-=use\_glib\ use\_gstreamer\ use\_gstreamer010\ use\_native\_fullscreen\_video\ legacy\_web\_audio\ web\_audio\ video\ gamepad -o Makefile.WebCore.Target WebKit.pro
# удаляем -fvisibility=default из полученных make, может ето можно сделать и опцией.
make -f Makefile.WebCore.Target -j 8*
Осталось забрать все библиотеки из `../lib/` и можно линковать проект. Минимально необходимо было:
```
libQt5Core.so libQt5Gui.so libQt5PrintSupport.so libQt5WebKit.so libQt5WebKitWidgets.so libQt5Widgets.so libQt5Newtork.so
libQt5Core.so.5 libQt5Gui.so.5 libQt5PrintSupport.so.5 libQt5WebKit.so.5 libQt5WebKitWidgets.so.5 libQt5Widgets.so.5 libQt5Network.so.5
```
###### Проблемы сборки
Eсли вы увидели:
`This application failed to start because it could not find or load the Qt platform plugin "xcb".`
Значит, для статической сборки вы забыли:
`Q_IMPORT_PLUGIN(QXcbIntegrationPlugin)`
А для динамической потерялся либо *libxcb.so*, либо если вы собрали *qtbase* с ключем *-qt-xcb* надо создать в проекте папку ./platforms с содежимым *qt/qtbase/plugins/platforms* (достаточно одного файла *libqxcb.so*).
При компиляции тестового модуля нужно ~~отключить инлайн функции (*-fno-inline-small-functions*) либо~~ взять весь список дефайнов, с которыми компилировалась библиотека, иначе, поскольку вы используете те же includes, что и скомпилированный WebKit, придется следить за всеми definами, которые попадают в заголовок. В WebCore::Document мой клиентский код из-за данной ошибки для переменной m\_parser потерял 8 байт в смещении, и появлялись они — ошибки — в самых разнообразных местах. | https://habr.com/ru/post/237771/ | null | ru | null |
# Мега-Учебник Flask, Часть 11: Поддержка e-mail
Это одиннадцатая статья в серии, где я описываю свой опыт написания веб-приложения на Python с использованием микрофреймворка Flask.
Цель данного руководства — разработать довольно функциональное приложение-микроблог, которое я за полным отсутствием оригинальности решил назвать `microblog`.
**Оглавление** [Часть 1: Привет, Мир!](http://habrahabr.ru/post/193242/)
[Часть 2: Шаблоны](http://habrahabr.ru/post/193260/)
[Часть 3: Формы](http://habrahabr.ru/post/194062/)
[Часть 4: База данных](http://habrahabr.ru/post/196810/)
[Часть 5: Вход пользователей](http://habrahabr.ru/post/222983/)
[Часть 6: Страница профиля и аватары](http://habrahabr.ru/post/223375/)
[Часть 7: Unit-тестирование](http://habrahabr.ru/post/223783/)
[Часть 8: Подписчики, контакты и друзья](http://habrahabr.ru/post/230643/)
[Часть 9: Пагинация](http://habrahabr.ru/post/230897/)
[Часть 10: Полнотекстовый поиск](http://habrahabr.ru/post/234613/)
[Часть 11: Поддержка e-mail(данная статья)](http://habrahabr.ru/post/234737/)
[Часть 12: Реконструкция](http://habrahabr.ru/post/234785/)
[Часть 13: Дата и время](http://habrahabr.ru/post/236753/)
[Часть 14: I18n and L10n](http://habrahabr.ru/post/236861/)
[Часть 15: Ajax](http://habrahabr.ru/post/237065/)
[Часть 16: Отладка, тестирование и профилирование](http://habrahabr.ru/post/237317/)
[Часть 17: Развертывание на Linux (и даже на Raspberry Pi!)](http://habrahabr.ru/post/237489/)
[Часть 18: Развертывание на Heroku Cloud](http://habrahabr.ru/post/237517/)
### Краткое повторение
В последних уроках мы занимались, в основном, улучшениями связанными с нашей базой данных.
Сегодня мы позволим нашей базе немного отдохнуть, и вместо этого посмотрим на одну очень важную функцию, которая есть у большинства веб-приложений: возможность отправки email пользователю.
В нашем маленьком приложении мы собираемся реализовать аналогичную функцию, мы будем высылать уведомление пользователю каждый раз, когда кто-то на него подписывается. Есть еще несколько вещей для которых может оказаться полезной функция отправки, поэтому постараемся спроектировать нашу функцию так, чтобы можно было ее повторно использовать.
### Введение в Flask-Mail
К счастью для нас, Flask уже имеет расширение обрабатывающее электронную почту, и хоть оно не выполняет 100% задач, оно очень близко к этому.
Установка Flask-Mail в наше виртуальное окружение довольно простая. Пользователи на отличных от Windows системах должны сделать:
```
flask/bin/pip install flask-mail
```
Для пользователей Windows всё немножко сложней, потому что одна из зависимостей Flask-Mail не работает в этой OS. На Windows вам нужно сделать следующее:
```
flask\Scripts\pip install --no-deps lamson chardet flask-mail
```
### Конфигурация
Ранее, когда мы добавляли Unit-тестирование мы добавили конфигурацию для Flask в которой указали email на который должны отсылаться уведомления об ошибках в production-версии нашего приложения. Та же информация используется для отправки почты приложением.
Нужно запомнить что нам нужно следующая информация:
* сервер через который отправляются email
* электронный адрес администратора
Это то, что мы сделали в предыдущей статье (файл `config.py`):
```
# email server
MAIL_SERVER = 'your.mailserver.com'
MAIL_PORT = 25
MAIL_USE_TLS = False
MAIL_USE_SSL = False
MAIL_USERNAME = 'you'
MAIL_PASSWORD = 'your-password'
# administrator list
ADMINS = ['you@example.com']
```
Разумеется вам придется ввести фактические данные в этот конфиг, для того, чтобы приложение действительно смогло отправлять вам электронные письма. Например, если вы хотите использовать приложение для отправки писем через gmail.com, нужно указать следующее:
```
# email server
MAIL_SERVER = 'smtp.googlemail.com'
MAIL_PORT = 465
MAIL_USE_TLS = False
MAIL_USE_SSL = True
MAIL_USERNAME = 'your-gmail-username'
MAIL_PASSWORD = 'your-gmail-password'
# administrator list
ADMINS = ['your-gmail-username@gmail.com']
```
Мы также должны инициализировать объект Mail, т.к. это будет объект, который будет соединяться с SMTP сервером и отправлять электронные письма для нас(файл `app/__init__.py`):
```
from flask.ext.mail import Mail
mail = Mail(app)
```
Давайте отправим email.
Чтобы понять как работает Flask-Mail работает, нам нужно отправить email из командной строки. Давайте запустим Python из нашего виртуального окружения и наберем следующее:
```
>>> from flask.ext.mail import Message
>>> from app import app, mail
>>> from config import ADMINS
>>> msg = Message('test subject', sender = ADMINS[0], recipients = ADMINS)
>>> msg.body = 'text body'
>>> msg.html = '**HTML** body'
>>> with app.app_context():
... mail.send(msg)
....
```
Фрагмент кода выше отправит письмо списку администраторов, указанных в `config.py`. Отправителем будет указан первый администратор из списка. Писмо будет иметь текстовую и HTML версии, что вы увидите зависит от настроек вашего почтового клиента. Обратите внимание, нам нужно создать `app_context`, чтобы отправить email. Последние релизы Flask-Mail это требуют. Контекст создается автоматически, когда запрос обрабатывается Flask.
Поскольку мы не находимся внутри запроса, мы можем создать контекст руками.
Теперь пришло время интегрировать этот код в наше приложение.
### Простой email фреймворк
Сейчас мы напишем впомогательную функцию, которая отправляет email. Это просто более общая версия вышеуказанного теста. Мы поместим эту функцию в новый файл, который выделим для наших функций связанных с email (файл `app/emails.py`):
```
from flask.ext.mail import Message
from app import mail
def send_email(subject, sender, recipients, text_body, html_body):
msg = Message(subject, sender = sender, recipients = recipients)
msg.body = text_body
msg.html = html_body
mail.send(msg)
```
Обратите внимание что Flask-mail поддерживает больше чем мы используем. Например списки скрытых копий и вложения доступны, но мы не будем использовать их в нашем приложении.
### Уведомления о подписках
Теперь, когда у нас есть базовый фреймворк для отправки электронной почты, мы можем написать функцию уведомляющую о подписчиках (файл `app/emails.py`):
```
from flask import render_template
from config import ADMINS
def follower_notification(followed, follower):
send_email("[microblog] %s is now following you!" % follower.nickname,
ADMINS[0],
[followed.email],
render_template("follower_email.txt",
user = followed, follower = follower),
render_template("follower_email.html",
user = followed, follower = follower))
```
Увидели что-то неожиданное?
Наш старый друг — функция `render_template` создает вид письма. Если вы помните, мы использовали эту функцию чтобы рендерить все HTML шаблоны из нашего представления. Так же как наши HTML, тело письма идеальный кандидат на использование шаблонов. Мы хотим, насколько это возможно, отделить логику от представления, поэтому письма будут идти в папке с шаблонами вместе с другими view.
Итак, сейчас мы напишем шаблоны для текстовой и HTML версий для нашего уведомления. Это текстовая версия (файл `app/templates/follower_email.txt`):
```
Dear {{user.nickname}},
{{follower.nickname}} is now a follower. Click on the following link to visit {{follower.nickname}}'s profile page:
{{url_for('user', nickname = follower.nickname, _external = True)}}
Regards,
The microblog admin
```
Для HTML версии мы можем сделать всё немножко красивей и показывать аватар подписчика и информацию из профиля (файл `app/templates/follower_email.html`):
```
Dear {{user.nickname}},
[{{follower.nickname}}]({{url_for('user', nickname = follower.nickname, _external = True)}}) is now a follower.
| | |
| --- | --- |
| | [{{follower.nickname}}]({{url_for('user', nickname = follower.nickname, _external = True)}})
{{follower.about\_me}}
|
Regards,
The `microblog` admin
```
Обратите внимание на `_external = True` в поле `url_for` нашего шаблона. По умолчанию, функция `url_for` генерирует URL'ы относительно текущей страницы. Для примера, code{url\_for(«index»)} будет `/index`, в то время, когда мы ожидаем `http://localhost:5000/index`. В электронной почте нет доменного контекста, поэтому мы должны указывать полные адреса URL, которые включают домен, в этом нам и поможет `_external`.
Финальным шагом станет подключение отправки электронного письма с функцией представления, которая обрабатывает `"Follow"` (файл `app/views.py`):
```
from emails import follower_notification
@app.route('/follow/')
@login\_required
def follow(nickname):
user = User.query.filter\_by(nickname = nickname).first()
# ...
follower\_notification(user, g.user)
return redirect(url\_for('user', nickname = nickname))
```
Сейчас вы должны создать двух пользователей (если вы еще не сделали этого) и сделать одного подписчиком другого, чтобы увидеть как работает уведомление по электронной почте. Это то что нужно? Мы закончили?
Теперь мы можем погладить себя по голове за прекрасно выполненную работу и вычеркнуть уведомления по электронной почте из списка функций, которые нам предстоит реализовать.
Но если вы поиграли с нашим приложением, вы заметили, что теперь, когда мы реализовали уведомления по электронной почте, после нажатия на «Follow» проходит несколько секунд, прежде чем браузер обновит страницу. А раньше это происходило мгновенно.
Итак, что произошло?
Проблема в том, что Flask-Mail отправляет электронные письма синхронно. Сервер блокируется, пока писмо отправляется и отправляет ответ браузеру, только когда сообщение будет доставлено. Вы можете представить что случится если мы попробуем отправить электронное письмо медленному серверу, или, что еще хуже, выключенному? Это плохо.
Это очень страшное ограничение, отправка электронного письма должна быть фоновой задачей, которая не мешает серверу, поэтому давайте посмотрим как мы можем всё это исправить.
### Асинхронные вызовы в Python
Мы хотим чтобы функция `send_email` завершалась мгновенно, пока работа по отправке письма идет в фоне.
Оказывается Python уже поддерживает запуск асинхронных задач, даже более чем одним способом. Модули threading и multiprocessing могут нам помочь.
Запуск нового потока, каждый раз, когда нам нужно отправить письмо, гораздо менее ресурсоемкая операция чем запуск нового процесса, поэтому давайте переместим вызов `mail.send(msg)` в поток(файл `app/emails.py`):
```
from threading import Thread
def send_async_email(msg):
mail.send(msg)
def send_email(subject, sender, recipients, text_body, html_body):
msg = Message(subject, sender = sender, recipients = recipients)
msg.body = text_body
msg.html = html_body
thr = Thread(target = send_async_email, args = [msg])
thr.start()
```
Если вы тестируете функцию «Follow» вы обратите внимание что браузер показывает обновленную страницу прежде чем писмо будет отправлено.
Итак, сейчас мы реализовали асинхронную отправку почты, но что если в будущем нам понадобится реализовать другие асинхронные функции? Процедура останется той же, но нам нужно будет дублировать код работы с потоками в каждом случае, что не есть хорошо.
Мы можем реализовать наше решение в виде декоратора. С декоратором код выше изменится на этот:
```
from decorators import async
@async
def send_async_email(msg):
mail.send(msg)
def send_email(subject, sender, recipients, text_body, html_body):
msg = Message(subject, sender = sender, recipients = recipients)
msg.body = text_body
msg.html = html_body
send_async_email(msg)
```
Гораздо лучше, не правда ли?
Код который делает эту магию, на самом деле очень простой. Мы запишем его в новый файл (файл `app/decorators.py`):
```
from threading import Thread
def async(f):
def wrapper(*args, **kwargs):
thr = Thread(target = f, args = args, kwargs = kwargs)
thr.start()
return wrapper
```
Сейчас когда мы случайно создали хорошую основу для асинхронных задач мы можем сказать что все сделано!
Ради упражнения давайте рассмотрим как изменилось бы наше решение, если бы мы использовали процессы вместо потоков.
Мы не хотим чтобы новый процесс стартовал каждый раз, когда мы отправляем письмо, вместо этого мы можем использовать класс `Pool` из модуля `multiprocessing`. Этот класс создает необходимое количество процессов (которые являются форками основного процесса) и все процессы ждут задачи, которые передаются через метод `apply_async`. Это может быть полезным и интересным для загруженых сайтов, но сейчас мы остановимся на потоках.
### Заключительные слова
Исходный код обновленного приложения доступен ниже:
Скачать [microblog-0.11.zip.](https://github.com/miguelgrinberg/microblog/archive/v0.11.zip)
Я получил несколько просьб разместить это приложение на GitHub или похожем сайте, я думаю это очень хорошая идея. Я буду работать над этим в ближайшем будущем. Оставайтесь на связи.
Спасибо за то что следите за серией моих туториалов. Надеюсь увидеть вас в следующих частях.
Miguel | https://habr.com/ru/post/234737/ | null | ru | null |
# 7 вредных советов проектировщику REST API
*Адаптация статьи REST WORST PRACTICES, © Jacob Kaplan-Moss. Статья написана применительно к Django, но информация будет актуальна для широкого круга специалистов.*
Думаю что лучший способ понять как нужно делать, изучить как делать НЕ нужно. Представляю вашему вниманию вредные советы проектировщикам REST API.
Несколько недель назад я отправил этот текст своему коллеге, который просил моего совета при проектировании REST API в Django. С тех пор я цитировал сам себя несколько раз, в связи с чем решил опубликовать эти советы, возможно, кому-то еще они покажутся ценными.
### Объединяй модели и ресурсы
В мире REST, ресурс — это центральное понятие. Очень заманчиво просто взять модель (строка в таблице), сказать что это и есть ресурс — одна модель, один ресурс. Это решение проваливается как только возникает задача — представить некий вид составного ресурса и уж точно проваливается в сильно денормализованных моделях.
Представьте модель Супергерой: вот единственный запрос **GET /heros/superman/** который должен вернуть все его характеристики: список друзей, список связанных с ним артефактов и т.д. Смотрите, данные, ассоциированные с ресурсом, на самом деле могут приходить из нескольких моделей. Тут же полезно вспомнить паттерн фасад — ресурс это фасад для моделей, а не конкретная модель.
### Жестко зашивай конкретную подсистему контроля доступа в код API
Способ контроля доступа должен быть подключаемым. Модуль контроля доступа должен определять какие операции над какими объектами допустимы — это единственный способ заставить работать что-то сложное.
Так вы сможете реализовать любой сценарий и сохранить контроль над системой разграничения доступа. Например, в одной системе вам может потребоваться реализовать анонимное чтение, чтение/запись при доступе с токеном разработчика и полный доступ при HTTP-аутентификации с данными администратора через админку.
### Делай формат возвращаемых данных зависимым от типа ресурса
Бывает очень заманчиво, по различным причинам, использовать различный формат результатов в зависимости от типа ресурса. Но это очень плохая идея, поскольку такой подход делает клиентский код очень сложным.
Вспомните Yahoo APIs — формат ResultSet/Result везде одинаков. Так же и Atom (GData).
Основная мысль — клиентский код не должен знать как парсить множество различных форматов данных.
### Пусть твой API поддерживает только один формат возвращаемых данных
JSON это, конечно, круто и его точно нужно поддерживать с самого начала. Но с развитием системы должна быть возможность выбора формата выходных данных, например, AtomPub.
Причем, формат вывода должен определяться нативно, через заголовок HTTP Accept, а не через лишние конструкции вида ?format=xml.
### Перегружай семантикой стандартные методы HTTP-протокола
Большинство виденных мною REST API отображают основные стандартные методы HTTP (POST/GET/PUT/DELETE) в соответствующие CRUD-методы (create/retrieve/update/delete). Это не очень хорошая идея, потому что одни ресурсы могут использовать паттерн POST-как-создатель-связанных-ресурсов, а другие могут использовать POST-как-редактирование для обратной совместимости с HTML-формами. Любая форма должна быть допустима.
Более того, такие системы не допускают использование расширенных HTTP-методов. WebDAV определяет несколько полезных методов, так же новый метод HTTP PATCH уже официально часть стандарта. Ни кто не говорит о том что вы должны ограничивать себя четырьмя основными методами HTTP, речь идет лишь о том чтобы эти методы широко поддерживались, т.к. нестандартные HTTP-запросы могут просто игнорироваться веб-сервером.
### Используй индексы для определения связей между ресурсами
Итак, вы хотите чтобы один ресурс ссылался на другой. Например, PhotoAlbum ссылается на объекты Photo. Обычно вы делаете это как-то так:
```
{
'album': 'whatever',
'photos': [1, 2, 3, 4]
}
```
Просто указываете ID объектов, да? Печально, но это означает что клиентский код должен «просто знать» о том как конструировать URL на ресурсы Photo. Это так же означает что клиентский и серверный код становятся зависимыми. Как бонус, вы получаете все проблемы, связанные с несовместимостью API и клиентского кода. Почти все API на нашей планете допускают эту ошибку, поэтому малейшее изменение в формате URL автоматически сломает всех клиентов вашего API.
Просто используйте готовые URL:
```
{
'photos': ['http//example.com/ph/1', ...]
}
```
Или, если волосы встают дыбом от дублирования, сообщите формат URL:
```
{
'photos': [1, 2, 3],
'photo_uri_template': 'http://example.com/ph/{id}'
}
```
### Жестко привяжи REST API к своему приложению
Любой большой API должен иметь выделенный сервер (серверы) для своей работы: характеристики производительности и факторы, от которых они зависят, так отличаются от обычных веб-приложений, что для больших API требуются отдельные, специальным образом настроенные, серверы. Это факт. Более того, если API-сервер падает, это не должно влиять на общедоступный веб-сайт.
Всем успехов в проектировании API! | https://habr.com/ru/post/325884/ | null | ru | null |
# Программирование на Android для web разработчика или быстрый старт для самых маленьких. Часть 2
Приветствую!
Статья является продолжением начатой мной [части 1](http://habrahabr.ru/post/165105/).
#### Предостережение
**Важно**: данный урок не является профессиональным. Автор урока не является специалистом в программировании для платформы Android. Я заранее приношу свои извинения, за неоправданные ожидания.
#### RegistrationActivity
В Activity для регистрации нужно проделать следующее:
* 1. Прочесть данные формы
* 2. Validation на стороне клиента (опционально и мной не реализовано)
* 3. Запрос к серверу в фоновом потоке
* 4. Обработка ответа сервера
Чтение формы элементарно и осложнений вызвать не должно:
```
final EditText login = (EditText)findViewById(R.id.login);
final EditText password = (EditText)findViewById(R.id.password);
final EditText password2 = (EditText)findViewById(R.id.password2); // при желании сравнить пароли
```
#### Работ с сетью в новом потоке
Используя [AsyncTask](http://developer.android.com/reference/android/os/AsyncTask.html) создадим фоновый поток:
```
// 3 параметр это тип возвращаемых данных методом doInBackground, его я буду обрабатывать в onPostExecute
class AsyncTaskExample extends AsyncTask {
// фоновая работа
@Override
protected String doInBackground(Void... params) {
}
// выполняется после doInBackground, имеет доступ к UI
protected void onPostExecute(String result) {
} catch (JSONException e) {
e.printStackTrace();
}
}
}
// запуск потока
new AsyncTaskExample().execute();
```
Запросы к серверу я вынес в отдельный класс (классы размещаются в той же паке что и Activity). Метод класса принимает логин, пароль и возвращает ответ сервера. Может выглядеть примерно так:
```
public class ServerSendData {
private static String server = "http://xxx.xxx.x.xxx/";
public static String mlogin = null;
public static String mpassword = null;
public static String sendRegData(String login,String password) {
String result = null;
mlogin = login;
mpassword = password;
try {
URL url = new URL("" + server + "apiregistration/create/"+mlogin+"/"+mpassword+"");
URLConnection connection = url.openConnection();
HttpURLConnection httpConnection = (HttpURLConnection)connection;
int responseCode = httpConnection.getResponseCode();
if (responseCode == HttpURLConnection.HTTP_OK) {
InputStream in = httpConnection.getInputStream();
BufferedReader r = new BufferedReader(new InputStreamReader(in));
result = r.readLine();
Log.w("res",""+result+"");
} else
{
}
}
catch (MalformedURLException e) {}
catch (IOException e1) {}
return result;
}
```
Стоит отметить, что мой сервер общается на JSON. Ответ выглядит так:
```
{"status":"login_busy"}
```
Далее, дело техники. Обращаемся к классу в методе doInBackground:
```
return ServerSendData.sendRegData(""+login.getText().toString()+"",""+ password.getText().toString()+"");
```
В onPostExecute работаем с результатом:
```
JSONObject object = new JSONObject(result);
String status = object.getString("status");
// status будет содержать login_busy
```
Для экономии моего времени и ваших нервных клеток, я осмелюсь прикрепить опрос. | https://habr.com/ru/post/165251/ | null | ru | null |
# Изучаем протоколы со Scapy
Статья расскажет, как можно использовать Scapy для создания пакетов UDP и TCP протокола, так же попробуем реализовать взаимодействие по сети, отправив короткое сообщение с использованием каждого из протоколов.
### Простые протоколы
TCP и UDP - это самые распространенные протоколы. По сути протокол - это то, что описывает правила работы систем и формат передаваемых данных. Для упрощения сетевые данные обозначаются как пакеты, а информация в них делится на служебную информацию и те данные, которые нужно передать.
На страницах wiki можно найти следующие картинки, которые как раз показывают концепцию разделения передаваемых данных на служебную информацию и полезную нагрузку.
Для TCP:
Выше представлен общий вид пакета для адресации по IPv4. Как видно из картинки, полей предостаточно и их заполнение частично лежит на приложении, которое передает данные, частично на операционной системе.
Для UDP:
Структура протокола немного проще, но тем не менее есть, над чем нужно поработать, прежде чем отправлять данные в сеть.
Протоколы TCP и UDP для модели TCP/IP являются транспортными, то есть они используются для задач маршрутизации данных и их основная задача - создание соединения или просто доставка данных для конкретного приложения, которое открывает специальную структуру - сокет (совокупность IP адреса и номера порта). Для каждого из этих протоколов существуют свои правила для настройки соединения. Рассмотрим процесс для каждого их них.
Начнем с UDP протокола. Это самый простой протокол, который не требует дополнительных или предварительных действий для передачи данных. Не предоставляет никаких механизмов для контроля соединения, если данные по какой-то причине не будут доставлены, то единственный способ, чтобы данные все-таки доставить, это переслать их заново.
Попробуем реализовать это взаимодействие. В качестве тестового стенда будем использовать следующий набор виртуальных машин:
* Windows 10 - система для получения и визуализации данных
* Kali Linux - система, которая будет отправлять сообщения
В качестве первого этапа запустим scapy. Сделать это достаточно просто, scapy - это набор классов, который интегрирован в интерактивный шелл языка программирования Python. В Kali Linux он установлен по умолчанию, чтобы им воспользоваться достаточно в терминале набрать `sudo scapy`. Sudo здесь необходимо для доступа к сетевому интерфейсу напрямую, scapy самостоятельно работает с пакетами, поэтому ему нужно больше прав:
Просто так отправлять данные не получится, поэтому нужно сначала открыть порты для взаимодействия. Так как наша целевая система Windows, то сделать это можно с использованием, например, netcat. Netcat можно найти так же на Kali Linux, нужно только его передать в Windows. Сделать это можно так:
`cd /usr/share/windows-resources/binaries/ && sudo python3 -m http.server 9090`
Теперь, чтобы получить доступ к файлу для Windows, нужно либо скачать файл через Браузер, либо через powershell. Открыть UDP порт можно вот так:
`nc.exe -u -lvvp 8585`
Порт открыт, теперь готовим пакет для отправки. Scapy в отличии от других библиотек сразу позволяет отправлять данные, используя известный протокол, то есть даже не нужно заботиться о заполнении всех необходимых для отправки информации данных. Так же очень просто понять, какие поля можно изменять для использования. Пример создания пакета для UDP:
```
ip = IP(dst="192.168.1.110")
udp = UDP()
udp.dport=8585
data = "HELLO FROM UDP!"
packet = ip/udp/Raw(data)
send(packet)
```
В результате получаем следующие данные на системе Kali Linux:
В системе Windows:
Попробуем так же отправить данные через TCP протокол. Стоит уточнить, что этот протокол в отличии от UDP требует предварительной настройки соединения. Для этого нужно пройти процесс 3-х рукопожатий. Это последовательность запросов, которую нужно выполнить перед тем, как отправить хоть какие-то данные. Наглядно это выглядит вот так:
Это взаимодействие просто так не реализовать отправкой данных. Так как протокол умеет настраивать и контролировать содение, а scapy не уведомляет ОС об открывающемся взаимодействии, то соответственно все этапы с картинки придется выполнять самостоятельно.
Так же стоит помнить, что на поведение соединения могут влиять некоторые поля. Поля, с которыми придется работать:
* flags - флаги состояния соединеня
* sequence - идентификатор, который используется ОС для отправки данных
Среди перечисленного самым большим камнем преткновения является sequence. Этот идентификатор генерируется рандомно ОС или устройством и, чтобы его угадать или подобрать, нужно либо слушать трафик, либо озаботиться о предварительном заполнении. Мы будем идти именно 2-м путем - создадим собственные идентификаторы для sequence.
Так как для некоторых операционных систем просчет sequence может отличаться от обычного инкремента счетчика, то операционная система может просто сбрасывать или переповторять много раз одни и те же пакеты. Для ОС Windows это поведение означает, что это будет переотправка RST пакета. Чтобы этого избежать, нужно добавить вот такое правило в файерволл на Kali Linux:
`sudo iptables -A OUTPUT -p tcp -d 192.168.1.110 -s 192.168.1.115 --dport 9090 --tcp-flags RST RST -j DROP`
Теперь можно произвести сборку пакетов и отправку в целевую систему. На целевой системе открываем порт:
`nc.exe -lvvp 9090`
Собираем пакеты:
```
from scapy.all import *
ip=IP(dst='192.168.1.110')
SYN=TCP(sport=1030, dport=9090, flags='S', seq=10)
SYNACK=sr1(ip/SYN)
my_ack = SYNACK.seq + 1
ACK=TCP(sport=1030, dport=9090, flags='A', seq=11, ack=my_ack)
send(ip/ACK)
payload = 'SEND TCP'
PUSH=TCP(sport=1030,dport=9090, flags='PA', seq=11, ack=my_ack)
send(ip/PUSH/payload)
```
Так как процесс многоступенчатый, то стоит записать все команды в один файл. Запускаем и получаем вот такой результат на Kali Linux:
И вот такой на Windows:
Таким простым способом можно изучать, как себя ведет ОС при обработке пакетов, и разбираться в основных проблемах, возникающих при передаче данных через TCP и UDP.
*Данная статья была подготовлена в преддверии старта курса Network Engineer. 20 января пройдет demoday курса, на который приглашаются все желающие. Регистрация на demoday* [*доступна по ссылке*](https://otus.pw/jHUl/)*.* | https://habr.com/ru/post/645627/ | null | ru | null |
# Policy-based Routing (PBR), как основное назначение (Часть 1)
**Что такое Policy-based Routing (PBR)**
Policy-based routing (PBR) перевод данного словосочетания несет смысл такого характера, как маршрутизация на основе определенных политик (правил, условий), которые являются относительно гибкими и устанавливаются Администратором. Другими словами это технология предоставляет условия гибкой маршрутизации (если смотреть на технологию с первоочередной ее задачи), по источнику или назначению пакета.
**Где применяется**
Применение данной технологии очень часто используется для организации избыточности в небольших офисах, при нескольких каналах связи с «вешним миром», «гуглится» примерно таким запросом (PBR 2 ISP). Ну, или другими аналогичными. Если вы «погуглите» то для избыточности нужно будет помимо PBR еще такие штуки как Tracking, SLA, на них я сильно внимание не буду заострять, как сейчас так и в дальнейшей части статьи.
*Кратко про SLA и tracking — это две технологии, точнее связка двух технологий (в нашем случае), которые генерируют различного рода icmp трафик (при заданных условиях), это я про SLA, и выполняют мониторинг данного генератора, а это про tracking.*
Так же PBR находит применение в настройках динамических протоколах маршрутизации (к примеру BGP; OSPF;EIGRP)для фильтрации и redistributions (перенаправления) роутов ну и мелочей типа изменение метрики маршрутов и т.п., и в статической маршрутизации (раскроется ниже), В построение механизмов улучшение качества сервисов (QoS). Возможно, что-то забыл, уж не обессудьте. В дальнейшем, в статье, я не буду раскрывать тему применения PBR в BGP, QoS, OSPF.
**Основы конструкции**
Собственно карта выглядит таким образом:
**Route-map** *namemap* **permit 5**
**match int fa0/0**
**set ip default next-hop** *10.10.10.1*
*Разберем по порядку:*
Первая строка (**route-map** *namemap* [**permit | deny**] [*sequence-number*]) содержит непосредственно команду которая открывает нашу карту (**route -map**), далее идет имя карты (*namemap*), для дальнейшего применение к политике этой карты затем идет **permit** (так как мы хотим, что бы трафик при выполнении условии описанных ниже выполнял действие). Т.е. идет перенаправление пакетов на шлюз *10.10.10.1*. Вместо параметра **permit** может выступать параметр **deny**, но он не так часто применяется. В большей степени он применяется только при *redistributions* (перенаправления), в динамических протоколах маршрутизации, а если быть точнее, наоборот, при deny не производить *redistributions* (перенаправления). Для нижеуказанного условия карты, последним параметром идет *sequence-number* он у нас *5* т.е. порядковый номер карты, он удобен для логического представления карт с одним и тем же именем. Так же для удобства администрирования карты (удаления в частности).
Вторая строка (**match interface fa0/0**), содержит условие, для какого трафика применять нашу карту. В нашем случае, у нас будет применяться весь трафик проходящий через интерфейс маршрутизатора **fastethernet0/0**. Тут можно по различным критериям делать выборку, как правило, все рисуют карту по **access-lists** (листам доступа) т.е. рисуют **access-list** с параметрами для каких сетей применять карту. Примеры **access-lists** с легким комментарием представлены ниже.
`access-list 101 permit ip 192.168.0.0 0.0.0.255 any
### этот access-list примененный к route-maps будет выбирать трафик сети 192.168.0.0/24
до любого назначения.
А при применении такого access-lists
access-list 101 deny ip 192.168.0.0 0.0.0.255 host 192.168.2.44
access-list 101 deny ip 192.168.0.0 0.0.0.255 192.168.1.0 0.0.0.31
access-list 101 permit ip 192.168.0.0 0.0.0.255 any
### в первой строчке не будет перенаправлять трафик до хоста 192.168.2.44
### по второй строке так же не будет перенаправлять на сеть 192.168.1.0/27
### ну и по третьей строке будет применять для всего остального трафика, сети 192.168.0.0/24.`
Так же добавить хочется что параметр **match** повторяющийся, т.е. выборку можно делать по нескольким критериям. К примеру метим по **access-lists**, и параллельно по размеру пакета **match length** *min max*, где *min max* это диапазон размера пакета от и до). И еще маленькое дополнение к этому параметру он не является обязательным. Другими словами если не делать выборку по критериям, то карта будет применяться ко всем пакетам, проходящим через интерфейс на который мы применим нашу карту маршрутизации.
Переходя к следующему параметру, скажу, что если вы выполните подкоманду **set ?** то помощь, вам покажет много значений, в основном эти значения направлены на опять же динамические протоколы маршрутизации. На данный момент я решил их не касаться (я планирую написать статьи про динамическую маршрутизацию, там и вернемся к ним). А перейдем сразу к **set ip**
Мы взяли в пример **set ip default next-hop** *10.10.10.1*
Тут мы опять же рассмотрим ключевое слово **default**, оно означает, что если не будет роутов в глобальной таблице маршрутизации информации о сети назначения пакета, то будет отрабатывать наша карта и пакет будет отправлен на следующий шаг в данном случае *10.10.10.1*.
Можно написать явный **set ip next-hop** *10.10.10.1* и тогда пакет в не зависимости от глобальной таблицы будет перенаправлен на наш **next-hop**, т.е. пакет попавший в критерий что он пришел на интерфейс **fa0/0**, отправится на *10.10.10.1* и он уже будет решать что с этим пакетом делать.
Далее рассматривая параметр **set ip**, можно задать следующий шагом(next-hop) как определенный ip адрес, для последующей маршрутизации, так непосредственно интерфейс. К примеру **set ip next-hop interface** *Dialer1*), это удобно когда у вас, к примеру не статический адрес на next-hop-е, а динамический и вы не можете явно прописать адрес 3-го уровня, ну или если вы забыли какой ip адрес у вас на интерфейсе и вам лень посмотреть. Как было подмечено ниже в комментариях, не стоит указывать интерфейсы, на которых прописана сеть с большим количеством хостов в сети, другими словами использовать стоит при point to point сети (с префиксов 30 ).Другие параметры **set ip**, используются для изменения параметров ip пакета. Установка маркирования приоритета пакета в QoS(**set ip precedence 3**), или сброса параметра пакета don’t fragments (**set ip df 0**), что позволит установить размер пакета, какой нужен маршрутизаторам для дальнейшей передачи по каналам связи.
Остается мелочь повесить **route-map** на интерфейс через который приходят пакеты нуждающиеся в перенаправлении пакетов в отличие от дефолтного маршрута глобальной таблицы маршрутизации. И получится такой листинг
`Route-map namemap permit 5
match int fa0/0
set ip default next-hop 10.10.10.1
interface FastEthernet0/0
encapsulation dot1Q 20
ip address 192.168.0.1 255.255.255.0
ip policy route-map namemap`
Прошу заметить, что данная конфигурация не совсем правильная в нашем случае, хотя рабочая. Тут сами подумайте, чем она не корректна, и какие условия нужно изменить.
Послесловие:
В этой части я попытался раскрыть азы PBR и как он работает с пакетами. Если у меня это получилось не внятно, прошу указать на ошибки. Буду очень признателен. В части 2 я опишу еще несколько моментов касающихся PBR, и приведу примеры построения маршрутизации, для конкретных случаев.
**UPD** [вот собственно и попытка продолжения часть 2](http://habrahabr.ru/blogs/cisconetworks/114197/)
Материал для статьи брался из головы, так что литературу указать не смогу, разве что www.
P.S статья эта была в песочнице, мне кто-то дал приглашение на хабр, но так как я был в офлайне долгое время приглашение утратило силу свою. хочу сказать спасибо товарищу который дал инвайт. сейчас я по приглашению [smartov](https://habrahabr.ru/users/smartov/), мы с ним знакомы по другому ресурсу в сети. Ему так же благодарность за приглашение.
*Posted by Mario* | https://habr.com/ru/post/101796/ | null | ru | null |
# Детективная история про SQL injection, местами blind
Доброго времени суток!
Не подумал бы писать статью об этом, т.к. думал, что тема довольно заезжена. Но, судя по [этой статье](http://habrahabr.ru/blogs/infosecurity/134372/) аудитории интересно. Окончательно меня убедил в том, что писать надо [вот этот комментарий](http://habrahabr.ru/blogs/infosecurity/134372/#comment_4461443).
Данная история произошла со «знакомым знакомого моего знакомого», но, для краткости буду писать цитатами с его слов, употребляя просто «я». Дело было полторы недели назад. Поехали.
Понадобилось мне изучить один европейский язык, в свете возможного переезда в одну европейскую страну. И нашёл я замечательный сайт, на котором предлагалось учить язык с помощью подкастов. Сами подкасты распространяются бесплатно, но можно купить PDF с записями уроков и упражнениями. Мне эти записи не очень нужны, но моя жена, в отличие от меня, вовсе не аудиал, а язык учить ей тоже надо. Прежде, чем что-то купить в интернете, я внимательно изучаю сайт продавца — не хочется, чтобы мои данные куда-то утекли. И в этом случае все оказалось более чем плохо. Желание покупать что-либо сразу отпало. Но и остаться без PDF неспортивно. В итоге я решил попробовать воспользоваться одной из найденных уязвимостей. Сразу скажу, что я принципиально не пользуюсь никакими автоматическими сканерами уязвимостей и принципиально не причиняю вреда пользователям ресурса — они же не виноваты, что хозяин ресурса коряво его написал. Поэтому моими инструментами являются соображалка и теоретические знания по причинам возникновения и использованию уязвимостей.
##### Начало
Первым делом я посмотрел на несколько демо-примеров доступных для загрузки PDF. Сначала пользователь отправлялся по адресу:
`/guide.php?id=lesson_id`
В этот момент проверяется имеет ли текущий пользователь право скачать заданный PDF. Если да — идет редирект по адресу:
`/download.php?f=filename.pdf`
Сразу же оказалось, что данный скрипт отдает указанный файл ничего не проверяя. Т.к. доступный пример для урока №1 имел имя файла 001.pdf я решил попробовать получить все файлы перебором. Если бы все было так просто, то и писать было бы не о чем. Но таким образом удалось добыть только первые 100 файлов. Остальные имели в своем имени timestamp времени создания и перебирать их стало невозможно, т.к. время создания отличалось на несколько месяцев.
##### Раскручиваем SQL injection
Довольно скоро обнаружилась банальнейшая SQL injection в GET параметре:
`/some_script.php?id=123`
Вроде бы дальше ее использование строится очень просто:
1. Определить количество параметров в запросе
2. Подобрать имена таблиц и полей (в случае MySQL 5.0 и выше — выбрать их из information\_schema)
3. Получить нужные имена файлов
4. Скачать сами файлы
Но проблемы начались с первого пункта — определить количество полей в запросе не удалось. При любом количестве полей в UNION SELECT и при любом номере в ORDER BY n я получал сообщение «You have error in your syntax...»
На самом деле я совершенно случайно догадался в чем именно проблема — попробовав сделать GROUP BY 1. На это я получил ошибку «cannot group by cnt». Оказалось, что уязвимый параметр используется дважды (ну по крайней мере это предположение мне опровергнуть не удалось).
Сначала выбирается количество записей с указанным id:
`SELECT count(*) FROM table where id=123`
Если количество записей 0, то считается, что страница не найдена и происходит редирект на главную страницу. Если записей не 0, вытаскивается информация:
`SELECT * FROM table where id=123`
Теперь становится понятно, почему не удалось выяснить количество полей в запросе — их 2 и в одном из них всегда окажется неверное количество полей в UNION. Придумать способ, который позволил бы вставить разное количество полей в UNION в первый и второй запрос, мне не удалось. И в этот момент SQL injection стала blind. Мне не удалось подобрать имя таблицы с путями к файлам, но зато удалось подобрать имя таблицы с данными пользователей (MySQL 4.1).
*Уважаемые разработчики, не делайте 2 запроса, там где можно сделать один! В этом случае можно было вместо SELECT count(\*) проверить количество записей возвращенных запросом SELECT \**
Теперь осталось придумать способ получать полезную информацию. Я сделал так:
`/script.php?id=123 limit 0,0 union all select length(username)>4 from tablename limit 0,1--`
Что мы здесь видим:
* **123 limit 0,0** — т.к. count(\*) всегда вернет нам ровно одну запись и мы не узнаем, что именно было возвращено нашей частью запроса, нужно убрать его из результата
* **union all select length(username)>4 from tablename limit 0,1--** — если длина имени пользователя больше 4, то условие верно, MySQL вернет единицу, а затем ошибку, при попытке выполнить второй запрос. Если условие неверно — вернет 0 и произойдет редирект. Ну и '--' для комментария в конце
Таким образом по HTTP заголовку можно понять, верное ли условие мы передали. Сначала определяем длину имени пользователя, затем побуквенно двоичным поиском вытаскиваем само имя ( lower(substr(username,1,1)) in ('a','b','c') ). Затем побуквенно вытаскиваем пароль. Но оказывается, что пароль хеширован в md5. И хотя хэширование без соли, но пароли администраторов сайта все равно подобрать не удалось (в rainbow tables нет, а брутфорсом на нетбуке заниматься не хотелось; да и неспортивно это).
После некоторых раздумий было решено идти другим путем. Т.к. в базе оказалось более 60000 пользователей я предположил, что у многих из них популярные пароли. А дальше нужно было всего лишь побуквенно вытащить имена пользователей у которых хэш пароля равен md5('password') — их оказалось больше 100 и среди них были люди купившие нужные PDF. И они любезно согласились ими со мной поделиться.
Все это было сделано с помощью очень простого скрипта, который отправлял HEAD-запрос (а зачем нам тело страницы?) и смотрел заголовок ответа. Если 200 — условие верно, если 302 — неверно.
##### Заключение
Зачем все это написано? Чтобы показать, что нужно знать суть и причины возникновения уязвимостей, а не заучивать способы их использования. Все способы использования SQL injection, которые я видел в интернете, предлагали определить количество полей через ORDER BY 5 или UNION SELECT 1,2,3… И человек, не захотевший подумать, ушел бы с сайта ни с чем.
Кроме того, я слегка горд своим обходным маневром вместо взлома хэша. Ну и [не так давно](http://habrahabr.ru/blogs/infosecurity/134372/#comment_4461443) высказывался скептицизм по поводу существования таких уязвимостей в современном интернете и по поводу практического применения blind SQL injection.
P.S. Все совпадения с реальностью являются случайными. Голоса знаменитостей сымитированы, причем убого. | https://habr.com/ru/post/134885/ | null | ru | null |
# Идеальный каталог, вариант реализации
В продолжении статьи "[Идеальный каталог, набросок архитектуры](https://habrahabr.ru/post/322930/)", я покажу на примерах как можно использовать предложенную структуру БД для хранения произвольных данных и выполнения произвольных поисков по этим данным. Скрипты лежат в репозитории — [universal\_data\_catalog\_idea](https://github.com/SbWereWolf/universal_data_catalog_idea).
Приглашаю под кат, тех кому интересно посмотреть на эти скрипты с авторскими комментариями.
Содержание репозитория
----------------------
В репозитории полный набор инфраструктурных скриптов:
1. создание таблиц
2. заполнения данными;
3. очистки таблиц от данных;
4. удаления всех созданных таблиц;
Когда я начинал писать скрипты их объём был небольшим, но когда я добрался до создания тестовых наборов, объём кода вырос до 1000+ строк. Такие большие скрипты вставлять в статью мне кажется излишним, поэтому если вам хочется потрогать «живые» данные, то клонируйте репозиторий и смотрите как оно в жизни получается.
В схеме БД я сделал небольшие изменения — редакторов (redactor\_id) вынес из контента (content), теперь контент сам по себе, редакторы сами по себе.
Основные моменты организации данных
-----------------------------------
Сама по себе система не диктует правил использования, логика к ней может быть применена любая.
Основное назначение системы это поиск данных, хранение данных — это необходимый, но тем не менее второстепенный функционал.
Хранить можно любые данные, любой конфигурации. Данные каталога состоят из Сущностей (item) и их Значений (content). Каждое Значение, является значением конкретной Характеристики (property). Сущности с одним и тем же набором Характеристик можно объединить в Рубрики (rubric).
Сущность может принадлежать одной Рубрике, может — нескольким, в представленном варианте — только одной.
Добавление данных (хранение)
----------------------------
Как добавлять данные в каталог можно посмотреть в \deploy\commit\_dml.sql. Последовательность такая:
1. создать Рубрики (rubric);
2. если необходима иерархия Рубрик, то создать Иерархию (element\_tree) и распределить рубрики по иерархии (rubric\_element\_tree);
3. добавить Характеристики (property);
4. если предполагается использование Характеристик в соответствии с какими либо правилами, то можно добавить Опции этих правил (tag) и соответствующим образом стыковать Характеристики и Опции (property\_tag);
5. назначить Рубрикам Характеристики (rubric\_property);
6. добавить Сущности (item);
7. сгруппировать Сущности по Рубрикам (rubric\_item);
8. добавить Значения (content) для Характеристик;
9. стыковать Значения с Сущностями (item\_content);
10. если предполагается что у Значений будет несколько редакторов, то добавить Редакторов (redactor) и назначить Значениям Редакторов (redactor\_content);
11. если предполагается не только строковый поиск, то конвертировать пользовательский ввод (content.raw) в конкретный тип данных и записать данные в соответствующую таблицу (date\_matter.date\_time, digital\_matter.digital, duration\_matter.duration, string\_matter.string);
Список вышел длинным, но по факту все шаги укладываются в два действия:
1. добавить Сущность;
2. задать Значения;
Остальные шаги по необходимости. С теорией хранения информации разобрались. Теперь практическое применение.
Практическое наполнение каталога
--------------------------------
Допустим мы хотим сделать своё «авито» для продажи экскаваторов.
Для этого мы добавим корневую рубрику «Экскаваторы», и к ней две дочерних «Экскаваторы карьерные» и «Экскаваторы погрузчики».
Для рубрики «Экскаваторы карьерные» назначаем свойства:
«Модель изделия»;
«Торговая марка»;
«Ёмкость ковша»;
«цена товара в рублях»;
«единицы измерения для товарной позиции»;
Для рубрики «Экскаваторы погрузчики» назначаем аналогичный набор свойств плюс свойство «Ёмкость лопаты».
Характеристики:
«Модель изделия»,
«Торговая марка»,
«Ёмкость ковша»,
«Ёмкость лопаты»,
являются системными, значения этих Характеристик задаёт контент менеджер, назначаем им Опцию — «SYSTEM\_PROPERTY».
«Ёмкость ковша» и «Ёмкость лопаты» это числовые данные — Опция «DIGITAL\_DATA\_TYPE», поиск по ним будет поиском по диапазону значений — «BETWEEN\_SEARCH\_TYPE».
«Модель изделия» и «Торговая марка» это строковые данные — «STRING\_DATA\_TYPE», поиск по Характеристике «Торговая марка» будет как по справочнику производителей — перечислением — «ENUMERATION\_SEARCH\_TYPE», по Характеристике «Модель изделия» будем искать вхождение подстроки — «LIKE\_SEARCH\_TYPE».
Забиваем Сущности и Значения. Теперь можно выполнить общий поиск.
Общий поиск
-----------
Общий поиск подразумевает под собой поиск везде, наше везде ограничено только Рубриками и Сущностями, в принципе можно искать ещё и в Значениях, благо они хранят пользовательский ввод в формате строк. Поиск везде подразумевает поиск подстроки, в каких колонках? Видимо только «title» и «description».
Поехали!
```
-- Поиск "везде" ( в рубриках и в позициях каталога )
SELECT
'RUBRIC',
rr.code,
rr.title,
rr.description
FROM rubric rr
WHERE
(rr.title ILIKE '%' || :SEARCH_PATTERN || '%'
OR rr.description ILIKE '%' || :SEARCH_PATTERN || '%')
AND EXISTS
(
SELECT NULL
FROM
(
WITH RECURSIVE road_map ( id, element_tree_id, code, horizont ) AS
(
SELECT
cet.id AS id,
cet.element_tree_id AS element_tree_id,
r.code AS code,
0 AS horizont
FROM
element_tree cet
LEFT JOIN rubric_element_tree ret
ON cet.id = ret.element_tree_id
LEFT JOIN rubric r
ON ret.rubric_id = r.id
WHERE r.code = rr.code
UNION
SELECT
pet.id,
pet.element_tree_id,
r.code,
horizont + 1
FROM
element_tree pet
JOIN road_map c
ON (c.element_tree_id = pet.id)
LEFT JOIN rubric_element_tree ret
ON pet.id = ret.element_tree_id
LEFT JOIN rubric r
ON ret.rubric_id = r.id
)
SELECT NULL
FROM
road_map rm
WHERE
rm.code = :CATALOG_ROOT
ORDER BY
horizont DESC
LIMIT 1
) R
)
UNION
SELECT
'ITEM',
i.code,
i.title,
i.description
FROM
rubric rr
JOIN rubric_item ri
ON rr.id = ri.rubric_id
JOIN item i
ON ri.item_id = i.id
WHERE
(i.title ILIKE '%' || :SEARCH_PATTERN || '%'
OR i.description ILIKE '%' || :SEARCH_PATTERN || '%')
AND EXISTS
(
SELECT NULL
FROM
(
WITH RECURSIVE road_map ( id, element_tree_id, code, horizont ) AS
(
SELECT
cet.id AS id,
cet.element_tree_id AS element_tree_id,
r.code AS code,
0 AS horizont
FROM
element_tree cet
LEFT JOIN rubric_element_tree ret
ON cet.id = ret.element_tree_id
LEFT JOIN rubric r
ON ret.rubric_id = r.id
WHERE r.code = rr.code
UNION
SELECT
pet.id,
pet.element_tree_id,
r.code,
horizont + 1
FROM
element_tree pet
JOIN road_map c
ON (c.element_tree_id = pet.id)
LEFT JOIN rubric_element_tree ret
ON pet.id = ret.element_tree_id
LEFT JOIN rubric r
ON ret.rubric_id = r.id
)
SELECT NULL
FROM
road_map rm
WHERE
rm.code = :CATALOG_ROOT
ORDER BY
horizont DESC
LIMIT 1
) R
);
```
### Параметры запроса
#### Корневая рубрика
```
:CATALOG_ROOT
```
Код корневой Рубрики (rubric.code), служит для ограничения области поиска, можем искать в «Экскаваторах» вообще, а можем искать только в карьерных, или можем искать в товарах вообще, а можем только в экскаваторах.
Определение, имеет ли очередной объект в предках заданную Рубрику, происходит через иерархический запрос специфичный для каждой СУБД.
Можно искать без ограничения по области, тогда если мы добавили в наш каталог услуги (например по аренде экскаваторов) и резюме (например машиниста экскаватора) и ищем подстроку «экскаватор», то у нас в результаты вываляться и позиции по аренде экскаваторов и позиции про машиниста экскаватора.
#### Строка поиска
```
:SEARCH_PATTERN
```
Строка поиска — собственно та подстрока которую будем искать, можно строку поиска разбить по пробелам (или любому другому разделителю) и искать с условием:
```
WHERE
(i.title ILIKE '%' || :PATTERN_PART1|| '%'
OR i.description ILIKE '%' || :PATTERN_PART1 || '%')
AND
(i.title ILIKE '%' || :PATTERN_PART2|| '%'
OR i.description ILIKE '%' || :PATTERN_PART2|| '%')
-- сколько угодно ещё частей строки поиска
AND
(i.title ILIKE '%' || :PATTERN_PART_N|| '%'
OR i.description ILIKE '%' || :PATTERN_PART_N|| '%')
```
Получившийся скрипт конечно выглядит «гигантским», но пишется он не в ручную, пишет его наше приложение, а СУБД проглотит любой скрипт, поэтому не надо смотреть на количество букв — это не существенно.
Допустим с помощью этого поиска пользователь нашёл нужную ему рубрику, теперь в рубрике надо найти интересную позицию, для этого надо в Рубрике сделать поиск среди Сущностей по заданным параметрам.
### Поиск по параметрам
Что бы пользователь представлял себе границы поиска, для него надо эти границы вычислить.
Если мы делаем поиск по рубрике, то показываем параметры (границы) поиска только для системных Характеристик.
Для этого посмотрим какие у нашей рубрики, есть системные Характеристики и какие способы поиска заданы:
```
-- Для поиска по рубрике необходимо сформировать параметры поиска - диапазоны допустимых значений для системных свойств
SELECT
btrim(p.code) AS "property",
btrim(tu.code) AS "author_type",
btrim(ts.code) AS "search_type",
btrim(tt.code) AS "data_type"
FROM
rubric r
JOIN rubric_property rp
ON rp.rubric_id = r.id
JOIN property p
ON rp.property_id = p.id
JOIN property_tag ptu
on p.id = ptu.property_id
JOIN tag tu
on ptu.tag_id = tu.id
JOIN property_tag pts
on p.id = pts.property_id
JOIN tag ts
on pts.tag_id = ts.id
JOIN property_tag ptt
on p.id = ptt.property_id
JOIN tag tt
on ptt.tag_id = tt.id
WHERE
r.code = 'ekskavatory-karernye'
AND tu.code = 'SYSTEM_PROPERTY'
AND ts.code IN ('LIKE_SEARCH_TYPE','BETWEEN_SEARCH_TYPE','ENUMERATION_SEARCH_TYPE')
AND tt.code IN ('DIGITAL_DATA_TYPE','STRING_DATA_TYPE')
;
/*
MANUFACTURER_MODEL, SYSTEM_PROPERTY, LIKE_SEARCH_TYPE, STRING_DATA_TYPE
TRADE_MARK, SYSTEM_PROPERTY, ENUMERATION_SEARCH_TYPE, STRING_DATA_TYPE
BUCKET_CAPACITY_M3, SYSTEM_PROPERTY, BETWEEN_SEARCH_TYPE, DIGITAL_DATA_TYPE
*/
```
#### Пояснение к запросу
Смотрим какие Характеристик являются системными:
```
tu.code = 'SYSTEM_PROPERTY'
```
Смотрим какой тип поиска определён для этих Характеристик:
```
ts.code IN ('LIKE_SEARCH_TYPE','BETWEEN_SEARCH_TYPE','ENUMERATION_SEARCH_TYPE')
```
Смотрим тип данных для этих Характеристик:
```
tt.code IN ('DIGITAL_DATA_TYPE','STRING_DATA_TYPE')
```
Если один из трех параметров поиска для Характеристики не задан, то поиск выполнить не возможно (соединение таблиц tu ts tt через JOIN).
Определяем свойства для рубрики «Экскаваторы карьерные».
```
r.code = 'ekskavatory-karernye'
```
#### Результат запроса
В итоге получаем три Характеристики и параметры поиска:
1. **MANUFACTURER\_MODEL**, SYSTEM\_PROPERTY, LIKE\_SEARCH\_TYPE, STRING\_DATA\_TYPE
2. **TRADE\_MARK**, SYSTEM\_PROPERTY,ENUMERATION\_SEARCH\_TYPE, STRING\_DATA\_TYPE
3. **BUCKET\_CAPACITY\_M3**, SYSTEM\_PROPERTY, BETWEEN\_SEARCH\_TYPE, DIGITAL\_DATA\_TYPE
Теперь для каждой Характеристики ищем границы.
Вычисление границ поиска
------------------------
### Вычисление границ поиска для «MANUFACTURER\_MODEL»
Для «MANUFACTURER\_MODEL» — тип поиска по вхождению («LIKE\_SEARCH\_TYPE») — границы не вычисляем, пользователю выводим **поле для ввода строки поиска** по этой Характеристике.
### Вычисление границ поиска для «TRADE\_MARK»
```
-- формирование параметров поиска
SELECT
sm.string
FROM
rubric r
JOIN rubric_item ri
ON r.id = ri.rubric_id
JOIN item i
ON ri.item_id = i.id
JOIN item_content ic
ON i.id = ic.item_id
JOIN content c
ON ic.content_id = c.id
JOIN property p
ON c.property_id = p.id
JOIN string_matter sm
ON c.id = sm.content_id
WHERE
p.code = 'TRADE_MARK'
AND r.code = 'ekskavatory-karernye'
GROUP BY sm.string;
/*
Уралмаш
Донэкс
*/
```
Тип данных — «STRING\_DATA\_TYPE» — значит анализируем — string\_matter.string. Способ поиска — «ENUMERATION\_SEARCH\_TYPE» — значит делаем «GROUP BY». Вычислили два значения — «Уралмаш» и «Донэкс», пользователю выводим **два чекбокса**.
### Вычисление границ поиска для «BUCKET\_CAPACITY\_M3»
```
-- формирование параметров поиска
SELECT
max(dm.digital) AS maximum,
min(dm.digital) AS minimum
FROM
rubric r
JOIN rubric_item ri
ON r.id = ri.rubric_id
JOIN item i
ON ri.item_id = i.id
JOIN item_content ic
ON i.id = ic.item_id
JOIN content c
ON ic.content_id = c.id
JOIN property p
ON c.property_id = p.id
JOIN digital_matter dm
ON c.id = dm.content_id
WHERE
p.code = 'BUCKET_CAPACITY_M3'
AND r.code = 'ekskavatory-karernye';
/*
25,0.75
*/
```
Тип данных — «DIGITAL\_DATA\_TYPE» — значит анализируем — digital\_matter.digital. Способ поиска — «BETWEEN\_SEARCH\_TYPE» — значит делаем MIN() и MAX(). Вычислили границы от 0.75 до 25, пользователю выводим что то такое:
```
```
Поиск по параметрам
-------------------
```
-- поиск по рубрике
/*
'ekskavatory-karernye'
'MANUFACTURER_MODEL'
'12'
'TRADE_MARK'
'Уралмаш'
'Донэкс'
'BUCKET_CAPACITY_M3'
0.75
25
*/
SELECT
i.code
FROM
rubric_item ri
join rubric r
on ri.rubric_id = r.id
JOIN item i
ON ri.item_id = i.id
JOIN item_content ic
ON i.id = ic.item_id
JOIN content c
ON ic.content_id = c.id
JOIN string_matter sm
ON c.id = sm.content_id
JOIN rubric_property rp
ON ri.rubric_id = rp.rubric_id
JOIN property p
ON c.property_id = p.id
AND p.id = rp.property_id
WHERE
r.code = :CODE
AND p.code = :MODEL_PROPERTY
AND sm.string LIKE '%'||:MODEL_LIKE||'%'
INTERSECT
SELECT
i.code
FROM
rubric_item ri
join rubric r
on ri.rubric_id = r.id
JOIN item i
ON ri.item_id = i.id
JOIN item_content ic
ON i.id = ic.item_id
JOIN content c
ON ic.content_id = c.id
JOIN string_matter sm
ON c.id = sm.content_id
JOIN rubric_property rp
ON ri.rubric_id = rp.rubric_id
JOIN property p
ON c.property_id = p.id
AND p.id = rp.property_id
WHERE
r.code = :CODE
AND p.code = :MARK_PROPERTY
AND sm.string IN ( :MARK1 , :MARK2)
INTERSECT
SELECT
i.code
FROM
rubric_item ri
join rubric r
on ri.rubric_id = r.id
JOIN item i
ON ri.item_id = i.id
JOIN item_content ic
ON i.id = ic.item_id
JOIN content c
ON ic.content_id = c.id
JOIN digital_matter dm
ON c.id = dm.content_id
JOIN rubric_property rp
ON ri.rubric_id = rp.rubric_id
JOIN property p
ON c.property_id = p.id
AND p.id = rp.property_id
WHERE
r.code = :CODE
AND p.code = :BUCKET_PROPERTY
AND dm.digital BETWEEN :MIN_BUCKET AND :MAX_BUCKET
;
```
По каждой Характеристике делаем поиск в соответствии с условиями заданными пользователем и выбираем те Сущности которые удовлетворяют всем условиям, то есть делаем пересечение — INTERSECT — результатов каждого отдельного поиска друг с другом.
Если пользователь задаст одно условие то поиск будет по одной Характеристике, если 100 условий, то будет выполнено 100 подзапросов и пользователю будут выданы те Сущности которые присутствуют в результатах каждого из 100 подзапросов.
В результате поиска по параметрам пользователь определил интересную ему позицию (Сущность).
Надо заметить что по хорошему поиск надо было выполнять с отбором по пользователю «SYSTEM», но я этот момент упустил.
Поиск по пользовательским значениям
-----------------------------------
Напоминаю что мы делаем «авито» для экскаваторов. То есть каждая позиция каталога имеет свою цену, и у каждого пользователя своя цена. И когда наш пользователь открыл карточку позиции каталога он увидел несколько предложений и соответственно захотел выполнить поиск по этим предложениям.
Были у нас свойства:
* «цена товара в рублях»;
* «единицы измерения для товарной позиции»;
Это пользовательские свойства, их значения задают пользователи, регулируется это Опцией «USER\_PROPERTY».
### Границы поиска
Определяем набор пользовательских Характеристик для рубрики «Экскаваторы погрузчики»:
```
SELECT
btrim(p.code) AS "property",
btrim(tu.code) AS "author_type",
btrim(ts.code) AS "search_type",
btrim(tt.code) AS "data_type"
FROM
rubric r
JOIN rubric_property rp
ON rp.rubric_id = r.id
JOIN property p
ON rp.property_id = p.id
JOIN property_tag ptu
on p.id = ptu.property_id
JOIN tag tu
on ptu.tag_id = tu.id
JOIN property_tag pts
on p.id = pts.property_id
JOIN tag ts
on pts.tag_id = ts.id
JOIN property_tag ptt
on p.id = ptt.property_id
JOIN tag tt
on ptt.tag_id = tt.id
WHERE
r.code = 'ekskavatory-pogruzchiki'
AND tu.code = 'USER_PROPERTY'
AND ts.code IN ('LIKE_SEARCH_TYPE','BETWEEN_SEARCH_TYPE','ENUMERATION_SEARCH_TYPE')
AND tt.code IN ('DIGITAL_DATA_TYPE','STRING_DATA_TYPE')
;
/*
GOODS_ITEM_PRICE_RUB,USER_PROPERTY,BETWEEN_SEARCH_TYPE,DIGITAL_DATA_TYPE
GOODS_ITEM_UNITS_OF_MEASURE,USER_PROPERTY,ENUMERATION_SEARCH_TYPE,STRING_DATA_TYPE
*/
```
«GOODS\_ITEM\_PRICE\_RUB»:
* «BETWEEN\_SEARCH\_TYPE» — поиск по диапазону;
* «DIGITAL\_DATA\_TYPE» — числовые данные;
«GOODS\_ITEM\_UNITS\_OF\_MEASURE»:
* «ENUMERATION\_SEARCH\_TYPE» — поиск с перечислением;
* «STRING\_DATA\_TYPE» — символьные данные;
```
-- формирование параметров поиска по Сущности 'jcb-4cx'
SELECT
min(dm.digital) AS minimum,
max(dm.digital) AS maximum
FROM
item i
JOIN item_content ic
ON i.id = ic.item_id
JOIN content c
ON ic.content_id = c.id
JOIN property p
ON c.property_id = p.id
JOIN digital_matter dm
ON c.id = dm.content_id
WHERE
p.code = 'GOODS_ITEM_PRICE_RUB'
AND i.code = 'jcb-4cx';
/*
3400000
4700000
*/
SELECT
sm.string
FROM
item i
JOIN item_content ic
ON i.id = ic.item_id
JOIN content c
ON ic.content_id = c.id
JOIN property p
ON c.property_id = p.id
JOIN string_matter sm
ON c.id = sm.content_id
WHERE
p.code = 'GOODS_ITEM_UNITS_OF_MEASURE'
AND i.code = 'jcb-4cx'
GROUP BY sm.string;
/*
р/шт
шт
шт.
*/
```
### Поисковый запрос
Видим что у всех позиций единица измерения в штуках, записана просто по разному, поэтому ищем только по цене.
```
/*
:ITEM_CODE => 'jcb-4cx'
:PRICE_PROPERTY => 'GOODS_ITEM_PRICE_RUB'
:MIN_PRICE => 3400000
:MAX_PRICE => 4000000
*/
SELECT
r.id,
r.title,
r.description,
c.raw
FROM
item i
JOIN item_content ic
ON i.id = ic.item_id
JOIN content c
ON ic.content_id = c.id
JOIN redactor_content rc
ON c.id = rc.content_id
JOIN redactor r
ON rc.redactor_id = r.id
JOIN digital_matter dm
ON c.id = dm.content_id
JOIN rubric_item ri
ON i.id = ri.item_id
JOIN rubric_property rp
ON ri.rubric_id = rp.rubric_id
JOIN property p
ON c.property_id = p.id
AND p.id = rp.property_id
WHERE
i.code = :ITEM_CODE
AND p.code = :PRICE_PROPERTY
AND dm.digital BETWEEN :MIN_PRICE AND :MAX_PRICE
;
/*
Василий Алибабаевич Уримчи,бригадир СМУ-3,3 800 000
Олег,Мы всегда можем договориться о взаимовыгодном сотрудничестве,3 400 000
*/
```
Собственно это упрощённый поиск чисто по одной Характеристике «цена».
В результате запроса можно выдавать и digital\_matter.digital, но тогда (если у нас будет INTERSECT по нескольким Характеристикам) надо делать приведение к типу TEXT ( digital\_matter.digital::TEXT), в принципе пользователю мы данные выводим в текстовом виде, поэтому можно выдавать content.raw.
Заключение
----------
Собственно этого достаточно что бы понять как можно идею идеального каталога применить на практике. Кейсов конечно на порядок больше чем поиск товара и поставщика.
Самое главное что я хотел показать, это то что идея **достаточно гибкая** что бы быть идеально Универсальной :)
Учитывая мой recovery\_mode, ещё через неделю я смогу выложить php скрипты для динамической генерации SQL запросов.
Спасибо всем кто читал, буду благодарен за любую критику и любые советы.
Addon
-----
Для полноты картины не хватает иерархических скриптов, для вывода всех рубрик от корневой, и для вывода всех родителей для произвольного элемента. Эти скрипты лежат в \deploy\view\_catalog\_settings\_and\_data.sql.
Карта рубрик:
```
-- показать карту иерархии Сущностей с уровнем иерархии, для корневой рубрики 'GOODS'
WITH RECURSIVE road_map ( id, element_tree_id, code, horizont ) AS
(
SELECT
pet.id AS id,
pet.element_tree_id AS element_tree_id,
r.code AS code,
0 AS horizont
FROM
element_tree pet
LEFT JOIN rubric_element_tree ret
ON pet.id = ret.element_tree_id
LEFT JOIN rubric r
ON ret.rubric_id = r.id
WHERE r.code = :ROOT
UNION
SELECT
cet.id,
cet.element_tree_id,
r.code,
horizont + 1
FROM
element_tree cet
JOIN road_map c
ON (c.id = cet.element_tree_id)
LEFT JOIN rubric_element_tree ret
ON cet.id = ret.element_tree_id
LEFT JOIN rubric r
ON ret.rubric_id = r.id
)
SELECT
code,
horizont
FROM
road_map
ORDER BY
horizont ASC;
```
Путь от корня до заданного узла (рубрики)
```
-- показать путь от потомка до родительского корневого элемента 'ekskavatory-karernye'
WITH RECURSIVE road_map ( id, element_tree_id, code, horizont ) AS
(
SELECT
cet.id AS id,
cet.element_tree_id AS element_tree_id,
r.code AS code,
0 AS horizont
FROM
element_tree cet
LEFT JOIN rubric_element_tree ret
ON cet.id = ret.element_tree_id
LEFT JOIN rubric r
ON ret.rubric_id = r.id
WHERE r.code = :CHILD
UNION
SELECT
pet.id,
pet.element_tree_id,
r.code,
horizont + 1
FROM
element_tree pet
JOIN road_map c
ON (c.element_tree_id = pet.id)
LEFT JOIN rubric_element_tree ret
ON pet.id = ret.element_tree_id
LEFT JOIN rubric r
ON ret.rubric_id = r.id
)
SELECT
code,
horizont
FROM
road_map
ORDER BY
horizont DESC;
```
Показать все Значения всех Характеристик одной Сущности
```
-- Значения Характеристик одной Сущности 'doneks-eo-4112a-1'
SELECT
i.title,
p.title,
dm.digital::TEXT
FROM
rubric_item ri
JOIN item i
ON ri.item_id = i.id
JOIN item_content ic
ON i.id = ic.item_id
JOIN content c
ON ic.content_id = c.id
JOIN digital_matter dm
ON c.id = dm.content_id
JOIN rubric_property rp
ON ri.rubric_id = rp.rubric_id
JOIN property p
ON c.property_id = p.id
AND p.id = rp.property_id
WHERE
i.code = :CODE
UNION
SELECT
i.title,
p.title,
sm.string::TEXT
FROM
rubric_item ri
JOIN item i
ON ri.item_id = i.id
JOIN item_content ic
ON i.id = ic.item_id
JOIN content c
ON ic.content_id = c.id
JOIN string_matter sm
ON c.id = sm.content_id
JOIN rubric_property rp
ON ri.rubric_id = rp.rubric_id
JOIN property p
ON c.property_id = p.id
AND p.id = rp.property_id
WHERE
i.code = :CODE;
``` | https://habr.com/ru/post/323498/ | null | ru | null |
# Rust — сохраняем безразмерные типы в статической памяти
Не так давно в качестве хобби я решил погрузиться в изучение embedded разработки на Rust и через какое-то время мне захотелось сделать себе логгер, который бы просто писал логи через UART, но при этом не знал какая конкретно реализация используется. Вот тут я быстро осознал, именно в этом конкретном случае я не могу полагаться на статический полиморфизм и мономорфизацию, ведь компилятор не знает сколько нужно памяти выделять под конкретную реализацию. Фактически это означает, что нам нужно как-то уметь сохранять в памяти типы, размер которых неизвестен на этапе компиляции. Такой способностью обладает тип `Box`, но он использует для этого динамическое выделение памяти из кучи. В итоге возникла идея написать свой аналог данного типа, но хранящий объект в предоставленном пользователем буфере, а не в глобальной куче.
А почему бы просто не взять какой-нибудь [linked\_list\_allocator](https://crates.io/crates/linked_list_allocator) от Фила, дать ему пару килобайт памяти и воспользоваться обычным `Box` типом, или даже взять какой-нибудь простейший bump аллокатор, ведь мы хотим использовать его лишь для того, чтобы создать несколько глобальных объектов, но есть множество сценариев, когда куча не используется принципиально? Это и дополнительная зависимость от целого `alloc` крейта и дополнительные риски, что использование кучи выйдет за рамки строго детерминированных сценариев, что будет приводить к трудноуловимым ошибкам.
С другой стороны, мы можем просто принимать `&'static dyn Trait` и таким образом переложить заботу о том, как получить такую ссылку, на конечного пользователя, но чтобы обеспечить потом доступ к этой ссылке, нам необходимо использовать примитивы синхронизации или же воспользоваться unsafe кодом, с другой стороны, конечный пользователь тоже должен воспользоваться ими, чтобы создать такую ссылку. В конечном итоге у нас получается или двойная работа или unsafe в публичном API, что довольно плохо. Да и в целом, Box обладает гораздо более широкой областью применения, например, его можно использовать для организации очереди задач в очередном futures executor.
### Что же такое безразмерные типы?
Хочу немного напомнить о том, что такое типы динамического размера (DST) и чем они отличаются от обычных. Большинство типов имеют фиксированный размер, известный на этапе компиляции, такие типы компилятор помечает трейтом `Sized`, но есть типы, размер которых в памяти неизвестен на этапе компиляции, поэтому компилятор не может размещать их в статической памяти или на стэке по значению, такие типы еще называют безразмерными.
Тут очень важно понимать, что для каждого конкретного типа компилятор **точно** знает внутреннее устройство его безразмерного аналога, проблема в том, что один и тот же безразмерный `dyn Display` может быть получен из самых разнообразных конкретных типов, чем и обеспечивается динамический полиморфизм. И именно поэтому можно приводить к безразмерным типам лишь ссылки и указатели, уж размер указателя компилятору всегда известен.
Ссылки и указатели в Rust это не всегда просто адреса в памяти, в случае с DST типами, помимо адреса хранится еще и объект с метаданными указателя, но гораздо проще это все осознать, если просто взглянуть на код стандартной библиотеки.
```
#[repr(C)]
pub(crate) union PtrRepr {
pub(crate) const\_ptr: \*const T,
pub(crate) mut\_ptr: \*mut T,
pub(crate) components: PtrComponents,
}
#[repr(C)]
pub(crate) struct PtrComponents {
pub(crate) data\_address: \*const (),
pub(crate) metadata: ::Metadata,
}
```
Отсюда видно, что указатель представляет из себя адрес на данные и, в некоторых случаях, какие-то байты с метаданными после. Получается, что размер указателя, в общем случае, может быть вообще любым, вот так, для примера, выглядят метаданные для любого `dyn Trait` - это просто статическая ссылка на таблицу виртуальных функций.
```
pub struct DynMetadata {
vtable\_ptr: &'static VTable,
phantom: crate::marker::PhantomData,
}
/// The common prefix of all vtables. It is followed by function pointers for trait methods.
///
/// Private implementation detail of DynMetadata::size\_of etc.
#[repr(C)]
struct VTable {
drop\_in\_place: fn(\*mut ()),
size\_of: usize,
align\_of: usize,
}
```
Таким образом, в текущей реализации, размер `&dyn Display` на x86\_64 составляет 16 байт, а когда мы пишем такой вот код:
```
let a: u64 = 42;
let dyn_a: &dyn Display = &a
```
Компилятор генерирует объект `VTable` и сохраняет его где-то в статической памяти, а обычную ссылку заменяет на широкую, содержащую кроме адреса еще и указатель на таблицу виртуальных функций. Ссылка на таблицу виртуальных функций статическая и не зависит от места расположения значения, таким образом, для того, чтобы создать желаемый `Box` из искомого значения `a`, нам необходимо извлечь метаданные из ссылки на `dyn_a` и все это вместе скопировать в заранее приготовленный для этого буфер. Чтобы все это сделать, нам необходимо использовать nightly features: [unsize](https://doc.rust-lang.org/std/marker/trait.Unsize.html) и [ptr\_metadata](https://doc.rust-lang.org/std/ptr/fn.metadata.html).
Для получения `&dyn T` из `&Value` используется специальный маркерный трейт `Unsize`, который выражает отношение между `Sized` типом и его безразмерным альтер-эго. То есть, `T` это `Unsize` в том случае, если `T` реализует `Trait`.
А чтобы работать с метаданными указателя используется функция `core::ptr::metadata` и типаж `Pointee`, который связывает тип указателя и тип его метаданных, в случае с безразмерными типами метаданные имеют тип `DynMetadata`, где `T` это искомый безразмерный тип.
```
#[inline]
fn meta_offset_layout(value: &Value) -> (DynMetadata, Layout, usize)
where
T: ?Sized + Pointee>,
Value: Unsize + ?Sized,
{
// Get dynamic metadata for the given value.
let meta = ptr::metadata(value as &T);
// Compute memory layout to store the value + its metadata.
let meta\_layout = Layout::for\_value(&meta);
let value\_layout = Layout::for\_value(value);
let (layout, offset) = meta\_layout.extend(value\_layout).unwrap();
(meta, layout, offset)
}
```
Помимо извлечения метаданных, данная функция еще и вычисляет размещение в памяти для метаданных и смещение по которому следует сохранять значение, но об этом мы подробнее еще поговорим.
*Обратите внимание, что мы берем*`Layout` от ссылки на метаданные, а не `DynMetadata::layout`, последний описывает размещение `VTable`, но нас интересует размещение самого `DynMetadata`, будьте внимательны!
### Пишем свой Box
Вот, теперь у нас есть все необходимое, чтобы написать наш `Box`, его код довольно простой:
Конструктор, который копирует данные и метаданные в предоставленный буфер, используя довольно удобное API указателя.
```
impl Box
where
T: ?Sized + Pointee>,
M: AsRef<[u8]> + AsMut<[u8]>,
{
pub fn new\_in\_buf(mut mem: M, value: Value) -> Self
where
Value: Unsize,
{
let (meta, layout, offset) = meta\_offset\_layout(&value);
// Check that the provided buffer has sufficient capacity to store the given value.
assert!(layout.size() > 0);
assert!(layout.size() <= mem.as\_ref().len());
unsafe {
let ptr = NonNull::new(mem.as\_mut().as\_mut\_ptr()).unwrap();
// Store dynamic metadata at the beginning of the given memory buffer.
ptr.cast::>().as\_ptr().write(meta);
// Store the value in the remainder of the memory buffer.
ptr.cast::()
.as\_ptr()
.add(offset)
.cast::()
.write(value);
Self {
mem,
phantom: PhantomData,
}
}
}
}
```
А вот и код, который собирает байты назад в `&dyn Trait`:
```
#[inline]
fn meta(&self) -> DynMetadata {
unsafe { \*self.mem.as\_ref().as\_ptr().cast() }
}
#[inline]
fn layout\_meta(&self) -> (Layout, usize, DynMetadata) {
let meta = self.meta();
let (layout, offset) = Layout::for\_value(&meta).extend(meta.layout()).unwrap();
(layout, offset, meta)
}
#[inline]
fn value\_ptr(&self) -> \*const T {
let (\_, offset, meta) = self.layout\_meta();
unsafe {
let ptr = self.mem.as\_ref().as\_ptr().add(offset).cast::<()>();
ptr::from\_raw\_parts(ptr, meta)
}
}
#[inline]
fn value\_mut\_ptr(&mut self) -> \*mut T {
let (\_, offset, meta) = self.layout\_meta();
unsafe {
let ptr = self.mem.as\_mut().as\_mut\_ptr().add(offset).cast::<()>();
ptr::from\_raw\_parts\_mut(ptr, meta)
}
}
```
Дальше смело можно добавить реализацию `Deref` и `DerefMut`, в конце концов, в данном случае это как раз тот самый случай, для которых эти самые типы и были созданы.
```
impl Deref for Box
where
T: ?Sized + Pointee>,
M: AsRef<[u8]> + AsMut<[u8]>,
{
type Target = T;
#[inline]
fn deref(&self) -> &T {
self.as\_ref()
}
}
impl DerefMut for Box
where
T: ?Sized + Pointee>,
M: AsRef<[u8]> + AsMut<[u8]>,
{
#[inline]
fn deref\_mut(&mut self) -> &mut T {
self.as\_mut()
}
}
```
```
running 8 tests
test tests::test_box_dyn_fn ... ok
test tests::test_box_nested_dyn_fn ... ok
test tests::test_box_in_provided_memory ... ok
test tests::test_box_trait_object ... ok
test tests::test_box_move ... ok
test tests::test_drop ... ok
test tests::test_layout_of_dyn ... ok
test tests::test_box_insufficient_memory ... ok
```
### Miri
Казалось бы, все замечательно, можно использовать библиотеку в боевом коде... Но, постойте, мы же написали unsafe код, как мы вообще можем быть уверены в том, что нигде не нарушили никакие инварианты? К счастью, существует такой проект, как Miri, который интерпретирует промежуточное представление MIR, генерируемое компилятором rustc, используя специальную виртуальную машину. Таким образом, можно находить очень многие ошибки в unsafe коде, подробнее об этом можно почитать в этой [статье](https://habr.com/en/post/460953/). Давайте попробуем запустить наши тесты используя Miri.
```
cargo miri test
Compiling static-box v0.0.1 (/home/aleksey/Projects/opensource/static-box)
Finished test [unoptimized + debuginfo] target(s) in 0.40s
Running unittests (target/x86_64-unknown-linux-gnu/debug/deps/static_box-e2c02215f3157959)
running 8 tests
test tests::test_box_dyn_fn ... error: Undefined Behavior: accessing memory with alignment 1, but alignment 8 is required
--> /home/aleksey/.rustup/toolchains/nightly-2021-04-25-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/ptr/mod.rs:886:9
|
886 | copy_nonoverlapping(&src as *const T, dst, 1);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ accessing memory with alignment 1, but alignment 8 is required
|
= help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
= help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
```
Ага! Вот и нашлась довольно серьезная проблема, которую мы упустили, и которую нам наша x86 архитектура просто взяла и простила - невыровненный доступ к памяти. Напомню, что процессоры при работе с памятью используют машинные слова, размер которых обычно равен размеру указателя, поэтому компиляторы вставляют в типы, которые не кратны размеру машинного слова, дополнительные байты для выравнивания, тоже самое касается и полей структур. В нашем случае, мы просто подряд пишем байты метаданных и значения в буфер, начиная с какого-то адреса, никак ничего не проверяя, поэтому может возникать ситуация, когда адреса полей становятся не кратными машинному слову.
Чтобы починить проблему логичнее всего рассчитать смещение от начала выданного нам буфера, которое удовлетворит требования к выравниванию, для этого мы будем брать указатель на выданный нам буфер, причем в том случае, когда мы передаем его по значению важно, чтобы он был размещен как поле структуры, в противном случае мы получим указатель на буфер, рассчитаем смещение для него, а позже этот буфер может быть перемещен в другую область памяти и наше рассчитанное смещение перестанет быть верным.
```
// Construct a box to move the specified memory into the necessary location.
// SAFETY: This code relies on the fact that this method will be inlined.
let mut new_box = Self {
align_offset: 0,
mem,
phantom: PhantomData,
};
let raw_ptr = new_box.mem.as_mut().as_mut_ptr();
// Compute the offset that needs to be applied to the pointer in order to make
// it aligned correctly.
new_box.align_offset = raw_ptr.align_offset(layout.align());
```
Вот собственно и все, после этого Miri больше не показывает ошибок выравнивания.
```
cargo miri test
Compiling static-box v0.1.0 (/home/aleksey/Projects/opensource/static-box)
Finished test [unoptimized + debuginfo] target(s) in 0.30s
Running unittests (target/x86_64-unknown-linux-gnu/debug/deps/static_box-ce23f69c165cf930)
running 11 tests
test tests::test_box_dyn_fn ... ok
test tests::test_box_in_provided_memory ... ok
test tests::test_box_in_static_mem ... ok
test tests::test_box_in_unaligned_memory ... ok
test tests::test_box_insufficient_memory ... ok
test tests::test_box_move ... ok
test tests::test_box_nested_dyn_fn ... ok
test tests::test_box_trait_object ... ok
test tests::test_drop ... ok
test tests::test_layout_of_dyn_split_at_mut ... ok
test tests::test_layout_of_dyn_vec ... ok
test result: ok. 11 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
Doc-tests static-box
running 2 tests
test src/lib.rs - (line 24) ... ok
test src/lib.rs - (line 48) ... ok
test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.15s
```
Хочу еще сказать несколько слов относительно типа `Layout`, в нем содержится два поля `size`, которое содержит размер памяти в байтах, необходимый для размещения объекта, и `align` - это число (причем всегда степень двойки), которому должен быть кратен указатель на объект данного типа. И таким образом, чтобы починить выравнивание, мы просто вычисляем сколько нам нужно прибавить к адресу начала буфера, чтобы получить адрес кратный `align`. Дополнительно довольно доступно написано про выравнивание у [у Фила](https://os.phil-opp.com/allocator-designs/#address-alignment).
### Заключение
Ура, теперь мы можем писать вот такой вот код!
```
use static_box::Box;
struct Uart1Rx {
// Implementation details...
}
impl SerialWrite for Uart1Rx {
fn write(&mut self, _byte: u8) {
// Implementation details
}
}
let rx = Uart1Rx { /* ... */ };
SOME_GLOBAL_WRITER.init_once(move || Box::::new(rx));
// A bit of code later.
SOME\_GLOBAL\_WRITER.lock().unwrap().write\_str("Hello world!");
```
Итак, мы при помощи unsafe и некоторого количества nightly фич смогли написать тип, позволяющий размещать полиморфные объекты на стеке или в статической памяти без использования кучи, что может быть полезным во многих случаях. Хотя, конечно, каждый раз при получении ссылки на объект приходится дополнительно вычислять адрес метаданных и значения, но мы не можем просто так взять и сохранить эти адреса как поля структуры, в этом случае она станет самоссылающиеся, что довольно неприятно в Rust контексте, это не работает с семантикой перемещения. В целом, если воспользоваться pin API, и сделать нашBox неперемещаемым, то можно будет позволить себе эту оптимизацию, а заодно и обеспечить возможность работать с любыми Future типами.
Хочу еще сказать напоследок, что не стоит бояться писать низкоуровневый unsafe код, но стоит 10 раз подумать над его корректностью и обязательно использовать Miri в [CI](https://github.com/alekseysidorov/static-box/blob/master/.github/workflows/ci.yml#L58) тестах, он отлавливает довольно много ошибок, а разработка низкоуровневого кода требует очень большой внимательности к деталям всевозможным граничным случаям. В конечном счете, именно знания того, как в реальности реализована та или иная языковая абстракция, позволяет перестать воспринимать её как черную магию. Часто все намного проще и очевиднее, чем кажется, стоит просто копнуть чуть поглубже.
А еще важно иногда выходить за рамки stable Rust, чтобы быть в курсе, куда же язык дальше развивается и тем самым расширять свой кругозор.
[Ссылка на крейт](https://crates.io/crates/static-box) | https://habr.com/ru/post/561012/ | null | ru | null |
# Композиция компонентов в React JS
По прошествии 2-х лет работы с React у меня накопилось немного опыта, которым хотелось бы поделиться. Если вы только начали осваивать React, то надеюсь эта статья поможет выбрать правильный путь развития проекта из 1-5 форм до огромного набора компонентов и при этом не запутаться.
Если вы уже профи, то, возможно, вспомните свои костыли. А возможно предложите более качественные решения описанных проблем.
В этой статье речь пойдет о моем личном мнении как организовать композицию компонентов.
Начнем с малого
---------------
Рассмотрим некоторую абстрактную форму. Будем подразумевать что полей в форме много (порядка 10-15 штук), но, чтобы глаза не разбегались, в качестве примера возьмем форму с 4-мя полями.
На вход в компонент прилетает многоуровневый объект такого вида:
```
const unit = {
name: 'unit1',
color: 'red',
size: {
width: 2,
height: 4,
},
}
```
Неопытный разработчик (как я в первый месяц работы с реактом) сделает все это в одном компоненте где в стейте будут храниться значения инпутов:
```
const Component = ({ values, onSave, onCancel }) => {
const [ state, setState ] = useState({});
useEffect(() => {
setState(values);
}, [ values, setState ]);
return
setState((state) => ({...state, name: value }))
}/>
setState((state) => ({...state, color: value }))
}/>
setState((state) => ({...state, size: { width: value } }))
}/>
setState((state) => ({...state, size: { height: value } }))
}/>
onSave(state)}>Save
onCancel()}>Cancel
}
```
Увидев, как быстро разработчик справился, заказчик предложит сделать на основе этой формы еще одну, но чтобы было без блока “size”.
Вариантов видится 2 (и оба не правильные):
1. Можно скопировать первый компонент и добавить туда то, чего не хватает или убрать лишнее. Такое обычно делают когда за основу берут не свой компонент и боятся что-то в нем сломать
2. Добавить в параметры дополнительные настройки компонента.
Если после реализации 3-5 форм проект окончен, то разработчику повезло.
Но обычно это только начало, и количество разных формочек только растет.
Потом требуется похожая, но без блока “color”.
Потом похожая, но с новым блоком “description”.
Потом какие-то блоки сделать только для чтения.
Потом похожую форму надо вставить в другую форму — вообще печаль, что из этого иногда получается.
Новые формы путем копирования
-----------------------------
Разработчик, выбравший подход с копированием, конечно быстро справится с реализацией новых форм. Пока их будет меньше 10. Но потом настроение будет постепенно падать.
Особенно когда случается редизайн. Отступы там между блоками формы подправить «немного», компонент выбора цвета поменять. Ведь все сразу предусмотреть нельзя и многие дизайнерские решения придется пересматривать после их воплощения в жизнь.
Тут важно обратить внимание на частое упоминание “похожую форму”. Ведь продукт один и все формочки должны быть похожие. В итоге приходится заниматься очень неинтересной и рутинной работой по переделке одного и того же в каждой форме, и тестировщикам кстати тоже надо будет каждую форму перепроверить.
> В общем, вы поняли. Не копируйте похожие компоненты.
Новые формы путем обобщения
---------------------------
Если разработчик выбрал второй путь, то конечно же тут он на коне — подумаете вы. У него всего несколько компонентов которыми можно нарисовать несколько десятков форм. Подправить по всему проекту отступ или поменять компонент “color” — это подправить две строчки в коде и тестировщику надо будет перепроверить всего в парочке мест.
Но на самом деле этот путь породил очень сложный в поддержке компонент.
Пользоваться им сложно, т.к. множество параметров, некоторые называются почти одинаково, чтобы понять за что отвечает каждый параметр надо лезть во внутренности.
Поддерживать тоже сложно. Как правило внутри сложные переплетения условий и добавление нового условия может сломать все остальное. Подправив компонент для вывода одной формы могут сломаться остальные.
> В общем, вы поняли. Не делайте компоненту много свойств.
Чтобы решить проблемы второго варианта разработчики начинают что? Правильно. Как настоящие разработчики они начинают разрабатывать нечто, что упрощает настройку сложного компонента.
Например делают параметр fields (ну как columns в react-table). И туда передают параметры полей: какое поле видимо, какое не редактируемое, имя поля.
Вызов компонента превращается в такой:
```
const FIELDS = {
name: { visible: true, disabled: true, label: 'Model', type: 'input' },
color: { visible: true, disabled: false, type: 'dropdown' },
size: { visible: true },
height: { visible: true },
width: { disabled: false },
}
```
В итоге разработчик горд собой. Он обобщил настройки всех полей и оптимизировал внутренний код компонента: теперь для каждого поля вызывается одна функция, которая преобразует конфигурацию в пропсы соответствующего компонента. Даже по имени типа рендерит разный компонент. Еще немного и получится свой фреймворк.
Круто? Уж слишком.
Надеюсь это не превратится в такое:
```
const FIELDS = {
name: getInputConfig({ visible: true, disabled: true, label: 'Model'}),
color: getDropDownConfig({ visible: true, disabled: false}),
size: getBlockConfig({ visible: true }),
height: getInputNumberConfig({ visible: true }),
width: getInputNumberConfig({ disabled: false }),
}
```
> В общем, вы поняли. Не изобретайте велосипед.
Новые формы путем композиции компонентов и вложенных форм
---------------------------------------------------------
Давайте вспомним на чем мы все таки пишем. У нас уже есть библиотека react. Не надо выдумывать никаких новых конструкций. Конфигурация компонентов в реакте описывается с помощью разметки JSX
```
const Form1 = ({ values }) => {
return
}
```
Кажется мы вернулись к первому варианту с копированием. Но на самом деле нет. Это композиция которая избавляет от проблем первых двух подходов.
Есть набор кирпичиков из которых собирается форма. Каждый кирпичик отвечает за что-то свое. Какой-то за лайоут и внешний вид, какой-то за ввод данных.
Если нужно изменить отступы во всем проекте, то это достаточно сделать в компоненте FormField. Если нужно поменять работу выпадающего списка, то это делается в одном месте в компоненте DropDown.
Если нужна похожая форма но например чтобы не было поля “color”, то выносим общие блоки в отдельные кирпичики и собираем другую форму.
Выносим блок Size в отдельный компонент:
```
const Size = () =>
```
Делаем форму с выбором цвета:
```
const Form1 = () =>
```
Делаем похожую форму, но без выбора цвета:
```
const Form2 = () =>
```
Самое главное, человеку, которому достанется такой код, не нужно разбираться с выдуманными конфигами предшественника. Все написано на знакомом любому react-разработчику JSX с подсказками параметров каждого компонента.
> В общем, вы поняли. Используйте JSX и композицию из компонентов.
Несколько слов по поводу State
------------------------------
Теперь обратим внимание на стейт. Точнее на его отсутствие. Как только мы добавим стейт, мы замкнем поток данных и переиспользовать компонента станет сложнее. Все кирпичики должны быть stateless (т.е. без стейта). И только на самом верхнем уровне собранную из кирпичиков форму можно подключать к стейту. Если форма сложная, то тут уже есть смысл разделить ее на несколько контейнеров и подконектить каждую часть к redux.
Не ленитесь делать отдельно stateless компонент формы. Тогда у вас будет возможность использовать его как часть другой формы, либо сделать на его основе statefull форму либо контейнер для подключения к redux.
Конечно в кирпичиках могут быть стейты для хранения внутреннего состояния не связанного с общим потоком данных. Например во внутреннем стейте DropDown (выпадающий список) удобно хранить признак раскрыт он или нет.
> В общем, вы поняли. Разделяйте компоненты на Stateless и Statefull.
Итого
-----
Как не удивительно, я периодически сталкиваюсь со всеми описанными в статье ошибками и проблемами которые из них вытекают. Надеюсь Вы не будете их повторять и тогда поддержка вашего кода станет намного проще.
Повторю основные тезисы:
1. Не копируйте похожие компоненты. Используйте принцип DRY.
2. Не делайте компоненты с большим количеством свойств и функционала. Каждый компонент должен отвечать за что-то свое (Single Responsibility из SOLID)
3. Разделяйте компоненты на Stateless и Statefull.
4. Не изобретайте свои конструкции. Используйте JSX и композицию из своих компонентов.
P.S.:
По сути это была подготовительная статья, чтобы читатель смог лучше понять мои дальнейшие мысли. Ведь остался не раскрыт основной вопрос. Как передавать данные от одного кирпичика другому? Про это читайте в [следующей статье](https://habr.com/ru/post/527372/). | https://habr.com/ru/post/524276/ | null | ru | null |
# О разворачивании строк в Java
Прочитав хабротопик [О разворачивании строк в .Net/C# и не только](http://habrahabr.ru/blogs/net/58333/), меня заинтересовало а как обстоят дела с той же проблемой в Java.
Не имея под руками машины с медленной памятью пришлось ограничится тестами на одной.
Времени проводить такое количество тестов как автор произвел в оригинале нету поэтому ограничусь проверкой нескольких мыслей однако тенденция в Java соблюдается — StringBuilder самый медленный результат.
Параметры машины: Intel® Core(TM) 2 Duo CPU E4600 @2.40GHz; 4GB Ram DDR2 (частоту к сожалению не скажу)
Своп напрочь отключён ОС — WinXP SP2.
Результаты в попугаях:
| | | | | |
| --- | --- | --- | --- | --- |
| **Java version** | **StringBuilder To Array** | **StringBuilder CharAt** | **Array To Array** | **Reflection To Array** |
| Java HotSpot(TM) Client VM (build 1.5.0\_14-b03, mixed mode) | 1667 | 1914 | 923 | 692 |
| Java HotSpot(TM) Server VM (build 1.5.0\_14-b03, mixed mode) | 1805 | 1374 | 1064 | 717 |
| Java HotSpot(TM) Client VM (build 10.0-b23, mixed mode, sharing) | 1458 | 1309 | 756 | 517 |
Код тестов:
> `Copy Source | Copy HTML1. private String testString = "";
> 2.
> 3. protected void setUp() throws Exception {
> 4. int charCount = 50 \* 1024 \* 1024;
> 5. Random rnd = new Random();
> 6. byte chars[] = new byte[charCount \* 2];
> 7. rnd.nextBytes(chars);
> 8. testString = new String(chars);
> 9. }
> 10.
> 11. public long \_testStringBuilderToArray() {
> 12. long start = System.currentTimeMillis();
> 13. StringBuilder builder = new StringBuilder(testString.length());
> 14. char data[] = testString.toCharArray();
> 15. int len = testString.length();
> 16. for (int i = len - 1; i >= 0 ; i--) {
> 17. builder.append(data[i]);
> 18. }
> 19. String reverse = builder.toString();
> 20. if ((reverse.charAt(2) == 'd') && (len == 1)) {
> 21. //To avoid compiler optimization
> 22. return 0;
> 23. }
> 24. long end = System.currentTimeMillis();
> 25. return (end - start);
> 26. }
> 27.
> 28. public long \_testStringBuilderCharAt() {
> 29. long start = System.currentTimeMillis();
> 30. StringBuilder builder = new StringBuilder(testString.length());
> 31. int len = testString.length();
> 32. for (int i = len - 1; i >= 0 ; i--) {
> 33. builder.append(testString.charAt(i));
> 34. }
> 35. String reverse = builder.toString();
> 36. if ((reverse.charAt(2) == 'd') && (len == 1)) {
> 37. //To avoid compiler optimization
> 38. return 0;
> 39. }
> 40. long end = System.currentTimeMillis();
> 41. return (end - start);
> 42. }
> 43.
> 44. public long \_testArrayToArray() {
> 45. long start = System.currentTimeMillis();
> 46. char reverseBytes[] = new char[testString.length()];
> 47. char data[] = testString.toCharArray();
> 48. int len = testString.length();
> 49. for (int i = len - 1; i >= 0 ; i--) {
> 50. reverseBytes[len - i - 1] = data[i];
> 51. }
> 52. String reverse = new String(reverseBytes);
> 53. if ((reverse.charAt(2) == 'd') && (len == 1)) {
> 54. //To avoid compiler optimization
> 55. return 0;
> 56. }
> 57. long end = System.currentTimeMillis();
> 58. return (end - start);
> 59. }
> 60.
> 61. public long \_testReflectionToArray() throws Exception {
> 62. long start = System.currentTimeMillis();
> 63.
> 64. Field stringClassValueField = String.class.getDeclaredField("value");
> 65. stringClassValueField.setAccessible(true);
> 66. char reverseBytes[] = new char[testString.length()];
> 67. char data[] = (char[])stringClassValueField.get(testString);
> 68. int len = testString.length();
> 69. for (int i = len - 1; i >= 0 ; i--) {
> 70. reverseBytes[len - i - 1] = data[i];
> 71. }
> 72. String reverse = new String(reverseBytes);
> 73. if ((reverse.charAt(2) == 'd') && (len == 1)) {
> 74. //To avoid compiler optimization
> 75. return 0;
> 76. }
> 77. long end = System.currentTimeMillis();
> 78. return (end - start);
> 79. }
> 80.
> 81.
> 82. public void testRunner() throws Exception {
> 83. long value = 0;
> 84. int testCount = 20;
> 85.
> 86. //StringBuilderToArray
> 87. value = 0;
> 88. for (int i = 0; i < testCount; i++) {
> 89. value += \_testStringBuilderToArray();
> 90. }
> 91. System.out.println("\_testStringBuilderToArray - " + (value / testCount));
> 92.
> 93. //\_testStringBuilderCharAt
> 94. value = 0;
> 95. for (int i = 0; i < testCount; i++) {
> 96. value += \_testStringBuilderCharAt();
> 97. }
> 98. System.out.println("\_testStringBuilderCharAt - " + (value / testCount));
> 99.
> 100. //\_testArrayToArray
> 101. value = 0;
> 102. for (int i = 0; i < testCount; i++) {
> 103. value += \_testArrayToArray();
> 104. }
> 105. System.out.println("\_testArrayToArray - " + (value / testCount));
> 106.
> 107. //\_testReflectionToArray
> 108. value = 0;
> 109. for (int i = 0; i < testCount; i++) {
> 110. value += \_testReflectionToArray();
> 111. }
> 112. System.out.println("\_testReflectionToArray - " + (value / testCount));
> 113. }` | https://habr.com/ru/post/58382/ | null | ru | null |
# Динамические промо в Magento
Disclaimer: эта статья не предназначена для «зубров». Ее основная аудитория – начинающие web-мастеры, у которых появляется желание сделать все «по-взрослому», но не всегда хватает идей, как именно это сделать.
Итак, началось все с того, что мне захотелось как-то оживить первую страницу своего магазина, который я проектировал, а кроме того, получить нормальный инструмент для представления важных промо-акций, товаров и т.п.
В «больших» магазинах вроде <http://www.lookfantastic.com/> сделан красивый блок, в котором эти самые динамические промо и представлены.
Конечно, в первую очередь я ринулся рыть [MagentoConnect](http://www.magentocommerce.com/magento-connect) на предмет готовых модулей, однако нашел только [Teaserbox](http://www.magentocommerce.com/extension/1778/teaserbox), который меня абсолютно не устроил: во-первых, флеш, во-вторых, рекламировать можно только товары (переход возможен только на описание товара), и в-третьих, невнятные кнопки, на которых, к тому же, надписи на русском языке не отображались.
Как раз в это время мне на глаза попалось сообщение о том, что появился бесплатный модуль для Magento от Mxperts, который позволял подключать [jQuery Tools](http://flowplayer.org/tools/). До этого с jQuery Tools я не сталкивался, поэтому полез смотреть, что же это такое. Сказать, что меня очаровали возможности библиотеки – значит ничего не сказать. Конечно, мысль сразу же заработала в направлении реализации моей идеи с помощью нового инструмента.
Писать и отлаживать полноценный модуль мне было лень, да и времени нет, поэтому я сделал все на скорую руку, однако решение вполне рабочее и при редкой смене промо-акций вполне имеет право на жизнь.
Итак. Предполагаем, что у вас уже установлен и настроен магазин на базе Magento. Названия разделов в админке я буду давать на русском языке, блок локализации установлен от niro (см. [русский форум](http://www.magentocommerce.com/boards/viewforum/31/) на [www.magentocommerce.com](http://www.magentocommerce.com)).
Для начала необходимо установить через MagentoConnect два модуля: [Mxperts jQuery](http://www.magentocommerce.com/extension/1619/mxperts--jquery-base) и [Mxperts jQuery-Tools](http://www.magentocommerce.com/extension/1662/mxperts--jquery-tools-and-flowplayer). Сразу предупреждаю: в той версии, что сейчас лежит на MagentoConnect (1.2.5 от 09.10.2009), есть ошибка. Необходимо [скачать](http://flowplayer.org/tools/download.html) с оригинального сайта jQuery Tools плагин circular (файлы tools.scrollable.circular-0.5.1.js и tools.scrollable.circular-0.5.1.min.js) и заменить ими те версии, которые окажутся после установки модулей в директории /js/jquery/jquerytools/.
На сайте jQuery Tools представлена весьма подробная и очень понятная [документация](http://flowplayer.org/tools/scrollable.html), поэтому самые основы я упоминать не буду. Суть в том, что нам нужно создать управляющую структуру и блоки, которые будут отвечать непосредственно за «страницы» промо.
Для этого в админке создаем статический CMS-блок, который будет отвечать за обвязку (CMS -> Статичные блоки, жмем кнопку «Добавить новый блок»):
> `<div id="promobox">-- jQuery tools promo box: tabs with autoscroll -->
>
> <ul id="flowtabs">
>
> <li><a id="t1" href="#"><span>Заголовок 1span><br />Привет, здесь 1!a>li>
>
> <li><a id="t2" href="#">="#"><span>Заголовок 2span><br />Привет, а здесь уже 2!a>li>
>
> <li><a id="t3" href="#"><span>Заголовок 3span><br />И, наконец, 3!a>li>
>
> ul>
>
>
>
> <div id="flowpanes">-- wrapper for scrollable items -->
>
> <div class="items">
>
> {{block type="cms/block" block\_id="home-page-promo-01"}}
>
> {{block type="cms/block" block\_id="home-page-promo-02"}}
>
> {{block type="cms/block" block\_id="home-page-promo-03"}}
>
> div>
>
> div>
>
> div>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Обзываем блок так, чтобы было удобно, идентификатор ставим, например, home-page-promo, устанавливаем статус Включено и сохраняем. Как видно из кода, здесь описываются у нас закладки (ярлыки) системы навигации по страницам промо и обвязка страниц.
Далее создаем страницы промо (как можно догадаться из текста, идентификаторы будут home-page-promo-XX).
home-page-promo-01:
> `<div>
>
> <div style="background: #F0F1F2; color:black">
>
> <h2>Forget about scrollbarsh2>
>
>
>
> <p>The purpose of this library is to make it extremely easy to add
>
> scrolling functionality to a website. Whenever you wish to scroll HTML
>
> elements in a visually-appealing manner, this is the only library you
>
> need. The main design goals of this library are to provide <em>visual
>
> customizationem> functionality and <em>programmabilityem>. Here are some
>
> example scenarios where you would benefit from using the library:p>
>
>
>
> <ul>
>
> <li>Home pages, like this one right hereli>
>
> <li>Product cataloguesli>
>
> <li>News tickersli>
>
> <li>Custom select boxes in formsli>
>
> <li>Image galleriesli>
>
> <li>Video playlistsli>
>
> <li>All kinds of navigational systemsli>
>
> ul>
>
>
>
> <p>The first version of the library was released on January 3, 2008.
>
> Since then, this tool has come a long way and it is now a stable and
>
> mature product.p>
>
> div>
>
> div>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
home-page-promo-02:
> `<div>
>
> <div style="background: #F0F1F2; color:black">
>
> <h2>Extendable architectureh2>
>
>
>
> <p>Just like other tools this tool can be extended with plugins.
>
> Currently available plugins include:p>
>
>
>
> <ul>
>
> <li><a href="http://flowplayer.org/tools/scrollable.html#circular">circulara>
>
> makes an infinite loop from the Scrollable items so they
>
> continue cycling back to the beginning once the last item is reached.li>
>
> <li><a
>
> href="http://flowplayer.org/tools/scrollable.html#autoscroll">autoscrolla>
>
> makes the scrolling behaviour automatic and is highly
>
> configurable.li>
>
> <li><a
>
> href="http://flowplayer.org/tools/scrollable.html#navigator">navigatora>
>
> provides navigation buttons for switching between pages in
>
> Scrollable.li>
>
> <li><a
>
> href="http://flowplayer.org/tools/scrollable.html#mousewheel">mousewheela>
>
> enables mousewheel support for Scrollable.li>
>
> ul>
>
>
>
>
>
> <p>You can also write <a
>
> href="http://flowplayer.org/tools/using.html#plugins">your own
>
> pluginsa>. Another way to alter the default behaviour is the ability to
>
> make your <a
>
> href="http://flowplayer.org/tools/demos/scrollable/easing.html">own
>
> animation effectsa>. There is lots of room for experimentation!p>
>
> div>
>
> div>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
home-page-promo-03:
> `<div>
>
> <div style="”background: #F0F1F2; color:black">
>
> <h2>Rich yet simpleh2>
>
>
>
> <ul style="font-size: 12px">
>
> <li>Horizontal and vertical scrolling.li>
>
> <li>Scrolling using navigational buttons, API calls, keyboard
>
> arrow keys, and the mouse scroll wheel.li>
>
> <li>The number of items scrolled at once is customizable.li>
>
> <li>The navigational buttons are setup without a single line of
>
> JavaScript.li>
>
> <li>Tabbed navigation like this one can be setup without any
>
> programming.li>
>
> <li>Programmatic actions are available, such as: <samp>nextsamp>,
>
> <samp>prevsamp>, <samp>nextPagesamp>, <samp>prevPagesamp>, <samp>seekTosamp>,
>
> <samp>beginsamp>, and <samp>endsamp>.li>
>
> <li>Dynamic addition and removal of Scrollable items.li>
>
> <li>The ability to customize the scrolling experience with <samp>onBeforeSeeksamp>
>
> and <samp>onSeeksamp> listeners.li>
>
> ul>
>
> div>
>
> div>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Внутри каждого элемента можно размещать все, что душе угодно, т.е. любую html-разметку. Например, в живом примере, приведенном в конце статьи, используются просто изображения.
Пришло время заняться css.
Приведу свою таблицу css, при этом в коде есть комментарии:
> `/\* Promobox styles \*/
>
>
>
> #promobox {
>
> width: 560px;
>
> height: 290px;
>
> margin: 0;
>
> padding: 0;
>
> }
>
>
>
> /\* Главный элемент для закладок \*/
>
> #flowtabs {
>
> float: right;
>
> /\* dimensions \*/
>
> width:172px;
>
> height: 0 !important;
>
> margin:0 !important;
>
> padding:0;
>
>
>
> /\* IE6 specific branch (prefixed with "\_") \*/
>
> \_margin-bottom:-2px;
>
> }
>
>
>
> /\* Стиль для закладки \*/
>
> #flowtabs li {
>
> margin:0;
>
> padding:0;
>
> text-indent:0;
>
> list-style-type:none;
>
> }
>
>
>
> /\* Стиль <a>-тега внутри закладки \*/
>
> #flowtabs li a {
>
> background:#fbfaf6;
>
> display:block;
>
> height: 50px;
>
> width: 168px;
>
> padding:18px 0 0 4px;
>
> margin:1px 0 1px 0;
>
> border-left: 5px solid #fbfaf6;
>
>
>
> /\* font decoration \*/
>
> color:#000;
>
> text-align:left;
>
> text-decoration:none;
>
> }
>
>
>
> #flowtabs li a span { text-transform:uppercase; font-weight:bold; }
>
>
>
> /\* Стиль для активной закладки \*/
>
> #flowtabs a.current { cursor:default; border-left: 5px solid #59111e; }
>
>
>
> /\* Страницы промо – стиль контейнера \*/
>
> #flowpanes {
>
> background: #fff;
>
> width:388px;
>
> height:290px;
>
>
>
> /\* from html \*/
>
> position:relative;
>
> overflow:hidden;
>
> }
>
>
>
> /\* Стиль отдельной страницы \*/
>
> #flowpanes div {
>
> display:none;
>
> color:#e65505;
>
> background: #fff;
>
>
>
> padding: 0 10px 0 0;
>
>
>
> /\* from html \*/
>
> float:left;
>
> display:block;
>
> width:378px;
>
> height: 290px;
>
> cursor:pointer;
>
> font-size:14px;
>
> }
>
>
>
> #flowpanes div h2 { color:#e65505; }
>
>
>
> /\* Стиль дополнительного вспомогательного контейнера \*/
>
> #flowpanes .items {
>
> height:20000em; /\* необходимо выделить достаточно пространства для всех – включая невидимые - страниц \*/
>
> position:absolute;
>
> clear:both;
>
> margin:0;
>
> padding:0;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Настало время настроить саму библиотеку jQuery и плагины к ней. Переходим в Система -> Конфигурация -> jQuery.
Выставляем значение Включено в Да. Рекомендую поставить Minified and Gzipped так же в Да (конечно, если Вы не планируете заниматься отладкой, если что-то пойдет не так). Там же есть замечательный пункт, который позволит проверить корректность установки jQuery: jQuery functionality check. Если Вы выставите его в Да, то после сохранения конфигурации и обновления главной страницы магазина в поле для поиска Вы должны увидеть новый текст. Если это произошло – значит, библиотека jQuery установлена и функционирует корректно.
Чтобы не возвращаться к этому пункту, выставьте в блоке jQuery Script1 статус Включено в Да и поместите в jQuery-Code следующий код:
> `// Выбираем #flowplanes и делаем его листаемым. Воспользуемся плагинами circular и navigator
>
> jQuery("#flowpanes").scrollable( {
>
> vertical : true, // укажем, что листать по вертикали
>
> size : 1, // количество одновременно видимых на экране страниц промо
>
> clickable : false
>
> // по клику мыши НЕ перемещаться на следующий элемент, т.к. нам нужно обеспечить корректность перехода в нужном нам направлении
>
> }).circular().mousewheel(400).navigator( {
>
> // для использования в качестве навигатора выберем блок с id #flowtabs
>
> navi : "#flowtabs",
>
>
>
> // укажем, что тег внутри навигатора должен использоваться как рабочий объект (а не непосредственные «дети» контейнера)
>
> naviItem : 'a',
>
>
>
> // укажем название класса "current" для активного тега в навигаторе
>
> activeClass : 'current'
>
>
>
> }).autoscroll( {
>
> // запускаем листание непосредственно при старте плагина
>
> autoplay : true,
>
> interval : 5000
>
> // указываем в миллисекундах интервал листания
>
> });
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Ставим параметр Ready в Да.
Теперь настроим jQuery Tools (Система -> Конфигурация -> jQuery Tools). Т.к. я не использую в настоящий момент никаких других плагинов, кроме Scrollable, то активной осталась сама библиотека и нужный модуль, все остальные я отключил:
Flowplayer Enabled: Нет
jQuery-Tools Enabled: **Да**
Minified and Gzipped: **Да**
Tabs: Нет
Slideshow plugin: Нет
History plugin: Нет
Tooltip: Нет
Slide effect: Нет
Dynamic positioning plugin: Нет
Scrollable: **Да**
Circular plugin: **Да**
Autoscroll plugin: **Да**
Navigator plugin: **Да**
Mousewheel plugin: **Да**
Overlay: Нет
Gallery plugin: Нет
Apple effect: Нет
Expose: Нет
Flashembed: Нет
Сохраняем изменения и в этом разделе.
Теперь остался последний штрих – вывести блок обвязки на главную страницу. Я для этого воспользовался возможностями Magento по изменению в настройках вида страницы. Переходим в CMS -> Управление страницами -> Home Page.
Собственно, в блок Содержание вставляем тег вызова статичного блока:
`{{block type="cms/block" block_id="home-page-promo"}}`
После этого, если Вы нигде не допустили ошибку, на первой странице у Вас должен появиться блок с промо-модулем, который не только совсем не уступает внешне подобному блоку на [lookfantastic.com](http://www.lookfantastic.com), но и, по моему мнению, за счет видимой динамики движения даже превосходит его.
Вживую все вышеприведенное работает на <http://lecompre.ru>. Очень надеюсь, что сервер выдержит (это отдельная головная боль, до нормальной оптимизации руки так и не дошли). Огромная просьба – ресурс недавно запущен в плавание и вполне живой, поэтому не балуйтесь особо, пожалуйста. Ну, и на дизайн сильно внимание не обращайте: нет пока денег на дизайнера.
На любые вопросы с удовольствием отвечу.
\_\_\_\_\_\_\_\_\_
Текст подготовлен в [ХабраРедакторе](http://www.bankinform.ru/HabraEditor) | https://habr.com/ru/post/76743/ | null | ru | null |
# Прочие варианты использования оператора else
Всем нам хорошо известен способ использования ключевого слова else совместно с if:
```
if x > 0:
print 'positive'
elif x < 0:
print 'negative'
else:
print 'zero'
```
Однако в Python’е существует и несколько других, неизвестных большинству программистов, применений else.
#### for… else
Бьюсь об заклад, что вам неизвестно, что else можно ставить сразу после окончания цикла for! Для чего, спросите вы? Когда элементы перебираемой последовательности будут исчерпаны, управление перейдет коду, находящемуся в блоке else. «А когда эти элементы не будут исчерпаны?» — когда вы выйдете из цикла досрочно по условию break.
Использование else в данном случае может выглядеть неразумным, так как else не совсем верно описывает характер происходящего, однако этот синтаксический сахар может быть полезным тогда, когда у вас в цикле имеется оператор break, и вам необходимо знать, переходило ли к нему управление. Допустим, у нас есть компьютер и список людей, и мы хотим, чтобы каждый из них воспользовался компьютером (до тех пор, пока один из них его не сломает). В конце цикла мы хотим узнать, был ли наш компьютер сломан. Обычно, мы записываем это таким образом:
```
broken = False
for person in people:
person.use(computer)
if computer.is_broken:
broken = True
break
if not broken:
print 'The computer is fine!'
```
С использованием for..else мы можем привести этот код к более удобочитаемой форме:
```
for person in people:
person.use(computer)
if computer.is_broken:
break
else:
print 'The computer is fine!'
```
#### while… else
Семантика здесь абсолютно та же, что и в предыдущем случае. Тело цикла while выполняется до тех пор, пока верно некое условие — это вы и так уже знаете. Если в какой-то момент условие перестало быть верным, выполнение переходит в ветвь else. Оператор break, если условие дойдет до него, прервет выполнение всего цикла while..else, таким образом, ветвь else выполняться не будет. В двух словах: логика поведения while..else точно такая же, как и у for..else.
```
while usage < 10 and person.want_to_play:
person.use(computer)
if computer.broken:
break
else:
print 'The computer is fine!'
```
#### try… except… else
Есть некоторый код, заключенный в блоке try. Вы хотите перехватывать определенные исключения, и обрабатывать их, но что, если в процессе выполнения никаких исключений выброшено не было? На помощь приходит условие else. Оно будет выполняться лишь в том случае, когда никаких исключения выброшено не было, и перед блоком finally (если он, конечно, существует). Нужно заметить, что исключения, порожденные в блоке else предшествующими конструкциями except, обрабатываться не будут:
```
def get_person(people):
try:
person = people[3]
except IndexError:
person = None
else:
person.do_work()
return person
```
Управление дойдет до ветви else, если иключение IndexError не было выброшено. Почему это может быть полезным? Мы можем внести person.do\_work() в блок try, но что произойдет, если do\_work() в процессе работы выбросит исключение IndexError? В таком случае, оно будет поймано нашим блоком except, результаты чего могут быть катастрофическими (если конечно мы не приготовились к этому заранее — в таком случае, IndexError, порожденный do\_work(), будет проброшен далее, как и происходит в нашей функции get\_person(person)).
#### Заключение
Честно говоря, я не нашел особой пользы от применения оператора else вне связки с if. Я считаю, что в большинстве случаев не следует использовать его вместе с операторами циклов, так как получающиеся конструкции являются не интуитивными (хотя им можно дать “зеленый свет” в ситуациях, когда это приводит к более краткому и удобочитаемому коду). С другой стороны, использование else совместно с try куда как более интуитивно, и, возможно, представляет собой лучшую альтернативу отлавливанию тех исключений, которые нужно пробросить дальше, или использованию флаговой переменной, позволяющей понять, было ли выброшено исключение в процессе работы блока try..except. | https://habr.com/ru/post/148365/ | null | ru | null |
# Выпущен новый модуль управления сетью партнеров интернет-магазина — PHPShop Partners
Представляем вашему вниманию новый модуль для интернет-магазина PHPShop Enterprise, который позволяет создать сеть партнеров и автоматизировать процесс учета бонусов и скидок партнерской программы.
В последней версии самой продаваемой из наших платформ для интернет-магазинов [PHPShop Enterprise 3.5](http://www.phpshop.ru), предусмотрен модуль PHPShop Partner, который позволит владельцу интернет-магазина успешно создать партнерскую сеть, многие процессы учета в которой будут происходить автоматически.
Модуль учитывает переходы клиентов по партнерским ссылкам, и в случае успешно выполненного заказа, начисляет партнеру бонус в виде заданного процента от оплаты.
Для каждого партнера мы предусмотрели личный кабинет, в котором осуществляется накопление бонусных средств, а также контроль оплаченных и неоплаченных заказов. Как только сумма бонуса достигает цифры, заданную как достаточную для вывода, партнер может подать заявку на вывод средств. Также в кабинете партнера в закладке «Материалы» доступны способы переадресации покупателей с сайта партнера на сайт интернет-магазина для учета бонусов.
#### Партнерская ссылка
Партнеры имеют несколько способов разместить товары в своем магазине. Самый простой – с помощью партнерской ссылки, которая имеет вид
```
[Купить кондиционер выгодно!](http://ваш сайт/?partner=XXX)
```
и содержит идентификационный ID партнера.
#### Подключение витрины товаров через JavaScript
Другой способ – подключение витрины товаров к сайту с помощью Java Script. Этот способ позволяет вывести в витрину товаров в любом месте сайта партнера, с учетом дизайна и настроек количества товара и каталога размещения. Способ поддерживает подключение нескольких витрин одновременно.
```
var PHPShopXmlManager1 = new PHPShopXmlManager();
PHPShopXmlManager1.url = 'http://сайт магазина';
PHPShopXmlManager1.imgwidth = 100;
PHPShopXmlManager1.partner = XXX;
PHPShopXmlManager1.category = 11;
PHPShopXmlManager1.limit = 5;
PHPShopXmlManager1.load();
```
**Описание настроек:**
* .partner = XXX; — идентификатор партнера
* .category = 11; — ID категории для вывода товаров. Если этот параметр опущен, то выводятся спецпредложения
* .limit=5; — лимит вывода товаров
Схему вывода товаров можно персонализировать с помощью настраиваемого шаблона вывода товаров.
#### Утилита Shop4Partner
Одним из самых простых способов размещения каталога товаров на сайте партнера является использование утилиты Shop4Partner. Всего несколько кликов требуется, чтобы сгенерировать HTML-код витрины товаров, который легко использовать на сайтах партнера. Утилита автоматически учитывает идентификатор партнера и имеет несколько шаблонов оформления.
#### Модуль Catalog
В качестве системы для вывода товаров по партнерской программе также можно использовать полнофункциональную бесплатную систему управления сайтом [PHPShop Micro](http://habrahabr.ru/company/phpshop/blog/120224/) с модулем Catalog для трансляции товаров по партнерской программе.
PHPShop Micro – идеальное решение для небольших сайтов, она не требует базы данных и работает исключительно на файлах, а поэтому подходит для бесплатных хостингов. Система управления сайтом имеет более 120 уникальных тем оформления и поддерживает вывод витрины товаров через Java Script.
Для того, чтобы начать транслирование товаров с помощью PHPShop Micro, нужно скачать архив по [ссылке](http://phpshopcms.ru/version/PHPShop-CMS-ME.tar.gz), распаковать его, загрузить в FTP сайта партнера и определить настройки оформления и вывода товаров для модуля Catalog.
Настройка модуля Catalog находится в файле phpshop/modules/catalog/inc/config.ini
* enabled=«1»; — включение модуля (0 — выключение)
* partner=«1»; — ID партнера
* right=«11»; — ID каталогов через запятую для вывода в правую колонку
* left=«6,3»; — ID каталогов через запятую для вывода в левую колонку
* limit\_left=4; — количество товаров в левой колонке
* right\_left=5; — количество товаров в правой колонке
Пример работы PHPShop.CMS Micro с включенным модулем Catalog: [micro.phpshopcms.ru](http://micro.phpshopcms.ru)
Подробнее о работе с модулем Partners [wiki.phpshop.ru/index.php/Partner\_Module](http://wiki.phpshop.ru/index.php/Partner_Module) | https://habr.com/ru/post/123197/ | null | ru | null |
# Работа с FTP и выгрузка данных в xlsx (Caché Object Script)
Предлагаю Вашему вниманию статью на следующие на темы:
1. Работа с FTP сервером с помощью %Net.FtpSession
2. Простой способ выгрузки данных в формат xls
3. Несколько полезных советов
#### Работа с FTP сервером.
Вебсервисы? Не, не слышали.
Третьего дня нашей компании довелось организовывать потоковую синхронизацию данных с производственным комплексом «Хэ». IT отдел заказчика настаивал на использовании FTP сервера, другие способы обмена яростно отвергались.
Нам понадобятся:
```
s ftp = ##class(%Net.FtpSession).%New() – класс для работы с FTP
ftp.Timeout = время в миллисекундах – таймаута пакета
ftp.Connect(хост, логин, пароль, порт) – коннект к FTP
ftp.SetDirectory(директория) – путь к директории на FTP (относительно корневой)
ftp.List(маска файла, ссылка на поток по значению) – вернёт список файлов, соответствующих маске, на ФТП в поток
ftp.Binary() – бинарный режим передачи данных
ftp.Retrieve(файл, .GlobalStream) – загрузка фала в поток
ftp.Delete(файл) – удаление файла
ftp.Append(имяфайла, поток) - дописать данные из потока в файл с именем
ftp.Logout() – закрытие FTP коннекта
```
**Пример импорта файлов с FTP сервера (файлы отбираются по маске).**
```
ClassMethod FTPGetFiles(ftp, fileName) As %Status
{
s ftp = ##class(%Net.FtpSession).%New()
s ftp.Timeout = 2000
s host = "11.111.11.111"
s port = 2021
s user = "myth/user"
s pass = "userspass"
if ftp.Connect(host, user, pass, port)
{
d ftp.SetDirectory("/TestDir")
// Маска файла
s fileName = "????????t??????vK*.xml"
// Работа с файлами по маске в указанной папке
d ..ParserDir(ftp, fileName)
s fileName = "????????a??????yK*.xml"
d ..ParserDir(ftp, fileName)
}
q ftp.Logout()
}
/// Загрузка в поток файлов, удовлетворяющих маске
ClassMethod ParserDir(ftp, fileName) As %Status
{
s file = ""
s x = 1
s file(x) = ""
// Список файлов из папки в поток
d ftp.List(fileName, .stream)
q:'$IsObject(stream)
while 'stream.AtEnd
{
// Чтение по одному символу из потока
s file = stream.ReadLine(1, .sc, .eol)
if ( file = $C(10) )
{
// Формирование массива дескрипторов файла
s x = x + 1
s file(x) = ""
}
else
{
// Формирование дескриптора файла
s file(x) = file(x) _ file
}
if $$$ISERR(sc)
{
w "ERROR"
q
}
}
// Переключение в бинарный режим
d ftp.Binary()
// Получение дескриптора следующего файла
s key = $ORDER(file(""),1)
while ( key '= "" )
{
// Имя файла
s fName = $E(file(key), 40, *)
if ( $L(fName) > 0 )
{
#dim GlobalStream As %GlobalBinaryStream;
// Дописываем данные из потока в файл с именем fName. В нашем случае из-за настроек виндового FTP и писем в CP1251 необходима трансформация кодировки
d ftp.Retrieve($zcvt($zcvt(fName,"I","CP1251"),"O","CP1251"),.GlobalStream)
#dim status As %String;
// Поиск вхождения буквы в имени файла
if ( $F(fName,"s") > 0 )
{
s status = ..Parser(GlobalStream, "Product", "Shipment", parser)
}
elseif ( $F(fName,"d") > 0 )
{
s status = ..Parser(GlobalStream, "Product", "Disposal" ,parser)
}
if ( status )
{
d ftp.Delete(fName)
}
}
s key = $order(file(key),1)
}
q ftp.Logout()
}
```
**Пример экспорта файлов на FTP сервер**
```
/// Экспорт файлов на FTP сервер
ClassMethod RunExport() As %Status
{
s ftp = ##class(%Net.FtpSession).%New()
s ftp.Timeout = 2000
s host = "11.111.11.111"
s port = 2021
s user = "myth/user"
s pass = "userspass"
if ftp.Connect(host, user, pass, port)
{
d ftp.Binary()
// Получение файлов по маске в папке в порядке сортировки
s st = ##class(%SQL.Statement).%New()
d st.%PrepareClassQuery("%File","FileSet")
s rs = st.%Execute("/usr/cachesys201221/csp/sm/export_xml","*.xml","Size,Name")
while rs.%Next()
{
// Удаляем файл с сервера, если такой уже есть
d ftp.Delete(rs.%GetData(6))
// Загружаем файл в поток
s stream = ##class(%FileBinaryStream).%New()
// 1 - Полный путь до файла на нашем локальном сервере
s stream.Filename = rs.%GetData(1)
// Если файл УСПЕШНО дописан на сервер - перемещаем его в директорию "done"
if ( ftp.Append(rs.%GetData(6),stream) = $$$OK )
{
d ##class(%File).Rename(rs.%GetData(1), ##class(%File).GetDirectory(rs.%GetData(1)) _ "done/" _ rs.%GetData(6))
}
k stream
}
}
d ftp.Logout()
k ftp
q $$$OK
}
```
#### Выгрузка данных в формат xlsx.
Ничто так не радует, как горе у соседа.
Хорошо помню, как утром, по приходу в офис, мне улыбался коллега и не без доли злорадствия рапортовал о выходе новой версии Mozilla Firefox. А все потому, что задача экспорта данных в excel в наших программных продуктах была разрешена с помощью браузерного плагина, который использовал написанную на visual-C библиотеку. После смены политики безопасности приложений FireFox, мне предстояло при каждой смене версии, в лучшем случае, скачивать новую SDK и пересобирать DLL-ку (и плагин в целом), в худшем – переписывать сишный код для DLL-ки и JS парсер страницы). Про необходимость обновления плагина у пользователей и вспоминать не хочется.
Однако третьего дня и на нашей улице перевернулся грузовик с печеньем в виде простого способа экспорта в формат Excel, коим хочу поделиться с Вами:
* Берём (формируем) html таблицу с данными
* Сохраняем таблицу в текстовый файл, меняем расширение на xls
* Открываем файл, не забываем жмакнуть «да» на табличке с предупреждением и … вуаля! Эксель прекрасно распознал нашу таблицу. При необходимости ячейкам можно передавать css стили и указывать формат данных.
**Пример**
```
#server(TestProject.MakeExcelFile($("#table_to_excel").html(), "PriceList"))#
ClassMethod MakeExcelFile(Data As %String, FileName As %String) As %Status
{
s FileName = "/tkf/reports/" _ FileName _ "_Excel.xls"
s stream = ##class(%Library.FileCharacterStream).%New()
s FP = $$GetFilename^%apiCSP(FileName)
if ( $L(Data) = 22 )
{
d stream.CopyFrom(Data)
}
else
{
d stream.Write(Data)
}
d stream.SetAttribute("Content-Length",stream.Size)
d stream.SetAttribute("ContentType","application/excel")
d stream.SetAttribute("Charset","UTF8")
d stream.SetAttribute("ContentDisposition","attachment; filename=" _ $p(FileName,"/",4))
d stream.LinkToFile(FP)
d stream.SaveStream()
s oid = stream.%Oid()
&js
q $$$OK
}
```
Ячейке, к примеру, можно задать размер шрифта — `Анна Антонова`, а можно указать числовой тип формата:
```
.toText{ mso-number-format:\"\@\"; }
Анна Антонова |
```
#### Полезные советы
###### Сокращения
Наверняка не все знают, что в COS существуют сокращенные версии операторов, вроде этих:
Set = s
Do = d
Write = w
Kill = k
Quit = q
…
Сокращения в большинстве случаев отражены в документации примерно так:
###### Типизация
COS — язык без строгой типизации, но иногда полезно или даже необходимо заранее провести типизацию, для этого и была создана конструкция #dim
Пример:
###### $CLASSNAME в SQL
Редкий, но вполне реальный случай – при построении запроса необходимо вывести имя класса (Аналог $CLASSNAME в SQL), для этих целей можно использовать скрытое поле, которое присуще всем классам — x\_\_classname.
Пример:
Есть 2 класса A и B, которые наследуются от общего предка Letters Extends %Persistent. Включим в выборку поле x\_\_classname.
Версия Cache — Cache for UNIX (Red Hat Enterprise Linux for x86-64) 2012.2.1 (Build 705U) Wed Oct 24 2012 14:32:01 EDT. | https://habr.com/ru/post/177609/ | null | ru | null |
# OpenToonz: снаружи и внутри
Прошло уже почти четыре года с тех пор, как PVS-Studio поверял исходный код OpenToonz. Этот проект является очень мощным инструментом для создания двухмерной анимации. За время с последней проверки с его помощью были созданы такие мультипликационные произведения, как Мэри и Ведьмин цветок, Бэтмэн-Нинзя, Промаре и другие. Раз большие студии продолжают пользоваться Toonz, то почему бы не проверить качество исходного кода еще раз?
С предыдущим разбором ошибок можно познакомиться в статье "[Плохой код пакета для создания 2D-анимаций Toonz](https://habr.com/ru/company/pvs-studio/blog/281138/)". В целом не похоже, что качество кода сильно повысилось, так что общее впечатление лучше не стало. К тому же, было обнаружено множество тех же ошибок, что и в предыдущей статье. Повторно мы их рассматривать не будем, благо выбрать новые есть из чего.
Впрочем, надо понимать, что наличие ошибок вовсе не обязательно мешает активно и продуктивно использовать программный продукт. Скорее всего, найденные ошибки живут в редко используемых или вовсе в неиспользуемых участках кода, иначе они были бы выявлены в процессе использования приложения и исправлены. Однако, это не значит, что статический анализ избыточен. Просто смысл статического анализа не в поиске старых и неактуальных ошибок, а в удешевлении процесса разработки. Многие ошибки при написании кода могут быть выявлены сразу, а не в процессе эксплуатации ПО. Соответственно, при регулярном использовании статического анализатора, ошибки исправляются на самом раннем этапе. Это экономит и время разработчиков, и деньги компании, и улучшает восприятие продукта пользователями. Согласитесь, неприятно постоянно отписывать разработчикам, что не работает то одно, то другое.
**Фрагмент N1**
[V610](https://www.viva64.com/ru/w/v610/) Undefined behavior. Check the shift operator '<<'. The left operand '(- 1)' is negative.
```
decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
{
int p1, m1;
p1 = 1 << cinfo->Al;
m1 = (-1) << cinfo->Al;
....
}
```
Не совсем ясно, чего автор кода хотел добиться здесь. Использование операторов сдвига с отрицательными числами приводит к неопределенному поведению. То, как поведение операторов сдвига описывается в стандарте, выглядит на первый взгляд немного запутанным, но все-таки сверимся с ним:
1. The type of the result is that of the promoted left operand. The behavior is undefined if the right operand is negative, or greater than or equal to the length in bits of the promoted left operand.
2. The value of E1 << E2 is E1 left-shifted E2 bit positions; vacated bits are zero-filled. If E1 has an unsigned type, the value of the result is E1 \* 2^E2, reduced modulo one more than the maximum value representable in the result type. Otherwise, if E1 has a signed type and non-negative value, and E1\*2^E2 is representable in the result type, then that is the resulting value; otherwise, the behavior is undefined.
Итак, поведение не определено, если правый или левый операнд имеет отрицательное значение. Если операнд имеет знаковый тип, неотрицательное значение и вмещается в результирующий тип, то поведение будет нормальным.
**Фрагмент N2**
[V517](https://www.viva64.com/ru/w/v517/) The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 156, 160. cameracapturelevelcontrol.cpp 156
```
void CameraCaptureLevelHistogram::mousePressEvent(QMouseEvent* event) {
if (event->button() != Qt::LeftButton) return;
if (m_currentItem == Histogram) {
m_histogramCue = true;
return;
}
if (m_currentItem == None) return;
QPoint pos = event->pos();
if (m_currentItem == BlackSlider) // <=
m_offset = pos.x() - SIDE_MARGIN - m_black;
else if (m_currentItem == GammaSlider)
m_offset = pos.x() - SIDE_MARGIN - gammaToHPos(m_gamma, m_black, m_white);
else if (m_currentItem == BlackSlider) // <=
m_offset = pos.x() - SIDE_MARGIN - m_white;
else if (m_currentItem == ThresholdSlider)
m_offset = pos.x() - SIDE_MARGIN - m_threshold;
}
```
Тут переменной *m\_offset* присваиваются различные значения в зависимости от значения *m\_currentItem*. Однако дублирование проверки на *BlackSlider* бессмысленно, и из тела условия можно увидеть, что в вычислении участвует переменная *m\_white*. Заглянем в возможные значения для *m\_currentItem*.
```
LevelControlItem m_currentItem;
enum LevelControlItem {
None = 0,
BlackSlider,
WhiteSlider,
GammaSlider,
ThresholdSlider,
Histogram,
NumItems
};
```
Оказывается, что возможно еще и значение *WhiteSlider*, на которое проверка как раз и не производится. Таким образом, вполне возможно, что какой-то из сценариев поведения был потерян из-за ошибки копипасты.
**Фрагмент N3**
[V517](https://www.viva64.com/ru/w/v517/) The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 784, 867. tpalette.cpp 784
```
void TPalette::loadData(TIStream &is) {
....
std::string tagName;
while (is.openChild(tagName)) {
if (tagName == "version") {
....
} else if (tagName == "stylepages") { // <=
while (!is.eos()) {
if (....){
....
}
....
is.closeChild();
}
} else if (tagName == "refImgPath") {
....
} else if (tagName == "animation") {
....
} else if (tagName == "stylepages") { // <=
int key = '0';
while (!is.eos()) {
int styleId = 0;
....
}
}
....
}
}
```
Еще одна похожая ошибка. Здесь также у одинаковых условий разные тела, но сделать вывод о возможных вариантах значения *tagName* уже нельзя. Скорее всего, просто какой-то вариант был упущен, и в итоге мы имеем код, который никогда не будет выполнен.
**Фрагмент N4**
[V547](https://www.viva64.com/ru/w/v547/) Expression 'chancount == 2' is always true. psd.cpp 720
```
void TPSDReader::readImageData(...., int chancount) {
....
if (depth == 1 && chancount == 1) { // <= 1
....
} else if (depth == 8 && chancount > 1) {
....
for (....) {
if (chancount >= 3) {
....
if (chancount == 4)
....
else
....
} else if (chancount <= 2) // <= 2
{
....
if (chancount == 2) // <= 3
....
else
....
}
....
}
....
} else if (m_headerInfo.depth == 8 && chancount == 1) {
....
}
```
В эти проверки закралась небольшая логическая ошибка. В проверке под номером один *chancount* сравнивается с 1, а проверке номер 2 проверяется, что эта переменная меньше или равна 2. В итоге, к условию под номером три единственным возможным значением *chancount* является 2. К неправильной работе программы такая ошибка может и не приведет, но она усложняет чтение и понимание кода. Например, непонятно, зачем тогда else-ветка…
В целом рассматриваемая в этом фрагменте функция занимает чуть больше 300 строк кода и состоит из таких вот нагромождений условий и циклов.
**Фрагмент N5**
[V614](https://www.viva64.com/ru/w/v614/) Uninitialized variable 'precSegmentIndex' used. Consider checking the fifth actual argument of the 'insertBoxCorners' function. rasterselection.cpp 803
```
TStroke getIntersectedStroke(TStroke &stroke, TRectD bbox) {
....
int precSegmentIndex, currentSegmentIndex, startSegmentIndex,
precChunkIndex = -1;
....
if (....) {
insertBoxCorners(bbox, points, outPoints, currentSegmentIndex,
precSegmentIndex);
....
}
}
void insertBoxCorners(...., int currentSegmentIndex, int precSegmentIndex) {
....
bool sameIndex = (precSegmentIndex == currentSegmentIndex);
....
int segmentIndex = precSegmentIndex;
....
}
```
Возможно, здесь ошибка была допущена еще при инициализации переменных *precSegmentIndex*, *currentSegmentIndex*, *startSegmentIndex*, *precChunkIndex*. Разработчик мог рассчитывать, что инициализация последнего элемента -1 инициализирует тем же значением, что и другие переменные, объявленные в той же строке.
**Фрагмент N6**
[V590](https://www.viva64.com/ru/w/v590/) Consider inspecting the 's != "" && s == «color»' expression. The expression is excessive or contains a misprint. cleanupparameters.cpp 416
```
void CleanupParameters::loadData(TIStream &is, bool globalParams) {
....
std::string s = is.getTagAttribute("sharpness");
....
if (....)
{
....
} else if (tagName == "lineProcessing")
....
if (s != "" && isDouble(s))
....
if (s != "" && isDouble(s))
....
if (s != "" && s == "color") // <=
....
} else if (tagName == "despeckling") {
....
}
....
}
```
Эта ошибка, даже скорее недочет, сама по себе приводит лишь к лишнему сравнению. Однако если мы взглянем на код в целом, станет ясно, что лишнее сравнение появилось в результате копипасты из предыдущих условий.
Такая лапша, занимающая десятки и более строк кода, вполне может хранить в себе еще какие-либо ошибки логики, и их поиск при таком форматировании может обернуться мучениями.
**Фрагмент N7**
[V772](https://www.viva64.com/ru/w/v772/) Calling a 'delete' operator for a void pointer will cause undefined behavior. pluginhost.cpp 1327
```
static void release_interface(void *interf) {
if (interf) delete interf;
}
```
Тут само сообщение анализатора уже достаточно исчерпывающее: вызов оператора *delete* для указателя на тип *void* приводит к неопределенному поведению. Если была необходима универсальная функция для удаления интерфейсов, возможно её стоило сделать шаблонной.
```
template
static void release\_interface(T \*interf) {
if (interf) delete interf;
}
```
**Фрагмент N8**
[V568](https://www.viva64.com/ru/w/v568/) It's odd that 'sizeof()' operator evaluates the size of a pointer to a class, but not the size of the 'm\_xshHandle' class object. tstageobjectcmd.cpp 455
```
class DVAPI TStageObjectParams {
....
};
class RemovePegbarNodeUndo final : public TUndo {
....
TXsheetHandle *m_xshHandle;
public:
int getSize() const override {
return sizeof *this + sizeof(TStageObjectParams) + sizeof(m_xshHandle);
}
....
}
```
[Достаточно часто](https://www.viva64.com/ru/examples/v568/) встречающаяся ошибка, которая может произойти как по невнимательности, так и по незнанию. Тут, скорее всего, было дело в невнимательности, поскольку в первом слагаемом *this* все-таки был разыменован. Если нужен размер объекта, то всегда нужно помнить, что указатель объекта нужно обязательно разыменовать. Иначе мы просто получаем размер самого указателя.
```
return sizeof *this + sizeof(TStageObjectParams) + sizeof(*m_xshHandle);
```
**Фрагмент N9**
[V568](https://www.viva64.com/ru/w/v568/) It's odd that 'sizeof()' operator evaluates the size of a pointer to a class, but not the size of the 'this' class object. shaderfx.cpp 107
```
struct RectF {
GLfloat m_val[4];
....
bool operator==(const RectF ▭) const {
return (memcmp(m_val, rect.m_val, sizeof(this)) == 0);
}
};
```
А тут, очевидно, забыли разыменовать указатель *this*. В итоге получаем не размер объекта, а размер указателя. Как результат, сравниваются только первые 4 или 8 байт (в зависимости от разрядности). Верный вариант кода:
```
return (memcmp(m_val, rect.m_val, sizeof(*this)) == 0);
```
**Фрагмент N10**
[V554](https://www.viva64.com/ru/w/v554/) Incorrect use of unique\_ptr. The memory allocated with 'new []' will be cleaned using 'delete'. screensavermaker.cpp 29
```
void makeScreenSaver(TFilePath scrFn, TFilePath swfFn,
std::string screenSaverName) {
struct _stat results;
....
int swfSize = results.st_size;
std::unique_ptr swf(new char[swfSize]);
....
}
```
Часто забывают, что от типа, которым инстанцируется unique\_ptr, зависит будет использоваться delete или delete[]. В итоге, если инстанцировать указатель как в рассматриваемом фрагменте, при этом выделяя память через new[], может возникнуть неопределенное поведение, так как освобождение будет происходить через delete. Чтобы этого избежать, нужно добавить к типу указателя квадратные скобки: std::unique\_ptr.
**Фрагмент N11**
[V521](https://www.viva64.com/ru/w/v521/) Such expressions using the ',' operator are dangerous. Make sure the expression 'm\_to, m\_from = it->first.getNumber()' is correct. flipbook.cpp 509
```
class LoadImagesPopup final : public FileBrowserPopup {
....
int m_from, m_to, ....;
....
}
void LoadImagesPopup::onFilePathClicked(....) {
TLevel::Iterator it;
....
it = level->begin();
m_to, m_from = it->first.getNumber(); // <=
for (; it != level->end(); ++it) m_to = it->first.getNumber();
if (m_from == -2 && m_to == -2) m_from = m_to = 1;
m_minFrame = m_from;
m_maxFrame = m_to;
....
}
```
Возможно, программист ожидал, что можно присвоить одно значение нескольким переменным, просто выписав их через запятую. Однако оператор "," в С++ работает иным образом. В нем первый операнд выполняется, и результат «сбрасывается», далее вычисляется второй операнд. И, хотя переменная *m\_to* инициализируется в последующем цикле, если что-то пойдет не так или кто-то неаккуратно произведет рефакторинг, возможно, что *m\_to* так и не получит значения. И вообще, в любом случае этот код выглядит странно.
**Фрагмент N12**
[V532](https://www.viva64.com/ru/w/v532/) Consider inspecting the statement of '\*pointer++' pattern. Probably meant: '(\*pointer)++'. trop.cpp 140
```
template
void doGammaCorrect(TRasterPT raster, double gamma) {
Gamma\_Lut lut(....);
int j;
for (j = 0; j < raster->getLy(); j++) {
T \*pix = raster->pixels(j);
T \*endPix = pix + raster->getLx();
while (pix < endPix) {
pix->r = lut.m\_table[pix->r];
pix->b = lut.m\_table[pix->b];
pix->g = lut.m\_table[pix->g];
\*pix++; // <=
}
}
}
```
Маленький недочет, который может дополнительно путать человека, читающего код. Инкремент, как и задумывалось, смещает указатель. Однако после этого происходит бессмысленное разыменование. Лучше просто написать *pix++*.
**Фрагмент N13**
[V773](https://www.viva64.com/ru/w/v773/) The function was exited without releasing the 'autoCloseUndo' pointer. A memory leak is possible. vectortapetool.cpp 575
```
void joinLineToLine(....) {
....
UndoAutoclose *autoCloseUndo = 0;
....
autoCloseUndo = new UndoAutoclose(....);
....
if (pos < 0) return;
....
TUndoManager::manager()->add(autoCloseUndo);
}
```
Подобных предупреждений было больше 20. Зачастую где-то в конце функции производится освобождение памяти, но для более ранних *return* этот необходимый шаг оказывается пропущен. Так и здесь. В конце указатель передается *TUndoManager::manager()->add()*, который берет на себя удаление указателя, однако выше присутствует *return* для которого этот метод забыли позвать. Так что всегда стоит помнить о своих указателях при любом выходе из функции, а не просто вписывать удаление куда-то в конец блока или перед последним *return*.
Однако, если для сокращенной версии кода, эта ошибка выглядит очевидной, то в реальном более запутанном коде, отследить такую проблему может быть затруднительно. Тут и поможет никогда неустающий статический анализатор.
**Фрагмент N14**
[V522](https://www.viva64.com/ru/w/v522/) Dereferencing of the null pointer 'region' might take place. palettecmd.cpp 94
```
bool isStyleUsed(const TVectorImageP vi, int styleId) {
....
int regionCount = vi->getRegionCount();
for (i = 0; i < regionCount; i++) {
TRegion *region = vi->getRegion(i);
if (region || region->getStyle() != styleId) return true;
}
....
}
```
Тут можно предположить, что разработчик перепутал правила short-circuit evaluation и подумал, что если первая проверка указателя вернет *false*, то далее разыменования такого нулевого указателя не произойдёт. Однако для оператора "||" все совсем наоборот.
**Фрагмент N15**
[V561](https://www.viva64.com/ru/w/v561/) It's probably better to assign value to 'ca' variable than to declare it anew. Previous declaration: xshcellmover.cpp, line 319. xshcellmover.cpp 323
[V561](https://www.viva64.com/ru/w/v561/) It's probably better to assign value to 'cb' variable than to declare it anew. Previous declaration: xshcellmover.cpp, line 320. xshcellmover.cpp 324xshcellmover.cpp 323
```
void redo() const override {
int ca = m_cellsMover.getStartPos().x;
int cb = m_cellsMover.getPos().x;
....
if (!m_cellsMover.getOrientation()->isVerticalTimeline()) {
int ca = m_cellsMover.getStartPos().y;
int cb = m_cellsMover.getPos().y;
}
....
if (ca != cb) {
....
}
....
}
```
Возможно еще одна копипаста, но с не совсем обычной сутью ошибки. Обращение к *x* было заменено на *y*, но вот тип переменной в начале строки, из-за которого и происходит локальная передекларация, убрать забыли. В итоге, вместо смены ориентации позиций для исходных *ca* и *cb*, создаются новые локальные *ca* и *cb*, с которыми далее ничего не происходит. А вот внешние *ca* и *cb* продолжают свое существование со значениями для *x*.
**Заключение N1**
В процессе написания статьи мне стало интересно потыкать и попробовать что-нибудь сделать в этой программе. Может мне повезло, но странное поведение не заставило себя ждать: зависание, отображение моих манипуляций с планшетом после отвисания и странный квадрат после нажатия *Ctrl+Z*. К сожалению, повторить это поведение у меня не вышло.
Но на самом деле, несмотря на такое поведение и привитие привычки регулярно нажимать *Ctrl+S*, OpenToonz впечатляет своим масштабом и функционалом. Все-таки не зря им пользуются и крупные студии.
И мое художество как бонус:
**Заключение N2**
В случае OpenToonz очевидно, что пытаться исправить сразу все обнаруженные анализатором ошибки станет большой задачей, которая застопорит процесс разработки. Для таких случаев существует подход «Массового подавления», когда технический долг заносится в suppress-базу анализатора и дальнейшая работа с анализатором проводится уже на основе свежих срабатываний. Ну а если появляется время, то можно и поразбирать технический долг.
P.S. Напоминаю, что разработчики открытых проектов могут использовать [бесплатный вариант лицензирования PVS-Studio](https://www.viva64.com/ru/b/0614/).
[](https://www.viva64.com/en/b/0720/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Victoria Khanieva. [OpenToonz](https://www.viva64.com/en/b/0720/). | https://habr.com/ru/post/494220/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.