text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Багобезопасный код: шаблон проектирования Null Safe
### Содержание
I. Описание проблемы
II. Обзор существующих решений
III. Вариант решения без применения аспектов.
IV. Решение на AspectJ
V. Динамические аспекты
VI. Послесловие.
VII. Ссылки и литература
### I.Описание проблемы
При программировании на Java (и некоторых других языках) часто приходиться работать со строковыми переменными и другими типами, представляющими собой объекты-обёртки примитивных типов например: Boolean, Integer, Double. Например есть бин (здесь и далее под бином имеется ввиду класс, поддерживающий рекомендации Java Beans):
```
public class SomeBean{
private String strField;
public void setStrField(String strField){
this.strField=strField;
}
public String getStrField(){
return strField;
}
// остальное описание пропущено
}
```
В дальнейшем, при использовании этого бина мы должны проверять поле на null:
```
String s=someBean.getStrField();
if (s!=null){
if (!s.isEmpty()){ // s.length()>0 Java 5-
doSomeThing();
}
}
```
И так нужно делать с любым полем-объектом. Если не сделать, то рано или поздно приложение завершится по непроверяемому исключению NullPointerException. Можно, конечно, принудительно перехватывать данное исключение, перекладывая свои ошибки на систему, однако это считается признаком безграмотного стиля программирования и влечет за собой потерю производительности, поскольку генерация исключения эквивалентна десяткам обычных команд. Такую проверку на null приходиться делать неоднократно, в самом бине и во многих местах за его пределами. Чем чаще используется бин, и чем сложнее приложение, тем чаще приходиться проверять на null, и соответственно приходиться выполнять рутинную работу, что влечет вероятность что-то пропустить, а это — увеличивает вероятность неработоспособности приложения. Подобный подход запутывает код, делает его менее наглядным, приводит к увеличению излишнего кода и уменьшает быстродействие. Я как программист часто сталкиваюсь с подобными вещами у коллег по цеху и даже в своей практике. Далее будет представлен краткий обзор существующих средств борьбы с null-зависимостью, и эффективное, на мой взгляд, общее решение на основе применения аспектов.
### II. Обзор существующих решений
Я предположил, что кто-то это делал уже до меня, и сделал обзор уже существующих решений.
1) аннотация @ NotNull из JSR-305 подробно описана в [1] и [2].
Ставится перед полями и методами, возвращающими объекты. Позволяет определить на уровне исходных текстов предварительно отмеченные IDE проблемные места.
```
@NotNull
public Color notNullMethod(){
return null;
}
```
Недостаток: сама аннотация не решает проблему, и нужно не забыть поставить ее во всех проблемных местах, JSR-305 не в состоянии проанализировать сложный код.
2) Checker Framework JSR-308 описана в [3] и [4].
Представляет более продвинутую технику по сравнению с JSR-305 за счет введения дополнительных проверок кода для анализа более сложного кода при проверке на null, а также предоставляет множество других полезных аннотаций для проверок многозадачности, типов, регулярных выражений и других.
Достоинства: развитый фреймворк
Недостатки применительно к обсуждаемой проблеме: аннотация @ NotNull не представляет решения, нужно не забыть поставить аннотацию во всех проблемных местах.
3) The Java Annotation Checker (JACK) [5] имеет те же достоинства и недостатки что и JSR-305
4) Project Coin, содержащий множество рекомендаций по улучшению Java (под влиянием языка Groovy), подробнее в [6] и [7]. Рассмотрим пример функции:
```
public String getPostcode(Person person){
if (person != null){
Address address = person.getAddress();
if (address != null){
return address.getPostcode();
}
}
return null;
}
```
По предложению Project Coin эту функцию можно было бы переписать через NullSafe-navigation:
```
public String getPostcode(Person person){
return person?.getAddress()?.getPostcode();
}
```
К сожалению, Oracle не включила эту возможность в Java 7, поэтому для Java придеться довольствоваться другими решениями.
5) Применение языка Groovy. Собственно, описанный выше NullSafe-navigation пошёл именно оттуда [8].
Достоинство: значительное упрощение кода
Недостаток: нужно всё равно помнить обо все проблемных местах
6) Apache Commons, StringUtils [9] и PropertyUtils [10]:
```
StringUtils.isBlank(null)= true
StringUtils.isBlank("")= true
StringUtils.isBlank(" ")= true
String firstName = (String) PropertyUtils.getSimpleProperty(employee, "firstName");
String city = (String)PropertyUtils.getNestedProperty(employee, "address(home).city");
```
Достоинства: упрощение проверок
Недостатки: проверять нужно везде, где требуется. Нужен дополнительный код для обработки исключений, генерируемых PropertyUtils.
7) Анализаторы статического кода FindBugs [11] и PMD [12], имеющие плагины под большинство IDE.
Достоинства: Очень мощные и полезные инструменты, анализирующие статический код без предварительной инъекции аннотаций.
Недостатки: Показывают проблемные места, но не предоставляют готового общего решения.
### III. Вариант решения без применения аспектов
Проверка на null, как и всякая задача чтения данных, на практике происходит чаще, чем присвоение (запись) значений. Поэтому операция чтения должна быть предельно оптимизирована по производительности. Можно переписать взаимодействие с полями бина в этом случае:
```
public class SomeBean{
private String strField="";
public void setStrField(String strField){
if (strField!=null){ this.strField=strField; }
}
public String getStrField(){
return strField;
}
}
```
Null-значения в таком случае игнорируются. Также поля принудительно инициализируются. Всё это вместе позволяет создать null-безопасный код, в котором уже не потребуются производить многочисленные проверки на null, что значительно упрощает написание кода и кардинально снижает вероятность что-либо пропустить.
Достоинства: не нужно больше заботиться о проверке на null для работы с такими полями, что значительно упрощает код и увеличивает быстродействие.
Недостатки: для каждого поля приходится писать код инициализации и код отсечения null.
### IV. Решение на AspectJ
Чтобы не писать для каждого кода отсечение null просто напрашивается на решение с помощью аспектов которое позволит обеспечить сквозную функциональность. Очевидно, что желательно действовать на уровне полей, так как операции с полями могут быть внутри бина, а сквозная функциональность должна быть универсальной, иначе в ней бы не было смысла.
Для выборочной пометки полей и целиком классов введем аннотацию NullSafe:
```
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.TYPE})
public @interface NullSafe {
boolean getter() default true;
}
```
```
@NullSafe(getter=false)
```
– нужно для упрощения логики и увеличения быстродействия в случае, если программист не поленился инициализировать поля в бине, в этом случае действию аспекта подвергается только запись в поле.
Для будущей лёгкой модификации аспект написан с использованием аннотированного AspectJ 5 и требует для работы Java 5+. Подробно про аспекты можно прочитать в [13],[14],[15].
```
@Aspect
public class NullSafeAspect {
@Pointcut(value="within(@NullSafe *)") // support annotation by class
public void byClass() {}
@Pointcut(value="!within(@NullSafe(getter=false) *)")
public void byClassNoGetter() {}
@Pointcut(value="get(@NullSafe Long||Integer||Double||Float||Short||Byte||java.math.BigDecimal *)")
public void fieldGetNumerics() {}
@Pointcut(value="!get(@NullSafe(getter=false) * *)")
public void fieldNoGetter() {}
@Pointcut(value="get(Long||Integer||Double||Float||Short||Byte||java.math.BigDecimal *)")
public void classGetNumerics() {}
@Pointcut(value="set(Long||Integer||Double||Float||Short||Byte||java.math.BigDecimal *)")
public void classSetNumerics() {}
@Pointcut(value="set(@NullSafe * *)") // all field-annotated
public void fieldSetAllSupported() {}
@Pointcut(value="classSetNumerics() || set(String||Boolean||Character *)")
public void classSetAllSupported() {}
@Pointcut(value="fieldGetNumerics() || get(@NullSafe String||Boolean||Character *)")
public void fieldGetAllSupported() {}
@Pointcut(value="classGetNumerics() || get(String||Boolean||Character *)")
public void classGetAllSupported() {}
@Around(value="(fieldSetAllSupported() || byClass() && classSetAllSupported()) && args(v)")
public void aroundSet(ProceedingJoinPoint jp, Object v) throws Throwable{
toLogSetter(jp, v);
if (v!=null){ jp.proceed();}
}
@Around(value="get(@NullSafe String *) && fieldNoGetter() || byClass() && get(String *) && byClassNoGetter()")
public String aroundGetString(ProceedingJoinPoint jp) throws Throwable{
String v=(String)jp.proceed();
if (v==null){return "";}
return v;
}
private Field getField(JoinPoint jp){
try{
Signature sig=jp.getStaticPart().getSignature();
Field field=sig.getDeclaringType().getDeclaredField(sig.getName());
field.setAccessible(true);
return field;
}catch(Exception e){
}
return null;
}
private Object getBean(JoinPoint jp){
try {
Field field=getField(jp);
if (field==null){return null;}
Object obj=field.getType().newInstance();
field.set(jp.getTarget(),obj);
return obj;
}catch(Exception e){
stackTraceToLog(e);
}
return null;
}
@Around(value="!fieldGetAllSupported() && get(@NullSafe * *) && fieldNoGetter() && byClassNoGetter()")
public Object aroundGetBean(ProceedingJoinPoint jp) throws Throwable{
Object v=jp.proceed();
if (v==null){
return getBean(jp);
}
return v;
}
private Object getNumeric(JoinPoint jp){
try {
Field field=getField(jp);
if (field==null){return null;}
Object obj=field.getType().getDeclaredConstructor(String.class).newInstance("0");
field.set(jp.getTarget(),obj);
return obj;
}catch(Exception e){
stackTraceToLog(e);
}
return null;
}
@Around(value="fieldGetNumerics() && fieldNoGetter() || byClass() && classGetNumerics() && byClassNoGetter()")
public Object aroundGetNumerics(ProceedingJoinPoint jp) throws Throwable{
Object v=jp.proceed();
if (v==null){
return getNumeric(jp);
}
return v;
}
}
```
Пример применения аннотации:
```
@NullSafe
public class SomeClassTestByClass extends SomeClass {
...
}
@NullSafe
private String strField;
@NullSafe
private HashMap> map;
@NullSafe(getter=false)
private ArrayList listString=new ArrayList();
```
Далее приведены разъяснения по поводу данного аспекта. Аннотация @Pointcut содержит описание стандартных точек пересечения. Within – означает действие внутри класса, в данном случае любого класса помеченного аннотацией @ NullSafe. Поддерживаются численные типы Long,Integer,Double,Float,Short,Byte,BigDecimal, которые инициализируются одинаковым шаблоном. Также поддерживаются String,Boolean,Character. Все упомянутые выше классы-обертки входят в понятие поддерживаемых аспектом типов. Также можно аннотировать на уровне поля любой другой бин или класс поддерживающий конструктор без параметров. Аннотирование класса подразумевает полную поддержку сразу для всех поддерживаемых типов полей. Все эти поля инициализируются с помощью reflection. Если инициализировать поля в коде, то это позволит увеличить быстродействие, отказавшись от геттеров используя @ NullSafe(getter=false). Set() и get() — в точках пересечения ответственны за запись или чтение поля бина, в том числе для операций с полями внутри бина. Совет @Advice отвечает за действия в точках пересечения. Использование совета [Before](https://habrahabr.ru/users/before/) для пересечения set() мне не показалось хорошей идеей, потому что для предотвращения выполнения кода требуется вызывать исключение, что неприемлемо с точки зрения быстродействия. По умолчанию аспект создается в виде Singleton. Вся обработка обеспечивается всего лишь одним методом в проекте для каждого типа. Полный пример готового аспекта с тестами приведен в проекте NullSafe в [18].
Достоинство: сквозная функциональность только там, где это необходимо.
Недостатки: всё еще нужно ставить аннотации на уровне классов и отдельных полей, а сквозная функциональность для всех классов без ограничений аннотацией @ NullSafe кажется мне некорректным решением.
### V. Динамические аспекты
Аспекты обычно являются статической модификацией кода и выполняется на этапе компиляции. Поэтому сложное описание точек пересечения никак не влияет на быстродействие готовой программы. Также AspectJ может производить динамическую модификацию байт-кода с помощью изменения загрузчика. Это нужно в случае применения аспектов для байт-кода, для которого нет исходных текстов. В этом случае нужно убрать аннотации и добавить упоминание определенных классов в аспекте NullSafeAspect (или создать новый аспект, который его наследует). Так как такая техника специфична для разных серверов приложений и сред, я не буду на ней подробно останавливаться. Подробнее об использовании динамических аспектов можно узнать из [16] и [17].
### VI. Послесловие
Данная статья является попыткой взглянуть на общеизвестную проблему под другим взглядом. Возможно использование null-значений необходимо для какого-либо конкретного алгоритма или базы данных, но этом случае, как показывает моя практика, часто возникает сомнения, оптимален ли алгоритм или база данных, не содержат ли они лишних данных. Подход, описанный в статье вполне может стать стандартной техникой написания более компактного и багоустойчивого кода, то есть стать одним из шаблонов проектирования на Java.
### VII. Ссылки и литература\*
1. [jcp.org/en/jsr/detail?id=305](http://jcp.org/en/jsr/detail?id=305)
2. [www.jetbrains.com/idea/documentation/howto.html](http://www.jetbrains.com/idea/documentation/howto.html)
3. [jcp.org/en/jsr/detail?id=308](http://jcp.org/en/jsr/detail?id=308)
4. [types.cs.washington.edu/checker-framework/current/checkers-manual.html](http://types.cs.washington.edu/checker-framework/current/checkers-manual.html)
5. [homepages.ecs.vuw.ac.nz/~djp/JACK](http://homepages.ecs.vuw.ac.nz/~djp/JACK/)
6. [blogs.oracle.com/darcy/entry/project\_coin\_final\_five](https://blogs.oracle.com/darcy/entry/project_coin_final_five)
7. [metoojava.wordpress.com/2010/11/15/java-7-awesome-features](http://metoojava.wordpress.com/2010/11/15/java-7-awesome-features/)
8. [groovy.codehaus.org/Operators](http://groovy.codehaus.org/Operators)
9. [commons.apache.org/lang/api-2.5/org/apache/commons/lang/StringUtils.html](http://commons.apache.org/lang/api-2.5/org/apache/commons/lang/StringUtils.html)
10. [commons.apache.org/beanutils/apidocs/org/apache/commons/beanutils/package-summary.html#package\_description](http://commons.apache.org/beanutils/apidocs/org/apache/commons/beanutils/package-summary.html#package_description)
11. [findbugs.sourceforge.net](http://findbugs.sourceforge.net/)
12. [pmd.sourceforge.net](http://pmd.sourceforge.net/)
13. [eclipse.org/aspectj/doc/released/adk15notebook/index.html](http://eclipse.org/aspectj/doc/released/adk15notebook/index.html)
14. [eclipse.org/aspectj/doc/released/progguide/index.html](http://eclipse.org/aspectj/doc/released/progguide/index.html)
15. AspectJ in Action. Second Edition. ISBN 978-1-933988-05-4
16. [www.eclipse.org/aspectj/doc/next/devguide/ltw.html](http://www.eclipse.org/aspectj/doc/next/devguide/ltw.html)
17. [static.springsource.org/spring/docs/3.2.x/spring-framework-reference/html/aop.html#aop-aj-ltw](http://static.springsource.org/spring/docs/3.2.x/spring-framework-reference/html/aop.html#aop-aj-ltw)
18. [sourceforge.net/projects/nullsafe/files](https://sourceforge.net/projects/nullsafe/files/)
\*все интернет-ссылки на момент написания статьи были действительны
02/2013 Oleg Nikolaenko | https://habr.com/ru/post/169827/ | null | ru | null |
# Чат вконтакта в качестве терминала
Вдохновлённый постом [«Простой диспетчер задач с веб-интерфейсом, написанный на языке GO для Unix-систем включая Android»](http://habrahabr.ru/post/247727/), языком Go и утилитой [simple status](https://github.com/cdarwin/simple_status), я решил написать в качестве забавного эксперимента чат-бота для социальной сети Vkontakte со схожим функционалом.
Почему выбор пал на чат-бота и социальную сеть? Кроме очевидного just for fun имеются и практические выкладки:
* Не нужны дополнительные телодвижения для доступа к приложению, запущенном на компьютере с динамическим ip или находящимся за роутером.
* Доступ к Вконтактике есть практически везде – достаточно иметь при себе телефон с доступом в интернет.
* Вопрос о реализации аутентификации на уровне конечного приложения практически отпадает.
Утилита представляет собой простого чат бота, реагирующего на текстовые команды. Пишем в VK сообщение самому себе, утилита с некоторой периодичностью опрашивает VK API и получает список сообщений. Дальше только остаётся сопоставить введённое сообщение со списком предопределённых текстовых команд.
Ничего сложного, правда есть некоторые нюансы, которые надо знать про VK API.
Во-первых, для доступа к личным сообщениям надо регистрировать VK приложение как desktop. И при запросе access token выставить права на доступ к личным сообщениям и «бланковую» страницу для callback.
Адрес для получения access token будет выглядеть примерно так:
```
https://oauth.vk.com/authorize?client_id=#####&scope=offline,messages&redirect_uri=https%3A%2F%2Foauth.vk.com%2Fblank.html&display=page&v=5.28&response_type=token
```
Во-вторых, есть ограничение по количеству запросов в секунду, поэтому получение сообщений происходит с таймером в 2 секунды.
```
c := time.Tick(2 * time.Second)
lastMsgId := int64(0)
for _ = range c {
msgs, err := getMsgs(lastMsgId)
if err != nil {
fmt.Println(err)
} else {
if len(msgs.Response.Items) > 0 {
lastMsgId = msgs.Response.Items[0].Id
}
for _, msg := range msgs.Response.Items {
msgBody := strings.Trim(msg.Body, "")
if checkVkId(msg.UserId) && checkTime(msg.Date) && checkResultPrefix(msgBody) {
go doCmd(msgBody)
}
}
}
}
```
Разбор входящего сообщения и отправка результата исполнения команды:
```
func doSysCmd(msg string) {
switch true {
case strings.HasPrefix(msg, "@sys/host"):
sendMsg(*vk_id, fmt.Sprintf("%+v", sysstat.GetHost()))
case strings.HasPrefix(msg, "@sys/disk"):
sendMsg(*vk_id, fmt.Sprintf("%+v", sysstat.GetDisk("/")))
case strings.HasPrefix(msg, "@sys/load"):
sendMsg(*vk_id, fmt.Sprintf("%+v", sysstat.GetLoad()))
case strings.HasPrefix(msg, "@sys/ram"):
sendMsg(*vk_id, fmt.Sprintf("%+v", sysstat.GetRam()))
case strings.HasPrefix(msg, "@sys"):
sendMsg(*vk_id, fmt.Sprintf("\n%+v", sysstat.GetSystem("/")))
case strings.HasPrefix(msg, "@sh"):
args := strings.SplitN(msg, " ", 2)
if len(args) < 2 {
return
}
fmt.Println("exec: ", args[1])
sendMsg(*vk_id, fmt.Sprintf(" %+v", sysstat.ExecShell(args[1])))
}
}
```
Кроме получения текущего статуса системы в качестве бонуса можно сохранять произвольные заметки командами:
> !list – вывод сохраненного списка с номерами id
>
> !add [текст] – добавить новую запись
>
> !del [номер] – удалить запись с указанным id
Заметки сохраняются исключительно в памяти.
Защита от краха приложения не предусмотрена, я взял за практику запускать подобные вещи под супервизором, который сам перезапускает приложение, если возникнет критическая ошибка. Потребление ОЗУ для go программ традиционно минимально и колеблется в районе 10 МБ, ещё столько же отнимает супервизор.
Исходники на [github](https://github.com/ZurgInq/vk_bot). | https://habr.com/ru/post/251083/ | null | ru | null |
# Сравнение методов прогнозирования конверсии цепочек рекламных каналов
Самая суть [цепочек рекламных каналов](https://en.wikipedia.org/wiki/Attribution_(marketing)) вызывает непреодолимое желание узнать, что вероятнее всего произойдет дальше в цепочке. Будет конверсия или нет?
Но это похвальное стремление часто утыкается в проблему. Если пытаться удерживать количество [ложно-положительных](https://en.wikipedia.org/wiki/Binary_classification) результатов в разумных рамках, количество истинно-положительных не впечатляет. Как следствие — результаты анализа зачастую не позволяют нам принимать адекватные управленческие решения. Адекватное прогнозирование требует больше данных, чем просто короткие цепочки пользовательских [прикосновений к каналам](https://www.optimizesmart.com/touch-point-analysis-google-analytics-attribution-modelling/#a1). Но это вовсе не значит, что задачу стоит бросать.
[](https://habr.com/ru/post/443562/)
В этой статье мы расскажем вам немного о серии экспериментов по разработке алгоритма прогнозирования конверсии. Эта статья — продолжение двух предыдущих на схожую тематику. [Вот первая](https://habr.com/ru/company/maxilect/blog/435000/), [Вот вторая](https://habr.com/ru/company/maxilect/blog/439356/).
Постановка задачи
-----------------
Любой, кто имел дело с машинным обучением в контексте прогнозирования, знаком с [LSTM](https://en.wikipedia.org/wiki/Long_short-term_memory) ([RNN](https://en.wikipedia.org/wiki/Recurrent_neural_network) нейронными сетями). Но у нас «прогнозирование» сводится к еще более простой задаче. Спрогнозировать конверсию — это значит классифицировать ту или иную цепочку, как принадлежащую классу «сконвертировавшихся в будущем».
Для LSTM существует огромное количество отличных материалов по созданию системы, которая предсказывает значения [временных рядов](https://machinelearningmastery.com/time-series-prediction-lstm-recurrent-neural-networks-python-keras/) и [буквы в словах](https://machinelearningmastery.com/text-generation-lstm-recurrent-neural-networks-python-keras/). В нашем случае задача была еще проще, на первый взгляд.
* Анализируя взаимодействие каналов, мы можем составить то, что выглядит как алфавит, где буквы — это отдельные каналы. Например — «(канал) 1», «(канал) 2»,…
* Из букв получается огромное количество «слов» в виде цепочек, которые являются всевозможными комбинациями взаимодействий между пользователем и каналами. Например, цепочка = «1», «2», «1», «3»; цепочка = «2», «4», «4», «1»;…
*Рис.1. Обработка грубых данных для удаления слишком коротких и расщепления слишком длинных цепочек.*
Наша цель — определить комбинацию касаний, которая максимизирует вероятность конверсии по всей базе потребителей для цепочек выбранной длины. Для этого мы выделяем слова (цепочки) требуемой длины из всей выборки. Если цепочка длиннее заданной, она расщепляется на несколько цепочек желаемой длины. Например — (1,2,3,4) -> (1,2,3), (2,3,4). Процесс обработки изображен на рисунке 1.
Первая попытка найти простое решение.
-------------------------------------
В этой попытке мы обучили сеть LSTM «почти сырым» цепочками одной длинны и получили значение [RUC AUC](https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve) где-то около 0.5, что говорит нам, что точность классификатора стремится к эффективности подброса монетки. Упс. Не сработало. Но попытаться сделать в тупую же стоило? Вдруг бы прокатило. Но нет. Пришлось немного подумать.
Анализ происходящего
--------------------
**Ключевое наблюдение 1**
[Однородные цепочки](https://habr.com/ru/company/maxilect/blog/435000/) в этом исследовании бесполезны. У них конверсия зависит только от длины цепочки и номера канала, классификатор [для них](https://habr.com/ru/company/maxilect/blog/439356/) строится [логистической мультирегрессией](https://en.wikipedia.org/wiki/Logistic_regression) с двумя факторами. Категориальный фактор — номер канала, и числовой — длина цепочки. Получается довольно прозрачно, хотя и бесполезно, потому что достаточно длинные цепочки в любом случае подозрительны на конверсию. Поэтому их можно не рассматривать вообще. Тут, надо отметить, что размер выборки существенно сокращается, потому что обычно где-то 80% всех цепочек однородные.
**Ключевое наблюдение 2**
Можете выбросить все (принципиально) неактивные каналы, чтобы ограничить объем данных.
**Ключевое наблюдение 3**
Для любой цепочки вы можете применить [one-hot](https://en.wikipedia.org/wiki/One-hot) кодирование. Это устраняет проблему, которая может возникнуть, если маркировать каналы как числовую последовательность. Например, выражение 3 — 1 = 2 не имеет смысла, если числа это номера каналов (Рис.2.).
Кроме всего прочего, мы попытались закодировать цепочку еще некоторым количеством странных способов, которые строились на различных предположениях о природе цепочек. Но так как это нам ничем не помогло, мы об этом говорить не будем. *Рис.2. Второе преобразование данных. Удалите все однородные цепи, примените one-hot кодирование.*
Вторая попытка простого решения
-------------------------------
Для разных вариантов кодировки цепочек были испробованы такие инструменты для классификации:
* LSTM
* Multiple LSTM
* [Многослойный персептрон (2,3,4, слоя)](https://en.wikipedia.org/wiki/Multilayer_perceptron)
* [Random Forest](https://en.wikipedia.org/wiki/Random_forest)
* [Gradient Boosting Classifier](http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingClassifier.html)(GBC)
* [SVM](https://en.wikipedia.org/wiki/Support_vector_machine)
* [Deep Convolutional Network](https://skymind.ai/wiki/convolutional-network) (c 2 слоями, чисто на всякий случай)
Параметры всех моделей оптимизировались с помощью алгоритма [Basin-hopping](https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.optimize.basinhopping.html). Результат оптимизма не вызывал. AUC ROC поднялся до 0.6, но в нашем случае этого было явно недостаточно.
Третья попытка: простое решение.
--------------------------------
Все происходящее естественным образом привело к мысли, что наиболее важно разнообразие состава каналов цепочек и фактический состав каналов при условии цепочек одинаковой длины. Это не настолько банальная мысль, потому что обычно считается, что еще важен порядок. Но предыдущие эксперименты с LSTM показали, что даже если это и так, это сильно нам не поможет. Поэтому надо максимально сфокусироваться на составе цепочки.
Например, можно удалить все дубли из цепочки и отсортировать, полученный список. Это можно сделать примерно таким простым кодом на питоне:
```
sorted_chain = tuple(sorted(list(set(chain))))
```
Преобразование к tuple нужно, чтобы потом использовать эту цепочку как ключ в словаре паттернов. После этого можно сосчитать, сколько и каких цепочек получилось. Получается, как на рисунке 3.
*Рис.3. Сортировка и подсчет шаблонов цепочек*
На первом проходе мы можем рассчитать средний коэффициент конверсии для каждой цепочки «шаблона» в данных.
Теперь мы сортируем получившийся список по убыванию конверсии и получаем классификатор с параметром «отсечки по конверсии». Проверяя тестовую цепочку, преобразованную вышеуказанным методом, на наличие одного из паттернов из списка с конверсией больше заданной, мы классифицируем ее как ту, которая породит конверсию, или бесполезную. Теперь мы можем протестировать все входящие цепочки с помощью этого классификатора уровня конверсии и предсказать результат. На основе того, что вышло, мы построили единственный график в этой статье, который показывает преимущество такого подхода. ROC кривую для этого подхода, который тут назван — Pattern Check.
*Рис.4. ROC кривые для разных классификаторов.*
Для нашего нового метода AUC = 0.7. Это уже что-то. Не прям победа, но уже далеко не подброс монетки. Замечание. Этот метод можно реализовать и без использования one-hot, как тут и описано для понятности, но при желании развить успех, он уже может потребоваться.
Выводы
------
При слове «паттерн» у людей, знакомых с машинным обучением сразу возникает мысль — «сверточные нейронные сети!» Да. Это так, но мы про это сейчас писать не будем. Мы привели тут неплохой, как нам кажется, метод преобразования цепочек, который с ходу дает возможность получить классификатор(предиктор), который работает лучше, чем использование в лоб даже самых продвинутых технологий. Его уже можно использовать для выделения группы пользователей с большой вероятностью конверсии и не бояться тысяч ложно-положительных. Для наших данных, при выборе отсечки в алгоритме по конверсии 0.25, мы получили для 5112 конверсий тестовой выборки, 523 истинно положительных и 1123 ложно-положительных, что в принципе, терпимо, при условии, что в тесте было 67 тыс. человек.
**P.S.** Чтобы быть в курсе новостей компании Maxilect и первыми узнавать обо всех публикациях, подписывайтесь на наши страницы в [VK](https://vk.com/maxilect), [FB](https://www.facebook.com/maxilectru/) или [Telegram-канал](https://t.me/maxilect). | https://habr.com/ru/post/443562/ | null | ru | null |
# Настройка в OpenSearch аутентификации и авторизации пользователей через Active Directory по протоколу LDAP
В этой статье я расскажу о том, как я настраивал аутентификацию и авторизацию доменных пользователей Active Directory в OpenSearch. В домене я не обладаю правами администратора домена и не могу влиять на структуру каталогов Active Directory. А сценарий настройки Active Directory в OpenSearch, предлагаемый на официальном сайте, применить к домену с разветвленной структурой каталогов оказалось не так просто, как хотелось бы.
**Содержание**
[1. Предисловие](#section1)
[2. Введение](#section2)
[3. Постановка задачи](#section3)
[4. Коротко об объектах настройки конфиденциальности в OpenSearch](#section4)
[5. Настройка LDAP](#section5)
[6. Получаем полный путь к объектам в AD](#section6)
[7. Применение настроек](#section7)
[8. Проблема применения настроек](#section8)
[9. Добавляем внутренних пользователей](#section9)
[10. Добавляем роли для пользователей AD](#section10)
[11. Добавляем «Backend» роли для пользователей AD](#section11)
[12. Послесловие](#section12)
1. Предисловие
--------------
Эта статья является продолжением статьи [«Установка, настройка и эксплуатация стэка OpenSearch в классической среде»](https://habr.com/ru/post/662527/). Однако, тема этой статьи достаточно узкая и практически не зависит от основной настройки всего стека OpenSearch (материала первой статьи). Поэтому эту статью можно считать самостоятельной.
2. Введение
-----------
Сразу отмечу, что в качестве Веб-интерфейса я использую OpenSearch-Dashboards. И в основном именно для OpenSearch-Dashboards мне нужна доменная авторизация.
Для того, чтобы настроить аутентификацию и авторизацию доменных пользователей Active Directory в OpenSearch по протоколу LDAP необходимо сконфигурировать файл «<основной\_каталог\_opensearch>/plugins/opensearch-security/securityconfig/config.yml» (в моем случае полный путь к этому файлу такой «/opt/opensearch/plugins/opensearch-security/securityconfig/config.yml»).
В файле конфигурации за аутентификацию и авторизацию отвечают два разных блока: «config.authc.ldap» и «config.authz.roles\_from\_myldap» соответственно. Так как я подключаю OpenSearch к одному единственному домену AD для авторизации и аутентификации пользователей, то частично конфигурация обоих блоков у меня будет совпадать. Если точнее, то вот эти блоки у меня будут совпадать: «config.authc.ldap.authentication\_backend.config.users» и «config.authz.roles\_from\_myldap.authorization\_backend.config.users».
3. Постановка задачи
--------------------
В домене Active Directory имеется три доменные группы: «Department05-Developers», «Department05-Admins», «Department05-Analysts». Необходимо, чтобы все пользователи домена, состоящие хотя бы в одной из этих трех доменных групп, могли войти в OpenSearch-Dashboards под своей доменной учетной записью и получили определенные роли в OpenSearch.
Для примера будем считать, что в каждой из этих доменных групп будет только по одному пользователю. В группе «Department05-Developers» состоит пользователь: «Пушкин Александр Сергеевич (PushkinAS)». В группе «Department05-Admins» состоит пользователь: «Горький Максим (GorkiiM)». В группе «Department05-Analysts» состоит пользователь: «Толстой Лев Николаевич (TolstoiLN)».
Договоримся, что FQDN контроллера домена AD будет таким: «server-ad.my.big.domain».
Договоримся, что учетная запись домена AD, предназначенная для просмотра LDAP будет такая: «user\_for\_LDAP». А пароль у неё будет такой: «Au5dUJ9q!54S». Отмечу, что нет необходимости давать этой учетной записи администраторские права.
Договоримся о том, что все три пользователя («PushkinAS», «GorkiiM», «TolstoiLN») находятся в разных населенных пунктах, а структура каталогов в AD учитывает населенный пункт при создании учетной записи, то есть учетные записи будут находиться по разным адресам в AD.
4. Коротко об объектах настройки конфиденциальности в OpenSearch
----------------------------------------------------------------
В OpenSearch, как и во многих других системах, для распределения привилегий в системе используются учетные записи.
Каждая учетная запись может иметь набор прав доступов, которые наделяют пользователя полномочиями.
Определенный набор прав доступов объединяется в роль. Пользователь может иметь как одну, так и несколько ролей. В случае, когда пользователю назначены несколько ролей, права доступов которых противоречат друг другу, преимущество имеют права, дающие пользователю больший доступ.
Например, если дать права администратора и наблюдателя одновременно, то фактически пользователь будет иметь права администратора.
А вот «Backend» роль сущность несколько абстрактная. «Обычная» роль может иметь «Backend» роль или даже несколько «Backend» ролей. Пользователь тоже может иметь «Backend» роль или даже несколько «Backend» ролей. Если «Backend» роль есть у пользователя, и эта же «Backend» роль есть у «обычной» роли, то такой пользователь становится обладателем этой «обычной» роли.
«Backend» роли становятся актуальными для использования при доменной авторизации. Потому как доменные пользователи не доступны для настройки прав или «обычных» ролей, они могут получить только «Backend» роль автоматически, в зависимости от настроенной конфигурации.
5. Настройка LDAP
-----------------
Для наглядности я сразу приведу уже сконфигурированный файл «config.yml» целиком (в моем случае это файл «/opt/opensearch/plugins/opensearch-security/securityconfig/config.yml»).
**/opt/opensearch/plugins/opensearch-security/securityconfig/config.yml**
```
---
# This is the main OpenSearch Security configuration file where authentication
# and authorization is defined.
_meta:
type: "config"
config_version: 2
config:
dynamic:
# Set filtered_alias_mode to 'disallow' to forbid more than 2 filtered aliases per index
# Set filtered_alias_mode to 'warn' to allow more than 2 filtered aliases per index but warns about it (default)
# Set filtered_alias_mode to 'nowarn' to allow more than 2 filtered aliases per index silently
#filtered_alias_mode: warn
#do_not_fail_on_forbidden: false
#kibana:
# Kibana multitenancy
#multitenancy_enabled: true
#server_username: kibanaserver
#index: '.kibana'
http:
anonymous_auth_enabled: false
xff:
enabled: false
internalProxies: '192\.168\.0\.10|192\.168\.0\.11' # regex pattern
#internalProxies: '.*' # trust all internal proxies, regex pattern
#remoteIpHeader: 'x-forwarded-for'
###### see https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html for regex help
###### more information about XFF https://en.wikipedia.org/wiki/X-Forwarded-For
###### and here https://tools.ietf.org/html/rfc7239
###### and https://tomcat.apache.org/tomcat-8.0-doc/config/valve.html#Remote_IP_Valve
authc:
kerberos_auth_domain:
http_enabled: false
transport_enabled: false
order: 6
http_authenticator:
type: kerberos
challenge: true
config:
# If true a lot of kerberos/security related debugging output will be logged to standard out
krb_debug: false
# If true then the realm will be stripped from the user name
strip_realm_from_principal: true
authentication_backend:
type: noop
basic_internal_auth_domain:
description: "Authenticate via HTTP Basic against internal users database"
http_enabled: true
transport_enabled: true
order: 4
http_authenticator:
type: basic
challenge: true
authentication_backend:
type: intern
proxy_auth_domain:
description: "Authenticate via proxy"
http_enabled: false
transport_enabled: false
order: 3
http_authenticator:
type: proxy
challenge: false
config:
user_header: "x-proxy-user"
roles_header: "x-proxy-roles"
authentication_backend:
type: noop
jwt_auth_domain:
description: "Authenticate via Json Web Token"
http_enabled: false
transport_enabled: false
order: 0
http_authenticator:
type: jwt
challenge: false
config:
signing_key: "base64 encoded HMAC key or public RSA/ECDSA pem key"
jwt_header: "Authorization"
jwt_url_parameter: null
roles_key: null
subject_key: null
authentication_backend:
type: noop
clientcert_auth_domain:
description: "Authenticate via SSL client certificates"
http_enabled: false
transport_enabled: false
order: 2
http_authenticator:
type: clientcert
config:
username_attribute: cn #optional, if omitted DN becomes username
challenge: false
authentication_backend:
type: noop
ldap:
description: "Authenticate via LDAP or Active Directory"
http_enabled: true
transport_enabled: false
order: 5
http_authenticator:
type: basic
challenge: false
authentication_backend:
# LDAP authentication backend (authenticate users against a LDAP or Active Directory)
type: ldap
config:
# enable ldaps
enable_ssl: false
# enable start tls, enable_ssl should be false
enable_start_tls: false
# send client certificate
enable_ssl_client_auth: false
# verify ldap hostname
verify_hostnames: true
hosts:
- server-ad.my.big.domain:389
bind_dn: 'cn=user_for_LDAP,ou=Service Accounts,ou=Moscow,dc=MY,dc=BIG,dc=DOMAIN'
password: 'Au5dUJ9q!54S'
users:
1-userbase:
base: 'CN=Пушкин Александр Сергеевич (PushkinAS),OU=Users,OU=Saint_Petersburg,DC=MY,DC=BIG,DC=DOMAIN'
search: '(sAMAccountName={0})'
2-userbase:
base: 'CN=Горький Максим (GorkiiM),OU=Users,OU=Nizhny_Novgorod,DC=MY,DC=BIG,DC=DOMAIN'
search: '(sAMAccountName={0})'
3-userbase:
base: 'CN=Толстой Лев Николаевич (TolstoiLN),OU=Users,OU=Yasnaya_Polyana,DC=MY,DC=BIG,DC=DOMAIN'
search: '(sAMAccountName={0})'
username_attribute: 'cn'
authz:
roles_from_myldap:
description: "Authorize via LDAP or Active Directory"
http_enabled: true
transport_enabled: false
authorization_backend:
# LDAP authorization backend (gather roles from a LDAP or Active Directory, you have to configure the above LDAP authentication backend settings too)
type: ldap
config:
# enable ldaps
enable_ssl: false
# enable start tls, enable_ssl should be false
enable_start_tls: false
# send client certificate
enable_ssl_client_auth: false
# verify ldap hostname
verify_hostnames: true
hosts:
- server-ad.my.big.domain:389
bind_dn: 'cn=user_for_LDAP,ou=Service Accounts,ou=Moscow,dc=MY,dc=BIG,dc=DOMAIN'
password: 'Au5dUJ9q!54S'
users:
1-userbase:
base: 'CN=Пушкин Александр Сергеевич (PushkinAS),OU=Users,OU=Saint_Petersburg,DC=MY,DC=BIG,DC=DOMAIN'
search: '(sAMAccountName={0})'
2-userbase:
base: 'CN=Горький Максим (GorkiiM),OU=Users,OU=Nizhny_Novgorod,DC=MY,DC=BIG,DC=DOMAIN'
search: '(sAMAccountName={0})'
3-userbase:
base: 'CN=Толстой Лев Николаевич (TolstoiLN),OU=Users,OU=Yasnaya_Polyana,DC=MY,DC=BIG,DC=DOMAIN'
search: '(sAMAccountName={0})'
username_attribute: 'cn'
roles:
1-rolebase:
base: 'CN=Department05-Developers,OU=Groups,OU=Moscow,DC=MY,DC=BIG,DC=DOMAIN'
search: '(member={0})'
2-rolebase:
base: 'CN=Department05-Admins,OU=Groups,OU=Moscow,DC=MY,DC=BIG,DC=DOMAIN'
search: '(member={0})'
3-rolebase:
base: 'CN=Department05-Analysts,OU=Groups,OU=Moscow,DC=MY,DC=BIG,DC=DOMAIN'
search: '(member={0})'
userroleattribute: null
userrolename: memberOf, SamAccountName
rolename: "cn"
resolve_nested_roles: false
roles_from_another_ldap:
description: "Authorize via another Active Directory"
http_enabled: false
transport_enabled: false
authorization_backend:
type: ldap
```
Описание всех параметров вы можете посмотреть на официальном сайте OpenSearch (<https://opensearch.org/docs/latest/security-plugin/configuration/ldap/>). Я опишу только некоторые параметры и моменты, которые вызвали у меня затруднения.
В параметре «config.authc.ldap.authentication\_backend.config.users» (и в параметре «config.authz.roles\_from\_myldap.authorization\_backend.config.users») содержится путь в LDAP по которому производится поиск учетных записей, которые смогут аутентифицироваться (и авторизоваться). Можно указать каталог, в котором содержатся учетные записи, и все учетные записи из этого каталога смогут аутентифицироваться (и авторизоваться), но при этом не получится отфильтровать учетные записи, которые не должны иметь возможность аутентификации (и авторизации). Так же вместо каталога можно указать саму учетную запись, которой нужно дать возможность аутентифицироваться (и авторизоваться). Таких каталогов или учетных записей можно указать любое количество.
В нашем случае, например, учетная запись «PushkinAS» расположена по адресу «OU=Users,OU=Saint\_Petersburg,DC=MY,DC=BIG,DC=DOMAIN». Но в этом же каталоге есть и другие учетные записи, для которых аутентификация (и авторизоваться) должна быть запрещена.
Одним из вариантов решения этой проблемы, я думаю, будет создание проксирующего LDAP сервера. Однако в моем случае пользователей не очень много и меняются они редко, и я пошел другим путем.
Простым решением для разграничения прав по аутентификации (и авторизации) будет создание списка из путей в LDAP к каждому пользователю, которым позволено аутентифицироваться (и авторизоваться) на сервере.
```
…
1-userbase:
base: 'CN=Пушкин Александр Сергеевич (PushkinAS),OU=Users,OU=Saint_Petersburg,DC=MY,DC=BIG,DC=DOMAIN'
search: '(sAMAccountName={0})'
2-userbase:
base: 'CN=Горький Максим (GorkiiM),OU=Users,OU=Nizhny_Novgorod,DC=MY,DC=BIG,DC=DOMAIN'
search: '(sAMAccountName={0})'
3-userbase:
base: 'CN=Толстой Лев Николаевич (TolstoiLN),OU=Users,OU=Yasnaya_Polyana,DC=MY,DC=BIG,DC=DOMAIN'
search: '(sAMAccountName={0})'
…
```
Так как нужно получить список пользователей AD, состоящих хотя бы в одной из трех доменных групп, получить к каждому из этих пользователей путь в LDAP (AD) и внести эти данные в конфигурацию в параметр «config.authc.ldap.authentication\_backend.config.users» и в параметр «config.authz.roles\_from\_myldap.authorization\_backend.config.users» я составил PowerShell скрипт, который всё это сделает и сгенерирует фрагмент конфигурации для этих параметров.
Думаю, знатоки PowerShell найдут что можно оптимизировать в этом скрипте, но главное, что он работает. Приведу текст скрипта:
**Get\_fragment\_of\_config.ps1**
```
$null=(chcp 1251)
# Список доменных групп
$List_of_groups =@(
"Department05-Developers"
"Department05-Admins"
"Department05-Analysts"
)
$List_users_text=""
# Собираем в единый текст список логинов
Foreach ($groups_n in $List_of_groups) {
$t=(net group $groups_n /domain)
for ($i=8; $i -le $t.Count-3; $i++){
$List_users_text+=$t[$i]
}
}
# Удаляем двойные пробелы
for ($i=1; $i -le 15; $i++){
$List_users_text=$List_users_text -replace "\s\s", " "
}
# Разбиваем логины на элементы массива
$List_users=@()
$List_users+=$List_users_text.Split(" ")
# Удаляем дубликаты логинов, если один и тот же логин есть в нескольких группах
$List_users = $List_users | select -uniq
# Сортируем логины по алфавиту
$List_users = $List_users | sort-object
# Удаляем первый элемент массива (пустая строка)
$null, $List_users = $List_users
# Получаем список логинов в формате пути LDAP, без префикса "LDAP://"
$List_users_LDAP=@()
Foreach ($user_n in $List_users) {
$user_name="*("+$user_n+")*"
$List_users_LDAP+=(([adsisearcher]“(&(objectcategory=person)(cn=$user_name))”).Findall()).Path -replace "LDAP://", ""
}
# Оставим только строки с содержанием (Удаляем пустые строки)
$List_users_LDAP2=@()
Foreach ($user_n in $List_users_LDAP) {
if (($user_n[0] -eq "C") -and ($user_n[1] -eq "N")) {
$List_users_LDAP2+=$user_n
}
}
$List_users_LDAP=$List_users_LDAP2
# Формируем конфиг
[int]$counter=1
# переменная - отступ; пробелы перед каждой строкой, для YAML
$before=" "
# конечный текст будет в переменной $config
$config=""
$config+=$before+'users:'+[System.Environment]::NewLine
Foreach ($user_n in $List_users_LDAP) {
$config+=$before+" "+$counter+"-userbase:"+[System.Environment]::NewLine
$config+=$before+" "+'base: '''+$user_n+''''+[System.Environment]::NewLine
$config+=$before+" "+'search: ''(sAMAccountName={0})'''+[System.Environment]::NewLine
$counter++
}
# Выводим конфиг
$config
```
Отмечу переменную «$user\_name». В моем случае, как я показывал в примерах, «CN» учетной записи имеет вид «Пушкин Александр Сергеевич (PushkinAS)», где «(PushkinAS)» является sAMAccountName (логином). Поэтому строка «$user\_name="\*("+$user\_n+")\*"» в моем случае позволит достоверно отфильтровать каждую учетную запись. Если в вашем домене Active Directory «CN» формируется иначе, то эту строку нужно будет скорректировать. В остальном, я надеюсь, скрипт получился универсальным.
Параметр «config.authz.roles\_from\_myldap.authorization\_backend.config.roles» содержит путь в LDAP по которому происходит поиск объектов, которые станут «Backend» ролями, в нашем случае этими объектами будут доменные группы. Таких каталогов можно указать любое количество. Укажем в этом параметре группы: «Department05-Developers», «Department05-Admins», «Department05-Analysts». Позже настроим на эти группы роль «readall», которая позволит просматривать все индексы.
```
…
1-rolebase:
base: 'CN=Department05-Developers,OU=Groups,OU=Moscow,DC=MY,DC=BIG,DC=DOMAIN'
search: '(member={0})'
2-rolebase:
base: 'CN=Department05-Admins,OU=Groups,OU=Moscow,DC=MY,DC=BIG,DC=DOMAIN'
search: '(member={0})'
3-rolebase:
base: 'CN=Department05-Analysts,OU=Groups,OU=Moscow,DC=MY,DC=BIG,DC=DOMAIN'
search: '(member={0})'
…
```
Параметр «config.authz.roles\_from\_myldap.authorization\_backend.config.userrolename». Значение «memberOf» сделает доменные группы доменного пользователя его «Backend» ролями, а значение «SamAccountName» сделает параметр доменной учетной записи «SamAccountName» (логин) «Backend» ролью доменного пользователя. Это позволит выдавать права доменным пользователям и по его группам, и по его логину.
```
…
userrolename: memberOf, SamAccountName
…
```
6. Получаем полный путь к объектам в AD
---------------------------------------
Полный путь к группе в AD через PowerShell можно получить так:
```
$group = ([adsisearcher]“(&(objectcategory=group)(cn=name_of_group))”).Findall()
$group
```
Вместо «name\_of\_group» подставьте название нужной вам группы.
Полный путь к пользователю в AD через PowerShell можно получить так:
```
$what_find="*("+"user_name"+")*"
$user = ([adsisearcher]“(&(objectcategory=person)(cn=$what_find))”).Findall()
$user
```
В переменную «$what\_find» подставьте логин нужного вам пользователя, в формате, который используется в вашем домене AD.
7. Применение настроек
----------------------
Для применения настроек, сделанных в файле «/opt/opensearch/plugins/opensearch-security/securityconfig/config.yml» (а также всех других файлов конфигураций в «/opt/opensearch/plugins/opensearch-security/securityconfig/») нужно запустить скрипт «/opt/opensearch/plugins/opensearch-security/tools/securityadmin.sh» и заново сгенерировать сертификаты, сделать это можно так:
```
cd /opt/opensearch/plugins/opensearch-security/tools
./securityadmin.sh -cd ../securityconfig/ -icl -nhnv \
-cacert ../../../config/root-ca.pem \
-cert ../../../config/kirk.pem \
-key ../../../config/kirk-key.pem
```
8. Проблема применения настроек
-------------------------------
Выполнение команды для применения настроек удаляет все изменения, сделанные в OpenSearch-Dashboards в разделе «Security», то есть все настройки пользователей и ролей. И это является проблемой, так как в конфигурацию со временем будет необходимо добавлять новых пользователей и удалять старых пользователей.
Видимо разработчики OpenSearch всё же подразумевают, что все пользователи в AD лежат в одном каталоге и «лишних» пользователей там нет. Либо всё-таки подразумевается использование проксирующего LDAP сервера. Другого объяснения я не нашел.
Для того чтобы обойти эту проблему можно вносить изменения не в Web-интерфейсе (OpenSearch-Dashboards), а через файлы конфигураций.
Далее опишу настройку конфигурационных файлов.
9. Добавляем внутренних пользователей
-------------------------------------
Добавим двух пользователей: «my\_admin» — с полным доступом ко всему (admin), «guest» — с правами на просмотр всех индексов.
Для этого отредактируем файл «/opt/opensearch/plugins/opensearch-security/securityconfig/internal\_users.yml»:
**/opt/opensearch/plugins/opensearch-security/securityconfig/internal\_users.yml**
```
...
# Добавить в конце файла
my_admin:
hash: "$2y$12$RYNld1qqXMuCQr7HCU/HnOiOn20smdWUzD4vJan2cdbVrKPtQkVZG"
reserved: false
backend_roles:
- "admin"
description: "Admin"
guest:
hash: "$2y$12$n330lm1W/VOV.VYT0xCQm.N/8HDoAqNzV.oQwnRDjLRXV9PfXSWby"
reserved: false
backend_roles:
- "readall"
description: "Readall"
```
Хэши паролей можно получить так же как описано [здесь](https://habr.com/ru/post/662527/#section2-5).
После редактирования конфигурации не забываем [применить настройки](#section7).
10. Добавляем роли для пользователей AD
---------------------------------------
Добавим две роли: роль «readall\_AD» с аналогичными правами как у роли «readall» — для просмотра всех индексов, роль «admin\_AD» с аналогичными правами как у роли «all\_access» (admin) — с полным доступом ко всему.
Для этого отредактируем файл «/opt/opensearch/plugins/opensearch-security/securityconfig/roles.yml»:
**/opt/opensearch/plugins/opensearch-security/securityconfig/roles.yml**
```
...
# Добавить в конце файла
# Allow AD users read all
readall_AD:
reserved: false
cluster_permissions:
- "cluster_composite_ops_ro"
index_permissions:
- index_patterns:
- '*'
allowed_actions:
- 'read'
# Allow AD users read all
admin_AD:
reserved: false
cluster_permissions:
- '*'
index_permissions:
- index_patterns:
- '*'
allowed_actions:
- '*'
tenant_permissions:
- tenant_patterns:
- '*'
allowed_actions:
- 'kibana_all_read'
- 'kibana_all_write'
```
После редактирования конфигурации не забываем [применить настройки](#section7).
11. Добавляем «Backend» роли для пользователей AD
-------------------------------------------------
Обладателям «Backend» ролей: «Department05-Developers», «Department05-Admins», «Department05-Analysts»; дадим роль «readall\_AD». Обладателям «Backend» ролей: «GorkiiM»; дадим роль «admin\_AD».
Для этого отредактируем файл «/opt/opensearch/plugins/opensearch-security/securityconfig/roles\_mapping.yml»:
**/opt/opensearch/plugins/opensearch-security/securityconfig/roles\_mapping.yml**
```
...
# Добавить в конце файла
readall_AD:
reserved: false
backend_roles:
- "Department05-Developers"
- "Department05-Admins"
- "Department05-Analysts"
admin_AD:
reserved: false
backend_roles:
- "GorkiiM"
```
После редактирования конфигурации не забываем [применить настройки](#section7).
12. Послесловие
---------------
На этом всё. Всем спасибо за внимание к статье, надеюсь она окажется для кого-то полезной. | https://habr.com/ru/post/664874/ | null | ru | null |
# Макросы в С и С++
Макросы - один из моих самых любимых инструментов в языках С и С++. Умные люди и умные книжки советуют по максимуму избегать использования макросов, по возможности заменяя их шаблонами, константами и inline-функциями, и на то есть веские основания. С помощью макросов можно создавать не только изящный код, но и плодить не менее изящные баги, которые потом будет очень сложно отловить и пофиксить. Но если соблюдать ряд несложных правил при работе с макросами, они становятся мощным оружием, которое не стреляет по твоим собственным коленям. Но сперва разберемся, что вообще такое макросы в С и С++?
### Что есть макросы?
В языках С и С++ есть такой механизм, как *препроцессор*. Он обрабатывает исходный код программы ДО того, как она будет скомпилирована. У препроцессора есть свои директивы, такие как *#include, #pragma, #if* и тд. Но нам интересн/а только директива *#define*.
В языке Си довольно распространенной практикой является объявление глобальных констант с помощью директивы *#define*:
```
#define PI 3.14159
```
А потом, на этапе препроцессинга, все использования *PI* будут заменены указанным в объявлении макроса токеном:
```
double area = 2 * PI * r * r;
```
После препроцессинга, который по сути является банальной подстановкой, это выражение превратится в:
```
double area = 2 * 3.14159 * r * r;
```
*PI* - макрос, в самом простом его исполнении. Естественно, макросы в таком виде не работают как переменные. Им нельзя присваивать новое значение или использовать их адрес.
```
// Так нельзя:
PI = 3; // после препроцессинга: 3.14159 = 3
int *x = &PI // после препроцессинга: int *x = &3.14159
```
О макросах важно понимать, что область видимости у них такая же, как у нестатических функций в языке Си, то есть они видны везде, куда их "заинклюдили". Однако в отличии от функций, объявление макроса можно отменить:
```
#undef PI
```
После этой строчки обращаться к PI будет уже нельзя.
### Макросы с параметрами
Самое интересное начинается, когда у макросов появляются параметры. Параметры в макросах работают примерно так же, как аргументы функции. Простой пример - макрос, который определяет больший из переданных ему параметров:
```
#define MAX(a, b) a >= b ? a : b
```
Макрос может состоять не только из одного выражения. Например макрос, который меняет значения двух переменных:
```
#define SWAP(type, a, b) type tmp = a; a = b; b = tmp;
```
Поскольку мы первым параметром передаем тип, данный макрос будет работать с переменными любого типа:
```
SWAP(int, num1, num2)
SWAP(float, num1, num2)
```
Однако использовать данный макрос так, как показано выше (один за другим) не получится, потому что в результате макроподстановки у нас окажется два объявления переменной *tmp* с разными типами. Решить эту проблему позволяет такая синтаксическая конструкция, как [statement expression](https://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html#Statement-Exprs):
```
#define SWAP(type, a, b) ({ type tmp = a; a = b; b = tmp; })
```
С помощью нее мы можем задать область видимости для макроса и безопасно объявлять переменные внутри. Но стоит помнить, что данная конструкция не входит в стандарт Си, а является GNU расширением языка. Она поддерживается компиляторами *gcc* и *clang*.
Также в подобных макросах, вместо передачи типа аргументов первым параметром, полезно использовать оператор *typeof* в языке C или *decltype в* C++*.* С их помощью можно удобно объявлять переменную *tmp* того же типа, что и переданные аргументы:
```
#define SWAP(a, b) ({ decltype(a) tmp = a; a = b; b = tmp; })
```
Макросы также можно записывать в несколько строк, но тогда каждая строка, кроме последней, должна заканчиваться символом '\':
```
#define SWAP(a, b) ({ \
decltype(a) tmp = a; \
a = b; \
b = tmp; })
```
Параметр макроса можно превратить в строку, добавив перед ним знак '#':
```
#define PRINT_VALUE(value) printf("Value of %s is %d", #value, value);
int x = 5;
PRINT_VALUE(x) // -> Value of x is 5
```
А еще параметр можно приклеить к чему-то еще, чтобы получился новый идентификатор. Для этого между параметром и тем, с чем мы его склеиваем, нужно поставить '##':
```
#define PRINT_VALUE (number) printf("%d", value_##number);
int value_one = 10, value_two = 20;
PRINT_VALUE(one) // -> 10
PRINT_VALUE(two) // -> 20
```
### Техника безопасности при работе с макросами
Есть несколько основных правил, которые нужно соблюдать при работе с макросами.
*1. Параметрами макросов не должны быть выражения и вызовы функций.*
Ранее я уже объявлял макрос *MAX*. Но что получится, если попытаться вызвать его вот так:
```
int x = 1, y = 5;
int max = MAX(++x, --y);
```
Со стороны все выглядит нормально, но вот что получится в результате макроподстановки:
```
int max = ++x >= --y ? ++x : --y;
```
В итоге переменная *max* будет равна не 4, как мы ожидали, а 3. Потом можно уйму времени потратить, отлавливая эту ошибку. Так что в качестве аргумента макроса нужно всегда передавать уже конечное значение, а не какое-то выражение или вызов функции. Иначе выражение или функция будут вычислены столько раз, сколько используется этот параметр в теле макроса. Эту проблему также можно решить с помощью описанного выше подхода со *statement expression*:
```
#define MAX(a,b) ({int _a = (a), _b = (b); _a > _b ? _a : _b; })
```
Использование временных переменных *\_a* и *\_b* в данном случае позволяет нам избежать side effect'ов параметров макроса *MAX*.
*2. Все аргументы макроса и сам макрос должны быть заключены в скобки.*
Это правило я уже нарушил при написании макроса *MAX*. Что получится, если мы захотим использовать этот макрос в составе какого-то математического выражения?
```
int result = 5 + MAX(1, 4);
```
По логике, переменная *result* должна будет иметь значение 9, однако вот что мы получаем в результате макроподстановки:
```
int result = 5 + 1 > 4 ? 1 : 4;
```
И переменная result внезапно примет значение 1. Чтобы такого не происходило, макрос MAX должен быть объявлен следующим образом:
```
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
```
В таком случае все действия произойдут в нужном порядке.
*3. Многострочные макросы должны иметь свою область видимости.*
Например у нас есть макрос, который вызывает две функции:
```
#define MACRO() doSomething(); \
doSomethinElse();
```
А теперь попробуем использовать этот макрос в таком контексте:
```
if (some_condition) MACRO()
```
После макроподстановки мы увидим вот такую картину:
```
if (some_condition) doSomething();
doSomethinElse();
```
Нетрудно заметить, что под действие *if* попадет только первая функция, а вторая будет вызываться всегда. Именно для того, чтобы избежать подобных багов, у макросов должна быть объявлена своя область видимости. Для удобства в этих целях принято использовать цикл *do-while.*
```
#define MACRO() do { \
doSomething(); \
doSomethingElse(); \
} while(0)
```
Поскольку в условии цикла стоит ноль, он отработает ровно один раз. Это делается, во первых, для того, чтобы у тела макроса появилась своя область видимости, ограниченная телом цикла, а во вторых, чтобы сделать вызов макроса более привычным, потому что теперь после *MACRO()* нужно будет обязательно ставить точку с запятой. Если бы мы просто ограничили тело макроса фигурными скобками, точку с запятой после его вызова поставить бы не получилось.
```
if (some_condition) MACRO();
```
### Еще немного примеров
В языке Си при помощи макросов можно эффективно избавляться от дублирования кода. Банальный пример - объявим несколько функций сложения для работы с разными типами данных:
```
#define DEF_SUM(type) type sum_##type (type a, type b) { \
type result = a + b; \
return result; \
}
```
Теперь чтобы нагенерировать таких функций для нужных нам типов, нужно просто использовать пару раз этот макрос в глобальной зоне видимости:
```
DEF_SUM(int)
DEF_SUM(float)
DEF_SUM(double)
int main() {
sum_int(1, 2);
sum_float(2.4, 6,3);
sum_double(1.43434, 2,546656);
}
```
Таким образом у нас получился аналог шаблонов из С++. Но стоит сразу обратить внимание, что данный способ не подойдет для типов, название которых состоит более чем из одного слова, например *long long* или *unsigned short*, потому что не получится нормально склеить название функции (*sum\_##type*). Для этого сперва придется объявить для них новый тип, состоящий из одного слова.
В современном С++ можно спокойно обходиться без макросов вовсе, используя только шаблоны и inline-функции. Но в Си жить с макросами все же удобнее, чем без них. При грамотном использовании макросы позволяют избавиться от большого количества дублирования кода и сделать сам код более симпатичным и удобочитаемым.
[**Мой блог в Телеграме**](https://t.me/eignatenko_blog) | https://habr.com/ru/post/546946/ | null | ru | null |
# Переход на новую версию HP Application Lifecycle Management (ALM)
[](http://habrahabr.ru/company/hp/blog/263281/) Привет Хабр!
У каждого HP Application Lifecycle Management (ALM) администратора рано или поздно возникает потребность в переходе на новую версию HP ALM. Большей частью этого процесса является миграция HP ALM проектов. Зачастую, это – довольно тривиальная задача, но иногда возникают моменты, требующие дополнительного разъяснения.
В данной статье я рассмотрю несколько сценариев восстановления HP ALM проектов из резервной копии и последующее обновление.
Итак, ваша компания решила переходить на новую версию HP ALM. После того, как эйфория прошла, пора начать планирование. Для начала стоит понять: можете ли вы напрямую обновиться до новой версии. На данный момент HP ALM поддерживает прямое обновление по следующему принципу:
| | | | | |
| --- | --- | --- | --- | --- |
| | v. 11.00 | v. 11.5x | v. 12.0x | v. 12.2x |
| v. 10.x | + | + | | |
| v. 11.00 | | + | + | + |
| v. 11.5x | | | + | + |
| v. 12.0x | | | | + |
Если вы планируете другой переход, например с v.10.xx до v.12.0x, это также возможно. Для этого вам нужно будет выполнить все, что описано ниже, но с обновлением на промежуточную версию v.10.xx –> 11.5x –> 12.0x. Соответственно, переход просто займёт несколько больше времени.
Следующим шагом будет проверка того, поддерживается ли используемая версия сервера баз данных новой версией HP ALM. Эту информацию можно легко найти на сайте HP в разделе [HP QC/ALM](https://hpln.hp.com/page/alm-qc-enterprise-technical-specifications). Если версия вашего сервера баз данных находится в списке совместимых, и вы не планируете переходить на новую версию (обратный случай мы рассмотрим чуть позже), переходим непосредственно к обновлению.
Для успешного обновления я бы порекомендовал плавный переход, с последовательным обновлением проектов. В случае, если у вас много активных проектов, нужно перестраховаться на случай непредвиденных ситуаций. Резкий переход, а именно обновление всех проектов как часть установки продукта, может остановить работу всей компании.
Первым шагом будет выполнение бюрократической процедуры для получения ресурсов для новой серверной машины.
Далее, приступаем к инсталляции HP ALM, и, как всегда, у нас есть несколько вариантов:
* Обновление базы данных всего продукта и проектов
* Чистая инсталляция, и последующая миграция и обновление проектов на новой базе продукта
В обоих случаях есть свои нюансы, например, при обновлении базы данных продукта, все ваши проекты и настройки появятся на новом сервере, поэтому резервные копии нужно делать заранее и для всех проектов. Во втором случае, ваши настройки и, самое главное, пароли не появятся на новом сервере. Я – поклонник LDAP-аутентификации, поэтому меня это не пугает. Также можно поговорить с администратором базы данных, я думаю – он разберется, как перенести пароли на новый сервер.
В случае, если у вас планируется плавный переход, я бы рекомендовал чистую инсталляцию, но, как всегда, с оговоркой: чтобы сделать вашу жизнь проще, используйте те же пути к файловым хранилищам, пароли и строки подключения (англ. сonnection string), которые были использованы в предыдущей версии, но будьте аккуратнее, чтобы не зацепить «продуктив». Что касается хранилища файлов проектов, я рекомендую перейти на сетевое хранилище, если оно у вас все еще не используется.
Следующим шагом будет выбор проекта для миграции на новую версию. Миграцию стоит начинать, отключив выбранный проект в сайт администрации. Если вы используете контроль версий, то не забудьте, что все сущности должны быть Check-ed In (возвращены). Далее, создайте копию базы данных проекта с помощью администратора сервера баз данных и копию файлового хранилища проекта.
Вы практически готовы, но, если используется MS SQL, еще понадобится выполнить, для копии базы данных проекта, **ПОСТРОЧНО,** следующий скрипт:
```
EXEC sp_change_users_login 'Report'
EXEC sp_change_users_login 'Update_One', 'td', 'td'
EXEC sp_changedbowner 'sa'
```
Этим вы удостоверитесь, что пользователь базы данных, который используется продуктом, сможет работать с восстановленной базой.
Далее вам предстоит работа с файловым хранилищем проекта. Потребуется отредактировать файл, с помощью которого HP ALM сервер узнает детали вашего проекта. Файл называется dbid.xml и находится по пути ````
...\\\
xml version="1.0" encoding="UTF-8"?
имя\_вашего\_проекта для\_Oracle\_изпользуется\_значение\_3\_для\_MS\_SQL\_значение\_2
обычно\_указывается\_дата\_создания connection\_string\_можете\_скорировать\_его\_из\_деталей\_базы\_данных\_в\_сайт\_администрации
имя\_базы\_данных\_проекта имя\_сервера\_базы\_данных\_проекта\_должно\_совпадать\_с\_именем\_сервера\_в\_сайт\_администрации пароль\_пользователя\_базы\_дынных\_имеющего\_права\_работать\_с\_базой\_проекта Включен\_ли\_версионный\_контроль\_для\_проекта\_N/Y путь\_к\_вайловому\_хранилищу\_проекта
не\_изменяйте\_значение
не\_изменяйте\_значение
не\_изменяйте\_значение
не\_изменяйте\_значение
не\_изменяйте\_значение
не\_изменяйте\_значение
```
*\* DB\_USER\_PASS – обычно значение хешировано, если вы не знаете хеш, указывайте пароль в следующем формате TXT:пароль\_в\_чистом\_виде*
Необходимо указать правильные строки подключения (англ. сonnection string), имя сервера базы данных. Эти данные должны совпадать с теми данными, которые указаны в соответствующем разделе вашего HP ALM сервера.
Если вы изменили имя базы данных проекта – не забудьте изменить соответствующее поле в dbid.xml. То же самое касается пути к файловому хранилищу и пароля пользователя баз данных, остальные же поля можно не менять.
Теперь можно подключить проект к HP ALM. Следующие шаги будут более веселыми и связанны они с работой в сайт администрации HP ALM.
1. Идём в сайт-администрацию
2. Нажимаем восстановить проект:
3. Указываем путь к только что отредактированному dbid.xml и выбираем домен для проекта, фактически указывая место в структуре доменов/проектов
4. Нажимаем ОК и вуаля. Ваш проект на новом сервере, правда это еще пол дела. Проект подключен, но он все еще предыдущей версии. Пора перейти к обновлению до нынешней версии продукта
Обновление довольно тривиально:
1. Правый щелчок мыши на проекте
2. Переходим в Меню Maintain Project
3. Делаем Verification
4. Repair
5. И Upgrade
В принципе, можно сразу запустить Upgrade, но я бы порекомендовал именно такой порядок, так как, иногда, возникают моменты, требующие вмешательства. Например, во время проверки были обнаружены ошибки.
Если или Когда, вы получили сообщение о том что все прошло хорошо, стоит еще раз выполнить верификацию.
Результат проверки
------------------
Результат проверки требует отдельного параграфа. Если проверка окончена и никаких проблем не найдено – мы идем дальше. Если же что-то пошло не так, HP ALM выдаст сообщение:
1. Были найдены проблемы, которые могут быть исправлены инструментом восстановления.
2. Были найдены проблемы, которые не могут быть исправлены инструментом восстановления.
В первом случае, просто запускаем инструмент восстановления (Repair Project). Инструмент восстановления является встроенным механизмом, который выполнит некоторые манипуляции с вашим проектом для дальнейшего успешного обновления до последней версии HP ALM.
Во втором случае, понадобится найти лог файл (ссылка на который будет в отчете о проверке проекта) и разобраться, в чем проблема. Я рекомендую привлечь к этому процессу администратора баз данных. Возможно, понадобится изменять какие-то значения напрямую в базе проекта. Также, в некоторых ситуациях, может помочь Exception файл.
HP не поддерживает существование дополнительного объекта в схеме и не рекомендует использовать Exception файл.
При восстановлении проекта лучше использовать эталонные (с той структурой, которую изначально использует HP ALM) базы. Однако, если вы хотите и нуждаетесь в дополнительных объектах, можете использовать Exception файл **НА СВОЙ СТРАХ И РИСК.** Для этого выполните следующие шаги:
1. Создайте Exception файла:
Exception файл сделан для дополнительных объектов, таких как: tables, views, triggers, columns.
Общая структура файла:
```
xml version="1.0" encoding="UTF-8"?
```
Для использования чего-либо, просто уберите комментарий соответствующей части
2. Сохраните файл на машине сервера с расширением .xml
3. Подключите файл к соответствующему проекту
И снова запустите верификацию.
Обновление с использования другого сервера баз данных
-----------------------------------------------------
Как я и обещал, остановимся на ситуации, когда нужно переходить на новый сервер баз данных (например, если вы хотите быть уверенным, что два сервера изолированы друг от друга) или на новую версию базы данных (например, если новая версия HP ALM не поддерживает вашу версию сервера баз данных).
Опять же, нужна помощь администратора баз данных. В принципе шаги довольно просты, но есть нюансы:
1. MS SQL
* Если проект восстанавливается на сервере баз данных, где уже была установлена любая версия HP ALM (хотя бы раз), то специальный пользователь базы данных уже существует. Если же нет, вам придется создать пользователь td вручную, для этого используйте следующие запросы:
```
USE [master]
GO
CREATE LOGIN [td] WITH PASSWORD=N'tdtdtd', DEFAULT_DATABASE=[master], CHECK_EXPIRATION=OFF, CHECK_POLICY=OFF
GO
```
* После того как вы восстановили базу данных проекта выполните ПОСТРОЧНО следующий скрипт.
```
EXEC sp_change_users_login 'Report'
EXEC sp_change_users_login 'Update_One', 'td', 'td'
EXEC sp_changedbowner 'sa'
```
2. Oracle
* При создании схемы нужно предоставить пользователю следующие привилегии, которые нужны HP ALM для работы с базой
```
GRANT "CONNECT"
GRANT CREATE SESSION
GRANT CREATE SEQUENCE
GRANT CREATE TABLE
GRANT CREATE TRIGGER
GRANT UNLIMITED TABLESPACE
GRANT CREATE VIEW
GRANT CREATE PROCEDURE
GRANT "CTXAPP"
ALTER USER DEFAULT ROLE ALL;
```
* При создании схемы используйте тот же пароль, который был задан при установке HP ALM сервера
Все остальные действия уже описаны выше.
Тестирование проектов
---------------------
Ну и последняя стадия процесса - это тестирование обновленных проектов
* Убедитесь, что вы можете войти в ALM проект с использованием своей учетной записи.
* Проведите базовое тестирование проекта.
* Попросите некоторых пользователей выполнить свои рутинные операции.
* Попросите некоторых пользователей, проверить новые возможности ALM.
* Удостоверьтесь, что разрешения для групп обновились успешно.
* Проверьте обратную совместимость ваших Workflow скриптов
* Если вы используете ALM интеграцию с инструментами HP или сторонними инструментами, проверьте обратную совместимость интеграций.
* Оповестите всех о успешном обновлении проекта.
Tips and Tricks
---------------
* Если вы не используете LDAP аутентификацию вам нужно будет начать с установки на существующую базу данных продукта, (все пароли пользователей хранятся именно там), но вы же используете LDAP?
* Если вы используете LAB\_PROJECT или проекты-шаблоны, начните с них.
* Ваше тестовое окружение должно быть полностью изолированно от продуктива, но, если же у вас нет такой возможности, удостоверьтесь, что в копиях баз данных проектов и продукта нет ссылок на оригинальные файловые хранилища и базы.
* Перед началом обновления рекомендуется описать все шаги и произвести оценку времени на их выполнение для всего процесса, начиная с получения ресурсов и заканчивая обновлением на продуктиве.
***Автор:** Андрей Матвиенко, руководитель команды тестирования HP ALM*` | https://habr.com/ru/post/263281/ | null | ru | null |
# MindStream. Как мы пишем ПО под FireMonkey. Часть 4 Serialization
[Часть 1](http://habrahabr.ru/post/232955/).
[Часть 2](http://habrahabr.ru/post/234801/).
[Часть 3. DUnit + FireMonkey](http://habrahabr.ru/post/241301/).
[Часть 3.1. По мотивам GUIRunner](http://habrahabr.ru/post/241377/).
Ещё в начале увлечения программированием мне нравилось работать с файлами. Работа, правда, в основном заключалась в чтении входных данных и записей результатов. Дальше была работа с БД, файлами я пользовался все реже. Максимум IniFile иногда. Поэтому задача сериализации была довольно интересной для меня.
Сегодня я расскажу о том, как мы добавили сериализацию в нашу программу, какие возникли трудности и как мы их преодолели. Так как материал уже не новый, то он скорее для новичков. Хотя, кое-какие приемы смогут ~~почерпнуть~~ покритиковать все.
Само понятие “сериализация” очень хорошо изложил [gunsmoker](https://habrahabr.ru/users/gunsmoker/) у себя в [блоге](http://www.gunsmoker.ru/2011/08/blog-post.html).
Я остановился на сериализации в [JSON формат](https://ru.wikipedia.org/wiki/JSON). Почему JSON? Он читабелен (я использую плагин для Notepad++), он позволяет описывать сложные структуры данных, ну и, наконец, в Rad Studio XE7 есть поддержка JSON из “коробки”.
Для начала напишем небольшой прототип, задачей которого будет сохранить некий объект:
```
...
type
TmsShape = class
private
fInt: integer;
fStr: String;
public
constructor Create(const aInt: integer; const aStr: String);
end;
constructor TmsShape.Create(const aInt: integer; const aStr: String);
begin
inherited
fInt := aInt;
fStr := aStr;
end;
procedure TForm2.btSaveJsonClick(Sender: TObject);
var
l_Marshal: TJSONMarshal;
l_Json: TJSONObject;
l_Shape1: TmsShape;
l_StringList: TStringList;
begin
try
l_Shape1 := TmsShape.Create(1, 'First');
l_Marshal := TJSONMarshal.Create;
l_StringList := TStringList.Create;
l_Json := l_Marshal.Marshal(l_Shape1) as TJSONObject;
Memo1.Lines.Text := l_Json.tostring;
l_StringList.Add(l_Json.tostring);
l_StringList.SaveToFile(с_FileNameSave);
finally
FreeAndNil(l_Marshal);
FreeAndNil(l_StringList);
FreeAndNil(l_Json);
FreeAndNil(l_Shape1);
end;
end;
```
В результате получим такой файл:
```
{
"type": "uMain.TmsShape",
"id": 1,
"fields": {
"fInt": 1,
"fStr": "First"
}
}
```
Следующим шагом сериализуем список фигур TmsShape; для этого добавим новый класс, у которого будет — поле “список”:
```
...
type
TmsShapeContainer = class
private
fList: TList;
public
constructor Create;
destructor Destroy;
end;
constructor TmsShapeContainer.Create;
begin
inherited;
fList := TList.Create;
end;
destructor TmsShapeContainer.Destroy;
begin
FreeAndNil(fList);
inherited;
end;
```
В код сохранения добавим создание контейнера и добавим ему 2 объекта, а также изменим параметр вызова маршалинга (разница между маршалингом и сериализацией как раз и описана в статье GunSmoker’a):
```
…
l_msShapeContainer := TmsShapeContainer.Create;
l_msShapeContainer.fList.Add(l_Shape1);
l_msShapeContainer.fList.Add(l_Shape2);
…
l_Json := l_Marshal.Marshal(l_msShapeContainer) as TJSONObject;
...
```
Остальной код не менялся.
На выходе получим такой файл:
```
{
"type": "uMain.TmsShapeContainer",
"id": 1,
"fields": {
"fList": {
"type": "System.Generics.Collections.TList",
"id": 2,
"fields": {
"FItems": [{
"type": "uMain.TmsShape",
"id": 3,
"fields": {
"fInt": 1,
"fStr": "First"
}
},
{
"type": "uMain.TmsShape",
"id": 4,
"fields": {
"fInt": 2,
"fStr": "Second"
}
}],
"FCount": 2,
"FArrayManager": {
"type": "System.Generics.Collections.TMoveArrayManager",
"id": 5,
"fields": {
}
}
}
}
}
}
```
Как видим, в файл попало слишком много лишней информации. Получается так вследствие особенностей реализации обработки объектов для маршалинга в стандартной библиотеке Json для XE7. Дело в том, что в стандартной библиотеке для этого описано 8 видов стандартных конверторов (converter):
```
//Convert a field in an object array
TObjectsConverter = reference to function(Data: TObject; Field: String): TListOfObjects;
//Convert a field in a strings array
TStringsConverter = reference to function(Data: TObject; Field: string): TListOfStrings;
//Convert a type in an objects array
TTypeObjectsConverter = reference to function(Data: TObject): TListOfObjects;
//Convert a type in a strings array
TTypeStringsConverter = reference to function(Data: TObject): TListOfStrings;
//Convert a field in an object
TObjectConverter = reference to function(Data: TObject; Field: String): TObject;
//Convert a field in a string
TStringConverter = reference to function(Data: TObject; Field: string): string;
//Convert specified type in an object
TTypeObjectConverter = reference to function(Data: TObject): TObject;
//Convert specified type in a string
TTypeStringConverter = reference to function(Data: TObject): string;
```
Более детально работу с конверторами описали [тут](http://www.danieleteti.it/2009/09/01/custom-marshallingunmarshalling-in-delphi-2010/).
Перевод, правда, с отсутствием форматирования [тут](http://keeper89.blogspot.com/2009/09/delphi-2010_4801.html).
В двух словах, есть 8 функций, которые умеют обрабатывать стандартные структуры данных. Однако, никто не мешает переопределить эти функции (они могут быть анонимные).
Попробуем?
```
…
l_Marshal.RegisterConverter(TmsShapeContainer, 'fList',
function(Data: TObject; Field: string): TListOfObjects
var l_Shape : TmsShape;
l_Index: integer;
begin
SetLength(Result, (Data As TmsShapeContainer).fList.Count);
l_Index := 0;
for l_Shape in (Data As TmsShapeContainer).fList do
begin
Result[l_Index] := l_Shape;
Inc(l_Index);
end;
end
);
...
```
На выходе получим несколько оптимальную версию:
```
{
"type": "uMain.TmsShapeContainer",
"id": 1,
"fields": {
"fList": [{
"type": "uMain.TmsShape",
"id": 2,
"fields": {
"fInt": 1,
"fStr": "First"
}
},
{
"type": "uMain.TmsShape",
"id": 3,
"fields": {
"fInt": 2,
"fStr": "Second"
}
}]
}
}
```
Всё, уже совсем хорошо. Но давайте представим, что нам необходимо сохранять строку и не сохранять число. Для этого воспользуемся [атрибутами](http://docwiki.embarcadero.com/RADStudio/XE6/en/Overview_of_Attributes).
```
type
TmsShape = class
private
[JSONMarshalled(False)]
fInt: integer;
[JSONMarshalled(True)]
fStr: String;
public
constructor Create(const aInt: integer; const aStr: String);
end;
```
На выходе получим:
```
{
"type": "uMain.TmsShapeContainer",
"id": 1,
"fields": {
"fList": [{
"type": "uMain.TmsShape",
"id": 2,
"fields": {
"fStr": "First"
}
},
{
"type": "uMain.TmsShape",
"id": 3,
"fields": {
"fStr": "Second"
}
}]
}
}
```
**Полный код модуля:**
```
unit uMain;
interface
uses
System.SysUtils,
System.Types,
System.UITypes,
System.Classes,
System.Variants,
FMX.Types,
FMX.Controls,
FMX.Forms,
FMX.Graphics,
FMX.Dialogs,
FMX.StdCtrls,
FMX.Layouts,
FMX.Memo,
Generics.Collections,
Data.DBXJSONReflect
;
type
TForm2 = class(TForm)
SaveDialog1: TSaveDialog;
Memo1: TMemo;
btSaveJson: TButton;
btSaveEMB_Example: TButton;
procedure btSaveJsonClick(Sender: TObject);
procedure btSaveEMB_ExampleClick(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
type
TmsShape = class
private
[JSONMarshalled(False)]
fInt: integer;
[JSONMarshalled(True)]
fStr: String;
public
constructor Create(const aInt: integer; const aStr: String);
end;
TmsShapeContainer = class
private
fList: TList;
public
constructor Create;
destructor Destroy;
end;
var
Form2: TForm2;
implementation
uses
json,
uFromEmbarcadero;
const
с\_FileNameSave = 'D:\TestingJson.ms';
{$R \*.fmx}
{ TmsShape }
constructor TmsShape.Create(const aInt: integer; const aStr: String);
begin
fInt := aInt;
fStr := aStr;
end;
procedure TForm2.btSaveEMB\_ExampleClick(Sender: TObject);
begin
Memo1.Lines.Assign(mainproc);
end;
procedure TForm2.btSaveJsonClick(Sender: TObject);
var
l\_Marshal: TJSONMarshal;
l\_Json: TJSONObject;
l\_Shape1, l\_Shape2: TmsShape;
l\_msShapeContainer: TmsShapeContainer;
l\_StringList: TStringList;
begin
try
l\_Shape1 := TmsShape.Create(1, 'First');
l\_Shape2 := TmsShape.Create(2, 'Second');
l\_msShapeContainer := TmsShapeContainer.Create;
l\_msShapeContainer.fList.Add(l\_Shape1);
l\_msShapeContainer.fList.Add(l\_Shape2);
l\_Marshal := TJSONMarshal.Create;
l\_StringList := TStringList.Create;
l\_Marshal.RegisterConverter(TmsShapeContainer, 'fList',
function(Data: TObject; Field: string): TListOfObjects
var l\_Shape : TmsShape;
l\_Index: integer;
begin
SetLength(Result, (Data As TmsShapeContainer).fList.Count);
l\_Index := 0;
for l\_Shape in (Data As TmsShapeContainer).fList do
begin
Result[l\_Index] := l\_Shape;
Inc(l\_Index);
end;
end
);
l\_Json := l\_Marshal.Marshal(l\_msShapeContainer) as TJSONObject;
Memo1.Lines.Text := l\_Json.tostring;
l\_StringList.Add(l\_Json.tostring);
l\_StringList.SaveToFile(с\_FileNameSave);
finally
FreeAndNil(l\_Marshal);
FreeAndNil(l\_StringList);
FreeAndNil(l\_Json);
FreeAndNil(l\_Shape1);
FreeAndNil(l\_Shape2);
FreeAndNil(l\_msShapeContainer);
end;
end;
{ TmsShapeContainer }
constructor TmsShapeContainer.Create;
begin
inherited;
fList := TList.Create;
end;
destructor TmsShapeContainer.Destroy;
begin
FreeAndNil(fList);
inherited;
end;
end.
```
Пора добавить сериализацию в наше приложение.
Напомню читателям как выглядит приложение:
А также UML-диаграмму:
Нам необходимо сериализовать класс TmsDiagramm. Но не весь. Нам нужен только список фигур на диаграмме и название диаграммы.
```
...
type
TmsShapeList = class(TList)
public
function ShapeByPt(const aPoint: TPointF): ImsShape;
end; // TmsShapeList
TmsDiagramm = class(TmsInterfacedNonRefcounted, ImsShapeByPt, ImsShapesController, IInvokable)
private
[JSONMarshalled(True)]
FShapeList: TmsShapeList;
[JSONMarshalled(False)]
FCurrentClass: RmsShape;
[JSONMarshalled(False)]
FCurrentAddedShape: ImsShape;
[JSONMarshalled(False)]
FMovingShape: TmsShape;
[JSONMarshalled(False)]
FCanvas: TCanvas;
[JSONMarshalled(False)]
FOrigin: TPointF;
f\_Name: String;
...
```
Добавим класс сериализации, у которого будет 2 статических функции:
```
type
TmsSerializeController = class(TObject)
public
class procedure Serialize(const aFileName: string; const aDiagramm: TmsDiagramm);
class function DeSerialize(const aFileName: string): TmsDiagramm;
end; // TmsDiagrammsController
```
Функция сериализации такая же, как в примере выше. Но вместо файла на выходе я получал exception:
Дебагер обрадовал ограничениями функции библиотеки:
А дело всё в том, что наш список:
```
type
TmsShapeList = class(TList)
public
function ShapeByPt(const aPoint: TPointF): ImsShape;
end; // TmsShapeList
```
Это список интерфейсов, которые не “кушает” Json из коробочки. Печально, но делать что-то надо.
Раз список интерфейсный, но объекты в нём реальные, а не сериализовать ли нам просто список объектов?
Сказано — сделано.
```
var
l_SaveDialog: TSaveDialog;
l_Marshal: TJSONMarshal; // Serializer
l_Json: TJSONObject;
l_JsonArray: TJSONArray;
l_StringList: TStringList;
l_msShape: ImsShape;
begin
l_SaveDialog := TSaveDialog.Create(nil);
if l_SaveDialog.Execute then
begin
try
l_Marshal := TJSONMarshal.Create;
l_StringList := TStringList.Create;
l_JsonArray := TJSONArray.Create;
for l_msShape in FShapeList do
begin
l_Json := l_Marshal.Marshal(TObject(l_msShape)) as TJSONObject;
l_JsonArray.Add(l_Json);
end;
l_Json := TJSONObject.Create(TJSONPair.Create('MindStream', l_JsonArray));
l_StringList.Add(l_Json.tostring);
l_StringList.SaveToFile(l_SaveDialog.FileName);
finally
FreeAndNil(l_Json);
FreeAndNil(l_StringList);
FreeAndNil(l_Marshal);
end;
end
else
assert(false);
FreeAndNil(l_SaveDialog);
end;
```
Идея, в общем, пройтись по списку и сохранить каждый объект.
Представил свое решение руководителю проекта. И?
В общем.
Получил я “по рукам”. За самодеятельность. Да и сам понимал, что десериализация теперь такая-же “ручная” получается.
Не подходит.
Руководитель, вмешавшись, посоветовал добавить каждому объекту метод HackInstance, который в последствии обретет вменяемое имя ToObject:
```
function TmsShape.HackInstance : TObject;
begin
Result := Self;
end;
```
Научив контролер сериализации работать правильно с объектами, получим такой модуль:
unit msSerializeController;
```
unit msSerializeController;
interface
uses
JSON,
msDiagramm,
Data.DBXJSONReflect;
type
TmsSerializeController = class(TObject)
public
class procedure Serialize(const aFileName: string;
const aDiagramm: TmsDiagramm);
class function DeSerialize(const aFileName: string): TmsDiagramm;
end; // TmsDiagrammsController
implementation
uses
System.Classes,
msShape,
FMX.Dialogs,
System.SysUtils;
{ TmsSerializeController }
class function TmsSerializeController.DeSerialize(const aFileName: string)
: TmsDiagramm;
var
l_UnMarshal: TJSONUnMarshal;
l_StringList: TStringList;
begin
try
l_UnMarshal := TJSONUnMarshal.Create;
l_UnMarshal.RegisterReverter(TmsDiagramm, 'FShapeList',
procedure(Data: TObject; Field: String; Args: TListOfObjects)
var
l_Object: TObject;
l_Diagramm: TmsDiagramm;
l_msShape: TmsShape;
begin
l_Diagramm := TmsDiagramm(Data);
l_Diagramm.ShapeList := TmsShapeList.Create;
assert(l_Diagramm <> nil);
for l_Object in Args do
begin
l_msShape := l_Object as TmsShape;
l_Diagramm.ShapeList.Add(l_msShape);
end
end);
l_StringList := TStringList.Create;
l_StringList.LoadFromFile(aFileName);
Result := l_UnMarshal.Unmarshal
(TJSONObject.ParseJSONValue(l_StringList.Text)) as TmsDiagramm;
finally
FreeAndNil(l_UnMarshal);
FreeAndNil(l_StringList);
end;
end;
class procedure TmsSerializeController.Serialize(const aFileName: string;
const aDiagramm: TmsDiagramm);
var
l_Marshal: TJSONMarshal; // Serializer
l_Json: TJSONObject;
l_StringList: TStringList;
begin
try
l_Marshal := TJSONMarshal.Create;
l_Marshal.RegisterConverter(TmsDiagramm, 'FShapeList',
function(Data: TObject; Field: string): TListOfObjects
var
l_Shape: ImsShape;
l_Index: Integer;
begin
assert(Field = 'FShapeList');
SetLength(Result, (Data As TmsDiagramm).ShapeList.Count);
l_Index := 0;
for l_Shape in (Data As TmsDiagramm).ShapeList do
begin
Result[l_Index] := l_Shape.HackInstance;
Inc(l_Index);
end; // for l_Shape
end);
l_StringList := TStringList.Create;
try
l_Json := l_Marshal.Marshal(aDiagramm) as TJSONObject;
except
on E: Exception do
ShowMessage(E.ClassName + ' поднята ошибка с сообщением : ' +
E.Message);
end;
l_StringList.Add(l_Json.tostring);
l_StringList.SaveToFile(aFileName);
finally
FreeAndNil(l_Json);
FreeAndNil(l_StringList);
FreeAndNil(l_Marshal);
end;
end;
end.
```
Посмотрим, что у нас получилось?
**В Json это будет выглядеть так:**
```
{
"type": "msDiagramm.TmsDiagramm",
"id": 1,
"fields": {
"FShapeList": [{
"type": "msCircle.TmsCircle",
"id": 2,
"fields": {
"FStartPoint": [[146,
250],
146,
250],
"FRefCount": 1
}
},
{
"type": "msCircle.TmsCircle",
"id": 3,
"fields": {
"FStartPoint": [[75,
252],
75,
252],
"FRefCount": 1
}
},
{
"type": "msRoundedRectangle.TmsRoundedRectangle",
"id": 4,
"fields": {
"FStartPoint": [[82,
299],
82,
299],
"FRefCount": 1
}
},
{
"type": "msRoundedRectangle.TmsRoundedRectangle",
"id": 5,
"fields": {
"FStartPoint": [[215,
225],
215,
225],
"FRefCount": 1
}
},
{
"type": "msRoundedRectangle.TmsRoundedRectangle",
"id": 6,
"fields": {
"FStartPoint": [[322,
181],
322,
181],
"FRefCount": 1
}
},
{
"type": "msUseCaseLikeEllipse.TmsUseCaseLikeEllipse",
"id": 7,
"fields": {
"FStartPoint": [[259,
185],
259,
185],
"FRefCount": 1
}
},
{
"type": "msTriangle.TmsTriangle",
"id": 8,
"fields": {
"FStartPoint": [[364,
126],
364,
126],
"FRefCount": 1
}
}],
"fName": "Диаграмма №1"
}
}
```
Пора заканчивать. Однако, в прошлых постах я описывал, как мы настроили инфраструктуру тестирования для нашего проекта. Поэтому напишем тесты. Фанаты TDD могут кинуть в меня “мокрой тряпкой”, и будут правы. Простите, Гуру. Я только учусь.
Для тестирования просто сохраним один объект (фигуру). И сравним его с оригиналом (то, что “я набрал руками”).
В общем:
```
unit TestmsSerializeController;
{
Delphi DUnit Test Case
----------------------
This unit contains a skeleton test case class generated by the Test Case Wizard.
Modify the generated code to correctly setup and call the methods from the unit
being tested.
}
interface
uses
TestFramework,
msSerializeController,
Data.DBXJSONReflect,
JSON,
FMX.Objects,
msDiagramm
;
type
// Test methods for class TmsSerializeController
TestTmsSerializeController = class(TTestCase)
strict private
FmsDiagramm: TmsDiagramm;
FImage: TImage;
public
procedure SetUp; override;
procedure TearDown; override;
published
procedure TestSerialize;
procedure TestDeSerialize;
end;
implementation
uses
System.SysUtils,
msTriangle,
msShape,
System.Types,
System.Classes
;
const
c_DiagramName = 'First Diagram';
c_FileNameTest = 'SerializeTest.json';
c_FileNameEtalon = 'SerializeEtalon.json';
procedure TestTmsSerializeController.SetUp;
begin
FImage:= TImage.Create(nil);
FmsDiagramm := TmsDiagramm.Create(FImage, c_DiagramName);
end;
procedure TestTmsSerializeController.TearDown;
begin
FreeAndNil(FImage);
FreeAndNil(FmsDiagramm);
end;
procedure TestTmsSerializeController.TestSerialize;
var
l_FileSerialized, l_FileEtalon: TStringList;
begin
FmsDiagramm.ShapeList.Add(TmsTriangle.Create(TmsMakeShapeContext.Create(TPointF.Create(10, 10),nil)));
// TODO: Setup method call parameters
TmsSerializeController.Serialize(c_FileNameTest, FmsDiagramm);
// TODO: Validate method results
l_FileSerialized := TStringList.Create;
l_FileSerialized.LoadFromFile(c_FileNameTest);
l_FileEtalon := TStringList.Create;
l_FileEtalon.LoadFromFile(c_FileNameEtalon);
CheckTrue(l_FileEtalon.Equals(l_FileSerialized));
FreeAndNil(l_FileSerialized);
FreeAndNil(l_FileEtalon);
end;
procedure TestTmsSerializeController.TestDeSerialize;
var
ReturnValue: TmsDiagramm;
aFileName: string;
begin
// TODO: Setup method call parameters
ReturnValue := TmsSerializeController.DeSerialize(aFileName);
// TODO: Validate method results
end;
initialization
// Register any test cases with the test runner
RegisterTest(TestTmsSerializeController.Suite);
end.
```
Ссылки которые мне пригодились:
[www.webdelphi.ru/2011/10/rabota-s-json-v-delphi-2010-xe2/#parsejson](http://www.webdelphi.ru/2011/10/rabota-s-json-v-delphi-2010-xe2/#parsejson)
[edn.embarcadero.com/article/40882](http://edn.embarcadero.com/article/40882)
[www.sdn.nl/SDN/Artikelen/tabid/58/view/View/ArticleID/3230/Reading-and-Writing-JSON-with-Delphi.aspx](http://www.sdn.nl/SDN/Artikelen/tabid/58/view/View/ArticleID/3230/Reading-and-Writing-JSON-with-Delphi.aspx)
[codereview.stackexchange.com/questions/8850/is-marshalling-converters-reverters-via-polymorphism-realistic](http://codereview.stackexchange.com/questions/8850/is-marshalling-converters-reverters-via-polymorphism-realistic)
[Json viewer plugin for Notepad++](http://sourceforge.net/projects/nppjsonviewer/?source=typ_redirect)
Старший коллега, [Александр](http://18delphi.blogspot.ru/), шагнул в разработке далеко вперед моей статьи. [Ссылка на репозиторий](https://bitbucket.org/ingword/mindstream). Все ваши замечания к коду оставляйте плз в BitBucket, благо репозиторий открытый. Все желающие попробовать себя в OpenSource — обращайтесь в личку.
Вот так выглядит диаграмма проекта сейчас:
Диаграмма тестов:
 | https://habr.com/ru/post/245441/ | null | ru | null |
# Программируем прямо в Nginx
Nginx — великолепный веб-сервер. Все мы привыкли использовать его в связке с бекендами на разных языках программирования. Но оказывается можно писать простые программы прямо внутри конфигурационного файла Nginx. Это можно использовать для балансировки, написания простых API и даже отдавать динамические страницы прямо из конфига.
В статье мы разберем примеры написания простых программ в конфиге nginx.
Выглядит это как написание кода в конфиге, что выглядит диковато, но удобно. Код выполняется асинхронно, не вмешиваясь в основной цикл событий Nginx, без коллбэков. Работает быстро и, что немаловажно, в совместимости с другими модулями и всем базовым функционалом.
Основным решением для Lua + Nginx считается [OpenResty](https://openresty.org/). Там много готовых модулей, как собственных на Lua, так и интегрированных из Nginx. Он отлично масштабируется и при этом сохраняет высокую производительность и пропускную способность Nginx.
Установка
---------
#### Lua
Поддержка чистого Lua поставляется в пакете nginx-extras
```
apt-get install nginx
apt-get install nginx-extras
```
сс [NiceDay](https://habr.com/ru/users/niceday/)
#### OpenResty
В этом случае сам Nginx устанавливать не нужно, OpenResty включает его в свою сборку. Если Nginx уже установлен, перед установкой его нужно отключить и остановить
```
sudo systemctl disable nginx
sudo systemctl stop nginx
```
Затем
```
sudo apt-get -y install --no-install-recommends wget gnupg ca-certificates
wget -O - https://openresty.org/package/pubkey.gpg | sudo apt-key add -
echo "deb http://openresty.org/package/ubuntu $(lsb_release -sc) main" \
| sudo tee /etc/apt/sources.list.d/openresty.list
sudo apt-get update
sudo apt-get -y install openresty
```
Наконец, запускаем OpenResty:
```
sudo /usr/local/openresty/bin/openresty
```
Вывода не последует, сервер просто запустится и будет доступен:
Остановка:
```
sudo /usr/local/openresty/bin/openresty -s quit
```
Hello world
-----------
Сначала создадим директорию и конфиг для нашего сайта:
```
sudo mkdir /usr/local/openresty/nginx/sites
sudo nano /usr/local/openresty/nginx/sites/default.conf
```
```
server {
listen 80 default_server;
listen [::]:80 default_server;
root /usr/local/openresty/nginx/html/default;
index index.html index.htm;
location / {
default_type 'text/plain';
content_by_lua_file /usr/local/openresty/nginx/html/default/index.lua;
}
}
```
Исполнять скрипты можно прямо в конфиге, но удобнее сразу подключить внешний файл
```
sudo nano /usr/local/openresty/nginx/html/default/index.lua
```
```
local name = ngx.var.arg_name or "Anonymous"
ngx.say("Hello, ", name, "!")
```
```
sudo mkdir /usr/local/openresty/nginx/html/default
sudo mv /usr/local/openresty/nginx/html/index.html /usr/local/openresty/nginx/html/default
```
Примеры
-------
Ниже собраны более практичные примеры из разных источников:
#### ruhighload.com
**Вывод HTML**
```
server {
location /hello {
default_type 'text/html';
content_by_lua '
ngx.say("Hello **world**!")
';
}
}
```
**Несколько обработчиков**
```
server {
location / {
default_type 'text/plain';
content_by_lua_file /var/www/lua/index.lua;
}
location /admin {
default_type 'text/plain';
content_by_lua_file /var/www/lua/admin.lua;
}
}
```
**Глобальные переменные**
```
http {
# объявляем глобальный контейнер
lua_shared_dict stats 1m;
server {
location / {
content_by_lua '
# увеличим переменную hits на 1 при каждом запросе
ngx.shared.stats:incr("hits", 1)
# выведем текущее значение
ngx.say(ngx.shared.stats:get("hits"))
';
}
}
}
```
**Скрипт для подсчета количества запросов в Redis**
```
apt-get install lua-nginx-redis
```
```
server {
location / {
content_by_lua '
local redis = require "nginx.redis"
local red = redis:new()
local ok, err = red:connect("127.0.0.1", 6379)
ok, err = red:incr("test")
local res, err = red:get("test")
ngx.say("hits: ", res)
';
}
}
```
#### openresty.org
[Routing MySQL Queries Based On URI Args](https://openresty.org/en/routing-mysql-queries-based-on-uri-args.html)
[Dynamic Request Routing Based on Redis](https://openresty.org/en/dynamic-routing-based-on-redis.html)
[Web App for OpenResty User Survey](https://github.com/openresty/openresty-survey)
[Code and data for the openresty.org site](https://github.com/openresty/openresty.org) — любой сайт, посвящённый определенной веб-технологии, использует её, и openresty.org не исключение
#### [habr.com/ru/post/270463](https://habr.com/ru/post/270463/)
**Поиск с кэшированием запросов**
```
-- search.lua
local string = ngx.var.arg_string -- получим параметр из GET запроса
if string == nil then
ngx.exec("/") -- если параметра нет, то сделаем редирект
end
local path = "/?string=" .. string
local redis = require "resty.redis" -- подключим библиотеку по работе с redis
local red = redis:new()
red:set_timeout(1000) -- 1 sec
local ok, err = red:connect("127.0.0.1", 6379)
if not ok then
ngx.exec(path) -- если нельзя подключиться к redis, то сделаем редирект
end
res, err = red:get("search:" .. string); -- получим данные из redis
if res == ngx.null then
ngx.exec(path) -- если данных нет, то сделаем редирект
else
ngx.header.content_type = 'application/json'
ngx.say(res) -- если данные есть, то отдадим их
end
```
```
# nginx.conf
location /search-by-string {
content_by_lua_file lua/search.lua;
}
```
#### [habr.com/ru/post/326486](https://habr.com/ru/post/326486/)
**Load balancer**
> В блоке http {} инициализируем lua.
>
>
>
> Код с комментариями:
>
>
>
>
> ```
> # путь до локально установленных *.lua библиотек с добавлением системных путей
> lua_package_path "/usr/local/lib/lua/?.lua;;";
> init_by_lua_block {
> -- подключение основного модуля
> -- в принципе, этот блок можно опустить
> require "resty.core"
> collectgarbage("collect") -- just to collect any garbage
> }
> ```
>
>
> в блоках \*\_lua\_block уже идёт lua-код со своим синтаксисом и функциями.
>
>
>
> Основной сервер, который принимает на себя внешние запросы.
>
>
>
> Код с комментариями:
>
>
>
>
> ```
> server {
> listen 80;
> server_name test.domain.local;
>
> location / {
> # проверяем наличие cookie "upid" и если нет — выставляем по желаемому алгоритму
> if ($cookie_upid = "") {
> # инициализируем пустую переменную nginx-а, в которую запишем выбранный ID бэкенда
> set $upstream_id '';
> rewrite_by_lua_block {
> -- инициализируем математический генератор для более рандомного рандома используя время nginx-а
> math.randomseed(ngx.time())
> -- также пропускаем первое значение, которое совсем не рандомное (см документацию)
> math.random(100)
> local num = math.random(100)
> -- получив число, бесхитростно и в лоб реализуем веса 20% / 80%
> if num > 20 then
> ngx.var.upstream_id = 1
> ngx.ctx.upid = ngx.var.upstream_id
> else
> ngx.var.upstream_id = 2
> ngx.ctx.upid = ngx.var.upstream_id
> end
> -- ID запоминаем в переменной nginx-а "upstream_id" и в "upid" таблицы ngx.ctx модуля lua, которая используется для хранения значений в рамках одного запроса
> }
> # отдаём клиенту куку "upid" со значением выбранного ID
> # время жизни явно не задаём, потому она будет действительна только на одну сессию (до закрытия браузера), что нас устраивает
> add_header Set-Cookie "upid=$upstream_id; Domain=$host; Path=/";
> }
>
> # если же кука у клиента уже есть, то запоминаем ID в ngx.ctx.upid текущего запроса
> if ($cookie_upid != "") {
> rewrite_by_lua_block {
> ngx.ctx.upid = ngx.var.cookie_upid
> }
> }
>
> # передаём обработку запроса на блок upstream-ов
> proxy_pass http://ab_test;
> }
> }
> ```
>
>
> Блок upstream, который используя lua заменяет встроенную логику nginx.
>
>
>
> Код с комментариями:
>
>
>
>
> ```
> upstream ab_test {
> # заглушка, чтобы nginx не ругался. В алгоритме не участвует
> server 127.0.0.1:8001;
>
> balancer_by_lua_block {
> local balancer = require "ngx.balancer"
>
> -- инициализируем локальные переменные
> -- port выбираем динамически, в зависимости от запомненного ID бэкенда
> local host = "127.0.0.1"
> local port = 8000 + ngx.ctx.upid
>
> -- задаём выбранный upstream и обрабатываем код возврата
> local ok, err = balancer.set_current_peer(host, port)
> if not ok then
> ngx.log(ngx.ERR, "failed to set the current peer: ", err)
> return ngx.exit(500)
> end
> -- в общем случае надо, конечно же, искать доступный бэкенд, но нам не к чему
> }
> }
> ```
>
>
> Ну и простой демонстрационный бэкенд, на который в итоге придут клиенты.
>
>
>
> Код без комментариев:
>
>
>
>
> ```
> server {
> listen 127.0.0.1:8001;
> server_name test.domain.local;
>
> location / {
> root /var/www/html;
> index index.html;
> }
> }
>
> server {
> listen 127.0.0.1:8002;
> server_name test.domain.local;
>
> location / {
> root /var/www/html;
> index index2.html;
> }
> }
> ```
>
>
> При запуске nginx-a с этой конфигурацией в логи свалится предупреждение:
>
>
>
>
> ```
> use of lua-resty-core with LuaJIT 2.0 is not recommended; use LuaJIT 2.1+ instead while connecting to upstream
> ```
>
#### 2Гис ([пост](https://habr.com/ru/company/2gis/blog/199504/))
> Эту часть придумал и сделал наш коллега AotD. Есть хранилище картинок. Их надо показывать пользователям, причем желательно производить при этом некоторые операции, например, resize. Картинки мы храним в ceph, это аналог Amazon S3. Для обработки картинок используется ImageMagick. На ресайзере есть каталог с кэшем, туда складываются обработанные картинки.
>
>
>
> Парсим запрос пользователя, определяем картинку, нужное ему разрешение и идем в ceph, затем на лету обрабатываем и показываем.
**serve\_image.lua**
```
require "config"
local function return_not_found(msg)
ngx.status = ngx.HTTP_NOT_FOUND
if msg then
ngx.header["X-Message"] = msg
end
ngx.exit(0)
end
local name, size, ext = ngx.var.name, ngx.var.size, ngx.var.ext
if not size or size == '' then
return_not_found()
end
if not image_scales[size] then
return_not_found('Unexpected image scale')
end
local cache_dir = static_storage_path .. '/' .. ngx.var.first .. '/' .. ngx.var.second .. '/'
local original_fname = cache_dir .. name .. ext
local dest_fname = cache_dir .. name .. size .. ext
-- make sure the file exists
local file = io.open(original_fname)
if not file then
-- download file contents from ceph
ngx.req.read_body()
local data = ngx.location.capture("/ceph_loader", {vars = { name = name .. ext }})
if data.status == ngx.HTTP_OK and data.body:len()>0 then
os.execute( "mkdir -p " .. cache_dir )
local original = io.open(original_fname, "w")
original:write(data.body)
original:close()
else
return_not_found('Original returned ' .. data.status)
end
end
local magick = require("imagick")
magick.thumb(original_fname, image_scales[size], dest_fname)
ngx.exec("@after_resize")
```
Подключаем биндинг imagic.lua. Должен быть доступен LuaJIT.
**nginx\_partial\_resizer.conf.template**
```
# Old images
location ~ ^/(small|small_wide|medium|big|mobile|scaled|original|iphone_(preview|retina_preview|big|retina_big|small|retina_small))_ {
rewrite /([^/]+)$ /__CEPH_BUCKET__/$1 break;
proxy_pass __UPSTREAM__;
}
# Try get image from ceph, then from local cache, then from scaled by lua original
# If image test.png is original, when user wants test_30x30.png:
# 1) Try get it from ceph, if not exists
# 2) Try get it from /cache/t/es/test_30x30.ong, if not exists
# 3) Resize original test.png and put it in /cache/t/es/test_30x30.ong
location ~ ^/(?(?.)(?..)[^\_]+)((?\_[^.]+)|)(?\.[a-zA-Z]\*)$ {
proxy\_intercept\_errors on;
rewrite /([^/]+)$ /\_\_CEPH\_BUCKET\_\_/$1 break;
proxy\_pass \_\_UPSTREAM\_\_;
error\_page 404 403 = @local;
}
# Helper failover location for upper command cause you can't write
# try\_files \_\_UPSTREAM\_\_ /cache/$uri @resizer =404;
location @local {
try\_files /cache/$first/$second/$name$size$ext @resize;
}
# If scaled file not found in local cache resize it with lua magic!
location @resize {
# lua\_code\_cache off;
content\_by\_lua\_file "\_\_APP\_DIR\_\_/lua/serve\_image.lua";
}
# serve scaled file, invoked in @resizer serve\_image.lua
location @after\_resize {
try\_files /cache/$first/$second/$name$size$ext =404;
}
# used in @resizer serve\_image.lua to download original image
# $name contains original image file name
location =/ceph\_loader {
internal;
rewrite ^(.+)$ /\_\_CEPH\_BUCKET\_\_/$name break;
proxy\_set\_header Cache-Control no-cache;
proxy\_set\_header If-Modified-Since "";
proxy\_set\_header If-None-Match "";
proxy\_pass \_\_UPSTREAM\_\_;
}
location =/favicon.ico {
return 404;
}
location =/robots.txt {}
```
Firewall для API. Валидация запроса, идентификация клиента, контроль rps и шлагбаум для тех, кто нам не нужен.
**firewall.lua**
```
module(..., package.seeall);
local function ban(type, element)
CStorage.banPermanent:set(type .. '__' .. element, 1);
ngx.location.capture('/postgres_ban', { ['vars'] = { ['type'] = type, ['value'] = element} });
end
local function checkBanned(apiKey)
-- init search criteria
local searchCriteria = {};
searchCriteria['key'] = apiKey;
if ngx.var.remote_addr then
searchCriteria['ip'] = ngx.var.remote_addr;
end;
-- search in ban lists
for type, item in pairs(searchCriteria) do
local storageKey = type .. '__' .. item;
if CStorage.banPermanent:get(storageKey) then
ngx.exit(444);
elseif CStorage.banTmp:get(storageKey) then
-- calculate rps and check is our client still bad boy 8-)
local rps = CStorage.RPS:incr(storageKey, 1);
if not(rps) then
CStorage.RPS:set(storageKey, 1, 1);
rps=1;
end;
if rps then
if rps > config.app_params['ban_params']['rps_for_ip_to_permanent_ban'] then
CStorage.RPS:delete(storageKey);
ban(type, item);
ngx.exit(444);
elseif config.app_params['ban_params']['rps_for_ip_to_tmp_ban'] > 0 and rps == config.app_params['ban_params']['rps_for_ip_to_tmp_ban'] then
local attemptsCount = CStorage.banTmp:incr(storageKey, 1) - 1;
if attemptsCount > config.app_params['ban_params']['tmp_ban']['max_attempt_to_exceed_rps'] then
-- permanent ban
CStorage.banTmp:delete(storageKey);
ban(type, item);
end;
end;
end;
ngx.exit(444);
end;
end;
end;
local function checkTemporaryBlocked(apiKey)
local blockedData = CStorage.tmpBlockedDemoKeys:get(apiKey);
if blockedData then
--storage.tmpBlockedDemoKeys:incr(apiKey, 1); -- think about it.
return CApiException.throw('tmpDemoBlocked');
end;
end;
local function checkRPS(apiKey)
local rps = nil;
-- check rps for IP and ban it if it's needed
if ngx.var.remote_addr then
local ip = 'ip__' .. tostring(ngx.var.remote_addr);
rps = CStorage.RPS:incr(ip, 1);
if not(rps) then
CStorage.RPS:set(ip, 1, 1);
rps = 1;
end;
if rps > config.app_params['ban_params']['rps_for_ip_to_permanent_ban'] then
ban('ip', tostring(ngx.var.remote_addr));
ngx.exit(444);
elseif config.app_params['ban_params']['rps_for_ip_to_tmp_ban'] > 0 and rps > config.app_params['ban_params']['rps_for_ip_to_tmp_ban'] then
CStorage.banTmp:set(ip, 1, config.app_params['ban_params']['tmp_ban']['time']);
ngx.exit(444);
end;
end;
local apiKey_key_storage = 'key_' .. apiKey['key'];
-- check rps for key
rps = CStorage.RPS:incr(apiKey_key_storage, 1);
if not(rps) then
CStorage.RPS:set(apiKey_key_storage, 1, 1);
rps = 1;
end;
if apiKey['max_rps'] and rps > tonumber(apiKey['max_rps']) then
if apiKey['mode'] == 'demo' then
CApiKey.blockTemporary(apiKey['key']);
return CApiException.throw('tmpDemoBlocked');
else
CApiKey.block(apiKey['key']);
return CApiException.throw('blocked');
end;
end;
-- similar check requests per period (RPP) for key
if apiKey['max_request_count_per_period'] and apiKey['period_length'] then
local rpp = CStorage.RPP:incr(apiKey_key_storage, 1);
if not(rpp) then
CStorage.RPP:set(apiKey_key_storage, 1, tonumber(apiKey['period_length']));
rpp = 1;
end;
if rpp > tonumber(apiKey['max_request_count_per_period']) then
if apiKey['mode'] == 'demo' then
CApiKey.blockTemporary(apiKey['key']);
return CApiException.throw('tmpDemoBlocked');
else
CApiKey.block(apiKey['key']);
return CApiException.throw('blocked');
end;
end;
end;
end;
function run()
local apiKey = ngx.ctx.REQUEST['key'];
if not(apiKey) then
return CApiException.throw('unauthorized');
end;
apiKey = tostring(apiKey)
-- check permanent and temporary banned
checkBanned(apiKey);
-- check api key
apiKey = CApiKey.getData(apiKey);
if not(apiKey) then
return CApiException.throw('forbidden');
end;
apiKey = JSON:decode(apiKey);
if not(apiKey['is_active']) then
return CApiException.throw('blocked');
end;
apiKey['key'] = tostring(apiKey['key']);
-- check is key in tmp blocked list
if apiKey['mode'] == 'demo' then
checkTemporaryBlocked(apiKey['key']);
end;
-- check requests count per second and per period
checkRPS(apiKey);
-- set apiKey's json to global parameter; in index.lua we send it through nginx to php application
ngx.ctx.GLOBAL['api_key'] = JSON:encode(apiKey);
end;
```
**validator.lua**
```
module(..., package.seeall);
local function checkApiVersion()
local apiVersion = '';
if not (ngx.ctx.REQUEST['version']) then
local nginx_request = tostring(ngx.var.uri);
local version = nginx_request:sub(2,4);
if tonumber(version:sub(1,1)) and tonumber(version:sub(3,3)) then
apiVersion = version;
else
return CApiException.throw('versionIsRequired');
end;
else
apiVersion = ngx.ctx.REQUEST['version'];
end;
local isSupported = false;
for i, version in pairs(config.app_params['supported_api_version']) do
if apiVersion == version then
isSupported = true;
end;
end;
if not (isSupported) then
CApiException.throw('unsupportedVersion');
end;
ngx.ctx.GLOBAL['api_version'] = apiVersion;
end;
local function checkKey()
if not (ngx.ctx.REQUEST['key']) then
CApiException.throw('unauthorized');
end;
end;
function run()
checkApiVersion();
checkKey();
end;
```
**apikey.lua**
```
module ( ..., package.seeall )
function init()
if not(ngx.ctx.GLOBAL['CApiKey']) then
ngx.ctx.GLOBAL['CApiKey'] = {};
end
end;
function flush()
CStorage.apiKey:flush_all();
CStorage.apiKey:flush_expired();
end;
function load()
local dbError = nil;
local dbData = ngx.location.capture('/postgres_get_keys');
dbData = dbData.body;
dbData, dbError = rdsParser.parse(dbData);
if dbData ~= nil then
local rows = dbData.resultset
if rows then
for i, row in ipairs(rows) do
local cacheKeyData = {};
for col, val in pairs(row) do
if val ~= rdsParser.null then
cacheKeyData[col] = val;
else
cacheKeyData[col] = nil;
end
end
CStorage.apiKey:set(tostring(cacheKeyData['key']),JSON:encode(cacheKeyData));
end;
end;
end;
end;
function checkNotEmpty()
if not(ngx.ctx.GLOBAL['CApiKey']['loaded']) then
local cnt = CHelper.tablelength(CStorage.apiKey:get_keys(1));
if cnt == 0 then
load();
end;
ngx.ctx.GLOBAL['CApiKey']['loaded'] = 1;
end;
end;
function getData(key)
checkNotEmpty();
return CStorage.apiKey:get(key);
end;
function getStatus(key)
key = getData(key);
local result = '';
if key ~= nil then
key = JSON:decode(key);
if key['is_active'] ~= nil and key['is_active'] == true then
result = 'allowed';
else
result = 'blocked';
end;
else
result = 'forbidden';
end;
return result;
end;
function blockTemporary(apiKey)
apiKey = tostring(apiKey);
local isset = getData(apiKey);
if isset then
CStorage.tmpBlockedDemoKeys:set(apiKey, 1, config.app_params['ban_params']['time_demo_apikey_block_tmp']);
end;
end;
function block(apiKey)
apiKey = tostring(apiKey);
local keyData = getData(apiKey);
if keyData then
ngx.location.capture('/redis_get', { ['vars'] = { ['key'] = apiKey } });
keyData['is_active'] = false;
CStorage.apiKey:set(apiKey,JSON:encode(cacheKeyData));
end;
end;
```
**storages.lua**
```
module ( ..., package.seeall )
apiKey = ngx.shared.apiKey;
RPS = ngx.shared.RPS;
RPP = ngx.shared.RPP;
banPermanent = ngx.shared.banPermanent;
banTmp = ngx.shared.banTmp;
tmpBlockedDemoKeys = ngx.shared.tmpBlockedDemoKeys;
```
#### Бонус! Примеры без использования Lua вообще.
Только конфиги, только хардкор
**Возврат страницы через return**
```
server {
...
location / {
default_type text/plain;
return 200 "Your IP: $remote_addr\n";
}
}
```
**force no-www**
```
server {
listen 80;
server_name example.org;
}
server {
listen 80;
server_name www.example.org;
return 301 $scheme://example.org$request_uri;
}
```
**force https**
```
server {
listen 80;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl;
# let the browsers know that we only accept HTTPS
add_header Strict-Transport-Security max-age=2592000;
...
}
```
**Редирект на определенный путь в URI**
```
location /old-site {
rewrite ^/old-site/(.*) http://example.org/new-site/$1 permanent;
}
```
**Кэш файлов**
```
open_file_cache max=1000 inactive=20s;
open_file_cache_valid 30s;
open_file_cache_min_uses 2;
open_file_cache_errors on;
```
**Keep-Alive с Upstream**
```
upstream backend {
server 127.0.0.1:8080;
keepalive 32;
}
server {
...
location /api/ {
proxy_pass http://backend;
proxy_http_version 1.1;
proxy_set_header Connection "";
}
}
```
[Напоследок, большой список конфигурационных шаблонов с Lua и без, с разной степенью сложности](https://gist.github.com/karmi/b0a9b4c111ed3023a52d)
Заключение
----------
Lua в Nginx в общем и OpenResty в частности гораздо быстрее и легковеснее php. Они помогают расширить базовый функционал Nginx, сделать его гибче, сохранив скорость обработки запроса и возможность тонкой настройки. OpenResty использует в проде огромное количество компаний, обеспечивая ему богатую экосистему и сильную поддержку комьюнити. Поле для экспериментов с Lua почти не ограничено, поэтому он может пригодиться в самых неожиданных местах. Если вы еще не пробовали Lua-in-Nginx, самое время изучить эту тему подробнее.
---
#### На правах рекламы
Необходим сервер для размещения сайта? [Наша компания](https://vdsina.ru/pricing?partner=habr17) предлагает надёжные серверы с посуточной или единоразовой оплатой, каждый сервер подключён к интернет-каналу в 500 Мегабит и бесплатно защищён от DDoS-атак!
[](https://vdsina.ru/eternal-server?partner=habr17) | https://habr.com/ru/post/504308/ | null | ru | null |
# Проблема трех раскладок в Linux
Имея одновременно три раскладки (английскую, русскую, украинскую) всегда в них путался, так как отличить их не глядя на индикатор не просто, а при потребности украинской раскладки, добавлять её и убирать каждый раз неудобно. Решается очень просто, расширением русской раскладки четырьмя дополнительными украинскими буквами (є, ї, і, ґ) и апострофом (’). Способ не претендует на уникальность, но здесь никто вроде бы еще не описывал. Для начала в настройках раскладки нужно выбрать клавишу для выбора клавиш третьего уровня:
Конфиги раскладок (в ubuntu, в других дистрибутивах путь может отличаться) лежат в /usr/share/X11/xkb/symbols/, в файлах ru, ua, us,
в них описаны соответствия клавиш символам. Состоит из секций которые друг друга наследуют, секция **common** базовая, так что при изменении в ней, изменятся и все дочерние. Например описание буквы «э»:
key { [ Cyrillic\_e, Cyrillic\_E ] };
В квадратных скобках первый параметр отвечает за сам символ, второй за символ + shift, третий за клавиша третьего уровня + символ, четвертый за клавиша третьего уровня + shift + символ. В данном случае есть только два параметра отвечающие за «э» и «Э», если написать что-то вроде:
key { [ Cyrillic\_e, Cyrillic\_E, Ukrainian\_ie, Ukrainian\_IE] };
то получим «э», «Э» и с Alt-ом "є" и "Є".
Немного покопавшись в украинской раскладке находим 5 нужных знаков и редактируем русскую раскладку
`sudo vim /usr/share/X11/xkb/symbols/ru`
а именно в секции:
key { [ Cyrillic\_hardsign, Cyrillic\_HARDSIGN, Ukrainian\_yi, Ukrainian\_YI ] };
key { [ Cyrillic\_yeru, Cyrillic\_YERU, Ukrainian\_i, Ukrainian\_I ] };
key { [ Cyrillic\_e, Cyrillic\_E, Ukrainian\_ie, Ukrainian\_IE ] };
key { [ Cyrillic\_ghe, Cyrillic\_GHE, Ukrainian\_ghe\_with\_upturn, Ukrainian\_GHE\_WITH\_UPTURN ] };
key { [ Cyrillic\_io, Cyrillic\_IO, apostrophe ] };
Теперь для использования украинских букв достаточно при нажатом правом Alt-е нажать соответствующую клавишу:
і = Alt + ы
ї = Alt + ъ
` = Alt + ё
є = Alt + э
На всякий случай [мой /usr/share/X11/xkb/symbols/ru](http://pastebin.ubuntu.com/550187/).
«Данный материал написан для «Первого конкурса русскоязычных статей для ОС Ubuntu 2011 года» (konkurs.ubuntu.ru)». | https://habr.com/ru/post/111059/ | null | ru | null |
# Анонс серии статей по настройке сервера Communigate Pro. Установка сервера
#### Всем привет!
Немного о наших разработках. Установка бесплатной версии.
Начиналось все с почтового сервера, но сейчас это уже полноценный Unified Communication сервер и используется в сетях TELE2, Beeline, AT&T, T-mobile… Сразу развеем миф, что мы заточены под операторов, во всем мире Communigate используют школы, университеты, корпорации, рестораны, автодилеры и т.д
Акцент на стандартные протоколы и открытые програмные интерфейсы делает возможным использование CommuniGate Pro в качестве платформы для разработки продвинутых решений в области унифицированных коммуникаций. Приглашаем потенциальных разработчиков для этой платформы [скачать](http://communigate.com/ru/main/purchase/download.html) и установить продукт, который в community режиме работает без ограничения функциональности при создании до пяти аккаунтов.
##### Что такое Communigate Pro?
Communigate Pro – это качественное решение со всем набором основных функций для передачи
сообщений, файлов, голоса и видео.
Основные характеристики нашей платформы:
* Одна надежная платформа для всех видов коммуникаций — не нужно устанавливать отдельные решения для почты, голоса, и мгновенных сообщений
* Масштабируемость и надежность (при объединении нескольких серверов в динамический кластер доступность сервисов достигает 99.999% от времени работы)
* Обширный список поддерживаемых протоколов и [стандартов](http://www.communigate.com/CommunigatePro/Features.html)
* Гибкость — возможность глубокой модификации графических интерфейсов и порядка обработки сигналов и сообщений
* Один клиентский протокол для всех задач — мы предоставляем простой и понятный XML [протокол](http://communigate.com/communigatepro/XMLAPI.html) для работы со всей функциональностью сервера
#### Установка
Для демонстрации установки в качестве операционной системы мы выбрали Windows, по той причине, что лучше всего ознакомиться с продуктом просто установив его на рабочую станцию или ноутбук. Установка занимает всего 5-10 минут и 100 MB на жестком диске.
У продукта есть «community» режим — можно абсолютно бесплатно пользоваться всеми возможностями, пока суммарное число учетных записей не больше 5.
##### Выбор дистрибутива
Последние стабильные версии продукта для различных платформ (поддерживается более 15 операционных систем) можно найти [здесь](http://communigate.com/communigatepro/default.html#Current)
##### Установка на Windows
Дистрибутив представляет собой простой zip архив. Запускаем Installer.exe:
* Application Folder — папка с программой и файлами настроек и интерфейсов по-умолчанию.
* Base Folder — папка с данными пользователей и всеми настройками отличными от стандартных.
При обновлении версии сервера заменяется только Application Folder.
После установки убеждаемся, что нужный процесс запущен:
##### Основные интерфейсы
В любом браузере, открываем этот URL:
`localhost:8010/` (или `http://[ip адрес сервера]:8010/`)
и попадаем в WebAdmin.
Администратором по-умолчанию является пользователь postmaster, при первом посещении админки выбираем пароль для него:
После логина попадаем на страницу основных настроек интерфейса:
Тут можно выбирать удобный язык интерфейса, часовой пояс и имя главного домена. Также рекомендуем переключиться с Basic режима на Expert (влияет на то какие настройки показываются, Basic режим хорош при самостоятельном изучении, но в данной серии статей мы будем пользоваться режимом Expert, так как только в нем видны самые интересные настройки).
WebAdmin представляет собой иерархическую систему вкладок. Для обозначения какой -либо настройки мы будем использовать такой формат:
Tab1->Tab2->Tab3->«Setting Name»
Например создать пользователя можно с помощью кнопки Users->Domains->[Имя домена]->«Create Account».
Помимо WebAdmin есть еще 3 web-интерфейса для пользователей:
* WebUser — HTML интерфейс с почтой, календарями и контактами, по-умолчанию доступен через порт 8100: `localhost:8100/`
* Pronto! — более функциональный Flash интерфейс, помимо почты, календарей и контактов поддерживает звонки, IM и некоторые дополнительные функции, доступен по URL вида `localhost:8100/Pronto/`
* Pronto! Lite — самый новый и минималистичный интерфейс на HTML 5, URL для доступа — `localhost:8100/?Skin=hPronto-#pronto-login`
Собственно на этом установка завершена, пользователи уже могут переписываться и звонить друг другу. Надо только помнить, что если DNS записей нет, то в настройках клиентов нужно использовать IP адрес компьютера вместо имени сервера, а при звонках нужно использовать полное имя аккаунта, так как мы еще не назначили короткие номера. Подробнее о всех этих настройках в следующих статьях.
#### Что дальше?
Примерные темы на следующие посты:
1. Основные объекты и понятия в Communigate Pro. Ньюансы настройки почты.
2. Календари, контакты, задачи, управление доступом к папкам
3. Базовые настройки IP телефонии, возможности встроенных приложений
4. Разработка собственных PBX приложений
5. Web — интерфейсы и их модификация
6. Взаимодействие с внешними программами. Фильтры и автоматизация административных задач
В комментариях оставляйте пожелания по содержанию будущих статей.
P.S. Пример одного из последних in-house клиентских интерфейсов:
 | https://habr.com/ru/post/185726/ | null | ru | null |
# Архивация по URL
Каждый год несколько процентов материалов, на которые я ссылаюсь, исчезают навсегда. Для человека, который старается не писать без пруфов, это неприемлемо, так что я разработал собственную стратегию борьбы с битыми ссылками. Если коротко — коллекция скриптов, демонов и архивных сервисов в интернете просто берёт и бэкапит всё подряд. URLы регулярно выгружаются из логов моего браузера и статей с моего сайта. Все страницы архивируются локально и на archive.org, так что при необходимости они будут вечно доступны из нескольких независимых источников.
linkchecker регулярно проходит по моему сайту в поисках битых ссылок; все обнаруженные потери могут быть либо заменены (если адрес поменялся, но страница всё ещё существует), либо восстановлены из архива. Кроме того, мои локальные архивы криптографически датируются через блокчейн биткойна на случай, если возникнут подозрения в фальсификации.
### Вымирание ссылок
*«Все составные вещи недолговечны. Стремитесь к собственному освобождению с особым усердием».*
[Последние слова Будды Шакьямуни](https://ru.wikipedia.org/wiki/%D0%91%D1%83%D0%B4%D0%B4%D0%B0_%D0%A8%D0%B0%D0%BA%D1%8C%D1%8F%D0%BC%D1%83%D0%BD%D0%B8#%D0%A1%D0%BC%D0%B5%D1%80%D1%82%D1%8C_/_%D0%9C%D0%B0%D1%85%D0%B0%D0%BF%D0%B0%D1%80%D0%B8%D0%BD%D0%B8%D1%80%D0%B2%D0%B0%D0%BD%D0%B0_(%D0%92%D0%B5%D0%BB%D0%B8%D0%BA%D0%B8%D0%B9_%D0%BF%D0%B5%D1%80%D0%B5%D1%85%D0%BE%D0%B4_%D0%B2_%D0%B0%D0%B1%D1%81%D0%BE%D0%BB%D1%8E%D1%82%D0%BD%D1%8B%D0%B9_%D0%BF%D0%BE%D0%BA%D0%BE%D0%B9_%D0%BD%D0%B8%D1%80%D0%B2%D0%B0%D0%BD%D1%8B))
Величина вымирания вызывает возмущение. Вот взгляд [Википедии](https://ru.wikipedia.org/wiki/%D0%92%D1%8B%D0%BC%D0%B8%D1%80%D0%B0%D0%BD%D0%B8%D0%B5_%D1%81%D1%81%D1%8B%D0%BB%D0%BE%D0%BA#%D0%A0%D0%B0%D1%81%D0%BF%D1%80%D0%BE%D1%81%D1%82%D1%80%D0%B0%D0%BD%D1%91%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D1%8C):
> В эксперименте 2003 года Фетерли (с соавторами) обнаружил, что примерно одна ссылка из 200 исчезает каждую неделю из интернета. МакКоун (с соавторами, 2005) обнаружил, что половина [URL](https://ru.wikipedia.org/wiki/URL), указанных в статьях журнала D-Lib Magazine, не были доступны через 10 лет после публикации, а другие исследования показали даже худшее вымирание ссылок в научной литературе [[5]](https://ru.wikipedia.org/wiki/%D0%92%D1%8B%D0%BC%D0%B8%D1%80%D0%B0%D0%BD%D0%B8%D0%B5_%D1%81%D1%81%D1%8B%D0%BB%D0%BE%D0%BA#cite_note-_b646f675eb204c2c-5) [[6]](https://ru.wikipedia.org/wiki/%D0%92%D1%8B%D0%BC%D0%B8%D1%80%D0%B0%D0%BD%D0%B8%D0%B5_%D1%81%D1%81%D1%8B%D0%BB%D0%BE%D0%BA#cite_note-_bf567166be006123-6). Нельсон и Аллен [[7]](https://ru.wikipedia.org/wiki/%D0%92%D1%8B%D0%BC%D0%B8%D1%80%D0%B0%D0%BD%D0%B8%D0%B5_%D1%81%D1%81%D1%8B%D0%BB%D0%BE%D0%BA#cite_note-_93a7d75ac6595d08-7) изучали вымирание ссылок в цифровых библиотеках и нашли, что около 3 % объектов были недоступны после одного года. В 2014 владелец сайта закладок Pinboard Мацей Цегловский сообщал, что «довольно стабильная доля» в 5 % ссылок вымирает за год [[8]](https://ru.wikipedia.org/wiki/%D0%92%D1%8B%D0%BC%D0%B8%D1%80%D0%B0%D0%BD%D0%B8%D0%B5_%D1%81%D1%81%D1%8B%D0%BB%D0%BE%D0%BA#cite_note-_bb5b17b69efe23c9-8). Исследование ссылок из каталога Yahoo! показало [период полураспада](https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D0%B8%D0%BE%D0%B4_%D0%BF%D0%BE%D0%BB%D1%83%D1%80%D0%B0%D1%81%D0%BF%D0%B0%D0%B4%D0%B0) случайной страницы в 2016—2017 годах (вскоре после того, как Yahoo! перестала публиковать этот каталог) около двух лет [[9]](https://ru.wikipedia.org/wiki/%D0%92%D1%8B%D0%BC%D0%B8%D1%80%D0%B0%D0%BD%D0%B8%D0%B5_%D1%81%D1%81%D1%8B%D0%BB%D0%BE%D0%BA#cite_note-_4a6f49b6c39d82c8-9).
Брюс Шнайер вспоминает, что за девять лет у одного его друга сломалась половина ссылок на странице (и не то чтоб [в 1998 году](https://www.gwern.net/docs/www/www.pantos.org/10723128e7820b8612d887af0fd0052d7ca41741.html) дела обстояли лучше), и что он сам порой выкладывал ссылку — а через пару дней [она уже не работала](https://web.archive.org/web/20121108093008/http://www.wired.com/politics/security/commentary/securitymatters/2008/02/securitymatters_0221). Виторио перебрал свои закладки из 1997 года в 2014-ом и обнаружил, что [91% не работает](https://notes.pinboard.in/u:vitorio/05dec9f04909d9b6edff), а половины нет даже в Internet Archive. Эрни Смит взял книгу про интернет из 1994 года и [нашёл в ней целую одну работающую ссылку](https://www.vice.com/en/article/paabgg/i-bought-a-book-about-the-internet-from-1994-and-none-of-the-links-worked). Internet Archive считает, что среднее время жизни страницы в интернете — [100 дней](https://web.archive.org/web/20080602034359/http://www.wired.com/culture/lifestyle/news/2001/10/47894). Статья в Science утверждает, что учёные обычно не вставляют URLы в научные публикации, а когда вставляют — [13% не работает через два года](https://www.gwern.net/docs/www/scimaps.org/d0b8798bc2a55f9a99ff87a4cb002bb043702294.pdf). Французская компания Linterweb изучала внешние ссылки во франкоязычной Википедии и обнаружила, что в 2008 году [5% были мертвы](http://fr.wikipedia.org/wiki/Utilisateur:Pmartin/Cache). Англоязычная Википедия пережила вспышку битых ссылок в 2010-январе 2011, когда их число выросло от нескольких тысяч до ~110 000 из [~17.5 миллионов](https://en.wikipedia.org/wiki/Wikipedia_talk%3AWikiProject_External_links%2FWebcitebot2#Summary). На некогда легендарной [Million Dollar Homepage](https://en.wikipedia.org/wiki/The_Million_Dollar_Homepage), последняя ссылка на которой была поставлена в январе 2006 и стоила 38 тысяч долларов, к 2017 не меньше половины ссылок были мертвы или захвачены киберсквоттерами (с неё до сих пор идёт трафик, так что некоторые адреса могут иметь ценность). Сайт закладок [Pinboard](https://en.wikipedia.org/wiki/Pinboard_%28website%29) отмечал [в августе 2014](https://nitter.cc/pinboard/status/501406303747457024), что 17% 3-летних ссылок и 25% 5-летних не открываются. И [так далее](http://journals.plos.org/plosone/article?id=10.1371/journal.pone.0115253), и [тому подобное](http://jnci.oxfordjournals.org/content/96/12/969.full), и [прочее в том же духе](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2213465/).
Ссылки сыплются даже в более-менее стабильных, модерируемых и не разорившихся системах. Хотя Твиттер как таковой прекрасно себя чувствует, [11% твитов времён Арабской Весны не открывались уже через год](https://arxiv.org/abs/1209.3026). А иногда незаметно исчезают сразу огромные объёмы данных: например, администрация MySpace где-то потеряла всю музыку, загруженную с 2003 по 2015, и объявила, что они “перестроили MySpace с нуля и решили перенести часть пользовательского контента со старой версии”. Правда, часть загрузок 2008-2010 была восстановлена и выложена на IA “[анонимным исследователем](https://archive.org/details/myspace_dragon_hoard_2010)”.
Я хочу, чтобы мои данные хотя бы пережили меня; скажем, дожили до 2070. По состоянию на 10 марта 2011 года (*прим. пер.: дата выхода первой версии этого текста. Последний апдейт датируется 5 января 2019*), у меня на сайте примерно 6800 внешних ссылок, из них 2200 не на Википедию. Даже при минимальной оценке в 3% умирающих ссылок в год, до 2070 доживут немногие. Если шанс выживания данной конкретной ссылки в данный год 97%, то вероятность её не потерять до 2070 равна 0.97^(2070-2011)≈0.16. 95-процентный доверительный интервал для такого биномиального распределения подсказывает, что ~336-394 ссылки из 2200 будут работать в 2070 году. Если использовать верхнюю оценку смертности в 50% ссылок в год — то в 2070 году, скорее всего, не останется ни одной.
Истина где-то между этими двумя экстремумами, но безопаснее исходить из допущения, что *все* внешние ссылки (кроме разве что Википедии и Internet Archive, специально заботящихся о долгожительстве материалов) рано или поздно накроются. Во всяком случае, не стоит полагаться на то, что всё будет нормально. Если не позаботиться сейчас, то нормально точно не будет.
Если мы хотим заархивировать данную конкретную страницу — то всё просто. Нужно либо пойти на Internet Archive и нажать там соответствующую кнопку, либо распечатать страницу в PDF прямо из браузера. Для сохранения более сложных страниц есть специальные плагины, например [ScrapBook](https://github.com/danny0838/firefox-scrapbook/wiki/Features). Но я захожу и ссылаюсь на огромное количество страниц, так что сохранять каждую из них вручную будет тяжеловато. Нужна система, которая бы автоматически обеспечивала корректные ссылки на все страницы, которые могут мне когда-нибудь понадобиться.
### Поиск битых ссылок
*Одну весну за другой
цветы излагают Закон,
не говоря ни единого слова,
но уяснив его суть
из срывающего их ветра*
[Сётэцу](https://en.wikipedia.org/wiki/Sh%C5%8Dtetsu)
Прежде всего, нужно как можно раньше находить свежеполоманные ссылки. Даже само по себе это позволит хотя бы подставлять материалы из архивов или кеша поисковых систем. У меня для этого используется [linkchecker](http://wummel.github.io/linkchecker/) в задаче [cron](https://en.wikipedia.org/wiki/Cron):
```
@monthly linkchecker --check-extern --timeout=35 --no-warnings --file-output=html \
--ignore-url=^mailto --ignore-url=^irc --ignore-url=http://.*\.onion \
--ignore-url=paypal.com --ignore-url=web.archive.org \
https://www.gwern.net
```
В таком виде эта команда вернёт кучу ложноположительных сигналов. Несколько сотен якобы битых ссылок будут найдены на одной только Википедии, потому что я ссылаюсь на редиректы; кроме того, linkchecker читает robots.txt и не может проверить заблокированные в нём адреса. Это можно исправить, добавив в `~/.linkchecker/linkcheckerrc` `"ignorewarnings=http-moved-permanent,http-robots-denied"` (полный список классов предупреждений есть в `linkchecker -h`).
Чем раньше битая ссылка найдена, тем раньше можно что-то с ней сделать. Что именно?
### Удалённое кеширование
*Всё, что ты постишь в Интернете, будет существовать до тех пор, пока оно тебя позорит, и исчезнет, как только оно тебе понадобится.*
[с сайта Ycombinator](https://news.ycombinator.com/item?id=21270467)
Можно попросить кого-нибудь другого хранить кэши всех нужных нам страниц. Как раз на такой случай есть несколько [веб-архивов](https://en.wikipedia.org/wiki/Archive_site):
1. [The Internet Archive](https://en.wikipedia.org/wiki/Internet_Archive)
2. [WebCite](https://en.wikipedia.org/wiki/WebCite)
3. [Perma.cc](http://perma.cc/) (сильно ограничен)
4. [WikiWix](http://wikiwix.com) (но у него есть конкретная функция — бэкапить исходящие ссылки Википедии — так что весь остальной интернет его интересует довольно мало).
5. [Archive.is](http://archive.today/)
6. [Pinboard](https://pinboard.in/) предоставляет архивацию за 25$ в год
7. [Hiyo.jp](http://hiyo.jp) и [Megalodon.jp](http://megalodon.jp) (но они на японском) *Прим.пер.: по состоянию на март 2021 первая ссылка не открывается. Что забавно, локальный архив Гверна честно отдаёт мне сохранённую главную страницу сервиса, но воспользоваться ей уже вряд ли получится.*
Есть и другие архивы, но они могут быть недоступны (например, кэш Google — хоть я и не верю, что Гугл и правда удаляет все свои кэши, отдавать их пользователям он точно перестаёт) или разнообразные коммерческие / государственные архивы (которые по определению недоступны публике ни для пополнения, ни для использования, и вообще мы про них знаем преимущественно по историям типа “знакомый моего знакомого знает одного парня, который работал в некой неназванной федеральной организации, и вот этот парень рассказывал, что у них там есть собственный Wayback Machine”).
Кстати, хранить в этих архивах собственный сайт — тоже неплохая идея:
* Бэкапы — это хорошо, но локальный бэкап тоже может случайно погибнуть (это я из собственного опыта говорю), так что неплохо бы иметь удалённые копии.
* Уменьшается пресловутый “автобусный фактор”: если завтра я попаду под автобус, то кто и как получит доступ к моим бэкапам? У кого будет время и желание в них потом разбираться? А про IA люди в целом понимают, что там и как, к тому же для работы с ним созданы специальные инструменты.
* Фокус на бэкапе самого сайта отвлекает внимание от необходимости бэкапить то, на что ты ссылаешься. Многие страницы мало чего стоят, если ссылки в них перестали открываться, а скрипты / демоны для архивации можно настроить так, чтобы они автоматически подтягивали всё необходимое.
Первый бот, который я для этого написал, [Wikipedia Archiving Bot](https://www.gwern.net/haskell/Wikipedia-Archive-Bot), просто кидал запросы в WebCite, Internet Archive и Archive.is. Потом он был модифицирован в вики-плагин [gitit](https://hackage.haskell.org/package/gitit), который прицепляется к коду сохранения страницы и пытается автоматически сохранить каждую свежедобавленную ссылку ([interwiki.hs](https://github.com/jgm/gitit/blob/master/plugins/Interwiki.hs)). Если вам плевать на приватность — то [Alexa Toolbar](https://en.wikipedia.org/wiki/Alexa_Toolbar) тоже умеет в автосохранение на Internet Archive.
В конце концов я написал [archiver](https://hackage.haskell.org/package/archiver), простенький демон, который мониторит текстовый файл с URL’ами. Исходники можно скачать через
```
git clone https://github.com/gwern/archiver-bot.git
```
Archiver состоит из библиотеки, которая по сути является просто обёрткой вокруг соответствующих HTTP-запросов, и исполняемого файла, который берёт список адресов, сообщает Internet Archive, что их не мешало бы сохранить, потом удаляет соответствующую строку из файла и продолжает в том же духе, пока файл не опустеет.
Вызов выглядит так:
```
archiver ~/.urls.txt gwern@gwern.net
```
. Он у меня когда-то крашился по непонятным причинам, так что я завернул команду в while true:
```
while true; do archiver ~/.urls.txt gwern@gwern.net; done
```
Потом я завернул его ещё и в сессию GNU screen:
```
screen -d -m -S "archiver" sh -c 'while true; do archiver ~/.urls.txt gwern@gwern.net; done'
```
. Ну и запускаем не руками, а через cron, так что в итоге получается:
```
@reboot sleep 4m && screen -d -m -S "archiver" sh -c 'while true; do archiver ~/.urls.txt gwern2@gwern.net "cd ~/www && nice -n 20 ionice -c3 wget --unlink --limit-rate=20k --page-requisites --timestamping -e robots=off --reject .iso,.exe,.gz,.xz,.rar,.7z,.tar,.bin,.zip,.jar,.flv,.mp4,.avi,.webm --user-agent='Firefox/4.9'" 500; done'
```
### Локальное кэширование
Удалённые архивы — это хорошо, но у них есть один фатальный недостаток: архивные сервисы не поспевают за ростом интернета и большей части материалов там может не быть. [Ainsworth *et al.* 2012](https://arxiv.org/abs/1212.6177) показали, что менее 35% веб-страниц заархивированы хоть где-нибудь, и подавляющее большинство из них сохранены только в одном архиве. К тому же и сами архивы в принципе могут умереть вместе со всем их содержимым. Так что локальное кэширование тоже должно быть.
Самый фундаментальный подход — взять кэширующее прокси, которое будет сохранять буквально *весь* ваш веб-трафик. Например, Live Archiving Proxy ([LAP](https://github.com/INA-DLWeb/LiveArchivingProxy)) или [WarcProxy](https://github.com/odie5533/WarcProxy) будет писать [WARC](https://en.wikipedia.org/wiki/Web_ARChive)-файлы для каждой посещённой через HTTP веб-страницы. [Zachary Vance](https://www.gwern.net/docs/www/blog.za3k.com/e6b85edad0874ce9f51ecac2c7a2225dbf016a6e.html) пишет, что можно настроить локальный HTTPS-сертификат и добраться до содержимого HTTPS-страниц за счёт MitM-атаки на собственный трафик.
Но это довольно тяжеловесное и прожорливое решение, так что хочется чего-то более аккуратного. Например, выгружать из браузера список посещённых страниц и пытаться их заархивировать.
Раньше я использовал скрипт с потрясающе оригинальным названием local-archiver:
**local-archiver.sh**
```
#!/bin/sh
set -euo pipefail
cp `find ~/.mozilla/ -name "places.sqlite"` ~/
sqlite3 places.sqlite "SELECT url FROM moz_places, moz_historyvisits \
WHERE moz_places.id = moz_historyvisits.place_id \
and visit_date > strftime('%s','now','-1.5 month')*1000000 ORDER by \
visit_date;" | filter-urls >> ~/.tmp
rm ~/places.sqlite
split -l500 ~/.tmp ~/.tmp-urls
rm ~/.tmp
cd ~/www/
for file in ~/.tmp-urls*;
do (wget --unlink --continue --page-requisites --timestamping --input-file $file && rm $file &);
done
find ~/www -size +4M -delete
```
Код не самый красивый, но вроде всё понятно.
1. Выгружаем адреса из SQL-файла Firefox и скармливаем их [wget](https://en.wikipedia.org/wiki/Wget). Это не самый подходящий инструмент для скачивания сайтов: он не может запускать JS/Flash, скачивать потоковое видео и прочая и прочая. Весь джаваскрипт будет просто скачан в виде файла, который, скорее всего, перестанет исполняться через пару лет, а динамически подгружаемый контент не сохранится. С другой стороны, это не такая уж большая проблема, потому что на практике мне нужен в основном как раз статический контент (а JS по большей части обеспечивает только ненужные свистелки), а видео можно бэкапить руками через `youtube-dl`. Если страница приватная и без логина не открывается — то можно вытащить куки из Firefox [специальным аддоном](https://addons.mozilla.org/en-US/firefox/addon/export-cookies/), скормить их wget через ключ `--load-cookies` и всё будет хорошо. Так что в целом wget мне хватает.
2. Скрипт дробит список URL на множество файлов и параллельно запускает бэкапы на каждом из них, потому что wget не умеет одновременно качать с нескольких доменов и может подвиснуть.
3. filter-urls — это ещё один скрипт, удаляющий адреса, которые не надо бэкапить. По сути это просто гора костылей:
```
#!/bin/sh
set -euo pipefail
cat /dev/stdin | sed -e "s/#.*//" | sed -e "s/&sid=.*$//" | sed -e "s/\/$//" | grep -v -e 4chan -e reddit
```
4. Удаляются большие файлы, типа видео / аудио. У меня это обычно подкасты.
Довольно быстро я понял, что у такого решения полно недостатков. Его надо не забывать запускать, оно пишет единственный архив (так что его нельзя поставить в cron, иначе повторяющиеся страницы съедят кучу места на жёстком диске), оно может подвиснуть, страницы могут умереть после посещения, но до сохранения, файлы в 4+ мегабайта могут оказаться полезными PDF’ками и прочая и прочая. Что особенно важно, я хочу бэкапиться как локально, так и удалённо.
Так что я сел писать archiver, который бы постоянно крутился в фоне и собирал адреса, бэкапил бы в Internet Archive и вёл себя более разумно с большими медиафайлами.
Я добавил туда ещё пару фич: во-первых, он принимает в качестве третьего аргумента произвольную sh-команду, которой будет отдана ссылка. Это полезно, если вам хочется что-нибудь делать со всеми сохранёнными страницами (например, вести логи).
Во-вторых, все страницы криптографически датируются и помечаются, так что если возникнут подозрения в том, что я сфальсифицировал что-то в своём архиве — можно будет подтвердить, что он не поменялся с момента создания. Система подробно расписана в [приложении](https://www.gwern.net/Timestamping), но смысл в том, что [специальный сервис](https://originstamp.com/) посылает копеечную транзакцию на адрес Bitcoin, производный от хэша документа, и при необходимости всегда можно найти в блокчейне доказательство, что в такую-то дату действительно существовала страница с таким-то хэшом.
### Расход ресурсов
Кажется, что такой локальный бэкап будет пожирать огромные ресурсы, но на самом деле за год набирается 30-50 Гб. Меньше, если настроить игнорирование страниц более жёстко, больше, если сохранять сайты целиком (а не только посещённые страницы). В долгосрочной перспективе всё это вполне жизнеспособно: с 2003 по 2011 средняя страница увеличилась в 7 раз (что неприятно), но цена хранения за тот же период упала в целых 128 раз. По состоянию на 2011 год, за 80 долларов можно купить минимум пару терабайт, так что гигабайт места на жёстком диске стоит около 4 центов. Получается, что весь бэкап стоит один-два доллара в год. На самом деле больше, потому что всё это надо хранить в нескольких копиях, но всё равно копейки. К тому же нам тут повезло: большая часть документов изначально цифровая и может быть автоматически перенесена с диска на диск или конвертирована в другой формат. Обратная совместимость в браузерах неплохо работает даже с документами из начала девяностых, и даже если что-то не откроется сразу, об этой проблеме можно будет думать, когда и если она действительно возникнет. Разумеется, если нужные данные зашиты в анимацию Adobe Flash или динамически подтягиваются из облака — то они пропали, но это всё ещё куда меньшая боль, чем если бы мы пытались сохранять программы и библиотеки (что потребовало бы полного стека двоично совместимых виртуалок или интерпретаторов).
Размер можно и уменьшить: tar-архив, пожатый 7-zip на максимальных настройках, примерно впятеро меньше исходника. Ещё процентов 10 можно убрать, найдя идентичные файлы через [fdupes](https://en.wikipedia.org/wiki/Fdupes) и подменив их на хардлинки (на веб-страницах полно абсолютно идентичного джаваскрипта). Хорошая фильтрация тоже не помешает. Например, за период с 2014-02-25 по 2017-04-22, я посетил 2,370,111 URL (в среднем 2055 в день); после фильтрации осталось 171,446 URL'ов, из которых всего 39,523 уникальных (34 в день, 12,520 в год).
По состоянию на 2017-04-22 архивы за 6 лет весят всего 55 Гб за счёт компрессии, агрессивной фильтрации, удаления больших доменов, которые и так бэкапит Internet Archive, и прочих ручных оптимизаций.
### Источники URL
Список страниц, которые надо сохранить, заполняется из нескольких источников. Во-первых, есть скрипт под названием firefox-urls:
**firefox-urls.sh**
```
#!/bin/sh
set -euo pipefail
cp --force `find ~/.mozilla/firefox/ -name "places.sqlite"|sort|head -1` ~/
sqlite3 -batch places.sqlite "SELECT url FROM moz_places, moz_historyvisits \
WHERE moz_places.id = moz_historyvisits.place_id and \
visit_date > strftime('%s','now','-1 day')*1000000 ORDER by \
visit_date;" | filter-urls
rm ~/places.sqlite
```
(filter-urls тот же самый, что и в local-archiver. Если я не хочу сохранять страницу локально, то я и в удалённый архив её не стану отправлять. Более того, у WebCite есть ограничение на число запросов, так что archiver еле справляется с нагрузкой и не надо грузить его ещё и пустой болтовнёй на форчане).
Этот скрипт запускается раз в час по крону:
```
@hourly firefox-urls >> ~/.urls.txt
```
Посещённые с последнего запуска адреса оказываются в файле и archiver их увидит при следующем запуске, так что всё, что я читаю, сохраняется навечно. Если у вас Chromium, то существуют аналогичные скрипты от Zachary Vance для извлечения [истории](https://github.com/za3k/rip-chrome-history) и [закладок](https://github.com/za3k/export-chrome-bookmarks).
Второй и, пожалуй, более полезный источник — парсер Markdown. Все ссылки аналогичным образом выдираются из моих документов ([link-extractor.hs](https://www.gwern.net/haskell/link-extractor.hs)), отправляются в файл списка, и рано или поздно они отправляются в архивы.
Наконец, иногда я скачиваю полный дамп всего сайта. В принципе я мог бы прокликать все страницы вручную и положиться на мои скрипты, но это не очень удобно. linkchecker по определению проверяет ссылки, так что неудивительно, что он может вернуть список всех URL на сайте и даже построить карту. Правда, среди многочисленных форматов, которые он умеет возвращать, нет простого списка адресов по одному на строчку, так что выхлоп нужно дорабатывать напильником (обратите внимание, что сильно перелинкованные сайты типа википедии лучше так не обходить):
```
linkchecker --check-extern -odot --complete -v --ignore-url=^mailto --no-warnings http://www.longbets.org | fgrep http | fgrep -v -e "label=" -e "->" -e '" [' -e '" ]' -e "/ " | sed -e "s/href=\"//" -e "s/\",//" -e "s/ //" | filter-urls | sort --unique >> ~/.urls.txt
```
### Что я в итоге делаю с битыми ссылками
Благодаря связке linkchecker и archiver, на Gwern.net почти нет битых ссылок. Когда они обнаруживаются, у меня уже подготовлено множество запасных вариантов:
1. Найти работающую версию страницы
2. Подставить копию из Internet Archive
3. Подставить копию из WebCite
4. Подставить копию из WikiWix
5. Использовать локальный дамп.
Если страница сохранена вместе со всеми необходимыми файлами (wget --convert-links --page-requisites), её можно превратить в пригодный для распространения PDF. Это удобнее, чем полная папка HTML, картинок и CSS, потому что один файл — это один файл, его проще передавать и на него проще ссылаться. Лично я пользуюсь [wkhtmltopdf](https://wkhtmltopdf.org/index.html), и меня устраивает. Например, мёртвая страница `http://www.aeiveos.com/~bradbury/MatrioshkaBrains/MatrioshkaBrainsPaper.html` превратилась во вполне читаемый [файл](https://www.gwern.net/docs/ai/1999-bradbury-matrioshkabrains.pdf). | https://habr.com/ru/post/546342/ | null | ru | null |
# Безопасность OAuth2 и Facebook Connect уязвимости
Это — [сиквел моей сногсшибательной первой статьи](http://habrahabr.ru/post/150756/).
Готов поспорить что каждый веб разработчик сталкивался с фейсбук коннектом или вконтакте логином или аутенфикацией через твиттер. Все это по сути построено на основе OAuth1/2.
Мое мнение заключается в том что мы все ступили не на ту дорожку. [OAuth это дорожка в ад](http://hueniverse.com/2012/07/oauth-2-0-and-the-road-to-hell/) (к слову, Эран Хаммер сейчас работает над заменой oauth — oz).
В этой статье я не буду погружаться в модель атаки а перескажу совершенно конкретные уязвимости которые вы можете начать использовать прямо сейчас.
#### CSRF на логине
В любой другой ситуации я бы сказал что CSRF на такой незначительной, хоть и state-changing, функции ничего не стоит. Но как только дело касается протоколов построенных на редиректах… Дело в том что в 99 процентов случаев процесс коннекта Site <= Facebook можно запустить загрузив GET /users/connect/facebook те начать процесс самому, без user interaction.
Идея в том, чтобы перелогинеть юзера на Фейсбуке (провайдере) в свой аккаунт, загрузить этот эндпоинт для коннекта, который автоматически подключит аккаунт атакующего к аккаунту жертвы на клиенте, и потом входить в аккаунт жертвы самому.
Фейсбук защищается лишь через проверку реферера:
Это новое воплощение [Самой Частой Ошибки](http://homakov.blogspot.com/2012/07/saferweb-most-common-oauth2.html) (не проверки state) только на более высоком уровне. Мы не подкидываем свой колбэк со своим кодом, а заставляем сам фейсбук вернуть код от вашего аккаунта путем форсированного перелогина. ФБ отказалось это исправлять, так как это ломает совместимость с разными существующими плагинами для фб. VK.com тоже уязвим (этим ребятам даже репортить некуда, посмещище какое то. Даже [магазин с фенечками](http://www.etsy.com/) более серьезно относится к безопасности). Этот баг можно использовать на любом сайте с omniauth, django-social-auth, php-sdk и так далее. Исправление — нужно проверять csrf token при загрузке /connect адреса.
Я бы даже сказал сама идея перелогина бросает тень на OAuth — ведь даже с помощью cookie forcing можно полностью заменить cookies жертвы и перелогинеть его на любом Провайдере. Это концептуальная ошибка которую уже никак не исправить.
#### signed\_request
СР это подписанный запрос с помощью client\_secret и создан он… непонятно зачем. Дело в том что это по сути тот же code-flow только code передается в # фрагменте и выпущен он для redirect\_uri = "". А значит если украсть signed\_request через 302 редирект его можно использовать чтобы зайти как владелец СР на сайте клиента (просто проставить куку fbsr\_CLIENT\_ID=SR).
Говоря простым языком, если на сайте есть Facebook JS SDK и вы нашли опен редирект (на домене или поддомене) — вы можете угнать любой аккаунт через слитие SR жертвы. И это опять таки не будет исправлено.
#### OAuth1 фиксация Paypal
Еще один WontFix. В пейпале перед запуском express checkout flow нужно получить request\_token отослав все свои параметры и потом уже загружать paypal?token=request\_token. Дело в том что вы можете выпустить этот токен для себя, путем фишинга загрузить этот УРЛ на браузере жертвы и убедить его оплатить этот токен (платеж и правда поступит Клиенту) то можно самому перейти по callback?token=token и получить все те деньги что заплатила жертва уже на свой аккаунт. Я проверял это на namecheap.
Это полная копия session fixation в OAuth1. Когда его открыли все провайдеры выключили коннект чтобы запатчить. В нашем же случае Paypal даже не пошевелил ухом. Тк уязвимы опять таки не они, а сайты-клиенты.
#### Вывод
Я крайне не рекомендую пользоваться логином через социальные сети. Если же вы вынуждены это реализовывать, постарайтесь прописать максимум проверок и поставить статические колбэки в настройках вашего клиента (hardening — уменьшение поверхности атаки). С багами выше я нашел эксплоиты для угона аккаунта на soundcloud, foursquare, songkick, airbnb, и еще десяток стартапов с соц логинами.
P.S. в яндекс баунти написал как у них угонять аккаунты, но им не сильно интересно поэтому копирую сюда:
1) фиксируем сессию на фейсбуке
2) вызываем у залогиненого в яндексе урл
[social.yandex.ru/broker/start?retpath=https%3A%2F%2Fsocial.yandex.ru%2Fhtml%2Fcloser%2Fpromo\_closer.html%23ddom%3D&consumer=social&popupName=social\_popup&application=&action\_if\_anonymous=ignore&result\_location=fragment&provider=fb&display=popup](https://social.yandex.ru/broker/start?retpath=https%3A%2F%2Fsocial.yandex.ru%2Fhtml%2Fcloser%2Fpromo_closer.html%23ddom%3D&consumer=social&popupName=social_popup&application=&action_if_anonymous=ignore&result_location=fragment&provider=fb&display=popup)
3) он автоматом приконектит атакерский фб к паспорту, но к счастью (моему сожалению) надо еще подтвердить auth через него. Немного соц инженерии, грузим
[passport.yandex.ru/passport?mode=authentication&retpath=https%3A%2F%2Fsocial.yandex.ru%2Fupdate%3Fprofile\_id%3D23177612%26allow\_auth%3D1](https://passport.yandex.ru/passport?mode=authentication&retpath=https%3A%2F%2Fsocial.yandex.ru%2Fupdate%3Fprofile_id%3D23177612%26allow_auth%3D1)
как видите там ни слова про фейсбук или аккаунты, просто требует ввести пароль, что юзер с удовольствием сделает (side-bug. наверно стоит объяснять для чего спрашивают пароль а то мало ли)
4) теперь можно через атакерский фб войти прямо в яндекс, отконнектить фейсбук, украсть почту и куки — perfect crime
[Original post in English.](http://homakov.blogspot.com/2014/01/two-severe-wontfix-vulnerabilities-in.html) | https://habr.com/ru/post/211362/ | null | ru | null |
# DDD на практике. Проектирование списка желаний
В интернете довольно много разрозненного материала по DDD. Если не считать синей книги, то в основном это короткие статьи с теорией, надёрганной из этой же книги, и которая мало пересекается с практикой. Возможно, конечно, что я просто плохо искал, но мне давно хотелось найти какой-нибудь цельный пример, что называется, «от и до». И я решил такой пример создать на Symfony 3 и VueJS. Сразу хочу сказать, что я изучаю DDD недавно, поэтому взял довольно простую предметную область — [список желаний](https://github.com/franzose/symfony-ddd-wishlist) (wish list).
Список желаний
--------------
Любой человек когда-нибудь да что-нибудь покупает. Будь то новый телефон, подарок, поездка за границу или даже квартира. Список желаний, как дополнение к «хардварной» копилке, призван помочь отслеживать накопленные средства по каждому из желаний и заставлять эти средства постоянно увеличивать. Допустим, сегодня я решил начать копить на новый ноутбук: добавлю желание и начну откладывать деньги. А завтра я захочу посчитать, какое количество денег нужно будет откладывать ежедневно, чтобы через полгода я смог купить хороший подарок жене.
Желание
-------
Желания, которые мы рассматриваем, можно удовлетворить, купив нечто за деньги. Из этого следует, что у каждого желания есть *стоимость*, *начальный фонд* (если вы начали копить деньги до того, как решили внести желание в список) и накопленные средства — *фонд*, который выражается суммой всех *вкладов*. Вклад — это единовременно отложенная сумма денег на конкретное желание. Поскольку желания требуют регулярных вложений, неплохо было бы определить и *базовую ставку*, ниже которой сумма вклада быть не может. К тому же мы должны иметь возможность отслеживать вклады в любое из желаний, чтобы при необходимости их изымать. По мере накопления достаточного количества средств желание становится исполненным. Если же есть избыток денежных средств, то его можно перераспределить на другие свои желания (об этом в одной из следующих статей).
### Проектируем сущности
Исходя из вышеперечисленных требований, мы можем закодировать две сущности: `Wish` (желание) и `Deposit` (вклад).
### Желание: конструктор сущности
Давайте начнём с желания и подумаем, какие поля нам понадобятся и как мы оформим конструктор сущности. Первое, что приходит в голову, это примерно вот такой код:
```
php
namespace Wishlist\Domain;
use DateTimeImmutable;
use Doctrine\Common\Collections\ArrayCollection;
class Wish
{
private $id;
private $name;
private $price;
private $fee;
private $deposits;
private $initialFund;
private $createdAt;
private $updatedAt;
public function __construct(
string $name,
int $price,
int $fee,
int $initialFund
) {
$this-name = $name;
$this->price = $price;
$this->fee = $fee;
$this->initialFund = $initialFund;
$this->deposits = new ArrayCollection();
$this->createdAt = $createdAt ?? new DateTimeImmutable();
$this->updatedAt = $createdAt ?? new DateTimeImmutable();
}
}
```
Однако здесь есть целый ряд проблем:
1. Используется суррогатный ключ
2. Отсутствует валидация полей
3. Если валидацию закодировать в конструктор, он станет еще монструознее
4. Отсутствует информация о валюте, в которой ведутся расчёты
5. Конструктор перегружен аргументами
Что же будем делать? Есть решение — использовать объекты-значения. Тогда конструктор нашей сущности преобразится следующим образом:
```
php
namespace Wishlist\Domain;
use DateTimeImmutable;
use Doctrine\Common\Collections\ArrayCollection;
class Wish
{
private $id;
private $name;
private $expense;
private $deposits;
private $published = false;
private $createdAt;
private $updatedAt;
public function __construct(
WishId $id,
WishName $name,
Expense $expense,
DateTimeImmutable $createdAt = null
) {
$this-id = $id;
$this->name = $name;
$this->expense = $expense;
$this->deposits = new ArrayCollection();
$this->createdAt = $createdAt ?? new DateTimeImmutable();
$this->updatedAt = $createdAt ?? new DateTimeImmutable();
}
}
```
Мы использовали три объекта-значения:
1. `WishId`, который представляет из себя `UUID`, генерируемый с помощью библиотеки [ramsey/uuid](https://github.com/ramsey/uuid)
2. `WishName` — название желания
3. `Expense`, который представляет «траты» на желание: стоимость, базовую ставку и начальный фонд (возможно, не самое удачное название, но другого я не придумал)
Вы спросите: почему в конструктор сущности попала дата её создания? Я вам отвечу: это сделано, чтобы облегчить написание тестов и нигде кроме тестов не используется. Возможно, не самое лучшее решение, конечно.
Что ж, раз мы использовали объекты-значения, неплохо было бы посмотреть и на их реализацию. Для начала подумаем, как реализовать идентификаторы (забегая вперёд, скажу, что кроме `WishId` у нас будет еще и `DepositId`). Для этого мы напишем простенький тест на примере одного из них (суть-то одна и та же, поэтому два разных теста писать смысла нет):
```
php
namespace Wishlist\Tests\Domain;
use Wishlist\Domain\WishId;
use PHPUnit\Framework\TestCase;
class IdentityTest extends TestCase
{
public function testFromValidString()
{
$string = '550e8400-e29b-41d4-a716-446655440000';
$wishId = WishId::fromString($string);
static::assertInstanceOf(WishId::class, $wishId);
static::assertEquals($string, $wishId-getId());
static::assertEquals($string, (string) $wishId);
}
public function testEquality()
{
$string = '550e8400-e29b-41d4-a716-446655440000';
$wishIdOne = WishId::fromString($string);
$wishIdTwo = WishId::fromString($string);
$wishIdThree = WishId::next();
static::assertTrue($wishIdOne->equalTo($wishIdTwo));
static::assertFalse($wishIdTwo->equalTo($wishIdThree));
}
}
```
Исходя из данных тестов, мы можем сделать базовый класс идентификаторов, который содержит общую логику:
```
php
namespace Wishlist\Domain;
use Ramsey\Uuid\Exception\InvalidUuidStringException;
use Ramsey\Uuid\Uuid;
use Ramsey\Uuid\UuidInterface;
use Wishlist\Domain\Exception\InvalidIdentityException;
abstract class AbstractId
{
protected $id;
private function __construct(UuidInterface $id)
{
$this-id = $id;
}
public static function fromString(string $id)
{
try {
return new static(Uuid::fromString($id));
} catch (InvalidUuidStringException $exception) {
throw new InvalidIdentityException($id);
}
}
public static function next()
{
return new static(Uuid::uuid4());
}
public function getId(): string
{
return $this->id->toString();
}
public function equalTo(AbstractId $id): bool
{
return $this->getId() === $id->getId();
}
public function __toString(): string
{
return $this->getId();
}
}
```
А «настоящие» идентификаторы просто от него «отпачковать»:
```
php
namespace Wishlist\Domain;
final class WishId extends AbstractId
{
//
}
</code
```
И то же самое с DepositId:
```
php
namespace Wishlist\Domain;
final class DepositId extends AbstractId
{
//
}
</code
```
Теперь рассмотрим `WishName`. Это самый простой объект-значение, и нам нужно лишь чтобы название не было пустым. Давайте для начала напишем тесты:
```
php
namespace Wishlist\Tests\Domain;
use Wishlist\Domain\WishName;
use PHPUnit\Framework\TestCase;
class WishNameTest extends TestCase
{
/**
* @expectedException \InvalidArgumentException
*/
public function testShouldNotCreateWithEmptyString()
{
new WishName('');
}
public function testGetValueShouldReturnTheName()
{
$expected = 'A bucket of candies';
$name = new WishName($expected);
static::assertEquals($expected, $name-getValue());
static::assertEquals($expected, (string) $name);
}
}
```
Теперь давайте, собственно, закодируем `WishName`. Кстати, для проверок здесь и далее будем использовать очень удобную библиотеку [webmozart/assert](https://github.com/webmozart/assert):
```
php
namespace Wishlist\Domain;
use Webmozart\Assert\Assert;
final class WishName
{
private $name;
public function __construct(string $name)
{
Assert::notEmpty($name, 'Name must not be empty.');
$this-name = $name;
}
public function getValue(): string
{
return $this->name;
}
public function __toString(): string
{
return $this->getValue();
}
}
```
Теперь перейдем к более интересному объекту-значению — `Expense`. Он призван контролировать корректные значения стоимости, базовой ставки и начального фонда. Поможем ему в этом, определив требования:
1. Стоимость может быть только положительным числом
2. То же относится к базовой ставке
3. Начальный фонд не может быть отрицательным числом, если указан
Помимо этого, на свойства накладываются следующие ограничения:
1. Базовая ставка должна быть меньше, чем стоимость
2. Начальный фонд также должен быть меньше, чем стоимость
Поскольку нам нужна еще и валюта, то для работы с деньгами мы не будем использовать «голые» `int`’ы, а воспользуемся библиотекой [moneyphp/money](https://github.com/moneyphp/money). Учитывая всё вышесказанное об `Expense`, напишем следующие тесты:
```
php
namespace Wishlist\Tests\Domain;
use Money\Currency;
use Money\Money;
use Wishlist\Domain\Expense;
use PHPUnit\Framework\TestCase;
class ExpenseTest extends TestCase
{
/**
* @expectedException \InvalidArgumentException
* @dataProvider nonsensePriceDataProvider
*/
public function testPriceAndFeeMustBePositiveNumber($price, $fee, $initialFund)
{
Expense::fromCurrencyAndScalars(new Currency('USD'), $price, $fee, $initialFund);
}
public function nonsensePriceDataProvider()
{
return [
'Price must be greater than zero' = [0, 0, 0],
'Fee must be greater than zero' => [1, 0, 0],
'Price must be positive' => [-1, -1, 0],
'Fee must be positive' => [1, -1, 0],
'Initial fund must be positive' => [2, 1, -1],
];
}
/**
* @expectedException \InvalidArgumentException
*/
public function testFeeMustBeLessThanPrice()
{
Expense::fromCurrencyAndScalars(new Currency('USD'), 100, 150);
}
/**
* @expectedException \InvalidArgumentException
*/
public function testInitialFundMustBeLessThanPrice()
{
Expense::fromCurrencyAndScalars(new Currency('USD'), 100, 50, 150);
}
/**
* @expectedException \InvalidArgumentException
*/
public function testNewPriceMustBeOfTheSameCurrency()
{
$expense = Expense::fromCurrencyAndScalars(new Currency('USD'), 100, 50, 25);
$expense->changePrice(new Money(200, new Currency('RUB')));
}
public function testChangePriceMustReturnANewInstance()
{
$expense = Expense::fromCurrencyAndScalars(new Currency('USD'), 100, 50, 25);
$actual = $expense->changePrice(new Money(200, new Currency('USD')));
static::assertNotSame($expense, $actual);
static::assertEquals(200, $actual->getPrice()->getAmount());
}
/**
* @expectedException \InvalidArgumentException
*/
public function testNewFeeMustBeOfTheSameCurrency()
{
$expense = Expense::fromCurrencyAndScalars(new Currency('USD'), 100, 50, 25);
$expense->changeFee(new Money(200, new Currency('RUB')));
}
public function testChangeFeeMustReturnANewInstance()
{
$expense = Expense::fromCurrencyAndScalars(new Currency('USD'), 100, 10, 25);
$actual = $expense->changeFee(new Money(20, new Currency('USD')));
static::assertNotSame($expense, $actual);
static::assertEquals(20, $actual->getFee()->getAmount());
}
}
```
В них, помимо всего прочего, заложена возможность смены стоимости и базовой ставки желания. Поэтому класс содержит два дополнительных теста на соответствие валют.
Теперь можем закодировать `Expense`:
```
php
namespace Wishlist\Domain;
use Money\Currency;
use Money\Money;
use Webmozart\Assert\Assert;
final class Expense
{
private $price;
private $fee;
private $initialFund;
private function __construct(Money $price, Money $fee, Money $initialFund)
{
$this-price = $price;
$this->fee = $fee;
$this->initialFund = $initialFund;
}
public static function fromCurrencyAndScalars(
Currency $currency,
int $price,
int $fee,
int $initialFund = null
) {
foreach ([$price, $fee] as $argument) {
Assert::notEmpty($argument);
Assert::greaterThan($argument, 0);
}
Assert::lessThan($fee, $price, 'Fee must be less than price.');
if (null !== $initialFund) {
Assert::greaterThanEq($initialFund, 0);
Assert::lessThan($initialFund, $price, 'Initial fund must be less than price.');
}
return new static(
new Money($price, $currency),
new Money($fee, $currency),
new Money($initialFund ?? 0, $currency)
);
}
public function getCurrency(): Currency
{
return $this->price->getCurrency();
}
public function getPrice(): Money
{
return $this->price;
}
public function changePrice(Money $amount): Expense
{
Assert::true($amount->getCurrency()->equals($this->getCurrency()));
return new static($amount, $this->fee, $this->initialFund);
}
public function getFee(): Money
{
return $this->fee;
}
public function changeFee(Money $amount): Expense
{
Assert::true($amount->getCurrency()->equals($this->getCurrency()));
return new static($this->price, $amount, $this->initialFund);
}
public function getInitialFund(): Money
{
return $this->initialFund;
}
}
```
Итак, мы рассмотрели все объекты-значения, которые используются сущностью `Wish`, с её конструктором определились, так что теперь пора перейти непосредственно к бизнес-логике.
### Желание: копим денежки
Представьте себе обычную копилку. Туда кладут монетки или бумажки определенного номинала и валюты. Т.е. делается вклад в копилку. Как только копилка заполняется доверху, её разбивают. Так и у нас с нашими желаниями: мы вкладываем некоторую сумму денег в них, а когда набирается достаточная сумма, считаем, что желание исполнено (можно идти в магазин :) и потому далее делать вклады в него уже бессмысленно. Есть еще одно небольшое ограничение: вклады можно делать, только если желание опубликовано (например, вы можете отложить его до лучших времен).
Пора снова писать тесты.
```
php
namespace Wishlist\Tests\Domain;
use DateInterval;
use DateTimeImmutable;
use Money\Currency;
use Money\Money;
use Symfony\Bundle\FrameworkBundle\Tests\TestCase;
use Wishlist\Domain\DepositId;
use Wishlist\Domain\Expense;
use Wishlist\Domain\Wish;
use Wishlist\Domain\WishId;
use Wishlist\Domain\WishName;
class WishTest extends TestCase
{
/**
* @expectedException \Wishlist\Domain\Exception\DepositIsTooSmallException
*/
public function testMustDeclineDepositIfItIsLessThanFee()
{
$wish = $this-createWishWithPriceAndFee(1000, 100);
$wish->publish();
$wish->deposit(new Money(50, new Currency('USD')));
}
public function testExtraDepositMustFulfillTheWish()
{
$wish = $this->createWishWithPriceAndFund(1000, 900);
$wish->publish();
$wish->deposit(new Money(150, new Currency('USD')));
static::assertTrue($wish->isFulfilled());
}
/**
* @expectedException \Wishlist\Domain\Exception\WishIsUnpublishedException
*/
public function testMustNotDepositWhenUnpublished()
{
$wish = $this->createWishWithEmptyFund();
$wish->deposit(new Money(100, new Currency('USD')));
}
/**
* @expectedException \Wishlist\Domain\Exception\WishIsFulfilledException
*/
public function testMustNotDepositWhenFulfilled()
{
$fulfilled = $this->createWishWithPriceAndFund(500, 450);
$fulfilled->publish();
$fulfilled->deposit(new Money(100, new Currency('USD')));
$fulfilled->deposit(new Money(100, new Currency('USD')));
}
public function testDepositShouldAddDepositToInternalCollection()
{
$wish = $this->createWishWithEmptyFund();
$wish->publish();
$depositMoney = new Money(150, new Currency('USD'));
$wish->deposit($depositMoney);
$deposits = $wish->getDeposits();
static::assertCount(1, $deposits);
static::assertArrayHasKey(0, $deposits);
$deposit = $deposits[0];
static::assertTrue($deposit->getMoney()->equals($depositMoney));
static::assertSame($wish, $deposit->getWish());
}
/**
* @expectedException \InvalidArgumentException
*/
public function testDepositAndPriceCurrenciesMustMatch()
{
$wish = $this->createWishWithEmptyFund();
$wish->publish();
$wish->deposit(new Money(125, new Currency('RUB')));
}
private function createWishWithEmptyFund(): Wish
{
return new Wish(
WishId::next(),
new WishName('Bicycle'),
Expense::fromCurrencyAndScalars(
new Currency('USD'),
1000,
100
)
);
}
private function createWishWithPriceAndFund(int $price, int $fund): Wish
{
return new Wish(
WishId::next(),
new WishName('Bicycle'),
Expense::fromCurrencyAndScalars(
new Currency('USD'),
$price,
10,
$fund
)
);
}
}
```
Чтобы тесты заработали, добавим несколько методов в сущность `Wish`:
```
php
namespace Wishlist\Domain;
// ...
// добавим в блок use несколько исключений
use Wishlist\Domain\Exception\DepositIsTooSmallException;
use Wishlist\Domain\Exception\WishIsFulfilledException;
use Wishlist\Domain\Exception\WishIsUnpublishedException;
// ...
public function deposit(Money $amount): Deposit
{
$this-assertCanDeposit($amount);
$deposit = new Deposit(DepositId::next(), $this, $amount);
$this->deposits->add($deposit);
return $deposit;
}
private function assertCanDeposit(Money $amount)
{
if (!$this->published) {
throw new WishIsUnpublishedException($this->getId());
}
if ($this->isFulfilled()) {
throw new WishIsFulfilledException($this->getId());
}
if ($amount->lessThan($this->getFee())) {
throw new DepositIsTooSmallException($amount, $this->getFee());
}
Assert::true(
$amount->isSameCurrency($this->expense->getPrice()),
'Deposit currency must match the price\'s one.'
);
}
public function isFulfilled(): bool
{
return $this->getFund()->greaterThanOrEqual($this->expense->getPrice());
}
public function publish()
{
$this->published = true;
$this->updatedAt = new DateTimeImmutable();
}
public function unpublish()
{
$this->published = false;
$this->updatedAt = new DateTimeImmutable();
}
public function getFund(): Money
{
return array_reduce($this->deposits->toArray(), function (Money $fund, Deposit $deposit) {
return $fund->add($deposit->getMoney());
}, $this->expense->getInitialFund());
}
```
Рассмотрим все эти методы поочередно.
1. `deposit` — проверяет, может ли быть сделан вклад, и если может, то совершает вклад в желание указанной суммы денег. Для этого создается объект сущности Deposit и сохраняется во внутреннюю коллекцию вкладов.
2. `isFulfilled` — указывает, исполнено ли желание. Ну, а мы ранее определились, что желание считается исполненным, если его накопления больше или равняются стоимости.
3. `publish/unpublish` — публикует или убирает в черновики соответственно.
4. `getFund` — возвращает фонд, т.е. накопленные средства.
Вы, должно быть, обратили внимание на то, что в методе `Wish::deposit` используется одноименная сущность. Теперь, чтобы продолжать развивать бизнес-логику желания дальше, нам необходимо запрограммировать сущность `Deposit`. Давайте этим и займемся, благо, что она гораздо проще и много времени это не займёт.
### Deposit: конструктор
Вклад будет иметь всего четыре свойства:
1. Идентификатор, поскольку это сущность, а также необходимо иметь возможность управлять вкладами
2. Желание, к которому относится этот вклад
3. Сумма вклада
4. Дата создания вклада
Также необходимо учесть, что вклад не может быть нулевым, поскольку это бессмысленно, как если бы мы в копилку клали воображаемые деньги, а в руках у нас даже не было бы игрушечного эквивалента денег :).
Как всегда, начнём с тестов:
```
php
namespace Wishlist\Tests\Domain;
use Mockery;
use Money\Currency;
use Money\Money;
use PHPUnit\Framework\TestCase;
use Wishlist\Domain\Deposit;
use Wishlist\Domain\DepositId;
use Wishlist\Domain\Wish;
class DepositTest extends TestCase
{
/**
* @expectedException \InvalidArgumentException
*/
public function testDepositAmountMustNotBeZero()
{
$wish = Mockery::mock(Wish::class);
$amount = new Money(0, new Currency('USD'));
new Deposit(DepositId::next(), $wish, $amount);
}
}
</code
```
В этом тесте мы использовали библиотеку [mockery/mockery](https://github.com/mockery/mockery), чтобы полностью не описывать желание, т.к. нас интересует логика самого вклада. Здесь есть повод для дискуссии относительного того, надо ли делать в конструкторе `Deposit` проверку желания, аналогичную той, что делается в методе `Wish::deposit`. Я этого делать не стал, поскольку напрямую сущность `Deposit` нигде не используется, все операции с вкладами, которые будут рассмотрены в статье, осуществляются только в сущности `Wish`.
Получилась вот такая простая сущность:
```
php
namespace Wishlist\Domain;
use DateTimeImmutable;
use DateTimeInterface;
use Money\Money;
use Webmozart\Assert\Assert;
class Deposit
{
private $id;
private $wish;
private $amount;
private $createdAt;
public function __construct(DepositId $id, Wish $wish, Money $amount)
{
Assert::false($amount-isZero(), 'Deposit must not be empty.');
$this->id = $id;
$this->wish = $wish;
$this->amount = $amount;
$this->createdAt = new DateTimeImmutable();
}
public function getId(): DepositId
{
return $this->id;
}
public function getWish(): Wish
{
return $this->wish;
}
public function getMoney(): Money
{
return $this->amount;
}
public function getDate(): DateTimeInterface
{
return $this->createdAt;
}
}
```
### Желание: изымаем вклад
С сущностью `Deposit` разобрались, теперь можно вернуться к программированию желания. По условию задачи мы можем не только накапливать деньги на желание, но и изымать уже сделанные вклады. Например, если какой-то из них был сделан по ошибке.
Естественно, сначала добавим несколько тестов в класс `WishTest`:
```
/**
* @expectedException \Wishlist\Domain\Exception\WishIsUnpublishedException
*/
public function testMustNotWithdrawIfUnpublished()
{
$wish = $this->createWishWithPriceAndFund(500, 0);
$wish->publish();
$deposit = $wish->deposit(new Money(100, new Currency('USD')));
$wish->unpublish();
$wish->withdraw($deposit->getId());
}
/**
* @expectedException \Wishlist\Domain\Exception\WishIsFulfilledException
*/
public function testMustNotWithdrawIfFulfilled()
{
$wish = $this->createWishWithPriceAndFund(500, 450);
$wish->publish();
$deposit = $wish->deposit(new Money(100, new Currency('USD')));
$wish->withdraw($deposit->getId());
}
/**
* @expectedException \Wishlist\Domain\Exception\DepositDoesNotExistException
*/
public function testWithdrawMustThrowOnNonExistentId()
{
$wish = $this->createWishWithEmptyFund();
$wish->publish();
$wish->withdraw(DepositId::next());
}
public function testWithdrawShouldRemoveDepositFromInternalCollection()
{
$wish = $this->createWishWithEmptyFund();
$wish->publish();
$wish->deposit(new Money(150, new Currency('USD')));
$wish->withdraw($wish->getDeposits()[0]->getId());
static::assertCount(0, $wish->getDeposits());
}
```
Как видим, ограничения на изъятие вкладов похожи на те, что мы писали для их внесения. Теперь добавим необходимую логику в класс желания:
```
php
namespace Wishlish\Domain;
// <...
public function withdraw(DepositId $depositId)
{
$this->assertCanWithdraw();
$deposit = $this->getDepositById($depositId);
$this->deposits->removeElement($deposit);
}
private function assertCanWithdraw()
{
if (!$this->published) {
throw new WishIsUnpublishedException($this->getId());
}
if ($this->isFulfilled()) {
throw new WishIsFulfilledException($this->getId());
}
}
private function getDepositById(DepositId $depositId): Deposit
{
$deposit = $this->deposits->filter(
function (Deposit $deposit) use ($depositId) {
return $deposit->getId()->equalTo($depositId);
}
)->first();
if (!$deposit) {
throw new DepositDoesNotExistException($depositId);
}
return $deposit;
}
```
Как говорится, в любой непонятной ситуации кидай эксепшн! Метод `withdraw` получился довольно простым, тем не менее мы учли все условия задачи:
1. Не получится изъять вклад, которого нет
2. Мы не сможем этого сделать, если желание в черновиках или уже исполнено
### Желание: рассчитываем излишки накоплений
Функция не самая важная, на самом деле, но она сделана на тот случай, когда в один прекрасный момент окажется, что под рукой нет нужной суммы для пополнения запасов, но есть большая. Ну, или, например, если вы откладывали на желание достаточно большие суммы, а потом просто «промахнулись», не уследив за количеством уже имеющихся средств. Посчитать излишки, на самом деле, просто: из стоимости желания вычтем его фонд и возьмём абсолютное значение. Если разница была положительной, излишки можно считать равными нулю.
Дополним класс `WishTest` новыми тестами:
```
public function testSurplusFundsMustBe100()
{
$wish = $this->createWishWithPriceAndFund(500, 300);
$wish->publish();
$wish->deposit(new Money(100, new Currency('USD')));
$wish->deposit(new Money(200, new Currency('USD')));
$expected = new Money(100, new Currency('USD'));
static::assertTrue($wish->calculateSurplusFunds()->equals($expected));
}
public function testSurplusFundsMustBeZero()
{
$wish = $this->createWishWithPriceAndFund(500, 250);
$wish->publish();
$wish->deposit(new Money(100, new Currency('USD')));
$expected = new Money(0, new Currency('USD'));
static::assertTrue($wish->calculateSurplusFunds()->equals($expected));
}
```
На основе вышесказанного и написанных тестов мы можем написать вот такой метод в сущности `Wish`:
```
php
namespace Wishlist\Domain;
// <...
public function calculateSurplusFunds(): Money
{
$difference = $this->getPrice()->subtract($this->getFund());
return $difference->isNegative()
? $difference->absolute()
: new Money(0, $this->getCurrency());
}
```
### Желание: вангуем дату исполнения
Предсказать дату исполнения желания можно двумя способами:
1. На основе стоимости и базовой ставки
2. На основе стоимости и накопленных средств
Первый способ простой: делим стоимость на базовую ставку, как результат получаем количество дней, которые уйдут на накопление средств. К текущей дате прибавляем полученные дни, и вот нам дата исполнения желания.
Второй способ немногим сложнее. Из стоимости вычитаем накопленные средства, полученную разность разделим на базовую ставку, это даст нам количество дней до исполнения желания, их прибавим к текущей дате и получим дату исполнения желания.
Алгоритмы есть, напишем тесты:
```
public function testFulfillmentDatePredictionBasedOnFee()
{
$price = 1500;
$fee = 20;
$wish = $this->createWishWithPriceAndFee($price, $fee);
$daysToGo = ceil($price / $fee);
$expected = (new DateTimeImmutable())->add(new DateInterval("P{$daysToGo}D"));
static::assertEquals(
$expected->getTimestamp(),
$wish->predictFulfillmentDateBasedOnFee()->getTimestamp()
);
}
public function testFulfillmentDatePredictionBasedOnFund()
{
$price = 1500;
$fund = 250;
$fee = 25;
$wish = $this->createWish($price, $fee, $fund);
$daysToGo = ceil(($price - $fund) / $fee);
$expected = (new DateTimeImmutable())->add(new DateInterval("P{$daysToGo}D"));
static::assertEquals(
$expected->getTimestamp(),
$wish->predictFulfillmentDateBasedOnFund()->getTimestamp()
);
}
```
Чтобы тесты стали зелеными, запрограммируем вычисление даты исполнения желания по заданным алгоритмам:
```
public function predictFulfillmentDateBasedOnFee(): DateTimeInterface
{
$daysToGo = ceil(
$this->getPrice()
->divide($this->getFee()->getAmount())
->getAmount()
);
return $this->createFutureDate($daysToGo);
}
public function predictFulfillmentDateBasedOnFund(): DateTimeInterface
{
$daysToGo = ceil(
$this->getPrice()
->subtract($this->getFund())
->divide($this->getFee()->getAmount())
->getAmount()
);
return $this->createFutureDate($daysToGo);
}
private function createFutureDate($daysToGo): DateTimeInterface
{
return (new DateTimeImmutable())->add(new DateInterval("P{$daysToGo}D"));
}
```
### Желание: меняем состояние
Всё, что нам осталось закодировать на данном этапе, — несколько несложных методов, которые меняют состояние желания:
1. Публикация и отправка в «черновики»
2. Изменение стоимости
3. Изменение базовой ставки вкладов
Думаю, вы и без меня догадались, что сначала мы под всё это дело напишем тесты в класс `WishTest`. Сперва для публикации:
```
public function testPublishShouldPublishTheWish()
{
$wish = $this->createWishWithEmptyFund();
$updatedAt = $wish->getUpdatedAt();
$wish->publish();
static::assertTrue($wish->isPublished());
static::assertNotSame($updatedAt, $wish->getUpdatedAt());
}
public function testUnpublishShouldUnpublishTheWish()
{
$wish = $this->createWishWithEmptyFund();
$updatedAt = $wish->getUpdatedAt();
$wish->unpublish();
static::assertFalse($wish->isPublished());
static::assertNotSame($updatedAt, $wish->getUpdatedAt());
}
```
Методы сущности будут столь же просты, сколь и тесты:
```
php
namespace Wishlist\Domain;
// <...
class Wish
{
// <...>
public function publish()
{
$this->published = true;
$this->updatedAt = new DateTimeImmutable();
}
public function unpublish()
{
$this->published = false;
$this->updatedAt = new DateTimeImmutable();
}
public function isPublished(): bool
{
return $this->published;
}
// <...>
}
```
Теперь то, что касается изменения стоимости и базовой ставки. Тесты:
```
public function testChangePrice()
{
$wish = $this->createWishWithPriceAndFee(1000, 10);
$expected = new Money(1500, new Currency('USD'));
$updatedAt = $wish->getUpdatedAt();
static::assertSame($updatedAt, $wish->getUpdatedAt());
$wish->changePrice($expected);
static::assertTrue($wish->getPrice()->equals($expected));
static::assertNotSame($updatedAt, $wish->getUpdatedAt());
}
public function testChangeFee()
{
$wish = $this->createWishWithPriceAndFee(1000, 10);
$expected = new Money(50, new Currency('USD'));
$updatedAt = $wish->getUpdatedAt();
static::assertSame($updatedAt, $wish->getUpdatedAt());
$wish->changeFee($expected);
static::assertTrue($wish->getFee()->equals($expected));
static::assertNotSame($updatedAt, $wish->getUpdatedAt());
}
```
И соответствующие им методы в сущности:
```
php
namespace Wishlist\Domain;
// <...
class Wish
{
// <...>
public function changePrice(Money $amount)
{
$this->expense = $this->expense->changePrice($amount);
$this->updatedAt = new DateTimeImmutable();
}
public function changeFee(Money $amount)
{
$this->expense = $this->expense->changeFee($amount);
$this->updatedAt = new DateTimeImmutable();
}
// <...>
}
```
Столько кода, столько тестов написано и ~~всё впустую~~ для того, чтобы наши желания исполнялись. Вот что в итоге мы можем делать с желанием:
1. Накапливать денежные средства — `Wish::deposit(Money $amount)`
2. Избавляться от них — `Wish::withdraw(DepositId $depositId)`
3. Рассчитывать дату исполнения двумя способами — `Wish::predictFulfillmentDateBasedOnFee()` и `Wish::predictFulfillmentDateBasedOnFund()`
4. Публиковать и убирать в черновики — `Wish::publish()`и `Wish::unpublish()`
5. Менять стоимость и базову ставку — `Wish::changePrice(Money $amount)` и `Wish::changeFee(Money $amount)`
И всё же статья когда-то должна закончиться, так что вишенкой на торте станет интерфейс репозитория желаний, который мы положим рядом с сущностью Wish:
```
php
namespace Wishlist\Domain;
interface WishRepositoryInterface
{
public function get(WishId $wishId): Wish;
public function put(Wish $wish);
public function slice(int $offset, int $limit): array;
public function contains(Wish $wish): bool;
public function containsId(WishId $wishId): bool;
public function count(): int;
public function getNextWishId(): WishId;
}</code
```
Его реализацию, а также много других интересных вещей, мы рассмотрим в следующих статьях на тему списка желаний. Удачи!
P.S.: [Исходный код проекта](https://github.com/franzose/symfony-ddd-wishlist). Актуальное состояние репозитория может отличаться от того, что было описано в статье. Тем не менее вы всегда можете посмотреть, как «Москва не сразу строилась» по отдельным коммитам хоть с самого начала :) | https://habr.com/ru/post/335834/ | null | ru | null |
# Математика в Gamedev по-простому. Триангуляции и Triangle.Net в Unity
Всем привет! Меня зовут Гриша, и я основатель CGDevs. Математика – очень крутой инструмент при разработке игр. Но если скажем без понимания [векторов](https://habr.com/post/430146/) и [матриц](https://habr.com/post/432544/) обойтись в принципе сложно, то алгоритмы триангуляций не столь обязательная вещь, но с помощью них решается достаточно большое количество интересных задач. Сегодня хотелось бы поговорить про достаточно важный инструмент в вычислительной геометрии, такой как триангуляции и их применение в игровой индустрии. Кроме того, я написал порт и немного обёрток великолепной библиотеки Triangle.Net для Unity. Если интересно – добро пожаловать под кат. Ссылка на гитхаб прилагается.
### Что такое триангуляция?
В общем случае **триангуляция** – это разбиение геометрического объекта на треугольники. Это понятие само по себе довольно простое. Базовый пример триангуляции в случае игровых движков – это меш. Строго говоря меш может состоять не только из треугольников, но в игровых движках по целому ряду причин берутся именно меши, состоящие из треугольников.
Триангуляции бывают разными, но один из самых популярных видов триангуляций является **триангуляция Делоне.** Этот вид триангуляции отличается тем свойством, что в окружности, описанной вокруг каждого треугольника, лежат только вершины этого треугольника.
### Зачем они нужны?
В целом за пределами игровой индустрии с помощью триангуляций решается большое количество задач. В геймдеве же первая задача, которая приходит на ум – это navigation mesh. Навмеш – это структура данных, которая определяет, по какому пространству игрок может ходить. Он позволяет избежать таких сложных вычислительных задач, как определение столкновений с частью окружения.
Вторая интересная задача, решаемая с помощью триангуляции Делоне в геймдеве – это генерация террейнов и объектов представленных в виде множества точек. Основным плюсом триангуляции Делоне в данном случае является то, что исходя из её свойств она позволяет избежать очень острых треугольников, которые будут мешать и создавать артефакты на тиррейне.
Помимо этого, с помощью триангуляции Делоне с ограничениями и таким алгоритмам как Chew's second algorithm и Ruppert's algorithm можно генерировать сетки ещё лучше для тиррейнов и генерировать хорошие сетки для другого применения – метода конечных элементов.
Сам по себе метод конечных элементов, это один из методов с помощью которого решаются задачи прикладной физике. В геймдеве он позволяет решать многие задачи, связанные с симуляцией деформаций, жидкостных симуляций и другого используемого для спец. эффектов. Обычно для записи эффектов в анимации, так как для реалтайма метод обладает слишком высокой вычислительной сложностью. Важной деталью при использовании метода является то, что ошибка метода зависит от углов треугольников в сетке. При наличии в сетке очень острых углов метод даёт огромную ошибку, по этой причине нужны алгоритмы, перечисленные выше.
Ну и конечно же в целом процедурная генерация мешей. Как пример в гитхаб проекте приведена сцена с возможностью рисовать меши. Некоторые физические головоломки используют это применение, как основную механику. Но кроме того алгоритмы триангуляции позволяют с помощью процедурной генерации решать такие задачи, как процедурная разрушаемость и прочее.
Помимо геймдева триангуляции используются в сетях, компьютерном зрении, различных аналитических алгоритмах, а так же в каких задачах вычислительной геометрии, как объединение и исключение многоугольников друг из друга (что бывает полезно часто и в задачах возникающих при разработке игр)
### Ear Clipping with Holes
Пожалуй, один из самых простых алгоритмов триангуляции. Даёт не лучшую сетку и обладает большой вычислительной сложностью О(n^2) в худшем случае.
[Подробнее про него можно прочитать в этой статье](https://www.geometrictools.com/Documentation/TriangulationByEarClipping.pdf)
### Bowyer–Watson algorithm
Алгоритм, генерирующий триангуляцию Делоне по набору точек. В целом, как и у большинства алгоритмов Делоне при правильной реализации алгоритмическая сложность O( n log n), где n – количество вершин. Но в некоторых случаях может занимать O(n^2).
Минусами относительно Ear Clipping является то, что данный алгоритм строит выпуклую триангуляцию и в базовой реализации не предполагает дыр в получившейся сетке.
### Обработка триангуляции Делоне (Delaunay refinement)
Chew's second algorithm и Ruppert's algorithm – это алгоритмы, которые позволяют вводить ограничения в триангуляцию Делоне и задать минимальный угол треугольника в сетке. Важной деталью алгоритмов является то, что они могут уйти в бесконечный цикл и гарантировано дают результат при углах между примерно 20.7 градусов и 29 градусов. Возможность задать минимальный угол важна при решении задач, описанных выше.
Chew’s second algorithm реализован в бесплатном пакете [www.cs.cmu.edu/~quake/triangle.html](http://www.cs.cmu.edu/~quake/triangle.html) и его порте на .Net [archive.codeplex.com/?p=triangle](https://archive.codeplex.com/?p=triangle)
### Triangle.Net для Unity
Ну и раз уж с помощью триангуляций можно решать так много крутых задач, то на праздниках захотелось реализовать свою обёртку для Unity, чтобы всегда иметь под рукой удобный инструмент. В данной реализации алгоритм триангуляции в среднем работает за O(n), а в худшем за O(n \* log n) – где n-количество вершин. К примеру, при тесте на 1кк вершин случайно разбросанных по квадрату юнити в редакторе на Intel Core i7-8700 строило сетку в среднем за 7.56 секунд.
Основные отличия от оригинальной библиотеки в наличии методов расширений заточенных под Unity, а так же замена double на float во всей библиотеке (+ пара определённых операторов для каста) Double в юнити не имеет особого смысла. Если считать физические симуляции, то я бы использовал отдельное приложение на плюсовой библиотеке, а результат вычислений уже отдавал Unity чисто для визуализации. А также переименован тип Mesh на TriangleNetMesh, чтобы не сбивать относительно Mesh из Unity. Да, они и так в разных неймспейсах, но тем не менее думаю новичков немного сбивал бы тот факт, что мы с помощью одного Mesh получаем другой.
Суть библиотеки в том, что вы сначала должны задать так называемый полигон. Потом на его основе сгенерировать уже меш. Для того, чтобы это работало с юнитёвыми структурами данных было введено несколько методов расширений.
**Пример использования**
```
public void GenerateMesh()
{
if(_CurrentState != MeshDrawerState.Nothing) return;
Polygon poly = new Polygon();
poly.Add(_Contour);
foreach (var hole in _Holes)
{
poly.Add(hole, true);
}
var triangleNetMesh = (TriangleNetMesh) poly.Triangulate();
GameObject go = new GameObject("Generated mesh");
var mf = go.AddComponent();
var mesh = triangleNetMesh.GenerateUnityMesh();
mesh.uv = GenerateUv(mesh.vertices);
mf.mesh = mesh;
var mr = go.AddComponent();
mr.sharedMaterial = \_MeshMaterial;
var collider = go.AddComponent();
collider.points = \_Contour.ToArray();
var rb = go.AddComponent();
rb.mass = triangleNetMesh.Triangles.Sum(tris => tris.Area);
Clear();
}
```
Для демонстрации и примера использования была сделана специальная демо-сцена с возможностью отрисовки мешей. С ней и портом библиотеки можно ознакомится в [github проекте.](https://github.com/CGDevsCommunity/Triangle.Net-for-Unity)
Спасибо за внимание! Надеюсь, что порт и статья кому-то будут полезны и стало чуть понятнее, зачем нужны триангуляция и знание математики в целом. Буду стараться продолжать раскрывать применения и способы решения разных математических задач в геймдеве. В самой вычислительной геометрии ещё очень много интересного, но помимо ещё есть множество других интересных разделов высшей математики. | https://habr.com/ru/post/435374/ | null | ru | null |
# Категоризация веб-ресурсов при помощи… трансформеров?
Привет! Меня зовут Анвар, я аналитик данных RnD-лаборатории. Перед нашей исследовательской группой стоял вопрос проработки внедрения ИИ в сервис фильтрации веб-контента SWG-решения [Solar webProxy](https://rt-solar.ru/products/solar_webproxy/). В этом посте я расскажу, зачем вообще нужен анализ веб-контента, почему из многообразия NLP-моделей для автоматизации решения этой задачи мы выбрали модель-трансформер. Кратко объясню, как с помощью математики взвесить смысловые отношения между словами. И конечно, опишу, как мы приземлили веб-фильтрацию в продукт.
Введение в веб-безопасность. Зачем анализировать содержание сайтов?
-------------------------------------------------------------------
Посещая различные сайты, можно с легкостью угодить в сети запрещенного контента, попасться на уловку мошенников или поймать опасный вирус. В некоторых случаях фильтровать контент просто необходимо, например, когда мы говорим о защите детей в интернете.
Как понять, что сайт является фишинговым или мошенническим, как оградить студентов, школьников, сотрудников компании от посещения запрещенных сайтов или сайтов с нецензурным содержанием?
Рис. 1. Опасность в интернетеБезусловно, работу по анализу содержимого сайтов можно проделать вручную. И это может быть оправдано, когда речь о малом стеке задач такого типа. Не составит большого труда проверить, к примеру, 1000 сайтов. Но что делать, если перед нами стоит задача ежедневной проверки нескольких тысяч или десятков тысяч сайтов? А именно такая задача стоит перед продуктом Solar webProxy.
Очевидно, что о ручной проверке не может идти речи — нужен способ автоматизированного выполнения этой задачи.
Итак, можно разработать компьютерную программу с некоторым алгоритмом, и она будет самостоятельно анализировать текстовое содержание сайтов. На основании триггера на определенные ключевые слова она сможет определять, к примеру, признаки обмана, мошенничества. Так, в тексте могут содержаться слова «ставки», «большие выигрыши», «испытай удачу», «стань богатым» и т.п. На основании этих слов или по общему числу их вхождений в текст можно сделать вывод, что такой сайт с высокой степенью вероятности является мошенническим либо по крайней мере вредоносным, поскольку может нанести материальный ущерб. То есть, сформировав некоторый корпус слов-триггеров, вполне возможно классифицировать сайты по их текстовому содержанию.
На первый взгляд, выглядит неплохо, но уже здесь мы сталкиваемся с проблемой. Сайт может содержать определенное количество слов-триггеров, но совсем не обязательно, что он будет относиться к той категории, которая определена на их основании. Например, по контенту о вреде алкоголя и курения на основании ключевых слов «алкоголь» и «курение» программа наверняка определит сайт, как с неразрешенным контентом. Хотя из контекста мы понимаем, что содержание этой страницы веб-сайта, напротив, посвящено здоровому образу жизни.
Примерно в этот момент в игру вступает понятие контекста. С его помощью мы можем понять содержимое сайта и правильно определить его категорию. Для понимания контекста содержимого сайтов успешно применяются некоторые модели искусственных нейронных сетей, об одной из которых далее пойдет речь.
Коротко об NLP и алгоритмах обработки естественного языка
---------------------------------------------------------
Итак, перед нами стоит задача автоматизировать процесс определения категории сайта по его текстовому содержанию. То есть, исходя из смысла отображенного на странице сайта и некоторого объема текста, понять главный его смысл, о чем этот текст.
Задача распознавания текста относится к сфере обработки естественного языка или NLP (natural language processing). NLP — направление искусственного интеллекта, нацеленное на обработку и анализ данных на естественном языке и обучение машин взаимодействию с людьми [1]. Цель NLP – научить компьютер понимать нашу разговорную и письменную речь [2].
Рис. 2. НейросетьКомпьютеры понимают только числовые данные, поэтому текст должен быть определенным образом приведен в этот формат. В теории можно закодировать слова на основании частоты их вхождения в текст либо просто сформировать некоторый словарь, в котором сопоставить слова или буквы с числовыми значениями.
Но как компьютер сможет понять смысл текста, если слова и смысловое наполнение имеют неоднозначную и нелинейную взаимосвязь? Подобная информация очень плохо поддается представлению в цифровом виде. Кроме этого, каждый язык имеет свою собственную грамматику, синтаксис и словарный запас [2].
Но если слова в предложениях трансформировать в числовой вектор и за меру взять расстояние между векторами, то будет проще обобщить влияние одного слова на другое. Такой подход называется методом вложения слов (word embedding).
Рис. 3. Word embeddingСуть подхода в том, что слова со схожим значением близки в векторном пространстве, поэтому можно определять значение слова по его «соседям». Над этими векторами можно производить арифметические действия и определять семантическое подобие слов, предложений и даже целых документов, а затем использовать эту информацию, чтобы выяснить, например, какой теме посвящен текст [1].
Используя данные, состоящие из таких векторов, мы можем применять различные методы Machine Learning. И поскольку искусственные нейронные сети лучшим образом справляются с векторно-матричными вычислениями, то выбор в их пользу становиться очевидным. Вцелом, нейронки более эффективны в задачах обработки естественного языка, по сравнению с иными методами машинного обучения [3].
Об NLP-нейронках
----------------
Искусственная нейронная сеть — это математическая модель, а также ее программное или аппаратное воплощение, построенные по принципу организации и функционирования биологических нейронных сетей — сетей нервных клеток живого организма.
Рис. 4. Схема нейросетиИскусственная нейросеть состоит из обрабатывающих элементов, подобных нейронам в мозге человека, которые взаимодействуют между собой путем отправки сигналов в соседние узлы и получения встречных сигналов [2].
Существует очень большое многообразие моделей искусственных нейронных сетей. Современные модели представляют собой так называемые глубокие модели. Они отличаются между собой количеством внутренних слоев и способом работы с данными, если говорить в общих чертах, не вдаваясь в сложные математические объяснения.
Как правило, чем сложнее модель нейронной сети, тем более сложные задачи она способна решать, но если мы решаем какую-то простую задачу, то нет смысла применять сложный инструмент. Понимание смысла текста отнюдь не является простой задачей. И в ее решении наилучшие метрики точности были достигнуты рекуррентными нейронными сетями, LSTM (сети с долгой краткосрочной памятью). Позже свое превосходство в этой нише обрели NLP-модели-трансформеры.
Описание упомянутых рекуррентных нейросетей (RNN), LSTM и GRU выходит за рамки темы статьи. Тем не менее для тех, кому интересно, расскажем в общих чертах об указанных моделях в спойлере.
Hidden textАрхитектура RNN позволяет модели поддерживать порядок слов в предложении и выявлять долгосрочные зависимости, что очень подходит для обработки последовательных входных данных. Однако RNN способны фиксировать зависимости только в одном направлении языка. То есть не учитывается влияние предшествующего слова на следующее за ним. Кроме этого, RNN не очень хороши в захвате долгосрочных зависимостей.
Рис. 5. RNNРекуррентные нейронные сети добавляют память к искусственным нейронным сетям, но реализуемая память получается короткой — на каждом шаге обучения информация в памяти смешивается с новой и через несколько итераций полностью перезаписывается.
LSTM избегают проблемы долговременной зависимости, запоминая значения как на короткие, так и на длинные промежутки времени. Это объясняется тем, что LSTM не использует функцию активации внутри своих рекуррентных компонентов. Таким образом, хранимое значение не размывается во времени.
Рис. 6. LSTMРазновидности LSTM часто используются в машинном переводе и в задачах генерирования текстов на естественном языке.
Перед нашей исследовательской группой стоял вопрос проработки возможности внедрения ИИ в сервис фильтрации веб-контента SWG-решения Solar webProxy. В результате перебора эмпирическим путем мы остановились на трансформере BERT, NLP-модели, которая, как мы потом убедились, оказалась очень удачной. По точности классификации текстового содержания веб-сайтов она превзошла все другие протестированные нами модели и алгоритмы Machine Learning.
Прежде чем использовать такой мощный и в то же время сложный инструмент, наша команда протестировала и более простые NLP-методы машинного обучения, в том числе «наивный байесовский классификатор», алгоритмы, использующие bag-of-words («мешок слов» — метод представления слов) и tf-idf (метрика определения частоты вхождения слов), а также простейшие модели нейронных сетей, состоящие из небольшого количества скрытых слоев. По объективным причинам, речь о которых пойдет дальше, данные методы и алгоритмы даже близко не приблизились к уровню точности BERT.
Знакомьтесь, BERT
-----------------
> — И за что тебя взяли?
> — Я купил машину, а она оказалась роботом. Кто знал… (с) К/ф Трансформеры.
>
>
BERT, или Bidirectional Encoder Representations from Transformers, — нейросетевая модель-трансформер от Google, на которой сегодня строится большинство инструментов автоматической обработки языка.
Релиз BERT в 2018 году стал некоторой переломной точкой в развитии NLP-моделей. Его появлению предшествовал ряд недавних разработок в области обработки естественного языка (BERT, ELMO и Ко в картинках — как в NLP пришло трансферное обучение): Semi-supervised Sequence learning (Andrew Dai и Quoc Le), ELMo (Matthew Peters и исследователи из AI2 и UW CSE), ULMFiT (Jeremy Howard и Sebastian Ruder), OpenAI Transformer (исследователи OpenAI Radford, Narasimhan, Salimans, и Sutskever) и Трансформер (Vaswani et al).
Итак, далее речь пойдет о трансформерах, но не о тех, о которых вы подумали!
Трансформеры в машинном обучении — это семейство архитектур нейронных сетей, общая идея которых основана на так называемом «самовнимании» (self-attention). Этот алгоритм математически взвешивает отношения между каждым элементом или словом с другими словами во входной последовательности.
Разберем на примере: *«Черепахе потребовалось очень много времени, чтобы перейти дорогу, потому что она очень медленная»*.
Здесь нам с первого взгляда видно, что последняя часть предложения «... она очень медленная» относится к черепахе, а не к дороге. Однако алгоритм Self-attention не сразу поймет смысл предложения. По мере того как алгоритм последовательно просматривает каждое слово в предложении, он ищет для себя «подсказки» (путем взвешивания слов), которые могут помочь в лучшем кодировании слова.
Более ранние архитектуры, чтобы обучиться предсказывали, какое слово, вероятнее всего, будет стоять следующим, учитывая все слова до него. На решение нейросети влияли только слова слева (так работает, например, трансформер от OpenAI). Такие нейросети называются однонаправленными.
Человек так не делает, обычно мы смотрим на все предложение разом. И чтобы сделать алгоритм более похожим на это, придумали двунаправленные нейронки. Здесь две сети работают параллельно, одна предсказывает слова слева направо, другая — справа налево. Потом результаты сетей объединяется.
По своей сути BERT — это обученный стек энкодеров Трансформера. Новшество заключается в предобучении модели на «маскированной языковой модели». Суть задачи —предсказать слово не в конце предложения, а в разных частях между словами. Маскированной модель называется потому, что искомый токен заменяется токеном "MASK".
Рис. 7. BERT-maskПриведенная схема работы позволяет учитывать все части фразы, а не только слова слева или справа.
В открытом доступе имеются различные предобученные вариации BERT (на различных языках) и любой желающий может использовать их в своей разработке.
Категоризация сайтов с BERT'ом
------------------------------
Для работы мы взяли предобученную модель bert-base-multilingual-cased. Предобученность модели означает то, что она подготовлена ее авторами для работы "из-коробки" - модель заранее обучена для общей / универсальной задачи и у нее уже есть веса. Как правило, такое обучение требует больших вычислительных мощностей и может занимать продолжительное время (недели, месяцы, если конечно у Вас нет крутого железа). То есть, "нельзя просто так взять и" обучить с нуля сложную модель искусственной нейронной сети. Для этого мы должны обладать, например, видеокарточками Titan от Nvidia с немалым числом производительных ядер.
Разработкой и обучением модели BERT занималась целая группа исследователей Google AI Language на многомиллионном наборе слов на разных языках (более 100). Обучение модели заняло 4 дня на 64-х матричных процессорах (TPU's). И они обучили ее для 11 наиболее распространенных языковых задач, таких как анализ настроений и распознавание именованных объектов. Такую предобученную модель можно далее использовать в задачах, имеющих свою специфику, но при этом скорее всего потребуется дополнительное дообучение на конкретном наборе с данными. Уже для такого дообучения вовсе не требуются значительные вычислительные мощности и вполне хватит даже обычного домашнего ПК со средним GPU.
Таким образом, БЕРТ в стоке обучен предсказывать слова в предложениях, а значит, у него есть то, что нам нужно — способность работать с предложениями, словами и контекстом и это можно применить для категоризации текста веб-сайтов. И мы дообучили BERT распознавать текстовое содержимое сайтов по 63 категориям (медицина, здоровье, видео, интернет-магазины, юмористические сайты, эротика, оружие, секты, криминал и пр.).
Для дообучения был сформирован собственный набор данных с примерами веб-контента. Как известно, от качества обучающей выборки зависит чуть ли не половина успешности модели, поэтому этапу формирования датасета уделялось много внимания.
Поскольку наш ИИ должен понимать категорию сайта по его текстовому содержанию, каждый обучающий пример в датасете должен быть представлен как текст из HTML-страницы. Для сбора таких данных мы написали несколько программ на языке Python.
Для доступа к сайтам с запросами использовали библиотеку **requests**. С помощью метода `get` «стучимся» к сайту и если все «ok», то есть нам вернулся ответ со статусом «200», мы можем работать с полученными данными.
`response = requests.get(url=current_url, timeout=10)`
Полученные данные представляют собой текст, включенный между HTML-тегами, и наша следующая задача — получить текст из определенных тегов. Для этого используем всем известную библиотеку BeautifulSoup. С помощью функций `find`, `find_all` можем найти определенные теги и получить из них данные в виде текста. Сам этот процесс называется парсингом HTML-страниц.
Веб-страницы могут содержать рекламу, значки, спецсимволы и прочее, что мешает корректному анализу текста. Поэтому каждый полученный в результате парсинга текст дополнительно очищается с помощью регулярных выражений и методов "match", "search" и "sub" из python-библиотеки "re". Сам процесс очистки заключается в том, что мы сначала составляем регулярное выражение, например, исключающее из текста все числовые значения, оставляя только буквенные. Затем, применяя метод "sub", удаляем все числа из текста, подменяя их пробелом. Если вы не знаете, что такое регулярные выражения, рекомендую посмотреть эту [статью](https://habr.com/ru/post/545150/).
Вуаля! Получаем очищенные данные, которые добавляем в датасет.
Как показали тесты, нам удалось добиться достаточно высоких результатов в категоризации. По 43 категориям из 63 точность распознавания варьируется в диапазоне 93-95%. И на этом мы не останавливаемся, а по мере накопления данных формируем дополнительные обучающие выборки, которые эпизодически используем для новых дообучений модели. Все это для повышения точности по тем категориям веб-сайтов, которые этого требуют. Кроме этого, с течением времени меняется и сам язык, в обороте речи появляются новые слова и выражения. Какие-то слова со временем понимаются по-разному. Все это требует нового дообучения НЛП-моделей, теперь уже в целях адаптации.
Знакомьтесь, категоризатор веб-сайтов Smart-Cat
-----------------------------------------------
Перед тем как брать контент с сайта, чтобы его категоризировать, неплохо было бы узнать, не является ли данный сайт вирусным, мошенническим или запрещенным Роскомнадзором. Поэтому я разработал программу — модуль для категоризатора, который проводит сверку с ежедневно обновляемой базой данных вирусных, запрещенных и мошеннических сайтов. Эту базу данных мы сформировали из открытых источников данных о вирусных сайтах (наподобие VirusTotal), мошеннических сайтов (в интернете имеются общедоступные ресурсы, предоставляющие такие списки), а также реестра Роскомнадзора. Если URL-адрес совпадет с записью в этой базе, категоризатор сделает отметку, что сайт является, к примеру, запрещенным на основании реестра РКН.
Кроме этого, непродолжительный срок существования сайта может вызывать определенные подозрения. Зачастую в таких случаях сайт оказывается вредоносным или мошенническим. Поэтому мы добавили еще один модуль проверки, который с помощью специальной Python-библиотеки «whois.api» проверяет время жизни сайта. В качестве контрольного порога мы выбрали шесть месяцев. Если сайт существует менее этого срока, программа поставит отметку о необходимости «обратить внимание» на этот факт.
В промышленных масштабах объем URL-адресов для проверки и категоризации может достигать сотен тысяч или даже миллионов. При этом среди них могут быть повторяющиеся адреса, IP-адреса, непригодные для парсера. Для общего понимания того, в чем разница между IP-адресом и URL читайте [данный](https://scicenter.online/saytov-internet-sozdanie-scicenter/ponyatie-adresa-url.html) материал. Для доступа к сайтам используются URL-адреса.
Кроме этого, URL может быть представлен тремя и более поддоменными уровнями. Как правило, такие URL недоступны, к ним практически невозможно подключиться (в основном такие адреса принадлежат сайтам, где требуется авторизация, либо это какие-либо специальные технические ресурсы). Для обработки таких моментов в категоризатор мы заложили функционал, который сокращает объем однотипных адресов (принадлежащих, к примеру, одному и тому же домену), удаляет IP-адреса, дубли и абракадабру, которая также встречается в больших списках URL-адресов. Здесь применяется та же схема, что и при обработке спарсенного веб-контента (см. выше).
Таким образом, пользователь передает в категоризатор список с URL-адресами. Smart-Cat на первом этапе проводит их предобработку. Затем выполняется сверка с базами данных. Если будет обнаружено совпадение, Smart-Cat сделает об этом отметку в результатах. И только после того, как прошли все проверки и чистки, оставшиеся URL переходят в модуль-парсер. Получившийся в результате контент передается BERT, который классифицирует его по категориям. На выходе мы имеем таблицу с детальной информацией по каждому URL-адресу.
Знакомьтесь, BERT-bot
---------------------
Для удобства работы с категоризатором Smart-Cat мы создали специальный Telegram-бот. Он умеет проводить проверки по базам запрещенных, вирусных и мошеннических сайтов и затем категорировать сайты по 63 классам. Бота зовут BERT-bot.
Для запуска Берта отправляем ему в Telegram список с URL-адресами в виде обычного текстового файла (.txt) и ждем результат. После своей работы BERT-bot отправит CSV-таблицу. В ней будут указаны результаты проверок по базе данных, итоги категоризации, а также сведения по URL-адресам, по которым не получилось установить соединение либо возникли проблемы с получением от них данных. Доступ к боту есть только у сотрудников компании.
Заключение
----------
Автоматизация процесса фильтрации сайтов по содержанию может быть реализована как с использованием методов машинного обучения, так и без них. Алгоритмы Machine Learning имеют свои нюансы и сложности в реализации. Поэтому там, где можно обойтись более легким решением, например простым сопоставлением данных между собой, лучше пойти в этом направлении.
Использование ИИ представляется более «дорогостоящим» решением, и к нему лучше прибегнуть при действительно сложных задачах. Так, мы, решая задачу фильтрации веб-сайтов по их текстовому содержанию, в первую очередь, проводим очистку данных и сверку с БД. И только потом, когда максимально проработан первоначальный массив с URL-адресами для проверки, наступает очередь работы искусственной нейронной сети. Она уже работает только с теми веб-сайтами, по которым на предыдущем этапе не были получены данные о категориях. В нашем случае мы реализовали комбинированное решение.
Предобученные языковые модели искусственных нейронных сетей, такие как BERT, демонстрируют наилучшую точность в классификации веб-сайтов по их текстовому содержанию. Но, как я уже сказал ранее, такие модели могут применяться не только в задачах классификации текста. При желании с помощью того же BERT'а можно реализовать «умного» переводчика, голосового ассистента (как Джарвиса у Тони Старка). При этом модель можно дообучить для работы в специфической сфере.
Системы с искусственным интеллектом в некоторых отраслях производства могут полностью заменить труд человека и стать, например, надежным инструментом в обеспечении информационной безопасности.
Если вы решаете задачи по автоматизации с помощью методов машинного обучения, расскажите о своем опыте в комментариях. Буду рад обменяться опытом :)
**Автор: Анвар Баширов, аналитик данных RnD-лаборатории Центра продуктов Dozor**
### Источники литературы и ссылки
1. Васильев Ю. Обработка естественного языка. Python и Spacy на практике // Спб.: Питер, 2021. - 256 с.
2. Обработка естественного языка с TensorFlow / пер. с англ. В.С. Яценкова. - М.: ДМК Пресс, 2020. - 382 с.
3. Нейросетевые методы в обработке естественного языка / пер. с англ. А.А. Слинкина. - ДМК Пресс, 2019. - 282 с. | https://habr.com/ru/post/690556/ | null | ru | null |
# Twitter открывает исходный код движка, заменяющего эмоджи на картинки
Речь здесь пойдёт о символах-картинках и о том, как отображать их.
По-японски они называются «絵文字» (где «絵» означает «картинка», а «文字» — «символ») или «えもじ», и произношение этого названия можно передавать разными способами: по [Хэпбёрну](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D0%A5%D1%8D%D0%BF%D0%B1%D1%91%D1%80%D0%BD%D0%B0) — «emoji», по [Поливанову](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D0%9F%D0%BE%D0%BB%D0%B8%D0%B2%D0%B0%D0%BD%D0%BE%D0%B2%D0%B0) — «эмодзи», в [киричзи](https://ru.wikipedia.org/wiki/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Tassadar/%D0%BA%D0%B8%D1%80%D0%B8%D1%87%D0%B7%D0%B8) у Тассадара — «эмочзи», по [Сергею Грису](http://www.komi.com/japanese/from_int/transcrip.htm) — «эмоджи» через мягкий «жи». Этот последний вариант мне больше всего нравится, его-то я и стану использовать и в заголовке, и в тексте.
Что такое эмоджи? Это миниатюрные пиктограммы и идеограммы, которые можно вставлять в текст почти так же, как и буквы.
Эмоджи многочисленны. Первый набор эмоджи (который придумал Курита для технологии [i-mode](https://en.wikipedia.org/wiki/I-mode) в 1998 или 1999 году) содержал 172 символов, состоявших всего-навсего из 12×12 пикселов. Через десять лет в Unicode 6.0 (2010 г.) было ужé 722 эмоджи, а стандарт нынешнего года (Unicode 7.0) дополнил их число ещё примерно четвертью тысячи эмоджи.
Эмоджи разнообразны. Среди них есть знаки эмоций (смайлики круглоголовые или со звериными ушками, а также различные жесты и позы), знаки Зодиака, шахматные фигуры, грани игральной кости, масти карт, любовные сердечки, священные символы, некоторые значки компьютерного интерфейса (GUI), стрелочки, галочки, крестики (прямые и косые), звёздочки, снежинки, обозначения разных родов транспорта, миниатюрные изображения современных элементов бытовой техники бытовых и технических приборов, орудий и инструментов, обозначения различных вариантов прогноза погоды, различных растений, цветов, зверушек, блюд (в основном японской национальной кухни), фаз луны, часов дня, празднеств, времён года, музыкальных инструментов, спортивных состязаний, аттракционов, различных зданий (гостиничных, вероисповедных, больничных, фабричных…), и так далее, и так далее.
А выражение «почти так же» я чуть выше употребил потому, что эмоджи всё же нельзя в полной мере считать обычными символами. На то есть две причины.
Во-первых, в кодировке Unicode код большинства эмоджи записывается более чем четырьмя шестнадцатеричными цифрами (символы Unicode, обладающие этим свойством, иногда принято называть «астральными», и к числу их относятся не только эмоджи), и в кодировке UTF-16 им соответствует не два, а четыре байта. Эта тонкость кодирования в некоторых обстоятельствах (например, в свойстве «**.length()**» у строки в языке JavaScript) приводит к тому, что один эмоджи считается за два обычных символа во время подсчёта общей длины строки, в том числе — по отношению к твиттеровскому ограничению (140 символов на одну микроблогозапись), в том числе — в официальном приложении Twitter для Android, насколько я мог заметить.
Во-вторых, символы эмоджи задуманы как состоящие из нескольких частей разного цвета (этим они отличаются от обычных символов обычного текста, целиком принимающих цвет текста). Если вывод текста на экран осуществляется движком, не имеющим никакого представления об этой особенности эмоджи, то тогда эмоджи становятся монохромными (например, чёрно-белыми в чёрном тексте на белом фоне) и производят несколько худшее (менее узнаваемое) впечатление (потому что читатель вынужден полагаться только на форму, но не на цвет — как если бы был жертвою дальтонизма).
Поддержка эмоджи есть далеко не везде.
Браузер Firefox полагается на встроенный движок вывода текста, и прямо сейчас выводит эмоджи всегда одноцветными. Некоторые другие браузеры для вывода текста, наоборот, полагаются на возможности операционной системы — и тогда поддержка эмоджи зависит от версии операционной системы.
В системе Android поддержка эмоджи появилась в версии 4.4 (в конце 2013 года).
В системах Apple поддержка эмоджи в соответствии с Unicode началась в iOS 5 (на мобильных устройствах) и в OS X Lion (на остальных), то есть в 2011 году; до этого времени эмоджи было меньше, да и кодировка их была другою.
В системе Windows поддержка полноцветных эмоджи появилась в Windows 8.1, но отображения монохромных эмоджи можно добиться в более ранних версиях Windows, установив на них шрифт, содержащий эти символы (майкрософтовский шрифт Segoe UI Symbol, например).
Строго говоря, любой открытый и свободный шрифт, содержащий множество эмоджи (ну, например, шрифт [Gdouros Symbola](http://fedoraproject.org/wiki/Gdouros_Symbola)) можно добавить к себе в операционную систему и пользоваться. Однако есть две важные проблемы: во-первых, в некоторые системы трудно или невозможно добавить новый шрифт (таковы, например, Android и Chrome OS), а во-вторых, эмоджи будут монохромными, если система не поддерживает также и многоцветность их.
Глядя на такое безобразие, в Твиттере придумали действенный костыль на языке JavaScript, способный прямо во браузере подменять обыкновенные эмоджи (символы Unicode) на такие картинки (в формате PNG), на которых соответствующий символ нарисован в готовом и правильном (цветном) виде. Картинки для этой цели были изготовлены [The Iconfactory](http://iconfactory.com/) — и 872 PNG-файла в нескольких размерах (16×16, 36×36, 72×72), и векторные аналоги их. Такой подход до известной степени позволил обойти проблему отображения цветных пиктограмм и идеограмм во браузерах.
Недавняя же новость заключается в том, что 6 ноября (в четверг на прошлой неделе) в Twitter (уступая просьбам общественности) [открыли исходный код](https://blog.twitter.com/2014/open-sourcing-twitter-emoji-for-everyone) своего движка эмоджи, выложили исходный код [на GitHub](https://github.com/twitter/twemoji).
Без промедления (в тот же день) твиттеровское средство замены эмоджи на картинки запустили [в Wordpress](http://en.blog.wordpress.com/2014/11/06/emoji-everywhere/).
Без промедления (в тот же день) и самому движку, и иллюстрациям [был предоставлен](https://www.maxcdn.com/blog/emojis-ftw/) бесплатный хостинг на MaxCDN, так что подключить их к себе можно несложным кодом:
```
```
(Сразу скажу, что замена эмоджи на картинки происходит не автоматически: подключённый код придётся ещё и вызвать, передав ему джаваскриптовую строку или элемент DOM.)
Установка готового пакета к себе на сайт (посредством [bower](http://bower.io/), [component](https://github.com/componentjs/component) или [npm](https://www.npmjs.org/package/twemoji)) также поддерживается.
Есть [страница предпросмотра](http://twitter.github.io/twemoji/preview.html), на которой можно ознакомиться с видом всех изображений эмоджи Твиттера (The Iconfactory), увидеть работу движка замены.
Во блоге Wordpress также упоминается о существовании [сайта](http://www.iemoji.com/emoji-cheat-sheet/all), на котором можно ознакомиться с тем видом, который эмоджи имеют в различных операционных системах и на различных устройствах. | https://habr.com/ru/post/362825/ | null | ru | null |
# Как мы слили финал IT-Планеты по программированию
Не мы плохие, а багов много. Разработка искусственного интеллекта для игры “Хоккей” за ~7 часов.
Изначально статья планировалась о стратегиях участников, о том, что они успели сделать за конкурсное время и рады ли проделанной работой, но, опросив финалистов восемь, стало ясно, что ничего не выйдет и надо срочно менять направление.
Дело в том, что на интересующие нас вопросы мы получали максимум 6 слов, а потом сразу же слышали **недовольства о багах**, с которыми столкнулись участники. Только один человек написал:
> Не хочу писать ничего отрицательного, думаю, это некорректно, да и организаторам самим должно быть грустно. Поэтому скажу, что идея задания достаточно интересная, хотя лично мне не очень нравится такой формат соревнований (Анна Прозорова).
Из заголовка статьи понятно, что мы ничего не выиграли. И да, именно “мы”. За конкурсные дни у меня появилось много хороших знакомых, в том числе и Анна ([odrus](https://habr.com/ru/users/odrus/)), являющаяся соавтором данной статьи. Также в последний момент мы разговорились со Львом ([zadamantiy](https://habr.com/ru/users/zadamantiy/)) и с его разрешения описали участие в финале.
Лично я являюсь участником движения “A Complaint Free World”, но я перевешу свой браслет на другую руку и буду жаловаться, хоть и в шуточной форме, ведь, с другой стороны, **таковы условия конкурса** и нужно быть хорошим специалистом, чтобы выиграть в нём и совладать с недочётами! Никаких претензий у нас нет, наоборот — большое спасибо!
Под катом, помимо описания правил игры, регламента конкурса и найденных багов, мы поделимся с Вами своими косяками, тем, с чем столкнулись лично и как решали ту или иную проблему, как готовились к конкурсу. Возможно, где-то Вы узнаете себя, если принимали участие в подобных конкурсах.
Цель статьи — это собрать фейлы конкурса как со стороны участников, так и со стороны организаторов, зарубить их себе на носу и больше никогда не наступать на те же грабли. Надеемся, что статья повысит уровень очередного конкурса.
Введение
--------
### Несколько слов о нас
#### Илья
Ежегодный участник Russian AI Cup и Mini AI Cup с 2017 года. Также слежу за Codingame и Halite. Особых достижений пока не имею, но многому научился от других. Для меня главное не участие, не победа, а выложиться на свои 100% и в конце сказать: «Я сделал всё, что мог, реализовал всё, что хотел, применил всё, что знал». Язык программирования Java не знаю. Для меня это уже обычная практика с конкурса на конкурс полностью изучать новый стек технологий.
#### Анна
Простой студент с небольшим опытом решения алгоритмических задач, но без особого опыта участия в олимпиадах и подобного рода контестах. Конкретно в IT-Планете решила поучаствовать, чтобы проверить свои знания и способности, получить опыт, пообщаться с интересными людьми. Изучала язык программирования Java в университете, но давно не имела практического опыта с ним.
#### Лев
Участвовал во всяких отборах ICPC, хакатонах вроде «Собери университет 20.35» и «Цифрового прорыва». Ну и по мелочи в каких-то университетских олимпиадах.
Соответственно, у нас университет обычно отправлял много участников на конкурс по sql, но в этом году его не было. Мне предложили поучаствовать в Java, пришлось в достаточно короткие сроки параллельно с сессией разбираться с новым для себя языком. В It-планете до этого не участвовал.
### Описание конкурса
#### Общее положение
IT-Планета — это конкурс для студентов и молодых специалистов из IT-сферы, целью которого является выявление и поддержка способных ребят. Проходит ежегодно с 2007 года. Участие в нём — это шанс проявить себя.
Номинация “Программирование Java” помогает найти практическое применение знаниям, полученным в процессе обучения.
Первый отборочный этап являлся заочным и представлял собой онлайн-тестирование для студентов зарегистрированных учебных заведений. Вопросы были достаточно сложными и интересными, но будем честны, большинство содержало код, который можно было перечитать и запустить.
Второй отборочный этап, как и первый, был заочным. Направлен на решение задач спортивного программирования. На решение 10 задач давалось двое суток, что позволяло основательно подготовиться к решению определенной задачи, изучить алгоритм/подход. Однако со всеми задачами никто не справился. Условие некоторых задач менялось по ходу контеста. Были косяки в тестах.
Международный финал очный. Необходимо было написать AI для игры “Хоккей с шайбой”. Давалось ~7 часов. Приблизительность из-за отсутствия “отмашки” старта и непонятности с обедом. Время было резиновым и аудитории не закрывались, но об этом ниже.
#### Задание
Задание было разработано специалистами ООО «СимбирСофт». Ниже представлено содержимое .pdf файла (с минимальными правками для статьи), который получил каждый участник.
**Задание**
**Описание задачи**
Где-то в загадочной стране, все жители которой маленькие роботы, встретились 2 команды для игры в хоккей. У обеих команд есть свой персональный робот-тренер, который постоянно следит за игрой, и говорит всем игрокам, куда им необходимо ехать. Все бы ничего, но роботы-игроки понимают только такие простые действия, как идти, бить по шайбе, идти в заданную тренером точку.
Вам предстоит стать тренером для красной команды игроков. Против вас будет играть синяя команда, которая управляется алгоритмом, который уже успешно побеждает другие команды. На поле одновременно играют 2 команды. Команда состоит из 4 игроков: нападающего, 2х защитников и вратаря.
Ваша задача — написать алгоритм управления красными ботами. Для управления персонажами у вас будут 3 метода, которые описаны ниже. Также есть метод, получающий информацию обо всех игроках на поле и координаты шайбы.
**Ограничения игры**
Вратарь может только доезжать до середины поля от ворот. Защитники и нападающие могут кататься по всему полю, кроме зоны вратарей (красный полукруг около ворот).
**Описание структуры приложения**
Приложение представлено в виде клиента и сервера. Сервер будет запакован в jar файл, и запущен фоном. На сервере содержится вся основная логика движения персонажей и шайбы, хранение информации обо всех персонажах, шайбе, времени и счете.
Клиент при запуске приложения устанавливает соединение с сервером, и, с заданной периодичностью, получает данные с сервера. Также он отвечает за отрисовку всех персонажей, ворот и шайбы на хоккейном поле.
Весь программный код необходимо писать в классе Algoritm в папке algoritm в клиентском приложении (все изменения в других файлах учитываться не будут).
В этом классе присутствует следующие методы:
* move(playerType, x, y) - Метод по перемещению игрока в указанную точку на карте.
* kick(playerType) - Метод по удару по шайбе определенным игроком.
* turn(playerType, angle) — Метод по повороту определенным игроком.
* getInfo() — Получение информации обо всех игроках и шайбы на карте.
Также есть статическая переменная level, которая отвечает за уровень сложности алгоритма. Для участников олимпиады будут доступны следующие уровни:
1. команда синих стоит;
2. команда синих ходит случайным образом по полю;
3. команда синих играет по «слабому алгоритму»;
4. команда синих играет по продвинутому алгоритму (для внутреннего тестирования).
Все методы, принимающие playerType работают только для игроков красной команды.
Переменная playerType представляет собой экземпляр класса PlayerType, и содержит
такие значения как вратарь, защитник1, защитник2, нападающий.
В классе Playground записаны константные значения игры (например середина поля, зона вратаря и т.д).
Метод getInfo() возвращает объект класса GameInfo.
**Уточнения**
* Если послать метод move несколько раз, то конечная точка, куда необходимо дойти персонажу, изменится (поэтому если необходимо дойти до конечной точки, то необходимо подождать пока персонаж дойдет до нее, прежде чем послать его в другую точку).
* Метод kick можно использовать только для игрока, который владеет шайбой.
* Метод turn принимает угол, при этом для нижнего стороны поля угол принимает значения от 0 (смотрит в сторону вражеских ворот) до 180 (смотрит в сторону своих ворот), а для верхнего полукруга угол принимает значения от 0 до -180.
#### Критерии оценки
Тоже взято из .pdf файла. Будет использоваться программный код только из класса Algoritm. Алгоритм каждого участника будет прогоняться против всех уровней сложности поочередно. По результатам прогона будут выставляться очки за результаты матча, а также будут начисляться баллы за реализованные возможности в алгоритме.
**Список критериев**
1. Атаки по воротам должны выполняться под разными углами. Например: прямо перед игроком вражеский вратарь — атака по воротам должна осуществиться под углом.
2. Игрок отдает пас свободному хоккеисту для выполнения атаки на ворота.
3. Пас должен отдаваться только в тех случаях, когда игрок не может сам произвести атаку (все углы для атаки ворот перекрыты).
4. Пас должен отдаваться только свободному для паса игроку. В приоритете хоккеисты с открытыми для атаки воротами.
5. Если атака невозможна команда должна отойти и перегруппироваться.
6. Доп. Баллы если отходят с помощью распасовок.
7. Доп. Баллы если используют вратаря для перегруппировок.
8. В защите должны блокироваться возможности отдать пас другому игроку противника.
9. Команда игрока придерживается стратегий. Например: 1 защитник всегда держится всегда чуть дальше, на случай контратаки противника.
10. Алгоритм учитывает показатели табло. Например: играет агрессивнее в случае проигрыша и наоборот осторожнее в выигрышной ситуации; при ничьей увеличивает агрессию ближе к концу матча.
Штрафные очки будут начисляться за:
1. Игрок забивает голы в свои же ворота.
2. Хоккеисты участника блокируют друг друга. (не дают друг другу пройти).
3. Намеренное блокирование игры. Например: упереться с шайбой в бортик до финала игры.
Основная часть
--------------
### Подготовка к конкурсу
#### Илья
Изначально писали, что в финале будет “Промышленная разработка”. Я ожидал обычной работы с базой, разработки GUI. Приложение для учёта чего-либо, например. С горем пополам согласился на финал, ибо был не очень рад тому, что придётся делать. Однако 17 сентября приходит письмо с регламентом проведения финала, а там сообщается следующее: “Имеется компьютерная 2D-игра «Хоккей», в которой по некоторому алгоритму играют компьютерные боты. Необходимо на языке программирования Java реализовать алгоритм, по которому будут действовать персонажи участников“ (на сайте было написано, что задание может быть изменено). В моей голове сразу же вспомнился Russian AI Cup 2014 года. Я обрадовался и понял, что не зря согласился принять участие.
Первым же делом пошел в очередной раз читать [статью победителя](https://habr.com/ru/post/241553/). В целом я помнил, что там было, но далеко не все моменты были ясны. Дальше отправился на [сайт конкурса](https://2014.russianaicup.ru/) и прочитал правила. На этом остановился, ведь любая поправка в правилах может полностью изменить всю игру. Я не знал о том, сколько будет физики в их игре, не знал о том, как происходит удар и подбор шайбы и т.д. Игру могли очень сильно упростить, что даже углы не нужны будут. Поэтому я начал ждать…
Ждал и дождался! Днём 27 сентября приходит письмо о проведении вебинара! 28 сентября в 19:00. Это был идеальный день и время для меня. Однако… Однако за 4 часа до запланированного старта пришло еще одно письмо с переносом на 17:00! Письмо о переносе пришло за час до начала… Летел как мог и опоздал на минут 15 (не ожидал, что еще надо будет ставить Flash Player).
На вебинаре задавал вопросы и получил общую картину об игре. Данных было достаточно, даже чтобы написать свою и основательно подготовиться. Однако до последнего не было понятно, как происходит удар, некоторые моменты разработчики не стали раскрывать, а местами и сами еще не до конца решили.
Записав всё самое ценное, я пошел общаться со знакомыми активными участниками RAIC’a. Привет и спасибо [m0rtido](https://habr.com/ru/users/m0rtido/), [DragoonXen](https://habr.com/ru/users/dragoonxen/), [oreshn1k](https://habr.com/ru/users/oreshn1k/). Обрисовав ситуацию, стало понятно, что надо хардкодить ифы и ни о каких симуляциях мира за такое время речи и не может идти. [oreshn1k](https://habr.com/ru/users/oreshn1k/) поделилась бомбезной книгой “Programming Game AI by Example”, в четвертой главе которой рассказывалось о дизайне AI для футбола. Мне так сильно понравилось написанное в книге, что я решил расписать для себя всю стратегию, которую собирался написать на конкурсе, и совершенно забыл об ограничении на время. То, что я собирался писать, не подходило для этого конкурса…
Моя проделанная бесполезная подготовка доступна на [quire](https://quire.io/w/IT-Planet/) (аккуратно, там аж 168 задач. Местами с описанием). Бесполезная для данного конкурса, а в целом это отличная систематизация полученных знаний из книги. Там же я подумал над симуляцией шайбы, чтобы узнавать её месторасположение через некоторое время, над поиском подходящего угла для удара по воротам, логикой передачи шайбы между игроками и кучей всего интересного.
Выше я уже написал, что без понятия, как писать на ЯП Java, поэтому помимо стратегии я занялся изучением синтаксиса языка. В этом мне помог отличный сайт, которым я пользуюсь уже не первый раз — [Learn X in Y minutes](https://learnxinyminutes.com/docs/java/). Зайдя в IntelliJ IDEA я понял, что писать на ней точно так же, как и на C#.
Вот с такой подготовкой я поехал в Москву.
#### Анна
Когда узнала о теме финала, первым делом решила повторить геому. А чтобы все это проходило ещё и весело, делала все это с помощью [Processing](https://processing.org/): смотрела примеры от разработчиков, связанные с движением, расчётом углов, скорости и ускорения, а потом практиковалась на своих небольших скетчах.
Время на то, чтобы освежить в памяти какие-то тонкости Джавы, я решила не тратить, потому что задача, как мне показалось, предполагала скорее навыки в написании стратегий и некотором знании математики. Поэтому я решила почитать [статью победителя RAIC 2014](https://habr.com/ru/post/241553/). Статья была интересная, но не особо полезная конкретно для данного конкурса, потому что физика могла отличаться кардинальным образом, да и времени будет дано намного меньше.
Вебинар от разработчиков был интересным и полезным, дал общую картину игры. Но я, к сожалению, не смогла посмотреть его полностью, потому что трансляция велась с помощью Flash и мой ноут именно в этот момент решил поиграться с синим экраном смерти.
В итоге непосредственно перед финалом у меня не было никакой заранее проработанной стратегии: сложно было что-то планировать, когда не раскрыты детали физики игры. Были мысли о том, на что стоит обратить внимание в первую очередь, какие вспомогательные методы написать сразу, но не более того. Я решила, что главное перед финалом — это отдохнуть, выспаться и прийти туда с хорошим настроением.
#### Лев
[Готовился] Около 16-20 часов. Соответственно, рассматривал геометрию, с которой я, к сожалению, не сильно в ладах. Заранее подготавливал формулы и расчёты, тестировал всё. Оценил область, из которой можно забить в ворота по условиям, данным организаторами на вебинаре, затем написал эмулятор некоторых действий и получил то, как будет выглядеть область при прямой симуляции ударов с разных точек и оптимальной стратегии вратаря. В итоге не пригодилось ровным счётом почти ничего и пришлось писать костыли на костылях.
### Распределение времени
#### Илья
С распределением времени на конкурсах и олимпиадах у меня всегда были проблемы. Я наступил на грабли в третий раз. Еще после первого сказал, что никогда не допущу этого. Вновь засел над одной задачей, долго не переключался на другую.
Потратил уйму времени, всю первую часть конкурса до обеда, на реализацию всяких обёрток для игроков команд, классов состояний, сообщений между ними, внутренних ролей. В общем шёл по тем задачам, которые сформировал до конкурса напрочь забыв советы опытных участников о хардкоде ифами и вспомогательных методах. Просто писал совершенно не думая о времени.
Опомнился на обеде. Понимал, что половина конкурса прошла, а у меня работы на ещё часов 10 чтобы хоть что-то начало двигаться. Было принято решение оставить всё что есть и начать с самого начала. Это были увлекательные последние часы конкурса, когда я перестал грустить и хихикал с поведения своих ботов. Очень быстро начал переключаться с задачи на задачу. Не выходит там — перешел на другую, потом вернулся. Желание было только одно — забить хоть как-то, хоть что-то. Поэтому было напрочь забыто о чистоте кода и ООП, местами оставлены интересные комментарии.
#### Анна
Сначала я решила разобраться с тем, как вообще работают основные методы в игре: движение хоккеистов, захват шайбы, повороты и пасы. На это я потратила около часа. Также изучила предоставленные данные и методы, которые были у хоккеистов и шайбы. Затем я решила, что неплохо было бы научиться находить угол между двумя объектами (в частности, между хоккеистом и шайбой). С этим у меня возникли большие трудности: сначала я долго разбиралась с методом Math.atan2, а затем пыталась конвертировать полученные данные в систему углов разработчиков. Со всем этим я мучилась до обеда и была очень расстроена тем, что кучу времени потратила на одну небольшую задачу, хотя за это же время могла написать стратегию как минимум для первого уровня.
После обеда я решила более рационально распределять время. Быстренько дописала метод с определением угла, затем написала стратегию для первого уровня. Потом плавно перешла к стратегии для второго уровня, которую применила в итоге и для третьего. Собственно, этим и залипанием в то, как странно ведут себя мои хоккеисты, я занималась до окончания финала. Код получился ужасный, нечитабельный, с кучей if’ов и копипасты, но со своей задачей он более-менее справлялся: мои хоккеисты забивали шайбы.
#### Лев
За выданное время (7 часов, что безумно мало для такого конкурса), сделал простенький алгоритм, который смог стабильно выигрывать 1-2 уровни с разгромным счётом. А дальше, в зависимости от случайных событий с 3-им уровнем алгоритм выдавал счёт от 0-2 до 6-0. К сожалению, на четвёртый уровень посмотреть так и не удалось. При этом уверен, что за это время можно написать куда лучший вариант, но для этого надо понимать, как вообще какой-нибудь поворот-то работает, а тут организаторы водили плечами, мол, сами не понимаем, почему тут так.
Больше всего времени ушло на то, чтобы разобраться, как и что работает в проекте, особенно бесили не работающие .equals() и два поля .TypeOfPlayer и .PlayerType, возвращавшие абсолютно разные вещи. Ну и какие-то странные поведения игроков, которые организаторы толком не могли объяснить (а мы не знаем, почему ваш персонаж именно тут едет спиной вперёд при единственной данной команде, ну и уже упомянутые повороты :) ). Затем, в какой-то момент, выясняется, что в проекте есть константы для размеров разных игровых объектов и их позиции, что, казалось бы, должно было быть в справочном материале изначально, но нет, в итоге убил время на то, чтобы считать их вручную.
### Наши косяки
#### Илья
* Мой главный косяк в ужасном распределении времени и безрезультатном написании лишних абстракций. Когда у тебя 7 часов — пиши плохой, неподдерживаемый код, если хочешь выиграть.
* Рофл с геомой. Я до сих пор не знаю, какой угол надо прибавить и как сервер обрабатывает его, поэтому на всякий тут % 360. Может 90 +, может 180, а может и все 270. Вообще не задумывался над этим и просто ставил как попало…
```
double res = 180 / Math.PI * Math.acos((pp.x - tp.x) / pp.dist(tp));
return (90 + (int) res) % 360;
```
* За минут 40 до конца конкурса я решил разобраться в дичи, которая происходила в поиске ближайшего игрока к шайбе. Дело оказалось в том, что мой метод squareDist класса Paint имел знак -, вместо + между квадратами разности координат (кстати, в таске на quire тоже -). И с таким багом я считал абсолютно все расстояния на протяжении нескольких часов…
* В самом начале конкурса я держал у себя в голове реализацию получения позиции шайбы в будущем. Для этого необходима её скорость. Как оказалось, из состояния мира ничего полезного нельзя достать вообще (считаю косяком организаторов, опираясь на то, что предоставляют другие конкурсы таких же форматов). Поэтому ту же скорость шайбы приходилось получать, исходя из её позиции в разные моменты игры. Я потратил очень много времени на отладку и не понимал, почему данные приходят так редко (обещали каждые 5мс). В общем, не удалось мне тогда довести просчёт до конца, но за ~час до окончания конкурса я заметил интересный кусок кода в своей стратегии, оставленный организаторами:
```
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
```
Выставив значение 10, я получил очень частое обновление данных, раскомментировал участок кода, отвечающий за получение скорости, и всё заработало! Спустя минут 20 после этого краем уха услышал вопрос от участника к организаторам по поводу этого куска кода, а тот ему и объяснил, что это сделали специально для нас, чтобы легче было разрабатывать. В тот момент я улыбнулся, поняв, что не один я так поздно осознал это.
#### Анна
* Как и Илье, мне не удалось в самом начале грамотно распределить своё время: я потратила кучу времени на одну мелкую, хоть и полезную, задачу, а должна была учить хоккеистов забивать шайбы.
* Кучу времени убила из-за того, что забыла сигнатуру метода Math.atan2: сначала идет y, а потом x. Я делала всё наоборот.
* При написании метода, определяющего, нет ли вражеских хоккеистов на определённом отрезке пути, допустила пару ошибок, из-за которых хоккеисты иногда отказывались двигаться куда-либо.
* В целом восприняла конкурс недостаточно серьёзно. Можно было подготовиться более основательно и быть более старательной и внимательной на самом финале.
#### Лев
* Первые два часа в логах случайно итерировал оба раза по команде союзников, вместо второго раза по команде ботов.
### Косяки организаторов
* Мало данных для комфортного написания сильных стратегий. Все, что нам дали, — это четыре метода для управления и позиции игроков на поле. Да, у шайбы был ещё её владелец. Из констант были доступны центр поля, зоны вратарей и ворот. Хоть на этом спасибо, но нам кажется, что следующий перечень значений был просто необходимым. Их получение мы просто костылили!
1. Скорость игроков (у каждой роли была своя скорость), шайбы;
2. Информация о замедлении шайбы;
3. Стартовые позиции игроков;
4. Размеры игроков, шайбы;
* На вебинаре разработчики прямым текстом говорили, что возможности получить исходный код сервера не будет. Про какие-то упаковщики речь шла, что .exe подсунут. Слово “обфускация” не мелькало, но намекали. А на деле получили мы .jar, который декомпилируется за пару секунд и становятся доступными не только константы и логика с физикой игры, которых не хватало участникам, но ещё и их исходный код бота 3 уровня, играющего против нас. К великому сожалению, сам это я заметил по приезду домой, а о декомпиляции услышал после конкурса от участников. Рассказывали, как кто-то это использовал во время финала. Если это и правда так, то очень неприятно. В такие моменты начинаешь жалеть, что правильный такой весь.
> Но в таком случае не очень честно (Александр Полищук [boba-alex](https://habr.com/ru/users/boba-alex/)).
> Ну, молодцы что использовали, раз в правилах не было запрета, а обфускатором решили не проходить, значит это было частью олимпиады (Максим Пьянков [maxzxwd](https://habr.com/ru/users/maxzxwd/)).
* Хоккеисты могли исчезнуть в случайный момент времени с поля и не появиться до конца игры. Можно пропихнуть игрока в зону вратаря.
* При вызове метода move() хоккеист мог повернуться не в том направлении. Из-за этого могло получиться что-то вроде “лунной походки”.
**Видео**
* Метод turn() разворачивает игроков заметно медленнее метода move() к определённой точке (происходит автоматический разворот в нужном направлении). Происходит такое, как правило, при коллизии с другим хоккеистом. Сравнение двух методов:
* Угол отражения оставляет желать лучшего. Огромная скорость после отскока от бортиков (видео замедленно в 4 раза). Незачёт шайбы, хоть она была в воротах.
Для сравнения, пример паса под прямым углом, у которого всё хорошо со скоростью и замедление есть.
**Видео**
* Нападающий вражеской команды стоял ближе к центру поля и сразу перехватывал шайбу в начале раунда (шайба не по центру текстуры поля тоже норма).
* Ограничение “вратарь может только доезжать до середины поля от ворот” распространяется только на нашу команды, для врагов такого правила нет.
* Для того, чтобы хоккеисты могли выполнять какие-либо действия, надо сначала к любому из них применить метод move();
* Организаторами в коде стратегии был оставлен таймаут, влияющий на частоту получения новых данных. Если просто удалить этот код, всё замирало. Многие не поняли его предназначение, а от организаторов не поступили объяснения. В правилах тоже эта часть кода не фигурировала. Многие на этом сели в лужу.
* У большого количества участников возникали проблемы со сборкой и изменением уровня стратегии (как оказалось, далеко не многие умели работать с maven’om).
* На вебинаре организаторы заявили, что Java будет использоваться 8 версии, однако в итоге для проекта нужна была минимум Java 11.
* Анна: после того, как села за рабочий компьютер, возникли проблемы с билдом из-за лишних пробелов в коде, который разбивали имя переменной. Не критично, но и не очень приятно.
* На некоторых компьютерах изначально не было ни файлов задания, ни интернета, а также зависимости подгружались долгое время.
* Участников было больше, чем ожидалось. Произошло это из-за каких-то доборов. Поэтому у человек ~13 были заминки с поиском компьютеров (некоторые доставали свои ноутбуки) и с нуля разворачивали проект.
* Обед не был жёстко регламентирован. Не давали определенного времени на трапезу, не закрывали аудитории. Голодающие получили дополнительный час на реализацию.
* Вверху, в описании конкурса, есть подзаголовок с критериями оценки. Проблема их в том, что там сказано о баллах, но не расписано, сколько и за что. В итоге получили непрозрачность и в целом непонимание того, что делать, чтобы выиграть.
> Наверное, было бы сложно сравнивать близких по уровню участников, так как не было чётких назначений баллов за фичи, был просто список. Участники могли реализовывать разные фичи, но из все равно надо было как-то сравнивать (Роман).
Заключение
----------
### Вывод
В целом, если перестать относиться к финалу слишком серьезно, было весело, интересно и очень залипательно. Да, пришлось тратить время не на написание стратегии, а чтобы справиться с багами разработчиков. Но когда приспосабливаешься и начинаешь играть по их правилам, начинаешь даже получать некоторое удовольствие от процесса. Конечно, хотелось бы, чтобы в дальнейшем разработчики более ответственно отнеслись к данной задаче и довели дело до конца, не предоставляя участникам финала сырой и недоработанный материал.
Также стоит отметить, что победители данного финала — большие молодцы: в таких непростых и неожиданных условиях они смогли собраться, разобраться во всем и выдать качественное решение. Респект таким пацанам.
### Благодарности
В первую очередь хотелось бы поблагодарить участников, которые помогли в написании статьи и любезно согласились ответить на наши вопросы. К сожалению, из-за смены направления, многий материал не приходился.
Спасибо Анне ([odrus](https://habr.com/ru/users/odrus/)), Льву ([zadamantiy](https://habr.com/ru/users/zadamantiy/)), Александру ([boba-alex](https://habr.com/ru/users/boba-alex/)), Максиму ([maxzxwd](https://habr.com/ru/users/maxzxwd/)), Ивану, Роману, Анне, Донату, Александру.
Также хотелось бы поблагодарить организаторов самого конкурса IT-Планета, организаторов финала по конкурсу “Программирование: Java” SimbirSoft, а в особенности разработчика Эдуарда, который присутствовал на финале и помогал участникам с проблемами билда, мог прояснить неочевидные моменты в логике игры.
> Спасибки за то, что конкурс вообще не кикнули, как сделали с сишарпом (Александр).
> Идея финала была хорошая, отборочные туры тоже (Иван).
### P.S.
Пока писали статью подъехали фоточки с конкурса и протоколы, а это значит, что теперь мы можем объявить свои места!
Больше всех кукарекал Илья — 28-32 место из 33
Анна — 16
Лев — 14
Спасибо, что дочитали аж до сюда! | https://habr.com/ru/post/472248/ | null | ru | null |
# Отладка приложений Node.js в Kubernetes?
#### Зачем вам это нужно?
При разработке кода на стороне сервера время от времени возникает проблема, которую очень трудно воспроизвести, наблюдаются утечки памяти или скачки процессора, которые вы не можете смоделировать локально, либо необходимо добавлять специальные журналы в приложение. При локальной разработке приложения используется инспектор Node.js для отладки и создания снапшотов памяти/процессора, которые помогут вам найти проблему, но как сделать то же самое в удаленной среде? К счастью, Node.js располагает отличной поддержкой для удаленной отладки, и в этой статье мы рассмотрим, как использовать ее в kubernetes.
#### Пример приложения
Мы будем использовать простой пример приложения для демонстрации всего процесса. Код демонстрационного приложения находится здесь: [https://github.com/amirilovic/example-app](https://github.com/amirilovic/example-ap).
#### Как включить режим отладки в процессе Node.js?
Конечно, режим отладки по умолчанию не включен для процесса Node.js, поскольку это позволяет выполнить произвольный код на удаленной машине. Есть два способа включить режим отладки в Node.js, используя флаг `--inspect`, либо посылая процессу сигнал SIGUSR1. Более подробную информацию об этом вы можете найти [здесь](https://nodejs.org/en/docs/guides/debugging-getting-started/).
#### Использование флага -- inspect
Когда вы запускаете процесс Node.js с флагом `--inspect`, режим отладки включается немедленно:
```
$ node --inspect dist/index.js Debugger listening on ws://127.0.0.1:9229/1393d28d-2e81-4096-85e2-f0f877f22c10 For help, see: https://nodejs.org/en/docs/inspector Server listening on port 3000...
```
В сообщении выше видно, что отладчик прослушивает порт 9229.
Теперь вы можете использовать vscode или chrome инспектор для присоединения отладчика к этому процессу:
В приведенном выше примере это конфигурация по умолчанию для присоединения к процессу Node.js:
```
{
"name": "Attach",
"port": 9229,
"request": "attach",
"skipFiles": ["/\*\*"],
"type": "pwa-node"
}
```
Важно отметить, что отладчик по умолчанию прослушивает только соединения, приходящие с localhost - он будет отклонять сессии отладки с удаленных адресов. Чтобы обойти это, вам нужно либо разрешить удаленные адреса, используя `--inspect=0.0.0.0:9229`, либо создать некий сетевой туннель между удаленным сервером и вашим компьютером; в следующих разделах я покажу, как легко сделать туннель в kubernetes.
#### Отправка сигнала SIGUSR1 запущенному процессу
Отправка сигнала процессу очень полезна для проведения спонтанной отладки без перезапуска процесса.
Откройте одно окно терминала, чтобы запустить процесс:
```
# start Node.js app
$ node dist/index.js
Server listening on port 3000...
```
Откройте другое окно терминала, чтобы включить режим отладки:
```
# find PID of Node.js process
$ ps aux | grep "node dist/index.js"
# use the PID to send USR1 signal to the process
$ kill -USR1 [PID]
```
Выполнив команду kill, вы заметите в первом окне терминала, что отладчик включен, со следующим сообщением:
```
Debugger listening on ws://127.0.0.1:9229/e2576437-dc86-4d42-9307-e9bf5db34e70
For help, see: https://nodejs.org/en/docs/inspector
```
Более подробную информацию об использовании `kill` для отправки сигналов процессам вы можете найти [здесь](https://bash.cyberciti.biz/guide/Sending_signal_to_Processes).
### Как проводить отладку в Kubernetes?
#### Обновление liveness и readiness проб
Во время отладки, если ваш процесс прервется на точке останова, Node.js не сможет ответить на запросы liveness (работоспособности) и readiness (готовности) в kubernetes, и kubernetes решит, что необходимо перезапустить под, завершая вашу сессию отладки. Для предотвращения этого необходимо изменить пробы таким образом, чтобы они допускали более продолжительные остановки процессов:
```
# removing livenessProbe
$ kubectl patch deploy/example-app --type json -p='[{"op": "remove", "path": "/spec/template/spec/containers/0/livenessProbe"}]'
# removing readinessProbe
$ kubectl patch deploy/example-app --type json -p='[{"op": "remove", "path": "/spec/template/spec/containers/0/readinessProbe"}]'
# adding dummy livenessProbe
$ kubectl patch deploy/example-app -p '{"spec": {"template": {"spec": {"containers": [{"name": "example-app", "livenessProbe": {"initialDelaySeconds": 5, "periodSeconds": 5, "exec": {"command": ["true"]}}}]}}}}'
# adding dummy readinessProbe
$ kubectl patch deploy/example-app -p '{"spec": {"template": {"spec": {"containers": [{"name": "example-app", "readinessProbe": {"initialDelaySeconds": 5, "periodSeconds": 5, "exec": {"command": ["true"]}}}]}}}}'
```
#### Уменьшение масштаба (опционально)
Для отладки вам необходимо убедиться, что запрос действительно попадает в тот под, к которому вы подключаетесь. Это может быть непросто, если у вас запущено несколько подов. В примере мы определили 3 реплики в нашем развертывании, а также выполнили автоматическое масштабирование подов с помощью ресурса HorizontalPodAutoscaler. Поэтому нам нужно сообщить kubernetes, чтобы он масштабировал все до 1 пода и сохранил это в таком виде.
```
# check the number of pods
$ kubectl get pods | grep example-app
NAME READY STATUS RESTARTS AGE
example-app-56cf79964d-g92n4 1/1 Running 0 53s
example-app-6b8fb58764-hhk46 1/1 Running 0 14s
example-app-6f79d6cf66-wdxqk 1/1 Running 0 71s
# update HPA to run only one replica
$ kubectl patch hpa/example-app -p '{"spec": {"minReplicas": 1, "maxReplicas": 1}}'
# update deployment to run only one replica
$ kubectl scale --replicas=1 deploy/example-app
# check the number of pods again
$ kubectl get pods | grep example-app
NAME READY STATUS RESTARTS AGE
example-app-6b8fb58764-2qlgn 1/1 Running 0 110s
```
#### Включение отладчика
Поскольку флаг `--inspect` не должен быть включен при запуске приложений в продакшене, проще сделать это в специальном порядке, отправив ему сигнал USR1, чем создавать новый под. Но сначала вам нужно найти PID вашего приложения Node.js.
Если в вашем образе docker вы запускаете приложение следующим образом:
```
CMD [ "node", "dist/index.js" ]
```
PID вашего приложения будет равен 1. Чтобы выяснить это точнее, в случае неуверенности, используйте следующие команды:
```
# find Node.js process PID
$ kubectl exec -it deploy/example-app -- /bin/sh -c "ps aux"
# if there is no ps in the docker image, use:
$ kubectl exec -it deploy/example-app -- /bin/sh -c "find /proc -mindepth 2 -maxdepth 2 -name exe -exec ls -lh {} \; 2>/dev/null"
lrwxrwxrwx 1 node node 0 Sep 30 04:11 /proc/1/exe -> /usr/local/bin/node
lrwxrwxrwx 1 node node 0 Sep 30 04:11 /proc/587/exe -> /bin/dash
lrwxrwxrwx 1 node node 0 Sep 30 04:11 /proc/594/exe -> /usr/bin/find
```
Затем включаем отладчик, в моем случае я использую PID 1.
```
# enable debugger
kubectl exec -it deploy/example-app -- /bin/sh -c "kill -USR1 1"
# verify that debugger has been enabled
$ kubectl logs deploy/example-app
Server listening on port 3000...
Debugger listening on ws://127.0.0.1:9229/496132b9-ec4b-43db-b103-4e15ba80518a
For help, see: https://nodejs.org/en/docs/inspector
```
#### Перенаправление портов
Для отладки с локальной машины на удаленный под, мы будем использовать функцию kubernetes port-forward:
```
# forward debug port from pod to our machine
$ kubectl port-forward deploy/example-app 9229:9229
Forwarding from 127.0.0.1:9229 -> 9229
Forwarding from [::1]:9229 -> 9229
```
После включения этой функции мы можем подключить отладчик Node.js к localhost:9229.
#### Отладка с помощью VSCode
Теперь вы можете подключить отладчик с помощью vscode. Но проблема в том, что вы не можете устанавливать точки останова, как обычно:
Вопрос заключается в том, что vscode не знает, как сопоставить файлы из контейнера с локальным исходным кодом. Чтобы это осуществить, нам нужно обновить конфигурацию присоединения в файле .vscode/launch.json:
```
{
"name": "Attach",
"port": 9229,
"request": "attach",
"skipFiles": ["/\*\*"],
"type": "pwa-node",
"localRoot": "${workspaceFolder}",
"remoteRoot": "/app",
"sourceMaps": true
}
```
Свойства, которые мы добавили, следующие:
* localRoot сообщает vscode, что является корнем проекта на вашем компьютере
* remoteRoot сообщает vscode, какой путь в контейнерах соответствует нашему localRoot
* sourceMaps сообщает vscode учитывать информацию из исходных кодовых карт, для того, чтобы мы действительно могли осуществлять отладку из файлов с исходными кодами.
После установки этого параметра мы сможем выполнять отладку нормально:
#### Профилирование процессора и снапшоты памяти
Если вам необходимо сделать отладку по утечке памяти или скачкам ЦП, лучшим инструментом для этого является chrome dev tools “Профилирование ЦП и памяти”. После включения дополнительных возможностей отладки можно легко подключиться с помощью chrome к удаленному процессу и выполнить профилирование. Откройте Chrome и перейдите в `chrome: // inspect`:
Дополнительную информацию о том, как использовать снапшоты памяти для поиска утечек, вы можете найти [здесь](https://www.toptal.com/nodejs/debugging-memory-leaks-node-js-applications).
#### Заключение
Надеюсь, прочитанное показало вам, насколько мощной является удаленная отладка в Node.js, и какой замечательный набор инструментов существует, чтобы вам в этом помочь. Не так уж часто возникают проблемы, требующие отладки удаленного процесса, но если применять методики, подобные этой, они могут предотвратить массу неприятностей.
---
> Материал подготовлен в рамках курса [«Инфраструктурная платформа на основе Kubernetes».](https://otus.pw/B3Fl/)
>
> Всех желающих приглашаем на бесплатное demo-занятие **«Контейнерная оркестрация с плавным переходом к k8s»**. На занятии поговорим о том, как было до оркестрации, какие проблемы пытались решить, что сейчас: обзор оркестраторов, плавный переход к k8s. На уроке расскажем основные компоненты k8s и их связь, варианты локального развертывания k8s, а также варианты развертывания на виртуальных машинах или baremetall.
> [**>> РЕГИСТРАЦИЯ**](https://otus.pw/PEi1/)
>
> | https://habr.com/ru/post/591903/ | null | ru | null |
# Построение моделей на панельных данных в Python, часть 2: метод «разность разностей» (diff-in-diff)
**Построение моделей на панельных данных в Python, часть 2: метод “разность разностей” (diff-in-diff).**
Привет, Хабр!
Данная статья является продолжением [статьи](https://habr.com/ru/post/710714/) “Построение моделей на панельных данных в Python, часть 1: объединенный МНК, модель с фиксированными эффектами, модель со случайными эффектами”. Напомню задачу: необходимо оценить, как изменились цены в отелях на островах Сардинии и Корсики после введения закона Макрона на острове Корсика.
Рассчитываем эффект воздействия методом разность разностей (diff-in-diff). Перед формальным описанием модели перечислю основные факторы, которые могут влиять на цену отеля:
* специфические особенности острова, в котором расположен отель (эффект острова);
* особенности различных периодов времени, например, изменение экономической конъюнктуры (временной эффект);
* эффект анонса закона Макрона (тот самый эффект, который мы пытаемся оценить).
Формально можем записать так: Yist =αs +μt +δ⋅Dist +εist, где индекс i - номер отеля, индекс s - остров (Корсика или Сардиния), индекс t - момент времени (период до анонса закона Макрона или период после него). Yist - цена отелей; переменная D равна 1 в отелях, которые находились на Корсике (и соответственно, на которые распространяется закон Макрона) и равно 0 во всех остальных случаях (если отели находились в Сардинии и на них закон Макрона не распространялся). αs - эффект острова, он имеет два значения: αcontrol, если наблюдение относится к контрольной группе, т.е. к Сардинии; αtreatment, если наблюдение относится к испытуемой группе, т.е. к Корсике. μt - временной эффект. Он равен μbefore до анонса закона Макрона и μafter после анонса закона, δ — эффект воздействия анонса закона Макрона. Это тот самый эффект, который требуется оценить; εist — случайные ошибки модели.
Подробные выкладки можно посмотреть в учебнике Картаева в главе 11[2].
Метод разности разностей непосредственно связан с оценкой моделей при помощи регрессий. Так как мы располагаем панельными данными об объектах из испытуемой и контрольной групп за два периода (до и после введения закона Макрона), оценка метода разности разностей может быть получена в результате применения следующей модели:
Yit = β0 + β1 ⋅ Xi + β2 ⋅ Zt + δ ⋅ Xi ⋅ Zt + εit, где Xi — бинарная переменная, которая равна единице, если i-й отель находится на Корсике, Zt - бинарная переменная, которая равна единице для всех наблюдений, относящихся ко второму периоду (периоду после анонса закона).
Для состоятельности оценки требуется экзогенность объясняющей переменной. Если регрессор оказывается эндогенным из-за пропуска других существенных факторов, влияющих на Y, то эта проблема может быть решена включением в уравнение контрольных переменных.
Важная предпосылка метода разность разностей - параллельные претренды. Именно эта предпосылка позволяет предполагать, что за два периода t=0 и t=1 динамика Y (в нашем случае цены на отелей) в тритмент-группе, если бы она не подверглась воздействию, была бы такой же, как и динамика Y в контрольной группе. Проверим соблюдение этой предпосылки на наших данных.
Претренды показателя “средняя цена за неделю” сохраняются до вступления закона в силу сохраняются(см. Рисунок 2).
```
import matplotlib.pyplot as plt
trends= df.groupby(['week_number', 'region'], as_index=False).agg({'eurP': 'mean'})
trends['region'] = trends['region'].apply(lambda x: 1 if x == 'Corsica' else 0)
fig, axes = plt.subplots(figsize=(9,6), dpi=80)
plt.plot(trends[trends['region'] == 1]['week_number'], trends[trends['region'] == 1]['eurP'], label = 'о. Корсика', color = 'dodgerblue')
plt.plot(trends[trends['region'] == 0]['week_number'], trends[trends['region'] == 0]['eurP'], label = 'о. Сардиния', color = 'deepskyblue')
plt.axvline(x = 28, color = 'lightsteelblue', label = "Закон обнародовали")
plt.axvline(x = 32, color = 'slategrey', label = "Закон вступил в силу")
plt.legend()
plt.xlabel('Номер недели', fontsize=12)
plt.ylabel('Цена за 1 номер за 1 день, евро', fontsize=12)
plt.title('Тренды средней цены на Корсике и в Сардинии', fontsize=14)
plt.show()
```
*Рисунок 2: Тренды средней цены за неделю на Корсике и в Сардинии*
Для построения моделей методом “разность разностей” добавим бинарные переменные.
```
def adding_dummies(df, col_names):
for column_name in col_names:
dummies =pd.DataFrame(pd.get_dummies(df[column_name],
prefix=column_name))
df=df.merge(dummies, left_index=True, right_index=True)
return(df)
df=adding_dummies(df, ['Star rating', 'Chain affiliation',
'hot_size', 'region'])
```
И предобработаем данные следующим образом: если в модель мы добавим переменную PostLaw\_Treated\_NoChain, которая равна PostLaw\* treat\* Chain affiliation\_0, то коэффициент при ней будет показывать насколько изменилась цена в отелях, которые “не сетевые”, на Корсике (где закон Макрона был принят) по сравнению с ценами в отелях, которые “не сетевые”, но уже в Сардинии (где закон не был принят). Введение таких новых переменных позволит нам сделать вывод об изменении цен в разрезе разных категорий.
```
df=df.rename(columns={'google_src': 'Google_Searchers',
'town_avail': 'Hotel_availability'})
df['Postlaw_Treated']=df['postlaw']*df['treat']
df['PostLaw_Treated_NoChain']= df['postlaw']*df['treat']*df['Chain affiliation_0']
df['PostLaw_Treated_Chain']= df['postlaw']*df['treat']*df['Chain affiliation_1']
df['PostLaw_Treated_0stars']= df['postlaw']*df['treat']*df['Star rating_0']
df['PostLaw_Treated_1stars']= df['postlaw']*df['treat']*df['Star rating_1']
df['PostLaw_Treated_2stars']= df['postlaw']*df['treat']*df['Star rating_2']
df['PostLaw_Treated_3stars']= df['postlaw']*df['treat']*df['Star rating_3']
df['PostLaw_Treated_4stars']= df['postlaw']*df['treat']*df['Star rating_4']
df['PostLaw_Treated_5stars']= df['postlaw']*df['treat']*df['Star rating_5']
df['PostLaw_Treated_small_size']= df['postlaw']*df['treat']*df['hot_size_0']
df['PostLaw_Treated_medium_size']= df['postlaw']*df['treat']*df['hot_size_1']
df['PostLaw_Treated_large_size']= df['postlaw']*df['treat']*df['hot_size_2']
df['DaysCorsica']= df['bdays']*df['region_Corsica']
df['DaysSardinia']= df['bdays']*df['region_Sardinia']
df['const']=1
```
Строим модели. В модели добавляем контрольные переменные: количество дней с момента введения закона (DaysCorsica, DaysSardinia) для оценки долгосрочности эффекта, количество запросов в Google (Google\_Searchers) и количество доступных отелей (Hotel\_availability).
```
from linearmodels import IV2SLS
from collections import OrderedDict
from linearmodels.iv.results import compare
mod11v='lprice100 ~ Postlaw_Treated + DaysCorsica + DaysSardinia + Google_Searchers + Hotel_availability - 1'
reg11v = IV2SLS.from_formula(mod11v,df).fit(cov_type="robust")
mod22v='lprice100 ~ PostLaw_Treated_NoChain + PostLaw_Treated_Chain + DaysCorsica + DaysSardinia + Google_Searchers + Hotel_availability - 1'
reg22v = IV2SLS.from_formula(mod22v,df).fit(cov_type="robust")
mod33v='lprice100 ~ PostLaw_Treated_0stars + PostLaw_Treated_1stars + PostLaw_Treated_2stars + PostLaw_Treated_3stars + PostLaw_Treated_4stars + PostLaw_Treated_5stars + DaysCorsica + DaysSardinia + Google_Searchers + Hotel_availability -1'
reg33v = IV2SLS.from_formula(mod33v,df).fit(cov_type="robust")
mod44v='lprice100 ~ PostLaw_Treated_small_size + PostLaw_Treated_medium_size + PostLaw_Treated_large_size + DaysCorsica + DaysSardinia + Google_Searchers + Hotel_availability - 1'
reg44v = IV2SLS.from_formula(mod44v,df).fit(cov_type="robust")
res1v = OrderedDict()
res1v["D-in-D"] = reg11v
res1v["Triple_Chains"] = reg22v
res1v["Triple_Stars"] = reg33v
res1v["Triple_Size"] = reg44v
result = compare(res1v, stars=True, precision='std_errors')
print(result)
```
Исходя из построенных моделей, мы можем сделать следующие выводы:
* введение закона Макрона повышает цену отелей, так как коэффициент при Postlaw\_Treated > 0. Но увеличение цены происходит только в краткосрочном периоде. С увеличением количества дней, которые прошли с момента введения закона (с 6 августа 2015 года) цена на отели снижается: коэффициенты при DaysCorsica и DaysSardinia отрицательные. Причем на Сардинии цены снижаются быстрее и краткосрочный рост цен на отели ниже, чем на Корсике, потому что коэффициент при DaysSardinia по модулю больше коэффициента при DaysCorsica.
* Цены на сетевые отели выросли больше, чем цены на несетевые отели, так как коэффициент при PostLaw\_Treated\_Chain > коэффициента при PostLaw\_Treated\_NoChain.
* Чем больше количество звезд у отеля, тем сильнее увеличилась цена после введения закона Макрона, кроме однозвездочных отелей - на них цена снизилась после введения закона (коэффициент при PostLaw\_Treated\_1stars < 0).
Результаты построения моделей методом разность разностей дали нам более содержательную интерпретацию, чем построение модели объединенного МНК, моделей с фиксированными и случайными эффектами.
Скачать код можно [тут](https://github.com/oluscha/model_on_panel_data/blob/main/models_on_panel_data.ipynb).
[1] Andrea Mantovani, Claudio A. Piga, Carlo Reggiani, Online platform price parity clauses: Evidence from the EU Booking.com case, European Economic Review, Volume 131, 2021, 103625, ISSN 0014-2921, <https://doi.org/10.1016/j.euroecorev.2020.103625>.
[2] Филипп Картаев “Введение в эконометрику”: учебник. – М.: Экономический факультет МГУ имени М.В. Ломоносова, 2019. – 472 с. ISBN 978-5-906932-22-8 | https://habr.com/ru/post/710716/ | null | ru | null |
# Пиши на C как джентльмен
*> «Code Monkey like Fritos
>
> Code Monkey like Tab and Mountain Dew
>
> Code Monkey very simple man
>
> With big warm fuzzy secret heart:
>
> Code Monkey like you
>
> Code Monkey like you»
>
>
— Jonathan Coulton — Code Monkey*
Я думаю, многим знакома эта шикарная песня Jonathan Coulton'а, и эта жизненная ситуация, когда «Rob say Code Monkey very diligent», но «his output stink» и «his code not 'functional' or 'elegant'».
Язык Си, подаривший нам столько полезного софта, потихоньку был вытеснен из десктопа и энтерпрайза такими высокоуровневыми гигантами как Java и C# и занял нишу системного программирования. И все бы хорошо, но системщики — очень ~~отбитые~~ своеобразные ребята. Задачи, которые порой возникают перед ними даже своей формулировкой способны вогнать в ужас простых смертных. Собственно говоря, так же, как и некоторые решения.
Сегодня мы поговорим о некоторых полезных практиках, которые я вынес из глубин системного программирования на Си. Поехали.
Пункты будут располагаться от самых фундаментальных и очевидных (ориентированных на новичков в языке Си) до самых специфичных, но полезных. Если чувствуете, что вы это знаете — листайте дальше.
Практика I: Соблюдайте единый Code Style и фундаментальные принципы «хорошего тона»
------------------------------------------------------------------------------------
Функция принимает в качестве аргумента переменную INPUT, парсит её в массив IncomingValues и возвращает result\_to\_return? Отставить быдлокод!
То, что в первую очередь выдает новичка — несоблюдение единого стиля написания кода в рамках конкретного приложения. Следом идет игнорирование правил «хорошего тона».
Вот несколько самых распространенных рекомендаций к оформлению кода на Си:
* **Названия макросов и макрофункций пишутся капсом, слова в названиях отделяются друг от друга нижним подчеркиванием.**
```
#define MAX_ARRAY_SIZE 32
#define INCORRECT_VALUE -1
#define IPC_FIND_NODE(x) ipc_find_node(config.x)
```
* **Названия переменных записываются в нижнем регистре, а слова в названиях отделяются нижним подчеркиванием**
```
int my_int_variable = 0;
char *hello_str = "hello_habrahabr";
pid_t current_pid = fork();
```
Вообще, этот пункт спорный. Мне доводилось видеть проекты, где имена переменных и функций пишутся в camelCase и PascalCase соответственно.
**UPD: Спасибо пользователю [fogree](https://habrahabr.ru/users/fogree/) за то, что он обнаружил косяк с перепутанным PascalCase и camelCase.**
* **Названия библиотечных функций общего пользования пишутся одним словом, иногда сокращенным, но это слово передает суть функции — что она должна делать.**
Кстати, рекомендую взять за привычку писать код так, чтобы одна функция делала только одну вещь. Именно это должно отразиться в названии.
То же можно сказать и про переменные — никаких a, b, c — в названии должен быть отражен смысл (итераторы не в счет). Самодокументируемый код — очень хорошая практика.
* **Специализированные функции (которые вызываются в пределах работы внутри какого-то специфичного контекста) лучше называть так, чтобы было определенно ясно, что делает эта функция.**
Как правило, можно выбрать между стилем написания названия: PascalCase и under\_score, тут уже зависит от вас.
```
/* пример функции общего пользования */
static void dgtprint(char *str) {
int i;
for (i = 0; i < strlen(str); i++) {
if (isdigit(str[i]))
printf("%c", str[i]);
else
print("_");
}
}
/* пример функции для работы со специфичным контекстом */
/* PascalCase */
void EnableAllVlans(struct vlan_cfg *vp) {
int i;
for (i = 0; i < VLAN_COUNT; i++) {
EnableVlanByProto(vp.vlan[i]);
}
}
/* under_score */
void enable_all_vlans(struct vlan_cfg *vp) {
int i;
for (i = 0; i < VLAN_COUNT; i++) {
enable_vlan_by_proto(vp.vlan[i]);
}
}
```
* **i, j, k — стандартные названия для итераторов цикла**
```
int array[MAX_ARRAY_SIZE] = arrinit();
register int i, j, k;
for (i = 0; i < MAX_ARRAY_SIZE; i++)
for (j = 0; j < MAX_ARRAY_SIZE; j++)
for (k = MAX_ARRAY_SIZE; k >= 0; k--)
dosmthng(i, j, k, array[i]);
```
* **Соблюдайте однородность переноса скобок**
```
if (condition) { dosmthng(); } else
{
dont_do_something();
} /* Не делайте так */
if (condition) {
dosmthng();
} else {
dont_do_something();
} /* Гораздо правильнее будет следовать одному правилу переноса скобок, как тут */
if (condition)
{
dosmthng();
}
else
{
dont_do_something();
} /* Или как тут */
/* Ну, или как тут, но это уже совсем экзотика */
if (condition) { dosmthng(); } else { dont_do_something(); }
```
* **Объявляйте переменные в начале функции.** Если это глобальные переменные, то в начале файла.
По возможности инициализируйте переменные при объявлении. Численные с помощью нуля, указатели — NULL:
```
int counter = 0, start_position = 0, unknown_position = 0;
struct dhcp_header * dhcp = NULL, * dhcp_temp = NULL;
char input_string[32] = { 0 };
```
Ну оставили мы переменные неинициализированными, и что?
А то. Если смотреть их (до инициализации) в отладке (в том же gdb), там будет лежать мусор. Это нередко сбивает с толку (особенно, если мусор «похож на правду»). Про указатели я вообще молчу.
* **Пишите комментарии с умом.**
Не надо комментировать каждую строчку кода — если вы пишите самодокументируемый код, большая часть его будет простой для понимания.
Оптимальное решение — писать описания функций, если из аргументов и названия сложно понять весь её функционал. Для переменных — правила те же, в пояснении нуждаются только какие-то нелинейный вещи, где одного названия мало.
На самом деле, в вопросе документации у вас есть полная свобода действий — надо лишь следить, чтобы комментариев было не много, но достаточно, чтобы человек, видящий ваш код в первый раз, не задавал вопросов.
```
/* Возвращает 1, если параметры, связанные с модемным
* соединением изменились, и 0, если нет.
*/
static int CheckModemConnection()
{
int i = 0;
/* Проверка сети отдельно - меняется чаще всего */
if (CHECK_CFG_STR(Network.LanIpAddress) || CHECK_CFG_STR(Network.LanNetmask))
return 1;
for(i = 0; i < MAX_MODEM_IDX; i++)
{
if (CHECK_CFG_INT(Modems.Modem[i].Proto) || CHECK_CFG_INT(Modems.Modem[i].MTU) ||
CHECK_CFG_STR(Modems.Modem[i].Username) || CHECK_CFG_STR(Modems.Modem[i].Password) ||
CHECK_CFG_STR(Modems.Modem[i].Number) || CHECK_CFG_STR(Modems.Modem[i].AdditionalParams) ||
CHECK_CFG_STR(Modems.Modem[i].PIN) || CHECK_CFG_STR(Modems.Modem[i].MRU) ||
CHECK_CFG_STR(Modems.Modem[i].PppoeIdle) || CHECK_CFG_STR(Modems.Modem[i].USBPort) ||
CHECK_CFG_STR(Reservation.Prefer) || CHECK_CFG_STR(Modems.Modem[i].PppoeConnectType) ||
CHECK_CFG_INT(Modems.Mode) || CHECK_CFG_INT(Aggregation.usb1) || CHECK_CFG_INT(Aggregation.usb2))
return 1;
}
return 0;
}
```
Если вы постоянно работаете с трекерами (вроде [RedMine](https://ru.wikipedia.org/wiki/Redmine)), то при внесении правок в код можно указать номер задачи, в рамках которой эти правки были внесены. Если у кого-то при просмотре кода возникнет вопрос а-ля «Зачем тут этот функционал?», ему не придется далеко ходить. В нашей компании еще пишут фамилию программиста, чтобы если что знать, к кому идти с расспросами.
> /\* Muraviyov: #66770 \*/
---
*P.S. Для тех кто устраивается на работу: так же не следует забывать, что в каждой компании, как правило, используется свой Code Style, и ему нужно следовать. В противном сулучае можно получить как минимум укоризненные взгляды товарищей-разрабов или втык от начальства.*
Практика II: Оптимизируйте структуру вашего проекта
----------------------------------------------------
Если у вас в проекте несколько файлов — имеет смысл хорошо подумать над структурой проекта.
Каждый проект уникален, но, тем не менее, существует ряд рекомендаций, которые помогут удобно структурировать проект:
1. **Называйте файлы так, чтобы всем было ясно, какой файл за что отвечает.**
Не следует называть файлы file1.c, mySUPER\_COOL\_header.h и т.д.
main.c — для файла с точкой входа, graph\_const.h — для заголовочника с графическими константами будет в самый раз.
2. **Храните заголовочники в директории include.**
Рассмотрим пример:
* project/
+ common.c
+ common.h
+ main.c
+ network.h
+ networking.c
+ networking\_v6.c
+ packet.c
+ packet.h
+ MakefileВ принципе, проект как проект. Но давайте на секунду представим, что у нас не 9 файлов, а, скажем, 39. Что-то быстро найти будет проблематично. Да, в консоли — пара пустяков, но что если человек работает с GUI, или, что еще хуже, пытается найти файл в Github/Gitlab/Bitbucket?
Если он точно не знает, какой файл ему нужен? Можно сберечь много нервов, если сделать так:
* project/
+ include/
- common.h
- network.h
- packet.h
+ common.c
+ main.c
+ networking.c
+ networking\_v6.c
+ packet.c
+ Makefile
Не забываем, что путь к директории include следует указать в параметрах сборки. Вот примерчик для простого Makefile (include в той же директории, что и Makefile):
```
@$(CC) $(OBJS) -o networkd -L$(ROMFS)/lib -linteraction -Wall -lpthread -I ./include
```
3. **Логически группируйте .c файлы в папки.**
Если у вас игра, в которой есть файлы, отвечающие за движок/звук/графику — будет удобно раскидать их по папкам. Звук, графику и движок — отдельно друг от друга.
4. Дополнение к предыдущему пункту — **файлы сборки круто размещать в каждой из таких отдельных директорий**, и просто вызывать их из файла сборки в корневой директории. В таком случае Makefile в корневой директории будет выглядеть примерно так:
```
.PHONY clean build
build:
cd sound/ && make clean && make
cd graphics/ && make clean && make
cd engine/ && make clean && make
sound:
cd sound/ && make clean && make
graphics:
cd graphics/ && make clean && make
engine:
cd engine/ && make clean && make
clean:
cd sound/ && make clean
cd engine/ && make clean
cd greaphics/ && make clean
```
Практика III: Используйте враппер-функции для обработки возвращаемых значений
------------------------------------------------------------------------------
Враппер-функция (функция-обертка) в языке Си используется как функция со встроенной обработкой возвращаемого значения. Как правило, в случае ошибки в работе функции, возвращаемое значение вам об этом скажет, а глобальная переменная errno примет в себя код ошибки.
Если вы пишите в системе (а сейчас большинство программ на си — именно системные программы), то нет ничего хуже, чем «немое» падение программы. По-хорошему, она должна красиво завершиться, напоследок сказав, что именно пошло не по плану.
Но обрабатывать значение от каждой функции в коде — такое себе решение. Тут же упадет читаемость, и объем (+ избыточность) кода увеличится в пару раз.
Тут и помогают врапперы. Рассмотрим первый пример — безопасный код без врапперов:
```
int sock_one = 0, sock_two = 0, sock_three = 0;
/* операция сравнения имеет больший приоритет, чем операция присваивания,
* поэтому присваивание выполняется в скобках
*/
if ((socket_one = socket(AF_INET , SOCK_STREAM , 0)) <= 0) {
perror("socket one");
exit(EXIT_ERROR_CODE);
}
if ((socket_two = socket(AF_INET , SOCK_DGRAM , 0)) <= 0) {
perror("socket two");
exit(EXIT_ERROR_CODE);
}
if ((socket_three = socket(PF_INET , SOCK_RAW , 0)) <= 0) {
perror("socket three");
exit(EXIT_ERROR_CODE);
}
```
Ну, такое себе, не правда ли? Теперь попробуем с обертками.
```
/* Где-то в коде... */
int Socket(int domain, int type, int proto) {
int desk = socket(domain, type, proto);
if (desk <= 0) {
perror("socket");
exit(EXIT_ERROR_CODE);
}
return desk;
}
/* ......... n строчек спустя - наш предыдущий пример ......... */
int socket_one = 0, socket_two = 0, soket_three = 0;
socket_one = Socket(AF_INET , SOCK_STREAM , 0);
socket_two = Socket(AF_INET , SOCK_DGRAM , 0);
socket_three = Socket(PF_INET , SOCK_RAW , 0);
```
Как видите, код по-прежнему безопасен (не будет «немого» падения), но теперь его функциональная часть гораздо компактнее.
Я называю обертки именем самих функций, но с большой буквы. Каждый сам волен выбрать, как их оформлять.
В использовании оберток есть небольшой минус, который, если захотеть, можно решить костылем. А что это за минус — можете предположить в комментариях :)
Практика IV: Используйте keywords как профи
--------------------------------------------
Хорошее знание keywords никогда не будет лишним. Да, и без них ваш код будет работать, не спорю. Но когда речь зайдет об экономии места, быстродействии и оптимизации — это именно то, чего вам будет не хватать.
К тому же, мало кто может похвастаться хорошим знанием ключевых слов, поэтому их повседневное использование может быть шансом блеснуть знаниями перед коллегами. Однако, не надо бездумно пихать кейворды всюду, куда только можно. Вот вам несколько фич:
* *register* — дает компилятору указание по возможности хранить переменную в регистрах процессора, а не в оперативной памяти. Использование модификатора register при объявлении переменной-итератора цикла с небольшим телом может повысить скорость работы всего цикла в несколько раз.
```
register byte i = 0;
for (i; i < 256; i++)
check_value(i);
```
* *restrict* — при объявлении указателя дает компилятору гарантию (вы, как программист, гарантируете), что ни один указатель не будет указывать на область памяти, на которую указывает целевой указатель. Профит этого модификатора в том, что компилятору не придется проверять, не указывает ли какой-то еще указатель на целевой блок памяти. Если у вас внутри функции несколько указателей одного типа — возможно, он вам пригодится.
```
void updatePtrs(size_t *restrict ptrA, size_t *restrict ptrB, size_t *restrict val);
```
* *volatile* — указывает компилятору, что переменная может быть изменена неявным для него образом. Даже если компилятор пометит код, зависимый от волатильной переменной, как dead code (код, который никогда не будет выполнен), он не будет выброшен, и в рантайме выполнится в полном объеме.
```
int var = 1;
if (!var) /* Эти 2 строчки будут отброшены компилятором */
dosmthng();
volatile int var = 1;
if (!var) /* А вот эти - нет */
dosmthng();
```
И это только вершина айсберга. Различных модификаторов и ключевых слов — [куча](http://en.cppreference.com/w/c/keyword).
Практика V: Не доверяйте себе. Доверяйте valgrind.
---------------------------------------------------
Если у вас в программе есть работа со строками, динамическое выделение памяти и все, где замешаны указатели, то не будет лишним проверить себя.
[Valgrind](https://ru.wikipedia.org/wiki/Valgrind) — программа, которая создана для того, чтобы помочь программисту выявить утечки памяти и ошибки контекста. Не буду вдаваться в подробности, скажу лишь, что даже в небольших программах он нередко находит косяки, которые совсем не очевидны для большинства программистов, но, тем не менее, в эксплуатации могут повлечь за собой большие проблемы. За всем не уследишь.
+ у нее есть и другой полезный функционал.
Более подробно о нем можно узнать [тут](https://www.opennet.ru/base/dev/valgrind_memory.txt.html).
Практика VI: Помогайте тем, кто хочет улучшить ваш софт
--------------------------------------------------------
Пример будет взят из исходников busybox 1.21. Для тех кто не знает, что такое busybox, можете посмотреть [эту вики-статью](https://ru.wikipedia.org/wiki/BusyBox).
**UPD:** до этого здесь был пример «плохого» кода из busybox. Спасибо пользователю [themiron](https://habrahabr.ru/users/themiron/) за то, что показал, что этот код был понят мною неправильно — это были лишь тонкости реализации, причем реализации очень хорошей. В качестве извинения за свою «клевету» на busybox, здесь будет пример хорошего кода.
Причем, все так же из busybox.
Код busybox очень эллегантен, пусть и совсем не прост. Всем, кто хочет взглянуть на язык си под другим углом — рекомендую ознакомиться с [исходниками](https://git.busybox.net/busybox/tree/networking/udhcp?h=1_26_stable).
Теперь обобщения по этому пункту на примерах из busybox. Все примеры взяты из udhcpc — крохотного [DHCP](https://ru.wikipedia.org/wiki/DHCP) клиента:
* **Оставляй комментарии, там где они нужны.**
Протокол DHCP имеет полную документацию в RFC, там описаны все возможные поля dhcp-пакета. Но, тем не менее, ребята озаботились и полностью задокументировали даже поля структуры. Эта структура — первое, на что посмотрит программист, расширяющий функционал программы (DHCP-клиент <-> DHCP-пакет).
*(файл networking/udhcp/common.h)*
```
struct dhcp_packet {
uint8_t op; /* BOOTREQUEST or BOOTREPLY */
uint8_t htype; /* hardware address type. 1 = 10mb ethernet */
uint8_t hlen; /* hardware address length */
uint8_t hops; /* used by relay agents only */
uint32_t xid; /* unique id */
uint16_t secs; /* elapsed since client began acquisition/renewal */
uint16_t flags; /* only one flag so far: */
#define BROADCAST_FLAG 0x8000 /* "I need broadcast replies" */
uint32_t ciaddr; /* client IP (if client is in BOUND, RENEW or REBINDING state) */
uint32_t yiaddr; /* 'your' (client) IP address */
/* IP address of next server to use in bootstrap, returned in DHCPOFFER, DHCPACK by server */
uint32_t siaddr_nip;
uint32_t gateway_nip; /* relay agent IP address */
uint8_t chaddr[16]; /* link-layer client hardware address (MAC) */
uint8_t sname[64]; /* server host name (ASCIZ) */
uint8_t file[128]; /* boot file name (ASCIZ) */
uint32_t cookie; /* fixed first four option bytes (99,130,83,99 dec) */
uint8_t options[DHCP_OPTIONS_BUFSIZE + CONFIG_UDHCPC_SLACK_FOR_BUGGY_SERVERS];
} PACKED;
```
* **Держи однотипные и зависимые друг от друга вещи поблизости.**
Листинг выше частично вошел сюда, т.к. подходит для еще одного примера.
Посмотрите: описание упакованных структур идет перед перечислением, отражающим размеры этих структур.
*(файл networking/udhcp/common.h)*
```
struct dhcp_packet {
uint8_t op; /* BOOTREQUEST or BOOTREPLY */
uint8_t htype; /* hardware address type. 1 = 10mb ethernet */
uint8_t hlen; /* hardware address length */
uint8_t hops; /* used by relay agents only */
uint32_t xid; /* unique id */
uint16_t secs; /* elapsed since client began acquisition/renewal */
uint16_t flags; /* only one flag so far: */
#define BROADCAST_FLAG 0x8000 /* "I need broadcast replies" */
uint32_t ciaddr; /* client IP (if client is in BOUND, RENEW or REBINDING state) */
uint32_t yiaddr; /* 'your' (client) IP address */
/* IP address of next server to use in bootstrap, returned in DHCPOFFER, DHCPACK by server */
uint32_t siaddr_nip;
uint32_t gateway_nip; /* relay agent IP address */
uint8_t chaddr[16]; /* link-layer client hardware address (MAC) */
uint8_t sname[64]; /* server host name (ASCIZ) */
uint8_t file[128]; /* boot file name (ASCIZ) */
uint32_t cookie; /* fixed first four option bytes (99,130,83,99 dec) */
uint8_t options[DHCP_OPTIONS_BUFSIZE + CONFIG_UDHCPC_SLACK_FOR_BUGGY_SERVERS];
} PACKED;
#define DHCP_PKT_SNAME_LEN 64
#define DHCP_PKT_FILE_LEN 128
#define DHCP_PKT_SNAME_LEN_STR "64"
#define DHCP_PKT_FILE_LEN_STR "128"
struct ip_udp_dhcp_packet {
struct iphdr ip;
struct udphdr udp;
struct dhcp_packet data;
} PACKED;
struct udp_dhcp_packet {
struct udphdr udp;
struct dhcp_packet data;
} PACKED;
enum {
IP_UDP_DHCP_SIZE = sizeof(struct ip_udp_dhcp_packet) - CONFIG_UDHCPC_SLACK_FOR_BUGGY_SERVERS,
UDP_DHCP_SIZE = sizeof(struct udp_dhcp_packet) - CONFIG_UDHCPC_SLACK_FOR_BUGGY_SERVERS,
DHCP_SIZE = sizeof(struct dhcp_packet) - CONFIG_UDHCPC_SLACK_FOR_BUGGY_SERVERS,
};
```
Если в этом же файле мы спустимся чуть пониже, то увидим, что объявления функций работы с опциями так же находятся в одном месте:
*(файл networking/udhcp/common.h)*
```
unsigned FAST_FUNC udhcp_option_idx(const char *name);
uint8_t *udhcp_get_option(struct dhcp_packet *packet, int code) FAST_FUNC;
int udhcp_end_option(uint8_t *optionptr) FAST_FUNC;
void udhcp_add_binary_option(struct dhcp_packet *packet, uint8_t *addopt) FAST_FUNC;
void udhcp_add_simple_option(struct dhcp_packet *packet, uint8_t code, uint32_t data) FAST_FUNC;
#if ENABLE_FEATURE_UDHCP_RFC3397
char *dname_dec(const uint8_t *cstr, int clen, const char *pre) FAST_FUNC;
uint8_t *dname_enc(const uint8_t *cstr, int clen, const char *src, int *retlen) FAST_FUNC;
#endif
struct option_set *udhcp_find_option(struct option_set *opt_list, uint8_t code) FAST_FUNC;
```
* **Не убирай безвозвратно неиспользуемый по умолчанию функционал**
В udhcpc есть огромное количество опций, которые по умолчанию не используются. Каждая опция соответствует макросу, который закрывает ее номер.
Если бы они были раскомментированы — то это были бы макросы, которые не всплывают нигде в коде. Человек, который спросил бы «а зачем все эти опции?» искал бы ответ очень долго. И не нашел бы.
Как итог — у нас получилось подобие интерфейса, где комментарием закрыты те опции, методы для которых еще не реализованы.
*(файл networking/udhcp/common.h)*
```
#define DHCP_PADDING 0x00
#define DHCP_SUBNET 0x01
//#define DHCP_TIME_OFFSET 0x02 /* (localtime - UTC_time) in seconds. signed */
//#define DHCP_ROUTER 0x03
//#define DHCP_TIME_SERVER 0x04 /* RFC 868 time server (32-bit, 0 = 1.1.1900) */
//#define DHCP_NAME_SERVER 0x05 /* IEN 116 _really_ ancient kind of NS */
//#define DHCP_DNS_SERVER 0x06
//#define DHCP_LOG_SERVER 0x07 /* port 704 UDP log (not syslog)
//#define DHCP_COOKIE_SERVER 0x08 /* "quote of the day" server */
//#define DHCP_LPR_SERVER 0x09
#define DHCP_HOST_NAME 0x0c /* either client informs server or server gives name to client */
//#define DHCP_BOOT_SIZE 0x0d
//#define DHCP_DOMAIN_NAME 0x0f /* server gives domain suffix */
//#define DHCP_SWAP_SERVER 0x10
//#define DHCP_ROOT_PATH 0x11
//#define DHCP_IP_TTL 0x17
//#define DHCP_MTU 0x1a
//#define DHCP_BROADCAST 0x1c
//#define DHCP_ROUTES 0x21
//#define DHCP_NIS_DOMAIN 0x28
//#define DHCP_NIS_SERVER 0x29
//#define DHCP_NTP_SERVER 0x2a
//#define DHCP_WINS_SERVER 0x2c
#define DHCP_REQUESTED_IP 0x32 /* sent by client if specific IP is wanted */
#define DHCP_LEASE_TIME 0x33
#define DHCP_OPTION_OVERLOAD 0x34
#define DHCP_MESSAGE_TYPE 0x35
#define DHCP_SERVER_ID 0x36 /* by default server's IP */
#define DHCP_PARAM_REQ 0x37 /* list of options client wants */
//#define DHCP_ERR_MESSAGE 0x38 /* error message when sending NAK etc */
#define DHCP_MAX_SIZE 0x39
#define DHCP_VENDOR 0x3c /* client's vendor (a string) */
#define DHCP_CLIENT_ID 0x3d /* by default client's MAC addr, but may be arbitrarily long */
//#define DHCP_TFTP_SERVER_NAME 0x42 /* same as 'sname' field */
//#define DHCP_BOOT_FILE 0x43 /* same as 'file' field */
//#define DHCP_USER_CLASS 0x4d /* RFC 3004. set of LASCII strings. "I am a printer" etc */
#define DHCP_FQDN 0x51 /* client asks to update DNS to map its FQDN to its new IP */
//#define DHCP_DOMAIN_SEARCH 0x77 /* RFC 3397. set of ASCIZ string, DNS-style compressed */
//#define DHCP_SIP_SERVERS 0x78 /* RFC 3361. flag byte, then: 0: domain names, 1: IP addrs */
//#define DHCP_STATIC_ROUTES 0x79 /* RFC 3442. (mask,ip,router) tuples */
#define DHCP_VLAN_ID 0x84 /* 802.1P VLAN ID */
#define DHCP_VLAN_PRIORITY 0x85 /* 802.1Q VLAN priority */
//#define DHCP_MS_STATIC_ROUTES 0xf9 /* Microsoft's pre-RFC 3442 code for 0x79? */
//#define DHCP_WPAD 0xfc /* MSIE's Web Proxy Autodiscovery Protocol */
#define DHCP_END 0xff
```
* **Инкапсулируй подобные функции в зависимости от предназначения.**
Довольно сложный для восприятия аспект, требующий пояснения. В двух словах: если у вас есть функция, которая внутри проекта вызывается с n комбинациями различных параметров (где n — небольшое число), причем каждая комбинация вызывается по нескольку раз, имеет смысл сделать для каждой комбинации отдельную функцию, вызывающую внутри себя целевую функцию, но уже с нужными параметрами. Например. У нас есть функция, отправляющая пакеты на определенный порт и адрес:
*(файл networking/udhcp/packet.c)*
```
/* Construct a ip/udp header for a packet, send packet */
int FAST_FUNC udhcp_send_raw_packet(struct dhcp_packet *dhcp_pkt,
uint32_t source_nip, int source_port,
uint32_t dest_nip, int dest_port, const uint8_t *dest_arp,
int ifindex)
{
struct sockaddr_ll dest_sll;
struct ip_udp_dhcp_packet packet;
unsigned padding;
int fd;
int result = -1;
const char *msg;
fd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));
if (fd < 0) {
msg = "socket(%s)";
goto ret_msg;
}
memset(&dest_sll, 0, sizeof(dest_sll));
memset(&packet, 0, offsetof(struct ip_udp_dhcp_packet, data));
packet.data = *dhcp_pkt; /* struct copy */
dest_sll.sll_family = AF_PACKET;
dest_sll.sll_protocol = htons(ETH_P_IP);
dest_sll.sll_ifindex = ifindex;
dest_sll.sll_halen = 6;
memcpy(dest_sll.sll_addr, dest_arp, 6);
if (bind(fd, (struct sockaddr *)&dest_sll, sizeof(dest_sll)) < 0) {
msg = "bind(%s)";
goto ret_close;
}
/* We were sending full-sized DHCP packets (zero padded),
* but some badly configured servers were seen dropping them.
* Apparently they drop all DHCP packets >576 *ethernet* octets big,
* whereas they may only drop packets >576 *IP* octets big
* (which for typical Ethernet II means 590 octets: 6+6+2 + 576).
*
* In order to work with those buggy servers,
* we truncate packets after end option byte.
*/
padding = DHCP_OPTIONS_BUFSIZE - 1 - udhcp_end_option(packet.data.options);
packet.ip.protocol = IPPROTO_UDP;
packet.ip.saddr = source_nip;
packet.ip.daddr = dest_nip;
packet.udp.source = htons(source_port);
packet.udp.dest = htons(dest_port);
/* size, excluding IP header: */
packet.udp.len = htons(UDP_DHCP_SIZE - padding);
/* for UDP checksumming, ip.len is set to UDP packet len */
packet.ip.tot_len = packet.udp.len;
packet.udp.check = inet_cksum((uint16_t *)&packet,
IP_UDP_DHCP_SIZE - padding);
/* but for sending, it is set to IP packet len */
packet.ip.tot_len = htons(IP_UDP_DHCP_SIZE - padding);
packet.ip.ihl = sizeof(packet.ip) >> 2;
packet.ip.version = IPVERSION;
packet.ip.ttl = IPDEFTTL;
packet.ip.check = inet_cksum((uint16_t *)&packet.ip, sizeof(packet.ip));
udhcp_dump_packet(dhcp_pkt);
result = sendto(fd, &packet, IP_UDP_DHCP_SIZE - padding, /*flags:*/ 0,
(struct sockaddr *) &dest_sll, sizeof(dest_sll));
msg = "sendto";
ret_close:
close(fd);
if (result < 0) {
ret_msg:
bb_perror_msg(msg, "PACKET");
}
return result;
}
```
Но dhcp не всегда нуждается в отправке пакета на один IP адрес. В основном используется широковещательная (BROADCAST) рассылка.
Но широковещательная отправка пакета — всего лишь отправка пакета по адресу, зарезервированному под broadcast. Собственно, для того, чтоб отправить широковещательный запрос, достаточно использовать описанную выше функцию, но в качестве адреса указать тот, что зарезервирован про бродкаст. Отсюда получаем функцию:
*(файл networking/udhcp/dhcpc.c)*
```
static int raw_bcast_from_client_config_ifindex(struct dhcp_packet *packet)
{
return udhcp_send_raw_packet(packet,
/*src*/ INADDR_ANY, CLIENT_PORT,
/*dst*/ INADDR_BROADCAST, SERVER_PORT, MAC_BCAST_ADDR,
client_config.ifindex);
}
```
Профит этого в том, что везде, где мы будем встречать эту функцию, можно будет по названию понять, что она делает. Если бы мы использовали функцию udhcp\_send\_raw\_packet, то нам бы осталось только гадать по параметрам.
Заключение
----------
---
Пиши код так, чтобы те, кто будет его сопровождать любили тебя, а не ненавидели. Сложная гибкая реализация гораздо лучше простого костыля.
Описывай интерфейсы доступа, комментируй проблемные моменты. Не делай констант, от изменения которых придется переписывать весь код. Не допускай утечек памяти. Следи за безопасностью и отказоустойчивостью кода.
***Пиши на Си как джентльмен.***
Удачи, Хабр! | https://habr.com/ru/post/325678/ | null | ru | null |
# Всё и сразу: автоматическая проверка размера бандла
Привет всем, меня зовут Илья. В ИТ я работаю около 6 лет, последние 2 года — в компании «Яндекс.Деньги» фронтенд-разработчиком. В обязанности входит поддерживать/развивать части приложений, в данный момент проект «Личный кабинет» (и нет, это не просто «в ие неправильные отступы поправить», «кнопке цвет поменять» или «быстро форму сошлепать»).
В отделе разработки у нас есть внутренний проект Challenges — так мы называем задачи, не связанные напрямую с основными продуктами. Это задачки, которые будут общественно полезны, помогут улучшить инфраструктуру, CI/CD и другое. Например, доработать бота, оповещающего о релизах, сделать плагин для IDEA по автогенерации assert по объекту и провести рефакторинг старой UI-библиотеки. Такие «вызовы» можно брать по желанию — они прекрасно подходят для разбавления бизнес-задач.
В один прекрасный момент я взял давно интересующую меня задачку по реализации автоматической проверки размера клиентского бандла приложения. Ведь всё, что можно проверять автоматически, лучше проверять автоматически.
Естественно, итогом стала не просто конкретная реализованная задача, а библиотека с правилами и общими функциями (ядро/core) для реализации любых чекеров (я надеюсь). В процессе решения задачки были набиты шишки, о которых тоже хочется рассказать.
Итак, есть Jenkins, Bitbucket, почта (или Telegram, Slack — что понадобится) и необходимость проверять размер бандла. Надо это всё подружить.
В Bitbucket для каждого pull request есть 2 автоматические проверки, без которых невозможен merge: задача в Jira переведена в статус «Проверена», и все автоматические проверки в Jenkins запущены и завершены успешно. Дальше по настроенному в Bitbucket хуку в Jenkins приходят оповещения об изменении ветки, для которой запускается вся пачка проверок. Джоба с проверкой (commit\_checker) имеет множество pipeline:
* запуск lint-скрипта;
* запуск тестов;
* проверка версии пакета — для библиотек важно, чтобы в новом pull request была повышена версия, так как после merge автоматически будет запущен build и publish в Nexus, локальный npm;
* проверка отсутствия пререлизных версий библиотек в package.json.
Когда всё завершается, по хуку Bitbucket информирует об успешном или не очень успешном завершении commit\_checker. В случае ошибок также приходит письмо с пояснениями, что нужно поправить, или ссылкой на лог. В этой challenge-задаче мне нужно было расширить commit\_checker и добавить ещё один pipeline для проверки размера бандла.
Так как лучше подойти к организации кода checker-ов для фронтенд-приложений?
Что хотим получить (сбор cведений)
==================================
Всё началось со сбора полных требований и хотелок от разработчиков. Я узнал, что в результате хочется видеть инфу о размере бандла (какая неожиданность) — сколько драгоценных байтов принёс к бандлу конкретный pull request. Точнее, видеть оповещение, если увеличение подозрительно большое. Например, обычная фронтовая ситуация: тянем новую, классную, супермодную либу, чтобы сложить два числа, которая весит 3 Мб. Также хорошо будет знать, не выходит ли общий размер продовского бандла за пределы разумного максимума (то есть получать оповещение с ругательствами). Ну и, конечно, блокировать merge до починки.
После этого я собрал информацию о текущем состоянии. Посоветовавшись с коллегами, выбрали итоговые размеры, к которым стремимся: для всех есть общее правило в 600 Кб (это, безусловно, огромный бандл, но с чего-то начинать надо).
Теперь появилась цель — сервис, который шлёт оповещения, если в pull request подозрительно увеличился размер бандла, либо блокирует merge и шлёт оповещения, если превышено максимальное значение. Всё просто.
О, а там вроде чекеры были...
=============================
Надо было понять, как это всё лучше запилить. Следовало поискать подходы и реализации, как добавляются новые проверки, через какой API шлются оповещения (письма в почте, Telegram). Мне посоветовали пару существующих библиотек, и я начал копаться в них.
Здесь есть несколько важных моментов. Мы используем Jenkins для запуска проверок и job с деплоем на тестовую схему или началом релиза (каждый микросервис имеет свой набор данных для job). Есть groove-скрипты для получения части информации и выполнения определенной проверки, а есть npm-пакеты с логикой проверки, и в groove просто запускается bin пакета. Джоба дженкинса либо успешно, либо не очень завершается — срабатывают хуки, и Bitbucket понимает, можно ли совершить merge или нет.
Значит, надо понять, где лучше реализовывать логику проверки: в groove-скриптах или на node в новом пакете — размазывать дальше это волшебство не хочется.
Выбор тёмной стороны
====================
Что же лучше: Groove или Node?
| | Плюсы | Минусы |
| --- | --- | --- |
| Groove | Другой язык и технологии — здесь я имею в виду мотивацию для людей, которые хотят изучать что-то новое. | 1. Хуже поддержка: так как писать в основном будут фронты, то знакомы они лучше с JS, поэтому и понимать/поддерживать/писать код будет лучше на JS, нежели на Groove.
2. Долгий старт. |
| Node | 1. Быстрый старт: не нужно специальных знаний и навыков, так как у нас все фронты работают с Node.
2. Выше качество кода, проще понимать/поддерживать.
3. Существующие известные решения для работы с письмами/Jira API/Bitbucket API.
4. Специализированные пакеты с различными проверками фронт-приложений, например, [size-limit](https://www.npmjs.com/package/size-limit). | 1. Нужна Node, так как из коробки у Jenkins её нет.
2. Для взаимодействия с API Jenkins необходимы дополнительные библиотеки/скрипты. |
Исходя из этого, решил писать чекер на Node.
«Хьюстон, у нас проблемы», или почему переписал код 3 раза
==========================================================
После изучения существующих библиотек, я отметил хорошие практики и сделал новую библиотеку. После реализации я увидел общую логику (отправка писем, поиск задач по Jira), которая в каждом чекере создавалась заново копипастой. Значит, нужна общая либа.
**Первая попытка**
Так появилось ядро, checker-core. Модуль собрал в себе всю общую логику, документацию о том, как создавать новые чекеры.
Теперь настала очередь логики проверки размера бандла. Первая идея — проверять в лоб: собирать прод-бандл, смотреть в папки/файлы, указанные как dist, и проверять их вес, сравнивать с максимальным. На паре приложений отдебажил мелкие ошибки — работает.
Следующая часть — проверка единовременного увеличения от pull request.
Первый вопрос — где хранить предыдущий размер бандла? Варианты такие:
* Собирать сначала ветку dev/master (рабочая версия), потом собирать новую фича-ветку и их сравнивать. Проблема — будет очень долго.
* Хранить во внешнем сервисе эти данные и запрашивать/сохранять во время проверок. Проблема — сейчас это долго и сложно, должен быть путь проще.
* Использовать Git и сохранять данные, например, в package.json, затем получать по API Bitbucket информацию из ветки dev/master и сравнивать с данными, полученными во время проверки. Отлично, подходит.
Второй вопрос — а когда сохранять новый размер?
Можно, конечно, в прекоммите, но люди его могут и пропустить — это ненадёжно. Самый надёжный способ — во время проверки. Мне показалось, что это просто, поэтому я так и сделал.
Теперь чекер умеет собирать приложение, определять размер бандла, сверять с максимальным и предыдущим и обновлять в BitBucket (в пул реквест приедет комит от Jenkins с обновлённым package.json). И тут я его запустил…
Я думал, что всё идёт хорошо, но почти тут же повалились письма с темой: «Алярм!», и, естественно, всё пошло не так, и раскалённый стул доставил меня почти до Марса.
Что же произошло?
Первая проблема. Приложения-то проверялись, а вот библиотеки проверять не нужно было: их у нас много, а в серверных библиотеках и бандла-то нет.
Вторая проблема. В моём гениальном плане по отправке коммита с новым размером было одно упущение: хук, который запускает проверки для ветки, срабатывает после отправки нового коммита в битбакет… Увидев все оповещения в почте и вопросы людей в общих чатах: «А что с Jenkins? Что-то он виснет», — я понял, что положил всем Jenkins (но быстро всё починил). Сделал коммит -> запустил проверку -> проверка сделала комит -> и всё заново.
И третья, последняя проблема. Все наши приложения имеют несколько подприложений, иными словами, есть несколько бандлов под разные группы страниц (группировка, уменьшение размера бандла). Так вот, я считал размер всех бандлов вместе.
**Вторая попытка**
Теперь надо убрать проверку для библиотек (изи, просто не запущу для них) и разницы размера бандла с девом и доработать проверку максимального размера.
Мне рассказали о модуле size-limit: он делает то, что мне надо, и я могу использовать информацию по всем отдельным бандлам для сравнения.
Переписываю. Отлично, проверяю… Всё заработало!
Теперь можно собрать всю информацию, установить максимумы и составить roadmap для уменьшения размеров бандлов.
**Третья попытка**
Пока наводил красоту в коде чекеров, я увидел, что size-limit обновился и там появились новые фичи, — круто, можно и обновить. Но, к сожалению, в нём ушло API взаимодействия из кода, и осталась только CLI. Оукей. Тогда придётся запускать cli-команды и обрабатывать их результат. Это и стало третьим переписыванием.
Теперь, наконец-то, можно запускать, тестировать и собирать фидбэк, чтобы улучшить взаимодействие.
Реализация кода: что получилось
===============================
**Checker-core**
Он имеет нехитрую структуру и документацию!
```
/src — всё содержимое чекера
|__ /tasks — обособленные и переиспользуемые при необходимости действия; например, получение метаинформации, отправка нотификации, могут использовать утилиты, выбрасывать исключения. Нужны для выполнения какой-то `job`.
|__ /models — модели, используемые в чекере; здесь происходит расширение моделей из `core`. Сущность, агрегирующая в себе информацию об объекте, например, npm-модуль. Регистрируется одна на `job`, все `tasks` используют инстанс модели, созданной в `job,` и мутируют его. Иначе говоря, это агрегатор данных по описываемой сущности для переиспользования между `tasks` и внутри `job`.
|__ /types — общие типы.
|__ /utils — вспомогательные утилиты (например, логгер, фильтрация версий пакетов (npm)).
|__ /errors — ошибки, которыми оперирует чекер.
|__ /enums — общие перечисления.
|__ /decorators — декораторы, используемые в `utils`, `tasks`, `job`.
|__ /declarations — определение модулей, не имеющих типов для Typescript.
```
### Модели
**Checker**
Модель Checker содержит основные методы, необходимые для чекера. Экземпляр этой модели используется для передачи данных между тасками и получения информации о приложении, зависимых либах, лиде и т.п.
**Module**
Модель Module используется для работы с конкретным сервисом/библиотекой, которая будет проверяться. Она может содержать специфичные проверки (сравнение бандла, сверка версий и т.п.).
### Таски
**get-issue-assignees**
Получение ответственных за последнюю вмерженную задачу. В модель Checker устанавливается информация о project, assignee, lead.
Examples
```
import {
Checker,
Logger,
IChecker,
JiraManagerSettings,
GetIssueAssignee
} from 'checker-core';
import {JiraSettings} from 'jira-manager';
import {IJobSettings} from '../types/IJobSettings';
export class ExampleJob {
readonly _checker: IChecker;
_jiraSettings: JiraManagerSettings;
constructor(settings: IJobSettings) {
if (settings === void 0) {
throw new Error('Has no Checker settings');
}
this._checker = new Checker(settings.checker);
this._jiraSettings = new JiraSettings(settings.jira);
Logger.info('-- ExampleJob:');
Logger.info(this._checker.appName);
}
start() {
const getIssueAssignee = new GetIssueAssignee();
return getIssueAssignee.run(this._checker, this._jiraSettings);
}
}
```
**get-last-merged-issue**
Получение последней вмерженной задачи. В модель Checker устанавливается информация о последней вмерженной задаче.
Examples
```
import {Checker, Logger, IChecker, GetLastMergedIssue} from 'checker-core';
import {IJobSettings} from '../types/IJobSettings';
export class ExampleJob {
readonly _checker: IChecker;
constructor(settings: IJobSettings) {
if (settings === void 0) {
throw new Error('Has no Checker settings');
}
this._checker = new Checker(settings);
Logger.info('-- ExampleJob:');
Logger.info(this._checker.appName);
}
start() {
const getLastMergedIssue = new GetLastMergedIssue();
return getLastMergedIssue.run(this._checker);
}
}
```
**get-last-commit-issue**
Получение последней закоммиченной задачи. В модель Checker устанавливается информация о последней закоммиченной задаче.
Examples
```
import {Checker, Logger, IChecker, GetLastCommitIssue} from 'checker-core';
import {IJobSettings} from '../types/IJobSettings';
export class ExampleJob {
readonly _checker: IChecker;
constructor(settings: IJobSettings) {
if (settings === void 0) {
throw new Error('Has no Checker settings');
}
this._checker = new Checker(settings);
Logger.info('-- ExampleJob:');
Logger.info(this._checker.appName);
}
start() {
const getLastCommitIssue = new GetLastCommitIssue();
return getLastCommitIssue.run(this._checker);
}
}
```
**send-notification и send-smtp-notification**
Посылка уведомлений на почту. Посылает переданный контент письма ответственному за последнюю задачу и на общую рассылку.
Разница между send-notification и send-smtp-notification — в способе отправки. Для smtp-письма нужно передать параметры по интерфейсу IMailTransportSettings.
Examples
```
import {
Checker,
Logger,
IChecker,
IMailTransportSettings,
IMailContent,
SendSmtpNotification
} from 'checker-core';
import {IJobSettings} from '../types/IJobSettings';
export class ExampleJob {
readonly _checker: IChecker;
_emailSettings: IMailTransportSettings;
constructor(settings: IJobSettings) {
if (settings === void 0) {
throw new Error('Has no Checker settings');
}
this._checker = new Checker(settings.checker);
this._emailSettings = settings.email;
Logger.info('-- ExampleJob:');
Logger.info(this._checker.appName);
}
start() {
const sendSmtpNotification = new SendSmtpNotification();
const mailContent: IMailContent = {
subject: 'Долг',
content: 'Где деньги, Лебовски?'
};
return sendSmtpNotification.run(this._checker, mailContent, this._emailSettings);
}
}
```
### Типы
Содержит основные используемые типы: объекты для передачи настроек, интерфейсы моделей и утилит.
### Утилиты
**Logger**
Утилита для логирования.
**Npm**
Утилита для получения данных из Nexus.
**mailTransport**
Утилита для выбора способа отправки письма (нативно через mail linux или через модуль nodemailer по smtp).
### Decorators
**logAsyncMethod**
Декоратор для метода класса, используется для логирования входящих параметров и результата выполнения метода в режиме дебага.
Если process.env.IS\_DEBUG\_MODE включен, производит логирование.
**validate**
Декоратор для валидации параметров метода. Подробные примеры можно посмотреть в тестах для декораторов.
```
Examples
import {
notNullProp, validate, required,
validInfo, notNull, requiredProp
} from 'checker-core';
class TestSum {
@validate
static sum(
@required
@notNull
@requiredProp(['a'])
@notNullProp(['a'])
@validInfo('a', Object)
a: Object,
@required
@notNull
@requiredProp(['b'])
@notNullProp(['b'])
@validInfo('b', Object)
b: Object
) {
return a.a + b.b;
}
}
```
### Errors
**MissingRequiredArgument**
Ошибки при валидации обязательного аргумента метода.
**MissingRequiredProperty**
Ошибки при валидации обязательного свойства в объекте, переданном в метод.
**NullArgument**
Ошибки при валидации аргумента метода, если он null.
**NullProperty**
Ошибки при валидации свойства в объекте, переданном в метод, если он null.
**TypeMismatch**
Ошибки при валидации аргумента на несоответствие типов с переданным.
### bundle-size-checker
Структура для конкретных чекеров описана в доке checker-core и очень похожа на core, появляется несколько новых сущностей:
```
/src — всё содержимое чекера
|__ /bin — исполняемые файлы, CLI чекера для запуска из консоли, выполняют 2 основные функции: подготавливают данные из аргументов запуска команды и запускают одну или несколько `job`. Также содержат логику результирующего действия на выполнение всей проверки, например, выход с сигналом 1 `process.exit(1)`;
|__ /jobs — класс, в котором инициализируются все необходимые модели (`checker` + те, что будут нужны), содержит логику выполнения конкретного действия необходимого для проверки. Могут использовать одну или несколько `task`, `utils`, также могут выбрасывать исключения;
|__ /tasks — обособленные и переиспользуемые при необходимости действия; например, получение метаинформации, отправка нотификации, могут использовать утилиты, выбрасывать исключения. Нужны для выполнения какой-то `job`;
|__ /models — модели, используемые в чекере, здесь происходит расширение моделей из `core`. Сущность, агрегирующая в себе информацию об объекте, например, npm-модуль. Регистрируется одна на `job`, все `tasks` используют инстанс модели, созданной в `job`, и мутируют его. Иначе говоря, это агрегатор данных по описываемой сущности для переиспользования между `tasks` и внутри `job`;
|__ /types — общие типы;
|__ /utils — вспомогательные утилиты (например, логгер, фильтрация версий пектов (npm));
|__ /errors — ошибки, которыми оперирует чекер;
|__ /enums — общие перечисления;
|__ /decorators — декораторы используемые в `utils`, `tasks`, `job`;
|__ /declarations — определение модулей, не имеющих типов для Typescript.
```
По сути, job — это класс, который получает все настройки, создает экземпляр checker-модели, запускает таски, переиспользуя их результат, а в конце, если упало с какой-то ошибкой, запускает таску, которая решает, как реагировать на ошибку (какое письмо послать, зафейлить чекер и т.п.).
Например:
```
import path from 'path';
import {JiraSettings} from 'jira-manager';
import {
Logger,
JiraManagerSettings,
IMailTransportSettings,
MissingRequiredProperty
} from 'checker-core';
import {Module} from '../models/module';
import {CompareBundleSize} from '../tasks/compare-bundle-size';
import {Checker} from '../models';
import {IJobCheckBundleSizeSettings} from '../types/IJobCheckBundleSizeSettings';
import {IModule} from '../types/IModule';
import {IModuleSettings} from '../types/IModuleSettings';
import {GetMetaInfo} from '../tasks/get-meta-info';
import {CheckBundleSizeNotEmpty} from '../tasks/check-bundle-size-not-empty';
import {GetBundleSize} from '../tasks/get-bundle-size';
import {ReadFileError} from '../errors/ReadFileError';
import {IPackageJson} from '../types/IPackageJson';
import {IChecker} from '../types/IChecker';
import {FilterException} from '../tasks/filter-exception';
// Описывает логику проверки размера бандла модуля.
export class CheckBundleSize {
readonly _checker: IChecker;
readonly _jobName = 'CheckBundleSize';
_moduleSettings: IModuleSettings;
_checkerModule: IModule;
_jiraSettings: JiraManagerSettings;
_emailSettings: IMailTransportSettings;
constructor(settings: IJobCheckBundleSizeSettings) {
if (settings.checker === void 0) {
throw new MissingRequiredProperty(this._jobName, 'constructor', 'settings', 'checker');
}
this._moduleSettings = settings.module;
this._emailSettings = settings.emailSettings;
this._jiraSettings = new JiraSettings(settings.jira);
this._checker = new Checker(settings.checker);
try {
const packageJsonPath = path.resolve(this._checker.rootPath, 'package.json');
const packageJson: IPackageJson = require(packageJsonPath);
this._checkerModule = new Module(
packageJson,
this._moduleSettings.maxBundleSize,
this._moduleSettings.needCheckBundleSize
);
} catch (err) {
Logger.info('Can nott load package.json');
throw new ReadFileError(this._jobName, 'package.json');
}
Logger.info(`${this._jobName}:`);
Logger.info(this._checker.appName);
}
// Выполняет проверку размера бандла модуля
async start() {
try {
const getBundleSizeTask = new GetBundleSize();
const getMetaInfo = new GetMetaInfo();
const checkBundleSizeEmpty = new CheckBundleSizeNotEmpty();
const compareBundleSize = new CompareBundleSize();
const getBundleSize = await getBundleSizeTask.run(this._checker, this._checkerModule);
if (!getBundleSize) {
return;
}
await getMetaInfo.run(this._checker, this._jiraSettings);
await checkBundleSizeEmpty.run(this._checker, this._checkerModule);
await compareBundleSize.run(this._checker, this._checkerModule);
} catch (err) {
const filterException = new FilterException(this._emailSettings);
await filterException.run(this._checker v , this._checkerModule, err);
throw err;
}
}
}
```
Эта джоба запускается в bin реализацию, которая отвечает за получение параметров из аргументов cli и передачу объекта с настройками в джобу.
```
…
const checkBundleSize = new CheckBundleSize(settings);
checkBundleSize.start()
.then(() => {
process.exit(0);
})
.catch((err: Error) => {
console.error(err);
console.error(`Can fail build: ${canFailBuild}`);
if (canFailBuild) {
process.exit(1);
} else {
process.exit(0);
}
});
```
Итого
=====
Было очень круто и полезно погрузиться в весь процесс сборки/проверки приложений, понять и разобраться в местах, где недоставало понимания (ну, и поломать дженкинсы, гы). Приведение в порядок, унификация правил и документаций сами по себе принесли довольно много пользы: стало проще разобраться с существующим кодом, написать новый, плюс сделать лучше отрефакторенный код. Отзывы коллег и некоторые мои идеи помогли составить roadmap для улучшения и доработок. Фактически теперь добавление автопроверок стало простым и быстрым, обновление и доработки — тоже.
Уже несколько раз проверка размера бандла принесла свои плоды, когда неожиданный минор библиотеки вдруг принёс кучу картинок или поломал сборку.
Сначала эта проблема казалась мне точечной. И сейчас хочется спросить: сталкивались ли вы с такой же проблемой у себя? Если будет спрос, то готов вынести свое решение в open source. | https://habr.com/ru/post/488754/ | null | ru | null |
# Cloud9 и OpenShift. Разработка и развертывание приложений в облаках
Так уж получилось, что сейчас я стажируюсь в одной компании, где очень тяжело выбить простую программку себе на десктоп, а тем более IDE, порой это даже превращается в целые недельные квесты. Но в то же время, в свободное от работы время, я очень люблю экспериментировать. Почитав статью про [онлайн IDE](http://habrahabr.ru/post/127567/) и имея аккаунт в OpenShift решил все таки попробовать создать и развернуть Yii приложение в облаках.
Сразу оговорюсь, что статья для начинающих. Кому интересно заходите!
**Связываем [Cloud9 IDE](https://c9.io/) и [OpenShift](https://openshift.redhat.com/app/).**
В качестве IDE я решил остановиться на Cloud9, дизайн и [функциональность](https://c9.io/site/features/) меня устраивает. Плюс то, что можно запускать приложение прямо в IDE, минус — не поддерживается хостинг баз данных, поэтому попробуем организовать доступ к базе данных, которую мы создадим в OpenShift.
Да и еще, мне улыбнулся Cloud9 из-за присутствии терминала (Alt+T), пускай хоть и ограниченного.
**Шаг 0.** Создаем аккаунты, если их у Вас еще нет.
Лично я использую бесплатные возможности.
Для Cloud9 это публичные рабочие среды по 128MB + 1 одна приватная + ограниченный терминал.
Для OpenShift это 3 small картриджа, каждый по 512MB RAM и 1GB disk. Картриджи это компоненты, которые можно добавить в приложение, такие как базы данных (MySQL, PosgreSQL и MondoDB) и инструменты администрирования (phpMyAdmin, RockMongo, Cron и т.п.).
Для маленьких экспериментов вполне достойно.
**Шаг 1.** Добавляем в OpenShift SSH ключ из Cloud9
SSH ключи, как известно, используются для безопасного соединения, вот хорошие статьи
В Cloud9 ключ можно найти в пункте Show SSH key в Your Account.
Копируем его и вставляем данный ключ в OpenShift, для этого в Your Account есть Public Keys
**Шаг 2.** Создаем рабочую среду в Cloud9 и добавляем приложение в OpenShift
Здесь все просто, главное — при создании приложения в Cloud9 выбрать git версию рабочей среды. Дальше git будет нашим верным помощником.
В OpenShift легким движением мыши создаем приложение с PHP 5.3.
**Шаг 3.** Добавляем git репозиторий приложения из OpenShift в рабочую среду Cloud9
После создания приложения в OpenShift можно увидеть его git репозиторий.
Для линковки данного репозитория к рабочей среде в Cloud9 используем следующие команды:
```
git remote add openshift -m master ssh://******.git/
git pull -s recursive -X theirs openshift master
```
**Шаг 4.** Подгружаем Yii в рабочей среде Cloud9 и создаем каркас приложения yii
Для загрузки yii фреймоврка в приложение используем его git репозиторий, добавив его как подмодуль:
```
git submodule add git://github.com/yiisoft/yii.git yii
git commit -m "added yii repository as submodule"
```
В репозитории подгрузим нужный нам релиз:
```
cd yii
git checkout 1.1.13
cd ..
git add yii
git commit -m "Use yii v1.1.13"
```
Теперь создадим каркас приложения yii. Для этого обычно используется скрипт webapp, но запустить его просто как shell не получится. Вместо этого будем использовать php версию скрипта, и да, нам понадобиться глобальный путь до нашей папки.
Выполним следующую команду и получим глобальный путь:
```
pwd
```
Имеем примерно следующее:
Теперь выполним скрипт с этим путем для создания каркаса приложения:
```
php yii/framework/yiic.php webapp /var/lib/stickshift/ffa13067224647beb05863058997082a/app-root/data/354172/php git
```
Добавим все полученное:
```
git add php
git commit -m "created yii skeleton app"
```
Пробный запуск php/index.php из Cloud9 покажет нам предупреждение:
*date(): It is not safe to rely on the system's timezone settings.*
Решается это добавлением в php/protected/config/main.php следующего:
```
php
// uncomment the following to define a path alias
// Yii::setPathOfAlias('local','path/to/local-folder');
date_default_timezone_set( 'UTC' );</code
```
И не забываем commit:
```
git commit -a -m "set the default timezone to UTC"
```
Хочу отметить, что проблема существует только в Cloud9, в Openshift приложение запускается без каких-либо предупреждений.
**Шаг 5.** Создаем базу данных в OpenShift и настраиваем соединение
Конечно, можно обойтись базой данных sqlite, но ради собственного интереса настроим MySQL, добавим картридж на странице приложения.
**UPD1:** ~~Обязательно запишите выданный пароль перед завершением, т.к. после этого я так и не нашел способ восстановить или изменить пароль :(.~~ Как подсказывает [Urchr](http://habrahabr.ru/users/Urchr/) в [комментариях](http://habrahabr.ru/post/165303/#comment_5698561), логин и пароль хранятся в переменных окружения. Для их получения можно использовать терминал Cloud9 и [удаленно подключиться](https://openshift.redhat.com/community/developers/remote-access) к приложению через SSH. Логин используется стандартный — *admin*, а пароль берется из $OPENSHIFT\_MYSQL\_DB\_PASSWORD.
**UPD2:** Адрес и порт базы данных ~~я смог узнать, только поставив картридж phpMyAdmin~~ можно также получить через консоль в переменных окружения $OPENSHIFT\_MYSQL\_DB\_HOST и $OPENSHIFT\_MYSQL\_DB\_PORT.
Для административных целей также поставим картридж с phpMyAdmin.
В том же php/protected/config/main.php настраиваем соединение с MySQL.
**Вот и все!**
Теперь приложение готово для дальнейших действий. Все это можно сделать используя только браузер, везде где есть интернет.
Использовались следующие источники:
1. [Look Ma, No Hands! Developing for the Cloud, in the Cloud with Cloud9 IDE](https://openshift.redhat.com/community/blogs/look-ma-no-hands-developing-for-the-cloud-in-the-cloud-with-cloud9-ide)
2. [Create Yii Project In Cloud9](http://www.yiiframework.com/wiki/373/create-yii-project-in-cloud9/)
Надеюсь, что статья окажется полезной! | https://habr.com/ru/post/165303/ | null | ru | null |
# Пишем документацию для Ruby on Rails проектов с помощью YARD
Добрый день, хабражители! Обнаружил, что на сайте нет статьи о том, как можно организовать процесс создания документации для Ruby on Rails проектов. Исправим эту проблему.
В статье будет рассказано, как с помощью гема [YARD](http://yardoc.org/)можно написать грамотную документацию к рельс проектам и автоматически сгенерировать документ, где эта документация будет представлена в презентативном виде. Пример документации можно посмотреть в коде сайта [ВалиИзРашки](https://github.com/cbrwizard/rashka).
Для начала — немного теории. Кому-то это может показаться капитанством, но моя цель сейчас — убедить тех, кто не пишет документацию к коду, что это очень полезно и вовсе не тяжело. Под документацией, как правило, понимают комментарии к коду или отдельный документ, где опписан код сайта.
#### Теория: зачем писать документацию?
Отвечая просто: чтобы код был понятнее. Вашему коллеге по работе не нужно будет вас отвлекать и задавать тысячу вопросов, а вам не придется ломать себе голову, вспоминая хитросплетения своего же кода. В понятном коде легче найти и уничтожить баг. Также вам самим будет легче добавить в код новую фичу, которую только что внезапно придумал заказчик или дизайнер.
##### Но лучший комментарий — это тот, который не нужно писать?
Действительно нужно писать такой понятный код, чтобы объем необходимых для понимания комментариев к нему был минимальным. Это достигается путем использования переменных с понятными названиями, предсказуемой и модульной структуры кода и так далее. Я сам раньше старался писать код, не прибегая к комментариям. Но вскоре понял, что потратить две секунды на чтение комментария к коду выгоднее, чем потратить 5-10 на чтение и понимание даже самого понятного кода. Как ни крути, а нормальным языком передать суть кода можно гораздо проще и эффективнее.
##### Но писать документацию — это же очень долго!
Ничего подобного. По тому методу, который тут описан, на написание документации к коду, который вы только что написали, вы будете тратить, в среднем, минуту. Эта минута с лихвой окупится, как только вы вернетесь к коду в следующий раз.
Если хотите еще аргументов в плюс документации, можете прочитать другие статьи умных людей на эту тему, например, просмотрите [эту](http://warpspire.com/talks/documentation/) презентацию. А мы перейдем к практике.
#### Практика: структуризированные комментарии YARD
Сначала в своих Ruby on Rails проектах я писал комментарии без определенной структуры. Перед каждым методом вкратце писал, что там происходит. Потом понял, что было бы удобно описывать, например, параметры, который этот метод принимает; а также то, что он возвращает. Встал вопрос, почему бы везде не придерживаться единого шаблона комментариев?
Нашел гем [YARD](http://yardoc.org/). Суть его в том, что вы пишите комментарии к своему коду, используя определенный простой синтаксис, чем-то отдаленно напоминающий xml/html. После чего вы запускаете команду, которая создаст html файлы, где будет расписан ваш код и документация к нему в удобном формате. Аналогом выступает гем [RDOC](http://docs.seattlerb.org/rdoc/), но его синтаксис показался мне более сложным.
Установим гем
```
$ gem install yard
```
либо добавим в Gemfile
```
gem 'yard'
```
и запустим bundle install.
Возьмем примерный метод с сайта [valiizrashki.ru](http://valiizrashki.ru/)
```
def try_to_evacuate(country_id)
country = Country.find(country_id)
if country.allows_immigrants?
evacuate!
true
else
false
end
end
```
Метод определяет, можно ли иммигрировать в другую страну и эвакуируется. Так и запишем перед объявлением метода в виде комментария.
```
# Определяет, можно ли иммигрировать в другую страну и эвакуируется
def try_to_evacuate(country_id)
country = Country.find(country_id)
...
```
Метод вызывается при нажатии по кнопке «валить». Запишем это с помощью YARD тега `@note`, который отвечает за различные дополнительные данные. Синтаксис выглядит так:
```
@имя_тега (пробел) содержимое тега
```
Если мы хотим несколько строк уместить в один тег, то используем табуляцию
```
@имя_тега
первая строчка содержимого
вторая строчка содержимого
```
Запишем информацию о месте вызова с тегом `@note` в том же месте, перед объявлением метода:
```
# Определяет, можно ли иммигрировать в другую страну и эвакуируется
# @note Вызывается при нажатии по кнопке "Валить"
def try_to_evacuate(country_id)
...
```
Запишем, что параметр принимает параметр с помощью тега `@param`. В квадратных скобках пишется тип данных этого параметра, после них — описание параметра.
```
# @param country_id [Integer] id страны
```
Запишем, что конкретно возвращает этот метод с помощью тега `@return`. Тут мы в квадратных скобках пишем тип данных, которые нам будут возвращены, после них — описание значения.
```
# @return [Boolean] получилось ли эвакуироваться
```
Для наглядности запишем пример использования этого метода. Сделаем это с помощью тега `@example`, в данном случае используя табуляцию.
```
# @example
# try_to_evacuate(2)
```
Также оставим ссылку на документацию модели стран с помощью тега `@see`, чтобы можно было туда быстро перескочить.
```
# @see Country
```
Итог получился таким:
```
# Определяет, можно ли иммигрировать в другую страну и эвакуируется
# @param country_id [Integer] id страны
# @note Вызывается при нажатии по кнопке "Валить"
# @example
# try_to_evacuate(2)
# @return [Boolean] получилось ли эвакуироваться
# @see Country
def try_to_evacuate(country_id)
country = Country.find(country_id)
if country.allows_immigrants?
evacuate!
true
else
false
end
end
```
В документации YARD есть и другие теги, которые можно изучить по [этой](http://rubydoc.info/gems/yard/file/docs/Tags.md) ссылке.
##### Время документации!
Чтобы всё было невероятно математично, создадим файл настройки в проекте под названием `.yardopts` со следующим содержимым:
```
--private
--protected
-o doc/ruby
```
После этого перейдем в терминале в папку вашего проекта и запустим там команду
```
$ yard
```
Создалась папка doc/ruby. Откроем её в проводнике и откроем там \_index.html. В браузере перейдем на наш метод и увидим это:
Выглядит неплохо. И ссылка на метод модели работает.
Зачем мы сделали файл настроек? Чтобы каждый раз можно было запускать генерацию документацию простой командой `yard`. Первые две строчки в файле отвечают за добавление приватных методов в документацию, а третья — назначает папку, в которой появится документация.
##### Бонус: документируем coffeescript
Для coffeescript сделали инструмент со схожим синтаксисом и функционалом под названием [codo](https://github.com/coffeedoc/codo). Не вижу причин, чтобы ограничиваться документацией к руби коду и не писать её для скриптов.
Пример задокументированной функции, которая переводит число в радианы:
```
# Перевод в радианы
# @param x [Integer] число
# @return [Integer] радианы
rad:(x) ->
x * Math.PI / 180
```
Создадим в корне проекта файл `.codoopts` и напишем там:
```
-o doc/coffee
```
После этого при запуске команды в корне проекта
```
$ codo
```
у нас создастся документация к coffeescript в папке doc/coffee.
Готово, вы восхитительны!
#### Заключение
В конце хочу отметить, что даже если вы не собирайтесь использовать автоматическую генерацию документации, то всё равно советую вам начать писать комментарии к коду в структурном виде. Это облегчит жизнь вам и вашим коллегам! | https://habr.com/ru/post/215879/ | null | ru | null |
# Минималистичный issue tracker на Django
В этой статье рассказывается, как за короткое время решить с помощью фреймворка Django, простую, но интересную задачу: создание системы баг-трекинга (система тикетов) для своего проекта. Наша система будет интегрирована с системой аутентификации пользователей Django и административным интерфейсом. Несмотря на свою примитивность, такое приложение, при некотором усовершенствовании, вполне может быть полезно для разработчика-одиночки или небольшой группы.
Я опишу действия в linux-окружении, используя Django версии 1.6, поэтому надо иметь ввиду, что для других операционных систем и версий фреймворка, что-то может работать по-другому (но без существенных изменений). Уровень статьи рассчитан на новичков, однако заострять внимание на подготовке рабочего окружения и разжевывать совсем элементарные вещи я не буду, и, если вам не понятно, что вообще делать вначале, рекомендую почитать [вот эту прекрасную статью](http://www.jeffknupp.com/blog/2013/12/18/starting-a-django-16-project-the-right-way/) и пройти [Django tutorial](http://docs.djangoproject.com/en/1.6/intro/tutorial01/).
Итак, какие задачи должно выполнять наше приложение:
* Редактирование багрепортов (доступно для администраторов, через стандартную админку Django)
* Просмотр багрепортов в виде списка и по отдельности (доступно для всех посетителей)
* Возможность регистрации в качестве нового пользователя
* Соответственно, login и logout через веб-интерфейс
* Добавление багрепортов через веб-интерфейс (доступно только для залогиненых пользователей)
В целях соблюдения концепции минималистичности багрепорт (или тикет) будет содержать название (title), описание (description), дату и время создания (created), автора (author), и статус открыт\закрыт (closed).
Процесс работы над приложением будет разделен на несколько этапов, и, чтобы упростить перемещение от одного этапа к другому, я создал [репозиторий](https://github.com/svfat/django-tutorial-bugreport/) на GitHub со всеми исходными кодами и коммитами на каждом этапе. Конечно, можно просто делать копипаст кода из статьи, но я предлагаю поступить иначе:
1. Подготоваливаете ваше рабочее окружение, устанавливаете django
2. Если у вас еще нет аккаунта на GitHub — создаете его
3. Делаете [форк (fork) моего репозитория](https://github.com/svfat/django-tutorial-bugreport/fork)
4. В рабочей папке (в шелле) выполняете команду git clone
5. Далее, в начале каждого этапа, я буду указывать команду git checkout -f , которую необходимо выполнить, чтобы код в рабочей папке синхронизировался с соответствующим коммитом репозитория.
Вы получите полный код готового проекта, в вашей рабочей среде. Можно запустить
```
cd django-tutorial-bugreport
./manage.py runserver
```
и в браузере перейдя по адресу [127.0.0.1:8000/bugs](http://127.0.0.1:8000/bugs/) «пощупать» финальный результат.
Этап №0 — создание приложения
-----------------------------
Прелесть git в том, что можно легко откатиться на любой этап разработки проекта, и для вашего удобства, я эти этапы пометил тегами. Итак, выполняем команду:
```
git checkout -f part-0
```
— тем самым сбросив проект к начальному состоянию, каким бы он был, если бы вы только что выполнили команду django-admin.py startproject…
Перейдем в папку проекта и создадим приложение bugtracker
```
./manage.py startapp bugtracker
```
Вносим наше приложение в project/settings.py (добавив `'bugtracker'` в кортеж `INSTALLED_APPS`)
Сразу настроим каталоги для темплейтов и статики:
`TEMPLATE_DIRS = (os.path.join(BASE_DIR, 'templates/'),)
STATICFILES_DIRS = (os.path.join(BASE_DIR, 'static/'),)`
Добавим такой urlpattern в project/urls.py — `url(r'^bugs/', include('bugtracker.urls'))`, после чего, все остальные нужные нам урлы уже будем описывать именно в bugtracker\urls.py, который мы создадим вот таким, пока почти пустым, иначе django будет выдавать ошибку:
```
# coding: utf-8
from django.conf.urls import patterns, include, url
urlpatterns = patterns('',
)
```
Затем создаем модель для багрепорта в файле bugtracker/models.py:
```
# coding: utf-8
from django.db import models
from django.contrib.auth.models import User
class Ticket(models.Model):
title = models.CharField(max_length=128)
text = models.TextField()
created = models.DateTimeField(auto_now=True)
closed = models.BooleanField(default=False)
user = models.ForeignKey(User,)
def __unicode__(self):
return self.title
```
Рассмотрим ее поближе: **title** — это название тикета, например *«Пепелац не взлетает»*, **text** — описание и шаги для воспроизведения бага, **created** — время и дата создания тикета, будет автоматически заполняться благодаря `auto_now=True`, **closed** — простейший вариант описания статуса тикета, закрыт он или открыт, по-умолчанию (при созданию) `closed = False`, то есть тикет не закрыт, **user** — пользователь, сообщивший о баге. В качестве юникодного представления модель возвращает **title**
Отредактируем bugtracker/admin.py, чтобы появилась возможность управлять тикетами из админки:
```
# coding: utf-8
from django.contrib import admin
from .models import Ticket
admin.site.register(Ticket)
```
И запустим
```
./manage.py syncdb
```
В результате этого, в базе данных создадутся необходимые таблицы, и будут запрошены логин, e-mail и пароль для создания пользователя-администратора.
Внимание, далее по тексту, при команде git checkout из git-репозитория db.sqlite3, и администратор имеет логин: admin, пароль: 123 (один-два-три)
Создав его, можно запускать:
```
./manage.py runserver
```
И заходить по адресу <http://127.0.0.1:8000/admin>, а после ввода логина и пароля, [создавать, редактировать и удалять тикеты.](http://127.0.0.1:8000/admin/bugtracker/ticket/)
Этап №1 — список тикетов
------------------------
Выполняем:
```
git checkout -f part-1
```
— по этой команде, появится файл db.sqlite3 содержащий ту самую базу данных, в которой уже созданы некоторые тикеты для тестирования, и логин администратора: admin, пароль: 123. Посмотрев содержимое тикетов, вы увидите, что я использовал небогатый функционал нашего приложения в качестве TODO-списка для него самого. Вид конечно в административном интерфейсе непригляден, и мы попробуем это исправить. Добавим в bugtracker/admin.py новый класс, который определяет интерфейс списка тикетов в админке и зарегистрируем его:
```
class TicketAdmin(admin.ModelAdmin):
list_display = ('closed', 'title', 'text', 'created', 'user')
list_filter = ['created', 'closed']
search_fields = ['title', 'text']
admin.site.register(Ticket, TicketAdmin)
```
После этого админка станет намного удобнее. Можно отметить пункт «Редактирование багрепортов» как выполненный.
Следующее, что мы сделаем — добавим возможность просмотра списка тикетов, не заходя в административный интерфейс. Для этого нам нужно создать базовый html-шаблон и шаблон собственно списка тикетов. Базовый шаблон будет находиться в файле templates/base.html:
```
Bugtracker - {% block title\_block %}{% endblock %}
{% block content\_block %}
{% endblock %}
```
Как видите он очень прост и содержит в себе два блока, для заголовка и содержимого.
Шаблон списка создадим в файле templates/list.html
```
{% extends 'base.html' %}
{% block title_block %}Main{% endblock %}
{% block content_block %}
Bug list
========
| Title | Created | Author | Status |
{% for ticket in object\_list %}
| {{ ticket.title }} | {{ ticket.created|date }} | {{ ticket.user }} | {{ ticket.closed|yesno:"CLOSED, OPENED" }} |
{% empty %}
| No tickets yet. |
{% endfor %}
{% endblock %}
```
Все это будет подставлено в базовый шаблон вместо
```
{% block content_block %}
{% endblock %}
```
. Содержимое представляет собой таблицу из четырек колонок, которая будет заполнена данными тикетов, а при их отсутствии (пустая) в таблице будет надпись
> No tickets yet.
Теперь напишем class-based view для этой функции в файле bugtracker/views.py, он очень прост:
```
from django.views.generic import ListView
from .models import Ticket
class BugListView(ListView):
model = Ticket
template_name = 'list.html'
```
Здесь определена модель для отображения в виде списка, и шаблон для отображения.
Осталось только, создать новый паттерн для URL "/bugs/" в файле bugtracker/urls.py: добавив
```
from .views import BugListView
```
и
```
url(r'^$', BugListView.as_view(), name='index'),
```
(как мы помним, в файле project/urls.py — общего для всего проекта, мы определили, что паттерны для `"/bugs"` находятся в `bugtracker/urls.py`, соответственно регэксп паттерна для URL `"/bugs/"` будет выглядеть именно так: `r'^$'`.
Заходим на <http://127.0.0.1:8000/bugs/> и видим страшноватую таблицу со списком всех наших тикетов. Так как дизайн мы прикрутим потом, можем смело поставить статус «Closed» для этого этапа в админке.
Этап №2 — детали тикета
-----------------------
Выполняем:
```
git checkout -f part-2
```
Добавим возможность просмотра каждого тега по-отдельности, используя DetailView, действуем по старой схеме.
Создаем шаблон templates/detail.html:
```
{% extends 'base.html' %}
{% block title_block %}{{ object.title }}{% endblock %}
{% block content_block %}
{{ object.closed|yesno:"CLOSED, OPENED" }} - {{ object.title }}
===============================================================
{{ object.user }} - {{ object.created|date }}
{{ object.text }}
{% endblock %}
```
Создаем view в bugtracker/views.py:
```
from django.views.generic import DetailView
class BugDetailView(DetailView):
model = Ticket
template_name = 'detail.html'
```
и в bugtracker/urls.py:
```
from .views import BugDetailView
```
в urlpattens добавляем
```
url(r'^(?P[0-9]+)/$', BugDetailView.as\_view(), name='detail'),
```
Кроме того, добавляем в шаблон templates/list.html ссылку на такой URL для каждого тикета, можно например сделать так:
```
[{{ ticket.title }}]({% url 'detail' ticket.pk %}) |
```
благодаря url 'detail' наши урлы будут генерироваться автоматически, и даже если структура урлов поменяется, то шаблон не «поломаются»
Проверяем, перейдя на <http://127.0.0.1:8000/bugs/> и затем кликнув по любой из ссылок. Если все работает, отмечаем в админке, что тикет закрыт.
Этап №3 — регистрация пользователей
-----------------------------------
```
git checkout -f part-3
```
Правильнее, конечно, вынести работу с пользователями в отдельное приложение и воспользоваться, например, [django-registration](http://django-registration.readthedocs.org/en/latest/index.html) для удобной работы с активацией, сменой и восстановлением паролей и т.д., но так как мы обучаемся, то не будем использовать батарейки, дабы не умножать сущности сверх необходимого.
При регистрации пользователей мы будем использовать встроенные функции django по работе с формами, для этого создадим шаблон templates/register.html:
```
{% extends 'base.html' %}
{% block title_block %}Registration{% endblock %}
{% block content_block %}
{% if user.is_authenticated %}
[Back to main page]({% url 'index' %})
{% else %}
{% csrf\_token %}
{{ form.as\_p }}
{% endif %}
{% endblock %}
```
В случае, если юзер не залогинен, то мы отображаем форму, которые передается в шаблон из следующего view (bugtracker/views.py):
```
from django.views.generic import CreateView
from django.core.urlresolvers import reverse_lazy
from django.contrib.auth.forms import UserCreationForm
class RegisterView(CreateView):
form_class = UserCreationForm
template_name = 'register.html'
success_url = reverse_lazy('index')
```
**success\_url** — это куда пользователя будет направлять при успешной регистрации, урл будет излечен из urlpatterns с помощью reverse\_lazy('index'), то есть в нашем случае "/bugs/"
Дополним базовый шаблон ссылкой на форму регистрации, которая будет отображаться только если юзер не залогинен:
```
{% if user.is_authenticated %}
Welcome, {{ user.username }}!
{% else %}
[Register]({% url 'register' %})
{% endif %}
```
Не забываем добавить импорт RegisterView в bugtracker/urls.py и в urlpattern — `url(r'^register/$', RegisterView.as_view(), name='register'),`
Теперь можно проверить работоспособность и перейти к следующему этапу.
Этап №4 — логин и логаут
------------------------
```
git checkout -f part-4
```
Здесь все просто, мы будем использовать встроенные джанговские шорткаты. Для логаута шаблон, не понадобиться, так как отображать-то в этой функции и нечего, нас просто будет переносить на главную страницу. Поэтому создаем шаблон только для логина (templates/login.html):
```
{% extends 'base.html' %}
{% block title_block %}Login{% endblock %}
{% block content_block %}
{% csrf\_token %}
{% if form.non\_field\_errors %}
{% for error in form.non\_field\_errors %}
{{ error }}
{% endfor %}
{% endif %}
{% for field in form %}
{{ field.label\_tag }}
{{ field }}
{% if field.errors %}
{% for error in field.errors %}
{{ error }}
{% endfor %}
{% endif %}
{% endfor %}
{% endblock %}
```
В bugtracker/urls.py пропишем следующее:
```
from django.core.urlresolvers import reverse_lazy
```
и
```
url(r'^login/$', 'django.contrib.auth.views.login',
{"template_name" : "login.html"}, name="login"),
url(r'^logout/$', 'django.contrib.auth.views.logout',
{"next_page" : reverse_lazy('login')}, name="logout"),
```
А templates/base.html переделаем так:
```
{% if user.is_authenticated %}
Welcome, {{ user.username }}
| [Logout]({% url 'logout' %})
{% else %}
[Register
| [Login]({% url 'login' %})]({% url 'register' %})
{% endif %}
```
Что бы после логина нас редиректило на главную страницу в settings.py пропишем
```
from django.core.urlresolvers import reverse_lazy
LOGIN_REDIRECT_URL = reverse_lazy('index')
```
Поиграем вдоволь, создавая новых пользователей, логинясь и разлогиниваясь под ними.
Этап №5 — добавление нового тикета
----------------------------------
```
git checkout -f part-5
```
Шаблон templates/add.html очень похож на тот, что мы создавали для RegisterView, только наоборот — функционал доступен авторизованному пользователю:
```
{% extends 'base.html' %}
{% block title_block %}Add ticket{% endblock %}
{% block content_block %}
{% if user.is_authenticated %}
[Back to main page]({% url 'index' %})
{% csrf\_token %}
{{ form.as\_p }}
{% else %}
You should be logged in to add tickets!
{% endif %}
{% endblock %}
```
Добавляем куда-нибудь в базовый шаблон ссылочку на add:
```
[Add ticket]({% url 'add' %})
```
View будет таким,
```
class BugCreateView(CreateView):
model = Ticket
template_name = 'add.html'
fields = ['title', 'text']
success_url = reverse_lazy('index')
def form_valid(self, form):
form.instance.user = self.request.user
return super(BugCreateView, self).form_valid(form)
```
То есть пользователю будут видны только поля title и text, а благодаря переопределению метода form\_valid в поле user будет подставлен индекс текущего пользователя.
Прописываем паттерн для урла 'add/' в bugtracker/urls.py, не забыв импортировать BugCreateView:
```
url(r'^add/$', BugCreateView.as_view(), name='add'),
```
Попробуем добавить новых тикетов, и переходим к следующему этапу.
Этап №6 — сделать нарядно
-------------------------
```
git checkout -f part-6
```
Все это более-менее удовлетворительно работает, но выглядит страшновато. На мой взгляд, самый простой и удобный способ улучшить наш интерфейс, доступный даже неспециалисту в верстке (как я) — это использовать twitter bootstrap. Для этого скачаем соответствующую библиотеку и распакуем её в папку static. После чего мы приступим к верстке шаблонов. У bootstrap куча примеров, поэтому особых сложностей возникнуть не должно. Поскольку, приводить здесь простыни получившегося HTML не имеет смысла, а нюансы верстки под bootstrap выходят за рамки этой статьи (и моих познаний), просто посмотрите исходники в [репозитории](https://github.com/svfat/django-tutorial-bugreport/), или выполните `git checkout -f final`, что бы получить окончательный вариант кода.
Стоит заметить, что третья версия bootstrap требует добавлять class=«form-control» к инпутам в формах.Известный мне самый простой метод, сделать это в шаблонах django (не используя дополнительных батареек) — это кастомный фильтр, который описан [здесь](http://vanderwijk.info/blog/adding-css-classes-formfields-in-django-templates/#comment-1193609278). Буду благодарен, если более искушенные читатели моей статьи поделятся своим опытом в комментариях.
Итог
----
Буквально за пару часов, а то и меньше, мы с вами создали вполне функциональное приложение, которое при дальнейшем улучшении, настройке и развитии, может хорошо послужить, в каких то других проектах, а может быть и как standalone-сервис. Вот мои несколько вполне реализуемых идей для его улучшения:
* HTTP API (сразу появляется возможность взаимодействия практически со всем чем угодно — программы, консольные скрипты, другие веб-сервисы и т.д.
* Побольше статусов для тикетов
* Пагинация в шаблоне вывода списка
* Возможность поручить исполнение тикета другому юзеру и контролировать статус
* Загрузка файлов и изображений
* Легкая настройка и кастомизация дополнительных полей для тикетов
* Система плагинов
Жду ваших замечаний, идей и предложений в комментариях. Спасибо!
**UPD:**Пока я готовил статью, вышел релиз django 1.7, в которую внедрена поддержка миграций, что раньше осуществлялось с помощью south. Команда syncdb теперь deprecated, поэтому, после изменений в моделях делаем:
./manage.py makemigrations <имя\_приложения>
./manage.py migrate
Для просмотра SQL-запроса соответствующего миграции, выполняем
./manage.py sqlmigrate <имя\_приложения> <номер\_миграции> | https://habr.com/ru/post/234307/ | null | ru | null |
# Передача цветного изображения с помощью Intel RealSense SDK
Вы задумали создать простое приложение с потоком цветного изображения, использующее [камеру Intel RealSense](https://software.intel.com/en-us/realsense/devkit) и [Intel RealSense SDK](https://software.intel.com/en-us/intel-realsense-sdk), или просто собираетесь использовать поток цветного изображения в одном из приложений? Вам нужно понятное приложение, простое в отслеживании его работы, действующее напрямую, без огромного объема дополнительного кода, отвлекающего от того, чему вы хотите научиться? В этом случае вам повезло, поскольку именно такого результата я попытался добиться здесь: я старался создать простой, но эффективный пример приложения и документ, описывающий использование камеры и SDK Intel RealSense.
[Этот пример](https://software.intel.com/sites/default/files/managed/06/4b/real_sense_simple_streaming.zip) был написан с помощью Intel RealSense SDK R4 и Visual Studio\* на языке C#, он был протестирован в выпуске R5. Для него требуется камера Intel RealSense F200.
Структура проекта
=================
В этом простом приложении я попытался отделить функциональность Intel RealSense SDK от кода уровня графического пользовательского интерфейса Windows\* Form, чтобы разработчикам было удобнее сосредоточиться на функциональности SDK, относящейся к поточной передаче изображения. Для этого я создал на C# класс-оболочку (RSStreaming), заключив в него несколько классов Intel RealSense SDK.
Приложение Windows Form содержит лишь несколько кнопок и элемент управления PictureBox, в котором отображается поток цветного изображения.
Обратите внимание, что я не пытаюсь создать идеальное приложение. Я добавил определенные средства обработки исключений, но этим и ограничился. Все остальное — уже ваша забота, если вы хотите применить правильные принципы программирования и добиться от приложения стабильности и удобства для пользователей.
Структура проекта опирается на использование событий для передачи данных, вследствие чего можно обойтись без тесных связей. Был создан вспомогательный класс событий RSNewImageArg, наследующий от EventArg. Он используется для публикации текущего кадра из камеры в клиентское приложение.
Начало работы
=============
Для работы потребуется камера Intel RealSense F200. Также требуется Intel RealSense SDK версии R4 или более поздней версии. Помимо этого, на компьютер необходимо установить соответствующий пакет [Depth Camera Manager (DCM)](https://software.intel.com/en-us/blogs/2015/10/18/intel-realsense-depth-camera-manager-dcm-overview). SDK и F200 DCM можно загрузить [здесь](https://software.intel.com/en-us/intel-realsense-sdk/download).
#### Требования
##### Требования к оборудованию
* Процессор Intel® Core™ 4-го поколения (на основе микроархитектуры Haswell).
* 8 ГБ свободного места на жестком диске.
* Камера Intel RealSense F200 (ее необходимо подключить к порту USB 3).
##### Требования к программному обеспечению
* 64-разрядная версия операционной системы Microsoft Windows 8.1 или Windows 10.
* Microsoft Visual Studio\* 2010–2015 с последней версией пакета обновления.
* Microsoft .NET\* 4.0 Framework для разработки на C#.
* Unity\* 5.x или более поздней версии для разработки игр на движке Unity.
Компоненты проекта
==================
#### RSNewImageArg.CS
*RSNewImageArg* является производным от класса C# EventArgs. Как видите, это небольшой класс-оболочка, к которому добавлен один частный элемент данных. Этот частный элемент данных *Bitmap \_bitMap* содержит текущее растровое изображение, извлеченное из потока камеры.
Этот класс используется как аргумент события, когда класс *RSStreaming* отправляет событие обратно в класс *Form*, указывая, что новое растровое изображение готово к показу.
#### RSStreaming.CS
*RSStreaming* — это класс-оболочка (своего рода «движок») с данными потока цветного изображения из камеры Intel RealSense. Я написал этот класс, преследуя следующие цели.
* Ясно и четко выделить как можно больше функций Intel RealSense SDK и как можно дальше отделить их от клиентского приложения.
* Попытаться предоставить в коде комментарии, чтобы помочь читателю разобраться в том, что именно делает код.
Ниже описываются все функции, входящие в класс *RSSpeechEngine*.
#### public event EventHandler OnStreamingImage
Событие *OnStreamingImage* служит для переключения сообщения обратно к клиентскому приложению, сообщая ему о том, что новое цветное растровое изображение готово к показу. Клиент создает обработки событий для обработки объекта *RSNewImageArg*.
#### public bool Initialized
Свойство метода получения используется в качестве флага, указывая, что класс *RSStreaming* инициализирован.
#### public bool IsStreaming
Свойство метода получения используется в качестве флага, указывая, что класс *RSStreaming* в настоящее время ведет поточную передачу данных цветного изображения.
#### public void StartStreaming()
Проверяет, инициализирован ли класс. Если нет, вызывает *InitCamera*, чтобы убедиться в том, что класс запущен и работает. Затем эта функция вызывает функцию *\_senseManager.StreamFrames( … )*.
Если вы успели ознакомиться с достаточным количеством материалов о разработке приложений для Intel RealSense, то, вероятно, вы обратили внимание, что получение данных с камеры зачастую осуществляется в циклах while. Например, приблизительно так.
```
while (!Stop)
{
/* Wait until a frame is ready: Synchronized or Asynchronous */
if (sm.AcquireFrame(Synced).IsError())
break;
/* Display images */
PXCMCapture.Sample sample = sm.QuerySample();
/* Render streams */
EventHandler render = RenderFrame;
PXCMImage image = null;
if (MainPanel != PXCMCapture.StreamType.STREAM\_TYPE\_ANY && render != null)
{
image = sample[MainPanel];
render(this, new RenderFrameEventArgs(0, image));
}
if (PIPPanel != PXCMCapture.StreamType.STREAM\_TYPE\_ANY && render != null)
render(this, new RenderFrameEventArgs(1, sample[PIPPanel]));
/\* Optional: Set Mirror State \*/
mirror = Mirror ? PXCMCapture.Device.MirrorMode.MIRROR\_MODE\_HORIZONTAL :
PXCMCapture.Device.MirrorMode.MIRROR\_MODE\_DISABLED;
if (mirror != sm.captureManager.device.QueryMirrorMode())
sm.captureManager.device.SetMirrorMode(mirror);
sm.ReleaseFrame();
/\* Optional: Show performance tick \*/
if (image!=null)
timer.Tick(PXCMImage.PixelFormatToString(image.info.format)+" "+image.info.width+"x"+image.info.height);
}
```
Да, это солидная порция кода. Этот код, возможно, делает гораздо больше, чем мой пример приложения, но я всего лишь хочу сказать, что у меня цикл while не используется таким образом. В моем приложении используется функция *StreamFrames(…)*. Эта функция обрабатывает цикл while внутри себя, а для каждого кадра она включает событие, на которое подписывается *RSStreamingRGB*. Работает это так.
1. Запускаем поток *PXCMSenseManager.StreamFrames(…)*.
2. Ловим событие обработчиком событий.
3. По окончании поточной передачи вызываем *PXCMSenseManager.Close( )*.
Мне нравится этот подход, потому что не хочется вручную возиться с циклом while, зная, когда и как останавливать цикл. Лучше пусть SDK позаботится об этом вместо меня. Вы увидите, как устроена эта методика, когда я буду рассказывать о функции *InitCamera()*, поэтому я не стану рассказывать про нее здесь. Просто убедитесь в том, что вы поняли, как можно передавать поток данных и разрешить SDK управлять циклом над необработанными данными, поступающими из камеры.
После вызова *StreamFrames* я задаю для логического флага *\_isStreaming* значение true, чтобы уведомить класс и клиентское приложение о начале передачи потока.
#### public void StopStreaming ( )
Остановка передачи потока — действие, противоположное StartStreaming. Эта функция дает команду SDK для остановки передачи потока данных из камеры и вызывает *Dispose()* для уничтожения объектов данных.
#### private void InitCamera ( )
*InitCamera()* создает экземпляр *PXCMSenseManager* и включает нужный нам тип потока. Как видите, я указываю поток цветного изображения с разрешением 320 x 240 при скорости 30 кадров в секунду.
Если помните, я говорил о возможности использовать событие из PXCMSenseManger, чтобы сообщить классу о доступности нового кадра данных цветного изображения available. Для этого используется класс событий *PXCMSenseMananger.Handler*. Процесс достаточно прост: создаем экземпляр класса *Handler*, назначаем его обработчику событий через *onNewSample*, затем инициализируем объект *PXCMSenseManager; \_senseMananger* с классом обработчика.
Затем задаем флагу *\_initialized* значение true. Как было сказано выше, с помощью этого флага мы сообщаем либо этому классу, либо клиентскому приложению о том, что класс *RSStreaming* инициализирован.
#### private pxcmStatus OnNewSample( )
Это обработчик событий для объекта *PXCMSenseMananger.Handler()*. Если помните, в функции *InitCamera()* я задаю обработчик событий объектов для этой функции.
Обработчик событий должен соответствовать заданной подписи функции. Функция должна возвращать значение *pxcmStatus* и принимать два параметра.
* Mid. Идентификатор потока. Если посредством функции *EnableVideoStream*s запрошено несколько потоков, то это может быть *PXCMCapture.CUID+0*, *PXCMCapture.CUID+1* и т. д.
* Sample. Доступное изображение.
Нужно преобразовать объект *PXCMCapture.Sample* в пригодное к использованию растровое изображение, которое может быть показано клиентским приложением.
Сначала я проверяю, что объект *sample.color* не является пустым и что внутреннее растровое изображение класса *\_colorImageData* также не является пустым. Нужно убедиться в том, что *\_colorImageData* не содержит никаких данных, а если содержит, то их нужно высвободить.
Затем нужно использовать объект *sample.colors* для заполнения *\_colorImagedata*. Это, по сути, объект метаданных для объекта цветного изображения *PXCMCapture.Sample*. После этого можно перейти к созданию растрового изображения, указав его размер.
Получив растровое изображение и убедившись в том, что оно не пустое, я включаю событие *OnStreamingImage*, указывая источник события и новый объект *RSNewImageArg*.
Наконец, нам **НЕОБХОДИМО** высвободить текущий кадр из объекта PXCMSenseMananger, а также, поскольку это требуется подписью функции, возвратить *pxcmStatus*. В этом месте можно было добавить код для обработки исключений, но я предпочел этого не делать ради простоты. Если бы я написал такой код, то мог бы возвращать другое состояние *pxcmStatus*, но я просто возвращаю состояние успеха.
#### private void Dispose ( )
*Dispose()* выполняет очистку. Я проверяю, что диспетчер не является пустым и что он был инициализирован. Если оба условия выполнены, то я взываю его метод очистки. Я проверяю, что растровое изображение RSStreaming не является пустым, и очищаю его. Затем я везде устанавливаю значение null.
#### MainForm.CS
Главная форма — это графический пользовательский интерфейс, в котором отображается поток цветного изображения. В нем можно управлять объектом *RSStreaming*. У него две глобальных переменных: экземпляр *RSStreamingRGB* и растровое изображение. Растровое изображение будет содержать текущее изображение из текущего кадра, который отправлен классом *RSStreamingRGB*.
#### public MainForm( )
Конструктор форм. Он создает новый объект *RSSTreamingRGB* и предоставляет событию *OnStreamingImage* обработчик событий.
#### private void btnStream\_Click( )
Обработчик событий при нажатии кнопки Start Streaming. Дает команду объекту *\_rsStreaming* на начало передачи потока путем вызова функции *StartStreaming()* этого объекта.
#### private void btnStopStream\_Click( )
Обработчик событий при нажатии кнопки Stop Streaming. Дает команду объекту *\_rsStreaming* на остановку передачи потока путем вызова функции *StopStreaming()* этого объекта.
#### private void UpdateColorImageBox( object source, RSNewImageArg e )
*UpdateColorImageBox* — обработчик событий для события *\_rsStream.OnStreamingImage*. Проверяет, что аргумент *newImage* не пуст и присваивает в этом случае *\_currentBitMap* новому растровому изображению, используя *newImage* в качестве источника растрового изображения.
Если не создать новое растровое изображение, то *\_currentBitMap* формы будет указывать на первоначальное растровое изображение, созданное пакетом SDK. Из-за этого могут возникнуть проблемы при вызове метода *RSStreaming.Dispose*. В клиентской программе имеется рамка рисунка, а в этой рамке отображается изображение, которое берется из SDK. Если при активной форме и рамке рисунка я попробую вызвать *RSStreaming.Dispose*, высвобождающий ресурсы SDK, то получится аварийный сбой, поскольку удаляется исходное изображение для рамки рисунка.
После назначения нового изображения для *\_currentBitMap* я вызываю *pictureBox.Invalidate()* и тем самым запускаю событие *Paint* рамки рисунка.
#### private void pictureBox\_Paint( object sender, PaintEventArgs e )
Это обработчик события *Paint* рамки рисунка, он переключается вызовом *pictureBox.Invalidate()*. Он дает команду на перерисовку рамки рисунка с использованием текущего исходного изображения.
Сначала проверяем, что *\_currentBitMap* не пуст, а затем задаем для него наиболее позднее растровое изображение, которое сохраняется в *\_currentBitMap*.
#### private void btnExit\_Click( )
Здесь все элементарно. Просто вызываем *Close()*. Нет необходимости обрабатывать очистку, поскольку все это происходит в методе *MainForm\_FormClosing*.
#### private void bMainForm\_FormClosing( )
Это событие форм, закрывающее обработчик событий. При вызове метода *Close()* в любой заданной функции вызывается событие *FormClosing*. Чтобы не дублировать код, я разместил здесь весь код очистки. Проверяем, что *\_rsStream* не пуст и что идет передача потока. Если эти условия выполнены, то вызываем *\_rsStream.StopStreaming()*. Нет необходимости вызывать метод очистки для *\_rsStreaming*, поскольку все необходимое уже сделано в *StopStreaming*.
Заключение
==========
Надеюсь, с помощью этой статьи и примера кода вы лучше поняли, как применять Intel RealSense SDK для создания простых приложений с передачей цветного изображения. Я стремился продемонстрировать, что это можно сделать в простом и понятном приложении: в нем реализованы все элементы, необходимые для успешного создания вашего собственного приложения для передачи цветного изображения. | https://habr.com/ru/post/279285/ | null | ru | null |
# Хабрачтец или как я сделал этим летом
Здравствуйте!
Вдохновленный постами о том, что нужно начать делать и все получится, в данном материале я хотел бы поделиться рассказом о результате многочисленных вдохновений и моём опыте разработки приложения для ОС Андроид. Постараюсь описать процесс от возникновения идеи до ее реализации.
Прошедшее лето подарило мне два с половиной месяца полной свободы, половину которых я потратил на написание программы. Я не то, чтобы новичок – мой диплом был первым достаточно серьезным проектом, однако, думаю, что именно данное приложение ~~принесет мне славу~~ будет вам интересно.
Что у меня было исходного на тот момент:
* Время
* Galaxy Tab
* Eclipse IDE с ADT plugin
Казалось бы. Причем тут Хабр?
А вот причем. Вашему вниманию — Хабрачтец:
Как я уже упомянул – в конце июня сего года мне уже предстояли пара месяцев свободных от какой-либо занятости. И я завел себе привычку, просыпаясь с утра, открывать на планшетнике пару тройку новостных приложений, заботливо предложенных Маркетом, и внимательно их изучать. А что, очень удобно. Чашка дымящегося кофе, вид с балкона, бутерброд и домашний беспроводной вай-фай отныне делали начало моего дня.
Свою ложку дёгтя добавило только отсутствие Хабраклиента – приходилось открывать Оперу, идти на сайт, скроллить, подгонять… Не то, чтобы прям неудобно, но все же одним пальцем не так-то просто понажимать, да позумить, особенно с чашкой кофе в руке. Где-то в один из таких моментов я подумал. И решил. Попытаться написать клиента для сайта по подобию уже имевшихся у меня приложений.
Что было исходного:
* Веб страница Хабра со всеми вытекающими
* Опыт написания дипломной работы, представляющая собой связку сервер – клиент, где клиент (барабанная дробь), да да – Андроид приложение
* Эклипс и плагины
* Гэлэкси Тэб
Что ставилось в задачу:
* Разбор страницы на составляющие: Посты, Вопросы, События
* Каждый элемент, будь то пост или вопрос, должен содержать все то, что содержит оригинал на сайте
* Возможность добавлять в избранное и хранить на устройстве
* Несложный интерфейс, сохраняющий стилистику и структуру оригинала
* И наконец изюминка – режим «Сохранения на будущее» (думаю, что суть ясна, объясню чуток позже)
Исходный материал помноженный на четыре недели (имеется ввиду действительно рабочие дни из тех двух месяцев – так-то я еще на море съездил) принес свои плоды – теперь я могу наслаждаться чтением Хабра в любом месте, где есть интернет.
Далее немного деталей.
##### Данные и их обработка
Технически приложение достаточно простое. У меня естественно не было доступа к API Хабра. Пришлось вертеться. Итак, поэтапно.
Хабрачтец делает запрос на адрес хабра и получает `HTML` код с помощью `HttpUrlConnection`. Данная операция по понятным причинам асинхронна – она не должна и потому не блокирует интерфейс. Последовательность действий проста – нажатие кнопки, запуск фоновой задачи, подключение к Хабру, получение кода и передача его заинтересованной `Activity` в виде объекта `String`, вложенного в специальный `Intent`, посредством оповещения (`Broadcast`). Ничего вроде особенного.
*Для гурманов: Однако в описанной выше последовательности была загвоздка. Для передачи данных внутри приложения (и вообще системы) используются объекты-намерения – `Intent`, пересылаемые в оповещениях – `Broadcast`. Так вот. Пару раз внутреннее содержимое постов не хотело грузится. Т.е. даже по логам было видно, что приложение нашло Хабр, загрузило код страницы, но дальше… ничего. Вообще. Тишина. Приложение не зависало, но и ничего не происходило. Перезапуски не помогали. Содержимое не появлялось. Проблема была оставлена до лучших времен и объяснилась практически случайно.
Дело в том, что все новые и свежие посты грузились легко и непринужденно. А вот почитать что-нибудь постарше и с большим количеством комментариев было уже нельзя. Внимательное(!) чтение логов выявило странную строку о системной ошибке – **!!!FAILED BINDER TRANSACTION!!!** Сложно не заметить, правда? Вот я и не заметил. Единственная строка, тут же забиваемая другим «мусором». В ней и крылась проблема. Гугление показало, что подобное возникает в случае, если данные используемые для передачи превосходят некий лимит. Начал мерять размер строки – 600 000 знаков. А ведь там даже 100 комментариев не было! В общем, добавил очистительные процедуры, провел несколько проб и выяснил предел, равный 250 тысячам знаков в строке. Сейчас, если даже после чистки размер превышен, строка обрезается и… не все комментарии будут доступны (\*плачет\*).
Решить, проблему можно относительно легко, хотя бы передавать данные в пару этапов. Думаю, что она будет решена в следующем обновлении.*
Далее HTML код веб-страниц с сайта обрабатывается на интересующие составляющие. Для этого используется библиотека [Jsoup](http://jsoup.org) – штука отличная, позволяющая извлекать все необходимые данные по указанным тэгам и аттрибутам. Достаточно одной ~~таблэтки~~ строки:
```
Document document = Jsoup.parse(html);
```
Ну а дальше уже разбор на элементы.
*Для гурманов: полученный после однострочной обработки объект класса `Document` предоставляет два варианта получения необходимых внутренних элементов. Первый с помощью «обычных» геттеров:*
```
//Так например извлекаются все посты с главной главной страницы
Elements contentElements = document.getElementsByAttributeValueContaining("class","hentry");
```
Второй с помощью более удобного общего метода `select()`
```
//То есть так:
document.select(".page-navigation .info-text [class*=live] ");
```
*Как видно второй вариант куда более удобен, позволяя сократить количество кода. Одной строкой ищутся элементы с аттрибутом class равным «page-navigation» и «info-text», а также содержащим слово «live». Однако существенных преимуществ в производительности замечено не было.*
«Отлов» нужных и не очень тэгов и атрибутов проводил вручную. Взял по одной странице каждого типа и смотрел глазками, какие элементы мне нужны, какие нет. Отдельное спасибо разработчикам – все было ясно и понятно. Точно также поступил и с основными ссылками на Хабр.
После обработки HTML создается отдельный объект соответствующего типа будь то пост, вопрос или событие, которые в последствии записываются в соответствующую таблицу с ключом = id. Таблицы сделаны статичными и доступны для всего приложения посредством `DataManager` — класса-синглтона. В памяти сохраняются с помощью пакета **java.io** и **Context.getDir()**.
*Для гурманов: думаю, что Андроид-разработчики, прочитав предыдущие строки, многозначительно хмыкнут и подумают про себя, что-нибудь вроде «тоже мне...». Дело в том, что не стоит (и я это уже понял) использовать в данном случае java.io, а естественно лучше базу данных. Я ловил кучу ошибок связанных как раз с ошибками в чтении и записи, ведь в Java объекты передаются по ссылке, которые нужно постоянно обновлять, что разумеется можно банально забыть сделать. Ну и разумеется скорость, теряемая на проверки и обновления не особо доставляет радости и прибавляет скорости работы приложению, причем снижение в данном случае линейно и зависит от числа запоминаемых элементов. Каюсь, делал как проще и быстрее. Не факт, что стало быстрее и уж точно не стало проще.
В общем будет переделано. 100%.*
С отображением основного текста поста (и любого другого материала) была небольшая заминка. Многие приложения используют для этих целей `WebView` – специальный вид для веб страниц, очень мощный инструмент, способный подгружать материал из сети, отображать уже существующий. Для меня его «недостатком» стала мощь. К примеру, аннотации реализованы как выпадающие элементы списка – использование `WebView` потребовало бы больше вычислительных ресурсов. Поэтому выбор пал на `TextView`, который получал от `Html.fromHtml(…)` метода объект `Spannable`. Вполне себе эффективный способ, позволяющий при желании с помощью `TagHandler` настраивать отображение нужных тэгов (например «code» — мой любимый) и подгружать картинки с `ImageGetter`.
*Для гурманов: О картинках и `ImageGetter`. По умолчанию загрузка в фоновом режиме не возможна – интерфейс блокировался. Решается легко и просто – фоновое задание, загрузка в кэш-директорию и обновление `TextView` по окончании.
Почему-то проходит не без проблем. Некоторые картинки, в основном с внешних ресурсов, не habrastorage, подгружаются через одну. Причину пока отловить не удалось. Работаю над этим.*
##### Плюшки
Режим редактирования позволяет указать интересующие материалы и загрузить их содержимое. Программа запишет все в память, и в последствии можно будет почитать их, например по дороге на работу в метро.
Возможно чистить как целиком все списки, сразу всю ленту, избранное, а можно и по несколько разрозненных на выбор.
Если не хочется тратиться на трафик, да и интересная ссылка видна в аннотации к посту – долгое нажатие поможет отобразить список всех доступных ссылок. То же самое действительно и для ссылок в ответах и комметариях.
По желанию есть возможность отослать ссылку на пост себе на почту. Мне не нужно в принципе – может понадобиться людям с аккаунтом, чтобы прокомментировать понравившийся пост позднее. В будущем доделаю-таки добавление событий в календарь, пока в альфа версии.
Что касается отображения видео – заменяю его на обычную ссылку. Единственное, что не получается представить – это Подкасты. Честно говоря, пока даже не пытался. Возможно все-таки придется вернуться ко `WebView`.
И, конечно, есть загрузка без картинок для «очень» мобильных сетей.
##### Интерфейс
Основной вид программы, как видно из первого скриншота – это вкладки, повторяющие три основных и наиболее интересных (мне – под себя ведь писал) раздела Хабра. Ближе к концу процесса разработки была идея использовать слайд эффект – переключение между разделами с помощью скользящего жеста пальцем. Однако желание больше соответствовать оригиналу пересилило. К тому же основной вид и его был к тому времени уже настолько сложен, что потребовал бы приличного времени на переделку.
Цвета, использованные в программе, как и расположение основных элементов – даты, имени автора, темы взяты тоже с хабра. Картинки и иконки (за исключеним тех, что в меню – ~~их притырил из sdk~~) рисовал сам. И, да… Я – не дизайнер (\*горестно вздыхает\*). Но старался, что уж тут.
*Для гурманов: Все-таки не стоит делать столь насыщенных деталями элементов списков. Тормозит прилично, хоть граница «ну невозможно этим пользоваться» и не была пересечена. Пользуюсь. Решением подобной проблемы может стать, к примеру, специальный адаптер с кэшированием, подгружающий и удаляющий элементы по мере их появляения на экране устройства. [Например такой.](https://github.com/commonsguy/cwac-endless)*
Дальше — меньше букв, больше скриншотов:
##### Производительность
В виду особенностей техники (Galaxy Tab у меня без 3G, модель P1010) работал исключительно с вай фаем. Дома линия в 8 Мбит. В нескольких кафе субъективно меньше. Разницы особо не ощущал.
Главный вопрос – сколько потребляется трафика. Ответ – столько же, сколько на доступ к Хабру через обычный браузер.
Не менее главный вопрос – как быстро все работает. Ответ – достаточно быстро. Как уже упоминалось, для новых постов, вопросов и событий – обработка проходит быстро, максимально до 2-3с, по измерениям. Если много комментариев, да еще и материал объемен – может быть больше. Рекорд по измерениям – 10с. Прилично, да? В защиту скажу, что это действительно было один раз. В среднем – менее 5 секунд.
Цифры действительны для отображения текста, картинки грузятся асинхронно и появляются после загрузки, поэтому влияние на чтение не учитывал.
Скорость прокрутки списков – `ListView` – стоит отдельного упоминания. Подтормаживает, но терпимо. Работал со списками до 70 элеметов, больше вроде не было необходимости.
##### Выводы
Процесс написания программы ~~офигителен~~ офигителен. Действительно, писать мне понравилось очень, даже, наверное, больше чем собственно пользоваться приложением. Все-таки программисты – творческие люди, чтобы там ни говорили. Это действительно эйфория – написать пару строк и увидеть результат.
Я попробовал себя в «теоретической» роли фрилансера. И, скажу вам, не фонтанирует. Дома, один с компом и телевизором, создающим фон, практически весь день (всю рекламу уже выучил). В том же офисе хоть какое-то общение ведь бывает. Живое, причем. Обедать – один, ведь все на работе. А если еще и наткнуться на проблему интересную, так она и в выходные может не отпустить. Я себя на мыслях о проблеме с количеством знаков в строке даже в кино ловил. Что там – я ее отцу и подруге объяснял! Про интенты, броадкасты. А он у меня – металлург, она – биолог…
Мне, надеюсь, удалось применить на практике те знания, что я получил в университете. И практические, и теоретические. И, конечно, приобрести новые. А главное узнать про некоторые свои недостатки. Как, например, «сделаю, чтоб работало» или написать кучу полезных методов, а потом все забыть и все равно заново писать код. Каюсь, подхрамывала и общая организация процесса.
##### Главное
Главное, что я для себя понял. Любому проекту (не автору даже) необходимо постоянно вдохновляться, чтобы расти и улучшаться дальше. Источником вдохновения может быть что угодно – перспективы денежные, моральные, конкурентные, банально по работе надо и т.п. Когда проект начинает выполнять свои задачи, причем удовлетворяя всех – и авторов, и пользователей – его развитие прекращается. Для Хабрачтеца я – автор и единственный на данный момент пользователь, и меня в нем все устраивает. Но я не хотел бы, чтобы он прекратил свое развитие. Именно поэтому, я рассказал о нем вам.
Итак, вам слово. | https://habr.com/ru/post/129738/ | null | ru | null |
# Java Challengers #3: Полиморфизм и наследование
Java Challengers #3: Полиморфизм и наследование
===============================================
*Мы продолжаем перевод серии статей с задачками по Java. [Прошлый пост про строки](https://habr.com/company/otus/blog/428449/) вызвал на удивление [бурную дискуссию](https://habr.com/company/otus/blog/428449/#comment_19340612). Надеемся, что мимо этой статьи вы тоже не пройдете мимо. И да — мы приглашаем теперь на юбилейный десятый поток нашего курса ["Разработчик Java"](https://otus.pw/kp8s/).*
Согласно легендарному [Венкату Субраманиам (Venkat Subramaniam)](https://twitter.com/venkat_s) полиморфизм является самым важным понятием в объектно — ориентированном программировании. *Полиморфизм* — или способность объекта выполнять специализированные действия на основе его типа — это то, что делает Java — код гибким. Шаблоны проектирования, такие как Команда (Command), Наблюдатель (Observer), Декоратор (Decorator), Стратегия (Strategy), и многие другие, созданные бандой четырех (Gang Of Four), все используют ту или иную форму полиморфизма. Освоение этой концепции значительно улучшит вашу способность продумывать программные решения.
Вы можете взять исходный код для этой статьи и поэксперементировать здесь: <https://github.com/rafadelnero/javaworld-challengers>
Интерфейсы и наследование в полиморфизме
----------------------------------------
В этой статье мы сфокусируемся на связи между полиморфизмом и наследованием. Главное иметь в виду, что полиморфизм требует *наследования* или *реализации интерфейса*. Вы можете увидеть это на примере ниже с Дюком (`Duke`) и Джагги (`Juggy`):
```
public abstract class JavaMascot {
public abstract void executeAction();
}
public class Duke extends JavaMascot {
@Override
public void executeAction() {
System.out.println("Punch!");
}
}
public class Juggy extends JavaMascot {
@Override
public void executeAction() {
System.out.println("Fly!");
}
}
public class JavaMascotTest {
public static void main(String... args) {
JavaMascot dukeMascot = new Duke();
JavaMascot juggyMascot = new Juggy();
dukeMascot.executeAction();
juggyMascot.executeAction();
}
}
```
Вывод этого кода будет таким:
```
Punch!
Fly!
```
Так как определены конкретные реализации, то будут вызваны методы и `Duke` и `Juggy`.
Перегрузка (overloading) метода — это полиморфизм? Многие программисты путают [отношение полиморфизма с переопределением методов (overriding) и перегрузкой методов (overloading)](https://stackoverflow.com/questions/154577/polymorphism-vs-overriding-vs-overloading). Фактически, только переопределение метода — это истинный полиморфизм. Перегрузка использует то же имя метода, но разные параметры. Полиморфизм — это широкий термин, поэтому всегда будут дискуссии на эту тему.
Какова цель полиморфизма
------------------------
Большим преимуществом и целью использования полиморфизма является уменьшение связанности клиентского класса с реализацией. Вместо того чтобы хардкодить, клиентский класс получает реализацию зависимости для выполнения необходимого действия. Таким образом, клиентский класс знает минимум для выполнения своих действий, что является примером слабого связывания.
Чтобы лучше понять цель полиморфизма, взгляните на `SweetCreator`:
```
public abstract class SweetProducer {
public abstract void produceSweet();
}
public class CakeProducer extends SweetProducer {
@Override
public void produceSweet() {
System.out.println("Cake produced");
}
}
public class ChocolateProducer extends SweetProducer {
@Override
public void produceSweet() {
System.out.println("Chocolate produced");
}
}
public class CookieProducer extends SweetProducer {
@Override
public void produceSweet() {
System.out.println("Cookie produced");
}
}
public class SweetCreator {
private List sweetProducer;
public SweetCreator(List sweetProducer) {
this.sweetProducer = sweetProducer;
}
public void createSweets() {
sweetProducer.forEach(sweet -> sweet.produceSweet());
}
}
public class SweetCreatorTest {
public static void main(String... args) {
SweetCreator sweetCreator = new SweetCreator(Arrays.asList(
new CakeProducer(),
new ChocolateProducer(),
new CookieProducer()));
sweetCreator.createSweets();
}
}
```
В этом примере вы можете видеть, что класс `SweetCreator` знает только о классе `SweetProducer`. Он не знает реализации каждого `Sweet`. Такое разделение дает нам гибкость для обновления и повторного использования наших классов, а это делает код намного проще в сопровождении. При проектировании кода всегда ищите способы сделать его максимально гибким и удобным. Полиморфизм — это очень мощный способ для использования в этих целях.
> Аннотация `@Override` обязывает программиста использовать такую же сигнатуру метода, которая должна быть переопределена. Если метод не переопределен, будет ошибка компиляции.
Ковариантные возвращаемые типы при переопределении метода
---------------------------------------------------------
Можно изменить тип возвращаемого значения переопределенного метода если это [ковариантный тип](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%B2%D0%B0%D1%80%D0%B8%D0%B0%D0%BD%D1%82%D0%BD%D0%BE%D1%81%D1%82%D1%8C_%D0%B8_%D0%BA%D0%BE%D0%BD%D1%82%D1%80%D0%B0%D0%B2%D0%B0%D1%80%D0%B8%D0%B0%D0%BD%D1%82%D0%BD%D0%BE%D1%81%D1%82%D1%8C_(%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)). Ковариантный тип в основном является подклассом возвращаемого значения.
Рассмотрим пример:
```
public abstract class JavaMascot {
abstract JavaMascot getMascot();
}
public class Duke extends JavaMascot {
@Override
Duke getMascot() {
return new Duke();
}
}
```
Поскольку `Duke` является `JavaMascot`, мы можем изменить тип возвращаемого значения при переопределении.
Полиморфизм в базовых классах Java
----------------------------------
Мы постоянно используем полиморфизм в базовых классах Java. Один очень простой пример — создание экземпляра класса `ArrayList` с объявлением типа как интерфейс `List`.
```
List list = new ArrayList<>();
```
Рассмотрим пример кода, использующий Java Collections API *без* полиморфизма:
```
public class ListActionWithoutPolymorphism {
// Пример без полиморфизма
void executeVectorActions(Vector vector)
{/\* Здесь повтор кода \*/}
void executeArrayListActions(ArrayList arrayList)
{/\* Здесь повтор кода \*/}
void executeLinkedListActions(LinkedList linkedList)
{/\* Здесь повтор кода \*/}
void executeCopyOnWriteArrayListActions(CopyOnWriteArrayList copyOnWriteArrayList)
{ /\* Здесь повтор кода \*/}
}
public class ListActionInvokerWithoutPolymorphism {
listAction.executeVectorActions(new Vector<>());
listAction.executeArrayListActions(new ArrayList<>());
listAction.executeLinkedListActions(new LinkedList<>());
listAction.executeCopyOnWriteArrayListActions(new CopyOnWriteArrayList<>());
}
```
Отвратительный код, не так ли? Представьте себе, что вам нужно его сопровождать! Теперь рассмотрим тот же пример с полиморфизмом:
```
public static void main(String... polymorphism) {
ListAction listAction = new ListAction();
listAction.executeListActions();
}
public class ListAction {
void executeListActions(List list) {
// Выполнение действий с различными списками
}
}
public class ListActionInvoker {
public static void main(String... masterPolymorphism) {
ListAction listAction = new ListAction();
listAction.executeListActions(new Vector<>());
listAction.executeListActions(new ArrayList<>());
listAction.executeListActions(new LinkedList<>());
listAction.executeListActions(new CopyOnWriteArrayList<>());
}
}
```
Преимущество полиморфизма — гибкость и расширяемость. Вместо того чтобы создавать несколько различных методов, мы можем объявить один метод, который получает тип `List`.
Вызов конкретных методов для полиморфного метода
------------------------------------------------
Можно вызвать конкретные методы при полиморфном вызове метода, это происходит за счет гибкости. Вот пример:
```
public abstract class MetalGearCharacter {
abstract void useWeapon(String weapon);
}
public class BigBoss extends MetalGearCharacter {
@Override
void useWeapon(String weapon) {
System.out.println("Big Boss is using a " + weapon);
}
void giveOrderToTheArmy(String orderMessage) {
System.out.println(orderMessage);
}
}
public class SolidSnake extends MetalGearCharacter {
void useWeapon(String weapon) {
System.out.println("Solid Snake is using a " + weapon);
}
}
public class UseSpecificMethod {
public static void executeActionWith(MetalGearCharacter metalGearCharacter) {
metalGearCharacter.useWeapon("SOCOM");
// Следующая строка не будет работать
// metalGearCharacter.giveOrderToTheArmy("Attack!");
if (metalGearCharacter instanceof BigBoss) {
((BigBoss) metalGearCharacter).giveOrderToTheArmy("Attack!");
}
}
public static void main(String... specificPolymorphismInvocation) {
executeActionWith(new SolidSnake());
executeActionWith(new BigBoss());
}
}
```
Техника, которую мы используем здесь — это приведение типов (casting) или сознательное изменение типа объекта во время выполнения.
Обратите внимание, что вызов определенного метода возможен только при приведении более общего типа к более специфичному типу. Хорошей аналогией было бы сказать явно компилятору: "Эй, я знаю, что я здесь делаю, поэтому я собираюсь привести объект к определенному типу и буду использовать этот метод."
Ссылаясь на приведенный выше пример, у компилятора есть веская причина не принимать вызов определенных методов: класс, который передаётся должен быть `SolidSnake`. В этом случае, у компилятора нет никакого способа гарантировать, что каждый подкласс `MetalGearCharacter` имеет метод `giveOrderToTheArmy`.
Ключевое слово `instanceof`
---------------------------
Обратите внимание на зарезервированное слово `instanceof`. Перед вызовом конкретного метода мы спросили, является ли `MetalGearCharacter` экземпляром (instanceof) `BigBoss`. Если это не экземпляр `BigBoss`, мы получим следующее исключение:
```
Exception in thread `main" java.lang.ClassCastException:
com.javaworld.javachallengers.polymorphism.specificinvocation.SolidSnake cannot
be cast to com.javaworld.javachallengers.polymorphism.specificinvocation.BigBoss
```
Ключевое слово `super`
----------------------
Что делать, если мы хотим сослаться на атрибут или метод из родительского класса? В этом случае мы можем использовать ключевое слово `super`.
Например:
```
public class JavaMascot {
void executeAction() {
System.out.println("The Java Mascot is about to execute an action!");
}
}
public class Duke extends JavaMascot {
@Override
void executeAction() {
super.executeAction();
System.out.println("Duke is going to punch!");
}
public static void main(String... superReservedWord) {
new Duke().executeAction();
}
}
```
Использование зарезервированного слова `super` в методе `executeAction` класса `Duke` вызывает метод родительского класса. Затем мы выполняем конкретное действие из класса `Duke`. Вот почему мы можем видеть оба сообщения в выводе:
```
The Java Mascot is about to execute an action!
Duke is going to punch!
```
Решите задачку по полиморфизму
------------------------------
Давайте проверим, что вы узнали о полиморфизме и наследовании.
В этой задачке Вам дается несколько методов от Matt Groening’s The Simpsons, от вавам требуется разгадать, какой будет вывод для каждого класса. Для начала внимательно проанализируйте следующий код:
```
public class PolymorphismChallenge {
static abstract class Simpson {
void talk() {
System.out.println("Simpson!");
}
protected void prank(String prank) {
System.out.println(prank);
}
}
static class Bart extends Simpson {
String prank;
Bart(String prank) { this.prank = prank; }
protected void talk() {
System.out.println("Eat my shorts!");
}
protected void prank() {
super.prank(prank);
System.out.println("Knock Homer down");
}
}
static class Lisa extends Simpson {
void talk(String toMe) {
System.out.println("I love Sax!");
}
}
public static void main(String... doYourBest) {
new Lisa().talk("Sax :)");
Simpson simpson = new Bart("D'oh");
simpson.talk();
Lisa lisa = new Lisa();
lisa.talk();
((Bart) simpson).prank();
}
}
```
Как вы думаете? Каким будет результат? Не используйте IDE, чтобы выяснить это! Цель в том, чтобы улучшить ваши навыки анализа кода, поэтому постарайтесь решить самостоятельно.
Выберите ваш ответ (правильный ответ вы сможете найти в конце статьи).
A)
I love Sax!
D'oh
Simpson!
D'oh
B)
Sax :)
Eat my shorts!
I love Sax!
D'oh
Knock Homer down
C)
Sax :)
D'oh
Simpson!
Knock Homer down
D)
I love Sax!
Eat my shorts!
Simpson!
D'oh
Knock Homer down
Что случилось? Понимание полиморфизма
-------------------------------------
Для следующего вызова метода:
```
new Lisa().talk("Sax :)");
```
вывод будет "I love Sax!". Это потому, что мы передаём строку в метод и у класса `Lisa` есть такой метод.
Для следующего вызова:
```
Simpson simpson = new Bart("D'oh");
simpson.talk();
```
Вывод будет "Eat my shorts!". Это потому, что мы инициализируем тип `Simpson` с помощью `Bart`.
Теперь смотрите, это немного сложнее:
```
Lisa lisa = new Lisa();
lisa.talk();
```
Здесь мы используем перегрузку метода с наследованием. Мы ничего не передаем методу `talk`, поэтому вызывается метод `talk` из `Simpson`.
В этом случае на выходе будет "Simpson!".
Вот еще один:
```
((Bart) simpson).prank();
```
В этом случае строка `prank` была передана при создании экземпляра класса `Bart` через `new Bart("D'oh");`. В этом случае сначала вызывается метод `super.prank()`, а затем метод `prank()` из класса `Bart`. Вывод будет:
```
"D'oh"
"Knock Homer down"
```
Распространенные ошибки с полиморфизмом
---------------------------------------
Распространенная ошибка думать, что можно вызвать конкретный метод без использования приведения типа.
Другой ошибкой является неуверенность в том, какой метод будет вызван при полиморфном создании экземпляра класса. Помните, что вызываемый метод является методом созданного экземпляра.
Также помните, что переопределение метода не является перегрузкой метода.
Невозможно переопределить метод, если параметры отличаются. Можно изменить тип возвращаемого значения переопределенного метода, если возвращаемый тип является подклассом.
Что нужно помнить о полиморфизме
--------------------------------
* Созданный экземпляр определяет, какой метод будет вызван при использовании полиморфизма.
* Аннотация `@Override` обязывает программиста использовать переопределенный метод; в противном случае возникнет ошибка компилятора.
* Полиморфизм может использоваться с обычными классами, абстрактными классами и интерфейсами.
* Большинство шаблонов проектирования зависят от той или иной формы полиморфизма.
* Единственный способ вызвать нужный ваш метод в полиморфном подклассе — это использовать приведение типов.
* Можно создать мощную структуру кода, используя полиморфизм.
* Экспериментируйте. Через это, вы сможете овладеть этой мощной концепцией!
Ответ
-----
Ответ — D.
Вывод будет:
```
I love Sax!
Eat my shorts!
Simpson!
D'oh
Knock Homer down
```
Как всегда приветствую ваши комментарии и вопросы. И ждём у [Виталия](https://otus.pw/B7TZ/) на [открытом уроке](https://otus.pw/o0wA/). | https://habr.com/ru/post/429120/ | null | ru | null |
# Мой друг Netmiko. Часть 2: Три улучшения Python-скрипта
Продолжаю ковырять автоматизацию рутины на сети из Huawei коммутаторов. На этот раз изыскания, которые позволили сократить код в 3 раза, а именно: хосты и команды перенесены в отдельные файлы, пароль и имя пользователя больше не хранятся в открытом тексте. Есть [демонстрация](https://forum.huawei.com/enterprise/ru/forum.php?mod=viewthread&tid=818375) запуска скрипта.
Я лучше воспринимаю вещи визуально, поэтому представил задачу по оптимизации скрипта в графическом виде (см. ниже) - а именно отразил три основные задачи:
1. Применить inventory файл, в котором перечислить ip-адреса всех сетевых устройств, а не создавать словарь для каждого из них.
2. Переместить конфигурационные команды в отдельный файл и так же, как и inventory файл вызывать его с помощью функции.
3. Избавиться от хранения пароля и имени пользователя в скрипте.
Я также убрал команды верификации (Их, конечно, можно и оставить, и они будут работать из конфигурационного файла, но для настоящей задачи они не нужны).
В комментарии к предыдущему посту [«Мой друг Netmiko»](https://habr.com/ru/company/huawei/blog/594229/) появился вопрос от пользователя [anders\_i](https://habr.com/ru/company/huawei/blog/594229/comments/#comment_23920403) о том, насколько можно масштабировать скрипт:
Тогда я использовал 4 виртуальных CloudEngine Huawei в eNSP. На этот раз я попробовал расширить их количество настолько, насколько хватит мощности Huawei MateBook X Pro 2021.
И расширить удалось до 8-ми. 9-ый запускаться отказался, оккупация 16GB ОЗУ составила 80%.
Обновленная топология выглядит так:
### 1. Создаю конфигурационный файл
Я предпочитаю редактор Nano (кто-то предпочитает Vim):
**nano switch\_file\_config**
В файле прописываю все команды из прошлого примера (команды могут быть любыми в зависимости от нужд) без пробелов/отступов. **Важно** указать команду **return** последней строкой. Как я понял, ее нужно прописывать вручную только при использовании конфигурационного файла – при прописывании команд в самом скрипке модуль Netmiko автоматически ее применяет и завершает SSH-соединение. Без **return** скрипт не сработает.
Список команд, перенесенные в отдельный файл:
Теперь весь предыдущий код:
```
for n in range (300,302):
print ("Creating VLAN " + str(n))
config_commands = [
'vlan ' + str(n),
'desc NETMIKO_VLAN ' + str(n),
'Commit'
]
output = ssh_connect.send_config_set(config_commands)
output = ssh_connect.send_config_set(
[
'interface range GE 1/0/9 GE 1/0/10',
'port trunk allow-pass vlan 300 301',
'commit'
]
)
```
Сокращаю до:
```
with open('switch_file_config') as f:
config_lines = f.read().splitlines()
print (config_lines)
```
и меняю строчку:
```
output = ssh_connect.send_config_set(config_lines)
```
Python функция **open** открывает указанный файл, читает его, разделяя на линии (форматируя) **f.read().splitlines()** и выводит на экран **print(config\_lines).** Модуль Netmiko **send\_config\_set** теперь будет обращаться к этому файлу **(config\_lines)**, применяя команды из него.
### 2. Создаю inventory-файл с IP-адресами коммутаторов:
Начинаю с того же создания файла в редакторе Nano:
**nano myswitches**
Это файл будет содержать список (list) IP-адресов коммутаторов:
Здесь главное - убедиться, чтобы не осталось пробелов.
Сохраняю командой Ctr+X.
Для небольшого теста я создал python-файл, назвал его openfile.py.
Прописал в нем простой скрипт, который будет открывать файл с IP-адресами и выводить их на экран:
```
f = open ('myswitches')
for IP in f:
print (IP)
```
Запустил его:
Как видно, первая строчка осталась пустой, а значит для Python она будет выглядеть как [‘ ’,]. При попытке запуска такого файла Python выдаст ошибку, что не смог связаться с адресом назначения. Поэтому пустых строк лучше не допускать.
Я настроил дополнительные 4 CE-коммутатора в eNSP, дав им IP-адреса и настроив SSH-соединение:
Теперь сокращаю весь предыдущий код:
```
CE_1_BORDER = {
'device_type': 'huawei',
'ip': '7.7.7.1',
'username': 'vasyo1',
'password': '@ghjcnjnF358986'
}
CE_2 = {
'device_type': 'huawei',
'ip': '7.7.7.2',
'username': 'vasyo1',
'password': '@ghjcnjnF358986'
}
CE_3 = {
'device_type': 'huawei',
'ip': '7.7.7.3',
'username': 'vasyo1',
'password': '@ghjcnjnF358986'
}
CE_4 = {
'device_type': 'huawei',
'ip': '7.7.7.4',
'username': 'vasyo1',
'password': '@ghjcnjnF358986'
}
all_devices = [CE_1_BORDER, CE_2, CE_3, CE_4]
for device in all_devices:
ssh_connect = ConnectHandler(**device)
```
До:
```
with open('myswitches') as f:
ip_lines = f.read().splitlines()
print (ip_lines)
for device in ip_lines:
ip_address_of_device = device
CE = {
'device_type': 'huawei',
'ip': ip_address_of_device,
'username': username,
'password': password
}
ssh_connect = ConnectHandler(**CE)
output = ssh_connect.send_config_set(config_lines)
```
С синтаксисом открытия файла все понятно.
В словаре Netmiko больше не прописываю IP-адрес. Вместо этого теперь код будем обращаться за IP-адресами к переменной **ip\_address\_of\_device**, которая равна переменной **device**, которая является частью цикла (loop) **for**, который читает **ip\_lines**, которая является переменной, содержащей IP-адреса устройств в файле **«myswitches».**
### 3. Удаляю пароль и имя пользователя из скрипта
Небезопасно хранить имя пользователя и пароль, что называется, clear text:
```
CE = {
'device_type': 'huawei',
'ip': ip_address_of_device,
'username': 'vasyo1',
'password': '@ghjcnjnF358986'
}
```
Вряд ли в производственной сети такое допустимо.
Поэтому я удалю их из скрипта, заменив переменными: переделаю скрипт таким образом, чтобы скрипт вывел на экран сообщение о необходимости ввода имени пользователя, а после введенные значения сохранил в переменной. Для этого использую функцию **input()**. Функция **input()** для версии Python 2.x называется **raw\_input().**
Функцию **getpass()** использую для ввода пароля.
```
username = input('Enter your SSH username: ')
password = getpass()
```
В словаре имя пользователя и пароль заменяю на переменные:
```
CE = {
'device_type': 'huawei',
'ip': ip_address_of_device,
'username': username,
'password': password
}
```
В итоге я получил улучшенный код, который сократился с 63 строк до 28 и стал более адаптированным для применения в реальной производственной практике. Выглядит он следующий образом (запуск скрипта на видео можно посмотреть [на странице](https://forum.huawei.com/enterprise/ru/forum.php?mod=viewthread&tid=818375) Huawei Форума ICT Club):
```
from getpass import getpass
from netmiko import ConnectHandler
username = input('Enter your SSH username: ')
password = getpass()
with open('switch_file_config') as f:
config_lines = f.read().splitlines()
print (config_lines)
with open('myswitches') as f:
ip_lines = f.read().splitlines()
print (ip_lines)
for device in ip_lines:
ip_address_of_device = device
CE = {
'device_type': 'huawei',
'ip': ip_address_of_device,
'username': username,
'password': password
}
ssh_connect = ConnectHandler(**CE)
output = ssh_connect.send_config_set(config_lines)
print(f"\n\n-------------- CE_{CE['ip']} --------------")
print(output)
print("-------------------- End -------------------")
```
Литература:
<https://stackoverflow.com/questions/5563089/raw-input-function-in-python>
<https://pynet.twb-tech.com/blog/automation/netmiko.html>
<https://pyneng.readthedocs.io/en/latest/book/18_ssh_telnet/netmiko.html>
<https://github.com/ktbyers/netmiko>
<https://github.com/ktbyers/netmiko/blob/master/netmiko/ssh_dispatcher.py>
Udemy.com - Python Network Programming for Network Engineers (Python 3) (David Bombal)
[https://www.pythoncentral.io/pythons-range-function-explained](https://www.pythoncentral.io/pythons-range-function-explained/) | https://habr.com/ru/post/648127/ | null | ru | null |
# Меры центральности в Network Science
Привет, Хабр!
Меня зовут Сергей Коньков, я Data Scientist и участник [профессионального сообщества NTA.](https://newtechaudit.ru/) За последние 10 лет интерес к науке Network Science неимоверно возрос, что повлекло за собой закономерное развитие всевозможных инструментов для исследований в данной области. Одним из таких инструментов является python-библиотека NetworkX, предназначенная для анализа графов или других сетевых структур. Этот пост будет направлен на объяснение и демонстрацию работы основных мер центральности, вычисляемых в графах.
Краткое описание библиотеки NetworkX с некоторыми примерами можно увидеть [здесь](https://habr.com/ru/post/125898/), также тут размещена документация и множество других публикаций, в разной степени затрагивающих NetworkX.
Для начала введем основные определения, необходимые для последовательного и плавного погружения в данную область по мере изложения материала.
Простым графом
 в теории графов называют совокупность двух множеств — множества вершин графа 
и множества его ребер *E* — неупорядоченных пар различных элементов множества .
Построим с помощью библиотеки NetworkX наш первый граф
, состоящий из множества вершин
 и множества ребер
```
import networkx as nx # импортируем библиотеку
G = nx.Graph() # создаем пустой граф
G.add_nodes_from([1, 2, 3, 4, 5]) # добавляем вершины в граф
G.add_edges_from([(1, 2), (3, 5), (1, 3), (1, 5), (4, 5), (3, 4), (4, 1)]) # добавляем ребра в граф
nx.draw(G, node_size=500, with_labels=True, node_color='y') # визуализация графа
```
Такая модель позволяет удобно работать с данными, представляющими из себя объекты, между которыми можно выделить связи. Одна из самых популярных областей, в которой используются графы является Process Mining – область, фокусирующаяся на обнаружении, анализе и оптимизации бизнес-процессов на основе данных из журналов событий.
Конечно же, область применения графов совсем не ограничивается одним только Process Mining; если данные возможно спроецировать на граф, то, сделав это, вы откроете для себя богатый спектр различных методов исследования, а библиотека NetworkX поможет в этом.
В данном посте исследуем [датасет](https://github.com/mathbeveridge/asoiaf), описывающий взаимодействия героев фэнтези-романа “Песнь Льда и Огня” Джорджа Мартина. Два героя связаны ребром, если их имена появляются в тексте на расстоянии не более 15 слов в соответствующей книге. Данные находятся в открытом доступе для 5 книг. Построенная по этим данным сеть является взвешенной, где вес ребра определяется числом взаимодействий (упоминаний в тексте).
```
import pandas as pd
book5 = pd.read_csv('game_of_thrones_network/asoiaf-book5-edges.csv')
book5.head()
```
Построим сеть (граф) персонажей по первой книге и посмотрим на структуру произвольного ребра такого графа.
```
G1=nx.from_pandas_edgelist(book1,'Source', 'Target', edge_attr=True, create_using=nx.Graph())
nx.draw(G1, node_size=25)
```
```
print(list(G1.edges(data=True))[16])
('Jaime-Lannister', 'Loras-Tyrell', {'Source': 'Jaime-Lannister', 'Target': 'Loras-Tyrell', 'Type': 'Undirected', 'weight': 3, 'book': 1})
```
Видно, что в получившемся графе есть связь между Джейме Ланнистером и Лорасом Тиреллом со значением веса 3.
Не будем рассматривать простейшие характеристики полученного графа: число ребер, число вершин, плотность графа, степени вершин и т.д., сразу перейдем к знакомству с новой характеристикой - центральностью вершин и мер для ее определения.
Характеристика **«центральность»** позволяет определить степень важности вершины графа, основываясь на ее расположении. Рассмотрим несколько способов ее вычисления.
#### 1. Центральность по степени (degree centrality)
Центральность по степени показывает, насколько важна конкретная вершина с точки зрения количества связей с другими вершинами в сети, и для взвешенного графа вычисляется следующим образом:
где  — индекс рассматриваемой вершины,  — вес ребра (i, j), — число вершин в графе.
Посмотрим на персонажей первой книги с наибольшим значением центральности по степени.
```
# топ-10 персонажей по убыванию значения центральности по степени
characters = sorted(list(nx.degree_centrality(G1).items()), key=lambda i: i[1], reverse=True)
print(*characters[:10], sep='\n')
```
#### 2. Центральность по собственному вектору (eigenvector centrality)
Недостаток предыдущей меры заключается в том, что она учитывает только ближайших соседей рассматриваемой вершины, эта же мера учитывает “влиятельность” (центральных) ближайших соседей самих по себе. Принцип данной меры можно описать так: “если мои друзья влиятельны, то и я буду более влиятельным”. Формула для вычисления данной меры:
где  — индекс рассматриваемой вершины,  — вес ребра (i, j),  — некоторый нормировочный коэффициент.
Для вычисления центральности по собственному вектору необходимо преобразовать данную формулу, введя обозначения
где  — вектор, состоящий из значений центральностей каждой вершины,  — матрица весов рассматриваемого графа.
Используя введенные обозначения, исходная формула преобразуется к
а это уже классическая задача на поиск собственных векторов матрицы, в качестве окончательного ответа необходимо брать собственный вектор, соответствующий максимальному собственному значению.
Посмотрим на топ-10 персонажей по мере центральности по собственному вектору.
```
# топ-10 персонажей по убыванию значения центральности по собственному вектору
characters = sorted(list(nx.eigenvector_centrality(G1).items()), key=lambda i: i[1], reverse=True)
print(*characters[:10], sep='\n')
```
Видно, что Санса Старк поднялась в топ-3 по сравнению с топ-10, соответствующим центральности по степени.
#### 3. Центральность по близости (closeness centrality)
Предыдущие меры обычно относят к структурным, следующие же рассматриваемые две меры принято относить к геометрическим, так как они основаны на кратчайших путях в графе. Центральности по близости
 для i-ой вершины графа вычисляется по формуле
где i и j — индексы вершин рассматриваемого графа,
 — кратчайший путь от вершины i к вершине j, т. е. минимальное число ребер, через которые надо пройти, чтобы из вершины i попасть в вершину j.
Данная мера имеет простой физический смысл: чем меньше расстояния от i-ой вершины до остальных j-ых вершин графа (в экстремальном случае
, т. е. вершины i и j связаны ребром), тем меньше будет знаменатель в формуле для
, и тем больше будет значение самой центральности. Важно отметить, что данная мера имеет смысл только для связных графов, так как при наличии изолированных вершин или целых компонент кратчайшие пути до этих объектов будут вырождаться в бесконечность со всеми вытекающими последствиями.
Как обычно, вычислим значение данной меры для каждой вершины нашего графа и посмотрим, какие персонажи теперь попадут в топ-10.
```
# топ-10 персонажей по убыванию значения центральности по близости
characters = sorted(list(nx.closeness_centrality(G1).items()), key=lambda i: i[1], reverse=True)
print(*characters[:10], sep='\n')
```
#### 4. Центральность по посредничеству (betweenness centrality)
Данная мера очень популярна, и часто в различных литературных источниках по Network Science при упоминании термина "центральность", имеется в виду как раз центральность по посредничеству. Формула для вычисления значения данной меры для i-ой вершины графа уже будет выглядеть сложнее:
где
 — число кратчайших путей от вершины j до вершины k,
 — число кратчайших путей от вершины j до вершины k, которые проходят через вершину i. Суммирование в данной формуле идет по всевозможным парам вершин
Простыми словами, данная мера показывает нам насколько часто рассматриваемая вершина i является «перевалочным пунктом» при переходах от одной вершины графа до любой другой. Она позволяет достаточно хорошо определять «узкие места» в графе — вершины, входящие в состав ребра или набора ребер, соединяющих два ярко выраженных кластера.
Посмотрим на топ-10, формируемый посредством вычисления значения данной меры.
```
# топ-10 персонажей по убыванию значения центральности по посредничеству
characters = sorted(list(nx.betweenness_centrality(G1).items()), key=lambda i: i[1], reverse=True)
print(*characters[:10], sep='\n')
```
Видим, что впервые в топе, причем достаточно высоко, появилась Дейенерис Таргариен, что говорит о том, что данный персонаж является важным с точки зрения посредника между остальными персонажами книги.
#### 5. Page Rank
Последняя из рассматриваемых мер в данном посте является тоже довольно популярной, но стоит немного особняком относительно предыдущих мер. Интересно, что изначально данная мера вводилась для того, чтобы ранжировать страницы при поисковом запросе в браузере Google Chrome. Раньше даже можно было смотреть, чему равен page rank открытого сайта. Важно отметить, что несмотря на популярность данной меры в области ранжирования веб-страниц, такое название она приобрела не из-за слова "page" ("страница" с англ.), а благодаря ее автору Ларри Пейджу (Larry Page).
Так как данная мера изначально применялась именно в веб-сети, то и вводилась она именно для направленного графа, каким как раз и является веб сеть, где некоторая страница может содержать в себе ссылку на другую страницу, но обратной ссылки может и не быть. Тем не менее, это не мешает обобщать данную меру на ненаправленный граф, просто считая, что при наличии ребра между двумя вершинами мы имеем два направленных ребра (от одной вершины к другой и наоборот).
Воспользуемся готовой реализацией данной меры из библиотеки NetworkX и выведем топ-10 персонажей нашей книги по мере Page Rank.
```
# топ-10 персонажей по убыванию значения Page Rank
characters = sorted(list(nx.pagerank(G1, alpha=0.85).items()), key=lambda i: i[1], reverse=True)
print(*characters[:10], sep='\n')
```
Функция nx.pagerank в качестве второго параметра принимает некое
, которое отвечает за вклад каждой из компонент в формуле для вычисления Page Rank, но часто принято для этого параметра указывать именно значение
В этом посте я представил основные и наиболее часто используемые меры центральности в Network Science, в действительности же их существует не один десяток. Искренне надеюсь, что вы почерпнете полезную или просто интересную для вас информацию, а может быть и примените этот материал в своих исследования в области Network Science и смежных областях. | https://habr.com/ru/post/715386/ | null | ru | null |
# Двухуровневый CI-процесс PHP-проекта
Непрерывная интеграция (CI, англ. Continuous Integration) — это практика разработки программного обеспечения, которая заключается в выполнении частых автоматизированных сборок проекта для скорейшего выявления и решения интеграционных проблем. Целей у непрерывной интеграции две:
* Недопущение появления в репозитории кода, который не соответствует принятым стандартам качества. Чистый репозиторий — чистые помыслы;
* Скорейшее выявление проблем качества и их устранение. Чем раньше выявил проблему — тем дешевле ее исправление.
На практике эти цели закрываются использованием статических анализаторов кода, тестами и их автоматизированным запуском.
### Современные возможности статического анализа
На текущий момент в PHP‑мире список статических анализаторов кода довольно широк. Наиболее популярные утилиты статического анализа:
* проверка кода на правила/стандарты его оформления. Например, [ecs](https://github.com/easy-coding-standard/easy-coding-standard), [phpcs](https://github.com/squizlabs/PHP_CodeSniffer);
* исправление оформления кода в соответствии с принятыми в команде правилами/стандартами. Например, [phpcbf](https://github.com/squizlabs/PHP_CodeSniffer);
* проверка кода и зависимостей проекта на наличие известных уязвимостей. Например, [security‑advisories](https://github.com/FriendsOfPHP/security-advisories);
* выполнять поиск неиспользуемого или дублирующего кода. Например, [phpmd](https://phpmd.org/), [phpcpd](https://github.com/sebastianbergmann/phpcpd);
* поиск неявных ошибок в коде. Например, [phpstan](https://github.com/phpstan/phpstan), [phan](https://github.com/phan/phan), [psalm](https://psalm.dev/);
* и многое другое.
И главное, эти богатые возможности можно и использовать для улучшения качества кода своего проекта!
### Проблематика
Обычно выполнение статического анализа кода выбранными инструментами происходит на сервере после обновления кода в удаленном репозитории. Особо ценны такие проверки при слиянии кода из одной ветки в другую перед выполнением командного ревью. Это централизованные проверки, позволяющие не допустить (в случае со слиянием) появления кода, не прошедшего все необходимые проверки в основной ветке. При таком подходе иногда возникают ситуации, когда при создании запроса на слияние двух веток запускаются автоматические проверки, которые выявляют какие‑то банальные недочеты в коде, которые мешают выполнения слияния, и которые необходимо устранить, например:
упавший pipeline из-за досадной ошибки.Обидно. Залил код, подождал, пока выполнится часть проверок, а в итоге получил ошибку. Конечно, выполняемые на сервере проверки перед созданием запроса на слияние хорошо бы выполнять на локальном компьютере. Но кто это делает? Единицы. Остальные надеются на собственную непогрешимость. Программисты же.
Для решения таких обидных недочетов, очевидно, необходимо чтобы проверки локально запускались автоматически. Отчасти это можно сделать настройкой собственной IDE на автозапуск инструментов статического анализа. Но такой подход имеет пару минусов:
* требуется ручная настройки IDE каждым разработчиком, работающим над проектом;
* IDE довольно много, и у каждого разработчика своя любимая среда разработки, поэтому разбираться, как настроить свою IDE придется в каждом частном случае.
### Решение
Можно пойти другим путем и использовать возможности, которые нам дают инструменты, которые есть в арсенале каждого PHP‑разработчика — git и composer. Composer умеет запускать произвольные пользовательские скрипты по окончании выполнения команд install и update, а git имеет технологию [git‑hooks](https://git-scm.com/docs/githooks). Если коротко, то это механизм запуска скрипта при наступлении какого‑то события в локальном гит‑репозитории. Событий довольно много, поэтому опишу самые полезные, на мой взгляд:
* pre‑commit — выполняется перед фиксацией изменений и вызывается при git commit;
* commit‑msg — выполняется при вызове команды git commit и позволяется отредактировать сообщение коммита;
* pre‑push — выполняется перед отправкой изменений в удаленный репозиторий и вызывается при git push.
И эти возможности можно успешно эксплуатировать в наших целях.
В триггере pre‑commit целесообразно запускать инструменты статического анализа, которые исправляют код перед коммитом, например, приводят код в соответствие принятому стилю написания. В триггере commit‑msg можно добавлять название ветки, в которой выполняются изменения, например. В триггере pre‑push целесообразно запускать самые тяжелые и долго выполняющиеся инструменты статического анализа, поскольку разработчик выполняет git push сильно реже, чем git commit.
Осталось позаботиться о том, чтобы эти триггеры появлялись автоматически в локальном репозитории разработчика. Для этих целей можно использовать готовые пакеты, которые очень легко настраиваются. Например, brainmaestro/composer‑git‑hooks или captainhook/captainhook. Их принцип установки идентичен. Первичная настройка хуков на примере использования пакета brainmaestro/composer‑git‑hooks:
1. Конфигурируем в composer.json. В полях /scripts/post-install-cmd и /scripts/post-update-cmd указываем команды на установку хуков при выполнении composer install и composer update. В /extra/hooks/pre-commit и /extra/hooks/pre-push описываем команды, которые будут выполняться перед коммитом и пушем. Пример:
```
{
...,
"scripts": {
...,
"post-install-cmd": [
"php ./vendor/bin/cghooks add --git-dir=./.git"
],
"post-update-cmd": [
"php ./vendor/bin/cghooks update --git-dir=./.git"
]
},
"extra": {
"hooks": {
"config": {
"stop-on-failure": ["pre-commit", "pre-push"]
},
"pre-commit": [
"php vendor/bin/phpcbf --standard=phpcsconf.xml app"
],
"pre-push": [
"cd src",
"php vendor/bin/phpcs --standard=phpcsconf.xml app",
"php vendor/bin/phpstan analyze -c phpstan.neon",
"php artisan test"
]
}
}
}
```
2. Устанавливаем composer‑пакет brainmaestro/composer‑git‑hooks. После окончания установки хуки будут прописаны в в локальном гит‑репозитории в.git/hooks/pre‑commit и.git/hooks/pre‑push;
3. Готово.
Попробуем в деле. Для наглядности, внёс ошибку в файл, а также неверное форматирование. Некорректные изменения, который я попытаюсь зафиксировать, выглядят так:
некорректные изменения в коде.То есть удалил необходимую зависимость — теперь при каждом http‑запросе вывалится эксепшн из‑за ее отсутствия. И также нарушил форматирование. Коммитим это добро:
консольный вывод команды автоматического форматирования кода.Хоба, запустился линтер и форматирование поправил. Правда придется отредактировать коммит и включить изменения линтера:
коммитим исправленный код.Теперь попробуем запушить код, содержащий ошибку:
не получилось запушить код, содержащий ошибку.И штатно отработал phpstan, который говорит нам, что код следует поправить, и он не улетит в удаленный репозиторий.
### Итог
Получился двухуровневый CI‑процесс — на первом уровне происходит контроль кодовой базы на рабочем компьютере разработчика, а на втором уровне происходит контроль на уровне удаленного репозитория. Отмечу также, что удаление одного из уровней контроля лишь снижает эффективность CI‑процесса, но лучше наличие хоть какого‑то CI, чем его полное отсутствие.
В итоге получаем код, удовлетворяющий нашим критериям качества. Проверка качества происходит автоматизировано. Лишний раз не запускаются ложные проверки качества на удаленном сервере при внесении изменений в удаленном репозитории. А мы вносим свой посильный вклад в декарбонизацию планеты, не заставляя железо лишний раз работать. | https://habr.com/ru/post/714514/ | null | ru | null |
# Управление VirtualBox с помощью консоли
Виртуализация… виртуализация…
Сейчас все пытаются выжать из своих аппаратных ресурсов как можно больше. Иметь несколько отдельных компьютеров с различными ОС немного накладно и не все организации пойдут на это. Но выход есть, можно использовать виртуальные машины. И возможно, что многие используют для этих целей замечательный продукт от Sun «VirtualBox». Я уверен, что большинство для настройки используют GUI интерфейс, т.к. это очень наглядно и удобно. Но многие ли задумывались о возможности управления VirtualBox через консоль.
Была поставлена задача: На один сервер поставить две ОС (Ubuntu и Windows). При этом был работающий сервер под управлением Ubuntu 9.04 Server Edition. Поэтому было решено ставить Windows XP в качестве гостевой системы.
Но возникла проблема на Ubuntu НЕ УСТАНОВЛЕНА никакая графическая среда, т.е. там есть только голая консоль.
Итак, что у нас есть:
* Хост система: Ubuntu 9.04 Server Edition
* VirtualBox 2.2.2
* Гостевая система: Windows XP
#### Установка VirtualBox
Скачиваем с официального сайта [VirtualBox](http://www.virtualbox.org) [пакет](http://download.virtualbox.org/virtualbox/2.2.2/virtualbox-2.2_2.2.2-46594_Ubuntu_jaunty_i386.deb) для Ubuntu 9.04
После того, как скачали, выполняем комманду:
`dpkg -i virtualbox-2.2_2.2.2-46594_Ubuntu_jaunty_i386.deb`
VirtualBox должен установится. Если возникла проблемы при установке пакета, изучите сообщение об ошибках. Возможно у вас не установлены необходимые пакеты. В моем случае у меня не был установлен пакет *libxslt1.1*, что моментально было исправлено командой `sudo apt-get install libxslt1.1`.
Добавляем себя в группу *vboxusers*
`sudo usermod -a -G vboxusers имя_пользователя`
#### Создание виртуальной машины
Для начала стоит отметить, что для управления виртуальными машинами через консоль используется одна команда VBoxManage (правда у неё очень много параметров).
Начнем.
1. Для начала создадим машину и сразу её зарегистрируем
`VBoxManage createvm -name имя_виртуальной_машины -register`
2. Далее необходимо создать диск для машины
`VBoxManage createhd --filename имя_диска --size размер_диска_в_мегабайтах`
Существует возможность выбрать тип диска VDI (VirtualBox), VMDK (VMWare), VHD (Microsoft Virtual PC). По умолчанию, конечно же, VDI :).
3. Делаем дополнительные настройки нашей виртуальной машины. Укажем:
* Тип гостевой ОС. Для получения списка поддерживаемых ОС выполните команду `VBoxManage list ostypes`
* Размер выделяемой памяти
* Наименование главного диска
* Возможность использовать VRDP (VirtualBox Remote Desktop Protocol)`VBoxManage modifyvm имя_виртуальной_машины --ostype тип_ОС --memory размер_памяти_в_мегабайтах --hda имя_диска --vrdp on`
4. Подключим образ диска, с которого будем ставить Windows XP
* Зарегестрируем DVD с образом дистрибутива системы
`VBoxManage openmedium путь_до_образа`
* Вставим наш диск в виртуальный привод
`VBoxManage modifyvm WindowsXP --dvd путь_до_образа`
5. Посмотрим на настройки нашей машины. Убеждаемся, что все нас устраивает и…
`VBoxManage showvminfo имя_машины`
#### … Запуск… Поехали
Чтобы запустить виртуальную машину надо выполнить
`VBoxManage startvm имя_машины --type vrdp`
Параметр *--type vrdp* нужен, чтобы подключиться к машине с помощью VRDP
Все, теперь осталось подключится к нашей машине, с помощью удаленного рабочего стола. Это можно сделать с помощью стандартных утилит: для windows это mstsc, для никсовых систем rdesktop.Т.к. у нас есть только консоль, то надо воспользоваться компьютером, имеющим графический рабочий стол.
Чтобы подключится, надо указывать IP хост машины и порт для данной виртуальной машины. В моем случае, я ничего не менял и использовал порт по умолчанию (3389). Чтобы изменить порт, выполните `VBoxManage --vrdpport порт`. Если у Вас установлено несколько виртуальных машин, то для того, чтобы подключаться к каждой их них, необходимо в настройках указать различные порты, например, для первой машины 3389, для второй 3390 и т.п.
#### Вместо эпилога
Теперь у нас запущена виртуальная машина и мы к ней спокойно можем подключаться используя протокол VRDP. Я спокойно установил Window XP, находясь за своим рабочим компьютером.
P.S. Windows XP была нужна только по одной причине. В проекте нужно было использовать MS SQL Server.
#### Полезные ссылки:
[Документация по VBoxManage](http://www.virtualbox.org/manual/UserManual.html#vboxmanage)
**UPD: [bsdemon](https://geektimes.ru/users/bsdemon/) предложил ещё один способ. Использовать [libvirt](http://libvirt.org/)** | https://habr.com/ru/post/60325/ | null | ru | null |
# Создание Ultimate Hacking Keyboard
*Перевод истории задумки и создания Ultimate Hacking Keyboard – необычной клавиатуры, проект которой вскоре планируют запустить на Kickstarter.*
#### Как я решил построить идеальную клавиатуру для разработчика с нуля
В августе 2007 на работе я заметил, насколько далека от идеала стандартная клавиатура для PC. Мне приходится сотни раз в день перемещать руки в разные её места, а ладони нужно держать близко друг к другу, что не очень удобно. Я подумал, что должен быть способ лучше.
Я начал думать, как можно улучшить клавиатуру и пришёл к этому:
Имея за плечами лишь опыт разработки софта и не зная ничего об электронике, мы сумели разработать и создать мощное и привлекательное устройство. Это был очень интересный опыт. В статье я хочу описать то, как это было сделано и как работает.
#### Как сделать клавиатуру?
Попробуем начать с чего-нибудь простого, например с Arduino, и постепенно повышать градус сложность, чтобы в конце прийти к Ultimate Hacking Keyboard.
#### Шаг 1: Клавиатура без клавиш
Сделаем USB-клавиатуру, которая выдаёт символ х раз в секунду. Для этого идеально подойдёт Arduino Micro. На ней стоит ATmega32U4 – это такой же AVR-микроконтроллер, который служит мозгом UHK.
С USB AVR микроконтроллером проще всего работать через библиотеку Lightweight USB Framework for AVRs (LUFA). При подключении к USB устройство должно передать особые структуры данных – USB-дескрипторы. Они сообщают компьютеры тип и свойства подключённого устройства и представлены в виде дерева. При этом устройство может реализовывать несколько функций.
Вот структура дескриптора для UHK:
```
Device descriptor
Configuration descriptor
Interface descriptor 0: GenericHID
Endpoint descriptor
Interface descriptor 1: Keyboard
Endpoint descriptor
Interface descriptor 2: Mouse
Endpoint descriptor
```
Стандартные клавиатуры выдают только один дескриптор. Но на нашей клавиатуре можно запрограммировать произвольные клавиши так, чтобы они выполняли роль мыши. А интерфейс GenericHID работает как канал для коммуникаций и передачи настроек. Полную реализацию для устройства на основе LUFA можно взять здесь.
Теперь можно ежесекундно отправлять символ х:
```
uint8_t isSecondElapsed = 0;
int main(void)
{
while (1) {
_delay_us(1000);
isSecondElapsed = 1;
}
}
bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo,
uint8_t* const ReportID,
const uint8_t ReportType,
void* ReportData,
uint16_t* const ReportSize)
{
USB_KeyboardReport_Data_t* KeyboardReport = (USB_KeyboardReport_Data_t*)ReportData;
if (isSecondElapsed) {
KeyboardReport->KeyCode[0] = HID_KEYBOARD_SC_X;
isSecondElapsed = 0;
}
*ReportSize = sizeof(USB_KeyboardReport_Data_t);
return false;
}
```
USB протокол работает по принципу поллинга, то есть компьютер опрашивает устройство через определённые промежутки времени (обычно 125 раз в секунду). Функция обратного вызова CALLBACK\_HID\_Device\_CreateHIDReport() отправляет сканкод символа на компьютер, если в переменной isSecondElapsed содержится 1. Переменной присваивается 1 в цикле каждую секунду, и 0 в функции обратного вызова.
#### Шаг 2: Клавиатура с четырьмя клавишами
Пока наша клавиатура не особенно полезна. Чтобы иметь возможность что-либо печатать, нужны клавиши. Их надо расположить по какой-то схеме (матрице). У 104-клавишной клавиатуры 6 рядов и 18 столбцов, но мы пока ограничимся матрицей 2х2. Схемка:
Как это выглядит на доске для прототипирования:
Если ROW1 соединён с PINA0, ROW2 с PINA1, COL1 с PORTB0 и COL2 с PORTB1, то код для опроса нажатий выглядит так:
```
/* Пин микроконтроллера, к которому подсоединён ряд или столбец */
typedef struct {
volatile uint8_t *Direction;
volatile uint8_t *Name;
uint8_t Number;
} Pin_t;
/* Эта часть матрицы хранится в Flash для экономии места в SRAM. */
typedef struct {
const uint8_t ColNum;
const uint8_t RowNum;
const Pin_t *ColPorts;
const Pin_t *RowPins;
} KeyMatrixInfo_t;
/* Эта часть матрицы хранится в SRAM */
typedef struct {
const __flash KeyMatrixInfo_t *Info;
uint8_t *Matrix;
} KeyMatrix_t;
const __flash KeyMatrixInfo_t KeyMatrix = {
.ColNum = 2,
.RowNum = 2,
.RowPins = (Pin_t[]) {
{ .Direction=&DDRA, .Name=&PINA, .Number=PINA0 },
{ .Direction=&DDRA, .Name=&PINA, .Number=PINA1 }
},
.ColPorts = (Pin_t[]) {
{ .Direction=&DDRB, .Name=&PORTB, .Number=PORTB0 },
{ .Direction=&DDRB, .Name=&PORTB, .Number=PORTB1 },
}
};
void KeyMatrix_Scan(KeyMatrix_t *KeyMatrix)
{
for (uint8_t Col=0; ColInfo->ColNum; Col++) {
const Pin\_t \*ColPort = KeyMatrix->Info->ColPorts + Col;
for (uint8\_t Row=0; RowInfo->RowNum; Row++) {
const Pin\_t \*RowPin = KeyMatrix->Info->RowPins + Row;
uint8\_t IsKeyPressed = \*RowPin->Name & 1<Number;
KeyMatrix\_SetElement(KeyMatrix, Row, Col, IsKeyPressed);
}
}
}
```
Код сканирует клавиатуру по одному столбцу за раз, и в столбце читает состояние отдельных переключателей. Затем состояние кнопок сохраняется в массиве. Внутри CALLBACK\_HID\_Device\_CreateHIDReport() на основании этого массива будут назначены соответствующие сканкоды.
#### Шаг 3: клавиатура из двух половинок
Продолжая путь к UHK, необходимо добавить вторую половину клавиатуры. Она будет содержать ещё одну матрицу клавиш, которая будет работать тем же методом. Интересным моментом будет общение двух половинок между собой. Три самых популярных протокола для соединения устройств — SPI, I2C и UART. В статье будет использован UART.
Двустороннее общение идёт через RX вправо и через TX влево. VCC и GND нужны для передачи питания. Для UART нужно, чтобы у всех устройств была одинаковая скорость передачи, количество бит данных и стоповых битов.
Пока что левая часть отправляет однобайтовые сообщения в правую через UART, представляющие собой нажатия и отпускания клавиш. Правая половина обрабатывает их и создаёт матрицу для полной клавиатуры.
Отправка сообщений с левой части:
```
USART_SendByte(IsKeyPressed<<7 | Row*COLS_NUM + Col);
Правая часть принимает сообщения:
void KeyboardRxCallback(void)
{
uint8_t Event = USART_ReceiveByte();
if (!MessageBuffer_IsFull(&KeyStateBuffer)) {
MessageBuffer_Insert(&KeyStateBuffer, Event);
}
}
```
Хэндлер прерывания KeyboardRxCallback() срабатывает при получении байта. Для скорейшего срабатывания хэндлеров полученные сообщения складываются в кольцевой буфер. Он обрабатывается из основного цикла, и матрица клавиатуры обновляется на основании этого сообщения.
Это упрощённое описание, результирующий протокол получится несколько посложнее. Надо будет обрабатывать многобайтовые сообщения, и проверять сообщения на правильность по контрольным суммам.
Прототип уже выглядит внушительно:
#### Шаг 4: LED дисплей
Мы захотели, чтобы у UHK было несколько раскладок, и чтобы пользователь знал, какая из них используется в данный момент. Для этого нам понадобится LED дисплей.
Дисплей представляет из себя матрицу 8х6
Каждые два ряда красных символов – это один из 14-сегментных дисплеев. Белые символы – три дополнительных статусных индикатора.
Для того, чтобы LED загорелся, на соответствующий столбец подаётся высокое напряжение, а на ряд – низкое. Из этого следует, что работать может только один столбец. Можно решить, что из-за этого нельзя работать со всеми дисплеями одновременно – но суть в том, что они просто мигают настолько быстро, что этого не замечает глаз.
Матрица LED управляется двумя интегральными микросхемами (ИС), одна из которых управляет рядами, а другая – столбцами. Столбцами управляет PCA9634 I2C:
Рядами управляет TPIC6C595:
Код:
```
uint8_t LedStates[LED_MATRIX_ROWS_NUM];
void LedMatrix_UpdateNextRow(bool IsKeyboardColEnabled)
{
TPIC6C595_Transmit(LedStates[ActiveLedMatrixRow]);
PCA9634_Transmit(1 << ActiveLedMatrixRow);
if (++ActiveLedMatrixRow == LED_MATRIX_ROWS_NUM) {
ActiveLedMatrixRow = 0;
}
}
```
LedMatrix\_UpdateNextRow() вызывается каждую миллисекунду и обновляет ряд матрицы. Массив LedStates сохраняет состояния отдельных LED, и обновляется через UART на основании сообщений с правой стороны клавиатуры примерно так же, как обрабатываются нажатия клавиш.
#### Общий план
Вот мы и построили компоненты для нашей клавиатуры. Внутренности клавиатуры представляют из себя компьютерную сеть в миниатюре: множество узлов, соединённых между собою.
Надо упомянуть и софт, работающий с клавиатурой на стороне компьютера – UHK Agent. В отличие от железной части, Agent пока в рудиментарном состоянии. Но основные принципы его работы уже определены, о чём я и хочу упомянуть.
UHK Agent – приложение для настроек клавиатуры под нужды пользователя. Хотя это и толстый (rich) клиент, Agent использует веб-технологии и работает на платформе webkit. С клавиатурой он общается через библиотеку node-usb. Он Express.js для доступа к нему сторонних приложений через REST API. Также он Angular.js для рисования красивого интерфейса пользователя.
```
var enumerationModes = {
'keyboard' : 0,
'bootloader-right' : 1,
'bootloader-left' : 2
};
function sendReenumerateCommand(enumerationMode, callback)
{
var AGENT_COMMAND_REENUMERATE = 0;
sendAgentCommand(AGENT_COMMAND_REENUMERATE, enumerationMode, callback);
}
function sendAgentCommand(command, arg, callback)
{
setReport(new Buffer([command, arg]), callback);
}
function setReport(message, callback)
{
device.controlTransfer(
0x21, // bmRequestType (константа этого запроса)
0x09, // bmRequest (константа этого запроса)
0, // wValue (MSB тип отчёта, LSB номер отчёта)
interfaceNumber, // wIndex (номер интерфейса)
message, // сообщение
callback
);
}
```
У каждой команды есть 8-битный идентификатор и набор аргументов, зависящих от команды. Сейчас реализована только команда re-enumerate.
Что же умеет этот софт? Agent может отображать износ кнопок и предупреждать о необходимости их замены. Он может предоставлять интерфейс для настройки различных раскладок. Задавать скорость и ускорение курсора мыши. И много всего другого.
#### Создание прототипа
На прототипы уходит очень много сил. Для начала нужно определиться с механическим дизайном – это само по себе сложная задача, для которой нужно подготовить множество пластиковых деталей, вырезать лазером детали из листов нержавеющей стали, выточить высокоточные стальные направляющие и приспособить неодимовые магниты, которые будут скреплять две половинки. Предварительно все детали просчитываются в CAD.
Корпус клавиатуры, распечатанный на 3D-принтере:
На основании механического дизайна и схемы нужно изготовить печатную плату. Правая часть выглядит в KiCad так:
Делаем плату и вручную припаиваем элементы:
Наконец, изготовив все части, напечатав и отшлифовав пластиковые детали, и собрав всё это вместе, мы получаем работающий прототип клавиатуры:
#### Заключение
Я сравниваю клавиатуры для разработчиков с музыкальными инструментами. Клавиатура – довольно интимный объект. Мы используем их весь день для создания завтрашних программ, печатая один символ за другим.
Поэтому для меня разработка UHK – это привилегия, и несмотря на все трудности, это волнующее приключение и прекрасный опыт в обучении новому.
За подробной информацией я приглашаю вас посетить сайт [ultimatehackingkeyboard.com](https://ultimatehackingkeyboard.com), и там же вы сможете подписаться на уведомление о начале нашей краудфандинговой компании. | https://habr.com/ru/post/376919/ | null | ru | null |
# Как Android-троян Gustuff снимает сливки (фиат и крипту) с ваших счетов
Буквально на днях Group-IB [сообщала](https://www.group-ib.ru/media/gustuff/) об активности мобильного Android-трояна Gustuff. Он работает исключительно на международных рынках, атакуя клиентов 100 крупнейших иностранных банков, пользователей мобильных 32 криптокошельков, а также крупных e-commerce ресурсов. А вот разработчик Gustuff — русскоязычный киберпреступник под ником Bestoffer. Еще недавно он нахваливал свой троян как «серьезный продукт для людей со знаниями и опытом».
Специалист по анализу вредоносного кода Group-IB **Иван Писарев** в своем исследовании подробно рассказывает о том, как работает Gustuff и в чем его опасность.
За кем охотится Gustuff
-----------------------
Gustuff относится к новому поколению вредоносных программ с полностью автоматизированными функциями. По словам разработчика, троян стал новой улучшенной версией вредоносной программы AndyBot, которая с ноября 2017 года атакует телефоны с ОС Android и крадет деньги через фишинговые веб-формы, маскирующиеся под мобильные приложения известных международных банков и платежных систем. Bestoffer сообщал, что цена аренды «Gustuff Bot» составляла $800 в месяц.
Анализ сэмпла Gustuff показал, что потенциально троян нацелен на клиентов, использующих мобильные приложения крупнейших банков, таких как Bank of America, Bank of Scotland, J.P.Morgan, Wells Fargo, Capital One, TD Bank, PNC Bank, а также на криптокошельки Bitcoin Wallet, BitPay, Cryptopay, Coinbase и др.
Изначально созданный как классический банковский троян, в текущей версии Gustuff значительно расширил список потенциальных объектов для атаки. Кроме Android-приложений банков, финтех-компаний и криптосервисов, Gustuff нацелен на пользователей приложений маркетплейсов, онлайн-магазинов, платежных систем и мессенджеров. В частности, PayPal, Western Union, eBay, Walmart, Skype, WhatsApp, Gett Taxi, Revolut и других.
Точка входа: расчет на массовое заражение
-----------------------------------------
Для Gustuff характерен «классический» вектор проникновения на Android-смартфоны через СМС-рассылки со ссылками на APK. При заражении Android-устройства трояном по команде сервера может произойти дальнейшее распространение Gustuff'а по базе контактов инфицированного телефона либо по базе данных сервера. Функциональные возможности Gustuff рассчитаны на массовое заражение и максимальную капитализацию бизнеса своих операторов – в нем присутствует уникальная функция «автозалива» в легитимные мобильные банковские приложения и криптокошельки, что позволяет ускорить и масштабировать кражу денег.
Исследование трояна показало, что функция автозалива реализована в нем при помощи Accessibility Service — сервиса для людей с ограниченными возможностями. Gustuff – не первый троян, который успешно обходит защиту от взаимодействия с элементами окон других приложений с помощью данного сервиса Android. Однако использование Accessibility Service в сочетании с автозаливом остается до сих пор достаточно редким явлением.
После загрузки на телефон жертвы Gustuff, используя Accessibility Service, получает возможность взаимодействовать с элементами окон других приложений (банковских, криптовалютных, а также приложений для онлайн-шоппинга, обмена сообщениями и др.), выполняя необходимые для злоумышленников действия. К примеру, по команде сервера троян может нажимать на кнопки и изменять значения текстовых полей в банковских приложениях. Использование механизма Accessibility Service позволяет трояну обходить механизмы защиты, используемые банками для противодействия мобильным троянам прошлого поколения, а также изменения в политике безопасности, внедренные Google в новые версии ОС Android. Так, Gustuff «умеет» отключать защиту Google Protect: по заверениям автора, данная функция срабатывает в 70% случаев.
Также Gustuff может демонстрировать фейковые PUSH-уведомления с иконками легитимных мобильных приложений. Пользователь кликает на PUSH-уведомление и видит загруженное с сервера фишинговое окно, куда сам вводит запрашиваемые данные банковской карты или криптокошелька. В другом сценарии работы Gustuff происходит открытие приложения, от имени которого демонстрировалось PUSH-уведомление. В этом случае вредоносная программа по команде сервера через Accessibility Service может заполнять поля формы банковского приложения для мошеннической транзакции.
В функциональные возможности Gustuff также входят отправка на сервер информации о заражённом устройстве, возможность чтения/отправления СМС-сообщений, отправление USSD-запросов, запуск SOCKS5 Proxy, переход по ссылке, отправление файлов (в том числе фотосканов документов, скриншотов, фотографий) на сервер, сброс устройства до заводских настроек.
Анализ вредоносной программы
----------------------------
Перед установкой вредоносного приложения ОС Android демонстрирует пользователю окно, содержащее в себе список запрашиваемых Gustuff'ом прав:
Установка приложения произойдет только после получения согласия пользователя. После запуска приложения троян покажет пользователю окно:
После чего удалит свою иконку.
Gustuff упакован, по словам автора, упаковщиком от FTT. После запуска приложение периодически обращается к CnC- серверу с целью получения команд. В нескольких исследованных нами файлах в качестве управляющего сервера использовался IP-адрес **88.99.171[.]105** (в дальнейшем будем обозначать как **<%CnC%>**).
После запуска программа начинает отправку сообщений серверу **http://<%CnC%>/api/v1/get.php**.
В качестве ответа ожидается JSON следующего формата:
```
{
"results" : "OK",
"command":{
"id": "<%id%>",
"command":"<%command%>",
"timestamp":"<%Server Timestamp%>",
"params":{
<%Command parameters as JSON%>
},
},
}
```
При каждом обращении приложение отправляет информацию о зараженном устройстве. Формат сообщения представлен ниже. Стоит отметить, что поля **full**, **extra**, **apps** и **permission** – опциональные и будут отправлены только в случае команды-запроса от CnC.
```
{
"info":
{
"info":
{
"cell":<%Sim operator name%>,
"country":<%Country ISO%>,
"imei":<%IMEI%>,
"number":<%Phone number%>,
"line1Number":<%Phone number%>,
"advertisementId":<%ID%>
},
"state":
{
"admin":<%Has admin rights%>,
"source":<%String%>,
"needPermissions":<%Application needs permissions%>,
"accesByName":<%Boolean%>,
"accesByService":<%Boolean%>,
"safetyNet":<%String%>,
"defaultSmsApp":<%Default Sms Application%>,
"isDefaultSmsApp":<%Current application is Default Sms Application%>,
"dateTime":<%Current date time%>,
"batteryLevel":<%Battery level%>
},
"socks":
{
"id":<%Proxy module ID%>,
"enabled":<%Is enabled%>,
"active":<%Is active%>
},
"version":
{
"versionName":<%Package Version Name%>,
"versionCode":<%Package Version Code%>,
"lastUpdateTime":<%Package Last Update Time%>,
"tag":<%Tag, default value: "TAG"%>,
"targetSdkVersion":<%Target Sdk Version%>,
"buildConfigTimestamp":1541309066721
},
},
"full":
{
"model":<%Device Model%>,
"localeCountry":<%Country%>,
"localeLang":<%Locale language%>,
"accounts":<%JSON array, contains from "name" and "type" of accounts%>,
"lockType":<%Type of lockscreen password%>
},
"extra":
{
"serial":<%Build serial number%>,
"board":<%Build Board%>,
"brand":<%Build Brand%>,
"user":<%Build User%>,
"device":<%Build Device%>,
"display":<%Build Display%>,
"id":<%Build ID%>,
"manufacturer":<%Build manufacturer%>,
"model":<%Build model%>,
"product":<%Build product%>,
"tags":<%Build tags%>,
"type":<%Build type%>,
"imei":<%imei%>,
"imsi":<%imsi%>,
"line1number":<%phonenumber%>,
"iccid":<%Sim serial number%>,
"mcc":<%Mobile country code of operator%>,
"mnc":<%Mobile network codeof operator%>,
"cellid":<%GSM-data%>,
"lac":<%GSM-data%>,
"androidid":<%Android Id%>,
"ssid":<%Wi-Fi SSID%>
},
"apps":{<%List of installed applications%>},
"permission":<%List of granted permissions%>
}
```
### Хранение конфигурационных данных
Gustuff хранит важную для работы информацию в preference-файле. Имя файла, как и имена параметров в нем – результат вычисления MD5-суммы от строки **15413090667214.6.1<%name%>**, где **<%name%>** — исходное имя-значение. Python-интерпретация функции генерации имени:
```
nameGenerator(input):
output = md5("15413090667214.6.1" + input)
```
В дальнейшем будем обозначать как **nameGenerator(input)**.
Таким образом, имя первого файла: **nameGenerator(«API\_SERVER\_LIST»)**, он содержит значения со следующими именами:
| **Имя переменной** | **Значение** |
| --- | --- |
| **nameGenerator(«API\_SERVER\_LIST»)** | Содержит список CnC-адресов в виде массива. |
| **nameGenerator(«API\_SERVER\_URL»)** | Содержит CnC-адрес. |
| **nameGenerator(«SMS\_UPLOAD»)** | Флаг по умолчанию установлен. Если флаг установлен – отправляет СМС-сообщения на CnC. |
| **nameGenerator(«SMS\_ROOT\_NUMBER»)** | Номер телефона, на который будут отправлены SMS-сообщений принятые зараженным устрйоством. По умолчанию null. |
| **nameGenerator(«SMS\_ROOT\_NUMBER\_RESEND»)** | Флаг по умолчанию сброшен. Если установлен – при получении зараженным устройством SMS оно будет отправлено на root-номер. |
| **nameGenerator(«DEFAULT\_APP\_SMS»)** | Флаг по умолчанию сброшен. Если данный флаг установлен – приложение будет обрабатывать входящие SMS- сообщения. |
| **nameGenerator(«DEFAULT\_ADMIN»)** | Флаг по умолчанию сброшен. Если флаг установлен – приложение имеет права администратора. |
| **nameGenerator(«DEFAULT\_ACCESSIBILITY»)** | Флаг по умолчанию сброшен. Если флаг установлен – запущен сервис, использующий Accessibility Service. |
| **nameGenerator(«APPS\_CONFIG»)** | JSON-объект, содержит список действий, которые необходимо выполнить при срабатывании Accessibility-события, связанного с определенным приложением. |
| **nameGenerator(«APPS\_INSTALLED»)** | Хранит список установленных на устройстве приложений. |
| **nameGenerator(«IS\_FIST\_RUN»)** | Флаг при первом запуске сбрасывается. |
| **nameGenerator(«UNIQUE\_ID»)** | Содержит уникальный идентификатор. Генерируется при первом запуске бота. |
### Модуль обработки команд от сервера
Приложение хранит адреса CnC-серверов в виде массива закодированных по **Base85** строк. Список CnC — серверов может быть изменен при поступлении соответствующей команды, в таком случае адреса будут хранится в preference-файле.
В ответ на запрос сервер отправляет приложению команду. Стоит отметить, что команды и параметры представлены в JSON-формате. Приложение может обрабатывать следующие команды:
| **Команда** | **Описание** |
| --- | --- |
| **forwardStart** | Начать отправление получаемых зараженным устройством SMS-сообщений на CnC-сервер. |
| **forwardStop** | Остановить отправление получаемых зараженным устройством SMS-сообщений на CnC-сервер. |
| **ussdRun** | Выполнить USSD-запрос. Номер, на который необходимо совершить USSD-запрос находится в JSON-поле «number». |
| **sendSms** | Отправить одно SMS-сообщение (при необходимости сообщение «дробится» на части). В качестве параметра команда принимает JSON-объект, содержащий поля «to» — номер назначения и «body» — тело сообщения. |
| **sendSmsAb** | Отправить SMS-сообщения (при необходимости сообщение «дробится» на части) всем из списка контактов зараженного устройства. Интервал между отправлением сообщений – 10 секунд. Тело сообщения находится в JSON-поле «body» |
| **sendSmsMass** | Отправить SMS-сообщения (при необходимости сообщение «дробится» на части) контактам, указанным в параметрах команды. Интервал между отправлением сообщений – 10 секунд. В качестве параметра команда принимает JSON-массив (поле «sms»), элементы которого содержат поля «to» — номер назначения и «body» — тело сообщения. |
| **changeServer** | Данная команда в качестве параметра может принимать значение с ключом «url» — тогда бот изменит значение nameGenerator(“SERVER\_URL”), либо «array» — тогда бот запишет массив в nameGenerator (“API\_SERVER\_LIST”) Таким образом приложение меняет адрес CnC-серверов. |
| **adminNumber** | Команда предназначена для работы с root-номером. Команда принимает JSON-объект со следующими параметрами: «number» — изменить nameGenerator(“ROOT\_NUMBER”) на полученное значение, «resend» — изменить nameGenerator(“SMS\_ROOT\_NUMBER\_RESEND”), «sendId» — отправить на nameGenerator(“ROOT\_NUMBER”) uniqueID. |
| **updateInfo** | Отправить на сервер информацию о зараженном устройстве. |
| **wipeData** | Команда предназначена для удаления пользовательских данных. В зависимости от какого имени было запущено приложение происходит либо полное стирание данных с перезагрузкой устройства (primary user), либо удаление только пользовательских данных (secondary user). |
| **socksStart** | Запустить Proxy-модуль. Работа модуля описана в отдельном разделе. |
| **socksStop** | Остановить работу Proxy-модуля. |
| **openLink** | Перейти по ссылке. Ссылка находится в JSON-параметре по ключу «url». Для открытия ссылки используется «android.intent.action.VIEW». |
| **uploadAllSms** | Отправить на сервер все принятые устройством SMS-сообщения. |
| **uploadAllPhotos** | Отправить на URL изображения с зараженного устройства. URL приходит как параметр. |
| **uploadFile** | Отправить на URL файл с зараженного устройства. URL приходит как параметр. |
| **uploadPhoneNumbers** | Отправить на сервер номера телефонов из списка контактов. Если в качестве параметра приходит JSON-объект значение с ключом «ab», приложение получает список контактов из телефонной книги. Если в качестве параметра приходит JSON-объект с ключом «sms», приложение читает список контактов из отправителей SMS-сообщений. |
| **changeArchive** | Приложение загружает файл с адреса, который приходит в качестве параметра по ключу «url». Загруженный файл сохраняется с именем «archive.zip». После этого приложение разархивирует файл, при необходимости используя пароль для архива «b5jXh37gxgHBrZhQ4j3D». Разархивированный файлы сохраняет в директорию [external storage]/hgps. В данной директории приложение хранит web-фейки (описано далее). |
| **actions** | Команда предназначена для работы с Action Service, который описан в отдельном разделе. |
| **test** | Ничего не делает. |
| **download** | Команда предназначена для загрузки файла с удаленного сервера и сохранении его в директорию «Downloads». URL и имя файла приходят в качестве параметра, поля в JSON-объекте параметре соответственно: «url» и «fileName». |
| **remove** | Удаляет файл из директории «Downloads». Имя файла приходит в JSON-параметре с ключом «fileName». Стандартное имя файла – «tmp.apk». |
| **notification** | Показать уведомление с текстами описания и заголовка, определяемыми управляющим сервером. |
Формат команды **notification**:
```
{
"results" : "OK",
"command":{
"id": <%id%>,
"command":"notification",
"timestamp":<%Server Timestamp%>,
"params":{
"openApp":<%Open original app or not%>,
"array":[
{"title":<%Title text%>,
"desc":<%Description text%>,
"app":<%Application name%>}
]
},
},
}
```
Уведомление, создаваемое исследуемым файлом, выглядит идентично уведомлениям, создаваемым приложением, указанным в поле **app**. Если значение поля **openApp** — True, при открытии уведомления запускается приложение, указанное в поле **app**. Если значение поля **openApp** — False, то:
* открывается фишинговое окно, содержимое которого загружается из директории **<%external storage%>/hgps/<%filename%>**
* открывается фишинговое окно, содержимое которого загружается с сервера **<%url%>?id=<%Bot id%>&app=<%Application name%>**
* открывается фишинговое окно, замаскированное под Google Play Card, с возможностью ввести данные карты.
Результат исполнения любой команды приложение отправляет на **<%CnC%>\set\_state.php** в виде JSON-объекта следующего формата:
```
{
"command":
{
"command":<%command%>,
"id":<%command_id%>,
"state":<%command_state%>
}
"id":<%bot_id%>
}
```
**ActionsService**
В список команд, которые обрабатывает приложение, входит **action**. При получении команды модуль обработки команд обращается к данному сервису с целью исполнения расширенной команды. В качестве параметра сервис принимает JSON-объект. Сервис может выполнять следующие команды:
**1.** **PARAMS\_ACTION** — при получении такой команды сервис в первую очередь получает из JSON- параметра значение по ключу Type, может быть следующим:
* **serviceInfo** – подкоманда получает из JSON-параметра значение по ключу **includeNotImportant**. Если флаг равен True — приложение устанавливает флаг **FLAG\_ISOLATED\_PROCESS** на сервис, использующий Accessibility Service. Таким образом, сервис будет запущен в отдельном процессе.
* **root** — получить и отправить на сервер информацию об окне, которое сейчас в фокусе. Приложение получает информацию при помощи класса AccessibilityNodeInfo.
* **admin** — запросить права администратора.
* **delay** — приостановить работу ActionsService на то количество миллисекунд, которое указано в параметре по ключу «data».
* **windows** — отправить список видимых пользователю окон.
* **install** — установить приложение на зараженное устройство. Название пакета — архива находится в ключе «fileName». Сам архив находится в директории Downloads.
* **global** – подкоманда предназначена для осуществления перехода с текущего окна:
+ на меню Quick Settings
+ назад
+ домой
+ к уведомлениям
+ к окну недавно открытых приложений
* **launch** — запустить приложение. Наименование приложения приходит как параметр по ключу **data**.
* **sounds** — изменить режим звука на silence.
* **unlock** — включает подсветку экрана и клавиатуры на полную яркость. Приложение выполняет данное действие при помощи WakeLock, в качестве тэга указывает строку [Application lable]:INFO
* **permissionOverlay** — функция не реализована (ответ на исполнение команды — {«message»:«Not support»} или {«message»:«low sdk»})
* **gesture** — функция не реализована (ответ на исполнение команды — {«message»:«Not support»}или {«message»:«Low API»})
* **permissions** — данная команда необходима для запроса прав для приложения. Однако функция запроса не реализована, таким образом команда не имеет смысла. Список запрашиваемых прав приходит как JSON-массив с ключом «permissions». Стандартный список:
+ android.permission.READ\_PHONE\_STATE
+ android.permission.READ\_CONTACTS
+ android.permission.CALL\_PHONE
+ android.permission.RECEIVE\_SMS
+ android.permission.SEND\_SMS
+ android.permission.READ\_SMS
+ android.permission.READ\_EXTERNAL\_STORAGE
+ android.permission.WRITE\_EXTERNAL\_STORAGE
* **open** — вывести на экран фишинговое окно. В зависимости от приходящего от сервера параметра приложение может демонстрировать следующие фишинговые окна:
+ Показать фишинговое окно, содержимое которого прописано в файле в директории **<%external directory%>/hgps/<%param\_filename%>**. Результат взаимодействия пользователя с окном будет отправлен по адресу **<%CnC%>/records.php**
+ Показать фишинговое окно, содержимое которого предварительно грузится с адреса **<%url\_param%>?id=<%bot\_id%>&app=<%packagename%>**. Результат взаимодействия пользователя с окном будет отправлен по адресу **<%CnC%>/records.php**
+ Показать фишинговое окно, замаскированное под Google Play Card.
* **interactive** — команда предназначена для взаимодействия с элементами окон других приложений при помощи AcessibilityService. Для взаимодействия в программе реализован специальный сервис. Исследуемое приложение может взаимодействовать с окнами:
+ Активным на данный момент. В таком случае параметр содержит id либо text (наименование) объекта, с которым необходимо взаимодействовать.
+ Видимыми пользователю на момент исполнения команды. Приложение выбирает окна по id.
Получив объекты **AccessibilityNodeInfo** для интересующих элементов окна, приложение в зависимости от параметров может выполнять действия:
+ focus — установить фокус на объект.
+ click — кликнуть на объект.
+ actionId — выполнить действие по ID.
+ setText — изменить текст объекта. Изменение текста возможно двумя способами: выполнить действие **ACTION\_SET\_TEXT** (если версия Android зараженного устройства – моложе либо равна **LOLLIPOP**), либо поместив в буфер обмена строку и вставив его в объект (для версий старше). Данная команда может быть использована для изменения данных в банковском приложении.
**2.** **PARAMS\_ACTIONS** — то же, что и **PARAMS\_ACTION**, только приходит JSON-массив команд.
Кажется, многим будет интересно, как выглядит функция взаимодействия с элементами окна другого приложения. Вот таким образом реализована данная функциональная возможность в Gustuff'е:
```
boolean interactiveAction(List aiList, JSONObject action, JsonObject res) {
int count = action.optInt("repeat", 1);
Iterator aiListIterator = ((Iterable)aiList).iterator();
int count = 0;
while(aiListIterator.hasNext()) {
Object ani = aiListIterator.next();
if(1 <= count) {
int index;
for(index = 1; true; ++index) {
if(action.has("focus")) {
if(((AccessibilityNodeInfo)ani).performAction(1)) {
++count;
}
}
else if(action.has("click")) {
if(((AccessibilityNodeInfo)ani).performAction(16)) {
++count;
}
}
else if(action.has("actionId")) {
if(((AccessibilityNodeInfo)ani).performAction(action.optInt("actionId"))) {
++count;
}
}
else if(action.has("setText")) {
customHeader ch = CustomAccessibilityService.a;
Context context = this.getApplicationContext();
String text = action.optString("setText");
if(performSetTextAction(ch, context, ((AccessibilityNodeInfo)ani), text)) {
++count;
}
}
if(index == count) {
break;
}
}
}
((AccessibilityNodeInfo)ani).recycle();
}
res.addPropertyNumber("res", Integer.valueOf(count));
}
```
Функция замены текста:
```
boolean performSetTextAction(Context context, AccessibilityNodeInfo ani, String text) {
boolean result;
if(Build$VERSION.SDK_INT >= 21) {
Bundle b = new Bundle();
b.putCharSequence("ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE", ((CharSequence)text));
result = ani.performAction(0x200000, b); // ACTION_SET_TEXT
}
else {
Object clipboard = context.getSystemService("clipboard");
if(clipboard != null) {
((ClipboardManager)clipboard).setPrimaryClip(ClipData.newPlainText("autofill_pm", ((CharSequence)text)));
result = ani.performAction(0x8000); // ACTION_PASTE
}
else {
result = false;
}
}
return result;
}
```
Таким образом, при правильной настройке управляющего сервера Gustuff способен заполнить текстовые поля в банковском приложении и нажать на необходимые для совершения транзакции кнопки. Трояну даже не нужно проходить авторизацию в приложении — достаточно отправить команду на демонстрацию PUSH-уведомления с последующим открытием ранее установленного банковского приложения. Пользователь сам пройдет авторизацию, после чего Gustuff сможет произвести автозалив.
### Модуль обработки СМС-сообщений
Приложение устанавливает обработчик события на принятие зараженным устройством СМС-сообщений. Исследуемое приложение может принимать команды от оператора, которые приходят в теле СМС- сообщения. Команды приходят в формате:
**7!5=<%Base64 encoded command%>**
Приложение ищет во всех приходящих СМС-сообщениях строку **7!5=**, при обнаружении строки – декодирует из Base64 строку по смещению 4 и исполняет команду. Команды аналогичны командам с CnC. Результат исполнения отправляется на тот же номер, с которого поступила команда. Формат ответа:
**7\*5=<%Base64 encode of «result\_code command»%>**
Опционально приложение может отправлять все принимаемые сообщения на Root-номер. Для этого в preference-файле должен быть указан Root-номер и установлен флаг редиректа сообщений. СМС-сообщение отправляется на номер злоумышленника в формате:
**<%From number%> — <%Time, format: dd/MM/yyyy HH:mm:ss%> <%SMS body%>**
Также опционально приложение может отправлять сообщения на CnC. СМС-сообщение отправляется на сервер в JSON-формате:
```
{
"id":<%BotID%>,
"sms":
{
"text":<%SMS body%>,
"number":<%From number%>,
"date":<%Timestamp%>
}
}
```
Если установлен флаг **nameGenerator(«DEFAULT\_APP\_SMS»)** – приложение останавливает обработку СМС-сообщения и очищает список входящих сообщений.
### Proxy-модуль
В исследуемом приложении присутствует Backconnect Proxy модуль (далее Proxy-модуль), который имеет отдельный класс, включающий в себя статические поля с конфигурацией. Конфигурационные данные хранятся в семпле в открытом виде:
Все действия, совершаемые Proxy-модулем, логируются в файлы. Для этого приложение в External Storage создает директорию с названием «logs» (поле ProxyConfigClass.logsDir в конфигурационном классе), в которой хранятся лог-файлы. Логирование происходит в файлы с именами:
1. **main.txt** – в данный файл происходит логирование работы класса с названием CommandServer. В дальнейшем логирование строки str в данный файл будем обозначать как mainLog(str).
2. **session-<%id%>.txt** — в данный файл происходит сохранение лог-данных, связанных с определенной сессией проксирования. В дальнейшем логирование строки str в данный файл будем обозначать как sessionLog (str).
3. **server.txt** – в данный файл происходит логирование всех данных, записываемых в вышеописанные файлы.
Формат лог-данных:
<%Date%> [Thread[<%thread id%>], id[]]: log-string
Возникающие в процессе работы Proxy-модуля исключения также логируются в файл. Для этого приложение формирует JSON-объект формата:
```
{
"uncaughtException":<%short description of throwable%>
"thread":<%thread%>
"message":<%detail message of throwable%>
"trace": //Stack trace info
[
{
"ClassName":
"FileName":
"LineNumber":
"MethodName":
},
{
"ClassName":
"FileName":
"LineNumber":
"MethodName":
}
]
}
```
После чего конвертирует его в строковое представление и логирует.
Запуск Proxy-модуля осуществляется после поступления соответсвующей комнады. При поступлении команды на запуск Proxy-модуля приложение запускает сервис с названием **MainService**, который отвечает за управление работой Proxy-модуля – его запуск и остановку.
Этапы запуска сервиса:
**1.** Запускает таймер, срабатывающий раз в минуту и проверяющий активность Proxy-модуля. Если модуль не активен – запускает его.
Также при срабатывании события **android.net.conn.CONNECTIVITY\_CHANGE** происходит запуск Proxy-модуля.
**2.** Приложение создает wake-lock с параметром **PARTIAL\_WAKE\_LOCK** и захватывает его. Таким образом не позволяет перейти CPU устройства в спящий режим.
**3.** Запускает класс обработки команд Proxy-модуля, предварительно логируя строку **mainLog(«start server»)** и
**Server::start() host[<%proxy\_cnc%>], commandPort[<%command\_port%>], proxyPort[<%proxy\_port%>]**
где **proxy\_cnc, command\_port и proxy\_port** – параметры, полученные из конфигурации Proxy- сервера.
Класс обработки команд имеет название **CommandConnection**. Сразу после запуска выполняет следующие действия:
**4.** Подключается к **ProxyConfigClass.host**: **ProxyConfigClass.commandPort** и отправляет туда данные о зараженном устройстве в JSON-формате:
```
{
"id":<%id%>,
"imei":<%imei%>,
"imsi":<%imsi%>,
"model":<%model%>,
"manufacturer":<%manufacturer%>,
"androidVersion":<%androidVersion%>,
"country":<%country%>,
"partnerId":<%partnerId%>,
"packageName":<%packageName%>,
"networkType":<%networkType%>,
"hasGsmSupport":<%hasGsmSupport%>,
"simReady":<%simReady%>,
"simCountry":<%simCountry%>,
"networkOperator":<%networkOperator%>,
"simOperator":<%simOperator%>,
"version":<%version%>
}
```
Где:
* id – идентификатор, пытается получить из Shared Preference файла с именем «x» значение с полем «id». Если данное значение получить не удалось — генерирует новое. Таким образом, Proxy-модуль имеет свой идентификатор, который генерируется аналогично Bot ID.
* imei — IMEI устройства. Если в процессе получения значения произошла ошибка — вместо этого поля будет записано текстовое сообщение об ошибке.
* imsi — International Mobile Subscriber Identity устройства. Если в процессе получения значения произошла ошибка — вместо этого поля будет записано текстовое сообщение об ошибке.
* model — The end-user-visible name for the end product.
* manufacturer — The manufacturer of the product/hardware (Build.MANUFACTURER).
* androidVersion — строка в формате "<%release\_version%> (<%os\_version%>),<%sdk\_version%>"
* country — текущее местоположение устройства.
* partnerId – пустая строка.
* packageName – package name.
* networkType — тип текущего сетевого соединения (пример: «WIFI», «MOBILE»). В случае ошибки возвращает null.
* hasGsmSupport – true – если телефон поддерживает GSM, иначе false.
* simReady – состояние SIM-карты.
* simCountry — ISO-код страны (на основании провайдера сим-карты).
* networkOperator — наименование оператора. Если в процессе получения значения произошла ошибка — вместо этого поля будет записано текстовое сообщение об ошибке.
* simOperator — The Service Provider Name (SPN). Если в процессе получения значения произошла ошибка — вместо этого поля будет записано текстовое сообщение об ошибке.
* version — данное поле хранится в конфиг-классе, для исследуемых версий бота оно было равно «1.6».
**5.** Переходит в режим ожидания команд от сервера. Команды от сервера поступают в формате:
* 0 offset – command
* 1 offset – sessionId
* 2 offset – length
* 4 offset — data
При поступлении команды приложение логирует:
**mainLog(«Header { sessionId<%id%>], type[<%command%>], length[<%length%>] }»)**
Возможны следующие команды от сервера:
| Name | Command | Data | Description |
| --- | --- | --- | --- |
| **connectionId** | 0 | Connection ID | Создать новое подключение |
| **SLEEP** | 3 | Time | Приостановить работу Proxy-модуля |
| **PING\_PONG** | 4 | - | Отправить PONG-сообщение |
PONG-сообщение состоит из 4 байт и выглядит следующим образом: **0x04000000**.
При поступлении команды connectionId (на создание нового подключения) **CommandConnection** создает экземпляр класса **ProxyConnection**.
* В проксировании принимают участие два класса: **ProxyConnection** и **end**. При создании класса **ProxyConnection** происходит подключение к адресу **ProxyConfigClass.host**: **ProxyConfigClass.proxyPort** и передача JSON-объекта:
```
{
"id":<%connectionId%>
}
```
В ответ сервер присылает SOCKS5-сообщение, которое содержит адрес удаленного сервера, с которым необходимо установить соединение. Взаимодействие с эти сервером происходит посредством класса **end**. Схематично установку соединения можно представить следующим образом:
Сетевые взаимодействия
-----------------------
Для предотвращения анализа трафика сетевыми снифферами взаимодействие между CnC-сервером и приложением может быть защищено посредством протокола SSL. Все передаваемые данные как с сервера так и на сервер представлены в JSON-формате. Приложение в ходе работы выполняет следующие запросы:
* **http://<%CnC%>/api/v1/set\_state.php** — результат исполнения команды.
* **http://<%CnC%>/api/v1/get.php** — получение команды.
* **http://<%CnC%>/api/v1/load\_sms.php** — выгрузка SMS-сообщений с зараженного устройства.
* **http://<%CnC%>/api/v1/load\_ab.php** — выгрузка списка контактов с зараженного устройства.
* **http://<%CnC%>/api/v1/aevents.php** – запрос производится при обновлении параметров, находящихся в preference-файле.
* **http://<%CnC%>/api/v1/set\_card.php** — выгрузка данных, полученных при помощи фишинг-окна, маскирующегося под Google Play Market.
* **http://<%CnC%>/api/v1/logs.php** – выгрузка лог-данных.
* **http://<%CnC%>/api/v1/records.php** – выгрузка данных, полученных при помощи фишинговых окон.
* **http://<%CnC%>/api/v1/set\_error.php** – оповещение о возникшей ошибке.
Рекомендации
------------
В целях защиты своих клиентов от угрозы мобильных троянов компании должны использовать комплексные решения, которые позволяют без установки дополнительного программного обеспечения на устройства пользователей, отслеживать и предупреждать вредоносную активность.
Для этого сигнатурные методы обнаружения мобильных троянов необходимо усиливать технологиями анализа поведения как клиента, так и самого приложения. Так же защита должна включать в себя функцию идентификации устройств с использованием технологии цифрового отпечатка, что позволит понять, когда учётная запись используется с нетипичного устройства и уже попала в руки мошенника.
Принципиально важный момент – наличие возможности кросс-канального анализа, что дает возможность компаниям контролировать риски, возникающие на стороне не только интернет-, но и мобильного канала, например, в приложениях для мобильного банкинга, для операций с криптовалютами и любых других, где может осуществляться финансовая транзакция.
### Правила безопасности для пользователей:
* не устанавливать приложения для мобильного устройства с ОС Android из каких-либо источников, кроме Google Play;
* при установке приложения обращать **особое внимание** на запрашиваемые приложением права;
* регулярно устанавливать обновления ОС Android;
* обращать внимание на расширения загружаемых файлов;
* не посещать подозрительные ресурсы;
* не переходить по ссылкам, полученным в SMS-сообщениях.
При участии **Семена Рогачева**, младшего специалиста по исследованию вредоносного кода Лаборатории компьютерной криминалистики Group-IB. | https://habr.com/ru/post/446948/ | null | ru | null |
# Строим надёжный процессинг данных — лямбда архитектура внутри Google BigQuery
В этой статье хочу поделиться способом, который позволил нам прекратить хаос с процессингом данных. Раньше я считал этот хаос и последующий ре-процессинг неизбежным, а теперь мы забыли что это такое. Привожу пример реализации на BiqQuery, но трюк довольно универсальный.
У нас вполне стандартный процесс работы с данными. Исходные данные в максимально сыром виде регулярно подгружаются в единое хранилище, в нашем случае в BigQuery. Из одних источников (наш собственный продакшн) данные приходят каждый час, из других (обычно сторонние источники) данные идут ежедневно.
В последствии данные обрабатываются до состояния пригодного к употреблению разнообразными пользователями. Это могут быть внутренние дашборды; отчёты партнёрам; результаты, которые идут в продакшн и влияют на поведение продукта. Эти операции могут быть довольно сложными и включать несколько источников данных. Но по большей части мы с этим справляется внутри BigQuery с помощью SQL+UDF. Результаты сохраняются в отдельные таблицы там же.
Очевидным способом организации этого процессинга является создание расписания операций. Если данные подгружаются ежедневно в час ночи, то мы настроим процессинг на 01:05. Если этот источник данных подгружается в районе 5й минуты каждого часа, то настроим процессинг на 10ю минуту каждого часа. Промежутки в 5 минут для пользователей не критичны и предполагается, что всё должно работать.
Но мир жесток! Данные не всегда приходят вовремя. Или вообще не приходят, если не починить. Если твоя часовая загрузка закончилась на 11й минуте, а трансформация запускалась на 10й – то пожалуйста, жди ещё час чтобы увидеть эти данные в дэшборде. А если операция использует несколько источников, то ситуация будет ещё веселее.
Более того, подгружаемые сырые данные не всегда верны (данные вообще всегда не верны!). Периодически данные приходится чистить или перезагружать. И тогда нужно перезапустить все операции и с корректными параметрами, чтобы всё починилось.
Это всё, конечно, проблемы с сырыми данными и нужно именно их и решать. Но это та война, в которой нельзя окончательно победить. Что-то всё равно будет поломано. Если источник данных внутренний – то ваши разработчики будут заняты новыми крутыми фичами, а не надёжностью трекинга. Если это сторонние данные, тогда вообще труба. Хотелось бы, чтобы по крайней мере процессинг не мешался по дороге и как только сырые данные починены — все клиенты сразу видели корректные результаты.
Это реально большая проблема. И как же ещё решить?
#### Решение №1 – убрать проблемные детали
Если процессинг приводит к проблемам, то не надо его делать! Не надо делать вообще никакой процессинг и хранить промежуточные результаты. Как только пользователю нужны результаты, всё должно вычисляться на лету из сырых данных. Учитывая скорость BigQuery это вполне реалистично. Особенно если все что вы делаете с данными это GROUP BY date и count(1), и нужны только данные за последние 14 дней.
Большинство аналитики работает именно с такими запросами. Поэтому мы данное решение активно используем. Но этот подход не работает со сложными трансформациями.
Одна проблема – это сложность кода. Если сложить все операции в один SQL запрос, то его будет не прочитать. К счастью это решается за счёт таблиц типа [view](https://cloud.google.com/bigquery/querying-data#views) (представления). Это логические таблицы в BigQuery, данные в них не хранятся, а генерируются из SQL-запроса на лету. Это сильно упрощает код.
Но другая проблема – это производительность. Здесь всё плохо. Не важно какие быстрые и дешёвые современные базы данных. Если запустить сложную трансформацию на одном годе исторических данных, это займёт время и будет стоить денег. Других вариантов нет. Эта проблема делает данную стратегию неприменимой в довольно большом проценте случаев.
#### Решение № 2 – построить сложную систему
Если нет возможности обойтись без системы управления процессингом, то нужно построить эту систему хорошо. Не просто расписание выполнения скриптов в cron, а система мониторинга загрузки данных, которая определяет когда и какие трансформации запускать. Наверное [паттерн pub/sub](https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern) тут очень подходит.
Но есть проблема. Если построить сложную систему более менее просто, то вот поддерживать её и ловить баги – это очень сложно. Чем больше кода, тем больше проблем.
По счастью есть и третье решение.
#### Решение № 3 – лямбда архитектура! …ну, типа того
[Лямбда архитектура](https://en.wikipedia.org/wiki/Lambda_architecture) – это знаменитый подход к процессингу данных, который использует преимущества обработки данных по расписанию и в реальном времени:
*\*Как нормально перевести на русский не знаю, batch job – это что пакетное задание? Кто знает, подскажите!*
Обычно это все строится с использованием нескольких решений. Но мы используем по сути тот же трюк просто внутри BigQuery.
И вот как это работает:
**Процессинг по расписанию (Batch layer).** Мы ежедневно выполняем SQL-запросы, которые трансформируют данные имеющиеся на текущий момент, и сохраняем результаты в таблицы. У всех запросов следующая структура:
Результаты этого запроса будут сохранены в table\_static (перезапишут её). Да, BigQuery позволяет сохранять результаты запроса в таблице, которая использовалась в этом запросе. В итоге мы берём старые, уже посчитанные данные (чтобы их не пересчитывать) и соединяем с новыми данными. X дней – это выбранный период, за который мы хотим пересчитать данные, чтобы учесть все возможные корректировки сырых данных. Предполагается что за X дней (сколько – это индивидуально для источника) все корректировки уже будут внесены, всё что сломалось починится и данные уже больше не будут меняться.
**Доступ в реальном времени (Speed layer + Serving layer).** Эти обе задачи объединены в один SQL-запрос:
Да, это тот же самый запрос! Его мы сохраняем как представление (view) с именем table\_live и все пользователи (дэшборды, другие запросы, и т.п.) тянут результаты из этого представления. Так как представления в BigQuery хранятся на логическом уровне (только запрос, не данные), каждый раз при обращении он будет пересчитывать последние X дней на лету и все изменения в изначальных данных будут отражены в результатах.
Так как запрос в обоих случаях одинаковый, то в реальности, чтобы избежать дупликации кода, ежедневный запрос (из batch layer) выглядит так:
```
SELECT * FROM table_live
```
(и сохраняем результаты в table\_static)
Этот подход имеет ряд важных преимуществ:
* Каждый пользователь получает актуальные результаты, нет никакой ресинхронизации между сырыми данными и агрегированными (это при условии, что все косяки с сырыми данными разрешаются за X дней)
* Пользователи получают результаты быстро. Никто не пересчитывает 2 года данных каждый раз, когда к ним обращаются. Пересчёт последних X дней в BigQuery происходит приемлемо быстро. X так и выбирается, чтобы не создавать проблем с производительностью. Можно и на часы вместо дней перейти конечно, но не приходилось этого делать с нашими данными.
* Не нужно вообще думать о расписании ежедневных операций. Просто нужно сделать это раз в день, но от времени загрузки сырых данных это не зависит. Кроме того, проблем не возникает, если в один день трансформация упадёт или если её запустить дважды. Чтобы пользователь заметил проблему, нужно чтобы процессинг «лежал» больше X дней.
* Для построения такой системы нужно минимальное количество кода (читай — проблем). Сам SQL-запрос на 10 строчек длиннее оригинального и теперь хранится внутри BigQuery как представление (view). Плюс нужно запускать ежедневный процессинг, но это элементарная задача.
* Издержки данной системы могут быть даже меньше, чем при создании сложной системы расписаний. Кажется, что должно быть дороже, так как мы постоянно пересчитываем X дней. Но наш опыт показывает, что наоборот. Если вы подгружаете данные каждый час, то вам придётся делать пересчёт каждый час, включая выходные. И ещё придётся пересчитывать, на X дней назад, чтобы отразить корректировки. Итого за неделю наберётся 24\*7=168 раз. Но в реальности пользователь может открывать этот дэшборд только три раза в неделю. При нашем подходе придётся пересчитать 7 раз по ежедневному расписанию и плюс 3 раза на лету. Существенно меньше.
PS Если любите использовать таблицы разбитые по датам в BigQuery (мы очень любим), то есть решение и для этого. Но это тема для другого поста. Подсказка – [функции](https://cloud.google.com/bigquery/query-reference#tablewildcardfunctions) для работы с этими таблицами не ругаются, если часть таблиц – это только представления.
PPS Если бы представления в BigQuery поддерживали кешинг (как это работает с обычными запросами), это было бы реально круто. Это по сути сделало бы их материализованными (materialized views). И эффективность нашего подхода стала бы ещё выше. Если вы согласны – [здесь](https://code.google.com/p/google-bigquery/issues/detail?id=184) можно поставить звёздочку, чтобы эту фичу быстрее реализовали. | https://habr.com/ru/post/279491/ | null | ru | null |
# Опыт внедрения 2fa на linux с duosecurity
На недавно прошедшей конференции [Zeronights](https://2016.zeronights.ru/program/defensive-track/) я рассказывал про двухфакторную аутентификацию, и какие проблемы могут быть при ее внедрении. К сожалению, времени выступления для полного погружения в тему было мало, поэтому я постараюсь раскрыть некоторые детали в рамках отдельных постов.
И начну с самой популярной темы, а именно двухфакторной аутентификации на linux — какие есть варианты настройки и почему даже очень хорошее решение требуется доработать напильником.
### Варианты настройки
Как я и говорил, тема 2fa для linux очень популярна, есть много решений, которые позволяют это сделать.
Существует два принципиальных способа сделать второй фактор при аутентификации через ssh. Первый способ — псевдо-второй фактор, запуск произвольного бинарника после стадии авторизации через опцию **ForceCommand** в настройках sshd:
[www.openssh.com/txt/release-4.4](https://www.openssh.com/txt/release-4.4)
Что хорошо в этом методе? Появилась поддержка с openssh4.4, поэтому вы вряд ли найдете сервер, где нельзя будет включить соответствующие настройки. На этом плюсы по сути заканчиваются. Минусов гораздо больше:
* если у вас включен tcpportforward, то выполнить проброс порта можно в обход существующих проверок в бинарнике;
* все, что прописано в rc-файле, будет выполнено до ForceCommand, поэтому там можно прописать выполнение exec sh и не подтверждать каждый раз вход вторым фактором;
* когда пользователь будет подключаться к серверу через sftp или scp, то он не увидит никакого приглашения, которое вы можете напечатать в случае стандартного входа с помощью ssh-клиента. Поэтому удобство для пользователя в этом случае практически сводится на нет.
Именно поэтому рассмотрим второй способ, который приводится в большинстве инструкций. Конечно же, это настройка с помощью pam-модуля.
### Второй фактор через pam
Классический сценарий представляет собой модификацию конфига **/etc/pam.d/sshd**, когда в самое начало помещают нужный модуль примерно в таком формате:
```
auth required pam_google_authenticator.so
```
Но это не решает проблему, если аутентификация выполняется не на уровне pam’а, а выполняется средствами самого sshd-сервера, например аутентификация по ключам. Как же быть в таком случае?
### Authentication Methods
К счастью, в openssh начиная с версии 6.2 сделали нативную поддержку второго фактора. Теперь с помощью опции **AuthenticationMethods** можно перечислить методы аутентификации, которые обязательно должны быть успешно пройдены для входа на сервер:
[lwn.net/Articles/544640](https://lwn.net/Articles/544640/)
Пример подобной конфигурации:
```
AuthenticationMethods publickey,password hostbased,publickey
```
Что же здесь написано? Для успешной аутентификации нужно пройти одну из следующих комбинаций:
* publickey+password
* или hostbased+publickey
Но где подключить модуль для двухфакторной аутентификации? Он подключается в методе keyboard-interactive. То есть если вы хотите, чтобы после аутентификации через publickey требовалось подтверждение через тот же модуль google auth, то задаете в конфиге sshd следующее:
```
AuthenticationMethods publickey,keyboard-interactive
```
а в файле **pam.d/sshd** указываете:
```
auth required pam_google_authenticator.so
```
Все довольно просто. Но ровно до тех пор, пока вы не захотите включить несколько методов аутентификации, при этом если один метод выполняется на уровне самого sshd (publickey или kerberos), а другой — на уровне pam (тот же password). Проблема заключается в том, что и password и keyboard-interactive обрабатываются в одном и том же pam-конфиге. Нужно как-то научиться отделять первую стадию аутентификации от второй в случае такого конфига sshd:
```
AuthenticationMethods password,keyboard-interactive publickey,keyboard-interactive
```
Я долго искал решение этой проблемы, и наткнулся на описание того, как facebook сделали у себя второй фактор:
[www.slideshare.net/yandex/004-tim-tickelchadgreene2fac](http://www.slideshare.net/yandex/004-tim-tickelchadgreene2fac)
[www.youtube.com/watch?v=pY4FBGI7bHM](https://www.youtube.com/watch?v=pY4FBGI7bHM)
Когда безопасники из facebook рассказывали про внедрение 2fa у себя, то они ссылались на подметоды аутентификации — **Authentication Submethods**. Это позволяет ограничить аутентификацию заданным устройством. В итоге у коллег получилось указать аутентификацию для keyboard-interactive именно через duo:
[lwn.net/Articles/544640](https://lwn.net/Articles/544640/) (комментарий от dugsong)
Но попытки найти эти коммиты или нужную версию openssh — 6.2p1 не увенчались успехом. Поэтому решено было изучать проблематику дальше.
### Эксперименты с настройкой pam
Тут мы снова вспоминаем, что же такое стэк pam, и с какими опциями можно подключать модуль. Все помнят стандартные варианты подключения в секции auth — required, requisite, sufficient, optional.
Но эксперименты по комбинированию модулей только с этими опциями ни к чему не привели. Либо у пользователя будут запрашивать пароль даже в случае аутентификации по ключу, либо можно будет обойти второй фактор повторным вводом пароля.
И тогда мы начинаем настраивать pam более тонко. Для каждого результирующего статуса можно указывать своё влияние на стэк, в т.ч. «пропускать» один или несколько подключаемых модулей.
Например, вот таким образом.
```
auth [success=1 default=ignore] pam_radius_auth.so
```
У себя при настройки двухфакторки через duosecurity мы сделали ровно такую конфигурацию pam, так как было замечено, что в случае невозможности интерактивного взаимодействия с пользователем модуль возвращает как раз **PAM\_ABORT**. То есть аутентификация начинает выглядеть так:
```
AuthenticationMethods gssapi-with-mic,keyboard-interactive password,keyboard-interactive
```
А конфиг pam.d/sshd становится вот таким:
```
auth [success=2 abort=ignore default=1] /lib64/security/pam_duo.so
auth [success=1 default=ignore] pam_unix.so nullok_secure
auth requisite pam_deny.so
auth required pam_permit.so
```
Рассмотрим, что происходит в первом варианте возможной аутентификации — gssapi-with-mic,keyboard-interactive
Пользователь логинится по kerberos-тикету, далее нужно пройти keyboard-interactive аутентификацию. Модуль pam\_duo успешно подключается, в случае успеха следует переход на **PAM\_PERMIT**, во всех остальных вариациях — на **PAM\_DENY**. Все довольно просто.
Что будет, если вход идет по паролю. Отрабатывает все тот же стэк pam-модулей, но pam\_duo не может инициализироваться и возвращается **PAM\_ABORT**. Т.к. у нас написано **abort=ignore**, то это ни на что не влияет, управление передается следующему модулю pam\_unix. Если все хорошо, то идет переход ко второй стадии — keyboard-interactive, и повторяется выше описанная механика.
Да, вроде все ок. Но есть нюанс.
pam\_duo позволяет задать дополнительные настройки — для кого требуется аутентификация, а для кого — нет.
[duo.com/docs/duounix#duo-configuration-options](https://duo.com/docs/duounix#duo-configuration-options)
Вот пример такой конфигурации:
```
groups = users,!wheel,!*admin
```
И что мы выяснили в результате тестирования? Что если пользователь, согласно примеру, состоит в группе wheel, то модуль вернет **PAM\_SUCCESS**, что довольно логично. Но это вернется до попытки провести инициализацию модуля, то есть даже в стадии password. Таким образом, зная логин такого пользователя, можно не просто обойти второй фактор, а зайти в систему, даже не зная пароль пользователя. В общем полный провал.
Также обнаруживаем вторую особенность. Если менять настройки не pam.d/sshd, а глобальные — password-auth, который обычно подключается в остальных модулях, то выясняется, что логин через локальную консоль происходит с возможностью подключать модули с интерактивным взаимодействием. То есть первая стадия проверки пропускается и сразу идет проверка второго фактора, где, как мы помним, можно знать просто имя учетки с группами-исключениями. Это тоже провал.
### Доработка напильником
Но пути назад нет, поэтому начинаем читать исходники.
Основной файл, в котором идут все проверки:
[github.com/duosecurity/duo\_unix/blob/master/pam\_duo/pam\_duo.c](https://github.com/duosecurity/duo_unix/blob/master/pam_duo/pam_duo.c)
Нас интересует функция **pam\_sm\_authenticate**. По мере изучения исходников, находим, что можно вызвать функцию для взаимодействия между модулем и приложением, которое вызывает модуль (в нашем случае это будет sshd):
[man7.org/linux/man-pages/man3/pam\_get\_item.3.html](http://man7.org/linux/man-pages/man3/pam_get_item.3.html)
[man7.org/linux/man-pages/man3/pam\_conv.3.html](http://man7.org/linux/man-pages/man3/pam_conv.3.html)
Примерно после 5 segfault (во время тестирования и подключения исправленного модуля) выясняем, какой из параметров будет отличаться в случае password и keyboard-interactive. Тестирование проводилось через попытку вывести пробел с использованием указанных функций. Указатель на **resp** в структуре **pam\_conv** будет равен 0, если это удалось.
В итоге получаем модифицированный исходник, который выполняет две функции — возвращает **PAM\_AUTHINFO\_UNAVAIL** при подключении модуля в стадии password. И возвращает **PAM\_AUTHINFO\_UNAVAIL**, если имя сервиса отличается от sshd (для избежания указанной выше ситуации со входом через локальную консоль):
[gist.github.com/videns/5348e3cc04fbce3a8c26fe3c99a61b50/revisions](https://gist.github.com/videns/5348e3cc04fbce3a8c26fe3c99a61b50/revisions)
Ну и для удобства установки на все сервера собираем пакет, например, с помощью того же fpm.
После установки модифицированного модуля нужно внести последние изменения в pam.d/sshd:
```
auth [success=2 authinfo_unavail=ignore default=1] /lib64/security/pam_duo.so
auth [success=1 default=ignore] pam_unix.so nullok_secure
auth requisite pam_deny.so
auth required pam_permit.so
```
В итоге если модуль подключается не на стадии keyboard-interactive, то будет возвращаться ответ **PAM\_AUTHINFO\_UNAVAIL**, который обрабатывается в стеке. Во всех остальных вариантах будет переход на pam\_deny или pam\_permit в случае успеха.
Также для тех учетных записей, которые используются в сервисах и соответственно должны входить по одному фактору, можно сделать отдельные настройки с помощью параметра **Match** в конфиге sshd.
Подводя итог скажу, что даже очень хорошее решение часто требуется немного доработать напильником, чтобы для пользователей это не стало вот таким:
Также готов поделиться еще информацией про двухфакторную аутентификацию, например, какие грабли были в момент интеграции или описать интересные фичи провайдера duosecurity. | https://habr.com/ru/post/322544/ | null | ru | null |
# Организация онлайн-вещания подкаста
Для [последней презентации Apple](http://tjournal.ru/paper/apple-october-event) мы решили расширить наши текстовые трансляции и добавить аудиоподкаст в реальном времени. Сначала мы хотели найти какое-нибудь готовое решение, но не смогли подобрать ничего, что могло бы вместить в себя несколько человек из разных точек континента, поэтому пришлось искать иной способ. О том, как сделать живую трансляцию аудиоподкаста (как у Радио-Т :-) с помощью одного ноутбука, одного сервера и Skype — читайте далее.
#### Настраиваем сервер
Главное, о чём необходимо позаботиться — широкий канал. У нас в пике было около 150-200 слушателей и около 10Мб/с с качеством в 64кб/c, так что рассчитать канал довольно просто, если знать примерное количество соединений.
Мы арендовали на время трансляции облачный сервер в Селектеле, это обошлось нам примерно в 25 рублей, канал потенциально до 1 гигабита, но за него нужно платить. Кстати, жёсткий диск не нужен объемный, достаточно буквально нескольких гигабайт, запись мы будем осуществлять на клиенте.
Начнём с того (у нас, кстати, debian), что установим Icecast 2 — бесплатное ПО для трансляции аудио в сеть. Рекомендуем ознакомиться с [документацией](http://www.icecast.org/docs/icecast-2.3.3/), там не очень много, зато можно себе представить, какие возможности открываются.
Установка:
```
apt-get install icecast2
# бэкап
cp /etc/icecast2/icecast.xml /etc/icecast2/icecast.xml.back
# тут необходимо установить ENABLE=TRUE
emacs /etc/default/icecast2
# сюда копируем конфиг
emacs /etc/icecast2/icecast.xml
```
Вот [тут](https://gist.github.com/chekalskiy/7371563) мы выложили конфиг с комментариями, но вам необходимо его подредактировать. Кстати, можно [настроить](http://habrahabr.ru/post/156591/) трансляцию таким образом, чтобы в случае отсутствия сигнала от источника, она не прерывалась, а перекидывалась на запасной источник, на котором, например, постоянно играет музыка.
Запускаем icecast:
```
service icecast2 start
```
Единственный большой минус Icecast — он не умеет микшировать потоки на стороне сервера, да и вообще по факту он просто берёт входящий с клиента поток и переадресовывает его слушателям, считая количество подключений, обеспечивая резервирование каналов и т.д.
Поэтому мы займёмся этим на своём компьютере. В качестве основной рабочей станции, которая в итоге и подключается к серверу мы использовали Macbook, поэтому здесь приведены инструкции на примере Mac OS X, но аналогичные действия можно проделать и с помощью Windows и Linux.
#### Микшируем звук
Для отправки аудиосигнала на сервер нам понадобится специальное ПО, можно выбрать из тех, что перечислены [здесь](http://www.icecast.org/3rdparty.php). Я использовал [nicecast](http://www.rogueamoeba.com/nicecast/) — условно-бесплатная, но при этом обладает фантастическими возможностями, например, умеет накладывать эффекты и микшировать аудиоканалы только с определённых интерфейсов разных приложений. К счастью, мы можем использовать программу бесплатно целый час, после чего приложение необходимо перезапустить, а трансляция прервётся. Есть полностью бесплатный аналог [butt](http://butt.sourceforge.net/), но его возможности куда более скудные.
Также нам понадобится какое-нибудь аудиоприложение для трансляции фоновой музыки — она позволяет заглушить некоторые шумы, а также является хорошим признаком того, что трансляция не прервалась и идёт, просто все ведущие увлечённо о чём-то молчат :-) Мы использовали [mixxx](http://www.mixxx.org/), в основном потому что он бесплатен и довольно могуч. Кстати, для фоновой музыки нам нужен специальный [podsafe](http://rpod.ru/podsafe/) трек, лицензия которого позволяет использовать его в подкастинге.
Итак, теперь можно попробовать подключиться: открываем Nicecast, во вкладке Source выбираем микрофон, в Quality ставим mono-канал (всё равно микрофон у нас моноканальный) и качество в районе 64-96 килобит в секунду, этого более, чем достаточно. Нажимаем ⌘4, чтобы настроить запись на локальный диск. Теперь самое интересное: нажимаем на клавиатуре ⌘2, в открывшемся окне нужно добавить наш сервер:
Нажимаем заветную кнопочку Start Broadcast и переходим по адресу (для наших настроек это `stream.tjournal.ru:8000/tjournal`) в браузере, с небольшой задержкой мы должны слышать то, что происходит вокруг. Теперь мы можем подключиться к нашему серверу по адресу `stream.tjournal.ru:8000/` и наблюдать активные потоки и количество слушателей у них. Ура!
Убедившись, что сервер работает, попробуем объединить несколько потоков: фоновую музыку и наш голос с микрофона. Для этого во вкладке Source выберем Silence Input (тишина) и перейдём во вкладку Effects, в которой и начинается магия.
Добавим эффект Application Mixer и выберем приложение mixxx (или даже iTunes). Затем добавим эффект VoiceOver — это наш микрофон. Придётся немного поиграть с настройками, чтобы голос не был слишком громким, а также чтобы некоторые шумы фильтровались программой (Auto Ducking). Мы добавили ещё два фильтра — Monomizer и Menu Bar Meters, но на самом деле их там очень много и можно долго экспериментировать.
#### Запускаем трансляцию
Осталось самое простое, звоним кому-нибудь в Skype и добавляем в эффекты ещё один Application Mixer, указывая ему на скайп. Кстати, можно снимать звук не со всего приложения, а только с определённых каналов. Чтобы создать виртуальные каналы мы использовали приложение [Soundflower](http://cycling74.com/products/soundflower/). Они позволят нам направить звук из mixxx на виртуальный аудиоканал и не слушать его в наушниках, а звук с этого виртуального канала будт снимать nicecast.
Окошко с эффектами:
Осталось протестировать всю связку и выложить плеер на сайт (можно и ограничиться ссылкой, но это слишком хардкорно). Кстати, эта трансляция прекрасно работает на мобильных устройствах. Мы воспользовались [uppod](http://uppod.ru/) для того, чтобы на странице был симпатичный плеер вместо простого тега ````
.
var player = null;
$(function(){
player = new Uppod({m:"audio",uid:"audioplayer",file:"http://stream.tjournal.ru:8000/tjournal", comment:"TJournal Live"});
setInterval(function() {
if (typeof player != 'undefined' && player != undefined && player != null) { if (player.Played() == 100) {
player.Stop();
player.Play();
}
}}, 10000);
});
```
Текстовые трансляции на TJournal построены на технологии long-polling и страницы пользователей не обновляются в течение всей презентации. Если использовать бесплатную версию nicecast, то нужно помнить, что трансляция будет прерываться раз в час, поэтому нужно предусмотреть, чтобы после перерыва она автоматически восстанавливалась незаметно для пользователя. Для этого каждые 10 секунд будем проверять состояние плеера и с помощью особенностей воспроизведения live streaming audio мы сможем отследить и перезапустить, когда трансляция прервалась, а не была приостановлена пользователем.
Вставляем код на сайт. Начинаем трансляцию. Вы восхитительны!` | https://habr.com/ru/post/202226/ | null | ru | null |
# Модальные окна на CSS
В наше время для различных сайтов нормой стали всевозможные всплывающие модальные окна — popup'ы — для регистрации, авторизации, информационные окна, — всевозможных форм и размеров. Также существует огромное количество плагинов к тому же jQuery для простого и удобного создания таких попапов — тот же [Shadowbox](http://shadowbox-js.com/), например.
Внешний вид, размеры и оформление таких попапов совершенно разнообразными — с оверлеем, тенюшками, анимациями — всего не счесть. Объединяет их только, пожалуй, тот факт, что обычно они выводятся в самом центре страницы — как по горизонтали, так и по вертикали. И центрирование это производится средствами JS. Я не буду вдаваться в подробности этих расчетов, опишу их лишь вкратце:
HTML-код попапа обычно имеет такую структуру:
`class="popup__overlay">` -- Оверлей -->
class="popup">... -- Попап вместе с содержимым -->
И CSS (*здесь и ниже я умышленно буду опускать написание некоторых свойств, необходимых лишь для некоторых браузеров и их версий, оставив лишь самое основное*):
`.popup\_\_overlay {
position: fixed;
left: 0;
top: 0;
background: #000;
opacity: .5;
filter: alpha(opacity=50);
z-index: 999
}
.popup {
position: absolute;
width: 20%;
z-index: 1000;
border: 1px solid #ccc;
background: #fff
}`
JS определяет браузер и версию браузера, и на основании этого высчитывает размеры рабочей области и размеры самого попапа (если они не заданы), а затем производятся нехитрые вычисления положения его левого верхнего угла (css-свойства left и top для .popup). Многие плагины также реагируют на изменение размеров страницы, пересчитывая всё это дело каждый раз, с тем, чтобы попап располагался точно в центре рабочей области.
Я по натуре своей перфекционист (знаю, порой это плохо), и частенько заморачиваюсь даже над мелкими деталями, пытаясь улучшить и добавить максимально возможную расширяемость этим деталям, и меня не мог не зацепить именно этот момент в работе всех этих плагинов. Возникла мысль, что всю работу по позиционированию попапа можно переложить с плеч JS на плечи самого браузера, то есть выполнять эту работу средствами CSS.
Этим и займёмся.
*Ниже я приведу пример попапа, работающего во всех мажорных версиях основных браузеров. Для корректной его работы в IE<9 необходима некоторая экстра-разметка и хаки, потому детальное описание написания такого метода я опущу, а для интересующихся выложу полную версию.*
Итак, у нас есть страница с кнопкой, при нажатии на которую должно всплывать модальное окно с некоторой информацией, а весь остальной контент должен затеняться оверлеем.
Для начала — HTML-код. Структура его будет немного отличаться от кода, указанного выше, почему — об этом ниже в статье; классы элементов останутся теми же:
`<div class="popup\_\_overlay">
<div class="popup">div>
div>`
И немного CSS:
`.popup\_\_overlay {
position: fixed;
left: 0;
top: 0;
width: 100%;
height: 100%;
z-index: 999
}
.popup {
}`
##### Фиксированные размеры
Самый простой вариант. Ничего нового изобретать не нужно:
`.popup {
left: 50%;
top: 50%;
width: 400px;
height: 200px;
margin-left: -200px;
margin-top: -100px
}`
Отрицательные margin'ы в половину ширины и высоты — банально и скучно, ничего оригинального в этом нет. Идём дальше.
##### Размеры попапа зависят от содержимого
Сперва — выравнивание по горизонтали — это вроде бы проще. Если попап фиксированной ширины — то достаточно будет следующего:
`.popup {
margin: auto
}`
На вертикальное выравнивание это никак не повлияет, и, к слову, если вам достаточно лишь горизонтального выравнивания, то на этом можно и остановиться, указав еще какой-нибудь верхний отступ попапа. Но нам этого мало! Идём дальше.
Вертикальное выравнивание. Здесь уже становится интересно. С такой задачей, конечно, без проблем справилась бы таблица или эмуляция таблицы с помощью display: table & display: table-cell, но заставить такое работать в старых IE — себе дороже. Таблица также отпадает — по понятным причинам.
Итак, margin уже отпадает — размеров мы не знаем. Вспоминаем, что же есть из свойств с подобными эффектами. Ага, text-align. Но только для инлайновых элементов. ОК. Кажется, сам Бог велел использовать display: inline-block — блочный элемент, к которому можно было бы применить свойства для инлайновых элементов. С поддержкой этого свойства у всех браузеров тоже всё, можно сказать, в порядке. Код становится примерно таким:
`.popup\_\_overlay {
position: fixed;
left: 0;
top: 0;
width: 100%;
height: 100%;
z-index: 999;
text-align: center
}
.popup {
display: inline-block;
vertical-align: middle
}`
Остаётся вертикальное выравнивание — нам подойдёт vertical-align. В любой другой ситуации было бы также уместно использовать line-height, но поскольку у нас нет фиксированной высоты страницы (line-height в данном контексте), здесь использовать её нельзя. На помощь приходит один трюк с вертикальным выравниванием элементов неизвестных размеров. Я точно помню, что нашел этот способ на Хабре, но, к сожалению, не смог найти ссылку на тот топик. Заключается этот способ в следующем: добавляется inline-block элемент нулевой ширины и 100%-ой высоты родителя, который «расхлопывает» высоту строки до 100% высоты родителя, то есть до высоты рабочей области страницы. Сделаем это изящнее — вместо лишней разметки воспользуемся псевдоэлементами:
`.popup\_\_overlay:after {
display: inline-block;
width: 0;
height: 100%;
vertical-align: middle;
content: ''
}`
Осталось добавить полупрозрачное затемнение оверлея — с этим справится rgba. Всё! Теперь положение попапа регулируется только средствами браузера на уровне CSS.
[Итоговый пример](http://jsfiddle.net/vend3tta/9zwD4/)
Из замеченных минусов метода — порой возникают глюки с отображением в IE 6-7, в частности, при использовании флоатов.
Повторюсь — мой метод не избавляет от использования JS вообще, он лишь частично оптимизирует скорость работы всплывающих окон за счет переноса части нагрузки с JS на CSS.
Уверен, что метод можно улучшить — как визуально, так и изнутри, и буду рад любым идеям и предложениям по этому поводу, а также замечаниям по работе и отображению в различных браузерах.
**UPD:** По просьбам, добавил пример, работающий в IE7+ — <http://jsfiddle.net/vend3tta/SE4tS/> | https://habr.com/ru/post/136351/ | null | ru | null |
# Асинхронное программирование в приложениях ASP.NET MVC 4
Прочитав [статью](http://habrahabr.ru/post/142318/) об изучении MVC и увидев [комментарий](http://habrahabr.ru/post/142318/#comment_4764117) пользователя [RouR](http://habrahabr.ru/users/rour/), я очень заинтересовался данной темой, ну и на ходу решил перевести указанную им [оригинальную статью](http://www.tugberkugurlu.com/archive/my-take-on-task-base-asynchronous-programming-in-c-sharp-5-0-and-asp-net-mvc-web-applications).
Если и тебе, дорогой хабражитель, это интересно — прошу под кат!
*«Я попробую показать вам, что нового несет в себе C# 5.0 с точки зрения асинхронного программирования при использовании ключевого слова **await**. Особенно для веб-приложений ASP.NET MVC 4.»*
Я некоторое время поигрался с [Visual Studio Async CTP](http://msdn.microsoft.com/en-us/vstudio/gg316360) и теперь у меня достаточно соображений о том, как он работает, и как его грамотно использовать. И это значит, что я могу написать об этом.
Главная проблема большинства нашего ПО — операции, требующие длительного времени исполнения. Пользователь запускает такую операцию — и она блокирует основной поток программы до тех пор, пока не закончится ее выполнение. И в результате мы получаем неудобное пользователю ПО и недовольных клиентов. Я уверен, что каждый из нас сталкивался с такими программами!
Асинхронное программирование — далеко не новая парадигма, она уже была во времена .NET 1.0. Я не очень интересовался программированием 3 года назад, так что это понятие для меня достаточно ново и до сих пор. Насколько я читал, концепция развивалась во многом с точки зрения .NET на асинхронное программирование и, как мне кажется, находится сейчас на лучшей своей стадии.
С одной стороны, в асинхронном программировании и так очень просто запутаться, как это уже случалось со мной несколько раз. Я ходил туда-сюда и много думал о том, как же эта штука работает и где ее применить. И мне хочется верить, что в конце концов я все верно понял. С другой стороны, еще проще запутаться в асинхронном программировании, если применять его в веб-приложениях, ведь у нас нет потока UI, в который мы немедленно могли бы вывести результаты работы. Асинхронно или нет, но пользователь должен ждать некоторое время. Именно поэтому асинхронное программирование нежелательно для веб-приложений. И если вы тоже так думаете (а я прежде и сам так считал), значит вы еще ничего не поняли!
Если ваша операция выполняется синхронно и занимает много времени, то у вас нет другого выбора, как блокировать основной поток до ее завершения. А если вы делаете ту же операцию асинхронно, то это означает, что вы запускаете операцию и продолжаете что-то делать, возвращаясь к результатам вашей операции только тогда, когда она уже завершится. Между запуском и окончанием операции ваш поток свободен и может делать другие вещи. Я думаю, что большая часть людей путается именно здесь. Создание дополнительных потоков — дело накладное и может привести к проблемам, но мне кажется, что это уже в прошлом. В .NET 4.0 резко увеличили лимит на количество запускаемых потоков, но это вовсе не значит, что везде и всюду нужно создавать множество потоков — по крайней мере теперь не стоит переживать при создании очередного потока. Сейчас идут (или мне лучше сказать — уже прошли?) много споров об асинхронном программировании:
* [Должны ли быть асинхронными обращения к моей БД?](http://blogs.msdn.com/b/rickandy/archive/2009/11/14/should-my-database-calls-be-asynchronous.aspx)
* [Должны ли быть асинхронными обращения к моей БД (часть 2)?](http://blogs.msdn.com/b/rickandy/archive/2011/07/19/should-my-database-calls-be-asynchronous-part-ii.aspx)
* [Как асинхронные операции в ASP.NET MVC используют потоки из пула .NET 4 (ThreadPool)?](http://stackoverflow.com/questions/8743067/do-asynchronous-operations-in-asp-net-mvc-use-a-thread-from-threadpool-on-net-4)
* [В чем недостатки использования ExecuteReaderAsync в C# AsyncCTP?](http://stackoverflow.com/questions/9432647/any-disadvantage-of-using-executereaderasync-from-c-sharp-asyncctp)
Я не знаю точного ответа на все эти вопросы, но вот вам пара примеров:
* Windows Runtime (WinRT) разрабатывался с хорошей поддержкой асинхронности. Все, что выполняется дольше 40мс (операции, связанные с сетью, файловой системой — то есть весь основной ввод-вывод) — все это должно быть асинхронным!
* [ASP.NET Web API](http://www.asp.net/web-api) позволяет отдавать данные вашего сервиса в нескольких форматах. Единственное, что следует отметить — в нем практически нет синхронных вызовов. Буквально (не в переносном смысле) — просто нет синхронных вызовов для некоторых методов!
Вот, как говорится, пора бы нам в том или ином виде воспользоваться преимуществами асинхронности. Так в чем же проблема? А проблема в том, как работает данная асинхронная модель. Как говорит [Андерс Хейлсберг](http://ru.wikipedia.org/wiki/%D0%A5%D0%B5%D0%B9%D0%BB%D1%81%D0%B1%D0%B5%D1%80%D0%B3,_%D0%90%D0%BD%D0%B4%D0%B5%D1%80%D1%81), эта программная модель выворачивает наш код наизнанку. Не говоря уже о том, как очень трудно сделать вложенные вызовы асинхронных операций с обработкой исключений.
#### Visual Studio Async CTP и как он работает
В C# 5.0 у нас будет новая модель асинхронного программирования, очень похожая на синхронную. А пока разработчики выпустили CTP для текущей версии, который доступен по Go-Live лицензии. Вот цитата из спецификации AsyncCTP:
*"**Асинхронные функции** — новая возможность в C#, которая позволяет легко описывать асинхронные вызовы. Когда выполнение функции дойдет до выражения с ключевым словом **await** и начнется его выполнение, остальная часть функции будет перестроена, как автоматическое продолжение выполняемой операции и произойдет моментальный возврат из асинхронной функции, в то время как сама функция будет продолжать выполняться. Другими словами — теперь работу по выстраиванию порядка выполнения кода на себя берет сам язык, а не программист. В результате чего асинхронный код приобретает логическую структуру."*
**Асинхронная функция** — это метод класса или анонимная функция, помеченные модификатором **async**. Она может возвращать как объект класса **Task**, так и **Task** для произвольного типа **T** — в таких функциях может быть **await**. Если же функция, помеченная **async**, возвращает **void** (что также допустимо) — тогда использовать **await** не удастся. Но с другой стороны, мы же можем в качестве **T** использовать любой тип.
#### ASP.NET MVC 4 и асинхронные возможности C#
Грамотное использование асинхронности в приложениях ASP.NET MVC может очень позитивно сказаться на производительности. Верите вы или нет, но это так. Сейчас я покажу как.
Так почему же мы не везде и все делаем асинхронно? А потому что это очень тяжело, чревато ошибками и в конечном счете трудно потом поддерживать наше приложение. Но с новой асинхронной моделью это скоро изменится.
В ASP.NET MVC 4 асинхронное программирование сильно изменилось. Возможно вы знаете, что в ASP.NET MVC 3 наш контроллер должен быть унаследован от [AsyncController](http://msdn.microsoft.com/en-us/library/system.web.mvc.asynccontroller.aspx) и должен соответствовать определенному шаблону. Об этом можно прочитать в статье "[Использование асинхронных контроллеров в ASP.NET MVC](http://msdn.microsoft.com/en-us/library/ee728598.aspx)".
В ASP.NET MVC 4 нам не нужно больше использовать AsyncController, достаточно наш контроллер пометить ключевым словом **async** и вернуть объект класса **Task** или **Task** (где **T** — обычно [ActionResult](http://msdn.microsoft.com/en-us/library/system.web.mvc.actionresult(v=vs.98).aspx)).
Я попробовал в одном приложении совместить сразу два примера, которые делают одно и то же действие — синхронно и асинхронно, соответственно. А также я провел нагрузочное тестирование, и результаты шокировали меня! Теперь давайте взглянем на код.
Во-первых, я создал простейший REST-сервис, использую новый [ASP.NET Web API](http://www.asp.net/web-api). Простейшая модель, которая хранит коллекцию в памяти (можно было использовать БД вместо этого):
```
public class Car
{
public string Make;
public string Model;
public int Year;
public int Doors;
public string Colour;
public float Price;
public int Mileage;
}
public class CarService
{
public List GetCars()
{
List Cars = new List
{
new Car
{
Make="Audi",
Model="A4",
Year=1995,
Doors=4,
Colour="Red",
Price=2995f,
Mileage=122458
},
new Car
{
Make="Ford",
Model="Focus",
Year=2002,
Doors=5,
Colour="Black",
Price=3250f,
Mileage=68500
},
new Car
{
Make="BMW",
Model="5 Series",
Year=2006,
Doors=4,
Colour="Grey",
Price=24950f,
Mileage=19500
}
//This keeps going like that
};
return Cars;
}
}
```
И код сервиса:
```
public class CarsController : ApiController
{
public IEnumerable Get()
{
var service = new CarService();
return service.GetCars();
}
}
```
Итак, у меня есть сервис. Теперь я напишу веб-приложение, которое будет получать данные от сервиса и показывать их. Для этого я написал класс сервиса, который получает данные и десериализует их: для асинхронных вызовов я использовал новый [HttpClient](http://blogs.msdn.com/b/henrikn/archive/2012/02/16/httpclient-is-here.aspx), а для синхронных — привычный [WebClient](http://msdn.microsoft.com/en-us/library/system.net.webclient.aspx). Также я использовал [Json.NET](http://nuget.org/packages/newtonsoft.json):
```
public class CarRESTService
{
readonly string uri = "http://localhost:2236/api/cars";
public List GetCars()
{
using (WebClient webClient = new WebClient())
{
return JsonConvert.DeserializeObject>
(
webClient.DownloadString(uri)
);
}
}
public async Task> GetCarsAsync()
{
using (HttpClient httpClient = new HttpClient())
{
return JsonConvert.DeserializeObject>
(
await httpClient.GetStringAsync(uri)
);
}
}
}
```
Про метод **GetCars** сказать нечего — он прост. А вот про **GetCarsAsync** можно сказать следующее:
* Он помечен ключевым словом **async**, которое говорит нам, что тут есть некий асинхронный код.
* Мы использовали ключевое слово **await** перед **HttpClient.GetStringAsync**, который возвращает **Task**. И мы можем использовать его, как обычный **string** — ключевое слово **await** нам это позволяет.
Ну и, наконец, вот он контроллер:
```
public class HomeController : Controller
{
private CarRESTService service = new CarRESTService();
public async Task Index()
{
return View("index", await service.GetCarsAsync());
}
public ActionResult IndexSync()
{
return View("index", service.GetCars());
}
}
```
Итак, у нас получился **Index** — асинхронная функция, возвращающая **Task**, и **IndexSync** — обычный синхронный вызов. Если мы перейдем по адресу **/home/index** или **/home/indexsync**, то мы не увидим особой разницы в скорости открытия страниц — она примерно одинакова.
Чтобы измерить разницу в работе этих методов, я создал нагрузочные тесты в MS Visual Studio 2010 Ultimate. Я буду в течение двух минут открывать эти две страницы, начиная с нагрузки в 50 пользователей, постепенно увеличивая ее по 20 пользователей раз в 5 секунд. Максимальным пределом будет величина в 500 пользователей. Смотрим результат (кликабельно):
[](http://www.tugberkugurlu.com/Content/Images/UploadedByAuthors/wlw/77d0b156dd2b_D494/asyncFTW.png)
Видно, что для синхронного варианта время отклика составляет **11.2** секунды, а для асинхронного — **3.65** секунды. Я думаю, разница очевидна.
Вот с этого момента я стал приверженцем концепции **«Все, что выполняется дольше 40мс (операции, связанные с сетью, файловой системой — то есть весь основной ввод-вывод) — все это должно быть асинхронным!»** | https://habr.com/ru/post/142372/ | null | ru | null |
# Как не нужно использовать Node.js Stream API
В интернете опять кто-то не прав – во вчерашнем [Node Weekly](https://nodeweekly.com/issues/261) была ссылка [на пост](https://itnext.io/streams-for-the-win-a-performance-comparison-of-nodejs-methods-for-reading-large-datasets-pt-2-bcfa732fa40e) в котором автор пытается измерить и сравнить с "аналогами" производительность Stream API в Node.js. Грусть вызывает, то как автор работает со стримами и какие он выводы он пытается на основе этого сделать:
> ...this worked pretty well on smaller files, but once I got to the biggest file, the same error happened. Although Node.js was streaming the inputs and outputs, it still attempted to hold the whole file in memory while performing the operations
Давайте попробуем разобраться, что не так с выводами и кодом автора.
С моей точки зрения проблема в том что автор статьи не умеет пользоваться Stream’ами и это проблема с которой приходиться довольно часто сталкиваться. У этого явления есть, на мой взгляд, три причины:
1. Сложная история Node.js Stream API – [боль и страдания описаны тут](https://stackoverflow.com/questions/21538812/what-is-streams3-in-node-js-and-how-does-it-differ-from-streams2)
2. Не самое интуитивное API, если пытаться пользоваться ним без каких-либо оберток
3. Довольно странная документация, которая представляет Stream’ы как что-то очень сложное и низкоуровневое
Все вместе это приводит к тому, что разработчики довольно часто не умеют и не хотят использовать Stream API.
Что не так с [кодом автора](https://github.com/paigen11/file-read-challenge)?
Для начала повторим тут задачу(оригинал на английском и ссылку на файл можно найти в посте):
Есть некий файл размером 2.5 ГБ со строками вида:
```
C00084871|N|M3|P|201703099050762757|15|IND|COLLINS, DARREN ROBERT|SOUTHLAKE|TX|760928782|CELANESE|VPCHOP&TECH|02282017|153||PR2552193345215|1151824||P/R DEDUCTION ($76.92 BI-WEEKLY)|4030920171380058715
```
Его нужно распарсить и узнать следующую информацию:
* Количество строк в файле
* Имена на 432-ой и 43243-ей строках(тут правда возникает вопрос как считать, с 0 или 1?)
* Самое часто встречаемое имя и сколько раз оно встречается
* Количество взносов по по каждому месяцу
В чем проблема? – Автор честно говорит, что загружает весь файл в память и из-за этого Node “вешается” и автор приводит нам интересный факт.
> Fun fact: Node.js can only hold up to 1.67GB in memory at any one time
Автор делает из этого факта странный вывод, что это Stream’ы загружают весь файл в память, а не он написал неправильный код.
Давайте опровергнем тезис: "*Although Node.js was streaming the inputs and outputs, it still attempted to hold the whole file*", написав небольшую программу, которая посчитает количество строк в файле любого размера:
```
const { Writable } = require('stream')
const fs = require('fs')
const split = require('split')
let counter = 0
const linecounter = new Writable({
write(chunk, encoding, callback) {
counter = counter + 1
callback()
},
writev(chunks, callback) {
counter = counter + chunks.length
callback()
}
})
fs.createReadStream('itcont.txt')
.pipe(split())
.pipe(linecounter)
linecounter.on('finish', function() {
console.log(counter)
})
```
*N.B.*: код намерено написан максимально просто. Глобальные переменные это плохо!
На что стоит обратить внимания:
* split – npm пакет который на “вход” принимает поток строк – на “выход” отдает поток наборов строк разделенным переносом строки. Скорее всего сделан как реализация Transformation stream. Мы в него pipe’ем наш ReadStream с файлом, а его самого pipe’ем в...
* linecounter — имплементация WritableStream. В ней мы реализуем два метода: для обработки одного кусочка(chunk) и нескольких. “Кусочком” в этой ситуации выступает линия кода. Обратка – добавление к счетчику нужного числа. Важно понимать – мы не будем загружать в этой ситуации весь файл в память, а API за нас поделит все на максимально удобные для обработки “кусочки”
* ‘finish’ – события которое “произойдет” когда “закончатся” данные поступающие на наш ReadableStream. Когда это произойдет мы залогируем данные счетчика
Ну что ж, испытаем наше творение на большом файле:
```
> node linecounter.js
13903993
```
Как видим – все работает. Из чего можем сделать вывод что Stream API прекрасно справляется с файлами любого размера и утверждение автора поста, мягко говоря, не верно. Приблизительно также мы можем посчитать любое другое значение требуемое в задаче.
Расскажите:
* Интересно ли вам почитать как решить задачу полностью и как привести получившийся код в удобный для сопровождения вид?
* Используете ли вы Stream API и с какими трудностями вы сталкивались? | https://habr.com/ru/post/427901/ | null | ru | null |
# Алгоритм Форчуна, подробности реализации
Последние несколько недель я работал над реализацией [алгоритма Форчуна](https://en.wikipedia.org/wiki/Fortune%27s_algorithm) на C++. Этот алгоритм берёт множество 2D-точек и строит из них [диаграмму Вороного](https://en.wikipedia.org/wiki/Voronoi_diagram). Если вы не знаете, что такое диаграмма Вороного, то взгляните на рисунок:
Для каждой входной точки, которая называется «местом» (site), нам нужно найти множество точек, которые ближе к этому месту, чем ко всем остальным. Такие множества точек образуют ячейки, которые показаны на изображении выше.
В алгоритме Форчуна примечательно то, что он строит такие диаграммы за время  (что оптимально для использующего сравнения алгоритма), где  — это количество мест.
Я пишу эту статью, потому что считаю реализацию этого алгоритма очень сложной задачей. На данный момент это самый сложный из алгоритмов, которые мне приходилось реализовывать. Поэтому я хочу поделиться теми проблемами, с которыми я столкнулся, и способами их решения.
Как обычно, код выложен на [github](https://github.com/pvigier/FortuneAlgorithm), а все использованные мной справочные материалы перечислены в конце статьи.
Описание алгоритма Форчуна
==========================
Я не буду объяснять, как работает алгоритм, потому что с этим уже хорошо справились другие люди. Могу порекомендовать изучить эти две статьи: [здесь](http://blog.ivank.net/fortunes-algorithm-and-implementation.html) и [здесь](https://jacquesheunis.com/post/fortunes-algorithm/). Вторая очень любопытна — автор написал интерактивное демо на Javascript, которое полезно для понимания работы алгоритма. Если вам нужен более формальный подход со всеми доказательствами, то рекомендую прочитать главу 7 книги [*Computational Geometry, 3rd edition*](http://www.cs.uu.nl/geobook/).
Более того, я предпочитаю разбираться с подробностями реализации, которые задокументированы не так хорошо. И именно они делают реализацию алгоритма такой сложной. В особенности я сосредоточусь на использованных структурах данных.
Я только написал псевдокод алгоритма, чтобы вы получили понятие о его глобальной структуре:
>
> ```
> добавляем событие места в очередь событий для каждого места
> пока очередь событий не пуста
> извлекаем верхнее событие
> если событие является событием места
> вставляем в линию побережья новую дугу
> проверяем наличие новых событий окружностей
> иначе
> создаём в диаграмме вершину
> удаляем из береговой линии стянутую дугу
> удаляем недействительные события
> проверяем наличие новых событий окружностей
> ```
>
Структура данных диаграммы
==========================
Первая проблема, с которой я столкнулся — выбор способа хранения диаграммы Вороного.
Я решил использовать структуру данных, широко применяемую в вычислительной геометрии, которая называется [двусвязным списком рёбер](https://en.wikipedia.org/wiki/Doubly_connected_edge_list) (doubly connected edge list, DCEL).
Мой класс `VoronoiDiagram` использует в качестве полей четыре контейнера:
```
class VoronoiDiagram
{
public:
// ...
private:
std::vector mSites;
std::vector mFaces;
std::list mVertices;
std::list mHalfEdges;
}
```
Я подробно расскажу о каждом из них.
Класс `Site` описывает входную точку. Каждое место имеет индекс, который полезен для занесения его в очередь, координаты и указатель на ячейку (`face`):
```
struct Site
{
std::size_t index;
Vector2 point;
Face* face;
};
```
Вершины ячейки представлены классом `Vertex`, у них есть только поле координат:
```
struct Vertex
{
Vector2 point;
};
```
Вот реализация полурёбер:
```
struct HalfEdge
{
Vertex* origin;
Vertex* destination;
HalfEdge* twin;
Face* incidentFace;
HalfEdge* prev;
HalfEdge* next;
};
```
Вы можете задаться вопросом — что такое полуребро? Ребро в диаграмме Вороного является общим для двух соседних ячеек. В структуре данных DCEL мы разделяем эти рёбра на два полуребра, по одному для каждой ячейки, и они связываются указателем `twin`. Более того, у полуребра есть исходная и конечная точки. Поле `incidentFace` указывает на грань, которой принадлежит полуребро. Ячейки в DCEL реализуются как циклический двусвязный список полурёбер, в котором соседние полурёбра соединены вместе. Поэтому поля `prev` и `next` указывают на предыдующие и следующие полурёбра в ячейке.
На рисунке ниже показаны все эти поля для красного полуребра:
Наконец, класс `Face` задаёт ячейку. Он просто содержит указатель на своё место и ещё один на одно из его полурёбер. Не важно, какое из полурёбер выбрано, потому что ячейка — это замкнутый полигон. Таким образом, мы получаем доступ ко всем полурёбрам при обходе циклического связанного списка.
```
struct Face
{
Site* site;
HalfEdge* outerComponent;
};
```
Очередь событий
===============
Стандартный способ реализации очереди событий — очередь с приоритетами. В процессе обработки событий места и окружностей нам может понадобиться удалить события окружностей из очереди, потому что они больше не являются действительными. Но большинство стандартных реализаций очереди с приоритетами не позволяют удалять элемент, не находящийся на вершине. В частности это относится и к `std::priority_queue`.
Эту проблему можно решить двумя способами. Первый, более простой — добавить к событиям флаг `valid`. Изначально `valid` имеет значение `true`. Тогда вместо удаления события окружности из очереди, мы можем просто присвоить его флагу значение `false`. Наконец, при обработке всех событий в основном цикле мы проверяем, равно ли значение флага `valid` события `false`, и если это так, то просто пропускаем его и обрабатываем следующее.
Второй способ, который применил я — не использовать `std::priority_queue`. Вместо неё я реализовал собственную очередь с приоритетами, которая поддерживает удаление любого содержащегося в ней элемента. Реализация такой очереди довольно проста. Я выбрал этот способ, потому что он делает код алгоритма чище.
Береговая линия
===============
Структура данных береговой линии — сложная часть алгоритма. В случае неверной реализации нет никаких гарантий, что алгоритм будет выполняться за . Ключ к получению такой временной сложности — использование самобалансирующегося дерева. Но это проще сказать, чем сделать!
В большинстве ресурсов, которые я изучал (две вышеупомянутые статьи и книга *Computational Geometry*), советуют реализовывать береговую линию как дерево, в котором внутренние узлы обозначают точки излома, а листья обозначают дуги. Но в них ничего не говорится о том, как сбалансировать дерево. Думаю, что такая модель не самая лучшая, и вот почему:
* в ней есть избыточная информация: мы знаем, что между двумя соседними дугами есть точка излома, поэтому необязательно представлять эти точки в виде узлов
* она неадекватна для самобалансировки: можно сбалансировать только поддерево, образованное точками излома. Мы и в самом деле не можем сбалансировать всё дерево целиком, потому что в противном случае дуги могут стать внутренними узлами и листьями точек излома. Написание алгоритма для балансировки только поддерева, образованного внутренними узлами, мне кажется кошмарной задачей.
Поэтому я решил представить береговую линию иначе. В моей реализации береговая линия тоже является деревом, но все узлы обозначают дуги. Такая модель не имеет ни одного из перечисленных недостатков.
Вот определение дуги `Arc` в моей реализации:
```
struct Arc
{
enum class Color{RED, BLACK};
// Hierarchy
Arc* parent;
Arc* left;
Arc* right;
// Diagram
VoronoiDiagram::Site* site;
VoronoiDiagram::HalfEdge* leftHalfEdge;
VoronoiDiagram::HalfEdge* rightHalfEdge;
Event* event;
// Optimizations
Arc* prev;
Arc* next;
// Only for balancing
Color color;
};
```
Первые три поля используются для структуры дерева. Поле `leftHalfEdge` указывает на полуребро, отрисованное крайней левой точкой дуги. А `rightHalfEdge` — на полуребро, отрисованное крайней правой точкой. Два указателя, `prev` и `next` используются для получения прямого доступа к предыдущей и следующей дуге береговой линии. Кроме того, они также позволяют обойти береговую линию как двусвязанный список. И наконец, у каждой дуги есть цвет, который используется для балансировки береговой линии.
Для балансировки береговой линии я решил воспользоваться [красно-чёрной схемой](https://en.wikipedia.org/wiki/Red%E2%80%93black_tree). При написании кода я вдохновлялся книгой [Introduction to Algorithms](https://en.wikipedia.org/wiki/Introduction_to_Algorithms). В главе 13 описаны два интересных алгоритма, `insertFixup` и `deleteFixup`, которые балансируют дерево после вставки или удаления.
Однако я не могу использовать приведённый в книге метод `insert`, потому что для нахождения места вставки узла в нём используются ключи. В алгоритме Форчуна нет ключей, мы только знаем, что нужно вставлять дугу до или после другой в береговой линии. Чтобы реализовать это, я создал методы `insertBefore` и `insertAfter`:
```
void Beachline::insertBefore(Arc* x, Arc* y)
{
// Find the right place
if (isNil(x->left))
{
x->left = y;
y->parent = x;
}
else
{
x->prev->right = y;
y->parent = x->prev;
}
// Set the pointers
y->prev = x->prev;
if (!isNil(y->prev))
y->prev->next = y;
y->next = x;
x->prev = y;
// Balance the tree
insertFixup(y);
}
```
Вставка `y` перед `x` выполняется в три этапа:
1. Находим место для вставки нового узла. Для этого я воспользовался следующим наблюдением: левый дочерний элемент `x` или правый дочерний элемент `x->prev` равен `Nil`, и тот из них, который равен `Nil` находится перед `x` и после `x->prev`.
2. Внутри береговой линии мы сохраняем структуру двусвязного списка, поэтому мы должны соответствующим образом обновлять указатели `prev` и `next` элементов `x->prev`, `y` и `x`.
3. Наконец, мы просто вызываем для балансировки дерева метод `insertFixup`, описанный в книге.
`insertAfter` реализуется аналогично.
Взятый из книги метод удаления можно реализовать без изменений.
Ограничение диаграммы
=====================
Вот выходные данные описанного выше алгоритма Форчуна:
Возникает небольшая проблема с некоторыми рёбрами ячеек на границе изображения: они не отрисовываются, потому что они бесконечны.
Хуже того — ячейка может и не быть одним фрагментом. Например, если мы возьмём три точки, находящиеся на одной прямой, то у средней точки будет два бесконечных полуребра, не связанных вместе. Это не очень нас устраивает, потому что мы не сможем получить доступ к одному из полурёбер, ведь ячейка является связанным списком рёбер.
Чтобы решить эти проблемы, мы ограничим диаграмму. Под этим я подразумеваю то, что мы ограничим каждую ячейку диаграммы, чтобы в них больше не было бесконечных рёбер и каждая ячейка являлась замкнутым полигоном.
К счастью, алгоритм Форчуна позволяет нам быстро найти бесконечные рёбра: они соответствуют полурёбрам, всё ещё находящимся в береговой линии к концу работы алгоритма.
Мой алгоритм ограничения получает в качестве входных данных прямоугольник (box) и состоит из трёх этапов:
1. Он обеспечивает размещение каждой вершины диаграммы внутри прямоугольника.
2. Отсекает каждое бесконечное ребро.
3. Замыкает ячейки.
Этап 1 тривиален — нам просто нужно расширить прямоугольник, если он не содержит вершину.
Этап 2 тоже довольно прост — он состоит из вычисления пересечений между лучами и прямоугольником.
Этап 3 также не очень сложен, только требует внимательности. Я выполняю его в два этапа. Сначала я добавляю точки углов прямоугольника к ячейкам, в вершинах которых они должны быть. Затем я делаю так, чтобы все вершины ячейки были соединены полурёбрами.
Рекомендую изучить код и задать вопросы, если вам нужны подробности об этой части.
Вот выходная диаграмма ограничивающего алгоритма:
Теперь мы видим, что все рёбра отрисовываются. И если уменьшить масштаб, то можно убедиться, что все ячейки замкнуты:
Пересечение с прямоугольником
=============================
Отлично! Но первое изображение из начала статьи лучше, правда?
Во многих случаях применения полезно иметь пересечение между диаграммой Вороного и прямоугольником, как и показано на первом изображении.
Хорошо то, что после ограничения диаграммы сделать это гораздо проще. Плохо то, что хоть алгоритм и не очень сложен, нам нужно быть внимательными.
Идея заключается в следующем: мы обходим её полурёбра каждой ячейки и проверяем пересечение между полуребром и прямоугольником. Возможны пять случаев:
1. Полуребро полностью находится внутри прямоугольника: такое полуребро мы сохраняем
2. Полуребро полностью находится снаружи прямоугольника: такое полуребро мы отбрасываем
3. Полуребро выходит наружу прямоугольника: мы усекаем полуребро и сохраняем его как *последнее полуребро, выходившее наружу*.
4. Полуребро входит внутрь прямоугольника: мы усекаем полуребро, чтобы связать его с *последним полуребром, выходившим наружу* (мы сохраняем его в случае 3 или 5)
5. Полуребро пересекает прямоугольник дважды: мы усекаем полуребро и добавляем полурёбра, чтобы связать ег с *последним полуребром, выходившим наружу*, а затем сохраняем его как новое *последнее полуребро, выходившее наружу*.
Да, получилось много случаев. Я создал картинку, чтобы все их показать:
Оранжевый полигон — это исходная ячейка, а красный — усечённая ячейка. Усечённые полурёбра обозначены красным. Зелёные рёбра добавлены, чтобы связать полурёбра, входящие в прямоугольник, с полурёбрами, выходящими наружу.
Применив этот алгоритм к ограниченной диаграмме, мы получаем ожидаемый результат:
Заключение
==========
Статья оказалась довольно длинной. И я уверен, что многие аспекты до сих пор вам непонятны. Тем не менее, надеюсь, она будет вам полезной. Изучите код, чтобы разобраться в подробностях.
Чтобы подвести итог и убедиться, что мы не потратили время зря, я измерил на своём (дешёвом) ноутбуке время вычисления диаграммы Вороного для разного количества мест:
* : 2 мс
* : 33 мс
* : 450 мс
* : 6600 мс
Мне не с чем сравнить эти показатели, но кажется, что это невероятно быстро!
Справочные материалы
====================
* [Оригинальная статья Стивена Форчуна](http://www.wias-berlin.de/people/si/course/files/Fortune87-SweepLine-Voronoi.pdf)
* [*Computational Geometry, 3rd edition*](http://www.cs.uu.nl/geobook/) by Mark de Berg, Otfried Cheong, Marc van Kreveld and Mark Overmars
* [Fortunes Algorithm: An intuitive explanation](https://jacquesheunis.com/post/fortunes-algorithm/) на jacquesheunis.com
* [Fortune’s algorithm and implementation](http://blog.ivank.net/fortunes-algorithm-and-implementation.html) на blog.ivank.net
* [*Introduction to Algorithms, 3rd edition*](http://mitpress.mit.edu/books/introduction-algorithms-third-edition) by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest and Clifford Stein | https://habr.com/ru/post/430628/ | null | ru | null |
# Pebble: пример использования Android-компаньона
 Благодаря официальному мобильному приложению Pebble отлично справляются с информированием о состоянии вашего смартфона — показывают входящие сообщения, информацию о вызовах и прочие уведомления. Но что делать, если такая нужная «мелочь», как например состояние батареи смартфона, количество непрочитанных SMS и e-mail, недоступна для использования в своих приложениях на часах? Вариант, реализовать это самому.
И так, о том как использовать PebbleKit Android для интеграции Pebble и Android-приложения на примере **уведомления о количестве пропущенных вызовов**: немного кода, перевод выдержек из [документации [1]](#Anchor1) и совсем мало картинок.
Тезисно, как работает взаимодействие мобильного приложения и watchappp:
* приложение-компаньон распознает, соединяется и обменивается информацией с Pebble через библиотеку PebbleKit;
* watchapp (watchface) и мобильное приложение обмениваются сообщениями в двустороннем режиме, идентификация канала с обоих сторон осуществляется по UUID приложения Pebble;
* обмен между Pebble-приложением и мобильным приложением осуществляется объектами [Dictionary [2]](#Anchor2).
Для решения поставленной задачи, вывода уведомления на часах о количестве пропущенных вызовов, необходимо:
* Pebble-приложение, которое умеет получать, обрабатывать и отображать информацию из приложения-компаньона;
* Android-приложение, которое отслеживает вызовы и отсылает количество неотвеченных в наше приложение на часах.
Watchapp
--------
В Pebble-приложении, точно так же как и в случае с PebbleKit JS, используется механизм [AppMessage API [3]](#Anchor3).
Так как наше приложении само не инициирует сеанс связи, а только ждет сообщение со стороны смартфона, я буду использовать [Synchronizing App UI [4]](#Anchor4) — вспомогательный слой поверх AppMessage, который упрощает синхронизацию значений между watchapp и мобильным устройством. Используется только два обратных вызова, один из которых в случае когда изменяется предопределенное значение, и другой, если происходит ошибка.
Определяем ключ, AppSync и буфер для синхронизации кортежа:
```
#define KEY_CALLS_COUNT 41
static AppSync s_sync;
static uint8_t s_sync_buffer[32];
```
Инициализацию механизама синхронизации и начального значения кортежа вынесем в отдельную функцию:
```
/* ... */
static void start_sync() {
app_message_open(app_message_inbox_size_maximum(),
app_message_outbox_size_maximum());
// Начальная инициализация кортежа (0 неотвеченных)
Tuplet initial_values[] = {
TupletInteger(KEY_CALLS_COUNT, 0),
};
app_sync_init(&s_sync, s_sync_buffer, sizeof(s_sync_buffer),
initial_values, ARRAY_LENGTH(initial_values),
sync_changed_handler, sync_error_handler, NULL);
}
static void init(void) {
/* ... */
start_sync();
}
```
Определяем обратные вызовы:
```
/* ... */
static char s_count_buffer[4];
/* ... */
static void sync_changed_handler(const uint32_t key, const Tuple *new_tuple,
const Tuple *old_tuple, void *context) {
// Преобразовываем полученное значение в строку
snprintf(s_count_buffer, sizeof(s_count_buffer),
"%d", (int)new_tuple->value->int32);
// Помечаем слой с индикатором для перерисовки
layer_mark_dirty(layer);
}
static void sync_error_handler(DictionaryResult dict_error,
AppMessageResult app_message_error,
void *context) {
APP_LOG(APP_LOG_LEVEL_ERROR, "sync error!");
}
/* ... */
```
*N.B. В данном случае, ключ используемый для обмена значением не требует регистрации в appinfo.json.*
Если сейчас запустить наше простое приложение, то на экране будет одинокий индикатор (0 пропущенных вызовов):
Android-приложение
------------------
Получить количество пропущенных вызовов в Android можно разными способами, в данном примере я буду брать её из «шторки» с уведомлениями — Notification Area.
Само приложение состоит из двух классов: MainActivity для ввода UUID watchapp'а которое будет принимать данные и сервиса NotificationListener, который отслеживает уведомления.
*N.B. Доступ к Notification Area через NotificationListenerService появился в Android 4.3. Так как используются дополнительные метаданные Notification.extras, пример будет гарантировано работать только на Android 4.4+.*
Для Android Studio добавление PebbleKit осуществляется через gradle-файл.
Добавляем в *app/build.gradle*:
```
dependencies {
compile 'com.getpebble:pebblekit:2.6.0'
}
repositories {
mavenCentral()
maven { url "https://oss.sonatype.org/content/groups/public/" }
}
```
После синхронизации PebbleKit можно использовать в своем проекте.
Для доступа к уведомлениям использую класс NotificationListener, унаследованный от NotificationListenerService с переопределенными методами onNotificationPosted() и onNotificationRemoved():
```
public class NotificationListener extends
NotificationListenerService {
@Override
public void onNotificationPosted(
StatusBarNotification sbn) {
this.getMissedCalls();
}
@Override
public void onNotificationRemoved(
StatusBarNotification sbn) {
this.getMissedCalls();
}
}
```
При добавлении или удалении уведомления, просматриваются все активные и если присутствует информация о пропущенных вызовах, количество их посылается в приложение на часах:
```
public class NotificationListener extends
NotificationListenerService {
// Счетчик пропущенных вызовов
int missedCallsCount = 0;
/*...*/
void getMissedCalls() {
int tCount = 0;
for (StatusBarNotification notif :
this.getActiveNotifications()) {
if (notif.getPackageName().equals("com.android.phone")) {
String extras_text = notif.getNotification().extras.getString(Notification.EXTRA_TEXT);
if (extras_text.indexOf("Пропущенных вызовов:") != -1) {
tCount = Integer.parseInt(extras_text.split(":")[1].trim());
}
}
}
if (tCount != missedCallsCount) {
missedCallsCount = tCount;
this.sendMissedCalls(missedCallsCount);
}
}
}
```
Для отправки данных на часы определяем ключ, UUID, формируем словарь и используем метод sendDataToPebble:
```
public class NotificationListener extends
NotificationListenerService {
UUID APPS_UUID;
private static final int CALLS_KEY = 41;
/*...*/
public void sendMissedCalls(int missedCalls) {
APPS_UUID = UUID.fromString(this.getUUID());
PebbleDictionary data = new PebbleDictionary();
data.addUint32(CALLS_KEY, missedCalls);
PebbleKit.sendDataToPebble(getApplicationContext(), APPS_UUID, data);
}
/*...*/
}
```
Для предоставления приложению прав доступа к уведомлениям необходимо добавить в манифест:
```
```
Замечание, после установки приложения необходимо разрешить сервис, без авторизаци работать не будет. Настройка находится по пути «Settings» -> «Security» -> «Notification access». В русской локали у меня «Настройки» -> «Конфиденциальность» -> «Доступ к уведомлениям».
Запускаем android-приложение, указываем в нем UUID Pebble-приложения, звоним и не отвечаем, смотрим как меняется уведомление на часах:
Исходники:
[notice watchapp](https://bitbucket.org/tmnhy/notify-ex/src/734ffd702ebbb46732bbf8aa6cb76fafb0d76993/notice/?at=master) — [pbw](https://bitbucket.org/tmnhy/notify-ex/src/734ffd702ebbb46732bbf8aa6cb76fafb0d76993/bin/notice.pbw?at=master)
[PebbleNotify (проект Android Studio)](https://bitbucket.org/tmnhy/notify-ex/src/734ffd702ebbb46732bbf8aa6cb76fafb0d76993/PebbleNotify/?at=master) — [apk](https://bitbucket.org/tmnhy/notify-ex/src/734ffd702ebbb46732bbf8aa6cb76fafb0d76993/bin/pebblenotify.apk?at=master)
[1. Pebble Developers // Mobile App Developer Guide](https://developer.getpebble.com/guides/mobile-apps/)
[2. Pebble Developers // Dictionary](https://developer.getpebble.com/docs/c/group___dictionary.html)
[3. Pebble Developers // App Communication](https://developer.getpebble.com/guides/pebble-apps/communications/appmessage)
[4. Pebble Developers // Synchronizing App UI](https://developer.getpebble.com/guides/pebble-apps/communications/appsync/) | https://habr.com/ru/post/249167/ | null | ru | null |
# IPv6 теория и практика: виды пакетов и автоконфигурация
Эта вторая статья, продолжающая цикл, посвященный IPv6. В [первой](http://habrahabr.ru/post/210100/) вводной статье речь шла о структуре IPv6 пакета, записи адресов, префиксе. Сегодня мы поговорим о том, какие виды пакетов бывают в IPv6, о важности мультикастов, а также, о видах автоматической конфигурации хоста в IPv6.
Примечание: в этой и других статьях под словом «маршрутизатор» я подразумеваю «маршрутизатор cisco».
#### Типы вещания в IPv6
В IPv6 существует три вида рассылки:
1. **Unicast** – один источник, один получатель
2. **Multicast** – один источник, несколько получателей
3. **Anycast** – один источник, несколько потенциальных получателей, но отсылается только одному из них.
Как мы видим, здесь нет широковещательной (*Broadcast*) рассылки. Там, где раньше использовалось широковещание, в IPv6 используются мультикастовые адреса. Действительно, зачем ограничивать себя рамками broadcast, когда multicast гораздо гибче – иногда можно отослать сообщение группе хостов, а иногда – всем.
#### Подробнее о мультикастах
В IPv6 для мультикастовых адресов выделен специальный диапазон FF00::/8. То есть, **все адреса, начинающиеся с FF – мультикастовые**.
Адреса мультикаст бывают двух типов:
1. Назначенные (Assigned multicast) – специальные адреса, назначение которых предопределено.
2. Запрошенные (Solicited multicast) – остальные адреса, которые устройства могут использовать для прикладных задач.
##### Назначенные адреса
Назначенные адреса – это зарезервированные для определённых групп устройств мультикастовые адреса. Отправляемый на такой адрес пакет будет получен всеми устройствами, входящими в группу. Существует два специальных назначенных мультикастовых адреса:
1. FF02::1 – в эту группу входят все устройства в локальной сети. Таким образом, данный специальный мультикастовый адрес ведёт себя как широковещательный адрес в IPv4. Все устройства обязаны принимать пакеты, отправленные на FF02::1.
2. FF02::2 – в эту группу входят все маршрутизаторы. С помощью данного адреса возможно сделать рассылку по маршрутизаторам, присутствующим в локальной сети. Как только на маршрутизаторе Cisco включается режим маршрутизации для IPv6, он автоматически становится участником этой группы и начинает принимать весь трафик, адресованный на FF02::2.
##### Запрошенные адреса
Адрес этого типа автоматически появляется, когда на некотором интерфейсе появляется юникастовый адрес. Адрес формируется из сети FF02:0:0:0:0:1:FF00::/104, оствашиеся 24 бита – такие же как у настроенного юникастового адреса. Обратите внимание, что /104 означает, что из данной сети только первые 104 бита берутся для формирования адреса (последние два нуля в записи не участвуют).
Когда некоторое устройство получает пакет, у которого адреса получателя находится в сети FF02:0:0:0:0:1:FF00/104, оно обязано принять этот пакет в том случае, если оставшиеся 24 бита в этом адреса равны последним 24-м битам в юникастовом адресе самого устойства.
Допустим, есть устройство с адресом 2001:0DB8:ABCD:0001:0000:0000:0123:A050. Последние 24 бита (6 шестнадцатеричных цифр) в данном случае – это «23:A050». Значит это устройство обязано принимать так же и трафик, приходящий на муьтикастовый адрес FF02:0:0:0:0:1:FF23:A050.
Такие мультикастовые адреса активно используются в ситуации, когда некоторое устройство хочет узнать MAC адрес своего соседа (аналог ARP в IPv4).
Например, некоторое устройство хочет отправить пакет на локальный адрес FE80::1234:5678. Это локальный адрес (так как начинается с FE80, подробнее о типах адресов в предыдущей статье), значит он находится в нашей локальной сети. Соответственно, чтобы на него что-то отправить, надо узнать MAC-адрес целевого устройства (для формирования Ethernet-фрейма). Хост отправляет на запрошенный (solicited) мультикастовый адрес, FF02:0:0:0:0:1:FF34:5678 пакет. Последние 24 бита «34:5678» были взяты из IPv6-адреса искомого устройства. В случае связки IPv4 и ARP, этот пакет отправлялся бы на адрес 255.255.255.255.
Далее искомое устройство отвечает на этот мультикастовый пакет юникастом, сообщая в ответе свой MAC-адрес.
Возможны ситуации, когда несколько устройств обработают такой пакет (если у них совпадают последние 24 бита адреса), но в этом нет ничего страшного, так как это в любом случае лучше широковещания, когда все устройства обрабатывали запрос.
#### Автоконфигурация
В IPv6 появился новый механизм автоконфигурации узла. Называется он Stateless Address Autoconfiguration или SLAAC. Используется он для автоматического получения IP адреса и сетевого префикса узлом, без использования DHCPv6 сервера, или совместно с ним.
Действительно, когда мы создаём некоторую сеть, мы прописываем адрес шлюза и префикс этой сети на маршрутизаторе. Этой информации достаточно, чтобы выдавать адреса устройствам. Механизм SLAAC позволяет маршрутизатору назначать устройствам адреса даже если в сети нет DHCPv6.
Маршрутизатор Cisco с рабочим IPv6 интерфейсом рассылает в сеть информацию об этой сети, включающую в себя сетевую часть IP адреса и длину префикса. Кроме того, в этом сообщении содержится адрес шлюза по умолчанию для сети. Сообщение это называется Router Advertisement (RA) и отправляется обычно раз в 200 секунд на мультикастовый адрес FF02::.
Если в сети появилось новое устройство, которому необходим адрес, ему необязательно ждать 200 секунд до ближайшей рассылки, оно может направит запрос маршрутизатору (Router Solicitation или RS) и попросить его выслать настройки немедленно. Запрос маршрутизатору выполняется на адрес FF02::2.
Оба сообщения RA и RS отправляются посредством протокола ICMPv6, с мультикастовым адресом получателя в IP пакете.
Для того чтобы маршрутизатор начал полноценно обслуживать сеть (рассылать в неё RA и отвечать на RS), мало настроить IPv6 адрес на интерфейсе, необходимо так же включить режим маршрутизации для IPv6 сетей, введя команду `ipv6 unicast routing` в режиме глобальной конфигурации.
Существует три способа назначения адреса:
1. Маршрутизатор выдаёт подсеть, префикс и адрес шлюза. Другую информацию устройства не получают.
2. Маршрутизатор выдаёт подсеть, префикс и адрес шлюза, а отдельный DHCPv6 сервер выдаёт дополнительную информацию: опции, маршруты, адреса DNS серверов и другую – по необходимости.
3. Stateless Address Autoconfiguration вообще не используется – устройство не использует RA от маршрутизатора, а обращается к DHCPv6 серверу, который предоставляет всю необходимую информацию, включая адрес, шлюз, префикс, DNS сервера и другую – в зависимости от настроек DHCP.
В случае использования третьего варианта, DHCP сервер выдаёт клиенту полный IPv6 адрес – все 128 бит, который назначается на интерфейсе клиента. В случае использования первых двух вариантов, маршрутизатор сообщает клиенту только сеть, в которой он находится, шлюз и префикс. Таким образом, клиенту недостаёт второй половины IP адреса (идентификатора интерфейса). Напомню, что адрес состоит из 128 бит, а маршрутизатор выдаёт максимум, только первые 64. Оставшиеся 64 бита, где должна находиться информация о хосте, должны быть заполнены самим устройством, маршрутизатору не важно, что именно устройство туда поместит, важно, чтобы первые 64 бита (сеть) были правильными. Для генерации правой половины IP адреса используется алгоритм [EUI-64](http://ciscotips.ru/eui-64) или вообще генерируется случайный набор цифр.
**UPD1:** Спрашивали меня в личку на счёт правой части адреса, почему так мало информации о ней. Отвечаю. Выдали вам в IPv4 сетку 192.168.0.0/24, и придумывайте себе правую часть какую изволите. То же и тут, только теперь есть где фантазии разгуляться :) У кого фантазия скудная — есть EUI-64 | https://habr.com/ru/post/210224/ | null | ru | null |
# Модуль PowerShell для Intel IoT Gateway
Шлюзы Intel для интернета вещей могут работать под управлением различных операционных систем. Одна из них – Windows 10 IoT. Сегодня мы поговорим о модуле для PowerShell **IntelIoTGatewaySetup**, который создан специально для поддержки IoT-шлюзов в среде Microsoft Windows.
[](https://habrahabr.ru/company/intel/blog/304046/)
Официально этот модуль называется «**Intel IoT Gateway Module for Microsoft Windows PowerShell**». Он помогает настроить операционную систему шлюза на заданный уровень безопасности ([Security SKU](https://software.intel.com/ru-ru/node/622255)).
Основные сведения
-----------------
Модуль входит в состав пакета **Windows Configuration Software for Intel IoT Gateway**. Пакет можно найти по вышеприведённому названию и скачать в [Центре загрузки Intel](https://downloadcenter.intel.com/). В настоящее время поддерживаются операционные системы Windows 10 IoT Enterprise и Windows 10 IoT Core.
**IntelIoTGatewaySetup** позволяет настраивать следующие функции безопасности Windows, указанные в [описании](https://software.intel.com/ru-ru/node/622255#A84AC2D2-DC9B-4C2D-94F6-80AE843EFA4B) уровней безопасности. Предусмотрено три уровня безопасности. В частности, это, в порядке возрастания обеспечиваемого уровня защиты, Basic SKU, Medium SKU, и High SKU. Каждый следующий уровень расширяет возможности предыдущего. Итак, вот список настраиваемых функций.
* Windows Update, Windows Defender, Windows Firewall, Windows User Account Control, USB Removable Media Lockdown, Virtualization Based Security, App Locker, Code Integrity.
* BitLocker с поддержкой модуля TPM для Windows 10 IoT Enterprise. Хотя в определениях уровней безопасности упомянуто использование TPM и сетевой разблокировки (Network Unlock) для среднего и высокого уровней, модуль PowerShell настраивает лишь BitLocker с поддержкой TPM, так как Network Unlock требует дополнительной сетевой инфраструктуры.
Хотя модуль **IntelIoTGatewaySetup** и настраивает множество параметров в соответствии с заданным уровнем безопасности, он не касается следующих возможностей:
* UEFI, Secure Boot и TPM. Всё это является частью аппаратных требований и требований к микропрограммам для шлюзов Intel. Таким образом, эти функции на шлюзе будут уже включены.
* Уровни привилегий учётных записей. Можно создать, в зависимости от особенностей использования системы, учётную запись с ролью администратора или обычную учётную запись со стандартным набором прав.
* ASLR. Эта возможность по умолчанию поддерживается и включена в ОС Windows, таким образом, в дополнительной настройке она не нуждается.
* Measured Boot. Эта функция реализуется благодаря прошивке UEFI, TPM и Windows. Она так же не нуждается в дополнительной настройке.
* [Remote Attestation](https://software.intel.com/ru-ru/node/622254#AC6A8430-8475-46A9-807F-A0FF3A4AE873). Эта функция нуждается в настройке дополнительной сетевой инфраструктуры и в дополнительном программном обеспечении.
* [BitLocker + Network Unlock](https://software.intel.com/ru-ru/node/622254#AC6A8430-8475-46A9-807F-A0FF3A4AE873). Технология Network Unlock требует настройки дополнительной сетевой инфраструктуры и возможностей DHCP-драйвера в UEFI. В результате модуль PowerShell способен настроить лишь BitLocker с поддержкой TPM.
* [USB Filter](https://software.intel.com/ru-ru/node/622254#AC6A8430-8475-46A9-807F-A0FF3A4AE873). Для настройки этой функции в соответствии с особенностями использования шлюза, применяйте групповые политики для того, чтобы управлять USB-устройствами, основываясь на Device ID или Class ID.
* [Keyboard Filter](https://software.intel.com/ru-ru/node/622254#AC6A8430-8475-46A9-807F-A0FF3A4AE873). Для настройки этого фильтра воспользуйтесь инструментом Windows ICD.
В папке **IntelIoTGatewaySetup** находятся следующие основные компоненты:
* **Readme.rtf**. Обычный сопроводительный файл с инструкциями по началу работы.
* **ModuleInstallation.ps1**. Вспомогательный скрипт для установки модуля **IntelIoTGatewaySetup**.
* Папка **IntelIoTGatewaySetup**. Здесь содержится сам модуль.
Установка модуля
----------------
Если у вас имеется шлюз, оснащённый дисплеем и клавиатурой, команды PowerShell, необходимые для установки модуля, можно исполнять непосредственно на шлюзе. После установки команды PowerShell, которые предоставляет модуль, так же можно исполнять прямо на шлюзе. Мы называем это локальной установкой и локальным исполнением команд.
Шлюз может быть расположен вне пределов физической досягаемости, кроме того, у него могут отсутствовать монитор и устройства ввода. В таком случае нужно воспользоваться другим компьютером, назовём его компьютером разработчика, который позволит организовать удалённое управление шлюзом и его настройку. Ниже мы будем рассматривать именно такой сценарий. Мы называем его удалённой установкой и удалённым исполнением команд.
Для того, чтобы установить модуль PowerShell на шлюз с компьютера разработчика, эти две системы должны быть в одной и той же подсети. Кроме того, этот процесс включает в себя временное сопоставление сетевого диска на компьютере и шлюза.
Итак, для удалённой установки модуля нужно выполнить следующие шаги.
Для начала – вот список операций, которые нужно произвести на шлюзе для того, чтобы обеспечить удалённый доступ к PowerShell.
* Если на шлюзе установлена Windows IoT Core, то всё уже готово к работе, ничего больше делать не нужно.
* Если же шлюз оснащён Windows IoT Enterprise, нужно разрешить удалённое взаимодействие с PowerShell, используя [эту](https://technet.microsoft.com/en-us/magazine/ff700227.aspx) и [эту](https://technet.microsoft.com/en-us/library/hh849694.aspx) инструкции. Например, для того, чтобы включить удалённый доступ к PowerShell, воспользуйтесь нижеприведёнными командами.
```
#Получим индекс NIC активного NIC
Get-NetAdapter
#$index – это полученный индекс.
#Переключим целевое активное соединение в приватный режим.
#В качестве разделителя в строке команды используется комбинация пробел + обратная галочка.
Set-NetConnectionProfile -InterfaceIndex $index `
-NetworkCategory Private
#Включим удалённый доступ
Enable-PSRemoting -Force
```
Теперь, когда шлюз готов к работе, займёмся компьютером, выполнив следующие шаги с использованием окружения PowerShell.
**1.** Убедитесь в том, что две следующих учётных записи, созданные на соответствующих устройствах, имеют административные полномочия. А именно:
* Учётная запись для компьютера разработчика, с которой осуществлён вход в систему.
* Учётная запись на шлюзе, которой мы воспользуемся позже.
**2.** Запустите интерпретатор командной строки PowerShell от имени администратора.
**3.** Для того, чтобы запустить скрипт **ModuleInstallation.ps1** нужно, чтобы в PowerShell использовалась политика выполнения скриптов `AllSigned` или `RemoteSigned`. Взгляните на следующие командлеты: `Get-ExecutionPolicy` и `Set-ExecutionPolicy`. Они позволяют, соответственно, узнавать и задавать политику выполнения. Например, с помощью такой команды можно задать использование политики `RemoteSigned`.
```
Set-ExecutionPolicy RemoteSigned
```
**4.** Воспользуйтесь точечной нотацией при вызове скрипта **ModuleInstallation.ps1**. Для того, чтобы это сделать, введите символ точки «.» и пробел перед путём к запускаемому скрипту. Этот подход позволяет запустить скрипт в [текущей области действия](https://technet.microsoft.com/ru-ru/library/hh847849.aspx).
```
. .\ModuleInstallation.ps1
```
**5.** Затем взгляните на справку по модулю, о котором мы здесь говорим, ознакомьтесь с примерами его использования. Для этого воспользуйтесь такой командой `Get-Help Install-IntelIoTGatewaySetup –Full`
**6.** Выполните команду `Install-IntelIoTGatewaySetup` для установки модуля с компьютера разработчика на шлюз. Правила использования этой команды можно найти в справочных материалах из предыдущего шага. Например, можно воспользоваться следующей последовательностью действий:
```
#$path это путь к папке, в которой находится загруженный модуль,
# например: ‘C:\IntelIoTGatewaySetup’
#$remoteip это IP-адрес удалённого шлюза,
#например: ‘192.168.2.5’
#$remoteaccount это учётная запись на шлюзе,
#например, ‘Tester’ или ‘Domain\Tester’
#В качестве разделителя в строке команды используется комбинация пробел + обратная галочка.
Install-IntelIoTGatewaySetup –ModuleLocalPath $path `
-RemoteGateway $remoteip `
-RemoteAccount $remoteaccount –Verbose
```
Обратите внимание на то, что при локальной установке можно исполнить команду `Install-IntelIoTGatewaySetup` непосредственно на шлюзе. Для деинсталляции модуля предусмотрена команда `Uninstall-IntelToTGatewaySetup`. Подробности об этом можно найти в справочных материалах к модулю.
**7.** После установки воспользуйтесь PowerShell для выполнения команд нашего модуля на шлюзе. Об особенностях использования PowerShell на удалённых системах можно почитать [здесь](http://blogs.technet.com/b/heyscriptingguy/archive/2013/11/26/remoting-week-remoting-sessions-in-powershell.aspx). Например, выполните, по порядку, нижеприведённые команды.
1. Запустите службу WInRM, если она ещё не запущена.
```
if ((Get-Service WinRM).Status.ToString() -ne 'Running') {
# Запуск службы WinRM
Write-Verbose "Start WinRM service."
net start WinRM
}
```
2. Добавьте удалённый шлюз в список TrustedHosts.
```
#Эта команда удалит исходный TrustedHosts и приведет к использованию $remoteip.
#Кроме того, она может добавить новое значение к списку TrustedHosts.
#Справку можно вызвать командой Get-Help Set-Item.
#$remoteip это IP-адрес удалённого шлюза.
#В качестве разделителя в строке команды используется комбинация пробел + обратная галочка.
Set-Item WSMan:\localhost\Client\TrustedHosts `
-Value $remoteip –Force
```
3. Создайте удалённую сессию PowerShell на удалённом шлюзе.
```
#$remoteip это IP-адрес удалённого шлюза.
#$remoteaccount это учётная запись с административными полномочиями
#на удалённом шлюзе.
#В качестве разделителя в строке команды используется комбинация пробел + обратная галочка.
$s = New-PSSession -ComputerName $remoteip `
-Credential "localhost\$remoteaccount"
```
4. Выполните эти команды на удалённом шлюзе.
```
#Запустите удалённый скрипт для тестирования
Invoke-Command -Session $s -ScriptBlock {
#В этом блоке можете запустить желаемые команды PowerShell.
#Эти команды будут запущены на удалённом шлюзе.
#взглянем на сведения о нашем модуле
Get-Command -Module IntelIoTGatewaySetup
Get-Module IntelIoTGatewaySetup
}
```
5. Закройте удалённую сессию PowerShell после того, как выполните все необходимые команды.
```
Remove-PSSession -Session $s
```
Использование модуля
--------------------
Здесь мы, так же, как в предыдущем разделе, исходим из предположения, что для работы со шлюзом используется компьютер. Расскажем о том, как пользоваться модулем. Для начала, если вы этого ещё не сделали, включите использование удалённого PowerShell на шлюзе. Теперь, на компьютере разработчика, выполните следующие шаги.
* Воспользуйтесь той же процедурой, которая описана в п.7 предыдущего раздела. Все следующие примеры рассчитаны на то, что исполняемые на удалённом шлюзе команды будут помещены внутрь блока конструкции `Invoke-Command`.
* После установки модуля воспользуйтесь командой `Get-Help` с параметром `–Full` для того, чтобы узнать подробности о командах модуля. Например, выполните следующую команду для того, чтобы получить список всех команд, доступных в модуле:
```
Get-Command -Module IntelIoTGatewaySetup
```
* Для настройки уровня безопасности служат команды `Enable-IoTWinSecurities` и `Disable-IoTWinSecurities`. Они, в свою очередь, вызывают другие команды модулей. Полезно будет взглянуть на справку по ним (`Get-Help Enable-IoTWinSecurities –Full`). Вот примеры работы с ними.
* Для того, чтобы включить базовый уровень безопасности («Basic» SKU) и задействовать приведённый в примере пароль восстановления BitLocker, выполните следующие команды.
```
#$RecoveryPW это пароль восстановления для BitLocker,
# который вы хотите использовать.
#Например: $RecoveryPW =
# '099825-222222-607607-626285-132319-115621-083204-229482'
#В качестве разделителя в строке команды используется комбинация пробел + обратная галочка.
Enable-IoTWinSecurities -SKU "Basic" `
-BitLockerRecoveryPW $RecoveryPW `
-AddPowerShellRemotingFirewallRule -ErrorLog –Verbose
```
Взгляните на сообщения о результатах работы команд для того, чтобы выяснить, нет ли среди них предупреждений или сообщений об ошибках, которые касаются включаемых функций безопасности.
Например, предупреждение может содержать рекомендацию о том, что сначала надо перезагрузить систему для того, чтобы завершить установку необходимых средств Windows, а потом снова выполнить команду установки.
Для того, чтобы отключить / удалить настройки уровня безопасности, выполните следующую команду:
```
Disable-IoTWinSecurities -ErrorLog -Verbose
```
Отдельные команды, используемые в `Enable-IoTWinSecurities` и `Disable-IoTWinSecurities`, можно применять и самостоятельно, для настройки отдельных функций безопасности.
Если TPM «не готов к использованию», его, сначала, нужно [установить](https://technet.microsoft.com/en-us/library/cc755108.aspx). В противном случае не получится включить BitLocker.
Если AppLocker настроен в соответствии с высоким уровнем безопасности («High» SKU), пользователи не смогут использовать PowerShell для добавления новых функций Windows. В соответствии с архитектурой системы, файл DISMHOST.EXE, который используется PowerShell, находится во временной папке, в директории, соответствующей учётной записи пользователя, а этот файл окажется заблокированным. В результате пользователи не смогут использовать наши команды для включения VBS, так как эта команда попытается установить необходимую ей функцию Windows. При выполнении команды `Enable-IoTWinSecurities` мы сначала выполняем установку VBS. Если нужно установить функции Windows, выполните перезагрузку системы для того, чтобы завершить их установку, а затем снова запустите команду.
Для функционирования системы User Mode Code Integrity нам нужно установить ключ реестра для того, чтобы разрешить размещению нашего модуля войти в режим Full Language Mode для Code Integrity Policy. В частности, рассматриваемый здесь модуль, по умолчанию, устанавливается по адресу `%Program Files%\WindowsPowerShell\Module`. Если это не так, соответствующий ключ реестра нужно настроить самостоятельно. Для этого нужно поместить путь, по которому установлен модуль (например, %`Program Files%\WindowsPowerShell\Module`) в запись типа `REG_MULTI_SZ`, которая называется «TestPath» и расположена в разделе реестра `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\CI\TRSData`.
Итоги
-----
Сегодня мы рассказали вам о новом средстве для настройки IoT-шлюзов Intel, которые работают под управлением Microsoft Windows. Рассмотренный здесь модуль для PowerShell, **IntelIoTGatewaySetup**, позволяет взаимодействовать со шлюзами как локально, так и удалённо, а собранные в нём команды помогают упростить и ускорить процедуры настройки шлюзов. | https://habr.com/ru/post/304046/ | null | ru | null |
# Поиск подстроки и смежные вопросы
Здравствуйте, уважаемое сообщество! Недавно на Хабре проскакивала неплохая обзорная [статья](http://habrahabr.ru/blogs/algorithm/111449/) о разных алгоритмах поиска подстроки в строке. К сожалению, там отсутствовали подробные описания каких либо из упомянутых алгоритмов. Я решил восполнить данный пробел и описать хотя бы парочку тех, которые потенциально можно запомнить. Те, кто еще помнит курс алгоритмов из института, не найдут, видимо, ничего нового для себя.
Сначала хотел бы предотвратить вопрос «на кой это надо? все уже и так написано». Да, написано. Но во-первых, полезно знать как работает используемые тобой иструменты на более низком уровне чтобы лучше понимать их ограничения, а во-вторых, есть достаточно большие смежные области, где работающей из коробочки функции strstr() окажется недостаточно. Ну и в-третьих, вам может неповезти и придется разрабатывать под мобильную платформу с неполноценным runtime, а тогда лучше знать на что подписываетесь, если решитесь самостоятельно его дополнять (чтобы убедиться, что это не сферическая проблема в вакууме, достаточно попробовать wcslen() и wcsstr() из Android NDK).
#### А разве просто поискать нельзя?
Дело в том, что очевидный способ, который все формулирует как «взять и поискать», является отнюдь не самым эффективным, а для такой низкоуровневой и сравнительно частовызываемой функции это немаловажно. Итак, план такой:
1. Постановка задачи: здесь перечислены определения и условные обозначения.
2. Решение «в лоб»: здесь будет описано, как делать не надо и почему.
3. Z-функция: простейший вариант правильной реализации поиска подстроки.
4. Алгоритм Кнута-Морриса-Пратта: еще один вариант правильного поиска.
5. Другие задачи поиска: вкратце пробегусь по ним без подробного описания.
#### Постановка задачи
Канонический вариант задачи выглядит так: есть у нас строка **A** (*текст*). Необходимо проверить, есть ли в ней подстрока **X** (*образец*), и если есть, то где она начинается. То есть именно то, что делает функция strstr() в C. Дополнительно к этому можно еще попросить найти все вхождения образца. Очевидно, что задача имеет смысл только если **X** не длинее **A**.
Для простоты дальнейшего объяснения введу сразу пару понятий. Что такое *строка* все, наверное, понимают — это последовательность символов, возможно пустая. *Символы*, или буквы, принадлежат некоторому множеству, которое называют *алфавитом* (данный алфавит, вообще говоря, может не иметь ничего общего с алфавитом в бытовом понимании). *Длина строки* |**A**| — это, очевидно, количество символов в ней. *Префикс строки* **A[**..i**]** — это строка из i первых символов строки **A**. *Суффикс строки* **A[**j..**]** — это строка из |**A**|-j+1 последних символов. Подстроку из **A** будем обозначать как **A[**i..j**]**, а **A[**i**]** — i-ый символ строки. Вопрос про пустые суффиксы и префиксы и т.д. не трогаем — с ними разобраться не сложно по месту. Еще есть такое понятие как *сентинел* — некий уникальный символ, не встречающийся в алфавите. Его обозначают значком $ и дополняют допустимый алфавит таким символом (это в теории, на практике проще применить дополнительные проверки, чем придумать такой символ, которого не могло бы оказаться во входных строках).
В выкладках будем считать символы в строке с первой позиции. Код писать традиционно проще отсчитывая от нуля. Переход от одного к другому не составляет трудностей.
#### Решение «в лоб»
Прямой поиск, или, как еще часто говорят, «просто взять и поискать»- это Первое решение, которое приходит в голову неискушенному программисту. Суть проста: идти по проверяемой строке **A** и искать в ней вхождение первого символа искомой строки **X**. Когда находим, делаем гипотезу, что это и есть то самое искомое вхождение. Затем остается проверять по очереди все последующие символы шаблона на совпадение с соответствующими символами строки **A**. Если они все совпали — значит вот оно, прямо перед нами. Но вот если какой-то из символов не совпал, то ничего не остается, как признать нашу гипотезу неверной, что возвращает нас к символу, следующему за вхождением первого символа из **X**.
Многие люди ошибаются в этом пункте, считая, что не надо возвращаться назад, а можно продолжать обработку строки **A** с текущей позиции. Почему это не так легко продемонстрировать на примере поиска **X**=*«AAAB»* в **A**=*«AAAAB»*. Первая гипотеза нас приведет к четвертому символу **A**: *"AAAAB"*, где мы обнаружим несоответствие. Если не откатиться назад, то вхождение мы так и не обнаружим, хотя оно есть.
Неправильные гипотезы неизбежны, а из-за таких откатываний назад при плохом стечении обстоятельств может оказаться, что мы каждый символ в **A** проверили около |**X**| раз. То есть вычислительная сложность сложность алгоритма O(|**X**||**A**|). Так поиск фразы в параграфе может и затянуться...
Справедливости ради следует отметить, что если строки невелики, то такой алгоритм может работать быстрее «правильных» алгоритмов за счет более предсказуемого с точки зрения процессора поведения.
#### Z-функция
Одна из категорий правильных способов поиска строки сводится к вычислению в каком-то смысле корреляции двух строк. Сначала отметим, что задача сравнения начал двух строк проста и понятна: сравниваем соответствующие буквы, пока не найдем несоответствие либо какая-нибудь из строк закончится. Рассмотрим множество всех суффиксов строки **A**: **A[**|**A**|..**]** **A[**|**A**|-1..**]**,… **A[**1..**]**. Будем сравнивать начало самой строки с каждым из ее суффиксов. Сравнение может дойти до конца суффикса, либо оборваться на каком-то символе ввиду несовпадения. Длину совпавшей части и назовем компонентой [Z-функции](http://ru.wikipedia.org/wiki/Z-%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F) для данного суффикса.
То есть Z-функция — это вектор длин наибольшего общего префикса строки с ее суффиксом. Ух! Отличная фраза, когда надо кого-то запутать или самоутвердиться, а чтобы понять что же это такое, лучше рассмотреть пример.
Исходная строка *«ababcaba»*. Сравнивая каждый суффикс с самой строкой получим табличку для Z-функции:
| суффикс | строка | | Z |
| --- | --- | --- | --- |
| ababcaba | ababcaba | -> | 8 |
| babcaba | ababcaba | -> | 0 |
| abcaba | ababcaba | -> | 2 |
| bcaba | ababcaba | -> | 0 |
| caba | ababcaba | -> | 0 |
| aba | ababcaba | -> | 3 |
| ba | ababcaba | -> | 0 |
| a | ababcaba | -> | 1 |
Префикс суффикса это ничто иное, как подстрока, а Z-функция — длины подстрок, которые встречаются одновременно в начале и в середине. Рассматривая все значения компонент Z-функции, можно заметить некоторые закономерности. Во-первых, очевидно, что значение Z-функции не превышает длины строки и совпадает с ней только для «полного» суффикса **A[**1..**]** (и поэтому это значение нас не интересует — мы его будем опускать в своих рассуждениях). Во-вторых, если в строке есть некий символ в единственном экземпляре, то совпасть он может только с самим собой, и значит он делит строку на две части, а значение Z-функции нигде не может превысить длины более короткой части.
Использовать эти наблюдения предлагается следующим образом. Допустим в строке *«ababcabсacab»* мы хотим поискать *«abca»*. Берем эти строчки и конкатенируем, вставляя между ними сентинел: *«abca$ababcabсacab»*. Вектор Z-функции выглядит для такой строки так:
| |
| --- |
| a b c a $ a b a b c a b с a c a b |
| 17 0 0 1 0 2 0 4 0 0 4 0 0 1 0 2 0 |
Если отбросить значение для полного суффикса, то наличие сентинела ограничивает Zi длиной искомого фрагмента (он является меньшей половиной строки по смыслу задачи). Но вот если этот максимум и достигается, то только в позициях вхождения подстроки. В нашем примере четверками отмечены все позиции вхождения искомой строки (отметьте, что найденные участки расположены внахлест друг с другом, но все-равно наши рассуждения остаются верны).
Ну, значит если мы сможем быстро строить вектор Z-функции, то поиск с его помощью всех вхождений строки сводится к поиску в нем значения ее длины. Вот только если вычислять Z-функцию для каждого суффикса, то будет это явно не быстрее, чем решение «в лоб». Выручает нас то, что значение очередного элемента вектора можно узнать опираясь на предыдущие элементы.
Допустим, мы каким-то образом посчитали значения Z-функции вплоть до соответствующего i-1-ому символу. Рассмотрм некую позицию rr.
Значит Zr символов начиная с этой позиции точно такие же, как и в начале строки. Они образуют так называемый Z-блок. Нас будет интересовать самый правый Z-блок, то-есть тот, кто заканчивается дальше всех (самый первый не в счет). В некоторых случаях самый правый блок может быть нулевой длины (когда никакой из непустых блоков не покрывает i-1, то самым правым будет i-1-ый, даже если Zi-1= 0).
Когда мы будем рассматривать последующие символы внутри этого Z-блока, сравнивать очередной суффикс с самого начала не имеет смысла, так как часть этого суфикса уже встречалась в начале строки, а значит уже была обработана. Можно будет сразу пропускать символы аж до конца Z-блока.
А именно, если мы рассматриваем i-й символ, находящийся в Zr-блоке, то есть соответствующий символ в начале строки на позиции k=i-r+1. Функция Zk нам уже известна. Если она меньше, чем оставшееся до конца Z-блока расстояние Zr-(i-r), то сразу можем быть уверены, что вся область совпадения для этого символа лежит внутри r-того Z-блока и значит результат будет тот же, что и в начале строки: Zi=Zk. Если же Zk >= Zr-(i-r), то Zi тоже больше или равна Zr-(i-r). Чтобы узнать насколько именно она больше, нам надо будет проверять следующие за Z-блоком символы. При этом в случае совпадения h этих символов с соответствующими им в начале строки, Zi увеличивается на h: Zi=Zk + h. В результате у нас может появиться новый самый правый Z-блок (если h>0).
Таким образом, сравнивать символы нам приходится только правее самого правого Z-блока, причем за счет успешных сравнений блок «продвигается» правее, а неуспешные сообщают, что вычисление для данной позиции окончено. Это обеспечивает нам построение всего вектора Z-функции за линейное по длине строки время.
Применив этот алгоритм для поиска подстроки получим сложность по времени O(|**A**|+|**X**|), что значительно лучше, чем произведение, которое было в первом варианте. Правда, нам пришлось хранить вектор для Z-функции, на что уйдет дополнительной памяти порядка O(|**A**|+|**X**|). На самом деле, если не нужно находить все вхождения, а достаточно только одного, то можно обойтись и O(|**X**|) памяти, так как длина Z-блока все-равно не может быть больше чем |**X**|, кроме этого можно не продолжать обработку строки после обнаружения первого вхождения.
Напоследок, пример функции, вычисляющей Z-функцию. Просто модельный вариант без каких либо хитростей.
````
void z_preprocess(vector & Z, const string & str)
{
const size\_t len = str.size();
Z.clear();
Z.resize(len);
if (0 == len)
return;
Z[0] = len;
for (size\_t curr = 1, left = 0, right = 1; curr < len; ++curr)
{
if (curr >= right)
{
size\_t off = 0;
while ( curr + off < len && str[curr + off] == str[off] )
++off;
Z[curr] = off;
right = curr + Z[curr];
left = curr;
}
else
{
const size\_t equiv = curr - left;
if (Z[equiv] < right - curr)
Z[curr] = Z[equiv];
else
{
size\_t off = 0;
while ( right + off < len && str[right - curr + off] == str[right + off] )
++off;
Z[curr] = right - curr + off;
right += off;
left = curr;
}
}
}
}
````
#### Алгоритм Кнута-Морриса-Пратта (КМП)
Не смотря на логическую простоту предыдущего метода, более популярным является другой алгоритм, который в некотором смысле обратный Z-функции — [алгоритм Кнута-Морриса-Пратта](http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9A%D0%BD%D1%83%D1%82%D0%B0_%E2%80%94_%D0%9C%D0%BE%D1%80%D1%80%D0%B8%D1%81%D0%B0_%E2%80%94_%D0%9F%D1%80%D0%B0%D1%82%D1%82%D0%B0) (КМП). Введем понятие [префикс-функции](http://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D1%84%D0%B8%D0%BA%D1%81-%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F). Префикс-функция для i-ой позиции — это длина максимального префикса строки, который короче i и который совпадает с суффиксом префикса длины i. Если определение Z-функции не сразило оппонента наповал, то уж этим комбо вам точно удастся поставить его на место :) А на человеческом языке это выглядит так: берем каждый возможный префикс строки и смотрим самое длинное совпадение начала с концом префикса (не учитывая тривиальное совпадение самого с собой). Вот пример для *«ababcaba»*:
| префикс | префикс | p |
| --- | --- | --- |
| a | a | 0 |
| ab | ab | 0 |
| ab**a** | **a**ba | 1 |
| ab**ab** | **ab**ab | 2 |
| ababc | ababc | 0 |
| ababc**a** | **a**babca | 1 |
| ababc**ab** | **ab**abcab | 2 |
| ababc**aba** | **aba**bcaba | 3 |
Опять же наблюдаем ряд свойств префикс-функции. Во-первых, значения ограничены сверху своим номером, что следует прямо из определения — длина префикса должна быть больше префикс-функции. Во-вторых, уникальный символ точно так же делит строку на две части и ограничивает максимальное значение префикс-функции длиной меньшей из частей — потому что все, что длиннее, будет содержать уникальный, ничему другому не равный символ.
Отсюда получается интересующий нас вывод. Допустим, мы таки достигли в каком-то элементе этого теоретического потолка. Это значит, что здесь закончился такой префикс, что начальная часть совпадает с конечной и одна из них представляет «полную» половинку. Понятно, что в префиксе полная половинка обязана быть спереди, а значит при таком допущении это должна быть более короткая половинка, максимума же мы достигаем на более длинной половинке.
Таким образом, если мы, как и в предыдущей части, конкатенируем искомую строчку с той, в которой ищем, через сентинел, то точка вхождения длины искомой подстроки в компоненту префикс-функции будет соответствовать месту окончания вхождения. Возьмем наш пример: в строке *«ababcabсacab»* мы ищем *«abca»*. Конкатенированный вариант *«abca$ababcabсacab»*. Префикс-функция выглядит так:
| |
| --- |
| a b c a $ a b a b c a b с a c a b |
| 0 0 0 1 0 1 2 1 2 3 4 2 3 4 0 1 2 |
Снова мы нашли все вхождения подстроки одним махом — они оканчиваются на позициях четверок. Осталось понять как же эффективно посчитать эту префикс-функцию. Идея алгоритма незначительно отличается от идеи построения Z-функции.
Самое первое значение префикс-функции, очевидно, 0. Пусть мы посчитали префикс-функцию до i-ой позиции включительно. Рассмотрим i+1-ый символ. Если значение префикс-функции в i-й позиции Pi, то значит префикс **A[**..Pi**]** совпадает с подстрокой **A[**i-Pi+1..i**]**. Если символ **A[**Pi+1**]** совпадет с **A[**i+1**]**, то можем спокойно записать, что Pi+1=Pi+1. Но вот если нет, то значение может быть либо меньше, либо такое же. Конечно, при Pi=0 сильно некуда уменьшаться, так что в этом случае Pi+1=0. Допустим, что Pi>0. Тогда есть в строке префикс **A[**..Pi**]**, который эквивалентен подстроке **A[**i-Pi+1..i**]**. Искомая префикс-функция формируется в пределах этих эквивалентных участков плюс обрабатываемый символ, а значит нам можно забыть о всей строке после префикса и оставить только данный префикс и i+1-ый символ — ситуация будет идентичной.
Задача на данном шаге свелась к задаче для строки с вырезанной серединкой: **A[**..Pi**]A[**i+1**]**, которую можно решать рекурсивно таким же способом (хотя хвостовая рекурсия и не рекурсия вовсе, а цикл). То есть если **A[**PPi+1**]** совпадет с **A[**i+1**]**, то Pi+1=PPi+1, а иначе снова выкидываем из рассмотрения часть строки и т.д. Повторяем процедуру пока не найдем совпадение либо не дойдем до 0.
Повторение этих операций должно насторожить — казалось бы получается два вложенных цикла. Но это не так. Дело в том, что вложенный цикл длиной в k итераций уменьшает префикс-функцию в i+1-й позиции хотя бы на k-1, а для того, чтобы нарастить префикс-функцию до такого значения, нужно хотя бы k-1 раз успешно сопоставить буквы, обработав k-1 символов. То есть длина цикла соответствует промежутку между выполнением таких циклов и поэтому сложность алгоритма по прежнему линейна по длине обрабатываемой строки. С памятью тут такая-же ситуация, как и с Z-функцией — линейная по длине строки, но есть способ сэкономить. Кроме этого есть удобный факт, что символы обрабатываются последовательно, то есть мы не обязаны обрабатывать всю строку, если первое вхождение мы уже получили.
Ну и для примера фрагмент кода:
````
void calc_prefix_function(vector & prefix\_func, const string & str)
{
const size\_t str\_length = str.size();
prefix\_func.clear();
prefix\_func.resize(str\_length);
if (0 == str\_length)
return;
prefix\_func[0] = 0;
for (size\_t current = 1; current < str\_length; ++current)
{
size\_t matched\_prefix = current - 1;
size\_t candidate = prefix\_func[matched\_prefix];
while (candidate != 0 && str[current] != str[candidate])
{
matched\_prefix = prefix\_func[matched\_prefix] - 1;
candidate = prefix\_func[matched\_prefix];
}
if (candidate == 0)
prefix\_func[current] = str[current] == str[0] ? 1 : 0;
else
prefix\_func[current] = candidate + 1;
}
}
````
Не смотря на то, что алгоритм более замысловат, реализация его даже проще, чем для Z-функции.
#### Другие задачи поиска
Дальше пойдет просто много букв о том, что этим задачи поиска строк не ограничиваются и что есть другие задачи и другие способы решения, так что если кому не интересно, то дальше можно не читать. Эта информация просто для ознакомления, чтобы в случае необходимости хотя бы осознавать, что «все уже украдено до нас» и не переизобретать велосипед.
Хоть вышеописанные алгоритмы и гарантируют линейное время выполнения, звание «алгоритма по умолчанию» получил [алгоритм Бойера-Мура](http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%91%D0%BE%D0%B9%D0%B5%D1%80%D0%B0_%E2%80%94_%D0%9C%D1%83%D1%80%D0%B0). В среднем он тоже дает линейное время, но еще и имеет лучше константу при этой линейной функции, но это в среднем. Бывают «плохие» данные, на которых он оказываются не лучше простейшего сравнения «в лоб» (ну прямо как с qsort). Он на редкость запутан и рассматривать его не будем — все-равно не упомнить. Есть еще ряд экзотических алгоритмов, которые ориентированы на обработку текстов на естественном языке и опираются в своих оптимизациях на статистические свойства слов языка.
Ну ладно, есть у нас алгоритм, который так или иначе за O(|**X**|+|**A**|) ищет подстроку в строке. А теперь представим, что мы пишем движок для гостевой книги. Есть у нас список запрещенных матерных слов (понятно, что так не поможет, но задача просто для примера). Мы собираемся фильтровать сообщения. Будем каждое из запрещенных слов искать в сообщении и… на это у нас уйдет O(|**X1**|+|**X2**|+...+|**Xn**|+n|**A**|). Как-то так себе, особенно если словарь «могучих выражений» «великого и могучего» очень «могуч». Для этого случая есть способ так предобработать словарь искомых строк, что поиск будет занимать только O(|**X1**|+|**X2**|+...+|**Xn**|+|**A**|), а это может быть существенно меньше, особенно если сообщения длинные.
Такая предобработка сводится к построению бора (trie) из словаря: дерево начинается в некотором фиктивном корне, узлы соответствует буквам слов в словаре, глубина узла дерева соответствует номеру буквы в слове. Узлы, в которых заканчивается слово из словаря называются терминальными и помечены неким образом (красным цветом на рисунке).
Полученное дерево является аналогом префикс-функции алгоритма КМП. С его помощью можно найти все вхождения всех слов словаря в фразе. Надо идти по дереву, проверяя наличие очередного символа в виде узла дерева, попутно отмечая встречающиеся терминальные вершины — это вхождения слов. Если соответствующего узла в дереве нет, то как и в КМП, происходит откат выше по дереву по специальным ссылкам. Данный алгоритм носит название [алгоритма Ахо-Корасика](http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%90%D1%85%D0%BE-%D0%9A%D0%BE%D1%80%D0%B0%D1%81%D0%B8%D0%BA). Такую же схему можно применять для поиска во время ввода и предсказания следующего символа в электронных словарях.
В данном примере построение бора несложно: просто добавляем в бор слова по очереди (нюансы только с дополнительными ссылками для «откатов»). Есть ряд оптимизаций, направленный на сокращение использования памяти этим деревом (т.н. сжатие бора — пропуск участков без ветвлений). На практике эти оптимизации чуть ли не обязательны. Недостатком данного алгоритма является его алфавитозависимость: время на обработку узла и занимаемая память зависят от количества потенциально возможных детей, которое равно размеру алфавита. Для больших алфавитов это серьезная проблема (представляете себе набор символов юникода?). Подробнее про это все можно почитать в этом [хабратопике](http://habrahabr.ru/blogs/algorithm/111874/) или воспользовавшись гуглояндексом — благо инфы по этомоу вопросу много.
Теперь посмотрим на другую задачу. Если в предыдущей мы знали заранее, что мы должны будем найти в поступающих потом данных, то здесь с точностью до наоборот: нам заранее выдали строчку, в которой будут искать, но что будут искать — неизвестно, а искать будут много. Типичный пример — поисковик. Документ, в котором ищется слово, известен заранее, а вот слова, которые там ищут, сыпятся на ходу. Вопрос, опять же, как вместо O(|**X1**|+|**X2**|+...+|**Xn**|+n|**A**|) получить O(|**X1**|+|**X2**|+...+|**Xn**|+|**A**|)?
Предлагается построить бор, в котором будут все возможные суффиксы имеющейся строки. Тогда поиск шаблона сведется к проверки наличия пути в дереве, соответствующего искомому шаблону. Если строить такой бор перебором всех суффиксов, то эта процедура может занять O(|**A**|2) времени, да и по памяти много. Но, к счастью, существуют алгоритмы, которые позволяют построить такое дерево сразу в сжатом виде — [суффиксное дерево](http://ru.wikipedia.org/wiki/%D0%A1%D1%83%D1%84%D1%84%D0%B8%D0%BA%D1%81%D0%BD%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE), причем сделать это за O(|**A**|). Недавно на Хабре была по этому поводу [статья](http://habrahabr.ru/blogs/algorithm/111675/), так что интересующиеся могут прочитать про [алгоритм Укконена](http://ru.wikipedia.org/wiki/%D0%A1%D1%83%D1%84%D1%84%D0%B8%D0%BA%D1%81%D0%BD%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE#.D0.9F.D0.BE.D1.81.D1.82.D1.80.D0.BE.D0.B5.D0.BD.D0.B8.D0.B5_.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.B0_.D0.B7.D0.B0_.D0.BB.D0.B8.D0.BD.D0.B5.D0.B9.D0.BD.D0.BE.D0.B5_.D0.B2.D1.80.D0.B5.D0.BC.D1.8F._.D0.90.D0.BB.D0.B3.D0.BE.D1.80.D0.B8.D1.82.D0.BC_ukk._.28Ukkonen.E2.80.99s_Algorithm.29) там.
Плохо в суффиксном дереве, как обычно, две вещи: то, что это дерево, и то, что узлы дерева алфавитозависимы. От этих недостатков избавлен [суффиксный массив](http://ru.wikipedia.org/wiki/%D0%A1%D1%83%D1%84%D1%84%D0%B8%D0%BA%D1%81%D0%BD%D1%8B%D0%B9_%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2). Суть суффиксного массива заключается в том, что если все суффиксы строки отсортировать, то поиск подстроки сведется к поиску группы расположенных рядом суффиксов по первой букве искомого образца и дальнейшего уточнения диапазона по последующим. При этом сами суффиксы в отсортированном виде хранить незачем, достаточно хранить позиции, в которых они начинаются в исходных данных. Правда, временные зависимости у данной структуры несколько хуже: единичный поиск будет обходиться O(|**X**| + log|**A**|) если подумать и сделать все аккуратно, и O(|**X**|log|**A**|) если не заморачиваться. Для сравнения в дереве для фиксированного алфавита O(|**X**|). Но зато то, что это массив, а не дерево, может улучшить ситуацию с кэшированием памяти и облегчить задачу предсказателю переходов процессора. Строится суффиксный массив за линейное время с помощью алгоритма Kärkkäinen-Sanders (уж извините, но плохо представляю как это должно звучать на русском). Нынче это один из самых популярных методов индексирования строк.
Вопросов приближенного поиска строк и анализа степени похожести мы тут касаться не будем совсем — слишком большая область для того, чтобы запихнуть в эту статью. Просто упомяну, что там люди зря хлеб не ели и придумали много всяких подходов, поэтому если столкнетесь с подобной задачей — найдите и почитайте. Весьма возможно такая задача уже решена.
Спасибо тем, кто читал! А тем, кто дочитал досюда, спасибо особенное!
**UPD:** Добавил [ссылку](http://habrahabr.ru/blogs/algorithm/111874/) на содержательную статью про бор (он же луч, он же префиксное дерево, он же нагруженное дерево, он же trie). | https://habr.com/ru/post/113266/ | null | ru | null |
# DevTips: Советы веб-разработчику (1-16)
Команда браузера [Google Chrome](https://www.google.ru/chrome/browser/desktop/) проделывает огромную работу для того, чтобы разработчикам жилось лучше. [Chrome DevTools](https://developer.chrome.com/devtools) — пример замечательного инструмента, сильно упрощающего отладку вашего веб-приложения. Но подчас не весь функционал этой системы виден с первого взгляда, поэтому [Umar Hansa](https://umaar.com/) — программист из Лондона — описывает его на [своем сайте](https://umaar.com/dev-tips), причем в весьма удобном формате: немного текста и короткий скринкаст. А мы, в свою очередь, решили сделать эти советы более доступными русскоязычной аудитории.
**Содержание**:
1. [Перенаправление порта позволит вам открывать локальные ссылки на мобильном устройстве](http://habrahabr.ru/company/mailru/blog/268519/#1)
2. [Активация псевдо-классов DOM-элемента](http://habrahabr.ru/company/mailru/blog/268519/#2)
3. [Повтор сетевого запроса при помощи cURL](http://habrahabr.ru/company/mailru/blog/268519/#3)
4. [Запуск сохранённых блоков кода (сниппетов) на любой веб-странице](http://habrahabr.ru/company/mailru/blog/268519/#4)
5. [Отслеживание изменений файлов через DevTools](http://habrahabr.ru/company/mailru/blog/268519/#5)
6. [Простая запись действий страницы](http://habrahabr.ru/company/mailru/blog/268519/#6)
7. [Поиск элементов DOM-дерева при помощи CSS-селекторов](http://habrahabr.ru/company/mailru/blog/268519/#7)
8. [Копирование изображения в формате Data URI](http://habrahabr.ru/company/mailru/blog/268519/#8)
9. [Переход к нужной строке при открытии файла](http://habrahabr.ru/company/mailru/blog/268519/#9)
10. [Упрощенная навигация между правками](http://habrahabr.ru/company/mailru/blog/268519/#10)
11. [Копирование ответа на сетевой запрос](http://habrahabr.ru/company/mailru/blog/268519/#11)
12. [Работа с несколькими курсорами при редактировании скриптов](http://habrahabr.ru/company/mailru/blog/268519/#12)
13. [Блочное выделение](http://habrahabr.ru/company/mailru/blog/268519/#13)
14. [Быстрый мониторинг событий в консоли](http://habrahabr.ru/company/mailru/blog/268519/#14)
15. [Доступ к выбранному DOM-узлу в консоли](http://habrahabr.ru/company/mailru/blog/268519/#15)
16. [Отслеживание незавершенных сетевых запросов при помощи фильтра is:running](http://habrahabr.ru/company/mailru/blog/268519/#16)
Продолжение: [17-32](http://habrahabr.ru/company/mailru/blog/268777/), [33-48](http://habrahabr.ru/company/mailru/blog/275425/).
1. Перенаправление порта позволит вам открывать локальные ссылки на мобильном устройстве
----------------------------------------------------------------------------------------
Для отладки локального сайта на мобильном устройстве, откройте на нем страницу (удобнее будет воспользоваться расширением «[Chrome to Phone](https://chrome.google.com/webstore/detail/google-chrome-to-phone-ex/oadboiipflhobonjjffjbfekfjcgkhco?hl=ru)»), далее включите удаленную отладку и перенаправьте на мобильное устройство локальный сайт через выделенный порт. После обновления страницы вы увидите, как все работает даже без использования командной строки!
**Посмотреть скринкаст**
2. Активация псевдо-классов DOM-элемента
----------------------------------------
Если вам нужно посмотреть, как конкретный DOM-элемент ведет себя в различных состояниях (`active`, `focus`, `hover` и `visited`), можно активировать любое из них в Chrome DevTools. Для этого кликните правой кнопкой мыши по нужному элементу в панели «Elements», а затем выберите «Force element state». Есть и другой способ: в панели характеристик элемента в разделе «Styles» кликните на кнопку «Toggle element state» и выберите конкретное состояние.
После изменения состояния узла, рядом с его открывающим тегом в DOM-дереве появится небольшой оранжевый индикатор-кружок. В каких-то случаях он появляется и у закрывающего тега (если он не слишком далеко ушел из поля зрения).
**Прим. перев.**: *в последних версиях разработчики браузера немного изменили контекстное меню узла в панели «Elements». Теперь состояния элемента может быть выбрано из него напрямую без промежуточного «Force element state». А оранжевый индикатор сам по себе стал кликабельным и открывает то же самое меню.*
**Посмотреть скринкаст**
3. Повтор сетевого запроса при помощи cURL
------------------------------------------
Каждый ресурс, отображаемый в панели «Network», имеет свое собственное контекстное меню, содержащее пункт «Copy as cURL». При выборе этого пункта в буфер обмена попадет команда, полностью эмулирующая выбранный запрос через утилиту «[cURL](http://curl.haxx.se/)» (включая заголовки запроса). Вставьте ее в терминал, подредактируйте по необходимости и запускайте.
**Прим. перев.**: *Чтобы повторить XHR-запрос без использования cURL, найдите его в панели «Network» и выберите пункт «Reply XHR» в его контекстном меню.*
**Посмотреть скринкаст**
4. Запуск сохранённых блоков кода (сниппетов) на любой веб-странице
-------------------------------------------------------------------
В DevTools есть функционал под названием «Сниппеты» (Snippets). При помощи него вы можете создавать или удалять код, который потом можно будет исполнить в контексте веб-страницы. Это гораздо удобней перепечатывания кода в панели «Console». Просто попробуйте:
* откройте панель «Source» → «Snippets» (она в левой вкладке);
* в контекстном меню этой вкладки выберите «New»
* введите подходящее имя для своего сниппета;
* запускайте его при помощи выбора пункта «Run» в меню сниппета (или «Cmd+Enter»).
Заметьте, что вам доступно полноценное многострочное редактирование и подтверждения случайного закрытия сниппета без сохранения.
**Посмотреть скринкаст**
5. Отслеживание изменений файлов через DevTools
-----------------------------------------------
Функция «Local modifications» позволяет вам отслеживать изменения файлов, которые были сделаны через DevTools. После изменения и сохранения файла через DevTools, выберите «Local modifications» в контекстном меню файла в левой колонке панели «Sources» и вы увидите список изменений, каждое из которых можно откатить.
**Посмотреть скринкаст**
6. Простая запись действий страницы
-----------------------------------
Когда вам нужно записать действия страницы при помощи панели «Timeline», открепите окно DevTools от основного окна браузера и поместите его так, чтобы кнопка начала записи располагалась как можно ближе к анализируемому участку страницы. Как альтернатива используете горячие клавиши «Cmd+E», чтобы начать/остановить запись поведения.
**Прим. перев.**: *такое расположение окна DevTools позволит избежать лишнего шума, возникающего пока вы ведете мышкой от кнопки записи до нужной части приложения.*
**Посмотреть скринкаст**
7. Поиск элементов DOM-дерева при помощи CSS-селекторов
-------------------------------------------------------
Чтобы быстрее найти интересующий вас DOM-узел в панели «Elements», используйте поиск по CSS-селекторам. Поиск вызывается сочетанием клавиш «Cmd+F».
**Посмотреть скринкаст**
8. Копирование изображения в формате Data URI
---------------------------------------------
Чтобы скопировать ссылку на изображение в формате Data URI (закодированную в base64), найдите нужную картинку в панели «Resources» и из ее контекстного меню (в правой панели) выберите «Copy Image as Data URL».
**Прим. перев.**: *это может быть полезно если вы, например, не хотите отправлять запрос за картинкой на сервер, а использовать ее base64-копию из CSS.*
**Посмотреть скринкаст**
9. Переход к нужной строке при открытии файла
---------------------------------------------
Переходите сразу к нужному месту в открываемом через команду «Cmd+O» в панели «Sources» файле, указывая желаемую позицию в формате `:номер_строки:номер_столбца`. Попробуйте:
* нажмите «Cmd+O» в открытом в панели «Sources» файле;
* введите «:5:9»
* вас перебросит к символу 9 строки 5.
**Посмотреть скринкаст**
10. Упрощенная навигация между правками
---------------------------------------
Панель «Sources» запоминает места всех изменения скриптов и позволяет вам циклически перемещаться между ними при помощи «Alt -» (назад) и «Alt +» (вперёд).
**Посмотреть скринкаст**
11. Копирование ответа на сетевой запрос
----------------------------------------
Кроме копирования заголовков запроса за сетевым ресурсом или заголовков ответа на него, вы можете скопировать весь ответ.
**Посмотреть скринкаст**
12. Работа с несколькими курсорами при редактировании скриптов
--------------------------------------------------------------
Вы можете использовать несколько курсоров одновременно для параллельного редактирования разных участков кода в панели «Sources». Для этого, зажав «Cmd», кликайте в те места, куда хотите поставить курсоры. Отменить выделение вы можете при помощи «Cmd+U».
**Посмотреть скринкаст**
13. Блочное выделение
---------------------
Вы можете использовать выделение блоком в панели «Sources», удерживая «Alt» во время перемещения мыши.
**Посмотреть скринкаст**
14. Быстрый мониторинг событий в консоли
----------------------------------------
Вы можете логировать все события объекта, используя метод `monitorEvents(object [, events])` из [Command Line API](https://developer.chrome.com/devtools/docs/commandline-api#monitoreventsobject-events). При наступлении события его объекты будут выведены в консоль. Это удобно, когда вы не можете вспомнить свойства конкретного события.
**Посмотреть скринкаст**
15. Доступ к выбранному DOM-узлу в консоли
------------------------------------------
Чтобы использовать в консоли DevTools выбранный в панели «Element» DOM-узел, просто наберите `$0`. Так же можно использовать конструкцию `$_`, которая вернет значение самого последнего вычисленного в консоли выражения.
**Прим. перев.**: *Панель «Sources» запоминает 5 последних выбранных элементов, доступ к которым осуществляется через* `$0`*,* `$1`*,* `$2`*,* `$3`*,* `$4`*. Эти конструкции являются полноценными Javascript-выражениями, поэтому поддерживают любые операции, например, вызов метода* `$0.appendChild(...)`*.
**Посмотреть скринкаст**
16. Отслеживание незавершенных сетевых запросов при помощи фильтра is:running
-----------------------------------------------------------------------------
Поиск в панель «Network» позволяет фильтровать активные (до сих пор не получившие ответа) запросы, при помощи выражения `is:running`. Ещё можно использовать такие фильтры, как `status-code`, `method`, `domain` и другие.
**Прим. перев.**: *на сегодняшний день в Chrome Canary 48 поддерживаются следующие фильтры:* `domain`*,* `has-response-header`*,* `is:running`*,* `larger-than`*,* `method`*,* `mime-type`*,* `mixed-content`*,* `scheme`*,* `set-cookie-domain`*,* `set-cookie-name`*,* `set-cookie-value`*,* `status-code`*.*
**Посмотреть скринкаст**
Ждите следующих частей!* | https://habr.com/ru/post/268519/ | null | ru | null |
# Big O Notation
Asymptotic notations are used to represent the complexity or running time of an algorithm. It is a technique of defining the upper and lower limits of the run-time performance of an algorithm. We can analyze the runtime performance of an algorithm with the help of asymptotic notations. Asymptotic notations are also used to describe the approximate running time of an algorithm.
**Types of Asymptotic Notations**
Following are the different types of asymptotic notations:
* Big O Notation (O)
* Big Omega Notation( Ω)
* Theta Notation ()
**Need of Big O Notation**
We can use Big O notation to compare and search different solutions to find which solution is best. The best solution is one that consumes less amount of time and space. Generally, time and space are two parameters that determine the efficiency of the algorithm.
Big O Notation tells accurately how long an algorithm takes to run. It is a basic analysis of algorithm efficiency. It describes the execution time required. It depends on the size of input data that essentially passes in. Big O notation gives us algorithm complexity in terms of input size. For the large size of input data, the execution time will be slow as compared to the small size of input data. Big O notation is used to analyze space and time.
Big O notation gives us the growth of the time. Big O notation of a particular function gives us the order of the growth of that function. It is used to tell the relative efficiencies of algorithms in terms of space and time. It makes us understand the execution time and the main requirement of the function of increasing input size.
If *f(x)* is a function , then there exists a function *g(x)* such that *g(x)* is greater than or equal to *f(x)* for all points *x* , where *x* is greater than *x0:*
We can say that *f(x)* is *O(g(x)).* This is **Big O Notation of** *f(x).*In its notation, 'O' stands for the order of magnitude. Big O notation represents the upper bound of an algorithm running time. Upper bound means maximum running time. It represents the worst case of an algorithm time complexity that is the largest amount of time an algorithm can take to for execution.
**Types of Measurement**
Following are the different ways to measure the algorithm efficiency such as:
*Average Case*
It is the average time required for the execution of an algorithm.
*Worst Case*
It is the maximum time required to execute an algorithm. It tells us how slow an algorithm can execute.
*Best Case*
The best case is the minimum time required for the execution of an algorithm. It tells how fast an algorithm can execute.
**Example**
To understand the above cases, let's consider an array:
![A= [ 2 ,3 , 4, 5,6]](https://habrastorage.org/getpro/habr/upload_files/119/322/4e3/1193224e3f4d343dd4f45feff41d39a5.svg)If we want to search for 2 in an above array and on comparing we found that element in the first position. Then it would be the **best case** because it requires minimum time.
If we want to search for 6 in the above array. Then we need to perform a comparison with each value in the array and it will require maximum time. So it would be the **worst case**.
If we need to find element 4 in a given array, then it would require an average time to perform comparison or execution. So this would be an **average case**.
When we talk about Big O notation, we typically look at the worst case.
**Working Principle**
To understand its working principle, the following things must be remembered while calculating running time :
1. We will ignore constants when there is a product of multiple terms. Because the run time of constant is only unit time. For example, if we have a function
 This function will execute 'n' times. So, in this function 'n' matters, not 8. So constant '8' will be ignored from this function. In this way, the run time complexity of this function will be 'On'
2. If the Big O is the sum of several terms then only keep the largest term and left the rest of the terms. For example, if we have :
 In this, we have two terms. Among these two terms, we will select the largest term. So here, just *'n'* is the largest term because 900 is a constant value. So, its complexity is *'O(n)'*. Similarly, if we have an expression like :
Then its complexity will be *'O(n2)'*.
3. In the case of unsimplified Big O expressions such as:
After dropping out constant values from these expressions, we have:
 4. Certain terms will dominate in it. Big O notation will be in this order:
*O(n)* has the smallest order due to less running time as compared to others. As the size of *'n'* terms increase, running time will increase. So, higher-order terms have high running time. So ignore the low order terms as *'n'* increases.
**Time Complexity Analysis**
Time complexity is a mathematical technique of showing how the runtime of a function rises as the size of the input increases. Time complexity gives us an idea about how function scales as input to the function gets larger. When the input size is small, the function will take less time. In time complexity analysis, firstly we have to understand the following terms:
*Constant Time*
In this, the time taken to complete a function does not increase with size but it remains constant. Big O notation of a constant time is always one. If we have some function *x=6\*5*; In this function, there is going to be no input to this function. So, its runtime is 1, and time complexity will be *'O(1)'*.
*Linear Time*
In this, as the size of the input increases, time increases linearly with size. If we have a linear function *f(x)=3x-1*. And the value of *x* is in the range of 0 *to n***.** This function will execute for 0 *to n* values. So in this way, the complexity of linear time will be *'O(n)'*.The expression *O(n)* will be read as *‘’*
*Quadratic Time*
In this, the time taken to complete a function increases with size in a quadratic manner. If we have a quadratic function *f(x) = 5x2 + 4y + 1*.Value of *x* and *y* in the range of 0 to *n*.
So the time complexity will be *'O(n2)'*.
**Big O Notation Worst-Case Complexity**
For all positive values of *n*, if *g(n)* is a function.
Where there exists constants *c* and *n0*, such that
To understand this, let us consider an example in which we have the following function:
The value of *f(n)* will always be less than and equal to *g(n2)*. So this function will work in the following way:
**Graph**
Let us consider the following graph. In this graph, the x-axis represents input size (n) and the y-axis represents time growth (T) of an algorithm. Time growth (T) increases with input size(n). Suppose that *f(n)* is a particular function with respect to the input side in this graph. For representing the upper bound, we plot a function *'c.g(n)'*.The value of function *f(n)* will not go above *'c.g(n)'*. The value of *f(n)* is always less than or sometimes equal to *c.g(n)*.
**Example 1**
Let us consider an array from 1 to 10
![A= [ 1,2,3,4,5,6,7,8,9,10]](https://habrastorage.org/getpro/habr/upload_files/753/20d/46b/75320d46b73e2bcbc51759bbfc7f1cb1.svg)Firstly, a function will be defined which will take an array ‘**A**' and find the sum of elements in the array. Inside this function, variables will be initialized. For each value of 'k' in this array, elements will be going to add in the variable *'total'*. In this way, the sum of all elements will be found in this array.
```
def find_sum(A);
total = 0 ;
for ( k=0 ; k<=n; k++){
total = total + k ;
}
return total
```
The run time of this function is based on the size of the input. For the Big O , find the fastest growing term and then take out the coefficient . Suppose , if the fastest growing time is
Where *'T'* is the time taken to run the function. Then coefficient will be taken out as
If we have two functions and one of them executes at constant time and the other one takes linear time. The first function will take *O(1)* and the second function will take *O(n)* time. On comparing these two functions, it can be concluded that the second function will take more time. *O(1)* is better than *O(n)* because it takes less time to execute.
**Example 2**
Let us consider another array
![B=[ 2,3,4,5,6,7,8,9,1,0]](https://habrastorage.org/getpro/habr/upload_files/3c4/d5b/921/3c4d5b9216ae5e5cf081089177ff19b0.svg)Now we will determine the time complexity and Big O notation without any experiment.
```
def find_sum(B);
total = 0 ;
return total;
```
In above code, time taken to execute *'total=0 '* is *O(1)* and it will also be same for *'return total'*.
Time taken to execute the entire function is
**Example 3**
Now let us consider another example in which we have taken the following array:
![C= [2,4,1,3,5,6,7,9,8,3]](https://habrastorage.org/getpro/habr/upload_files/0f1/0ca/b34/0f10cab34995d0f6dc2810fa047ac93b.svg)
```
def find_sum(C)
total = 0
for ( each f in C)
total = total + f;
return total;
```
Now to find the Big O notation and time complexity of this function, the execution time will be analyzed. As the variable *'total '* takes an equal amount of time at every time. So, it has time complexity as *'O(1)'*. And *'return total'* will also have the same time complexity. Time taken will be
 In the above expression, c2 is the fastest-growing term.
**Example 4**
Let us consider another example related to quadratic time. For this purpose, we consider a two-dimensional array that is:
![ B = [2,3,4,4,2,8,[1,6,3]]](https://habrastorage.org/getpro/habr/upload_files/c60/d2f/40a/c60d2f40a4fb69d00ce09e90759e902c.svg)In this array, we have a total of nine elements. As the number of columns is equal to the number of rows in this array so we have *'n2'* elements in this array. Now we will define a function that will find the sum of elements of this array. Then define a variable *'total'* and assign a value equal to zero. Then a double for loop will be executed. In the for-loop, variable 'i' represents the element in each row.
```
def find_sum(B)
total=0;
for ( Each i in row of B:)
total = total + i ;
return total;
```
Now for finding the time complexity and Big O notation , it can be seen that time taken to execute complete function is :
 The fastest growing term in above expression is *C2*.
**Space Complexity Analysis**
In space complexity analysis, we take a look at how much memory or space is used. For this purpose, let’s consider an example. We have created the sum variable ‘S’ and assigned its value to zero. In for loop, we initialize a counter variable only at once for the entire loop. On looking at the inner variable *'number=numbers[i]'*, this will execute on every single iteration of this for a loop. Once this iteration is finished, memory will be freed for this variable. As this entire loop runs it's not as if each of these number variables is going to persevere in memory. Space complexity will be only *'O(1)'*
```
const cal_avg = (num){
S=0;
for ( i=0 ; i < num.length ; i++){
num= num[i];
S= S+ num;
}
return S /num.length;
};
```
**Properties of Big O Notation**
It has the following properties:
**Application of Big O Notation**
Following are the applications of Big O Notation:
* It is used to quickly compare multiple functions in terms of their performance.
* Also used to analyze the execution time of an algorithm | https://habr.com/ru/post/559518/ | null | en | null |
# Знакомство с Apache Mahout
*Привет.
Моя первая [статья](http://habrahabr.ru/post/188350/) на Хабре показала, что не многие знают о библиотеке Mahout. (Может быть, конечно, я в этом ошибаюсь.) Да и ознакомительного материала по этой теме здесь нет. Поэтому я решил написать пост, рассказывающий о возможностях библиотеки. Пара проб пера показали, что лучшим введением в тему будут небольшие выдержки из книги “Mahout in Action” Owen, Anil, Dunning, Friedman. Поэтому я сделал вольный перевод некоторых мест, которые, как мне кажется, хорошо рассказывают об области применения Mahout.*
#### Встречаем Apache Mahout (1)
*\* Здесь и далее в скобках указана глава из книги.*
* Mahout это *opensource* библиотека для машинного обучения от Apache. Алгоритмы, которые библиотека реализует в совокупности можно назвать машинным обучением или коллективным интеллектом. Это может означать многое, но в настоящий момент это означает в первую очередь рекомендательные системы (коллаборативная фильтрация), кластеризацию и классификацию.
* Mahout *масштабируем*. Mahout стремиться стать инструментом машинного обучения с возможностью обработки данных на одной или нескольких машинах. В текущей версии Mahout масштабируемые реализации машинного обучения написаны на java, а некоторые части построены на проекте распределенных вычислений Apache Hadoop.
* Mahout это *java библиотека*. Она не предоставляет пользовательского интерфейса, предупакованного сервера или установщика. Это фреймворк инструментов, предназначенных для использования и адаптации разработчиками.
…
Mahout содержит ряд моделей и алгоритмов, многие все еще в разработке или экспериментальной фазе ([алгоритмы](https://cwiki.apache.org/confluence/display/MAHOUT/Algorithms)). На этом раннем этапе жизни проекта, три ключевые темы наиболее заметны: рекомендательные системы (коллаборативная фильтрация), кластеризация и классификация. Это далеко не все что есть в Mahout, но эти темы наиболее заметные и зрелые.
…
В теории Mahout — это проект, открытый для реализации любого вида моделей машинного обучения. На практике в настоящий момент реализованны три ключевых области машинного обучения.
…
#### Рекомендательные системы. (1.2.1)
Рекомендательные системы – это наиболее узнаваемая модель машинного обучения из используемых сегодня. Вы видите сервисы или сайты которые пытаются рекомендовать книги или фильмы, или статьи, базируясь на ваших предыдущих действиях. Они пытаются выводить вкусы и предпочтения, и идентифицировать неизвестные предметы, которые представляют интерес.
* Amazon.com это, возможно, наиболее известный сайт в электронной комерции применивший рекомандации. Основываясь на покупках и активности на сайте, амазон рекомендует книги и другие вещи которые могут вызвать интерес.
* Netflix также рекомендует DVD, которые могут быть интересны и предлагают приз в 1М$ для исследователей, которые могут улучшить качество их рекомендаций.
* Социальные сети, такие как Фейсбук, используют варианты рекомендетельных техник для выявления людей, наиболее вероятно подходящих под определение “еще не связанных друзей”.
#### Кластеризация (1.2.2)
Кластеризация менее очевидна, но оказывается в не менее известных упоминаниях. Как следует из названия, методы кластеризации пытаются группировать большие числа предметов вместе в кластеры, которые имеют общее сходство. Таким образом устанавливают иерархию и порядок в больших или трудных для понимания множествах данных, и таким способом устанавливают интересные закономерности или делают набор данных более легким для понимания.
* Google News группирует новостные статьи по названию, используя технику кластеризации.
* Поисковые механизмы такие как Clusty так же группируют свои поисковые результаты.
* Заказчики могут быть сгруппированы в сегменты (кластера) при помощи техники кластеризации, основанные на атрибутах: доход, местоположение, покупательские привычки.
Кластеризация помогает определять структуру и даже иерархию, в большой коллекции вещей, которую, может быть, даже сложно осмыслить. Предприятия могут использовать эту технику для определения скрытых групп среди пользователей, или разумной организации большой коллекции документов, или определения общих паттернов использования для сайтов используя их логи.
#### Классификация (1.2.3)
Модели классификации решают является или нет предмет частью определенной категории или есть ли у нее некоторый атрибут. …
* Yahoo! Mail решает является или нет входящее сообщение спамом, основываясь на предшествующих письмах и сообщений на спам от пользователей, а также характеристиках самих писем.
* Google's Picasa и другие приложения для управления фотографиями могут определять область изображения содержащую человеческое лицо.
* Программа оптического распознавания символов классифицирует малые области отсканированного текста на отдельные символы.
Классификация помогает решить соответствует ли новый кусок вводных данных или предмет предыдущим рассмотренным шаблонам; и она часто используется для классификации поведения или шаблона. Это может быть использовано для обнаружения подозрительной сетевой активности или мошенничества. А также для выяснения того, указывает на разочарование или удовлетворение сообщение пользователя.
Каждая из этих моделей работает лучше, когда снабжена большим количеством хороших входных данных. В некоторых случаях, эти методы должны не только работать на больших объемах данных, но должны получать результат быстро, и эти факторы делают масштабируемость главной задачей. Одна из основных причин использовать Mahout это именно масштабируемость.
*Как неоднократно отмечается в книге, нет готового рецепта который можно взять и применить к типовой ситуации. Для каждого случая нужно пробовать различные алгоритмы и входные данные. Только поняв суть алгоритмов можно успешно применять библиотеку.*
#### Запуск первой рекомендательной системы (2.2)
… сейчас мы исследуем простую пользователе-ориентированную рекомендательную систему.
##### Создание входных данных (2.2.1)
…
Рекомендательная система нуждается во входных данных на которых будут основываться рекомендации. Эти данные принимают форму предпочтений на языке Mahout. Т.к. рекомендательные системы более понятны в ключе рекомандации предметов (items) пользователям, то будем говорить о предпочтении как об ассоциации пользователь – предмет. … Предпочтение состоит из ID пользователя и ID предмета, и обычно числа, выражающего степень предпочтения этого пользователя этому предмету (оценку). ID в Mahout это всегда целые числа. Значение предпочтения может быть любым, главное что большее значение выражает большую положительную привязанность. Например, эти значения могут быть рейтингом по шкале от 1 до 5, где 1 показывает что предмет пользователю не нравится, 5 показывает, что предмет очень нравится.
Создаем файл intro.csv, содержащий информацию userID, itemID, value.
…
Теперь, запустим следующий код.
```
class RecommenderIntro {
public static void main(String[] args) throws Exception {
DataModel model = new FileDataModel (new File("intro.csv"));
UserSimilarity similarity = new PearsonCorrelationSimilarity (model);
UserNeighborhood neighborhood = new NearestNUserNeighborhood (2, similarity, model);
Recommender recommender = new GenericUserBasedRecommender (model, neighborhood, similarity);
List recommendations = recommender.recommend(1, 1);
for (RecommendedItem recommendation : recommendations) {
System.out.println(recommendation);
}
}
}
```
DataModel хранит и предоставляет доступ ко всем предпочтениям, пользователям и предметам, нужным для вычислений. Реализация UserSimilarity обеспечивает некоторое представление о том, как похожи вкусы пользователей; она может быть основана на одной из множества метрик или вычислений. (метрики описаны в первом посте) Реализация UserNeighborhood определяет понятие группы пользователей, которые наиболее близки к данному пользователю. (Первый параметр 2 – это количество пользователей в этой группе.) Наконец, реализация Recommender связывает предыдущие три компонента вместе, чтобы сделать рекомендации пользователям. Метод recommend(int userId, int number) принимает два параметра: пользователь и количество рекомендаций которые нужно сделать этому пользователю.
Вывод: RecommendedItem [item:XXX, value:Y]. *Где Y – прогнозируемая оценка, выставленная пользователем 1 предмету XXX. Именно этот предмет порекомендован польозвателю, т.к. у него самая высокая прогнозируемая оценка.* | https://habr.com/ru/post/189098/ | null | ru | null |
# Загрузка классов в серверах приложений, особенности JBoss AS 7
Java характеризуется динамической загрузкой классов. Для поиска и загрузки используется механизм делегирующих classloader'ов. В Java SE окружении их количество ограничивается 2-3, но в серверах приложений оно приближается к 10 иерархическим classloader'ам. Этим объясняется большое время запуска (обычно от минуты) и деплоя приложений.
В JBoss AS 7 разработчикам удалось сильно сократить время запуска (пустой appserver запускается за 3-4 секунды на рабочей станции). Этому способствовала новая система загрузки классов в данном сервере приложений. Такой подход всё же обладает своими недостатками.
Данная статья касается механизма загрузки классов в различных окружениях, особенностях работы с JBoss AS 7, сопряжения с системой сборки Apache Maven и IDE IntelliJ IDEA.
#### Загрузка классов в Java
Согласно [Java Language Specifiaction](http://docs.oracle.com/javase/specs/ "Java language specifications") JVM динамически загружает, связвает и инициализирует классы. Поиск и загрузка класса осуществляется иерархией класслоадеров.
При старте ява-машины используется *bootstrap classloader* (который отвечает за загрузку базовых классов из rt.jar и прочих частей реализации JVM). В дальнейшем обычно происходит делегация *system classloader'у*, который осуществляет поиск в пределах указанного программе *CLASSPATH*. И в простейшем случае этим ограничивается.
В дальнейшем происходит загрузка и разбор class-файла, его связывание (верификация, подготовка и разрешение зависимостей класса). После чего происходит инициализация. То есть, загрузка описания класса, инициализация статических полей и выполнение статических инициализаторов происходит
«лениво», по необходимости. На этом основан паттерн для lazy-инициализации со static-holder'ом, описанный в [Effective Java](http://www.amazon.com/Effective-Java-2nd-Joshua-Bloch/dp/0321356683 "Joshua Bloch, Effective Java (2nd ed)").
В окружениях типа servlet-контейнеров, серверов приложений и OSGi всё существенно усложняется. В них существует сложная иерархия класслоадеров, призванная дать доступ к разрешенному (например, библиотекам, предоставляемым окружением) и, при этом, изолировать разные «модули» друг от друга.
То есть в двух загруженных веб-приложениях могут быть разные версии одного и того же класса, которые будут видны только соответствующим приложениям.
Естественно, что класс может и не обнаружится — тогда происходит ошибка загрузки оного, как правило, приводящая к падению JVM, если её не перехватывать (как делают сервера приложений).
#### Обычная структура загрузки в servlet-контейнере (tomcat, jetty)
В окружениях такого типа иерархия classloader'ов, конечно, усложняется. После *system classloader'а*, который предназначен для запуска самого servlet-контейнера, поиск делегируется далее по цепочке.
Для каждого приложения, задеплоенного в контейнер, создается свой класслоадер, который ищёт по классам в *WEB-INF/classes* и jar-файлам в *WEB-INF/lib* (всё в пределах war этого приложения).
Далее происходит делегация *common classloader'у*, который ищёт по общим для всех клиентов библиотекам (в CATALINA\_HOME/lib в случае tomcat'а).
#### Сервера приложений
Дальнейший рассказ коснётся загрузки классов app-сервером glassfish. Как полагается, первый в длинной цепочке загрузки *bootstrap classloader*. После него управление передается *public-api classloader'у*, который отвечает за классы, интерфейсы и аннотации стека Java EE и другие API, экспортированные сервером приложений. Следующим выступает знакомый нам по tomcat'у *common classloader*, отвечающий за общие для всего app-server'a библиотеки. Далее в цепочке оказывается *connector classloader*, который позволяет получить всем приложениям доступ к JCA. После чего управление передается *lifecyclemodule classloader'у*. Он предназначен для загрузки классов, управляющих жизненным циклом бинов в приложениях. Следующий герой — *applib classloader*, сильно напоминающий common, но работающий с некоторыми группами приложений. И в последнюю очередь срабатывает *archive classloader*, работающий с классами из WAR/EAR/RAR/EJB-JAR и др.
Такая сложная система поиска и загрузки классов позволяет упростить сами класслоадеры, более чётко разделить на уровни абстрации, избежать дублирования библиотек. Основным же недостатком является огромная неповоротливость этой системы и, как следствие, большое время загрузки app-server'а и деплоя приложений.
#### Особенности героя повествования JBoss AS 7
JBoss AS 6 по структуре класслоадеров очень напоминает glassfish. По времени старта — аналогично. Чем же принципиально отлечается 7 версия? Почему она привлекла внимание разработчиков?
Ответ прост: очень быстрый старт. Раньше не было сервера приложений, стартующего за секунды. AS 6 и GlassFish стартую минуту в лучшем случае. Для разработчика, у которого несчатсный glassfish умирает по PermGen при постоянных редеплоях это просто спасение.
Итак, перейдём к технической стороне вопроса. Как удалось достигнуть таких скоростей? Основой, позволившей решить проблему медленной работы иерархических класслоадеров, является *JBoss Modules*. Этот проект направлен на *модульный* (а не иерархический) подход к загрузке классов. Поиск осуществляется в пределах небольшого набора модулей. Возникает вопрос, как окружению узнать в каких модулях необходимо искать?
Решается он, к сожалению, только явным перечислением модулей-зависимостей. Для этого в развертываемый war в его манифест дописывается поле *Dependencies* в котором перечисляются зависимости.
По её имени сервер находит xml, описывающий данный модуль: набор jar-файлов, входящих в него, и модули, от которых зависит данный.
##### Использование maven'а
При использовании maven для сборки такой подход к предоставлению пакетов приводит к тому, что часть зависимостей в pom.xml должны быть объявлены provided. Например, при использовании slf4j это будет выглядеть следуюзим образом:
```
org.slf4j
slf4j-api
1.6.1
provided
org.apache.maven.plugins
maven-war-plugin
org.slf4j
```
##### Отладка в IntelliJ IDEA
Несмотря на всю прелесть данной IDE в ней часто встречаются неприятные недоработки. Например, при взаимодействии с maven'ом. При попытке отлаживать проект, использующий конфиг из предыдущего пункта, выясняется, что артифакт собранный maven'ом корректно работает,
а при деплое из Idea вылетает NoClassDefFoundError. Это связано с тем, что IDEA не используется данные из pom.xml, а генерирует свой MANIFEST.MF, отлучающийся отсутствием пункта Dependencies.
Обойти такое поведение можно создав свой манифест такого вида:
`Manifest-Version: 1.0
Dependencies: org.slf4j`
Очевидный недостаток такого workaround'а — дублирование информации о зависимостях в двух местах. | https://habr.com/ru/post/140133/ | null | ru | null |
# Yapf — причесываем код Python автокорректором
В эпоху все большей популярности различных js и css linter'ов, не удивительно появление удобного линтера с автокоррекцией для Python.
Приветствуйте, [Yapf](https://github.com/google/yapf/) — готовое решение, для превращения каши из строк во вполне читаемый код. И поверьте, он вам пригодится.
Большинство современных линтеров для Python — например, autopep8 и pep8ify — сделаны, чтобы удалить ошибки в коде. Это имеет некоторые очевидные ограничения. Например, код, который соответствует PEP8, не может быть переформатирован. Но это не значит, что код выглядит хорошо.
YAPF использует другой подход. Он основан на [«clang-format»](http://llvm.org/devmtg/2013-04/jasper-slides.pdf), разработанном Daniel Jasper. В сущности, алгоритм берет код и переформатирует его до формата, соответствующего стилю руководства, даже если исходный код не нарушает руководство по стилю. Идея также похожа на инструмент gofmt для языка программирования Go: конец всех священных войн о форматировании — если вся кодовая база проекта просто перекачивается через YAPF всякий раз, когда вносятся изменения, стиль остается согласованным во всем проекте, и нет смысла спорить о стиле в каждом обзоре кода.
Конечная цель состоит в том, что код python c YAPF пишется так же хорошо, как код, который мог бы написать программист, если бы следовал руководству по стилю. Это избавляет от тяжелой работы по поддержке кода.
А теперь перейдем к практической части:
YAPF можно использовать как из командной строки, так и в виде плагина для текстового редактора. Сейчас есть плагины для Emacs, VIM и Sublime Text.
Я в основном использую Sublime Text, поэтому покажу как его настроить для использования YAPF.
Плагин для Sublime Text — [github.com/jason-kane/PyYapf](https://github.com/jason-kane/PyYapf)
1. Установка.
```
pip install yapf
```
Установите Sublime Package Control, следуя инструкциям здесь (если вы еще этого не сделали).
Ctrl-Shift-P (Mac: Cmd-Shift-P) и выберите «Управление пакетами: установить пакет».
Найдите в списке «PyYapf Python Formatter».
2. Настройка.
После установки у вас появится PyYapf в меню настроек.
Чтобы все заработало, требуется указать, где у вас лежит файл Yapf (в моем случае, он был в папке Python)
Откройте настройки PyYapf — Settings default, скопируйте их. Потом откройте PyYapf — Settings User, вставьте скопированные правила и укажите путь до Yapf файла.
После этого можно уже использовать YAPF для форматирования кода. Нажмите Ctrl-Alt-F и код будет преобразован. По умолчанию применяются настройки PEP8.
Пример до и после.
Вы можете настроить в нем множество правил. YAPF позволяет делать гибкую настройку различных параметров, подробнее тут — <https://github.com/google/yapf#id8>
Надеюсь YAPF поможет вам писать красивый и чистый код, соответствующий многочисленным стандартам. | https://habr.com/ru/post/324336/ | null | ru | null |
# Система настроек и смена версий программ: эволюция жизнеспособных форм
*Константно-переменный дуализм.*
Настройки у программ существуют давно, от самых древних ассемблерных программ, имеющих в своём коде константы в качестве настроек. Обновление таких программ происходило с полной заменой кода, поэтому изменение системы настроек не влекло отрицательных последствий. В худшем случае, приходилось переучиваться пользованию интерфейсом. Положение стало меняться при преемственности типов данных и настроек программ. В своё время Microsoft уделяла огромное внимание совместимости программ и данных в операционных системах, в чём была их сильная сторона. Да и сейчас поддержка режима XP Mode — это продолжение политики совместимости. Применительно к веб, пользователям часто встречаются ситуации, когда данные и настройки у них остаются от прежних версий (в куках, в сторонних базах данных), а версия программы — на сервере или скрипт на клиенте — изменяется. Возникает проблема совместимости версий программ и данных и необходимость выработки некоторой политики поддержки совместимости. Новая версия может не устроить по совместимости с браузерами (из-за багов или неполной поддержки), тогда откат к прежней на время исправления багов не должен сопровождаться потерей или искажением настроек, при том, что количество их может меняться с изменением версии.
Требуется подход не просто к настройкам и их организации, а к проблемам смены версий и преемственности настроек. Программы в вебе развиваются мелкими шагами, смена версий происходит часто. Такой же подход к работе с настройками относится и к другим программам, не связанным с вебом, но имеющим частую смену версий. Аналогичные рассуждения можно отнести к форматам всех данных в программах, не только к форматам хранения настроек.
Основные тезисы, которые выводятся и прорабатываются в статье:
\*) настройки — объект для программ и клиентских веб-приложений с похожими моделями поведения;
\*) настройки по умолчанию — не что иное, как рекомендации производителя по настройкам;
\*) изменение настроек при смене версий программы — это изменение рекомендаций производителя; могут существовать смены версий только ради смены настроек;
\*) настройки пользователя — рекомендации пользователя себе;
\*) экспорт-импорт настроек — возможность обмена между пользователями, сохранения рекомендаций, переноса между компьютерами;
(Далее — по смене версий.)
\*) изменение семантики настройки производителем (при смене версий) — ошибка, вводящая нарушение логики при апгрейде — даунгрейде;
\*) при хранении 2 состояний настроек с переключением на кнопке «возврат» возможен ряд функций без усложнения интерфейса: проба новых настроек при смене версии, откат к старым настройкам, проба и хранение сторонних рекомендаций;
\*) для сохранения простоты нежелательна более сложная система манипуляций. Существует экспорт-импорт для всех расширенных действий;
\*) возврат к настройкам производителя — отдельная функция («Сброс»);
\*) рекомендации производителя «зашиты» в программу, поэтому не занимают отдельного места, их может быть несколько (профили настроек), для сохранения других рекомендаций есть кнопка «Сохранить»;
Увидев глубину и общность проблемы настроек и рекомендаций, обрисуем круг требований, которые попытаемся поддержать. Нужно иметь достаточно простую и универсальную систему настроек, которая бы удовлетворительно работала и развивалась при смене версий. В результате получится практичный алгоритм поддержки обозначенного круга требований. После построения алгоритма покажем реализацию подсистемы настроек на \*.user.js и отдельную процедуру на \*.js. Она была сделана из соображений, что лучше сразу описать регламент работы с настройками для себя и пользователей и не отходить от него, чем вырабатывать потом, исправляя собственные ошибки.
### Круг требований: насколько настройки будут совместимы по версиям программы
При смене версий меняется всё — программа, настройки, логика и семантика (содержательные значения настроек). Смена версий — это ещё одно измерение развития логики, которое учитывает приход данных из старых версий, настроек из них, а иногда — наоборот, из новых версий, если происходит даунгрейд или перенос настроек на другой компьютер, другую версию программы. Смоделировав ситуации смены версий, начинаем понимать, каких правил необходимо придерживаться, а какую свободу можно оставить. Или, говоря другими модными словами, создадим *паттерн проектирования* «Настройки».
Касаясь проблем совместимости, каждый разработчик живо вспоминает классический кошмар, который устроила фирма Adobe с версиями программы Photoshop, ~~чтобы поухватистее вывернуть карманы клиентов~~. Тут, скорее всего, она действовала с умыслом, тем более, что история повторяется с их другими дорогостоящими программами. Поработали 1-2 года с флагманской программой индустрии — платите следующий взнос. Такого подхода не могут позволить себе мелкие программы и сервисы, а, наоборот, смену версий требуется делать бесплатно и очень часто, чуть ли не с каждым выходом новой версии какого-либо браузера. Необходима чёткая и обоюдно комфортная смена версий с поддержкой совместимости настроек. (А также, один к одному — форматов данных и их семантики, но **будем исследовать только настройки**.) При этом разные пользователи могут обновиться далеко не от предыдущей версии, а бОльшая часть пользователей не будет утруждать себя работой с настройками, или некоторые настройки будут отсутствовать вообще, но быть автоматическими — например, сохранение параметров расположения окна в системе.
Система сохранения и перехода между версиями учитывает эти факты и обеспечивает:
1) хранение и восстановление настроек в текущей версии программы;
2) при обновлении программы — не забывать старые настройки на случай возврата к старой версии (хотя бы на 1 шаг назад);
3) неизменность смысла старых настроек в среде сколь угодно новой версии (семантика не должна меняться; почему — разбор ниже);
4) не напрягать пользователя слежением за версиями и не принуждать его делать какие-либо действия (лучшее — враг хорошего; нет необходимости — не отвлекать);
5) не стремиться к гигантизму и хранить разницы (диффы) в настройках — шаг оптимизации.
При работе с версиями скрипта JS, который на клиенте тоже оказывается полноценной программой, обнаружилась проблема сохранения настроек пользователя при смене версий. Сразу же вспомнились вопросы совместимости версий Фотошопа и некоторых других монстров. И подумалось, что решить проблему правильной работы с пользовательскими настройками лучше в зародышевом состоянии, пока скрипт не пошёл в массы и не появилось множество недовольных пользователей, которые вынуждены будут вручную, по памяти настраивать новую версию программы, или, ещё хуже, старые настройки войдут в противоречие с новой версией, возникнет нетестированный баг. Предлагать пользователю «сбросить всё и установить по новой» — конечно, известный и безобразный способ решения таких проблем, с которым искушённые пользователи смирились. (В самом деле, что они могут сделать с производителем Фотошопа, когда пользы больше, чем неприятностей?) Лучше сразу заложить в проект технику разрешения конфликтов настроек при смене версий. Так были построены правила работы с версиями и настройками, которым мог бы следовать проектировщик программы.
Во второй части в следующей статье — реализация тестовой страницы на JS — готовый скрипт, в котором можно проверить работоспособность подхода. В скрипте настройки пользователя — произвольная многоуровневая структура, поэтому её можно портировать в различные проекты, в которых тоже задумались о необходимости корректной смены версий. Или, используя первую и вторую части, написать логику на другом языке. Усилия не пройдут даром и можно сэкономить на труде дизайнера по заготовке красивой таблички такого содержания:
| ~~Перед установкой рекомендуется удалить настройки предыдущей версии…~~ |
| --- |
### О политике сохранения настроек программ при переходе к новым версиям.
[](http://andybialk.blogspot.com/2010/04/how-to-train-your-dragon.html)Как уже упоминалось, смена версий программы — выход в новое измерение, от решения проблем с багами кодов в одной простыне программы к решению проблем её развития. Разработчики могут не сразу осознать специфику этой области, если долго работают над рядом других очень важных функций своей программы, а вопрос о смене версий на первом плане не стоит. Но когда-то он встаёт, и начинается эволюция.
Что было в эпоху динозавров: программа при установке новой версии начинает работать плохо или вообще не работает. Рекомендация: перед установкой новой программы удалите предыдущую версию (и очистить реестр и файлы папок от данных из старой версии программы). В особо тяжёлых случаях — не открывать данные, созданные в старой версии программой новой версии.
Другой древний вариант: при переходе к новой версии программа не спрашивает, какие были настройки — она ставит дефолтные, а пользователь устанавливает их вручную. Способ обхода проблемы с программой: иногда подменяют данные в ini-файлах, реестре (win detected), конфигурационных файлах, и этим спасают себя от части работы по настройке. Ещё варианты решения — хранить программу с образом виртуальной ОС, в которой она установлена; ставить redisributable пакет, в котором создали работающий настроенный образ программы, а затем его упаковали для повторной инсталляции; использовать тихую инсталляцию с параметрами настройки, предусмотренную в довольно многих серьёзных программах.
Случай более приспособленных форм жизни: программа начинает понимать старые настройки, оставшиеся от предыдущей версии. Что для этого нужно делать при создании программы?
*Речь будет идти, то о программах, то о вебе и сайтах, потому что там и там предмет обсуждения один — пользовательский интерфейс, версии продуктов. Только входной поток иной. Для программ — это настройки и их наследование разными версиями, для веба — это страницы данных и их отображение разными браузерами. Иногда эти данные настолько похожи на настройки, что их начинают так называть, а веб-страницы или виджеты на них начинают называть приложениями.*
### Новые настройки
Хороши были времена, когда новая версия программы имела полностью новые настройки. Тогда вопроса наследования просто не стояло. Как в эпоху динозавров, новая версия просит всё-всё установить заново или пользоваться настройками по умолчанию. Но наследственность как базовое свойство развивающихся систем быстро изжила этот недостаток. От программ стала требоваться не только совместимость по данным, но и совместимость по настройкам. Сначала динозавры, а потом и куры начали требовать яиц, положив начало вопросу о том, что раньше появилось. Установил новую версию — не потерял заданные ранее настройки, скажем, размеров окна и шрифта. Но система настроек от версии к версии имеет свойство развиваться, поэтому приходится учитывать развиваемость программ, эволюцию жизненных форм. И ещё, программа может обновиться до какой угодно версии, даже до более старой, а значит, она должна корректно использовать не только любые предыдущие настройки, но и настройки в любом будущем формате!
Например, в системе тегов и атрибутов HTML, XML имеется правило: если встречается новый атрибут или тег, он игнорируется (его смысл неизвестен). Очевидно, и в системе настроек логично **при появлении новых — игнорировать их**. Так, в HTML-страницы, а ещё ранее — в настройки программ для разных версий той же программы ввели самое первое и простое правило совместимости.
### Интерпретация имеющихся настроек
Однако, даже при неизменных настройках программа может (по ошибке) начать интерпретировать некоторую настройку иначе. Если программы — от разных производителей, которые от пользователя получают одинаковые данные, они могут интерпретировать данные в несколько разных смыслах. Например, у одних размер экрана учитывает первый монитор, у других — максимальное измерение из группы всех подключённых мониторов. Если снова обратиться к аналогии с HTML, то это в HTML известно как проблема совместимости представлений данных в браузерах. Даже одинаковые данные (таблицы, поля ввода) вызывают немного разное отображение результатов.
Есть проблема — взялись за её решение. Теперь есть «совместимое» представление, а есть строгое. При большом количестве версий браузеров количество строгих представлений растёт, а совместимых — растёт ещё быстрее (в квадрате), т.к. каждый браузер и версия будет иметь своё представление о совместимости.
Если бы мы приняли такой подход для совместимости настроек в программах, то надо было бы написать правила переноса настроек между версиями. Потому что установка версий не всегда происходит последовательно. Есть перескоки через версии, есть возвраты к прежним (например, по причине багов новых версий). Понятно, что этот процесс, даже если будет начат на уровне 2-3 версий программы, быстро наскучит разработчикам, и они начнут поддерживать только самые актуальные совместимости — переход от старой версии к новой.
**Придерживание единой линии поведения — лучшее средство постройки Вавилонской башни.**
### Исчезновение старых настроек или некоторых их значений
Если в новой версии программы (или даже при новом запуске) перестали поддерживаться значения, установленные в настройках ранее, программа должна достойно на это отреагировать.
Например, в ту же эпоху динозавров, все (или многие) программы считали, что должны появляться в середине экрана и занимать примерно 50% ширины экрана. Если пользователь решит сменить положение и размер окна, было совсем не обязательно, что в следующий раз программа откроет окно на новом месте. Почему так?
Если программа запомнит положение и размеры окна, то в другой раз она может запросто оказаться за пределами экрана, если сменили монитор. Поддержка программы усложняется, а эволюция не всегда поддерживала сложные формы жизни. Увидеть монитор и окружение — это долгие процедуры, которые в неразвитом API создавали ад для разработчика, и они (или эти идеи у них) вымирали, даже не дав потомства — работающих в этом ключе программ. Программы могли быть крайне сложными, но иметь примитивный интерфейс, потому что каждое дополнительное действие над работающей программой могло дать серию багов и необходимость нового цикла тестирования.
Но шли годы, и с появлением более совершенных API и сред разработки у разработчиков прибавилось сил и уверенности в будущем. ~~Динозавры обросли перьями и начали летать.~~ Теперь вполне реально увидеть, что если программа приняла недопустимое значение из настроек, она не загнётся в агонии и не будет сметена безжалостной рукой ~~природы~~ пользователя, а поступит разумно.
Разумные альтернативы:
1) выбрать ближайшее похожее значение;
2) выбрать значение по умолчанию;
3) предложить выбор комплекса связанных значений, поскольку изменение параметра иногда требует изменения других.
**Разумная программа реагирует на недопустимое для данной версии значение**.
### Смена семантики настройки
Это — наиболее сложный случай запутывания программой своих прежних настроек. Если контроль настроек базируется на передаче имени + значения каждой настройки, то искажение смысла (т.е. действий программы) значения приведёт к неконтролируемому пользователем изменению поведения программы.
Например, ранее 1 — это открывать на весь экран, теперь — в большом окне.
Изменилось понимание дефолтной настройки, а в файле настроек не хранятся дефолтные значения. Очевидно, что наличие таких изменений смысла приведёт к ошибкам и потребует исправления.
Таким образом, как браузеры стремятся белое называть белым (правда, не всегда, например фон страницы кастомизируется), так и программа стремится в настройках видеть то, что в них было заложено по смыслу. (Если некоторая переменная windowWidth указывала на ширину окна, нет смысла в новой версии ей указывать количество работников предприятия.)
Не все поступают так откровенно. Вот — (гипотетический) пример очень скрытного изменения смысла. До версии N ширину окна в ОС разработчики считали по внутренней границе окна, а с N-й решили, что правильнее считать вместе с бордюром. И тогда, если ранее пользователь устанавливал в прежних версиях ширину 100, в N-й он получит внутреннюю ширину (по прежнему смыслу) 98, 96 или другую, зависящую от настроек ОС. На месте разработчиков, при необходимости ввода другой ширины, для неё нужно выбрать другое название (имя, ключ в настройках). А прежнее за ненадобностью можно навсегда удалить (или оставить процедуру конвертирования, только для совместимости версий).
**Смену семантики значения настройки нужно рассматривать как ошибку разработчика.**
### Смена дефолтного значения
Наиболее безобидный случай из приводящих к нарушениям работы.
К примеру, есть 2 чекбокса, оба выбраны. Первый чекбокс пользователь обнулил, второй его устроил (а если бы не был выбран, пользователь его бы выбрал, потому что хочет значений, 0, 1). В следующей версии производитель сбросил оба чекбокса. Пользователь в сохранённых настройках имеет только выбор первого: 0, Х, где Х означает предоставление выбора производителю. И имеет проблему, потому что в интерфейсе не было и нет возможности закрепить дефолтное значение второго чекбокса.
Результат — неодинаковая работа системы настроек для разных пользователей. Всё в порядке с пассивными и проблемы для активных, не могущих зафиксировать выбор дефолтной настройки. (Из этого следуют рекомендации профессионалов в смежных областях — CSS, например — учитывать действия атрибутов по умолчанию, прописывая их явно (CSS reset), чтобы в случае изменения политики умолчания в будущем не возникло иного понимания атрибутов.)
Выход в том, чтобы давать возможность фиксировать настройку, даже если она находится в значении по умолчанию. Другими словами, пользователь выразит явное желание установить это значение, а не пассивное согласие на настройки (рекомендацию) производителя. Следовательно, мы не можем, как это обычно делают, не дать возможность указать фиксацию настройки пользователя в том же значении, в котором она находится сейчас. *(Это и был тот самый тонкий момент, сбой системы без фиксации дефолтных настроек, который заставил разобрать проблемы.)*
В системах голосования, если кто-то уже проголосовал так же, как и пользователь, вовсе не значит, что пользователь не может так же проголосовать. Аналогично — и в настройках. **«Облегчение» выбора настройки по умолчанию без возможности подтверждения, фиксации её в интерфейсе является «медвежьей услугой» и источником проблем.** С фиксацией — соблюдается баланс рекомендации производителя и выбора пользователя.
В нашем случае с чекбоксами, нужно не просто давать изменять настройки, но и указывать фиксацию каждой. Для оптимальности процесса, если пользователь что-то изменил, это уже означает фиксацию. Зато, её теперь нужно смочь снять — вернуться к значению по умолчанию, опять же, для каждой настройки. Аналогично — вернуться к выбору другого авторитетного пользователя, если система будет поддерживать не один профиль настроек, а импорт других авторских настроек в том числе.
Далее, производитель делает смену настроек неспроста, поэтому полезно, чтобы о ней узнали, в ненавязчивом режиме. Если пользователь заинтересовался настройками, он должен увидеть то новое, что произошло с ними с момента его последнего захода в настройки. Если он зашёл первый раз, ничего не выделяется, всё ново. Если что-то менял или фиксировал ранее, а производитель изменил свою рекомендацию — пользователь увидит изменение. **Разработчик обеспечивает указание на смену дефолтных настроек**.
Вопрос плавно подходит к системе помощи, подсказок, информации и выбору рекомендаций. Место оповещения об изменении настроек — также лучшее место описания настроек вообще или подсказок по ним.
Следовательно, интерфейс выбора настройки обрастает 2 элементами: фиксацией/снятием фиксации и подсказкой как по истории изменений, так и описанием настройки вообще.
Примерно так (просто перечислены элементы управления):
```
[0] - чекбокс_1 (?) _fix_
[1] - чекбокс_2 (?) _unfix_
[__] - поле_3 (?) _fix_
```
В квадратных скобках — значение чекбокса; знаки вопроса — подсказки; цвет вопросов может указывать на то, что системе есть, что сказать об изменениях. Значки «fix/unfix» — ссылки на фиксацию дефолтов или возврат к ним. Если рекомендателей несколько, значки фиксации усложняются. Можно иметь в ряду настроек — указание о пользователях, выбравших эту настройку (сколько и с каким статусом), и среди них — значение настройки разработчика. С таким подходом настройки начинают напоминать оценки социальной сети. Что ж, может быть, это — один из вариантов коллективного использования программ.
Если механизма фиксации нет — имеем проблемы интерфейса и логики. Впрочем, в интерфейсах чекбоксов в ОС эту проблему решили перебором 3 состояний: 0, 1, default. В HTML её тоже решить можно применением disabled и циклическим перебором с помощью JS. Тогда, по крайней мере, для чекбоксов и радиокнопок не потребуется элемент fix/unfix.
### Что, если работа новой версии не устроила?
В этом случае, очевидно, требуется откат к последней устраивающей версии. При этом некоторые данные могут остаться новые (обычно из предметной области), а настройки программы следует брать из старых настроек, но при этом часть новых настроек тоже может оказаться полезной и сохраняется как рекомендация для старых или для новой стабильной версии.
… Второй раз появилось слово «рекомендация». Это непривычно для настроек. Есть «дефолтное значение» как рекомендация разработчика, есть (бывает) сброс к дефолтным значениям, но нет рекомендаций. Есть импорт настроек, но тогда все настройки примут новые значения, и сравнивать можно лишь с тем, что было до смены. Рекомендация — это возможность попробовать изменить настройку или их группу и немедленно увидеть и сравнить результат.
Идея рекомендации и сравнения — очень мощная. (Так, кстати, работала и эволюция в эпоху динозавров.) Ряд сайтов магазинов старается максимально удобно представить товары для сравнения. Это — та же рекомендация выбора, как рекомендация установить некоторую настройку. Поэтому, если мы осилим показать в программе последствия рекомендации настройки, откроются перспективы сделать ещё очень многое и неожиданно полезное тем же инструментом.
Вернёмся к откату версии. Чтобы полноценно сделать откат, программе не следует безоговорочно забывать старые настройки. Лучше, **если она помнит последний шаг смены версии программы**. Если пользователь не успел опробовать все возможности прежних версий — пусть помнит и прежние шаги. Тогда он получит возможность выявления последней правильно работающей версии. Очевидно, это будет полезно для разработки и тестирования. В эпоху динозавров такого ещё не было…
### Разумное ограничение интерфейса
Правда, не хотелось бы так усложнять интерфейс выбора настроек, чтобы оперировать с несколькими наборами сразу. Это хорошо для профессиональных тестировщиков и других разработчиков, но есть задача сделать массовый элемент управления, поэтому лучше, если он будет максимально простым и гибким. Обычно **гибкость достигают экспортом-импортом настроек**. С ним пользователь в отдельном месте вне программы может реализовать любую систему каталогизации и хранения версий, что опять-таки, сложно. В дополнение ко всесильной системе экспорта, хорошо бы иметь простую подсистему, не требующую прибегания к экспорту, насколько это будет возможно.
Попробуем **хранить не 1 список настроек, а 1 или 2**, относящихся, например, к текущей версии и к прежней. Или текущую версию и экспериментальную. Тогда в интерфейсе управления нам надо иметь всего одну кнопку (как в калькуляторах — кнопку «М» (память) ), чтобы переключаться между своими настройками и не путаться в них, не вводить имена и не строить «менеджер». Для всего, что больше — имеется к услугам экспорт. Это фундаментальное упрощение интерфейса, будем надеяться, позволит построить практичную модель и останется интуитивно понятной, как кнопка «М».
Отправная точка такой идеи — в том, что большинство действий, в том числе проверка новой версии и откат к старой, не требуют оперирования с более чем 2 списками настроек. Проверка чьей-то рекомендации с хранением одного «комплекта» своих настроек — тоже. Далее опишем техническую реализацию.
Хранить настройки — означает разместить их в localStorage, чтобы использовать в пределах браузера, независимо от перезагрузок. Кроме хранимых наборов, можно временно тестировать другие настройки, не затрагивая хранимых. Сохранение делается нажатием кнопки «Сохранить» или загрузкой новой версии программы. Откатиться можно без использования новых настроек (по умолчанию) или с использованием (указывается при откате). Перейти к произвольной другой версии — с выбором из тех же двух. Новые настройки выбираются, если номер версии — больше версии настроек нового комплекта. Если 2 комплекта одинаковы, всё равно считается, что их — два. Хранятся — как разности, поэтому, чем меньше различий, тем меньше занято места. Текущие настройки хранятся как разность между рекомендациями производителя и пользовательским выбором. Разность понимается как указание настройки в случае, если она выбрана пользователем (даже если совпадает с дефолтной) и неуказание, если иначе.
Есть ещё один технический момент, что в браузере наиболее просто реализовать чтение настроек в начале загрузки страницы, а затем считать их константами. Процесс смены настроек требует перезагрузки, поэтому какое-либо тестирование требует сохранения комплекта настроек, а для незабывания настроек пользователя нужно хранить 2 комплекта и использовать затем ту же кнопку «Вернуться» для восстановления.
Что можем делать с 2 списками настроек? Соберём полный список.
1. Перейти **к новой версии программы** и загрузить новые настройки из неё. Старые останутся для отката, а новые — для продолжения работы.
2. Если выполняется откат, во втором наборе **сохраняются данные новых настроек**, если их пользователь изменял. При повторном переходе к той же или более новой версии используется наработанное.
3. **Сохранение другой рекомендации** (импорт — сохранить) стирает данные для отката, чтобы настройки другой рекомендации могли исследоваться после перезапуска браузера.
4. **Тестирование других настроек** (настройки — тестировать — сохранить), которые можно продолжить после перезапуска браузера и после перезагрузки страницы.
Ничего не мешает тестировать настройки без их сохранения, но тогда мы ограничены пределами времени до перезагрузки страницы. Так можно протестировать самые простые и немедленно действующие настройки. Большинство настроек устанавливают свои значения в программе как раз в начале загрузки страницы, поэтому без сохранения в localStorage они не смогут быть протестированы. Механизм сохранения 2 комплектов настроек позволяет тестировать без таких ограничений, что создаёт хорошее дополнение к возможностям скриптов.
### Почему такое внимание к количеству данных и их ограниченности?
Потому что, с одной стороны, есть стремление к простоте и понятности настроек. Чем меньше сущностей, тем лучше. Самое простое — иметь один комплект настроек — «мои». Для минимума манипуляций вводятся настройки «другие» и единственная кнопка переключения «Возврат». Запутаться сложно, а функций добавляет. Есть и другая сторона вопроса.
Казалось бы, что трудного в том, чтобы перенести настройки на сервер в базу данных, а там — работать с ними сколь угодно сложно: хранить для каждой версии, пересматривать историю? Тут подходим к паре других сущностей нашей задачи. Первая — предполагается хранение настроек независимо от авторизации на сервере. Без авторизации или для другой задачи — в качестве настроек юзерскрипта на клиенте, где авторизации тоже не предполагается. Вторая сущность постановки — хранение настроек в текстовом виде для экспорта предполагает наиболее компактную форму хранения, поэтому надо иметь наиболее короткую и редактируемую вручную строку. Поэтому есть 2 комплекта, и то, хранятся только разности настроек, чтобы данных было меньше.
### Интерфейс переключения настроек
Этот раздел требует отдельной статьи и другого блога. То, что делали раньше, называется «Архитектура программы», но такого блога нет, есть только тег «Архитектура». Чтобы описание было законченным, опишем результаты кратко, словами, без иллюстраций, а подробности вынесем в другую статью. Получилось, как обычно в текстовых описаниях интерфейсов — скучно, трудночитаемо **и предназначено только тем, кто подобным занимался** и хочет сравнить результаты.
В начале, без особых действий пользователь не получает никаких дополнительных элементов в интерфейсе нигде, до тех пор, пока он не начнёт пробовать изменить настройки. Нет даже (или не активизирована) кнопки «Экспорт», потому что экспорт пустой строки — это, по умолчанию, согласие с настройками производителя.
Есть кнопка (или поле ввода) "**Импорт**", по которой через поле ввода загружаем строку JSON или нечто подобное для смены настроек. Немедленно видим отражение этих настроек в интерфейсе настроек, название рекомендателя, версию настроек + версию программы, для которой они были сделаны. Нет ничего необычного, если в другую версию программы (старую или новую) загрузим настройки произвольной версии. Сработают те, ключи которой найдутся в текущей версии программы. Появляются призывные кнопки "**Протестировать**" и "**Отмена**". Вторая восстанавливает просмотр своих настроек и ничего не делает, а первая сохраняет как актуальную — загруженную импортированную версию, а как резерв — текущую, стирая при этом любую другую резервную версию, если она была (одноуровневый стек).
Наличие сохранённой резервной версии отмечается в панели настроек. Поэтому, как только нажмём «Протестировать» — на кнопке "**Вернуться**", которая придёт на смену, появится информация о сохранённой версии пользователя (её может не быть, если настроек пользователя не было, но режим «тест» всё равно включается). В интерфейсе страниц появляется постоянно висящая ссылка на блок настроек"**тест**" (как напоминание о пришедшей почте).
При нажатии на «Вернуться» получаем возврат настроек для программы (обычно приводятся в действие после перезагрузки страницы), а в панели настроек — настройки для теста и кнопки «Протестировать»-«Отмена» — прежний шаг операции.
Если **загружается новая версия скрипта** (программы), что отмечается по анализу localStorage, она действует на состояние настроек аналогично, если они были когда-то изменены. Создаётся копия старых настроек и… аналогично «тест», появляется нотификатор "**новая версия**". Если этого не сделать, изменение поведения программы вызовет недоумение пользователя. Здесь возникает вопрос, показывать ли эту кнопку всем или только интересующимся. Скорее всего, второе, а для всех — нотификатор прячется в панель настроек.
Если смена версии происходит многократно, ничего особо не меняется, только значение новой версии скрипта (и новые настройки). Если пользователь изменил настройки для новой версии, появляется кнопка "**Сохранить**", по клику на которой **появляется 2 группы настроек**: к новой версии и к старой. «Вернуться» вызовет ротацию версий: слово «Вернуться» сменится на "**Применить новые**", чтобы снова переключиться на новые настройки, как в случае «Протестировать». Чтобы вернуться к старой программе, нужно нажать появившуюся кнопку "**Откат**", который произойдёт на версию, номер которой запомнен при последней правке старых настроек. (Этот механизм требует доступа к любой выпущенной версии.) Для переключения к другим версиям — спадающий список номеров.
Если пользователь изменил комплект настроек ещё раз, когда 2 комплекта сохранены, но имеется 3-я версия программы, нового сохранения в стеке не будет, изменится только текущая группа (после нажатия «Сохранить»).
Кнопка "**Подтвердить настройки**" — чтобы отказаться от хранения запомненного состояния — отката, оставшись на новой версии (значок «новая версия» удаляется). Если состояние одно, кнопка называется «Стереть настройки» или "**Сброс**", и память очищается от настроек, используются настройки по умолчанию. «Сброс» защищён от случайного нажатия.
Учитывая **ограничение числа комплектов настроек двумя**, любое действие тестирования сотрёт настройки отката и не восстановит их по окончанию теста. Чтобы их не потерять, пользуются кнопкой **экспорта**, которая активизируется при наличии какой-либо пользовательской настройки.
Перечислим ещё раз список кнопок и нотификаторов и их группировку:
\* Импорт, Экспорт — для внесения-извлечения настроек в виде строки;
\* Протестировать, Отмена — применение настроек, отмена показа импорта в настройках;
\* «тест» — нотификатор, подсказывающий, что настройки находятся в режиме теста;
\* Вернуться — восстановление своих настроек, выход из теста;
\* «новая версия» — нотификатор, говорящий о загрузке новой версии (в панели настроек);
\* Откат — аналог «Вернуться» для отката к прежней версии;
\* комбо или список версий — к какой версии будет откат;
\* Сохранить, Отмена — подтверждение смены настроек от пользователя; аналогично «Протестировать», но без нотификации;
\* Подтвердить настройки (вместо «Вернуться») или Сброс — удаление хранимых настроек, применение текущих (или умолчательных), снятие нотификатора «новая версия»;
\* Применить новые — после отката — перейти обратно к новой версии настроек.
*В следующей серии попробуем увидеть всё это вживую, но, вполне возможно, что в скрипте это ещё не будет работать, а писать статью с разрисовкой интерфейса будет никому не нужно — программирование идёт без макетов. Тогда дождёмся публичного скрипта с описанными механизмами в качестве демонстрации.*
### Итоги
Получен интерфейс работы с настройками без технологических изъянов, которые могли быть без учёта развития программы при смене версий. Введено понятие «рекомендация» и предусмотрена возможность работы с несколькими рекомендациями и с форматом настроек, совместимым по версии программы в любую сторону — работающим как с новыми версиями (для апгрейдов), так и со старыми (для откатов). | https://habr.com/ru/post/133989/ | null | ru | null |
# Nemesida WAF: защита сайта и API от атак и паразитного трафика
За прошедшие выходные мы зафиксировали всплеск атак на веб-ресурсы, уверен, с этим столкнулись и вы. И пока зарубежные вендоры решают, кто из них уходит, кто - нет, мы продолжаем работать на отечественном рынке, улучшать механизмы работы Nemesida WAF и делиться своими результатами.
С атаками сталкиваются все владельцы публичных веб-ресурсов — некоторые узнают об этом сразу, другие — потом. По своей сути атаки можно разделить на 3 типа — **попытки компрометации данных** (Injection, XSS, CSRF, LFI/RFI и т.д.), **DDoS L7** и **атаки на $$$** (например, злоупотребление функционалом восстановления пароля по СМС).
### Выявление атак
Сталкиваясь с атаками на веб-ресурсы, администраторы пытаются перекрыть вредоносный трафик настройками веб-сервера, установкой Rate Limit, созданием правил блокировок или ограничением доступа по IP из списка стран. Эти действия требуют навыков и не всегда приводят к ожидаемым последствиям. Гораздо эффективнее будет использовать WAF.
**ModSecurity и NAXSI** - наиболее популярные бесплатные решения, способные блокировать вредоносный трафик с использованием сигнатурного анализа. Мы специализируемся на коммерческой разработке технически сложного продукта с полноценным модулем машинного обучения, сканером уязвимостей, качественной визуализацией событий и т.д., но желая сделать свой вклад с ИБ-сообщество, мы реализовали бесплатную версию продукта - без ML и сканера, но отличной визуализацией и качественной сигнатурной базой - **Nemesida WAF Free**.
Просмотр атак### Атаки ботов
Атаки ботов могут представлять такую же угрозу, как самые «лютые» уязвимости OWASP — за неделю можно потерять несколько миллионов рублей на обычных формах регистрации/восстановления паролей по СМС. Современные бот-сети, как птица-говорун, отличаются умом и сообразительностью — и валидные куки могут получать, и CSRF-токены, и даже, говорят, способны капчу обходить. В конце-концов боты могут просто «положить» ресурс. В коммерческой версии Nemesida WAF используются продвинутые механизмы, позволяющие по совокупности признаков и поведенческому анализу выявлять и блокировать паразитный ботнет-трафик.
Реально противодействовать атакам ботов очень сложно — временное ограничение по странам не всегда помогает, ровно как и попытки заблокировать их по полю User-Agent или другим признакам — после нескольких блокировок ботнет будет направлять запросы с новых IP и с новыми полями. Для решения этой проблемы в Nemesida WAF мы используем набор признаков, влияющих на принятие решения о блокировании: репутационную GeoIP-базу, наличие адреса в списках прокси-серверов (VPN/Tor/etc) или хостинг-площадок и поведенческий анализ. Запросы, которые не были явно определены как паразитные, не блокируются, но сохраняются для последующего анализа на повторы атак. Такой подход позволяет отсекать 80-100% вредоносного трафика, при этом в редких случаях ошибочной блокировки легитимному пользователю предлагается себя разблокировать, используя функционал Captcha.
Злоупотребление функционалом восстановления пароля по SMS### Расширенный анализ запросов
Мы не раз писали о преимуществах и недостатках сигнатурного анализа и машинного обучения. Если кратко — первый быстрый, но не точный, второй точный, но медленный. Комбинирование двух типов анализа и расширенные механизмы нормализации запросов в Nemesida WAF позволяют избавиться от проблем пропусков и ложных срабатываний даже на обычном железе. Еще одно преимущество Nemesida WAF — обучение и распознавание происходит локально, без использования облачных вычислений (проще говоря, вы не передаете трафик за пределы собственного периметра). В паблике можно найти множество способов обхода сигнатурного анализа — от банального расщепления нагрузки вроде `un","ion se","lect` до использования различных кодировок и манипуляций:
* Использование функции возврата массива возможных вариантов исправления слов в PHP для автоматической нормализации запроса на стороне веб-приложения, опубликованная [0xInfection](https://twitter.com/0xInfection/status/1396489575699161089)
* Применение различных кодировок для обхода фильтрации
* Использование особенностей нормализации данных средствами Bash (при OS Command Injection): `/???/??t /???/p??s??` (нормализуется до `/bin/cat /etc/passwd`)
Проблемы обхода WAF, приведенные в примерах, ровно как и другие, решаются в Nemesida WAF за счет механизмов нормализации запроса и его анализа модулем машинного обучения на основе признаков атаки, а не только сигнатур. В общем, лучше посмотрите, как это работает на практике.
### Быстрый старт
Мы понимаем, что любой новый продукт требует времени на настройку и обслуживание, поэтому одной из основных задач определили как возможность запуска «из коробки» с минимальными настройками. На запуск основных компонентов у нас уходит примерно 5-10 минут: достаточно указать лиц. ключ и прокси-сервер (если используется). Это позволит запустить защитные механизмы и приступить к настройкам вспомогательных модулей — Nemesida WAF API и Cabinet (для приема и отображения аномалий в веб-интерфейсе), Signtest (для управления модулем машинного обучения) и Scanner (для поиска уязвимостей). По каждому компоненту доступна подробная инструкция.
У вас мало времени, мы это ценим, поэтому подготовили уже преднастроенные образы виртуальной машины (Virtual Appliance) для KVM/VMWare/VirtualBox и образ для [Docker](https://nemesida-waf.ru/manuals/6387). Еще мы ценим вашу конфиденциальность, поэтому все компоненты Nemesida WAF **устанавливаются локально** и не передают трафик за пределы вашей инфраструктуры.
Ссылка на Nemesida WAF: [nemesida-waf.ru](https://nemesida-waf.ru/)
Еще мы разработали инструмент для проверки работы WAF - [waf-bypass](https://github.com/nemesida-waf/waf-bypass)
Всем пока, оставайтесь здоровыми и защищенными. | https://habr.com/ru/post/654409/ | null | ru | null |
# Минимальная Arduino своими руками
Arduino — это хорошо, когда хочется быстро реализовать идею, не заморачиваясь мелочами. Но когда идея проверена, лишняя функциональность начинает просто мешать.
Собирая робота на гусеничном шасси, я столкнулся с тем, что бутерброд из Arduino + MotorShield + Sensor Shield плюс ко всему аккумулятор и прочие компоненты обросли проводами и стали с трудом помещаться на не самом крошечном шасси. Городить еще кучу шилдов, чтобы избавиться от лишних проводов не хотелось.
Появилась идея избавиться от всего, что в Arduino не требуется в готовом девайсе. Попутно хотелось снизить стоимость робота.
Многих интересующихся электроникой отпугивает еще и стоимость Arduino в магазинах. С ebay и китайских магазинов посылка идет долго, изобретательский пыл успевает остыть, поэтому приобретение откладывается «на потом», «когда сын подрастет». Поэтому я решил собрать Arduino-совместимую плату из деталей, которые всегда можно купить в городе.
В итоге я получил Arduino-совместимую плату, стоимостью в 210 рублей на макетной плате и в ~270 рублей в готовом для наращивания функционала виде.
[](http://fotki.yandex.ru/users/masterraven/view/347326/)
«[Minimalist Arduino](http://fotki.yandex.ru/users/masterraven/view/347326/)»
С нуля до полной готовности собирается с дешевым 40Вт паяльником за 1 выходной без каких-то особых навыков.
Лазерного принтера у меня нет, печатные платы самостоятельно никогда не разводил, поэтому решено было использовать не ЛУТ, а макетную плату с односторонней металлизацией (максимально дешевая, всегда есть в продаже).
Сначала я хотел купить Atmega328P в DIP корпусе, чтобы воспользоваться статьей [Arduino on a Breadboard](http://arduino.cc/en/Main/Standalone) и собрать Arduino на беспаечной макетке.
Но оказалось, что в DIP28 ее в Москве крайне трудно найти, да к тому же в этом корпусе она существенно дороже. Зато в наличии навалом Atmega168 в любом корпусе. Но цена DIP28 и TQFP-32 отличается тоже довольно существенно. Для робота на гусеничном шасси и домашней автоматизации возможностей Atmega168 более чем достаточно, поэтому поборов страх, я решил сэкономить и использовать 168ю в TQFP-32 корпусе (шаг ножек — 0.8мм)
Все компоненты кроме эпоксидной макетки я купил в Москве, в одном магазине (макетки продаются в любом радиомагазине или на рынке, просто у меня уже было 5 штук, купленных ранее на ebay).
Итак, для начала нужно припаять микроконтроллер размером 9х9 мм на DIP переходник, чтобы более комфортно с ней было работать.
mkpochtoi не работал, поэтому купить готовую макетную плату не получилось, купил макетку MP-QFP, от которой ножовкой по металлу отпилил кусок под TQFP-32.
Просмотрев [видеоурок по пайке](http://habrahabr.ru/blogs/easyelectronics/70500/) от [DIHALT](https://geektimes.ru/users/dihalt/) я водрузил микруху на макетку с помощью обычного 40Вт паяльника, потратив на это чуть больше 5 минут (опыта пайки таких мелких компонентов и вообще SMD компонентов у меня не было). В качестве флюса использовал несколько капель глицерина (попросил у девушки, она занимается мыловарением). Отмыл горячей водой и высушил феном.
[](http://fotki.yandex.ru/users/masterraven/view/345693/)
«[Atmega 168PA-AU](http://fotki.yandex.ru/users/masterraven/view/345693/)»
40-ногую линейку PBS-40 кусачками настрогал на кусочки по 4 ножки и впаял с обратной стороны. Я взял гнезда, а не штырьки, чтобы микроконтроллерную плату можно было подключать к макетке проводками без пайки.
Дальше все как в статье — собрал на макетной плате схему, использовав [datasheet](http://www.atmel.com/dyn/resources/prod_documents/doc2545.pdf) от семейства Atmega 48/88/168 (номера ножек на [DIP28](http://arduino.cc/en/uploads/Hacking/Arduino-To-Atmega8-Pins.png) и TQFP-32 различаются).
Поскольку процессор я взял чистый, то предстояло прошить его бутлоадером от Arduino. Тут меня поджидала засада:
Arduino IDE знает только Atmega168 и ничего не знает об Atmega168P (точнее Atmega168PA-AU) — более свежей версии микросхемы. Прошивать она его отказалась. А еще раньше я выяснил, что Freeduino Nano v5.0 почему-то не хочет работать ISP программатором. Пришлось разобрать робота и достать Freeduino 2009. с помощью скетча ArduinoISP и примера на Freeduino.ru удалось заставить avrdude игнорировать различие в сигнатуре (ключ -F) и прошить бутлоадер, фьюзы и лок.
У меня сработал такой вариант:
`::Прошиваем bootloader (порт COM9 нужно поменять на Ваш)
avrdude -F -C avrdude.conf -p m168p -c avrisp -P COM9 -b 19200 -e -U flash:w:optiboot_diecimila.hex
::Прошиваем fuse и lock биты
avrdude -F -C avrdude.conf -p m168p -c avrisp -P COM9 -b 19200 -Uefuse:w:0x00:m -Uhfuse:w:0xdd:m -Ulfuse:w:0xff:m -Ulock:w:0x0F:m`
На официальном сайте есть [описание подключения](http://arduino.cc/en/Tutorial/ArduinoISP) для прошивки:
Как вариант, можно обновить файл avrdude.conf, прописав правильную сигнатуру, но нужды в этом особой нет.
Все, Arduino на макетке готова. Можно подключать любой USB — serial TTL (или RS-232-TTL) адаптер и зашивать скетч из Arduino IDE, выбрав Board->Arduino Diecimila, Duemilanove or Nano w/Atmega168.
[](http://fotki.yandex.ru/users/masterraven/view/345750/)
«[Breadboard Arduino](http://fotki.yandex.ru/users/masterraven/view/345750/)»
Убедившись в работоспособности, я занялся переносом на макетную плату.
Сложнее всего оказалось оптимально разместить элементы. Для этого наиболее простым бесплатным инструментом оказался Fritzing. Правда нагромождение картинок и проводов выглядит страшно, но позволяет при сборке не запутаться в проводах:
[](http://fotki.yandex.ru/users/masterraven/view/347324/)
«[Minimalist Arduino](http://fotki.yandex.ru/users/masterraven/view/347324/)»
Я старался уменьшить количество отдельных проводов, припаивая где возможно выводы воткнутого компонента к нужному контакту просто сгибая его ножки и обрезая излишек.
Добавив примерно 65 р на запчасти я получил вот такой результат:
[](http://fotki.yandex.ru/users/masterraven/view/347325/)
«[Minimalist Arduino](http://fotki.yandex.ru/users/masterraven/view/347325/)»
Для удобства я добавил шину питания и землю (2 гребенки справа внизу), кнопку питания, гнездо RX, TX, DTR для загрузки скетчей и ICSP разъем для прошивки микроконтроллера программатором прямо на плате.
[](http://fotki.yandex.ru/users/masterraven/view/347331/)
«[Minimalist Arduino в сборе](http://fotki.yandex.ru/users/masterraven/view/347331/)»
Воткнув микроконтроллерную плату с Atmega328P-AU, можно прогапгрейдить девайсик для задач, где 16 кб под скетч не хватает. Оставшееся на макетке место я собираюсь использовать под сенсоры, драйвер мотора и прочие нужные вещи.
Вот список компонентов и цен:
| Наименование | Цена | Кол-во | Стоимость |
| --- | --- | --- | --- |
| Mакетная плата MP-QFP | 64 | 1 | 64 |
| Glass-Epoxy Board Prototyping PCB 9x15 FR4 | 43 | 1 | 43 |
| PBS-4 | 4 | 8 | 32 |
| PBS-6 | 4 | 2 | 8 |
| PLS-40 | 4 | 1 | 4 |
| ATMega168PA-AU | 62 | 1 | 62 |
| LM7805 1A 5V Positive Voltage Regulator | 15 | 1 | 15 |
| 16.000MHz Clock Crystal | 10 | 1 | 10 |
| 22pF Capacitor | 1 | 2 | 2 |
| 10uF Capacitor | 5 | 2 | 10 |
| 100nF Capacitor | 1 | 1 | 1 |
| 10kOhm Resistor | 1 | 1 | 1 |
| 150 Ohm Resistor | 1 | 2 | 2 |
| DTS-61 кнопка | 2 | 1 | 2 |
| PS-22E85L | 7 | 1 | 7 |
| WF-02 вилка на плату | 1 | 1 | 1 |
| Red 3mm LED | 2 | 1 | 2 |
| Green 3mm LED | 2 | 1 | 2 |
| | | **Итого** | 268р. |
Сантиметров 20 монтажного провода, припой и флюс я не посчитал :)
Получилось даже чуть-чуть дешевле чем Arduino Pro Mini ($9.5), при этом удобнее в использовании и не нужно ждать 3 недели, пока приедет из китая ).
Но самое приятное — это может собрать каждый и все компоненты есть в продаже и легко доступны. Ждать и искать ничего не нужно. Увидели на хабре интересный проект на ардуино? Соберите его!
Если нет знакомых с ардуино или прогрмматором, то бутлоадер за 50 рублей вам может прошить продавец, а переходник USB — Serial TTL покупать не обязательно, если у компа есть COM порт.
Я собрал вот такой переходник из MAX232CPE, разъема DB9F и 4 конденсаторов по рублю штука:
[](http://fotki.yandex.ru/users/masterraven/view/347332/)
«[Loading Sketch](http://fotki.yandex.ru/users/masterraven/view/347332/)» | https://habr.com/ru/post/131589/ | null | ru | null |
# Паттерн BIF: чистый код фронтенда и удобная работа с серверными данными
В материале, перевод которого мы сегодня публикуем, речь пойдёт о том, что делать в ситуации, когда данные, получаемые с сервера, выглядят не так, как нужно клиенту. А именно, сначала мы рассмотрим типичную проблему такого рода, а потом разберём несколько путей её решения.
[](https://habr.com/company/ruvds/blog/416011/)
Проблема неудачного серверного API
----------------------------------
Рассмотрим условный пример, в основе которого лежат несколько реальных проектов. Предположим, мы занимаемся разработкой нового веб-сайта для некоей, уже какое-то время существующей, организации. У неё уже есть конечные точки REST, однако они не вполне рассчитаны на то, что мы собираемся создать. Здесь нам нужно обращаться к серверу только для аутентификации пользователя, для получения сведений о нём и для загрузки списка непросмотренных уведомлений этого пользователя. Как результат, нам интересные следующие конечные точки серверного API:
* `/auth`: авторизует пользователя и возвращает токен доступа.
* `/profile`: возвращает основную информацию о пользователе.
* `/notifications`: позволяет получить непрочитанные уведомления пользователя.
Представим, что нашему приложения все эти данные всегда нужно получать единым блоком, то есть, в идеале, хорошо было бы, если бы вместо трёх конечных точек у нас была бы всего одна.
Однако перед нами встаёт гораздо больше проблем, нежели слишком большое количество конечных точек. В частности, речь идёт о том, что данные, которые мы получаем, выглядят не лучшим образом.
Например, конечная точка `/profile` была создана в давние времена, писали её не на JavaScript, в результате имена свойств в возвращаемых ей данных выглядят, для JS-приложения, непривычно:
```
{
"Profiles": [
{
"id": 1234,
"Christian_Name": "David",
"Surname": "Gilbertson",
"Photographs": [
{
"Size": "Medium",
"URLS": [
"/images/david.png"
]
}
],
"Last_Login": "2018-01-01"
}
]
}
```
В общем — ничего хорошего.
Правда, если посмотреть на то, что выдаёт конечная точка `/notifications`, то вышерассмотренные данные из `/profile` покажутся прямо-таки симпатичными:
```
{
"data": {
"msg-1234": {
"timestamp": "1529739612",
"user": {
"Christian_Name": "Alice",
"Surname": "Guthbertson",
"Enhanced": "True",
"Photographs": [
{
"Size": "Medium",
"URLS": [
"/images/alice.png"
]
}
]
},
"message_summary": "Hey I like your hair, it re",
"message": "Hey I like your hair, it really goes nice with your eyes"
},
"msg-5678": {
"timestamp": "1529731234",
"user": {
"Christian_Name": "Bob",
"Surname": "Smelthsen",
"Photographs": [
{
"Size": "Medium",
"URLS": [
"/images/smelth.png"
]
}
]
},
"message_summary": "I'm launching my own cryptocu",
"message": "I'm launching my own cryptocurrency soon and many thanks for you to look at and talk about"
}
}
}
```
Тут список сообщений является объектом, а не массивом. Далее, здесь имеются и данные пользователя, так же неудобно устроенные, как и в случае с конечной точкой `/profile`. И — вот уж сюрприз — свойство `timestamp` содержит количество секунд с начала 1970-го.
Если бы мне пришлось нарисовать схему архитектуры той адски неудобной системы, о которой мы только что говорили, выглядела бы она так, как показано на рисунке ниже. Красный цвет используется для тех частей этой схемы, которые соответствуют плохо подготовленным к дальнейшей работе данным.
*Схема системы*
Мы, в данных обстоятельствах, можем не стремиться к тому, чтобы исправить архитектуру этой системы. Можно просто загрузить данные из этих трёх API и использовать эти данные в приложении. Например, если понадобится вывести на странице полное имя пользователя, нам надо будет скомбинировать свойства `Christian_Name` и `Surname`.
Тут хотелось бы сделать одно замечание, касающееся имён. Идея разделения полного имени человека на личное имя и фамилию, характерна для западных стран. Если вы разрабатываете нечто, рассчитанное на международное использование, постарайтесь рассматривать полное имя человека в виде неделимой строки, и не делайте предположений о том, как разбить эту строку на более мелкие части для того, чтобы использовать то, что получилось, в тех местах, где нужна краткость или хочется обратиться к пользователю в неофициальном стиле.
Вернёмся к нашим неидеальным структурам данных. Первая очевидная проблема, которую тут можно увидеть, выражается в необходимости объединения разрозненных данных в коде пользовательского интерфейса. Она заключается в том, что нам может понадобиться повторять это действие в нескольких местах. Если делать это надо лишь изредка — проблема не так уж и серьёзна, но вот если такое нужно часто — это уже куда хуже. Как результат, тут происходят нежелательные явления, вызываемые несоответствием того, как устроены данные, получаемые с сервера, и того, как они используются в приложении.
Вторая проблема заключается в усложнении кода, используемого для формирования пользовательского интерфейса. Я считаю, что такой код должен быть, во-первых, как можно более простым, во-вторых — как можно более понятным. Чем больше внутренних преобразований данных приходится делать на клиенте — тем выше его сложность, а сложный код — это то место, где обычно скрываются ошибки.
Третья проблема касается типов данных. Из вышеприведённых фрагментов кода можно видеть, что, например идентификаторы сообщений — это строки, а идентификаторы пользователей — числа. С технической точки зрения всё нормально, но подобные вещи способны запутать программиста. Кроме того, посмотрите на представление дат! А как вам беспорядок в той части данных, которая относится к изображению профиля? Ведь всё, что нам нужно — это URL, ведущий к соответствующему файлу, а не нечто такое, из чего придётся создавать этот URL самостоятельно, пробираясь сквозь дебри вложенных структур данных.
Если мы будем обрабатывать эти данные, передавая их в код пользовательского интерфейса, тогда, анализируя модули, нельзя будет сходу точно понять, с чем именно мы там работаем. Преобразование внутренней структуры данных и их типа при работе с ними создаёт дополнительную нагрузку на программиста. А ведь без всех этих сложностей вполне можно обойтись.
На самом деле, как вариант, можно было бы реализовать статическую систему типов для решения этой проблемы, но строгая типизация не способна, лишь фактом своего наличия, сделать плохой код хорошим.
Теперь, когда вы смогли убедиться в серьёзности стоящей перед нами проблемы, поговорим о способах её решения.
Решение №1: изменение серверного API
------------------------------------
Если неудобное устройство существующего API не продиктовано какими-то важными причинами, в таком случае ничто не мешает создать его новую версию, лучше удовлетворяющую потребностям проекта, и расположить эту новую версию, скажем, по адресу `/v2`. Пожалуй, такой подход можно назвать наиболее удачным решением вышеописанной проблемы. Схема такой системы представлена на рисунке ниже, зелёным цветом выделена структура данных, которая отлично соответствует нуждам клиента.
*Новое серверное API, выдающее именно то, что нужно клиентской части системы*
Приступая к разработке нового проекта, API которого оставляет желать лучшего, я всегда интересуюсь возможности внедрения только что описанного подхода. Однако, иногда устройство API, пусть и неудобное, преследует некие важные цели, или изменение серверного API попросту невозможно. В таком случае я прибегаю к следующему подходу.
Решение №2: паттерн BFF
-----------------------
Речь идёт о старом добром паттерне BFF ([Backend-For-the-Frontend](https://samnewman.io/patterns/architectural/bff/)). С использованием этого паттерна можно абстрагироваться от запутанных универсальных конечных точек REST и отдавать фронтенду именно то, что ему нужно. Вот как выглядит схематичное представление такого решения.
*Применение паттерна BFF*
Смысл существования BFF-слоя — удовлетворение потребностей фронтенда. Возможно, он будет использовать дополнительные конечные точки REST, или сервисы GraphQL, или веб-сокеты, или что угодно другое. Главная его цель — сделать всё возможное для удобства клиентской части приложения.
Моя любимая архитектура — это NodeJS BFF, используя которую фронтенд-разработчики могут делать то, что им нужно, создавая прекрасные API для разрабатываемых ими клиентских приложений. В идеале соответствующий код находится в том же репозитории, что и код самого фронтенда, что упрощает совместное использование кода, например, для проверки отправленных данных, и на клиенте, и на сервере.
Кроме того это означает, что выполнение задач, требующих изменения клиентской части приложения и его серверного API выполняется в одном репозитории. Мелочь, как говорится, а приятно.
Однако, BFF можно применять не всегда. И этот факт ведёт нас к ещё одному решению задачи удобного использования плохих серверных API.
Решение №3: паттерн BIF
-----------------------
Паттерн BIF (Backend In the Frontend) использует ту же логику, которая может применяться при использовании BFF (комбинирование нескольких API и очистка данных), но эта логика перемещается на сторону клиента. На самом деле, идея это не новая, такое можно было увидеть и лет двадцать назад, но такой подход способен помочь в деле работы с плохо организованными серверными API, поэтому мы о нём и говорим. Вот как это выглядит.
*Применение паттерна BIF*
### ▍Что такое BIF?
Как можно судить из предыдущего раздела, BIF — это паттерн, то есть — подход к осмыслению кода и к его организации. Его использование не приводит к необходимости убирать какую-то логику из проекта. Он всего лишь отделяет логику одного типа (модификация структур данных) от логики другого типа (формирование пользовательского интерфейса). Это аналогично идее «разделения ответственности», которая у всех на слуху.
Тут мне хотелось бы отметить, что, хотя нельзя назвать это катастрофой, мне часто приходилось видеть неграмотные реализации BIF. Поэтому мне и кажется, что многим будет интересно услышать рассказ о том, как правильно реализовать этот паттерн.
BIF-код стоит рассматривать как код, который однажды можно взять и перенести на Node.js-сервер, после чего всё будет работать так же, как раньше. Или даже перенести его в приватный NPM-пакет, который будет использоваться в нескольких фронтенд-проектах в рамках одной компании, что просто восхитительно.
Вспомним о том, что выше мы обсуждали основные проблемы, возникающие при работе с неудачным серверным API. Среди них — слишком частое обращение к API и то, что возвращаемые ими данные не соответствуют нуждам фронтенда.
Решение каждой из этих проблем мы разобьём на отдельные блоки кода, каждый из которых будет размещён в собственном файле. В результате BIF-слой клиентской части приложения будет состоять из двух файлов. Кроме того, к ним будет прилагаться файл с тестом.
### ▍Комбинирование обращений к API
Выполнение множества обращения к серверным API в нашем клиентском коде — не такая уж и серьёзная проблема. Однако мне хотелось бы это абстрагировать, сделать так, чтобы можно было бы выполнить единственный «запрос» (от кода приложения к BIF-слою), и получить в ответ именно то, что нужно.
Конечно, в нашем случае от выполнения трёх HTTP-запросов к серверу никуда не деться, но приложению знать об этом необязательно.
API моего BIF-слоя представлено в виде функций. Поэтому, когда приложению нужны какие-то данные о пользователе, оно будет вызывать функцию `getUser()`, которая вернёт ему эти данные. Вот как выглядит эта функция:
```
import parseUserData from './parseUserData';
import fetchJson from './fetchJson';
export const getUser = async () => {
const auth = await fetchJson('/auth');
const [ profile, notifications ] = await Promise.all([
fetchJson(`/profile/${auth.userId}`, auth.jwt),
fetchJson(`/notifications/${auth.userId}`, auth.jwt),
]);
return parseUserData(auth, profile, notifications);
};
```
Здесь сначала выполняется запрос к сервису аутентификации для получения токена, который можно использовать для того, чтобы авторизовать пользователя (не будем тут говорить о механизмах аутентификации, всё же наша основная цель — BIF).
После получения токена можно, одновременно, выполнить два запроса, получающих данные профиля пользователя и сведения о непрочитанных уведомлениях.
Кстати, посмотрите на то, как красиво выглядит конструкция `async/await`, когда с ней работают, используя `Promise.all` и применяют деструктурирующее присваивание.
Итак, это был первый шаг, здесь мы абстрагировались от того, что обращение к серверу включает в себя три запроса. Однако, дело пока ещё не сделано. А именно, обратите внимание на вызов функции `parseUserData()`, которая, как можно судить из её имени, приводит в порядок данные, полученные с сервера. Поговорим о ней.
### ▍Очистка данных
Хочу сразу дать одну рекомендацию, которая, как я полагаю, способна серьёзно повлиять на проект, в котором раньше не было BIF-слоя, в частности — на новый проект. Постарайтесь на какое-то время не думать о том, что именно вы получаете с сервера. Вместо этого сосредоточьтесь на том, какие данные нужны вашему приложению.
Кроме того, лучше всего не пытаться, при проектировании приложения, учитывать его возможные будущие потребности, скажем, относящиеся к 2021 году. Просто постарайтесь сделать так, чтобы сегодня приложение работало именно так, как нужно. Дело в том, что чрезмерное увлечение планированием и попытки предугадать будущее — это главная причина неоправданного усложнения программных проектов.
Итак, вернёмся к нашим делам. Сейчас нам известно, как выглядят данные, получаемые из трёх серверных API, и известно, во что они должны превратиться после разбора.
Похоже, что тут перед нами один из тех редких случаев, когда применение TDD действительно имеет смысл. Поэтому напишем большой длинный тест для функции `parseUserData()`:
```
import parseUserData from './parseUserData';
it('should parse the data', () => {
const authApiData = {
userId: 1234,
jwt: 'the jwt',
};
const profileApiData = {
Profiles: [
{
id: 1234,
Christian_Name: 'David',
Surname: 'Gilbertson',
Photographs: [
{
Size: 'Medium',
URLS: [
'/images/david.png',
],
},
],
Last_Login: '2018-01-01'
},
],
};
const notificationsApiData = {
data: {
'msg-1234': {
timestamp: '1529739612',
user: {
Christian_Name: 'Alice',
Surname: 'Guthbertson',
Enhanced: 'True',
Photographs: [
{
Size: 'Medium',
URLS: [
'/images/alice.png'
]
}
]
},
message_summary: 'Hey I like your hair, it re',
message: 'Hey I like your hair, it really goes nice with your eyes'
},
'msg-5678': {
timestamp: '1529731234',
user: {
Christian_Name: 'Bob',
Surname: 'Smelthsen',
},
message_summary: 'I\'m launching my own cryptocu',
message: 'I\'m launching my own cryptocurrency soon and many thanks for you to look at and talk about'
},
},
};
const parsedData = parseUserData(authApiData, profileApiData, notificationsApiData);
expect(parsedData).toEqual({
jwt: 'the jwt',
id: '1234',
name: 'David Gilbertson',
photoUrl: '/images/david.png',
notifications: [
{
id: 'msg-1234',
dateTime: expect.any(Date),
name: 'Alice Guthbertson',
premiumMember: true,
photoUrl: '/images/alice.png',
message: 'Hey I like your hair, it really goes nice with your eyes'
},
{
id: 'msg-5678',
dateTime: expect.any(Date),
name: 'Bob Smelthsen',
premiumMember: false,
photoUrl: '/images/placeholder.jpg',
message: 'I\'m launching my own cryptocurrency soon and many thanks for you to look at and talk about'
},
],
});
});
```
А вот код самой функции:
```
const getPhotoFromProfile = profile => {
try {
return profile.Photographs[0].URLS[0];
} catch (err) {
return '/images/placeholder.jpg'; // стандартное изображение
}
};
const getFullNameFromProfile = profile => `${profile.Christian_Name} ${profile.Surname}`;
export default function parseUserData(authApiData, profileApiData, notificationsApiData) {
const profile = profileApiData.Profiles[0];
const result = {
jwt: authApiData.jwt,
id: authApiData.userId.toString(), // ID всегда должны иметь строковой тип
name: getFullNameFromProfile(profile),
photoUrl: getPhotoFromProfile(profile),
notifications: [], // Массив с уведомлениями должен присутствовать всегда, даже если он пуст
};
Object.entries(notificationsApiData.data).forEach(([id, notification]) => {
result.notifications.push({
id,
dateTime: new Date(Number(notification.timestamp) * 1000), // дата, полученная с сервера, выражена в секундах, прошедших с начала эпохи Unix, а не в миллисекундах
name: getFullNameFromProfile(notification.user),
photoUrl: getPhotoFromProfile(notification.user),
message: notification.message,
premiumMember: notification.user.Enhanced === 'True',
})
});
return result;
}
```
Мне хотелось бы отметить, что когда удаётся собрать в одном месте две сотни строк кода, ответственных за модификацию данных, разбросанных до этого по всему приложению, это вызывает просто замечательные ощущения. Теперь всё это находится в одном файле, для этого кода написаны модульные тесты, а все неоднозначные моменты снабжены комментариями.
Выше я говорил, что BFF — это мой любимый подход к комбинированию и очистке данных, но есть одна область, в которой BIF превосходит BFF. А именно, данные, пришедшие с сервера, могут включать в себя JavaScript-объекты, которые не поддерживает JSON, вроде объектов типа `Date` или `Map` (пожалуй, это — одна из самых недостаточно используемых возможностей JavaScript). Например, в нашем случае приходится конвертировать дату, пришедшую с сервера (выраженную в секундах, а не в миллисекундах) в JS-объект типа `Date`.
Итоги
-----
Если вам кажется, что у вашего проекта есть что-то общее с тем, на котором мы рассматривали проблемы неудачных API, проанализируйте его код, задавая себе следующие вопросы об использовании на клиенте данных, пришедших с сервера:
* Приходится ли вам объединять свойства, которые никогда не используются раздельно (например, имя и фамилию пользователя)?
* Приходится ли в JS-коде работать с именами свойств, сформированных так, как в JS не принято (нечто вроде PascalCase)?
* Каковы типы данных различных идентификаторов? Может быть, иногда это — строки, иногда — числа?
* Как в вашем проекте представлены даты? Может быть, иногда это — JS-объекты `Date`, готовые к использованию в интерфейсе, а иногда — числа, или даже строки?
* Часто ли приходится проверять свойства на предмет их существования, или проверять, является ли некая сущность массивом, прежде чем начать перебор элементов этой сущности для формирования на её основе какого-нибудь фрагмента пользовательского интерфейса? Может ли случиться так, что эта сущность не будет массивом, хотя бы и пустым?
* Приходится ли, при формировании интерфейса, сортировать или фильтровать массивы, которые, в идеале, должны уже быть правильно отсортированы и отфильтрованы?
* Если оказывается, что, при проверке свойств на предмет их существования, искомых свойств нет, приходится ли переходить к использованию неких значений, применяемых по умолчанию (например — использовать стандартную картинку в тех случаях, когда в данных, полученных с сервера нет фотографии пользователя)?
* Единообразно ли именуются свойства? Случается ли так, что одна и та же сущность может иметь разные имена, что, возможно, вызвано совместным использованием, условно говоря, «старых» и «новых» серверных API?
* Приходится ли, наряду с полезными данными, передавать куда-либо и данные, которые никогда не используются, делая это лишь из-за того что они поступают из серверного API? Мешают ли эти неиспользуемые данные при отладке?
Если вы можете положительно ответить на один-два вопроса из этого списка, то, пожалуй, вам не стоит ремонтировать то, что и так исправно работает.
Однако, если вы, читая эти вопросы, узнаёте в каждом из них проблемы вашего проекта, если устройство вашего кода от всего этого неоправданно усложняется, если его тяжело воспринимать и тестировать, если в нём кроются ошибки, которые сложно обнаруживать — присмотритесь к паттерну BIF.
В итоге хочется сказать, что при внедрении BIF-слоя в существующие приложения дело облегчается благодаря тому, что делать это можно поэтапно, маленькими шагами. Скажем, первая версия функции для подготовки данных, назовём её `parseData()`, может просто, без изменений, возвращать то, что поступает на её вход. Затем можно постепенно перемещать логику из кода, ответственного за формирование пользовательского интерфейса, в эту функцию.
**Уважаемые читатели!** Сталкивались ли вы с проблемами, для решения которых автор этого материала предлагает использовать паттерн BIF?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/416011/ | null | ru | null |
# Не блокчейн
Чуть больше 10 лет назад, 3 января 2009 года был создан genesis block Биткойна. Так началась история блокчейна, обещавшая перевернуть мир, создать новую экономику, сделать существующие банки реликтами прошлого.
10 лет — достаточно долгий срок, чтобы подвести итоги, поговорить почему ничего подобного не произошло и, скорее всего, не произойдет.
Если немного абстрагироваться от технологий, то блокчейн — это распределенный реестр записей (ledger), что-то вроде бухгалтерской книги, которую ведет не одно лицо, а множество. Множество независимых агентов договорились об общих правилах ведения учета: каждый ведет свои записи, записи сравниваются и агенты как-то определяют, какую именно последовательность записей считать правильной.
Очевидно, что если много агентов могут договориться о ведении записей, то ровно те же записи может вести и один агент, централизованно, ни с кем не договариваясь. До создания блокчейна все так и вели реестры — централизованно.
Легко показать, что централизованный реестр вести проще. Если цена централизованной транзакции равна единице, то та же транзакция будет стоить `N + X(N)`, если ее ведут `N` агентов: каждый агент повторяет транзакцию ценою единица `= N`, плюс агентам нужно между собой договориться `=` какая-то положительная функция `X()` от `N`.
Отсюда следует, что распределенная транзакция всегда, без исключений, дороже, чем централизованная:
> `**N + X(N) > 1**`
Это и есть фундаментальная причина того, что блокчейн так и не нашел широкого применения.
### Для чего?
На сегодня существуют три категории применения блокчейна:
1. Совершение незаконных сделок.
Если кому-то нужно совершить незаконную сделку, то по определению закон ее не защищает. Мало того, высока вероятность, что закон будет преследовать участников сделки. Совершение незаконных сделок с централизованным посредником очень опасно и дорого, так как посредник подвергается значительному риску и требует за то значительной платы. Совершение подобных сделок при помощи криптовалюты удобно решает проблему слишком дорогого/невозможного посредника. Несмотря на то, что распределенная сделка при прочих равных дороже централизованной, это все равно лучше, чем риск сесть в тюрьму.
В эту категорию попадают всякие Silk Roads, отмывка денег, обход валютного регулирования. В частности, в этой категории находится наиболее масштабное на сегодня применение криптовалют: вывод денег из Китая. Китайские власти наложили очень жесткие ограничения на вывод капитала из страны. Для того, чтобы эти ограничения обойти, китайцы покупают майнинговые системы и электричество внутри страны за юани, майнят криптовалюту, продают ее за границей за доллары.
2. Законные транзакции — неэффективный/незаконный бизнес.
Блокчейн дороже, чем централизованная транзакция. И, тем не менее, часто его пытаются использовать, несмотря на неэффективность. Так происходит потому, что неэффективность компенсируется иным способом.
Например, [ICO](https://ru.wikipedia.org/wiki/ICO_(%D0%BA%D1%80%D0%B8%D0%BF%D1%82%D0%BE%D0%B2%D0%B0%D0%BB%D1%8E%D1%82%D1%8B)). Бизнес-модель, продвигаемая ICO-компаниями, как правило, не жизнеспособна. Даже в тех редких случаях, когда она работает, ровно тоже самое можно сделать эффективнее без блокчейна. Однако, если бы вместо I**C**O компания попробовала бы выйти на традиционное [I**P**O](https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D0%B2%D0%B8%D1%87%D0%BD%D0%BE%D0%B5_%D0%BF%D1%83%D0%B1%D0%BB%D0%B8%D1%87%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%B5%D0%B4%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5), IPO бы или провалилось вовсе, или смогло бы получить в десятки раз меньше капитала в обмен на значительную часть акций компании. То есть в отличие от IPO, ICO приносило и существенно больше денег и владельцы не теряли контроль над компанией. Почему так? Во-первых, эффект толпы, потому что “блокчейн — это будущее, он перевернет все”. Во-вторых, обходятся требования регулятора рынка ценных бумаг: увеличивается спрос за счет неквалифицированных инвесторов. В-третьих, легко привлекаются криминальные деньги для их отмывки.
И да, в этой категории находится и лично ваше любимое ICO, сами подставьте сюда его название. Подавляющее большинство ICO мало отличается от финансовых пирамид.
В этой же категории находятся попытки компаний типа IBM, Maersk, Сбербанка и т.п. работать над блокчейном. “Блокчейн — это будущее. Мы должны быть на переднем крае его разработки”. По-английски такое поведение называется “fear of missing out” или FMO — страх отстать. Никакой пользы от этих разработок нет вообще. Все, что можно сделать с блокчейном, можно сделать эффективнее без него. “Но как же, – спросите вы. – Это же большие уважаемые компании, наверно они понимают куда тратят свои деньги?” А вот нет. В большой компании существует большая дистанция между людьми, принимающими решения, и людьми, понимающими, что происходит. Первые не обязательно слушают вторых. Кроме того, исполнители могут быть рады получать деньги и делать то, что им скажут, даже если понимают, что занимаются ерундой. Руководство может понимать, что блокчейн не нужен, но при этом все равно тратить на него деньги, исходя из требований совета директоров и риска “ну а вдруг там все-таки что-то есть, а мы отстанем?” ([Пари Паскаля](https://ru.wikipedia.org/wiki/%D0%9F%D0%B0%D1%80%D0%B8_%D0%9F%D0%B0%D1%81%D0%BA%D0%B0%D0%BB%D1%8F)).
3. Продаем кирки и лопаты
По-английски selling picks and shovels. Во времена золотой лихорадки в Калифорнии самые большие деньги заработали не старатели, а продавцы лопат. История повторилась во времена блокчейна — деньги зарабатывают криптовалютные биржи (в том числе на “ой нас обокрали, не виноватые мы”), NVidia, продавцы оборудования для майнинга и т.п. Бизнес вполне здоровый, за исключением случаев откровенного мошенничества, но производный от категорий 1 и 2.
### А как же smart contracts?
Договор нужен для того, чтобы в случае проблем принудить участников сделки к выполнению своих обязательств. Обычные договоры защищены законом: стороны могут быть принуждены всей силой государства. Иными словами, если кто-то отказывается от выполнения условий, он рискует, что к нему в дверь постучат люди с оружием и физической силой лишат нарушителя собственности, свободы или жизни.
Смарт-контракты дают дополнительные возможности только если стороны производят обмен ценностями, полностью представленными в блокчейне, и даже в этом случае только очень ограниченно. Как только ценность выводится из блокчейна, смарт-контракт теряет возможность принудить сторону к выполнению обязательств. Мало того, даже если ценности остаются в блокчейне, возможности отката сделок как мера принуждения может привести к катастрофическому каскаду откатов.
Например, Вася заключил с Колей смарт-контракт, по которому Вася дал Коле в долг 1 ETH на месяц под 10%. В конце месяца смарт-контракт должен списать из Колиного кошелька в Васин 1.1 ETH. Но вот незадача, в Колином кошельке в конце месяца не оказалось 1.1 ETH. Там вообще ничего не оказалось, так как Коля все деньги потратил на крутую космическую станцию в Eve Online и уже ее угробил. Что Вася будет делать со своим смарт-контрактом?
* Он может пойти в обычный не-смарт суд, но зачем тогда смарт-контракт?
* Можно было, конечно, положить деньги в эскроу, но зачем тогда Коле кредит от Васи если он не может деньгами воспользоваться?
* Откатить сделки Коли, чтобы вернуть Васе его 1.1 ETH? С какой стати продавец космической станции должен возвращать деньги, если он выполнил свои обязательства в полном объеме?
* Предположим даже, что Коля потратил 1 ETH полностью внутри блокчейна, но получатели колиных денег тоже совершали транзакции. Васин 1 ETH поучаствовал в 1 млн транзакций за месяц. Вы предлагаете их все откатить?
Практически смарт-контракты применяются только при продаже токенов во время ICO. Для продающей стороны токены не имеют никакой ценности (их инкрементальная цена в точности равна нулю). Продавец не несет никакого риска по сделке, даже в случае ее отката потому что он обменивает товар с нулевой ценность на товар с ненулевой. Обязательства продавца оказываются выполненными в момент доставки не имеющих никакой ценности токенов. Таким образом, риск недоставки токенов исключительно низок и только поэтому контракты там работают.
### Что ваши доллары? Бумажки!
А вот и нет. У фидуциарных денег (фиат-денег или бумажных денег) есть одно принципиальное отличие от криптовалюты: у них есть конечный потребитель. Каждое государство, выпускающее свои деньги, собирает налоги с граждан. Налоги практически везде номинируются в валюте государства. Даже если в стране масштабно используется чужая валюта для транзакций, налоги все равно номинируются в своей валюте, а значит она должна быть куплена как минимум для уплаты налогов. Это и создает конечный спрос на госвалюту, а значит ее стоимость не может упасть до нуля пока государство собирает налоги, даже если в остальном она полностью исключена из оборота.
Что касается долларов, то в США приблизительно четверть ВВП собирается в качестве налогов. Четверть рабочего времени каждого американца принудительно тратится на поддержку государства и доллара. Ничего подобного ни у одной криптовалюты нет.
Количество фидуциарных валют ограничено количеством государств на Земле. Количество криптовалют не ограничено ничем. Каждый житель земли может иметь свою личную криптовалюту. Каждая бактерия, живущая в кишечнике каждого жителя Земли, может иметь свою криптовалюту. Каждый атом, составляющий Землю может иметь свою криптовалюту. Предложение валют ничем не ограничено в принципе. А спрос ограничен объемом экономической деятельности, совершаемой при помощи криптовалют, что, в долгосрочной перспективе сводится к категории 1 — незаконным транзакциям. Неограниченное предложение — ограниченный спрос.
### Прочие мелочи
Забыли пин-код от своего банк-клиента? Не беда, позвонили или сходили в банк, поменяли пинкод. Забыли ключ к своему криптокошельку? Не беда. Позвонили в … Никуда не позвонили. Деньги пропали.
Заключили контракт, написав на бумажке: “Коля должен Васе 100 тыс рублей”. Коля не вернул, Вася пошел в суд и выиграл, получил исполнительный лист и отобрал у Коли его машину. Заключили Вася и Коля смартконтракт на 1 ETH, а дальше смотри выше. Васины деньги пропали.
“Сколько вам будет стоить перевести 2 млн рублей из России в Уганду? А вот если переводить в биткойнах, то это будет стоить всего $10 (ну или около того)”. А вот нет. Вы заплатите $10 за перевод 10 BTC из одного кошелька в другой, но если вы захотите их потратить, то вам нужно будет BTC сконвертировать в нормальные деньги, и тут вы заплатите сильно больше, чем денежный перевод из страны в страну даже через WU.
“[Lightning network](https://ru.wikipedia.org/wiki/Lightning_Network) решит все проблемы”. Да, решит некоторые проблемы, но решение вам не понравится. Помните формулу `N + X(N) > 1`? Так вот Lightning network решает проблемы путем уменьшения `N`. То есть снижает цену транзакции путем уменьшения количества агентов, делая систему менее распределенной. Тогда может быть стоит поступить радикально и уменьшить их до минимально возможного значения — единицы?
### Что ждать от блокчейна в будущем?
В будущем криптовалюта останется, но будет использоваться практически исключительно для совершения незаконных транзакций, то есть категория 1. Биткойн скорее всего не подешевеет до нуля, но количество транзакций будет постепенно снижаться, особенно если в Китае начнутся экономические проблемы и спрос на вывод капитала упадет.
Возможно, кто-то найдет истинно распределенное применение блокчейну. Например, криптовалютный TRON Foundation, недавно купивший компанию BitTorrent Inc (на самом деле называется Rainberry, Inc.), надеется скрестить криптовалютные транзакции с протоколом Битторент. И то, и другое является распределенным, соответственно, может быть что-то интересное из этого получится. Однако, более вероятно, что все выродится в плату криптовалютой за пиратский контент, т.е. снова категория 1. | https://habr.com/ru/post/438104/ | null | ru | null |
# Как сделать костыль для Тинькофф Инвестиций своими руками или уведомления об action required for take profit / stop loss
Есть такой брокер — Тинькофф Банк. И есть проблема в том, что на текущий момент этот брокер не имеет приказов take profit / stop loss. Поэтому, если вы хотите торговать более активно, то вам нужно костылить какое-то временное решение, пока в недрах Тинькоффа программисты разрабатывают киллер фичу take profit/stop loss, и под катом — одно из них.
**update:** 22.03.2019, Брокер выкатил мажорную версию 3.0.0 в Google Play, в которой take profit/stop loss все-таки появились.
Почему я решил написать эту статью здесь? Мне показалось, что Тинькофф Банк и его продукты довольно популярны среди айтишников, и, возможно, у кого-то есть такая же потребность, а желания или времени городить свой велосипед нет. Поэтому делюсь своим.
Для начала — об альтернативных возможностях, предоставляемых собственно Брокером.
Первое, у Тинькоффа есть лимитные заявки, которые появились в феврале 2019 (два года ждали, без шуток!), но они работают в пределах одного дня и что хуже — в небольшом денежном интервале, что на волатильном рынке создает неудобства. Просто нельзя задать значения меньше (больше) определенного порога, рассчитываемого от текущих котировок. Ну и задать больше одной лимитной заявки, вероятно, нельзя (у меня при попытке сохранить первую заявку мобильное приложение всегда крашится, а на сайте такой функциональности нет).
Второе, внутри их мобильного приложения можно подписаться на изменение цены, установив абсолютный порог или порог на изменение в процентах (на увеличение или уменьшение), но вы можете установить один и только один порог на актив.
Логика моего велосипеда проста:
1) у нас есть thresholds (здесь и далее — пороги) для нашей ценной бумаги (актива), на который у нас должно происходить ручное действие take profit / stop loss. Пороги рассчитываем самостоятельно, исходя из цены покупки актива;
2) мы должны парсить откуда-то данные текущей цены актива;
3) посылать себе извещение, если один из порогов был достигнут.
Несмотря на незамысловатое описание, есть нюансы в реализации :)
1) Пока мой портфель состоял из одного актива, пороги прописал прямо в теле скрипта, а поиск бумаги сделан был даже не переменной, а просто магической строчкой. Плохое решение, но для проверки идеи было достаточно. По мере диверсификации портфеля я сделал файл, откуда грузятся ценные бумаги, биржи, на которых они торгуются и значения порогов.
2) Поскольку моим активом была иностранная ценная бумага, которая торгуется на Санкт-Петербургской бирже, то сначала я решил парсить данные с сайта Санкт-Петербургской биржи, со следующей страницы: [spbexchange.ru/ru/market-data/Default.aspx](http://spbexchange.ru/ru/market-data/Default.aspx)
Сортировка на СПб бирже идёт по объему торгов, и моя ценная бумага всегда находилась по первой странице. Работало замечательно, но 8 марта всё сломалось. Почему-то TSLA оказалась аж на 25-ой странице, а их пагинатор грузит данные динамически через JS. Такую проблему можно решить «в лоб»: парсить все страницы, до тех пор, пока не найдем наш актив. Но такой подход не очень эффективен, если считать время выполнения цикла скрипта. Вместо этого я решил добавить парсинг с tradingview.com. Там не нужно лопатить длинные списки на большем количестве страниц. Там у каждого актива есть примерно такая ссылка:
[www.tradingview.com/symbols/NASDAQ-TSLA](https://www.tradingview.com/symbols/NASDAQ-TSLA/)
Мне казалось, что всё должно завестись быстро и просто, но возникла проблема — интересующие меня данные подгружаются через JS и обычный Requests с этим не справился.
У этой проблемы есть три известных мне решения:
PyQT, selenium (webdriver) и расширение Requests-HTML. Поскольку у меня в проекте уже был Requests, было решено использовать его же расширение.
К сожалению, работало это решение не очень стабильно, пришлось поискать варианты решения.
```
session = HTMLSession()
r = session.get(url)
my = r.html.render(timeout=30)
selector = 'span.tv-symbol-header-quote__value.tv-symbol-header-quote__value--large.js-symbol-last'
price = r.html.find(selector)[0].text
r.close()
session.close()
```
Обратите внимание на timeout, а также вызовы метода close(). Их не во всех примерах можно встретить, но с ними работает лучше, чем без них.
3) Регистрируемся на сервисе, который умеет посылать СМСки (sms.ru), берем их API, создаем ключ. До 5 СМСок в сутки — бесплатно. Мне — достаточно.
Ключ выглядит так:
24A41EA5-EEEE-CCCC-5555-094143C2EDDD
а отправка СМС в первых версиях была реализована вот так:
```
def send_message(mymessage):
sms_url = 'https://sms.ru/sms/send?api_id=key&to=number&msg=message&json=1'
sms_url = sms_url.replace('key', mykey)
sms_url = sms_url.replace('number', mynumber)
sms_url = sms_url.replace('message', mymessage)
sms_response = requests.get(sms_url)
```
Во время разработки возник следующей вопрос: а что делать, если мы уже послали пользователю СМС о пересечении порога? Пока проверок никаких не было, оно посылало СМС еще раз. Каждый раз. Довольно быстро «съел» бесплатный лимит и стал думать, что с этим делать. Пришлось добавить счетчик отосланных СМС (sms\_counter), который мы проверяем перед вызовом send\_message.
```
global sms_counter
sms_counter = sms_counter + 1
```
Прицепом пойдет еще один вопрос: отлично, во время торговой сессии мы обрабатываем одно пересечение порога определенным активом, и нас это устраивает. Что делать к следующей торговой сессии? Было решено обнулять счетчик высланных СМС. Вариантов было три: хранить данные в БД (но у меня, на текущей момент, stateless приложение), парсить время/дату или перезапускать скрипт. Пока что я делаю третий вариант, но в перспективе перейду ко второму или к первому варианту.
Сейчас решение уже работоспособно, и его можно скачать с [Гитхаба](https://github.com/Areso/Stock-watcher)
Для пользователей, которые не понимают, что такое Python и как его настраивать, предлагаю попробовать запустить упакованное [решение для Windows](https://github.com/Areso/Stock-watcher/releases/tag/1.0.11)
Планы для дальнейшего развития:
1) парсить дату/время, для обнуления счетчика СМС (вместо перезапуска скрипта);
2) сейчас это stateless приложение, но намереваюсь привинтить БД;
3) после п.2, хочу добавить отслеживание резких скачков увеличение/уменьшение цены, относительно цены закрытия предыдущего дня;
4) расширить «коммуникационные» возможности: больше путей (Telegram, Viber, голосовые звонки, другие варианты) и провайдеров (намерен добавить smsc.ru, так как sms.ru иногда теряет отзывчивость, и, хоть и посылает СМС, но скрипт не выполняется дальше до тех пор, пока мы не получим sms\_response). | https://habr.com/ru/post/442734/ | null | ru | null |
# Динамические Linq-запросы или приручаем деревья выражений
#### Введение
Linq to Entity позволяет очень выразительно со статической проверкой типов писать сложные запросы. Но иногда надо нужно сделать запросы чуть динамичнее. Например, добавить сортировку, когда имя колонки задано строкой.
Т.е. написать что то вроде:
```
var query = from customer in context.Customers
select customer;
//ошибка! не компилируется.
query = query.OrderBy("name");
var data = query.ToList();
```
На помощь в этом случае придет динамическое построение деревьев выражений (expression trees). Правда одних выражений будет недостаточно, потребуется динамически находить и конструировать шаблонные методы. Но и это не так сложно. Подробности ниже.
#### Сортировка запросов linq to entity, когда имя поля задано строкой
Вообще для упорядочивания данных, возвращаемых Linq — запросом, применяются 4 метода:
```
OrderBy
OrderByDescending
ThenBy
ThenByDescending
```
Напишем обобщенный метод, который будет принимать 3 аргумента.
```
public static IOrderedQueryable ApplyOrder(
this IQueryable source,
string property,
string methodName
)
```
Где source — исходный IQueriable, к которому нужно добавить упорядочивание; property – имя свойства, по которому производится сортировка; methodName – название метода упорядочивания из списка выше. Конечно, в боевом коде ApplyOrder сделан приватным, и пользователь имеет дело с методами:
```
OrderBy (this IQueryable source, string property)
OrderByDescending (this IQueryable source, string property)
ThenBy (this IQueryable source, string property)
ThenByDescending (this IQueryable source, string property)
```
Которые устроены тривиально и в итоге вызывают ApplyOrder.
```
public static IOrderedQueryable ApplyOrder(
this IQueryable source,
string property,
string methodName
)
{
//Создаем аргумент лямбда выражения. в данном случае мы формируем лямбду x => x.property, а значит аргумент будет один
var arg = Expression.Parameter(typeof(T), "x");
//Начинаем построение дерева выражения. x => x. Возвращаем переданный аргумент без изменений
Expression expr = arg;
//Второй и последний шаг построения дерева выражения. Обращаемся к свойству property. x => x.property
expr = Expression.Property(expr, property);
//Создаем из дерева выражений лямбду, привязываем к ней аргумент
var lambda = Expression.Lambda(expr, arg);
//Находим в классе Queryable метод с именем methodName. Магия поиска и создания шаблонного метода чуть ниже
var method = typeof(Queryable).GetGenericMethod(
methodName,
//Типы аргументов шаблона метода
new[] { typeof(T), expr.Type },
//Типы параметров метода
new[] { source.GetType(), lambda.GetType() }
);
//Выполняем метод, передавая ему неявный параметр this и лямбду.
//Т.е. выполняем source.OrderBy(x => x.property);
return (IOrderedQueryable)method.Invoke(null, new object[] { source, lambda });
}
```
Комментарии поясняют что происходит. Сначала делается дерево выражений, в котором происходит обращение к сортируемому полю. Затем из дерева выражений создается лямбда. Далее конструируется метод сортировки, способный принять лямбду. И, в конце концов, этот метод динамически запускается на выполнение.
Самым сложным моментом здесь оказывается динамическое создание шаблонного метода, что вынесено в отдельный метод расширения GetGenericMethod.
```
public static MethodInfo GetGenericMethod(
this Type type,
string name,
Type[] genericTypeArgs,
Type[] paramTypes
)
{
var methods =
//выбираем у типа все методы
from abstractGenericMethod in type.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static)
//фильтруем по имени
where abstractGenericMethod.Name == name
//интересуют только generic-методы
where abstractGenericMethod.IsGenericMethod
//выбираем параметры, которые принимает метод
let pa = abstractGenericMethod.GetParameters()
//отбрасываем методы принимающие иное количество параметров
where pa.Length == paramTypes.Length
//создаем конкретный метод, указывая типы шаблона
select abstractGenericMethod.MakeGenericMethod(genericTypeArgs) into concreteGenericMethod
//у созданого метода проверяем типы параметров, чтобы имеющиеся у нас типы могли быть назначены параметрам метода
where concreteGenericMethod.GetParameters().Select(p => p.ParameterType).SequenceEqual(paramTypes, new TestAssignable())
select concreteGenericMethod;
//выбираем первый удовлетворяющий всем условиям метод.
return methods.FirstOrDefault();
}
```
Здесь для метод name создается у класса type, при этом имеется 2 списка типов. Список genericTypeArgs указавает для каких типов должен быть создан универсальный метод, а paramTypes показывает параметры каких типов должен принимать этот метод. Все дело в перегрузке, иногда метод может быть с разными сигнатурами, и нам нужно выбрать правильную. Поиск идет не вполне по правилам c# разрешения перегрузок, лишь принимается во внимание, чтобы можно было присвоить переданные значения аргументам метода. И затем, не долго, думая берется первая удовлетворяющая условиям перегрузка. Сравнение типов на возможность присвоения значения одного типа другому выполняется специальным классом TestAssignable.
```
private class TestAssignable : IEqualityComparer
{
public bool Equals(Type x, Type y)
{
//Если тип значение типа y может использовано в качестве значения типа x, то нас это устраивает
return x.IsAssignableFrom(y);
}
public int GetHashCode(Type obj)
{
return obj.GetHashCode();
}
}
В результате можно писать такой код:
var context = new Models.TestContext();
var query = from customer in context.Customers
select customer;
query = query
.ApplyOrder("name", "OrderBy")
.ApplyOrder("surname", "ThenBy")
.ApplyOrder("id", "ThenByDescending");
var data = query.ToList();
```
Показаный подход с минимальными измнениями можно адаптировать к IEnumerable<> для работы с Linq to objects. | https://habr.com/ru/post/181065/ | null | ru | null |
# Заполнить виджет градиентом, изображением или гифкой с помощью ShaderMask
Один из наиболее популярных способов сделать элемент UI выразительным и аутентичным состоит в том, чтобы заполнить его картинкой, градиентом или анимированной гифкой.
Ниже приведен пример реализации данных эффектов на Flutter. Представленный подход будет работать с любым виджетом на всех поддерживаемых платформах. В качестве примера мы будем заполнять графикой Text.
План
----
Реализация будет идти по сценарию, предложенному командой разработчиков Flutter в серии видео "Widget of the Week".
**Основные шаги для заполнения текста графикой:**
1. Создать TextChild виджет для отображения текста.
2. Создать [Shader](https://api.flutter.dev/flutter/dart-ui/Shader-class.html) с нашей кастомной графикой.
3. Применить Shader к TextChild с помощью [ShaderMask](https://api.flutter.dev/flutter/widgets/ShaderMask-class.html).
```
Widget buildBeautifulText() {
// 1. Create text child
final textChild = TextChild();
// 2. Create shader
final shaderCallback = createShader();
// 3. Apply shader to text child
return ShaderMask(
blendMode: BlendMode.srcIn,
shaderCallback: shaderCallback,
child: textChild,
);
}
```
Кейс 1. Шейдер градиента
------------------------
Заполнить виджет градиентом достаточно легко, и при удачном применении данного эффекта можно получить весьма впечатляющие результаты. Для реализации нам потребуется описать желаемый градиент и попросить его создать шейдер. Полученный шейдер можно сразу применить к дочернему виджету, используя ShaderMask.
```
// Create gradient shader
ShaderCallback gradientShader() {
// Define linear gradient
const gradient = LinearGradient(
colors: [
Colors.red,
Colors.blue,
],
begin: Alignment.topLeft,
end: Alignment.bottomRight,
tileMode: TileMode.mirror,
);
// Create shader
final shaderCallback = gradient.createShader;
return shaderCallback;
}
// Build text with gradient shader
Widget buildBeautifulText() {
// 1. Create text child
final textChild = TextChild();
// 2. Create shader callback
final shaderCallback = gradientShader();
// 3. Apply shader to text child
return ShaderMask(
blendMode: BlendMode.srcIn,
shaderCallback: shaderCallback,
child: textChild,
);
}
```
В примере мы использовали линейный градиент от красного к синему. Процесс можно также повторить с градиентами любого типа ([Linear](https://api.flutter.dev/flutter/painting/LinearGradient-class.html), [Radial](https://api.flutter.dev/flutter/painting/RadialGradient-class.html), [Sweep](https://api.flutter.dev/flutter/painting/SweepGradient-class.html)).
Полный код для данного кейса можно посмотреть и запустить через [DartPad](https://dartpad.dev/3a10925e525aafb17f7675dda73d834a).
Кейс 2. Шейдер изображения
--------------------------
В Flutter есть класс [ImageShader](https://api.flutter.dev/flutter/dart-ui/ImageShader-class.html), который позволяет создавать шейдеры для изображений. Для этого необходимо передать ему *данные изображения*.
**Шаг 1. Создать ImageProvider**
Мы будем использовать [ImageProvider](https://api.flutter.dev/flutter/painting/ImageProvider-class.html), чтобы получить *данные изображения* из любого доступного источника ([сеть](https://api.flutter.dev/flutter/painting/NetworkImage-class.html), [assets](https://api.flutter.dev/flutter/painting/AssetImage-class.html), [файл](https://api.flutter.dev/flutter/painting/FileImage-class.html), [память](https://api.flutter.dev/flutter/painting/MemoryImage-class.html)). ImageProvider поддерживает форматы `JPEG`, `PNG`, `GIF`, `Animated GIF`, `WebP`, `Animated WebP`, `BMP` и `WBMP`.
```
// 1. Create ImageProvider
// JPEG
const jpegProvider = NetworkImage(
'https://picsum.photos/1000',
);
// Animated GIF
const gifProvider = NetworkImage(
'https://media.giphy.com/media/5VKbvrjxpVJCM/giphy.gif',
);
```
**Шаг 2. Создать ImageShader для изображения**
ImageProvider поставляет нам экземпляры класса [Image](https://api.flutter.dev/flutter/dart-ui/Image-class.html) из пакета `dart:ui`, которые мы можем передать в ImageShader, чтобы создать [ShaderCallback](https://api.flutter.dev/flutter/rendering/ShaderCallback.html). Данный колбэк создает шейдер с учетом границ поверхности, к которой он будет применен.
Мы заполним графикой весь прямоугольник. В этом процессе будем использовать преобразования матрицы [Matrix4](https://api.flutter.dev/flutter/vector_math_64/Matrix4-class.html), чтобы изменить размер и отцентровать изображение.
Можно пойти альтернативным путем и вместо изменений матрицы изменить [TileMode](https://api.flutter.dev/flutter/dart-ui/TileMode.html). Режимы `mirror` и `repeat` должны хорошо себя проявить при работе с повторяющимися узорами.
Код этого шага можно изменить, чтобы настроить сочетания Matrix4 и TileMode для реализации своего уникального дизайна.
```
// 2. Create image shader for given Rect size
ShaderCallback createImageShader(ui.Image image) {
shaderCalback(Rect bounds) {
// Calculate scale for X and Y sides
final scaleX = bounds.width / image.width;
final scaleY = bounds.height / image.height;
final scale = max(scaleX, scaleY);
// Calculate offset to center resized image
final scaledImageWidth = image.width * scale;
final sacledImageHeight = image.height * scale;
final offset = Offset(
(scaledImageWidth - bounds.width) / 2,
(sacledImageHeight - bounds.height) / 2,
);
final matrix = Matrix4.identity()
// Scale image
..scale(scale, scale)
// Center horizontally and vertically
..leftTranslate(
-offset.dx,
-offset.dy,
);
// Image shader
return ImageShader(
image,
TileMode.decal,
TileMode.decal,
matrix.storage,
);
}
```
**Шаг 3. Подписаться на ImageStream**
При использовании ImageProvider у нас есть возможность подписаться на [ImageStream](https://api.flutter.dev/flutter/painting/ImageStream-class.html), который отслеживает текущий кадр изображения. Подписка на данный поток позволит нам реагировать на изменения изображения, которые происходят в результате анимаций или изменений исходного ресурса изображения.
Документация Flutter уже содержит [код](https://api.flutter.dev/flutter/painting/ImageProvider-class.html) использования ImageStream в виджете. Нам остается лишь изменить его метод `build` и добавить поле `child` для дочернего виджета.
Добавляем поле `child`:
```
// See MyImage class from Flutter docs
// https://api.flutter.dev/flutter/painting/ImageProvider-class.html
class ImageShaderBuilder extends StatefulWidget {
const ImageShaderBuilder({
super.key,
required this.imageProvider,
// Add child widget
required this.child,
});
// Add child widget
final Widget child;
final ImageProvider imageProvider;
@override
State createState() => \_ImageShaderBuilderState();
}
```
Изменяем метод `build`:
```
// See MyImage class from Flutter docs
// https://api.flutter.dev/flutter/painting/ImageProvider-class.html
class _ImageShaderBuilderState extends State {
// Keep the source code
// Change only build method
@override
Widget build(BuildContext context) {
final image = \_imageInfo?.image;
// No image for shader -> show child
if (image == null) {
return widget.child;
}
final shaderCallback = createImageShader(image);
// Apply shader to the child
return ShaderMask(
blendMode: BlendMode.srcIn,
shaderCallback: shaderCallback,
child: widget.child,
);
}
}
```
**Шаг 4. Использовать шейдер изображения**
Теперь мы можем использовать `ImageShaderBuilder` для реализации ярких и запоминающихся пользовательских интерфейсов.
```
Widget buildBeautifulText() {
// 1. Create text child
const textChild = TextChild();
// 2. Create ImageProvider
const imageProvider = NetworkImage(
'https://media.giphy.com/media/5VKbvrjxpVJCM/giphy.gif',
);
// 3. Apply shader to text child
return const ImageShaderBuilder(
imageProvider: imageProvider,
child: textChild,
);
}
```
Полный код для данного кейса можно посмотреть и запустить через [DartPad](https://dartpad.dev/bd2b5913a16c9aa38ad84d0059806cee).
Заключение
----------
Благодарю за чтение!
Не стесняйтесь писать внизу свои мысли, предложения и пожелания по поводу данной статьи. Я буду рад учесть их в своих следующих публикациях, а также отвечу на любые вопросы в комментариях.
Ставьте лайки, если статья оказалась полезна.
**Об авторе**
* *Имя:* Иван Мосягин ([LinkedIn](https://www.linkedin.com/in/mosivan/))
* *Компания:* Shark Company ([LinkedIn](https://www.linkedin.com/company/sharkcompany/))
* *Должность:* Flutter Developer | https://habr.com/ru/post/703218/ | null | ru | null |
# Соотношение сторон и масштабирование изображений в Image компоненте
Адаптированный переводСогласно правилам Хабра я указал ссылку на оригинальную статью. Но хочу отметить, что данный перевод является адаптацией оригинальной статьи с авторскими изменениями.
Давайте попробуем посмотреть за короткий промежуток времени как работает масштабирование в Image. Для, тем, кто пришел в SwiftUI из UIKit думает что система достаточно простая и все модификаторы понятны, но иногда это работает, не так, как вы ожидаете.
Растяжение изображений
----------------------
Началось это все после pull request коллеги с фиксом бага деформации изображения. Во время ревью кода, я был удивлен, что предыдущая версия кода уже использовала `aspectRatio` и новая версия была странным решением, объединяющим `ZStack` и прочие хаки.
```
Image("otus")
.resizable()
.aspectRatio(2, contentMode: .fill)
```
Проблема в том, что используя aspect ratio в Image и установка ratio — просто некрасиво растягивает изображение и делает использование самого ratio параметра бесполезным.
Забавно, что все поиски, которые дают решение этого самого простого кейса — не объясняют почему так происходит. Примеры решений всегда не содержат `.aspectRatio(contentMode: .fill)` и используют другие комбинации кода для фикса.
Что бы мне хотелось (пользователи UIKit поймут), чтобы существовало поведение аналогичное UIImageView content mode — то есть масштабировало картинку, а не просто растягивало ее. То есть — я хочу использовать `aspectRatio` без указания конкретного числового варианта и получить верное масштабирование.
Собственно это и должно делать `aspectRatio`, подумал я.
Должна существовать комбинация модификаторов, которая без хаков вроде ZStack и прочего дает прелполагемый результат — думал я, но похоже ошибся.
AspectRatio и layout
--------------------
Как и в случае со многими модификаторами в SwiftUI, важно понимать, что они на самом деле не применяют никакого поведения напрямую. Это не похоже на то, что мы говорим «объекту» изображения соблюдать соотношение сторон. Неа! Здесь мы не устанавливаем свойства объекта. Так что не позволяйте своему уму все усложнять и заставлять вас думать так. Это лишь, по сути, желаемое видение результата, а не реальные свойства объекта.
Модификатор `aspectRatio` — это модификатор layout. Это означает, что он принимает участие в процессе компоновки SwiftUI. На самом деле процесс компоновки довольно прост: предложенные размеры идут вниз по иерархии, а уже принятые поднимаются вверх, выполняя позиционирование с ними.
Вооруженный тулзой для анализа SwiftUI компонентов от ребят из [Swift Talk](https://talk.objc.io/) я продебажил поведение модификатора для того, чтобы сложить картинку в голове. Это то, чем я часто занимаюсь, даже если я думаю, что знаю, как все должно работать, я хочу убедиться, что моя модель верна. И я копаю все глубже и глубже, пока не смогу придумать больше вопросов, которые могли бы пошатнуть мою ментальную модель.
Начнем с проблемного примера:
```
Image("otus")
.resizable()
.logSizes("Image")
.aspectRatio(2, contentMode: .fit)
.logSizes("Ratio")
```
Можем наблюдать, как `aspect ratio` получает размер, вычисляет соответствующий размер с учетом соотношения и передает его в Image. Image принимает размер и просто рендерит себя в нем. Если поменяем его на `.fill` поведение останется таким же с разностью в том, что оно будет чуть больше.
Давайте попробуем без числового значения вообще, просто применим `.fill`
```
Image("otus")
.resizable()
.logSizes("Image")
.aspectRatio(contentMode: .fill)
.logSizes("Ratio")
```
Тут изобржение выглдяит вполне корректно, без чрезмерного растягивания (результат зависит от конкретного изображения — можете поэксперементировать — но в целом он приемлим).
Однако давайт посмотрим на лог — это не Image магическим путем (внутри, как UIImageView) не растягивается, оно принимает нужный размер, в котором растягиваться не нужно. Модификатор `aspect ratio` на этот раз выполняет некоторые вычисления, чтобы найти правильный размер, соответствующий алгоритму. И опять же, просто рендерит себя в этом размере, больше ничего.
Теперь оно имеет смысл — подумал я. Модификатор соотношения сторон просто изменяет предлагаемый размер, который передается ниже по иерархии, и изображение просто рендерится в соответствии с этим размером, заполняя все пиксели в этом пространстве, не заботясь о том, приведет ли это к растяжению.
Это объясняет, почему так много примеров предоставляют frame, а не ratio, что противоречит цели динамических пользовательских интерфейсов. Таким образом, решение, предложенное моим коллегой, было правильным: использовать соотношение сторон для вычисления «frame», в который нужно встроить изображение, а затем позволить Image заполнить все пространство.
Несмотря на это, я подумал: «Должен же быть способ сделать это, соединив модификаторы в цепочку!»…
Связывание соотношений сторон во имя справедливости
---------------------------------------------------
Итак, идея заключалась в том, чтобы сохранить `aspect ratio` изображения без определенного числа и использовать другой родительский модификатор для создания правильного размера:
*Я использую квадратное соотношение в качестве примера, потому что оно ясно покажет, что результат неверен, а не квадратен.*
(возьмем другое изображение, более отлчиное от квадрата для яркого примера)
Как видите — не сработало.
Если вы проанализируете логи, вы увидите, как внешний модификатор изменяет размер на квадрат, но внутреннее соотношение затем вычисляет новый размер в соответствии с его правилом заполнения (fill) и используется для вычисления размера изображения. В конце результат тот же, поскольку изображение получает этот «заполненный» кадр.
Теперь вы можете сказать: «Но я указал соотношение сторон 1, почему это не соблюдается?» и ответ снова тот же. Модификатор не делает ничего, кроме уменьшения предлагаемого размера. Представление нижнего члена иерархии может игнорировать это и выбрать другой размер, о котором сообщается выше. А когда система компоновки идет вверх, коррекции нет. Модификатор aspect ratio не заставит сообщаемый размер дочернего элемента быть равным 1.
Вы легко это увидите, если вместо этого воспользуетесь frame:
```
Image("otus2")
.resizable()
.logSizes("Image")
// .aspectRatio(contentMode: .fill)
.frame(width: 100, height: 300)
.logSizes("Inner Ratio")
.aspectRatio(1, contentMode: .fit)
.logSizes("Outer Ratio")
```
Наглядно видно, как frame выбирает размер, игнорируя предлагаемый размер родительского соотношения сторон, и aspect ratio ничего не может с этим поделать. Опять же, предлагаемые размеры уменьшаются, а выбранные окончательные размеры увеличиваются. Ничего более. Неужели так просто.
Простые общие сценарии
----------------------
В качестве примечания давайте посмотрим, почему общие примеры, используемые для обучения соотношению сторон для изображений, работают.
Обычно примеры начинаются с демонстрации того, как изображения растягиваются:
Здесь мы видим, как frame предлагает размер изображения, а Image просто берет его и рендерит сам себя, что приводит к очевидному растяжению.
Тогда предлагаемое решение обычно состоит в том, чтобы просто использовать соотношение сторон без числа, чтобы исправить его:
Это, конечно, исправляет растяжение. Теперь `aspectRatio` исследует изображение, чтобы узнать его соотношение сторон, затем вычисляет правильный размер с учетом ограничений и предлагает это изображению, чтобы просто отображать себя в нем.
Но, конечно, вы фиксируете размеры, что полностью противоречит любому современному, адаптируемому дизайну.
И просто для полноты картинки попробуйте вместо этого использовать `fill`:
Это еще больше все испортит, потому что изображение выходит за границы, вам нужно его обрезать. Попытайтесь разобраться, почему это происходит. Соотношение сторон по‑прежнему проверяет изображение на предмет желаемого соотношения и использует его для расчета правильного размера с помощью алгоритма заполнения, который увеличивает размер. Этот отчет поднимается до тех пор, пока не найдет кадр. Фрейм ничего не может с этим поделать, опять же, процесс компоновки, идущий вверх, сводится только к позиционированию, но он упрям и возвращает размер исправления, который вы ему дали. Это означает, что макет снаружи думает, что это 200, но изображение, отображается намного больше по итогу.
Виноват рендеринг изображения
-----------------------------
К этому моменту я испробовал много комбинаций, но я просто развлекался, учился по пути и подтверждал свою модель: да, но решения на горизонте не было. Все работало как надо. Модификатор соотношения сторон просто предлагает подходящий размер, вот и все.
Проблема здесь в том, что рендеринг изображения довольно простой. Как только вы применяете resizable, это просто означает, что изображение будет отображать все пиксели, заполняя весь заданный ему размер. Это имеет смысл, но раздражает, учитывая обстоятельства. У этого модификатора есть resizingMode, который заставит вас надеяться, что это решение, но нет, он просто переключается между растяжением и мозаикой. Я думаю, что если бы вы могли сказать, что этот режим вписывается (fit) или заполняется (fill), это больше соответствовало бы моим ожиданиям.
Решение первое (не самое оптимальное)
-------------------------------------
Итак, каково решение? К сожалению, нам нужно разбить иерархию на две части.
Сначала создайте `frame`, ограничив размер до определенного желаемого соотношения.
```
Rectangle()
.aspectRatio(2, contentMode: .fit)
```
Затем вставьте изображение в этот frame и используйте другое соотношение сторон, чтобы придать ему нужный размер. Нам также нужно обрезать результат, так как использование заливки приведет к тому, что Image выйдет за границы, как описано выше.
```
Rectangle()
.aspectRatio(2, contentMode: .fit)
.overlay {
Image("otus")
.resizable()
.aspectRatio(contentMode: .fill)
}
.clipped()
```
Поскольку это немного громоздко, я подумал, что было бы неплохо иметь для этого многоразовый модификатор. Но это связано с большим количеством вопросов, связанных с дизайном API, поэтому не стесняйтесь делать то, что больше подходит для вашей кодовой базы. Вот как пример моего решения:
```
extension View {
func framedAspectRatio(
_ ratio: CGFloat? = nil,
contentMode: ContentMode
) -> some View {
Color.clear
.aspectRatio(ratio, contentMode: .fit)
.overlay {
self
.aspectRatio(contentMode: contentMode)
}
.clipped()
}
}
```
С таким расширением итоговый код в принципе не плох:
```
Image("otus")
.resizable()
.framedAspectRatio(2, contentMode: .fill)
```
Лучшее решение с frame
----------------------
На самом деле взгляд в направление - разбить решения на 2 куска был верный изначально, однако разобравшись в работе frame - можно найти лучшее решение:
В документации frame примерно следующее:
*Если в заданном измерении не указано ни минимальное, ни максимальное ограничение, фрейм принимает поведение размера своего дочернего элемента в этом измерении. Если оба ограничения указаны в frame, frame безоговорочно принимает предложенный для нее размер, привязанный к ограничениям.*
Ну это же то, что я хотел!
```
Image("otus")
.resizable()
.aspectRatio(contentMode: .fill)
// this is the magic trick
.frame(
minWidth: 0,
maxWidth: .infinity,
minHeight: 0,
maxHeight: .infinity
)
.aspectRatio(2, contentMode: .fit)
.clipped()
```
Но я должен признать, что потратил несколько часов, пытаясь полностью понять поведение frame. Когда я был счастлив, понимая, что делает передача обоих ограничений, но я пришел в замешательство, потому что, когда я передал только minHeight: 0, поведение все еще было тем, которое я хотел!
Диаграмма с [SwiftUI Lab](https://swiftui-lab.com/frame-behaviors/#altering-behaviors) была очень полезна для понимания документации в наглядной форме, но даже при этом изменение поведения от следования дочернему размеру к предлагаемому размеру немного сбивает с толку. Я понимаю общие случаи, и он всегда делает то, что вы от него ожидаете, но... Мне приходится слишком много думать, меня все еще что-то смущает.
Заключение
----------
Я люблю эти головоломки! Мне нравится углубляться не для того, чтобы найти решение, а для того, чтобы убедиться, что я понимаю, что происходит. В конце пути я буду счастлив укрепить свою мысленную модель того, как все работает, даже если окончательный ответ не очень удовлетворителен.
В конечном счете, я надеюсь, что этот пост послужит не только объяснением такого поведения, но и вдохновит вас на то, чтобы углубиться и убедиться, что вы действительно понимаете, как все работает.
Источники:* [*https://talk.objc.io/episodes/S01E319-inspecting-hstack-layout*](https://talk.objc.io/episodes/S01E319-inspecting-hstack-layout)
* [*https://alejandromp.com/blog/image-aspectratio-without-frames/*](https://alejandromp.com/blog/image-aspectratio-without-frames/)
*Для красивого, функционального и эффективного UI не нужны Autolayout, Xib и сториборды. SwiftUI - современный фреймворк для быстрого создания приложений от Apple. Приглашаю вас на* [*бесплатный урок*](https://otus.pw/Um5p/)*, где покажем и расскажем, как с помощью данной технологии сделать простое приложение для просмотра галереи изображений.*
* [Зарегистрироваться на бесплатный урок](https://otus.pw/Um5p/) | https://habr.com/ru/post/714438/ | null | ru | null |
# ROS: карта глубин на Raspberry Pi «малой кровью»
Если вы используете ROS при создании роботов, то наверняка знаете, что в ней есть поддержка работы со стереокамерами. Можно построить, например, карту глубин видимой части пространства или облако точек. И мне стало интересно, насколько просто будет использовать в ROS стереокамеру StereoPi на базе малины. Раньше я уже убедился, что карта глубин отлично строится силами OpenCV, но вот с ROS никогда дела не имел. И решил попробовать. Я хочу рассказать о моих приключениях в поиске решения.
### 1. Бывает ли вообще ROS на Raspberry Pi?
Сначала я решил узнать, есть ли возможность собрать ROS для Raspberry Pi. Первое, что мне подсказал гугл – это список инструкций по установке разных версий ROS на Raspberry Pi, а именно вот эту страничку [ROS wiki](http://wiki.ros.org/ROSberryPi/Setting%20up%20ROS%20on%20RaspberryPi)
Отлично, уже есть от чего отталкиваться! Я хорошо помнил, сколько занимала сборка OpenCV на Raspberry (примерно часов восемь), поэтому решил поискать готовые образы карточек MicroSD для экономии времени.
### 2. Есть ли готовые образы карточек MicroSD с ROS для Raspberry?
Оказалось, что и этот вопрос решен уже несколькими командами разработчиков. Если не брать разовые сборки энтузиастами, то выделялась парочка образов, которые постоянно обновляются с выходом новых версий ОС и ROS.
Первый вариант – это ROS, установленный на родную ОС Raspbian от команды ROSbots, вот страничка с обновляемой ссылкой на образ: [ready-to-use-image-raspbian-stretch-ros-opencv](https://medium.com/@rosbots/ready-to-use-image-raspbian-stretch-ros-opencv-324d6f8dcd96)
Второй – это [образы от Ubiquiti Robotics на убунте](https://downloads.ubiquityrobotics.com).
Ну что же, второй вопрос тоже был достаточно быстро закрыт. Пора заныривать поглубже.
### 3. Как в ROS устроена работа с камерой Raspberry Pi?
А какие стереокамеры вообще поддерживаются в ROS? Я посмотрел страничку со стереокамерами, для которых заявлено наличие готовых драйвера под ROS, вот эту:
[wiki.ros.org/Sensors](http://wiki.ros.org/Sensors)
Там нашлось два раздела:
***2.3 3D Sensors (range finders & RGB-D cameras)**
**2.5 Cameras***
Оказалось, что в первом разделе указаны не только стереокамеры, но и TOF сенсоры, и сканирующие лидары — в общем всё, что сразу может давать информацию в 3D. А во втором уже идут стереокамеры. Попытка посмотреть драйвера к нескольким стереокамерам радости мне не прибавила, так как намекала на серьезное погружение в код.
Хорошо, отступим на шаг назад. Как идет работа с одной камерой Raspberry Pi в ROS?
Тут меня ждало три приятных сюрприза:
* оказывается, для ROS есть специальная нода ***raspicam\_node*** как раз для работы с камерой Raspberry Pi
* сорсы ноды лежат на гитхабе, код активно поддерживается и хорошо документирован: [github.com/UbiquityRobotics/raspicam\_node](https://github.com/UbiquityRobotics/raspicam_node)
* автор ноды Rohan Agrawal ([@Rohbotics](https://github.com/rohbotics)) работает в компании, которая активно поддерживает один из готовых образов для Raspberry Pi
Я посмотрел гитхабовский репозиторий raspicam\_node и заглянул в issues. Там я нашел открытую issue с ёмким названием «stereo mode» почти семимесячной давности, без ответов и комментариев. Собственно, в ней дальше и развивались все события.
### 4. Хардкор или нет?
Чтобы не задавать детских вопросов авторам я решил посмотреть исходники и оценить, чем грозит добавление стереорежима. Меня больше заинтересовала сишная часть вот тут: [github.com/UbiquityRobotics/raspicam\_node/tree/kinetic/src](https://github.com/UbiquityRobotics/raspicam_node/tree/kinetic/src)
Ну что, ребята написали драйвер погружаясь на уровень MMAL. Я также вспомнил, что исходники по работе малины в стереорежиме тоже открыты (эволюцию можно проследить [вот тут на форуме малины](https://www.raspberrypi.org/forums/viewtopic.php?f=43&t=85012&sid=3ccbc2eceb9cfc2d57ff1fa5be46fb02)), и задача написания полноценного стереодрайвера решаема, но масштабна. Глянув на описание драйверов других камер я понял, что необходимо публиковать не только левую и правую картинки, но и выдавать параметры обеих камер, применять к каждой свои результаты калибровки и делать много других вещей. Это тянуло на эксперименты длиной в месяц-два. Поэтому я решил распараллелить подход, а именно: написать автору вопрос о поддержке стерео, а самому поискать более простое, но работающее решение.
### 5. Диалоги с автором
В ветке про стереорежим на гитхабе я задал вопрос автору, упомянув, что стерео поддерживается малиной аж с 2014 года, и предложил в случае надобности выслать ему отладочную плату для экспериментов. Напомню, что я все еще сомневался в том, что в данном дистрибутиве стерео будет работать как в родном Raspbian.
Rohan ответил на удивление быстро, сообщив, что их дистриб использует малиновое ядро и все должно работать. И попросил проверить это на одной из их сборок.
Малиновое ядро! Ура! Теоретически стереокартинка должна захватываться без танцев с бубном!
Я скачал и развернул их последний образ [по ссылке от Rohan](https://downloads.ubiquityrobotics.com/pi.html) и запустил простенький скрипт на питоне по захвату стереопары. Оно работало!
После этого Rohan написал, что он глянет код драйвера на предмет стереорежима, и написал парочку вопросов. Например, у нас стереорежим выдает одну склеенную картинку, а нам бы надо ее резать на две – левую и правую. И второй вопрос о параметрах калибровки каждой камеры – как с этим быть.
Я сказал, что в качестве первого шага можно брать картинки с камер независимо. Да, они не будут синхронизированы по времени захвата и настройкам (типа яркости-контрастности-баланса белого), но в качестве первого шага это может вполне сойти.
Rohan оперативно [выкатил патч](https://github.com/UbiquityRobotics/raspicam_node/pull/55), позволяющий непосредственно из ROS указывать, с какой из камер брать картинки. Я его проверил – выбор камеры работает, уже отличный результат.
### 6. Неожиданная помощь
И тут в ветке появляется комментарий от юзера Wezzoid. Он рассказал, что делал проект на базе стереокамеры на Pi Compute 3 с использованием малиновой девборды. Его четырехногий шагающий робот трекал положение объекта в пространстве, менял положение камер и держал заданное расстояние до него (проект выложен на hackaday.io [тут](https://hackaday.io/project/159212-augmented-mekamon-robot) ).
И он поделился кодом, в котором он захватывал картинку, резал ее питоновыми средствами пополам и публиколвал как ноды левой и правой камер.
Питон в этих вопросах не очень быстрый товарищ, поэтому он использовал невысокое разрешение 320х240 и хороший лайфхак. Если мы захватываем стереокартинку side-by-sibe (одна камера слева на стереокартинке, вторая справа), то питон должен порезать каждую из 240 строчек пополам. А вот если сделать картинку top-bottom (левая камера – верхняя половина кадра, правая – нижняя), то питон режет массив пополам за одну операцию. Что и было успешно сделано юзером Wezzoid.
Плюс он выложил свой питоновый код на Pastebin, который проделывал эту операцию. Вот он:
**Код Wezzoid по публикации нод двух камер из стереопары**
```
#!/usr/bin/env python
# picamera stereo ROS node using dual CSI Pi CS3 board
# Wes Freeman 2018
# modified from code by Adrian Rosebrock, pyimagesearch.com
# and jensenb, https://gist.github.com/jensenb/7303362
from picamera.array import PiRGBArray
from picamera import PiCamera
import time
import rospy
from sensor_msgs.msg import CameraInfo, Image
import yaml
import io
import signal # for ctrl-C handling
import sys
def parse_calibration_yaml(calib_file):
with file(calib_file, 'r') as f:
params = yaml.load(f)
cam_info = CameraInfo()
cam_info.height = params['image_height']
cam_info.width = params['image_width']
cam_info.distortion_model = params['distortion_model']
cam_info.K = params['camera_matrix']['data']
cam_info.D = params['distortion_coefficients']['data']
cam_info.R = params['rectification_matrix']['data']
cam_info.P = params['projection_matrix']['data']
return cam_info
# cam resolution
res_x = 320 #320 # per camera
res_y = 240 #240
target_FPS = 15
# initialize the camera
print "Init camera..."
camera = PiCamera(stereo_mode = 'top-bottom',stereo_decimate=False)
camera.resolution = (res_x, res_y*2) # top-bottom stereo
camera.framerate = target_FPS
# using several camera options can cause instability, hangs after a while
camera.exposure_mode = 'antishake'
#camera.video_stabilization = True # fussy about res?
stream = io.BytesIO()
# ----------------------------------------------------------
#setup the publishers
print "init publishers"
# queue_size should be roughly equal to FPS or that causes lag?
left_img_pub = rospy.Publisher('left/image_raw', Image, queue_size=1)
right_img_pub = rospy.Publisher('right/image_raw', Image, queue_size=1)
left_cam_pub = rospy.Publisher('left/camera_info', CameraInfo, queue_size=1)
right_cam_pub = rospy.Publisher('right/camera_info', CameraInfo, queue_size=1)
rospy.init_node('stereo_pub')
# init messages
left_img_msg = Image()
left_img_msg.height = res_y
left_img_msg.width = res_x
left_img_msg.step = res_x*3 # bytes per row: pixels * channels * bytes per channel (1 normally)
left_img_msg.encoding = 'rgb8'
left_img_msg.header.frame_id = 'stereo_camera' # TF frame
right_img_msg = Image()
right_img_msg.height = res_y
right_img_msg.width = res_x
right_img_msg.step = res_x*3
right_img_msg.encoding = 'rgb8'
right_img_msg.header.frame_id = 'stereo_camera'
imageBytes = res_x*res_y*3
# parse the left and right camera calibration yaml files
left_cam_info = parse_calibration_yaml('/home/pi/catkin_ws/src/mmstereocam/camera_info/left.yaml')
right_cam_info = parse_calibration_yaml('/home/pi/catkin_ws/src/mmstereocam/camera_info/right.yaml')
# ---------------------------------------------------------------
# this is supposed to shut down gracefully on CTRL-C but doesn't quite work:
def signal_handler(signal, frame):
print 'CTRL-C caught'
print 'closing camera'
camera.close()
time.sleep(1)
print 'camera closed'
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
#-----------------------------------------------------------
print "Setup done, entering main loop"
framecount=0
frametimer=time.time()
toggle = True
# capture frames from the camera
for frame in camera.capture_continuous(stream, format="rgb", use_video_port=True):
framecount +=1
stamp = rospy.Time.now()
left_img_msg.header.stamp = stamp
right_img_msg.header.stamp = stamp
left_cam_info.header.stamp = stamp
right_cam_info.header.stamp = stamp
left_cam_pub.publish(left_cam_info)
right_cam_pub.publish(right_cam_info)
frameBytes = stream.getvalue()
left_img_msg.data = frameBytes[:imageBytes]
right_img_msg.data = frameBytes[imageBytes:]
#publish the image pair
left_img_pub.publish(left_img_msg)
right_img_pub.publish(right_img_msg)
# console info
if time.time() > frametimer +1.0:
if toggle:
indicator = ' o' # just so it's obviously alive if values aren't changing
else:
indicator = ' -'
toggle = not toggle
print 'approx publish rate:', framecount, 'target FPS:', target_FPS, indicator
frametimer=time.time()
framecount=0
# clear the stream ready for next frame
stream.truncate(0)
stream.seek(0)
```
### 7. Запускаем публикацию нод левой и правой камер
При первом запуске код ругнулся, что нету доступа к YML файлам с параметрами камер. Я использовал малиновые камеры V2 и помнил, что на гитхабе в комплекте к ***raspicam\_node*** шли готовые файлики с результатами калибровки для разных моделей камер: [github.com/UbiquityRobotics/raspicam\_node/tree/kinetic/camera\_info](https://github.com/UbiquityRobotics/raspicam_node/tree/kinetic/camera_info)
Я взял один из них, сделал две копии и сохранил с именами left.yml и right.yml, прописав в них разрешение камер из скрипта автора. Вот что получилось для левой камеры:
**left.yml**
```
image_width: 320
image_height: 240
camera_name: left
camera_matrix:
rows: 3
cols: 3
data: [1276.704618338571, 0, 634.8876509199106, 0, 1274.342831275509, 379.8318028940378, 0, 0, 1]
distortion_model: plumb_bob
distortion_coefficients:
rows: 1
cols: 5
data: [0.1465167016954302, -0.2847343180128725, 0.00134017721235817, -0.004309553450829512, 0]
rectification_matrix:
rows: 3
cols: 3
data: [1, 0, 0, 0, 1, 0, 0, 0, 1]
projection_matrix:
rows: 3
cols: 4
data: [1300.127197265625, 0, 630.215390285608, 0, 0, 1300.670166015625, 380.1702884455881, 0, 0, 0, 1, 0]
```
Для правой имя камеры заменено на right, а сам файлик назван right.yml. В остальном файл идентичен.
Так как я не планировал делать сложный проект, я не стал повторять длинные пути автора с вложенными подпапками и просто положил файлики в корень домашней папки рядом с питоновым скриптом. Код успешно стартовал, выводя в консоли статусные сообщения.
Оставалось только посмотреть, что же в итоге публикуется нашими левой и правой камерами. Для этого я запустил rqt\_image\_view. В выпадающем меню появились пункты /left/image\_raw и /right/image\_raw, при выборе которых я видел изображения с левой и правой камер.
Ну что же, эта штука заработала! Теперь самое интересное.
### 8. Смотрим карту глубин.
Для просмотра карты глубин я не стал придумывать свой подход и пошел по классическому [мануалу из ROS по настройке стереопараметров](http://wiki.ros.org/stereo_image_proc/Tutorials/ChoosingGoodStereoParameters).
Оттуда я выяснил, что хорошо бы публиковать обе ноды в определенном namespace, а не в корне как это делал Wezzoid. В итоге старые строчки публикации вида
```
left_img_pub = rospy.Publisher('left/image_raw', Image, queue_size=1)
```
стали выглядеть так:
```
left_img_pub = rospy.Publisher('stereo/right/image_raw', Image, queue_size=1)
```
После этого запускаем ноду обработки стереорежима stereo\_image\_proc:
```
ROS_NAMESPACE=stereo rosrun stereo_image_proc stereo_ige_proc
```
Ну и нам же хочется посмотреть на результат, поэтому стартуем смотрелку:
```
rosrun image_view stereo_view stereo:=/stereo image:=image_rect_color
```
И для настройки параметров карты глубин запускаем утилиту настройки:
```
rosrun rqt_reconfigure rqt_reconfigure
```
В итоге видим картинку, приведенную в самом начале статьи. Вот фрагмент чуть крупнее:
Все файлики я выложил на гитхабе: [github.com/realizator/StereoPi-ROS-depth-map-test](https://github.com/realizator/StereoPi-ROS-depth-map-test)
### 9. Ближайшие планы
После моей публикации результата в дискуссии на гитхабе Rohan написал «Круто! Походу нужно мне забрать свою StereoPi». Мы списались с ним по почте, я отправил ему плату. Надеюсь, что с работающим железом в руках ему будет проще допилить и отладить полноценный стереодрайвер для ROS и Raspberry.
### 10. Итоги
Карту глубин из стереокартинки на малине в ROS можно получить, причем несколькими путями. Выбранный для быстрой проверки путь является не самым оптимальным в плане производительности, но может использоваться в прикладных целях. Прелесть в его простоте и возможности сразу начать эксперименты.
Ну и из забавного: уже после получения результатов я заметил что Wezzoid, предложивший свое решение, и был автором вопроса про публикацию двух стереокартинок. Сам спросил, сам решил. | https://habr.com/ru/post/431092/ | null | ru | null |
# Всепротокольный бот на PHP за 10 минут, или как Microsoft Bot Framework и Azure Functions облегчают нам жизнь
Абсолютно невозможно отрицать, что развитие естественных паттернов в интерфейсах дало фантастический толчок к развитию всей ИТ-индустрии в целом. И речь не только и не столько о голосовых интерфейсах, сколько о повсеместном внедрении жестов, гигантском сдвиге в парадигме мобильных платформ и, конечно, существенных работах в области UI и UX в целом. В то время как индустрия стремится стать все более дружелюбной для все более широких масс людей, обычная и, в определенной степени, рутинная разработка превращается в бесконечные попытки объять необъятное. Если раньше нас в основном заботили уровни абстракции языков и фреймворков, то сейчас перед нами стоят куда более глобальные вопросы. Как найти баланс между сложным и функциональным интерфейсом? Стоит ли начинать новый проект с микросервисов? На эти вопросы я не могу ответить, зато я могу рассказать вам об инструментах, которые уже сейчас существенно облегчают и удешевляют освоение и применение новых технологий и подходов к разработке.
Введение
--------
У чат-ботов длинная и не очень успешная история, но, как и про тач-интерфейсы или нейронные сети, про них можно сказать – всему свое время. В последнем витке истории боты обязаны своей популярностью азиатским мессенджерам и социальным сетям. Получив старт в Азии, они отправились покорять западные социальные сервисы. Те, в свою очередь, наспех состряпав API, стали соревноваться в разнообразии возможностей и размере потенциального заработка на их платформах. Что, превратило жизнь обычных разработчиков, перед которыми встали те же задачи по освоению ботов, но со стороны поставщиков контента и услуг, в сущий кошмар.
Одних только мессенджеров, потенциально выходящих на клиента, можно с тем или иным успехом насчитать с десяток, а ведь есть еще классические СМС, Email и веб-чаты. И все это требует специального подхода, ведь каждый предлагает свой собственный API или SDK. И хорошо бы умудриться покрыть всех одним более или менее консистентным кодом, чтобы не разрабатывать и не поддерживать десяток разных реализаций одного и того же. Бизнес требует не столько качественное покрытие меньших каналов продаж, сколько количественное покрытие большего числа каналов. Даже, если одни каналы приносят больше денег, чем другие. Или, если одни каналы предлагают больше возможностей, чем другие.
Так как же покрыть максимально большее число каналов, не превращая свою работу в бесконечную беготню между разными реализациями одного и того же? Одно из доступных решений — воспользоваться фреймворком. Это, конечно, не решит всех проблем, но сохранит, как минимум, психическое равновесие и, в идеале, деньги заказчика или работодателя.
Microsoft Bot Framework
-----------------------
[Microsoft Bot Framework](https://dev.botframework.com/) был впервые представлен год назад на конференции [Microsoft Build 2016](http://build.microsoft.com/). Однако, он до сих пор находится в стадии Preview, что может создать определенные трудности разного толка с использованием его в больших проектах в текущем виде. По крайней мере, я точно не могу рекомендовать использовать его в продакшн прямо сейчас.
Я не буду рассказывать обо всех возможностях и преимуществах этого фреймворка, вы можете легко узнать об этом из его [документации](https://docs.botframework.com/en-us/) или любой другой [статьи](https://habrahabr.ru/search/?target_type=posts&order_by=relevance&q=Microsoft+Bot+Framework&flow=) о нем. В рамках же этого материала я хочу сделать небольшое погружение в практическую реализацию бота для Microsoft Bot Framework.
Может показаться, что бот – это в принципе сложно, а с незнакомым фреймворком и подавно, но это не так. Как и заявлено в заголовке, реализация самого простого бота с Microsoft Bot Framework займет у вас не более 10-и минут. Примерно столько заняло у меня написание и отладка кода для этой статьи и вдвое больше ушло на поиск подходящего шаблона для его запуска в Azure Functions.
#### Почему PHP?
Я выбрал PHP для этого материала по ряду причин. Во-первых, потому что основное направление моей работы — веб-разработка, а PHP, по крайней мере в России, остается самым популярным языком в этой области. Я думал о том, чтобы включить в пример и код на Python’е, но решил не усложнять и без того раздувшийся материал. Если это будет интересно, можно вынести в отдельную статью. Во-вторых, Microsoft хоть и заявляет, что с Bot Framework можно работать на PHP или Python’е, но фактически старательно игнорирует их, не даёт никакой документации или примеров, нет даже SDK. Все, что есть – это REST API и его документация. Реализация на совести разработчика, который скорее всего проигнорируют плохо документированную для его языка технологию, какой бы чудесной и простой она не была. Примеры на других языках не всегда читаются легко, особенно если они перегружены чуждыми конструкциями, вроде «async/await».
#### Почему Azure Functions?
Я выбрал [Azure Functions](https://azure.microsoft.com/ru-ru/services/functions/), потому что это самый простой и дешевый способ для любого читателя – попробовать и поупражняться с кодом этого примера. Фактически, все, что от вас требуется для запуска полноценного бота из этого материала – это нажать кнопку [«Deploy to Azure»](#deploy2azure) и ввести пару параметров для приложения. Azure сам создаст и сконфигурирует необходимые ресурсы, загрузит код примера из GitHub и установит биллинг таким образом, чтобы вам не пришлось платить за все время работы приложения. Вы будете оплачивать только непосредственные вызовы бота, фактически сообщения, которые он обрабатывает.
Кроме того, если вам интересна тема микросервисов с бессерверной (serverless) архитектурой и вы еще не знакомы с Azure Functions, то это станет для вас отличным поводом для знакомства. Однако, микросервисы и роль Azure Functions в них – это другая тема для другой статьи.
Реализация
----------
Отдельно отмечу, что этот пример намеренно написан самым простым, линейным, хорошо читаемым и наглядным способом. Безусловно, его нельзя применять в качестве рабочего кода. Так как для PHP на данный момент нет никакого SDK, усложнение этого примера классами и отдельными функциями было бы совершенно излишним и только усложнило его читаемость и восприятие.
#### Подготовка
Итак, первое, что вам нужно сделать, это создать самого бота: <https://dev.botframework.com/bots/new>. Придумайте боту имя (Name), описание (Description) и альяс для именования в URL’ах (Bot handle). Учтите, что в отличие от имени и описания, альяс после создания бота изменить нельзя. Оставьте поле «Messaging endpoint» пока пустым, мы заполним его после запуска приложения.
Нажмите кнопку «Manage Microsoft App ID and password», чтобы создать идентификатор и пароль для вашего приложения. ID и пароль нужны для авторизации приложения в качестве бота при отправке сообщений в чат, поэтому сохраните их. Нажмите кнопку «Завершить операцию и вернуться к Bot Framework».
На этом подготовительная часть почти закончена. Ознакомьтесь, подтвердите свое согласие со всеми соглашения и нажмите кнопку «Register». Если все указано верно, вы очень скоро увидите сообщение «Bot created». Номинально, ваш бот готов. Осталось научить его общаться.
#### Код
Первым делом устанавливаем ID и пароль приложения для аутентификации бота. Вы получили их на прошлом шаге. Заодно устанавливаем URL, куда будем обращаться с ними за токеном, авторизующим ответы бота.
```
$client_id = getenv('MicrosoftAppId');
$client_secret = getenv('MicrosoftAppPassword');
$authRequestUrl = 'https://login.microsoftonline.com/common/oauth2/v2.0/token';
```
В этом примере я получаю параметры из переменных окружения, но вы можете установить их напрямую в коде.
```
$client_id = ‘26XXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX’;
$client_secret = ‘CJPXXXXXXXXXXXXXXXXXXXXXXXXXXXX’;
$authRequestUrl = 'https://login.microsoftonline.com/common/oauth2/v2.0/token';
```
Далее читаем тело POST-запроса с сообщением от пользователя и десериализуем его из JSON-формата в массив *$deserializedRequestActivity*.
```
$request = file_get_contents(getenv('req'));
$deserializedRequestActivity = json_decode($request, true);
```
В этом примере я получаю тело запроса из переменной окружения *req*, что преднастроено в биндингах Azure Functions. Вы можете получать тело запроса из потока *php://input*, если не используете Azure Functions.
```
$request = file_get_contents('php://input');
$deserializedRequestActivity = json_decode($request, true);
```
Если *$deserializedRequestActivity* содержит поле *id*, считаем входящий запрос корректным и начинаем обработку. Прежде всего, нужно получить токен для авторизации ответа на сообщение. Токен можно получить через POST-запрос к oAuth сервису Microsoft. Я использую [stream context](http://php.net/manual/en/stream.contexts.php) для запроса только потому, что его реализация выглядит нагляднее, вы можете использовать [CURL](http://php.net/manual/en/book.curl.php).
```
$authRequestOptions = array(
'http' => array(
'header' => "Content-type: application/x-www-form-urlencoded\r\n",
'method' => 'POST',
'content' => http_build_query(
array(
'grant_type' => 'client_credentials',
'client_id' => $client_id, //ID приложения
'client_secret' => $client_secret, //Пароль приложения
'scope' => 'https://graph.microsoft.com/.default'
)
)
)
);
```
Создаем сконфигурированный выше stream context и выполняем из него запрос к oAuth-сервису.
```
$authRequestContext = stream_context_create($authRequestOptions);
$authResult = file_get_contents($authRequestUrl, false, $authRequestContext);
```
Читаем ответ на запрос и десериализуем его в массив *$authData*.
```
$authData = json_decode($authResult, true);
```
Если *$authData* содержит поле *access\_token*, считаем аутентификацию успешной и продолжаем обработку. Определяем, какой тип сообщения мы получили и готовим текст ответа на сообщение в случае, если тип входящего сообщения message. В этом примере мы не будем обрабатывать все прочие типы сообщений, поэтому всем остальным типам просто говорим, что мы не знакомы с ними.
```
switch ((string)$deserializedRequestActivity['type']) {
case 'message':
$message = 'New message is received: ' . (string)$deserializedRequestActivity['text'];
break;
default:
$message = 'Unknown type';
break;
}
```
Теперь, когда мы знаем, что отвечать, формируем массив *$deserializedResponseActivity* с данными ответа, который позже передадим в Microsoft Bot Framework.
```
$deserializedResponseActivity = array(
//Мы отвечаем обычным сообщением
'type' => 'message',
//Текст ответа на сообщение
'text' => $message,
//Говорим, что ответ - это простой текст
'textFormat' => 'plain',
//Устанавливаем локаль ответа
'locale' => 'ru-RU',
//Устанавливаем внутренний ID активности, в контексте которого мы находимся (берем из поля id входящего POST-запроса с сообщением)
'replyToId' => (string)$deserializedRequestActivity['id'],
//Сообщаем id и имя участника чата (берем из полей recipient->id и recipient->name входящего POST-запроса с сообщением, то есть id и name, которым было адресовано входящее сообщение)
'from' => array(
'id' => (string)$deserializedRequestActivity['recipient']['id'],
'name' => (string)$deserializedRequestActivity['recipient']['name']
),
//Устанавливаем id и имя участника чата, к которому обращаемся, он отправил нам входящее сообщение (берем из полей from->id и from->name входящего POST-запроса с сообщением)
'recipient' => array(
'id' => (string)$deserializedRequestActivity['from']['id'],
'name' => (string)$deserializedRequestActivity['from']['name']
),
//Устанавливаем id беседы, в которую мы отвечаем (берем из поля conversation->id входящего POST-запроса с сообщением)
'conversation' => array(
'id' => (string)$deserializedRequestActivity['conversation']['id']
)
);
```
Сформировав ответ, готовимся его отправить, для чего формируем URL, куда и будем его передавать. По сути, URL собирается из параметров входящего POST-запроса и выглядит следующим образом:
`https://*{activity.serviceUrl}*/v3/conversations/*{activity.conversation.id}*/activities/*{activity.id}*`
Где *activity* — это входящий POST-запрос с сообщением, десериализованный ранее в массив *$deserializedRequestActivity*.
Пропускаем *{activity.serviceUrl}* через *rtrim*, чтобы исключить последний закрывающий слеш, потому что иногда он есть, а иногда его нет. Также *{activity.id}* необходимо пропустить через *urlencode*, потому что в нем встречаются специальные символы, которые ломают URL и мешают выполнить запрос.
```
$responseActivityRequestUrl = rtrim($deserializedRequestActivity['serviceUrl'], '/') . '/v3/conversations/' . $deserializedResponseActivity['conversation']['id'] . '/activities/' . urlencode($deserializedResponseActivity['replyToId']);
```
URL готов, теперь готовим POST-запрос к Microsoft Bot Connector API, в котором передадим ответ на входящее сообщение. Первым делом конфигурируем stream context. Я использую [stream context](http://php.net/manual/en/stream.contexts.php) для запроса только потому, что его реализация выглядит нагляднее, вы можете использовать [CURL](http://php.net/manual/en/book.curl.php).
```
$responseActivityRequestOptions = array(
'http' => array(
//Устанавливаем в заголовок POST-запроса данные для авторизации ответа, тип токена (token_type) и сам токен (access_token)
'header' => 'Authorization: ' . $authData['token_type'] . ' ' . $authData['access_token'] . "\r\nContent-type: application/json\r\n",
'method' => 'POST',
//В тело запроса вставляем сериализованный в JSON-формат массив с данными ответа $deserializedResponseActivity
'content' => json_encode($deserializedResponseActivity)
)
);
```
И сразу же его создаем и выполняем из stream context’а сконфигурированный запрос к Microsoft Bot Connector API.
```
$responseActivityRequestContext = stream_context_create($responseActivityRequestOptions);
$responseActivityResult = file_get_contents($responseActivityRequestUrl, false, $responseActivityRequestContext);
```
Готово, пользователь в чате читает наш ответ, а мы пишем в поток STDOUT лог о получении и обработке очередного сообщения.
```
fwrite(STDOUT, 'New message is received: "' . (string)$deserializedRequestActivity['text'] . '"');
```
#### Запуск
Вышеописанный код лежит на [GitHub](https://github.com/denisyfrolov/azure-functions-php-bot/blob/master/messages/run.php), нет никакой необходимости копипастить его отсюда или писать заново. Вы можете развернуть код в своем собственном окружении, либо воспользоваться готовым шаблоном для Azure Functions. Если вы собираетесь разворачивать код в собственном окружение, [жмите сюда](#skipazf), чтобы пропустить часть про Azure Functions.
[](https://portal.azure.com/#create/Microsoft.Template/uri/https%3A%2F%2Fraw.githubusercontent.com%2Fdenisyfrolov%2Fazure-functions-php-bot%2Fmaster%2Fazuredeploy.json)
Чтобы выполнить автоматическое развертывание кода в Azure, просто нажмите кнопку «Deploy to Azure», расположенную чуть выше. Мастер развертывания запросит у вас только «Microsoft App Id» и «Microsoft App Password», смело вводите те, что получили на этапе [подготовки](#preparing). Обязательно измените значение поля «App Name», так как указанное в шаблоне имя уже используется, и развертывание закончится ошибкой, если оставить его как есть. Просто добавьте туда пару случайных цифр. Дополнительно можете выбрать существующую группу ресурсов или создать новую, если хотите. В остальном параметры лучше оставить как есть. Не забудьте ознакомиться и согласиться с условиями, затем жмите «Приобрести».
Последний штрих, нужно взять ссылку на развернувшееся приложение и воткнуть ее в поле «Messaging endpoint» созданного на этапе [подготовки](#preparing) бота.
Дождитесь окончания развертывания приложения и отправляйтесь в группу ресурсов, в которую вы его развернули.
Заходите внутрь инстанса «Службы приложений» с именем только что развернутого приложения.
Слева под именем функции «messages» перейдите в меню «Разработка» и в открывшемся справа окне жмите ссылку «Get Function URL». В попапе будет ссылка следующего вида.
`https://*{имя\_вашего\_приложения}*.azurewebsites.net/api/messages?code=*JqXXXXXXXXXXXXXXX...*`
Параметр *code* защищает ваше приложение от случайных и злонамеренных срабатываний. Не зная этого ключа, нельзя заставить приложение работать, а значит нельзя перегрузить ее запросами и вогнать вас в долги перед Azure. Поэтому постарайтесь никому этот параметр не показывать.
Копируйте ссылку, возвращайтесь в [список ваших ботов](https://dev.botframework.com/bots) на портале фреймворка, оттуда зайдите в редактирование бота и вставьте ее (или аналогичную на скрипт *messages/run.php* из примера, если вы не использовали Azure Functions) в поле «Messaging endpoint».
Проверка и отладка
------------------
Не спешите уходить со страницы управления ботом. Справа вы найдете окошко веб-чата, где можно уже попробовать написать что-нибудь своему новому электронному питомцу.
Если вы развернули код из [шаблона Azure Functions](#deploy2azure), то не пугайтесь, если на ваши первые сообщения ответы придут с некоторой задержкой. Это связано с режимом работы инстанса «Службы приложения». Для снижения ваших затрат на хостинг примера, в шаблоне включен так называемый [«План потребления»](https://docs.microsoft.com/ru-ru/azure/azure-functions/functions-scale), в котором служба потребляет ресурсы по мере необходимости. Проще говоря, она запускается и масштабируется только тогда, когда в этом есть реальная необходимость. Если еще проще, служба будет в состоянии stand by до тех пор, пока ее веб-хук не дернет кто-нибудь, имеющий на это право. Если в процессе выполнения ей не хватит доступных ресурсов, она смаштабируется автоматически. Таким образом, вы сэкономите часы вычисления, но [обратите внимание](https://azure.microsoft.com/ru-ru/pricing/details/functions/), что это не единственный ресурс, который вы оплачиваете. После обработки вызова и по истечении некоторого времени, служба снова «уснет».
Если же вы уже отправили боту несколько сообщений и не получили от него никакого ответа, то перво-наперво [посетите](#deploy2azure) инстанс «Службы приложений». Там находятся журнал вызовов службы (в том числе и с данными из потока STDOUT) и инструмент для тестирования кода.
По умолчанию код будет слинкован с репозиторием примера на GitHub в режиме [непрерывного развертывания](https://docs.microsoft.com/ru-ru/azure/app-service-web/app-service-continuous-deployment). Поэтому в консоли вы увидите предупреждение о доступности кода только для чтения. Чтобы изменить код, вам нужно либо совсем отключить непрерывное развертывание, либо клонировать репозиторий и перелинковать службу на него. И то, и другое можно сделать, если перейти из меню консоли слева в «Параметры приложения-функции» и там нажать на кнопку «Настроить непрерывную интеграцию».
Подключение каналов
-------------------
По умолчанию к боту будут подключены Skype и веб-чат. Дополнительно подключаются как мессенджеры вроде Telegram’а и Slack’а, так и Email или SMS каналы. Есть также REST API интерфейс Direct Line, который позволяет вам использовать свои собственные приложения-чаты или мессенджеры. Настройки всех дополнительных каналов сопровождаются подробной инструкций и, как правило, не вызывают никаких затруднений, поэтому не вижу смысла здесь вдаваться в детали этих процедур.
«Адреса и явки» бота из данного примера:
* [](https://join.skype.com/bot/ad7d6aec-1c3d-4c8e-9d87-5c834056c97e)
* Telegram [@Azure\_Func\_PHP\_Bot](https://telegram.me/Azure_Func_PHP_Bot)
* [веб-чат](https://webchat.botframework.com/embed/phpbot?s=n6j83OK31H0.cwA.AJA.diwP4kkGJgbh9jcLg8Bvcv6XDAMutxAZ82G3Bgxsk8Y)
Заключение
----------
Не секрет, что Microsoft работает над естественными интерфейсами уже очень давно и на данный момент добилась если и не больших, то точно не меньших успехов, чем соратники по цеху. На мой взгляд, этот фреймворк прекрасный тому пример. Он предлагает одно из широчайших покрытий каналов с относительно минимальными трудозатратами. Кроме того, его возможности не сводятся к работе с общими для всех мессенджеров фичами и прямыми чатами. Microsoft Bot Framework позволяет работать с фичами, уникальными для того или иного мессенджера, а также работать в групповых чатах с присущей им логикой. Конечно, он далеко не единственный, и у кого-то может быть другое мнение на этот счет.
Цель этой статьи: показать на примере, как любой веб-разработчик, с правильными инструментами под руками, может уже сейчас без лишних затрат и усилий создать своего первого бота. И я надеюсь, что этого будет достаточно, чтобы вы хотя бы попробовали.
Но этого совершенно точно недостаточно для поручения боту ваших клиентов. Когда мы говорим о естественных интерфейсах, мы подразумеваем не только формат взаимодействия с пользователем, но и то, как это взаимодействие будет им ощущаться, тот самый UX. Как показывает практика, пользователь не очень-то любит общаться с ботами, которые воспринимают только сухие команды и не способны ответить ни на один вопрос. И на эту проблему у Microsoft есть довольно элегантное решение [Microsoft Cognitive Services](https://www.microsoft.com/cognitive-services).
Microsoft Cognitive Services и работа с естественной речью – очень большая и важная часть, которой можно было бы продолжить тему этой статьи. Но, в первую очередь мне хочется услышать, насколько вам это интересно в контексте веб-разработки? Стоит ли из этого делать цикл статей? Примеры на каких языках вам бы хотелось видеть в будущем?
#### Ссылки по теме
* Исходный код примера на [GitHub](https://github.com/denisyfrolov/azure-functions-php-bot)
* Документация [Microsoft Bot Framework](https://docs.botframework.com/en-us/)
* Документация [Azure Functions](https://docs.microsoft.com/ru-ru/azure/azure-functions/)
* [Получить 30 дней бесплатного использования Azure](https://azure.microsoft.com/ru-ru/free/) | https://habr.com/ru/post/325130/ | null | ru | null |
# Очень долгая компиляция проекта .NET Framework под Windows CE и решение.
Если ваш несложный, казалось бы, проект, который вы пишете в MS Visual Studio 2005/2008 под ОС Windows CE собирается очень долго (у меня время сборки было примерно минут 5), то вы пришли по адресу. У меня была такая проблема, но всемогущий гугель меня выручил.
Диагностика
-----------
Выбираем
> `Tools — Options — Projects and Solutions — Build and Run`
В списке `MSBuild project buld output verbosity` выберем `Diagnostic`. Теперь открываем окно output
> `View — Output`
и собираем проект и после долгого ожидания в самом конце огромного лога, который выдал компилятор, видим следующее:````
Task Performance Summary:
0 ms Message 3 calls
0 ms WriteLinesToFile 2 calls
0 ms RemoveDuplicates 3 calls
0 ms FindAppConfigFile 1 calls
0 ms ConvertToAbsolutePath 1 calls
0 ms ReadLinesFromFile 2 calls
0 ms AssignTargetPath 5 calls
0 ms Delete 2 calls
0 ms MakeDir 2 calls
0 ms CreateProperty 1 calls
0 ms GetFrameworkPath 1 calls
10 ms ResolveAssemblyReference 1 calls
10 ms GetDeviceFrameworkPath 1 calls
20 ms AssignCulture 1 calls
30 ms Copy 6 calls
40 ms FindUnderPath 7 calls
60 ms ResolveComReference 1 calls
290 ms CreateCSharpManifestResourceName 1 calls
761 ms GenerateResource 1 calls
2804 ms Csc 1 calls
118073 ms PlatformVerificationTask 1 calls
````Последняя строка просто тихий ужас какой-то, правда? Раскочегариваем гугель и [находим следущее](http://blogs.msdn.com/vsdteam/archive/2006/09/15/756400.aspx). Оказывается, что Platform Verification Task — это специальная процедура, которая проверяет, сможет ли программа, которая только что скомпилировалась, запуститься на всех платформах, на которых есть .NET Framework. В реализации под одну платформу может отсутствовать что-нибудь, что присутствует в реализации под другую.
Решено, отключаем!
------------------
1. Открываем файл
> `%windir%\Microsoft.NET\Framework\v2.0.50727\Microsoft.CompactFramework.Common.Targets`
для редактирования.
2. Если установлен .NET Framework 3.5, то открываем точно такой же файл
> `%windir%\Microsoft.NET\Framework\v3.5\Microsoft.CompactFramework.Common.Targets`
3. Находим строку
> `Name="PlatformVerificationTask">`
и заменяем её на
> `Name="PlatformVerificationTask" Condition="'$(SkipPlatformVerification)' != 'true'">`
4. Теперь заводим новую переменную окружения. Для этого нажимаем волшебное сочетание клавиш `windows+break`. Далее
> `Дополнительно — Переменные среды — Системные переменные — Добавить`
Имя переменной
> `SkipPlatformVerification`
значение
> `true`
Теперь нужно перезайти в систему, а то без этого переменные окружения не обновляются.
Всё! Теперь должно работать быстро.
UPD:
P.S.
По поводу п.4: Обновляются переменные окружения или не обновляются… Тут тайна, покрытая мраком. В одном случае обновилось, в другом — нет. У нас с пользователем [DarkestMaster](https://habrahabr.ru/users/darkestmaster/) чуть ссора на этой почве не произошла, но, вроде бы всё хорошо. | https://habr.com/ru/post/41218/ | null | ru | null |
# Пришло время Java 12! Обзор горячих JEP-ов
Прошло полгода, а значит — [время устанавливать новую Java](https://mail.openjdk.java.net/pipermail/jdk-dev/2019-March/002718.html)! Это был долгий путь, и до конца добрались немногие. Из интересных JEP-ов отвалились [сырые строки](https://openjdk.java.net/jeps/326), а вот об оставшемся мы поговорим под катом.
Как всё происходит
==================
Выпуск новой версии Java проходит согласно новому «ускоренному» релизному циклу длиной примерно в полгода. Точные даты определены на [странице проекта](https://openjdk.java.net/projects/jdk/12/). Для JDK 12 существовало несколько основных фаз:
* 2018/12/13 — Первая фаза замедления (в этот момент делается форк от основной ветки в репозитории);
* 2019/01/17 — Вторая фаза замедления (завершить всё, что только можно);
* 2019/02/07 — Релиз-кандидат (фиксятся только самые важные баги);
* 2019/03/19 — Релиз, General Availability. **< — вы находитесь здесь**
Что нам с этого расписания? Да в сущности, ничего — мы только что пришли к финишу, и барски взираем на любителей легаси с высоты новенькой свеженькой JDK 12.
Баги! Паника! Все на дно!
=========================
Когда выходит новая не-LTS версия, обычно всем глубоко наплевать на новые фичи. Интересней, не развалится ли всё к морским чертям.
Конечно, баги есть, много, но не в JDK 12 :) Судя по джире — всё в норме:
Процитирую запрос, чтобы вы *в точности* понимали, что такое «норма»:
```
project = JDK AND issuetype = Bug AND status in (Open, "In Progress", New) AND priority in (P1) AND (fixVersion in (12) OR fixVersion is EMPTY AND affectedVersion in (12) AND affectedVersion not in regexVersion("11.*", "10.*", "9.*", "8.*", "7.*", "6.*")) AND (labels is EMPTY OR labels not in (jdk12-defer-request, noreg-demo, noreg-doc, noreg-self)) AND (component not in (docs, globalization, infrastructure) OR component = infrastructure AND subcomponent = build) AND reporter != "Shadow Bug" ORDER BY priority, component, subcomponent, assignee
```
Конечно, *вообще* баги имеют место быть, никуда они не денутся в настолько огромном проекте. Утверждается только, что прямо сейчас P1 багов не замечено.
Более формально общение с багами задекларировано в специальном документе, [JEP 3: JDK Release Process](https://openjdk.java.net/jeps/3), владельцем которого является наш бессмертный стюард по неспокойным волнам Java-океана — Марк Рейнхольд.
И в особенности стоит [докопаться абзаца](https://openjdk.java.net/jeps/3#Bug-Deferral-Process), рассказывающего, ~~кто виноват и что делать~~, как переносить тикеты, если к 12 релизу уже не успеть. Надо поставить в багтрекере метку `jdk$N-defer-request` в которой N указывает, с какого именно релиза хочется перенести, и оставить комментарий, первая строка которого — *Deferral Request*. Дальше за ревью всех таких запросов берутся лиды соответствующих областей и проектов.
Проблемы прохождения TCK нельзя проигнорировать подобным образом — гарантируется, что Java остаётся Java, а не чем-то жабообразным. Метка `jdk$N-defer-request label` никуда не исчезает. Интересно, что они делают с людьми, которые нарушают правило неудаления метки — предлагаю скормить морским свинкам.
Тем не менее, таким образом можно посмотреть, сколько багов перенесено на JDK 13. Попробуем такой запрос:
```
project = JDK AND issuetype = Bug AND status in (Open, "In Progress", New) AND (labels in (jdk12-defer-request) AND labels not in (noreg-demo, noreg-doc, noreg-self)) AND (component not in (docs, globalization, infrastructure) OR component = infrastructure AND subcomponent = build) AND reporter != "Shadow Bug" ORDER BY priority, component, subcomponent, assignee
```
Всего 1 штука, [JDK-8216039](https://bugs.openjdk.java.net/browse/JDK-8216039): «TLS with BC and RSASSA-PSS breaks ECDHServerKeyExchange». Негусто. Если этот довод всё ещё не помог, то, как ваш адвокат, рекомендую попробовать успокоительное.
И что же в сухом остатке?
=========================
Ясно, что большинство фичей затрагивает не пользователей (Java-программистов), а разработчиков самого OpenJDK. Поэтому я на всякий случай делю фичи на **внешние** и **внутренние**. Внутренние можно пропустить, но я обижусь, столько текста написал.
**189: [Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)](http://openjdk.java.net/jeps/189)**
**Внешняя фича**. Вкратце, люди не любят, когда Java тормозит, особенно если SLA требует отзывчивости порядка 10-500 миллисекунд. Теперь у нас есть бесплатный низкопаузный GC, который пытается работать ближе к левому краю этого диапазона. Компромисс таков, что мы обмениваем CPU и RAM на уменьшение задержек. Фазы маркировки и уплотнения хипа работают параллельно с живыми тредами приложения. Оставшиеся небольшие паузы связаны с тем, что всё равно надо искать и обновлять корни графа объектов.
Если ничего из сказанного не имеет для вас никакого смысла — не беда, Shenandoah *просто работает*, вне зависимости от понимания или непонимания глубинных процессов.
Работают над ним Алексей Шипилёв, Кристина Флад и Роман Кеннке — нужно сильно постараться, чтобы не знать об этих людях. Если вы в целом понимаете, как работают GC но не представляете, чем там может заниматься разработчик — рекомендую взглянуть на хаброперевод чудесной Лёшиной статьи [«Самодельный сборщик мусора для OpenJDK»](https://habr.com/ru/company/jugru/blog/443250/) или на серию [JVM Anatomy Quarks](https://shipilev.net/jvm/anatomy-quarks/). Это **очень интересно**.
> **Экстремально важно.** Oracle решили не поставлять Sheandoah ни с какой из своих релизных сборок — ни с той, что на jdk.java.net, ни с той, которая на oracle.com. Учитывая, что Shenandoah — одна из важнейших фичей JDK 12, стоит установить какую-то другую официальную сборку, [например, от Azul](https://www.azul.com/downloads/zulu/).
---
**230: [Microbenchmark Suite](http://openjdk.java.net/jeps/230)**
**Внутренняя фича**. Если вы хоть раз пытались писать микробенчмарки, то знаете, что это делается на JMH. JMH — это фреймворк для создания, сборки, запуска и анализа микробенчмарков для Java и других JVM-языков, написанный [сами понимаете кем](https://shipilev.net/) (все совпадения случайны). К сожалению, не всё, что делается в мире "нормальных" приложений можно применить внутри JDK. Например, вряд ли мы когда-то увидим там нормальный код на Spring Framework.
К счастью, начиная с 12 версии можно использовать хотя бы JMH, и уже есть набор тестов, которые на нём написаны. Посмотреть можно в [`jdk/jdk/test/micro/org/openjdk/bench`](https://hg.openjdk.java.net/jdk/jdk12/file/0276cba45aac/test/micro/org/openjdk/bench) (можете в браузере прямо посмотреть, этот путь — ссылка).
Например, вот как выглядит [тест на GC](https://hg.openjdk.java.net/jdk/jdk12/file/0276cba45aac/test/micro/org/openjdk/bench/vm/gc/Alloc.java).
> Напомню что здесь у нас не StackOverflow, и использовать код из копипасты, здесь и далее в статье, запрещено без чтения и соблюдения всех лицензий из [соответствующего файла](https://hg.openjdk.java.net/jdk/jdk12/file/0276cba45aac/test/micro/org/openjdk/bench/vm/gc/Alloc.java) и [проекта OpenJDK](https://hg.openjdk.java.net/jdk/jdk12/file/0276cba45aac) вообще, иначе на каком-нибудь суде у тебя с легкостью отсудят последние носки.
```
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Thread)
public class Alloc {
public static final int LENGTH = 400;
public static final int ARR_LEN = 100;
public int largeLen = 100;
public int smalllen = 6;
@Benchmark
public void testLargeConstArray(Blackhole bh) throws Exception {
int localArrlen = ARR_LEN;
for (int i = 0; i < LENGTH; i++) {
Object[] tmp = new Object[localArrlen];
bh.consume(tmp);
}
}
//...
}
```
---
**[325: Switch Expressions (Preview)](http://openjdk.java.net/jeps/325)**
**Внешняя фича**. Коренным способом изменит ваш подход к написанию бесконечных свичей длиной более двух экранов. Глядите:
### Virgin Java Switch vs ...
```
int dayNum = -1;
switch (day) {
case MONDAY:
case FRIDAY:
case SUNDAY:
dayNum = 6;
break;
case TUESDAY:
dayNum = 7;
break;
case THURSDAY:
case SATURDAY:
dayNum = 8;
break;
case WEDNESDAY:
dayNum = 9;
break;
}
```
**Почему плохо**: много букв, можно пропустить break (особенно, если ты наркоман, или болеешь СДВГ).
### … vs Chad Java Swtich Expression!
```
int dayNum = switch (day) {
case MONDAY -> 0;
case TUESDAY -> 1;
default -> {
int k = day.toString().length();
int result = f(k);
break result;
}
};
```
**Почему хорошо**: мало букв, безопасно, удобно, новая клёвая фича.
**Бонус**: если ты садист, то тебе доставит глубочайшее удовлетворение, как тысячи разработчиков IDE теперь мучаются с поддержкой этой фичи. Да, [lany](https://habr.com/ru/users/lany/), да? ~~Его можно поймать [после доклада 6-ого апреля](https://jpoint.ru/talks/4ltyzdxqzmpeofbgkld7ns/) и мягко попросить выдать все грязные подробности.~~
> **Это preview фича, просто так она не заработает!** При компиляции, в `javac` нужно передать опции командной строки `--enable-preview --release 12`, а для запуска через `java` — один только флаг `--enable-preview`.
---
**334: [JVM Constants API](http://openjdk.java.net/jeps/334)**
**Внутренняя фича**. Разработчикам хочется манипулировать классфайлами. Нужно делать это удобно, и это постановка задачи. По крайней мере, так сказал Брайан Гёц, который владеет этим JEP-ом :-) Всё это часть более масштабного поля брани, но пока не будем углубляться.
В каждом Java-классе есть так называемый "константный пул", где находится свалка либо каких-то значений (вроде стрингов и интов), или рантаймовые сущности вроде классов и методов. Порыться в этой свалке можно с помощью [инструкции ldc](https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-6.html#jvms-6.5.ldc) — "load costant", поэтому всё это барахло называется loadable constants. Есть ещё специальный случай для invokedynamic, но неважно.
Если мы работаем с классфайлами, то хотим удобно моделировать байткодные инструции, и следовательно — loadable constants. Первое желание — просто наделать соответствующих Java-типов, но как представить им "живой" класс, структуру [`CONSTANT_Class_info`](https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-4.html#jvms-4.4.1)? `Class`-объекты зависят от корректности и консистентности загрузки классов, а с загрузкой классов в Java творится адовая вакханалия. Начнём с того, что не все классы можно загрузить в VM, а описывать-то их всё равно надо!
Хотелось бы как-то попроще управлять вещами вроде классов, методов и менее известными зверьми вроде method handles и динамических констант, с учётом всех этих тонкостей.
Это решается введением новых [value-based](https://docs.oracle.com/javase/8/docs/api/java/lang/doc-files/ValueBased.html) типов символических ссылок (в смысле [JVMS 5.1](https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-5.html#jvms-5.1)), каждая из которых описывает какой-то конкретный вид констант. Описывает чисто номинально, в отрыве от загрузки классов или вопросов доступа. Они живут в пакетах вроде `java.lang.invoke.constant` и есть не просят, а на сам патч можно [взглянуть здесь](http://cr.openjdk.java.net/~vromero/constant.api/webrev.04/constants.api.patch).
---
**340: [One AArch64 Port, Not Two](http://openjdk.java.net/jeps/340)**
**Внешняя фича**. Уже в JDK 9 сложилась странная ситуация, когда Oracle и Red Hat одновременно поставили на боевое дежурство свои ARM-порты. И вот мы видим конец истории: 64-битную часть оракловского порта убрали из апстрима.
Можно было бы долго копаться в истории самому, но есть способ лучше. В разработке этого JEP поучаствовала компания [BellSoft](http://bell-sw.com), а её офис расположен в Питере, рядом с бывшим офисом компании Oracle.
Поэтому я сразу обратилился сразу к Алексею Войтылову, CTO компании BellSoft:
> "BellSoft выпускает Liberica JDK, которая, помимо x86 Linux/Windows/Mac и Solaris/SPARC, поддерживает и ARM. Начиная с JDK 9 для ARM мы сфокусировались на улучшении производительности порта AARCH64 для серверных применений и продолжили поддерживать 32-битную часть ARM порта для встраиваемых решений. Таким образом на момент выхода JDK 11 сложилась ситуация, когда 64-битную часть порта от Oracle никто не поддерживал (включая Oracle), и OpenJDK сообщество приняло решение удалить ее, чтобы сфокусироваться на AARCH64 порте. На настоящий момент он более производительный (см, например, [JEP 315](http://openjdk.java.net/jeps/315), который мы заинтегрировали в JDK 11) и, начиная с JDK 12, поддерживает все фичи, присутствовавшие в порте от Oracle (последнюю, Minimal VM, я заинтегрировал в сентябре). Поэтому в JDK 12 я с удовольствием помог Bob Vandette удалить этот рудимент. В итоге OpenJDK сообщество получило один порт на AARCH64 и один порт ARM32, что, безусловно, облегчает их поддержку."
---
**341: [Default CDS Archives](http://openjdk.java.net/jeps/341)**
**Внутренняя фича**. Проблема в том, что при старте Java-приложения загружаются тысячи классов, отчего создаётся ощущение, что Java ощутимо тормозит при старте. Да кому тут врать, это не просто "ощущение" — так оно и есть. Чтобы исправить проблему издревле практикуются различные ритуалы.
Class Data Sharing — это фича, пришедшая к нам [из глубины веков](http://www.oracle.com/technetwork/java/javase/8u40-relnotes-2389089.html), как коммерческая фича из JDK 8 Update 40. Она позволяет упаковать весь этот стартапный мусор в архив какого-то своего формата (вам не нужно знать — какого), после чего скорость запуска приложений возрастает. А через некоторое время появился [JEP 310](https://openjdk.java.net/jeps/310): Application Class-Data Sharing, который позволил обходиться таким же образом не только с системными классами, но и классами приложений.
Для классов JDK это выглядит так. Вначале мы дампим классы командой `java -Xshare:dump`, и потом запускаем приложение, сказав ему использовать этот кэш: `java -Xshare:on -jar app.jar`. Всё, стартап немного улучшился. Вот вы знали об этой фиче? Много кто не знает до сих пор!
Здесь выглядит странно вот что: зачем каждый раз самостоятельно ритуально писать `-Xshare:dump`, если дефолтный результат выполнения этой команды немножко предсказуем ещё на этапе создания дистрибутива JDK? Согласно [документации](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/class-data-sharing.html), если дистрибутив Java 8 устанавливался с помощью инсталлятора, то прямо в момент установки он должен запускать нужные команды за тебя. Типа, инсталлятор тихонечко майнит в уголке. Но зачем? И что делать с дистрибутивом, который распространяется не в виде инсталлятора, а как зипник?
Всё просто: начиная с JDK 12 архив CDS будет генериться создателями дистрибутива, сразу же после линковки. Даже для ночных билдов (при условии что они 64-битные и нативные, не для кросс-компиляции).
Пользователям даже не нужно знать о наличии этой фичи, потому что, начиная с JDK 11, `-Xshare:auto` включена по-умолчанию, и такой архив подхватится автомагически. Таким образом, просто **сам факт обновления на JDK 12 ускоряет запуск приложения!**
---
**344: [Abortable Mixed Collections for G1](http://openjdk.java.net/jeps/344)**
**Внутренняя фича**. Честно говоря, ~~я ничего не понимаю в работе G1~~ объяснение фичей GC дело неблагодарное, т.к. требует понимания деталей его работы и от объясняющего, и от понимающего. Для большинства же людей, GC — это какой-то чёртик из табакерки, которому можно накрутить в случае чего. Поэтому проблему надо объяснить как-то попроще.
**Проблема**: G1 мог бы работать и получше.
Ладно, проблема в том, что GC — это компромисс множества параметров, один из которых — продолжительность паузы. Иногда пауза оказывается слишком долгой, и тогда неплохо иметь возможность её отменить.
Когда такое происходит? G1 действительно анализирует поведение приложения и выбирает фронт работ (выраженный в виде *collection set*) на основе своих умозаключений. Когда объем работ утверждён, G1 берётся собрать все живые объекты в collection set, упрямо и без остановок, за один присест. Иногда это занимает излишне много времени. По сути, это означает, что G1 неправильно посчитал объем работ. Его можно обдурить, внезапно поменяв поведение своего приложения так, что эвристика будет отрабатывать поверх протухших данных, когда в collection set попадет слишком много старых регионов.
Чтобы выйти из положения, G1 был доработан следующим механизмом: если эвристика регулярно выбирает неверный объем работ, G1 переходит на инкрементальную сборку мусора, шаг за шагом, и каждый следующий шаг (если он не влез в целевое время выполнения) можно отменить. Кое-что инкрементально собирать не имеет смысла (молодые регионы), поэтому вся такая работа выделяется в "обязательный" блок, который таки выполняется непрерывно.
Что с этим делать конечному пользователю? Ничего, нужно обновиться на JDK 12, всё станет лучше само собой.
---
**346: [Promptly Return Unused Committed Memory from G1](http://openjdk.java.net/jeps/346)**
**Внутренняя фича**. Проблема в том, что если у нас есть большой хип, который никто активно не использует, кажется справедливым получить всю эту неактивную память назад в операционную систему. До JDK 12 этого, впрочем, не происходило.
Чтобы достигнуть своей цели по допустимой длине паузы, G1 производит набор инкрементальных, параллельных и многоэтапных циклов. В JDK 11 он отдаёт commited-память операционной системе только при full GC, или в ходе фазы параллельной маркировки. Если подключить логирование (-Xloggc:/home/gc.log -XX:+PrintGCDetails -XX:+PrintGCDateStamps), то эта фаза отображается как-то так:
```
8801.974: [G1Ergonomics (Concurrent Cycles) request concurrent cycle initiation, reason: occupancy higher than threshold, occupancy: 12582912000 bytes, allocation request: 0 bytes, threshold: 12562779330 bytes (45.00 %), source: end of GC]
8804.670: [G1Ergonomics (Concurrent Cycles) initiate concurrent cycle, reason: concurrent cycle initiation requested]
8805.612: [GC concurrent-mark-start]
8820.483: [GC concurrent-mark-end, 14.8711620 secs]
```
Забавно то, что G1 как может борется с полными остановками, да и concurrent cycle запускает только при частых аллокациях и забитом хипе. Наша ситуация, когда хип никто не трогает — это нечто прямо противоположное. Ситуации, когда G1 почешется отдать память в операционную систему будут происходить ну очень редко!
Так бы все и забили на эту проблему ("купи ещё больше оперативки, чего как нищеброд!"), если бы не одно но — есть всякие облака и контейнеры, в которых это означает недостаточную утилизацию и потерю серьезных денег. Глядите, какой [крутой доклад](https://www.slideshare.net/jelastic/elastic-jvm-automatic-vertical-scaling-of-the-java-heap), до краёв наполненный болью.
Решением стало научить G1 хорошо вести себя в этом конкретном случае, как уже умеют Шенанда или GenCon из OpenJ9. Нужно определять недостаточную утилизацию хипа и соответственно уменьшать его использование. На каких-то тестах на Томкате это позволило уменьшить расход памяти почти в два раза.
Суть в том, что приложение считается неактивным, или если истёк интервал (в миллисекундах) с последней сборки и нет concurrent cycle, или если `getloadavg()` на периоде в одну минуту показал нагрузку ниже определённого порога. Как только что-то из этого произошло, запускается периодическая сборка мусора — она конечно, не почистит настолько же хорошо, как полная сборка, зато минимально затронет приложение.
Можно повтыкать вот в этот лог:
```
(1) [6.084s][debug][gc,periodic ] Checking for periodic GC.
[6.086s][info ][gc ] GC(13) Pause Young (Concurrent Start) (G1 Periodic Collection) 37M->36M(78M) 1.786ms
(2) [9.087s][debug][gc,periodic ] Checking for periodic GC.
[9.088s][info ][gc ] GC(15) Pause Young (Prepare Mixed) (G1 Periodic Collection) 9M->9M(32M) 0.722ms
(3) [12.089s][debug][gc,periodic ] Checking for periodic GC.
[12.091s][info ][gc ] GC(16) Pause Young (Mixed) (G1 Periodic Collection) 9M->5M(32M) 1.776ms
(4) [15.092s][debug][gc,periodic ] Checking for periodic GC.
[15.097s][info ][gc ] GC(17) Pause Young (Mixed) (G1 Periodic Collection) 5M->1M(32M) 4.142ms
(5) [18.098s][debug][gc,periodic ] Checking for periodic GC.
[18.100s][info ][gc ] GC(18) Pause Young (Concurrent Start) (G1 Periodic Collection) 1M->1M(32M) 1.685ms
(6) [21.101s][debug][gc,periodic ] Checking for periodic GC.
[21.102s][info ][gc ] GC(20) Pause Young (Concurrent Start) (G1 Periodic Collection) 1M->1M(32M) 0.868ms
(7) [24.104s][debug][gc,periodic ] Checking for periodic GC.
[24.104s][info ][gc ] GC(22) Pause Young (Concurrent Start) (G1 Periodic Collection) 1M->1M(32M) 0.778ms
```
Разобрались? Я — нет. В JEP есть и подробный сурдоперевод каждой строчки лога, и как работает алгоритм, и всё остальное.
"Ну и что, зачем я это узнал?" — спросите вы. Теперь у нас появились две дополнительные ручки: `G1PeriodicGCInterval` и `G1PeriodicGCSystemLoadThreshold`, которые можно крутить, когда станет плохо. Плохо ведь точно когда-нибудь станет, это Java, детка!
---
Итоги
=====
В результате у нас на руках крепкий релиз — не революция, но эволюция, сфокусированная на улучшении перформанса. Ровно половина улучшений касаются производительности: три JEP-а про GC и один про CDS, которые обещают включиться сами собой, стоит только обновиться до JDK 12. Кроме того, мы получили одну языковую фичу (switch expressions), два новых инструмента для разработчиков JDK (Constants API и тесты на JMH), и теперь сообщество может лучше сфокусироваться над одним-единственным 64-битным портом на ARM.
В общем, переходите на JDK 12 сейчас, и да пребудет с вами Сила. Она вам понадобится.
> Минутка рекламы. Совсем скоро, 5-6 апреля, пройдёт конференция JPoint, на которой соберётся огромное количество людей, знающих толк в JDK и всевозможных новых фичах. Например, точно будет Саймон Риттер из Азула с докладом [«JDK 12: Pitfalls for the unwary»](https://jpoint.ru/talks/35kmzgw4ds3gyt849hbaeo/?utm_source=habr&utm_medium=444434). Самое правильное место, чтобы обсудить свежий релиз! Подробней о JPoint можно узнать на [официальном сайте](https://jpoint.ru/?utm_source=habr&utm_medium=444434). | https://habr.com/ru/post/444434/ | null | ru | null |
# Создание софтверного движка 2.5D
В настоящее время интерес к софтверным движкам, как из игр Quake, DOOM или Duke Nukem 3D практически нулевой. Однако, эти движки имели своё очарование и мне, например, очень нравится графика именно таких вот движков с нереалистичными текстурами на стенах. Конечно, такие текстуры можно накладывать без фильтрации и в OpenGL, получая такой же уровень графики, но всё же, написать собственный софтверный движок было весьма интересно. Движок уровня Quake я написать в своё время не смог, так как не удалось создать редактор 3D карты – я просто не представлял, как вообще рисовать в 3D карту. Да и с большой вероятность текстурирование в произвольном случае в моём исполнении (без ассемблера) было бы очень медленно. Но движок уровня DOOM мне покорился. Основу такого движка я написал в 2002 году, пользуясь книжкой Шикина и Борескова “Компьютерная графика. Полигональные модели”. На базе того движка используя графику из Doom я написал некое подобие игры под MS-DOS на Watcom C. Несколько лет назад я решил вынуть из той игры код движка и переработать его под мои текущие знания языка Си++ и представления о том, как стоило бы устроить этот движок. Ну и заодно перенести этот движок под Windows и дополнить наклонами головы, как в Blood или Duke Nukem. О том, что в результате получилось, я и написал в этой статье.
Итак, в этой статье я расскажу, как написать движок уровня Duke Nukem 3D, однако, без наклонных поверхностей, которые есть в этой игре. То есть, до движка Build моё творение не дотянуло. Кроме того, представленный движок будет использовать не BSP (как DOOM), а метод порталов. Изначальный мой движок использовал как раз BSP, но, как оказалось, метод порталов работает быстрее. Про BSP же я тоже расскажу и приведу сам движок его использующий.
В движках описываемого типа плоская карта. Это значит, что лабиринт состоит из зон (секторов), которые не могут находиться одна над другой. Сектора для удобства работы с ними мы будем считать выпуклыми многоугольниками.
*Вид лабиринта из редактора карты*
Для каждого сектора задаётся высота пола и потолка, а также стены (сегменты), которые находятся в секторе. Такие сегменты являются сплошной стеной и выводятся при отрисовке от пола до потолка. Между секторами располагаются специальные сегменты – линии раздела. Линии раздела закрывают перепады высот между секторами и, кроме того, являются порталами в другой сектор из выбранного. Следует иметь в виду, что для портального движка внутри сектора сегменты и линии раздела не могут располагаться не выпуклым многоугольником, иначе потребуется упорядочивание сегментов внутри сектора (если этого не сделать, будет неясно, какой сегмент выводить на переднем плане, а какой на заднем). Для BSP-движка это не важно – он сам упорядочивает сегменты на этапе разбиения карты.
Как же работает BSP-движок? Да очень просто. Достаточно взять какой-либо сегмент или линию раздела карты и разрезать ей всё пространство карты (корень дерева) на две половинки, как показано на рисунке — это будет левое и правое поддерево.
*Разбиение карты*
Каждую из этих половинок тоже можно разрезать другой выбранной линией. И так далее, до того момента, когда разбивать будет уже нечего и вы пришли в лист дерева (или вы достигли требуемого качества разбиения – DOOM, например, разбивает, насколько я помню, до выпуклых многоугольников, а я разбиваю до отдельных линий). При таком разрезании из-за ошибок округления сегменты и линии раздела будут разрезаться с ошибками округления, поэтому стоит выбрасывать из списка получающихся фрагментов фрагменты с длиной уровня погрешности. В целом, алгоритм рекурсивный. При выводе же графики достаточно рекурсивно сравнивать положение игрока относительно разбивающих линий и выводить лабиринт от листа (где находится игрок) к корню в обратном порядке. Тем самым вы автоматически получите упорядочение сегментов и линий раздела от игрока в бесконечность. В процессе обработки дерева можно определять видимость поддеревьев, если описать вокруг них прямоугольники и проверять, может видеть игрок эти прямоугольники или нет. Такой приём также ускорит вывод лабиринта.
Портальный движок работает несколько иначе. Прежде всего, он не требует разбиения пространства. Мы просто должны узнать, в каком из секторов находится игрок, и имея список порталов сектора, последовательно переходить из сектора в сектор через эти порталы. Чтобы не крутить по кругу, стоит блокировать порталы, через которые мы уже проходили. Алгоритм такого хождения тоже рекурсивный и тоже в результате мы получаем упорядочивание секторов и сегментов от игрока в бесконечность. Порталы могут быть геометрические (с помощью математики мы отрезаем куски карты, видимые через портал (со всеми ошибками округления в подарок)) и экранные (здесь мы корректируем левую и правую границу зоны вывода картинки на экран). Экранный портал для софтверного движка более предпочтителен, так как очень просто реализуем и работает очень быстро. Единственная непонятная ситуация возможна, когда игрок стоит прямо на портале. В этом случае при отрисовке этого портала границы портала не изменяем, иначе одна из половинок окажется неотрисованной.
*Экранный портал*
Для того, чтобы определить, стоит игрок на портале или нет, воспользуемся уравнением
В этом уравнении портал задаётся прямой с координатами (x1;y1)-(x2;y2), а положение игрока соответствует координатам (x,y). Если в результате расчета значение P окажется в некотором диапазоне (я принял от -10 до +10), то можно считать, что (x,y) находится очень близко к прямой, на которой лежит портал.
Общим в обоих вариантах движков является метод рисования вертикальных и горизонтальных поверхностей. Так как движок у нас типа DOOM, то никаких произвольно ориентированных поверхностей у нас не будет – только вертикальные и горизонтальные. Как их выводить? Допустим, с помощью порталов или BSP-дерева мы получим упорядоченный от игрока в бесконечность набор сегментов и линий раздела. Чтобы находящиеся вдали сегменты не затёрли уже выведенные ближние к игроку, мы будем использовать линии горизонта. Для каждого столбца экрана (размер окна по X зададим макросом WINDOW\_WIDTH) мы зададим две координаты – верхнюю и нижнюю. Итого, нам нужен массив TopLine[WINDOW\_WIDTH] и массив BottomLine[WINDOW\_WIDTH]. Перед выводом сцены нужно инициализировать эти массивы так:
```
for(n=0;n
```
Где WindowHeight – высота окна, а WindowWidth-ширина окна.
Если для какого-либо столбца экрана x при выводе окажется, что TopLine[x]>BottomLine[x], то данный столбец полностью заполнен, и выводить его не требуется.
Сегмент или линия раздела (которая выводится два раза – как верхняя и как нижняя) при выводе всегда отсекаются по линиям горизонта. Текстурируется только та часть, которая находится между линиями горизонта. В промежуток между верхней точкой выводимой линии или сегмента и TopLine[x] выводится текстура потолка, а между BottomLine[x] и нижней точкой текстура пола (разумеется, для верхней линии раздела пол не рисуется, как и для нижней не рисуется потолок).
При выводе сегмента мы должны установить после вывода столбца TopLine[x]>BottomLine[x], так как сегмент закрывает собой всё, что за ним находится.
*Вывод сегмента*
При выводе верхней линии раздела, TopLine[x] переносится в нижнюю точку линии раздела. При выводе нижней линии раздела, BottomLine[x] переносится в верхнюю точку линии раздела.
При построении сцены используется перспективная проекция в соответствии с формулой:
Здесь Z – координата глубины (от игрока), а X и Y – положение объекта относительно игрока.
Перед проецированием отображаемый объект нужно сначала переместить относительно позиции игрока и развернуть на угол зрения:
После разворота и отсечения относительно линии, задающей полуплоскость, на которую смотрит игрок, (в моём случае это (-1;1)-(1;1)) можно выполнять проецирование.
Текстурирование сегментов и линий раздела осуществляется вертикальными линиями столбец за столбцом. При этом используется тот факт, что внутри столбца точки текстуры изменяются линейно, а между столбцами линейно изменяются 1/Z и t/Z (t-значение точки внутри текстуры). Разумеется, при всяких обрезаниях сегментов и линий раздела необходимо корректировать начальную и конечную точку текстуры как внутри столбцов, так и между столбцами.
Текстурирование полов и потолков выполняется уже горизонтальными линиями. Это текстурирование со всей математикой немного сложнее, и подробно рассмотрено в книжке Шикина и Борескова “Компьютерная графика. Полигональные модели” в главе “Текстурирование горизонтальных поверхностей”, поэтому я поленился написать здесь формулы перехода между индексами текстуры при таком текстурировании. Я лучше расскажу о том, чего в книжке Шикина и Борескова нет.
Чтобы верно залить пол или потолок после вывода сегмента/линии раздела нам потребуется такая штука, как таблица VisualPlanes. Дело в том, что стены мы выводим вертикально, а пол/потолок горизонтально. Следовательно, нам нужно сначала вывести стену, а затем уже пол или потолок. Вот для этого и нужна эта таблица. Что она собой представляет?
```
//параметры текстурирования полов и потолков
struct SVisualPlanes
{
long MinX;//минимальная координата X области
long MaxX;//максимальная координата X области
long TopY[WINDOW_WIDTH];//верхняя координата
long BottomY[WINDOW_WIDTH];//нижняя координата
};
```
Такая вот структура описывает всего лишь фрагмент пола (или потолка) от MinX до MaxX с заданной внутри него верхней и нижней координатой столбцов. Выглядит просто и логично, да? Не так просто будет понять, как из этого набора вертикальных столбцов перейти к горизонтальным линиям. Таких таблиц нужно две – для пола и для потолка. В DOOM эти таблицы полов/потолков собираются и объединяются друг с другом (и этим обусловлено ограничение на их количество в одной сцене). Я так не стал делать и использую одни и те же две таблицы пола и потолка, а вывожу пол и потолок сразу после вывода стены. Точки в эти таблицы добавляются вот по каким критериям:
```
//----------------------------------------------------------------------------------------------------
//заполнение линии буфера текстур пола
//----------------------------------------------------------------------------------------------------
void CEngine_Base::DrawFloorLine(long x,long y1,long y2,SVisualPlanes &sVisualPlanes_Bottom)
{
if (y2=WindowHeight) return;
if (y1=WindowHeight) y2=WindowHeight-1;
if (x>sVisualPlanes\_Bottom.MaxX) sVisualPlanes\_Bottom.MaxX=x;
if (xsVisualPlanes\_Bottom.BottomY[x]) sVisualPlanes\_Bottom.BottomY[x]=y2;
}
//----------------------------------------------------------------------------------------------------
//заполнение линии буфера текстур потолка
//----------------------------------------------------------------------------------------------------
void CEngine\_Base::DrawFlowLine(long x,long y1,long y2,SVisualPlanes &sVisualPlanes\_Top)
{
if (y2<0) return;
if (y1>WindowYCenterWithOffset) return;
if (y1<0) y1=0;
if (y2>WindowYCenterWithOffset) y2=WindowYCenterWithOffset;
if (x>sVisualPlanes\_Top.MaxX) sVisualPlanes\_Top.MaxX=x;
if (xsVisualPlanes\_Top.BottomY[x]) sVisualPlanes\_Top.BottomY[x]=y2;
}
```
Здесь x – координата столбца, y1-верхняя точка столбца, y2-нижняя точка столбца, WindowYCenterWithOffset-координата центра экрана (наш движок позволит наклонять голову и тем самым нам вместо истинного центра экрана нужен будет смещённый центр – об этом ниже).
Инициализируются эти таблицы перед каждым выводом стены так:
```
SVisualPlanes sVisualPlanes_Top;
SVisualPlanes sVisualPlanes_Bottom;
sVisualPlanes_Top.MinX=WINDOW_WIDTH-1;
sVisualPlanes_Top.MaxX=0;
sVisualPlanes_Bottom.MinX=WINDOW_WIDTH-1;
sVisualPlanes_Bottom.MaxX=0;
for(n=0;n
```
А вот рисование по таким таблицам выполняется следующим кодом:
```
//----------------------------------------------------------------------------------------------------
//рисование потолков
//----------------------------------------------------------------------------------------------------
void CEngine_Base::DrawFlow(long sector_index,const SVisualPlanes &sVisualPlanes_Top)
{
//параметры сектора
long level=vector_CISectorPtr[sector_index]->GetUp();
long texture=vector_CISectorPtr[sector_index]->GetCTextureFollow_Up_Ptr()->GetCurrentTexture().TextureIndex;
long bright=vector_CISectorPtr[sector_index]->GetLighting();
long z=static_cast((level-PlayerZ)\*(WindowYCenter));
long x1;
long x2;
long x;
long y;
x1=sVisualPlanes\_Top.MinX;
x2=sVisualPlanes\_Top.MaxX;
if (x2y\_bottom)
{
y\_bottom++;
X\_Table[y\_bottom]=x;
}
//если верхняя линия опускается
zd=(WindowYCenterWithOffset-y\_top)+1;
while(y\_topy2)
{
long dist=z/zd;
long scale=dist/zd;
DrawTextureLine(dist,scale,bright,texture,y\_bottom,X\_Table[y\_bottom],x-1);
y\_bottom--;
zd++;
}
}
//заливаем промежуток между top и bottom
long zd=(WindowYCenterWithOffset-y\_top)+1;
for(y=y\_top;y<=y\_bottom;y++,zd--)
{
long dist=z/zd;
long scale=dist/zd;
DrawTextureLine(dist,scale,bright,texture,y,X\_Table[y],x2);
}
}
//----------------------------------------------------------------------------------------------------
//рисование полов
//----------------------------------------------------------------------------------------------------
void CEngine\_Base::DrawFloor(long sector\_index,const SVisualPlanes &sVisualPlanes\_Bottom)
{
//параметры сектора
long level=vector\_CISectorPtr[sector\_index]->GetDown();
long texture=vector\_CISectorPtr[sector\_index]->GetCTextureFollow\_Down\_Ptr()->GetCurrentTexture().TextureIndex;
long bright=vector\_CISectorPtr[sector\_index]->GetLighting();
long z=static\_cast((PlayerZ-level)\*(WindowYCenter));
long x1;
long x2;
long x;
long y;
x1=sVisualPlanes\_Bottom.MinX;
x2=sVisualPlanes\_Bottom.MaxX;
if (x2y\_bottom)
{
y\_bottom++;
X\_Table[y\_bottom]=x;
}
//если верхняя линия опускается
zd=(y\_top-WindowYCenterWithOffset)+1;
while(y\_topy2)
{
long dist=z/zd;
long scale=dist/zd;
DrawTextureLine(dist,scale,bright,texture,y\_bottom,X\_Table[y\_bottom],x-1);
y\_bottom--;
zd--;
}
}
//заливаем промежуток между top и bottom
long zd=(y\_top-WindowYCenterWithOffset)+1;
for(y=y\_top;y<=y\_bottom;y++,zd++)
{
long dist=z/zd;
long scale=dist/zd;
DrawTextureLine(dist,scale,bright,texture,y,X\_Table[y],x2);
}
}
```
Здесь DrawTextureLine рисует одну горизонтальную линию текстуры пола или потолка. При выводе используется буфер начальных координат X для каждой координаты Y: long X\_Table[WINDOW\_HEIGHT].
Сначала в этот буфер мы записываем MinX для первого столбца. Идея тут в том, что при проходе по столбцам мы отслеживаем, как ведёт себя координата Y. Если для левой границы при выводе пола верхняя координата уменьшается, а нижняя увеличивается, мы отмечаем этот факт в буфере начальных координат по X для данных координат Y (X\_Table[y]). Но если изменение Y пойдёт в обратную сторону, значит, мы перешли к “закрыванию” линии и перед закрытием линию нужно текстурировать. Этот фокус работает потому, что мы используем выпуклые сектора. Кстати, при выводе сцены с помощью BSP-дерева, следует помнить, что выводится стена целиком, при этом её части могут быть перекрыты другими стенами (при выводе в этих местах линии горизонта установлены в TopLine[x]>BottomLine[x]), а это значит, что при таких разрывах требуется запускать текстурирование полов и потолков и начинать формировать таблицу VisualPlanes заново. В методе порталов таких проблем нет, там стена всегда отсекается по порталу.
*Текстурирование с помощью VisualPlanes*
В моём движке можно наклонять голову. Это делается сдвигом координат центра экрана на величину, равную тангенсу угла наклона, умноженного на половину высоты экрана. Разумеется, это даёт эффект искажения картинки, столь известный по играм на движке Build.
Также в движке есть освещение. Ну тут совсем всё просто – чем дальше от игрока (координата Z), тем темнее. И для стен и для полов/потолков реализация такого затемнения сложности не представляет.
Ну вот, вроде как и всё.
В [архиве](https://yadi.sk/d/mCN_vdv_3Jir5B) лежит сам движок и редактор карт (пока до конца недоделанный – например, нельзя изменить стартовую позицию игрока). Не пугайтесь, если в исходниках увидите многочисленные сдвиги (>> и <<) – местами я использовал вычисления с фиксированной точкой.
В движке управление – курсор, мышка, ctrl-присесть, F1-F3-смена класса движков (экранный портал, геометрический портал, BSP-дерево), F5-сохранить координаты игрока, F9-восстановить координаты игрока.
Добавил ссылки на github:
[Движок](https://github.com/da-nie/3DEngine-Universal)
[Редактор карт](https://github.com/da-nie/3dEngine-Editor)
[Моя старая игра типа Doom под MS-DOS от 2002 года](https://github.com/da-nie/Doom4) | https://habr.com/ru/post/329972/ | null | ru | null |
# Кеширование данных в LINQ-to-SQL, в т.ч. и NULL
Хочу поделиться с хабрасообществом парочкой классов, которые я использую в своих ASP.NET проектах. Один является обёрткой для объекта Cache, другой содержит расширяющие методы для кеширования результатов запросов LINQ-to-SQL.
Итак, задача: кешировать запросы LINQ-to-SQL.
Что должно быть в результате:
1) расширяющий метод для кеширования коллекции записей (после выполнения ToList())
2) расширяющий метод для кеширования одной записи (FirstOrDefault()),
3) обобщающий метод для работы с кешем, позволяющий доставать записи и приводить к указанному типу
3) возможность кеширования NULL.
Проблемы:
1) невозможно записать NULL в Cache
2) FirstOrDefault() может возвращать не только Nullable типы, но и типы значений (int, double и т.д.)
Итак, напишем класс для работы с кешем:
> `1. public static class CacheStorage
> 2. {
> 3. internal static object Null = new Object();
> 4.
> 5. public static object Get(string index)
> 6. {
> 7. return HttpContext.Current.Cache.Get(index);
> 8. }
> 9.
> 10. public static CacheItem Get(string key)
> 11. {
> 12. CacheItem result = new CacheItem
> 13. {
> 14. Cached = false,
> 15. Item = default(T)
> 16. };
> 17.
> 18. object obj = Get(key);
> 19.
> 20. if (obj != null)
> 21. {
> 22. result.Cached = true;
> 23. result.Item = obj == CacheStorage.Null ? default(T) : (T)obj;
> 24. }
> 25.
> 26. return result;
> 27. }
> 28.
> 29. public static void Put(string key, object value)
> 30. {
> 31. if (value == null)
> 32. {
> 33. value = CacheStorage.Null;
> 34. }
> 35.
> 36. int expirationMinutes = 2;
> 37.
> 38. HttpContext.Current.Cache.Insert(key, value, null, DateTime.Now.AddMinutes(expirationMinutes), TimeSpan.Zero);
> 39. }
> 40. }
> 41.
> 42. public class CacheItem
> 43. {
> 44. public T Item { get; set; }
> 45. public bool Cached { get; set; }
> 46. }
> \* This source code was highlighted with Source Code Highlighter.`
Самые простые методы — получение данных из кеша и запись:
> `1. public static object Get(string index)
> 2. {
> 3. return HttpContext.Current.Cache.Get(index);
> 4. }
> 5.
> 6. public static void Put(string key, object value)
> 7. {
> 8. if (value == null)
> 9. {
> 10. value = CacheStorage.Null;
> 11. }
> 12.
> 13. int expirationMinutes = 2;
> 14.
> 15. HttpContext.Current.Cache.Insert(key, value, null, DateTime.Now.AddMinutes(expirationMinutes), TimeSpan.Zero);
> 16. }
> \* This source code was highlighted with Source Code Highlighter.`
Метод записи, конечно, требует доработки для вашего приложения, т.к. я его максимально успростил (настройки нужно вынести в конфигурацию, сделать поддержку различных политик кеширования). Наверное, вы заметили, что в методе Put есть условие, проверяющее на null значение, которое мы хотим поместить в кеш. При выполнении такого условия, подменяем это значение на заглушку,
> `1. internal static object Null = new Object();
> \* This source code was highlighted with Source Code Highlighter.`
которая не null, но в нашем контексте как-бы null :)
Интереснее выглядит обобщающий метод для получения данных из кеша. Он возвращает не просто объект нужного нам типа, а объект CacheItem, в котором содержатся, собственно, возвращаемое значение и признак кеширования:
> `1. public static CacheItem Get(string key)
> 2. {
> 3. CacheItem result = new CacheItem
> 4. {
> 5. Cached = false,
> 6. Item = default(T)
> 7. };
> 8.
> 9. object obj = Get(key);
> 10.
> 11. if (obj != null)
> 12. {
> 13. result.Cached = true;
> 14. result.Item = obj == CacheStorage.Null ? default(T) : (T)obj;
> 15. }
> 16.
> 17. return result;
> 18. }
> \* This source code was highlighted with Source Code Highlighter.`
где CacheItem это
> `1. public class CacheItem
> 2. {
> 3. public T Item { get; set; }
> 4. public bool Cached { get; set; }
> 5. }
> \* This source code was highlighted with Source Code Highlighter.`
Т.е., если в кеше находится null, то мы возвращаем признак кеширования false, а объект возвращаем как значение по умолчанию (default(T)). Если в кеше не null, то признак кеширования будет true, а объект будет по умолчанию, если в кеше хранится наша null-заглушка, либо приведённый к нужному типу объект.
В общем, как-то мудрёно описал работу, в коде, думаю, проще разобраться.
Теперь класс с методами для кеширования запросов LINQ-to-SQL:
> `1. public static class QueryResultCache
> 2. {
> \* This source code was highlighted with Source Code Highlighter.`
Первый метод кеширует вызов ToList():
> `1. public static List FromCache(this IQueryable query,
> 2. params object[] parameters)
> 3. {
> 4. string key = QueryResultCache.GetKey(parameters);
> 5.
> 6. List result = CacheStorage.Get(key) as List;
> 7.
> 8. if (result == null)
> 9. {
> 10. result = query.ToList();
> 11. CacheStorage.Put(key, result);
> 12. }
> 13.
> 14. return result;
> 15. }
> \* This source code was highlighted with Source Code Highlighter.`
Второй метод кеширует вызов FirstOrDefault():
> `1. public static T FirstOrDefaultFromCache(this IQueryable query,
> 2. params object[] parameters)
> 3. {
> 4. string key = QueryResultCache.GetKey(parameters);
> 5.
> 6. CacheItem result = CacheStorage.Get(key);
> 7.
> 8. if (!result.Cached)
> 9. {
> 10. result.Item = query.FirstOrDefault();
> 11. CacheStorage.Put(key, result.Item);
> 12. }
> 13.
> 14. return result.Item;
> 15. }
> \* This source code was highlighted with Source Code Highlighter.`
В этом методе как раз и используется шаманство с классом CacheItem (прим.: для ToList() это не нужно, т.к. данный метод возвращает всегда коллекцию; в случае отсутствия данных она будет нулевой длины)
Для размещения в кеше нужен уникальный ключ, который можно сгенерить в MD5, например, склеив параметры, переданные в кеширующий метод:
> `1. private static string GetKey(object[] parameters)
> 2. {
> 3. return GetMD5(string.Join(string.Empty, parameters.Select(x => x.ToString()).ToArray()));
> 4. }
> 5.
> 6. private static string GetMD5(string input)
> 7. {
> 8. MD5 md5Hasher = MD5.Create();
> 9.
> 10. byte[] data = md5Hasher.ComputeHash(Encoding.Default.GetBytes(input));
> 11.
> 12. StringBuilder sBuilder = new StringBuilder();
> 13.
> 14. for (int i = 0; i < data.Length; i++)
> 15. {
> 16. sBuilder.Append(data[i].ToString("x2"));
> 17. }
> 18.
> 19. return sBuilder.ToString();
> 20. }
> 21. }
> \* This source code was highlighted with Source Code Highlighter.`
Теперь можно попробовать эти классы в действии. Создадим простенькое приложение, и закешируем List, string и int значения. Запускаем SQL-профайлер и видим, что в течение 2-х минут SQL-сервер отдыхает.
Все исходники доступны [здесь](http://podelki.milovanov.info/linqcache.zip) (.net 4.0, в web.config нужно прописать свою connectionString. SQL для создания базы находится в файле DB.sql).
Замечания и критика приветствуется. | https://habr.com/ru/post/106958/ | null | ru | null |
# React, AbortController и асинхронные onClick вызовы
Добрый день, читатели Хабра, представляю вашему вниманию перевод статьи [**React, Abort Controller and onClick async calls**](https://medium.com/@cis.bart/react-abort-controller-and-onclick-async-calls-aa4776772262)**.**
Что такое Abort Controller в JavaScript Web Apps, как его использовать в React для прерывания асинхронных вызовов? Теория и некоторые примеры использования.
### Что в статье?
В самом начале мы поговорим о **базовой теории** **асинхронных функций** в JavaScript и о том, как они работают.
Затем немного об Abort Controller и о том, зачем его вообще использовать?
По окончании введения я покажу **два варианта использования** в React: первый - когда **получаете данные при монтировании компонента**, а второй - для **асинхронных запросов, вызываемых пользовательским действием**, например, onClick.
**Обзор статьи:**
1. Асинхронные (async) и синхронные (sync) функции, Fetch API и AbortController
2. Жизненный цикл компонента в React и зачем нужно "прибираться" перед размонтированием компонента
3. Отмена асинхронного сигнала для событий, вызванных монтированием компонента
4. Отмена асинхронного сигнала для событий, вызванных взаимодействием с пользователем
5. Некоторые мысли и репозиторий с кодом
Асинхронные (async) и синхронные (sync) функции и AbortController
-----------------------------------------------------------------
Как вы, вероятно, знаете, JavaScript поддерживает особый вид программирования - асинхронное программирование. Если по какой-то причине вы до сих пор не знаете об этом, вернитесь к этой статье через некоторое время :)
**Асинхронное** программирование использует такой синтаксис, как **async-await** или **then**, и основная причина, по которой нужно его использовать - это взаимодействие с сервером, на котором хранятся данные, которые мы хотим отображать в приложении.
### Синхронные функции
Прежде чем перейти к асинхронным функциям, несколько слов о синхронных :)
**JavaScript** является [однопоточным](https://dev.to/steelvoltage/if-javascript-is-single-threaded-how-is-it-asynchronous-56gd) языком программирования, что в основном означает, что он **выполняет только одну функцию за раз**.
Все функции в вашем приложении помещаются в специальную очередь, которая называется [callstack](https://developer.mozilla.org/en-US/docs/Glossary/Call_stack), и во время фазы выполнения функции удаляются из callstack после завершения. Вот что значит синхронный.
### Асинхронные функции
**Проблема синхронного подхода** заключается в том, что иногда мы хотим, например, **отправить запрос в API** и можем ждать (неизвестно сколько времени), прежде чем получим ответ от сервера. Поскольку мы ждем, **функция не завершается**, поэтому наш **стек вызовов блокируется**. Вот почему асинхронное программирование — очень полезная штука :)
В качестве ответа на этот вызов [Web API](https://stackoverflow.com/questions/37643506/what-is-the-difference-between-a-web-application-and-web-api/37643591) имеет специальные **методы**/интерфейсы, **которые способны взять под контроль асинхронные операции**. Это означает, что пользовательский агент - браузер разблокирует обратный вызов, чтобы можно было выполнить другие действия. Затем, когда любые данные возвращаются с сервера, он возвращает ответ в наш callstack в качестве **функции обратного вызова (колбэка)**.
### Fetch API
Одним из интерфейсов, используемых для связи с API сервера, является [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API). У него есть как минимум одна замечательная особенность - он может использовать **AbortController**. Использование метода fetch в вашем приложении указывает браузеру, что он должен **использовать Fetch API.**
### AbortController
[AbortController](https://developer.mozilla.org/en-US/docs/Web/API/AbortController) - это специальный объект, который содержит свойство **signal**. Это свойство можно добавить к асинхронной функции, используя fetch в качестве одной из [опций](https://developer.mozilla.org/en-US/docs/Web/API/fetch). Это связывает определенный сигнал с определенной функцией. Но зачем это делать?
Еще одним методом AbortController является **abort()**, который способен **отменить выполнение функции**. Это означает, что если сервер отвечает, браузер проигнорирует этот ответ, и он **не будет передавать колбэк в наш стек вызовов**. Хорошо, но как это можно использовать?
Жизненный цикл компонента в React и зачем "прибираться" перед размонтированием компонента?
------------------------------------------------------------------------------------------
Все (?) современные JavaScript фреймворки и библиотеки **основаны на компонентах**. Компоненты - это многократно используемые элементы, которые могут быть использованы в любой части приложения (при условии, что они построены таким образом). Можно легко сказать, что современные **веб-приложения построены по модульному принципу**.
Каждый компонент имеет **свой жизненный цикл** - момент, когда он отображается (монтирование), момент, когда он уничтожается (размонтирование) и всё, что происходит между этими моментами (обновление).
### Жизненные цикл компонента в React
**В классовых компонентах** доступ к жизненному циклу может быть предоставлен с помощью методов типа **componentDidMount()** или **componentWillUnmount()**. На мой взгляд, эти названия не требуют объяснений :)
С тех пор как были введены **хуки**, мы можем получить доступ к жизненному циклу функциональных компонентов, используя [useEffect](https://reactjs.org/docs/hooks-reference.html#useeffect). В отношении того, как он используется, он может вести себя как детектор событий **монтирования, размонтирования или обновления** компонента. Вот несколько основных примеров:
```
const [showLoading, setShowLoading] = useState(false)
useEffect(
() => {
let timer1 = setTimeout(() => setShowLoading(true), 1000)
// здесь происходит очищение таймаута при размонтировании компонента
// как при componentWillUnmount
return () => {
clearTimeout(timer1)
}
},
[] //useEffect сработает один раз
//если передадим значение в массив, наример так [data], тогда
//clearTimeout будет срабатывать каждый раз когда значение date меняется
)
```
### Зачем "прибираться" перед размонтированием компонента?
Существует своего рода риск при использовании асинхронных функций, которые пытаются обновить состояние компонента. В чем он заключается? **Колбэк может вернуться**, но конкретный **компонент**, инициализировавший асинхронный вызов, **может быть уже размонтирован!**
Что происходит в такой ситуации? Вы можете получить предупреждение об утечке памяти:
Warning: Can only update a mounted or mounting component. Обычно это означает, что вы вызвали setState, replaceState или forceUpdate на размонтированном компоненте. Что является пустой/холостой командой.
А значит, это как-то влияет на производительность приложения. А это не самая лучшая практика :) В [этой статье](https://www.robinwieruch.de/react-warning-cant-call-setstate-on-an-unmounted-component) довольно подробно рассматривается этот вопрос.
Чтобы этого избежать, вам нужно **отменить все подписки и асинхронные вызовы, когда компонент размонтируется!**
Отмена асинхронного сигнала для событий, вызванных монтированием компонента
---------------------------------------------------------------------------
Итак, после того, как мы рассмотрели базовую теорию, давайте посмотрим случай, когда нам нужно **получить** некоторые **данные из API сразу после монтирования компонента**:
```
export const Articles = () => {
const [state, setState] = useState([]);
useEffect(() => {
const abortController = new AbortController();
const {signal} = abortController;
const apiCall = async path => {
try {
const request = await fetch(path, {
signal: signal,
method: 'GET',
});
const response = await request.json();
setState([response]);
} catch (e) {
if (!signal?.aborted) {
console.error(e);
}
}
};
apiCall('https://jsonplaceholder.typicode.com/posts/1');
return () => {
abortController.abort();
};
}, [setState]);
return (
<>
{state.map(article=> (
{article?.title}
================
{article?.body}
))}
);
};
```
На первый взгляд это кажется немного сложным, но на самом деле это, вероятно, один из самых простых примеров использования AbortController :) Просто перед размонтированием компонента я вызываю метод AbortController.abort(). Вот и все!
Отмена асинхронного сигнала для событий, вызванных взаимодействием с пользователем
----------------------------------------------------------------------------------
Гипотетически, если пользователь хочет **получить некоторые данные с сервера, нажав на кнопку** (или любым другим способом)? Если слабое соединение и медленный интернет, пользователь может начать раздражаться и перейти к другому экрану. Как отменить такой сигнал? Сложность здесь заключается в том, что вам нужно передать уникальный сигнал в useEffect, но этот сигнал фактически инициализируется вне useEffect - в функции, которая обрабатывает действие onClick. Я знаю, что это может показаться простым, но есть одна загвоздка...
Насколько я знаю, в React нет встроенного метода, который мог бы справиться с этим сценарием (но возможно, есть какая-то библиотека?), что делать в подобном случае?
### Fetch как пользовательский хук
Первым шагом будет **создание пользовательского хука,** который может принимать сигнал в качестве параметра или просто предоставлять уникальный сигнал. Затем **он возвращает как метод fetch, так и метод abort**:
```
import {compile} from 'path-to-regexp';
import {GET_ARTICLE_PATH} from './articles-routes';
export const useGetSingleArticle = ({ articleId, abortController = new AbortController()}) => {
const baseUrl = 'https://jsonplaceholder.typicode.com';
const path = baseUrl + compile(GET_ARTICLE_PATH)({articleId});
const { signal, abort } = abortController || {};
const articleRequest = fetch(path, {
signal: signal,
method: 'GET',
});
return [articleRequest, abort?.bind(abortController)];
};
```
Таким образом, теперь вы можете привязать любой сигнал к вашему асинхронному вызову или использовать сигнал по умолчанию и легко использовать его.
### React Хуки
Добавим три простых хука внутри нашего компонента:
```
const [articleId, setArticleId] = useState(2);
const [articleRequest, abortArticleRequest] = useGetSingleArticle({articleId: articleId});
const abortFuncs = useRef([]);
```
Первый - это просто поставщик уникального параметра для API хук.
Второй - это наш API хук, где мы получаем функцию вызова API и уникальный метод для прерывания сигнала.
Третий хук - это массив, в котором хранятся все наши сигналы.
### Обработчик нажатия (клика)
Следующий шаг - это асинхронная функция, которая обрабатывает действие onClick:
```
const fetchOnClick = async () => {
try {
abortFuncs.current.unshift(abortArticleRequest);
const newArticleRequest = await articleRequest;
const newArticle = await newArticleRequest.json();
setState([...state, newArticle]);
setArticleId(articleId +1);
} catch(e) {
console.error(e);
}
}
```
Ключевым в нашей проблеме является передача нашего метода abort в массив с помощью метода unshift(). Затем я просто получаю данные и обновляю состояние.
Обновление в useEffect
----------------------
Теперь нужно сделать обновление в хуке useEffect, созданном в предыдущем примере. Я создаём функцию abortClickRequests, которая проходит через массив с сигналами и вызывает abort() для каждого из них.
```
useEffect(() => {
const abortController = new AbortController();
const {signal} = abortController;
const apiCall = async path => {
try {
const request = await fetch(path, {
signal: signal,
method: 'GET',
});
const response = await request.json();
setState([response]);
} catch (e) {
if (!signal?.aborted) {
console.error(e);
}
}
};
const abortClickRequests = () => {
abortFuncs.current.map(abort => abort());
}
apiCall('https://jsonplaceholder.typicode.com/posts/1');
return () => {
abortClickRequests();
abortController.abort();
};
}, [setState]);
```
Когда компонент будет уничтожен, я просто вызываю предопределенную функцию, и всё!
Мысли
-----
В целом эта реализация довольно простая и скорее является представлением концепции :)
Первый недостаток этого кода я вижу в том, что **я прерываю все сигналы** внутри таблицы, а не только те, которые на 100% не завершены. Я полагаю, что это можно оптимизировать.
Второй момент заключается в том, что на самом деле **трудно** (?) **проверить**, действительно ли эти сигналы прерваны. Теоретически все должно быть в порядке, но как мы можем быть уверены на 100%?
Я не знаю, может быть, все эти усилия на самом деле бессмысленны, потому что существует какая-то библиотека с функцией, которая обрабатывает эту ситуацию? Но тогда мы переходим к бесконечному разговору о чрезмерном использовании библиотек…
Вы можете сказать, что эта проблема **не является проблемой** и не стоит о ней беспокоиться :D
Я не уверен... А у вас есть какие-нибудь мысли?
Дополнительно
-------------
Если вы хотите провести дополнительные исследования в этой области, вы можете начать с моего репозитория, который я создал для этой статьи. Там есть рабочая реализация.
Вот несколько ресурсов, которые меня вдохновили - [RWieruch](https://www.robinwieruch.de/react-warning-cant-call-setstate-on-an-unmounted-component), [Spec](https://dom.spec.whatwg.org/#interface-abortcontroller), [SLorber](https://sebastienlorber.com/handling-api-request-race-conditions-in-react).
В общем, если вы считаете, что эта статья - полная ерунда, пожалуйста, **не стесняйтесь поделиться этим в комментариях** :) | https://habr.com/ru/post/588799/ | null | ru | null |
# Структурированное сопоставление с шаблонами в Python 3.10
Версия [Python 3.10](https://www.python.org/dev/peps/pep-0619/), работа над которой началась 25 мая 2020 года, запланирована к выпуску 4 октября 2021 года и будет содержать ряд интересных нововведений. Одним из многообещающих нововведений будет *структурированное сопоставление с шаблонами* (structured pattern matching). Для этого будет введена специальная [инструкция сопоставления с шаблонами](https://www.python.org/dev/peps/pep-0634/#the-match-statement) `match`. Функциональность сопоставления с шаблонами несомненно вызовет интерес, в особенности у программистов ФП, где она играет важную роль. Остальные новинки новой версии языка описаны [здесь](https://www.python.org/dev/peps/pep-0619/#features-for-3-10).
Python, при всей его мощи и популярности, долгое время не имел формы управления потоком, которая имеется в других языках, — способа брать значение и элегантно его сопоставлять с одним из множества возможных условий. В языках C и C++ для этого служит конструкция `switch/case`; в Rust и F# эта конструкция называется «сопоставлением с шаблонами».
Принятые для этого в Python традиционные способы не являются элегантными. Один из них состоит в написании цепочки выражений `if/elif/else`. Другой - в хранении значений, которые сопоставляются как ключи, в словаре, а затем в использовании значений по ключу для выполнения действия — например, хранить функцию в качестве значения и использовать ключ или какую-либо другую переменную на входе. Во многих случаях эти приемы работают хорошо, но громоздки в конструировании и техническом сопровождении.
После безуспешности многих предложений по добавлению в Python синтаксиса, похожего на `switch/case`, для Python 3.10 было принято недавнее предложение создателя языка Python Гвидо ван Россума и ряда других авторов: *структурированное сопоставление с шаблонами*. Структурированное сопоставление с шаблонами не только позволяет выполнять простые сопоставления в стиле `switch/case`, но и поддерживает более широкий спектр вариантов использования.
**Содержание статьи**
* Введение в структурированное сопоставление с шаблонами на языке Python
* Сопоставление с переменными с помощью структурированного сопоставления
* Сопоставление с несколькими элементами с помощью структурированного сопоставления
* Шаблоны в структурированном сопоставлении
* Сопоставление с объектами с помощью структурированного сопоставления
* Эффективное применение структурированного сопоставления
* Классификация вариантов применения
Введение в структурированное сопоставление с шаблонами на языке Python
----------------------------------------------------------------------
Структурированное сопоставление с шаблонами вводит в Python инструкцию `match/case` и шаблонный синтаксис. Инструкция `match/case` следует той же базовой схеме, что и `switch/case`. Она берет объект, проверяет его на соответствие одному или нескольким шаблонам сопоставления и выполняет действие, если находит совпадение.
```
match command:
case "quit":
quit()
case "reset":
reset()
case unknown_command:
print (f"Неизвестная команда '{unknown_command}')
```
За каждой инструкцией `case` следует шаблон, с которым выполняется сопоставление. В приведенном выше примере мы используем простые строковые литералы в качестве целей сопоставления но возможны и более сложные сопоставления.
Python выполняет сопоставления, просматривая список случаев сверху вниз. При первом совпадении Python выполняет инструкции в соответствующем блоке `case`, затем переходит к концу блока `match` и продолжает работу с остальной частью программы. Между инструкциями `case` нет «проскакивания», но можно разработать свою логику для манипулирования несколькими возможными случаями в одном блоке `case` (подробнее об этом позже).
Также можно захватывать все совпадение целиком или ее часть и использовать его повторно. В инструкции `case` для неизвестной команды, `unknown_command`, в приведенном выше примере значение «захватывается» в переменной unknown\_command, поэтому мы можем использовать его повторно.
Сопоставление с переменными с помощью структурированного сопоставления
----------------------------------------------------------------------
Здесь стоит упомянуть важное замечание. Если вы перечисляете имена переменных в инструкции `case`, то это не означает, что сопоставление будет делаться с содержимым именованной переменной. Переменные в `case` используются для захвата значения, с которым выполняется сопоставление.
Если вы хотите выполнить сопоставление с содержимым переменной, то эта переменная должна быть представлена в виде имени через точку, как перечисление. Вот пример:
```
from enum import Enum
class Command(Enum):
QUIT = 0
RESET = 1
match command:
case Command.QUIT:
quit()
case Command.RESET:
reset()
```
Не нужно обязательно использовать перечисление; подойдет любое имя свойства через точку. Тем не менее, перечисления, как правило, являются для этого наиболее знакомым и идиоматичным способом в Python.
Сопоставление с несколькими элементами с помощью структурированного сопоставления
---------------------------------------------------------------------------------
Ключевой фактор для наиболее эффективного сопоставления с шаблонами заключается не только в том, чтобы использовать его в качестве замены поиска по словарю, но и для того, чтобы описывать структуру того, с чем вы хотите выполнять сопоставление. При таком подходе вы можете выполнять сопоставления, основываясь на числе элементов, с которыми вы выполняете сопоставление, или их комбинации.
Вот несколько более сложный пример. Здесь пользователь вводит команду, за которой обычно следует имя файла.
```
command = input()
match command.split():
case ["выйти"]:
quit()
case ["загрузить", filename]:
load_from(filename)
case ["сохранить", filename]:
save_to(filename)
case _:
print (f"Непонятная команда '{command}'")
```
Давайте проинспектируем эти инструкции `case` по порядку:
`case ["выйти"]:` тестирует то, с чем мы выполняем сопоставление, представляет собой список с одной единственной позицией `"выйти"`, полученной в результате разбивки введенного значения.
`case ["загрузить", filename]:` тестирует, что первый элемент разбивки представляет собой строковое значение `"загрузить"`, и что за ним следует второе строковое значение. Если это так, то мы сохраняем второе строковое значение в переменной `filename` и используем его для дальнейшей работы. То же самое для инструкции `case ["сохранить", filename]:`.
`case _:` представляет собой сопоставление с подстановочным символом. Оно совпадает, если к этому моменту не совпал ни один другой шаблон. Обратите внимание, что переменная `_` на самом деле ни к чему не привязывается; имя `_` используется в качестве сигнала для команды `match`, что рассматривается подстановочный (универсальный) случай (именно по этой причине мы обращаемся переменной `command` в теле блока `case`; ничего не было захвачено.)
Шаблоны структурированного сопоставления
----------------------------------------
Шаблоны могут быть представлены простыми значениями, либо могут содержать более сложную логику сопоставления. Вот несколько примеров:
`case "a":` сопоставляет с одним единственным значением `"a"`.
`case ["a","b"]:` сопоставляет с коллекцией `["a","b"]`.
`case ["a", value1]:` сопоставляет с коллекцией из двух значений, и поместить второе значение в переменную захвата `value1`.
`case ["a", *values]:` сопоставляет с коллекцией, по меньшей мере, из одного значения. Другие значения, если они есть, помещаются в значения. Обратите внимание, что в коллекцию может включаться только одна позиция со звездочкой (как это принято делать с аргументами со звездочкой в функции Python).
`case ("a"|"b"|"c"):` оператор ИЛИ (`|`) может использоваться, чтобы иметь возможность манипулировать несколькими случаями `case` в одном единственном блоке `case`. Здесь мы сопоставляем с `"a"`, либо с `"b"`, либо с `"c"`.
`case ("a"|"b"|"c") as letter:` делает то же что и выше, за исключением того, что мы размещаем совпавшую позицию в переменную `letter`.
`case ["a", value] if <выражение>:` сопоставляет с захваченным элементом, только если выражение является истинным. В выражении могут использоваться переменные захвата. Например, если бы мы использовали значение `if` в коллекции `valid_values`, то вариант `case` был бы валидным, только если захваченное значение фактически находилось в указанной коллекции.
`case ["z", _]:` будет совпадать любая коллекция позиций, которая начинается с `"z"`.
Сопоставление с объектами с помощью структурированного сопоставления
--------------------------------------------------------------------
Наиболее продвинутой особенностью системы структурированного сопоставления с шаблонами в Python является способность выполнять сопоставление с объектами, обладающими специфическими свойствами. Возьмем приложение, в котором мы работаем с объектом под названием `media_object` и мы хотим его конвертировать в файл .jpg и вернуть из функции.
```
match media_object:
case Image(type="jpg"):
# Вернуть как есть
return media_object
case Image(type="png") | Image(type="gif"):
return render_as(media_object, "jpg")
case Video():
raise ValueError("Не получается извлечь кадры из видео")
case other_type:
raise Exception(f"Обработать медиатип {media_object} не получается")
```
В каждом приведенном выше случае `case` мы ищем специфический вид объекта, иногда со специфическими атрибутами. Первая инструкция `case` совпадает с объектом `Image`, атрибут которого установлен равным `"jpg"`. Вторая инструкция `case` совпадает в случае, если тип равен `"png"` либо `"gif"`. Третья инструкция `case` совпадает с любым объектом, имеющим тип `Video`, не зависимо от его атрибутов. И заключительная инструкция `case` является нашим всеохватывающим случаем, если все другие не сработают.
Захватывать также можно с помощью объектных паросочетаний:
```
match media_object:
case Image(type=media_type):
print (f"Снимок имеет тип {media_type}")
```
Эффективное применение структурированного сопоставления
-------------------------------------------------------
Ключевым фактором в структурированном сопоставлении с шаблонами Python является написание парсочетаний, полностью охватывающие структурированные случаи, с которыми вы хотите выполнять сопоставление. Простые проверки с константами будут работать прекрасно, но если это все, что вам нужно, то простая сверка по словарю могла бы быть более подходящим вариантом. Реальная выгода от структурированного сопоставления с шаблонами вытекает из способности выполнять парсочетания с объектами, а не с отдельно взятым объектом или даже подборкой позиций.
Следует иметь в виду еще одну важную вещь, и это порядок паросочетаний. То, какие паросочетания вы будет тестировать в первую очередь, повлияет на эффективность и точность вашего сопоставления в целом. Большинство людей, строивших длинные цепочки `if/elif/else`, это поймут, но сопоставление с шаблонами требует от вас еще более тщательного обдумывания порядка из-за потенциальной сложности. Сначала следует размещать самые конкретные паросочетания, а самые общие - последними.
Наконец, если ваша задача может быть решена с помощью простой цепочки `if/elif/else` или поиска по словарю — используйте их! Сопоставление с шаблонами является мощным, но не универсальным средством. Используйте его только тогда, когда оно имеет наибольший смысл для решения задачи.
Классификация вариантов применения
----------------------------------
На данный момент можно выделить следующие сценарии применения функциональности структурированного сопоставления с шаблонами в будущем:
* **Обыкновенная инструкция switch/case**
```
# ПРИМЕЧАНИЕ:
# для выполнения приведенных ниже примеров кода
# требуется Python версии 3.10.
# Обыкновенная инструкция switch/case
def match_errno(errno):
match errno:
case 0:
pass
case 1:
pass
case 42:
print("42!")
case _: # совпадает с любым числом
print("универсальное совпадение")
```
* **Сопоставление с использованием списка литералов**
```
# Сопоставление с использованием списка литералов
def command_split(command):
match command.split():
case ["make"]:
print("make по умолчанию")
case ["make", cmd]:
print(f"найдена команда make: {cmd}")
case ["restart"]:
print("выполняется перезапуск")
case ["rm", *files]:
print(f"удаляются файлы: {files}")
case _:
print("совпадений не найдено")
```
* **Сопоставление с использованием списка литералов и оператора ИЛИ (|)**
```
# Сопоставление с использованием списка литералов и оператора ИЛИ (|)
def match_alternatives(command):
match command.split():
case ["север"] | ["переместиться на", "север"]:
print("выполняется перемещение на север")
case ["взять", obj] | ["поднять", "с пола", obj] | ["понять", obj, "с пола"]:
print(f"выполняется поднятие: {obj}")
```
* **Групповое сопоставление с использованием кортежа альтернатив и оператора as**
```
# Групповое сопоставление с использованием кортежа альтернатив и оператора as
def match_capture_subpattern(command):
match command.split():
case ["переместиться на", ("север" | "юг" | "восток" | "запад") as direction]:
print(f"выполняется перемещение на {direction}")
```
* **Сопоставление с использованием списка литералов и ограничителя if**
```
# Сопоставление с использованием списка литералов и ограничителя if
def match_guard(command, exits):
match command.split():
case ["переместиться на", direction] if direction in exits:
print(f"выполняется перемещение на {direction}")
case ["переместиться на", _]:
print(f"переместиться в указанном направлении не получается")
```
* **Сопоставление с классом**
```
# Сопоставление с классом
from dataclasses import dataclass
@dataclass
class Click:
position: tuple[int, int]
button: str
@dataclass
class KeyPress:
key_name: str
@dataclass
class Quit:
pass
def match_by_class(event):
match event:
case Click(position=(x,y), button="left"):
print(f"обрабатывается левое нажатие в {x,y}")
case Click(position=(x,y)):
print(f"обрабатывается другое нажатие в {x,y}")
case KeyPress("Q"|"q") | Quit():
print("выход из программы")
case KeyPress(key_name="up arrow"):
print("перемещение вверх")
case KeyPress():
pass # игнорировать другие нажатия клавиш
case other_event:
raise ValueError(f'нераспознанное событие: {other_event}')
```
**Сопоставление со словарем**
```
# Сопоставление со словарем
def match_json_event(event):
match event:
case {"transport": "http"}:
print("небезопасное insecure событие проигнорировано")
case {"verb": "GET", "page": "articles", "pageno": n}:
print(f"разрешено взять статью на странице {n}...")
case {"verb": "POST", "page": "signup"}:
print("обрабатывается вход в систему")
```
Код главной программы:
```
def main():
# x, y = 1, 2
command_split("make")
command_split("make clean")
command_split("restart")
command_split("rm a b c")
command_split("doesnt match")
match_errno(42)
match_alternatives("go north")
match_alternatives("pick up sword")
match_capture_subpattern("go north")
match_capture_subpattern("go east")
match_guard("go north", exits=["east", "south"])
match_guard("go north", exits=["north"])
match_by_class(Click(position=(0,0), button="left"))
match_by_class(Quit())
try:
match_by_class("BADVALUE")
except ValueError:
pass
match_json_event({"verb": "GET", "page": "articles", "pageno": 5, "info": "extra"})
pass
if name == 'main':
main()
```
Пост написан по материалам [статьи](https://www.infoworld.com/article/3609208/how-to-use-structural-pattern-matching-in-python.html). Исходный код взят [отсюда](https://github.com/mCodingLLC/VideosSampleCode/blob/master/match_statement.py). [Репо](https://github.com/mCodingLLC/VideosSampleCode) на Github по указанной ссылке содержит много других примеров кода, которые будут полезны интересующимся. Старый вариант «сопоставления» можно найти [тут](https://github.com/mCodingLLC/VideosSampleCode/blob/master/match_statement_the_old_way.py). Видео по теме поста можно найти [тут](https://www.youtube.com/watch?v=-79HGfWmH_w). Данная статья может быть обновлена, когда появятся функционально-ориентированные примеры. | https://habr.com/ru/post/555804/ | null | ru | null |
# Самописный таймер в виде функции для промышленного контроллера Simatic S7-1200
Еще для серии S7-300 и S7-400 под Step 7 классических версий предлагаемых разработчику таймеров вполне хватало — это и стандартные таймеры IEC, реализованные в виде функциональных блоков, и таймеры S5 (которые, к слову, до сих пор существуют для серии S7-1500). Однако в ряде случаев разработчик не применял стандартные инструменты и реализовывал собственные таймеры, чаще всего — в виде функций. Такие таймеры-функции необходимы были при «айтишном» подходе к программированию, в котором оперировали не отдельными экземплярами функциональных блоков технологического оборудования, с соответствующей обвязкой входов и выходов, а массивами структур. Например — массив структуры типа «дискретный вход». Или массив структуры «агрегат». Такой подход к программированию имеет право на существование, поскольку позволяет серьезно экономить рабочую память CPU, но, с другой стороны, делает программный код трудночитаемым. Стороннему программисту и с простым видом программы на LAD разобраться получается далеко не сразу, а про кучи индексов, массивов и функций их обработки — и речи не идет, тут без документации к ППО (и без поллитры, разумеется) вообще никуда.
Эти массивы структур, как правило, обрабатывались в функциях. В принципе, ничто не мешало делать обработку и в функциональных блоках, но всегда вставал важный вопрос — как работать с таймерами в этих случаях? Стандартные таймеры предполагают либо номер (S5), либо экземпляр функционального блока (IEC). Речь, напоминаю, идет об обработке массивов структур для классических ПЛК Simatic, и «вкрячить» в эти структуры еще и номера таймеров, а тем более — экземпляры — либо сложно, либо просто невозможно.
По этой причине и создавался собственный функционал таймера в виде функции. В принципе, для работы любого таймера необходимо знать всего несколько вещей — состояние входа, уставку времени и сколько времени уже прошло с момента активации.
Для 300 и 400 серии определить это время можно было двумя способами. Первый — смотреть время выполнения главного OB1 (есть соответствующая переменная в самом OB1) или циклических OB и увеличивать внутренний аккумулятор времени при каждом вызове таймера при условии подачи «истины» на вход. Не очень хороший вариант, поскольку это время отличается для OB1 и циклических OB. Второй способ — системная функция TIME\_TCK, которая при каждом вызове возвращала одно-единственное значение — внутренний счетчик миллисекунд центрального процессора.
Таким образом, для таймера типа TON (задержка включения) алгоритм работы был таков:
* по переднему фронту запроса срабатывания сбрасываем выход и запоминаем текущее значение системного таймера TIME\_TCK
* если на вход запроса продолжает поступать «истина» определяем текущее значение системного таймера и вычитаем из него значение, которые мы запомнили на этапе запуска таймера (не забываем при это, что TIME\_TCK возвращает значение от 0 до (2 ^ 31 — 1), а при превышении верхнего порогового значения начинает отсчет с нуля). В результате получили, сколько миллисекунд прошло с момента активации отсчета времени. Если прошло меньше заданного, подаем на выход «ложь», в противном случае — «истину»
* если на вход запроса приходит «ложь», обнуляем выход таймера
С появлением «тысячной» серии ситуация немного изменилась. Дело в том, что линейка S7-1500 унаследовала поддержку системного вызова TIME\_TCK, и любители подхода «стоя и в гамаке» (а как еще можно назвать программу, которая только и делает, что обрабатывает массивы структур, оперируя при этом жуткими индексами?) могли спокойно продолжать использовать свои наработки.
Линейка базовых контроллеров S7-1200 основана на другой архитектуре, и в ней есть ряд отличий от S7-1500. В том числе — отсутствие системного вызова TIME\_TCK. В рядах разработчиков, не обладающих достаточной гибкостью мышления, пошло недовольство — невозможно выполнить копи/паст старых программ. Тем не менее, поставленную задачу определения, сколько времени прошло с момента предыдущего вызова, можно выполнить, используя функцию [runtime](https://support.industry.siemens.com/cs/document/87668055/for-s7-1200-s7-1500-how-do-you-measure-the-runtime-of-the-complete-program-subprograms-or-specific-organization-blocks-?dti=0&pnid=13911&lc=en-WW).
Данная функция возвращает время, прошедшее с ее предыдущего вызова, в секундах в виде вещественного числа двойной точности LREAL. Подробности описаны в справке. Для внутренних целей необходимо дополнительная переменная MEM (тоже типа LREAL).
Приведу исходники первого приближения функции, и дам некоторые примечания.
Объявление функции:
```
FUNCTION "PerversionTON" : Void
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1
VAR_INPUT
IN : Bool; // Вход таймера
PT : Real; // Уставка времени в секундах
END_VAR
VAR_OUTPUT
Q : Bool; // Выход таймера
END_VAR
VAR_IN_OUT
INPrv : Bool;
MEM : LReal;
TimeACC : UDInt;
END_VAR
VAR_TEMP
udiCycle : UDInt;
udiPT : UDInt;
END_VAR
```
Со входами/выходами все ясно: IN, Q и PT. Уставку времени завел в виде вещественного, это секунды. Просто так захотелось (а зря, но об этом ниже). Далее о переменных области InOut. Поскольку у нас именно функция, то у нас нет области STAT, нет переменных, которые сохраняют свое значение при последующем вызове функции, а такие переменные необходимы:
INPrv — для определения положительного фронта запроса
MEM — вспомогательная переменная для работы системного вызова runtime
TimeACC — аккумулятор времени, который будет хранить количество микросекунд идущей в настоящий момент задержки срабатывания.
Переменные TimeACC, udiCycle и udiPT заданы в формате UDINT, беззнаковое целое, 4 байта. Несмотря на то, что и задание времени я указал в виде вещественного, и функция runtime возвращает вещественное аж двойной точности, я предпочту выполнять простые операции суммирования и сравнения целочисленными операндами для экономии процессорного времени. Время в моем случае учитывается с точностью до микросекунды. Причина проста — если огрублять время до миллисекунды, то при почти пустом OB1 (например, если во всей программе контроллера вызывается только один таймер и более ничего) возможны «пропуски» циклов, программа иногда выполняется и за 250 мкс. Но в этом случае максимально допустимое значение аккумулятора времени составит 4 294 секунды, почти 4 295 (2 ^ 32 — 1 = 4 294 967 295). Ничего не поделать, такая «оптимизация» требует жертв.
Текст функции.
```
#udiCycle := LREAL_TO_UDINT(RUNTIME(#MEM) * 1000000); //прошло микросекунд со времени предыдущего вызова
#udiPT := REAL_TO_UDINT(#PT * 1000000); //уставка таймера в микросекундах
IF (#IN AND (NOT #INPrv)) THEN //по переднему фронту входа обнулить аккумулятор времени и сбросить выход
#TimeACC := 0;
#Q := FALSE;
ELSIF (#IN AND #INPrv) THEN //если на вход продолжает поступать "истина"
#TimeACC += #udiCycle; //увеличть аккумулятор времени на величину "прошло времени с прошлого вызова"
IF #TimeACC >= #udiPT THEN //если накопленное время достигло или превысило уставку
#Q := TRUE; //дать выход "истина"
#TimeACC := #udiPT; //зафиксировать аккумулятор временеи
ELSE //если накопленное время не достигло уставки времени
#Q := FALSE; //сбросить выход
END_IF;
ELSE //во всех остальных случаях - сбросить выход и обнулить аккумулятор времени
#Q := FALSE;
#TimeACC := 0;
END_IF;
#INPrv := #IN; //предыдущее значение запроса
ENO := #Q; //выход ENO для красоты при использовании этой функции в языках LAD и FBD
```
Первые две строчки — пересчет уставки таймера из количестве секунд, задаваемого в формате REAL, в количество микросекунд. Так же определяется время в микросекундах, прошедшее с предыдущего вызова программного блока.
Далее алгоритм следующий, и я его уже приводил:
* по переднему фронту входа IN обнуляем выход Q и сбрасываем аккумулятор времени
* если на вход продолжает поступать «истина», увеличиваем аккумулятор времени на известную уже величину udiCycle и сравниваем его с уставкой времени. При превышении уставки времени таймер отработал, дать на выход «истину», в противном случае — дать на выход «ложь»
* в случаях подачи на вход IN значения «ложь» обнулить выход Q и сбросить аккумулятор времени.
В конце функции для возможности определения фронта входа IN запомнить его предыдущее значение. Так же дать на выход ENO (при использовании функции в графических языках, типа LAD) значение выхода Q.
Убеждаемся в работоспособности функции, после чего становится интересным оценить ее быстродействие и при необходимости улучшить (уже на первый взгляд становится ясно, что ряд вычислений идет в холостую и зря отнимает процессорное время). Для оценки быстродействия объявляю массив из 1000 структур данных таймера.
Объявление структуры. Её поля дублируют входные и выходные переменные функции таймера.
```
TYPE "typePervTONdata"
VERSION : 0.1
STRUCT
IN : Bool; // Вход таймера
PT : Real; // Задание времени таймера
Q : Bool; // Выход таймера
INPrv : Bool; // Для определения фронта входа
MEM : LReal; // Для вычисления прошедшего времени
TimeACC : UDInt; // Аккумулятор времени
END_STRUCT;
END_TYPE
```
В глобальном блоке данных «TortureTON» объявляется массив структур:
```
TONs : Array[0..999] of "typePervTONdata";
```
В организационном блоке OB1 выполняется следующий код:
```
FOR #i := 0 TO 999 DO
"TortureTON".TONs[#i].IN := "startton";
"PerversionTON"(IN := "TortureTON".TONs[#i].IN,
PT := "TortureTON".TONs[#i].PT,
Q := "TortureTON".TONs[#i].Q,
INPrv := "TortureTON".TONs[#i].INPrv,
MEM := "TortureTON".TONs[#i].MEM,
TimeACC := "TortureTON".TONs[#i].TimeACC);
END_FOR;
```
Объявлено 1000 «экземпляров» таймеров, у каждого задано время в 10 секунд. Вся 1000 таймеров начинает отсчет времени по значению маркерной переменной startton.
Запускаю диагностические функции контроллера (S7-1214C DC/DC/DC, версия FW 4.4, версия Step7 — V16) и смотрю время цикла сканирования контроллера. На «холостом ходе» (когда на вход таймеров поступает «ложь») вся тысяча обрабатывается в среднем за 36-42 миллисекунды. Во время отсчета десяти секунд это показание вырастает примерно на 6-8 миллисекунд и временами зашкаливает за 50 мс.
Смотрим, что можно улучшить в коде функции. Во-первых, строки в самом начале программного блока:
```
#udiCycle := LREAL_TO_UDINT(RUNTIME(#MEM) * 1000000); //прошло микросекунд со времени предыдущего вызова
#udiPT := REAL_TO_UDINT(#PT * 1000000); //уставка таймера в микросекундах
```
Они вызываются всегда, вне зависимости от того, считает ли время таймер, не считает или уже посчитал. Большое расточительство — нагружать не особо мощный CPU серии 1200 расчетами, связанными с вещественными двойной точности. Разумно перенести обе строчки в часть кода, обрабатывающая отсчет времени (если на вход продолжает поступать «истина»). Так же необходимо продублировать вычисление udiCycle в код, обрабатывающий положительный фронт на входе таймера. Это должно разгрузить «холостую работу» таймера, когда на вход поступает значение «ложь». На практике таймеры в программируемых логических контроллерах чаще всего работают «на холостую». Например, время фильтрации дребезга контактов — это десятки миллисекунд. Управляющий импульс дискретного выхода — несколько сотен миллисекунд, обычно от 0.5 до 1.0 секунды. Время контроля выполнения команды агрегата (например, время полного открытия задвижки) — от десятков секунд до нескольких минут. ПЛК на производстве же работает 24 часа в сутки и 365 (а иногда и больше!) дней в году. То есть, чаще всего на входе таймера находится либо «ноль», и таймер ничего не считает, либо длительное время поступает «единица», и таймер уже все посчитал. Для разгрузки CPU холостого хода второго вида (таймер уже посчитал) необходимо на этапе «на вход продолжает поступать истина» проверять — а посчитал ли уже таймер все время и выставил ли выход в истину. В этом случае никаких вычислений выполнять не следует.
Для внесения этих изменений необходимо выход Q таймера перенести из области OUTPUT в область IN\_OUT, и значение выхода будет сохраняться во внешних переменных (в данном примере — в массиве структур). После доработки весь код функции, включая объявление, выглядит следующим образом:
```
FUNCTION "PerversionTON" : Void
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1
VAR_INPUT
IN : Bool; // Вход таймера
PT : Real; // Уставка времени в секундах
END_VAR
VAR_IN_OUT
Q : Bool; // Выход таймера
INPrv : Bool;
MEM : LReal;
TimeACC : UDInt;
END_VAR
VAR_TEMP
udiCycle : UDInt;
udiPT : UDInt;
END_VAR
BEGIN
IF (#IN AND (NOT #INPrv)) THEN //по переднему фронту входа обнулить аккумулятор времени и сбросить выход
#TimeACC := 0;
#Q := FALSE;
#udiCycle := LREAL_TO_UDINT(RUNTIME(#MEM) * 1000000); //фиксируем "базу времени" по фронту
ELSIF (#IN AND #INPrv) THEN //если на вход продолжает поступать "истина"
IF (NOT #Q) THEN
#udiCycle := LREAL_TO_UDINT(RUNTIME(#MEM) * 1000000); //прошло микросекунд со времени предыдущего вызова
#udiPT := REAL_TO_UDINT(#PT * 1000000); //уставка таймера в микросекундах
#TimeACC += #udiCycle; //увеличить аккумулятор времени на величину "прошло времени с прошлого вызова"
IF #TimeACC >= #udiPT THEN //если накопленное время достигло или превысило уставку
#Q := TRUE; //дать выход "истина"
#TimeACC := #udiPT; //зафиксировать аккумулятор времени
END_IF;
END_IF;
ELSE //во всех остальных случаях - сбросить выход и обнулить аккумулятор времени
#Q := FALSE;
#TimeACC := 0;
END_IF;
#INPrv := #IN; //предыдущее значение запроса
ENO := #Q; //выход ENO для красоты при использовании этой функции в языках LAD и FBD
END_FUNCTION
```
После этого время выполнения улучшается: холостой ход обработки таймеров составляет 23 мс, при работающей фильтрации времени 37-40 мс.
В этом коде функции отсутствует проверка на недопустимое значение уставки таймера — отрицательную величину (при переводе вещественного в беззнаковое целое произойдет искажение уставки) или величину больше 4294.9 секунд (произойдет переполнение и искажение уставки времени). Необходимо либо контролировать значение величины PT в коде, либо доверить задачу проверки диапазона временной уставки (от 0 до 4294.9 секунд) операторской системе верхнего уровня. Проверка диапазона средствами программы PLC увеличивает время обработки примерно до 45-46 мс (а, вообще, самый правильный способ — это задавать время таймера не в формате REAL, а в формате UDINT в миллисекундах и заниматься ерундой).
Проект прикладной программы с таймером для среды TIA Portal Step 7 версии 16 доступен по [ссылке](https://drive.google.com/file/d/13dsrbXbxHhOaxchs4-TMrFpFMCZWHtcx/view?usp=sharing). | https://habr.com/ru/post/491200/ | null | ru | null |
# Дайджест событий для HR-специалистов в IT-области на август 2017
Август — время отпусков и отдыха, но HR-специалистам некогда отдыхать. Хотя событий в августе меньше, чем обычно, «Мой круг» публикует для всех, кто ещё не уехал на море или уже успел вернуться, перечень полезных и интересных мероприятий для HR-специалистов, которые проходят в августе.
---
#### **В поиске все средства хороши или где еще не ступала нога рекрутера**
**Когда**: 4 августа, 18:00
**Где**: Санкт-Петербург, Большой Сампсониевский проспект, д. 61 к.2, БЦ «Бекар», коворкинг GrowUp
**Условия участия**: Бесплатно
**Организатор**: «Мой круг»
Успешные рекрутеры делятся опытом по использованию различных средств поиска кандидатов.
* **Егор Яценко**, со-основатель агентства Wanted: Profi, расскажет о своем опыте рекрутинга в мессенджерах.
* **Евгения Остроумова**, IT-рекрутер агентства GMS, расскажет о том, зачем разработчикам Twitter и как через нетворкинг искать интересных кандидатов.
* **Анна Атрошкина**, со-основатель агентства INDEX, расскажет о приемах и секретах поиска на «Моем круге» и «Хабрахабре».
**[Подробности и регистрация](https://moikrug.timepad.ru/event/544210/)**
---
#### **Препарируем профессию Scala Developer (семинар)**
**Когда**: 8 августа, 18:00
**Где**: Москва, место проведения уточняется
**Условия участия**: Бесплатно
**Организатор**: Spice IT
Докладывает Алексей Фомкин из Scala User Group.
**[Подробности мероприятия](http://www.facebook.com/groups/mskithr)** (в группе Moscow IT HR Community на Facebook, группа закрытая, требуется вступление)
---
#### **Как искать разработчиков в AmazingHiring (вебинар)**
**Когда**: 10 августа, 15:00
**Где**: Вебинар
**Условия участия**: Бесплатно
**Организатор**: AmazingHiring
На вебинаре расскажут, как выжать максимум от поиска в AmazingHiring:
* Как составлять лучшие поисковые запросы
* Что делать с поисковой выдачей
* Как работать с профилем кандидата
* Объединение данных
* Функциональность ATS
* Работа плагина для Google Chrome
* Как хитро использовать систему
**[Подробности и регистрация](http://amazinghiring.us10.list-manage.com/track/click?u=b91fb3e9ae400e0b3feb60d4c&id=8715c9a339&e=989daff5e4)**
---
#### **Секреты IT-подбора (тренинг)**
**Когда**: 24-25 августа, 11:00
**Где**: Москва, улица Новый Арбат д. 21, стр. 1, HYUNDAI MOTORSTUDIO
**Условия участия**: стоимость обучения 10 900 рублей (скидка 50% по промокоду `IT RECRUITER`)
**Организатор**: IT Recruiter School
Тренинг создан для тех, кто хочет развиваться в самой динамичной отрасли мира, но не обладает достаточными знаниями. На тренинге вам помогут разобраться в сложной технической терминологии, вы подробно разберете коммуникацию и площадки для привлечения IT-специалистов.
**[Подробности и регистрация](https://agency21-vek.timepad.ru/event/501918/)**
---
#### **Препарируем профессию Product Manager (семинар)**
**Когда**: 28 августа, 18:00
**Где**: Москва, место проведения уточняется
**Условия участия**: Бесплатно
**Организатор**: Spice IT
Докладывают Марк Тен из Sports.ru и Харитон Матвеев из SkyEng.
**[Подробности мероприятия](http://www.facebook.com/groups/mskithr)** (в группе Moscow IT HR Community на Facebook, группа закрытая, требуется вступление)
---
#### **Базовые понятия разработки ПО (вебинар)**
**Когда**: 29 августа, 12:00
**Где**: вебинар
**Условия участия**: Бесплатно
**Организатор**: iChar
Курс вебинаров поможет рекрутерам погрузиться в IT вакансии, разобраться в стеке технологий, терминологии и других особенностях.
На первом вебинаре будут обсуждаться базовые понятия разработки ПО, чтобы у участников сложилось одинаковое понимание терминологии при прослушивании наших вебинаров.
Лектор: Максимачёв Алексей Юрьевич, Заместитель Директора по IT Медицинского центра «XXI век»
**[Подробности и регистрация](https://ichar-events-org.timepad.ru/event/552501/)**
---
**Об организаторах мероприятий**
* [Мой круг](https://moikrug.ru/) — сервис поиска ИТ-специалистов, часть экосистемы Хабрахабра.
* [AmazingHiring](http://amazinghiring.ru/) — сервис для поиска ИТ-специалистов.
* [GMS](https://gmsservices.ru/) — рекрутинговое агентство, специализируется на поиске ИТ-специалистов.
* [INDEX](http://hh-it.ru/) — рекрутинговое агентство, специализируется на поиске ИТ-специалистов; у агенства также есть INDEX School, где обучают HR специалистов, которые работают в ИТ-сфере.
* [IT Recruiter School](http://itrecruiter.ru/) — школа ИТ-рекрутинга.
* [Spice IT](http://www.spice-agency.ru/) — рекрутинговое агентство, специализируется на поиске ИТ-специалистов; у агенства есть сообщество Moscow IT HR Community, объединяющее московских HR специалистов.
* [Wanted: Profi](http://www.wanted-profi.ru/) — рекрутинговое агентство, специализируется на поиске ИТ-специалистов.
* [iChar](http://ichar.ru/) — рекрутинговое агентство в ИТ, ищет ИТ-специалистов, Sales & Marketing профессионалов, финансистов для IT-Бизнеса, стартапов и других компаний.
Если мы пропустили какие-то события для HR-специалистов в области ИТ, которые проходят в августе, пожалуйста, добавляйте их в комментарии. | https://habr.com/ru/post/334732/ | null | ru | null |
# Codeigniter: делаем сессии наконец стабильными (прежде всего для авторизаций)
Сессии в Codeigniter хороши всем. Правда, очень удобно сделаны, особенно когда вы храните сессии в БД (что я считаю единственно верным). Куки шифрованные, в куках ничего, кроме идентификатора нету. Они привязываются к user\_agent и, опционально, к IP. Красиво, безопасно.
Но есть у них очень существенный недостаток: жизнь сессии считается от поля **last\_activity**. Это значит, что если у вас стоит expire сессии в двое суток, то при обращении к сессии, у которой last\_activity < time()-172800, она ликвидируется и начинется новая. Следственно, для того что бы пользователям не приходилось каждый раз логиниться на сайт, last\_activity нужно поддерживать в акутальном состоянии.
Поле last\_activity обновляется в двух случаях: когда вы записываете что-то новое в сессию, либо когда сессия обновляется (по-умолчанию каждые 5 минут, опять же, относительно last\_activity; указывается в конфиге). И вот главная проблема в том, что при обновлении сессии **меняется session\_id** и текущая сессия у пользователя сессия прерывается, стартует новая.
Откровенно говоря, подобное поведение сессий привело меня в состояние… удивления. В таких реалиях использование родных сессий в качестве инструмента поддержки авторизации кажется невозможным…
Проблема «животрепещущая», о ней часто вспоминают на форумах Codeigniter, но толкового решения там нигде я так и не увидел.
Но голь, как известно, на выдумки хитра, поэтому простое решение таки нашлось.
Первое, что нужно сделать, это в **config/config.php** указать периодичность обновления сессии равным времени ее expire'а:
================
`$config['sess_time_to_update'] = $config['sess_expiration'];`
================
Затем, включить [хуки](http://codeigniter.com/user_guide/general/hooks.html):
================
`$config['enable_hooks'] = TRUE;`
================
Затем, в **config/hooks.php**:
================
`$hook['post_controller_constructor'] = array(
'class' => '',
'function' => 'sess_update',
'filename' => 'sess_update.php',
'filepath' => 'hooks'
);`
================
(точку хука можно, в принципе, любую, главное, что бы он выполнялся при каждом открытии страницы)
И в hooks создаем **sess\_update.php**:
================
`php<br/
function sess_update()
{
$CI =& get_instance();
if ($CI->session->userdata('last_activity')< time() - 300) {
$CI->session->set_userdata('last_activity', time());
}
}`
================
Функция проста, как 5 копеек: получаем ссылку на суперобъект codeigniter'а, смотрим, не прошло ли 5 минут с момента последнего обновления сессии (что бы не штормить базу лишними запросами каждый раз) и, если прошло, вручную устанавливаем пол last\_activity равным текущему времени.
По сути, получается тот же эффект, что указание 5 минут в $config['sess\_time\_to\_update'], но при этом сама сессия остается невредимой, данные никуда не деваются и, ваш авторизированный пользователь, прийдя на сайт на следующий день, или через два (в зависимости от значения $config['sess\_expiration']) останется авторизированным. | https://habr.com/ru/post/130853/ | null | ru | null |
# Обзор ретро-футуристичного КПК DevTerm с Linux
[](https://habr.com/ru/company/ruvds/blog/655123/)
Команда ClockworkPI выпустила интересный карманный девайс с ОС Linux, который легко собирается без паяльника, имеет экран с разрешением 1280х480, предлагает богатые возможности для кастомизации и даже оснащён неожиданным диковинным модулем — термальным принтером.
Не каждый день анонсируют выход портативного опенсорсного компьютера с Linux, поэтому я не устоял перед заказом [DevTerm от ClockworkPi](https://www.clockworkpi.com/devterm), ещё когда [впервые узнал](https://hackaday.com/2020/12/08/devterm-beats-cyberdeck-builders-to-the-punch/) об этом миниатюрном стильном терминале, включающем экран 1280х480 (сдвоенный VGA) и маленький термопринтер.
Конечно же, глобальный дефицит полупроводников вкупе с промедлениями доставок ведёт к задержкам, но всё же заветный комплект оказался-таки на месте. Мне всегда нравились малогабаритные машины, особенно поставляемые в виде грамотно спроектированного комплекта, так что я смогу в деталях поведать вам о сборке и запуске такого девайса.
▍ Продуманный дизайн
--------------------
Сборка DevTerm может стать отличным проектом выходного дня или свободного вечера. Продуманный дизайн взаимосвязанных деталей и разъёмов позволяет обойтись полностью без пайки. При этом процесс сборки в основном состоит из защёлкивания аппаратных модулей и пластиковых деталей согласно инструкции. Любой, кто имеет опыт в сборке пластиковых модельных комплектов, сможет вкусить приятное чувство ностальгии от вырезания деталей и их скрепления.
Руководство сопровождено хорошими иллюстрациями, а крайне грамотный механический дизайн существенно упрощает процесс сборки. Использование самоцентрирующихся деталей и фиксаторов, которые сами выступают в качестве центрирующих бобышек, является довольно изящным решением. Не нужно никаких инструментов, и, за исключением двух мелких винтов для крепления процессорного модуля — аппаратный крепёж вообще отсутствует.
Естественно, некоторые детали довольно деликатны и не имеют полноценной защиты от дурака, но всё же у любого, кто знаком со сборкой электроники, проблем тут возникнуть не должно.
*Большая часть компонентов — это пластиковые детали в каркасе*
*Ностальгия для тех, кому доводилось собирать пластиковые комплекты*
*Инструкция по сборке написана понятно и подробно*
*В конструкции практически отсутствует аппаратный крепёж, а детали сами вписываются на свои места*
Единственное, что в набор не входит, это две батареи 18650 и рулон термобумаги 58 мм для принтера. А для двух упомянутых винтов крепления процессорного модуля потребуется миниатюрная крестовая отвёртка.
▍ Модульные компоненты
----------------------
Помимо экрана и принтера, внутри DevTerm есть четыре основных узла, каждый из которых соединяется с другими без пайки. Клавиатура с мини-трекболом полностью автономна и подключается через пружинные контакты. На основной плате расположен ЦПУ. Плата EXT оборудована вентилятором и портами ввода-вывода: USB, USB-C, Micro-HDMI и аудио. Оставшаяся часть платы занимается питанием и вмещает два аккумулятора 18650. USB-порт, кстати, используется исключительно для зарядки. При этом внутри даже остаётся свободное место для внесения доработок или установки дополнительных компонентов.
*Все модули представляют полностью автономные компоненты*
*Подключаются модули через разъёмы, не требуя пайки*
*Все порты ввода-вывода расположены сбоку. Питание подаётся спереди*
Такая модульная схема оказывается очень кстати. К примеру, она позволяет использовать в DevTerm различные процессоры и модули памяти, включая основанные на [Raspberry Pi CM3+ Lite](https://www.raspberrypi.com/products/compute-module-3-plus/?variant=compute-module-3plus-lite), который является начинкой Raspberry Pi 3 Model B+ и выполнен в формфакторе, подразумевающем интеграцию в другое оборудование.
В [репозитории DevTerm](https://github.com/clockworkpi/DevTerm) есть схемы, код и справочная информация, например, эскизы платы. Там нет проектных файлов в формате CAD, но они могут появиться в будущем. На странице продукта сказано, что CAD-файлы для кастомизации или 3D-печати собственных деталей доступны в репозитории GitHub, но на момент написания статьи я их там не обнаружил.
▍ Использование DevTerm
-----------------------
*Образ ОС, записанный на карту памяти, вполне работоспособен и позволяет выполнить загрузку, но я настоятельно рекомендую обновиться до последней версии ОС, прежде чем приступать к отладке*
После включения DevTerm загружается сразу на рабочий стол, и одним из первых дел я решил настроить соединение по WiFi и включить SSH-сервер. На экране приветствия подробно пояснялось, как это сделать – но старая версия ОС, с которой пришёл мой DevTerm, содержала небольшую опечатку, в связи с чем следование инструкциям приводило к ошибке. Были и ещё кое-какие недочёты, но обновление ПО многое исправило.
Особенно напрягало предустановленное поведение трекбола, так как каждый свайп пальцем приводил лишь к незначительному смещению указателя. Кроме того, трекбол плохо реагирует на диагональные движения. К счастью, один [пользователь [guu] переписал прошивку для клавиатуры](https://forum.clockworkpi.com/t/ive-rewritten-devterm-keyboard-trackball-firmware/7671/23), и я настоятельно рекомендую использовать именно эту обновлённую версию, которая существенно исправляет проблемы с трекболом. Модуль клавиатуры можно перепрограммировать новой прошивкой из оболочки на самом DevTerm, но будет гораздо удобнее сделать это из сеанса ssh, так как физическая клавиатура может на время этого процесса перестать отвечать.
[Обновление ОС моего DevTerm A04 до последней версии](https://forum.clockworkpi.com/t/devterm-os-a04-image-files/7761) исправило большинство бросившихся изначально в глаза проблем – к примеру, отсутствие звука в динамиках, из-за чего я даже усомнился в их правильном подключении – так что рекомендую начать с обновления ОС, и уже потом отлаживать оставшиеся проблемы.
▍ Клавиатура и трекбол
----------------------
Модуль клавиатуры включает в себя миниатюрный трекбол и три отдельных клавиши мыши. При этом клик трекболом по умолчанию приравнивается к клику левой клавишей. Раскладка выглядит симпатично: трекбол расположился посерёдке в верхней части клавиатуры, а три клавиши мыши заняли центральное место под пробелом.
Разработанная Clockwork «клавиатура в формате 65%» имеет классическую раскладку, и я решил, что проще всего печатать на DevTerm будет, взяв его в обе руки и набирая текст большими пальцами, как если бы это был гипертрофированный Blackberry. В качестве альтернативы можно положить устройство на стол. Так клавиатура окажется под наклоном, который подразумевает уже традиционный тип ввода, но лично для меня при таком способе набора клавиши оказались маловаты.
Сенсорного экрана нет, значит, навигация по GUI опирается на использование трекбола либо горячих клавиш. Управлять трекболом, расположенным в верхней центральной части устройства, при клавишах мыши, расположенных внизу, мне показалось весьма неудобным. Чисто функционально комбинация клавиатуры и трекбола в DevTerm обеспечивает все необходимые инструменты в компактной и сбалансированной раскладке. Единственная проблема здесь с эргономичностью.
▍ Удобство удалённого доступа
-----------------------------
DevTerm не всегда используется в качестве исключительно портативной машины. В случае настройки конфигурации и других аналогичных действий, подключение через `ssh` — оказывается более удачным способом, чем работа со встроенной клавиатурой.
Ещё одна альтернатива – это настройка доступа к удалённому рабочему столу, чтобы DevTerm можно было использовать во всей его красе сдвоенного VGA с разрешением 1280х480 прямо с удобного настольного ПК.
Для максимально быстрой реализации этой затеи я установил на девайс пакет `vino` и с помощью TightVNC запустил удалённый сеанс со своего рабочего компьютера.
Vino – это VNC-сервер для среды рабочего стола GNOME, а [TightVNC](https://www.tightvnc.com/download.php) доступен для очень многих систем. VNC-сервер устанавливается командой `sudo apt install vino` (по умолчанию прослушивается порт 5900), и хотя я не рекомендую делать так всем, но последующее выполнение `gsettings set org.gnome.Vino require-encryption false` приведёт к отключению аутентификации и любой защиты соединения, предоставив доступ к рабочему столу DevTerm через один только IP адрес устройства.
Не лучшее решение с позиции безопасности, но оно позволило мне довольно быстро обойти проблемы с трекболом и клавиатурой, что в сложной ситуации может оказаться по-своему ценно.
▍ Термо-печать
--------------
Термопринтер оказался неожиданной плюшкой. Рулон бумаги в нём устанавливается в отдельный съёмный блок. Вообще, функциональность принтера полностью модульная. Печатное оборудование внутри DevTerm расположено сразу за портом расширения, в который устанавливается отсек для бумажной ленты. Этот узел можно полностью удалить и переоборудовать освободившееся место под свои нужды.
С точки зрения функциональности этот мини-принтер работает отлично, и я даже немного попечатал – насколько хватило заряда батарей. Печать при низком заряде ведёт к потускнению картинки, так что лучше этого избегать. Думаю, что это также нужно учитывать, планируя вносить какие-либо модификации.
*Тестовый принт во всей своей миниатюрной красе*
*Съёмный отсек для бумаги (с защитной крышкой)*
*Порт расширения для бумагодержателя (DevTerm на 3D-печатной подставке)*
Качество печати и разрешение во многом аналогичны любому чековому принтеру, так что не стоит ожидать многого. Является ли этот принтер просто маркетинговой фишкой? Возможно, но он определённо является стильной опцией, которую можно использовать как эталон, если вдруг захочется установить на его место иное оборудование.
▍ Кастомизируемый КПК с Linux
-----------------------------
Очевидно, что инженеры ClockworkPi вложили немало усилий в то, чтобы их детище можно было кастомизировать на свой лад. Разъёмы между модулями имеют удобный доступ, при этом есть свободное место на платах, а также немного места внутри корпуса — в частности, за модулем принтера.
Если вдруг захочется поработать с паяльником, то сюда определённо можно втиснуть кастомное оборудование с проводами. Модульная структура основной сборки также способствует простоте модификации, что делает устройство привлекательной основой для сборки кибердеки.
Несмотря на то что 3D-модели физических деталей пока ещё в репозитории проекта недоступны, один предприимчивый деятель уже слепил [3D-макет подставки](https://www.tinkercad.com/things/iB2n0KXmySi), которая удерживает устройство под удобным для работы углом. Когда 3D-модели деталей всё же доберутся до репозитория, это всё сильно упростит.
А что вы думаете о таком дизайне карманного устройства? Есть ли у вас свои идеи по встраиванию в него неаппаратных модов? Как уже говорилось, модуль печати (и связанный с ним слот расширения) можно легко переделать. Лично я неравнодушен к [идее Тома Нарди о создании USB-устройств в формате картриджа](https://hackaday.com/2021/03/13/its-not-a-computer-if-it-doesnt-have-a-cartridge-slot/). Будет здорово, если и вы поделитесь своими мыслями в комментариях.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=obzor_retro-futuristichnogo_kpk_devterm_s_linux) | https://habr.com/ru/post/655123/ | null | ru | null |
# Операционные системы с нуля; Уровень 0
 Добрый день/вечер/ночь/утро! Есть один экспериментальный курс по операционным системам. Есть он в Стэнфордском университете. Но часть материалов доступно всем желающим. Помимо слайдов доступны полные описания практических занятий.
Чем этот курс отличается от прочих других? Большая часть кода пишется самостоятельно и выполняется на вполне реальном современном железе. В качестве целевой платформы выбран [Raspberry Pi 3 model B](https://www.raspberrypi.org/products/raspberry-pi-3-model-b/). Т.е. достаточно актуальная архитектура AArch64. ARMv8 Cortex-A53, четыре ядра, 64-бита и вот это всё. В качестве основного языка программирования выбран [Rust](https://www.rust-lang.org/). Который безопасный, быстрый, без GC и так далее. Его, Rust, предполагается изучать во время курса.
Тут есть про диски, файловые системы, операции ввода-вывода, потоки /процессы, планирование, виртуальную память, защиту и безопасность, прерывания, параллелизм и синхронизацию. Как и в любом другом, уважающем себя курсе. Разница в актуальности материала и в количестве практики. Коддить придётся **много**.
Примечание переводчика
----------------------
Если вы хотели увидеть дословный перевод, то его не будет. Вместо этого я буду стараться сделать текст полезным и понятным. Например в тех местах, которые актуальны только для студентов Стэнфорда, я помещу информацию полезную остальным. Тут может быть немного сленга, чуточку несвязанных с оригиналом иллюстраций и небольшое количество дополнительных комментариев. В угоду читабельности тут не будет явных Примечаний Переводчика™. Текст можно считать художественным переводом или статьёй по мотивам. Я не сварщик — не обижусь.
Откуда я узнал про этот курс? Некто выложил [ссылочку на Hacker News](https://news.ycombinator.com/item?id=16134618). Я случайно увидел и проникся. Немного сам тыкал материалы курса и в итоге решился это дело переводить.
Обзор
-----
В этой части будем настраивать малинку и необходимые инструменты. По итогам у нас будет малинка, мигающая светодиодом. Тут есть четыре основных этапа. Для начала нам требуется убедиться, что связь Pi с компьютером вполне себе работает. Запустим предварительно подготовленную программу. Во втором этапе разберёмся, как светодиодики подключать. Про макетную плату и проводки. На третьем этапе соберём ~~няшный~~ сишный код и запустим его на Pi. Установим кросскомпилятор `aarch64-none-elf` и попробуем его в деле. И на четвёртом этапе перепишем это всё дело на Rust.
Парочка полезных ссылок:
* [Документация по процессору BCM2837](https://web.stanford.edu/class/cs140e/docs/BCM2837-ARM-Peripherals.pdf) — главным образом про периферию
* [Красочная исчерпывающая статья](https://learn.sparkfun.com/tutorials/how-to-use-a-breadboard) про макетную плату и проводки
* [Про использование GPIO в малинке](https://www.raspberrypi.org/documentation/usage/gpio-plus-and-raspi2/README.md)
* [Кратко про базовый синтаксис Rust](https://learnxinyminutes.com/docs/rust/) для тех, кто и так неплохо программирует
* [Оффициальный учебник по Rust](https://doc.rust-lang.org/book/second-edition/) на ангельском ([русскоязычная версия](https://github.com/ruRust/rust_book_2ed) ещё не готова — можно помочь с переводом)
* [Rusty Types for Solid Safety](https://web.stanford.edu/class/cs140e/notes/lec2/paper.pdf)
* [Шпаргалка по лайфтаймам в Rust](https://habrahabr.ru/post/322140/)
* [Шпаргалка по контейнерам в Rust](https://docs.google.com/presentation/d/1q-c7UAyrUlM-eZyTo1pd8SZ0qwA_wYxmPZVOQkoDmH4/present?token=AC4w5VgEyYo5AyyCd0GYMh-mP8O3hNlQQA%3A1518749570893&includes_info_params=1#slide=id.p) (синий текст кликабелен)
Фаза 0: Начало работы
---------------------
Перед выполнением курса следует достать себе в непосредственное пользование unix-подобную операционную систему. Это может быть Linux, BSD или macOS с установленными `git`, `wget`, `tar`, `screen` и `make`. Теоретически может заработать в Windows 10 с подсистемой linux, но никто не проверял наверняка. По крайней мере такая конфигурация не поддерживается. Т.е. для виндузятников нет готовых рецептов и рекомендуется установить [Ubuntu LST](https://www.ubuntu.com/download/desktop) или [Fedora](https://getfedora.org/en/workstation/download/).
Из железа нам потребуются:
* Raspberry Pi 3 model B (обязательно с процем BCM2837)
* Макетная плата, она же доска для прототипирования
* microSD карточка (плюс адаптер/переходник)
* USB-UART переходник (CP2102 USB TTL)
* Десяток многоцветных светодиодов
* Резисторы на 100 Ом и на 1 кОм по четыре штуки
* проводки
В обсуждении на reddit есть [ссылочки](https://www.reddit.com/r/cs140e/comments/7ql4fw/info_general_discussion/dsq6uhz/) на amazon с тем, что может потребоваться. Впрочем всё это можно купить в любом другом магазине. В том числе и в офлайне. Кроме этого всего можно докупить ещё каких либо компонентов на свой вкус.
**Внимание**: малинка чувствительна к электростатике. Старайтесь не трогать голыми руками контакты. Вас током не убьёт и даже не поцарапает, а вот саму малинку вполне себе может вывести из строя. Заземляйтесь.
Когда это всё есть в наличии можно стянуть код задания:
```
git clone https://web.stanford.edu/class/cs140e/assignments/0-blinky/skeleton.git 0-blinky
cd assignment0
make fetch
```
Не стесняйтесь исследовать содержимое самостоятельно.
Фаза 1: Готовим малинку
-----------------------
Первое, что нам требуется сделать — это настройка CP2102-переходника. Он нужен для общения между компьютером и Pi. По мимо этого малинка получает через него жизненно необходимые 5 вольт. С одной стороны USB, с другой штук пять штырьков, посередине платка.
### Настройка драйверов
На линуксе всё должно заработать сразу из коробки. На маках потребуется установить драйвер. Скачиваем [этот архив](https://www.silabs.com/documents/public/software/Mac_OSX_VCP_Driver.zip) и распаковываем. Запускаем `SiLabsUSBDriverDisk.dmg` и соглашаемся с пунктами о продаже души по лицензии. После этого на подмонтированном томе запускаем `Silicon Labs VPC Driver.pkg`. Устанавливаем и перезагружаемся.
Попробуйте вставить CP2102 в свободный USB-слот. Если всё работает, то должны появится соответствующие файлы в `/dev`. В случае мака `/dev/tty.SLAB_USBtoUART`. В случае линукса что-то вроде `/dev/ttyUSB0`. Запишите — пригодится. Вынимаем переходник.
### Подключение малинки
Теперь подключаем Raspberry Pi к CP2102. Вот таблица соответствия разъёмов:
| Разъёмы на CP2102 | Разъёмы на Raspberry Pi |
| --- | --- |
| +5v | 4 |
| GND | 6 |
| RXD | 8 |
| TXD | 10 |
Нумерация пинов на малинке (ещё есть [интерактивная](https://pinout.xyz/) версия):
Всё вместе будет выглядеть так (цвета проводов можно выбирать произвольно):
**Важно**: проверьте и перепроверьте соединения перед подключением этого всего к компьютеру. Нам нужна свежая малинка, а не подгоревшее варенье.
Если есть уверенность в правильности сопряжения малинки и переходника — можно таки подключить CP2102 к компу.
### Запуск
Raspberry Pi подгружает программки с microSD-карточки во время включения. Прямо сейчас мы разберёмся, как это готовить.
Для начала нам нужно скинуть на microSD-шку файлики из склонированного репозитория. А именно те, которые лежат в папке `files/firmware`. Т.е. `bootcode.bin`, `config.txt` и `start.elf`. Скопировать их следует в корень флеш-карты. Если вдруг в склонированном репозитории нет этих файликов — вы забыли про `make fetch`.
> **Зачем нужны `bootcode.bin`, `config.txt` и `start.elf`?**
>
> Это всё является загрузчиком для малинки. `bootcode.bin` — первый загрузчик. Его задача — загрузить `start.elf`. Который настраивает процессор в соответствии с содержимым файла `config.txt`. После этого он загружает `kernel8.img` и передаёт ему управление. Кстати где он?
Теперь копируем `files/activity-led-blink.bin` из репо в корень флеш-карты и даём этому файлику имя `kernel8.img`. Размонтируем карту и вытаскиваем. Убеждаемся, что малинка отключена. Затем вставляем карточку в малинку и подключаем малинку к питанию. Мы должны увидеть мигающий светодиод на малинке и на CP2102-переходнике. Мигание последнего означает, что там передаются некие данные.
Данные? Какие данные? Для того, чтоб посмотреть их нам нужно подключить эмулятор последовательного терминала к CP2102 и прочитать, что там происходит. Будем использовать [screen](https://www.gnu.org/software/screen/manual/screen.html#Overview) ибо он установлен и на Linux, и на macOS. Вспомните путь к устройству из папки `/dev` и запустите
```
screen /dev/<имя> 115200
```
В Linux может потребоваться использовать `sudo` для запуска этой команды. Впрочем можно добавить своего пользователя в группу `dialout` и не писать перед этой командой `sudo` постоянно:
```
sudo gpasswd --add <имя-пользователя> dialout
```
Так или иначе, но мы должны увидеть приветствия от малинки. Для выхода из `screen` следует нажать `k`, а затем ответить `y` на предложение о выходе.
Фаза 2: Мигаем светодиодом
--------------------------
На этом этапе мы подключим 16-й вывод GPIO (физический контакт №36) малинки к светодиодику на макетке. Проверим его работу используя предварительно подготовленный бинарник с прошивкой. Убедитесь что малинка отключена.
### GPIO: General Purpose I/O (Ввод-вывод общего назначения)
Как следует из названия, GPIO является общим механизмом передачи данных/сигналов между какими либо двумя устройствами через электрические контакты.
GPIO-выводы на малинке могут работать как *входы* или как *выходы*. Когда контакт является *выходным*, его можно включить или выключить. Под включением контакта подразумевается, что с него можно взять 3.3 вольта. Под выключением подразумевается, что через этот контакт ток не идёт. Когда же GPIO-контакт является *входным*, то малинка проверяет, есть ли на оном 3.3 вольта, либо же нет.
Эти контакты невероятно, умопомрачительно универсальны и их можно использовать для реализации огромного спектра различных функций. Подробности можно узнать в [документации](https://www.raspberrypi.org/documentation/usage/gpio-plus-and-raspi2/README.md). Документация не просто так прилагается. Её можно, а иногда необходимо, читать по ходу курса.
### Подключение светодиода.
Начнём с построения вот такой схемки:
Если никогда не пользовали макетку, то рекомендуется почитать (или хотяб посмотреть картинки) [вот в этом руководсве](https://learn.sparkfun.com/tutorials/how-to-use-a-breadboard). На нашей схеме мы подсоединяем светодиодик к контакту 3.3 вольта (вывод №1) и к контакту с нулевым потенциалом (за номером 14). Обратите внимание на правильность подключения светодиода. Более короткая его ножка должна быть подключена через резистор к пину 14 (нулевой потенциал, или *земля* (ground) по другому). После этого можно подключить малинку к питанию. Светодиод будет гореть (если всё подключено правильно). Если светодиод перевернуть, то он просто не будет гореть. Он в конце концов такой же [диод](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D0%BE%D0%B4), как и любые его друзья.
Если всё заработало с равномерно горящим светодиодом, то можно попробовать оным помигать. Отрубаем малинку от питания. Теперь переподключаем светодиод от пина 1 к пину 36 (GPIO 16) вот таким образом:
Опять вынимаем карту памяти. Копируем на неё `files/gpio16-blink.bin` под именем `kernel8.img` вместо старого с тем же именем. Ставим карточку обратно и подключаем малинку к питанию. Теперь светодиод должен безудержно мигать.
Фаза 3: Няшный Си
-----------------
На этот раз мы будем писать на сях прогу, которая будет делать тоже, что и `gpio16-blink.bin`. Для того, чтоб иметь возможность компилировать няшную сишечку под малинку нам нужен кросс-компилятор под `aarch64-none-elf`.
### Установка кросс-компилятора
Нам нужно установить GNU-тулчейн для под архитектуру `aarch64-none-elf` (компилятор gcc и его компанию вроде objcopy).
#### Под macOS
Для начала стоит установить менеджер пакетов [homebrew](https://brew.sh/). Если уже установлен, то эту часть можно пропустить.
1. Установите инструменты Xcode для командной строки. Появится диалоговое окно. Когда появится — нажмите "Установить", "Продолжить" или что там обычно.
```
xcode-select --install
```
2. Запустите скрипт установки Homebrew. Оный проведет вас через остальную часть процесса установки.
```
/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
```
Теперь установим тулчейн aarch64-none-elf используя homebrew.
```
brew tap SergioBenitez/osxct
brew install aarch64-none-elf
```
Проверим, всё ли правильно установлено:
```
$ aarch64-none-elf-gcc --version
aarch64-none-elf-gcc (GCC) 7.2.0
Copyright (C) 2017 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
```
#### Под Linux
1. Загрузим и распакуем [aarch64-none-elf-linux-x64.tar.gz](https://web.stanford.edu/class/cs140e/files/aarch64-none-elf-linux-x64.tar.gz). После этого переместим `arch64-none-elf` в `/usr/local/bin`:
```
wget https://web.stanford.edu/class/cs140e/files/aarch64-none-elf-linux-x64.tar.gz
tar -xzvf aarch64-none-elf-linux-x64.tar.gz
sudo mv aarch64-none-elf /usr/local/bin
```
2. Добавим `/usr/local/bin/aarch64-none-elf/bin` к переменной окружения `PATH`. Как именно — это зависит от вашего конкретного диструбутива Linux. В большинстве случаев следует добавить в `~/.profile` следующее:
```
PATH="/usr/local/bin/aarch64-none-elf/bin:$PATH"
```
3. Проверяем, всё ли нормально. В качетве вывода мы должны получить версию gcc и всё такое.
```
aarch64-none-elf-gcc --version
```
Можно собрать самому из исходников, если такое желание возникнет. Подробнее [вот тут](https://wiki.osdev.org/GCC_Cross-Compiler).
### Теперь немного о железе
Взаимодействие подавляющего большинства современных аппаратных устройств с ПО осуществляется через отображение его в память [Memory-mapped I/O](https://en.wikipedia.org/wiki/Memory-mapped_I/O). Суть такова: с устройствами можно общаться так, будто это просто некая часть памяти. При этом предоставляется спецификация о том, что будет происходить при записи или чтении определённых адресов в памяти. Адреса обычно разделяются на кусочки по 32 или 64 бита, которые называют регистрами. Регистры могут быть доступны только для чтения из них, для записи или для того и другого сразу.
Как мы узнаем, какие регистры и для чего использовать, и где в памяти они находятся? Производители различных устройств пишут документацию на эти самые устройства. Обычно их зовут даташитами (data sheet), мануалами (device manual), ну или просто документацией. Нет какого либо общего широко распространённого формата для документирования устройств. Иногда документация может быть недостаточной или её может не быть вообще. Умение читать и понимать аппаратную документацию это вполне себе полезный скилл и в некотором роде даже искусство.
### Интерфейс GPIO в памяти
Документацию на многие периферийные устройства, которые есть у Rasbperry Pi, можно найти в документе [BCM2837 ARM Peripherals Manual](https://web.stanford.edu/class/cs140e/docs/BCM2837-ARM-Peripherals.pdf). Про GPIO можно почитать на 89 странице.
> **Падажжи, там же местами про BCM2835, а у нас BCM2837. Это норм?**
>
>
>
> Если открыть руководство, то там можно увидеть во многих местах упоминание BCM2835. Мы просто взяли руководство к нему и исправили некоторые ошибки. Ну и заголовок поменяли на BCM2837. BCM2837 и BCM2835 имеют одинаковые периферийные устройства с теми же *относительными* адресами в памяти. Основное отличие в общей конфигурации физической памяти. Базовый *физический* адрес периферийных устройств на BCM2837 — `0x3F000000`, в отличии от `0x20000000` в BCM2835. Однако оба чипа отображают эти адреса на `0x7E000000`. Вкратце на BCM2837 "периферийный" адрес `0x7EXXXXXX` будет находится на физическом адресе `0x3FXXXXXX`. Приведённая документация изменена с учётом этого.
Для нашей задачи нам достаточно следующих регистров:
| имя | адрес | описание | размер | чтение/запись |
| --- | --- | --- | --- | --- |
| GPFSEL1 | 0x7E200004 | GPIO Function Select 1 | 32 бита | и то и другое |
| GPSET0 | 0x7E20001C | GPIO Pin Output Set 0 | 32 бита | только запись |
| GPCLR0 | 0x7E200028 | GPIO Pin Output Clear 0 | 32 бита | только запись |
Тащемто это непосредственно скопировано прямо из документации со страницы 90.
Теперь почитайте документацию для регистра `GPFSELn` на страницах 91 и 92. Мы записываем в этот регистр для настройки пинов в качестве выходных или входных. Какое должно быть значение в каждом поле регистра `GPFSEL1` для настройки вывода №16 GPIO, чтоб он стал выходом?
Теперь опять читаем документацию на странице 95. Про регистры `GPSET0` и `GPCLR0`. Мы записываем в регистр `GPSET0` для включения контакта. А в `GPCLR0` для выключения. Какое значение нам требуется записать в эти регистры для включения/выключения вывода 16?
### Написание кода
В каталоге `phase3/` репы есть заготовка кода для построения двоичного файла для малинки. Пока обойдёмся без объяснения того, зачем нужны `crt0.S`, `layout.ld` и `Makefile`. Вместо этого сосредоточимся на `blinky.c`. В нём вы обнаружите, что уже указаны адреса всех трёх необходимых нам регистров в верхней части. Кроме этого там есть парочка функций, которыми можно создать временную задержку. Задача состоит в том, чтоб дополнить функцию `main` так, чтобы вывод №16 GPIO был настроен как выход, а затем то включался, то выключался для мигания светодиодом.
Когда код будет готов — его следует протестировать. Для начала скомпилируйте его, запустив `make`, находясь в директории `phase3/`. Если всё хорошо и нет ошибок, то создастся файлик `blinky.bin`. Переименовываем его в `kernel8.img`, копируем на microSD-карточку и запускаем это всё на малинке. Если уже есть работающий `kernel8.img` — можно переходить к следующей фазе.
> Подсказки:
>
>
>
> Настройка/включение/выключение пинов могут быть реализованы за одну строку кода.
>
>
>
> Тут пригодятся операторы `<<`, `|`, `&` и `~`.
>
>
>
> В сишечке можно использовать шестнадцатеричную и двоичную формы. Для числа три что-то вроде `0x03` и `0b011` соответственно.
Фаза 4: Ржавчина
----------------
В этот раз мы будем писать программу, подобную `gpio16-blink.bin`, но уже на Rust. Код пишем в `phase4/src/lib.rs`.
### Установка Rust и Xargo
Для того, чтоб компилять программы на Rust, нам следует этот самый компейлятор установить. Помимо этого мы установим `xargo`, который является обёрткой, связанной с менеджером пакетов `cargo`. Xargo позволяет нам компейлировать наш код для Rasbperry Pi и всего такого.
1. Идём на <https://rustup.rs/> и следуем инструкциям для установки `rustup`. Убедитесь, что Rust был установлен корректно, запустив `rustc --version`.
2. Теперь используем `rustup` и `cargo` (который установился вместе с rustc на прошлом шаге) для установки ночной сборки Rust. Заодно и исходники стандартной библиотеки установим. И `xargo` разумеется.
```
rustup default nightly-2018-01-09
rustup component add rust-src
cargo install xargo
```
3. Проверяем установленные команды и убеждаемся, что версии всего этого соответствуют тому, чего мы от них хотим:
```
$ rustc --version
rustc 1.25.0-nightly (b5392f545 2018-01-08)
$ xargo --version
xargo 0.3.10
cargo 0.25.0-nightly (a88fbace4 2017-12-29)
```
Теперь у нас есть вполне себе рабочий компилятор Rust.
### Написание кода
Для написания кода в файле `phase4/src/lib.rs` нужно знать по крайней мере следующие конструкции:
1) Вы можете читать из и писать в то, что находится за голыми указателями (`*mut T`) при помощи методов `read_volatile()` и `write_volatile()`. Например у нас объявлено такое:
```
const A: *mut u32 = 0x12 as *mut u32;
const B: *mut u32 = 0x34 as *mut u32;
```
Мы можем записать 32-разрядное целое число без знака с адресом `0x12` в ячейку с адресом `0x34` примерно вот так:
```
B.write_volatile(A.read_volatile());
```
2) Локальные переменные обявляются при помощи конструкции `let имя_переменной = некое_выражение;`.
Можно прочитать `A` из предыдущего примера (т.е. значение, расположенное по адресу `0x12`) в переменную вот таким образом:
```
let value = A.read_volatile();
```
3) Вызвать функцию `fn f(param: usize);` можно вот так: `f(123);`.
4) Блок `loop` можно использовать для бесконечного повторения чего либо:
```
loop {
do_this_again_and_again();
}
```
5) В Rust есть следующие побитовые операторы:
* `!` — инверсия
* `<<` — сдвиг влево
* `>>` — сдвиг вправо
* `|` — битовое ИЛИ
* `&` — битовый И.
Теперь вы готовы помигать светодиодом из кода на Rust. Код пишем в `phase4/src/lib.rs`. Переведите сишный код в аналогичный rust-код (в функции `kmain`). Тут уже объявлены необходимые регистры и функция "сна", которая создаёт задержку на некоторое время. Используйте это всё.
Когда будете готовы проверить свою прогу, скомпилируйте её, запустив `make` в каталоге `phase4`. Если всё нормально, то создастся файл `build/blinky.bin`, который переименовываем в `kernel8.img` и кладём на microSD-карточку, которую затем вставляем в малинку. Когда светодиодик снова замигает — можно считать, что данная часть туториала завершена.
**UPD** [Следующая серия](https://habrahabr.ru/post/351082/) | https://habr.com/ru/post/349248/ | null | ru | null |
# Насильственная оптимизация запросов PostgreSQL
Что делать, когда имеется приложение с закрытым исходным кодом, которое обращается к БД не самым оптимальным образом? Как потюнить запросы, не меняя приложение, а возможно и саму БД?
Если вы не задавались такими вопросами — вы очень успешный и строгий DBA.
Ну а если задавались — позвольте поделиться страданиями и опытом.
### Нужно хранить больше данных, или постановка задачи
Этот раздел можно смело пролистать, если не интересна история вопроса.
Изначально у нас была проприетарная система, которая парсила свои данные из закрытого формата в базу PostgreSQL, откуда мы эти данные читали, анализировали и обрабатывали.
Кроме того, инструментарий этой системы также использовал эту базу для неких операций, так что отказаться от нее и создать копию со своей структурой казалось бесперспективной идеей.
По умолчанию система автоматически удаляла записи старше недели, так что проблем с производительностью на стенде не наблюдалось.
Однако, нам требуется хранить данные намного дольше, покуда хватит места на диске сервера. Ну и очень желательно не терять доступ к этим данным и по прежнему пользоваться встроенным инструментарием системы даже для старых данных.
Поэтому очевидным решением было сделать партиционирование и триггеры на операции INSERT. Фокус достаточно простой и эффективный. Данные вставляются в нужные партиции, удаление старых записей отключили, вроде бы все хорошо.
Пока не прошло пару лет и данных хорошенько не поднакопилось.
Тут «внезапно» оказалось, что запросы, которые делает инструментарий используемой системы, не ограничивает выборку по дате (а точнее ограничивает ее не по тому полю, по которому идет разбиение на партиции). Т.е. если мы что-то ищем — поиск идет по всем партициям. Также начали тормозить и операции UPDATE — в условиях там использовался только ID-шник.
В результате запрос выполняется долго, просаживает все остальные запросы, нагрузка стремительно растет.
Конечно, первое что приходит в голову — обратиться к разработчику.
Однако, в большинстве случаев его либо уже нет в зоне доступа, либо он запросит стоимость еще одной такой системы за доработку в несколько строк.
Поэтому возникла идея, что наверное уже есть какой-то прокси, который может нам помочь.
### Нам нужен прокси
Быстрое гугление не нашло четкого ответа на вопрос, как можно переписать поступивший запрос на стороне PostgreSQL или какого-то стороннего софта.
Поэтому (ну и just for fun тоже, конечно) была написана довольно простая софтина, которая принимает подключения от клиентов и проксирует их в PostgreSQL. При этом поступающие SQL-запросы читаются, и, если нужно, заменяются.
[Делюсь ссылкой на github](https://github.com/nickkarikh/db-query-proxy)
Пока никаких бинарных пакетов не делал, руки не дошли. Но сборка довольно простая. Написано все на C++/Qt, т.к. уже давно на этом пишу…
Конфиг довольно простой:
Указываем какой интерфейс и порт слушать:
```
listen_address=0.0.0.0
listen_port=5433
```
Заставляем нерадивый софт подключаться по указанному адресу вместо прямого подключения к PostgreSQL-серверу.
Прописываем куда пробрасывать соединения (в данном примере прокси размещен на той же машине что и PostgreSQL-сервер):
```
dst_address=127.0.0.1
dst_port=5432
```
Задаем регулярное выражение для отлова нужного запроса:
```
query = SELECT \* FROM tablename WHERE (.+)
```
Говорим что нужно его переписать:
```
action = rewrite
```
Говорим как переписать:
```
rewrite = SELECT * FROM tablename WHERE (col3 >= '$(now-1M)') AND $(1)
```
В данном примере добавляем в условия запроса фильтр по колонке с датой, указывая что нас интересуют только записи за последний месяц.
Можно было бы написать и так:
```
rewrite = SELECT * FROM tablename WHERE (col3 >= now() - interval '1 month') AND $(1)
```
Но тогда запрос не будет оптимальным из-за наличия функции now() — поиск все равно будет осуществляться по всем партициям. Для того чтобы искать только в нужных, необходимо указать значение-константу. Поэтому наш прокси подставляет вместо конструкции $(now-1M) таймстемп уже со сдвигом на один месяц.
Результат (из лога):
```
ORIGINAL query: SELECT * FROM tablename WHERE id=1;
MODIFIED query (rule 1): SELECT * FROM tablename WHERE (col3 >= '2018-11-12 11:25:23.0+00') AND id=1;
```
Таким образом можно подменить, в принципе, любой запрос. Ответы от сервера не изменяются и передаются клиенту как есть. Таким образом минимизируется задержка передачи. Кроме того, приложение обычно ждет ответа определенного формата, поэтому набор колонок в запросе и ответе менять нежелательно.
Также можно легко вывести все интересующие запросы в лог:
```
query = .+
action = log
```
В репозитории есть конфиг с примерами и более детальным описанием.
Кстати, легко определить насколько разработчик грамотно пишет работу с БД. Например, если увидите такой часто выполняющийся запрос, значит кому-то пора покурить мануалы.
```
INSERT INTO tablename (col1, col2, col3) VALUES('value1', 1, '2018-12-31')
```
Должно быть вот так:
```
INSERT INTO tablename (col1, col2, col3) VALUES($1::varchar, $2::integer, $3::date)
```
К сожалению, пока что наш прокси так писать не умеет :/ но сделать это не сложно. Возможно, в будущем можно будет с его помощью переписывать первый запрос на второй.
Да, важный момент — пока что SSL не поддерживается, так что все соединения от клиентов к прокси будут без шифрования.
Буду рад комментариям и замечаниям.
Если будет активный интерес пользователей, возможно буду дальше развивать проект.
Можно добавить работу и с другими базами. | https://habr.com/ru/post/432944/ | null | ru | null |
# adb: tap, swipe и два дымящихся event'а
Разработчики приложений для Android, а также тестировщики знают про команды `adb shell input tap X Y` и `adb shell input swipe X1 Y1 X2 Y2 [DurationMs]`. Но у каждой из них есть свой фатальный недостаток. Что это за недостатки, как их исправить с помощью event'ов и о нюансах я расскажу в этой статье. Да, чуть не забыл: сторонние приложения не используются, рут не нужен.
adb input tap
-------------
Разберём недостатки `adb input tap`. Вообще, эта команда работает хорошо и надёжно, функцию выполняет, но медленно. Под капотом [происходит приблизительно следующее](https://github.com/Genymobile/scrcpy/issues/231): adb соединяется с локальным "серверным" adb-процессом; запрос уходит через него в устройство; на устройстве запускается shell и выполняется скрипт для команды input; этот скрипт запускает новый java-процесс; java-процесс имитирует нажатие. Самым затратным по времени, как пишут по сссылке, является запуск java-процесса. К примеру, на моём Galaxy Note 4, adb input tap выполняется за 1160 мс.
Есть способ получше: пользоваться командой shell'а `sendevent`. И в интернетах обычно так и советуют поступать (или написать свой "sendevent"). Действительно, его использование ускоряет процесс (на том же телефоне один тап проходит за 860 мс), но главный недостаток - в надёжности. Изредка (приблизительно один случай на тысячу или несколько) некоторые сообщения как будто портятся или неполностью обрабатываются. К примеру, два последовательных тапа превращаются в проведение по экрану (из точки первого тапа в точку второго). Есть способ ещё лучше: писать данные напрямую в event-устройство, но сначала немного теории.
Разберёмся, какие команды нужно послать, чтобы сымитировать тап по экрану. Как следует из [документации](https://www.kernel.org/doc/html/v4.13/input/multi-touch-protocol.html), существуют два типа протоколов: A и B. Причём первый помечен как устаревший, и, видимо, более не используется (ни на телефоне, ни на эмуляторе Memu он не работает). Будем пользоваться протоколом B.
Самый простой способ "на коленке" составить список сообщений - это записать сообщения, которые происходят при реальном физическом тапе по экрану. Сначала определим, какое устройство используется для собственно тачскрина. Воспользуемся командой `adb shell getevent -p`. То устройство, у которого в списке `ABS (0003)` будут значения `0030`, `0035` и `0036`, и является тачскрином. Что значат эти числа, я объясню чуть ниже. (строго говоря так выглядит любое устройство, которое реагирует на касания на некоторой области, например тачпад, но такие случаи для упрощения в этой статье не рассматриваются)
Теперь, зная название устройства (к примеру, пусть это будет `/dev/input/event6`) воспользуемся командой `adb shell getevent /dev/input/event6`. Если вывод идёт с задержкой и большими блоками, замените `shell` на `exec-out`: `adb exec-out getevent /dev/input/event6`. Пример вывода от одного тапа по экрану (с телефона):
`0003 0039 0000046E
0001 014a 00000001
0001 0145 00000001
0003 0035 0000039C
0003 0036 000005AC
0003 0030 00000007
0000 0000 00000000
0003 0039 FFFFFFFF
0001 014a 00000000
0001 0145 00000000
0000 0000 00000000`
Каждая строка состоит из трёх шестнадцатеричных чисел. Первое число - это тип сообщения, второе - код сообщения, третье - некторое значение, смысл которого определяется первыми двумя. Разберём подробнее, что значат эти числа, посмотрим в [исходники](https://github.com/torvalds/linux/blob/master/include/uapi/linux/input-event-codes.h). Типы сообщений:
`EV_SYN 0 // синхронизация пакетов, используем только один код:
SYN_REPORT 0 // значение для этого кода всегда 0`
`EV_KEY 1 // кнопки и "кнопки", мы будем использовать следующие коды сообщений:
BTN_TOOL_FINGER 0x0145 // значения: 0 - нет пальца, 1 - есть палец
BTN_TOUCH 0x014A // значения: 0 - нет нажатия, 1 - есть нажатие`
`EV_ABS 3 // абсолютные оси и также MT (multitouch) события, используем следующие коды сообщений:
ABS_MT_TRACKING_ID 0x0039 // идентификатор контакта с тач-скрином
ABS_MT_POSITION_X 0x0035 // координата X
ABS_MT_POSITION_Y 0x0036 // координата Y
ABS_MT_TOUCH_MAJOR 0x0030 // сила нажатия`
Сообщения для взаимодействия складываются в пакеты ~~а пакеты в пакеты с пакетами~~. В первом пакете с прикосновением должен находиться неотрицательный идентификатор контакта с поверхностью. А в последнем для отпускания идентификатор равен -1. Настоящий драйвер для каждого контакта инкрементирует идентификатор, но для простых, не мультитач касаний, можно всегда использовать один и тот же. Например, ноль. Мультитач-касания чуть сложнее и хорошо описаны в документации (продублирую ещё раз [ссылку](https://www.kernel.org/doc/html/v4.13/input/multi-touch-protocol.html)), но выходят за рамки этой статьи.
Единичный тап состоит из касания в указанной точке и из отпускания. Это два пакета:
`EV_ABS, ABS_MT_TRACKING_ID, 0
EV_ABS, ABS_MT_POSITION_X, <координата X>
EV_ABS, ABS_MT_POSITION_Y, <координата Y>
EV_ABS, ABS_MT_TOUCH_MAJOR, 5
EV_KEY, BTN_TOUCH, 1
EV_KEY, BTN_TOOL_FINGER, 1
EV_SYN, SYN_REPORT, 0`
`EV_ABS, ABS_MT_TRACKING_ID, -1
EV_KEY, BTN_TOUCH, 0
EV_KEY, BTN_TOOL_FINGER, 0
EV_ABS, ABS_MT_TOUCH_MAJOR, 0
EV_SYN, SYN_REPORT, 0`
Если пользоваться методом `adb shell sendevent`, и даже если перечислять sendevent'ы через точку с запятой, это всё равно 12 вызовов команды. Посмотрим формат сообщения в [исходнике sendevent.c](https://android.googlesource.com/platform/system/core/+/android-5.0.2_r3/toolbox/sendevent.c). Нас интересует то, что пишется непосредственно в устройство:
`struct input_event {
struct timeval time;
__u16 type;
__u16 code;
__s32 value;
};`
Всё про всё - 16 байт. Структура timeval - это 8 байт, она не используется, все нули. Порядок байт - LSB. К примеру, отправка сообщения`EV_ABS, ABS_MT_TRACKING_ID, -1` приводит к записи в устройство следующих байт:
`0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x03, 0x00, 0x39, 0x00, 0xFF, 0xFF, 0xFF, 0xFF`
В линуксе есть два способа вывода произвольных значений: `printf` и `echo -en`. Но `printf` заканчивает вывод после того, как встретит первый 0 (но при этом, к примеру, `printf "\x31\x00\x32\x00">test.txt` создаст файл размером 2 байта). У `echo` такого недостатка нет. В итоге команда выглядит так: (в кавычках нужно записать все данные пакетов, но я сократил здесь для наглядности)
`adb shell echo -en "\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x39\x00...">/dev/input/event6`
Чтобы каждый раз не запускать процесс adb, можно запустить его один раз с параметром `shell` и записывать ему в stdin команды (после записи не забывать делать flush для stdin).
Для контроля выполнения нажатия запустим второй процесс `adb` с параметром `shell getevent /dev/input/event6` или `exec-out getevent /dev/input/event6` и будем слушать его stdout. Пример вывода - см. выше (три hex-числа в каждой непустой строке). После отправки пакетов для нажатия, ожидаем получения сообщений `EV_ABS, ABS_MT_TRACKING_ID, -1`, а затем `EV_SYN, SYN_REPORT, 0`. Это можно считать подтверждением того, что нажатие было обработано. (да, технически пользователь может тыкнуть в экран, и мы считаем *его* последний пакет, но речь идёт про автоматизированное взаимодействие и пользователя здесь быть не должно)
Выбор `shell` или `exec-out` для `adb getevent` таки зависит от устройства. При старте программы делаем автоопределение: нужно отправить пустышку из четырёх сообщений: `EV_ABS, ABS_MT_TRACKING_ID, 0`; `EV_SYN, SYN_REPORT, 0`; `EV_ABS, ABS_MT_TRACKING_ID, -1`; `EV_SYN, SYN_REPORT, 0`, и если за, скажем, одну десятую секунды ничего не было получено, пробуем другой параметр.
В итоге всё время от отправки команды до получения подтверждения на том же подопытном телефоне составляет около 60 мс, т.е. раз в двадцать быстрее, чем `adb input tap`.
adb input swipe
---------------
Недостатки: как и tap, во-первых, выполняется долго, а во-вторых "от себя" добавляет инерцию. Т.е. это не просто "прикоснуться в точке A, провести до B и отпустить". Реальное отпускание может произойти немного дальше или ближе от указанной точки B. Это зависит от параметра длительности.
Для прямой записи в устройство используются три пакета: прикосновение, перемещение и отпускание завершением:
`EV_ABS, ABS_MT_TRACKING_ID, 0
EV_ABS, ABS_MT_POSITION_X, <координата X1>
EV_ABS, ABS_MT_POSITION_Y, <координата Y1>
EV_ABS, ABS_MT_TOUCH_MAJOR, 5
EV_KEY, BTN_TOUCH, 1
EV_KEY, BTN_TOOL_FINGER, 1
EV_SYN, SYN_REPORT, 0`
`EV_ABS, ABS_MT_POSITION_X, <координата X2>
EV_ABS, ABS_MT_POSITION_Y, <координата Y2>
EV_SYN, SYN_REPORT, 0`
`EV_ABS, ABS_MT_TRACKING_ID, -1
EV_KEY, BTN_TOUCH, 0
EV_KEY, BTN_TOOL_FINGER, 0
EV_ABS, ABS_MT_TOUCH_MAJOR, 0
EV_SYN, SYN_REPORT, 0`
Контроль со стороны `getevent` аналогичен тому, что применялся для тапа. Скорость выполнения тоже практически такая же, как и для тапа.
Примечания и выводы
-------------------
1. В Android до версии 7.1.2 было ограничение на размер shell-команды в 1024 байта. Начиная [с 7.1.2 ограничение снято](https://www.androidpolice.com/2016/04/24/android-n-feature-spotlight-adb-has-much-faster-transfer-speeds-improvements-to-shell-commands-and-a-bunch-of-compatibility-fixes/) (к сожалению, не смог найти официальной информации, как и размера нового ограничения). Тем не менее, приведённые выше команды укладываются и в лимит 1024: для tap длина команды получается 797 байт, для swipe - 989.
2. Можно вести по экрану не просто из точки A в точку B, но и добавлять любые промежуточные точки. А чтобы это происходило не мгновенно, а с задержкой, команду echo можно разбивать таким образом:
`echo -en "данные_пакета">dev/input/event6;sleep delaySec;echo -en "данные_следующего_пакета">dev/input/event6` ... и так далее
, где delaySec - задержка в секундах. Допускается использование дробных чисел, т.е. `sleep 0.1` задержит на 100 мс.
3. При использовании echo-способа, тап и тап с перемещением выполняются существенно быстрее, чем adb input tap/swipe и гарантируют точность. | https://habr.com/ru/post/712374/ | null | ru | null |
# Я давно хотел открыть свою страницу на vkontakte.ru
и наконец я смогу это сделать! теоретически…
итак, основная идея — использовать данные моего профайла на сайте vkontakte.ru при формировании моей домашней страницы (она естественно не требует никакой аутентификации и видна всему интернету — в это и заключается смысл «открывания профайла»). сделать это я планирую используя API, который недавно открыли для разработки социальных сетей и клиентских приложений на основе vkontakte.ru (userapi.com).
зачем это мне? всё просто — у меня пока нет блога и домашней странички тоже нет, но иногда я пишу заметки vkontakte.ru и хочу шарить их ещё и с теми кто предпочитает блоги и xml-ленты (я и сам предпочитаю гугл reader) + с теми, кто ещё не знает меня и возможно и никогда не узнает, если гугл и яндес не будут знать… + в моём профиле достаточно информации, которую я не хочу скрывать, но и копипастить на свой сайт при изменении не хочу
+меня можно будет комментить с openid и вообще доздраствует open social :)
UPD
я зарегистрировал свой «проект» на userapi.com и получил id проекта — при авторизации необходимо указывать это идентификатор — это сделано для того чтобы я имел возможность авторизоваться используя только свой номер на сайте (он указывается при регистрации проекта).
дальше я попробовал авторизоваться как написано в документации и ввёл в строку браузера:
[login.userapi.com/auth?login=force&site=](http://login.userapi.com/auth?login=force&site=)[MY\_PROJECT\_ID]&email=[MY\_EMAIL]&pass=[MY\_PASSWORD]
сервер перенаправил меня сайт моего проекта #sid=сгенерированный идентификатор сессии
«странный механизм» — подумал я — «но работает и какая разница как я получу этот идентификатор»
затем я попробовал получить доступ к данны (из примеров в документации) — передаёшь идентификатор сессии и другие параметры запроса, а в ответ получаешь данные — работает :)
дальше я написал маленький код, чтобы чуть-чуть приблизиться к своей задумке:
`from httplib import HTTPConnection
from urllib import urlencode
import re
site = [MY_PROJECT_ID]
email = [MY_EMAIL]
password = [MY_PASSWORD]
id = 389606
auth_conn = HTTPConnection("login.userapi.com")
auth_conn.request("GET", "/auth?"+urlencode({"login": "force",
"site":site,
"email": email,
"pass":password,}))
auth_resp = auth_conn.getresponse()
location = auth_resp.getheader("location")
auth_conn.close()
sid = re.compile("\w+$").search(location).group()
conn = HTTPConnection("userapi.com")
conn.request("GET", "/data?"+urlencode({"act": "activity",
"from": 0,
"to": 10,
"id": id,
"sid": sid,}))
resp = conn.getresponse()
data = resp.read()
print data
conn.close()`
всё заработало и я решил перенести это дело на хостинг, чтобы быстренько сделать свой сайт на django :) и что я вижу? не могу подключиться к серверу!!! я смотрю в код, пробую wget, потом lynx — тоже самое! проверяю соединение с другими хостами — всё работает, копипую скрипт на другой хостинг — опять не работает :) прошу исполнить мой скрипт друга — работает… и тут я понимаю хостеры тупа забанены!!! зачем?
смотрим в документацию и размышляем… api написан с учетом того, чтобы работать через AJAX (в большинства запросов передаётся имя колбэка и «странная» авторизация сделана по тем же причинам). хостеров видимо забанели чтобы не возможности напрямую «сливать» данные и как защиту от нарушений пользовательского соглашения, предполагая что разработка проектов сторонних будет вестись таким образом что запросы к userapi.com будут идти напрямую от пользователя минуя сервер проекта т.е. сторонний проект по суте предоставлял бы только интерфейс…
по-моему, очень достаточно дурацкая защита… никто не мешает воровать пользовательские данные, а главное пароли с помощью того же AJAX (только вставлять код-воришку не всегда, чтобы втереться в доверие)… почему было не сделать авторизацию так как она реализована в openid?! странно…
в итоге, думаю, не проблема найти «чистенький» хостинг, но может это была дурацкая идея? и vkontakte.ru не мой выбор? | https://habr.com/ru/post/44660/ | null | ru | null |
# Automation: быстрый старт или «А ну-ка, Excel, пиши за меня сам!»
Небольшой топик-шпаргалка для быстрого написания скриптов для автоматической обработки документов ms office'а. А так же для помощи в преодолении синдрома чистого листа.
Как правильно заметили в недавнем [топике](http://habrahabr.ru/blogs/net/139706/), сама работа скрипта может быть и не быстрой, но чаще важнее сам результат, да и объёмы далеко не всегда такие большие. Зато Automation позволяет написать скрипт практически на любом языке. Здесь я выдам заготовки для JavaScript и IronPython, но, надеюсь, в комментариях найдётся место и для других языков (например, на PowerShell).
#### Чуть-чуть лирики
Для работы через automation нужен следующий минимум:
* MS Office (если есть документы, то он, видимо, есть/будет установлен)
* Интерпретатор выбранного языка (для JS, VBS и PowerShell этот пункт не актуален)
* Ещё раз MS Office для подглядывание за генерацией кода в VBA (в записываемых макросах)
Ещё раз повторюсь. Цель — быстро написать скрипт без сложных требований (производительность, встраивание, работа без ms office и т.п.).
#### Собственно, код
Имхо, самый разумный вариант — это JScript или VBScript (точнее [Windows script host](http://msdn.microsoft.com/en-us/library/ms950396.aspx)), т.к. интерпретатор уже идёт с операционной системой, и можно раздавать скрипт друзьям/коллегам, не требуя от них никаких дополнительных действий — перетащил xls(x)-файл на скрипт в explorer'е и работа пошла:
```
var excel = WScript.CreateObject("Excel.Application");
var fileName = WScript.Arguments.Item(0);
try {
main();
} catch(e) {
// Чтобы процесс не завис в памяти
delete excel;
throw e;
}
function main() {
//excel.Visible = true; // Иногда хочется поспать перед экраном, где что-то происходит, но так работает дольше
//var book = excel.Workbooks.Add(); // Новая книга (создать)
var book = excel.Workbooks.Open(fileName); // Старая книга
var sheet = book.Worksheets.Item(1); // (в VBA нумерация с единицы)
// Что-то делаем
for (var i = 1; i <= 10; i++) { // нумерация ячеек с единицы
sheet.Range("A" + i).Value = "hello_" + i;
}
// Сохраняем результат
book.Close(true); // сохранить
//book.Close(true, newFileName); // сохранить как...
WScript.Sleep(2000); // не помню, зачем это :)
}
```
Главный недостаток — сложно отлаживаться (только что убил полчаса на цикл for — нумерация с 0 выдавала ошибку о пропущенной точке с запятой).
Но если цель — написать быстро, а JS/VBS известны гораздо хуже родного и знакомого питона, то (IronPython):
```
# coding=utf-8
# IronPython 2.6
# hint: http://www.ironpython.info/index.php/Interacting_with_Excel
import clr, os
clr.AddReferenceByName('Microsoft.Office.Interop.Excel, Version=11.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c')
from Microsoft.Office.Interop import Excel
ex = Excel.ApplicationClass()
#ex.Visible = True
ex.DisplayAlerts = False
def main():
ws = workbook.Worksheets[1]
# rowsCount = ws.UsedRange.Rows.Count
# Делаем что-то полезное:
for i in range(1,11):
ws.Range("A{0}".format(i)).Value = 'hello_{0}'.format(i)
# Точка входа с контролем ошибок
workbook = ex.Workbooks.Open( os.path.realpath( 'test.xlsx' ) )
try:
main()
finally:
workbook.Save()
workbook.Close()
```
#### Немного полезных фактов
Самая главная подсказка — редактор макросов в Excel. Записываем действие, которое хотим выполнить (*View -> Macros -> Record macro...*, имя значения не имеет), открываем его код (*View -> Macros -> View macros...*) и делаем по образу и подобию. Сама запись макроса — просто набор действий, которые хочется автоматизировать. Например, вставить или изменить какое-то значение, поменять цвет/шрифт и т.п. Запись макроса лучше производить в отдельном документе, во избежание.
Для лучшей ориентации в ~~мире объектов~~ объектном мире Excel — [система классов](http://msdn.microsoft.com/en-us/library/aa209782%28v=office.10%29.aspx) (тоже самое, но для [Office 2010](http://msdn.microsoft.com/en-us/library/ff846392.aspx)).
Небольшой бонус: [константы для цветовых индексов](http://msdn.microsoft.com/en-us/library/aa199411%28office.10%29.aspx).
P.S. Где-то у меня был код для работы с Automation из C++, но это уже совсем другая история :) | https://habr.com/ru/post/139850/ | null | ru | null |
# Как стереть данные так, чтобы их не смогли восстановить спецслужбы?
Восстановление и уничтожение данных — две стороны одной медали. Чтобы знать, когда и как можно вернуть себе информацию, надо понимать и как она может быть уничтожена безвозвратно. А в некоторых ситуациях бывает просто необходимо: например, уничтожение корпоративной информации при утилизации оборудования, уничтожение ваших личных данных при передаче диска в пользование друзьям или продаже, а может быть вы раз и навсегда хотите удалить историю переписки с любовницей ;) Считается, что лучшие специалисты по восстановлению данных работают в спецслужбах, поэтому мы сформулировали вопрос именно таким образом: как уничтожить информацию с диска так, чтобы её не восстановили ни копы из отдела «К», ни Q из Джеймса Бонда, ни даже наши специалисты из [StoreLab](http://www.storelab-rc.ru/).
#### Уничтожение данных программным методом
Если вы хотите ещё использовать жёсткий диск после уничтожения данных, и никуда не тропитесь, то стоит посмотреть в сторону программных методов удаления данных.
##### Полная перезапись диска
Существует много алгоритмов для уничтожения данных через полную перезапись диска. Но все они сводятся к N-кратному форматированию и записи на него двоичных единиц, нулей и псевдослучайных чисел. Так как скорость записи на диск обычно не превышает 70 MB/s, то вооружившись калькулятором мы посчитаем, сколько нам потребуется времени?
Формула достаточно простая: Объём диска (MB) / Скорость записи \* Количество циклов = Секунды;
500000 / 70 \* 7 = 50000 (сек.).
Из этого мы можем сделать вывод, что диск объёмом в 500 GB будет “стираться” около 13 часов. Но стоит ли нам использовать 7 циклов перезаписи? Современные носители информации не оставляют остаточной намагниченности после перезаписи данных. Поэтому нам хватит и одного цикла. Значит времени нам понадобится не 13 часов, а всего лишь 1.5.
Операционные системы имеют инструменты для полного удаления файлов.
Windows:
```
format c:
```
Вместо "*c:*" необходимо указать букву логического раздела.
*Для Windows Vista и старше, предыдущие поколения Windows удаляют только служебную информацию.*
Linux:
```
dd if=/dev/zero of=/dev/sda bs=4k
```
Вместо "*/dev/sda*" необходимо указать адрес устройства для форматирования.
##### Частичная перезапись данных
Используя прямое подключение к жёсткому диску на нижнем уровне через API драйвера диска или собственный драйвер, можно быстро испортить информацию, перезаписывая промежутки данных псевдослучайными числами. Напрямую указывая адрес памяти, в который выполнять запись, мы не нуждаемся в полной перезаписи диска. Также через API драйвера диска можно получить адреса, в которых хранится информация, и перезаписывать только эту область памяти. Данный способ самый сложный в своём исполнении, но с другой стороны позволяет быстро уничтожить только конфиденциальную информацию, сохраняя работоспособность диска.
Работа с драйвером предполагает 2 стадии. Первая — это получение адреса и длину данных, обычно один файл записан в разных местах на диске, поэтому мы получим массив адресов и массив длин. Второй шаг — это запись псевдослучайных чисел в данные области памяти, запись необходимо производить также через драйвер, для того, чтобы операционная система не заблокировала или не перенаправила запись данных в другую область диска.
#### Уничтожение данных вместе с диском
Усложним задачу: представим, что у нас нет времени на безопасное для диска уничтожение данных. В таком случае единственное что вам может помочь — уничтожение самого диска. А если быть точным, то нужно уничтожить только блины, на которые записывается информация.
##### Механическое уничтожение данных
*На картинке показан жёсткий диск после помещения его в устройство для давления жётских дисков ([EDR Solutions](http://edrsolutions.com/))*.
Раз и навсегда уничтожить данные получится, если испортить блины жёсткого диска. Сложно и зачастую невозможно восстановить данные с поцарапанных дисков, не забудьте держать рядом с собой отвёртку, ведь вам придётся снять крышку жёсткого диска и ею же можно жёсткий диск поцарапать. Естественно, данные будут стёрты в тех местах, где была проведена царапина и смежных с ней. В остальных местах данные можно будет восстановить в лаборатории. Не жалейте свои силы на царапины, лёгкие полоски не уничтожат данные даже в местах, где побывала ваша отвёртка. А если погнуть блин, как показано на картинке, то ваши данные уже точно никем никогда не будут восстановлены.
Но уронить диск на пол будет недостаточно. Да, он не определится компьютером, но данные успешно восстановят в лаборатории. HDD диск не переживёт падения со стола, причём в выключенном состоянии высота безопасного падения больше, чем во время работы диска. SSD были разработаны с расчётом на такой случай, даже падение из окна первого-второго этажа не убьёт диск. Это достигается за счёт того, что в SSD нет подвижных элементов, все действия выполняет контроллер. Информация по прежнему может быть прочитана программным или непрограммным способом.
Современные диски сделаны из стекла с магнитным напылением. Достаточно снять крышку диска, вытащить магнитный диск и сломать его. Диск из стекла лёгко ломается, но стоит соблюдать меры безопасности, дабы не порезаться. Слом диска приведёт к разрушению всего слоя напыление и восстановить данные уже не представится возможным.
##### Физически
*«То, что не убивает нас, делает нас сильнее.»* Логично будет предположить и обратное: то, что не делает нас сильнее, убивает нас. Из [предыдущей статьи](http://habrahabr.ru/company/storelab/blog/151043/) вы могли узнать, что охлаждение диска отрицательно влияет на его работу. Но можно ли его так убить? Положив в морозильную камеру ваш носитель важной информации, вы его не убиваете. В ваших руках “бомба” замедленного действия — диск будет работать и с него можно будет прочитать информацию программным способом. Когда же диск сломается, то все данные без особого труда восстанавливаются в “чистой комнате”.
А что диски думают о нагревании? Среди всех устройств диска нас интересуют только блины. Материал, которым покрыт блин, способен размагничиваться при температуре 450 °C. При нагревании магнитный слой должен окисляться и становиться зелёного цвета. Ещё один негативный для диска, но положительный для нас результат даёт температура более 660 °C. 
При такой температуре начинает плавиться алюминий — основа блина жёсткого диска. Температуру в 750 °C в домашних условиях можно получить от пламени свечи или горящей спички. Для достижения максимальной температуры необходимо пламя подставить самым краем к блину.
Также размагнитить диск можно с помощью электромагнита, воздействуя на блин переменным магнитным полем с увеличением расстояния от магнита до диска. Для таких целей было разработано специальное оборудование «[Устройства уничтожения информации](http://www.runtex.ru/)». Воздействуя импульсами на жёсткие диски, они полностью размагничивают диск, что приводит к невозможности восстановить какие-либо данные на нём. Данные устройства уничтожают всё за 2-3 секунды.
##### Химически
Как вы уже, наверное, поняли, чтобы уничтожить данные — нужно уничтожить магнитный слой блина жёсткого диска. На диск достаточно вылить любой жидкости, которая способна изменять свойства ферромагнетиков. Чтобы изменить строение оксида хрома (ферромагнетик, которым покрывают блины жёстких дисков, — магнитный слой диска), необходимо вылить на него соляную кислоту или воду при температуре 100 °C.
#### Что ещё важно?
* Если вам не требуется длительное хранение конфиденциальных данных — записывайте их на энергозависимую (оперативную) память, тогда вам не придётся беспокоиться об уничтожении.
* Убедитесь, что с других носителей, на которых когда-либо была записана копия, нельзя восстановить ваши данные.
* Будьте бдительны при передаче данных по сети. Используйте устройства криптографической защиты. Если ваша информация останется на сервере, то уничтожение её с вашего носителя никак не защитит её. В этом случае имеет смысл шифровать хранимую в облаке информацию специальным софтом.
**Читайте так же:**
* [Пятнадцать мифов о восстановлении и потере данных](http://habrahabr.ru/company/storelab/blog/151043/)
* [Двадцать способов потерять свои данные](http://habrahabr.ru/company/storelab/blog/150499/)
Надеемся, ваши данные всегда будут в безопасности! | https://habr.com/ru/post/151554/ | null | ru | null |
# Готовим Helm с GitLab, KinD и Chart-Testing
В этой статье мы рассмотрим, как более-менее прилично организовать процесс тестирования и публикации чартов, встреченные при этом подводные камни, а также рассмотрим пару великолепных инструментов, которые совершенно незаслуженно получили крайне мало внимания не только на Хабре, но и вообще в русскоязычном сегменте интернета.
Очень кстати, в недавно вышедшем релизе Gitlab 14.1, появился [долгожданный](https://gitlab.com/gitlab-org/gitlab/-/issues/18997) функционал хранения Helm-чартов во встроенном Package Registry. Отлично, заодно и разберемся, как его использовать.
Используемые инструменты
------------------------
### KinD
Первый инструмент, о котором пойдет речь, буквально *kubernetes-in-docker*, позволяет запустить практически полноценный кластер локально на нодах-контейнерах. Под капотом использует kubeadm для настройки узлов и kustomize для слияния предоставленного конфига и сгенерированной внутри конфигурации. Полную документацию можно найти [тут](https://kind.sigs.k8s.io/docs/user/configuration/). Также по желанию можно установить не только ingress-nginx, [манифесты](https://github.com/kubernetes/ingress-nginx/tree/main/deploy/static/provider/kind) которого для KinD можно найти в его репозитории, но и Ambassador или Contour.
Что примечательно, схема с оригинального сайта не совсем верна, внутри контейнера не используется dockershim, а, в соответствие последним тенденциям, kubelet общается с containerd напрямую через сокет.Еще одним моментом будет отсутствие поддержки сервисов типа LoadBalancer. Поэтому до развернутого приложения нужно ходить по INTERNAL-IP ноды, узнать который можно с помощью kubectl или docker inspect, например:
```
kubectl get no -o wide
NAME STATUS ROLES AGE VERSION INTERNAL-IP EXTERNAL-IP OS-IMAGE KERNEL-VERSION CONTAINER-RUNTIME
k8s-test-control-plane Ready master 36h v1.19.11 172.18.1.2 Ubuntu 21.04 5.4.0-80-generic containerd://1.5.2
k8s-test-worker Ready compute 36h v1.19.11 172.18.1.3 Ubuntu 21.04 5.4.0-80-generic containerd://1.5.2
```
Запущенные контейнеры-ноды помечаются лейбами `io.x-k8s.kind.cluster` и `io.x-k8s.kind.role`, в дальнейшем нам это пригодится.
Сейчас и далее предполагается, что локально уже установлен Docker, описывать в этой статье [инструкцию](https://docs.docker.com/engine/install/) его установки сочту излишним. Аналогично поступим и с [Helm](https://helm.sh/ru/docs/intro/install/).
Устанавливаем kind в систему:
```
curl -Lo ./kind "https://kind.sigs.k8s.io/dl/v0.11.1/kind-$(uname)-amd64"
chmod +x ./kind
sudo mv ./kind /usr/local/bin/kind
```
### Chart Testing
Второй инструмент - chart-testing, [репо](https://github.com/helm/chart-testing) и [документацию](https://github.com/helm/chart-testing/blob/main/doc/ct.md) которого можно найти на GitHub. В паре с [chart-releaser](https://github.com/helm/chart-releaser) широко применяется для организации репо Helm-чартов в Github-pages. Оба имеют соответствующие экшены: [chart-testing-action](https://github.com/helm/chart-testing-action) и [chart-releaser-action](https://github.com/helm/chart-releaser-action).
Инструмент позволит упростить автоматизацию тестирования наших чартов, причем отберет из них только измененные по сравнению с master/main веткой origin. Будучи добавлен в pre-commit хук, не позволит забыть увеличить версию Helm-чарта. Что он нам поможет делать:
* Прогон линта по нашим свеженаписанным Helm-чартам.
* Валидацию Chart.yaml.
* Развертывание Helm-чарта в отдельный сгенерированный неймспейс текущего активного кластера kubernetes (не обязательно KinD).
* Очистка окружения за собой вне зависимости от успешности развертывания.
Понятно, что все вышеперечисленное можно сделать и с помощью Bash-полотна, python, костыля и пары велосипедов, но мы ведь не за этим сюда пришли, правда? Хотя Bash-полотно все-таки будет.
Установка:
```
sudo mkdir -p /tmp/ct /etc/ct
curl -sL "https://github.com/helm/chart-testing/releases/download/v3.4.0/chart-testing_3.4.0_linux_amd64.tar.gz" | tar -xvz -C /tmp/ct
sudo mv /tmp/ct/etc/chart_schema.yaml /etc/ct/chart_schema.yaml
sudo mv /tmp/ct/etc/lintconf.yaml /etc/ct/lintconf.yaml
sudo mv /tmp/ct/ct /usr/local/bin/ct
sudo chmod +x /usr/local/bin/ct
rm -rf /tmp/ct
```
На этом вводное рассмотрение инструментария заканчиваем и переходим к подготовке пайплайна.
Кейс первый: публичный репозиторий и DinD
-----------------------------------------
Создаем и клонируем к себе git-репо, можно использовать и уже существующий проект, но для простоты повествования опишу процесс создания “с нуля”. В корне проекта создаем и переходим в директорию `charts`. Создаем наш первый чарт:
```
mkdir charts
cd charts
helm create test-chart
```
В Chart.yaml нужно добавить `keywords` и `maintainers`:
```
keywords:
- example
maintainers:
- name:
email:
```
Сразу стоит уточнить, что проверка мейнтейнеров проводится по наличию пути `https:///`. Отключить её можно в следующем конфиге ct.yaml, добавив `validate-maintainers: false`.
Зачастую необходимо производить тестирование чарта с какими-либо предопределенными параметрами. Чтобы их передать при раскатке с помощью ct, нужно создать директорию `ci` в директории конкретного чарта и в ней разместить `*-values.yaml`, например, `./charts/test-chart/ci/test-values.yaml`. Таких файлов может быть несколько, но не указывайте в них пересекающиеся значения, т.к. порядок применения или только некоторые из них выбрать нельзя.
Далее создадим файлы:
`ct.yaml` - конфиг chart-testing, позволит минимизировать указание ключей при запуске.
ct.yaml
```
# See https://github.com/helm/chart-testing#configuration
remote: origin
target-branch: main
chart-dirs:
- charts
helm-extra-args: --timeout=120s
```
`kind-cluster.yaml` - конфиг KinD. Кластер kubernetes будет разворачиваться внутри сервиса DinD (docker-in-docker), соответственно, описываем, что api-сервер должен слушать все интерфейсы, патч ClusterConfiguration, где добавляем хостнейм, с которым будем к нему подключаться, тип и количество нод.
Версия kubernetes выбирается через версию docker-имаджа KinD. Доступные варианты перечислены в [release notes](https://github.com/kubernetes-sigs/kind/releases/tag/v0.11.1) на GitHub.
Ноды добавляются просто повторением одной и той же строки, например, при указании двух строк `- role: worker` будет создано две воркер-ноды. Таким же образом можно варьировать и количество мастер-нод.
kind-cluster.yaml
```
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
networking:
ipFamily: ipv4
apiServerAddress: "0.0.0.0"
kubeadmConfigPatchesJSON6902:
- group: kubeadm.k8s.io
version: v1beta2
kind: ClusterConfiguration
patch: |
- op: add
path: /apiServer/certSANs/-
value: docker
nodes:
- role: control-plane
- role: worker
```
`.gitlab-ci.yml` - описание пайплайна. Документацию по синтаксису можно найти [здесь](https://docs.gitlab.com/ce/ci/yaml/). Публичный GitLab “из коробки” предоставляет облачные раннеры с Docker, нам же потребуется настроить запуск сервиса DinD рядом с контейнером, в котором будет бежать выполнение пайплайна. Также и в сами образы, используемые для запуска джоб, в процессе выполнения нужно будет добавить недостающие бинари и конфиги утилит. Конфиг исключительно для примера, никто не запрещает собрать свой образ со всем необходимым для этого пайплайна.
.gitlab-ci.yml
```
# Объявляем стадии пайплайна
stages:
- "lint"
- "chart-test"
- "chart-release"
variables:
# Выбираем версию kubectl, соответственно используемой версии kubernetes
CI_KUBECTL_VER: v1.19.0
# Объявляем версии Helm, chart-testing и KinD
CI_HELM_VER: v3.6.3
CI_CT_VER: v3.4.0
CI_KIND_VERSION: v0.11.1
# Часть пути, по которому мы в дальнейшем будем подключать Helm-репо
CI_HELM_CHANNEL: stable
# Название создаваемого кластера kubernetes
CI_KIND_CLUSTER_NAME: k8s-test
# Для удобства переписываем в переменные имаджи нод с дайджестами
# в соответствии с используемой версией KinD
CI_KIND_IMAGE_1_17: 'kindest/node:v1.17.17@sha256:66f1d0d91a88b8a001811e2f1054af60eef3b669a9a74f9b6db871f2f1eeed00'
CI_KIND_IMAGE_1_18: 'kindest/node:v1.18.19@sha256:7af1492e19b3192a79f606e43c35fb741e520d195f96399284515f077b3b622c'
CI_KIND_IMAGE_1_19: 'kindest/node:v1.19.11@sha256:07db187ae84b4b7de440a73886f008cf903fcf5764ba8106a9fd5243d6f32729'
CI_KIND_IMAGE_1_20: 'kindest/node:v1.20.7@sha256:cbeaf907fc78ac97ce7b625e4bf0de16e3ea725daf6b04f930bd14c67c671ff9'
CI_KIND_IMAGE_1_21: 'kindest/node:v1.21.1@sha256:69860bda5563ac81e3c0057d654b5253219618a22ec3a346306239bba8cfa1a6'
# Указываем, какой образ будем использовать в этом пайплайне
CI_KIND_IMAGE: $CI_KIND_IMAGE_1_19
# Описываем небольшие сниппеты, которые легко переиспользовать в нескольких джобах,
# а также улучшают читабельность кода.
.check-and-unshallow: &check-and-unshallow
- git version
- |
if [ -f "$(git rev-parse --git-dir)/shallow" ]; then
echo "this is a shallow repository";
git fetch --unshallow --prune --prune-tags --verbose
else
echo "not a shallow repository";
git fetch --prune --prune-tags --verbose
fi
- git rev-parse --verify HEAD
- git rev-list HEAD --count
- git rev-list HEAD --count --first-parent
.get-kube-binaries: &get-kube-binaries
- apk add -U wget
- wget -O /usr/local/bin/kind "https://github.com/kubernetes-sigs/kind/releases/download/${CI_KIND_VERSION}/kind-linux-amd64"
- chmod +x /usr/local/bin/kind
- wget -O /usr/local/bin/kubectl "https://storage.googleapis.com/kubernetes-release/release/${CI_KUBECTL_VER}/bin/linux/amd64/kubectl"
- chmod +x /usr/local/bin/kubectl
.install-ct: &install-ct
- |
export CT_URL="https://github.com/helm/chart-testing/releases/download/${CI_CT_VER}"
export CT_TAR_FILE="chart-testing_${CI_CT_VER#v}_linux_amd64.tar.gz"
echo "install chart-testing ${CI_CT_VER} from \"${CT_URL}/${CT_TAR_FILE}\""
mkdir -p /tmp/ct /etc/ct
wget -O "/tmp/${CT_TAR_FILE}" "${CT_URL}/${CT_TAR_FILE}"
tar -xzvf "/tmp/${CT_TAR_FILE}" -C /tmp/ct
mv /tmp/ct/etc/chart_schema.yaml /etc/ct/chart_schema.yaml
mv /tmp/ct/etc/lintconf.yaml /etc/ct/lintconf.yaml
mv /tmp/ct/ct /usr/bin/ct
rm -rf /tmp/ct
ct version
.install-helm: &install-helm
- |
export HELM_URL="https://get.helm.sh"
export HELM_TAR_FILE="helm-${CI_HELM_VER}-linux-amd64.tar.gz"
echo "install HELM ${CI_HELM_VER} from \"${HELM_URL}/${HELM_TAR_FILE}\""
mkdir -p /tmp/helm
wget -O "/tmp/${HELM_TAR_FILE}" "${HELM_URL}/${HELM_TAR_FILE}"
tar -xzvf "/tmp/${HELM_TAR_FILE}" -C /tmp/helm
mv /tmp/helm/linux-amd64/helm /usr/bin/helm
rm -rf /tmp/helm
chmod +x /usr/bin/helm
helm version
# Добавляем Package Registry проекта с авторизацией через job-token
# и плагин для push в Helm-репо
.helm-add-project-as-repo: &helm-add-project-as-repo
- >-
helm repo add
--username gitlab-ci-token
--password "${CI_JOB_TOKEN}"
"${CI_PROJECT_NAME}"
"${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/helm/${CI_HELM_CHANNEL}"
- helm plugin install https://github.com/chartmuseum/helm-push.git
- helm repo list
# Описываем сами джобы
# Линт. Тут просто берем родной имадж chart-testing, ничего дабавлять не требуется
chart-lint:
stage: lint
image: quay.io/helmpack/chart-testing:v3.4.0
tags:
- "docker"
script:
- *check-and-unshallow
- ct lint --config ct.yaml
only:
- pushes
except:
- master
- main
# Здесь добавляем все необходимые бинари, поднимаем KinD
# и разворачиваем в него тестируемые чарты
chart-test:
stage: chart-test
image: docker:20.10-git
variables:
# Use TLS https://docs.gitlab.com/ee/ci/docker/using_docker_build.html#tls-enabled
DOCKER_HOST: tcp://docker:2376
DOCKER_TLS_CERTDIR: "/certs"
# Сервис DinD нам не нужен в остальных джобах, поэтому укажем его здесь,
# чтобы не замедлять весь пайплайн
services:
- name: docker:20.10-dind
alias: docker
tags:
- "docker"
script:
- *check-and-unshallow
- apk add -U wget
# Добавляем недостающие бинари
- *get-kube-binaries
- *install-ct
- *install-helm
# разворачиваем KinD
- >-
kind create cluster
--name ${CI_KIND_CLUSTER_NAME}
--image ${CI_KIND_IMAGE}
--config=kind-cluster.yaml
--wait 5m
# Правим kubeconfig, чтобы указанный хост api-server соответствовал хосту DinD,
# который, в свою очередь, мы ранее указали в патче ClusterConfiguration
- sed -i -E -e 's/127\.0\.0\.1|0\.0\.0\.0/docker/g' "$HOME/.kube/config"
# Разворачиваем наши чарты
- ct install --config ct.yaml
after_script:
# не обязательно, т.к. сервис все равно будет погашен с завершением джобы
- kind delete cluster --name k8s-test
only:
- pushes
except:
- master
- main
# Упаковываем чарты и публикуем их в Package Registry
chart-release:
stage: chart-release
image: quay.io/helmpack/chart-testing:v3.4.0
tags:
- "docker"
script:
- *check-and-unshallow
- apk add jq yq
- *helm-add-project-as-repo
# используем доработанный скрипт из экшена chart-releaser
- >-
./gitlab-cr.sh
--charts-dir charts
--charts-repo-url "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/helm/${CI_HELM_CHANNEL}"
--repo "${CI_PROJECT_NAME}"
only:
- master
- main
```
Зачем тут unshallow? Chart-testing просматривает историю гит для поиска измененных чартов, а GitLab по умолчанию делает shallow clone с глубиной 50 коммитов, что дает вероятность его [падения](https://github.com/helm/chart-testing/issues/186), когда он пытается просмотреть больше. Это поведение можно настроить через [clone](https://docs.gitlab.com/ee/ci/pipelines/settings.html#choose-the-default-git-strategy), а не fetch или через [git depth](https://docs.gitlab.com/ee/ci/pipelines/settings.html#limit-the-number-of-changes-fetched-during-clone), на вкус и цвет, так сказать.
Канал Helm-repo лучше использовать один, например, stable (название на самом деле можно выбрать любое) или же минимальное их разнообразие. Дело в том, что в интерфейсе GitLab определить какой чарт из какого канала можно примерно никак и разнообразие нейминга в этом случае приведет только к увеличению хаоса. В целом работает аналогично Chartmuseum и Helm-repo в GitHub-pages. Получить и распарсить индекс можно по пути `"${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/helm/${CI_HELM_CHANNEL}/index.yaml"`
Также обращу внимание, что поиск изменений происходит при сравнении текущего HEAD и указанного в конфиге ct `target-branch` в origin. Это еще один повод не пушить в мастер, т.к. в таком случае внутри пайплайна сравнивать будет не с чем.
Представленный пайплайн предполагает разработку в отдельной ветке, там же прогоняется линт и тестирование, затем мердж в мастер, где происходит упаковка и публикация чарта в Package Registry.
`gitlab-cr.sh` Скрипт упаковки и публикации чарта мы подсмотрим в оригинальном GitHub [экшене](https://github.com/helm/chart-releaser-action/blob/main/cr.sh). К сожалению, chart-releaser с GitLab пока не работает, поэтому перепишем на использование helm для поиска версии чарта по Helm-repo, а затем упаковки и публикации, если текущей версии найдено не будет:
gitlab-cr.sh
```
#!/usr/bin/env bash
# Copyright The Helm Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
set -o errexit
set -o nounset
set -o pipefail
needy_tools=("jq" "yq" "helm")
show_help() {
cat << EOF
Usage: $(basename "$0")
-h, --help Display help
-d, --charts-dir The charts directory (default: charts)
-u, --charts-repo-url The Gitlab helm package registry URL (default: "/projects//packages/helm/stable")
-r, --repo The repo name
EOF
}
main() {
local charts\_dir=charts
local repo=
local charts\_repo\_url=
parse\_command\_line "$@"
for tool in "${needy\_tools[@]}"; do
assert\_tools "$tool"
done
local repo\_root
repo\_root=$(git rev-parse --show-toplevel)
pushd "$repo\_root" > /dev/null
echo 'Looking up latest tag...'
local latest\_tag
latest\_tag=$(lookup\_latest\_tag)
echo "Discovering changed charts since '$latest\_tag'..."
local changed\_charts=()
readarray -t changed\_charts <<< "$(lookup\_changed\_charts "$latest\_tag")"
if [[ -n "${changed\_charts[\*]}" ]]; then
rm -rf .cr-release-packages
mkdir -p .cr-release-packages
rm -rf .cr-index
mkdir -p .cr-index
for chart in "${changed\_charts[@]}"; do
if [[ -d "$chart" ]]; then
package\_chart "$chart"
else
echo "Chart '$chart' no longer exists in repo. Skipping it..."
fi
done
release\_charts "$repo"
else
echo "Nothing to do. No chart changes detected."
fi
popd > /dev/null
}
parse\_command\_line() {
while :; do
case "${1:-}" in
-h|--help)
show\_help
exit
;;
-d|--charts-dir)
if [[ -n "${2:-}" ]]; then
charts\_dir="$2"
shift
else
echo "ERROR: '-d|--charts-dir' cannot be empty." >&2
show\_help
exit 1
fi
;;
-u|--charts-repo-url)
if [[ -n "${2:-}" ]]; then
charts\_repo\_url="$2"
shift
else
echo "ERROR: '-u|--charts-repo-url' cannot be empty." >&2
show\_help
exit 1
fi
;;
-r|--repo)
if [[ -n "${2:-}" ]]; then
repo="$2"
shift
else
echo "ERROR: '--repo' cannot be empty." >&2
show\_help
exit 1
fi
;;
\*)
break
;;
esac
shift
done
if [[ -z "$repo" ]]; then
echo "ERROR: '-r|--repo' is required." >&2
show\_help
exit 1
fi
if [[ -z "$charts\_repo\_url" ]]; then
charts\_repo\_url="${CI\_API\_V4\_URL}/projects/${CI\_PROJECT\_ID}/packages/helm/stable"
fi
}
lookup\_latest\_tag() {
git fetch --tags > /dev/null 2>&1
if ! git describe --tags --abbrev=0 2> /dev/null; then
git rev-list --max-parents=0 --first-parent HEAD
fi
}
filter\_charts() {
while read -r chart; do
[[ ! -d "$chart" ]] && continue
local file="$chart/Chart.yaml"
if [[ -f "$file" ]]; then
echo "$chart"
else
echo "WARNING: $file is missing, assuming that '$chart' is not a Helm chart. Skipping." 1>&2
fi
done
}
lookup\_changed\_charts() {
local commit="$1"
local changed\_files
changed\_files=$(git diff --find-renames --name-only "$commit" -- "$charts\_dir")
local depth=$(( $(tr "/" "\n" <<< "$charts\_dir" | sed '/^\(\.\)\*$/d' | wc -l) + 1 ))
local fields="1-${depth}"
cut -d '/' -f "$fields" <<< "$changed\_files" | uniq | filter\_charts
}
lookup\_chart\_in\_repo\_by\_version() {
local chart="$1"
local chart\_version
chart\_version="$(yq r "${chart}/Chart.yaml" 'version')"
local chart\_name
chart\_name="$(yq r "${chart}/Chart.yaml" 'name')"
helm search repo "${repo}/${chart\_name}" --version "$chart\_version" -o json | jq -r '.[].version'
}
package\_chart() {
local chart="$1"
local chart\_version\_in\_repo
chart\_version\_in\_repo="$(lookup\_chart\_in\_repo\_by\_version "$chart")"
local args=("$chart" --destination .cr-release-packages)
if [[ -z "$chart\_version\_in\_repo" ]]; then
echo "Packaging chart '$chart'..."
helm package "${args[@]}"
else
echo "$chart with version $chart\_version\_in\_repo already exist in repo. Skipping..."
fi
}
release\_charts() {
local repo="$1"
echo 'Releasing charts...'
for f in .cr-release-packages/\*.tgz
do
[ -e "$f" ] || break
helm push "$f" "$repo"
done
}
assert\_tools() {
local tool="$1"
command -v "$tool" >/dev/null 2>&1 || {
echo "ERROR: ${tool} is not installed." >&2
exit 1
}
}
main "$@"
```
Готово. Коммитим, пушим в develop и наблюдаем, как пайплайн становится зеленым, после чего мерджим нашу ветку в master(main) и по завершению пайплайна получаем тарболл чарта в Package Registry.
Добавляем Helm-repo (подставьте свой ID проекта):
```
helm repo add habr-test https://gitlab.com/api/v4/projects//packages/helm/stable
"habr-test" has been added to your repositories
```
Проверяем, что тестовый чарт опубликован:
```
helm search repo habr-test/test-chart
NAME CHART VERSION APP VERSION DESCRIPTION
habr-test/test-chart 0.1.0 1.16.0 A Helm chart for Kubernetes
```
Кейс второй: раннер с монтированием сокета Docker
-------------------------------------------------
Сразу оговорюсь, что монтирование сокета с хоста в контейнеры, создаваемые раннером не лучшее решение в плане безопасности, но пока что необходимо, например, если вы пользуетесь [werf](https://werf.io/). В таком случае запустить DinD будет как минимум не самой тривиальной задачей, т.к. сокет монтируется и в контейнеры сервисов.
Тем не менее задача легко решаема, поскольку контейнеры KinD в этом случае будут подниматься в Docker хоста, где запущен раннер, а интерфейс docker0 доступен изнутри контейнера и практически всегда имеет адрес `172.17.0.1`. Как и в случае с сервисом DinD мы добавим этот адрес через патч ClusterConfiguration в `kind-cluster.yaml`:
```
kubeadmConfigPatchesJSON6902:
- group: kubeadm.k8s.io
version: v1beta2
kind: ClusterConfiguration
patch: |
- op: add
path: /apiServer/certSANs/-
value: 172.17.0.1
```
И sed’ом по ходу выполнения пайплайна заменим `0.0.0.0` в кубконфиге на адрес интерфейса docker0: `sed -i -E -e 's/0\.0\.0\.0/172\.17\.0\.1/g' "$HOME/.kube/config"`
Кроме того, нужно позаботиться и об удалении контейнеров KinD в случае отмены задания GitLab, т.к. контейнер задания будет просто убит kill без выполнения `after_script`. Подробнее с сутью проблемы можно ознакомиться в этом [issue](https://gitlab.com/gitlab-org/gitlab/-/issues/15603). В этом нам помогут лейбы, которые KinD ставит на запускаемые контейнеры нод. Сперва добавляем CI\_JOB\_ID в переменную названия кластера, затем, перед запуском кластера, создаем контейнер “мертвой руки”, который после некоторого таймаута будет завершать контейнеры с лейбой `io.x-k8s.kind.cluster=job-${CI_JOB_ID}`.
Пример пайплайна для работы с docker0
```
# Объявляем стадии пайплайна
stages:
- "lint"
- "chart-test"
- "chart-release"
variables:
# Выбираем версию kubectl, соответственно используемой версии kubernetes
CI_KUBECTL_VER: v1.19.0
# Объявляем версии Helm, chart-testing и KinD
CI_HELM_VER: v3.6.3
CI_CT_VER: v3.4.0
CI_KIND_VERSION: v0.11.1
# Часть пути, по которому мы в дальнейшем будем подключать Helm-репо
CI_HELM_CHANNEL: stable
# Название создаваемого кластера kubernetes
CI_KIND_CLUSTER_NAME: job-${CI_JOB_ID}
# Название контейнера отложенного удаления кластера
CI_KIND_REAPER_NAME: job-${CI_JOB_ID}-reaper
# Для удобства переписываем в переменные имаджи нод с дайджестами
# в соответствии с используемой версией KinD
CI_KIND_IMAGE_1_17: 'kindest/node:v1.17.17@sha256:66f1d0d91a88b8a001811e2f1054af60eef3b669a9a74f9b6db871f2f1eeed00'
CI_KIND_IMAGE_1_18: 'kindest/node:v1.18.19@sha256:7af1492e19b3192a79f606e43c35fb741e520d195f96399284515f077b3b622c'
CI_KIND_IMAGE_1_19: 'kindest/node:v1.19.11@sha256:07db187ae84b4b7de440a73886f008cf903fcf5764ba8106a9fd5243d6f32729'
CI_KIND_IMAGE_1_20: 'kindest/node:v1.20.7@sha256:cbeaf907fc78ac97ce7b625e4bf0de16e3ea725daf6b04f930bd14c67c671ff9'
CI_KIND_IMAGE_1_21: 'kindest/node:v1.21.1@sha256:69860bda5563ac81e3c0057d654b5253219618a22ec3a346306239bba8cfa1a6'
# Указываем, какой образ будем использовать в этом пайплайне
CI_KIND_IMAGE: $CI_KIND_IMAGE_1_19
# Описываем небольшие сниппеты, которые легко переиспользовать в нескольких джобах,
# а также улучшают читабельность кода.
.check-and-unshallow: &check-and-unshallow
- git version
- |
if [ -f "$(git rev-parse --git-dir)/shallow" ]; then
echo "this is a shallow repository";
git fetch --unshallow --prune --prune-tags --verbose
else
echo "not a shallow repository";
git fetch --prune --prune-tags --verbose
fi
- git rev-parse --verify HEAD
- git rev-list HEAD --count
- git rev-list HEAD --count --first-parent
.get-kube-binaries: &get-kube-binaries
- wget -nv -O /usr/local/bin/kind "https://github.com/kubernetes-sigs/kind/releases/download/${CI_KIND_VERSION}/kind-linux-amd64"
- chmod +x /usr/local/bin/kind
- wget -nv -O /usr/local/bin/kubectl "https://storage.googleapis.com/kubernetes-release/release/${CI_KUBECTL_VER}/bin/linux/amd64/kubectl"
- chmod +x /usr/local/bin/kubectl
.install-ct: &install-ct
- |
export CT_URL="https://github.com/helm/chart-testing/releases/download/${CI_CT_VER}"
export CT_TAR_FILE="chart-testing_${CI_CT_VER#v}_linux_amd64.tar.gz"
echo "install chart-testing ${CI_CT_VER} from \"${CT_URL}/${CT_TAR_FILE}\""
mkdir -p /tmp/ct /etc/ct
wget -nv -O "/tmp/${CT_TAR_FILE}" "${CT_URL}/${CT_TAR_FILE}"
tar -xzvf "/tmp/${CT_TAR_FILE}" -C /tmp/ct
mv /tmp/ct/etc/chart_schema.yaml /etc/ct/chart_schema.yaml
mv /tmp/ct/etc/lintconf.yaml /etc/ct/lintconf.yaml
mv /tmp/ct/ct /usr/bin/ct
rm -rf /tmp/ct
ct version
.install-helm: &install-helm
- |
export HELM_URL="https://get.helm.sh"
export HELM_TAR_FILE="helm-${CI_HELM_VER}-linux-amd64.tar.gz"
echo "install HELM ${CI_HELM_VER} from \"${HELM_URL}/${HELM_TAR_FILE}\""
mkdir -p /tmp/helm
wget -nv -O "/tmp/${HELM_TAR_FILE}" "${HELM_URL}/${HELM_TAR_FILE}"
tar -xzvf "/tmp/${HELM_TAR_FILE}" -C /tmp/helm
mv /tmp/helm/linux-amd64/helm /usr/bin/helm
rm -rf /tmp/helm
chmod +x /usr/bin/helm
helm version
# Добавляем Package Registry проекта с авторизацией через job-token
# и плагин для push в Helm-репо
.helm-add-project-as-repo: &helm-add-project-as-repo
- >-
helm repo add
--username gitlab-ci-token
--password "${CI_JOB_TOKEN}"
"${CI_PROJECT_NAME}"
"${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/helm/${CI_HELM_CHANNEL}"
- helm plugin install https://github.com/chartmuseum/helm-push.git
- helm repo list
# Создаем контейнер отложенной очистки
.create-kind-reaper: &create-kind-reaper
- >-
docker run --rm -d --name ${CI_KIND_REAPER_NAME}
-e CI_KIND_CLUSTER_NAME=${CI_KIND_CLUSTER_NAME}
-e CI_REAPER_SLEEP=${CI_REAPER_SLEEP:-300}
-v /var/run/docker.sock:/var/run/docker.sock
docker:20.10
sh -c
'sleep ${CI_REAPER_SLEEP};
docker rm -fv $(docker ps -aq --filter label=io.x-k8s.kind.cluster=${CI_KIND_CLUSTER_NAME})'
# Описываем сами джобы
# Линт. Тут просто берем родной имадж chart-testing, ничего дабавлять не требуется
chart-lint:
stage: lint
image: quay.io/helmpack/chart-testing:v3.4.0
tags:
- "docker"
script:
- *check-and-unshallow
- ct lint --config ct.yaml
only:
- pushes
except:
- master
- main
# Здесь добавляем все необходимые бинари, поднимаем KinD
# и разворачиваем в него тестируемые чарты
chart-test:
stage: chart-test
image: docker:20.10-git
tags:
- "docker"
script:
- *check-and-unshallow
- apk add -U wget
# Добавляем недостающие бинари
- *get-kube-binaries
- *install-ct
- *install-helm
# запускаем рипер
- *create-kind-reaper
# разворачиваем KinD
- >-
kind create cluster
--name ${CI_KIND_CLUSTER_NAME}
--image ${CI_KIND_IMAGE}
--config=kind-cluster.yaml
--wait 5m
# Правим kubeconfig, чтобы указанный хост api-server соответствовал хосту docker0,
# адрес которого, в свою очередь, мы ранее указали в патче ClusterConfiguration
- sed -i -E -e 's/0\.0\.0\.0/172\.17\.0\.1/g' "$HOME/.kube/config"
# Разворачиваем наши чарты
- ct install --config ct.yaml
after_script:
# удаляем кластер KinD
- kind delete cluster --name ${CI_KIND_CLUSTER_NAME}
# удаляем контейнер отложенной очистки
- docker rm -fv ${CI_KIND_REAPER_NAME}
only:
- pushes
except:
- master
- main
# Упаковываем чарты и публикуем их в Package Registry
chart-release:
stage: chart-release
image: quay.io/helmpack/chart-testing:v3.4.0
tags:
- "docker"
script:
- *check-and-unshallow
- apk add jq yq
- *helm-add-project-as-repo
# используем доработанный скрипт из экшена chart-releaser
- >-
./gitlab-cr.sh
--charts-dir charts
--charts-repo-url "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/helm/${CI_HELM_CHANNEL}"
--repo "${CI_PROJECT_NAME}"
only:
- master
- main
```
Для подключения к приватному Helm-репо на pull будет достаточно прав `read_api` персонального токена, но намного правильнее использовать для этого [deploy token](https://docs.gitlab.com/ee/user/project/deploy_tokens/index.html) с правами `read_package_registry`. Аналогичный пример подключения Helm-репо с авторизацией токеном задания GitLab можно найти в сниппете "helm-add-project-as-repo".
### Заключение
Статья получилась довольно насыщенной ссылками на документацию, но возможно, это облегчит путь тех, кто еще не слишком уверенно ориентируется в предметной области. Кроме того все материалы собраны в [репо на GitHub](https://github.com/hornwind/habr-gitlab-kind-ct).
Благодарю за внимание и надеюсь, что этот дебют получился достаточно интересным и поможет вам в автоматизации своего проекта или послужит отправной точкой в изучении новых инструментов. | https://habr.com/ru/post/574496/ | null | ru | null |
# Битва двух якодзун, или Cassandra vs HBase. Опыт команды Сбербанка
Это даже не шутка, похоже, что именно эта картинка наиболее точно отражает суть этих БД, и в конце будет понятно почему:
Согласно DB-Engines Ranking, две самых популярных NoSQL колоночных базы — это Cassandra (далее CS) и HBase (HB).
Волею судеб наша команда управления загрузки данных в Сбербанке уже [давно](https://habr.com/ru/company/sberbank/blog/420425/) и плотно работает с HB. За это время мы достаточно хорошо изучили её сильные и слабые стороны и научились её готовить. Однако наличие альтернативы в виде CS все время заставляло немного терзать себя сомнениями: а правильный ли выбор мы сделали? Тем более, что результаты [сравнения](https://www.datastax.com/products/compare/nosql-performance-benchmarks), выполненного DataStax, говорили, что CS легко побеждает HB практически с разгромным счетом. С другой стороны, DataStax — заинтересованное лицо, и верить на слово тут не стоит. Также смущало достаточно малое количество информации об условиях тестирования, поэтому мы решили выяснить самостоятельно, кто же является королем BigData NoSql, и полученные результаты оказались весьма интересны.
Однако прежде чем перейти к результатам выполненных тестов, необходимо описать существенные аспекты конфигураций среды. Дело в том, что CS может использоваться в режиме допускающем потерю данных. Т.е. это когда только один сервер (нода) отвечает за данные некоего ключа и если он по какой-то причине отвалился, то значение этого ключа будет потеряно. Для многих задач это не критично, однако для банковской сферы это скорее исключение, чем правило. В нашем случае принципиально иметь несколько копий данных для надежного хранения.
Поэтому рассматривался исключительно режим работы CS в режиме тройной репликации, т.е. создание кейспейса выполнялось с такими параметрами:
```
CREATE KEYSPACE ks WITH REPLICATION = {'class' : 'NetworkTopologyStrategy', 'datacenter1' : 3};
```
Далее есть два способа обеспечить необходимый уровень консистентности. Общее правило:
NW + NR > RF
Что означает, что количество подтверждений от нод при записи (NW) плюс количество подтверждений от нод при чтении (NR) должно быть больше фактора репликации. В нашем случае RF = 3 и значит подходят следующие варианты:
2 + 2 > 3
3 + 1 > 3
Так как нам принципиально важно максимально надежно сохранить данные, была выбрана схема 3+1. К тому же HB работает по аналогичному принципу, т.е. такое сравнение будет более честным.
Необходимо отметить, что DataStax в своем исследовании делали наоборот, они ставили RF = 1 и для CS и для HB (для последней путем изменения настроек HDFS). Это действительно важный аспект, потому что влияние на производительность CS в этом случае огромное. Например, на картинке ниже показан рост времени требующегося для загрузки данных в CS:
Тут мы видим следующее, чем больше конкурирующих потоков пишет данные, тем дольше времени это занимает. Это естественно, но важно, что при этом деградация производительности для RF=3 существенно выше. Иными словами, если мы пишем в 4 таблицы в каждую по 5 потоков (итого 20), то RF=3 проигрывает примерно в 2 раза (150 секунд RF=3 против 75 для RF=1). Но если мы увеличим нагрузку, загружая данные в 8 таблиц в каждую по 5 потоков (итого 40), то проигрыш RF=3 уже в 2,7 раз (375 секунд против 138).
Возможно, отчасти в этом заключается секрет успешного для CS нагрузочного тестирования выполненного DataStax, потому что для HB на нашем стенде изменение фактора репликации с 2 до 3 не оказало никакого влияния. Т.е. диски не являются узким местом для HB для нашей конфигурации. Однако тут есть много и других подводных камней, потому что нужно отметить, что наша версия HB была немного пропатчена и затюнена, среды совершенно разные и т.д. Также стоит отметить, что возможно я просто не знаю как правильно готовить CS и существуют какие-то более эффективные способы работать с ней и надеюсь в комментариях мы выясним это. Но обо всем по порядку.
Все тесты производились на железном кластере состоящем из 4 серверов, каждый в конфигурации:
*CPU: Xeon E5-2680 v4 @ 2.40GHz 64 threads.
Диски: 12 штук SATA HDD
java version: 1.8.0\_111*
Версия CS: 3.11.5
**Параметры cassandra.yml**num\_tokens: 256
hinted\_handoff\_enabled: true
hinted\_handoff\_throttle\_in\_kb: 1024
max\_hints\_delivery\_threads: 2
hints\_directory: /data10/cassandra/hints
hints\_flush\_period\_in\_ms: 10000
max\_hints\_file\_size\_in\_mb: 128
batchlog\_replay\_throttle\_in\_kb: 1024
authenticator: AllowAllAuthenticator
authorizer: AllowAllAuthorizer
role\_manager: CassandraRoleManager
roles\_validity\_in\_ms: 2000
permissions\_validity\_in\_ms: 2000
credentials\_validity\_in\_ms: 2000
partitioner: org.apache.cassandra.dht.Murmur3Partitioner
data\_file\_directories:
— /data1/cassandra/data # каждая директория dataN — отдельный диск
— /data2/cassandra/data
— /data3/cassandra/data
— /data4/cassandra/data
— /data5/cassandra/data
— /data6/cassandra/data
— /data7/cassandra/data
— /data8/cassandra/data
commitlog\_directory: /data9/cassandra/commitlog
cdc\_enabled: false
disk\_failure\_policy: stop
commit\_failure\_policy: stop
prepared\_statements\_cache\_size\_mb:
thrift\_prepared\_statements\_cache\_size\_mb:
key\_cache\_size\_in\_mb:
key\_cache\_save\_period: 14400
row\_cache\_size\_in\_mb: 0
row\_cache\_save\_period: 0
counter\_cache\_size\_in\_mb:
counter\_cache\_save\_period: 7200
saved\_caches\_directory: /data10/cassandra/saved\_caches
commitlog\_sync: periodic
commitlog\_sync\_period\_in\_ms: 10000
commitlog\_segment\_size\_in\_mb: 32
seed\_provider:
— class\_name: org.apache.cassandra.locator.SimpleSeedProvider
parameters:
— seeds: "\*,\*"
concurrent\_reads: 256 # пробовали 64 — разницы не замечено
concurrent\_writes: 256 # пробовали 64 — разницы не замечено
concurrent\_counter\_writes: 256 # пробовали 64 — разницы не замечено
concurrent\_materialized\_view\_writes: 32
memtable\_heap\_space\_in\_mb: 2048 # пробовали 16 Гб — было медленнее
memtable\_allocation\_type: heap\_buffers
index\_summary\_capacity\_in\_mb:
index\_summary\_resize\_interval\_in\_minutes: 60
trickle\_fsync: false
trickle\_fsync\_interval\_in\_kb: 10240
storage\_port: 7000
ssl\_storage\_port: 7001
listen\_address: \*
broadcast\_address: \*
listen\_on\_broadcast\_address: true
internode\_authenticator: org.apache.cassandra.auth.AllowAllInternodeAuthenticator
start\_native\_transport: true
native\_transport\_port: 9042
start\_rpc: true
rpc\_address: \*
rpc\_port: 9160
rpc\_keepalive: true
rpc\_server\_type: sync
thrift\_framed\_transport\_size\_in\_mb: 15
incremental\_backups: false
snapshot\_before\_compaction: false
auto\_snapshot: true
column\_index\_size\_in\_kb: 64
column\_index\_cache\_size\_in\_kb: 2
concurrent\_compactors: 4
compaction\_throughput\_mb\_per\_sec: 1600
sstable\_preemptive\_open\_interval\_in\_mb: 50
read\_request\_timeout\_in\_ms: 100000
range\_request\_timeout\_in\_ms: 200000
write\_request\_timeout\_in\_ms: 40000
counter\_write\_request\_timeout\_in\_ms: 100000
cas\_contention\_timeout\_in\_ms: 20000
truncate\_request\_timeout\_in\_ms: 60000
request\_timeout\_in\_ms: 200000
slow\_query\_log\_timeout\_in\_ms: 500
cross\_node\_timeout: false
endpoint\_snitch: GossipingPropertyFileSnitch
dynamic\_snitch\_update\_interval\_in\_ms: 100
dynamic\_snitch\_reset\_interval\_in\_ms: 600000
dynamic\_snitch\_badness\_threshold: 0.1
request\_scheduler: org.apache.cassandra.scheduler.NoScheduler
server\_encryption\_options:
internode\_encryption: none
client\_encryption\_options:
enabled: false
internode\_compression: dc
inter\_dc\_tcp\_nodelay: false
tracetype\_query\_ttl: 86400
tracetype\_repair\_ttl: 604800
enable\_user\_defined\_functions: false
enable\_scripted\_user\_defined\_functions: false
windows\_timer\_interval: 1
transparent\_data\_encryption\_options:
enabled: false
tombstone\_warn\_threshold: 1000
tombstone\_failure\_threshold: 100000
batch\_size\_warn\_threshold\_in\_kb: 200
batch\_size\_fail\_threshold\_in\_kb: 250
unlogged\_batch\_across\_partitions\_warn\_threshold: 10
compaction\_large\_partition\_warning\_threshold\_mb: 100
gc\_warn\_threshold\_in\_ms: 1000
back\_pressure\_enabled: false
enable\_materialized\_views: true
enable\_sasi\_indexes: true
Настройки GC:
**### CMS Settings**-XX:+UseParNewGC
-XX:+UseConcMarkSweepGC
-XX:+CMSParallelRemarkEnabled
-XX:SurvivorRatio=8
-XX:MaxTenuringThreshold=1
-XX:CMSInitiatingOccupancyFraction=75
-XX:+UseCMSInitiatingOccupancyOnly
-XX:CMSWaitDuration=10000
-XX:+CMSParallelInitialMarkEnabled
-XX:+CMSEdenChunksRecordAlways
-XX:+CMSClassUnloadingEnabled
Памяти jvm.options выделялось 16Gb (еще пробовали 32 Gb, разницы не замечено).
Создание таблиц выполнялось командой:
```
CREATE TABLE ks.t1 (id bigint PRIMARY KEY, title text) WITH compression = {'sstable_compression': 'LZ4Compressor', 'chunk_length_kb': 64};
```
Версия HB: 1.2.0-cdh5.14.2 (в классе org.apache.hadoop.hbase.regionserver.HRegion нами был исключен MetricsRegion который приводил к GC при кол-ве регионов более 1000 на RegionServer)
**Параметры non-default HBase**zookeeper.session.timeout: 120000
hbase.rpc.timeout: 2 minute(s)
hbase.client.scanner.timeout.period: 2 minute(s)
hbase.master.handler.count: 10
hbase.regionserver.lease.period, hbase.client.scanner.timeout.period: 2 minute(s)
hbase.regionserver.handler.count: 160
hbase.regionserver.metahandler.count: 30
hbase.regionserver.logroll.period: 4 hour(s)
hbase.regionserver.maxlogs: 200
hbase.hregion.memstore.flush.size: 1 GiB
hbase.hregion.memstore.block.multiplier: 6
hbase.hstore.compactionThreshold: 5
hbase.hstore.blockingStoreFiles: 200
hbase.hregion.majorcompaction: 1 day(s)
HBase Service Advanced Configuration Snippet (Safety Valve) for hbase-site.xml:
hbase.regionserver.wal.codecorg.apache.hadoop.hbase.regionserver.wal.IndexedWALEditCodec
hbase.master.namespace.init.timeout3600000
hbase.regionserver.optionalcacheflushinterval18000000
hbase.regionserver.thread.compaction.large12
hbase.regionserver.wal.enablecompressiontrue
hbase.hstore.compaction.max.size1073741824
hbase.server.compactchecker.interval.multiplier200
Java Configuration Options for HBase RegionServer:
-XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:CMSInitiatingOccupancyFraction=70 -XX:+CMSParallelRemarkEnabled -XX:ReservedCodeCacheSize=256m
hbase.snapshot.master.timeoutMillis: 2 minute(s)
hbase.snapshot.region.timeout: 2 minute(s)
hbase.snapshot.master.timeout.millis: 2 minute(s)
HBase REST Server Max Log Size: 100 MiB
HBase REST Server Maximum Log File Backups: 5
HBase Thrift Server Max Log Size: 100 MiB
HBase Thrift Server Maximum Log File Backups: 5
Master Max Log Size: 100 MiB
Master Maximum Log File Backups: 5
RegionServer Max Log Size: 100 MiB
RegionServer Maximum Log File Backups: 5
HBase Active Master Detection Window: 4 minute(s)
dfs.client.hedged.read.threadpool.size: 40
dfs.client.hedged.read.threshold.millis: 10 millisecond(s)
hbase.rest.threads.min: 8
hbase.rest.threads.max: 150
Maximum Process File Descriptors: 180000
hbase.thrift.minWorkerThreads: 200
hbase.master.executor.openregion.threads: 30
hbase.master.executor.closeregion.threads: 30
hbase.master.executor.serverops.threads: 60
hbase.regionserver.thread.compaction.small: 6
hbase.ipc.server.read.threadpool.size: 20
Region Mover Threads: 6
Client Java Heap Size in Bytes: 1 GiB
HBase REST Server Default Group: 3 GiB
HBase Thrift Server Default Group: 3 GiB
Java Heap Size of HBase Master in Bytes: 16 GiB
Java Heap Size of HBase RegionServer in Bytes: 32 GiB
+ZooKeeper
maxClientCnxns: 601
maxSessionTimeout: 120000
Создание таблиц:
*hbase org.apache.hadoop.hbase.util.RegionSplitter ns:t1 UniformSplit -c 64 -f cf
alter 'ns:t1', {NAME => 'cf', DATA\_BLOCK\_ENCODING => 'FAST\_DIFF', COMPRESSION => 'GZ'}*
Тут есть один важный момент — в описании DataStax не сказано, сколько регионов использовалось при создании таблиц HB, хотя это критично для больших объемов. Поэтому для тестов было выбрано кол-во = 64, что позволяет хранить до 640 ГБ, т.е. таблицу среднего размера.
В HBase на момент проведения теста было 22 тысячи таблиц и 67 тысяч регионов (это было бы убийственно для версии 1.2.0, если бы не патч о котором сказано выше).
Теперь что касается кода. Так как не было ясности, какие конфигурации являются более выигрышным для той или иной БД, тесты производились в различных комбинациях. Т.е. в одних тестах загрузка шла одновременно в 4 таблицы (для подключения использовались все 4 ноды). В других тестах работали с 8 разными таблицами. В некоторых случаях размер батча был равен 100, в других 200 (параметр batch — см. код ниже). Размер данных для value 10 байт или 100 байт (dataSize). Всего каждый раз записывалось и вычитывалось по 5 млн. записей в каждую таблицу. При этом в каждую таблицу писали/читали 5 потоков (номер потока — thNum), каждый из которых использовал свой диапазон ключей (count = 1 млн):
```
if (opType.equals("insert")) {
for (Long key = count * thNum; key < count * (thNum + 1); key += 0) {
StringBuilder sb = new StringBuilder("BEGIN BATCH ");
for (int i = 0; i < batch; i++) {
String value = RandomStringUtils.random(dataSize, true, true);
sb.append("INSERT INTO ")
.append(tableName)
.append("(id, title) ")
.append("VALUES (")
.append(key)
.append(", '")
.append(value)
.append("');");
key++;
}
sb.append("APPLY BATCH;");
final String query = sb.toString();
session.execute(query);
}
} else {
for (Long key = count * thNum; key < count * (thNum + 1); key += 0) {
StringBuilder sb = new StringBuilder("SELECT * FROM ").append(tableName).append(" WHERE id IN (");
for (int i = 0; i < batch; i++) {
sb = sb.append(key);
if (i+1 < batch)
sb.append(",");
key++;
}
sb = sb.append(");");
final String query = sb.toString();
ResultSet rs = session.execute(query);
}
}
```
Соответственно аналогичный функционал был предусмотрен для HB:
```
Configuration conf = getConf();
HTable table = new HTable(conf, keyspace + ":" + tableName);
table.setAutoFlush(false, false);
List lGet = new ArrayList<>();
List lPut = new ArrayList<>();
byte[] cf = Bytes.toBytes("cf");
byte[] qf = Bytes.toBytes("value");
if (opType.equals("insert")) {
for (Long key = count \* thNum; key < count \* (thNum + 1); key += 0) {
lPut.clear();
for (int i = 0; i < batch; i++) {
Put p = new Put(makeHbaseRowKey(key));
String value = RandomStringUtils.random(dataSize, true, true);
p.addColumn(cf, qf, value.getBytes());
lPut.add(p);
key++;
}
table.put(lPut);
table.flushCommits();
}
} else {
for (Long key = count \* thNum; key < count \* (thNum + 1); key += 0) {
lGet.clear();
for (int i = 0; i < batch; i++) {
Get g = new Get(makeHbaseRowKey(key));
lGet.add(g);
key++;
}
Result[] rs = table.get(lGet);
}
}
```
Так как в HB о равномерном распределении данных должен заботиться клиент, то функция соления ключа выглядела так:
```
public static byte[] makeHbaseRowKey(long key) {
byte[] nonSaltedRowKey = Bytes.toBytes(key);
CRC32 crc32 = new CRC32();
crc32.update(nonSaltedRowKey);
long crc32Value = crc32.getValue();
byte[] salt = Arrays.copyOfRange(Bytes.toBytes(crc32Value), 5, 7);
return ArrayUtils.addAll(salt, nonSaltedRowKey);
}
```
Теперь самое интересное — результаты:
Тоже самое в виде графика:
Преимущество HB настолько удивительное, что есть подозрение о наличие какого-то узкого места в настройке CS. Однако гуглеж и кручение наиболее очевидных параметров (вроде concurrent\_writes или memtable\_heap\_space\_in\_mb) ускорения не дало. При этом в логах чисто, ни на что не ругается.
Данные легли по нодам равномерно, статистика со всех нод примерно одинаковая.
**Вот как выглядит статистика по таблице с одной из нод**Keyspace: ks
Read Count: 9383707
Read Latency: 0.04287025042448576 ms
Write Count: 15462012
Write Latency: 0.1350068438699957 ms
Pending Flushes: 0
Table: t1
SSTable count: 16
Space used (live): 148.59 MiB
Space used (total): 148.59 MiB
Space used by snapshots (total): 0 bytes
Off heap memory used (total): 5.17 MiB
SSTable Compression Ratio: 0.5720989576459437
Number of partitions (estimate): 3970323
Memtable cell count: 0
Memtable data size: 0 bytes
Memtable off heap memory used: 0 bytes
Memtable switch count: 5
Local read count: 2346045
Local read latency: NaN ms
Local write count: 3865503
Local write latency: NaN ms
Pending flushes: 0
Percent repaired: 0.0
Bloom filter false positives: 25
Bloom filter false ratio: 0.00000
Bloom filter space used: 4.57 MiB
Bloom filter off heap memory used: 4.57 MiB
Index summary off heap memory used: 590.02 KiB
Compression metadata off heap memory used: 19.45 KiB
Compacted partition minimum bytes: 36
Compacted partition maximum bytes: 42
Compacted partition mean bytes: 42
Average live cells per slice (last five minutes): NaN
Maximum live cells per slice (last five minutes): 0
Average tombstones per slice (last five minutes): NaN
Maximum tombstones per slice (last five minutes): 0
Dropped Mutations: 0 bytes
Попытка уменьшать размер батча (вплоть до отправки поштучно) не дала эффекта, стало только хуже. Возможно, что на самом деле это действительно максимум производительности для CS, так как полученные результаты по CS похожи на те, что получились и у DataStax — порядка сотни тысяч операций в секунду. Кроме того, если посмотреть на утилизацию ресурсов, то увидим, что CS использует гораздо больше и ЦПУ и дисков:
*На рисунке показана утилизация во время прогона всех тестов подряд для обоих БД.*
Что касается мощного преимущества HB при чтении. Тут видно, что для обоих БД утилизация дисков при чтении крайне низкая (тесты на чтение это завершающая часть цикла тестирования каждой БД, например для CS это с 15:20 до 15:40). В случае HB причина понятна — большая часть данных висит в памяти, в memstore и часть закешировалась в blockcache. Что касается CS, то тут не очень ясно как она устроена, однако также утилизации дисков не видно, но на всякий случай была сделана попытка включить кэш row\_cache\_size\_in\_mb = 2048 и установлен caching = {‘keys’: ‘ALL’, ‘rows\_per\_partition’: ‘2000000’}, но от этого стало даже чуть хуже.
Также стоит еще раз проговорить существенный момент про кол-во регионов в HB. В нашем случае было указано значение 64. Если же уменьшать его и сделать равным например 4, то при чтении скорость падает в 2 раза. Причина в том, что memstore будет забиваться быстрее и файлы будут флашиться чаще и при чтении нужно будет обрабатывать больше файлов, что для HB достаточно сложная операция. В реальных условиях это лечится продумыванием стратегии пресплитинга и компактификации, в частности мы используем самописную утилиту, которая занимается сборкой мусора и сжатием HFiles постоянно в фоновом режиме. Вполне возможно, что для тестов DataStax выделяли вообще 1 регион на таблицу (что не правильно) и это бы несколько прояснило, почему HB так проигрывал в их тестах на чтение.
Предварительные выводы отсюда получаются следующие. Если допустить, что в ходе тестирования не было допущено грубых ошибок, то Cassandra похожа на колосса на глиняных ногах. Точнее, пока она балансирует на одной ноге, как на картинке в начале статьи, она показывает относительно неплохие результаты, но при схватке в одинаковых условиях проигрывает вчистую. При этом учитывая низкую утилизацию CPU на нашем железе мы научились высаживать по два RegionServer HB на хост и тем самым удвоили производительность. Т.е. с учетом утилизации ресурсов ситуация для CS получается еще более плачевная.
Безусловно, эти тесты достаточно синтетические и объем данных, который использовался тут, относительно скромный. Не исключено, что при переходе на терабайты ситуация была бы иная, однако если для HB мы умеем грузить терабайты, то для CS это оказалось проблематично. Она зачастую выдавала OperationTimedOutException даже при этих объемах, хотя параметры ожидания отклика и так были увеличены в разы по сравнению с дефолтными.
Надеюсь, что совместными усилиями мы найдем узкие места CS и если получится её ускорить, то в конце поста обязательно добавлю информацию об итоговых результатах.
**UPD:** Были применены следующие рекомендации на настройке CS:
*disk\_optimization\_strategy: spinning
MAX\_HEAP\_SIZE=«32G»
HEAP\_NEWSIZE=«3200M»
-Xms32G
-Xmx32G
-XX:+UseG1GC
-XX:G1RSetUpdatingPauseTimePercent=5
-XX:MaxGCPauseMillis=500
-XX:InitiatingHeapOccupancyPercent=70
-XX:ParallelGCThreads=32
-XX:ConcGCThreads=8*
Что касается настроек ОС, это достаточно долгая и сложная процедура (получать рута, ребутить сервера и т.д.), поэтому эти рекомендации не применялись. С другой стороны, обе БД в равных условиях, так что все честно.
В части кода, сделан один коннектор для всех потоков пишущих в таблицу:
```
connector = new CassandraConnector();
connector.connect(node, null, CL);
session = connector.getSession();
session.getCluster().getConfiguration().getSocketOptions().setConnectTimeoutMillis(120000);
KeyspaceRepository sr = new KeyspaceRepository(session);
sr.useKeyspace(keyspace);
prepared = session.prepare("insert into " + tableName + " (id, title) values (?, ?)");
```
Данные отправлялись через биндинг:
```
for (Long key = count * thNum; key < count * (thNum + 1); key++) {
String value = RandomStringUtils.random(dataSize, true, true);
session.execute(prepared.bind(key, value));
}
```
Это не оказало ощутимого влияния на производительность записи. Для надежности запустил нагрузку инструментом YCSB, абсолютно такой же результат. Ниже статистика по одному потоку (из 4х):
*2020-01-18 14:41:53:180 315 sec: 10000000 operations; 21589.1 current ops/sec; [CLEANUP: Count=100, Max=2236415, Min=1, Avg=22356.39, 90=4, 99=24, 99.9=2236415, 99.99=2236415] [INSERT: Count=119551, Max=174463, Min=273, Avg=2582.71, 90=3491, 99=16767, 99.9=99711, 99.99=171263]
[OVERALL], RunTime(ms), 315539
[OVERALL], Throughput(ops/sec), 31691.803548848162
[TOTAL\_GCS\_PS\_Scavenge], Count, 161
[TOTAL\_GC\_TIME\_PS\_Scavenge], Time(ms), 2433
[TOTAL\_GC\_TIME\_%\_PS\_Scavenge], Time(%), 0.7710615803434757
[TOTAL\_GCS\_PS\_MarkSweep], Count, 0
[TOTAL\_GC\_TIME\_PS\_MarkSweep], Time(ms), 0
[TOTAL\_GC\_TIME\_%\_PS\_MarkSweep], Time(%), 0.0
[TOTAL\_GCs], Count, 161
[TOTAL\_GC\_TIME], Time(ms), 2433
[TOTAL\_GC\_TIME\_%], Time(%), 0.7710615803434757
[INSERT], Operations, 10000000
[INSERT], AverageLatency(us), 3114.2427012
[INSERT], MinLatency(us), 269
[INSERT], MaxLatency(us), 609279
[INSERT], 95thPercentileLatency(us), 5007
[INSERT], 99thPercentileLatency(us), 33439
[INSERT], Return=OK, 10000000*
Тут видно что скорость одного потока порядка 32 тыс записей в секунду, работало 4 потока, получается 128 тыс. Кажется, большего на текущих настройках дисковой подсистемы не выжать.
Насчет чтения интереснее. Благодаря советам камрадов его удалось радикально ускорить. Чтение осуществлялось не в 5 потоков, а в 100. Увеличение до 200 эффекта уже не давало. Также в билдер добавлено:
.withLoadBalancingPolicy(new TokenAwarePolicy(DCAwareRoundRobinPolicy.builder().build()))
В результате, если раньше тест показывал 159 644 ops (5 потоков, 4 таблицы, батч 100), то теперь:
100 потоков, 4 таблицы, батч = 1 (поштучно): 301 969 ops
100 потоков, 4 таблицы, батч = 10: 447 608 ops
100 потоков, 4 таблицы, батч = 100: 625 655 ops
Так как результаты лучше с батчами, прогнал аналогичные\* тесты с HB:
*\*Так как при работе в 400 потоков функция RandomStringUtils, которая использовалась ранее, грузила CPU на 100%, она была заменена более быстрым генератором.*
Таким образом, увеличение количества потоков при загрузке данных дает небольшой прирост производительности HB.
Что касается чтения, тут приведены результаты нескольких вариантов. По просьбе [0x62ash](https://habr.com/ru/users/0x62ash/) выполнялась команда flush перед чтением и также приведены для сравнения несколько других вариантов:
Memstore — чтение из памяти, т.е. до сброса на диск.
HFile+zip — чтение из файлов, сжатых алгоритмом GZ.
HFile+upzip — чтение из файлов без сжатия.
Обращает на себя внимание занятная особенность — маленькие файлы (см. поле «Данные», где записи 10 байт) обрабатываются медленнее, особенно если они сжаты. Очевидно, что это так только до определенного размера, явно файл в 5 Гб не будет обработан быстрее 10 Мб, но явно указывает на то, что во всех этих тестах еще не паханное поле для исследований различных конфигураций.
Для интереса поправил код YCSB для работы с HB батчами по 100 штук, чтобы замерить латентность и прочее. Ниже результат работы 4-х экземпляров, которые писали в свои таблицы, каждый по 100 тредов. Получилось следующее:
**Одна операция = 100 записей**[OVERALL], RunTime(ms), 1165415
[OVERALL], Throughput(ops/sec), 858.06343662987
[TOTAL\_GCS\_PS\_Scavenge], Count, 798
[TOTAL\_GC\_TIME\_PS\_Scavenge], Time(ms), 7346
[TOTAL\_GC\_TIME\_%\_PS\_Scavenge], Time(%), 0.6303334005483026
[TOTAL\_GCS\_PS\_MarkSweep], Count, 1
[TOTAL\_GC\_TIME\_PS\_MarkSweep], Time(ms), 74
[TOTAL\_GC\_TIME\_%\_PS\_MarkSweep], Time(%), 0.006349669431061038
[TOTAL\_GCs], Count, 799
[TOTAL\_GC\_TIME], Time(ms), 7420
[TOTAL\_GC\_TIME\_%], Time(%), 0.6366830699793635
[INSERT], Operations, 1000000
[INSERT], AverageLatency(us), 115893.891644
[INSERT], MinLatency(us), 14528
[INSERT], MaxLatency(us), 1470463
[INSERT], 95thPercentileLatency(us), 248319
[INSERT], 99thPercentileLatency(us), 445951
[INSERT], Return=OK, 1000000
20/01/19 13:19:16 INFO client.ConnectionManager$HConnectionImplementation: Closing zookeeper sessionid=0x36f98ad0a4ad8cc
20/01/19 13:19:16 INFO zookeeper.ZooKeeper: Session: 0x36f98ad0a4ad8cc closed
20/01/19 13:19:16 INFO zookeeper.ClientCnxn: EventThread shut down
[OVERALL], RunTime(ms), 1165806
[OVERALL], Throughput(ops/sec), 857.7756504941646
[TOTAL\_GCS\_PS\_Scavenge], Count, 776
[TOTAL\_GC\_TIME\_PS\_Scavenge], Time(ms), 7517
[TOTAL\_GC\_TIME\_%\_PS\_Scavenge], Time(%), 0.6447899564764635
[TOTAL\_GCS\_PS\_MarkSweep], Count, 1
[TOTAL\_GC\_TIME\_PS\_MarkSweep], Time(ms), 63
[TOTAL\_GC\_TIME\_%\_PS\_MarkSweep], Time(%), 0.005403986598113236
[TOTAL\_GCs], Count, 777
[TOTAL\_GC\_TIME], Time(ms), 7580
[TOTAL\_GC\_TIME\_%], Time(%), 0.6501939430745767
[INSERT], Operations, 1000000
[INSERT], AverageLatency(us), 116042.207936
[INSERT], MinLatency(us), 14056
[INSERT], MaxLatency(us), 1462271
[INSERT], 95thPercentileLatency(us), 250239
[INSERT], 99thPercentileLatency(us), 446719
[INSERT], Return=OK, 1000000
20/01/19 13:19:16 INFO client.ConnectionManager$HConnectionImplementation: Closing zookeeper sessionid=0x26f98ad07b6d67e
20/01/19 13:19:16 INFO zookeeper.ZooKeeper: Session: 0x26f98ad07b6d67e closed
20/01/19 13:19:16 INFO zookeeper.ClientCnxn: EventThread shut down
[OVERALL], RunTime(ms), 1165999
[OVERALL], Throughput(ops/sec), 857.63366863951
[TOTAL\_GCS\_PS\_Scavenge], Count, 818
[TOTAL\_GC\_TIME\_PS\_Scavenge], Time(ms), 7557
[TOTAL\_GC\_TIME\_%\_PS\_Scavenge], Time(%), 0.6481137633908777
[TOTAL\_GCS\_PS\_MarkSweep], Count, 1
[TOTAL\_GC\_TIME\_PS\_MarkSweep], Time(ms), 79
[TOTAL\_GC\_TIME\_%\_PS\_MarkSweep], Time(%), 0.006775305982252128
[TOTAL\_GCs], Count, 819
[TOTAL\_GC\_TIME], Time(ms), 7636
[TOTAL\_GC\_TIME\_%], Time(%), 0.6548890693731299
[INSERT], Operations, 1000000
[INSERT], AverageLatency(us), 116172.212864
[INSERT], MinLatency(us), 7952
[INSERT], MaxLatency(us), 1458175
[INSERT], 95thPercentileLatency(us), 250879
[INSERT], 99thPercentileLatency(us), 446463
[INSERT], Return=OK, 1000000
20/01/19 13:19:17 INFO client.ConnectionManager$HConnectionImplementation: Closing zookeeper sessionid=0x36f98ad0a4ad8cd
20/01/19 13:19:17 INFO zookeeper.ZooKeeper: Session: 0x36f98ad0a4ad8cd closed
20/01/19 13:19:17 INFO zookeeper.ClientCnxn: EventThread shut down
[OVERALL], RunTime(ms), 1166860
[OVERALL], Throughput(ops/sec), 857.000839860823
[TOTAL\_GCS\_PS\_Scavenge], Count, 707
[TOTAL\_GC\_TIME\_PS\_Scavenge], Time(ms), 7239
[TOTAL\_GC\_TIME\_%\_PS\_Scavenge], Time(%), 0.6203829079752499
[TOTAL\_GCS\_PS\_MarkSweep], Count, 1
[TOTAL\_GC\_TIME\_PS\_MarkSweep], Time(ms), 67
[TOTAL\_GC\_TIME\_%\_PS\_MarkSweep], Time(%), 0.0057419056270675145
[TOTAL\_GCs], Count, 708
[TOTAL\_GC\_TIME], Time(ms), 7306
[TOTAL\_GC\_TIME\_%], Time(%), 0.6261248136023173
[INSERT], Operations, 1000000
[INSERT], AverageLatency(us), 116230.849308
[INSERT], MinLatency(us), 7352
[INSERT], MaxLatency(us), 1443839
[INSERT], 95thPercentileLatency(us), 250623
[INSERT], 99thPercentileLatency(us), 447487
[INSERT], Return=OK, 1000000
Получается, что если у CS AverageLatency(us) на запись 3114, то у HB AverageLatency(us) = 1162 (помним, что 1 операция = 100 записям и поэтому надо делить).
В целом получается такой вывод — в заданных условиях имеет место существенное преимущество HBase. Однако нельзя исключать, что SSD и тщательный тюнинг ОС изменит картину радикально. Также нужно понимать, что очень многое зависит от сценариев использования, запросто может оказаться так, что если взять не 4 таблицы, а 400 и работать с терабайтами, баланс сил сложится совсем иным образом. Как говорили классики: практика — критерий истины. Надо пробовать. За одно ScyllaDB теперь уже имеет смысл проверить, так что продолжение следует… | https://habr.com/ru/post/484096/ | null | ru | null |
# Пентест вебсайта с помощью Owasp Zap
Сегодня защита веб-приложения имеет решающее значение, поэтому осваивать пентест инструменты приходится и самим разработчикам. О мощном фреймворке [WPScan](https://habr.com/ru/company/alexhost/blog/527612/) для пентеста WordPress мы уже писали, но сайты бывают и на других движках. Именно поэтому сегодня разберем более универсальный пентест-инструмент OWASP ZAP (Zed Attack Proxy).
### Что такое OWASP ZAP?
OWASP (Open Web Application Security Project) — всемирная некоммерческая организация, деятельность которой направлена на повышение безопасности ПО.
OWASP ZAP (Zed Attack Proxy) — один из самых популярных в мире инструментов безопасности. Это часть сообщества OWASP, а значит, что этот инструмент абсолютно бесплатный.
### Почему многие выбирают OWASP ZAP?
Он предназначен для пользователей с широким спектром опыта в области безопасности, поэтому отлично подходит для разработчиков и функциональных тестировщиков, которые плохо знакомы с пентестами.
ZAP создает прокси-сервер между клиентом и вашим сайтом. Пока вы перемещаетесь по своему веб-сайту, он фиксирует все действия, а затем атакует сайт известными методами.
#### Открытый исходный код!
Проект был запущен в 2010 году, но до сих пор дорабатывается и регулярно обновляется.
### Настройка среды ZAP
ZAP является кроссплатформенным и для своей работы требует только наличия JAVA 8+. Поэтому можно обойтись без [Kali Linux или других ОС](https://habr.com/ru/company/alexhost/blog/525102/) для белого хакинга.
### Запуск OWASP ZAP
При запуске ZAP предложит сохранить сеанс. Если мы хотим получить конфигурацию своего веб-сайта или результаты тестирования позже, тогда следует сохранить сеанс, а пока можно выбрать значение: «*No,I do not want to persist the session...*».
### В чем разница между активным и пассивным сканированием?
#### Что такое пассивное сканирование?
С точки зрения теста на проникновение, пассивное сканирование — это безобидный тест, который ищет только ответы и проверяет их на наличие известных уязвимостей. Пассивное сканирование не изменяет данные сайта, что делает его более безопасным.
### Что такое активное сканирование?
Активное сканирование атакует веб-сайт различными известными методами. Активное сканирование может изменять данные и вставлять вредоносные скрипты. Поэтому лучше таким образом тестировать сайты, которые развернуты на локальном хосте, как мы уже делали с нашей [пентест лабораторией WordPress](https://habr.com/ru/company/alexhost/blog/527968/).
### Введение в ZAP UI
Давайте кратко рассмотрим макет пользовательского интерфейса ZAP, чтобы понять основы. На следующем экране перечислены окна с 4мя разделами.
#### 1. Режимы
В верхнем левом углу экрана видны режимы, которых всего 4:
* Стандартный режим: позволяет делать что угодно с любым веб-сайтом.
* Режим атаки: активно проверяет любые веб-сайты.
* Безопасный режим: отключает все вредоносные функции во время сканирования.
* Защищенный режим: позволяет сканировать веб-сайты в определенной области. Это предотвращает сканирование нежелательных сайтов.
#### 2. Сайты
Здесь будут перечислены все сайты, к которым мы получаем доступ через ZAP.
**2.1 — Показывать только URL-адреса**. Желательно включить эту опцию, так как после первых тестов данный раздел будет сильно засорен. Чтобы сфокусироваться на целевом веб-сайте необходимо поставить на него флаг «*In Scope*».
#### 3. Окно рабочей области
Окно рабочей области состоит из 3 вкладок:
**3.1 — Окно быстрого запуска**. Это самый быстрый и прямой способ начать активное сканирование. Введите адрес целевого веб-сайта и нажмите кнопку атаки. Сначала он краулит веб-сайт, а затем выполняет активное сканирование.
**3.2 — Окно запроса и ответа**. Это наиболее часто используемые части пользовательского интерфейса. На вкладке запроса вы видите, что окно разделено на 2 части:
* Верхний показывает заголовок запроса и файлы cookie
* Нижний показывает параметры сообщения отправленного на сервер
Окно ответа аналогично окну запроса и показывает:
* Заголовок
* Тело ответа
#### 4. Нижнее окно
Нижнее окно показывает:
* Результаты
* Историю запросов
* Уязвимости теста
*Самая важная вкладка здесь — вкладка «Alerts».*
**4.1 — Вкладка «Alerts»**. Показывает уязвимости, обнаруженные на целевом веб-сайте. Когда мы щелкаем по одному из предупреждений в списке, открывается соответствующий запрос/ответ в правом верхнем углу и выводится точная информация об уязвимости.
Давайте посмотрим, что произошло на предыдущем изображении.
Запрос POST выполняется по адресу <http://localhost:22742/api/TokenAuth/Authenticate>. Пользователь входит в систему с учетными данными и сервер возвращает ошибку http-500.
`HTTP-500 Internal Server Error.`
OWASP ZAP считает, что это проблема. И в 3-м окне вы увидите некоторую информацию о ней. Он показывает точный URL и желтый флаг (средний риск). В описании говорится:
*Эта страница содержит сообщение об ошибке/предупреждении, которое может раскрывать конфиденциальную информацию, такую как расположение файла, вызвавшего необработанное исключение. Эта информация может быть использована для дальнейших атак на веб-приложение. Предупреждение может быть ложным, если сообщение об ошибке находится на странице документации.*
Это круто, потому что OWASP ZAP чувствует некоторую утечку информации. Он подозревает, что веб-сайт выдает [необработанное исключение](https://habr.com/ru/post/347284/).
Это может быть действительно уязвимым, когда веб-сайт показывает злоумышленнику некоторый стек исключений и предоставляет информацию о среде или коде. Но в нашем примере ответ представляет собой содержимое JSON, в котором говорится «Invalid user name or password», но разработчик предпочитает отправлять его через HTTP-500. Это ложное срабатывание, поскольку никакая информация не раскрывается.
В разделе решения содержится информация о том, как решить проблему.
### Проксирование вашего сайта: JxBrowser
В более ранней версии OWASP ZAP приходилось настраивать прокси-сервер вашего браузера для захвата запросов, но сейчас есть полезная функция JxBrowser! Это браузер на основе Chromium, интегрированный в OWASP ZAP. По умолчанию в нем настроена вся конфигурация прокси, что позволяет OWASP ZAP пропускать через него весь трафик. Нажмите "*Launch Browser*" и перейдите на свой веб-сайт.
### Навигация по сайту
Чтобы извлечь дерево веб-сайта необходимо просканировать его в JxBrowser. Нужно поразить все функции и пройти все возможные действия. Данный этап очень важен!
### Краулинг сайта
Краулинг сайта означает сканирование всех ссылок и получение структуры веб-сайта. О других [краулерах](https://habr.com/ru/company/alexhost/blog/529120/) мы уже писали ранее.
#### Зачем нам краулинг?
Краулинг нужен лишь в тех случаях, когда получить ко всему доступ только с помощью навигации не удалось. Он может обнаружить моменты, которые были упущены, а также когда проксирование невозможно.
Для его запуска щелкните правой кнопкой мыши на сайт и выберите в меню «*Attack*», а затем нажмите «*Spider*». Убедитесь, что напротив пункта «*recurse*» стоит флажок! Нажмите кнопку «*Start Scan*». Это займет некоторое время в зависимости от количества ссылок на вашем сайте.
### Как протестировать SPA (приложение одной страницы)?
Если это веб-сайт SPA, тогда необходимо дополнительно указать, что параметры представляют структуру, а не данные приложения.
Если охватить все функции и действия своего SPA-сайта, то не нужно будет краулить его.
### Расширения
Owasp добавило площадку расширений, ознакомиться со списком которых можно с помощью значка 3х цветного прямоугольника. Чтобы установить расширение, щелкните вкладку *Marketplace* и введите имя расширения в поле. Затем нажмите кнопку «*Install Selected*». Перезагружать ZAP не нужно.
Несколько полезных расширений:
* Active Scanner rules
* Passive Scanner rules
* FuzzDB
### Настройки сканирования
Рекомендуем использовать следующие настройки сканирования. В меню «Analyse» выберите «*Scan Policy Manager*». Нажмите кнопку «*Modify*». В окне «*Scan Policy*» установите «*Low*» => «*Threshold To All*» и нажмите кнопку «*Go*». То же, как и с Insane => Strength To All и нажмите кнопку *Go*. Все атаки будут сохранены в памяти, а сканирование будет более надежным. Для сохранения настроек нажимаем кнопку Ок.
### Старт атаки
Атака на целевой сайт очень проста.
**1 — Добавьте свой сайт в контекст**. Для этого щелкните правой кнопкой мыши целевой веб-сайт на левой панели. Выберите:
* «Include in Context»
* «Default Context»
Теперь вы видите, что во всплывающем окне появляется новый URL-адрес веб-сайта, который добавляет ваш веб-сайт как регулярное выражение. Звездочка (\*) в URL-адресе означает атаку на все URL-адреса этого веб-сайта. Наконец, жмем кнопку ОК.
**2 — Показать только URL-адреса в текущей области**. Таким образом мы скрываем другие веб-сайты и предотвращаем случайные атаки.
**3 — Запускаем краулинг.**
**4 — Атака!** Это главная цель. Запустим активное сканирование.
Кнопка «Start Scan» запустит процесс, который может занять много времени (в зависимости от количества URL-адресов).
### Фаззинг
Фаззинг — это отправка неожиданных или случайных данных на входы веб-сайта. Обычно мы проверяем вводимые данные на стороне клиента, поэтому игнорируем некоторые проблемы в серверной части. Когда вводятся нечеткие ключевые данные (например, основной поисковый ввод на веб-сайте или входные данные на странице входа), можно увидеть ошибки кодирования и лазейки в безопасности. Это необязательный шаг безопасности.
Если вы хотите запустить фаззер, тогда в левой части панели найдите запрос, который хотите обработать. Щелкните правой кнопкой мыши и выберите «*Attack*», затем нажмите «*Fuzz*». В окне фаззера будут видны данные для публикации запроса. Нажмем на них и выделим текст, который желаем атаковать. На правой панели нажмите кнопку «*Add*». Вы увидите окно *Payloads*. Снова нажмите кнопку «*Add*». В окне «*Add Payload*» выберите «*File Fuzzers*» в поле со списком типов. Выберите файл, который хотите использовать. Этот файл представляет собой базу данных, которая будет использоваться для брутфорса. [Брутфорсить сайты на WordPress](https://habr.com/ru/company/alexhost/blog/528494/) можно другими методами, о которых мы уже писали ранее.
Когда процесс брутфорса закончится, результаты будут перечислены на нижней вкладке под названием Fuzzer. Те, которые помечены как Fuzzed, требуют особого внимания.
### Принудительный просмотр
Краулер ищет известные URL-адреса с органическими ссылками, но он не может найти URL-адрес, который нигде не упоминается на сайте. В этом случае на помощь приходит принудительный просмотр, который использует брутфорс словари, чтобы проверить, есть ли какие-либо другие скрытые URL-адреса, такие как панель администратора или что-то, что можно взломать.
### Break
Break — очень хорошая функция для перехвата и изменения запросов и ответов. Если вы хотите изменить какие-либо данные публикации запроса или данные ответа, щелкните на сайт правой кнопкой мыши, выберите «*Break*», в окне «*Add Break Point*» нажмите «*Save*». Теперь на нижней панели будет видно, что точка останова включена.
Отныне все запросы будут перехватываться инструментом OWASP ZAP. Всякий раз, когда вы делаете запрос с исходного веб-сайта, окно ZAP выводится на передний план и позволяет вам изменить запрос. После того, как вы нажмете зеленую кнопку воспроизведения на панели инструментов, ZAP выдаст вам отправленный сервером ответ. Этот ответ также можно изменить. Таким образом, ваш браузер получит измененный ответ.
### Результаты и отчет
Мы хорошо просканировали сайт на предмет известных уязвимостей и пришло время ознакомиться с результатами.
Увидеть проблемы можно на вкладке «*Alerts*», расположенной в нижней панели. На следующем экране представлены 5 предупреждений с цветными флажками. Если нет красного флага, тогда вам повезло. Если красные флажки есть, тогда в первую очередь необходимо поработать над их устранением.
Если никаких предупреждений не видно, возможно, что-то было сделано не так.
Когда вы щелкаете одно из предупреждений, отображается соответствующее окно запроса и ответа. Есть хороший инструмент для создания отчетов, который автоматически создает удобный файл отчета. Можно экспортировать отчеты в форматах:
* HTML
* XML
* JSON
* Markdown
В качестве примера выберем HTML.
Как видите, это хорошо организованный итоговый отчет, который в исходном виде можно отправлять любому коллеге.
[](http://alexhost.com/ru/) | https://habr.com/ru/post/530110/ | null | ru | null |
# Добавили возможность встраивать JS-скрипты в доски. Как мы делаем свою систему управления проектами
Первого апреля системе YouGile исполнился год. Нешуточный срок для проекта, который начался с мысли — «А давайте на выходных сделаем себе удобную систему управления проектами». Сейчас несколько тысяч пользователей, в основном переходят с BaseCamp и Trello, все открыто для [тестирований и присылания](https://ru.yougile.com/) нам обратной связи.
Относимся к этому, как к крупному эксперименту, нет никакой коммерциализации, и уже на достаточно большой базе пользователей ищем функции, способные сделать управление любыми проектами принципиально удобнее.
**В общем, свежая функция в том, что теперь, немного зная JavaScript, можно полностью модифицировать под себя базовую версию системы.**
Работает просто — по комбинации клавиш Ctrl+~ вызывается встроенный редактор JavaScript.
Можно на JS писать или заливать любые скрипты и они будут менять работу отдельных досок или проектов в компании. Выделена библиотека — примерно 200 объектов и методов, которые позволяют менять параметры системы, выполнять свой код на различные события в системе и удобно создавать свои элементы интерфейса или изменять существующие.
**В статье рассматриваются примеры и задается вопрос о необходимости такой функции в системах управления проектами.**
**Нет никаких ограничений по возможностям кастомизации:**
* Из стандартной доски можно получить хорошо заточенную систему отдела поддержки куда падают тикеты, автоматически распределяются по менеджерам, а наверху выводится средняя скорость ответа по последним 100 карточкам. У нас это так сейчас и работает.
* Очень легко писать ботов. Например, тому, кто пишет сообщений в два раза больше, чем в среднем по команде, может приходить «А не слишком ли ты сегодня много пишешь, товарищ?», или сделать бота, который в чат компании в 23:00 кидает весь список закрытых сегодня задач.
* Можно сделать доску с любой статистикой и отчетностью. Для себя вывели доску со списком всех изменений по задачам и доску с актуальными задачами по каждому человеку. Можно также строить любые графики, например, зависимость количества закрытых задач от активности в чатах. В крупных компаниях этот пример перестает быть абсурдным.
**Каждый из этих примеров реализуется минут за 20.**
Немного историй о том, почему решили делать такую функцию
---------------------------------------------------------
При разработке системы управления проектами есть одна мощная особенность. Хотелок от пользователей приходит невероятное количество и они практически не пересекаются друг с другом. Получаются огромные доски с разными запросами и вырисовывается миллион путей развития. Приходит понимание, что всё присутствующее сегодня на рынке — BaceCamp, Jira, YouTrack, Asana и тем более Trello, удовлетворяют компании только на базовом уровне. **Популярные универсальные решения никогда не соответствуют запросом команд больше 20 человек.**
Рынок невероятно живой. У всякого, кто участвовал в хоть каких-то проектах и работал с какими-то системами, есть что сказать. Среднее высказывание выглядит так:
“BaseCamp/Jira/YouTrack/Asana подходят плохо, там нельзя это и это, но ничего лучше нет. Мы привыкли и **используем 5 разных систем** в разных отделах и раз в полгода что-то меняем”
**В крупных конторах вообще до слёз — на вопрос: «Почему не пользуетесь Asana?», ответ: «Да она недавно у нас внедрена и скорее всего не приживётся.»**
Сперва мы решились доработать систему под одну достаточно крупную команду в 50 человек, хотелки которых были очень логичны и просты. Но после доработок, как всегда неожиданно, появились новые пожелания. И эти новые были уже самые разные, прилетели от всех отделов. Коллектив просто прорвало на идеи как доработать систему под их процесс.
Вот примерно так и родилось понимание, что самая большая потребность на рынке систем управления проектами — кастомизация. Нужна простая базовая версия, которая как и другие неплохо удовлетворяет в первом приближении, но всё, что можно только придумать, должно быть легко дорабатываемо.
Как пользоваться
================
→ [Manual.pdf](https://yougile.com/media/docs/yougile-api-manual.pdf)
Всё достаточно просто, но придется быть хоть немного программистом. Если уровень прав в компании — «админ», то будет доступна кнопка (или комбинация Ctrl+~) вызова редактора кода. Тут можно писать или заливать свои скрипты.
**Есть библиотека с выделенными методами и объектами.** Полный список расположен в блоке «API навигатор» в правой части. Любой объект можно потянуть мышкой в редактор — тогда будет вставлен пример кода, который работает с этим объектом.
#### **Пример №1. Бот планерок**
**Уведомляет о планёрке в 9:55 и выбирает случайного модератора.**
**1.** Выбираем чат (задачу) в который будет падать сообщение с напоминанием. В системе есть специальная вкладка «Навигатор по объектам». Тут легко узнать id любого элемента системы (пользователь, задача, колонка, доска, проект, компания) Таким образом реализуется доступ к работе с элементами.
```
var task = Items.get('ca1307c2-9b83-4796-897c-7c071dc2fa94');
```
**2.** Создаем функцию, которая делает случайный выбор из списка участников и размещает сообщение в выбранном ранее чате.
```
function notifyOfPlanning() {
var users = Users.listAll();
// случайный юзер
var chosen = users[Math.floor(Math.random() * users.length)];
// сообщение от лица cистемы (пустой отправитель)
Chat.postMessage(task, '', `Планёрка, ведущий — (${chosen.name})`);
// сохраняем время последнего уведомления
task.setData({lastRun: App.time()});
}
```
**3.** Создаем функцию которая проверяет необходимость размещать сообщение.
```
function check() {
if (new Date().getDay() > 5) { // если выходной, то не уведомляем
return;
}
var last = task.getData().lastRun;
if (!last) {
notifyOfPlanning(); // первый раз уведомит сразу
} else {
var now = App.time(); // серверное время (unix timestamp UTC)
var dayStart = now - now % (24 * 3600 * 1000);
var planningTime = dayStart +
6 * 3600 * 1000 + 55 * 60 * 1000; // 6:55 по Гринвичу (или 9:55 MSK)
if (last < planningTime && now > planningTime) {
notifyOfPlanning();
}
}
}
// проверяем необходимость нотифицировать раз в 30 сек
setInterval(check, 30000);
```
**Полный код скрипта с комментариями**
```
/**
* Бот, который уведомляет о планёрке в 9:55
* и выбирает случайного ведущего.
*/
// задача, в которую будут попадать сообщения с напоминанием
var task = Items.get('ca1307c2-9b83-4796-897c-7c071dc2fa94');
function notifyOfPlanning() {
var users = Users.listAll();
var chosen = users[Math.floor(Math.random() * users.length)]; // случайный юзер
// сообщение от лица системы (пустой отправитель)
Chat.postMessage(task, '', `Планёрка, ведущий — (${chosen.name})`);
// сохраняем время последнего уведомления
task.setData({lastRun: App.time()});
}
function check() {
if (new Date().getDay() > 5) { // если выходной, то не уведомляем
return;
}
var last = task.getData().lastRun;
if (!last) {
notifyOfPlanning(); // первый раз уведомит сразу
} else {
var now = App.time(); // серверное время (unix timestamp UTC)
var dayStart = now - now % (24 * 3600 * 1000);
var planningTime = dayStart +
6 * 3600 * 1000 + 55 * 60 * 1000; // 6:55 по Гринвичу (или 9:55 MSK)
if (last < planningTime && now > planningTime) {
notifyOfPlanning();
}
}
}
// проверяем необходимость нотифицировать раз в 30 сек
setInterval(check, 30000);
```
**Больше примеров** можно найти непосредственно в редакторе. Выложили 4 работающих скриптов с подробными комментариями:
* Настройка своего фона на каждой доске.
* Лента всех действий и событий в компании.
* Отображение времени ответа на сообщения в чатах.
* Выполнение JS прямо в чате. Можно использовать как калькулятор.
Проблема
--------
Понятно, что сама идея легко настраиваемых решений для управления проектами востребована, но является ли наш вариант доступным для хоть сколько-нибудь массового пользователя? Требование уметь немного писать код — очень высокое. Хотя, вероятно, уже в любой компании больше 30 человек такой человек должен быть.
P.S. Названия у функции нет. Называть API не хотим, в сознании за этим уже многое зарезервировано и это не совсем то, что мы сделали. Если есть идеи, дайте знать. | https://habr.com/ru/post/325608/ | null | ru | null |
# Классификатор обращений пользователей (1C + python)
1. Описание задачи
------------------
В нашей компании очень много пользователей и каждый день они шлют массу обращений на самые разные темы. У нас есть два отдела: "Программные разработки" и "Системные администраторы", и что бы облегчить жизнь техподдержке, был написан классификатор, который стыкует обращение пользователя на тот или другой отдел. В основе классификатора лежит логистическая регрессия.
2. Общая логика
---------------
1. Собрать исходные данные
2. Подготовить данные (почистить, привести в нужный формат)
3. Обучить модель
4. Подать новое обращение в модель и получить ответ
Все очень просто! Сам в шоке =)
3. Полезные ссылки
------------------
Тут оставлю некоторые ссылки
1. [Лекция Coursera](https://ru.coursera.org/learn/machine-learning/lecture/4BHEy/regularized-logistic-regression)
2. [Статья на Хабре](https://habrahabr.ru/company/io/blog/265007/)
3. <https://www.youtube.com/watch?v=1vklt6IHeJI>
4. [Подробнее про векторное представление документов](http://scikit-learn.org/stable/modules/feature_extraction.html#text-feature-extraction)
5. [Разряженные матрицы](http://www.scipy-lectures.org/advanced/scipy_sparse/)
6. [Трансформер](http://scikit-learn.org/stable/modules/feature_extraction.html#common-vectorizer-usage)
7. [Подробнее про разреженные матрицы](http://docs.scipy.org/doc/scipy-0.14.0/reference/sparse.html)
4. Собираем данные
------------------
Мы работаем в системе 1С, поэтому, делаем запрос к базе и выбираем все отработанные обращения с начала времен. Будем использовать эти данные для обучения. Результатом запроса будет являться таблица, где в первой колонке будет текст обращений пользователей, а во второй "1" или "0", где "1" - это "Программные разработки", а "0" - "Системные администраторы".
```
Функция ПолучитьСырыеДанные()
Запрос = Новый Запрос;
Запрос.Текст =
"ВЫБРАТЬ
| ОбращениеВТехПоддержку.ТекстВопроса КАК Appeal,
| ВЫБОР
| КОГДА ОбращениеВТехПоддержку.ОтделОбслуживания.Код = 50
| ТОГДА 1
| ИНАЧЕ 0
| КОНЕЦ КАК Prediction
|ИЗ
| Документ.ОбращениеВТехПоддержку КАК ОбращениеВТехПоддержку
|ГДЕ
| ОбращениеВТехПоддержку.ДатаОтработки <> ДАТАВРЕМЯ(1, 1, 1)";
Возврат Запрос.Выполнить().Выгрузить();
КонецФункции
```
Далее я решил почистить данные и оставить только слова без цифр, спец символов и пр... Тут можно по экспериментировать!!!
Функция чистит текст обращения. Могут остаться двойные или тройные пробелы но, они будут отброшены при векторизации текста.
```
Функция ПочиститьПоле(ПреобразованноеПоле) Экспорт
СимволыДляЗамены = "1234567890";
СимволыДляЗамены = СимволыДляЗамены + "(){}[]:;""'\|<>.,/?";
СимволыДляЗамены = СимволыДляЗамены + "*-+=_";
СимволыДляЗамены = СимволыДляЗамены + "!@#$%^&№";
Для НомерСимвола = 0 По СтрДлина(СимволыДляЗамены) Цикл
Символ = Сред(СимволыДляЗамены, НомерСимвола, 1);
ПреобразованноеПоле = СтрЗаменить(ПреобразованноеПоле, Символ, "");
КонецЦикла;
ПреобразованноеПоле = СтрЗаменить(ПреобразованноеПоле, """", " ");
ПреобразованноеПоле = СтрЗаменить(ПреобразованноеПоле, Символы.ПС, " ");
ПреобразованноеПоле = СтрЗаменить(ПреобразованноеПоле, Символы.ВК, " ");
ПреобразованноеПоле = СтрЗаменить(ПреобразованноеПоле, Символы.НПП, " ");
ПреобразованноеПоле = СтрЗаменить(ПреобразованноеПоле, Символы.ПФ, " ");
Возврат ПреобразованноеПоле;
КонецФункции
```
Результатом данного этапа должен стать .СSV файл с которым будем дальше работать.
Тут мы как раз данный файл и собираем.
```
Функция ПреобразоватьТЗвТекстCSV(ТЗ, Разделитель = ",", флЭкспортироватьИменаКолонок = Истина)
ТекстCSV = "";
Если флЭкспортироватьИменаКолонок Тогда
ПодготовленнаяСтрока = "";
Для Каждого Колонка Из ТЗ.Колонки Цикл
ПодготовленнаяСтрока = ПодготовленнаяСтрока + Колонка.Имя + Разделитель;
КонецЦикла;
ПодготовленнаяСтрока = Лев(ПодготовленнаяСтрока, СтрДлина(ПодготовленнаяСтрока) - 1);
ТекстCSV = ТекстCSV + ПодготовленнаяСтрока + Символы.ПС;
КонецЕсли;
Счетчик = 0;
Для Каждого Строка Из ТЗ Цикл
//Если Счетчик = 10000 Тогда
// Прервать;
//КонецЕсли;
ПодготовленнаяСтрока = "";
Для Каждого Колонка Из ТЗ.Колонки Цикл
ПреобразованноеПоле = Строка[Колонка.Имя];
Если Колонка.Имя = "Appeal" Тогда
ПочиститьПоле(ПреобразованноеПоле);
КонецЕсли;
ПодготовленнаяСтрока = ПодготовленнаяСтрока + ПреобразованноеПоле + Разделитель;
КонецЦикла;
ПодготовленнаяСтрока = Лев(ПодготовленнаяСтрока, СтрДлина(ПодготовленнаяСтрока) - 1);
ТекстCSV = ТекстCSV + ПодготовленнаяСтрока + Символы.ПС;
Счетчик = Счетчик + 1;
КонецЦикла;
Возврат ТекстCSV;
КонецФункции
```
Файл готов, начинается самое интересное.
5. Обучение модели
------------------
```
# -*- coding: utf-8 -*-
import pickle
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn import linear_model
#Путь к .csv файлу
DATA_PATH = r"\\app1\1C\work\Вложения\Python_projects\ClassifierOfUserRequests\data\train.csv"
#Файл где хранятся данные о точности нашей модели (для информации)
MODEL_ACCURACY_PATH = r"\\app1\1C\work\Вложения\Python_projects\ClassifierOfUserRequests\model_accuracy.txt"
#Тут мы храним нашу модель
MODEL_PATH = r"\\app1\1C\work\Вложения\Python_projects\ClassifierOfUserRequests\model.pickle"
#Тут мы храним наш векторизатор, что бы приводить входящие обращения к нужному виду
VECTORIZER_PATH = r"\\app1\1C\work\Вложения\Python_projects\ClassifierOfUserRequests\vectorizer.pickle"
def train_model():
# Вычитываем исходные данные
train_df = pd.read_csv(DATA_PATH)
# Выбираем отдельно данные по двум отделам
train_df_0 = train_df[train_df['Prediction'] == 0]
train_df_1 = train_df[train_df['Prediction'] == 1]
# Смотрю на размер меньшего по колву данных массива, его и берем за основу.
size_0 = train_df_0.shape[0]
# Наша задача с балансировать две эти выборки, поэтому из большей я рандомно выбираю
# такое же кол во данных как есть в меньшей !!!!!!!!
train_df_1 = train_df_1.sample(frac=1).reset_index(drop=True)
train_df_1 = train_df_1[:size_0]
# Собираем две одинаковые по размеру выборки вместе
train_df = pd.concat([train_df_0, train_df_1], ignore_index=True)
train_df.Prediction.value_counts(normalize=True)
# Приводим содержимое в нижний регистр
appeal = list(train_df.Appeal.values)
appeal = [str(l).lower() for l in appeal]
# Для решения задачи классификации необходимо преобразовать каждое обращение
# в вектор. Размерность данного вектора будет равна количеству слов
# используемых во всех обращениях вообще! Каждая координата соответствует
# слову, значение в координате равно количеству раз, слово используется в
# в обращении.
vectorizer = TfidfVectorizer()
tfidfed = vectorizer.fit_transform(appeal)
# Делим выборку на тренировочную и тестовую
X = tfidfed
y = train_df.Prediction.values
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.7, random_state=42)
# Создаем объект классификатора
# С параметрами можно поиграться, может получится настроить еще точнее!!!
clf = linear_model.SGDClassifier(max_iter=10000, random_state=42, loss="log", penalty="l2", alpha=1e-5, eta0=1.0,
learning_rate="optimal")
# Обучаем модель
clf.fit(X_train, y_train)
# Пишем данные точности в файлик, в моем случаем 94%
with open(MODEL_ACCURACY_PATH, 'w', encoding='utf-8') as f:
f.write("Train accuracy = %.3f\n" % accuracy_score(y_train, clf.predict(X_train)))
f.write("Test accuracy = %.3f" % accuracy_score(y_test, clf.predict(X_test)))
# В питоне все объект, поэтому мы можем замариновать нашу модель и векторизатор
# что бы потом их можно было легко использовать
with open(MODEL_PATH, 'wb') as f:
pickle.dump(clf, f)
with open(VECTORIZER_PATH, 'wb') as f:
pickle.dump(vectorizer, f)
if __name__ == "__main__":
train_model()
```
Готово, спасибо инженерам, которые делают эти библиотеки !!!!
6. Как использовать?
--------------------
Пишем скрипт, который будет принимать входящее обращение и выдавать ответ. Обращаю внимание, входящий запрос должен быть почищен той же функцией который мы готовили исходники!
Ответ будет писать во временный файл.
Код ниже рассчитан на обмен с 1С, а именно, дополнительно принимает имя файла через который будет происходить обмен.
```
# -*- coding: utf-8 -*-
import logging
import pickle
import sys
MAIN_DIR = r"\\app1\1C\work\Вложения\Python_projects\ClassifierOfUserRequests"
LOG_PATH = r"\\app1\1C\work\Вложения\Python_projects\ClassifierOfUserRequests\log.txt"
VECTORIZER_PATH = r"\\app1\1C\work\Вложения\Python_projects\ClassifierOfUserRequests\vectorizer.pickle"
MODEL_PATH = r"\\app1\1C\work\Вложения\Python_projects\ClassifierOfUserRequests\model.pickle"
# Логер пропускаем, ничего интересного!
def create_logger(name, log_level=logging.DEBUG, stdout=False, file=None):
'''
Создает логера, есть возможность создать логера с выводом в stdout или в файл или туда и туда.
'''
logger = logging.getLogger(name)
logger.setLevel(log_level)
formatter = logging.Formatter(fmt='[%(asctime)s] - %(name)s - %(levelname).1s - %(message)s',
datefmt='%Y.%m.%d %H:%M:%S')
if file is not None:
fh = logging.FileHandler(file, encoding='utf-8-sig')
fh.setLevel(log_level)
fh.setFormatter(formatter)
logger.addHandler(fh)
if stdout:
ch = logging.StreamHandler()
ch.setLevel(log_level)
ch.setFormatter(formatter)
logger.addHandler(ch)
return logger
def main():
# Принимаем почищеное обращение пользователя (текс)
user_request = sys.argv[1].lower()
# Имя файла обмена который создает 1С и в последствии удалит
pred_path = sys.argv[2]
logger.info(user_request)
# Востанавливаем наш векторизатор
with open(VECTORIZER_PATH, 'rb') as f:
vectorizer = pickle.load(f)
# Востанавливаем нашу модель
with open(MODEL_PATH, 'rb') as f:
model = pickle.load(f)
# Приводим обрашение к вектору
transform_request = vectorizer.transform([user_request])
# Пишем ответ в файл обмена
with open(MAIN_DIR + '\\' + pred_path, 'w') as f:
prediction = str(model.predict(transform_request)[0])
f.write(prediction)
logger.info(prediction)
if __name__ == '__main__':
try:
logger = create_logger("log", file=LOG_PATH)
main()
except Exception as e:
logger.error(e)
```
На стороне 1С
```
Функция ПредсказатьОтдел(ТексОбращения) Экспорт
Путьприложения = "\\app1\1C\work\Вложения\Python_projects\ClassifierOfUserRequests\";
ОчищеныйЗапрос = ПочиститьПоле(ТекстОбращения);
ИмяФайлаОбмена = СтрЗаменить(СтрЗаменить(СтрЗаменить(Строка(ТекущаяДата()), ".", ""), " ", ""), ":", "") + ".txt";
//внимательно с кавычками !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
КомандаИтог = """" + Путьприложения + "predict\predict.exe""" + " """ + ОчищеныйЗапрос + """" + " """ + ИмяФайлаОбмена + """";
ЗапуститьПриложение(КомандаИтог,, Истина);
Попытка
ПутьКФайлуОбмена = Путьприложения + ИмяФайлаОбмена;
Предсказание = Новый ЧтениеТекста;
Предсказание.Открыть(ПутьКФайлуОбмена);
Ответ = Предсказание.ПрочитатьСтроку();
Предсказание.Закрыть();;
УдалитьФайлы(ПутьКФайлуОбмена);
Исключение
Сообщить(ОписаниеОшибки());
Сообщить("Не удалось автоматически определить отдел обращения!");
КонецПопытки;
Если Ответ = "1" Тогда
ПредсказаниыйОтдел = Справочники.Отделы.НайтиПоНаименованию("Программные разработки");
Иначе
ПредсказаниыйОтдел = Справочники.Отделы.НайтиПоНаименованию("IT");
КонецЕсли;
Возврат ПредсказанныйОтдел;
КонецФункции
```
7. Ускоряемся
-------------
Что бы отрабатывало быстрее, рекомендую скомпилировать скрипт предсказатор.
Флаги компиляции
```
pyinstaller -F --hidden-import="sklearn" --hidden-import="sklearn.feature_extraction" --hidden-import="sklearn.utils._weight_vector"predict.pyw
```
так много, что бы библиотека "sklearn" удачно подтянулась.
`.pyw` - что бы не вылезало консольное окно.
7.1 Оказалось ...
-----------------
В поисках лучшего решения по интеграции с 1С наткнулся на статью <https://habr.com/ru/post/332082/>, atnes - от души тебе !!!
Итого. Делаем COM объект
```
class PredictWrapper:
# com spec
_public_methods_ = ['predict', ] # методы объекта
_public_attrs_ = ['version', ] # атрибуты объекта
_readonly_attr_ = []
_reg_clsid_ = '{9cb58c50-2d01-41e9-99d5-07e1fa4baf16}' # uuid объекта
_reg_progid_= 'PredictWrapper' # id объекта
_reg_desc_ = 'COM wrapper for LR_model' # описание объекта
def __init__(self):
self.VECTORIZER_PATH = r"\\app1\1C\work\Вложения\Python_projects\ClassifierOfUserRequests\vectorizer.pickle"
self.MODEL_PATH = r"\\app1\1C\work\Вложения\Python_projects\ClassifierOfUserRequests\model.pickle"
def predict(self, user_request):
import sklearn
import pickle
with open(self.VECTORIZER_PATH, 'rb') as f:
vectorizer = pickle.load(f)
with open(self.MODEL_PATH, 'rb') as f:
model = pickle.load(f)
transform_request = vectorizer.transform([user_request])
return str(model.predict(transform_request)[0])
def main():
import win32com.server.register
win32com.server.register.UseCommandLine(PredictWrapper)
print('registred')
if __name__ == '__main__':
main()
```
А на стороне 1С
```
обВыбратьОтдел = Новый COMОбъект("PredictWrapper");
Ответ = обВыбратьОтдел.predict(ТекстВопроса);
```
8. Готово
---------
Схема работает очень хорошо! Проверено.
Как Вы понимаете, по аналогии можно придумать множество вариантов использования ... Можете прочекать стихи поэтов и потом выбирать, кому принадлежит авторство, разумеется в формате 1v1 =) Либо Пушкин либо Лермонтов. | https://habr.com/ru/post/569206/ | null | ru | null |
# Система мониторинга OpenNMS
Ни в малейшей степени не желаю показаться непатриотичным, но исторически сложилось так, что при выборе корпоративной системы мониторинга сетевой инфраструктуры у нас на предприятии победила OpenNMS, сместив с этой должности бабушку Cacti и обогнав земляка-Zabbix. Сравнительный анализ Open Source систем мониторинга не входит в мои планы, поэтому просто в общих чертах расскажу об OpenNMS, благо на Хабре о ней не писали и вообще информации о ней немного.
Основная функция OpenNMS (Open Network Monitoring System) – мониторинг различных сервисов и внутренних систем сетевого и серверного оборудования. Для сбора информации используются так называемые «коллекторы», работающие по SNMP, HTTP, ИТДИТП протоколам. Отдельных серверных агентов у OpenNMS нет. Если информация окажется востребованной, то примеры реализаций «обёрток» я опишу в следующем материале в разделе «Юзкейсы». Не хочу больше повторять ошибок с публикацией гигантских простыней текста, в которых сложно разобраться как автору, так и читателям.
Краткая характеристика
----------------------
OpenNMS динамично развивается, довольно неплохо документирована, но сообщество разрозненное, а конфигурирование в виде правки несметного количества XML файлов может многих отпугнуть. Система написана на Java с довесками на Perl и выпущено порядочное количество дистрибутивов под различные платформы. При желании её можно запустить на любой машине с Java SDK и сервером PostgreSQL.
> A 1 GHz Pentium III (or equivalent processor) or better. A minimum of 256 MB of RAM, although 512 MB is strongly recommended.
Эти системные требования из официальной документации, мягко говоря, являются *самыми минимальными* и позволят именно что только запустить саму систему. Поэтому, позволю себе немного подкорректировать их: 64-битный CPU, 2 Gb RAM (это самый-самый минимум), высокопроизводительный жёсткий диск.
Прожорливость системы напрямую зависит от количества узлов, которые она будет мониторить. Система с более чем 1500 узлами и 5000 интерфейсами на них (VLAN'ы, порты, сервисы и т.п.) комфортно себя чувствует на Xeon E5520 c 12 Gb оперативки и SAS хардами. При этом под хранение rrd файлов отдан 2Gb tmpfs раздел. Запас по мощности выделен более чем двухкратный — это задел на рост сети и аппетитов системы в процессе обновления и развития.
Установка
---------
Предварительно ставим `ntp, net-snmp, net-snmp-utils, postgresql, postgresql-server, perl`. Базово настраиваем и запускаем все означенные сервисы. Затем устанавливаем JDK последней версии, скачав его с сайта Oracle, и наконец можно подключать репозиторий OpenNMS и ставить саму систему
```
rpm -Uvh http://yum.opennms.org/repofiles/opennms-repo-stable-rhel6.noarch.rpm
yum install opennms iplike
```
Последний пакет – довесок к PostgreSQL от разработчиков OpenNMS в виде хранимой процедуры IPLIKE, помогающей работать с запросами по IP-адресам и адресам сетей, используя маски вроде `192.168.4-255.*`, что активно используется в рамках самой системы.
**[!]** Если имя хоста, на который ставится система, не резолвится на прописанных в resolv.conf DNS серверах, пропишите его в hosts. В противном случае, система не запустится. Также следует обратить внимание на первичную настройку PostgreSQL. После дефолтной установки сервера в `/var/lib/pgsql/data/pg_hba.conf` в поставьте *method trust* всем трём local подключениям.
```
/opt/opennms/bin/runjava -S /usr/java/latest/bin/java
/opt/opennms/bin/install -dis
/etc/init.d/opennms start
```
После запуска система будет доступна по `hostname:8980`. Отдельный веб-сервер устанавливать не обязательно – вебинтерфейс OpenNMS работает через Jetty сервер. Впрочем, при желании можно переконфигурировать сам Jetty, или на 80й порт повесить Nginx или apache с mod\_proxy и делать proxy\_pass на все запросы.
При переустановке всей системы, следует дропнуть базу данных и удалить `/var/opennms`. В противном случае возникнут коллизии с графиками и отчётами. Для полной переустановки делаем `yum reinstall opennms` и `/opt/opennms/bin/install -dis`, для частичной – только второе.
Бывает так, что OpenNMS при запуске выдаёт сообщение `Started OpenNMS, but it has not finished starting up`. Прежде всего, следует проверить, не допущена ли ошибка в конфигурации и все ли сервисы запущены (команда `opennms -v status`). И если все сервисы запущены, то у меня для вас плохие новости – OpenNMS не хватает ресурсов и она хочет послабления. Создаём файл `$opennms/etc/opennms.conf` с содержанием `START_TIMEOUT=20`. Число в параметре – это коэффициент, на который будет умножаться 5-секундный интервал проверки запущенности всех сервисов. По умолчанию этот параметр равен 10 и получается, что если за 50 секунд все сервисы не успеют отрапортовать об успешном запуске – будет возвращена ошибка. То есть `START_TIMEOUT=20` это 100-секундное ожидание запуска всех систем.
Интерфейс и настройка
---------------------
Пожалуй, я пропущу часть с детальным описанием веб-интерфейса – в общих чертах система станет понятной через 10 минут прогулок по разделам, но стоит сразу отметить, что одной работой с веб-интерфейсом при конфигурировании системы не отделаться — придётся основательно покопаться в XML файлах.
Так, например, добавить *SNMP community* для определенной подсети можно легко через веб-интерфейс в разделе `Admin → Configure SNMP by IP`. Но просмотреть и отредактировать уже добавленные community можно только в соответствующем XML-файле. При этом диапазоны подсетей, за которыми нужно наблюдать (`network discovery`), можно полностью редактировать из веб-интерфейса.
Поскольку редактировать конфигурационные файлы придётся много, я бы рекомендовал подключить любую привычную CVS, чтобы отслеживать изменения. Также я бы посоветовал выработать привычку после редактирования конфигурационного файла проверять его как `xmllint --noout filename.xml`. И финальный штрих: изменения конфигурационных файлов применяются перезапуском демона opennms, что занимает порядочно времени.
Внутренняя механика
-------------------
 Основной единицей сбора данных является интерфейс, который под собой объединяет определенные сервисы. Все интерфейсы на одном устройстве группируются в ноду. Интерфейс не обязательно может быть сетевым – с точки зрения OpenNMS температурные датчики тоже являются интерфейсами. Начиная с версии 1.9, однотипные интерфейсы организуются в отдельные группы.
При обнаружении нового интерфейса срабатывает событие `newSuspect`, после чего система пытается обнаружить сервисы на этом интерфейсе, по цепочке найти другие интерфейсы на устройстве и сгруппировать полученную информацию в ноду. Получать данные о новых интерфейсах OpenNMS может автоматически (проводя поиск по заданным диапазонам с определенной периодичностью), вручную (вызывая perl скрипт) или по получению SNMP trap’а.
```
# Вручную скормим системе сервер, на котором она сама и установлена:
perl /opt/opennms/bin/send-event.pl --interface 192.168.11.11 uei.opennms.org/internal/discovery/newSuspect
```
Теперь в Events → All Events можно наблюдать завораживающий процесс рождения новой ноды. Скорость её появления варьируется в зависимости от устройства и составляет от нескольких секунд до нескольких минут.
Отдельный интерес представляют собой Resource Graphs – графики системных ресурсов. После добавления новой ноды мы увидим только данные по умолчанию для каждого сервиса (например, время отклика ICMP и HTTP в случае наличия последнего). Однако, вполне можно расширить объём получаемой информации. Например, мы хотим снимать больше данных с другого сервера под управлением CentOS. Получать данные мы будем по SNMP, поэтому на целевом сервере устанавливаем net-snmp и редактируем `/etc/init.d/snmp/snmpd.conf`
```
# комментируем в начале конфига строки с com2sec, group, view и
# добавляем read-only комьюнити
rocommunity stat
# правим location и contact
syslocation Datacenter N1, Rack 2
syscontact admin@domain.tld
# описываем разделы для мониторинга
disk / 10000
disk /var 10000
# описываем предельные значения load average
load 12 14 14
```
Открываем 161 UDP порт в iptables, запускаем snmpd и заводим новое SNMP комьюнити в OpenNMS (Admin → Operations → Configure SNMP Community Names by IP). После этого можно открывать добавленную ноду и делать ей Rescan. После завершения сканирования, информации станет больше и графики станут предоставлять данные о дисковом пространстве, инодах и загрузке системы.
Перезагружать opennms при добавлении SNMP комьюнити через админку формально не требуется. Но иногда обновление этого файла или добавление новой discovery group подхватывается с большой задержкой и быстрее перезагрузить opennms, чем ждать, пока она очнётся самостоятельно.
Ещё немного внутренней механики
-------------------------------
Разумеется, OpenNMS умеет сканировать сеть и определять появление новых устройств в сети. Процесс поиска настраивается в веб-интерфейсе в разделе Admin → Configure Discovery или в файле `$opennms/etc/discovery-configuration.xml`.
###### Изображение с сайта [oopsmonk](http://oopsmonk.blogspot.com)
Чуть детальнее остановимся на связях между сервисами в OpenNMS, запускающимися после обнаружения нового интерфейса и срабатывания newSuspect. Существует два сервиса, которые определяют наличие различных сервисов: capsd (capabilities daemon) и provisiond (provisioning daemon). По умолчанию они запускаются оба, и для меня остаётся загадкой, зачем это сделано. Ведь начиная с версии 1.8.0, capsd признан устаревшим, хотя при этом сохраняет высший приоритет по сравнению с provisiond.
Поэтому моя личная рекомендация — отключать capsd, перекладывая всю заботу об обнаружении сервисов на плечи provisiond. Работа с последним открывает доступ к условиям инициализации (provisioning requisitions), которые позволяют гибко настраивать определяемые сервисы, автоматически включать мониторинг нужных интерфейсов на узлах, сортировать узлы по категориям и т.п.
Непосредственно определением сервиса занимаются детекторы, являющиеся частью provisiond. Детекторы занимаются только обнаружением и регистрацией сервиса в рамках интерфейса, а сбором информации занимается pollerd. В ранних версиях системы сбором и обработкой данных занимались collectd и pollerd; первый собирал значения для графиков, а второй обрабатывал значения по запросу. Затем Collectd интегрировали в Pollerd и мороки с конфигурацией стало поменьше, хотя кое-где ещё можно наткнуться на оба понятия, что может вызвать определённую путаницу.
Замыкают цепочку обработки данных политики (policies), которые определяют правила, применяющиеся к нодам, попадающим под определенные условия инициализации. На данный момент доступны три: MatchingIpInterfacePolicy, MatchingSnmpInterfacePolicy, NodeCategorySettingPolicy. Их названия говорят сами за себя и применение политик позволяет управлять механиками получения информации с искомых интерфейсов. В качестве примеров:
* Применяя MatchingSnmpInterfacePolicy можно включать принудительный сбор информации с интерфейсов, имеющих в description определённое слово (например, *[mon]*).
* С помощью NodeCategorySettingPolicy отправлять все свитчи D-Link в отдельную категорию.
* С MatchingIpInterfacePolicy мы отключили сбор информации с 80 порта со всех коммутаторов, находящихся в одной подсети. График времени HTTP отклика в случае с коммутаторами не нужен — всегда есть ICMP ответ и данные с интерфейсов, в которых указано волшебное слово *[mon]*
Заключение
----------
*Стабильность.* Единственный серьёзный глюк в системе был зарегистрирован во время «сбоя високосной секунды». И то, это пострадали системы баз данных, а не сама OpenNMS. В остальном, ни одного нарекания на стабильность за несколько лет работы.
*Сложность.* Система сложная и комплексная. Ею легко пользоваться с точки зрения саппорта — всё красиво, наглядно и есть даже клиент для айфона *[x]*. Но процесс настройки (особенно в первый раз) может легко сжечь уйму нервных клеток. Документация покрывает почти все базовые аспекты системы, но стоит отметить неприятную особенность — многие статьи содержат информацию для предыдущих версий. Логически причины этого вполне понятны: поддерживать актуальность для такой комплексной системы — задача не из простых. Но нашу жизнь это совсем не упрощает.
*Гибкость.* Разобравшись в системе, можно подключать свои события, трапы и модули для мониторинга. Если оборудование отдаёт какие-то параметры по SNMP или HTTP – его можно мониторить. Хранение данных в RRD позволяет гибко настраивать внешний вид графиков (которые по умолчанию не блещут красотой) в привычном RRDTool синтаксисе. Превышение пороговых значений обрабатывается в виде уведомлений и алармов. Внешние системы могут получать данные из OpenNMS по ReST или напрямую из базы.
Я не смогу ответить на вопросы «А почему не %systemname%?» и сознательно не стал на себя брать сравнительный анализ разных систем мониторинга — после продолжительной работы с одной системой и определенной привязки к её функционалу, непредвзятого обзора бы не получилось, а ресурсов такая работа отняла бы слишком много. На вопросы о самой системе отвечу с удовольствием, а если тема будет худо-бедно актуальной, то в продолжение этого ознакомительного материала можно будет написать примеры юзкейсов. | https://habr.com/ru/post/193682/ | null | ru | null |
# Подключение дисплея DVD плеера к микроконтроллеру
Начну с предыстории, зачем же мне все это нужно. Я задался целью сделать себе HTPC компьютер на базе корпуса от DVD плеера Daewoo DV-500, внешне он мне нравится, и свободного места в нем достаточно для установки необходимого железа внутрь. Но помимо всего, я задумал оставить родной индикатор и задействовать его для отображения различной информации. О том, как я подключал дисплей к микроконтроллеру и расшифровывал протокол обмена этого дисплея, пойдет в этой статье.
Такую работу надо начинать с поиска информации, в первую очередь я нашел схему плеера, проблем с этим, на мое удивление, не возникло. По схеме я смог понять с чем предстоит работать, но найти описания на контроллер дисплея сразу не получилось, т.к. на схеме он подписан неправильно. К сожалению, документацию на контроллер я нашел в последний момент, случайно, но к этому времени я практически полностью разобрал протокол.
Итак, что же мы имеем:
Мы имеем контроллер VFD дисплея NEC D16312 (обратите внимание как подписан контроллер на схеме, не удивительно что я сразу не смог найти о нем инфу), с подключенными к нему VFD дисплеем, клавиатурной матрицей и светодиодом. С «внешним миром» контроллер подсоединятся через последовательный интерфейс посредством разъема CN1.
Для перехвата сообщений от контроллера основной платы в контроллер дисплея я буду использовать логический анализатор. Я, например, пользуюсь китайским клоном USBee AX PRO, свои ф-ции он выполняет на отлично и стоит недорого.
Подключаем выводы Data, Clk и Cs к любым трем выводам логического анализатора, не забываем также соединить землю. Далее, соединяем анализатор по USB с компьютером и запускаем USBee Suite (я опускаю процесс установки драйверов и программного обеспечения для логического анализатора, это выходит за рамки статьи). В настройках Speed and Samples ставим следущие параметры: Sample Rate — 2Msps, Buffer Size — 10M samples. Этого будет достаточно чтоб захватить кадр обмена размером в 5 секунд.
Дальнейшие мои действия таковы, делаю единичный захват (кнопка Capture Once) и сразу-же включаю плеер. Как только появилась первая информация на экране — выключаю захват. После проделывания таких действий для различных вариантов отображаемого текста, я стал анализировать полученную информацию.
Итак, какие же имеются закономерности во всех посылках команд. Во-первых, что бросилось в глаза сразу, это периодичность посылки команды с кодом 0x42 и тремя пустыми байтами после нее. Команда имеет строгую периодичность появления даже когда видеоплеер в состоянии покоя. Я предположил, что это команда опроса клавиатуры, проверить теорию очень легко, зажимаю любую кнопку на плеере и делаю захват кадра в программе.
Сразу же после байта 0x42 появился не нулевой байт, а раньше был 0! Таким образом 0x42 — команда опроса клавиатуры, которая отсылается контроллером основной платы в контроллер дисплея и в ответ на эту команду контроллер дисплея отвечает кодом нажатой клавиши (или 0 если не нажата ни одна).
Следующей на очереди стала команда с кодом 0x40, она появлялась только когда на экран выводилась информация. После нее всегда идут два байта, первый байт всегда начинается с 0xCX, где X изменяющееся значение. Третий байт имеет произвольные значения, но главное что при первом включении он всегда равен 0
На этом скриншоте видно что второй байт растет с каждой посылкой группы 0x40, скорее всего он задает адрес символа и третьим байтом записывается значение символа. В данном случае 0 очищает символ. Всегда после отсылки всех групп с кодом 0x40 последует два байта 0x02 0x8F.
Ну и последней группой данных является команда, начинающаяся с кодом 0x41 и последующим нулевым байтом после нее. Команда появляется только при первом включении видеоплеера.
Анализ данных вырисовал более-менее понятную картинку работы контроллера, осталось только проверить все на практике. Я использовал отладочную платку LPCXpresso, полученною мною «нахаляву» в рамках какого-то конкурса от NXP. Платка оснащена простеньким 32х битным контроллером LPC1114. Т.к. контроллер питается напряжением 3.3В, а контроллер дисплея D16312 от 5ти вольт, то соединять их выводы напрямую я не решился. Возможно, выводы микроконтроллера толерантны к напряжению 5В, но у меня в наличии имелась платка согласования уровней 3.3-5В и я использовал ее.
Итак, из разъема, идущего к основной плате, извлекаем 3 провода, отвечающие за пины Data, Cs и Clk соответственно пины 1, 2 и 3. К плате контроллера дислея припаиваемся проводами к точкам соединения Data, Clk и Cs, а также нам понядобятся выводы GND и +5V VCC. На первое воемя, я присоединил извлеченные от основной платы три контакта с логическим анализатором, чтобы дебажить передаваемую информацию.
Вот так у меня выглядит содениение с отладочной платкой
Вся железная часть готова, пора приступать к софту. Для начала напишем программу, которая будет повторять полученные в ходе анализа, данные. Для LPCXpresso используется одноименная LPCXpresso IDE на базе Eclipse. Запускаем, указываем путь к нашему новому рабочему пространству и импортим в него 2 стандартных библиотеки CMSIS\_CORE\_LPC11xx и LPC11xx\_cmsis2\_Lib, они нам понадобятся для разработки. Далее создадим новый проект File->New->C/C++->LPCXpresso C Project далее LPC11 / LPC12 -> LPC11xx /… ->C Project. Задаем имя проекта и в следующем окне выбираем целевой контроллер, в моем случае это LPC1114/302. На следующем шаге в списке уже должна появиться библиотека CMSIS\_CORE\_LPC11xx, т.к. мы ее импортировали ранее. В окне задания DSP библиотеки ничего не меняем и на следующем шаге оставляем все по умолчанию, жмем Finish.
Добавляем следующий код в сгенеренный файл <имя проекта>.c
```
#ifdef __USE_CMSIS
#include "LPC11xx.h"
#include "clkconfig.h"
#include "gpio.h"
#endif
#include
void Delay(int32\_t ticks);
void BeginCommand(uint8\_t cmd, uint8\_t isSingle);
void EndCommand();
void Clock();
void WriteData(uint8\_t data);
#define PORT 3
#define DATA\_BIT 2
#define CLK\_BIT 0
#define CS\_BIT 1
int main(void)
{
GPIOInit();
// Set pins to output
GPIOSetDir(PORT, CLK\_BIT, 1);
GPIOSetDir(PORT, CS\_BIT, 1);
GPIOSetDir(PORT, DATA\_BIT, 1);
while(1)
{
BeginCommand(0x40, 1);
BeginCommand(0xC0, 0);
WriteData(0xFF);
EndCommand();
BeginCommand(0x02, 1);
BeginCommand(0x8F, 1);
Delay(3000000);
}
return 0 ;
}
void Delay(int32\_t ticks)
{
volatile int32\_t i = ticks;
while(i--);
}
void BeginCommand(uint8\_t cmd, uint8\_t isSingle)
{
GPIOSetValue(PORT, CLK\_BIT, 1);
GPIOSetValue(PORT, CS\_BIT, 0);
Delay(10);
WriteData(cmd);
if (isSingle)
{
EndCommand();
}
}
void EndCommand()
{
GPIOSetValue(PORT, CLK\_BIT, 1);
GPIOSetValue(PORT, CS\_BIT, 1);
Delay(10);
}
void Clock()
{
Delay(10);
GPIOSetValue(PORT, CLK\_BIT, 0);
Delay(10);
GPIOSetValue(PORT, CLK\_BIT, 1);
}
void WriteData(uint8\_t data)
{
GPIOSetDir(PORT, DATA\_BIT, 1);
uint8\_t i = 0;
for (i = 0; i < 8; ++i)
{
uint8\_t isSet = (data & 0x01);
GPIOSetValue(PORT, DATA\_BIT, isSet);
Clock();
data = data >> 1;
}
}
```
Здесь видим несколько ф-ций для работы с последовательным портом. В самом верху файла задаются настройки порта и пинов для данных, синхронизации и строба. В моем случае все висит на порту 3, пин 2 отвечает за сигнал Data, 0 — синхронизацию и 1 — стробирование.
Ф-ция BeginCommand отсылает команду в порт, у этой ф-ции имеется второй интересный параметр. Если присмотреться на графики сигналов выше, то можно увидеть что сигнал стробирования, выставляется в активный (низкий) уровень, перед посылкой данных, и меняется между двумя независимыми командами. Но не переключается, если после отправки команды должны передаваться данные
Так вот, второй параметр говорит что команда является атомарной если isSingle == 1. Для случая неатомарных команд предназначена ф-ция EndCommand, которую следует вызывать после отсылки данных.
Отсылка же данных выполняется в ф-ции WriteData, по очереди, бит-за-битом, начиная с младшего, передаем в пин Data информацию. Каждое выставление данных сопровождается сигналом синхронизации, ф-ция Clock генерирует его.
В ф-ции main сначала инициализируем работу с входами ввода/вывода, далее выставляем пины Data, Clk и Cs на вывод. В бесконечном цикле имитируем команды, которые были получены ранее на этапе анализа данных. Т.о. мы отправили в контроллер дисплея последовательность данных 0x40 0xC0 0xFF 0x02 0x8F, а контроллер ответил выводом \_8
Т.о. было установлено что команда:
— 0x42 — отвечает за обработку клавиатуры. После ее отправки в контроллер дисплея нужно выставить порт Data на вход и прочитать с него данные, предварительно синхронизировав сигналом Clk
— 0x40 — команда записи данных в дисплей, после нее должна записываться команда указания адреса символа, а после указания адреса записываются данные
— 0x41 — это команда для управления светодиодом, после нее идет байт с данными какой светодиод должен быть включен или нет
Более подробную информацию вы можете найти в руководстве по данному контроллеру дисплея D16312, там расписаны как должны формироваться команды. Ну, а я оформил всю работу в небольшую библиотечку, которая лежит на [гитхабе](https://github.com/evg1985/D16312Lib). Библиотека позволяет отображать текст, управлять спецсимволами, заполнять символ диска в процентном соотношении, читать клавиатуру, менять яркость отображения и управлять светодиодом. На этом все, надеюсь кому-то это чтиво будет полезным и интересным. А на закуску я оставлю видео, с демонстрацией работы библиотеки | https://habr.com/ru/post/231735/ | null | ru | null |
# HTTP-заголовки в I2P. Почему HTTP-прокси предпочтительнее SOCKS
Для выхода в скрытую сеть [I2P](https://habr.com/ru/post/552072/) необходимо программное обеспечение — I2P-роутер: [i2pd](https://i2pd.website/) (C++) или [I2P](https://geti2p.net/ru) (Java). Данное приложение содержит в себе всю внутреннюю логику I2P и обеспечивает взаимодействие с другими участниками сети. Операционная система пользователя не знает что делать с доменными именами ".i2p", поэтому их необходимо передавать напрямую в I2P-роутер посредством прокси на локальном адресе (`127.0.0.1:4447` - SOCKS, `127.0.0.1:4444` - HTTP). Аналогичным образом дела обстоят с луковичными доменами ".onion", которые передаются непосредственно в Tor-маршрутизатор без попытки разрешить его наравне с другими доменными именами (ru, com, org и т.п.) через обычный DNS сервер.
В обиходе прокси протоколов закрепились два титана: HTTP и SOCKS. Заметная разница между ними в том, что HTTP-прокси не умеет передавать UDP-трафик, так как фактически работает в текстовом режиме, а SOCKS передает информацию между пользователем и конечным сервером в бинарном виде, что в конечном счете позволяет работать с любым видом трафика и с UDP в том числе, который обеспечивает комфортное использование IP-телефонии, а также позволяет играть в любые онлайн игры.
HTTP-заголовки — неотъемлемая часть протокола HTTP, на котором работают почти все ресурсы в сети интернет, которые вы открываете через веб-браузер. В них передается пользовательский запрос на сервер и информация о клиенте: язык, версия операционной системы, версия веб-браузера и иногда другие идентификационные данные. Основная информация об устройстве передается в значении "User-Agent". Предполагается, что дополнительная информация о клиенте должна помочь серверу предоставить нужную страницу в лучшем виде: на родном языке пользователя, с адаптацией под его браузер и так далее.
Обратите внимание на строку User-Agent. Если речь идет о приватности, то здесь всё плохо. Информация об операционной системе и веб-браузере в совокупности с другими передаваемыми значениями весьма уникальна, чтобы с большой точностью отслеживать (профилировать) пользователя, который может быть не авторизован на сайте и даже регулярно чистить куки.
Любимый многими SOCKS-прокси априори не вмешивается в передаваемые заголовки, так как передает всю информацию в бинарном виде, следовательно, чтобы приватно сидеть через SOCKS-прокси, нужно заменять стандартные заголовки на стороне веб-браузера. В противном случае сервер видит на каком языке вы предпочитаете общаться, какой операционной системой и каким веб-браузером пользуетесь. Между прочим говоря, Tor предоставляет только SOCKS-прокси.
I2P-роутеры имеют оба вида прокси по умолчанию, но рекомендуется использовать именно HTTP-прокси, так как используя его, вы автоматически обезличиваете свой запрос. I2P-роутер отсекает чувствительную информацию о вас и заменяет Uset-Agent загадочной строкой "MYOB/6.66 (AN/ON)", которая одинакова для всех пользователей.
Помимо этого, HTTP-прокси i2pd налету анализирует запрашиваемый URL и в случае отсутствия нужного короткого домена из зоны ".i2p" предлагает обратиться за ним на один из внутрисетевых регистраторов. SOCKS-прокси в аналогичной ситуации просто не сможет найти пункт назначения и пользователь получает в веб-браузере стандартную страницу ошибки.
На вопрос о значении загадочного набора символов в юзер-агенте I2P-роутера мне [ответили](http://major.acetone.i2p/irc2p/i2p-dev/2021/12/07) в чате команды разработчиков:
"MYOB" можно перевести как "Не твое дело", 6.66 — число зверя (отсылка к Библии, книга Откровения Иоанна Богослова aka Апокалипсис), "AN/ON" — просто витиеватая форма слова "аноним".
Лично я не понял причем тут неправославное число, но надеюсь, что это не станет поводом для запрета I2P в России. | https://habr.com/ru/post/594823/ | null | ru | null |
# Зачем нужно понимать ООП
Часто я встречаю разработчиков, которые пишут код на объектно-ориентированном языке программирования, но не понимают принципов ООП. Это могут быть начинающие девелоперы, которые еще на собеседованиях сталкиваются с проблемами объяснения принципов. А также это могут быть, казалось бы, опытные программисты, которые не понимают принципов, заложенных в язык программирования, на котором они пишут. Второй случай хотелось бы встречать реже, но на практике это не так. Часто разработчики смотрят на наследование или полиморфизм, как на особенности языка, как на какой-то технический инструмент и не думают, о вещах, которые лежат в основе этих механизмов.
**Все, что будет изложено ниже — сугубо мои размышления, я не претендую на статус истины в последней инстанции и не жду, что все примут мою точку зрения. Я надеюсь, эта статья натолкнет на размышления и даст толчок к развитию собственного понимания у каждого читателя.**
Примеры кода буду приводить из iOS разработки.
> Я считаю, если ты пишешь код на объектно-ориентированном языке программирования, ты обязан не только знать определения, но и понимать суть, которая вложена в эту парадигму.
На мой взгляд, если функциональное или структурное программирование — принципы которые больше относятся к написанию именно кода, то ООП это уже не про код, а моделирование сложных систем. Наш мозг воспринимает мир как набор объектов, которые взаимодействуют друг с другом. Если функция — просто действие без контекста, то метод класса это уже действие в определенном контексте, это действие, которое относится к определенному объекту. И система приобретает вид взаимодействия различных объектов между собой. Таким образом, ООП позволяет сделать описание системы более понятным для восприятия.
> Также заранее хочу добавить, это описание идеального сферического программирования в вакууме и в реальности множество вещей нарушаются в угоду практичности. Но стремление к идеалу только улучшит качество кода. И не стоит забывать, что гонка за крайностью — тоже плохо.
#### Наследование
Что такое программирование в целом — это написание детальной инструкции, которую должна выполнить машина. К тому же эта инструкция должна быть понятной как машине, так и человеку, который будет вносить изменения в инструкцию в будущем.
Так как ООП — это про моделирование, то код мы пишем начиная с абстракции частей системы и взаимодействия между этими частями, которые мы должны записать в виде кода. Например, социальная сеть, которая состоит из пользователей, взаимодействующих друг с другом. Помимо пользователей, система состоит из более мелких компонентов, таких как сообщения, посты, лайки, комментарии. Даже сам пользователь может являть собой подсистему в системе. Как человек состоит из различных органов и частей тела: сердце, мозг, руки, пальцы, так и пользователь в системе может состоять из более мелких составляющих. Но уже не руки или глаза, а адрес, интересы, записи об образовании, которые можно выносить как отдельные объекты. Уже на этапе анализа можно проследить принципы объектно-ориентированного подхода. У нас есть пользователь — абстракция реального человека. Но у пользователя могут быть разные роли: админ, обычный пользователь, VIP пользователь, анонимный посетитель. Они все являются абстракциями реальных людей и пользователями данной системы. Но каждая из вышеперечисленных ролей имеет свои особенности и при этом все имеют общее — они пользуются системой и должны зарегистрироваться в системе (у каждого может быть свой способ) и они все должны пройти процедуру входа в систему.
> Это и есть принцип наследования, где каждый админ/VIP-клиент/аноним являются пользователями, но не каждый пользователь должен быть админом или VIP-пользователем.
Неправильное понимание принципа приводит к ошибкам в коде. Типичная ошибка — если есть общие поля или методы, значит нужно делать базовый класс, хотя классы наследники по логике не имеют ничего общего.
Еще пример ошибочной трактовки принципа наследования, это когда базовый класс и наследник являются представителями разных логических групп. Выглядит это следующим образом, реализуем MVC в iOS проекте, где UIViewController это Controller с абстрактными методами, которые должен реализовать наследник. А наследник — это уже Model. Там где по логике проектирования должно быть взаимодействие между двумя группами классов, один класс становиться одновременно и Model и Controller. Не говорим уже о том, что UIViewController в реалиях iOS разработки еще и берет на себя роль View. В итоге мы получаем один объект, который делает все сам. Если у нас есть пользователь (User), то он будет и Controller и View одновременно.
**Пример наследования в iOS**
```
/**
Нужно сделать экран профиля пользователя, в котором отображаются имя и фамилия. Этот экран должен переиспользоваться.
*/
// INCORRECT
class UserProfileViewController: UIViewController {
// MARK: - IBOutlets
@IBOutlet private var firstNameLabel: UILabel!
@IBOutlet private var lastNameLabel: UILabel!
/**
Заполнение данных оставляем классу наследнику в виде абстрактных методов
*/
// MARK: - Abstract methods
func firstName() -> String? {
return nil
}
func lastName() -> String? {
return nil
}
// MARK: - Lifecycle
override func viewDidLoad() {
super.viewDidLoad()
firstNameLabel.text = firstName()
lastNameLabel.text = lastName()
}
}
/**
Создаем класс-наследник, который отвечает за функцию заполнения данных. В таком случае, наследник будет выполнять роль не только UIViewController, а и роль модели, которая предоставляет данные для отображения.
*/
class UserProfileModel: UserProfileViewController {
override func firstName() -> String? {
return "Name"
}
override func lastName() -> String? {
return "Last name"
}
}
// CORRECT
/**
Корректней будет, добавить новый класс-модель, которая будет предоставлять данные.
*/
class UserProfileModel {
func firstName() -> String? {
return "Name"
}
func lastName() -> String? {
return "Last name"
}
}
/**
В таком случае у нас будут два отдельных класса, каждый из которых имеет свою зону ответственности.
*/
class UserProfileViewController: UIViewController {
var model: UserProfileModel?
// MARK: - IBOutlets
@IBOutlet private var firstNameLabel: UILabel!
@IBOutlet private var lastNameLabel: UILabel!
// MARK: - Lifecycle
override func viewDidLoad() {
super.viewDidLoad()
setupUserInfo()
}
// MARK: - Private
private func setupUserInfo() {
firstNameLabel.text = model?.firstName()
lastNameLabel.text = model?.lastName()
}
}
// PERFECT
/**
Еще лучше, взаимодействие между двумя типами классов, контроллер и модель, сделать через протокол, чтобы можно было создавать и использовать разные модели.
*/
protocol UserProfileProtocol {
func firstName() -> String?
func lastName() -> String?
}
class UserProfileViewController: UIViewController {
var model: UserProfileProtocol?
// MARK: - IBOutlets
@IBOutlet private var firstNameLabel: UILabel!
@IBOutlet private var lastNameLabel: UILabel!
// MARK: - Lifecycle
override func viewDidLoad() {
super.viewDidLoad()
setupUserInfo()
}
// MARK: - Private
private func setupUserInfo() {
firstNameLabel.text = model?.firstName()
lastNameLabel.text = model?.lastName()
}
}
class UserProfileModel: UserProfileProtocol {
// MARK: - UserProfileProtocol
func firstName() -> String? {
return "Name"
}
func lastName() -> String? {
return "Last name"
}
}
```
Представляю эту картину в реальной жизни, у нас есть регистратура, где некий администратор ведет записи о посетителях в тетрадку. Также в этой тетради можно читать данные о посетителях. Мы получаем посетителя — Model, человека в регистратуре — Controller и тетрадь View. И в вышеуказанной интерпретации принципа наследования мы получаем, что посетитель всегда является регистратором и тетрадкой. Уже дико выглядит то, что человек и тетрадка одно целое. И логика наследования нарушается. Если рассматривать, что посетитель и регистратор — люди и принять тот факт, что представитель класса регистратора может стать посетителем, то логичней сказать, что регистратор является наследником посетителя.
> Это пример, когда непонимание принципа наследования приводит к сложности понимания системы.
По принципу наследования, базовый класс содержит общие свойства для некоторой группы наследников, которая связана общим логическим смыслом. Если наследники не имеют общего смысла, а просто имеют случайные общие свойства, то скорей всего наследование неправильно реализовано.
#### Абстракция
Я уже затронул принцип наследования, хотя хотелось бы начать с такого принципа как абстракция. На мой взгляд это базовый принцип ООП (также абстракция относится и к остальным парадигмам) и он незаслуженно перешел в разряд опционального принципа.
> Абстракция гласит — останавливаем внимание на важных и необходимых аспектах объекта и игнорируем ненужные для нас.
Как это выглядит: когда мы описываем что-то, мы упоминаем только о тех вещах, которые важны в нашем повествовании. Например, когда парень рассказывает другу о том, как в салоне видел крутую машину, он говорит о важных для них вещах: мощность двигателя, систему тормозов, диаметр колес. Хотя особенностей автомобиля безграничное множество. В своем разговоре ребята не упоминают о молекулярном составе автомобиля, хотя такая характеристика определенно существует у физического тела. Незнание законов физики заставляет упустить такой показатель как сила трения между определенными деталями. Даже дело не в образовании, в данном разговоре все эти детали не важны, они упускаются.
В этом примере используется модель описания автомобиля с набором только необходимых качеств.Так же и в программировании. Когда будет создаваться мобильное приложения для продажи автомобилей, программисту определенно нужно будет описать модель этого автомобиля. Естественно разработчик не будет писать модель у которой 100500 полей и методов.
Наверно пренебрежением этим принципом в реальной разработке, является добавление ненужных методов и свойств классу. Впоследствии, получаем непонимание и нарушение принципа единственной ответственности с SOLID.
Также к абстракции я бы отнес декомпозицию, когда сложный объект разбивается на систему. Мы абстрагируемся от некоторых особенностей и переносим их в отдельный компонент. Пример: пользователь у которого есть место проживания, то есть адрес. Адрес в свою очередь состоит из города, улицы, номера дома и т. д. В этот момент мы думаем, а нужно ли указывать страну или регион? Если это приложения для пользования администрацией конкретного района города, то можно упустить такие детали. В итоге мы получаем пользователя, который абстрагируется от некоторых деталей адреса. Опять-таки, непонимание того, что мы не только пишем код, но и занимаемся моделированием, приводит к тому, что у нас есть, допустим, MenuViewController, который состоит из 5000+ строк кода.
**Пример абстракции через декомпозицию**
```
/**
Распространенная ситуация: создаем класс, к примеру, простую модель пользователя. Но с добавлением функционала, все больше появляется полей и методов в этом классе.
*/
// INCORRECT
class User {
let firstName: String
let lastName: String
let fullName: String
let age: Int
let birthday: Date
let street: String
let postalCode: Int
let city: String
var phoneNumber: String?
var phoneCode: String?
var phoneFlag: UIImage?
var isLoggined: Bool = false
var isAdmin: Bool = false
// MARK: - Init
init(firstName: String,
lastName: String,
fullName: String,
age: Int,
birthday: Date,
street: String,
postalCode: Int,
city: String) {
self.firstName = firstName
self.lastName = lastName
self.fullName = fullName
self.age = age
self.birthday = birthday
self.street = street
self.postalCode = postalCode
self.city = city
}
// MARK: - Admin functionality
func createNewReport() {
guard isAdmin else { return }
print("New report created")
}
func updateReport(for user: User) {
guard isAdmin else { return }
print("Update report for \(user.fullName)")
}
}
// CORRECT
/**
Правильней будет, декомпозировать код, абстрагируя части большого сложного класса на маленькие компоненты.
*/
class Address {
let street: String
let postalCode: Int
let city: String
init(street: String,
postalCode: Int,
city: String) {
self.street = street
self.postalCode = postalCode
self.city = city
}
}
class Name {
let firstName: String
let lastName: String
init(firstName: String,
lastName: String) {
self.firstName = firstName
self.lastName = lastName
}
var fullName: String {
firstName + " " + lastName
}
}
class PhoneNumber {
let phone: String
let code: String
let flag: UIImage
init(phone: String,
code: String,
flag: UIImage) {
self.phone = phone
self.code = code
self.flag = flag
}
}
class User {
/**
В результате, класс User уменьшился в размерах, при этом мы абстрагируемся от деталей имени и адреса.
*/
let name: Name
let address: Address
let birthday: Date
var phoneNumber: PhoneNumber?
init(name: Name,
address: Address,
birthday: Date) {
self.name = name
self.address = address
self.birthday = birthday
}
}
/**
Так как после логина система получает залогиненого Пользователя, то класс User не должен отвечать за состояния системы. За статус логина будет отвечать новая сущность, тем самым система абстрагируется от деталей логики этого статуса.
*/
class LoginSession {
var user: User?
var isLoggined: Bool {
user != nil
}
}
/**
Дополнительные свойства Администратора выносяться в класс-наследник Пользователя.
*/
class Admin: User {
func createNewReport() {
print("New report created")
}
func updateReport(for user: User) {
print("Update report for \(user.fullName)")
}
}
```
#### Полиморфизм
Следующим стоило бы написать об инкапсуляции, принцип, наверное, самый спорный и интересный. Так что я его оставлю на закуску. Наследование уже упомянул, так что можно перейти к полиморфизму.
Полиморфизм плавно вытекает из наследования. Гласит он следующее: можно создавать классы наследники, которые будут имитировать интерфейс базового класса, но со своей собственной реализацией. Этот принцип отражается в таком принципе SOLID как принцип Барбары Лисков: мы можем подставлять объекты классов наследников там, где предполагается использование базового класса, при этом замена не должна никак себя проявлять.
Если взять пример с регистратурой, когда у нас есть просто человек (посетитель, не будем абстрагироваться и делать посетителя наследником человека) и есть регистратор. Должна быть возможность регистратору из другого отдела пройти через текущую регистратуру как обычному посетителю. В жизни это вполне реальный пример.
Пример в коде: множество наследников UIViewController, которые пушатся, презентятся и добавляются в UITabBarController как обычные UIViewController.
Как по мне, самый простой принцип. Но он довольно часто нарушается, когда класс наследник превращается в что-то новое и его уже нельзя использовать там, где использовался базовый класс. Также к нарушению относятся многочисленные опциональные методы и поля, которые в ходе неправильного наследования не нужны классу-наследнику. В этот момент, когда предполагается выполнение определенного метода базового класса, ничего не происходит. В лучшем случае ничего не произойдет, но может получиться так, что приложение либо неадекватно начинает себя вести либо крашится вовсе.
> Полиморфизм — когда наследники делают все по своему, но результат работы такой же как у базового класса. Если наследник занимается чем-то своим и не дает результат такой, который ожидается от базового класса — значит с наследованием и полиморфизмом что-то не так.
Пример: есть базовый класс автомобиль, который предположительно должен заехать в гараж. Создаем летающий автомобиль-наследник (как в фильме «Назад в будущее 2»). Какой будет результат при попытке загнать этого монстра в гараж? Да, он может залететь в гараж, если функция езды будет полностью заменена на функцию полета. А если функция полета была новым функционалом, а функция езды вообще заблокирована? То мы не сможем спрятать нашего летуна от непогоды. Это уже не будет автомобиль, это будет что-то новое. Результат — из-за неправильного моделирования и наследования был нарушен принцип полиморфизма и получился нежелательный результат.
> Добавлю, что полиморфизм тесно связан с наследованием и проблемы в наследовании отзываются еще большими проблемами в полиморфизме.
#### Инкапсуляция
И вот пришла очередь инкапсуляции. Ходит много дискуссий, что же собой представляет инкапсуляция. И существует как минимум два определения:
Инкапсуляция — это сокрытие методов и полей класса, которые не нужны при использовании объектов этого класса.
Инкапсуляция — это обьединение данных и методов, которые обрабатывают эти данные.
Первый вариант иногда воспринимается как инкапсуляция = сокрытие, что, как я считаю, не совсем верное понимание.
Для меня инкапсуляция — это проектирование класса таким образом, чтобы скрыть те методы и поля, которые могут нарушить логику работы класса, заложенную в этот класс. То есть, инкапсуляция != сокрытие. Сокрытие это механизм, который попросту скрывает часть возможностей класса, тогда как инкапсуляция отвечает за то, какие возможности будут доступны, а какие могут нарушить абстракцию этого класса и, соответственно, должны быть скрыты.
К примеру, я разрабатываю кнопку, которая в момент нажатия становится немного светлее. Проще говоря, когда кнопка в состоянии “нажата”, цвет фона становится светлее.
Для этого я создаю класс наследник UIButton и в наследнике добавляю метод, который устанавливает цвет кнопки в цвет с альфа каналом 50% от оригинального. А также я добавляю метод, который возвращает бэкграунд цвет кнопки в оригинальный, без альфа канала.
Если эти два метода будут доступны при использовании моей кастомной кнопки, то может нарушиться поведение этой кнопки. К примеру в момент нажатия можно вызвать метод, который устанавливает оригинальный цвет. Или же вдруг сделать кнопку светлее, как будто она нажата, хотя это не так.
**Пример кнопки с открытыми методами, которые могут нарушить повидение этой кнопки**
```
/**
Создаем кнопку, у которой при нажатии цвет бэкграунда устанавливается в оригинальный цвет но с альфаканалом 0,5
*/
// INCORRECT
class Button: UIButton {
/**
Добавляем два метода, которые устанавливают цвет бекграунда для состояния нажатой кнопки и нормального состояния кнопки
*/
func decorateSelected() {
backgroundColor = backgroundColor?.withAlphaComponent(0.5)
}
func decorateDeselected() {
backgroundColor = backgroundColor?.withAlphaComponent(1)
}
override var isSelected: Bool {
didSet {
if isSelected {
decorateSelected()
} else {
decorateDeselected()
}
}
}
}
// SAMPLE
/**
Проблемой будет то, что методы, декорирующие кнопку в разных состояних, являются публичными. А это значит, что можно нарушить логику работы кнопки, вызвав метод в неправильный момент.
*/
let button = Button()
button.decorateSelected()
// CORRECT
class Button: UIButton {
override var isSelected: Bool {
didSet {
if isSelected {
decorateSelected()
} else {
decorateDeselected()
}
}
}
/**
Мы сделали методы, настраивающие внешний вид кнопки, приватными, тем самым обеспечили правильную логику отображения.
*/
// MARK: - Private
private func decorateSelected() {
backgroundColor = backgroundColor?.withAlphaComponent(0.5)
}
private func decorateDeselected() {
backgroundColor = backgroundColor?.withAlphaComponent(1)
}
}
// PERFECT
/**
Но! У кнопки остаеться возможнось измененить цвет через базовое поле var backgroundColor: UIColor?. Поэтому, немного заморочившись, делаем невозможным менять цвет в момент, когда кнопка нажата.
*/
class Button: UIButton {
override var backgroundColor: UIColor? {
get {
super.backgroundColor
}
set {
if isHighlighted == false {
super.backgroundColor = newValue
}
}
}
override var isHighlighted: Bool {
willSet {
if newValue {
decorateSelected()
}
}
didSet {
if isHighlighted == false {
decorateDeselected()
}
}
}
// MARK: - Private
private func decorateSelected() {
backgroundColor = backgroundColor?.withAlphaComponent(0.5)
}
private func decorateDeselected() {
backgroundColor = backgroundColor?.withAlphaComponent(1)
}
}
```
> Инкапсуляция — не бездумное сокрытие каких-то полей или методов, а проектирование класса с определенным набором возможностей, которые не должны нарушаться.
По поводу объединения данных и методов, которые обрабатывают эти данные, я с этим согласен, но с оговоркой. В моем понимании ООП — моделирование объектов в коде, что само собой подразумевает, наличие состояния и действий у этого объекта.
> Если просуммировать, то инкапсуляция — проектирование самостоятельной единицы (объекта), которая выполняет некую роль в системе, имеет набор параметров и методов. При этом все, что может нарушить роль этого объекта, скрыто.
#### Заключение
Что в целом я хотел сказать? Я считаю, что программирование сложных систем, которые состоят из множества компонентов, начинается с моделирования, а не кодинга. А для моделирования лучше всего подходит ООП парадигма, так как она вобрала в себя принципы, позволяющие упростить моделирование и дальнейшее написание кода. Поэтому правильное понимание принципов ООП ключ к грамотному моделированию. В свою очередь хорошо спроектированная система проще переноситься в код и этот код проще поддерживается в будущем. | https://habr.com/ru/post/479640/ | null | ru | null |
# Оптимизация GUI на Qt
Как правило, при создании desktop-приложений на платформе Qt не возникает проблем, связанных с медленностью работы GUI. Qt – платформа достаточно надежная, неплохо вылизанная по всем параметрам, в том числе и по скорости работы. Однако всё же иногда бывают ситуации, когда из-за обилия виджетов графический интерфейс немного притормаживает, и это печально). В этой статье я приведу один частный пример простого графического интерфейса и покажу, как за два шага можно сначала ускорить его в 11 раз, а потом и в целых 34 раза. Вдобавок к этому, я постараюсь немного осветить механизм принятия решения для таких оптимизационных задач, постараюсь показать направление мыслей для правильного решения. Поехали!
Сразу оговорюсь, я не буду пытаться показать самый оптимальный код и самое быстрое решение. Я буду показывать лишь то решение, которое оказывается достаточным в плане скорости, и которое требует довольно небольшой переделки кода.
Итак, задачу в студию!
Нам надо нарисовать в две колонки список параметров: имя и значение. Параметров много. Они могут быть сгруппированы в группы с общим заголовком. Таким образом, у нас будет виджет с небольшой шириной, но с большой высотой. Его, конечно, стоит поместить в QScrollArea. Собственно, вот этот виджет:
Код виджета был написан когда-то давно, быстро и просто, и он содержал в себе намек на будущее расширение функциональности, то есть, говоря по-честному, некоторую функциональную избыточность. Вот этот код.
Файл FormLayoutWgt.h
```
#pragma once
#include
#include
class FormLayoutWgt : public QScrollArea
{
Q\_OBJECT
public:
FormLayoutWgt(QWidget\* parent = 0);
virtual ~FormLayoutWgt();
typedef QList< QPair > WidgetList;
void setContents(const WidgetList& widgetList);
QSize sizeHint() const;
public slots:
void clear();
private:
QFormLayout\* \_pLayout;
};
```
Файл FormLayoutWgt.cpp
```
#include "FormLayoutWgt.h"
FormLayoutWgt::FormLayoutWgt(QWidget* parent)
: QScrollArea(parent)
{
QWidget* pWidget = new QWidget;
setWidget(pWidget);
setWidgetResizable(true);
_pLayout = new QFormLayout;
_pLayout->setLabelAlignment(Qt::AlignLeft);
_pLayout->setFieldGrowthPolicy(QFormLayout::ExpandingFieldsGrow);
pWidget->setLayout(_pLayout);
}
FormLayoutWgt::~FormLayoutWgt()
{
clear();
}
void FormLayoutWgt::clear()
{
if (_pLayout != 0)
{
QLayoutItem* item;
for (int i = 0; i < _pLayout->rowCount(); i++)
{
item = _pLayout->itemAt(i, QFormLayout::LabelRole);
if (item != 0) delete item->widget();
item = _pLayout->itemAt(i, QFormLayout::FieldRole);
if (item != 0) delete item->widget();
}
int count = _pLayout->rowCount();
for (int i = 0; i < count; i++)
_pLayout->removeRow(0);
}
}
void FormLayoutWgt::setContents(const WidgetList& widgetList)
{
for (int i = 0; i < widgetList.size(); i++)
{
if (widgetList.at(i).first.isEmpty())
_pLayout->addRow(widgetList.at(i).second);
else
_pLayout->addRow(widgetList.at(i).first, widgetList.at(i).second);
}
}
QSize FormLayoutWgt::sizeHint() const
{
return QSize(270, 200);
}
```
А вот примерный сценарий использования такого виджета.
Файл MainWindow.h
```
#pragma once
#include "FormLayoutWgt.h"
class MainWindow : public QWidget
{
Q_OBJECT
public:
MainWindow(QWidget *parent = Q_NULLPTR);
public slots:
void fill();
private:
FormLayoutWgt::WidgetList generateContents() const;
FormLayoutWgt* _flw;
};
```
Файл MainWindow.cpp
```
#include "MainWindow.h"
#include
#include
MainWindow::MainWindow(QWidget \*parent)
: QWidget(parent)
{
QVBoxLayout\* layout = new QVBoxLayout();
setLayout(layout);
\_flw = new FormLayoutWgt();
QPushButton\* fill = new QPushButton("Fill");
QPushButton\* clear = new QPushButton("Clear");
layout->addWidget(fill);
layout->addWidget(clear);
layout->addWidget(\_flw);
connect(clear, SIGNAL(released()), \_flw, SLOT(clear()));
connect(fill, SIGNAL(released()), SLOT(fill()));
}
FormLayoutWgt::WidgetList MainWindow::generateContents() const
{
FormLayoutWgt::WidgetList widgetList;
for (int i = 0; i < 300; i++)
{
widgetList << qMakePair(QString(), new QLabel(QString("### Group%1
").arg(i + 1)));
widgetList << qMakePair(QString("Field1"), new QLabel("Value1"));
widgetList << qMakePair(QString("Field2"), new QLabel("Value2 long long long long"));
widgetList << qMakePair(QString("Field3\n"), new QLabel("Value3 \n two rows"));
widgetList << qMakePair(QString(), new QLabel("==========================="));
}
return widgetList;
}
void MainWindow::fill()
{
auto content = generateContents();
\_flw->setContents(content);
}
```
Получили вот такое тестовое мини-приложение, которое и хотим ускорить:
Код виджета был написан когда-то давно, когда число параметров было небольшое – до нескольких десятков. И он исправно и быстро работал, но до тех пор, пока число параметров не возросло до нескольких сотен (или даже тысяч). GUI стало визуально притормаживать. Общее впечатление пользователя от мгновенно работающего приложения стало немного смазываться. И, в принципе, не стоит винить в этом старый код, ведь он писался для априори более простой задачи.
Итак, перед нами замаячила задача оптимизации. Как ее решать? Для начала, конечно, найти слабое место. И вот тут первая проблема: профилировщик нам тут особо не поможет. Казалось бы, что создание и добавление виджетов – и есть то слабое место. То есть вот эта часть кода:
```
_flw->setContents(content);
```
Но нет, измерение времени показывает тут какие-то жалкие 7 мс. А своими глазами мы видим, что GUI замирает почти на секунду. То есть события (мыши, клавиатуры) перестают обрабатываться на это время. И да, профилировщик показывает, что именно в цикле обработки событий и идут те самые непонятные вычисления.
В чем же здесь дело? Дело в самом Qt. А именно, в сложных алгоритмах ядра работы с виджетами. Дело в том, что, вызывая какую-либо команду в Qt, связанную с виджетами, Вы не можете никогда надеяться на то, что эта команда будет исполнена прямо сейчас. Часто она просто ставится в очередь задач. А исполнение задач из этой очереди может происходить как в отдельном потоке, так и в цикле обработки событий в основном потоке. Это, на самом деле, очень хорошая особенность Qt, благодаря которой мы получаем в целом очень быстрый GUI. Так, вызывая функцию QLabel::setText тысячу раз подряд с одним и тем же параметром, мы не получаем тысячекратного замедления, а получаем лишь однократную перерисовку QLabel с последним поданным значением параметра.
Конкретно в нашей задаче эта особенность Qt повлияла лишь на то, что стало сложнее понимать, как замерить наши тормоза. Что ж, придется немного поиграть с бубном. Для этого добавим таймер, запустим его после добавления всех данных на лэйаут, а остановим при первом вызове события resizeEvent.
```
void FormLayoutWgt::setContents(const WidgetList& widgetList)
{
for (int i = 0; i < widgetList.size(); i++)
{
if (widgetList.at(i).first.isEmpty())
_pLayout->addRow(widgetList.at(i).second);
else
_pLayout->addRow(widgetList.at(i).first, widgetList.at(i).second);
}
_timer.start();
}
void FormLayoutWgt::resizeEvent(QResizeEvent* event)
{
if (_timer.isValid())
{
qDebug() << "gui time = " << _timer.elapsed();
_timer.invalidate();
}
QScrollArea::resizeEvent(event);
}
```
Получили 703 мс, и это как раз то замедление, которое видят наши глаза, и которое послужило причиной оптимизации.
Что дальше? Как ускорить-то, если вся работа фактически происходит в затаенных глубинах Qt, в которые у нас доступа нет? (Да, если кто-то думает, что можно взять исходники Qt и немного подрихтовать, то эта плохая идея, но зато лучший способ убить пару месяцев.)
На самом деле все просто. Просто понять, почему такой долгий расчет идет в глубине кода Qt. Мы пытаемся разместить виджеты на QFormLayout. То есть, фактически, на табличном лэйауте. А ему для отрисовки каждого виджета нужно знать координаты, на которых рисовать. И также ширину и высоту. А значит, нужно опросить каждый виджет, в каких размерах ему будет комфортно отрисоваться. То есть как минимум, обратиться к функции sizeHint() для каждого виджета. А ведь есть еще функция QWidget::heightForWidth(int). А еще у виджетов могут быть разные политики QSizePolicy… И это все надо лэйауту учесть до отрисовки, потом провести расчет координат всех строк и столбцов, и только потом можно рисоваться. Потому неудивительно, что такой расчет для нескольких сотен виджетов может быть не такой мгновенный, к которому мы привыкли.
Хорошо, это мы поняли, а что с этим делать? Можно попытаться по сути сделать то же самое, что делает QFormLayout, но сэкономить при этом на обёртках. Получим немного больше кода, но более быстрого. За базу для отрисовки будем брать QTableWidget (ну раз мы поняли, что мы фактически таблицу и рисуем). Получим такой код (в нем сразу привожу танцы с бубном по поводу замера времени):
Файл TwoColumnWgt.h
```
#pragma once
#include
#include
class TwoColumnWgt : public QTableWidget
{
public:
TwoColumnWgt(QWidget\* parent = 0);
virtual ~TwoColumnWgt();
typedef QList< QPair > WidgetList;
void setContents(const WidgetList& widgetList);
void clear();
protected:
virtual void paintEvent(QPaintEvent\* event);
private:
QElapsedTimer \_timer;
};
```
Файл TwoColumnWgt.cpp
```
#include "TwoColumnWgt.h"
#include
#include
#include
TwoColumnWgt::TwoColumnWgt(QWidget\* parent)
: QTableWidget(parent)
{
setColumnCount(2);
verticalHeader()->hide();
horizontalHeader()->hide();
setShowGrid(false);
setWordWrap(false);
setSortingEnabled(false);
setSelectionMode(QAbstractItemView::NoSelection);
setFocusPolicy(Qt::NoFocus);
setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
verticalHeader()->setSectionResizeMode(QHeaderView::Fixed);
verticalHeader()->setDefaultSectionSize(QFontMetrics(this->font()).height());
auto pal = palette();
pal.setColor(QPalette::Base, pal.color(QPalette::Window));
setPalette(pal);
}
TwoColumnWgt::~TwoColumnWgt()
{
clear();
}
void TwoColumnWgt::clear()
{
for (int i = rowCount() - 1; i >= 0; i--)
model()->removeRow(i);
}
void TwoColumnWgt::setContents(const WidgetList& widgetList)
{
int maxW1 = 0;
int maxW2 = 0;
int maxSpanW = 0;
QFontMetrics fm(this->font());
int pixelsHigh = fm.height();
int hOffset = pixelsHigh / 2;
setRowCount(widgetList.size());
for (int row = 0; row < widgetList.size(); row++)
{
verticalHeader()->setSectionResizeMode(row, QHeaderView::Fixed);
QWidget\* w = widgetList.at(row).second;
QString title = widgetList.at(row).first;
if (title.isEmpty())
{
setSpan(row, 0, 1, 2);
setCellWidget(row, 0, w);
QSize sh = w->sizeHint();
verticalHeader()->resizeSection(row, sh.height() + hOffset);
maxSpanW = std::max(sh.width(), maxSpanW);
}
else
{
int pixelsWide = fm.horizontalAdvance(title);
maxW1 = std::max(pixelsWide, maxW1);
setItem(row, 0, new QTableWidgetItem(title));
setCellWidget(row, 1, w);
QSize sh = w->sizeHint();
verticalHeader()->resizeSection(row, sh.height() + hOffset);
maxW2 = std::max(sh.width(), maxW2);
}
}
int wOffset = fm.horizontalAdvance("123");
maxW1 += wOffset;
maxW2 = std::max(maxSpanW - maxW1, maxW2);
horizontalHeader()->resizeSection(0, maxW1);
horizontalHeader()->resizeSection(1, maxW2);
\_timer.start();
}
void TwoColumnWgt::paintEvent(QPaintEvent\* event)
{
if (\_timer.isValid())
{
qDebug() << "gui time = " << \_timer.elapsed();
\_timer.invalidate();
}
QTableWidget::paintEvent(event);
}
```
Этот код уже показывает выполнение в 65 мс против старых 710. Ускорение в 11 раз. Причем, вся работа уже делается именно в коде TwoColumnWgt::setContents, а не в цикле обработки событий Qt. По крайней мере, теперь можно отказаться от трюков при замерах времени.
Хорошо, ускорили в 11 раз, стоит ли продолжать? Однозначно да. Во-первых, такая оптимизация может не работать при переходе на следующую версию Qt (мы же сэкономили на внутренних обертках Qt, а их реализация может поменяться, значит, и прирост скорости может нивелироваться). Во-вторых, ускорение в 11 раз мы получили именно на этом примере, а на других похожих может получиться и другая, меньшая цифра (например, попробуйте увеличить длину текста, и увидите, что коэффициент ускорения упадет).
Как можно ускорить еще? Да просто двигаться в этом же направлении. Мы уже перешли от QFormLayout с ячейками-виджетами к QTableWidget с ячейками-виджетами. Осталось совсем избавиться от виджетов внутри QTableWidget, заменить их на более легковесные (и привычные таблицам) ячейки QTableWidgetItem. При этом, как может показаться, мы потеряем в функциональности, потому что раньше мы же могли ставить ЛЮБЫЕ виджеты в таблицу, а теперь только текст! На самом деле, и раньше не требовались ЛЮБЫЕ виджеты, раз уж мы говорим про конкретную задачу с двумя колонками «имя-значение». Нужен так или иначе текст, а значит, в QTableWidgetItem мы вписываемся. Но если всё же действительно требуется нарисовать что-то эдакое, то тогда нужно будет переносить это на делегаты, и это тоже будет довольно быстро работать.
К этой мысли – что от виджетов в таблице надо отказываться – можно прийти и другим путем. Запустив профилировщик, мы увидим, что критическое место – замеры размеров виджета (sizeHint). То есть надо заменить эти замеры на какие-то другие, более простые и быстрые. А это могут быть только функции класса QFontMetrics.
Итак, с этим пониманием упростим тогда систему входных
параметров и изменим немного код. Также приблизим конечную визуализацию
(размеры шрифтов, отступы) к начальной. Получим вот это:
Файл tcwvar.h
```
#pragma once
#include
#include
struct TcwContent
{
QString title;
QString value;
};
struct TcwHeader
{
QString title;
};
struct TcwSeparator
{
};
using TcwVariant = std::variant;
```
Файл TwoColumnWgt.h
```
#pragma once
#include "tcwvar.h"
#include
class TwoColumnWgt : public QTableWidget
{
public:
TwoColumnWgt(QWidget\* parent = 0);
void setContents(const std::vector& variants);
void clear();
private:
QString separatorText(const std::vector&) const;
};
```
Файл TwoColumnWgt.cpp
```
#include "tcw.h"
#include
#include
TwoColumnWgt::TwoColumnWgt(QWidget\* parent)
: QTableWidget(parent)
{
setColumnCount(2);
verticalHeader()->hide();
horizontalHeader()->hide();
setShowGrid(false);
setWordWrap(false);
setSortingEnabled(false);
setSelectionMode(QAbstractItemView::NoSelection);
setFocusPolicy(Qt::NoFocus);
setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
verticalHeader()->setSectionResizeMode(QHeaderView::Fixed);
verticalHeader()->setDefaultSectionSize(QFontMetrics(this->font()).height());
auto pal = palette();
pal.setColor(QPalette::Base, pal.color(QPalette::Window));
setPalette(pal);
}
void TwoColumnWgt::clear()
{
for (int i = rowCount() - 1; i >= 0; i--)
model()->removeRow(i);
}
void TwoColumnWgt::setContents(const std::vector& variants)
{
QFontMetrics fm(this->font());
int maxW1 = 0;
int maxW2 = 0;
int maxSpanW = 0;
int pixelsHigh = fm.height();
int hOffset = pixelsHigh / 2;
QString sepText = separatorText(variants);
setRowCount(variants.size());
for (int row = 0; row < variants.size(); row++)
{
if (const TcwContent\* content = std::get\_if(&variants[row]))
{
// add left margin
QString title = " " + content->title;
// add two cells
setItem(row, 0, new QTableWidgetItem(title));
auto\* item = new QTableWidgetItem;
item->setData(0, content->value);
setItem(row, 1, item);
// calculate sizes
int pixelsWide = fm.horizontalAdvance(title);
maxW1 = std::max(pixelsWide, maxW1);
QFontMetrics fm(item->font());
auto rect = fm.boundingRect(QRect(0, 0, 1000, 1000),
Qt::AlignTop | Qt::AlignLeft, content->value);
maxW2 = std::max(rect.width(), maxW2);
// correct row height
verticalHeader()->resizeSection(row, rect.height() + hOffset);
}
else if (const TcwHeader\* header = std::get\_if(&variants[row]))
{
// add left margin
QString title = " " + header->title;
// add cell
setSpan(row, 0, 1, 2);
auto\* item = new QTableWidgetItem;
auto font = item->font();
font.setBold(true);
constexpr double fontRatio = 10.0 / 8.25;
int pixelSize = font.pixelSize();
double pointSizeF = font.pointSizeF();
if (pointSizeF != -1)
font.setPointSizeF(pointSizeF \* fontRatio);
else
font.setPixelSize(qRound(pixelSize \* fontRatio));
item->setFont(font);
item->setData(0, title);
setItem(row, 0, item);
// calculate sizes
QFontMetrics fm(font);
int hw = fm.horizontalAdvance(title) + fm.horizontalAdvance("1");
maxSpanW = std::max(hw, maxSpanW);
}
else if (const TcwSeparator\* separator = std::get\_if(&variants[row]))
{
// add cell
setSpan(row, 0, 1, 2);
auto\* item = new QTableWidgetItem;
item->setData(0, sepText);
setItem(row, 0, item);
// correct row height
verticalHeader()->resizeSection(row, hOffset);
}
}
//correct column sizes
maxW1 += fm.horizontalAdvance("12");
horizontalHeader()->resizeSection(0, maxW1);
if (maxW2 > maxSpanW - maxW1)
resizeColumnToContents(1);
else
horizontalHeader()->resizeSection(1, maxSpanW - maxW1);
}
QString TwoColumnWgt::separatorText(const std::vector& variants) const
{
// calculate column sizes
int column1Size = 0;
int column2Size = 0;
for (auto& variant : variants)
{
if (auto\* content = std::get\_if(&variant))
{
column1Size = std::max(content->title.size(), column1Size);
auto list = content->value.split('\n');
for (auto item : list)
column2Size = std::max(item.size(), column2Size);
}
}
// add left margin
return " " + QString(column1Size + column2Size, '-');
}
```
Файл MainWindow.cpp (фрагмент)
```
std::vector MainWindow4::generate() const
{
std::vector results;
for (int i = 0; i < 300; i++)
{
results.emplace\_back(TcwHeader{ QString("Group%1").arg(i + 1) });
results.emplace\_back(TcwContent{ "Field1", "Value1" });
results.emplace\_back(TcwContent{ "Field2", "Value2 long long long long" });
results.emplace\_back(TcwContent{ "Field3\n", "Value3 \n two rows" });
results.emplace\_back(TcwSeparator());
}
return results;
}
```
Это решение работает уже 21 мс, то есть в 34 раза быстрее, чем исходное решение.
Итог
----
Оптимизационные задачи, связанные с GUI, на Qt возникают не так уж часто, поскольку платформа Qt сама по себе очень неплоха (я не говорю про задачи типа «нарисовать график из миллиарда точек», там, конечно, нужно писать свою быструю библиотеку, как это сделали мы). Но, когда такие задачи возникают на обычном офисном GUI (набор простых контролов и форм), их всё же можно решать относительно несложными действиями и с весьма приятным результатом по скорости. Однако, как правило, всё же чем-то (немного) придется жертвовать, ибо чудес не бывает. Благо, что в архитектуре и в требованиях к софту, скорее всего, заложена некоторая избыточность, и вот ей как раз и можно пожертвовать. | https://habr.com/ru/post/672962/ | null | ru | null |
# Разбираемся с синтаксисом шаблонов в Angular2
Многие впервые увидев синтаксис шаблонов Angular2 начинают причитать, мол ужас какой сделали, неужто нельзя было как в Angular1 хотя-бы. Зачем нужно было вводить это разнообразие скобочек, звездочек и прочей ерунды! Однако при ближайшем рассмотрении все становится куда проще, главное не пугаться.
Так как шаблоны в AngularJS являются неотъемлемой его частью, важно разобраться с ними в самом начале знакомства с новой версии этого фреймворка. Заодно обсудим, какие преимущества дает нам данный синтаксис по сравнению с angular 1.x. Причем лучше всего будет рассматривать это на небольших примерах.
Данная статья во многом основана на материалах этих двух статей:
* [Angular2: синтаксис шаблонов](http://julienrenaux.fr/2015/12/02/angular2-series-template-syntax/)
* [Angular2: Синтаксис биндинга данных](http://www.wintellect.com/devcenter/jcarroll/build-an-angular-2-app-data-binding-syntax)
Для того, что бы упростить подачу материала, давайте разберемся. Под AngularJS я буду подразумевать всю ветку Angular 1.x, в то время как под Angular2 — ветку 2.x.
Так же спасибо господину [Bronx](https://habrahabr.ru/users/bronx/) за ценное [дополнение](http://habrahabr.ru/post/274743/#comment_8731271), которое я включил в текст статьи.
Примечание: вечер выходного дня, потому о опечатках и т.д. сообщайте в личку. Премного благодарен и приятного чтения.
[Биндинг свойств элементов
-------------------------](#bindingh-svoistv-eliemientov)
В случае простого вывода данных разницы вы не почувствуете, однако, если вы решите передать часть состояния в качестве значения какого-либо атрибутов элементов, можно уже наблюдать интересные решения.
Давайте освежим в памяти как работают биндинги на атрибуты в AngularJS. Для этого мы обычно напрямую пробрасывали выражения (интерполируемые при компиляции шаблона) прямо в атрибут элемента, либо пользовались одной из множества директив. Например `ngValue` для установки значения свойства `value` у инпутов.
Приведем пример как это работает в AngularJS:
Так же не забываем что мы можем просто интерполировать результат выражения напрямую в качестве значения аргумента:
Заметим интересную особенность. Второй вариант многие его избегают, так как можно увидеть промежуточное состояние до того, как angular интерполирует значения. Однако первый вариант использует директивы. То есть для того что бы у нас все было хорошо, красиво и удобно, нам надо сделать по директиве на каждое свойство всех элементов. Согласитесь, не слишком то удобно. Почему бы не добавить какое-то обозначение для атрибута, которое бы говорило ангуляру замэпить значение на него. Причем было бы неплохо что бы синтаксис был валидным. И они добавили, теперь для этого надо всего-лишь обернуть интересующий нас атрибут (любой атрибут) в квадратные скобки — `[]`.
По сути синтаксис `[]` это ни что иное как сокращенная запись для `bind-prop`. Если убрать сахар то пример выше будет записан как:
Однако вспомним как можно поменять атрибуты в Javascript:
```
element[prop] = 'value';
```
именно отсюда и берутся эти квадратные скобочки. Мы поясняем что значения будут мэпится прямо на свойства элементов. То есть вместо директивы `ng-bind-html` мы можем просто биндить результат выражения на `[inner-html]`. Или вместо `ng-hide` мы можем использовать свойство `[hidden]` самого элемента. Это значительно уменьшает количество специфичных для angular вещей которые нужно знать и приближает нас к DOM, при этом у нас все еще сохраняется абстракция от оного.
Ну и закрыть этот вопрос стоит указав, что у нас так же есть возможность мэпить интерполируемое значение, так же как это было в AngularJS:
[События
-------](#sobytiia)
В AngularJS мы могли подписаться на события элементов используя специальные директивы. Так же, как и в случае со свойствами, нам приходится иметь дело с [целой кучей](https://developer.mozilla.org/en-US/docs/Web/Events) возможных событий. И на каждое событие приходилось делать директиву. Пожалуй, самой популярной из таких директив является `ngClick`:
Учитывая что мы уже решили такую проблему для свойств элементов, то наверное так же стоит решать и эту проблему? Именно это и сделали! Для того, что бы подписаться на событие, достаточно прописать атрибут используюя следующий синтаксис: `(eventName)`. Таким образом у нас есть возможность подписаться на любое событие генерируемое нашим элементом, при этом без надобности писать отдельную директиву:
Так же как и в случае с биндингом свойств, это так же сахар для `on-` записи. То есть пример выше можно было зы баписать как:
А вид скобочек получается из ассоциаций с установлением обработчиков событий в javascript:
```
element.addEventListener('click', ($event) => doSomething($event));
```
Стоит так же отметить важное отличие в поведении, если сравнивать с биндингом событий в AngularJS. Теперь Angular2 будет выбрасывать нам ошибки в случае обращения к несуществующему методу. Как если бы мы вызывали код прямо в javascript. Я думаю многие из тех у кого бывали глупые баги из-за опечаток в этом контексте будут рады. В некоторых случаях это добавляет определенные неудобства и потому был добавлен так же Elvis-оператор, о котором мы поговорим чуть позже.
[Двусторонний биндинг
--------------------](#dvustoronnii-bindingh)
Существует распространенное мнение, что двусторонний биндинг это плохо, и что это основной грех ангуляра. Это не совсем так. Проблема с двусторонним биндингом в AnugularJS была в том, что он используется повсеместно, не давая разработчикам альтернативы (возможно ситуация с этим в скором времени изменится).
Все же иногда возникают случаи когда двусторонний биндинг здорово упрощает разработку, особенно в случае форм. Так как же реализован оный в Angular2? Давайте подумаем, как организовать двусторонний биндинг имея односторонний биндинг свойст элементов и биндинг событий:
Опять же, не очень то удобно. Посему в Angular2 так же есть синтаксический сахар с использованием `ngModel`. Результат будет идентичен тому, что мы привели выше:
[Локальные переменные
--------------------](#lokal-nyie-pieriemiennyie)
Для передачи данных между элементами в пределах одного шаблона используются локальные переменные. Наиболее близкой аналогией в AngularJS, пожалуй, можно считать доступ к элементам формы по имени через ngForm. Конечно, это не совсем корректное сравнение, так как работает это только за счет директивы `ngForm`. В Angular2 вы можете использовать ссылку на любой объект или DOM элемент в пределах элемента шаблона и его потомков, используя локальные переменные `#`.
```
```
В данном примере мы можем видеть, как через переменную `movieplayer` мы можем получить доступ к API медиа элемента прямо в шаблоне.
Помимо символа `#`, вы так же можете объявлять переменные используя префикс `var-`. В этом случае вместо `#movieplayer` мы могли бы записать `var-movieplayer`.
Благодаря локальным переменным нам больше не нужно делать новые директивы всякий раз, когда действия над одними элементами должны менять что-то у других. Например, в примере выше, мы можем быстро добавить кнопку которая запускает просмотр видео. В этом собственно главное концептуальное отличие Angular2 от AngularJS, меньше бесполезных микро-директив, большая концентрация внимания на компонентах.
[Звездочка (символ \*)
---------------------](#zviezdochka-simvol)
Символ `*` вызывает больше всего вопросов. Давайте разберемся, зачем он понадобился. Для осознания причин добавления этого символа, нам стоит вспомнить о таком элементе как `template`.
Элемент `template` позволяет нам задекларировать кусочек DOM, который мы можем инициализировать позже, что дает нам более высокую производительность и более рациональное использование ресурсов. Чем-то это похоже на `documentFragment` в контексте HTML.
Пожалуй, будет проще показать зачем оно надо на примере:
```
```
В этом небольшом примере мы можем видеть, что блок скрыт (`display:none`). Однако браузер все равно будет пытаться загрузить картинку, даже если она не понадобится. Если подобных вещей на странице много, это может пагубно отразиться на общей производительности страницы.
Решением этой проблемы станет использование элемента `template`.
```
```
В этом случае браузер не будет загружать изображение, пока мы не инициализируем шаблон.
Но вернемся к нашим баранам. Использование символа `*` перед директивой элемента позволит ангуляру при компиляции обернуть элемент в шаблон. Проще посмотреть на примере:
Этот шаблон будет трансформирован в такой:
```
```
Теперь должно стать ясно, что этот символ предоставляет синтаксический сахар для достижения более высокой производительности при использовании условных директив вроде `ngFor`, `ngIf` и `ngSwitch`. Логично что нет нужды в создании экземпляра компонента `hero-detail` пока `isActive` не является истиной.
[Пайпы
-----](#paipy)
Пайпы — это прямой аналог фильтров из AngularJS. В общем и целом синтаксис их применения не особо поменялся:
```
My birthday is {{ birthday | date:"MM/dd/yy" }}
```
Зачем понадобилось менять название с уже привычных фильтров на новые пайпы — отдельный вопрос. Сделано это было что бы подчеркнуть новую механику работы фильтров. Теперь это не синхронные фильтры, а асинхронные пайпы (по аналогии с unix pipes).
В AngularJS фильтры запускаются синхронно на каждый $digest цикл. Этого требует механизм отслеживания изменений в AngularJs. В Angular2 же отслеживание изменений учитывает зависимости данных, посему это позволяет оптимизировать целый ряд концепций. Так же появилось разделение на stateful и stateless пайпы (в то время как фильры AngularJS заведомо считались stateful).
Stateless пайпы, как это может быть понятно из названия, не имеют собственного состояния. Это чистые функции. Они выполняются только один раз (или если изменились входящие данные). Большинство пайпов в Angular2 являются stateless пайпами. Это позволяет существенно увеличить производительность.
Stateful пайпы напротив, имеют свое состояние и они выполняются часто в связи с тем что внутренне состояние может поменяться. Примером подобного пайпа является `Async`. Он получает на вход промис, подписывается на изменения и возвращает заресолвленное значение.
```
// это не TypeScript, это babel со stage-1, ну так, к сведенью
@Component({
selector: 'my-hero',
template: 'Message: {{delayedMessage | async}}',
})
class MyHeroAsyncMessageComponent {
delayedMessage = new Promise((resolve, reject) => {
setTimeout(() => resolve('You are my Hero!'), 500);
});
}
// повелись? Неее, это просто TypeScript без определения типов.
```
В этом примере компонент `my-hero` выведет `Message: You are my Hero!` только после того, как будет заресолвлен промис `delayedMessage`.
Для того что бы сделать stateful пайпы мы должны явно объявить это в метаданных оного. Иначе Angular2 будет считать его stateless.
[Elvis оператор
--------------](#elvis-opierator)
В AngularJS мы могли делать обращения к чему угодно совершенно безболезненно, что частенько выливалось в весьма коварные баги и затрудняло отладку. Вам наверняка приходилось сталкиваться с опечатками в `ngClick`, при которых код не выполнял требуемых действий а фреймворк не давал нам никаких подсказок что же пошло не так. В Angular2 мы наконец будем получать ошибки! Однако подобное решение не всем может придтись по душе без дополнительного сахара.
В Javascript нам частенько приходится проверять наличие каких-либо свойств. Думаю все мы писали что-то подобное:
```
if (cordova && cordova.plugins && cordova.plugins.notification){
// use cordova.plugins.notification
}
```
Делая такие проверки мы конечно же хотим избежать подобного:
```
TypeError: Cannot read property 'notification' of undefined.
```
Для решения этой проблемы был введен [Elvis оператор](http://dobsondev.com/wp-content/uploads/2014/12/Elvis-Operator.png), как сокращенная версия тернарного оператора. Вы могли видеть подобный в Coffeescript. В Angular2 решили эту проблему используя тот же оператор, но на уровне шаблонов:
```
Go To Work
```
Данная запись означает, что свойство `employer` опционально, и если оно имеет пустое значение, то остальная часть выражения игнорируется. Если убрать сахар, то эта запись будет выглядеть так:
```
Go To Work
```
Если бы мы не воспользовались этим оператором и при этом не делали бы подобной проверки, то в этой ситуации мы бы получили `TypeError`.
Так же как и в coffescript данный оператор можно использовать сколько угодно раз в рамках одного выражения, например так: `a?.b?.c?.d`
[Выводы
------](#vyvody)
Разработчики Angular2 проделали огромную работу для того что бы сделать синтаксис шаблонов более гибким и мощным. Да, некоторые вещи требуют немного времени для адаптации, но в целом со временем все это кажется более чем естественным. А главное, не так все страшно как кажется на первый взгляд. | https://habr.com/ru/post/274743/ | null | ru | null |
# Смена пола и расы на селфи с помощью нейросетей
Привет, Хабр! Сегодня я хочу рассказать вам, как можно изменить свое лицо на фото, используя довольно сложный пайплайн из нескольких генеративных нейросетей и не только. Модные недавно приложения по превращению себя в даму или дедушку работают проще, потому что нейросети медленные, да и качество, которое можно получить классическими методами компьютерного зрения, и так хорошее. Тем не менее, предложенный способ мне кажется очень перспективным. Под катом будет мало кода, зато много картинок, ссылок и личного опыта работы с GAN'ами.
Задачу можно разбить на следующие шаги:
* найти и вырезать лицо на фото
* преобразовать лицо нужным образом (превратить в женщину/чернокожего и т.п.)
* улучшить/увеличить полученное изображение
* вставить трансформированное лицо обратно в оригинальное фото
Каждый из перечисленных шагов можно реализовать отдельной нейросетью, но можно обойтись и без них. Давайте по порядку.
Детекция лица
-------------
Здесь проще всего. Можно ничего не выдумывать и просто взять `dlib.get_frontal_face_detector()`([пример](http://dlib.net/face_detector.py.html)). Dlib'овский детектор по умолчанию использует линейный классификатор, обученный на HOG-фичах.
Как мы видим, выдаваемый прямоугольник содержит не все лицо, поэтому лучше его увеличить. Оптимальные коэффициенты увеличения можно подобрать руками. В итоге у вас может получиться подобный метод и подобный результат:
**код**
```
def detect_single_face_dlib(img_rgb, rescale=(1.1, 1.5, 1.1, 1.3)):
fd_front_dlib = dlib.get_frontal_face_detector()
face = fd_front_dlib(img_rgb, 1)
if len(face) > 0:
face = sorted([(t.width() * t.height(), (t.left(), t.top(), t.width(), t.height()))
for t in face],
key=lambda t: t[0], reverse=True)[0][1]
else:
return None
if rescale is not None and face is not None:
if type(rescale) != tuple:
rescale = (rescale, rescale, rescale, rescale)
(x, y, w, h) = face
w = min(img_rgb.shape[1] - x, int(w / 2 + rescale[2] * w / 2))
h = min(img_rgb.shape[0] - y, int(h / 2 + rescale[3] * h / 2))
fx = max(0, int(x + w / 2 * (1 - rescale[0])))
fy = max(0, int(y + h / 2 * (1 - rescale[1])))
fw = min(img_rgb.shape[1] - fx, int(w - w / 2 * (1 - rescale[0])))
fh = min(img_rgb.shape[0] - fy, int(h - h / 2 * (1 - rescale[1])))
face = (fx, fy, fw, fh)
return face
```
Если же работа "старых" методов по каким-то причинам вас не устраивает, можно попробовать deep learning. Для решения задачи обнаружения лица подойдут любые Region Proposal Networks, например [YOLOv2](https://arxiv.org/abs/1612.08242) или [Faster-RCNN](https://arxiv.org/abs/1506.01497). Как попробуете — обязательно поделитесь тем, что у вас получилось.
Трансформация лица
------------------
Вот тут самое интересное. [Как вы уже наверняка знаете](https://habrahabr.ru/company/ods/blog/336594/), преобразовать лицо или сделать маску можно и без нейросетей, и это будет хорошо работать. Но генеративные сети — гораздо более перспективный инструмент для обработки изображений. Уже есть огромное количество моделей, типа `GAN`, которые умеют вытворять самые разные трансформации. Задача преобразования изображений из одного набора (домена) в другой называется Domain Transfer. С некоторыми архитектурами Domain Transfer сетей вы могли познакомиться в нашем [недавнем обзоре GAN'ов](https://habrahabr.ru/company/ods/blog/322514/).
### Cycle-GAN
Почему именно Cycle-GAN? Да потому что она работает. Посетите [сайт проекта](https://junyanz.github.io/CycleGAN/) и посмотрите, что можно делать с помощью этой модели. В качестве датасета достаточно двух наборов изображений: DomainA и DomainB. Допустим, у вас есть папки с фотографиями мужчин и женщин, белых и азиатов, яблок и персиков. Этого достаточно! Клонируете [репозиторий авторов](https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix) с реализацией Cycle-GAN на pytorch и приступаете к обучению.
### Как это работает
На этом рисунке из [оригинальной статьи](https://arxiv.org/abs/1703.10593) достаточно полно и кратко описан принцип работы модели. По-моему, очень простое и изящное решение, которое дает хорошие результаты.
По сути, мы обучаем две функции-генератора. Одна —  — учится по входному изображению из домена  генерировать изображение из домена . Другая —  — наоборот, из  в . Соответствующие дискриминаторы  и  им в этом помогают, как это свойственно GAN'ам. Обычный Advesarial Loss (или GAN Loss) выглядит следующим образом:
![$L_{GAN}(G, D_Y, X, Y)=\mathbb{E}_{y\sim p_{data}(y)}[\log D_Y(y)]+\mathbb{E}_{x\sim p_{data}(x)}[\log (1-D_Y(G(x)))]$](https://habrastorage.org/getpro/habr/formulas/d10/d59/028/d10d590282f430fd7337fca878fd8bbb.svg)
Дополнительно авторы вводят так называемый Cycle Consistensy Loss:
![$L_{cyc}(G,F) = \mathbb{E}_{x \sim p_{data}(x)}[\left \| F(G(x))-x \right \|_1] + \mathbb{E}_{y \sim p_{data}(y)}[\left \| G(F(y))-y \right \|_1]$](https://habrastorage.org/getpro/habr/formulas/ed1/c22/bed/ed1c22bed3d34b1d37748964a6f597ff.svg)
Суть его в том, чтобы изображение из домена , пройдя через генератор , а потом через генератор , было максимально похоже на оригинал. Короче, .
Таким образом, целевая функция принимает вид:
и мы решаем следующую задачу оптимизации:
Здесь  — гиперпараметр, контролирующий вес дополнительного лосса.
Но это еще не все. Было замечено, что генераторы очень сильно меняют цветовую гамму оригинального изображения.
Чтобы это исправить, авторы добавили дополнительный лосс — Identity Loss. Это своего рода регуляризатор, который требует от генератора identity mapping для изображений целевого домена. Т.е. если на вход генератору зебр пришла зебра — то не надо такую картинку изменять.
![$L_{identity}(G,F) = \mathbb{E}_{y \sim p_{data}(y)}[\left \| G(y)-y \right \|_1] + \mathbb{E}_{x \sim p_{data}(x)}[\left \| F(x)-x \right \|_1]$](https://habrastorage.org/getpro/habr/formulas/3ea/9bc/8bc/3ea9bc8bc2fd2bbdb5f61cfba307197f.svg)
На (мое) удивление это помогло решить проблему сохранения цветовой гаммы. Вот примеры от авторов статьи (там картины Моне пытаются преобразовать в реальные фотографии):
### Архитектуры используемых сетей
Для того чтобы описать используемые архитектуры, введем некоторые условные обозначения.
`c7s1-k` — это сверточный слой 7х7 с последующей батч-нормализацией и ReLU, со страйдом 1, паддингом 3 и количеством фильтров k. Такие слои не уменьшают размерность нашего изображения. Пример на pytorch:
```
[nn.Conv2d(n_channels, inplanes, kernel_size=7, padding=3),
nn.BatchNorm2d(k, affine=True),
nn.ReLU(True)]
```
`dk` — сверточный слой 3х3 со страйдом 2 и кол-вом фильтров k. Такие свертки уменьшают размерность входного изображения в 2 раза. Опять пример на pytorch:
```
[nn.Conv2d(inplanes, inplanes * 2, kernel_size=3, stride=2, padding=1),
nn.BatchNorm2d(inplanes * 2, affine=True),
nn.ReLU(True)]
```
`Rk` — residual блок с двумя свертками 3х3 с одинаковым количеством фильтров. У авторов он сконструирован так:
```
resnet_block = []
resnet_block += [nn.Conv2d(inplanes, planes, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(planes, affine=True),
nn.ReLU(inplace=True)]
resnet_block += [nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(planes, affine=True)]
```
`uk` — 3x3 up-convolution слой с BatchNorm и ReLU — для увеличения размерности изображения. Опять пример:
```
[nn.ConvTranspose2d(inplanes * 4, inplanes * 2, kernel_size=3, stride=2,
padding=1, output_padding=1),
nn.BatchNorm2d(inplanes * 2, affine=True),
nn.ReLU(True)]
```
С указанными обозначениями генератор с 9 резнет-блоками выглядит так:
`c7s1-32,d64,d128,R128,R128,R128,R128,R128,R128,R128,R128,R128,u64,u32,c7s1-3`
Мы делаем изначальную свертку с 32 фильтрами, потом два раза уменьшаем изображение, попутно увеличивая количество фильтров, затем идут 9 резнет-блоков, потом два раза увеличиваем изображение, уменьшая кол-во фильтров, и финальной сверткой создаем 3-канальный выход нашей нейросети.
Для дискриминатора будем ипользовать обозначение `Ck` — свертка 4х4 с последующими батч-норм и LeakyReLU с параметром 0.2. Архитектура дискриминатора следующая:
`C64-C128-C256-C512`
При этом для первого слоя `C64` мы не делаем BatchNorm.
А в конце еще добавляем один нейрон с сигмоидной функцией активации, который говорит, фейк ему пришел или нет.
#### Еще пару слов про дискриминатор
Такой дискриминатор является так называемой fully-convolutional сетью — в нем нет полносвязных слоев, только свертки. Такие сети могут принимать на вход изображения любого размера, а количество слоев регулирует receptive field сети. Впервые такая архитектура была представлена в статье [Fully Convolutional Networks for Semantic Segmentation](https://arxiv.org/abs/1411.4038).
В нашем случае генератор мапит входное изображение не на один скаляр, как обычно, а на 512 выходных картинок (уменьшенного размера), по которым уже делается вывод "real or fake". Это можно интерпретировать как взвешенное голосование по 512 патчам входного изображения. Размер патча (рецептивного поля) можно прикинуть пробросив обратно ко входу все активации. Но хорошие люди [сделали утилиту](https://github.com/rbgirshick/rcnn/blob/master/utils/receptive_field_sizes.m), которая посчитает все за нас. Такие сети еще называют PatchGAN.
В нашем случае 3-слойный PatchGAN при входном изображении 256х256 имеет рецептивное поле 70х70, и это эквивалентно тому, как если бы мы вырезали несколько случайных патчей 70х70 из входа и по ним судили, реальная картинка пришла или сгенерированная. Контролируя глубину сети, мы можем контролировать размер патчей. Например, 1-слойный PatchGAN имеет рецептивное поле 16х16, и в таком случае мы смотрим на низкоуровневые фичи. 5-слойный PatchGAN будет уже смотреть почти на всю картинку целиком. [Вот здесь](https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix/issues/39#issuecomment-305575964) Phillip Isola мне доходчиво объяснил всю эту магию. Почитайте, вам тоже должно стать понятней. Главное: полностью сверточные сети работают лучше обычных, и ими надо пользоваться.
### Особенности обучения Cycle-GAN
#### Данные
Для начала мы попробовали решить задачу превращения лиц мужщин в женщин и наоборот. Благо, датасеты для этого есть. Например, [CelebA](http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html), содержащий 200 тысяч фотографий лиц знаменитостей с бинарными метками Пол, Очки, Борода и пр.
Собственно, разбив этот датасет по нужному признаку мы получаем порядка 90к картинок мужщин и 110к — женщин. Это наши DomainX и DomainY.
Средний размер лиц на этих фото однако не очень большой (около 150х150), и вместо ресайза всех картинок к 256х256 мы привели их к 128х128. Также, для сохранения соотношения сторон, картинки не растягивались, а вписывались в черный квадрат 128х128. Типичный вход генераторов мог выглядеть так:
#### Perceptual Loss
Интуиция и опыт подсказали нам считать identity loss не в пространстве пикселей, а в пространстве фич предобученной VGG-16 сети. Именно этот трюк был впервые представлен в статье [Perceptual Losses for Real-Time Style Transfer and Super-Resolution](https://arxiv.org/abs/1603.08155) и широко используется в задачах Style Transfer. Логика здесь простая: если мы хотим делать генераторы инвариантыми к стилю изображений из целевого домена, то зачем считать ошибку на пикселях, если есть фичи, содержащие информацию о стиле. К какому эффекту это привело, вы узнаете чуть позже.
#### Процедура обучения
В целом модель получилась довольно громоздкой, учатся сразу 4 сети. Изображения по ним надо несколько раз прогнать туда-сюда, чтобы посчитать все лоссы, а потом и обратно распространить все градиенты. Одна эпоха обучения на CelebA (200к картинок 128х128) на GForce 1080 занимает порядка 5 часов. Так что особо не поэкспериментируешь. Скажу лишь, что наша конфигурация отличалась от авторской только заменой Identity Loss на Perceptual. PatchGAN'ы с большим или меньшим количеством слоев не зашли, оставили 3-слойный. Оптимизатор для всех сетей — Adam с параметрами `betas=(0.5, 0.999)`. Learning rate по умолчанию `0.0002` и уменьшался каждую эпоху. BatchSize был равне 1, и во всех сетках BatchNorm был заменен (авторами) на InstanceNorm. Интересный момент — на вход дискриминатору подавался не последний выход генератора, а случайная картинка из буфера в 50 изображений. Таким образом, дискриминатору мог прийти образ, сгенерированный прошлой версией генератора. Этот трюк и многие другие, которые использовали авторы, перечислены в заметке Сумита Чинталы (автора PyTorch) [How to Train a GAN? Tips and tricks to make GANs work](https://github.com/soumith/ganhacks). Рекомендую распечатать этот список и повесить возле рабочего места. У нас не дошли руки перепробовать все, что там есть, например LeakyReLU и альтернативные методы апсемплинга для генератора. Но повозились с дискриминатором и расписанием обучения пары генератор/дискриминатор. Это действительно добавляет стабильности.
### Эксперименты
Сейчас пойдет больше картинок, вы наверное уже заждались.
Вообще обучение генеративных сетей несоклько отличается от других задач глубокого обучения. Здесь часто вы не увидите привычной вам картины идущего вниз лосса и растущей метрики качества. Оценить насколько хороша ваша модель можно только смотря на выходы генераторов. Типичная картина, которую мы наблюдали выглядела примерно так:
Генераторы постепенно расходятся, остальные лоссы чуть-чуть уменьшились, но тем не менее, сеть выдает приличные картинки и явно чему-то научилась. Кстати, для визуализации хода обучения модели мы использовали [visdom](https://github.com/facebookresearch/visdom), довольно простой в настройке и удобный инструмент от Facebook Research. Каждые несколько итераций мы смотрели на следующие 8 картинок:
* real\_A — вход из домена А
* fake\_B — real\_A, преобразованная генератором A->B
* rec\_A — реконструированная картинка, fake\_B, преобразованный генератором B->A
* idty\_B — real\_A, преобразованный генератором B->A
* и 4 аналогичных изображения в обратную сторорну
В-среднем, хорошие результаты можно увидель уже после 5ой эпохи обучения. Смотрите, ошибка генераторов никак не уменьшается, но это не помешало сети превратить человека, похожего на Хинтона, в женщину. Ничего святого!
Иногда дела могут идти совсем плохо.
В таком случае можно нажимать Ctrl+C и звонить журналистам, рассказывать, как вы остановили искусственный интеллект.
В целом, несмотря на некоторые артефакты и низкое разрешение, Cycle-GAN на ура справился с задачей.
Смотрите сами:
Мужчины <-> Женщины
Белые <-> Азиаты
Белые <-> Черные
Вы заметили интересный эффект, который дают identity mapping и perceptual loss? Посмотрите на idty\_A и idty\_B. Женщина становится более женственной (больше макияжа, гладкая светлая кожа), мужщине добавляется растительность на лице, белые становятся еще белее, а черные, соттветственно — чернее. Генераторы выучивают средний стиль для всего домена, благодаря perceptual loss. Здесь прямо напрашивается создание приложения для "бьютификации" ваших фоточек. Shut up and give me your money!
Вот вам Лео:
И еще несколько знаменитостей:
Лично меня этот мужик-Джоли испугал.
А теперь, внимание, очень сложный кейс.
Увеличение разрешения
---------------------
CycleGAN хорошо справился с поставленной задачей. Но получающиеся изображения имеют маленький размер и некие артефакты. Задача увеличения разрешения называется Image Superresolution. И эту задачу уже научились решать с помощью нейронных сетей. Хочу отметить две state-of-the-art модели: SR-ResNet и EDSR.
### SRResNet
В статье [Photo-Realistic Single Image Super-Resolution Using a Generative Adversarial Network](https://arxiv.org/abs/1609.04802) авторы предлагают архитектуру генеративной сети для задачи super-resolution (SRGAN), в основу которой положена ResNet. В дополнение к попиксельной MSE авторы добавляют Perceptual loss, используя активации предобученной VGG (видите, все так делают!) и дискриминатор, естесственно.
В генераторе используются residual блоки со свертками 3x3, 64 фильтрами, батчнормом и ParametricReLu. Для увеличения разрешения используются два SubPixel слоя.
В дискриминаторе есть 8 сверточных слоев с ядром 3х3 и увеличивающимся числом каналов с 64 до 512, активации везде — LeakyReLu, после каждого удвоения числа фич — разрешение картинки уменьшается за счет страйда в свертках. Пулинг-слоев нет, в конце — два полносвязных слоя и сигмоида для классификации. Схематично генератор и дискриминатор изображены ниже.
### EDSR
[Enhanced Deep Super-Resolution network](https://arxiv.org/abs/1707.02921) это тот же SRResNet, но с тремя модификациями:
* Нет батч-нормализации. Это позволяет сократить до 40% используемой во время обучения памяти и увеличить число фильтров и слоев
* За пределами residual блоков не используется ReLu
* все resnet-блоки умножаются на коэффициент 0.1 перед их добавлением к предыдущим активациям. Это позволяет стабилизировать обучение.
### Обучение
Для обучения SR-сети нужно иметь датасет изображений высокого разрешения. Определенные усилия и время пришлось потратить на то, чтобы спарсить с инстаграма несколько тысяч фотографий по хештегу #face. Но куда без этого, все мы знаем, что сбор и обработка данных это 80+% объема нашей работы.
Обучать SR-сети принято не на полных изображениях, а на патчах небольшого размера, вырезанных из них. Это позволяет генератору обучиться работать с мелкими деталями. А в рабочем режиме на вход сети можно подавать картинки любого размера, ведь это fully-convolutional сеть.
На практике EDSR, которая, якобы, должна работать лучше и быстрее ее предшественника SRResNet, не показала лучших результатов и обучалась гораздо медленнее.
В итоге для нашего пайплайна мы выбрали SRRestNet, обученную на патчах 64х64, в качестве Perceptual loss использовались 2 и 5 слои VGG-16, и дискриминатор мы вообще убрали. Ниже несколько примеров из обучающего множества.
А вот так эта модель работает на наших искусственных изображениях. Не идеал, но уже неплохо.
Вставка изображения в оригинал
------------------------------
Даже эту задачу можно решить нейросетями. Я нашел одну интересную работу по image blending. [GP-GAN: Towards Realistic High-Resolution Image Blending](https://arxiv.org/abs/1703.07195). Подробности рассказывать не буду, покажу лишь картинку из статьи.
Реализовать эту вещь мы не успели, отделались простым решением. Вставляем наш квадрат с трансформированным лицом обратно в оригинал, постепенно увеличивая прозрачность картинки ближе к краям. Получается примерно так:
Опять же, не идеал, но на скорую руку — ок.
Заключение
----------
Много вещей еще можно попробовать, чтобы улучшить текущий результат. У меня целый список есть, нужно только время и побольше видеокарточек.
И вообще, очень хочется собраться на каком-нибудь хакатоне и допилить получившийся прототип до нормального веб-приложения.
А дальше уже можно думать о том, чтобы попробовать перенести ГАНы на мобильные устройства. Для этого надо пробовать разные техники по ускорению и уменьшению нейросетей: факторизация, knowledge distillation, вот это вот все. И про это у нас скоро будет отдельный пост, следите за обновлениями. До новых встреч!
 | https://habr.com/ru/post/340154/ | null | ru | null |
# В апреле выйдет GNU Compiler Collection 12
Смягчение уязвимости Trojan Source, оптимизация функций приведения типов, многомерный оператор `[]`, подавление предупреждений о вендорных атрибутах — вот лишь некоторые возможности GCC 12. Подробностями делимся к старту [курса по разработке на C++](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_260422&utm_term=lead).
---
Релиз GNU GCC 12.1 (полный список изменений [здесь](https://gcc.gnu.org/gcc-12/changes.html)) состоится в апреле 2022 года. Уже сейчас GCC 12 — системный компилятор в Fedora 36, и он будет доступен в Red Hat Enterprise Linux в Red Hat Developer Toolset 7 или Red Hat GCC Toolset 8 и 9. Я расскажу только о новых фичах, влияющих на C++.
Диалект GCC 12 по умолчанию — -std=gnu++17. C++23 указывается параметром -std=c++23; флаг -std=gnu++23 включает расширения GNU. C++20 и C++23 в GCC 12 по-прежнему экспериментальные, а в апрельском GCC реализовано ещё несколько предложений из С++23.
### if consteval
В C++17 появился оператор constexpr if, условие в котором должно быть выражением-константой, (оно явно вычисляется как константа).
* Если условие истинно, ветвь else отбрасывается, то есть не генерируется во время компиляции.
* Если условие ложно, соответствующая ветвь также отбрасывается.
* Если функция объявлена как constexpr, во время компиляции она может вычисляться или не вычисляться в зависимости от контекста.
Чтобы разработчик имел представление о том, когда вычисляется функция, в стандартную библиотеку C++20 введена функция std::is\_constant\_evaluated. Она возвращает true, когда текущий контекст вычисляется во время компиляции:
```
#include
int slow (int);
constexpr int fn (int n)
{
if (std::is\_constant\_evaluated ())
return n << 1; // #1
else
return slow (n); // #2
}
constexpr int i = fn (10); // does #1
int n = 10;
int i2 = fn (n); // calls slow function #2
```
В C++20 появилось ключевое слово consteval. Функция, функция-член или конструктор с consteval — это немедленная функция (immediate function), для которой компилятор не генерирует код.
Немедленные функции вычисляются во время компиляции и должны генерировать константу, кроме случаев, когда такая функция вызывается из другой немедленной функции, а если это не так, то возникает ошибка компиляции.
Как бы то ни было, в предыдущем тесте правила языка запрещают заменить n << 1 вызовом функции consteval:
```
#include
int slow (int);
consteval int fast (int n) { return n << 1; }
constexpr int fn (int n)
{
if (std::is\_constant\_evaluated ())
return fast (n); // 'n' is not a constant expression
else
return slow (n);
}
constexpr int i = fn (10);
```
Этот недочёт [исправлен](https://wg21.link/p1938) предложением о выражении if consteval, реализованном в GCC 12. С помощью if consteval вызывать немедленные функции можно так:
```
#include
int slow (int);
consteval int fast (int n) { return n << 1; }
constexpr int fn (int n)
{
if consteval {
return fast (n); // OK
} else {
return slow (n);
}
}
constexpr int i = fn (10);
```
> if consteval допустимо в обычной функции, где нет constexpr. Кроме того, в отличие от обычного if, в if consteval фигурные скобки обязательны.
>
>
Проблема взаимодействия if constexpr и std::is\_constant\_evaluated, к счастью, обнаруживается компилятором, смотрите раздел std::is\_constant\_evaluated в предупреждениях для if.
#### auto(x)
GCC 12 [допускает](https://wg21.link/p0849) ключевое слово auto в приведении типов функционального стиля: auto [приводится](https://en.cppreference.com/w/cpp/language/value_category) к prvalue.
```
struct A {};
void f(A&); // #1
void f(A&&); // #2
A& g();
void
h()
{
f(g()); // calls #1
f(auto(g())); // calls #2 with a temporary object
}
```
> Обратите внимание: допустимы auto(x) и auto{x}, но не decltype(auto)(x).
>
>
#### Нелитеральные переменные в функциях constexpr
Когда функции constexpr не вычисляются как константы, GCC 12 [допускает](https://wg21.link/p2242) нелитеральные переменные, переходы goto и метки в них, что полезно для кода, подобного следующему (взят из предложения):
```
#include
template constexpr bool f() {
if (std::is\_constant\_evaluated()) {
return true;
} else {
T t; // OK when T=nonliteral in C++23
return true;
}
}
struct nonliteral { nonliteral(); };
static\_assert(f());
```
Такой код не компилируется в C++20, но компилируется в C++23, потому что ветвь else не вычисляется. Также только в C++23 компилируется следующий пример:
```
constexpr int
foo (int i)
{
if (i == 0)
return 42;
static int a;
thread_local int t;
goto label;
label:
return 0;
}
```
#### Многомерный оператор []
В C++ функция-член `operator[]` используется для доступа к элементам массива и элементам типов, подобных массивам, таким как std::array, std::span, std::vector и std::string. GCC 12 [поддерживает](https://wg21.link/p2128) многомерный оператор индекса. Выражения с запятыми в `[]` [устарели](https://wg21.link/p1161) в C++20, а в C++23 значение запятой в `[]` изменилось.
В C++20 оператор `[]` принимал только один элемент, поэтому доступ к элементам многомерных массивов получали через операторы вызова функций: arr(x, y, z), и похожих обходных путей, не лишённых недостатков. Поэтому C++23 позволяет оператору `[]` принимать ноль или более аргументов, а значит, при компиляции с флагом -std=c++23 будет работать этот пример:
```
template
struct W {
constexpr auto operator[](T&&...);
};
W<> w1;
W w2;
W w3;
```
Понятнее будет этот код с крайне наивной реализацией:
```
struct S {
int a[64];
constexpr S () : a {} {};
constexpr S (int x, int y, int z) : a {x, y, z} {};
constexpr int &operator[] () { return a[0]; }
constexpr int &operator[] (int x) { return a[x]; }
constexpr int &operator[] (int x, long y) { return a[x + y * 8]; }
};
void g ()
{
S s;
s[] = 42;
s[5] = 36;
s[3, 4] = 72;
}
```
В качестве расширения GNU, если GCC не находит перегрузку оператора `[]`, то ведёт себя как раньше, но выдаёт предупреждение:
```
void f(int a[], int b, int c)
{
a[b,c]; // deprecated in C++20, invalid but accepted with a warning in C++23
a[(b,c)]; // OK in both C++20 and C++23
}
```
Учтите, что `operator[]` не поддерживает аргументы по умолчанию, но представляется, что их [разрешат](https://wg21.link/cwg2507) позже. Если и когда это случится, будет работать код ниже:
```
struct X {
int a[64];
constexpr int& operator[](int i = 1) { return a[i]; }
};
```
#### elifdef и elifndef
В C и C++ директивы #ifdef и #ifndef — это синтаксический сахар для #ifdefined(...) и #if !defined(...). Удивительно, но у других вариантов этих директив таких сокращений нет. Чтобы исправить это, разработчики C и C++ приняли предложения [N2645](http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2645.pdf) и [P2334R1](https://wg21.link/p2334). В GCC 12 реализованы оба предложения, поэтому следующий пример компилируется:
```
#ifdef __STDC__
/* ... */
#elifndef __cplusplus
#warning "not ISO C"
#else
/* ... */
#endif
```
> Для компиляции этого примера в C++20 и более ранних версиях нужно включить расширения GNU. Другими словами, флаг -std=c++20 приводит к ошибке компиляции, а с флагами -std=gnu++20 и -Wpedantic — к предупреждению типа pedantic, то есть о несоответствии стандарту ISO.
>
>
#### Псевдонимы в операторе инициализации
GCC 12 [разрешает](https://wg21.link/p2360r0) объявлять псевдонимы в операторе инициализации, используемом внутри if, for и switch:
```
for (using T = int; T e : v)
{
// use e
}
```
### Исправления и внутренние улучшения
Изменения в этом разделе согласуют GCC с нововведениями стандарта и разрешают ранее некорректное поведение.
#### Изменения поиска зависимого оператора
До GCC 12 компилятор выполнял неквалифицированный поиск зависимого операторного выражения во время определения шаблона, а не во время инстанцирования. Поведение GCC 12 соответствует существующему поведению зависимых выражений вызова:
```
#include
namespace N {
struct A { };
}
void operator+(N::A, double) {
std::cout << "#1 ";
}
template
void f(T t) {
operator+(t, 0);
t + 0;
}
// Since it's not visible from the template definition, this later-declared
// operator overload should not be considered when instantiating f(N::A),
// for either the call or operator expression.
void operator+(N::A, int) {
std::cout << "#2 ";
}
int main() {
N::A a;
f(a);
std::cout << std::endl;
}
```
В GCC 11 и старых компиляторах программа выведет #1 #2, но в GCC 12 — #1 #1: ранее в перегрузку разрешалось только выражение вызова #1, а в GCC 12 в перегрузку разрешается и операторное выражение.
#### Спецификатор auto для указателей и ссылок на массивы
GCC 12 поддерживает предложение из [отчёта](https://wg21.link/cwg2397) о дефектах DR2397: спецификатор auto для указателей и ссылок на массивы, и теперь тип элемента массива может быть типом со спецификатором auto, то есть код ниже работает:
```
int a[3];
auto (*p)[3] = &a
auto (&r)[3] = a;
```
Но массив неявно преобразуется в указатель, поскольку вывод типа auto здесь выполняется с точки зрения вывода аргумента шаблона функции, поэтому не работает ни один из фрагментов ниже:
```
auto (&&r)[2] = { 1, 2 };
auto arr[2] = { 1, 2 };
int arr[5];
auto x[5] = arr;
```
Хотя когда-нибудь он может заработать.
#### Свёртывание тривиальных функций
std::move или std::forward — это приведения типов, реализованные как вызовы функций, то есть компилятор генерирует отладочную информацию, сохраняемую даже после встроенного вызова, хотя отлаживать такой код не нужно.
GCC 12 преобразует вызовы некоторых тривиальных встроенных функций, например std::move, std::forward, std::addressof и std::as\_const) в простые приведения типов. Это часть общей процедуры свёртывания выражений при оптимизации компилятором.
Так количество отладочной информации GCC может сократиться на 10%, также сокращаются используемая память и время компиляции. Оптимизация включается флагом -ffold-simple-inlines.
#### Ограничения в излишне свободной спецификации enum direct-list-initialization
GCC 12 учитывает [отчёт](https://wg21.link/cwg2374) о дефекте, предложение в котором запрещает, например, прямую инициализацию перечисления с ограниченной областью действия из другого перечисления этого же типа:
```
enum class Orange;
enum class Apple;
Orange o;
Apple a{o}; // error with GCC 12
```
#### Нетиповые аргументы шаблона в частичных специализациях
Ранее использование некоторых параметров шаблона как его аргументов запрещалось. Этот запрет сняли в ответ на [отчёт](http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1315) о дефекте. Следующее вероятное применение параметра шаблона как его аргумента скомпилируется:
```
template struct A {};
template struct A {}; // OK with GCC 12
```
#### Подстановки в параметры функции в лексическом порядке
Вывод аргументов шаблона C++ несколько изменился, когда в [отчёте](http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1227) указали, что подстановка выполняется, слева направо, то есть в лексическом порядке, из-за чего может возникнуть нежелательный эффект:
```
template
struct A { using type = typename T::type; };
template void g(T, typename A::type);
template long g(...);
long y = g(0, 0); // OK in GCC 12, error in GCC 11
template void h(typename A::type, T);
template long h(...);
long z = h(0, 0); // error in GCC 12, OK in GCC 11
```
GCC 12 подставляет аргументы слева направо, проверяя ошибку типа до подстановки оставшихся аргументов. Таким образом, для g(0, 0) компилятор пытается подставить void в g(T, typename A::type) и видит, что первая замена приводит к недопустимому для параметра типу void.
Эта замена — SFINAE («неудачная подстановка — не ошибка»), поэтому вместо первой перегрузки, которая отбрасывается, выбирается g(...). Но для h(0, 0) компилятор в typename A::type сначала подставляет void. И это серьёзная ошибка, ведь создание экземпляра A не является непосредственным контекстом.
GCC 11 и более ранние версии выполняли эту замену справа налево, приводя к обратному: g(0, 0) вызывало ошибку компиляции, тогда как h(0, 0) компилировалось.
#### Более строгая проверка атрибутов в объявлениях friend
Объявление friend с любым атрибутом должно быть определением, но до версии 12 GCC не проверял это соответствие. Кроме того, атрибут C++11 не может находиться в середине decl-specifier-seq:
```
template
struct S {
[[deprecated]] friend T; // warning: attribute ignored
[[deprecated]] friend void f(); // warning: attribute ignored
friend [[deprecated]] int f2(); // error
};
S s;
```
#### Дедуктивные руководства (deduction guides) теперь могут объявляться в области видимости класса
Из-за бага в версиях GCC до 11 включительно дедуктивные руководства нельзя было объявить на уровне класса. Ошибка [исправлена](https://gcc.gnu.org/PR79501) в GCC 12, следующий код компилируется:
```
struct X {
template struct A {};
A() -> A;
};
```
GCC 12 также поддерживает руководства по дедукциям без шаблонов на уровне класса.
#### Cравнение нулевых указателей теперь отклоняется
Сравнение типа больше-меньше между константами нулевого указателя и указателями имеют неправильный формат, что диагностируется в GCC 12:
```
decltype(nullptr) foo ();
auto cmp = foo () > 0; // error: ordered comparison of pointer with integer zero
```
Общий статус устранения дефектов указан на странице [C++ Defect Report Support in GCC](https://gcc.gnu.org/projects/cxx-dr-status.html).
### Новые и доработанные предупреждения
В GCC 12 доработали множество предупреждений:
#### -Wuninitialized
Теперь -Wuninitialized предупреждает об использовании неинициализированных переменных в списках инициализаторов элементов, а значит, оптимизирующий компилятор может обнаруживать такие ошибки:
```
struct A {
int a;
int b;
A() : b(1), a(b) { }
};
```
Здесь поле b используется неинициализированным: порядок инициализаторов элементов в списке инициализаторов не важен, но важен порядок объявлений в определении класса. Для предупреждения, когда порядок инициализаторов элементов не соответствует порядку объявления, можно использовать -Wreorder.
-Wuninitialized не предупреждает о более сложных инициализаторах и об использовании адреса объекта:
```
struct B {
int &r
int *p;
int a;
B() : r(a), p(&a), a(1) { } // no warning
};
```
Кстати, запрос на усиление этого предупреждения поступил около 17 лет назад. Видимо, иногда что-то требует времени.
#### -Wbidi-chars
-Wbidi-chars должно смягчить [CVE-2021-42574](https://nvd.nist.gov/vuln/detail/CVE-2021-42574), известную как [Trojan Source](https://trojansource.codes/). Оно предупреждает о двунаправленных управляющих символах UTF-8, которые могут изменить направление письма слева направо на справа налево и наоборот.
Некоторые комбинации управляющих символов могут запутать программиста: код, который кажется закомментированным, на самом деле компилируется, или наоборот. Чтобы узнать больше, смотрите статью Дэвида Малкольма [Prevent Trojan Source attacks with GCC 12](https://developers.redhat.com/articles/2022/01/12/prevent-trojan-source-attacks-gcc-12) на Red Hat Developer.
#### -Warray-compare
Новая опция -Warray-compare предупреждает об устаревшем в C++20 способе сравнения массивов:
```
int arr1[5];
int arr2[5];
bool same = arr1 == arr2; // warning: comparison between two arrays
```
#### -Wattributes
Опции -Wno-attributes=ns::attr и -Wno-attributes=ns:: подавляют предупреждения о неизвестных атрибутах области действия в C++11 и C2X. Также для этого можно использовать #pragma GCC Diagnostic ignored\_attributes "ns::attr".
Новое поведение обнаружит опечатки и устранит нежелательные предупреждения о вендорных атрибутах:
```
[[deprecate]] void g(); // warning: should be deprecated
[[company::attr]] void f(); // no warning
```
При компиляции с флагом -Wno-attributes=company:: предупреждение вызовет только первое объявление.
#### Новые параметры предупреждений о несоответствии версий языка
По умолчанию в GCC 12 включены эти параметры предупреждений:
* -Wc++11-extensions
* -Wc++14-extensions
* -Wc++17-extensions
* -Wc++20-extensions
* -Wc++23-extensions
Эти параметры управляют существующими предупреждениями pedantic о появлении новых конструкций C++ в коде по старому стандарту. Например, новым параметром -Wno-c++11-extensions можно подавлять предупреждения об использовании вариативных шаблонов в коде C++98.
#### std::is\_constant\_evaluated в предупреждениях для if
Условие в if constexpr явно вычисляются как константа, а значит, if constexpr (std::is\_constant\_evaluated()) — всегда true. Предупреждение появилось в GCC 10, GCC 12 распространил его на сомнительные случаи:
```
#include
int
foo ()
{
if (std::is\_constant\_evaluated ()) // warning: always evaluates to false in a non-constexpr function
return 1;
return 0;
}
consteval int
baz ()
{
if (std::is\_constant\_evaluated ()) // warning: always evaluates to true in a consteval function
return 1;
return 0;
}
```
#### -Wmissing-requires
Опция -Wmissing-requires предупреждает о пропущенных requires:
```
template concept Foo = \_\_is\_same(T, int);
template
concept Sequence = requires (Seq s) {
/\* requires \*/ Foo;
};
```
Разработчик, видимо, хотел вызвать концепт Foo (вложенное requires), перед которым должно стоять ключевое слово requires. В этом тесте Foo — это идентификатор-концепт, который делает Sequence истинным, если выражение Foo валидное. Выражение Foo справедливо для всех Seq.
#### -Waddress
-Waddress теперь предупреждает, например, о сравнении адреса нестатической функции-члена с nullptr:
```
struct S {
void f();
};
int g()
{
if (&S::f == nullptr) // warning: the address &S::f will never be NULL
return -1;
return 0;
}
```
### Благодарности
Как и всегда, я хотел бы поблагодарить своих коллег из Red Hat, которые сделали компилятор GNU C++ намного лучше, особенно Джейсона Меррилла, Якуба Елинека, Патрика Палку и Джонатана Уэйкли.
### Заключение
В GCC 13 мы планируем доработать оставшиеся особенности C++23, см. в таблицу [C++23 Language Features](https://gcc.gnu.org/projects/cxx-status.html#cxx23) на странице [C++ Standards Support in GCС](https://gcc.gnu.org/projects/cxx-status.html). [Отправляйте](https://gcc.gnu.org/bugs/) отчёты об ошибках и не стесняйтесь помогать делать GCC ещё лучше.
А мы поможем прокачать ваши навыки или с самого начала освоить профессию, востребованную в любое время:
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_260422&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_260422&utm_term=conc)
Выбрать другую [востребованную профессию](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_260422&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_260422&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_260422&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_260422&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_260422&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_260422&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_260422&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_260422&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_260422&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_260422&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_260422&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_260422&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_260422&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_260422&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_260422&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_260422&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_260422&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_260422&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_260422&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_260422&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_260422&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_260422&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_260422&utm_term=cat) | https://habr.com/ru/post/662932/ | null | ru | null |
# Заканчивается поддержка Python 3.6
Приблизительно через 3 недели истекает срок поддержки Python 3.6. Больше никаких исправлений багов и безопасности. При этом [сегодня](https://pypistats.org/packages/__all__) 15% пакетов, загруженных с PyPI, предназначены для Python 3.6. Подробности под катом.
---
Обновление может повлечь за собой и некоторые другие изменения, поэтому рассмотрим некоторые связанные с этим вопросы, в частности сосредоточившись на дистрибутивах Linux с долгосрочной поддержкой (LTS — Long-Time Support). Я буду во всем полагаться на очень полезный сайт [endoflife.date](https://endoflife.date/).
Что это значит?
---------------
Python 3.6 выпущен в декабре 2016 года, 5 лет назад. Из [PEP 494](https://www.python.org/dev/peps/pep-0494/#lifespan) следует, что:
* первые два года выпуски исправлений ошибок и исправлений безопасности выходили каждые 3 месяца;
* после этого релизы происходили по мере необходимости;
* релизы прекратятся через 5 лет после выхода 3.6.
Декабрь 2021 года — последний месяц, когда будет выпущен Python 3.6. Начиная с января 2022 года, если есть критическая ошибка безопасности, она не будет исправлена командой разработчиков Python.
«Но я на Linux, обновляться не нужно»
-------------------------------------
Некоторые дистрибутивы Linux гарантируют долгосрочную поддержку в течение известного периода, включая исправление ошибок безопасности. Если вы используете один из этих дистрибутивов, и он содержит Python 3.6, вы можете рассчитывать на то, что дистрибутив предоставит исправления безопасности, даже если команда разработчиков Python этого не сделает. Теоретически вам пока не нужно обновлять систему. Но на практике есть подводные камни.
Старые версии дистрибутива со временем перестанут поддерживаться:
* Ubuntu 18.04 прекращает обновления безопасности в апреле 2023-го.
* RHEL 7 прекращает обновления безопасности в июне 2024 года.
Хотя вы будете получать обновления безопасности, вы не обязательно получите другие исправления ошибок. И Ubuntu 18.04, и RHEL 7 сейчас ограничиваются обновлениями безопасности.
Ваши зависимости перестанут получать обновления. Сторонние библиотеки и фреймворки Python начнут отказываться от поддержки Python 3.6. А это значит, что если в этих библиотеках есть критическая ошибка, то исправление может быть недоступно в Python 3.6, а ваш дистрибутив Linux очень не любит делать бэкпорты для всех существующих библиотек Python.
Это происходит в мире Java, где обновление до версии log4j с исправлением критической ошибку безопасности требует достаточно новой версии Java. Если вы не обновились, у вас проблемы.
«Но я на Ubuntu 20.04/RHEL 8, у меня много времени»
---------------------------------------------------
Если вы работаете на новом дистрибутиве Linux с LTS, то у вас есть ещё столько лет исправлений безопасности и багов в Python 3.6. Но по-прежнему существуют две проблемы:
* сокращение поддержки: команды дистрибутивов Linux ограничены во времени, а также имеют не столь богатый опыт по сравнению с командой разработчиков Python. Я уверен, что критические исправления будут внесены, но случайные раздражители останутся;
* сторонние зависимости перестанут получать обновления. LTS Linux здесь не поможет, за исключением случаев, когда вы работаете только с зависимостями из дистрибутива.
Дело в том, что и Ubuntu 20.04, и RHEL 8 сейчас поставляют Python 3.9. Вы можете обновить систему, не меняя дистрибутив Linux или способ установки Python. Просто выполните `apt-get install python3.9` или `dnf install python 3.9`. Есть пакет Python 3.8, он может быть полезен как промежуточный.
Обновления
----------
В краткосрочной перспективе ваша задача — как можно скорее перейти на поддерживаемые версии ваших зависимостей.
В целом выпуски Python 3 обратно совместимы. Поэтому теоретически вы можете просто перейти на версию 3.7, исправить все ошибки, затем перейти на версию 3.8, и так до Python 3.9 или, [после января 2022](https://pythonspeed.com/articles/switch-python-3.10/), Python 3.10.
Проблема заключается в том, что библиотеки, от которых вы будете зависеть, перестанут поддерживать старые версии Python. Посмотрим на Django, вот [таблица](https://docs.djangoproject.com/en/4.0/faq/install/#what-python-version-can-i-use-with-django) поддержки версийи [endoflife.date/django](https://endoflife.date/django):
* Django 2.2 (LTS) будет получать исправления безопасности до апреля 2022 года и поддерживает Python 3.5–3.9.
* Django 3.2 (LTS) имеет исправления безопасности до апреля 2024 года и поддерживает Python 3.6–3.10.
* Последний релиз — Django 4.0, он поддерживает Python 3.8–3.10.
Если вы используете Django 2.2, у вас есть 3 месяца, чтобы перейти на Django 3.2. А если вы всё ещё на Python 3.5, то у вас ещё больше проблем: Django 3.2 его не поддерживает. Если вы работаете на Django 3.x, просто убедитесь, что вы на Django 3.2 и всё в порядке.
Апгрейд: долгосрочно
--------------------
В конце концов Python 3.9 перестанет получать обновления. Django 3.2 перестанет получать обновления. Ubuntu 20.04 и RHEL 8 также перестанут получать обновления.
Если вы откладываете обновление до последней минуты, то оно станет мучительным, потому что вам придётся вносить большое количество серьёзных изменений сразу. И если вы в декабре 2021 года всё ещё на Python 3.6, то это признак организационной проблемы. Следующим шагом должно стать создание процесса, который будет [обновлять](https://pythonspeed.com/articles/when-update-dependencies/) ваши зависимости регулярно.
Научиться плотно работать с Python вы сможете на наших курсах:
* [Профессия Fullstack-разработчик на Python (15 месяцев)](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_141221&utm_term=conc)
* [Профессия Data Scientist (24 месяца)](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_141221&utm_term=conc)
[Узнайте подробности](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_141221&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_141221&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_141221&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_141221&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_141221&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_141221&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_141221&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_141221&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_141221&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_141221&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_141221&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_141221&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_141221&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_141221&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_141221&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_141221&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_141221&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_141221&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_141221&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_141221&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_141221&utm_term=cat)
**А также:**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_141221&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_141221&utm_term=conc) | https://habr.com/ru/post/595477/ | null | ru | null |
# Мобильная Установка Доказательства Актуальности Контроля Измерений. Часть 1. «Хороший человек идет на войну»
Итак, надоело! Даже, не так, ДОСТАЛО! А точнее, за.... Впрочем, не буду прибегать к ненормативной лексике. Квартира, купленная 2.5 года назад - это не квартира, а какое-то вечное испытание. Да такое, что Форт Баярд отдыхает. Кроме того, в конце игры Баярда можно нехило поднять золотишка, а чем тут все закончится - я еще не знаю. Недостаточная (ниже норм, утвержденных Правительством РФ, а эти нормы, скажем так, разрабатывались моржами) температура воздуха в помещении, отсутствие горячей воды по утрам, а ежедневное принятие душа превращается в соревнование "кто быстрей", ибо вода неожиданно может стать кипятком. Или, наоборот, льдом. Бездействие управляющей компании, сбор инициативной группы, объявления по подъездам, коллективная жалоба... это и многие другие веселые подробности останутся за рамками повествования.
Итак, если какой-то параметр, будь то температура или давление, не устраивает, то этот параметр надо для начала измерить. Желательно, в автоматическом режиме, непрерывно и с сохранением всех значений. И тут на помощь приходят средства промышленной автоматизации - датчик давления, датчик температуры, и программируемый логический контроллер с модулем аналоговых входов и поддержкой протокола HART. Почему именно они? Во-первых, я АСУшник, а не электронщик. Во-вторых, я исполняю обязанности руководителя технической группы Управления "Цифровое производство" уральского филиала компании ООО "Сименс". А, стало быть, все эти игрушки у меня есть. Этого оказалось вполне достаточно, чтобы продумать, собрать на коленке и запрограммировать систему, которой я дал замысловатое название Мобильная Установка Доказательства Актуальности Контроля Измерений (весь смысл замысловатости заключается в получившейся аббревиатуре... настолько я огорчен сложившейся ситуацией).
В качестве датчика, измеряющего давление, выступает Siemens Sitrans P DS3 с диапазоном измерения от 0 до 16 бар, выходом 4..20 мА и, что немаловажно, поддержкой цифрового протокола HART. HART означает Highway Addressable Remote Transducer. По сути, это цифровой протокол обмена данными между системой управления и датчиком. Обмен данными двухсторонний. Для кодирования нулей и единичек цифрового обмена используется частотная модуляция, которая накладывается прямо поверх аналогового сигнала 4..20 мА. Поддержка HART сильно играет мне на руку, поскольку позволяет избежать дополнительного аналого-цифрового преобразования на стороне ПЛК и, скажем откровенно, "забить" на "землю" (боюсь, что после этих слов мне коллеги руки не подадут). На фотографии этот красавец уже подключен к домашнему водопроводу.
Датчик температуры - тоже Siemens, тоже с HART'ом. Вторичка - Sitrans TH300, первичка - обычный Pt100 в толстой гильзе. Именно из-за гильзы он не подошел для замеров температуры воздуха - просто огромная инерция измерений.
В качестве CPU применяется S7-1510 (он же ET200SP CPU), заказной номер 6ES7 510-1DJ01-0AB0, версия прошивки 2.8. К CPU справа подключен четырехканальный модуль аналоговых входов с поддержкой HART, заказной номер 6ES7 134-6TD00-0CA1. Блок питания слева от контроллера, весьма большой и очень избыточный по мощности в моем случае.
Для визуализации измеряемых параметров и, что немаловажно, для их архивации взял базовую операторскую панель второго поколения, KTP400 Basic, 6AV2 123-2DB03-0AX0, прошивка обновлена до 16.0. Причина для такого выбора простая - мобильных панелей у меня под рукой нет, а "немобильные", стандартные версии предназначены для врезки в дверь шкафа управления, но никак не для того, чтобы держать их в руках. Маленькую четырехдюймовую панель на весу удержать можно без проблем, а вот семидюймовую Comfort или Unified одной рукой не удержишь. Разбивать подотчетное оборудование и попадать на 1200 евро её листовой стоимости не хочется никак, поэтому лучше маленькую и легкую, чем большую, тяжелую, но функциональную.
Для обвязки применяется обычный провод сечением 0.5 мм2 и НШВИ 0.5х8. Техническая эстетика не соблюдается никак. Корпуса нет. Заземляющих проводников нет. Все обвязано, абы как. Прикладное ПО далеко не универсально, уставок от оператора нет, даже константы не применяются, все тупо в лоб. В общем, это ни в коем случае не готовое решение, которое можно сертифицировать и вносить в реестр СИ. Я напишу про это тут один раз, дабы избежать войн в комментариях, да, со всеми этими замечаниями я согласен.
Датчики подключаем к каналам 0 и 1 аналогового модуля в соответствии с документацией.
У нас используется вариант (1) - двухпроводное подключение датчика. Под "двухпроводностью" подразумевается, что к датчику в общем случае идет всего два провода, "+" и "-" непосредственно от аналогового модуля. Отдельного питания на датчик не требуется, он запитывается от модуля AI. Электроника модуля получает энергию по внутренней шине контроллера, а "силовая" часть подается на отдельные клеммы. В итоге, первый датчик (датчик давления) садим на контакты №9 и 13 (нулевой канал), датчик температуры - №№10 и 14 (первый канал).
Для программирования и конфигурирования этой системы применяем среду разработки TIA Portal V16 (+update 3), в составе Step 7 Professional (контроллер) и WinCC Basic (операторская панель). После создания проекта в первую очередь создаем и конфигурируем ПЛК.
Включаем System and Clock Memory, пригодится.
Задаем IP адрес CPU - 192.168.43.205. Конфигурируем аналоговый модуль. Второй и третий каналы отключаем, на нулевом и первом включаем HART и активируем всю диагностику (диагностика совсем необязательна в моем простом случае).
Обзор настройки каналов модуляНастройка нулевого (и первого тоже) каналаПоскольку в данном случае задействовано всего 2 канала, а от функционала HART требуется всего лишь передача значения измеряемой величины, то можно поступить просто и забирать первичную переменную HART обоих датчиков через пространство ввода/вывода аналогового модуля. Тем самым избавляемся от необходимости осуществлять системный вызов в программе PLC.
Из этой таблицы видно, что нам надо забрать две переменные с адресов ID8 и ID13. Первичные переменные HART будут поступать нам, как готовые вещественные величины. Пропишем эти адреса в Tag Table. Так же я еще прописал все четыре аналоговых канала модуля, но в программе они никак не используются... просто привычка объявлять переменные по каналам, которые есть в проекте.
Посмотрим, что я начудил в программе контроллера. Вообще, в ПЛК можно обойтись без какой-либо программы вообще. Информация с датчиков и так автоматически поступает в переменные с именами CH0\_*HART (давление) и CH1*\_HART (температура). Однако, установка изначально разрабатывалась, как универсальная - она замеряет и Т воздуха, и Т воды, и давление воды, да еще и в нескольких местах (воздух в разных комнатах, например). Если обойтись одним трендом, то можно уже через день запутаться, что, где и когда измерял. Поэтому программа контроллеру тут носит больше "организационный" характер.
Все необходимые переменные сведены в один блок данных.
Вся программа написана в "главном" огранизационном блоке. Расписывать ее нет необходимости, можно ознакомиться с комментариями в коде.
```
"Data".CurrentPress := "Ch0_HART" / 10.0; //давление перевести из бар в МПа
"Data".CurrentTemp := "Ch1_HART"; //текущая температура
IF "Data".MeasP THEN //если включен (с панели) замер давления
//допускается всего 4 места измерения давления - в ванной (ХВС, ГВС) и на кухне
IF "Data".WaterSelector <= 0 OR "Data".WaterSelector > 4 THEN
"Data".WaterSelector := 1;
END_IF;
//создать для панели сообщение "идет замер давления в/на <место замера и выбранная труба">
CASE "Data".WaterSelector OF
1: //ХВС в ванной
"Data".WaterMessage := W#2#0000000000000001;
2: //ГВС в ванной
"Data".WaterMessage := W#2#0000000000000010;
3: //ХВС на кузне
"Data".WaterMessage := W#2#0000000000000100;
4: //ГВС на кухне
"Data".WaterMessage := W#2#0000000000001000;
END_CASE;
//тнекщее давление в МПа скопировать в отдельную переменную для тренда
"Data".CurrentPress_M := "Data".CurrentPress;
//если замер только что включили, сбросить минимальное и максимальное зафиксированное значение
IF (NOT "Data".MeasP_prv) THEN
"Data".MinPress_M := "Data".CurrentPress_M;
"Data".MaxPress_M := "Data".CurrentPress_M;
END_IF;
//зафиксировать при необходимости минимальное значение
IF "Data".CurrentPress_M < "Data".MinPress_M THEN
"Data".MinPress_M := "Data".CurrentPress_M;
END_IF;
//зафиксировать максимальное значение давления во время этого замера
IF "Data".CurrentPress_M > "Data".MaxPress_M THEN
"Data".MaxPress_M := "Data".CurrentPress_M;
END_IF;
//выставить аварийные и предупредительные сообщения
"Data".P003Alarm_M := "Data".CurrentPress_M < 0.03;
"Data".P01Alarm_M := "Data".CurrentPress_M < 0.1;
"Data".P02Alarm_M := "Data".CurrentPress_M < 0.2;
ELSE //если замер давления не ведется
"Data".CurrentPress_M := 0.0; //обнулить переменную для тренад давления
"Data".WaterMessage := W#2#0000000000000000; //сбросить "место проведения давления"
"Data".P003Alarm_M := FALSE; //сбросить флаги алармов и сообщений
"Data".P01Alarm_M := FALSE;;
"Data".P02Alarm_M := FALSE;;
END_IF;
IF "Data".MeasTair THEN //аналогично для температуры воздуха
IF "Data".PlaceSelector <= 0 OR "Data".PlaceSelector > 7 THEN
"Data".PlaceSelector := 7;
END_IF;
CASE "Data".PlaceSelector OF
1: //спальня
"Data".PlaceMessage := W#2#0000000000000001;
2: //детская
"Data".PlaceMessage := W#2#0000000000000010;
3: //зал
"Data".PlaceMessage := W#2#0000000000000100;
4: //кухня
"Data".PlaceMessage := W#2#0000000000001000;
5: //ванная
"Data".PlaceMessage := W#2#0000000000010000;
6: //туалет
"Data".PlaceMessage := W#2#0000000000100000;
7: //прочее
"Data".PlaceMessage := W#2#0000000001000000;
END_CASE;
"Data".CurrentTemp_Mair := "Data".CurrentTemp;
IF (NOT "Data".MeasTair_prv) THEN
"Data".MinTemp_Mair := "Data".CurrentTemp_Mair;
"Data".MaxTemp_Mair := "Data".CurrentTemp_Mair;
"Data".MeasTwater := false;
END_IF;
IF "Data".CurrentTemp_Mair < "Data".MinTemp_Mair THEN
"Data".MinTemp_Mair := "Data".CurrentTemp_Mair;
END_IF;
IF "Data".CurrentTemp_Mair > "Data".MaxTemp_Mair THEN
"Data".MaxTemp_Mair := "Data".CurrentTemp_Mair;
END_IF;
"Data".T18Alarm_M := "Data".CurrentTemp < 18;
"Data".T20Alarm_M := "Data".CurrentTemp < 20;
"Data".T22Alarm_M := "Data".CurrentTemp < 22;
ELSE
"Data".CurrentTemp_Mair := 0.0;
"Data".PlaceMessage := W#2#0000000000000000;
"Data".T18Alarm_M := FALSE;
"Data".T20Alarm_M := FALSE;
"Data".T22Alarm_M := FALSE;
END_IF;
//аналогично для температуры воды
IF "Data".MeasTwater THEN
"Data".CurrentTemp_Mwater := "Data".CurrentTemp;
IF (NOT "Data".MeasTwater_prv) THEN
"Data".MinTemp_Mwater := "Data".CurrentTemp_Mwater;
"Data".MaxTemp_Mwater := "Data".CurrentTemp_Mwater;
"Data".MeasTair := false;
END_IF;
IF "Data".CurrentTemp_Mwater < "Data".MinTemp_Mwater THEN
"Data".MinTemp_Mwater := "Data".CurrentTemp_Mwater;
END_IF;
IF "Data".CurrentTemp_Mwater > "Data".MaxTemp_Mwater THEN
"Data".MaxTemp_Mwater := "Data".CurrentTemp_Mwater;
END_IF;
"Data".T40Alarm_M := "Data".CurrentTemp < 40;
"Data".T55Alarm_M := "Data".CurrentTemp < 55;
"Data".T57Alarm_M := "Data".CurrentTemp < 57;
"Data".T60Alarm_M := "Data".CurrentTemp < 60;
ELSE
"Data".CurrentTemp_Mwater := 0.0;
"Data".T40Alarm_M := FALSE;
"Data".T55Alarm_M := FALSE;
"Data".T57Alarm_M := FALSE;
"Data".T60Alarm_M := FALSE;
END_IF;
//при первом запуске контроллера сбросить зафисированные мин и макс "общих" (не замерных) величин
"tonFirstScan".TOF(IN:=NOT "FirstScan",
PT:=T#1s);
IF "tonFirstScan".Q THEN
IF "Data".CurrentPress < "Data".MinPress THEN
"Data".MinPress := "Data".CurrentPress;
END_IF;
IF "Data".CurrentPress > "Data".MaxPress THEN
"Data".MaxPress := "Data".CurrentPress;
END_IF;
IF "Data".CurrentTemp < "Data".MinTemp THEN
"Data".MinTemp := "Data".CurrentTemp;
END_IF;
IF "Data".CurrentTemp > "Data".MaxTemp THEN
"Data".MaxTemp := "Data".CurrentTemp;
END_IF;
END_IF;
//сбросить мин и макс по запросу с панели
IF "Data".ResetPressStat THEN
"Data".MinPress := "Data".CurrentPress;
"Data".MaxPress := "Data".CurrentPress;
"Data".ResetPressStat := FALSE;
END_IF;
IF "Data".ResetTempStat THEN
"Data".MinTemp := "Data".CurrentTemp;
"Data".MaxTemp := "Data".CurrentTemp;
"Data".ResetTempStat := FALSE;
END_IF;
//выставить обобщенный флаг "идет замер"
"Data".Meas := "Data".MeasP OR "Data".MeasTair OR "Data".MeasTwater;
//для определения фронтов
"Data".MeasP_prv := "Data".MeasP;
"Data".MeasTair_prv := "Data".MeasTair;
"Data".MeasTwater_prv := "Data".MeasTwater;
//сообщения для панели оператора
"Data".Alarms.%X0 := "Data".MeasP;
"Data".Alarms.%X1 := "Data".MeasTair;
"Data".Alarms.%X2 := "Data".MeasTwater;
"Data".Alarms.%X3 := "Data".T18Alarm_M;
"Data".Alarms.%X4 := "Data".T20Alarm_M;
"Data".Alarms.%X5 := "Data".T40Alarm_M;
"Data".Alarms.%X6 := "Data".P003Alarm_M;
"Data".Alarms.%X7 := "Data".P01Alarm_M;
"Data".Alarms.%X8 := "Data".P02Alarm_M;
"Data".Alarms.%X9 := "Data".T22Alarm_M;
"Data".Alarms.%X10 := "Data".T55Alarm_M;
"Data".Alarms.%X11 := "Data".T57Alarm_M;
"Data".Alarms.%X12 := "Data".T60Alarm_M;
```
Перейдем к конфигурирования прикладного программного обеспечения операторской панели. Добавим ее в общий проект и зададим ip адрес.
Добавим некоторые настройки рантайма - выбор бита для списков и цвет алармов в зависимости от их класса.
Создадим соединение с контроллером и вытащим необходимые тэги (все это делается автоматически при вытаскивании тэга с ПЛК на любой экран панели). Выставим минимально возможное время опроса переменных в 100 мс.
Все тэги берем с блока данных 1 ПЛКДля тэгов Data\_*Alarms, DataWaterMessage и Data*\_PlaceMessage создадим сообщения.
Создадим Alarm Log для сообщений панели на максимальное количество записей, 500000. Весь лог будет храниться в текстовом виде на USB-флэшке, подключенной к панельке. Журнал циклический, по достижению предельного количества записей, старые будут затираться.
В настройках классов сообщений укажем, алармы каких классов будут сохраняться на фдэшке
Аналогично создадим хранилище для исторических трендов, которое будет так же храниться на флэшке в виде текстового файла. "Трендировать" будем три переменных - значение давление, температуры воздуха и температуры воды во время измерения (не на постоянной основе). Запись значений будет производиться только при изменении переменной, а не на постоянной основе. В противном случае журнал начнет весьма быстро перезатираться.
Создадим стартовый экран. Тут отображается мгновенное значение давления и температуры с датчиком, зафиксированные "экстремальные" значения, кнопки их сброса, информация о проводящемся замере и кнопка останова замеров.
Кнопкой F1 листаем экраны замеров. Остановися только на экране давления, два других аналогичны. На этом экране отображается текущее мгновенное значение давления при идущем замере, эксремумы давления, выбор места проведения измерения и график с историческими данными. Кнопкой F3 начинаем замер давления, кнопкой F4 останавливаем,
На любом экране кнопкой F2 открывается журнал событий.
Дополнительно для собственного удобство я сделал копию этой панели и изменил ее тип на PC Station с одиночной SCADA-системой WinCC RT Advanced. На 4дюймовом экране очень неудобно смотреть графики.
Зато, на 24 дюймах смотреть удобно
Установка находится в работе с 21 декабря. За это время мне стало изместно время пикового вечернего разбора воды, это в районе 22 часов местного времени. Ситуация удручающая, давление падает ниже установленных норм (0.03МПа) и падает влоть до нуля. Да и в целом давление не постоянное, оно может за секунду упасть с трех килограммов до одного, а потом за 5 секунд подняться до 2.5 килограмм.
В настоящий момент система полностью локальна. Все данные сохраняются в панельке, на фэшке переносятся на ПК и изучаются на нем.
Следующим шагом будет установка к линейку ПЛК WiFi модуля, настройка WiFi-моста и создание полноценного операторского интерфейса на базе WinCC OA под управлением Linux Debian (Buster). | https://habr.com/ru/post/535202/ | null | ru | null |
# Размещение кучи FreeRTOS в разделе CCMRAM для STM32
При разработке одного девайса на базе STM32F407 столкнулся с проблемой нехватки оперативной памяти. Назначение самого девайса не принципиально, но важно, что изначальный код писался для десктопной системы и его нужно было просто портировать на микроконтроллер под управлением FreeRTOS. А так как исходный код был написан на С++ и вопрос об экономии ОЗУ даже не стоял, то и вылезла соответствующая проблема.
Заниматься оптимизацией кода, одновременно добавляя себе проблем с поиском новых ошибок, очень не хотелось. Поэтому своевременно вспомнилось, что данная версия микроконтроллера имеет на борту дополнительный сегмент ОЗУ размером 64К (CCM SRAM), который сейчас никак не был задействован. Эврика — вот оно, решение!
Но к сожалению, все оказалось не так просто.
### Результаты поиска готового решения
В официальной документации на [CCMRAM](https://www.st.com/resource/en/application_note/dm00083249-use-stm32f3-stm32g4-ccm-sram-with-iar-ewarm-keil-mdk-arm-and-gnu-based-toolchains-stmicroelectronics.pdf) приводятся примеры для размещения в ней исполняемого кода, стека или отдельных переменных.
Поиск по форумам выдал несколько ссылок на разные способы использования CCMRAM, но к сожалению, все они являлись разными вариациями тех способов, которые были описаны в официальной документации. И все они требовали перелопачивать исходный код для добавления атрибутов при объявлении каждой функции или переменной.
Для GCC, в моем случае, примерно вот так:
```
__attribute__((section(".ccmram")));
```
В добавок, некоторые переменные имеют значение по умолчанию, что требует модифицировать загрузчик таким образом, что бы при старте прошивки такие переменные копировались в отдельную область для инициализированных или [обнуленных переменных](https://habr.com/ru/post/578036/).
Ну и финальной сложностью были ограничения самой CCMRAM. Она висит на отдельной шине к которой у DMA нет доступа, а прямой доступ к памяти планировалось использовать очень активно.
Другими словами, решая одну проблему, можно было нечаянно добавить ворох других, и зарыться в отладку для поиска привнесенных багов.
### К счастью, удалось найти простое решение со стороны FreeRTOS.
Размер кучи был меньше размера сегмента CCM RAM и решение напрашивалось само-собой — переместить кучу в данный раздел.
И это удалось сделать минимальными правками кода.
1. В ld файле (в моем случае STM32F407VGTX\_FLASH.ld) добавляется новая секция:
```
.ccmram :
{
. = ALIGN(8);
. = . + _Min_Heap_Size;
. = ALIGN(8);
} >CCMRAM
```
2. В секции « .\_user\_heap\_stack » комментируется или удаляется строка
```
/* . = . + _Min_Heap_Size; */
```
Строки с *\_Min\_Heap\_Size* требуются для выдачи предупреждений линковщиком в случае недостатка размера ОЗУ.
3. В теле программы добавляется единственная переменная
```
uint8_t ucHeap[ configTOTAL_HEAP_SIZE ] __attribute__((section(".ccmram"))) = {0};
```
4. А при сборке проекта добавляется препроцессорное определение
```
configAPPLICATION_ALLOCATED_HEAP=1
```
В результате — куча FreeRTOS в CCM SRAM с минимальным количеством правок в исходном коде! | https://habr.com/ru/post/546670/ | null | ru | null |
# Проверяем исходный код FlashDevelop с помощью PVS-Studio
Для проверки качества диагностик нашего статического анализатора и его рекламы мы регулярно анализируем проекты с открытым исходным кодом. Разработчики проекта FlashDevelop сами попросили нас проверить их продукт, что мы с радостью и сделали.
Введение
--------
[FlashDevelop](http://www.flashdevelop.org/) — популярная среда разработки Flash-приложений, поддерживающая Action Script версии 2 и 3, Haxe, JavaScript, HTML, PHP, C#, и обладающая функционалом, присущим современным редакторам кода, например, автодополнение кода, встроенная поддержка svn, git, mercurial, шаблоны, сторонние плагины, темы подсветки синтаксиса и многое другое. Примечательно, что FlashDevelop использовали Fireaxis Games при разработке [XCOM: Enemy Unknown](https://xcom.com/ru/xcom-enemy-unknown).
Результаты проверки
-------------------
Учитывая то, что FlashDevelop — продукт с открытым исходным кодом, и написан на языке C#, мы захотели проверить его нашим анализатором. Для анализа был использован статический анализатор PVS-Studio v6.05. Поскольку разбирать все найденные проблемные места в рамках этой статьи не представляется возможным, рассмотрим наиболее интересные сообщения анализатора.
### Неиспользуемые возвращаемые значения методов
Как известно, строки в C# — иммутабельные объекты, и методы, отвечающие за изменение строки, на самом деле возвращают новый объект типа String, сохраняя изначальную строку неизменной. Однако, как показывает практика, разработчики забывают про эту особенность. Например, анализатор обнаружил следующие ошибки:
[V3010](http://www.viva64.com/ru/d/0406/) The return value of function 'Insert' is required to be utilized. ASPrettyPrinter.cs 1263
```
public void emit(IToken tok)
{
....
lineData.Insert(0, mSourceData.Substring(prevLineEnd,
((CommonToken)t).StartIndex - prevLineEnd));
....
}
```
[V3010](http://www.viva64.com/ru/d/0406/) The return value of function 'Insert' is required to be utilized. MXMLPrettyPrinter.cs 383
```
private void prettyPrint(....)
{
....
while (aToken.Line == currentLine)
{
lineData.Insert(0, aToken.Text);
....
}
....
}
```
Вероятно, разработчик имел в виду такую конструкцию:
```
lineData = lineData.Insert(....);
```
Другой пример срабатывания диагностики V3010:
[V3010](http://www.viva64.com/ru/d/0406/) The return value of function 'NextDouble' is required to be utilized. ASFileParser.cs 196
```
private static string getRandomStringRepl()
{
random.NextDouble();
return "StringRepl" + random.Next(0xFFFFFFF);
}
```
Этот код не содержит ошибки с точки зрения фунционала, тем не менее, вызов *random.NextDouble()* не несет никакой смысловой нагрузки и может быть удален.
### Проверка на null после приведения типов
Стандартной практикой после операции приведения типа является проверка полученного значения на null на случай, если исходный тип не может быть приведен к желаемому. При выполнении такой рутинной операции разработчик может быть невнимательным и проверить не ту переменную. Наш анализатор не устаёт и внимательно следит за такими вещами:
[V3019](http://www.viva64.com/ru/d/0388/) Possibly an incorrect variable is compared to null after type conversion using 'as' keyword. Check variables 'item', 'val'. WizardHelper.cs 67
```
public static void SetControlValue(....)
{
....
string val = item as string;
if (item == null) continue;
....
}
```
Очевидно, что в этом примере на null следует проверять переменную *val*, а не *item*, и код должен выглядеть следующим образом:
```
string val = item as string;
if (val == null) continue;
```
### Дублирование тел методов
Когда в коде встречаются методы с одинаковыми телами, это всегда вызывает подозрения. В лучшем случае, такой код требует рефакторинга, а в худшем — механический копипаст искажает логику работы программы. Чтобы не быть голословным, рассмотрим следующие примеры.
[V3013](http://www.viva64.com/ru/d/0389/) It is odd that the body of 'SuspendMdiClientLayout' function is fully equivalent to the body of 'PerformMdiClientLayout' function (377, line 389). DockPanel.MdiClientController.cs 377
```
private void SuspendMdiClientLayout()
{
if (GetMdiClientController().MdiClient != null)
GetMdiClientController().MdiClient.PerformLayout(); //<=
}
private void PerformMdiClientLayout()
{
if (GetMdiClientController().MdiClient != null)
GetMdiClientController().MdiClient.PerformLayout();
}
```
Как мы видим, тела методов *SuspendMdiClientLayout* и *PerformMdiClientLayout* абсолютно идентичны. Вероятно, это произошло из-за копирования кода. Название метода *SuspendMdiClientLayout* предполагает, что он отвечает за приостановку лэйаута, однако вместо этого выполняется перерисовка лэйаута: *MdiClient.PerformLayout()*. Я предполагаю, что корректная реализация этого метода должна быть такой:
```
private void SuspendMdiClientLayout()
{
if (GetMdiClientController().MdiClient != null)
GetMdiClientController().MdiClient.SuspendLayout(); //<=
}
```
Другой пример. В проекте реализован тип *Lexer*, предназначенный для лексического разбора чего-то. В этом типе реализовано 28 однотипных методов с сигнатурами вида *private static bool StateXX (FsmContext ctx)*, где XX находится в диапазоне от 1 до 28. Нет ничего удивительного в том, что при выполнении такого объема рутинной работы глаз разработчика может замылиться, что привело появлению в коде ошибки, на которую анализатор PVS-Studio реагирует следующим образом:
[V3013](http://www.viva64.com/ru/d/0389/) It is odd that the body of 'State11' function is fully equivalent to the body of 'State15' function (532, line 589). Lexer.cs 532
```
private static bool State11 (FsmContext ctx)
{
ctx.L.GetChar ();
switch (ctx.L.input_char) {
case 'e':
ctx.Return = true;
ctx.NextState = 1;
return true;
default:
return false;
}
}
private static bool State15 (FsmContext ctx)
{
ctx.L.GetChar ();
switch (ctx.L.input_char) {
case 'e':
ctx.Return = true;
ctx.NextState = 1;
return true;
default:
return false;
}
}
```
Тот факт, что два метода обрабатывают одну и ту же ситуацию, кажется весьма подозрительным. Неясно, как исправить эту проблему, логика работы известна только автору. Также я очень сомневаюсь, что эта проблема легко могла быть обнаружена во время проведения code review, ведь читать большое количество монотонного кода гораздо труднее, чем его писать. С другой стороны, здесь хорошо помогают статические анализаторы.
### Безусловный выход из цикла
При дальнейшем анализе был обнаружен такой интересный момент:
[V3020](http://www.viva64.com/ru/d/0410/) An unconditional 'break' within a loop. AirWizard.cs 1760
```
private void ExtensionBrowseButton_Click(....)
{
....
foreach (var existingExtension in _extensions)
{
if (existingExtension.ExtensionId
== extensionId) extension = existingExtension;
break;
}
....
}
```
Рискну предположить, что разработчик хотел пробежать по элементам коллекции *\_extensions*, найти первый объект *existingExtension* с соответствующим *extensionId* и выйти из цикла. Но из-за экономии на скобках цикл безусловно завершается после первой итерации, что существенно влияет на логику работы программы.
### Выражение всегда истинно/ложно
Другой распространенный источник ошибок — это условные выражения. Если выражение включает большое количество переменных, граничных значений, достаточно сложное ветвление, — вероятность совершения ошибки увеличивается. Рассмотрим, например, такой условный оператор:
```
private void SettingChanged(string setting)
{
if (setting == "ExcludedFileTypes"
|| setting == "ExcludedDirectories"
|| setting == "ShowProjectClasspaths"
|| setting == "ShowGlobalClasspaths"
|| setting == "GlobalClasspath")
{
Tree.RebuildTree();
}
else if (setting == "ExecutableFileTypes")
{
FileInspector.ExecutableFileTypes =
Settings.ExecutableFileTypes;
}
else if (setting == "GlobalClasspath") //<=
{
// clear compile cache for all projects
FlexCompilerShell.Cleanup();
}
}
```
Статический анализатор PVS-Studio сообщает о следующей ошибке:
[V3022](http://www.viva64.com/ru/d/0391/) Expression 'setting == «GlobalClasspath»' is always false. PluginMain.cs 1194
Действительно, условие *else if (setting == «GlobalClasspath»)* не будет выполнено никогда, потому что это же условие присутствует в самом первом *if*. А ведь от выполнения этого условия зависит выполнение какой-то логики. Чтобы упростить читабельность этого метода, я бы переписал его с использованием оператора *switch*.
Следующий пример никогда не выполнимого условия:
[V3022](http://www.viva64.com/ru/d/0391/) Expression 'high == 0xBF' is always false. JapaneseContextAnalyser.cs 293
```
protected override int GetOrder(byte[] buf, int offset,
out int charLen)
{
byte high = buf[offset];
//find out current char's byte length
if (high == 0x8E || high >= 0xA1 && high <= 0xFE)
charLen = 2;
else if (high == 0xBF)
charLen = 3;
....
}
```
Анализатор сообщает нам, что выражение *'high == 0xBF'* всегда ложно. Это действительно так, потому что значение *0xBF* попадает в диапазон *high >= 0xA1 && high <= 0xFE*, проверяемый в первом *if*.
Еще один пример сообщения от диагностики V3022:
[V3022](http://www.viva64.com/ru/d/0391/) Expression '!Outline.FlagTestDrop' is always true. DockPanel.DockDragHandler.cs 769
```
private void TestDrop()
{
Outline.FlagTestDrop = false;
....
if (!Outline.FlagTestDrop)
{
....
}
....
}
```
В этом фрагменте мы видим, что поле *Outline.FlagTestDrop*, которому присвоено значение false и которое дальше в коде не изменяется, используется в условном операторе *if*. Возможно, в этом методе не был реализован функционал, изменяющий значение этого поля, ведь для чего-то же разработчик реализовал проверку *if (!Outline.FlagTestDrop)*.
### Использование экземпляра перед тем, как он был проверен на null
В практике постоянно возникает необходимость проверить переменную на null, например, после приведения типа, выборке элемента из коллекции и т.д. В таких ситуациях мы проверяем, что полученная переменная не равна null, и только потом используем. Однако, как показывает наша практика, разработчик может начать сразу использовать полученный объект, и только потом проверить, что он не равен null. О таких ошибках сообщает диагностика V3095:
[V3095](http://www.viva64.com/ru/d/0504/) The 'node' object was used before it was verified against null. Check lines: 364, 365. ProjectContextMenu.cs 364
```
private void AddFolderItems(MergableMenu menu, string path)
{
....
DirectoryNode node = projectTree.SelectedNode
as DirectoryNode;
if (node.InsideClasspath == node)
menu.Add(RemoveSourcePath, 2, true);
else if (node != null && ....)
{
menu.Add(AddSourcePath, 2, false);
}
....
}
```
В этом примере поле *projectTree.SelectedNode* имеет тип *GenericNode*, который является базовым типом для *DirectoryNode*. Приведение объекта базового типа к производному типу может быть неуспешным, и в результате переменная node может содержать пустую ссылку. Однако, как мы видим, после операции приведения типа разработчик сразу обращается к полю *node.InsideClasspath*, и только потом проверяет переменную *node* на null. Такая реализация может привести к возникновению *NullReferenceException*.
### Перезаписывается значение переданного аргумента
Анализатор выявил такое потенциально проблемное место в коде:
[V3061](http://www.viva64.com/ru/d/0468/) Parameter 'b' is always rewritten in method body before being used. InBuffer.cs 56
```
public bool ReadByte(byte b) // check it
{
if (m_Pos >= m_Limit)
if (!ReadBlock())
return false;
b = m_Buffer[m_Pos++]; //<=
return true;
}
```
Значение переданного в этот метод аргумента *b* не используется, потом перезаписывается, и все равно далее не используется. Можно предположить, что этот метод реализован не так, как задумано (на это намекает и комментарий "*// check it* "). Возможно, сигнатура этого метода должна выглядеть следующим образом:
```
public bool ReadByte(ref byte b)
{
....
}
```
### Неверный порядок аргументов, переданных в метод
Следующее подозрительное место, найденное анализатором, не так просто заметить при проведении code review:
[V3066](http://www.viva64.com/ru/d/0459/) Possible incorrect order of arguments passed to '\_channelMixer\_OVERLAY' method: 'back' and 'fore'. BBCodeStyle.cs 302
```
private static float _channelMixer_HARDLIGHT(float back,
float fore)
{
return _channelMixer_OVERLAY(fore, back);
}
```
Метод \_channelMixer\_OVERLAY имеет такую сигнатуру:
```
static float _channelMixer_OVERLAY(float back, float fore)
```
Возможно именно так и задумано. Однако есть вероятность, что при обращении к этому методу аргументы *fore* и *back* были перепутаны местами. И анализатор помогает проверить такие места.
### Небезопасный вызов обработчика события
Диагностика [V3083](http://www.viva64.com/ru/d/0485/) предназначена для обнаружения потенциально небезопасных вызовов обработчиков событий. В анализируемом проекте эта диагностика выявила большое количество таких мест. Разберем ситуацию небезопасного вызова обработчика на конкретном примере:
[V3083](http://www.viva64.com/ru/d/0485/) Unsafe invocation of event 'OnKeyEscape', NullReferenceException is possible. Consider assigning event to a local variable before invoking it. QuickFind.cs 849
```
protected void OnPressEscapeKey()
{
if (OnKeyEscape != null) OnKeyEscape();
}
```
На первый взгляд, код кажется абсолютно корректным: если поле OnKeyEscape не равно null, вызываем это событие. Однако использовать такой подход не рекомендуется. Допустим, что у события OnKeyEscape один подписчик, и допустим, что после проверки этого поля на null этот подписчик отписался от этого события (в другом потоке, например). После того, как у события не осталось подписчиков, поле OnKeyEscape будет содержать пустую ссылку, и попытка вызвать событие приведет в возникновению NullReferenceException.
Особенно неприятно, что это крайне трудновоспроизводимая ошибка. Пользователь может пожаловаться, что нажатие ESC привело в ошибке. Однако даже нажав ESC тысячу раз, вряд ли программисту удастся понять, что не так.
Обезопасить вызов события можно, объявив дополнительную промежуточную переменную:
```
var handler = OnKeyEscape
if (handler != null) handler();
```
В C# версии 6 появился оператор проверки на null (?.), позволяющий значительно упростить код:
```
OnKeyEscape?.Invoke();
```
### Возможные опечатки
Эвристические возможности нашего анализатора позволяют обнаруживать весьма интересные подозрительные места в коде. Например:
[V3056](http://www.viva64.com/ru/d/0453/) Consider reviewing the correctness of 'a1' item's usage. LzmaEncoder.cs 225
```
public void SetPrices(....)
{
UInt32 a0 = _choice.GetPrice0();
UInt32 a1 = _choice.GetPrice1();
UInt32 b0 = a1 + _choice2.GetPrice0();
UInt32 b1 = a1 + _choice2.GetPrice1();
....
}
```
Вполне вероятно, что этот код был написан методом копипаста. И мне кажется, что для вычисления значения переменной *b0* должна использоваться переменная *a0* вместо *a1*. В любом случае, найденное подозрительное место должно послужить поводом для разработчиков внимательно посмотреть на этот код. И вообще, лучше использовать более информативные имена переменных.
### Повторное пробрасывание исключений
В коде было обнаружено несколько мест, в которых перехваченное исключение пробрасывается дальше. Реализовано это, например, следующим образом:
```
public void Copy(string fromPath, string toPath)
{
....
try
{
....
}
catch (UserCancelException uex)
{
throw uex;
}
....
}
```
Анализатор при проверке этого метода выдает сообщение:
[V3052](http://www.viva64.com/ru/d/0456/) The original exception object 'uex' was swallowed. Stack of original exception could be lost. FileActions.cs 598
Такое пробрасывание исключения приводит к тому, что оригинальный стек вызовов затирается новым, начинающимся с текущего метода. Это сильно затруднит поиск места, в котором возникло оригинальное исключение, при отладке.
Чтобы сохранить оригинальный стек вызовов при повторном генерации исключений, нужно просто использовать оператор *throw*:
```
try
{
....
}
catch (UserCancelException uex)
{
throw;
}
```
### Вероятное возникновение исключения InvalidCastException при обходе коллекции
Дальнейший анализ кода выявил потенциально небезопасное место:
[V3087](http://www.viva64.com/ru/d/0489/) Type of variable enumerated in 'foreach' is not guaranteed to be castable to the type of collection's elements. VS2005DockPaneStrip.cs 1436
```
private void WindowList_Click(object sender, EventArgs e)
{
....
List tabs = new List(Tabs);
foreach (TabVS2005 tab in tabs)
....
}
```
Коллекция *tabs* содержит элементы типа *Tab*, в то время как при итерации элементы этой коллекции приводятся к типу *TabVS2005*, который является наследником типа *Tab*. Это приведение небезопасно и может привести к возникновению исключения *System.InvalidCastException*.
Эта же диагностика обнаружила похожий небезопасный код:
```
public int DocumentsCount
{
get
{
int count = 0;
foreach (DockContent content in Documents)
count++;
return count;
}
}
```
Здесь коллекция *Documents* содержит элементы *IDockContent*, и их явное преобразование к типу *DockContent* может быть небезопасным.
### Избыточная проверка условий
Ну, и напоследок давайте рассмотрим примеры кода, не содержащего ошибок, но, тем не менее, избыточно усложненного:
[V3031](http://www.viva64.com/ru/d/0416/) An excessive check can be simplified. The '||' operator is surrounded by opposite expressions. DockContentHandler.cs 540
```
internal void SetDockState(....)
{
....
if ((Pane != oldPane) || (Pane == oldPane
&& oldDockState != oldPane.DockState))
{
RefreshDockPane(Pane);
}
....
}
```
Условия *Pane != oldPane* и *Pane == oldPane* являются взаимоисключающими, а, следовательно, это выражение можно упростить:
```
if (Pane != oldPane ||
oldDockState != oldPane.DockState)
```
Аналогично, условное выражение в другом методе:
```
void SetProject(....)
{
....
if (!internalOpening || (internalOpening
&& !PluginBase.Settings.RestoreFileSession))
{
RestoreProjectSession(project);
}
....
}
```
также может быть упрощено до:
```
if (!internalOpening || !PluginBase.Settings.RestoreFileSession)
```
Заключение
----------
Проект FlashDevelop развивается уже более 10 лет и имеет достаточно большую кодовую базу. Применение статических анализаторов кода на таких проектах приносит интересные результаты и позволяет повысить качество программного продукта. Думаю, разработчикам проекта будет интересно взглянуть на найденные ошибки. Предлагаю всем разработчикам на языках C, C++ или C# [скачать последнюю версию](http://www.viva64.com/ru/pvs-studio-download/) статического анализатора кода PVS-Studio и проверить свои проекты.
Если триальной версии будет недостаточно ([подробности](http://www.viva64.com/ru/b/0395/)), то предлагаем [связаться](http://www.viva64.com/ru/about-feedback/) с нами и получить ключ для более подробного изучения инструмента.
[](http://www.viva64.com/en/b/0412/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Pavel Kusnetsov. [Checking the Source Code of FlashDevelop with PVS-Studio](http://www.viva64.com/en/b/0412/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/305718/ | null | ru | null |
# Логические поля в базах данных, есть ли противоядие
Часто в таблицах содержится большое количество логических полей, проиндексировать все из них нет возможности, да и эффективность такой индексации низка. Тем не менее, для работы с произвольными логическими выражениями в SQL пригоден механизм многомерной индексации о чем и пойдёт речь под катом.
В SQL логические поля используются в основном в двух случаях. Во-первых, когда действительно нужен бинарный атрибут, например, ‘купля/продажа’ в таблице сделок. Такие атрибуты редко меняются со временем.
Во-вторых, для записи состояния [конечного автомата](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D0%B5%D1%87%D0%BD%D1%8B%D0%B9_%D0%B0%D0%B2%D1%82%D0%BE%D0%BC%D0%B0%D1%82), которым описывается запись. Имеется в виду, что логический объект, соответствующий записи таблицы, проходит ряд состояний, число которых и переходы между которыми определяются прикладной логикой. Простой пример — техника “soft-delete”, когда запись физически не уничтожается, а только помечается как удалённая.
Если автомат сложный, таких полей может быть изрядное количество, в одной из [наших](https://arqatech.com/ru/products/qort/) таблиц 58 (+14 устаревших) таких полей (включая наборы флагов) и это не что-то из ряда вон выходящее. Так не было задумано изначально, но по мере развития продукта и изменения внешних требований развиваются и соответствующие автоматы, приходят и уходят разработчики, меняются аналитики… в какой-то момент может оказаться безопаснее завести новый флаг, нежели разбираться во всех хитросплетениях. Тем более что накопились исторические данные и их состояния обязаны оставаться адекватными.
**оффтоп**Чем-то это похоже на эволюционный процесс, когда в геноме хранится масса информации/механизмов, которые на первый взгляд и не нужны вовсе, но избавиться от них невозможно. С другой стороны, стоит относиться с уважением к этим механизмам, ведь именно они позволили эволюционным предшественникам выжить (в том числе во время [великих вымираний](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%81%D1%81%D0%BE%D0%B2%D0%BE%D0%B5_%D0%B2%D1%8B%D0%BC%D0%B8%D1%80%D0%B0%D0%BD%D0%B8%D0%B5)) и победить в эволюционной гонке. Опять же, кто знает, куда заведет нас эволюция и что окажется полезным в дальнейшем.
Завести флаг означает не только добавить поле соответствующего типа, но и учесть его в работе автомата, какие состояния оно затрагивает, в каких переходах участвует. На практике это выглядит так:
* процесс или ряд процессов, назовём их “писателями”, создают новые записи в начальном состоянии (возможно, в одном из начальных состояний)
* ряд процессов, назовём их “читателями”, время от времени читают объекты, находящиеся в нужных им состояниях
* ряд процессов, назовём их “обработчиками”, следят за конкретными состояниями и исходя из прикладной логики меняют эти состояния. Т.е. осуществляют деятельность конечного автомата.
Для того чтобы выбрать записи, находящиеся в конкретном состоянии, редко когда достаточно фильтрации по одному из булевых полей. Обычно это целое выражение, иногда нетривиальное. Казалось бы, надо проиндексировать эти поля и SQL-процессор сам разберётся. Но не всё так просто.
Во первых, булевых полей может быть много, индексировать их все было бы слишком расточительно.
Во вторых, это может оказаться бесполезным т.к. селективность по каждому из полей будет низкой, а совместная вероятность статистикой SQL-процессора не покрывается.
Пусть, в таблице T1 есть два булевых поля: F1 & F2, а запрос
```
select F1, F2, count(1) from T1 group by F1, F2
```
выдаёт
| F1 | F2 | COUNT |
| --- | --- | --- |
| false | false | 499 |
| false | true | 1 |
| true | false | 1 |
| true | true | 499 |
Т.е. хотя, по F1 & F2 выпадение true и false равновероятно, сочетание (true,false) выпадает только один раз из тысячи. В результате, если раздельно проиндексировать F1 & F2 и принудить использовать эти индексы в запросе, SQL-процессору пришлось бы прочитать по половине обоих индексов и пересечь результаты. Возможно, дешевле прочитать всю таблицу и вычислить выражение для каждой строчки.
И даже если собирать статистику по исполненным запросам, толку от нее будет мало т.к. статистика конкретно по полям, отвечающим за состояние автомата очень сильно плавает. Ведь в любой момент может прийти “обработчик” и половину строк из состояния S1 перевести в S2.
Для работы с такими выражениями напрашивается многомерный индекс, алгоритм которого был [представлен ранее](https://habr.com/post/464057/) и неплохо себя зарекомендовал.
Но прежде требуется разобраться каким образом произвольное логическое выражение превратится в запрос(ы) к индексу.
#### Дизъюнктивная нормальная форма
Единичный запрос к многомерному индексу представляет собой многомерный прямоугольник, ограничивающий пространство запроса. Если поле участвует в запросе, для него задаётся ограничение. Если нет, прямоугольник по этой координате ограничен только разрядностью данной координаты. Логические координаты имеют разрядность 1.
Поисковый запрос в таком индексе является цепочкой из & (конъюнкцией), например, выражение: v1 & v2 & v3 & (!v4), эквивалентно v1:[1,1], v2:[1,1], v3:[1,1], v4:[0,0]. А все остальные поля имеют диапазон: [0,1].
Учитывая это, наш взор сразу обращается в сторону [ДНФ](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D0%B7%D1%8A%D1%8E%D0%BD%D0%BA%D1%82%D0%B8%D0%B2%D0%BD%D0%B0%D1%8F_%D0%BD%D0%BE%D1%80%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D1%84%D0%BE%D1%80%D0%BC%D0%B0) — одной из канонических форм логических выражений. Утверждается, что любое выражение может быть представлено к виду дизъюнкции конъюнкций литералов. Под литералом здесь понимается логическое поле или его отрицание.
Иными словами, путём нехитрых манипуляций, любое логическое выражение может быть представлено в виде дизъюнкции нескольких запросов к многомерному логическому индексу.
Есть и одно НО. Такое преобразование в некоторых случаях может привести к экспоненциальному росту размера выражения. Например, преобразование из
приводит к выражению размером в 2\*\*n термов. В таких случаях прикладному разработчику стоит задуматься о физическом смысле того, что он делает, а со стороны SQL процессора всегда можно отказаться от использования логического индекса, если число конъюнкций превышает пределы разумного.
#### Алгоритм многомерной индексации
Для многомерной индексации используются свойства самоподобной нумерующей кривой на основе гипер-кубических симплексов со стороной 2. Как [оказалось](https://habr.com/post/464057/), практическое значение имеют два варианта таких кривых — Z-кривая и кривая Гильберта.
*Фиг.1 двумерная Z-кривая, 3 и 6 итерации*
*Фиг.2 двумерная кривая Гильберта, 3 и 6 итерации*
* N-мерный симплекс со стороной 2 имеет 2\*\*n вершин и (2\*\*n-1) переходов между ними.
* Элементарная итерация симплекса превращает каждую вершину симплекса в симплекс нижнего уровня.
* Проделав нужное число итераций, можно построить гипер-кубическую решетку любого размера.
* При этом каждый узел этой решетки будет иметь свой уникальный номер — путь, проделанный по нумерующей кривой от ее начала. При этом каждый узел этой решетки имеет значение по каждой из координат. Фактически, нумерующая кривая переводит многомерную точку в одномерное значение, пригодное для индексации обычным B-деревом.
* Все узлы, находящиеся внутри симплекса любого уровня, находятся в пределах одного интервала и этот интервал не пересекается ни с одним симплексом того же уровня.
* Следовательно, любой поисковый прямоугольник (параллелепипед) может быть разбит на небольшое число гипер-кубических подзапросов, в пределах каждого из которых индекс может быть прочитан одним поиском/траверзом.
* К этому добавим магию низкоуровневой работы с B-деревом для того, чтобы не делать бесполезные запросы и … алгоритм готов.
Вот как это работает на практике:
*Фиг.3 Пример поиска в двумерном индексе (Z-кривая)*
На фиг.3 показано разбиение исходного поискового экстента на подзапросы и найденные при этом точки. Использовался двумерный индекс, построенный на случайном равномерно распределенном наборе 100 000 000 точек в экстенте [1 000 000, 1 000 000].
#### Логический многомерный индекс
Раз уж речь зашла о многомерном индексировании, самое время задуматься, а насколько многомерным он может быть? Есть ли какие-то объективные ограничения?
Конечно, ведь B-дерево имеет страничную организацию и для того, чтобы быть деревом, на странице должно гарантированно помещаться не менее двух элементов. Если принять страницу за 8К, значит на хранение одного элемента не может уходить больше 4К. В 4К без сжатия влезает около 1000 32-разрядных значений. Это довольно много, выше пределов любого разумного применения, можно сказать, что физические пределы практически не доступны.
Есть и другая сторона, каждое дополнительное измерение отнюдь не бесплатно, на него уходит дисковое пространство и замедляется работа. С точки зрения “физического смысла”, в один индекс должны попадать поля, которые меняются одновременно и поиск по ним тоже идёт совместно. Никакого смысла индексировать всё подряд нет.
С логическими полями всё по другому. Как мы видели, в одних и тех же механизмах могут быть задействованы десятки логических полей. А затраты на хранение/чтение довольно малы. Есть соблазн собрать всё без исключения логические поля в одном индексе и посмотреть что получится.
Правда, есть нюансы:
* До сих пор в индексируемом значении разряды разных координат перемешивались, в младших разрядах ключа оказывались младшие разряды координат … Поэтому порядок следования полей при индексации не имел значения.
* Теперь же на хранение значения одного логического поля тратится один разряд. Т.е. какие-то логические поля попадут в конец ключа, а какие-то в начало. А это означает, что фильтрация по части полей будет проходить очень эффективно, а по некоторым очень неэффективно. В самом деле, если мы делаем поиск по самому младшему разряду, придётся прочитать весь индекс чтобы получить ответ. Но это (скорее всего) лучше, чем прочитать всю таблицу, чтобы ответить на тот же вопрос.
* Возникает проблема выбора — все логические поля равны, но некоторые окажутся равнее прочих. Из общих соображений, необходимо смотреть на перекосы статистики, чем сильнее соотношение true/false для конкретного поля отстоит от равновесного, тем старше должен быть разряд, в котором окажется его значение.
* Исчезает разбиение по типу нумерующей кривой, если раньше приходилось выбирать между Z-кривой и кривой Гильберта, на одноразрядных данных практической разницы нет.
* NULL-ы. Если исходить из того, что NULL — это не неизвестное значение, а отсутствие какого бы то ни было значения, то такие записи не должны попадать в индекс. В одномерных индексах так и происходит. Но в нашем случае может оказаться, что часть логических полей содержит значения, а часть нет. В результате мы не можем положить это в индекс т.к. алгоритм поиска не умеет работать с троичной логикой. А следовательно, такие записи должно быть невозможно вставить в таблицу (при наличии многомерного индекса, необязательно логического, кстати)
Ожидается, что логический многомерный индекс может в некоторых случаях работать не слишком эффективно. Строго говоря, любой индекс может работать неэффективно, если слишком большое количество данных попадает в область поиска. Но для логического многомерного индекса это усугубляется описанной выше зависимостью от порядка полей, когда ради небольшого результата придётся прочитать весь индекс. Насколько это является проблемой на практике, может показать только эксперимент.
#### Численный эксперимент
Построение индекса:
* индекс будет 128-разрядным, т.е. построен по 128 логическим полям
* и будет содержать 2\*\*30 элементов
* значением элемента индекса будет число от 0 до 2\*\*30
* ключом элемента индекса будет то же число, сдвинутое на 48 разрядов влево, т.е. логические поля с 48 по 78 будут заполнены разрядами числа в том же порядке
* в результате получим 30 значимых логических полей в середине ключа, остальные разряды будут заполнены 0
* Каждое из логических полей имеет равную статистику true/false
* Все они статистически независимы
Поиск:
* Каждому эксперименту соответствует выбор нескольких подряд идущих логических полей и задание для них поисковых значений. Не потому, что алгоритм умеет искать только полосами, а из-за того, что так можно нагляднее представить результаты эксперимента, имеем всего две размерности — ширина полосы и её положение
* Всего 24 серии экспериментов. В каждой серии будем искать такие значения, где полоса логических полей соответствующей ширины N (от 1 до 24 разрядов) принимает значение true.
* В каждой серии будет подсерия экспериментов, в которой полоса логических полей выбранной ширины располагается с различными сдвигами S от начала полосы в 30 значимых логических полей. Всего (30-N) экспериментов в подсерии.
* В каждом эксперименте делается поиск всех элементов индекса, удовлетворяющих условию, т.е. поля с номерами в интервале [48 + S, 48 + S + N -1] будем искать в интервале [1,1], остальные — в интервале [0,1]
* Поиск делается с холодного старта
* Результатом является число прочитанных дисковых страниц, с учетом кэширования (кэш на 4096 страниц)
* Контроль правильности работы делается двумя путями — число найденных элементов должно быть равно 2\*\*(30-N) и в найденных значениях можно проверить соответствующие разряды
Итак,
*Фиг.4 Результаты, число прочитанных страниц в разных сериях*
По Y — отложены количества прочитанных страниц.
По X — сдвиг полос от самого младшего (48) разряда к старшему. Полосы разной ширины подписаны и отмечены разными цветами.
*Фиг.5 Те же данные что и Фиг.4, другое представление*
По X — сдвиг полосы
По Y — ширина полосы
Что следует отметить:
* хотя на картинках это прямо не видно, индекс работает правильно, это видно и по числу найденных элементов и по содержанию самих элементов
* все полосы шириной не больше 10 со сдвигом 0 требуют сплошного чтения индекса
* полосы шириной от 1 до 18 с ростом сдвига выходят на асимптоту 2\*\*(-N) от размера всего индекса, что логично
* для более широких полос асимптота — высота дерева, меньше неё чтений быть не может
* на листовой странице индекса помещается чуть больше 1000 элементов, это видно по полосе шириной 10, которая при сдвиге 0 уже не требует чтения всего индекса, некоторые страницы удаётся пропускать
* низкоуровневая фильтрация работает на удивление хорошо. Рассмотрим полосу шириной 10. Идеальный для поиска вариант — со сдвигом 20 (всего 30 значимых полей), когда в префиксе вообще нет неопределенных полей, данные можно найти единственным траверзом. В этой ситуации при поиске читается примерно 1/1000 индекса — 779 страниц.
Промежуточный случай — сдвиг 10, у нас префикс и суффикс в 10 неизвестных полей. Число страниц — 2484, всего втрое хуже, чем в идеальном случае.
И даже в худшем случае со сдвигом в 0 (префикс в 20 неизвестных полей) удаётся пропускать какие-то страницы.
В целом можно признать алгоритм многомерной индексации работоспособным даже в таком доведенном до абсурда случае. А ведь рассматривается самый неудачный с точки зрения логического индекса вариант — равновероятные состояния по всем независимым логическим полям.
#### Эксперимент на реальных данных
Таблица *Trades*, всего 278 479 918 строк, данные одного из тестовых контуров.
Результаты выполнения некоторых запросов в таблице ниже:
| N | Запрос | Число строк в результате | Прочитано страниц |
| --- | --- | --- | --- |
| 1 | IsProcessed==0 && NullStatus==0 | 6 273 | 9 |
| 2 | IsProcessed==0 && NullStatus==0 && IsCoverage==0 | 6 273 | 9 |
| 3 | IsCoverage==1 && QF\_ICEBERG==1 | 1 388 128 | 386 |
| 4 | PutStatus==1 && PayStatus == 0 | 61 788 376 | 16 486 |
| 5 | IsProcessed==1 && NullStatus==0 &&
QF\_CURR\_PFI==0 && QF\_TERMINATION==0 | 278 473 645 | 74 285 |
| 6 | IsProcessed==1 && PutStatus==0 &&
IsCoverage==1 | 1 650 240 | 447 |
| 7 | QF\_UNK3==0 && QF\_UNK4==0 | 23 392 | 19 |
На чтение/обработку одной страницы в среднем уходит 0.8 мсек.
Нет необходимости описывать смысл конкретных запросов, они здесь просто для демонстрации работоспособности. Которая, кстати, подтверждена.
Но прежде чем данная техника сможет принести практическую пользу, предстоит еще очень много сделать. Так что, продолжение следует. | https://habr.com/ru/post/483056/ | null | ru | null |
# Перенаправление данных из COM-порта в Web
Недавно на хабре была статья [«Отображаем данные из Serial в Chrome Application»](http://habrahabr.ru/company/amperka/blog/263505/) о том, как красиво представить данные, отправляемые Arduin-кой в Serial. По-моему, ребята предложили очень красивое решение, которое с одной стороны выглядит достаточно простым, а с другой позволяет получить прекрасный результат с минимумом усилий.
В комментариях к статье было высказано сожаление о том, что такое решение не заработает под Firefox-ом и высказана идея, что «можно еще написать простенький веб-сервер с выдачей html на основе этой штуки». Меня эта идея «зацепила», быстрый поиск в google готового решения не выдал, и я решил реализовать идею сам. И вот, что из этого вышло.
*Предупреждение! Предлагаемое решение ни в коем случае нельзя рассматривать как законченное. В отличие от Serial Projector от Амперки — это концепт, демонстрация возможного подхода, работающий прототип и не более того.*
Некоторое время назад я делал проект, в котором использовал встроенные в Android-смартфон акселерометры для управления сервами, подключёнными к Arduino. Тогда для этих целей я воспользовался проектами [Scripting Layer for Android (SL4A)](https://github.com/damonkohler/sl4a) и [RemoteSensors](https://github.com/Jonty/RemoteSensors). Оказывается, в стандартную библиотеку python-а входит пакет [BaseHTTPServer](https://docs.python.org/2/library/basehttpserver.html), с помощью которого поднять веб-сервис на питоне — это задача на пару строчек кода.
Под рукой не было никаких датчиков для Arduino, поэтому в качестве источника отображаемой информации я воспользовался встроенным в Arduino Uno внутренним термометром. Насколько я понимаю, он не очень точный и совсем не предназначен для измерения температуры окружающей среды, но для прототипирования вполне сойдёт.
После недолгого гугления возник вот такой скетч для ардуинки:
```
// source: https://code.google.com/p/tinkerit/wiki/SecretThermometer
long readTemp() {
long result;
// Read temperature sensor against 1.1V reference
ADMUX = _BV(REFS1) | _BV(REFS0) | _BV(MUX3);
delay(2); // Wait for Vref to settle
ADCSRA |= _BV(ADSC); // Convert
while (bit_is_set(ADCSRA,ADSC));
result = ADCL;
result |= ADCH<<8;
result = (result - 125) * 1075;
return result;
}
void setup() {
Serial.begin(115200);
}
int count = 0;
void loop() {
String s = String(count++, DEC) + ": " + String( readTemp(), DEC );
Serial.println(s)
delay(1000);
}
```
Этот скетч открывает COM-порт, настраивает его на скорость 115200 бод и затем каждую секунду пишет в него текущее значение встроенного термометра. (Не спрашивайте меня, в каких единицах выдаётся температура — для описываемой задачи это не важно). Поскольку значение меняется не очень активно, для лучшей видимости изменения данных перед температурой выводится номер строки.
Для проверки того, что веб-сервер будет отдавать наружу только целые строки, а не их части по мере чтения из COM-порта, строка
```
Serial.println(s)
```
была заменена на
```
for(int i=0; i < s.length(); i++ ){
Serial.print( s.charAt(i) );
delay( 200 );
}
Serial.println("");
```
т.е. сформированная строка выводится в последовательный порт не целиком, а посимвольно, с паузами в 200 мс.
Для начала был написан совсем простенький прототип веб-сервера (ниже он разобран по частям):
```
# -*- coding: utf-8 -*-
#-- based on: https://raw.githubusercontent.com/Jonty/RemoteSensors/master/remoteSensors.py
SERIAL_PORT_NAME = 'COM6'
SERIAL_PORT_SPEED = 115200
WEB_SERVER_PORT = 8000
import time, BaseHTTPServer, urlparse
import serial
ser = None
def main():
global ser
httpd = BaseHTTPServer.HTTPServer(("", WEB_SERVER_PORT), Handler)
#-- workaround for getting IP address at which serving
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(('google.co.uk', 80))
sData = s.getsockname()
print "Serving at '%s:%s'" % (sData[0], WEB_SERVER_PORT)
ser = serial.Serial(SERIAL_PORT_NAME, SERIAL_PORT_SPEED, timeout=0)
httpd.serve_forever()
class Handler(BaseHTTPServer.BaseHTTPRequestHandler):
# Disable logging DNS lookups
def address_string(self):
return str(self.client_address[0])
def do_GET(self):
self.send_response(200)
self.send_header("Content-type", "application/x-javascript; charset=utf-8")
self.end_headers()
try:
while True:
new_serial_line = get_full_line_from_serial()
if new_serial_line is not None:
self.wfile.write(new_serial_line)
self.wfile.write("\n")
self.wfile.flush()
except socket.error, e:
print "Client disconnected.\n"
captured = ''
def get_full_line_from_serial():
""" returns full line from serial or None
Uses global variables 'ser' and 'captured'
"""
global captured
part = ser.readline()
if part:
captured += part
parts = captured.split('\n', 1);
if len(parts) == 2:
captured = parts[1]
return parts[0]
return None
if __name__ == '__main__':
main()
```
Разберём скрипт по частям.
Поскольку это прототип, то все основные параметры работы (имя COM-порта, его скорость, а также номер TCP-порта, на котором будет работать веб-сервер) указаны прямо в исходном тексте:
```
SERIAL_PORT_NAME = 'COM6'
SERIAL_PORT_SPEED = 115200
WEB_SERVER_PORT = 8000
```
Разумеется, можно организовать чтение этих параметров из командной строки. Например, с помощью модуля argparse это делается очень быстро, просто и гибко.
В данном же случае пользователям Windows надо в диспетчере устройств узнать имя COM-порта, к которому подключена Arduin-ка. У меня это был 'COM6'. Пользователям других операционок надо использовать средства своих ОС. У меня совсем нет опыта работы с MacOS и в Linux-е я с COM-портами тоже не работал, но там, скорее всего, это будет что-нибудь типа "/dev/ttySn".
Далее идёт определение глобальной переменной, к которой будет привязан экземпляр класса Serial, отвечающего в питоне за работу с COM-портом:
```
ser = None
```
В строчке
```
httpd = BaseHTTPServer.HTTPServer(("", WEB_SERVER_PORT), Handler)
```
создаётся веб-сервер, который будет слушать запросы на заданном порту WEB\_SERVER\_PORT. А обрабатывать эти запросы будет экземпляр класса Handler, описанный ниже.
Следующие строки — это небольшой «хак», позволяющий вывести IP-адрес, на котором собственно работает запущенный веб-сервер:
```
#-- workaround for getting IP address at which serving
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(('google.co.uk', 80))
sData = s.getsockname()
print "Serving at '%s:%s'" % (sData[0], WEB_SERVER_PORT)
```
Насколько я понял, не существует иного способа узнать этот IP. А как без этого знания мы будем обращаться из браузера к нашему серверу?
Поэтому приходится открывать сокет и подключаться к сайту гугла, чтобы из атрибутов уже этого сокета извлечь информацию о собственном IP-адресе.
Чуть ниже происходит открытие COM-порта и собственно запуск веб-сервера:
```
ser = serial.Serial(SERIAL_PORT_NAME, SERIAL_PORT_SPEED, timeout=0)
httpd.serve_forever()
```
Затем следует описание класса, который отвечает за обработку полученных запущенным веб-сервером запросов:
```
class Handler(BaseHTTPServer.BaseHTTPRequestHandler):
```
Это наследник встроенного в модуль BaseHTTPServer класса, в котором достаточно переопределить только метод do\_GET
Поскольку, это ещё пока прототип, то сервер будет «рад» любому запросу — какой бы URL у него не запросили, он будет отдавать клиенту все данные читаемые из COM-порта. Поэтому в Handler.do\_GET он сразу отвечает кодом успеха и нужными заголовками:
```
self.send_response(200)
self.send_header("Content-type", "application/x-javascript; charset=utf-8")
self.end_headers()
```
после чего запускается бесконечный цикл, в котором происходит попытка чтения целой строчки из COM-порта и, если эта попытка оказалась успешной, передача её веб-клиенту:
```
while True:
new_serial_line = get_full_line_from_serial()
if new_serial_line is not None:
self.wfile.write(new_serial_line)
self.wfile.write("\n")
self.wfile.flush()
```
В проекте, который был взят за основу, этот бесконечный цикл был «завёрнут» в блок try … except, с помощью которого предполагалось аккуратно обрабатывать разрыв соединения. Возможно, в Android-е (базовый проект разрабатывался под него) это и работает нормально, но у меня под Windows XP так не вышло — при разрыве соединения возникало какое-то другое исключение, которое я так и не научился перехватывать. Но, к счастью, это не мешало веб-серверу работать нормально и принимать следующие запросы.
Функция получения целой строки из COM-порта работает по тому же принципу, что и у создателей Serial Projector:
* есть некоторый глобальный буфер, в котором хранится всё, что прочитано из COM-порта
* при каждом обращении к функции она пытается прочитать что-нибудь из COM-порта
* если ей это удаётся, то
+ она добавляет только что прочитанное к указанному глобальному буферу
+ пытается поделить глобальный буфер максимум на две части символом конца строки
+ если и это ей удаётся, то первую часть она возвращает в вызвавшую процедуру, а вторую часть использует в качестве нового значения глобального буфера
* если в COM-порту нет новых данных или не найден символ конца строки, то функция возвращает None:
```
captured = ''
def get_full_line_from_serial():
""" returns full line from serial or None
Uses global variables 'ser' and 'captured'
"""
global captured
part = ser.readline()
if part:
captured += part
parts = captured.split('\n', 1);
if len(parts) == 2:
captured = parts[1]
return parts[0]
return None
```
В результате получилось так:
Видно, что в браузере появляются строчки, читаемые из COM-порта. Я ничего не понимаю в веб-фронтенде: JavaScript, Ajax, CSS и DOM — это для меня тёмный лес. Но мне кажется, что для программистов, создающих веб-интерфейсы, этого должно быть вполне достаточно, чтобы преобразовать этот вывод в такую же красивую картинку, что выдаёт Serial Projector от Амперки. По-моему, задача сводится к тому, чтобы создать javascript-сценарий, который обращается к веб-серверу, читает из него поток и последнюю прочитанную строчку выводит в нужное место веб-страницы.
На всякий случай я решил подстраховаться и попытался сделать первое приближение своими силами. Не очень глубокий поиск в гугле подсказал, что вообще-то для таких целей, по крайней мере, раньше использовали WebSockets или Server-Sent Events. Я нашел, как мне показалось, неплохой [учебник](http://www.html5rocks.com/en/tutorials/eventsource/basics) по использованию Server-Sent Events и решил использовать эту технологию.
*Примечание! Похоже, это не самое лучшее решение, потому что эта технология не заработала ни в Internet Explorer 8, ни в браузере, встроенном в Android 2.3.5. Но она заработала хотя бы в Firefox 39.0, поэтому я не стал «копать» дальше.*
Почитав указанный учебник, а также ещё один [на русском языке](http://webonrails.ru/post/398545752424454925/), я взял за основу проект [simpl.info/eventsource](https://simpl.info/eventsource/).
С точки зрения питоновского скрипта изменения под Server-Sent Events совершенно незначительные:
* надо заменить тип отдаваемых клиенту данных:
строчку
```
self.send_header("Content-type", "application/x-javascript; charset=utf-8")
```
заменить на
```
self.send_header("Content-type", "text/event-stream")
```
* а также перед прочитанной из COM-порта строчкой вставить префикс «data: » и добавить ещё один символ перевода строки:
строки
```
self.wfile.write(new_serial_line)
self.wfile.write("\n")
```
заменить на
```
self.wfile.write('data: ' + new_serial_line)
self.wfile.write("\n\n")
```
Всё остальное могло бы, наверное, остаться без изменений, но…
Сперва я создал файл index.html вот такого содержания:
```
Заголовок
=========
var dataDiv = document.querySelector('#data');
var source = new EventSource('http://192.168.1.207:8000/')
source.onmessage = function(e) {
dataDiv.innerHTML = e.data;
};
```
Самые интересные в нём — это строка
```
```
которая формирует место для вывода очередной строчки из COM-порта, и javascript-сценарий
```
var dataDiv = document.querySelector('#data');
var source = new EventSource('http://192.168.1.207:8000/')
source.onmessage = function(e) {
dataDiv.innerHTML = e.data;
};
```
который собственно и занимается чтением потока из веб-сервера и выводом прочитанной информации в указанное место.
Я предполагал открывать этот файл в браузере, например, с диска или с какого-нибудь другого веб-сервера, но это не сработало: при открытии страницы с диска javascript-сценарий однократно обращался к запущенному питоновскому веб-серверу и тут же разрывал соединение. Я не понял, почему так происходит, и предположил, что это, возможно, какое-то проявление защиты браузера от различных атак. Наверное, ему не нравится, что сама страница открыта с одного источника, а сценарий считывает данные из другого источника.
Поэтому было принято решение поменять питоновский веб-сервер так, чтобы он отдавал и эту html-страницу. Тогда бы получилось, что и страница, и поток считываются из одного источника. Не знаю, то ли моё предположение насчёт безопасности оказалось верным, то ли ещё что, но при такой реализации всё заработало как надо.
Поменять, разумеется, надо только класс-обработчик запросов Handler:
```
class Handler(BaseHTTPServer.BaseHTTPRequestHandler):
# Disable logging DNS lookups
def address_string(self):
return str(self.client_address[0])
def do_GET(self):
if self.path == '/' or self.path == '/index.html':
self.process_index()
elif self.path == '/get_serial':
self.process_get_serial()
else:
self.process_unknown()
def process_index(self):
self.send_response(200)
self.send_header("Content-type", "text/html; charset=utf-8")
self.end_headers()
self.wfile.write(open('index.html').read())
self.wfile.write("\n\n")
self.wfile.flush()
def process_get_serial(self):
self.send_response(200)
self.send_header("Content-type", "text/event-stream")
self.end_headers()
try:
while True:
new_serial_line = get_full_line_from_serial()
if new_serial_line is not None:
self.wfile.write('data: ' + new_serial_line)
self.wfile.write("\n\n")
self.wfile.flush()
except socket.error, e:
print "Client disconnected.\n"
def process_unknown(self):
self.send_response(404)
```
В данном варианте предполагается, что веб-сервер будет отвечать только на два запроса: '/index.html' (отдавая html-код страницы) и '/get\_serial' (отдавая бесконечный поток строк, считываемых из COM-порта). На все остальные запросы он будет отвечать кодом 404.
Поскольку index.html отдаётся питоновским веб-сервером, то его можно слегка изменить, указав вместо абсолютного адреса потока строк из COM-порта относительный:
строку
```
var source = new EventSource('http://192.168.1.207:8000/')
```
заменить на
```
var source = new EventSource('/get_serial')
```
В итоге получилось вот так:
На этом я решил остановиться. Как мне кажется, оформить страницу красиво — это уже должно быть совсем просто. Но я не владею ни HTML, ни CSS, поэтому пусть это сделает кто-нибудь другой. Я видел свою задачу в том, чтобы показать, что сделать веб-сервис, отдающий данные из COM-порта, вроде бы, совсем не сложно.
Все исходники можно взять [на гитхабе](https://github.com/alguryanow/serial2web).
Ещё раз повторюсь: представленный код — это не законченное решение, которое можно «пускать в продакшен». Это только прототип, который показывает принципиальный подход к решению задачи.
Над чем тут ещё можно поработать:
* во-первых, чтение данных из COM-порта в питоновском скрипте сделано очень «топорно» — по сути дела происходит постоянный поллинг «а нет ли чего свеженького?». Такой подход, разумеется, нагружает процессор и одно ядро на моём компьютере занято на 100%.
В качестве решения можно использовать блокирующее чтение с таймаутом. Для этого достаточно при открытии COM-порта качестве таймаута указать ненулевое значение (в секундах), например:
```
ser = serial.Serial(SERIAL_PORT_NAME, SERIAL_PORT_SPEED, timeout=0.03)
```
Кроме того, в описании модуля pySerial есть три примера создания моста: «TCP/IP — serial bridge», «Single-port TCP/IP — serial bridge (RFC 2217)» и «Multi-port TCP/IP — serial bridge (RFC 2217)» — можно посмотреть, как подобные задачи решают профессионалы.
* во-вторых, данные может получать только один клиент. До тех пор, пока страница не будет закрыта на первом клиенте, нельзя подключиться к этому серверу и получать значения на втором компьютере. С одной стороны, это, наверное, правильно: COM-порт один, а потребителей несколько — кому из них отдавать прочитанную строчку? Если вы считаете, что ответом на данный вопрос должно быть «всем», то вот мои мысли по этому поводу. Как мне кажется, вопрос нельзя решить только использованием «честного» многопоточного веб-сервера (например, какого-нибудь Tornado или Flask), который может одновременно обслуживать запросы нескольких веб-клиентов. Потому что вы не можете из каждого потока открывать COM-порт и выполнять чтение из него — в этом случае данные из COM-порта будут уходить только одному потоку/процессу. Поэтому, по-моему, надо разбить серверную часть на две части:
+ zmq-сервер, который работает с COM-портом, читает из него строки и рассылает их через PUB-сокет всем заинтересованным потребителям
+ питоновский веб-сервер вместо подключения к COM-порту подключается к zmq-серверу и получает данные от него
Если вы не знакомы с библиотекой ZMQ (ZeroMQ), то вместо неё можно воспользоваться обычными TCP/IP или UDP-сокетами, но я бы настоятельно рекомендовал познакомиться с ZMQ, потому что эта библиотека очень сильно облегчает решение подобных задач. Мне кажется, что с помощью ZMQ решение уложится максимум в 20 строк. (Не могу удержаться, чтобы не написать: даже если вы не планируете решать описанную задачу, но ваша работа связана с мультипоточным/мультипроцессным программированием с обменом данными между потоками/процессами, присмотритесь к этой библиотеке — возможно, это то, о чём вы так давно мечтали)
* поток данных пока однонаправленный — из COM-порта в веб-браузер. Вы пока не можете из браузера послать данные в Arduino. Сдаётся мне, что эта задача тоже не очень сложная и она, в отличии от предыдущей, может решиться только
+ использованием многопоточного сервера
+ доработкой метода Handler.do\_GET таким образом, чтобы он воспринимал GET-запросы с параметрами и значения определённых из них отправлял в COM-порт
По-моему, при желании написать полноценный аналог встроенного в Arduino IDE монитора последовательного порта на основе веб-технологий — не так уж и сложно. Лично для себя я вижу сложность только в создании нормального фронтенда.
* через браузер пока нельзя задать имя COM-порта и параметры его работы. С одной стороны это кажется логичным: откуда пользователь на другой стороне нашей планеты может знать, к какому именно COM-порту и на какой скорости подключена ардуина? Зато это точно знает питоновский веб-сервер, запущенный на том же самом компьютере. Но если всё-таки желательно дать пользователю возможность менять имя COM-порта или параметры его работы, то опять-таки это запросто решается доработкой метода Handler.do\_GET
* для запуска сервера требуется установить python. Это вообщем-то не сложно, но, если по каким-то причинам этого делать нельзя или не хочется, то на помощь может придти pyInstaller. С его помощью питоновский скрипт можно скомпоновать в один исполнимый файл (в случае Windows — в .exe), который просто копировать на компьютер, к которому подключена ардуинка.
Возможно, лучшим решением было бы использовать в этом случае язык Go. Насколько я знаю, в нём задача создания файла для «дистрибуции» решена лучше.
В заключение: может возникнуть вопрос: «а не проще ли эту задачу решать через какое-нибудь готовое облако?». Почему бы не публиковать читаемые из COM-порта данные в облаке, а на клиентах просто обращаться к соответствующему сервису в облаке? Наверное, такое решение тоже имеет право на существование, но перед применением такого решения надо ответить на следующие вопросы:
* существуют ли готовые веб-сервисы, которые позволяют публиковать данные с нужной мне скоростью/частотой? Существуют ли среди них бесплатные или готовы ли вы платить соответствующие деньги?
* готовы ли вы к тому, что в случае падения облака или коннекта к нему, вы останетесь без данных
* не смущает ли вас то, что для того, чтобы передать данные из одной комнаты в другую, они два раза пересекут океан или полконтинента? | https://habr.com/ru/post/264663/ | null | ru | null |
# Использование сервисов и обработка их результатов в Xamarin
Продолжим обсуждать различные задачи для Xamarin с которыми приходится регулярно сталкиваться, так как статьи по данной тематике появляются не очень часто. Данная статья больше будет полезна начинающим разработчикам, но и более опытным тоже может быть интересно.
Итак, почему такая тема? Поработав на разных проектах, словил себя на мысли, что на каждом из них для вызова сервисов и обработки ошибок используются совершенно разные подходы. В этой статье я решил собрать все, с чем приходилось столкнуться, показать, какие есть варианты, и подумать, какие у каждого есть плюсы и минусы.
Рассмотрим различные подходы на простом примере, где у нас будет запрос списка стандартных моделек с бекенда, а затем преобразование их в список вью-моделек для отображения коллекции. UI часть мы здесь рассматривать не будем, ограничимся только работой сервисов и вью-модели.
Итак, наша простая модель, которую мы и будем запрашивать с бекенда:
```
public class ItemModel
{
public string Id { get; set; }
public string Title { get; set; }
public string Description { get; set; }
public string CreatedDate { get; set; }
public string ModifiedDate { get; set; }
}
```
И соответствующая ей View Model, в которой нам понадобятся всего 2 поля из модели для последующего отображения:
```
public class ItemViewModel : ViewModel
{
public ItemViewModel(ItemModel item)
{
Title = item.Title;
Description = item.Description;
}
public string Title { get; }
public string Description { get; }
}
```
Также у нас будет сервис, непосредственно при помощи которого мы будем запрашивать данные из вью-модели:
```
public interface IDataService
{
Task> LoadItemsAsync();
}
```
И RequestService, который уже и будет отправлять запросы на сервер:
```
public interface IRequestService
{
Task GetAsync(string url);
}
```
Во вью-модели основной страницы будем хранить список ItemViewModel. Заранее уточню - ObservableCollection используется из MvvmCross, так как в ней присутствует поддержка `AddRange()`, что лучше сказывается на работе UI.
```
public class MainViewModel : ViewModel
{
private readonly IDataService _dataService;
public MainViewModel(IDataService dataService)
{
_dataService = dataService;
}
public MvxObservableCollection Items { get; set; } = new();
}
```
Теперь дело осталось за малым - в MainViewModel вызвать загрузку данных. Добавим ее сразу при инициализации вью-модели.
Наверное, многим начинающим разработчикам приходит первая мысль сделать вот так:
```
public async Task Initialize()
{
var result = await _dataService.LoadItemsAsync();
var itemModels = result.ToList();
if (itemModels.Any())
{
var items = new List();
itemModels.ForEach(m => items.Add(new ItemViewModel(m)));
Items.AddRange(items);
}
}
```
Где реализация `LoadItemsAsync()` выглядит как-то так:
```
public Task> LoadItemsAsync()
{
var url = "https://customapiservice/v1/items";
return \_requestService.GetAsync>(url);
}
```
И действительно, все это дело будет работать, но только до того момента, пока мы не получим в ответе от сервера что-то из 400-х или 500-х ошибок. Как только это произойдет, мы моментально получим crash. И следующая мысль, как это дело фиксить, скорее всего будет вот такая:
```
public async Task Initialize()
{
try
{
var result = await _dataService.LoadItemsAsync();
var itemModels = result.ToList();
if (itemModels.Any())
{
var items = new List();
itemModels.ForEach(m => items.Add(new ItemViewModel(m)));
Items.AddRange(items);
}
}
catch (Exception e)
{
// Показать сообщение об ошибке загрузки пользователю
}
}
```
И в целом, такой подход уже имеет право на жизнь. Однако предлагаю сразу рассмотреть преимущества и недостатки такого способа.
Плюсы очевидны:
* легко дебажить, и сразу можно быстро отловить, что что-то пошло не так
* сразу видно, где мы обернули вызов, а где нет
Недостатки также легко сразу заметить:
* нужно постоянно оборачивать вызов сервиса в try-catch, и есть вероятность где-то забыть это сделать
* соответственно, более громоздкий код вью-модели
Но ведь можно и немного улучшить подход, дабы не писать в каждой вью-модели при каждом обращении к сервисам обертку try-catch, и делегировать это дело непосредственно сервисам. Рассмотрим подобную реализацию метода `LoadItemsAsync()`:
```
public async Task> LoadItemsAsync()
{
IEnumerable result;
try
{
var url = "https://customapiservice/v1/items";
result = await \_requestService.GetAsync>(url);
}
catch (Exception e)
{
result = new List();
}
return result;
}
```
Но тогда возникает вопрос - как нам понять, когда бекенд просто возвращает пустой список, а когда - ошибку. К сожалению, с такой реализацией во вью-модели этого узнать не выйдет. Единственный вариант - возвращать null, но тогда нам потребуется дополнительная проверка во вью модели, а это снова лишний код. Да и не факт, что сам api нам не вернет null, если данных нет.
Потому в данном случае есть свои плюсы:
* По-прежнему легко дебажить, но теперь breakpoints перемещаются непосредственно в сервис
* Нет необходимости оборачивать каждый вызов данного метода в try-catch, и код во вью-модели становится менее громоздким
Но так же присутствует немного недостатков:
* По прежнему необходимо не забывать оборачивать каждый метод сервиса в try-catch
* Иногда нет возможности на выходе точно понять, мы словили exception, либо же просто не получили результат
Потому можно попробовать еще немного улучшить данный подход. Для этого сначала создадим класс, который будет хранить результат отработки сервиса:
```
public class ServiceResult
{
public ServiceResult(TResult result)
{
IsSuccessful = true;
Result = result;
}
public ServiceResult(TError error)
{
IsSuccessful = false;
Error = error;
}
public bool IsSuccessful { get; }
public TResult Result { get; }
public TError Error { get; }
}
```
А далее немного изменим сигнатуру метода `LoadItemsAsync()`, и отрефакторим его в соответствии с новым подходом:
```
public interface IDataService
{
Task, Exception>> LoadItemsAsync();
}
```
```
public async Task, Exception>> LoadItemsAsync()
{
try
{
var url = "https://customapiservice/v1/items";
var result = await \_requestService.GetAsync>(url);
return new ServiceResult, Exception>(result);
}
catch (Exception e)
{
return new ServiceResult, Exception>(e);
}
}
```
Благодаря этому, теперь во вью-модели мы можем понять, что что-то пошло не так, при этом нам не требуется постоянно оборачивать вызов метода в try-catch:
```
public async Task Initialize()
{
var result = await _dataService.LoadItemsAsync();
if (result.IsSuccessful)
{
var itemModels = result.Result.ToList();
if (itemModels.Any())
{
var items = new List();
itemModels.ForEach(m => items.Add(new ItemViewModel(m)));
Items.AddRange(items);
}
}
else
{
// Показать сообщение об ошибке загрузки пользователю
}
}
```
В данном случае можно выделить следующие плюсы:
* Все еще легко дебажить, как и в предыдущем варианте.
* Так же нет необходимости оборачивать каждый вызов данного метода в try-catch
* Теперь во вью-модели сразу понятно, вызов был успешен, либо что-то пошло не так
Но не обошлось и без своих недостатков:
* Необходимо следить за сигнатурой метода, и не забывать, что необходимо возвращать именно ServiceResult
* Необходима проверка во вью-модели, что в какой-то степени сравнимо с оберткой в try-catch, но в данном случае эта проверка обязательна, и не получится о ней забыть
* Все так же нужно каждый метод сервиса оборачивать в try-catch
Идея для следующего подхода была позаимствована у OperationFactory из [FlexiMvvm](https://github.com/epam-cross-platform-lab/FlexiMvvm). Суть подхода заключается в том, что мы передаем в сервис в качестве параметров Func **OnSuccess** и **OnError**, которые будут вызываться в случае успешного выполнения операции, либо же в случае ошибки соответственно. Изменим наш `DataService` в соответствии с новым подходом:
```
public interface IDataService
{
Task LoadItemsAsync(
Func, Task> onSuccess = null,
Func onError = null);
}
```
```
public async Task LoadItemsAsync(
Func, Task> onSuccess = null,
Func onError = null)
{
try
{
var url = "https://customapiservice/v1/items";
var result = await \_requestService.GetAsync>(url);
onSuccess?.Invoke(result);
}
catch (Exception e)
{
onError?.Invoke(e);
}
}
```
Благодаря чему во вью-модели получаем следующую картину:
```
public async Task Initialize()
{
await _dataService.LoadItemsAsync(HandleLoadSuccess, HandleLoadError);
}
private Task HandleLoadSuccess(IEnumerable result)
{
var itemModels = result.ToList();
if (itemModels.Any())
{
var items = new List();
itemModels.ForEach(m => items.Add(new ItemViewModel(m)));
Items.AddRange(items);
}
return Task.CompletedTask;
}
private Task HandleLoadError(Exception arg)
{
// Показать сообщение об ошибке загрузки пользователю
}
```
Как можно заметить, из преимуществ - теперь все структурировано немного красивее, мы не засоряем `Initialize()`, и обрабатываем результат в зависимости от успешности, каждый в своем отдельном методе.
Итого, преимущества:
* Код во вью-модели стал еще чище и более читаемым
* По прежнему еще легко дебажить
Недостатки:
* Добавляются два обязательных параметра в каждый метод сервиса - **OnSuccess** и **OnError**, что может стать неудобным решением, особенно, если метод сервиса и так уже принимает несколько различных параметров
* Все так же нужно каждый метод сервиса оборачивать в try-catch
Потому далее рассмотрим вариант, еще более приближенный к вышеупомянутой OperationFactory. Для этого вернемся к нашему `ServiceResult` и немного прокачаем его. Назовем получившийся класс `ServiceCall`, так как по сути теперь он и будет отвечать за вызов основного метода. Хранить он в себе будет 3 различных Func. Первый - непосредственно само действие метода, второй - обработчик успешного выполнения, третий - обработчик ошибки.
При вызове `ExecuteAsync()` мы оборачиваем вызов основного метода в try-catch-finally. Далее если ловим exception - то вызываем **ErrorHandler**, но так же внутри try-catch, так как тут тоже можно словить exception. Если же все прошло успешно - вызываем **SuccessHandler**, так же обернутый в try-catch.
```
public class ServiceCall
{
private readonly Func> \_callAction;
public ServiceCall(Func> callAction)
{
\_callAction = callAction;
}
public Func SuccessHandler { get; set; }
public Func ErrorHandler { get; set; }
public async Task ExecuteAsync()
{
TResult result = default;
var isSuccess = false;
try
{
result = await \_callAction.Invoke();
isSuccess = true;
}
catch (Exception e)
{
try
{
await ErrorHandler.Invoke(e);
}
catch (Exception)
{
}
}
finally
{
if (isSuccess)
{
try
{
await SuccessHandler.Invoke(result);
}
catch (Exception)
{
}
}
}
}
}
```
Затем создадим интерфейс `ServiceCallHandler`, и его реализацию, которую и будет возвращать наш сервис в будущем. Ниже рассмотрим только асинхронную обработку, но так же можно будет добавить и вариант с синхронной обработкой.
```
public interface IServiceCallHandler
{
IServiceCallHandler OnSuccessAsync(Func handler);
IServiceCallHandler OnErrorAsync(Func handler);
Task ExecuteAsync();
}
```
```
public class ServiceCallHandler : IServiceCallHandler
{
private ServiceCall \_serviceCall;
public ServiceCallHandler(ServiceCall serviceCall)
{
\_serviceCall = serviceCall;
}
public IServiceCallHandler OnSuccessAsync(Func handler)
{
\_serviceCall.SuccessHandler = handler;
return this;
}
public IServiceCallHandler OnErrorAsync(Func handler)
{
\_serviceCall.ErrorHandler = handler;
return this;
}
public Task ExecuteAsync() => \_serviceCall.ExecuteAsync();
}
```
И изменим соответственно наш сервис
```
public interface IDataService
{
IServiceCallHandler> LoadItems();
}
```
```
public IServiceCallHandler> LoadItems()
{
var serviceCall = new ServiceCall>(LoadItemsAction);
return new ServiceCallHandler>(serviceCall);
}
private Task> LoadItemsAction()
{
var url = "https://customapiservice/v1/items";
return \_requestService.GetAsync>(url);
}
```
Тогда метод `Initialize()` в нашей вью-модели будет выглядеть следующим образом, где `HandleLoadSuccess` и `HandleLoadError` уже известные нам методы из предыдущего примера.
```
public async Task Initialize()
{
await _dataService
.LoadItems()
.OnSuccessAsync(HandleLoadSuccess)
.OnErrorAsync(HandleLoadError)
.ExecuteAsync();
}
```
Преимущества такого подхода:
* Код во вью модели, как и в предыдущем подходе, стал чище, и более читаемым. К тому же теперь удобно задавать параметры OnSuccess и OnError опционально.
* Теперь не нужно оборачивать в try-catch ни тело метода сервиса, ни вызов во вью-модели. Для этого можно воспользоваться классом ServiceCall.
Правда, как и везде, не обошлось и без недостатков:
* Становится немного сложнее дебажить
* Необходимо следить за сигнатурой метода, и не забывать, что необходимо возвращать именно IServiceCallHandler
* Необходимо помнить об обязательном вызове ExecuteAsync()
В качестве собственного мнения, скажу, что по опыту использования последний вариант оказался наиболее удобным. Даже несмотря на ряд недостатков, код становится в разы менее громоздким. Результат работы сервиса обрабатывается в отдельных методах, что делает эти методы более компактными.
Если у вас есть также интересные способы, не упомянутые в данной статье - делитесь ими в комментариях, возможно, кто-то почерпнет для себя что-то полезное. | https://habr.com/ru/post/540304/ | null | ru | null |
# Разработка игр для детей с использованием Intel Perceptual Computing. Пример «Приключений Клифорда»
Предлагаем вам сокращенный перевод статьи, освещающей разработку серии интерактивных развивающих игр для детей младшего возраста «Приключения Клифорда» от компании Scholastic Interactive. Разноплановое использование жестов и голоса в этой игре стали возможными благодаря технологии [Intel Perceptual Computing SDK 2013](https://software.intel.com/en-us/vcsource/tools/perceptual-computing-sdk) в сочетании с камерой Creative Senz3D\*. Также обсуждаются новые методы распознавания жестов и голоса с помощью перцепционных вычислений, методика решения проблем с SDK.
#### Концепция развивающей игры
В серии из четырех интерактивных эпизодов про Клифорда игроки просматривают сюжет и взаимодействуют с ним. Игра вовлекает детей в действие, предлагая различными способами «помогать» Клифорду определенными жестами и высказываниями. Благодаря интерактивной технологии Scholastic Клифорд реагирует на голос и движения детей. В ходе сюжета игры они смотрят анимированные отрывки каждого приключения и активно содействуют героям, прикасаясь к экрану или произнося ответы на вопросы. Сюжет развивается по мере взаимодействия ребенка с игрой. Каждая игра рассчитана на развитие базовых навыков грамотности и может повторяться сколько угодно раз.
Intel Perceptual Computing SDK 2013 включает в себя API, образцы кода, а также руководства по программной интерпретации жестов и речи. Разработчики могут без труда сочетать возможности SDK по распознаванию речи, жестов руки и пальцев, мимики, технологии дополненной реальности и вычитания фона, создавая ПО для различных устройств. Использование микрофона, камеры, сенсорного экрана, функций определения положения в пространстве и геолокации, широко распространенных на планшетах, ноутбуках трансформерах и компьютерах-моноблоках повышает многомерность восприятия новых приложений.
#### Разработки на основе Intel Perceptual Computing Platform
Адаптация перцепционных вычислений к анализу движений и голоса детей несет в себе ряд сложностей. Scholastic всесторонне протестировала каждый прототип, чтобы оценить дизайн игры и реальность прохождения ее уровней. Это помогло выявить потенциальные проблемы, с которыми могла столкнуться целевая аудитория, и найти для них решения.
Некоторые аспекты проведенной работы могут представить особый интерес с точки зрения перцепционных вычислений. Они приводятся ниже.
##### Калибровка распознавания голоса
Чтобы обеспечить приемлемое качество распознавания голоса, потребовалось провести ряд проверок. Голос ребенка изменяется по мере взросления, особенно в том возрасте, на который рассчитана серия «Клифорд». Поэтому необходимо было добиться такого уровня калибровки, чтобы детский голос и речевые конструкции распознавались правильно.
*Эпизод игры, требующий речевого участия игрока*
##### Распознавание и локализация жестов
В одной из игр «Приключений Клифорда» от ребенка требуется помочь собаке ловить игрушки, падающие с дерева. Для этого нужно касанием руки «схватить» корзину на экране и двигать ее в разные стороны.
Были разработаны специальные алгоритмы, распознающие жесты и сопоставляющие их с координатами касания, чтобы корзина на экране двигалась вслед за рукой ребенка. В тестировании с удовольствием принимали участие маленькие игроки. Ранее разработчики ошибочно полагали, что у ребенка жесты удержания объекта на экране не будут сильно отличаться от жестов взрослого. Но работа с детьми заставила пересмотреть дизайн игры таким образом, чтобы она воспринимала их нечеткие движения.Научить сенсоры понимать размашистые, часто ошибочные и хаотичные жесты ребенка, состоящие из множества касаний, было непросто. Требовалось много работы по определению прототипов жестов и отбору их наиболее общих конфигураций. Область регистрации касаний была расширена, чтобы даже неточный жест распознавался и вызывал нужную реакцию приложения.
К примеру, в другой мини-игре дети помогают Клифорду убрать из сада сорняки. Вместо того, чтобы заставлять игроков брать сорняк и двигать руку вверх, вытягивая его, разработчики выбрали движения захвата и раскрытия ладони, обозначающие выдергивание и выбрасывание.
Ниже приведен фрагмент кода игры, калибрующий жесты игрока в обучающем упражнении, где требуется вращать руками мячик. В эпизоде, изображенном на рисунке ниже, для более точного контроля объекта и легкости движений применили экспоненциальное сглаживание (exponential smoothing). Оно вычленяет или, по крайней мере, приблизительно вычисляет случайные движения игрока, которые программа должна игнорировать
*Вращение мяча*
```
void TutorialActivity::MoveHandHandler(Hand^hand)
{
D2D_POINT_2F normalizedTouchPos = {hand->x*GetWidth(), hand->y*GetHeight()};
//calc distance
//exponential smoothing
float new x = m_gestureBallSpin->GetPosition().x*0.9f + normalizedTouchPos.x*0.1f ;
float new y = m_gestureBallSpin->GetPosition().y*0.9f + normalizedTouchPos.y*0.1f ;
m gestureBallSpin->SetPosition(new x, new y);
float x = m_gestureBallSpin->GetPosition().x - m_EEhand->GetPosition().x;
float y = m_gestureBallSpin->GetPosition().y - m_EEhand->GetPosition().y;
if(sqrt(x*x + y*y) < 400)
{
SetTutorialState(TUTORIAL_MOVEYOURHAND_DONE);
//there it is
m_EEhand->FadeTo(0,0.5f);
if( !m_tutorialIsStopping ) {
m_moveTutorial[5]->Play([this](SoundInstance^, bool reachedEnd)
{
m gestureBallSpin->MoveTo(GetWidth()*0.5f, -GetHeight(), 0.5f);
GoToSprinkleHandState();
});
}
}
}
```
#### Решение проблем с Intel Perceptual Computing SDK
SDK от Intel дает реальный эффект погружения в игру, игроки получают немедленную реакцию программы на их действия. Это создает ощущение физического участия в происходящем. Однако разработчики столкнулись с некоторыми ограничениями в возможностях распознавания сложных движений и голосовых реакций детей.
##### Жесты
Камера, воспринимающая жесты, сфокусирована на расстоянии около 60–90 см. Поэтому мелкие движения регистрируются лучше, чем размашистые или комплексные, выходящие за пределы данного диапазона. Оптимальный набор жестов был определен методом проб и ошибок. Специалистам пришлось подумать о различных условиях окружающей среды, освещении и расстоянии до камеры.
С точки зрения SDK, API и других используемых технологий, разработать первоначальные варианты жестов несложно, потому что обучающие упражнения, образцы кода и используемые структуры имеются в SDK. После настройки среды разработки можно выполнять обучающее упражнение, например отслеживание пальцев, чтобы изучить взаимодействие сенсоров и кода в SDK.
```
#include "gesture render.h"
#include "pxcgesture.h"
class GesturePipeline: public UtilPipeline {
public:
GesturePipeline (void):UtilPipeline(),m_render(L"Gesture Viewer") {
EnableGestureO ;
}
virtual void PXCAPI OnGesture(PXCGesture::Gesture *data) {
if (data->active) m_gdata = (*data);
}
virtual void PXCAPI OnAlert(PXCGesture::Alert *data) {
switch (data->label) {
case PXCGesture::Alert::LABEL_FOV_TOP:
wprintf_s(L"******** Alert: Касание верхней границы.\n");
break;
case PXCGesture::Alert::LABEL_FOV_BOTTOM:
wprintf_s(L"******** Alert: Касание нижней границы.\n");
break;
case PXCGesture::Alert::LABEL_FOV_LEFT:
wprintf_s(L"******** Alert: Касание левой границы.\n");
break;
case PXCGesture::Alert::LABEL_FOV_RIGHT:
wprintf_s(L"******** Alert: Касание правой границы.\n");
break;
}
}
virtual bool OnNewFrame(void) {
return
m_render.RenderFrame(Querylmage(PXCImage::IMAGE TYPE DEPTH),QueryGesture() ,&m gdata);
}
protected:
GestureRender m render;
PXCGesture::Gesture m gdata;
};
```
Программисты обнаружили, что в SDK не хватает различных систем координат для жестов. Это пришлось восполнить собственными разработками.
*Визуальная схема координат жестов*
Изначально команда разработчиков использовала подход node[8].positionImage.x/y, игнорируя данные о глубине, т. к. они не требовались для интерпретации жестов. Но впоследствии был найден более оптимальный подход. Использовалось «глубинное изображение» и отыскивался ближайший пиксель, на основе чего эффективно определялся жест. Затем было добавлено экспоненциальное сглаживание.
##### Распознавание голоса
Распознавание голоса в игре сильно зависело от устройств и сюжета. На одних устройствах и в одних ситуациях оно работало хорошо, в других условиях не работало совсем.
Игра должна подсказывать детям команду, которую нужно произнести, чтобы она была записана с помощью микрофона. Функция должна работать даже на фоне посторонних звуков и музыкального сопровождения игры. Распознавание голоса может работать в режиме детектирования речи, когда программа пытается определить, что вы сказали, или в режиме словаря, когда сказанное сопоставляется с вашим словарем, который определяется в случае данной игры пользователем.
Сначала специалисты попробовали первый режим и настроили его на учет любых звуков, основываясь на том, что речь маленьких детей не всегда четко артикулируется. Но результаты оказались неудовлетворительными. Тогда было решено перейти к режиму словаря. Он хорошо работает, если слова произносятся отчетливо. Разработчики попробовали добавить в словарь варианты слов, чтобы увеличить вероятность их распознавания (например, *трактор — тлактол — тъяктол*). Однако режим словаря не дал ожидаемых результатов, потому что чем больше в словаре единиц, тем выше вероятность ошибки. Пришлось искать компромисс между величиной списка слов и потенциальной долей ошибок. В конечном варианте список допустимых слов был сведен к минимуму, чтобы оставить возможность простого взаимодействия ребенка с игрой.
#### Заключение
Стадия тестирования прошла весело. Разработчики получили ценный опыт, работая с детьми, конечными пользователями приложения. И еще приятнее было увидеть готовую игру в использовании. Один из наших старших специалистов показал ее своей трехлетней дочери, и все мы были очень рады услышать, что девочка играла в «Приключения Клифорда» с огромным интересом и азартом.
Теперь Scholastic не терпится применить свои технологии в новых проектах. Совместно с Symbio ведется работа над новой игрой на основе Intel RealSense 3D SDK, которую планируется выпустить осенью этого года.Анонсированная на выставке CES 2014 технология [Intel RealSense](http://www.intel.com/content/www/us/en/architecture-and-technology/realsense-overview.html) — это новый образ Intel Perceptual Computing, SDK с интуитивным пользовательским интерфейсом и функциями распознавания речи, жестов, движений руки и мимики в сочетании с улучшенными 3D камерами. Intel RealSense предоставляет разработчикам дополнительные возможности, такие как использование в сканировании, редактировании, 3D-печати, а также технологии дополненной реальности. Благодаря им пользователи могут манипулировать отсканированными 3D объектами с помощью новейшей технологии сенсорного управления. | https://habr.com/ru/post/237227/ | null | ru | null |
# Онлайн-чемпионат SIBUR Challenge 2021 для аналитиков данных
Привет, Хабр!
Мы с AI Community и AI Today проводим онлайн-чемпионат по анализу данных **Sibur Challenge 2021**. Участвовать могут все, кто занимается машинным обучением. Призовой фонд в 650 000 рублей между собой разделят 5 первых мест:
1 место – 250 000;
2 место – 175 000;
3 место – 100 000;
4 место – 75 000;
5 место – 50 000.
А самым активным участникам мы подарим плащи СИБУР х WOS, каски СИБУР Диджитал, плюс сертификаты на обучение, рюкзаки и худи. Под активностью, кстати, мы понимаем продуктивное общение в [Telegram-чате челленджа](https://www.t.me/siburchallenge), репосты наших анонсов, хорошие вопросы по сути задания и творческий подход к решению задачи!
**Теперь о задании**
Продукты СИБУРа покупают в 90 странах по всему миру, и у нас большая и разветвлённая сеть поставок, которая при этом состоит из широкой линейки продуктов.
У нашего «дерева продуктов» есть своя специфика – допустим, у нас есть различные марки пропиленов, и мы должны выбрать, какую из них продавать. Для каждой из них используются разные технологические операции – при производстве используются различные добавки, катализаторы и т.д.
Соответственно, нам нужно максимально заранее приобрести сырьё, чтобы успеть не только произвести, но и довезти наш продукт. До Австралии, например, он будет плыть довольно долго. Потому чем раньше мы поймём, что хотим производить – тем лучше. Для этого и нужны прогнозы.
Прогнозную модель месячного спроса нужно построить на основе исторических данных по продажам за последние 4 года по всем направлениям. Для каждой из сделок указан объем продукции, клиент, регион, группа продукта с многоуровневой детализацией, тип контракта, точная дата и другие показатели. Всего в наборе 914 групп продуктов, для каждой из которых мы хотим построить предсказание на месяц.
Для участия нужно лишь заполнить [**форму по ссылке**](http://ai-community.com/sibur-challenge-2021/?utm_source=habr&utm_medium=article&utm_campaign=challenge). А выполнить задание можно до **7 декабря, 23:59.**
На платформу Sibur Challenge нужно будет загрузить код, который генерирует предсказания. Результат каждого участника будет определяться его положением на лидерборде, а положение на лидерборде – качеством модели (для оценки качества мы используем RMSLE).
В общем, приглашаем!
**Как избежать популярных ошибок**
1. Отправляйте инференс;
2. Не забывайте паковать файлы в архивы (платформа не рассматривает `predict.py` как валидный файл);
3. Не пакуйте файлы с директорией внутри — `predict.py`, к примеру, потом не находится, и ничего не работает. То есть, файл должен лежать в корне;
4. Зависимости нужно добавлять в `requirements.txt`. Но только реально нужные :) | https://habr.com/ru/post/593027/ | null | ru | null |
# Как написать UI-автотесты, если не умеешь программировать?
Всем привет! В этой статье пойдет речь о том, как написать простые UI-тесты на языке Java. Это будет интересно тем, кто давно хотел попробовать себя в автоматизации или добавить новенького в свой текущий проект.
В этой статье не будет большой остановки на теории, а также на том, как настроить рабочую среду. Эти темы я упомяну кратко и дам ссылки, которые помогут разобраться в них самостоятельно.
Основная часть статьи будет посвящена практическому разбору теста и нюансам их написания.
Собирайте с собой друзей, хорошее настроение и поехали!
**Что такое UI-тесты? Плюсы и минусы.**
UI-тестирование – это тестирование пользовательского интерфейса программы/сайта/приложения и др.
**Звучит легко, а чем такие автотесты полезны?**
1) Такие тесты используются, чтобы автоматизировать рутинные задачи и однотипные действия, например, проверку товаров в каталогах.
2) Чтобы ускорить или упростить проверку сложных пользовательских путей. Например, в кейсе, где есть очень много тестовых данных и переходов или для прохождения которого нужна сильная концентрация.
3) Чтобы снять часть работы с сотрудников, если их мало на проекте, часть проверок можно перенести на автотесты.
**Какие инструменты нужны?**
Для написания таких тестов нужны специальные программы и инструменты. Некоторые из них требуют установки и настройки, некоторые нет. Сейчас все будет расписано по порядку.
* **DevTools** - это инструмент разработчика, он встроен практически во все современные браузеры и включается по кнопке F12. Здесь потребуется вкладка Elements (Элементы).
* **ChroPath** – это плагин для браузера, позволяющий быстро сформировать локатор для элемента страницы. Подробнее об это будет написано дальше. Скачать можно по ссылке: [ChroPath](https://chrome.google.com/webstore/detail/chropath/ljngjbnaijcbncmcnjfhigebomdlkcjo).
* **IntelliJ IDEA by JetBrains** - интегрированная среда разработки программного обеспечения. С помощью нее будут написаны тесты. Бесплатную версию этой программы можно скачать с официального сайта: [Community Edition](https://www.jetbrains.com/idea/download/%23section=windows).
* **JDK** Java Development Kit — «комплект для разработки на Java». Это, простыми словами, сам язык Java, без которого мы не сможем написать никакой код. Скачать его можно здесь: [Сайт с Amazon Corretto](https://docs.aws.amazon.com/corretto/latest/corretto-11-ug/downloads-list.html). А как установить быстро и понятно можно посмотреть здесь: [Как скачать и установить Amazon Corretto](https://www.youtube.com/watch?v=-p0NTsSHlxg). Также кроме Amazon Corretto можно установить другие JDK, вот например: Инструкция.
* **Maven** - инструмент для управления и сборки проектов на Java. Он очень облегчает работу с проектами, так что этот пункт не стоит пропускать. [Установка Maven](https://javarush.com/groups/posts/2523-chastjh-4osnovih-maven).
Создаем проект и добавляем туда нужные плюшки.
----------------------------------------------
1. Открываем IntelliJ IDEA.
2. Нажимаем File – New – Project.
3. Выбираем тип проекта Maven (на этом моменте убедитесь, что в Project SDK стоит как раз Amazon Corretto).
4. Нажимаем Next.
5. В блокe Name задаем название проекта, а в Location папку, где он будет лежать.
6. Нажимаем Finish. Проект создан.
### Настройка зависимостей
Теперь, чтобы использовать инструменты для автоматизации (Selenium, Selenide), а также пользоваться другими фреймворками и библиотеками, нужно будет импортировать зависимости. Для этого:
1. Развернуть папку с названием проекта в левом баре.
2. Открыть файл pom.xml (когда проект только-только создан файл открыт по умолчанию).
pom.xml - это XML-файл, который содержит информацию о деталях проекта, и конфигурации используемых для создания проекта на Maven.
3. Добавить в project новые зависимости из списка:
`com.codeborne
selenide
5.23.2
junit
junit
4.13.2
test`
4. Затем обязательно нужно нажать кнопку Load Maven Changes, чтобы изменения сохранились.
Другие зависимости можно найти и самостоятельно добавить в проект на сайте: [https://mvnrepository.com](https://mvnrepository.com/).
### Как работать в IntelliJ IDEA
Прежде, чем переходить к самой интересной части и начинать писать тест, я предлагаю (настоятельно ! 😊) ознакомиться с этим блоком, особенно, если вы еще не работали в IntelliJ IDEA. Иначе дальше будет сложновато сходу разобраться в интерфейсе программы.
#### Как создавать классы
1. В папке main-java создаем package и называем его POM (page object model).
2. Далее таким же образом создаем класс, только выбираем не package, а Java Class. Назовем класс MainPage.
Лучше все слова в названиях классов начинать с заглавной буквы.3. Таким же образом создаются классы, где будут лежать тесты, только из другой папки.
#### Как запускать тесты
Далее, когда вы уже напишите свои первые тесты их нужно будет запустить, чтобы получить результат. Это можно сделать двумя способами.
1. Запуск теста из интерфейса. Для этого в тестовом классе нажмите кнопку play. Тест запуститься самостоятельно.
2. Запуск теста с помощью Maven. Для этого в правом блоке меню выберите команду verify и тесты запустятся точно также.
А еще это можно сделать через командную строку прямо в программе. В нижнем меню откройте вкладку Terminal и введите команду «mvn verify».
**Как отладить тесты.**
1. Внутри теста поставьте брекпоинты (для этого нажмите на строку рядом с нужным фрагментом кода) на моменты теста, которые хотите тщательнее проверить (это может быть нажатие на кнопки, открытие разных страниц, проверки).
2. Далее нажмите кнопку Debug.
3. Управляйте шагами теста с помощью меню.
Структура проекта
-----------------
**Описание POM и методов**
Обычно проект состоит из нескольких классов package, в котором находятся классы POM (page object model) «объектная модель страницы». Эти классы содержат в себе описание элементов со страниц и методы для взаимодействия с ними.
`//ссылка на package, в котором находится класс package POM;
//взаимосвязь с нужными библиотеками и фреймворками
import com.codeborne.selenide.SelenideElement;
import org.openqa.selenium.support.FindBy;
import org.openqa.selenium.support.How;
//взаимосвязь с нужными библиотеками и фреймворками название класса
public class TestClassPage {
//описание SelenideElement (элемент со страницы)
@FindBy(how = How.XPATH (CLASS_NAME, NAME, ID и др) using = "локатор xpath или название класса (другого атрибута) элемента")
private SelenideElement elementName;
//метод для взаимодействия с вышеописанным элементом
public TestClass testMethodName() {
elementName.click();
return this;
}
}`
В классах добавляются конструкции для описания SelenideElement. Таким образом элемент описывается как переменная. Благодаря этому с ним удобнее будет взаимодействовать и поменять локатор, если понадобится.
В How прописываем атрибут элемента, в этом случает это имя класса, а в using значение класса, которые находим в elements. Атрибутом может быть Xpath, Class\_NAME, NAME и много других.
Теперь напишем метод для взаимодействия с элементом. Почему нельзя просто взять элемент и с ним делать всякие вещи в тесте? Можно, но так возможно получить различные ошибки как при написании кода, так при воспроизведении теста, так как не будет соблюдаться принцип инкапсуляции (об этом можно прочитать на досуге 😊).
Чтобы написать метод добавляем в код такую конструкцию.
`public MainPage goToTheEnterAccountButton() {
enterToAccountButton.click();
return this;
}`
Когда написали внутри метода имя переменной с кнопкой «Войти», поставьте рядом с ним точку. Вы увидите все доступные взаимодействия для этого элемента.
Так как нужно нажать на кнопку, чтобы перейти на страницу авторизации, выберем функцию click.
Метод готов, теперь его можно будет вызвать в тесте.
**Как еще можно взаимодействовать с элементом.**
Также можно обратиться к элементу на странице без описания его как отдельной переменной. Для этого можно не описывать переменную, а искать элемент с помощью локатора сразу в методе.
Подбор атрибута и локатора аналогичен тому, как это делается в SelenideElement.
`$(byText("Тест элемент")).shouldBe(Condition.visible).click();
$(byClassName("test_element_class")).shouldBe(Condition.visible).click();
$(byId("test_element_id")).shouldBe(Condition.visible).click();
$(byName("element_name")).shouldBe(Condition.visible).click();`
**Описание тестового класса.**
Из чего состоит тестовый класс показано ниже. Эту структуру можно использовать в своих проектах.
`import POM.TestClassPage;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static com.codeborne.selenide.Selenide.*;
import static com.codeborne.selenide.Selenide.closeWebDriver;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
//название тестового класса
public class TestClass {
//обращение к классу из POM, чтобы взаимодействовать с его элементами
private TestClassPage testClassPage;
//переменные, которые могут быть нужны в тесте
private final String number = "12121212";
//аннотация Before - внутри прописывается то, что нужно сделать ДО теста
@Before
public void setUp() {
//открытие страницы веб-сайта с привязкой его к классу из POM; делается с
//помощью инструментов Selenide (WebDriver)
testClassPage = open("https://testSite.ru/", TestClassPage.class);
}
//аннотация After, содержит то, что нужно сделать ПОСЛЕ теста
@After
public void tearDown() {
//эти методы очищают куки и закрывают браузер
clearBrowserCookies();
clearBrowserLocalStorage();
closeWebDriver();
}
//аннотация Test, здесь содержится сам тест и проверки
@Test
//название теста
public void testName() {
//вызов класса из POM, а затем вызов меетода, относящегося к этому классу
testClassPage.clickToEnterButton();
//проверка с помощью Assert (бывают разные типы проверок) - здесь проверяется условие
//на истинность - в скобках указывается условие, которое нужно проверить.
assertTrue(testClassPage.openAuthPage());
}
}`
Начнем писать автотесты
-----------------------
**Первый тест**
**Работа в POM**
Чтобы написать первый тест разберем небольшой тест-кейс.
1. Открываем сайт https://rostov.rt.ru/
2. Нажимаем на кнопку «Войти».
3. На странице авторизации проверяем заголовок. Нужно убедиться, что открылась именно страница авторизации.
Что мы видим из этого тест-кейса? За один маленький тест открывается 2 страницы, а также идет взаимодействие с двумя элементами. Это нужно будет описать в коде. Начнем с описания кнопки и заголовка.
Для этого пойдем по следующему алгоритму:
1. Создайте package и назовите его POM.
2. В package создайте класс и назовите его MainPage.
3. Так как нужно описать кнопку «Войти» идем в DevTools, открываем вкладку Elements. Выберите инструмент для просмотра элементов.
4. В коде страницы видим следующую конструкцию, которая подсвечивается при наведении на кнопку «Войти»:
5. Создаем Selenide Element с этим классом.
`@FindBy(how = How.XPATH, using = "sp-l-0-2")
private SelenideElement enterToAccountButton;`
6. Создаем метод для взаимодействия с кнопкой «Войти». В реальности мы бы кликнули на нее левой кнопкой мыши. Здесь за такое же действие отвечает функция click().
`public MainPage goToTheEnterAccountButton() {
enterToAccountButton.click();
return this;
}`
Дальше нужно описать вторую страницу, используемую в тесте.
1. В POM создаем класс AuthPage. Дальше описываем заголовок страницы как SelenideElement.
*2.* Написать локатор к титулу можно и с по CLASS\_NAME, и по Xpath. На этом этапе советую использовать ChroPath.
3. Если использовать Xpath, то локатор можно просто скопировать из расширения и вставить в код.
`@FindBy(how = How.XPATH, using = "//h1[contains(text(),'Авторизация по коду')]")
private SelenideElement authPageTittle;`
4. Теперь напишем метод для проверки текста заголовка.
Используем ту же конструкцию, что дана в части «Структура проекта». Только тип возвращаемых данных меняем на Boolean. Это нужно потому, что мы будем проверять истинность условия (действительно ли заголовок содержит текст «Авторизация по коду»).
`public boolean openAuthPage() {
//вызываем переменную с заголовком
//дальше пишем условие - переменая должна содержать текст и в скобках пишем необходимый текст
authPageTittle.shouldHave(Condition.exactText("Авторизация по коду"));
//если условие указанное выше выполняется, то метод должен вернуть true - правда
return true;
}`
Дальше этот метод тоже можно будет использовать в тесте.
#### Написание теста
Тестом считается именно часть кода, написанная внутри метода под аннотацией @Test. Но нужно учитывать и то, что нужно будет сделать до и после теста.
На подготовительном этапе можно открыть страницу, перейти к нужному разделу сайта.
А после теста нужно провести «уборку», например, удалить пользователей или другие данные, которые были созданы в процессе.
1. Создадим тестовый класс EnterTest.
2. И сразу обращаемся к классам, с которыми будем взаимодействовать.
`private MainPage mainPage;
private AuthPage authPage;`
3. В этом случае перед тестом нужно открыть главную страницу сайта. Этот этап пойдет в аннотацию Before.
`@Before
public void setUp() {
mainPage = open("https://voronezh.rt.ru/", MainPage.class);
}`
4. Дальше (уже внутри теста) происходит нажатие на кнопку «Войти». Тест нужно будет назвать. Название должно передавать смысл проверки и содержать слово Test.
`@Test
public void openAuthorizationTest() {
mainPage.goToTheEnterAccountButton();
}`
5. Затем открывается уже другая страница, связанная с классом AuthPage. Ее нужно открыть точно также, как MainPage в начале теста, иначе программа не поймет с какой страницы она должна брать данные.
`@Test
public void openAuthorizationTest() {
mainPage.goToTheEnterAccountButton();
authPage = open("https://b2c.passport.rt.ru/auth/realms/b2c/protocol/openid-connect/" +
"auth?client_id=lk_decosystems&redirect_uri=https://rostov.rt.ru/&response_type=" +
"code&scope=openid&_gl=1*1chzy0a*_ga*Mjk0OTYxOTY2LjE2NjQyNzU1MTY.*" +
"_ga_9G5GWSHJG0*MTY3MTcyODk1NS4xOS4xLjE2NzE3MjkwMzcuNTEuMC4w", AuthPage.class);`
6. А затем по тесту мы должны провести проверку – правильный ли на странице заголовок. Последний шаг теста можно добавить сразу же в Assert.
`@Test
public void openAuthorizationTest() {
mainPage.goToTheEnterAccountButton();
authPage = open("https://b2c.passport.rt.ru/auth/realms/b2c/protocol/openid-connect/" +
"auth?client_id=lk_decosystems&redirect_uri=https://rostov.rt.ru/&response_type=" +
"code&scope=openid&_gl=1*1chzy0a*_ga*Mjk0OTYxOTY2LjE2NjQyNzU1MTY.*" +
"_ga_9G5GWSHJG0*MTY3MTcyODk1NS4xOS4xLjE2NzE3MjkwMzcuNTEuMC4w", AuthPage.class);
assertTrue(authPage.openAuthPage());
}`
Первый тест готов. Теперь его можно запускать. При запуске программа сама запустит тест в браузере Google Chrome.
После успешно пройденного теста вы увидите внизу экрана такое изображение:
В случае, если тест завершился неудачно или с ошибками нужно провести дебаг и выяснить, на каком этапе теста падает ошибка.
### Второй тест
Теперь возьмем за основу первый тест и немного усложним его. Будем вводить в поле на странице авторизации несуществующий номер телефона и нажимать на кнопку «Получить код». А потом проверим, что на экране появилось сообщение об ошибке.
#### POM
Для этого нужно будет дописать элементы и методы в классе AuthPage.
1. Бокс для номера телефона или email опишем через Xpath. Но также можно это сделать через How.ID.
Получается такая переменная:
`@FindBy(how = How.XPATH, using = "//input[@id='address']")
private SelenideElement setNumberOrEmail;`
2. Сразу напишем метод с этим боксом. В нем будет возвращаться содержимое страницы, так что тип данных напишем AuthPage. Еще в методе нужно будет передать переменную, в которой будет содержаться номер телефона или email.
Для этого в скобках у названия пишем String (тип передаваемых данных, в этому случае – строка) и название переменной.
`public AuthPage setNumberOrEmail(String number) {
return this;
}`
Дальше нужно описать действие, имитирующее заполнение бокса. Вызываем переменную setNumberOrEmail и функцию setValue. В скобках функции передаем переменную (их может быть несколько).
`public AuthPage setNumberOrEmail(String number) {
setNumberOrEmail.setValue(number);
return this;
}`
3. Опишем кнопку «Получить код». Описать локатор также можно через Xpath, попробуйте найти его самостоятельно на сайте.
`@FindBy(how = How.XPATH, using = "//button[@id='otp_get_code']")
private SelenideElement getCodeButton;`
4. Дальше пишем метод, который нажимает на кнопку «Получить код». Он не будет возвращать true или false, не будет содержать переменных. Поэтому этот метод можно сделать по аналогии с тем, что был дан в первом тесте.
`public AuthPage getCode() {
getCodeButton.click();
return this;
}`
5. Опишем переменную с текстом ошибки. Это можно сделать как с помощью CLASS\_NAME, так и с Xpath.
`@FindBy(how = How.CLASS_NAME, using = "rt-input-container")
private SelenideElement errorText;`
6. Напишем метод с проверкой текста сообщения об ошибке. Он будет аналогичен методу из первого теста.
`public boolean getErrorText() {
errorText.shouldHave(Condition.exactText("E-mail или мобильный телефон\n" +
"Введите телефон в формате +7ХХХХХХХХХХ или +375XXXXXXXXX, или email в формате example@email.ru"));
return true;
}`
**Тест**
Этот тест можно будет написать в том же тестовом классе, так как происходит проверка функциональности из одного блока.
1. В тестовом классе описываем переменную. В ней будет содержаться условный номер телефона.
`private final String number = "12121212";`
2. Создаем новый тест и называем его по-другому. Нажатие на кнопку «Войти» и открытие страницы авторизации остается также, как и в прошлом тесте.
3. Чтобы написать номер телефона на странице вызовем 2 метода с authPage. Это можно сделать так:
`authPage.setNumberOrEmail(number);
authPage.getCode();`
А можно таким образом. Этот способ предпочтительнее, так как тест выглядит лаконичнее.
`authPage.setNumberOrEmail(number)
.getCode();`
4. Делаем проверку, которая тоже аналогична проверке из первого теста.
`assertTrue(authPage.getErrorText());`
**Третий тест**
В третьем тесте нужно будет открыть вкладку «Интернет» на главной странице. Затем из выпадающего меню выберем вкладку «Домашний интернет». После этого совершится переход на новую страницу и там нужно будет выбрать тариф «Облачный». После выбора тарифа будет открыта страница с подробностями о нем и нужно будет убедиться, что открыта правильная страница.
**POM**
1. В классе MainPage описываем кнопку «Интернет» и метод для взаимодействия с ней.
`@FindBy(how = How.XPATH, using = ".//span[contains(text(),'Интернет')]")
private SelenideElement internetButton;`
Метод строится также по стандартному типу.
`public MainPage clickToInternetButton() {
internetButton.click();
return this;
}`
2. Чтобы описать кнопку «Домашний интернет» будем использовать команду Find. Здесь проще всего искать ее по тексту.
`public MainPage clickToHomeInternetButton() {
$(byText("Домашний интернет")).shouldBe(Condition.visible).click();
return this;
}`
3. Дальше откроется страница с выбором тарифов. Для нее создадим новый класс. Назовем его HomeInternetPage.
На странице нужно будет нажать на стрелку, чтобы прокрутить бары с выбором тарифов, а затем нажать на карточку с тарифом «Облачный».
4. Описать кнопку-стрелку можно с помощью CLASS\_NAME.
Получается так:
`@FindBy(how = How.CLASS_NAME, using = "rt-carousel-v3-arrow")
private SelenideElement arrowButton;`
5. Чтобы описать нажатие на карточку тарифа будем нажимать на заголовок. Описать его лучше всего через Xpath, так как class name не уникальный в данном случае для разных тарифов.
`@FindBy(how = How.XPATH, using = "//div[contains(text(),'Облачный')]")
private SelenideElement oblachInternetButton;`
6. В этот раз можно объединить действия в общем методе под названием chooseTariff.
`public HomeInternetPage chooseTariff() {
arrowButton.shouldBe(Condition.visible).click();
oblachInternetButton.click();
return this;
}`
7. Теперь опишем класс для страницы с подробным описанием тарифа. Я заранее называю его CreateOrderPage, так как дальше он будет использоваться еще и в другом тесте.
Для этого теста достаточно описать заголовок страницы и метод с ним.
`@FindBy(how = How.XPATH, using = "//h2[contains(text(),'Облачный')]")
private SelenideElement tariffTitle;`
`public boolean textFromTitleOrder() {
tariffTitle.shouldHave(Condition.text("Облачный"));
return true;
}`
**Дополнения к тесту**
А еще на этом этапе усложним часть, описанную в @Before.
Каждый раз, когда в браузере открывается домашняя страница сайта в самом начале теста мы видим всплывающее окно – с выбором города. Добавим сюда метод с нажатием на кнопку «Продолжить».
Для этого в MainPage добавим кнопку:
`@FindBy(how = How.CLASS_NAME, using = "rt-button-small")
private SelenideElement continueButton`;
И метод:
`public MainPage clickToContinueButton() {
continueButton.click();
return this;
}`
Теперь этот метод можно вызывать перед тестом.
**Тест**
1. Создадим тестовый класс InternetTariffTest. В нем сразу нужно будет обратиться к трем страницам.
`private MainPage mainPage;
private HomeInternetPage homeInternetPage;
private CreateOrderPage createOrderPage;`
2. В @Before теперь добавляем еще один метод с подтверждением региона.
`@Before
public void setUp() {
mainPage = open("https://voronezh.rt.ru/", MainPage.class);
mainPage.clickToContinueButton();
}`
3. В самом тесте сначала вызываем методы с открытием страницы «Домашний интернет».
`@Test
public void chooseInternetTariffTest() {
mainPage.clickToInternetButton()
.clickToHomeInternetButton();`
4. Затем открываем страницу с выбором тарифов и вызываем метод.
`@Test
public void chooseInternetTariffTest() {
mainPage.clickToInternetButton()
.clickToHomeInternetButton();
homeInternetPage = open("https://voronezh.rt.ru/homeinternet", HomeInternetPage.class);
homeInternetPage.chooseTariff();`
5. После этого переходим на страницу с подробной информацией о тарифе и делаем проверку.
`@Test
public void chooseInternetTariffTest() {
mainPage.clickToInternetButton()
.clickToHomeInternetButton();
homeInternetPage = open("https://voronezh.rt.ru/homeinternet", HomeInternetPage.class);
homeInternetPage.chooseTariff();
createOrderPage = open("https://voronezh.rt.ru/about_offer?offer=418923262504&cardId" +
"=3ee2ecc6&lcs=active&pr7=" +
"POSTPAIDUNLIM&ref=%2Fhomeinternet&tech=" +
"2&speed=100&tech=2&speed=100&tech=2&speed=100&cardPos=5",
CreateOrderPage.class);
assertTrue(createOrderPage.textFromTitleOrder());
}`
**Четвертый тест**
В этом тесте нужно будет оформить заявку на подключение тарифа, выбранного на прошлом этапе. Но при этом заявку нужно оформить с некорректными данными. А потом проверить, что на странице появились сообщения об ошибке.
**POM**
Для оформления заявки нужно заполнить поля с адресом, именем и номером телефона. Потом нажать кнопку отправить. Но если адрес и номер некорректные, то на странице появятся 2 сообщения. Все эти элементы и нужно описать.
1. В данном случае все боксы для данных удобно описать с помощью атрибута Name.
`@FindBy(how = How.NAME, using = "address")
private SelenideElement addressBox;
@FindBy(how = How.NAME, using = "fullName")
private SelenideElement nameBox;
@FindBy(how = How.NAME, using = "phoneNumber")
private SelenideElement numberBox;`
2. Сообщения об ошибке можно описать по Xpath, а можно найти в методе с помощью find.
`@FindBy(how = How.XPATH, using = "//span[contains(text(),'Выберите дом из справочника')]")
private SelenideElement errorAddress;
@FindBy(how = How.XPATH, using = "//span[contains(text(),'Введите существующий номер телефона')]")
private SelenideElement errorPhone;`
3. Чтобы заполнить заявку можно сделать метод, который будет получать 3 переменные String и заполнять соответствующие поля.
`public CreateOrderPage fillOrder(String address, String name, String phoneNumber) {
addressBox.setValue(address);
nameBox.setValue(name);
numberBox.setValue(phoneNumber);
return this;
}`
4. А далее нужно написать метод, который будет проверять, что сообщения об ошибках отображаются на странице. В предыдущих методах мы проверяли, содержит ли элемент текст. Теперь будет проверяться то, существует ли элемент на странице.
`public boolean errorMessagesIsVisible() {
errorAddress.shouldBe(Condition.visible);
errorPhone.shouldBe(Condition.visible);
return true;
}`
**Тест**
В этом тесте нужно будет заполнить заказ и проверить, отобразились ли ошибки. В @Before будет практически полностью содержаться предыдущий тест.
1. Создадим тестовый класс CreateInternetOrderTest. Обратимся к страницам, которые будут использоваться в тесте.
`private MainPage mainPage;
private HomeInternetPage homeInternetPage;
private CreateOrderPage createOrderPage;`
2. Дальше нужно создать переменные.
`private final String address = "г Воронеж, ул Минская, д 100000";
private final String name = "Иванов Иван Иваныч";
private final String phone = "7900000000"`;
3. В @Before прописывается полный путь вплоть до открытия страницы с подробностями о тарифе.
`@Before
public void setUp() {
mainPage = open("https://voronezh.rt.ru/", MainPage.class);
mainPage.clickToInternetButton()
.clickToHomeInternetButton();
homeInternetPage = open("https://voronezh.rt.ru/homeinternet", HomeInternetPage.class);
homeInternetPage.chooseTariff();
createOrderPage = open("https://voronezh.rt.ru/about_offer?offer=418923262504&cardId=3ee2ecc6&lcs=active&pr7=" +
"POSTPAIDUNLIM&ref=%2Fhomeinternet&tech=" +
"2&speed=100&tech=2&speed=100&tech=2&speed=100&cardPos=5", CreateOrderPage.class);
}`
4. А сам тест выглядит очень лаконично. Вызывается страница с созданием заявки, а потом идет проверка.
`@Test
public void creatingInternetOrderWithoutFieldsTest() {
createOrderPage.fillOrder(address, name, phone);
assertTrue(createOrderPage.errorMessagesIsVisible());
}`
Подведем итоги
--------------
Теперь вы умеете писать самые простые UI-тесты на Java с помощью фреймворка Selenide. Возможности автоматизированного тестирования только начинаются на этом этапе. Существуют юнит-тесты, API-тесты, которые могут выполнять другие задачи тестирования.
Но даже эти простые тесты можно улучшить. Например, с помощью фреймворка Allure или за счет комбинации UI-тестирования с другими типами тестов.
Файл с тестами, которые разобраны здесь будет приложен к статье. Можно попробовать на их основе сделать своей проект. А также внутри содержится еще один бонусный тест, его тоже можно разобрать самостоятельно в качестве маленького челленджа.
Всем удачи и спасибо за внимание!
Проект можно найти здесь: <https://github.com/nadezdabokareva/RTK-demo-selenide> | https://habr.com/ru/post/707710/ | null | ru | null |
# Как сделать два приложения из одного. Опыт Тинькофф Джуниор
Привет, меня зовут Андрей и я занимаюсь приложениями Тинькофф и Тинькофф Джуниор для платформы Android. Хочу рассказать о том, как мы собираем два похожих приложения из одной кодовой базы.
`Тинькофф Джуниор — это мобильное банковское приложение, ориентированное на детей до 14 лет. Оно похоже на обычное приложение для взрослых, только в него добавлены некоторые функции (например, темы оформления), а другие, наоборот, выключены (например, кредитки).`
.  
На старте проекта мы рассматривали различные варианты его реализации и приняли ряд решений. Сразу же стало очевидно, что два приложения (Тинькофф и Тинькофф Джуниор) будут иметь значительную часть общего кода. Мы не хотели делать форк от старого приложения, а потом копировать исправления ошибок и новый общий функционал. Чтобы работать с двумя приложениями сразу, мы рассматривали три варианта: Gradle Flavors, Git Submodules, Gradle Modules.
### Gradle Flavors
Многие наши разработчики уже пробовали использовать Flavors, плюс мы могли применить многомерную сборку (multi-dimensional flavors) для использования с уже существующими flavors.
Однако Flavors имеют один фатальный недостаток. Android Studio считает кодом только код активного флейвора — то есть то, что лежит в папке main и в папке флейвора. Остальной код считается текстом наравне с комментариями. Это накладывает ограничения на некоторые инструменты студии: поиск использования кода, рефакторинг и другие.
### Git Submodules
Еще один вариант реализации нашей идеи — использовать сабмодули гита: вынести общий код в отдельный репозиторий и подключать его как сабмодуль к двум репозиториям с кодом конкретного приложения.
Этот подход увеличивает сложность работы с исходным кодом проекта. Также разработчикам все равно пришлось бы работать со всеми тремя репозиториями, чтобы вносить правки при изменении API общего модуля.
### Многомодульная архитектура
Последний вариант — перейти на многомодульную архитектуру. Этот подход лишен недостатков, которые есть у двух других. Однако переход на многомодульную архитектуру требует временных затрат на рефакторинг.
На момент начала работы над Тинькофф Джуниор у нас было два модуля: маленький модуль API, описывающий работу с сервером, и большой монолитный модуль application, в котором была сосредоточена основная часть кода проекта.
В итоге мы хотели получить два модуля приложений: *adult* и *junior* и некий общий *core*-модуль. Мы выделили два варианта:
* Вынесение общего кода в общий модуль *common*. Этот подход «правильнее», однако он требует больше времени. Мы оценивали объемы переиспользования кода приблизительно в 80%.
* Преобразование модуля приложения в библиотеку и подключение этой библиотеки к тонким модулям *adult* и *junior*. Этот вариант быстрее, однако он принесет в Тинькофф Джуниор код, который никогда не будет выполняться.
У нас было время в запасе, и мы решили начать разработку по первому варианту (модуль *common*) с условием перейти к быстрому варианту, когда у нас закончится время на рефакторинг.
В итоге так и случилось: мы перенесли часть проекта в модуль *common*, а потом оставшийся модуль *application* превратили в библиотеку. В результате сейчас мы получили такую структуру проекта:
У нас есть модули с фичами, что позволяет нам разграничивать «взрослый», общий или «детский» код. Однако модуль *application* всё еще достаточно большой, и сейчас там хранится около половины проекта.
### Превращаем приложение в библиотеку
В документации есть простая [инструкция](https://developer.android.com/studio/projects/android-library.html#Convert) по превращению приложения в библиотеку. Она содержит четыре простых пункта и, казалось бы, никаких трудностей быть не должно:
1. Открыть файл `build.gradle` модуля
2. Удалить `applicationId` из конфигурации модуля
3. В начале файла заменить `apply plugin: 'com.android.application'` на `apply plugin: 'com.android.library'`
4. Сохранить изменения и синхронизировать проект в Android Studio (**File > Sync Project with Gradle Files**)
Однако конвертация заняла несколько дней и итоговый дифф получился таким:
* 183 files changed
* 1601 insertions(+)
* 1920 deletions(-)
##### Что же пошло не так?
Прежде всего в библиотеках идентификаторы ресурсов — это [не константы](http://tools.android.com/tips/non-constant-fields). В библиотеках, как и в приложениях, генерируется файл *R.java* со списком идентификаторов ресурсов. И в библиотеках значения идентификаторов не являются константными. Джава не позволяет делать свитч по неконстантным значениям, и все свитчи нужно заменить на if-else.
```
// Application
int id = view.getId();
switch(id) {
case R.id.button1:
action1();
break;
case R.id.button2:
action2();
break;
}
// Library
int id = view.getId();
if (id == R.id.button1) {
action1();
} else if (id == R.id.button2) {
action2();
}
```
Далее мы столкнулись с коллизией пакетов.
Предположим, у вас есть библиотека, у которой package = *com.example*, и от этой библиотеки зависит приложение с package = *com.example.app*. Тогда в библиотеке будет сгенерирован класс *com.example.R*, а в приложении, соответственно, *com.example.app.R*. Теперь создадим в приложении активити *com.example.MainActivity*, в которой попробуем обратиться к R-классу. Без явного импорта будет использован R-класс библиотеки, в котором не указаны ресурсы приложения, а только ресурсы библиотеки. Однако Android Studio не подсветит ошибку и при попытке перейти из кода к ресурсу всё будет окей.
### Dagger
В качестве фреймворка для инъекции зависимостей мы используем Dagger.
В каждом модуле, содержащем активити, фрагменты и сервисы, у нас есть обычные интерфейсы, в которых описаны *inject*-методы для этих сущностей. В модулях приложений (*adult* и *junor*) интерфейсы-компоненты даггера наследуются от этих интерфейсов. В модулях мы приводим компоненты к необходимым для данного модуля интерфейсам.
#### Мультибиндинги
Разработку нашего проекта значительно упрощает использование мультибиндингов.
В одном из общих модулей мы определяем интерфейс. В каждом модуле приложения (*adult*, *junior*) описываем реализацию этого интерфейса. С помощью аннотации `@Binds` указываем даггеру, что всякий раз вместо интерфейса необходимо инжектить его конкретную реализацию для детского или взрослого приложения. Также мы нередко собираем коллекцию реализаций интерфейса (Set или Map), при этом такие реализации описаны в разных модулях приложения.
#### Флейворы
Для разных целей мы собираем несколько вариантов приложения. Флейворы, описанные в базовом модуле, должны быть описаны и в зависимых модулях. Также для корректной работы Android Studio необходимо, чтобы во всех модулях проекта были выбраны совместимые варианты сборки.
### Выводы
За короткий срок мы реализовали новое приложение. Теперь мы отгружаем новый функционал в двух приложениях, написав его один раз.
При этом мы потратили некоторое время на рефакторинг, попутно уменьшив технический долг, и перешли на многомодульную архитектуру. По пути мы столкнулись с ограничениями со стороны Android SDK и Android Studio, с которыми успешно справились. | https://habr.com/ru/post/454128/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.