text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Разбираем лямбда-выражения в Java
*От переводчика: LambdaMetafactory, пожалуй, один из самых недооценённых механизмов Java 8. Мы открыли его для себя совсем недавно, но уже по достоинству оценили его возможности. В версии 7.0 фреймворка [CUBA](https://www.cuba-platform.ru/) улучшена производительность за счет отказа от рефлективных вызовов в пользу генерации лямбда выражений. Одно из применений этого механизма в нашем фреймворке — привязка обработчиков событий приложения по аннотациям, часто встречающаяся задача, аналог [EventListener](https://habr.com/users/eventlistener/) из Spring. Мы считаем, что знание принципов работы LambdaFactory может быть полезно во многих Java приложениях, и спешим поделиться с вами этим переводом.*
В этой статье мы покажем несколько малоизвестных хитростей при работе с лямбда-выражениями в Java 8 и ограничения этих выражений. Целевая аудитория статьи — senior Java разработчики, исследователи и разработчики инструментария. Будет использоваться только публичный Java API без `com.sun.*` и других внутренних классов, поэтому код переносим между разными реализациями JVM.
### Короткое предисловие
Лямбда-выражения появились в Java 8 как способ имплементации анонимных методов и,
в некоторых случаях, как альтернатива анонимным классам. На уровне байткода лямбда-выражение заменяется инструкцией `invokedynamic`. Эта инструкция используется для создания реализации функционального интерфейса и его единственный метод делегирует вызов фактическому методу, который содержит код, определенный в теле лямбда-выражения.
Например, у нас есть следующий код:
```
void printElements(List strings){
strings.forEach(item -> System.out.println("Item = %s", item));
}
```
Этот код будет преобразован компилятором Java во что-то похожее на:
```
private static void lambda_forEach(String item) { //сгенерировано Java компилятором
System.out.println("Item = %s", item);
}
private static CallSite bootstrapLambda(Lookup lookup, String name, MethodType type) { //
//lookup = предоставляется VM
//name = "lambda_forEach", предоставляется VM
//type = String -> void
MethodHandle lambdaImplementation = lookup.findStatic(lookup.lookupClass(), name, type);
return LambdaMetafactory.metafactory(lookup,
"accept",
MethodType.methodType(Consumer.class), //сигнатура фабрики лямбда-выражений
MethodType.methodType(void.class, Object.class), //сигнатура метода Consumer.accept после стирания типов
lambdaImplementation, //ссылка на метод с кодом лямбда-выражения
type);
}
void printElements(List strings) {
Consumer lambda = invokedynamic# bootstrapLambda, #lambda\_forEach
strings.forEach(lambda);
}
```
Инструкция `invokedynamic` может быть примерно представлена как вот такой Java код:
```
private static CallSite cs;
void printElements(List strings) {
Consumer lambda;
//begin invokedynamic
if (cs == null)
cs = bootstrapLambda(MethodHandles.lookup(),
"lambda\_forEach",
MethodType.methodType(void.class, String.class));
lambda = (Consumer)cs.getTarget().invokeExact();
//end invokedynamic
strings.forEach(lambda);
}
```
Как видно, `LambdaMetafactory` применяется для создания [CallSite](https://docs.oracle.com/javase/7/docs/api/java/lang/invoke/CallSite.html) который предоставляет фабричный метод, возвращающий обработчик целевого метода,. Этот метод возвращает реализацию функционального интерфейса, используя `invokeExact`. Если в лямбда-выражении есть захваченные переменные, то `invokeExact` принимает эти переменные как фактические параметры.
В Oracle JRE 8 metafactory динамически генерирует Java класс, используя ObjectWeb Asm, который и создает класс-реализацию функционального интерфейса. К созданному классу могут быть добавлены дополнительные поля, если лямбда-выражение захватывает внешние переменные. Этот похоже на анонимные классы Java, но есть следующие отличия:
* Анонимный класс генерируется компилятором Java.
* Класс для реализации лямбда-выражения создается JVM во время выполнения.
---
**Реализация metafactory зависит от вендора JVM и от версии**
---
Конечно же, инструкция `invokedynamic` используется не только для лямбда-выражений в Java. В основном, она применяется при выполнении динамических языков в среде JVM. [Движок Nashorn](http://www.oracle.com/technetwork/articles/java/jf14-nashorn-2126515.html) для исполнения JavaScript, который встроен в Java, интенсивно использует эту инструкцию.
Далее мы сфокусируемся на классе `LambdaMetafactory` и его возможностях. Следующий
раздел этой статьи исходит из предположения, что вы отлично понимаете как работают методы metafactory и что такое `MethodHandle`
Трюки с лямбда-выражениями
--------------------------
В этом разделе мы покажем, как строить динамические конструкции из лямбд для использования в ежедневных задачах.
### Проверяемые исключения и лямбды
Не секрет, что все функциональные интерфейсы, которые есть в Java, не поддерживают проверяемые исключения. Преимущества проверяемых исключений перед обычными — это очень давний (и до сих пор горячий) спор.
А что, если вам нужно использовать код с проверяемыми исключениями внутри лямбда-выражений в сочетании с Java Streams? Например, нужно преобразовать список строк в список URL как здесь:
```
Arrays.asList("http://localhost/", "https://github.com").stream()
.map(URL::new)
.collect(Collectors.toList())
```
В конструкторе [URL(String)](https://docs.oracle.com/javase/8/docs/api/java/net/URL.html#URL-java.lang.String-) объявлено проверяемое исключение, таким образом, он не может быть использован напрямую в виде ссылки на метод в классе [Functiion](https://docs.oracle.com/javase/8/docs/api/java/util/function/Function.html).
Вы скажете: "Нет, возможно, если использовать вот такую хитрость":
```
public static T uncheckCall(Callable callable) {
try { return callable.call(); }
catch (Exception e) { return sneakyThrow(e); }
}
private static T sneakyThrow0(Throwable t) throws E { throw (E)t; }
public static T sneakyThrow(Throwable e) {
return Util.sneakyThrow0(e);
}
// Пример использования
//return s.filter(a -> uncheckCall(a::isActive))
// .map(Account::getNumber)
// .collect(toSet());
```
Это грязный хак. И вот почему:
* Используется блок try-catch.
* Исключение выбрасывается ещё раз.
* Грязное использование стирания типов в Java.
Проблема может быть решена более "легальным" способом, с использованием знания следующих фактов:
* Проверяемые исключения распознаются только на уровне Java компилятора.
* Секция `throws` — это всего лишь метаданные для метода без семантического значения на уровне JVM.
* Проверяемые и обычные исключения неразличимы на уровне байткода в JVM.
Решение — обернуть метод `Callable.call` в метод без секции `throws`:
```
static V callUnchecked(Callable callable){
return callable.call();
}
```
Этот код не скомпилируется, потому что у метода `Callable.call` объявлены проверяемые исключения в секции `throws`. Но мы можем убрать эту секцию, используя динамически сконструированное лямбда-выражение.
Сначала нам нужно объявить функциональный интерфейс, в котором нет секции `throws`
но который сможет делегировать вызов к `Callable.call`:
```
@FunctionalInterface
interface SilentInvoker {
MethodType SIGNATURE = MethodType.methodType(Object.class, Callable.class);//сигнатура метода INVOKE
V invoke(final Callable callable);
}
```
Второй шаг — создать реализацию этого интерфейса, используя `LambdaMetafactory` и делегировать вызов метода `SilentInvoker.invoke` методу `Callable.call`. Как было сказано ранее, секция `throws` игнорируется на уровне байткода, таким образом, метод `SilentInvoker.invoke` сможет вызвать метод `Callable.call` без объявления исключений:
```
private static final SilentInvoker SILENT_INVOKER;
final MethodHandles.Lookup lookup = MethodHandles.lookup();
final CallSite site = LambdaMetafactory.metafactory(lookup,
"invoke",
MethodType.methodType(SilentInvoker.class),
SilentInvoker.SIGNATURE,
lookup.findVirtual(Callable.class, "call", MethodType.methodType(Object.class)),
SilentInvoker.SIGNATURE);
SILENT_INVOKER = (SilentInvoker) site.getTarget().invokeExact();
```
Третье — напишем вспомогательный метод, который вызывает `Callable.call` без объявления исключений:
```
public static V callUnchecked(final Callable callable) /\*no throws\*/ {
return SILENT\_INVOKER.invoke(callable);
}
```
Теперь можно переписать stream без всяких проблем с проверяемыми исключениями:
```
Arrays.asList("http://localhost/", "https://dzone.com").stream()
.map(url -> callUnchecked(() -> new URL(url)))
.collect(Collectors.toList());
```
Этот код скомпилируется без проблем, потому что в `callUnchecked` нет объявления проверяемых исключений. Более того, вызов этого метода может быть заинлайнен при помощи [мономорфного инлайн кэширования](https://en.wikipedia.org/wiki/Inline_caching#Monomorphic_inline_caching), потому что это только один класс во всей JVM, который реализует интерфейс `SilentOnvoker`
Если реализация `Callable.call` выкинет исключение во время выполнения, то оно будет перехвачено вызывающей функцией без всяких проблем:
```
try{
callUnchecked(() -> new URL("Invalid URL"));
} catch (final Exception e){
System.out.println(e);
}
```
Несмотря на возможности этого метода, нужно всегда помнить про следующую рекомендацию:
---
**Скрывайте проверяемые исключения при помощи callUnchecked только если уверены, что вызываемый код не выкинет никаких исключений**
---
Следующий пример показывает пример такого подхода:
```
callUnchecked(() -> new URL("https://dzone.com")); //этот URL всегда правильный и конструктор никогда не выкинет MalformedURLException
```
Полная реализация этого метода находится [здесь](https://bitbucket.org/bytex-solutions/snamp/src/master/framework/src/main/java/com/bytex/snamp/internal/Utils.java), это часть проекта с открытым кодом [SNAMP](https://snamp.io/).
### Работаем с Getters и Setters
Этот раздел будет полезен тем, кто пишет сериализацию/десериализацию для различных форматов данных, таких как JSON, Thrift и т.д. Более того, он может быть довольно полезен, если ваш код сильно полагается на рефлексию для Getters и Setters в JavaBeans.
Getter, объявленный в JavaBean — это метод с именем `getXXX` без параметров и возвращаемым типом данных, отличным от `void`. Setter, объявленный в JavaBean — метод с именем `setXXX`, с одним параметром и возвращающий `void`. Эти две нотации могут быть представленв как функциональные интерфейсы:
* Getter может быть представлен классом [Function](https://docs.oracle.com/javase/8/docs/api/java/util/function/Function.html), в котором аргумент — значение `this`.
* Setter может быть представлен классом [BiConsumer](https://docs.oracle.com/javase/8/docs/api/java/util/function/BiConsumer.html), в котором первый аргумент — `this`, а второй — значение, которое передается в Setter.
Теперь мы создадим два метода, которые смогут преобразовать любой getter или setter в эти
функциональные интерфейсы. И неважно, что оба интерфейса — generics. После стирания типов
реальный тип данных будет `Object`. Автоматическое приведение возвращаемого типа и аргументов может быть сделано при помощи `LambdaMetafactory`. В дополнение, [библиотека Guava](https://github.com/google/guava/wiki/CachesExplained) поможет с кэшированием лямбда-выражений для одинаковых getters и setters.
Первый шаг: необходимо создать кэш для getters и setters. Класс [Method](https://docs.oracle.com/javase/8/docs/api/java/lang/reflect/Method.html) из Reflection API представляет реальный getter или setter и используется в качестве ключа.
Значение кэша — динамически сконструированный функциональный интерфейс для определенного getter'а или setter'а.
```
private static final Cache GETTERS = CacheBuilder.newBuilder().weakValues().build();
private static final Cache SETTERS = CacheBuilder.newBuilder().weakValues().build();
```
Во-вторых, создадим фабричные методы, которые создают экземпляр функционального интерфейса на основе ссылок на getter или setter.
```
private static Function createGetter(final MethodHandles.Lookup lookup,
final MethodHandle getter) throws Exception{
final CallSite site = LambdaMetafactory.metafactory(lookup, "apply",
MethodType.methodType(Function.class),
MethodType.methodType(Object.class, Object.class), //signature of method Function.apply after type erasure
getter,
getter.type()); //actual signature of getter
try {
return (Function) site.getTarget().invokeExact();
} catch (final Exception e) {
throw e;
} catch (final Throwable e) {
throw new Error(e);
}
}
private static BiConsumer createSetter(final MethodHandles.Lookup lookup,
final MethodHandle setter) throws Exception {
final CallSite site = LambdaMetafactory.metafactory(lookup,
"accept",
MethodType.methodType(BiConsumer.class),
MethodType.methodType(void.class, Object.class, Object.class), //signature of method BiConsumer.accept after type erasure
setter,
setter.type()); //actual signature of setter
try {
return (BiConsumer) site.getTarget().invokeExact();
} catch (final Exception e) {
throw e;
} catch (final Throwable e) {
throw new Error(e);
}
}
```
Автоматическое приведение типов между аргументами типа `Object` в функциональных интерфейсах (после стирания типов) и реальными типами аргументов и возвращамого значения достигается при помощи разницы между `samMethodType` и `instantiatedMethodType` (третий и пятый аргументы метода metafactory, соответственно). Тип созданного экземпляра метода — это и есть специализация метода, который предоставляет реализацию лямбда-выражения.
В-третьих, создадим фасад для этих фабрик с поддержкой кэширования:
```
public static Function reflectGetter(final MethodHandles.Lookup lookup, final Method getter) throws ReflectiveOperationException {
try {
return GETTERS.get(getter, () -> createGetter(lookup, lookup.unreflect(getter)));
} catch (final ExecutionException e) {
throw new ReflectiveOperationException(e.getCause());
}
}
public static BiConsumer reflectSetter(final MethodHandles.Lookup lookup, final Method setter) throws ReflectiveOperationException {
try {
return SETTERS.get(setter, () -> createSetter(lookup, lookup.unreflect(setter)));
} catch (final ExecutionException e) {
throw new ReflectiveOperationException(e.getCause());
}
}
```
Информация о методе, полученная из экземпляра класса `Method` с использованием Java Reflection API может быть легко преобразована в `MethodHandle`. Примите во внимание, что у методов экземпляров класса, всегда есть скрытый первый аргумент, используемый для передачи `this` в этот метод. У статических методов такого параметра нет. Например, реальная сигнатура метода `Integer.intValue()` выглядит как `int intValue(Integer this)`. Эта хитрость используется в нашей имплементации функциональных оберток для getters и setters.
А теперь — время тестировать код:
```
final Date d = new Date();
final BiConsumer timeSetter = reflectSetter(MethodHandles.lookup(), Date.class.getDeclaredMethod("setTime", long.class));
timeSetter.accept(d, 42L); //the same as d.setTime(42L);
final Function timeGetter = reflectGetter(MethodHandles.lookup(), Date.class.getDeclaredMethod("getTime"));
System.out.println(timeGetter.apply(d)); //the same as d.getTime()
//output is 42
```
Этот подход с закэшированными getters и setters можно эффективно использовать в библиотеках для сериализации/десериализации (таких, как Jackson), которые используют getters и setters во время сериализации и десериализации.
---
**Вызовы функциональных интерфейсов с динамически сгенерированными реализациями с использованием `LambdaMetaFactory` [значительно быстрее](http://www.jroller.com/thnagy/entry/methodhandle_vs_reflection_benchmark), чем вызовы через Java Reflection API**
---
Полную версию кода можно найти [здесь](https://bitbucket.org/bytex-solutions/snamp/src/master/framework/src/main/java/com/bytex/snamp/internal/Utils.java), это часть библиотеки [SNAMP](https://snamp.io/).
Ограничения и баги
------------------
В этом разделе мы рассмотрим некоторые баги и ограничения, связанные с лямбда-выражениями в компиляторе Java и JVM. Все эти ограничения можно воспроизвести в OpenJDK и Oracle JDK с `javac` версии 1.8.0\_131 для Windows и Linux.
### Создание лямбда-выражений из обработчиков методов
Как вы знаете, лямбда-выражение можно сконструировать динамически, используя `LambdaMetaFactory`. Чтобы это сделать, нужно определить обработчик — класс `MethodHandle`, который указывает на реализацию единственного метода, который определен в функциональном интерфейсе. Давайте взглянем на этот простой пример:
```
final class TestClass {
String value = "";
public String getValue() {
return value;
}
public void setValue(final String value) {
this.value = value;
}
}
final TestClass obj = new TestClass();
obj.setValue("Hello, world!");
final MethodHandles.Lookup lookup = MethodHandles.lookup();
final CallSite site = LambdaMetafactory.metafactory(lookup,
"get",
MethodType.methodType(Supplier.class, TestClass.class),
MethodType.methodType(Object.class),
lookup.findVirtual(TestClass.class, "getValue", MethodType.methodType(String.class)),
MethodType.methodType(String.class));
final Supplier getter = (Supplier) site.getTarget().invokeExact(obj);
System.out.println(getter.get());
```
Этот код эквивалентен:
```
final TestClass obj = new TestClass();
obj.setValue("Hello, world!");
final Supplier elementGetter = () -> obj.getValue();
System.out.println(elementGetter.get());
```
Но что, если мы заменим обработчик метода, который указывает на `getValue` на обработчик, который представляет getter поля:
```
final CallSite site = LambdaMetafactory.metafactory(lookup,
"get",
MethodType.methodType(Supplier.class, TestClass.class),
MethodType.methodType(Object.class),
lookup.findGetter(TestClass.class, "value", String.class), //field getter instead of method handle to getValue
MethodType.methodType(String.class));
```
Этот код должен, ожидаемо, работать, потому что `findGetter` возвращает обработчик, который указывает на getter поля и у него правильная сигнатура. Но, если вы запустите этот код, то увидите следующее исключение:
```
java.lang.invoke.LambdaConversionException: Unsupported MethodHandle kind: getField
```
Что интересно, getter для поля работает нормально, если будем использовать [MethodHandleProxies](https://docs.oracle.com/javase/8/docs/api/java/lang/invoke/MethodHandleProxies.html):
```
final Supplier getter = MethodHandleProxies
.asInterfaceInstance(Supplier.class, lookup.findGetter(TestClass.class, "value", String.class)
.bindTo(obj));
```
Нужно отметить, что `MethodHandleProxies` — не очень хороший способ для динамического создания лямбда-выражений, потому что этот класс просто оборачивает `MethodHandle` в прокси-класс и делегирует вызов [InvocationHandler.invoke](https://docs.oracle.com/javase/8/docs/api/java/lang/reflect/InvocationHandler.html#invoke-java.lang.Object-java.lang.reflect.Method-java.lang.Object:A-) методу [MethodHandle.invokeWithArguments](https://docs.oracle.com/javase/8/docs/api/java/lang/invoke/MethodHandle.html#invokeWithArguments-java.lang.Object...-). Этот подход использует Java Reflection и работает очень медленно.
Как было показано ранее, не все обработчики методов могут быть использованы для создания лямбда-выражений во время выполнения кода.
---
**Только несколько типов обработчиков методов могут быть использованы для динамического создания лямбда-выражений**
---
Вот они:
* REF\_invokeInterface: может быть создан при помощи [Lookup.findVirtual](https://docs.oracle.com/javase/8/docs/api/java/lang/invoke/MethodHandles.Lookup.html#findVirtual-java.lang.Class-java.lang.String-java.lang.invoke.MethodType-) для методов интерфейсов
* REF\_invokeVirtual: может быть создан с помощью Lookup.findVirtual для виртуальных методов класса
* REF\_invokeStatic: создается при помощи [Lookup.findStatic](https://docs.oracle.com/javase/8/docs/api/java/lang/invoke/MethodHandles.Lookup.html#findStatic-java.lang.Class-java.lang.String-java.lang.invoke.MethodType-) для статических методов
* REF\_newInvokeSpecial: может быть создан при помощи [Lookup.findConstructor](https://docs.oracle.com/javase/8/docs/api/java/lang/invoke/MethodHandles.Lookup.html#findConstructor-java.lang.Class-java.lang.invoke.MethodType-) для конструкторов
* REF\_invokeSpecial: может быть создан с помощью [Lookup.findSpecial](https://docs.oracle.com/javase/8/docs/api/java/lang/invoke/MethodHandles.Lookup.html#findSpecial-java.lang.Class-java.lang.String-java.lang.invoke.MethodType-java.lang.Class-)
для приватных методов и раннего связывания с виртуальными методами класса
Остальные типы обработчиков вызовут ошибку `LambdaConversionException`.
### Generic исключения
Этот баг связан с компилятором Java и возможностью объявлять generic исключения в секции `throws`. Следующий пример кода демонстрирует это поведение:
```
interface ExtendedCallable extends Callable{
@Override
V call() throws E;
}
final ExtendedCallable urlFactory = () -> new
URL("http://localhost");
urlFactory.call();
```
Этот код должен скомпилироваться, потому что конструктор класса `URL` выбрасывает `MalformedURLException`. Но он не компилируется. Выдается следующее сообщение об ошибке:
```
Error:(46, 73) java: call() in
```
Но, если мы заменим лямбда-выражение анонимным классом, то код скомпилируется:
```
final ExtendedCallable urlFactory = new ExtendedCallable() {
@Override
public URL call() throws MalformedURLException {
return new URL("http://localhost");
}
};
urlFactory.call();
```
Из этого следует:
---
**Вывод типов для generic исключений не работет корректно в сочетании с лямбда-выражениями**
---
### Ограничения типов параметризации
Можно сконструировать generic объект с несколькими ограничениями типов, используя знак `&`: .
Такой способ определения generic параметров редко используется, но определенным образом влияет на лямбда-выражения в Java из-за некоторых ограничений:
* Каждое ограничение типа, кроме первого, должно быть интерфейсом.
* Чистая версия класса с таким generic учитывает только первое ограничение типа из списка.
Второе ограничение приводит к разному поведению кода во время компиляции и во время выполнения, когда происходит связываение с лямбда-выражения. Эту разницу можно продемонстрировать, используя следующий код:
```
final class MutableInteger extends Number implements IntSupplier, IntConsumer { //mutable container of int value
private int value;
public MutableInteger(final int v) {
value = v;
}
@Override
public int intValue() {
return value;
}
@Override
public long longValue() {
return value;
}
@Override
public float floatValue() {
return value;
}
@Override
public double doubleValue() {
return value;
}
@Override
public int getAsInt() {
return intValue();
}
@Override
public void accept(final int value) {
this.value = value;
}
}
static OptionalInt findMinValue(final Collection values) {
return values.stream().mapToInt(IntSupplier::getAsInt).min();
}
final List values = Arrays.asList(new MutableInteger(10), new MutableInteger(20));
final int mv = findMinValue(values).orElse(Integer.MIN\_VALUE);
System.out.println(mv);
```
Этот код абсолютно корректный и успешно компилируется. Класс `MutableInteger` удовлетворяет ограничениям обобщенного типа T:
* `MutableInteger` наследуется от `Number`.
* `MutableInteger` реализует `IntSupplier`.
Но код упадет с исключением во время выполнения:
```
java.lang.BootstrapMethodError: call site initialization exception
at java.lang.invoke.CallSite.makeSite(CallSite.java:341)
at java.lang.invoke.MethodHandleNatives.linkCallSiteImpl(MethodHandleNatives.java:307)
at java.lang.invoke.MethodHandleNatives.linkCallSite(MethodHandleNatives.java:297)
at Test.minValue(Test.java:77)
Caused by: java.lang.invoke.LambdaConversionException: Invalid receiver type class java.lang.Number; not a subtype of implementation type interface java.util.function.IntSupplier
at java.lang.invoke.AbstractValidatingLambdaMetafactory.validateMetafactoryArgs(AbstractValidatingLambdaMetafactory.java:233)
at java.lang.invoke.LambdaMetafactory.metafactory(LambdaMetafactory.java:303)
at java.lang.invoke.CallSite.makeSite(CallSite.java:302)
```
Так получается, потому что конвейер JavaStream захватывает только чистый тип, который, в нашем случае — класс `Number` и он не реализует интерфейс `IntSupplier`. Эту проблему можно исправить явным объявлением типа параметра в отдельном методе, используемом в качестве ссылки на метод:
```
private static int getInt(final IntSupplier i){
return i.getAsInt();
}
private static OptionalInt findMinValue(final Collection values){
return values.stream().mapToInt(UtilsTest::getInt).min();
}
```
Этот пример демонстрирует некорректный вывод типов в компиляторе и среде исполнения.
---
**Обработка нескольких ограничений типов generic параметров в сочетании с использованием лямбда-выражений во время компиляции и выполнения — неконсистентна**
--- | https://habr.com/ru/post/432418/ | null | ru | null |
# Как определить HTTP_REFERER flash'ки
Предыстория такова. Есть на некоем ресурсе флеш-виджет которые выполняет какие-то операции с пользовательским контентом. В моем конкретном случае, это фотографии. Задача стояла следующим образом. Необходимо собирать статистику показов с внешних ресурсов, т.е. сколько раз и где флешка засветилась на экранах пользователей. задача так же усложнялась и тем, что по сути показы должны были учитываться **не самой флешки, а меняющихся в ней фотографий**. Если же вам так же понадобится учитывать показ контента внутри флеш, то, увы, прийдется обратиться к флешеру, сваявшего этот виджет. Зачем, я объясню позже.
Итак приступим. Все мы прекрасно знаем, что флешка передать реферера не может, вернее может, но этот реферер будет физическим адресом размещения самой флешки. Что не есть хорошо и нам абсолютно не надо. Так как же передать реферера? Очень просто, достаточно обвернуть выдачу флешки в php-скрипт. В котором мы будем выхватывать реферера учитывать показ. Если же у вас задача, так же как и у меня, «со звездочкой», то делаем нехитрый трюк с редиректом и добавлением параметра в запрос, таким вот образом. Получив реферер, в PHP скрипте, мы генерируем новый запрос к флешке и делаем по нему редирект. Флешка в свою очередь, получив этот параметр, добавляет его к каждому запросу (в моем случае фотографии) к нашему серверу, где этот запрос, обрабатывается скриптом, который учитывает всю необходимую нам информацию, включая реферера. Теперь чтоб совсем все стало ясно, приведу небольшой пример утопического кода (без проверок и пр. только логика, так что, пожалуйста не возмущайтесь понапрасну):
```
// Файл flashcatch.php
$file = './flash.swf';
$referer = $_SERVER['HTTP_REFERER'];
// Если не надо делать никаких более действий, то прямо здесь счетаем показ
// ...
// Устанавливаем тип содержимого
header('Content-Type: application/x-shockwave-flash');
// Читаем и отдаем флешку.
echo file_get_content($file);
exit();
```
Если понадобиться добавить параметр для последующего учета показов контента внутри самой флешки то код немного усложниться.
```
// Файл flashcatch-trick.php
$file = './flash.swf';
$referer = $_SERVER['HTTP_REFERER'];
// Добавляем параметр к запросу на флешку например referer.
if (strpos($_SERVER['REQUEST_URI'], '?')) {
$connector = '&';
} else {
$connector = '?';
}
$newRequest = 'http://' . $_SERVER['SERVER_NAME'] . $_SERVER['REQUEST_URI'] . $connector . 'referer=' . $referer;
// Если запрос является внешним и запрос не содержит в себе параметра referer то делаем редирект
if (isExternalRequest() && !$_REQUEST['referer']) {
header ('Location: ' . $newRequest);
exit();
}
// Устанавливаем тип содержимого
header('Content-Type: application/x-shockwave-flash');
// Читаем и отдаем флешку.
echo file_get_content($file);
exit();
```
И вот тут, вспоминаем про флешера, во флешку передаем новый параметр, в котором прописан реферер, в моем случае это параметр referer. А флешер, формируя запросы к серверу для получения фотографий (аудио, видео), подставляет его и сервер при выдаче содержимого флешке, учитывает реферера и показ, соответсвенно.
Функция *isExternalRequest* не приведена, ее не составит труда написать самому. Суть ее думаю ясна, вернет true если это внешний запрос и false если свой же сервер запросил флешку. | https://habr.com/ru/post/148284/ | null | ru | null |
# Переход на ReactiveCocoa v.4
Если вы когда – либо интересовались [фреймворком ReactiveCocoa](https://github.com/ReactiveCocoa/ReactiveCocoa), то заметили, что есть небольшое количество постов на тему реактивного программирования и фреймворка ReactiveCocoa, такие как [Знакомство с ReactiveCocoa](https://habrahabr.ru/post/248771/), или [Лучший мир с ReactiveCocoa](https://habrahabr.ru/post/215033/). До сегодняшнего дня, все эти посты были на тему ReactiveCocoa 2 версий, которая была написана на и для Objective-C. Сейчас все больше набирает популярность язык Swift, разработчики ReactiveCocoa усиленно работают над новой версией, которая будет написана на языке Swift и будет иметь некоторые функциональные особенности, которые являются фундаментальными для данного языка.
Я подозреваю, что многие из вас, как и я, с огромным желанием оставили Objective-C и перешли на Swift. Если вы хотели бы использовать ReactiveCocoa с новым языком, я вам настоятельно рекомендую попробовать использовать новую версию ReactiveCocoa. И я уверен, что наше сообщество получит огромную пользу от вклада, сделанного вами. С другой стороны, если вы работаете над большими бизнес приложениями в продакшн для определенного заказчика, я должен вам сказать – не делайте этого или хорошенько подумайте перед тем как использовать его. Но об этом мы поговорим дальше, если кого заинтересовал — прошу под кат.
### Состояние ReactiveCocoa на сегодняшний день
Во время написания данной статьи, ReactiveCocoa (с этого времени именуемый, как RAC) находится в неопределенном состоянии. Когда первая версия языка Swift была опубликована, разработчики начали работу над третей версией RAC. Тем не менее, не так давно компания Apple выпустила Xcode 7.0, который содержит поддержку языка Swift версий 2.0. Это вызвано некоторыми критическими изменениями в RAC3, но также имеются некоторые значительные упрощения по отношению к новому API. Изменения подтолкнули разработчиков к началу работ над RAC4.
RAC4 еще далеко не в том состоянии, чтобы использовать ее для создания стабильных приложений, но многие уже это делают, также необходимо проявлять осторожность из-за того, что система часто изменяется. Протокол изменений гласит — “Возможно наличие критических изменений, поэтому будьте готовы к этому, перед тем как интегрировать его в приложение.” Но все же, если вы действительно готовы испытать RAC4, я поделюсь некоторыми советами, которые помогут начать использовать новую версию RAC.
### Скажите досвидание RACSignal
В RAC2 все сигналы использовали тип RACSignal. Сигнал может быть в двух типов — hot (горячий) и cold (холодный). Горячий сигнал имеет, как минимум, одного подписчика, который обрабатывает отправляемые на него события, мне это напоминает замкнутую цепь, которая не имеет начала и не имеет конца. Холодный сигнал — это один из сигналов, который может не иметь подписчиков и поэтому не обеспечивает каких-либо действий или передачи информации. Его можно разбить на этапы, холодный сигнал не начинает свою работу пока на него кто-то не подпишется.
RAC4 разделяет концепцию сигналов на два различных вида: Signal Producers (Инициаторы сигналов) и Signals (сигналы). Процедура сигнала очень похожа на RACSignal; сигнал находится в бездействии до тех пор, пока он не будет запущен. Разработчики изменили терминологию слова subscribed на started, поскольку этот вариант описывает данное состояние сигнала более точно. Например, SignalProducer может иметь множественное количество подписчиков, которые подписаны для получения событий, но сигнал не стает активным, и подписчики не увидят никаких событий до тех пор, пока он не будет запущен по какой-то причине. Сигнал запускается вызовом метода start().
Другим новым типом является Signal. Signal подобен пожарному рукаву. Вы подключаете его к источнику и события протекают через него. Пока нет запуска сигнала, вы можете использовать его для работы подобно SignalProducer. Сигналы также не поддерживают никакой истории. Когда подписчик подписывается на события от сигнала, он получит все будущие события, но ни одного прошлого события. Сигналы очень полезны для передачи информации в реальном времени, что возникает как результат взаимодействия пользователя с приложением. Например, сигнал может отправлять цифры и сымволы, которые пользователь вводит в текстовое поле.
### Метод Defer убрали
Вы также заметите, что RAC4 больше не содержит операцию defer (перенос). В отличие от вызова функции в RAC2, мы будем часто использовать блоки переноса, если потребуется запись функции, которая возвращает сигнал, а также выполняет некоторые другие операции (подобно регистрированию отлаженного текста), когда сигнал переходит в горячее состояние.
Опции defer в RAC4, больше не существует. Для демонстраци данного примера авторы предлагают нам рассмотреть started, подобный следующему.
На языке Swift:
```
func logIn(username: String, password: String) -> SignalProducer {
return accountManager.logIn(username, password: password)
.on( started: {
print("Logging in...")
}
}
```
в отличие от, языка Objective-C
```
- (RACSignal *)logInWithUsername:(NSString *)username andPassword:(NSString *)password {
return [RACSignal defer:^{
NSLog("Logging in...");
return [accountManager logInUser:username withPassword:password];
}];
}
```
### MutableProperties
Одна из особенностей, которая мне действительно нравится в RAC4 — это класс MutableProperty. MutableProperty является контейнером для объекта, изменяемый во время выполнения программы. Он также содержит инициатор сигнала, который автоматически отправляет каждое значение, которое было назначено подписчику.
### Строгая типизация
Наиболее сложным для меня при переходе на RAC4 было привыкание к строгой типизации, связанной с сигналами. В RAC2 сигналы не имеют никакой информации про объекты или ошибки. Ограничение являлось только тем, что все объекты, отправленные на них, должны быть получены из NS объектов (не примитивов). В RAC4 сигнал определяется данным типом для значений, определяемых для него и для ошибок, что могут произойти. Например,
```
var signalA = SignalProducer ...
```
определяет сигнал, который может быть отправлен только объектам типа String, и только ReallyBadError могут происходить при этом. Безопасность с точки зрения типов имеет некоторые преимущества в отношении того, что стает более понятно то, какая информация была отправлена, но в то же самое время это усложняет комбинирование сигналов.
В RAC2, вы можете легко взять сигнал, который отправляет Бананы, соединить его с сигналом, который отправляет Апельсины, и связать результат с сигналами которые отправляют Ананасы. Результирющий сигнал не будет иметь надлежащий вид, но код будет скомпилирован.
В RAC4, компилятор будет показывать ошибки, если вы будете пытаться вернуть сигналы, отправляющие Яблоки из функции, которая возможно возвращает сигнал, который отправляет Персики.
### Комбинирование сигналов
Комбинирование сигналов является более сложным из-за того, что авторы избавились от хороших функций, которые использовали массивы сигналов для образования связывания, слияния, и т.п… Например в Objective-C, если вы хотите сделать объединения двух сигналов, вы должны выполнить следующее:
```
-(RACSignal *) bakeCakeWith:(NSArray *)ingredients {
RACSignal *preheatSignal = [self.oven preheat:@(350)];
RACSignal *bakeSignal = [self.baker combine:ingredients];
return [RACSignal concat:@[preheatSignal, bakeSignal];
}
```
Теперь в RAC4, вы должны выполнить следующее.
```
func bakeCake(ingredients: Array) -> SignalProducer {
let (combinerSignal, combinerSink) = SignalProducer.buffer(1)
sendNext(combinerSink, self.oven.preheat(350))
sendNext(combinerSink, self.baker.combine(ingredients))
return combinerSignal.flatten(.Concat)
}
```
Но вы можете создать собственную функцию, которая будет легко исполнять то же самое, что и в языке Objective-C.
Я определенно испытывал некоторое разочарование знакомясь с языком Swift и RAC4, но это был действительно веселый путь который я проделал. Я планирую продолжать двигаться дальше, и я призываю вас сделать то же самое.
*Вот несколько действительно хороших источников где можно больше узнать о RAC:*
[Stanfy MadCode Meetup #11: Why do you need to switch from Obj-C to Swift, or let’s talk about ReactiveCocoa v4](https://www.youtube.com/watch?v=S-D04dz1tR4&nohtml5=False)
[An Introduction to ReactiveCocoa](https://nomothetis.svbtle.com/an-introduction-to-reactivecocoa)
[MVVM WITH REACTIVECOCOA 3.0](http://blog.scottlogic.com/2015/05/15/mvvm-reactive-cocoa-3.html)
[Reactive Swift: upgrading to ReactiveCocoa 3.0](https://blog.alltheflow.com/reactive-swift-upgrading-to-reactivecocoa-3-0/) | https://habr.com/ru/post/281106/ | null | ru | null |
# Telegram-бот на Java для самых маленьких — от старта до бесплатного размещения на heroku
### В следующих сериях
Это первая статья в моей серии «для самых маленьких» — [следующая](https://habr.com/ru/post/646017/) посвящена Telegram-боту на вебхуках на Spring с ~~блекджеком и~~ Redis и клавиатурами. Будут ещё:)
### Для кого написано
Если вы ни разу не писали Telegram-ботов на Java и только начинаете разбираться — эта статья для вас. В ней подробно и с пояснениями описано создание реального бота, автоматизирующего одну конкретную функцию. Можно использовать статью как мануал для создания скелета своего бота, а потом подключить его к своей бизнес-логике.
### Предыстория
Когда моя дочь начала изучать арифметику, я между делом накидал алгоритм генерации простых примеров на сложение и вычитание вида «5 + 7 =», чтобы не придумывать и не гуглить для неё задания.
И тут на глаза попалась новость, что Telegram выпустил новую версию Bot API 5.0. Ботов я раньше не писал, и потому решил попробовать поднять бота как интерфейс для своей поделки. Все примеры, которые мне удалось найти, показались либо совсем простыми (нужные мне функции не были представлены), либо очень сложными для новичка. Также мне не хватало объяснений, почему выбран тот или иной путь. В общем, написано было сразу для умных, а не для меня. Потому я решил описать свой опыт создания простого бота — надеюсь, кому-нибудь это поможет быстрее въехать в тему.
### Что в статье есть, чего нет
В статье есть про:
* создание бекенда не-инлайн бота на Java 11 с использованием Telegram Bot Api 5.0;
* обработка команд вида `/dosomething`;
* обработка текстовых сообщений, не являющихся командами (т.е. не начинающихся с "/");
* отправку пользователю текстовых сообщений и файлов;
* деплой и запуск бота на [heroku](https://www.heroku.com/).
В статье **нет** про:
* использование функций ботов, не перечисленных выше (например, создание клавиатур — я их сначала добавил, но в итоге они мне просто не пригодились);
* создание списка заданий;
* работу с Word-документом;
* обеспечивающие функции — логирование, тесты и т.п.;
* общение с [BotFather](https://t.me/BotFather) (создание бота, получение его токена и формирование списка команд подробно и понятно описано во многих источниках, вот первый попавшийся [мануал](https://botcreators.ru/blog/kak-sozdat-svoego-bota-v-botfather/)).
Из примеров кода в статье эти функции исключены, чтобы упростить восприятие. [Исходный код](https://github.com/taksebe-official/mentalCalculation) лежит на GitHub. Если у вас вдруг есть вопросы, пишите в личку, с удовольствием проконсультирую.
### Бизнес-функции бота
Бот позволяет:
* выдавать пользователю справочную текстовую информацию в ответ на команды `/start`, `/help` и `/settings`;
* обрабатывать и запоминать пользовательские настройки, направленные текстовым сообщением заданного формата. Настроек три — минимальное + максимальное число, используемые в заданиях, и количество страниц выгружаемого файла;
* оповещать пользователя о несоблюдении им формата сообщения;
* формировать Word-файл с заданиями на сложение, вычитание или вперемешку в ответ на команды `/plus`, `/minus` и `/plusminus` с использованием дефолтных или установленных пользователем настроек.
Можно потыкать — [MentalCalculationBot](https://t.me/MentalCalculationBot) (должен работать). Выглядит так:
### Порядок разработки
* разобраться с зависимостями;
* создать класс бота и реализовать обработку текстовых сообщений пользователя, не являющихся командами;
* создать классы команд;
* прописать запуск приложения;
* задеплоить на heroku.
Ниже подробно расписан каждый пункт.
### Зависимости
Для управления зависимостями использовался [Apache Maven](https://maven.apache.org/). Нужные зависимости — собственно [Telegram Bots](https://core.telegram.org/bots) и [Lombok](https://projectlombok.org), использовавшийся для упрощения кода (заменяет стандартные java-методы аннотациями).
Вот что вышло в
**pom.xml**
```
\*\*\*
\*\*\*
1.0-SNAPSHOT
\*\*\*
\*\*\*
jar
11
${java.version}
${java.version}
UTF-8
1.18.16
4.1.2
5.0.1
org.telegram
telegrambots
${telegram.version}
org.telegram
telegrambotsextensions
${telegram.version}
org.projectlombok
lombok
${org.projectlombok.version}
compile
${project.artifactId}
org.apache.maven.plugins
maven-compiler-plugin
3.8.1
${java.version}
org.projectlombok
lombok
${org.projectlombok.version}
org.apache.maven.plugins
maven-dependency-plugin
3.1.2
copy-dependencies
package
copy-dependencies
org.apache.maven.plugins
maven-surefire-plugin
3.0.0-M5
```
### Класс бота и обработка текстовых сообщений
Мой класс `Bot` унаследован от `TelegramLongPolling**Command**Bot`, который, в свою очередь, наследуется от более распространённого в примерах `TelegramLongPollingBot`. Он хорош тем, что в нём уже реализованы приём и обработка команд — то есть сообщений, начинающихся с "/". Можно создавать отдельные классы команд (подробнее о них ниже), инициализировать их в конструкторе бота и уже в них писать логику их обработки.
В классе `Bot` таким образом остаётся только логика обработки текстовых сообщений, не являющихся командами. В моём случае это пользовательские настройки или мусорные сообщения, не соответствующие формату. Для лаконичности логику их обработки тоже стоит вынести в отдельный вспомогательный класс, вызывая его метод из переопределенного метода `processNonCommandUpdate(Update update)` класса `Bot`.
В качестве параметров для инициализации бота используются его имя и токен, полученные от [BotFather](https://t.me/BotFather). В ходе разработки удобно создать тестового бота и прописать его параметры прямо в коде, чтобы проще было запускать бекенд локально и отлаживать прямо в Telegram, однако перед релизом стоит пересоздать бота и вынести эти настройки из кода — например, в переменные окружения (об этом ниже).
Получился вот такой
**Bot.java**
```
import lombok.Getter;
import org.telegram.telegrambots.extensions.bots.commandbot.TelegramLongPollingCommandBot;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.Message;
import org.telegram.telegrambots.meta.api.objects.Update;
import org.telegram.telegrambots.meta.api.objects.User;
import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
import ru.taksebe.telegram.mentalCalculation.telegram.commands.operations.MinusCommand;
import ru.taksebe.telegram.mentalCalculation.telegram.commands.operations.PlusCommand;
import ru.taksebe.telegram.mentalCalculation.telegram.commands.operations.PlusMinusCommand;
import ru.taksebe.telegram.mentalCalculation.telegram.commands.service.HelpCommand;
import ru.taksebe.telegram.mentalCalculation.telegram.commands.service.SettingsCommand;
import ru.taksebe.telegram.mentalCalculation.telegram.commands.service.StartCommand;
import ru.taksebe.telegram.mentalCalculation.telegram.nonCommand.NonCommand;
import ru.taksebe.telegram.mentalCalculation.telegram.nonCommand.Settings;
import java.util.HashMap;
import java.util.Map;
public final class Bot extends TelegramLongPollingCommandBot {
private final String BOT_NAME;
private final String BOT_TOKEN;
//Настройки по умолчанию
@Getter
private static final Settings defaultSettings = new Settings(1, 15, 1);
//Класс для обработки сообщений, не являющихся командой
private final NonCommand nonCommand;
/**
* Настройки файла для разных пользователей. Ключ - уникальный id чата
*/
@Getter
private static Map userSettings;
public Bot(String botName, String botToken) {
super();
this.BOT\_NAME = botName;
this.BOT\_TOKEN = botToken;
//создаём вспомогательный класс для работы с сообщениями, не являющимися командами
this.nonCommand = new NonCommand();
//регистрируем команды
register(new StartCommand("start", "Старт"));
register(new PlusCommand("plus", "Сложение"));
register(new MinusCommand("minus", "Вычитание"));
register(new PlusMinusCommand("plusminus", "Сложение и вычитание"));
register(new HelpCommand("help","Помощь"));
register(new SettingsCommand("settings", "Мои настройки"));
userSettings = new HashMap<>();
}
@Override
public String getBotToken() {
return BOT\_TOKEN;
}
@Override
public String getBotUsername() {
return BOT\_NAME;
}
/\*\*
\* Ответ на запрос, не являющийся командой
\*/
@Override
public void processNonCommandUpdate(Update update) {
Message msg = update.getMessage();
Long chatId = msg.getChatId();
String userName = getUserName(msg);
String answer = nonCommand.nonCommandExecute(chatId, userName, msg.getText());
setAnswer(chatId, userName, answer);
}
/\*\*
\* Получение настроек по id чата. Если ранее для этого чата в ходе сеанса работы бота настройки не были установлены, используются настройки по умолчанию
\*/
public static Settings getUserSettings(Long chatId) {
Map userSettings = Bot.getUserSettings();
Settings settings = userSettings.get(chatId);
if (settings == null) {
return defaultSettings;
}
return settings;
}
/\*\*
\* Формирование имени пользователя
\* @param msg сообщение
\*/
private String getUserName(Message msg) {
User user = msg.getFrom();
String userName = user.getUserName();
return (userName != null) ? userName : String.format("%s %s", user.getLastName(), user.getFirstName());
}
/\*\*
\* Отправка ответа
\* @param chatId id чата
\* @param userName имя пользователя
\* @param text текст ответа
\*/
private void setAnswer(Long chatId, String userName, String text) {
SendMessage answer = new SendMessage();
answer.setText(text);
answer.setChatId(chatId.toString());
try {
execute(answer);
} catch (TelegramApiException e) {
//логируем сбой Telegram Bot API, используя userName
}
}
}
```
Класс обработки текстовых сообщений
**NonCommand.java**
```
import ru.taksebe.telegram.mentalCalculation.exceptions.IllegalSettingsException;
import ru.taksebe.telegram.mentalCalculation.telegram.Bot;
/**
* Обработка сообщения, не являющегося командой (т.е. обычного текста не начинающегося с "/")
*/
public class NonCommand {
public String nonCommandExecute(Long chatId, String userName, String text) {
Settings settings;
String answer;
try {
//создаём настройки из сообщения пользователя
settings = createSettings(text);
//добавляем настройки в мапу, чтобы потом их использовать для этого пользователя при генерации файла
saveUserSettings(chatId, settings);
answer = "Настройки обновлены. Вы всегда можете их посмотреть с помощью /settings";
//логируем событие, используя userName
} catch (IllegalSettingsException e) {
answer = e.getMessage() +
"\n\n Настройки не были изменены. Вы всегда можете их посмотреть с помощью /settings";
//логируем событие, используя userName
} catch (Exception e) {
answer = "Простите, я не понимаю Вас. Возможно, Вам поможет /help";
//логируем событие, используя userName
}
return answer;
}
/**
* Создание настроек из полученного пользователем сообщения
* @param text текст сообщения
* @throws IllegalArgumentException пробрасывается, если сообщение пользователя не соответствует формату
*/
private Settings createSettings(String text) throws IllegalArgumentException {
//отсекаем файлы, стикеры, гифки и прочий мусор
if (text == null) {
throw new IllegalArgumentException("Сообщение не является текстом");
}
//создаём из сообщения пользователя 3 числа-настройки (min, max, listCount) либо пробрасываем исключение о несоответствии сообщения требуемому формату
return new Settings(min, max, listCount);
}
/**
* Добавление настроек пользователя в мапу, чтобы потом их использовать для этого пользователя при генерации файла
* Если настройки совпадают с дефолтными, они не сохраняются, чтобы впустую не раздувать мапу
* @param chatId id чата
* @param settings настройки
*/
private void saveUserSettings(Long chatId, Settings settings) {
if (!settings.equals(Settings.getDefaultSettings())) {
Bot.getUserSettings().put(chatId, settings);
} else {
Bot.getUserSettings().remove(chatId);
}
}
}
```
### Классы команд
Все классы команд наследуются от `BotCommand`.
Команды в моём боте делятся на 2 группы:
* Сервисные — возвращают справочную информацию;
* Основные — формируют файл с заданиями.
Структура классов команд для этих групп идентична — в абстрактном суперклассе реализуются общие методы, в наследуемые от него классах отдельных команд вынесена их кастомная логика. Разница лишь в том, что Основные команды обращаются к внешним классам, где реализована бизнес-логика, в то время как Сервисные просто формируют текстовый ответ.
Начнём с более простых Сервисных команд. В абстрактный суперкласс вынесен метод отправки пользователю ответа, а в классах команд формируется текст ответа.
Абстрактный суперкласс Сервисных команд
**ServiceCommand.java**
```
import org.telegram.telegrambots.extensions.bots.commandbot.commands.BotCommand;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.bots.AbsSender;
import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
/**
* Суперкласс для сервисных команд
*/
abstract class ServiceCommand extends BotCommand {
ServiceCommand(String identifier, String description) {
super(identifier, description);
}
/**
* Отправка ответа пользователю
*/
void sendAnswer(AbsSender absSender, Long chatId, String commandName, String userName, String text) {
SendMessage message = new SendMessage();
//включаем поддержку режима разметки, чтобы управлять отображением текста и добавлять эмодзи
message.enableMarkdown(true);
message.setChatId(chatId.toString());
message.setText(text);
try {
absSender.execute(message);
} catch (TelegramApiException e) {
//логируем сбой Telegram Bot API, используя commandName и userName
}
}
}
```
Класс Сервисной команды на примере
**StartCommand.java**
```
import org.telegram.telegrambots.meta.api.objects.Chat;
import org.telegram.telegrambots.meta.api.objects.User;
import org.telegram.telegrambots.meta.bots.AbsSender;
/**
* Команда "Старт"
*/
public class StartCommand extends ServiceCommand {
public StartCommand(String identifier, String description) {
super(identifier, description);
}
@Override
public void execute(AbsSender absSender, User user, Chat chat, String[] strings) {
//формируем имя пользователя - поскольку userName может быть не заполнено, для этого случая используем имя и фамилию пользователя
String userName = (user.getUserName() != null) ? user.getUserName() :
String.format("%s %s", user.getLastName(), user.getFirstName());
//обращаемся к методу суперкласса для отправки пользователю ответа
sendAnswer(absSender, chat.getId(), this.getCommandIdentifier(), userName,
"Давайте начнём! Если Вам нужна помощь, нажмите /help");
}
}
```
В суперклассе Основных команд, помимо аналогичного метода отправки ответов, содержится формирование Word-документа.
**OperationCommand.java**
```
import org.telegram.telegrambots.extensions.bots.commandbot.commands.BotCommand;
import org.telegram.telegrambots.meta.api.methods.send.SendDocument;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.InputFile;
import org.telegram.telegrambots.meta.bots.AbsSender;
import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
import ru.taksebe.telegram.mentalCalculation.calculation.Calculator;
import ru.taksebe.telegram.mentalCalculation.calculation.PlusMinusService;
import ru.taksebe.telegram.mentalCalculation.enums.OperationEnum;
import ru.taksebe.telegram.mentalCalculation.fileProcessor.WordFileProcessorImpl;
import ru.taksebe.telegram.mentalCalculation.telegram.Settings;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.List;
/**
* Суперкласс для команд создания заданий с различными операциями
*/
abstract class OperationCommand extends BotCommand {
private PlusMinusService service;
OperationCommand(String identifier, String description) {
super(identifier, description);
this.service = new PlusMinusService(new WordFileProcessorImpl(), new Calculator());
}
/**
* Отправка ответа пользователю
*/
void sendAnswer(AbsSender absSender, Long chatId, List operations, String description, String commandName, String userName) {
try {
absSender.execute(createDocument(chatId, operations, description));
} catch (IOException | IllegalArgumentException e) {
sendError(absSender, chatId, commandName, userName);
e.printStackTrace();
} catch (TelegramApiException e) {
//логируем сбой Telegram Bot API, используя commandName и userName
}
}
/\*\*
\* Создание документа для отправки пользователю
\* @param chatId id чата
\* @param operations список типов операций (сложение и/или вычитание)
\* @param fileName имя, которое нужно присвоить файлу
\*/
private SendDocument createDocument(Long chatId, List operations, String fileName) throws IOException {
FileInputStream stream = service.getPlusMinusFile(operations, Bot.getUserSettings(chatId));
SendDocument document = new SendDocument();
document.setChatId(chatId.toString());
document.setDocument(new InputFile(stream, String.format("%s.docx", fileName)));
return document;
}
/\*\*
\* Отправка пользователю сообщения об ошибке
\*/
private void sendError(AbsSender absSender, Long chatId, String commandName, String userName) {
try {
absSender.execute(new SendMessage(chatId.toString(), "Похоже, я сломался. Попробуйте позже"));
} catch (TelegramApiException e) {
//логируем сбой Telegram Bot API, используя commandName и userName
}
}
}
```
Класс Основной команды на примере
**PlusMinusCommand.java**
```
import org.telegram.telegrambots.meta.api.objects.Chat;
import org.telegram.telegrambots.meta.api.objects.User;
import org.telegram.telegrambots.meta.bots.AbsSender;
import ru.taksebe.telegram.mentalCalculation.enums.OperationEnum;
/**
* Команда получение файла с заданиями на сложение и вычитание
*/
public class PlusMinusCommand extends OperationCommand {
public PlusMinusCommand(String identifier, String description) {
super(identifier, description);
}
@Override
public void execute(AbsSender absSender, User user, Chat chat, String[] strings) {
//формируем имя пользователя - поскольку userName может быть не заполнено, для этого случая используем имя и фамилию пользователя
String userName = (user.getUserName() != null) ? user.getUserName() :
String.format("%s %s", user.getLastName(), user.getFirstName());
//обращаемся к методу суперкласса для формирования файла на сложение и вычитание (за это отвечает метод getPlusMinus() перечисления OperationEnum) и отправки его пользователю
sendAnswer(absSender, chat.getId(), OperationEnum.getPlusMinus(), this.getDescription(), this.getCommandIdentifier(), userName);
}
}
```
### Приложение
В методе main инициализируется `TelegramBotsApi`, в котором и регистрируется Bot.
`TelegramBotsApi` в качестве параметра принимает `Class extends BotSession`. Если нет никаких заморочек с прокси, можно использовать `DefaultBotSession.class`.
Чтобы получать имя и токен бота как переменные окружения, необходимо использовать `System.getenv()`.
Получаем вот такой
**MentalCalculationApplication.java**
```
import org.telegram.telegrambots.meta.TelegramBotsApi;
import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
import org.telegram.telegrambots.updatesreceivers.DefaultBotSession;
import ru.taksebe.telegram.mentalCalculation.telegram.Bot;
import java.util.Map;
public class MentalCalculationApplication {
private static final Map getenv = System.getenv();
public static void main(String[] args) {
try {
TelegramBotsApi botsApi = new TelegramBotsApi(DefaultBotSession.class);
botsApi.registerBot(new Bot(getenv.get("BOT\_NAME"), getenv.get("BOT\_TOKEN")));
} catch (TelegramApiException e) {
e.printStackTrace();
}
}
}
```
### Деплой на [heroku](https://www.heroku.com/)
Для начала нужно создать в корне проекта файл Procfile и написать в него одну строку:
`worker: java -Xmx300m -Xss512k -XX:CICompilerCount=2 -Dfile.encoding=UTF-8 -cp ./target/classes:./target/dependency/* <путь до приложения, в моём случае ru.taksebe.telegram.mentalCalculation.MentalCalculationApplication>`
, где worker — это тип процесса.
Если в проекте используется версия Java, отличная от 8, также необходимо создать в корне проекта файл system.properties и прописать в нём одну строку:
`java.runtime.version=<версия Java>`
Далее порядок такой:
1. Регистрируемся на heroku и идём в консоль;
2. `mvn clean install`;
3. `heroku login` — после выполнения потребуется нажать любую клавишу и залогиниться в открывшемся окне браузера;
4. `heroku create <имя приложения>` — создаём приложение на heroku;
5. `git push heroku master` — пушим в репозиторий heroku;
6. `heroku config:set BOT_NAME=<имя бота>` — добавляем имя бота в переменные окружения;
7. `heroku config:set BOT_TOKEN=<токен бота>` — добавляем токен бота в переменные окружения;
8. `heroku config:get BOT_NAME` (аналогично BOT\_TOKEN) — убеждаемся, что переменные окружения установлены верно;
9. `heroku ps:scale worker=1` — устанавливаем количество контейнеров (dynos) для типа процесса worker (ранее мы выбрали этот тип в Procfile), при этом происходит рестарт приложения;
10. В интерфейсе управления приложением в личном кабинете на heroku переходим к логам (прячутся под кнопкой «More» в правом верхнем углу) и убеждаемся, что приложение запущено;
11. Тестируем бота через Telegram.
Если вы храните код на GitHub, то в интерфейсе управления приложением в личном кабинете на heroku на вкладке «Deploy» вы можете в дальнейшем переключить деплой на GitHub-репозиторий (по запросу или автоматически), чтобы не пушить параллельно в два репозитория.
### Что можно доделать
Heroku периодически перезапускает приложение, и тогда введённые пользователем настройки удаляются. Можно добавить к проекту БД (например, Heroku Redis, как в [другом моём боте](https://habr.com/ru/post/646017/)), чтобы этого избежать.
Я делать этого не буду, так как обычно печатаю сразу много заданий, и каждое следующее обращение к боту в любом случае начинается с введения новых настроек. Но если кто возьмётся, буду рад проконсультировать.
### Вместо заключения
Как выяснилось, не только лишь все видели чудесный советский мультик про [козлёнка, который учился считать до 10](https://youtu.be/y6cR0n0rUoE). | https://habr.com/ru/post/528694/ | null | ru | null |
# Решение японских кроссвордов в Wolfram Mathematica
Японский кроссворд — это известная головоломка, ответом которой является рисунок. Что это такое и как это решать, можно почитать на [Википедии](http://ru.wikipedia.org/wiki/%D0%AF%D0%BF%D0%BE%D0%BD%D1%81%D0%BA%D0%B8%D0%B9_%D0%BA%D1%80%D0%BE%D1%81%D1%81%D0%B2%D0%BE%D1%80%D0%B4). Я хочу показать, как можно написать программу, которая будет решать японский кроссворд в системе Wolfram *Mathematica* путем перебора.
#### **Основные идеи**
Идея решения методом перебора заключается в том, чтобы создать списки всевозможных расположений клеток для всех строк и столбцов. После этого с помощью полученных списков найти те клетки, информация о которых будет точно известна. Затем отсеять такие расположения, которые противоречат найденной информации. Интуитивно понятно, что если циклически повторять последние две процедуры, то можно найти информацию о любой клетке. Итак, задачу можно разбить на три подзадачи:
1. Составление всех возможных расположений.
2. Поиск закрашенных и незакрашенных клеток.
3. Удаление противоречащих расположений.
Поскольку Wolfram *Mathematica* создана для работы со списками, то и расположения клеток будут храниться в программе как списки. Будем обозначать информацию о клетках следующим образом:
* 1 — закрашенная клетка;
* 0 — незакрашенная клетка;
* \* — клетка, о которой ничего не известно.
Например, снизу показаны эквивалентные список и расположение клеток:
#### **Составление всех возможных расположений**
##### **Немного теории**
Рассмотрим конкретный пример. Необходимо найти всевозможные расположения для таких данных:
Выше показано одно из таких расположений. Как перебрать *все возможные* расположения?
Сделаем это следующим путем. Поставим в соответствие *ключу* (цифрам слева от поля) такие группы клеток: `{{1,0}, {1,1,0}, {1,1,1}}`. Теперь создадим список, который будет хранить места, куда мы будем расставлять эти группы по порядку. В местах, куда мы будем ставить эти группы, будем хранить нули. Таким образом, получим список мест `{0,0,0,0,0}`. Расставляя группы клеток по порядку всеми способами на полученные места, как несложно убедиться, получим все требуемые расстановки для данных из задачи. Если поставить группы по порядку на места с номерами 1, 3, 4, то получится расположение из примера выше. Таким образом, получается, что все расположения равносильны [сочетаниям](http://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%87%D0%B5%D1%82%D0%B0%D0%BD%D0%B8%D0%B5) из количества мест по количеству групп. Выбирая каким-нибудь образом места, куда ставить группы, мы получаем одно из возможных расположений. Для данных из примера количество расположений равно десяти.
На вопросы «Почему в последней группе в конце нет нуля?» и «Почему мест именно пять?» сознательный читатель должен ответить сам.
##### **Реализация**
Понятно, что писать самому функцию, которая будет осуществлять перебор, особого желания нет, потому что в *Mathematica* существует встроенная функция `Subsets[list, {n}]`, которая это сделает. Она принимает список `list` как множество элементов и число `n` в качестве параметров и возвращает список подмножеств множества `list` длины `n`. Для нашего примера ее использование для перебора всех мест будет выглядеть так:
`In := Subsets[{1,2,3,4,5}, {3}]`
`Out = {{1,2,3}, {1,2,4}, {1,2,5}, {1,3,4}, {1,3,5}, {1,4,5}, {2,3,4}, {2,3,5}, {2,4,5}, {3,4,5}}`
Теперь напишем свою функцию, которая будет принимать число (длину поля `len`, для данных примера — `10`) и список (ключ `clue`, для данных примера — `{1,2,3}`) в качестве параметров и возвращать список всевозможных расположений. Будем все делать последовательно. Для начала создадим функцию, которая превращает число в список единиц. Для этого есть встроенная функция `ConstantArray[c, n]`; `c` — это элемент, которым заполняется список, а `n` — длина этого списка.
`In := ConstantArray[1, 2]`
`Out = {1, 1}`
Далее, нам нужно присоединить ноль в конец этого списка. Это делается при помощи `Append[expr, elem]`. Первый параметр — список, второй — то, что будем присоединять.
`In := Append[{1, 1}, 0]`
`Out = {1, 1, 0}`
Соберем эти две функции в одну используя такой объект, как чистая функция (pure function). Это можно сделать двумя способами: либо `Function[arg, Append[ConstantArray[1, arg], 0]`, либо короче — `Append[ConstantArray[1, #], 0]&`.
Теперь осталось применить эту функцию к каждому элементу списка, который соответствует ключу. Для этого есть очень полезная функция `Map[f, expr]`. Она применяет функцию `f` к каждому элемента списка `expr`. У нее также есть короткий вариант: `f /@ expr`.
`In := Append[ConstantArray[1, #], 0]& /@ {1, 2, 3}`
`Out = {{1,0}, {1,1,0}, {1,1,1,0}}`
Осталось только удалить ноль из последней группы. Тут поможет функция `Delete[expr, {i, j}]`. Она удалит элемент из списка `expr` с индексом `{i, j}`. Не забываем, что последний элемент имеет индекс -1.
`In := Delete[{{1,0}, {1,1,0}, {1,1,1,0}}, {-1, -1}]`
`Out = {{1,0}, {1,1,0}, {1,1,1}}`
Собранное все вместе выглядит так:
`In := groups = Delete[Append[ConstantArray[1, #], 0]& /@ clue, {-1, -1}]`
`Out = {{1,0}, {1,1,0}, {1,1,1}}`
Со списком мест все понятно, но нам понадобится функция `Total[list]`, которая суммирует элементы списка `list`.
`In := positions = ConstantArray[0, len - Total[clue] + 1]`
`Out = {0,0,0,0,0}`
Сейчас самое важное — это использование функции `Subsets`. Плюс нам понадобится функция `Range[n]`, которая возвращает список `{1, 2, ..., n}` и `Length[list]`, которая дает длину списка `list`.
`In := sub = Subsets[Range[len - Total[clue] + 1], {Length[clue]}]`
`Out = {{1,2,3}, {1,2,4}, {1,2,5}, {1,3,4}, {1,3,5}, {1,4,5}, {2,3,4}, {2,3,5}, {2,4,5}, {3,4,5}}`
Мы получили список мест, куда расставлять группы клеток. Теперь будем заниматься расстановкой. Для этого нам нужна функция `ReplacePart[expr, i->new]`, она заменяет в списке `expr` элемент с номером `i` на элемент `new`. Но для начала получим список замен, чтобы потом удобнее записать код. Это нам поможет сделать функция `MapThread[f, {a`1`, a`2`, ...}, {b`1`, b`2`, ...}]`. Результат ее выполнения будет следующим: `{f[a`1`, b`1`], f[a`2`, b`2`], ...}`. Итак, создаем список замен:
`In := rep = MapThread[Function[{x, y}, x->y], {#, groups}]& /@ sub`
`Out = {{1->{1,0}, 2->{1,1,0}, 3->{1,1,1}}, {1->{1,0}, 2->{1,1,0}, 4->{1,1,1}}, {1->{1,0}, 2->{1,1,0}, 5->{1,1,1}}, {1->{1,0}, 3->{1,1,0}, 4->{1,1,1}}, {1->{1,0}, 3->{1,1,0}, 5->{1,1,1}}, {1->{1,0}, 4->{1,1,0}, 5->{1,1,1}}, {2->{1,0}, 3->{1,1,0}, 4->{1,1,1}}, {2->{1,0}, 3->{1,1,0}, 5->{1,1,1}}, {2->{1,0}, 4->{1,1,0}, 5->{1,1,1}}, {3->{1,0}, 4->{1,1,0}, 5->{1,1,1}}}`
Финал всей затеи — это расстановка на свои места. Тут делаем `Flatten[list]`, который уберет лишние скобки:
`In := all = Flatten[ReplacePart[positions, #]]& /@ rep`
`Out = {{1,0,1,1,0,1,1,1,0,0}, {1,0,1,1,0,0,1,1,1,0}, {1,0,1,1,0,0,0,1,1,1}, {1,0,0,1,1,0,1,1,1,0}, {1,0,0,1,1,0,0,1,1,1}, {1,0,0,0,1,1,0,1,1,1}, {0,1,0,1,1,0,1,1,1,0}, {0,1,0,1,1,0,0,1,1,1}, {0,1,0,0,1,1,0,1,1,1}, {0,0,1,0,1,1,0,1,1,1}}`
Вот и все, все расстановки получены. Осталось это все объединить в один модуль для удобства и мы получим требуемую функцию.
`allPositions[len_, clue_] :=`
`Module[{groups, positions, sub, rep, all},`
`groups = Delete[Append[ConstantArray[1, #], 0]& /@ clue, {-1, -1}];`
`positions = ConstantArray[0, len - Total[clue] + 1];`
`sub = Subsets[Range[len - Total[clue] + 1], {Length[clue]}];`
`rep = MapThread[Function[{x, y}, x->y], {#, groups}]& /@ sub;`
`all = Flatten[ReplacePart[positions, #]]& /@ rep;`
`Return[all];]`
#### **Поиск закрашенных и незакрашенных клеток**
Теперь среди всего этого добра, что мы получим, используя нашу функцию, нужно извлечь информацию о клетках. Пусть мы имеем некоторый список расположений. Если найдется такое место, где во всех расположениях стоит 1 либо 0, то это дает нам право утверждать, что на этой позиции *всегда* будет закрашенная либо, соответственно, незакрашенная клетка. На мой взгляд, самая простая реализация функции, которая будет это делать, состоит в следующем: все расположения суммируются поэлементно и в полученном списке ищутся либо числа, равные количеству всех расположений, либо нули. В первом случае эти числа меняются на единицы, а во втором — нули остаются на своих местах. Все остальные элементы заменяются звездочками. Для реализации воспользуемся функцией `ReplaceAll[list, rule]`. Она заменит в списке `list` элементы в соответствии с правилами `rule`. Конструкция `x_ /; x!=0` означает «элемент `x`, такой что `x ≠ 0`».
`findInformation[list_] := ReplaceAll[Total[list], {x_ /; x!=0 && x!=Length[list] -> "*", x_ /; x==Length[list] -> 1}]`
Для нашего примера работа функции выглядит так:
`In := findInformation[allPositions[len, clue]]`
`Out = {*,*,*,*,*,*,*,1,*,*}`
Восьмая клетка во всех расположениях будет закрашенная, поэтому и во всей сетке она будет закрашенная. Об остальных клетках ничего сказать нельзя.
#### **Удаление противоречащих расположений**
Полученную информацию можно использовать для того, чтобы отсеивать расположения, которые ей противоречат. Функция `DeleteCases[expr, pattern]` будет нашим фильтром — она удаляет из списка expr все элементы, которые не удовлетворяют шаблону `pattern`. Также будет использоваться функция `Except[c]`, которая выбирает все, кроме ее параметра.
`deleteFromList[list_, test_] := DeleteCases[list, Except[ReplaceAll[test, "*"->_]]]`
Вернемся к примеру, пусть мы получили, что расположение клеток должно удовлетворять такому шаблону: `{*,*,0,0,*,1,0,*,*,*}`. Запустив нашу функцию, получим:
`In := deleteFromList[allPositions[len, clue], {"*","*",0,0,"*",1,0,"*","*","*"}]`
`Out = {{1,0,0,0,1,1,0,1,1,1}, {0,1,0,0,1,1,0,1,1,1}}`
Получилось, что из десяти расположений удовлетворяют шаблону только два.
#### **Собираем все воедино. Финальный этап**
Мы шаг за шагом создали все необходимые для решения кроссворда функции. Теперь важно все красиво собрать, чтобы получить решение. В качестве примера я использую кроссворд, взятый из киевского журнала японских кроссвордов «Релакс». Его автором является А. Леута.
Кроссворд задается в программу в виде списка ключей для строк и для столбцов.
`rows = {{1}, {2}, {4}, {3,1}, {4,1}, {12}, {9}, {4,1}, {1,1,1,1,1}, {1,1,1,1}, {1,3,1}, {2,1,1}, {9,1}, {4,5,1}, {3,4,1}, {3,5,3}, {3,1,5}, {5,1,2}, {7,3}, {4,10}, {4,3,3}, {4,2,3}, {5,2,2}, {5,3,2}, {4,1,1,2}, {3,2,2}, {2,2}, {7}, {10}, {2,6}};`
`cols = {{3}, {6}, {8}, {13}, {1,12,1}, {2,7,2,1}, {5,2,7,4}, {5,3,12}, {8,2,3,1,1,2}, {8,2,1,3}, {2,3,4,1,4}, {2,2,1,1,5,3,5}, {4,6,7,2}, {2,3,3,8,2}, {1,2,2,2}, {1,4,1}, {2}, {2}, {9}, {1}};`
Вводить размеры сетки не нужно, потому что и так их можно определить:
`rowlength = Length[cols]`
`collength = Length[rows]`
В программе рисунок будет храниться как список списков или обыкновенная матрица. Перед решением у нас нет информации вообще, поэтому каждый элемент ее будет звездочкой.
`pic = ConstantArray["*", {collength, rowlength}];`
Теперь самая громоздкая часть решения кроссворда — это наполнение списков всевозможных расположений. Тут нужно немного подождать.
`rowpos = allPositions[rowlength, #]& /@ rows;`
`colpos = allPositions[collength, #]& /@ cols;`
Когда все расположения заполнены, то можно приступать к решению. Идея такая: производится поиск по всем строкам закрашенных клеток и эти клетки записываются в основную сетку. Затем из расположений для столбцов удаляются те, которые противоречат полученной информации и ведется поиск по столбцам и т. д. Поиск будет проходить до тех пор, пока в сетке будет хотя бы одна звездочка; думаю, что работу цикла `While` объяснять не нужно. `MemberQ` в приведенном коде возвращает `True`, если в сетке имеется звездочка и `False` в противоположном случае. Также используется [транспонирование](http://ru.wikipedia.org/wiki/%D0%A2%D1%80%D0%B0%D0%BD%D1%81%D0%BF%D0%BE%D0%BD%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%B0%D1%8F_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D0%B0) (`Transpose`) для того, чтобы можно было равноправно работать как со строками, так и со столбцами. Для вывода рисунка имеется встроенная функция `ArrayPlot`, которая закрашивает клетку черным, если в ней стоит 1 и белым, если 0 (звездочка закрашивается по умолчанию в коричневый цвет). Для того, чтобы видеть, как динамически меняется рисунок в процессе решения, используется `Dynamic`.
`Dynamic[ArrayPlot[pic, Mesh->True]]`
`While[MemberQ[pic, "*", 2],`
`pic = findInformation /@ rowpos;`
`colpos = MapThread[deleteFromList, {colpos, Transpose[pic]}];`
`pic = Transpose[findInformation /@ colpos];`
`rowpos = MapThread[deleteFromList, {rowpos, pic}];]`
В результате получается вот такой рисунок:
Возможно, кто-то заметил, что решение является весьма неоптимальным. Да, это так, но не в оптимальности дело. Цель статьи — показать, что средствами Wolfram *Mathematica* можно удобно и быстро решить такую задачу. Но если уже говорить об оптимальности, то для этой задачи есть много способов оптимизации алгоритма, например, проводить отсеивание и поиск информации только в тех столбцах и строках, информация о клетках которых добавилась на предыдущем шагу, в данной версии программы поиск осуществляется во всех столбцах и строках. | https://habr.com/ru/post/204784/ | null | ru | null |
# Операции сравнения в C++20
Встреча в Кёльне прошла, стандарт C++20 приведён к более или менее законченному виду (по крайней мере до появления особых примечаний), и я хотел бы рассказать об одном из грядущих нововведений. Речь пойдёт о механизме, который обычно называют *operator<=>* (стандарт определяет его как «оператор трёхстороннего сравнения», но у него есть неформальное прозвище «космический корабль»), однако я считаю, что область его применения гораздо шире.
У нас не просто будет новый оператор — семантика сравнений претерпит существенные изменения на уровне самого языка.
Даже если ничего больше вы из этой статьи не вынесете, запомните эту таблицу:
| | | |
| --- | --- | --- |
| | **Равенство** | **Упорядочение** |
| **Базовые** | *==* | *<=>* |
| **Производные** | *!=* | *<*, *>*, *<=*, *>=* |
Теперь у нас будет новый оператор, *<=>*, но, что ещё важнее, операторы теперь систематизированы. Есть базовые операторы и есть производные операторы — каждая группа обладает своими возможностями.
Об этих возможностях мы поговорим коротко во вступлении и рассмотрим подробнее в следующих разделах.
Базовые операторы могут быть [**обращены**](https://brevzin.github.io/c++/2019/07/28/comparisons-cpp20/#reversing-primary-operators) (т.е. переписаны с обратным порядком параметров). Производные операторы могут быть [**переписаны**](https://brevzin.github.io/c++/2019/07/28/comparisons-cpp20/#rewriting-secondary-operators) через соответствующий базовый оператор. Ни обращённые, ни переписанные кандидаты не порождают новых функций, они просто являются заменами на уровне исходного кода и отбираются из [**расширенного набора кандидатов**](https://brevzin.github.io/c++/2019/07/28/comparisons-cpp20/#specific-lookup-rules). Например, выражение *a < 9* теперь может вычисляться как *a.operator<=>(9) < 0*, а выражение *10 != b* — как *!operator==(b, 10)*. Это значит, что можно будет обойтись одним или двумя операторами там, где для достижения того же поведения сейчас требуется вручную написать 2, 4, 6 или даже 12 операторов. [Краткий](https://brevzin.github.io/c++/2019/07/28/comparisons-cpp20/#summary-of-rules) обзор правил будет представлен ниже вместе с таблицей всех возможных преобразований.
И базовые, и производные операторы можно определять в качестве используемых [**по умолчанию**](https://brevzin.github.io/c++/2019/07/28/comparisons-cpp20/#defaulting-comparisons). В случае базовых операторов это означает, что оператор будет применяться к каждому члену в порядке объявления; в случае производных операторов — что будут использоваться переписанные кандидаты.
Следует отметить, что не существует такого преобразования, при котором оператор одного вида (т.е. равенства или упорядочения) мог бы выражаться через оператор другого вида. Иными словами, столбцы в нашей таблице никак не зависят друг от друга. Выражение *a == b* никогда не будет вычисляться как *operator<=>(a, b) == 0* неявно (но, разумеется, ничто не мешает вам определить свой *operator==* через *operator<=>*, если захочется).
Рассмотрим небольшой пример, в котором покажем, как выглядит код до и после применения нового функционала. Мы напишем тип строки, не учитывающий регистр, *CIString*, объекты которого могут сравниваться как друг с другом, так и с *char const\**.
В C++17 для нашей задачи потребуется написать 18 функций сравнения:
```
class CIString {
string s;
public:
friend bool operator==(const CIString& a, const CIString& b) {
return a.s.size() == b.s.size() &&
ci_compare(a.s.c_str(), b.s.c_str()) == 0;
}
friend bool operator< (const CIString& a, const CIString& b) {
return ci_compare(a.s.c_str(), b.s.c_str()) < 0;
}
friend bool operator!=(const CIString& a, const CIString& b) {
return !(a == b);
}
friend bool operator> (const CIString& a, const CIString& b) {
return b < a;
}
friend bool operator>=(const CIString& a, const CIString& b) {
return !(a < b);
}
friend bool operator<=(const CIString& a, const CIString& b) {
return !(b < a);
}
friend bool operator==(const CIString& a, const char* b) {
return ci_compare(a.s.c_str(), b) == 0;
}
friend bool operator< (const CIString& a, const char* b) {
return ci_compare(a.s.c_str(), b) < 0;
}
friend bool operator!=(const CIString& a, const char* b) {
return !(a == b);
}
friend bool operator> (const CIString& a, const char* b) {
return b < a;
}
friend bool operator>=(const CIString& a, const char* b) {
return !(a < b);
}
friend bool operator<=(const CIString& a, const char* b) {
return !(b < a);
}
friend bool operator==(const char* a, const CIString& b) {
return ci_compare(a, b.s.c_str()) == 0;
}
friend bool operator< (const char* a, const CIString& b) {
return ci_compare(a, b.s.c_str()) < 0;
}
friend bool operator!=(const char* a, const CIString& b) {
return !(a == b);
}
friend bool operator> (const char* a, const CIString& b) {
return b < a;
}
friend bool operator>=(const char* a, const CIString& b) {
return !(a < b);
}
friend bool operator<=(const char* a, const CIString& b) {
return !(b < a);
}
};
```
В C++20 можно обойтись всего лишь 4 функциями:
```
class CIString {
string s;
public:
bool operator==(const CIString& b) const {
return s.size() == b.s.size() &&
ci_compare(s.c_str(), b.s.c_str()) == 0;
}
std::weak_ordering operator<=>(const CIString& b) const {
return ci_compare(s.c_str(), b.s.c_str()) <=> 0;
}
bool operator==(char const* b) const {
return ci_compare(s.c_str(), b) == 0;
}
std::weak_ordering operator<=>(const char* b) const {
return ci_compare(s.c_str(), b) <=> 0;
}
};
```
Я расскажу, что всё это значит, подробнее, но сначала давайте немного вернёмся в прошлое и вспомним, как работали сравнения до стандарта C++20.
Сравнения в стандартах с C++98 по C++17
---------------------------------------
Операции сравнения почти не менялись с момента создания языка. У нас было шесть операторов: *==*, *!=*, *<*, *>*, *<=* и *>=*. Стандарт определяет каждый из них для встроенных типов, но в целом они подчиняются одним и тем же правилам. При вычислении любого выражения *a @ b* (где *@* — один из шести операторов сравнения) компилятор ищет функции-члены, свободные функции и встроенные кандидаты с именем *operator@*, которые могут быть вызваны с типом *A* или *B* в указанном порядке. Из них выбирается самый подходящий кандидат. Вот и всё. По сути, *все* операторы работали одинаково: операция *<* не отличалась от *<<*.
Такой простой набор правил легко усвоить. Все операторы абсолютно независимы и эквивалентны. Неважно, что мы, люди, знаем о фундаментальном отношении между операциями *==* и *!=*. С точки зрения языка, это одно и то же. Мы же используем идиомы. Например, мы определяем оператор *!=* через *==*:
```
bool operator==(A const&, A const&);
bool operator!=(A const& lhs, A const& rhs) {
return !(lhs == rhs);
}
```
Аналогично, через оператор *<* мы определяем все остальные операторы отношения. Мы пользуемся этими идиомами, потому что, несмотря на правила языка, мы на самом деле не считаем все шесть операторов эквивалентными. Мы принимаем, что два из них являются базовыми (*==* и *<*), а через них уже выражаются все остальные.
В самом деле, стандартная библиотека шаблонов (Standard Template Library) целиком построена на этих двух операторах, и огромное количество типов в эксплуатируемом коде содержит определения только одного из них или их обоих.
Однако оператор *<* не очень-то подходит на роль базового по двум причинам.
Во-первых, через него нельзя гарантированно выразить другие операторы отношения. Да, *a > b* означает ровно то же, что *b < a*, но неверно, что *a <= b* значит ровно то же, что *!(b < a)*. Последние два выражения будут эквивалентны, если имеется свойство трихотомии, при котором для любых двух значений верно только одно из трёх утверждений: *a < b*, *a == b* или *a > b*. При наличии трихотомии выражение *a <=b* означает, что мы имеем дело либо с первым, либо со вторым случаем… а это эквивалентно утверждению, что мы не имеем дела с третьим случаем. Поэтому *(a <= b) == !(a > b) == !(b < a)*.
Но что если отношение не обладает свойством трихотомии? Это характерно для отношений частичного порядка. Классический пример — числа с плавающей запятой, для которых любая из операций *1.f < NaN*, *1.f == NaN* и *1.f > NaN* даёт *ложь*. Поэтому *1.f <= NaN* также даёт *ложь*, но при этом *!(NaN < 1.f)* — *правда*.
Единственный способ реализовать оператор *<=* в общем виде через базовые операторы — это расписать обе операции как *(a == b) || (a , что является большим шагом назад в том случае, если нам *всё же* придётся иметь дело с линейным порядком, поскольку тогда будет вызываться не одна функция, а две (например, выражение *«abc..xyz9» <= «abc..xyz1»* придётся переписать как *(«abc..xyz9»== «abc..xyz1») || («abc..xyz9» < «abc..xyz1»)* и дважды сравнивать всю строку целиком).
Во-вторых, оператор *<* не очень подходит на роль базового из-за особенностей его использования в лексикографических сравнениях. Программисты часто допускают такую ошибку:
```
struct A {
T t;
U u;
bool operator==(A const& rhs) const {
return t == rhs.t &&
u == rhs.u;
}
bool operator< (A const& rhs) const {
return t < rhs.t &&
u < rhs.u;
}
};
```
Чтобы определить оператор == для коллекции элементов, достаточно один раз применить *==* к каждому члену, но с оператором *<* так не получится. С точки зрения этой реализации, множества *A{1, 2}* и *A{2, 1}* будут считаться эквивалентными (так как ни одно из них не меньше другого). Чтобы исправить это, следует применить оператор *<* дважды к каждому члену, кроме последнего:
```
bool operator< (A const& rhs) const {
if (t < rhs.t) return true;
if (rhs.t < t) return false;
return u < rhs.u;
}
```
Наконец, чтобы гарантировать правильную работу сравнений разнотипных объектов — т.е. гарантировать, что выражения *a == 10* и *10 == a* означают одно и то же, — обычно рекомендуют писать сравнения как свободные функции. На самом деле это вообще единственный способ реализовать такие сравнения. Это неудобно, потому что, во-первых, придётся следить за соблюдением этой рекомендации, а во-вторых, обычно такие функции приходится объявлять скрытыми друзьями для более удобной реализации (т.е. внутри тела класса).
Заметим, что не всегда при сравнениях разнотипных объектов требуется писать именно *operator==(X, int)*; они могут также подразумевать случаи, когда *int* может неявно приводиться к *X*.
Подведём итоги по правилам до стандарта C++20:
* Все операторы обрабатываются одинаково.
* Мы используем идиомы для облегчения реализации. Операторы *==* и *<* мы принимаем за базовые идиомы и выражаем остальные операторы отношения через них.
* Вот только оператор *<* не очень подходит на роль базового.
* Важно (и рекомендовано) писать сравнения разнотипных объектов как свободные функции.
Новый базовый оператор упорядочения: <=>
----------------------------------------
Самое значительное и заметное изменение в работе сравнений в C++20 — это добавление нового оператора — *operator<=>*, оператора трёхстороннего сравнения.
С трёхсторонними сравнениями мы уже знакомы по функциям *memcmp*/*strcmp* в C и *basic\_string::compare()* в C++. Все они возвращают значение типа *int*, которое представлено произвольным положительным числом, если первый аргумент больше второго, *0* — если они равны, и произвольным отрицательным числом в противном случае.
Оператор «космический корабль» возвращает не значение типа *int*, а объект, принадлежащий к одной из категорий сравнения, чьё значение отражает вид отношения между сравниваемыми объектами. Существует три основных категории:
* *strong\_ordering*: отношение линейного порядка, при котором равенство подразумевает взаимозаменяемость элементов (т.е. *(a <=> b) == strong\_ordering::equal* подразумевает, что для всех подходящих функций *f* имеет место *f(a) == f(b)*. Термину «подходящая функция» намеренно не даётся чёткого определения, но к таковым не относятся функции, которые возвращают адреса своих аргументов или *capacity()* вектора и т.п. Нас интересуют только «существенные» свойства, что тоже очень расплывчато, но можно условно считать, что речь идёт о *значении* типа. Значение вектора — это содержащиеся в нём элементы, но не его адрес и т.п.). Эта категория включает в себя следующие значения: *strong\_ordering::greater*, *strong\_ordering::equal* и *strong\_ordering::less*.
* *weak\_ordering*: отношение линейного порядка, при котором равенство определяет лишь некоторый класс эквивалентности. Классический пример — нечувствительное к регистру сравнение строк, когда два объекта могут быть *weak\_ordering::equivalent*, но не равны в строгом смысле (этим объясняется замена слова *equal* на *equivalent* в имени значения).
* *partial\_ordering*: отношение частичного порядка. В этой категории к значениям *greater*, *equivalent* и *less* (как в *weak\_ordering*) добавляется ещё одно — *unordered* («неупорядоченно»). С его помощью можно выражать отношения частичного порядка в системе типов: *1.f <=> NaN* даёт значение *partial\_ordering::unordered*.
В основном вы будете работать с категорией *strong\_ordering*; это также оптимальная категория для использования по умолчанию. Например, *2 <=> 4* возвращает *strong\_ordering::less*, а *3 <=> -1* — *strong\_ordering::greater*.
Категории более сильного порядка могут неявно приводиться к категориям более слабого порядка (т.е. *strong\_ordering* приводимо к *weak\_ordering*). При этом текущий вид отношения сохраняется (т.е. *strong\_ordering::equal* превращается в *weak\_ordering::equivalent*).
Значения категорий сравнения можно сравнивать с литералом *0* (не с любым *int* и не с *int*, равным *0*, а просто с литералом *0*) с помощью одного из шести операторов сравнения:
```
strong_ordering::less < 0 // true
strong_ordering::less == 0 // false
strong_ordering::less != 0 // true
strong_ordering::greater >= 0 // true
partial_ordering::less < 0 // true
partial_ordering::greater > 0 // true
// unordered - особое значение, которое невозможно
// сравнить ни с каким другим значением
partial_ordering::unordered < 0 // false
partial_ordering::unordered == 0 // false
partial_ordering::unordered > 0 // false
```
Именно благодаря сравнению с литералом *0* мы можем реализовывать операторы отношения: *a @ b* эквивалентно *(a <=> b) @ 0* для каждого из таких операторов.
Например, *2 < 4* можно вычислить как *(2 <=> 4) < 0*, что превращается в *strong\_ordering::less < 0* и даёт значение *true*.
На роль базового элемента оператор *<=>* подходит намного лучше, чем оператор *<*, поскольку он избавлен от обеих проблем последнего.
Во-первых, выражение *a <= b* гарантированно эквивалентно *(a <=> b) <= 0* даже при частичном порядке. Для двух неупорядоченных значений *a <=> b* даст значение *partial\_ordered::unordered*, а *partial\_ordered::unordered <= 0* даст *false*, что нам и требуется. Это возможно потому, что *<=>* может вернуть больше разновидностей значений: так, категория *partial\_ordering* содержит четыре возможных значения. Значение типа *bool* может быть только *true* или *false*, поэтому раньше мы не могли различать сравнения упорядоченных и неупорядоченных значений.
Для большей ясности рассмотрим пример отношения частичного порядка, не связанный с числами с плавающей запятой. Допустим, мы хотим добавить типу *int* состояние NaN, где NaN — это просто значение, которое не образует упорядоченной пары ни с одним задействованным значением. Сделать это можно, используя для его хранения *std::optional*:
```
struct IntNan {
std::optional val = std::nullopt;
bool operator==(IntNan const& rhs) const {
if (!val || !rhs.val) {
return false;
}
return \*val == \*rhs.val;
}
partial\_ordering operator<=>(IntNan const& rhs) const {
if (!val || !rhs.val) {
// состояние unordered можно выразить
// как значение первого класса
return partial\_ordering::unordered;
}
// <=> возвращает значение strong\_ordering для int,
// но оно может быть неявно приведено к partial\_ordering
return \*val <=> \*rhs.val;
}
};
IntNan{2} <=> IntNan{4}; // partial\_ordering::less
IntNan{2} <=> IntNan{}; // partial\_ordering::unordered
// принцип работы этих операций см. в следующем разделе
IntNan{2} < IntNan{4}; // true
IntNan{2} < IntNan{}; // false
IntNan{2} == IntNan{}; // false
IntNan{2} <= IntNan{}; // false
```
Оператор *<=* возвращает правильное значение потому, что теперь мы можем выразить больше информации на уровне самого языка.
Во-вторых, чтобы получить всю необходимую информацию, достаточно один раз применить *<=>*, что облегчает реализацию лексикографического сравнения:
```
struct A {
T t;
U u;
bool operator==(A const& rhs) const {
return t == rhs.t &&
u == rhs.u;
}
strong_ordering operator<=>(A const& rhs) const {
// выполняем трёхстороннее сравнение
// элементов t. Если результат != 0 (т.е. элементы t
// различаются), это будет результат
// всего сравнения
if (auto c = t <=> rhs.t; c != 0) return c;
// в противном случае сравниваем
// следующую пару элементов
return u <=> rhs.u;
};
```
Более подробный разбор см. в [P0515](https://wg21.link/p0515) — исходном предложении по добавлению *operator<=>.*
Новые возможности операторов
----------------------------
Мы не просто получаем в своё распоряжение новый оператор. В конце концов, если бы показанный выше пример с объявлением структуры *A* говорил лишь о том, что вместо *x < y* теперь придётся всякий раз писать *(x <=> y) < 0*, это никому бы не понравилось.
Механизм разрешения сравнений в C++20 заметно отличается от старого подхода, но это изменение напрямую связано с новой концепцией двух базовых операторов сравнения: *==* и *<=>*. Если раньше это была идиома (запись через *==* и *<*), которой пользовались мы, но о которой не знал компилятор, то теперь и он будет понимать это различие.
Ещё раз приведу таблицу, которую вы уже видели в начале статьи:
| | | |
| --- | --- | --- |
| | **Равенство** | **Упорядочение** |
| **Базовые** | *==* | *<=>* |
| **Производные** | *!=* | *<*, *>*, *<=*, *>=* |
Каждый из базовых и производных операторов получил новую способность, о чём я скажу пару слов далее.
### Обращение базовых операторов
В качестве примера возьмём тип, который может сравниваться только с *int*:
```
struct A {
int i;
explicit A(int i) : i(i) { }
bool operator==(int j) const {
return i == j;
}
};
```
С точки зрения старых правил, нет ничего удивительного в том, что выражение *a == 10* работает и вычисляется как *a.operator==(10)*.
Но как насчёт *10 == a*? В C++17 это выражение считалось бы явной синтаксической ошибкой. Не существует такого оператора. Чтобы такой код заработал, пришлось бы писать симметричный *operator==*, который бы сначала брал значение *int*, а затем *A*… а реализовывать это пришлось бы в виде свободной функции.
В C++20 базовые операторы могут быть обращены. Для *10 == a* компилятор найдёт кандидат *operator==(A, int)* (на самом деле это функция-член, но для наглядности я пишу её здесь как свободную функцию), а затем дополнительно — вариант с обратным порядком параметров, т.е. *operator==(int, A)*. Этот второй кандидат совпадает с нашим выражением (причём идеально), так что его мы и выберем. Выражение *10 == a* в C++20 вычисляется как *a.operator==(10)*. Компилятор понимает, что равенство симметрично.
Теперь расширим наш тип так, чтобы его можно было сравнивать с *int* не только через оператор равенства, но и через оператор упорядочения:
```
struct A {
int i;
explicit A(int i) : i(i) { }
bool operator==(int j) const {
return i == j;
}
strong_ordering operator<=>(int j) const {
return i <=> j;
}
};
```
Опять же, выражение *a <=> 42* работает прекрасно и вычисляется по старым правилам как *a.operator<=>(42)*, но вот *42<=>* a было бы неправильно с точки зрения C++17, даже если бы оператор *<=>* уже существовал в языке. Но в C++20 *operator<=>*, как и *operator==*, симметричен: он распознаёт обращённые кандидаты. Для *42 <=>* a будет найдена функция-член *operator<=>(A, int)* (опять же, я пишу её здесь как свободную функцию просто для большей наглядности), а также синтетический кандидат *operator<=>(int, A)*. Этот обращённый вариант точно соответствует нашему выражению — его и выбираем.
Однако *42 <=>* *a* вычисляется НЕ как *a.operator<=>(42)*. Так было бы неправильно. Это выражение вычисляется как *0 <=> a.operator<=>(42)*. Попробуйте сами догадаться, почему эта запись — правильная.
Важно отметить, что никаких новых функций компилятор не создаёт. При вычислении *10 == a* не появился новый оператор *operator==(int, A)*, а при вычислении *42 <=> a* не появился *operator<=>(int, A)*. Просто два выражения переписаны через обращённые кандидаты. Повторю: никаких новых функций не создаётся.
Также обратите внимание, что запись с обратным порядком параметров доступна только для базовых операторов, а для производных — нет. То есть:
```
struct B {
bool operator!=(int) const;
};
b != 42; // ok и в C++17, и в C++20
42 != b; // ошибка и в C++17, и в C++20
```
### Переписывание производных операторов
Вернёмся к нашему примеру со структурой *A*:
```
struct A {
int i;
explicit A(int i) : i(i) { }
bool operator==(int j) const {
return i == j;
}
strong_ordering operator<=>(int j) const {
return i <=> j;
}
};
```
Возьмём выражение *a != 17*. В C++17 это синтаксическая ошибка, потому что не существует оператора *operator!=*. Однако в C++20 для выражений, содержащих производные операторы сравнения, компилятор будет также искать соответствующие им базовые операторы и выражать через них производные сравнения.
Мы знаем, что в математике операция *!=* по сути означает НЕ *==*. Теперь это известно и компилятору. Для выражения *a!= 17* он будет искать не только операторы *operator!=*, но и *operator==* (а также, как в предыдущих примерах, обращённые *operator==*). Для данного примера мы нашли оператор равенства, который нам почти подходит, — нужно только переписать его в соответствии с желаемой семантикой: *a != 17* будет вычисляться как *!(a == 17)*.
Аналогично, *17 !=* a вычисляется как *!a.operator==(17)*, что является одновременно и переписанным, и обращённым вариантом.
Похожие преобразования проводятся и для операторов упорядочения. Если бы мы написали *a < 9*, то попытались бы (безуспешно) найти *operator<*, а также рассмотрели бы базовые кандидаты: *operator<=>*. Соответствующая замена для операторов отношения выглядит так: *a @ b* (где *@* — один из операторов отношения) вычисляется как *(a <=> b) @ 0*. В нашем случае — *a.operator<=>(9) < 0*. Аналогично, *9 <= a* вычисляется как *0 <= a.operator<=>(9)*.
Заметим, что, как и в случае с обращением, компилятор не создаёт никаких новых функций для переписанных кандидатов. Они просто по-другому вычисляются, а все трансформации проводятся только на уровне исходного кода.
Вышесказанное приводит меня к следующему совету:
***ТОЛЬКО БАЗОВЫЕ ОПЕРАТОРЫ****: В своём типе определяйте только базовые операторы (== и <=>).*
Поскольку базовые операторы дают весь набор сравнений, то и определять достаточно только их. Это значит, что вам понадобится только 2 оператора для сравнения однотипных объектов (вместо 6, как сейчас) и только 2 оператора для сравнения разнотипных объектов (вместо 12). Если вам нужна только операция равенства, то достаточно написать 1 функцию для сравнения однотипных объектов (вместо 2) и 1 функцию для сравнения разнотипных объектов (вместо 4). Класс *std::sub\_match* представляет собой крайний случай: в C++17 в нём используется 42 оператора сравнения, а в C++20 — только 8, при этом функциональность никак не страдает.
Так как компилятор рассматривает также обращённые кандидаты, все эти операторы можно будет реализовывать как функции-члены. Больше не придётся писать свободные функции только ради сравнения разнотипных объектов.
### Особые правила поиска кандидатов
Как я уже упоминал, поиск кандидатов для *a @ b* в C++17 происходил по следующему принципу: находим все операторы *operator@* и выбираем из них наиболее подходящий.
В C++20 используется расширенный набор кандидатов. Теперь мы будем искать все *operator@*. Пусть *@@* — это базовый оператор для *@* (это может быть один и тот же оператор). Мы также находим все *operator@@* и для каждого из них добавляем его обращённую версию. Из всех этих найденных кандидатов выбираем наиболее подходящий.
Заметьте, что перегрузка оператора разрешается за **один-единственный** проход. Мы не пытаемся подставлять разные кандидаты. Сначала мы собираем их все, а затем выбираем из них наилучший. Если такого не существует, поиск, как и раньше, заканчивается неудачей.
Теперь у нас гораздо больше потенциальных кандидатов, а значит и больше неопределённости. Рассмотрим следующий пример:
```
struct C {
bool operator==(C const&) const;
bool operator!=(C const&) const;
};
bool check(C x, C y) {
return x != y;
}
```
В C++17 у нас был только один кандидат для *x != y*, а теперь их три: *x.operator!=(y)*, *!x.operator==(y)* и *!y.operator==(x)*. Что же выбрать? Они все равнозначны! (Примечание: кандидата *y.operator!=(x)* не существует, так как обращать можно только базовые операторы.)
Для снятия этой неопределённости введены два дополнительных правила. Необращённые кандидаты предпочтительнее обращённых; непереписанные кандидаты предпочтительнее переписанных. Тогда получается, что *x.operator!=(y)* «главнее» *!x.operator==(y)*, а тот «главнее» *!y.operator==(x)*. Этот принцип согласуется со стандартными правилами, по которым «побеждает» наиболее точный вариант.
Ещё одно замечание: на этапе поиска нас не интересует тип возвращаемого значения кандидатов *operator@@*. Мы просто находим их. Нас интересует только, являются ли они наилучшим выбором или нет.
Неудачный исход при поиске теперь тоже выглядит по-другому. Если наилучший кандидат — переписанный или обращённый (например, мы написали *x < y*, а наилучший кандидат — это *(x <=> y) < 0*), но корректно переписать или обратить сравнение невозможно (например, *x <=> y* возвращает *void* или какой-то иной тип, потому что мы вообще пишем на DSL), то программа считается некорректной. Возвращаться и искать другой подходящий вариант мы уже не будем. В случае с операцией равенства мы принимаем, что никакой тип возвращаемого значения кроме *bool* не совместим с переписанными кандидатами (логика здесь такая: если *operator==* не возвращает *bool*, можем ли мы считать такую операцию операцией равенства?)
Например:
```
struct Base {
friend bool operator<(const Base&, const Base&); // #1
friend bool operator==(const Base&, const Base&);
};
struct Derived : Base {
friend void operator<=>(const Derived&, const Derived&); // #2
};
bool f(Derived d1, Derived d2) {
return d1 < d2;
}
```
Для выражения *d1 < d2* будут найдены два кандидата: *#1* и *#2*. Наилучший вариант — *#2*, так как он является точным совпадением, значит, его и выбираем. Поскольку это переписанный кандидат, то *d1 < d2* вычисляется как *(d1 <=> d2) < 0*. Но это некорректное выражение, ведь нельзя сравнивать *void* с *0* — значит, и всё сравнение некорректно. Заметьте, что после этой неудачи мы уже не будем совершать какие-либо действия, чтобы выбрать кандидат *#1*.
### Краткий обзор правил
Очевидно, что эти правила сложнее тех, что были в C++17, но я привожу их полностью в этом небольшом разделе. Здесь не будет сносок, посвящённых каким-то особым случаям или исключениям. Просто запомните самые главные принципы:
* Обращение доступно только для базовых операторов
* Переписываться могут только производные операторы (через соответствующие базовые)
* При поиске кандидатов за один проход ищутся все операторы с данным именем, а также все их обращённые и переписанные версии
* Если наилучший кандидат является переписанной или обращённой версией и при этом такая замена является недопустимой, программа считается некорректной.
Если вы будете следовать этому совету и определять **ТОЛЬКО БАЗОВЫЕ ОПЕРАТОРЫ**, вам и не придётся беспокоиться обо всём этом. Все ваши сравнения будут работать.
Для ясности я привожу таблицу со всеми возможными преобразованиями на уровне исходного кода. В каждом случае выражение в первом столбце имеет больший приоритет, чем выражение во втором, а то, в свою очередь, имеет больший приоритет, чем выражение в третьем столбце (при прочих равных условиях). Обратите внимание, что второй и третий столбцы содержат только базовые операторы:
| | | |
| --- | --- | --- |
| **Исходная операция** | **Вариант 1** | **Вариант 2** |
| *a == b* | *b == a* | |
| *a != b* | *!(a == b)* | *!(b == a)* |
| *a <=> b* | *0 <=> (b <=> a)* | |
| *a < b* | *(a <=> b) < 0* | *(b <=> a) > 0* |
| *a <= b* | *(a <=> b) <= 0* | *(b <=> a) >= 0* |
| *a > b* | *(a <=> b) > 0* | *(b <=> a) < 0* |
| *a >= b* | *(a <=> b) >= 0* | *(b <=> a) <= 0* |
Варианты с «космическим кораблём» в правом столбце обычно пишутся с тем же оператором, что и в исходной версии, т.е. *a < b* пишется как *0 < (b <=> a)*, но я написал их с противоположными знаками, чтобы нагляднее показать, как меняется знак в переписанной версии.
### Определение сравнений для использования по умолчанию
Среди прочего в C++17 раздражает необходимость подробно расписывать поэлементные лексикографические сравнения. Это занятие утомительно и чревато ошибками. Напишем полный набор операторов для линейно упорядоченного типа с тремя членами:
```
struct A {
T t;
U u;
V v;
bool operator==(A const& rhs) const {
return t == rhs.t &&
u == rhs.u &&
v == rhs.v;
}
bool operator!=(A const& rhs) const {
return !(*this == rhs);
}
bool operator< (A const& rhs) const {
// я предпочитаю этот стиль, потому что так сложнее ошибиться,
// чем если использовать вложенные ?: или &&/||
if (t < rhs.t) return true;
if (rhs.t < t) return false;
if (u < rhs.u) return true;
if (rhs.u < u) return false;
return v < rhs.v;
}
bool operator> (A const& rhs) const {
return rhs < *this;
}
bool operator<=(A const& rhs) const {
return !(rhs < *this);
}
bool operator>=(A const& rhs) const {
return !(*this < rhs);
}
};
```
Ещё лучше было бы использовать какой-нибудь *std::tie()*, но это всё равно утомительно.
Теперь давайте попробуем написать ту же структуру, следуя моему совету: определять только базовые операторы:
```
struct A {
T t;
U u;
V v;
bool operator==(A const& rhs) const {
return t == rhs.t &&
u == rhs.u &&
v == rhs.v;
}
strong_ordering operator<=>(A const& rhs) const {
// сравниваем элементы T
if (auto c = t <=> rhs.t; c != 0) return c;
// ... теперь U
if (auto c = u <=> rhs.u; c != 0) return c;
// ... теперь V
return v <=> rhs.v;
}
};
```
Тут не просто меньше кода. Сама реализация *<=>* гораздо проще для понимания по сравнению с реализацией *<*. Она очевидней, поскольку полное сравнение можно выполнить за один проход. Проверки *c != 0* не дадут нам продолжить, если мы обнаружим пару неравных значений, и каким бы отношением ни было выражено это неравенство (*меньше* или *больше*), это будет окончательный результат сравнения.
В итоге получается обычное поэлементное лексикографическое сравнение *по умолчанию*. А в C++20 достаточно просто сказать компилятору, что мы хотим:
```
struct A {
T t;
U u;
V v;
bool operator==(A const& rhs) const = default;
strong_ordering operator<=>(A const& rhs) const = default;
};
```
Нужно явно указать, какие операторы сравнения должен сгенерировать компилятор по умолчанию. Наш код можно ещё упростить, если категорию сравнения определять автоматически:
```
struct A {
T t;
U u;
V v;
bool operator==(A const& rhs) const = default;
auto operator<=>(A const& rhs) const = default;
};
```
Можно пойти ещё дальше. В типичном сценарии, когда требуется обычное поэлементное сравнение на равенство и отношение, достаточно определить только один оператор:
```
struct A {
T t;
U u;
V v;
auto operator<=>(A const& rhs) const = default;
};
```
Это единственный случай, когда компилятор сгенерирует оператор сравнения, который вы сами не писали. Последние два варианта абсолютно идентичны: у нас есть и заданный по умолчанию *operator==*, и заданный по умолчанию *operator<=>*.
Темы будущих статей
-------------------
В этой статье мы рассмотрели основы сравнений в C++20: как работают синтетические кандидаты и как они находятся. Мы также коротко рассмотрели трёхстороннее сравнение и особенности его реализации. У меня в запасе есть ещё несколько интересных тем, которые тоже стоит осветить, но я стараюсь писать не слишком длинные статьи, так что ждите новых постов.
Примечание переводчика
----------------------
Команда PVS-Studio с интересом познакомилась с этой статьей, так как нам в ближайшее время предстоит реализовать поддержку нового оператора <=> в анализаторе. А поскольку статья очень полезная и хорошо всё объясняет, мы решили сделать её перевод для хабра-сообщества. На наш взгляд, это очень нужное нововведение языка, так как по нашему опыту операторы сравнения очень часто содержат ошибки (см. статью "[Зло живёт в функциях сравнения](https://habr.com/ru/company/pvs-studio/blog/329090/)"). Теперь С++ программистам жить станет проще и ошибок данного типа будет меньше.
Заодно возникла идея создать в PVS-Studio новую диагностику для поиска некорректно написанных операторов <, которые были описаны в статье:
```
bool operator< (A const& rhs) const {
return t < rhs.t && u < rhs.u;
}
```
Подобный код может присутствовать в старых больших проектах. Возможно, и ещё какие-то диагностики сделаем. Надо подумать.
Первоисточник: [Comparisons in C++20](https://brevzin.github.io/c++/2019/07/28/comparisons-cpp20/).* | https://habr.com/ru/post/465575/ | null | ru | null |
# Перехватываем запуск любого приложения в Windows и пытаемся ничего не сломать
Если вы много занимаетесь отладкой приложений под Windows — вы, возможно, слышали о таком замечательном механизме, как [Image File Execution Options](https://msdn.microsoft.com/en-us/library/a329t4ed(v=vs.100).aspx) (**IFEO**). Одна из предоставляемых им возможностей позволяет отлаживать приложение в условиях, более приближенных к боевым. Записав в нужное место в реестре специальный ключик, мы можем вместо программы автоматически запускать её отладчик, позволяя ему делать свои отладочные дела. Однако кто сказал, что этот механизм (фактически — перехвата запуска чего угодно) можно использовать только в подобных целях? Эта статья вовсе не об использовании вещей по назначению.
Под катом рассказ о том, как я попытался выжать побольше из этого механизма в своих добрых целях, и какие подводные камни мне встретились на пути. А у меня тут хорошие, отборные камни.
> Вообще говоря, идея эта не нова. Я знаю как минимум три программы, которые используют этот механизм для не-отладочных целей: широко известные [Process Explorer](https://docs.microsoft.com/en-us/sysinternals/downloads/process-explorer) и [Process Hacker](https://wj32.org/processhacker/index.php) — для замены стандартного диспетчера задач; и [AkelPad](http://akelpad.sourceforge.net/ru/index.php) — для замены блокнота. Но я решил пойти немного дальше.
**Итак, что мы имеем:** мы можем запустить свою программу вместо любой другой наперёд заданной, если заранее пропишем себя в реестре. Причём не особо важно кто, как, и с какими правами будет её запускать.
Что можно полезного сделать, обладая такими возможностями? Первое, что пришло мне в голову: спросить пользователя — а действительно ли он хочет, чтобы этот процесс запускался? Быстро разобравшись, как прописать себя в IFEO я смастерил крохотную утилиту с диалоговым окошком и кнопками Да/Нет, которая запускает перехваченную программу только при согласии пользователя. Сразу после запуска я осознал всю глубину своей наивности. Уже догадываетесь, что произошло при выборе «Да»? Конечно же, я снова запустил себя и получил новое окно с запросом подтверждения, и здесь можно продолжать до бесконечности. Перехват сработал отлично.
Не уверен, насколько полезным оказался бы этот механизм, если бы не было возможность его обойти: отладчику-то нужно запустить отлаживаемый процесс. Так что в Image File Execution Options есть одно исключение. Начнём с того, что в пользовательском режиме есть всего два метода запуска процессов: [CreateProcess](https://msdn.microsoft.com/en-us/library/windows/desktop/ms682425(v=vs.85).aspx) и [ShellExecuteEx](https://msdn.microsoft.com/en-us/library/windows/desktop/bb762154(v=vs.85).aspx). Да и то, второй, в конце концов, тоже вызывает CreateProcess, но об этом позже. Так вот, исключение же это заключается в том, что запуски процессов с флагом DEBUG\_PROCESS не перехватывается. Это и решает проблему с отладчиками, но, в моём случае, это также означает, что на IFEO нельзя полагаться полностью. И тем не менее, я не знаю ни одной программы (кроме отладчиков, разумеется), которые пользовались бы этим флагом. Нельзя просто поставить этот флаг и наслаждаться: понадобится дополнительный код, чтобы всё заработало.
### Регистрация файла в IFEO
Если вы проследите с помощью [Process Monitor](https://docs.microsoft.com/en-us/sysinternals/downloads/procmon)'а за тем, что происходит при вызове функции CreateProcess — вы, вероятно, найдёте много чего интересного. Помимо коррекции ошибок в имени файла, о которой мы поговорим чуть позже, вы обнаружите обращение в реестр за настройками IFEO. Как это выглядит:
Если этот ключ будет найден, то также будет проверено наличие определённых полей, в том числе строкового поля **Debugger**. Оно-то нам и нужно. В нём хранится путь к отладчику, или, в нашем случае, к программе, запускаемой вместо данной.
```
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution
Options\YourExecutable.exe]
"Debugger" = "C:\Path-to-debugger\Debugger.exe"
```
Стоит заметить, что здесь есть свои ограничения:
* Проверяется исключительно имя исполняемого файла. Это значит — никаких масок. Нельзя просто взять, и перехватить вызов **\*.exe**.
* Действие для всех программ с одинаковым именем исполняемого файла будет одинаковым. До тех пор, пока мы не воспользуемся ключом **UseFilter**. Тогда, да, можно назначать конкретный отладчик для конкретного исполняемого файла, основываясь на его полном пути. Опять же — без масок.
**Подробности про UseFilter**
> Для использования фильтрации в ветке IFEO\YourExecutable.exe надо создать DWORD поле **UseFilter** c ненулевым значением. В этом случае, при попытке создания процесса, он обойдёт все под-ключи в данной ветке, и в каждом из них будет сверять значение строкового поля **FilterFullPath** с полным путём к исполняемому файлу. При совпадении будет запущен найденный в поле **Debugger** исполняемый файл. Если совпадений не будет найдено — будет запущен Debugger по умолчанию (то есть тот, что использовался бы без всяких фильтров).
>
>
>
> **Замечание:** любой под-ключ без поля **FilterFullPath** трактуется как совпадение, и все настройки берутся с него и имеют приоритет над теми, что были бы без фильтра.
### Назначение стандартных действий
Изначальный смысл этой затеи для меня был в том, что, узнав про IFEO, я решил написать программу, которая предлагала бы пользователю набор типичных действий (реализованных в виде маленьких утилит), назначаемых для других программ. Это было ещё до того, как я решил написать статью, осознав, сколько тут занятных вещей можно рассказать. А потому, используем эти утилиты в качестве наглядного и практического примера для повествования. Итак, на что хватило моего воображения:
* **Ask.exe** — оповещает пользователя о попытке запуска и спрашивает разрешения;
* **Deny.exe** — отказывает в запуске. При этом может как оповещать пользователя, так и делать это молча. Очень удобно, если надо запретить винде запускать какую-нибудь телеметрию
* **Elevate.exe** — всегда запрашивает UAC для повышения прав до Администратора;
* **Drop.exe** — понижает привилегии процесса. Это просто венец творения. По смыслу аналогичен утилитам DropMyRights и [PsExec](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) с флагом -ℓ. Но в сочетании с IFEO — гораздо эффективнее;
* **PowerRequest.exe** — не даёт компьютеру заснуть / погасить экран до тех пор, пока программа не завершится.
Для регистрации этих действий было написано две версии представленной на скриншоте программы: GUI и консольная. Здесь и рассказывать не о чем. Просто читаем/пишем в реестр.
Как можно догадаться из заголовка, самое интересное — это как подменить чужую программу во время исполнения, и при этом ничего не сломать. Но сперва несколько очевидных, хотя и необходимых вещей. Если уж и запускать перехваченный процесс, то надо как можно лучше воспроизвести те же условия, при которых запустили нас самих. А это значит:
* Точно такая-же структура [STARTUPINFO](https://msdn.microsoft.com/en-us/library/windows/desktop/ms686331(v=vs.85).aspx), установка флага *bInheritHandles*, и такая же рабочая директория;
* Ожидание завершения запускаемого процесса для получения его кода возврата и передачи по цепочке;
* И… ещё один трюк, о котором я расскажу чуть позже.
Хорошо. А как мы узнаем, что запускать-то?
### Оценим возможности
Пусть в IFEO в качестве отладчика для программы **A.exe** прописано следующее:
```
"C:\My-Path\B.exe" /param
```
Если кто-то попытается создать процесс "C:\Folder\**A.exe**" с параметром *-a* то будет создан процесс **B.exe** cо следующей командной строкой:
```
"C:\My-Path\B.exe" /param "C:\Folder\A.exe" -a
```
Поскольку мы сами пишем код для **B.exe** — мы без проблем разберём командную строку на составляющие части и вполне можем запустить **A.exe** с теми же параметрами, с каким его хотел запустить этот безымянный кто-то. Здесь-то у нас и появляется полноценная свобода. Хотим — запускаем с другими привилегиями, захотим — сможем и передаваемые параметры поменять.
Любопытно во всём этом вот что: как, по-вашему, реагирует на столь вольное обращение [контроль учётных записей](https://ru.wikipedia.org/wiki/User_Account_Control)? Правильный ответ: а никак. Если в проводнике выбрать «Запуск от имени Администратора» на файле **A.exe**, то в сообщении UAC будет показываться информация именно о файле **A.exe**, и именно его цифровая подпись будет определять цвет окна. А то, что вместо него будет запущен **B.exe** — это дело десятое. Нет, здесь нет особых проблем с безопасностью: запись в IFEO сама требует административных привилегий. Для нас это значит нечто иное: записав наши утилиты в IFEO мы **вообще** не будем смущать пользователя неверными сообщениями контроля учётных записей. Ведь с его точки зрения — так оно и должно выглядеть.
### Как обычно запускают процессы
С появлением контроля учётных записей в Windows Vista запуск процессов стал более сложным. Дело в том, что теперь для запуска некоторых программ вызов CreateProcess может оказаться неудачным по причине недостатка прав. В этом случае [GetLastError](https://msdn.microsoft.com/en-us/library/windows/desktop/ms679360(v=vs.85).aspx) возвращает ERROR\_ELEVATION\_REQUIRED. На такой случай в Windows встроено даже специальное [исправление проблем с совместимостью](https://msdn.microsoft.com/ru-ru/library/cc722422.aspx), хотя я так и не заметил, чтобы оно хоть что-то исправляло. Современные же программы в ответ на эту ошибку должны вызывать ShellExecuteEx с действием "runas" для запроса повышения привилегий. Это значит, что типичный код создания процесса теперь выглядит так:
```
if not CreateProcess(…) then
else if GetLastError = ERROR_ELEVATION_REQUIRED then
ShellExecuteEx(…) // с действием "runas"
else
// обработка других ошибок
```
Поскольку наши утилиты должны работать всегда, они не будут требовать повышенных привилегий для запуска, а значит тот процесс, который попытается запустить **A.exe** (и вместо него запустит наш **B.exe**) **никогда** не получит ERROR\_ELEVATION\_REQUIRED. Вроде бы: и ладно, ничего страшного, мы и сами cможем запросить повышение прав для него, если потребуется. А теперь представим себе, что так и произошло. Вот запустил кто-то **A.exe**, вместо него запустились мы, а поскольку **A.exe** требователен к привилегиям — мы не можем запустить его CreateProcess'ом, а потому должны использовать ShellExecuteEx. Уже догадались? ShellExecuteEx же **всегда** перехватывается IFEO, там нет флага DEBUG\_PROCESS, который мог бы нас спасти. В результате мы снова запустим самого себя. Правда, на этот раз у нас уже хватит привилегий использовать CreateProcess для запуска **A.exe**. И всё это без каких-либо видимых следов со стороны UAC! Можно мозг сломать, не правда ли? Я и сам не до конца привык к концепции «почти всеобъемлющего перехвата своих же действий».
По этой причине в утилите **Elevate.exe** нельзя обойтись одним лишь ShellExecuteEx'ом — мы просто не сможем обойти IFEO. В случае же **Ask.exe** это добавляет ещё одну проблему. Вот спросили мы пользователя, подтвердил он запуск. А затем ShellExecuteEx'ом в сочетании с IFEO мы запустили снова себя. Что, опять спрашивать будем? Пришлось добавить подавление вторичного вопроса. А ведь это невозможно сделать простым дописыванием специального параметра: куда бы мы его не дописали, мы же всё равно собираемся запускать **A.exe**, так что он будет неотличим от его собственных параметров. Это весьма неплохое упражнение для ума — попытаться заранее предугадать все эти сложности.
### Отличие CreateProcess от ShellExecuteEx
Вы читали [документацию](https://msdn.microsoft.com/en-us/library/windows/desktop/ms682425(v=vs.85).aspx) на CreateProcess? Там есть один момент, который многие упускают, потенциально создавая некоторую уязвимость в безопасности своих приложений. Это же относится и к устаревшей функции [WinExec](https://msdn.microsoft.com/en-us/library/windows/desktop/ms687393(v=vs.85).aspx), являющейся обёрткой над CreateProcess'ом. Два первых параметра функции определяют, что и с какими аргументами будет запускаться. Это *lpApplicationName* и *lpCommandLine*. Вот перевод куска текста из MSDN:
> Параметр *lpApplicationName* может иметь значение *NULL*. Тогда имя исполняемого файла должно быть первой отделенной пробелом подстрокой в *lpCommandLine*. Если вы используете длинные имена файлов, которые могут содержать пробелы, воспользуйтесь кавычками для указания, где заканчивается имя файла и начинаются аргументы. В противном случае имя файла является двусмысленным.
Почему люди продолжают забывать ставить кавычки? Так ведь и так работает — в CreateProcess встроен механизм коррекции ошибок. Установим *lpApplicationName* в *NULL* и попытаемся запустить программу передав в *lpCommandLine* имя её исполняемого файла: **C:\Program Files\Sub Dir\Program Name**. Что будет делать CreateProcess? Искать в строке то, что можно запустить, пока не найдёт, да ещё и подставляя расширение файла:
> **C:\Program** Files\Sub Dir\Program Name
>
> **C:\Program.exe** Files\Sub Dir\Program Name
>
> **C:\Program Files\Sub** Dir\Program Name
>
> **C:\Program Files\Sub.exe** Dir\Program Name
>
> **C:\Program Files\Sub Dir\Program** Name
>
> **C:\Program Files\Sub Dir\Program.exe** Name
>
> **C:\Program Files\Sub Dir\Program Name**
Если хотите поэкспериментировать — создайте файл **C:\Program.exe** у себя на компьютере и посмотрите, попадётся ли какая из программ на это. У себя я поймал на этом Process Hacker (fix уже есть в ночной сборке), Punto Switcher (надо бы мне им тоже написать), и один из плагинов к Far Manager. Кстати, проводник Windows тоже знает об этой проблеме:
Возвращаясь к вопросу: а что это значит для нас? Из IFEO мы получаем именно *lpCommandLine*. Да, мы можем просто передать его в CreateProcess — если там и была такая проблема — она останется, здесь мы бессильны. Но также нам может понадобиться передавать его в ShellExecuteEx, а там, упс, такой коррекции ошибок нету. Там отдельно *lpFile* и отдельно *lpParameters*. Придётся самостоятельно разбирать строку по пробелам и искать имя первого существующего исполняемого файла также, как это делает CreateProcess. Супер.
А сейчас мы немного отвлечёмся и поговорим о других любопытных вещах. Я собираюсь рассказать о том, как работает одна из утилит.
### Понижая привилегии
Принцип «Запускать любую программу с минимальными необходимыми ей правами» здесь, вероятно, знаком всем. Но вот что делать, если автор понравившейся вам программы об этом принципе не слышал — вопрос уже более сложный. Иногда в таких ситуациях спасают механизмы устранения проблем совместимости:
```
SetEnvironmentVariable('__COMPAT_LAYER', 'RunAsInvoker');
```
Это заметно снижает число случаев, когда CreateProcess не сможет запустить программу и вернёт ERROR\_ELEVATION\_REQUIRED. Но это работает не всегда. Например, над этим методом имеют приоритет \*.sdb патчи.
Ещё есть специальные утилиты, которые умеют запускать процессы с Elevated-токеном (т.е. как-бы от имени администратора), но при этом вырезают все соответствующие привилегии. Это [DropMyRights](https://yadi.sk/d/XCFoh2yK3LwZYw), написанная [Майклом Ховардом из Microsoft](https://en.wikipedia.org/wiki/Michael_Howard_(Microsoft)), и [PsExec](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) из широко известного комплекта [Microsoft Sysinternals](https://docs.microsoft.com/en-us/sysinternals/), запускаемая с ключом -ℓ. Как ни странно, но эти утилиты добиваются своего разными путями.
Мне больше по душе оказался метод, используемый в DropMyRights. Да и исходники у него открытые. Используется там [Windows Safer API](https://msdn.microsoft.com/en-us/library/windows/desktop/ms721849(v=vs.85).aspx#safer_functions), который позволяет буквально в несколько строк кода вычислять токен с урезанными привилегиями, который можно сразу использовать в [CreateProcessAsUser](https://msdn.microsoft.com/en-us/library/windows/desktop/ms682429(v=vs.85).aspx). Эх, хотел бы я, чтобы все писатели инсталляторов знали, как это просто, и не запускали программы с максимальными правами по окончании установки…
А теперь объединим оба упомянутых подхода, совместив их с IFEO. В результате получаем автоматическое понижение прав и минимум запросов к контролю учётных записей. Не знаю как вам, но мне это очень нравиться. А поскольку повышение прав путём вызова ShellExecuteEx'а перехватывается всегда, то, насколько я понимаю, у программы, находящейся под действием нашей утилиты, нет шансов самостоятельно выбраться до тех пор, пока пользователь не подтвердит UAC для другого исполняемого файла, находящегося в кооперации с ограничиваемым. Но для действительно серьёзных случаев — пользуйтесь песочницами вроде Sandboxie. Или виртуальными машинами, если на то пошло.
### Обход IFEO
Возвратимся к основной теме. Я вот всё говорю, мол, запустим процесс с флагом DEBUG\_PROCESS и будет нам счастье, на свои грабли сами не попадёмся. Но для того, чтобы всё заработало, необходимо сделать ещё кое-что. С этим флагом мы запустим процесс под отладкой, а значит, нам будут приходить отладочные события. Если их не обработать — процесс так и останется висеть неподвижно. Для их обработки понадобятся всего две функции: [WaitForDebugEvent](https://msdn.microsoft.com/en-us/library/windows/desktop/ms681423(v=vs.85).aspx) и [ContinueDebugEvent](https://msdn.microsoft.com/en-us/library/windows/desktop/ms679285(v=vs.85).aspx).
Однако не все программы нормально относятся к отладчикам, верно? Не то, чтобы я специально делал исключение ради вирусов, но отсоединение отладчика действительно будет лучшей идеей. Мы ведь здесь не ради написания отладчика собрались. А вот тут, неожиданно, наступает сложность: это действие, вероятно, относится к недокументированным возможностям, ибо на MSDN я его не нашёл. А потому будем пользоваться документацией Process Hacker'a. Итак, нам потребуется функция [NtRemoveProcessDebug](http://processhacker.sourceforge.net/doc/ntdbg_8h.html#a897a6ae8fbdfb0c783e5993e277492c7) из **ntdll.dll**. Ей же нужен *DebugObjectHandle*, который можно получить с помощью [NtQueryInformationProcess](https://msdn.microsoft.com/en-us/library/windows/desktop/ms684280(v=vs.85).aspx), запросив у неё [ProcessDebugObjectHandle = 30](http://processhacker.sourceforge.net/doc/ntpsapi_8h_source.html) в качестве *ProcessInformationClass*. Вот и всё. Хотя… Лучше не делайте так с чужими процессами: их отладчик может в этот момент ждать отладочное событие, а для них самих может быть включён kill-on-close.
> **UPD.**
>
> Я был неправ, и потому пошёл более сложным путём. Документированная функция для этого есть, это [DebugActiveProcessStop](https://msdn.microsoft.com/en-us/library/windows/desktop/ms679296(v=vs.85).aspx). Вместе с ней рекомендуется использовать [DebugSetProcessKillOnExit](https://msdn.microsoft.com/en-us/library/windows/desktop/ms679307(v=vs.85).aspx).
Стоит заметить, что здесь имеется особенность, связанная с разрядностью операционной системы: 32-битный процесс не может запускать 64-битный процесс с флагом DEBUG\_PROCESS. Зато 64-битный может запускать кого угодно.
Ах да, вы ещё помните? Выше я обещал рассказать про ещё один трюк, позволяющий добиться чуть лучшей совместимости при последующем запуске перехватываемых процессов.
### Магия контроля учётных записей
Я уже говорил, что контроль учётных записей вообще никак не реагирует на происходящее. И если вы ещё тогда задались вопросом «А почему?», то вам точно сюда.
Как работает UAC и каким образом позволяет повышать привилегии? Хорошо ответ на этот вопрос дан в англоязычной статье [Vista UAC: The Definitive Guide](https://www.codeproject.com/Articles/19165/Vista-UAC-The-Definitive-Guide). Если коротко: ShellExecuteEx, пробиваясь через дебри вызовов COM, обращается к сервису AppInfo. Тот создаёт процесс **consent.exe**, который и выводит то окно с предложением подтвердить запуск, и, при необходимости, ввести пароль. Само создание процесса, естественно, происходит уже после всего этого. И используется там самый обычный [CreateProcessAsUser](https://msdn.microsoft.com/en-us/library/windows/desktop/ms682429(v=vs.85).aspx). Именно на этом этапе срабатывает IFEO, и, перехватывая создание процесса, запускает нас. Именно поэтому контроль учётных записей ничего об этом не знает.
Самые догадливые уже должны были задаться вопросом: если процесс создаётся кем-то другим, то как получается, что его родительским процессом всё равно оказывается инициатор запроса?
Начиная с Windows Vista в CreateProcess вместо [STARTUPINFO](https://msdn.microsoft.com/en-us/library/windows/desktop/ms686331(v=vs.85).aspx) можно подсунуть [STARTUPINFOEX](https://msdn.microsoft.com/en-us/library/windows/desktop/ms686329(v=vs.85).aspx) (если воспользоваться флагом EXTENDED\_STARTUPINFO\_PRESENT). Он содержит всю ту же информацию + *lpAttributeList* со списком атрибутов процесса. Этот список атрибутов надо создать, вызвав [InitializeProcThreadAttributeList](https://msdn.microsoft.com/en-us/library/windows/desktop/ms683481(v=vs.85).aspx), а затем обновить средствами [UpdateProcThreadAttribute](https://msdn.microsoft.com/en-us/library/windows/desktop/ms686880(v=vs.85).aspx). Подменить родительский процесс можно, указав флаг PROC\_THREAD\_ATTRIBUTE\_PARENT\_PROCESS и предоставив дескриптор нужного процесса. О чём тут стоит помнить:
* Дескриптор процесса, которого мы делаем новым родителем, должен иметь права PROCESS\_CREATE\_PROCESS и жить вплоть до вызова [DeleteProcThreadAttributeList](https://msdn.microsoft.com/en-us/library/windows/desktop/ms682559(v=vs.85).aspx);
* Следует установить значение поля **cb** вложенного STARTUPINFO в SizeOf(STARTUPINFOEX).
> Готовый пример на C# есть на [StackOverflow](https://stackoverflow.com/questions/10554913/how-to-call-createprocess-with-startupinfoex-from-c-sharp-and-re-parent-the-ch).
Часто ли вы при анализе, например, подозрительной активности на компьютере исходите из того, кто какой процесс запустил? О, теперь вы точно не станете так делать.
Тут есть некоторые любопытные особенности. Мне вспоминается шутливая фраза из одного мультика, звучит она примерно так: «да что там, даже при моём рождении не присутствовал ни один из моих родителей…». Как ни странно, но здесь возможно нечто подобное. Если между вызовом [OpenProcess](https://msdn.microsoft.com/en-us/library/windows/desktop/ms684320(v=vs.85).aspx)'a и самим созданием процесса назначаемый родитель будет завершён — не беда. Просто дочерний процесс будет «как бы» создан родителем после своего завершения. Почему бы и нет.
Всё бы хорошо, но этот трюк не сработает с ShellExecuteEx'ом — там всё просто: кто вызвал, тот и родитель. Однако поскольку у нас включён IFEO — финальное слово всегда остаётся за CreateProcess'ом: без него мы не выберемся из перехвата. Так что, пройдясь по цепочке процессов можно найти того, кто всё это затеял изначально, и назначить его родителем. Возможно, результат теперь не так красиво выглядит в Process Explorer'е и Process Hacker'е, зато с точки зрения чужого процесса всё будет в порядке. Ну, за исключением, разве что, «внебрачных» детей, которые появились при запуске и ожидают кода возврата перехваченного процесса. Тут уж ничего не поделать.
На картинке схема того, как я из **Far.exe** запускаю **nsx.exe**, на который назначено действие **Ask.exe**, и которому для запуска требуются повышенные привилегии.
Если честно, я думал, что идея с подменой родительского процесса — просто ещё одна прикольная возможность, не больше. Однако она действительно исправила несколько проблем. Так, тот же Far Manager может создавать второй процесс для выполнения более привилегированных действий, а при наличии перехвата эта функциональность ломалась. Подмена же родителя вновь починила это.
### Чего делать не стоит
Я довольно долго не решался проверить это у себя на компьютере, ибо разворачивать виртуальную машину было лень: что будет, если в качестве запускаемой при перехвате программы установить её же саму? К счастью, ничего страшного. Но дальше я решил проявить благоразумие и не стал у себя на компьютере проверять гипотезы вроде «ой, а если попробовать создать цикл **A** → **B** → **A**…». Также, думаю, не стоит пытался устанавливать перехват важных системных процессов (я встроил их список в утилиту регистрации с подтверждением действия). Хотя, мне и любопытно, что произойдёт. Ибо всё, что я запускал от имени SYSTEM перехватывалось. Так что я добавил подавление всех диалоговых окон в нулевой сессии, ну, чтобы не зависеть в подобных случаях от сервиса UI0Detect.
И последнее: я не рекомендовал бы ставить действия на программы, создающие много однотипных процессов. Одно дело — пара дополнительных процессов, другое — целые полчища. Также не стоит трогать группы процессов, активно взаимодействующих друг с другом. И тех, что используют сложные дополнительные защитные механизмы. В общем, вы поняли: на **chrome.exe** лучше ничего не назначать. Если обнаружите проблемы совместимости: пишите мне или сразу в исходники на Гитхаб. В программу встроен список подобных проблем для предостережения пользователей.
### Нерешённые проблемы
В Windows сосуществуют сразу несколько [подсистем](https://msdn.microsoft.com/en-us/library/windows/desktop/ms680339(v=vs.85).aspx) для исполняемых файлов. Три самых известных это **Native** (драйвера), **Windows CUI** (консольные приложения), и **Windows GUI** (графические приложения). Поскольку драйвера нас сейчас совершенно не интересуют — нам надо разобраться в различиях между вторым и третьим вариантом, и выбрать как компилировать наши утилиты. Вот здесь и начинаются проблемы — как мы хотим: красиво или удобно? Различия между этими подсистемами не столь велики, поскольку консольное приложение может создавать окна, а графическое — консоль. Да и то, GUI даже не всегда означает взаимодействие с пользователем: фоновые сервисы запускаются в **svchost.exe**, который работает в подсистеме Windows GUI.
Для нас существенным отличием являются начальные условия при запуске. За исключением особых случаев, приложения из консольной подсистемы при старте уже имеют консоль, притом видимую. Даже если первым делом при старте программы мы её спрячем, то она успеет появиться перед исчезновением. Хотим ли мы пугать неискушённого пользователя такими вещами? Наверное, нет. Я надеялся, что в исправлениях совместимости из [Application Compatibility Toolkit](https://msdn.microsoft.com/en-us/library/windows/desktop/dd562082(v=vs.85).aspx) найдётся что-то, что сможет исправить эту проблему, но, судя по всему, там нет функции «спрятать консоль по умолчанию». А потому, для себя я выбрал графическую подсистему. Всё бы хорошо, но у неё есть заметный минус. Если вы активно пользуетесь приложениями из консольной подсистемы, то сразу обратите внимание: все консольные программы, на которые назначено какое-либо стандартное действие, создают новую консоль, а не пользуются имеющейся. Это не критично, хотя и не всегда приятно. Если вам вдруг захочется сделать другой выбор в этом вопросе, а Delphi под рукой нет — просто пропатчите нужные файлы, отвечающие за стандартные действия: замените **02** на **03** по смещению 0x15C.
### Заключение
Я надеюсь, что этот «экскурс в 1001 любопытный факт о работе Windows» оказался действительно любопытным и даже полезным. Я знаю, не все здесь жалуют Delphi, но уж с почти чистым WinApi, холиваров, надеюсь, не возникнет.
Код получившихся программ и бинарники доступны на [**Гитхабе**](https://github.com/diversenok/ExecutionMaster). Программа тестировалась на Windows 7 и выше, про Windows Vista — без понятия. Ниже — однозначно нет.
P. S. Если у вас сложилось мнение, что в каком-то вопросе я основательно заблуждаюсь — не кидайтесь помидорами сразу, давайте сперва разрешим это недоразумение, и исправим неточности в статье. Спасибо. | https://habr.com/ru/post/335736/ | null | ru | null |
# Автоматическая система полива сада на Home Assistant, ESP8266 и MiFlora
Некоторое время назад у моей семьи появился дом с небольшим садом в очень теплом и засушливом месте, и перед нами встала проблема регулярного полива.
Хотелось, чтобы система полива была автоматической, при этом при ее выборе приходилось учитывать следующие условия:
* очень дорогая вода, которую надо экономить всеми доступными способами
* разные по потребностям во влаге растения в саду, от суккулентов до влаголюбивых
* необходимость полностью автономного полива во время отсутствия людей в доме, желательно с возможностью удаленного контроля
* засушливый климат, не прощающий ошибок с поливом
Оценив готовые решения, которые удалось найти в местных DIY сетях и на Amazon и почитав отзывы об их надежности (как правило, не самой высокой), решили попробовать сделать что-то самостоятельно.
*Disclaimer: Автор не является IT-специалистом, и не претендует на профессиональное знание описываемой темы. Уровень исполнения проекта — хобби. Об уровне своих знаний в сфере программирования и электроники автор прекрасно осведомлен и будет очень признателен за предложения по улучшению и оптимизации использованных решений.*
### Принципиальная схема
Сад был разбит на 4 зоны полива, каждая из них снабжается индивидуальным датчиком влажности почвы и может поливаться по индивидуальному графику и разным количеством воды.
По земле проложены ПНД-трубки капельного полива с перфорацией, которые подключены к трубам сходящимся в водоразборном узле и подключенным через электромагнитные клапаны к водопроводу. Клапаны управляются реле подключенными к ESP8266 (Sonoff 4Ch).
Полив осуществляется по таймерам, в ночное время, чтобы увеличить количество воды, которое впитается в землю и не будет испарено солнцем.
При наступлении запланированного времени полива проверяется соответствие нескольким условиям:
* влажность почвы ниже заданной величины
* отсутствуют прогнозируемые осадки в достаточно большом количестве на ближайшие 2 дня
* не превышен лимит воды по поливу заданного для этой линии
### Использованное оборудование
**Raspberry Pie** с установленным HassIO (уже была)
**ESP32 DevKit**, прошитая ESPHome, выступающая bluetooth-гейтвеем для MiFlora и принимающая данные от проводных датчиков влажности. Расположена в саду
Проводные датчики влажности **Capacitive Soil Moisture Sensor v1.2**, измеряющие влажность в ближних к месту установки ESP32 зонам полива
**Датчики MiFlora**, подключены к ESP32 по BLE, измеряющие влажность в удаленных зонах полива.
**SONOFF 4Ch**, прошитый ESPHome, расположен в водоразборном узле, куда приходят трубы от всех зон полива
**4 Нормально-закрытых электромагнитных клапана на 220В** расположены в водоразборном узле и подключены к Sonoff 4Ch. Открывают подачу воды для полива. Выбрана нормально-закрытая модель, с тем чтобы вероятность «наводнения» в случае каких-либо сбоев электрики и электроники была минимальной, и чтобы минимизировать количество требуемых выходов реле.
**Импульсный водосчетчик**, стоящий на входе в систему полива в водоразборном узле и подключенный к Sonoff 4ch. Позволил полностью передать данные о расходе воды в Home Asssistant и реализовать функционал полива заданным количеством. Весьма удачным оказалось то, что на этой версии sonoff уже распаяны контакты для прошивки и даже есть один свободный GPIO02 – на него и был повешен импульсный счетчик.
*Так выглядит коллектор с установленными клапанами и счетчиком воды. Контроллер (sonoff 4Ch) в кадр не попал, он установлен на расстоянии в полметра в щитке IP65*
### Настройки ESPHome и Home Assistant
**Sonoff 4Ch**Код ESPHome для него максимально примитивен, но на всякий случай приведу:
```
switch:
- platform: gpio
name: "Система полива линия 1"
pin: GPIO12
id: sw1
icon: mdi:water
- platform: gpio
name: "Система полива линия 2"
pin: GPIO5
id: sw2
icon: mdi:water
- platform: gpio
name: "Система полива линия 3"
pin: GPIO4
id: sw3
icon: mdi:water
- platform: gpio
name: "Система полива линия 4"
pin: GPIO15
id: sw4
icon: mdi:water
binary_sensor:
- platform: gpio
name: "WaterCounter"
id: button
pin:
number: GPIO2
mode: INPUT_PULLUP
```
**Capacitive Soil Moisture Sensor v1.2**Кусок кода для ESPHome:
```
sensor:
- platform: adc
pin: GPIO34
filters:
- lambda: |-
if (x > 3.22) {
return 0;
} else if (x < 1.65) {
return 100;
} else {
return (3.22-x) / (3.22-1.65) * 100.0;
}
name: "Датчик влажности почвы 1 линия проводной"
update_interval: 60s
attenuation: 11db
unit_of_measurement: "%"
accuracy_decimals: 0
icon: mdi:water-percent
```
Подключать датчик можно только к аналоговым входам (ADC) микроконтроллера
Датчик придется калибровать, задав предельные значения напряжения для сухого датчика (в моем случае 3.22 В) и погруженного в воду (1,65 В). Я это делал включив демонстрацию log'ов в плагине ESPHome для HassIO и записав показания датчика в сухом виде и при погружении в воду.
После перепрошивки ESP32 в Home Assistant ничего настраивать не надо, там автоматически появляется датчик влажности с правильными единицами измерения
**Импульсный счетчик воды**Я использовал счетчик «Пульсар», но вообще должен подойти любой счетчик с импульсным выходом (идентифицируется по торчащему проводу). Принцип действия таких счетчиков очень простой — рядом с колесиками счетчика расположен геркон, который активируется магнитом, расположенном на одной из цифр колеса учета (у меня — цифра 3 на колесике 10 литров).
Соответственно, подключив провода от счетчика к GND и одному из GPIO мы можем получить простейший бинарный сенсор.
Код для ESPHome при этом примитивен:
```
binary_sensor:
- platform: gpio
name: "WaterCounter"
id: counter
pin:
number: GPIO2
mode: INPUT_PULLUP
```
В Home Assistant все немного сложнее:
Там я сделал несколько счетчиков (counter), сенсор и автоматизацию для работы с ними
При этом есть общий счетчик истраченной за все время воды (фактически, это виртуальный «двойник» механического счетчика). Он реализован в двух ипостасях — как counter, измеряемый в литрах и растущий в результате реакции на изменения бинарного сенсора из ESPHome, и как sensor, измеряемый в кубических метрах и берущий данные из предыдущего counter (для удобства сравнения цифр со счетами за воду).
Для целей управления поливом и сбора статистики были также созданы по 2 счетчика на каждую линию полива — один за все время, а второй за «сегодня». Так как физический счетчик у нас один, а линий четыре, для получения точных данных расхода по каждой линии полив каждой линии был разнесен по разным временным интервалам и запрещено одновременное их включение.
**Кусок кода для автоматизации (внутри automations.yaml или отдельный файл)**
```
- alias: Подсчет воды по общему счетчику
trigger:
- entity_id: binary_sensor.watercounter
platform: state
from: 'on'
to: 'off'
action:
- data:
entity_id:
- counter.my_water_counter
service: counter.increment
- alias: Подсчет воды по 1 линии
trigger:
- entity_id: binary_sensor.watercounter
platform: state
from: 'on'
to: 'off'
condition:
- condition: state
entity_id: switch.sistema_poliva_liniia_1
state: 'on'
action:
- data:
entity_id:
- counter.my_water_line1, counter.my_water_line1t
service: counter.increment
```
**Кусок кода configuration.yaml общий счетчик воды + два счетчика по одной линии полива**
```
sensor:
- platform: template
sensors:
water_counter:
unit_of_measurement: 'M3'
value_template: "{{ (states('counter.my_water_counter')| float)/1000 }}"
counter:
my_water_counter:
initial: 2.667
step: 10
my_water_line1:
name: "Полив 1 линия за все время (л)"
initial: 0
step: 10
my_water_line1t:
name: "Полив 1 линия сегодня (л)"
initial: 0
step: 10
```
**Датчик MiFlora**Датчик MiFlora при использовании ESPHome настраивается очень просто, инструкцию можно найти на сайте проекта [esphome.io](https://esphome.io/components/sensor/xiaomi_hhccjcy01.html)
В Home Assistant после такой настройки сразу появляются имеющиеся на датчике сенсоры — влажность, температура, освещенность и «фертильность» почвы. Единственный недостаток — странная работа сенсора заряда батареи, но для моих целей это не было критично.
**Виртуальный сенсор прогнозируемых осадков**Смысл этого сенсора — выдавать в числовом виде прогноз осадков на ближайшие два дня. Эта цифра впоследствии используется в автоматизации и если она превышает заданный порог, полив не происходит.
Изначально сенсор построен на базе данных сервиса darksky. К сожалению, за время настройки системы этот сервис успела купить компания Apple и объявила о постепенном сворачивании работы сервиса «на сторону». API пока работает, но, судя по всему, скоро потребуется искать альтеранативу этому решению, благо в HA довольно много других сервисов погоды. Здесь я привожу настройки для darksky, думаю, что даже с другим сервисом большая их часть сохранит актуальность.
Сначала создаем 2 сенсора по количеству осадков на завтра и послезавтра:
**Кусок кода configuration.yaml или sensors.yaml для сенсоров прогноза**
```
sensor:
- platform: darksky
api_key: xxxx_your_API_key_xxxx
forecast:
- 1
- 2
monitored_conditions:
- precip_intensity
```
В результате в HA появляются два сенсора: sensor.dark\_sky\_precip\_intensity\_1d и sensor.dark\_sky\_precip\_intensity\_2d, которые выдают цифры интенсивности осадков на завтра и послезавтра измеряемые в мм в час.
Затем делаем на основе трех прогнозов один template-sensor:
**Кусок кода configuration.yaml или sensors.yaml для обобщенного сенсора осадков**
```
sensor:
- platform: template
sensors:
rain2days:
unit_of_measurement: 'mm'
value_template: "{{ (((states('sensor.dark_sky_precip_intensity_2d')| float)+(states('sensor.dark_sky_precip_intensity_1d')| float))*24)| round(3) }}"
```
В HA появляется sensor.rain2days который уже выдает общие осадки в мм на ближайшие 2 дня.
По опыту использования, прогноз от Darksky не особо точен если речь идет о слабеньком дождике, но сильные ливни он предсказывает очень неплохо и для моих целей этого вполне достаточно
После того, как все данные собраны, можно приступать непосредственно к поливу.
Вот так у меня выглядит кусок интерфейса с одной из зон в Home Assistant:
Здесь можно задать количество воды для полива (ползунком) и посмотреть значения основных сенсоров и счетчиков. Я привел интерфейс для одной из линий, для остальных все аналогично, только на линиях с проводными датчиками данных несколько меньше.
В интерфейсе можно заметить одну «лишнюю» деталь — вспомогательный сенсор «Достигнута норма». Его пришлось ввести, т.к. мне не удалось заставить работать condition:template для остановки автоматизации при достижении нормы по количеству воды, и в результате автоматизация просто проверяет значение этого сенсора. Уверен, что эту часть автоматизации можно сделать проще и элегантней, но моего уровня для этого не хватило.
Ниже код получившегося «костыльного» темплейт-сенсора:
**Сенсор достаточности полива (внутри configuration.yaml или отдельный файл)**
```
- platform: template
sensors:
line4_status:
friendly_name: "Линия 4 - достигнута норма"
value_template: >-
{% if states('counter.my_water_line4t')|float > states('input_number.slider4')|float %}
yes
{% elif states('counter.my_water_line4t')|float == states('input_number.slider4')|float %}
yes
{% else %}
no
{% endif %}
```
Автоматизация для запуска полива в конечном итоге выглядит так:
**Запуск полива (внутри automations.yaml или отдельный файл)**
```
- alias: Включение полива 4я линия в 23.01
trigger:
platform: time
at: "23:01:00"
condition:
condition: and
conditions:
# ПРОВЕРЯЕМ НОРМУ ПО ОСАДКАМ
- condition: numeric_state
entity_id: sensor.rainfor2days
below: 5
# ПРОВЕРЯЕМ НОРМУ ПО ПОКАЗАНИЮ ДАТЧИКА ВЛАЖНОСТИ
- condition: numeric_state
entity_id: sensor.miflora_1_moisture
below: 50
# ПРОВЕРЯЕМ, НАДО ЛИ ЕЩЕ ПОЛИВАТЬ СЕГОДНЯ ПО КОЛИЧЕСТВУ
- condition: state
entity_id: 'sensor.line4_status'
state: 'no'
action:
- service: switch.turn_on
entity_id: switch.sistema_poliva_liniia_4
```
Полив запускается поздно вечером, при этом каждая линия запускается в свой временной интервал. Разделение по времени запуска позволяет использовать один счетчик воды на входе для получения данных по 4 линиям.
При запуске проверяются три условия:
* не превышен ли лимит по количеству воды на сегодня (если, например, включали полив вручную)
* не превышает ли влажность 50% (по наблюдениям в наших условиях свежеполитая почва имеет влажность не более 60%)
* не ожидается ли осадков более 5 мм в ближайшие два дня.
Следующая автоматизация — отключение полива:
**Отключение полива (внутри automations.yaml или отдельный файл)**
```
- alias: Выключение полива 4й линии
trigger:
#Отключение по достижению лимита воды на полив
- entity_id: sensor.line4_status
platform: state
to: 'yes'
for:
seconds: 5
#Отключение по времени
- platform: time
at: "23:59:00"
#Отключение по достижению предельной влажности
- platform: numeric_state
entity_id: sensor.miflora_1_moisture
above: 65
#Отключение по времени нахождения крана в открытом состоянии
- platform: state
entity_id: switch.sistema_poliva_liniia_4
to: 'on'
for:
minutes: 60
action:
- service: switch.turn_off
entity_id: switch.sistema_poliva_liniia_4
```
В автоматизации использовано целых 4 варианта триггеров, но в большинстве случаев она срабатывает по первому — «костыльному» сенсору, который отслеживает превышение лимита по количеству воды. Остальные триггеры сделаны в большой степени для подстраховки.
Ну и последняя относящаяся к проблеме автоматизация — обнуление ежедневного счетчика
**Обнуление ежедневного счетчика (внутри automations.yaml или отдельный файл)**
```
- alias: Обнуление ежедневного таймера 4я линия
trigger:
- platform: time
at: "00:00:01"
action:
- service: counter.reset
entity_id: counter.my_water_line4t
```
### Экономика проекта
Затраты на управляющую часть системы полива получились следующие:
(Raspberry PIE c HassIO на борту и WiFi router с покрытием в саду уже были до начала проекта, их я не учитываю)
Электромагнитный клапан UNIPUMP BCX-15 1/2" (нормально закрытый) 4\*20 евро
Sonoff 4CH 17 евро
Счетчик импульсный Пульсар 8 евро
ESP32 DevKitC 3.5 евро
Capacitive Soil Moisture Sensor v1.2 2\*0.67 евро
Датчики MiFlora 2\*16 евро
Щитки, коллектор, провода, фиттинги все вместе около 50 евро
ИТОГО: около 190 евро
Затраты времени на настройку датчиков и МК — примерно 3-4 вечера по нескольку часов, но большая часть времени была потрачена на «изобретение велосипедов» и придумывание «костылей», в целом работы там немного. Физическая сборка системы заняла около 2 вечеров.
В целом, ожидается экономия воды примерно в 20-50% по сравнению с «глуповатой» системой на таймерах и при местных ценах на воду система должна окупиться за один-два сезона.
### Недостатки и планы по доработке
По итогам выполнения проекта вскрылись некоторые нюансы и возможности для дальнейшего совершенствования.
В частности, я бы заменил электромагнитные клапана 220В на модель 24В — это напряжение являются стандартными для систем полива. В этом случае пришлось бы добавить в систему трансформатор на 24В и сменить Sonoff 4Ch на что-то с сухим контактом (например, Sonoff 4CH Pro или что-то самосборное). Сами клапана при этом стоят дешевле (от 8 евро) и снижают вероятность поражения электрическим током.
Также выяснилось, что для работы с пластиковыми трубопроводами давление из водопровода является слишком высоким, и фитинги могут подтекать во время цикла полива. В моем случае это не критично, все фитинги расположены над поливаемой землей, но по-хорошему надо добавить на входе редуктор для понижения давления.
Еще немного расстроила невозможность учета количества воды для полива в объемах меньших чем 10 литров — именно этот объем является минимальной измеряемой величиной для такого счетчика. Эту проблему можно решить, разобрав счетчик и поменяв местами колесики, но пока до этого не дошли руки. | https://habr.com/ru/post/497606/ | null | ru | null |
# Простейшая игра на Arduino с дисплеем 1602 — Часть #2
ЧАСТЬ #2 от начала до конца
===========================
Продолжаем делать игру на arduino и в дальнейшем всунем эту игру в программу, которую я делаю для машины и на наших полученных знаниях создадим вторую игру, для забавы ради и сделаем правильную музыку для нее.
Что бы понять, что нам сейчас нужно писать, мы должны составить план, что же мы будем иметь и в каком виде. У нас есть главный герой, у него два кадра анимации и это мы уже в прошлом уроке уже разобрали. Делать ему изменение спрайта прыжка я не стал, не потому что мне лень, просто не вижу пока что в этом смысла. Далее у нас должно быть обозначение жизни, делать просто сердечки в ряд не интересно, и цифры тоже банально, давайте сделаем три очка жизни и обозначим их, например уровнем заряда батарейки. И для радости глаза сердечко, которое будет биться возле этой батарейки. Количество очков за раунд, установим слева экрана, чисто в цифровом виде и враг у нас будет злой кактус, для начала пойдет.
С объектами мы определились и давайте их отрисуем, сразу все спрайты и запишем их.
     
  
Рабочие спрайты у нас есть и мы уже можем представить как будет выглядеть это на экране, следуя первому уроку мы выпишем их в двоичной системе, помним, где ноль там пусто, а где единица, у нас горит пиксель. Приступим:
```
"--------------------------------------------------------------------------"
//Главный герой первый спрайт:
byte Player_1[SYMBOL_HEIGHT] = {B01110,B01110,B00100,B01110,B10101,B00100,B01110,B01010,};
//Главный герой второй спрайт:
byte Player_2[SYMBOL_HEIGHT] = {B00000,B01110,B01110,B00100,B11111,B00100,B01110,B01010,};
//Злой кактус:
byte Enemy_1[SYMBOL_HEIGHT] = {B00010,B00110,B10111,B10110,B11111,B00110,B00110,B11111,};
//Сердечко большое:
byte Heart_L[SYMBOL_HEIGHT] = {B00000,B01010,B11111,B11111,B11111,B01110,B00100,B00000,};
//Сердечко маленькое:
byte Heart_R[SYMBOL_HEIGHT] = {B00000,B00000,B01010,B11111,B01110,B00100,B00000,B00000,};
//Батарейка три жизни:
byte Battery1[SYMBOL_HEIGHT] = {B01110,B11111,B11111,B11111,B11111,B11111,B11111,B11111,};
//Батарейка две жизни:
byte Battery2[SYMBOL_HEIGHT] = {B01110,B10001,B10011,B10111,B11111,B11111,B11111,B11111,};
//Батарейка одна жизнь:
byte Battery3[SYMBOL_HEIGHT] = {B01110,B10001,B10001,B10001,B10011,B10111,B11111,B11111,};
//Батарейка ноль жизней:
byte Battery4[SYMBOL_HEIGHT] = {B01110,B10001,B10001,B10001,B10001,B10001,B10001,B11111,};
"--------------------------------------------------------------------------"
```
Теперь у нас есть спрайты, и пришло время это все оживлять. Для начала подумаем какие дополнительные функции нам нужны. Зная, что arduino работает не идеально и местами даже очень капризно, мы начинаем стараться максимально упростить этому микроконтроллеру жизнь. Не перегружать и одновременно требовать полной отдачи. Так что выведем такие дополнительные функции, которые будут жить своей жизнью и делать все что нам надо:
— анимация сердца
— анимация героя
— проверка урона по герою
— движение злого кактуса
— начисление очков (пока что ежесекундно +1, дальше поменяем)
— обновление экрана (но это не точно, скорее всего, мы уберем эту функцию и добавим другую, мне не понравилось, что экран моргает, хочется стабильности). В последствии заменим эту функцию на удаление прошлого местоположения героя, это уберет пративное мерцание экрана, а обнуления злодея, будет внутри злого скрипта, думаю там одна или две строчки максимум будет.
— управление пультом
— настройки loop и setup
Мы хотим, что бы у нас была анимация биения сердца. Выводя ее в отдельную функцию и заставив жить своей отдельной жизнью нам проще будет отслеживать работу и в дальнейшем проще будет редактировать, так как у нас все, ну или почти все находиться в одном месте. Этот код, можно было бы вывести в loop () и закомментировать, но я, лично, привык разбивать на отдельные функции, ты не ищешь код во всем списке и знаешь, что отдельная функция, контролирует отдельные элементы нашей игры.
Сейчас, я буду писать отрезки кода, мы их соединим в конце и получиться полноценный скрипт, я вам сейчас объясню суть да идею, а потом соберем пазл и будем наслаждаться результатом.
Перед началом самого кода, объясню парочку моментов.
lcd.createChar // это команда обращения к экрану и задействования одной из ячеек памяти для записи новых символов. В скобочках записывается номер ячейки и через запятую, название переменной с информацией.
Контроль за отрисовкой будем вести через цифровую переменную, используя четыре цифры, для правильности анимации, если бы мы хотели сделать так что бы сердце просто билось туда-сюда то нам и подошла бы обычная переменная bool. Но у меня мысль другая, один большой удар и два коротких, так будет смотреться интереснее.
```
"--------------------------------------------------------------------------"
void HeartHit () // функция анимации сердечка
{
if (HeartControl == 0 || HeartControl == 2){lcd.createChar(1, Heart_L);} //если наша переменная покажет ноль или два, мы в ячейку один записываем большое сердце
if (HeartControl == 1 || HeartControl == 3){lcd.createChar(1, Heart_R);} //если наша переменная покажет один или два, мы в ячейку один записываем малое сердце
if (currentMillis - HeartHitBigCheck >= HeartHitBig) { // время большого зависания удара
if (currentMillis - HeartHitLightCheck >= HeartHitLight) { // время коротких ударов
HeartHitLightCheck = currentMillis; // обнуление контроля времени коротких ударов
if (HeartControl<3){HeartControl++;} // если переменная контроля отрисовки менее трех, то при каждом срабатывании скрипта мы плюсуем один к сумме
else {HeartControl = 0; HeartHitBigCheck = currentMillis;} //но если сумма переменной превысила три, то обнуляем ее и обнуляем счетчик длительного залипания сердца
}
}
}
"--------------------------------------------------------------------------"
```
Еще раз, хочу сконцентрировать ваше внимание на этом коде:
lcd.createChar(x, y); присваивание в ячейку пямяти « x » от (0…7) данные для отображения на экране « y »
Идем дальше =)
Теперь, у нас есть код, который создает эффект интересного биения сердечка, ничего полезного оно не делает, только понты =)
Далее основываясь на этом, создадим анимацию нашего героя, есть огромные плюсы, чем дальше мы погружаемся в эту статью, тем больше вы узнаете мой стиль мышления, а мне, уже меньше надо вам объяснять и больше акцентировать внимание на коде и построении идеи. Я буду стараться больше объяснять в комментариях скрипта, что бы меньше писать вне скрипта.
Так что приступим к главному герою и создадим еще одну функцию для этого:
```
"--------------------------------------------------------------------------"
// я переписал этот кусок кода и он будет отличаться от первой части статьи(чуток). Это для меня нормально =) На работоспособность, это никак не влияет но лучше использовать новый вариант.
void PlAn () // функция анимации главного героя
{
If (JumpB == true && GGpozY == 0){ // это контроль прыжка (активация прыжка будет в другой части кода) Если прыжок = правда И позиция нахождения наверху.
if (currentMillis - JumpUPCheck >= JumpUP) { // проверка времени в полете 0.8f
JumpB = false; GGclear (); GGpozY = 1; // когда время выходит, возвращаем нашего героя на землю и ждем следующего прыжка. Прыжок = лож; активация функции очищения местонахождения героя (); позиция вертикали главного героя = нижняя полоса;
}
}
if (AnimPlayer == 1){lcd.createChar(0, Player_1);} //Если переменная контроля анимации один, записываем в ячейку памяти первый спрайт героя
if (AnimPlayer == 2){lcd.createChar(0, Player_2);} //Если переменная контроля анимации два, записываем в ячейку памяти второй спрайт героя
if (AnimPlayer < 2) // если переменная до двух, выставляем курсор на то место, где находиться наш главный герой и рисуем из памяти спрайт героя
{
lcd.setCursor(GGpozX, GGpozY); // выставили на позицию
lcd.write(0); // отрисовали
}
if (currentMillis - AnimatedTimeCheck >= AnimatedTime) { // проверка времени
AnimatedTimeCheck = currentMillis; // обнуление времен
if (AnimPlayer == 2){AnimPlayer = 1;} // если переменная контроля анимации два то один
else{AnimPlayer = 2;} // а если один, то два.
}
}
void GGclear () // функция обновления героя
{
lcd.setCursor(GGpozX, GGpozY); // позиция героя
lcd.print(" "); //очищаем его
}
"--------------------------------------------------------------------------"
```
Теперь таймер, эм, точнее очки наши, которые будут начисляться, давайте просто напишем таймер и будем считать что это очки.
```
"--------------------------------------------------------------------------"
void timer () // функция очков
{
if (currentMillis - DHTTimeRCheck >= DHTTimeR) // таймер который срабатывает раз в секунду
{
DHTTimeRCheck = currentMillis; // обнуление таймера
Timer_z ++; // плюсуем единицу к общей сумме
lcd.setCursor(0, 0); // выставляем курсор на первую верхнюю точку
lcd.print(Timer_z); // выводим данные на экран
}
}
--------------------------------------------------------------------------"
```
Вот и все. Чем дальше тем легче.
Теперь, осталось отработать нашего кактуса.
Его задача простая, появиться, прошагать весь путь справа на левое и попытаться соприкоснутся с героем, что бы нанести урон. С уроном все проще, one touch – one hit. Пока что увеличения сложности, делать мы не будем. Пусть кактус двигается со скоростью 0.5f (сложность это уже будет ваше домашнее задание =)) ну или русским языком пол секунды – один шаг.
Давайте глянем, как будет смотреться, этот кусок кода:
```
"--------------------------------------------------------------------------"
void enemy_go () // функция злодея
{
if (Emeny_check_1 == 0) // что бы враг появлялся с случайно задержкой, нам надо сделать так что бы пока не было злодея на экране, у нас срабатывал рандом и при правильном числе, призывался злодей а этот рандом ждал пока он снова не понадобиться
{
Emeny_control = random (100); // я подумал, если мы задействуем разные методы, то это будет интереснее, по этому, высчитать шанс появления злодея, можно будет рандомом.
if (Emeny_control == 1) { // если рандом = 1 из 100 то запускаем злодея.
Emeny_check_1 = 1; // запускаем персонажа, по сути, тут можно использовать bool так как у нас два состояния, или да или нет, а мне сейчас переделывать было лень
hitON = false; // эта функция проверяет был ли нанесен урон главному герою
}
}
if (Emeny_check_1 == 1) // когда рандом одобрен, злодей пошел в бой
{
if (currentMillis - TimeBlinkCheck >= TimeBlink) //проверка временем 0.5f
{
TimeBlinkCheck = currentMillis; //обнуление проверки время
lcd.createChar(2, Enemy_1); //присваиваем ячейке памяти 2 спрайт кактуса
lcd.setCursor(E1pozX, E1pozY); //выбрали 1ю точку кактуса
lcd.print(" "); //обнуляем ее
E1pozX--; //перемещаем влево на один шаг
lcd.setCursor(E1pozX, E1pozY); //выставляем 2ю позицию
lcd.write(2); //отрисовываем кактус
if (E1pozX <= 0) //если кактус дошел до края экрана
{
lcd.setCursor(0,1); //выставляем курсор на край экрана
lcd.print(" "); //обнуляем его
Emeny_control = 0; //обнуляем функцию рандома
Emeny_check_1 = 0; //закрываем доступ к этой части скрипта
E1pozX = 16; // - \/ \/ \/
E1pozY = 1; // - выставляем катус обратно на позицию Х и У
}
}
}
}
"--------------------------------------------------------------------------"
```
Осталось совсем чуток и после разбирательства каждого куска, я смогу уже выложить полный скрипт собранный, настроенный и готовый для теста на ваших устройствах.
Так у нас на очереди теперь один из самых главных скриптов, это скрипт проверки урона и включение геймовера в случае отсутствия жизни. Ничего сверхъестественного в скрипте нет. По этому, можем начать его разбирать (кстати, если вы были внимательны, то вы бы заметили, что когда мы создавали сердечко, мы его не отобразили на экране, так вот, вы сейчас увидите, куда я запихнул эту часть кода):
```
"--------------------------------------------------------------------------"
void check_hit_gg_1 () //функция получения урона
{
if (E1pozX == GGpozX && E1pozY == GGpozY && hitON == false){ //проверка что координаты Х и Y совпали, что у героя, что у кактуса
LifeCheck -= 1; // минусуем од ХП
hitON = true; // возвращаем проверку и теперь наш герой снова может получать урон
if (LifeCheck <= 0){ // если жизни меньше чем ноль
AnimPlayer = 50; //отключаем срабатывание loop ()
Emeny_check_1 = 50; // отключаем случайное срабатывание кактуса
lcd.clear(); //чистим экран
lcd.setCursor(3, 0); //устанавливаем курсор
lcd.print("GAME OVER"); // пишем заветное слово
}
} else { // НО! Если герой и кактус не сошлись в соитие то…
lcd.setCursor(13, 0); // устанавливаем курсор и …
lcd.write(1); // отображение сердечка
lcd.setCursor(14, 0);
lcd.print("="); // это просто равно
lcd.setCursor(15, 0);
lcd.write(3); // отображение батарейки
}
}
"--------------------------------------------------------------------------"
```
Этот код очень простой, основная его функция, это проверять, и ждать пока условия все будут выполнены, что бы остановить игру и сообщить нам, что мы проиграли.
Теперь последняя функция, это управление. По сути, если мы разобрали код выше, то для нас он покажется проще простого. С первого урока, мы вытянули коды пульта, у меня выписаны они все, выглядят они вот так:
`* CH- 0xFFA25D
* CH 0xFF629D
* CH+ 0xFFE21D
* << 0xFF22DD
* >> 0xFF02FD
* >|| 0xFFC23D
* - 0xFFE01F
* + 0xFFA857
* EQ 0xFF906F
* 0 0xFF6897
* 100+ 0xFF9867
* 200+ 0xFFB04F
* 1 0xFF30CF
* 2 0xFF18E7
* 3 0xFF7A85
* 4 0xFF10EF
* 5 0xFF38C7
* 6 0xFF5AA5
* 7 0xFF42BD
* 8 0xFF4AB5
* 9 0xFF52AD`
Кнопка \_ код (внимание!) (коды на пультах могут отличаться)
Кто не читал, советую прочитать 1ю часть.
Что-то подобное, потом будет и у вас, и вы сможете без проблем настраивать все, что вам нужно.
Теперь мы создадим простейший алгоритм, основываясь на том, что уже знаем и наша игра, оживет.
```
"--------------------------------------------------------------------------"
void IRCheck () // функция ИК порта
{
if ( irrecv.decode( &results )) // если данные пришли, то
{
if (results.value == 0xFF18E7 && GGpozY == 1){ // если нажали кнопку « 2 » и позиция на «Земле»
GGclear (); // очищаем прошлое местонахождение героя
GGpozY = 0; // выставляем позицию на 2ю полосу (типа прыжок)
JumpB = true; // переменная обозначающая что мы в фазе прыжка
JumpUPCheck = currentMillis; // обнуляем счетчик проверки времянахождения в воздухе
} // 2
if (results.value == 0xFF10EF && GGpozX >= 0){ // Если нажали на четверку и вы не упираетесь в левый край экрана
GGclear (); // тоже что и до этого
GGpozX -= 1; // перемещаем главного героя влево
} // 4
if (results.value == 0xFF5AA5 && GGpozX <= 15){ //если нажали шесть и не упираемся в правую сторону экрана
GGclear (); //должны были уже запомнить
GGpozX += 1; // перемещаем вправо
} // 6
if (results.value == 0xFF6897){ // 0 //если нажать ноль, то игра делает рестарт…
lcd.clear(); // очищаем экран
AnimPlayer = 1; //возвращаем переменную запуска анимации
LifeCheck = 3; // восстанавливаем ХП
Timer_z = 0; // обнуляем счетчик
GGpozX = 8; // \/ \/ \/
GGpozY = 1; // возвращаем главного героя на центр экрана
Emeny_check_1 = 0; // возвращаем данные генератора кактусов
E1pozX = 16; // \/ \/ \/
E1pozY = 1; // выставляем стартовую позицию кактуса.
}
irrecv.resume(); // обнуляем данные датчика
}
"--------------------------------------------------------------------------"
```
Вывод от выше написанного кода:
кнопка 2 это прыжок
кнопка 4 это шаг влево
кнопка 6 это шаг вправо
кнопка 0 обнуляет игру и перезапускает ее
Вот, теперь осталось нам настроить setup & loop, уже все идет к концу. Мы создали все дополнительные функции и нам осталось только все это склеить и добавить библиотеки. Я думаю, мы рассмотрим переменные и главные настройки setup\loop уже в общем коде, так что приступим, а потом от вас требуется ctrl + c & ctrl + v и все =) и дальнейшее самостоятельное развитие в этом направлении, если вам конечно это все понравилось.
```
"--------------------------------------------------------------------------"
#include // ИК модуль
#include // i2P шина
#include // дисплей 1602
LiquidCrystal\_I2C lcd(0x3F,16,2); // Устанавливаем дисплей
int AnimPlayer = 1; // анимация героя
int GGpozX = 8; // позиция героя ось Х
int GGpozY = 1; // позиция героя ось У
int Emeny\_check\_1 = 0; // проверка злодея
int Emeny\_control = 0; // рандомим это число что бы были задержки между призывом кактуса
int E1pozX = 16; // позиция злодея Х
int E1pozY = 1; // позиция злодея У
int HeartControl = 0; // контроль анимации сердечка
int LifeCheck = 3; // количество жизней
long Timer\_z = 0; // счетчик очков
long AnimatedTime = 300; // время обновления анимации героя
long AnimatedTimeCheck = 0; // проверка вышеуказанного
long HeartHitBig = 800; // время задержки сердца большое
long HeartHitLight = 250; // время задержки сердца малое
long HeartHitBigCheck = 0; // проверка большого удара сердца
long HeartHitLightCheck = 0; // проверка малого удара сердца
long BatteyBlink = 200; // время бликов батарейка когда осталось 1 ХП
long BatteyBlinkCheck = 0; // проверка вышеуказанного
long JumpUP = 800; // время нахождения в прыжке
long JumpUPCheck = 0; // проверка вышеуказанного
long DHTTimeR = 1000; //обновление секунда
long DHTTimeRCheck = 0; //проверка обновление секунд
long TimeBlink = 500; // обновление пол секунды
long TimeBlinkCheck = 0; //проверка мигание настроек
long currentMillis = 0; // главный счетчик времени
bool JumpB = false; // прыжок или нет
bool BatteryB = false; // батарейка пуста или почти
bool hitON = false; // удар или нет
decode\_results results; // вывод результата данных с ИК
IRrecv irrecv(A0); // порт аналоговый под ИК модуль
enum { SYMBOL\_HEIGHT = 8 };
byte Player\_1[SYMBOL\_HEIGHT] = {B01110,B01110,B00100,B01110,B10101,B00100,B01110,B01010,};
byte Player\_2[SYMBOL\_HEIGHT] = {B00000,B01110,B01110,B00100,B11111,B00100,B01110,B01010,};
byte Enemy\_1[SYMBOL\_HEIGHT] = {B00010,B00110,B10111,B10110,B11111,B00110,B00110,B11111,};
byte Heart\_L[SYMBOL\_HEIGHT] = {B00000,B01010,B11111,B11111,B11111,B01110,B00100,B00000,};
byte Heart\_R[SYMBOL\_HEIGHT] = {B00000,B00000,B01010,B11111,B01110,B00100,B00000,B00000,};
byte Battery1[SYMBOL\_HEIGHT] = {B01110,B11111,B11111,B11111,B11111,B11111,B11111,B11111,};
byte Battery2[SYMBOL\_HEIGHT] = {B01110,B10001,B10011,B10111,B11111,B11111,B11111,B11111,};
byte Battery3[SYMBOL\_HEIGHT] = {B01110,B10001,B10001,B10001,B10011,B10111,B11111,B11111,};
byte Battery4[SYMBOL\_HEIGHT] = {B01110,B10001,B10001,B10001,B10001,B10001,B10001,B11111,};
void setup() {
Serial.begin(9600); // скорость порта
irrecv.enableIRIn(); // запускаем прием
lcd.init(); // запуск экрана
Wire.begin(); // запуск ИК
lcd.backlight();// Включаем подсветку дисплея
}
void loop() {
currentMillis = millis(); // присваиваем миллисекунды
IRCheck (); //запускаем функцию ИК модуля
if (AnimPlayer < 3){ // если герой анимируется, значит он жив, значит работаем дальше
if (LifeCheck == 3) {lcd.createChar(3, Battery1);} //показываем жизнь полная
if (LifeCheck == 2) {lcd.createChar(3, Battery2);} //показываем жизнь средняя
if (LifeCheck == 1) {//начинаем блинькать жизнью, когда 1 хп остался
if (BatteryB == false){lcd.createChar(3, Battery3);} //показываем жизнь почти пусто
if (BatteryB == true){lcd.createChar(3, Battery4);} //показываем жизнь пусто
if (currentMillis - BatteyBlinkCheck >= BatteyBlink) {BatteyBlinkCheck = currentMillis; //проверка времени
if (BatteryB == false) {BatteryB = true;} else {BatteryB = false;}} //меняем положение
}
timer(); //запуск таймера
check\_hit\_gg\_1 (); //запуск поверки урона
PlAn(); //запуск анимации ГГ
HeartHit (); // запуск анимации сердца
enemy\_go(); // запуск злодея
}
}
void IRCheck () // функция ИК порта
{
if ( irrecv.decode( &results )) // если данные пришли, то
{
if (results.value == 0xFF18E7 && GGpozY == 1){ // если нажали кнопку « 2 » и позиция на «Земле»
GGclear (); // очищаем прошлое местонахождение героя
GGpozY = 0; // выставляем позицию на 2ю полосу (типа прыжок)
JumpB = true; // переменная обозначающая что мы в фазе прыжка
JumpUPCheck = currentMillis; // обнуляем счетчик проверки времянахождения в воздухе
} // 2
if (results.value == 0xFF10EF && GGpozX >= 0){ // Если нажали на четверку и вы не упираетесь в левый край экрана
GGclear (); // тоже что и до этого
GGpozX -= 1; // перемещаем главного героя влево
} // 4
if (results.value == 0xFF5AA5 && GGpozX <= 15){ //если нажали шесть и не упираемся в правую сторону экрана
GGclear (); //должны были уже запомнить
GGpozX += 1; // перемещаем вправо
} // 6
if (results.value == 0xFF6897){ // 0 //если нажать ноль, то игра делает рестарт…
lcd.clear(); // очищаем экран
AnimPlayer = 1; //возвращаем переменную запуска анимации
LifeCheck = 3; // восстанавливаем ХП
Timer\_z = 0; // обнуляем счетчик
GGpozX = 8; // \/ \/ \/
GGpozY = 1; // возвращаем главного героя на центр экрана
Emeny\_check\_1 = 0; // возвращаем данные генератора кактусов
E1pozX = 16; // \/ \/ \/
E1pozY = 1; // выставляем стартовую позицию кактуса.
}
irrecv.resume(); // обнуляем данные датчика
}
}
void timer () // функция очков
{
if (currentMillis - DHTTimeRCheck >= DHTTimeR) // таймер который срабатывает раз в секунду
{
DHTTimeRCheck = currentMillis; // обнуление таймера
Timer\_z ++; // плюсуем единицу к общей сумме
lcd.setCursor(0, 0); // выставляем курсор на первую верхнюю точку
lcd.print(Timer\_z); // выводим данные на экран
}
}
// я переписал этот кусок кода и он будет отличаться от первой части статьи(чуток). Это для меня нормально =) На работоспособность, это никак не влияет но лучше использовать новый вариант.
void PlAn () // функция анимации главного героя
{
if (JumpB == true && GGpozY == 0){ // это контроль прыжка (активация прыжка будет в другой части кода) Если прыжок = правда И позиция нахождения наверху.
if (currentMillis - JumpUPCheck >= JumpUP) { // проверка времени в полете 0.8f
JumpB = false; GGclear (); GGpozY = 1; // когда время выходит, возвращаем нашего героя на землю и ждем следующего прыжка. Прыжок = лож; активация функции очищения местонахождения героя (); позиция вертикали главного героя = нижняя полоса;
}
}
if (AnimPlayer == 1){lcd.createChar(0, Player\_1);} //Если переменная контроля анимации один, записываем в ячейку памяти первый спрайт героя
if (AnimPlayer == 2){lcd.createChar(0, Player\_2);} //Если переменная контроля анимации два, записываем в ячейку памяти второй спрайт героя
if (AnimPlayer < 2) // если переменная до двух, выставляем курсор на то место, где находиться наш главный герой и рисуем из памяти спрайт героя
{
lcd.setCursor(GGpozX, GGpozY); // выставили на позицию
lcd.write(0); // отрисовали
}
if (currentMillis - AnimatedTimeCheck >= AnimatedTime) { // проверка времени
AnimatedTimeCheck = currentMillis; // обнуление времен
if (AnimPlayer == 2){AnimPlayer = 1;} // если переменная контроля анимации два то один
else{AnimPlayer = 2;} // а если один, то два.
}
}
void GGclear () // функция обновления героя
{
lcd.setCursor(GGpozX, GGpozY); // позиция героя
lcd.print(" "); //очищаем его
}
void enemy\_go () // функция злодея
{
if (Emeny\_check\_1 == 0) // что бы враг появлялся с случайно задержкой, нам надо сделать так что бы пока не было злодея на экране, у нас срабатывал рандом и при правильном числе, призывался злодей а этот рандом ждал пока он снова не понадобиться
{
Emeny\_control = random (100); // я подумал, если мы задействуем разные методы, то это будет интереснее, по этому, высчитать шанс появления злодея, можно будет рандомом.
if (Emeny\_control == 1) { // если рандом = 1 из 100 то запускаем злодея.
Emeny\_check\_1 = 1; // запускаем персонажа, по сути, тут можно использовать bool так как у нас два состояния, или да или нет, а мне сейчас переделывать было лень
hitON = false; // эта функция проверяет был ли нанесен урон главному герою
}
}
if (Emeny\_check\_1 == 1) // когда рандом одобрен, злодей пошел в бой
{
if (currentMillis - TimeBlinkCheck >= TimeBlink) //проверка временем 0.5f
{
TimeBlinkCheck = currentMillis; //обнуление проверки время
lcd.createChar(2, Enemy\_1); //присваиваем ячейке памяти 2 спрайт кактуса
lcd.setCursor(E1pozX, E1pozY); //выбрали 1ю точку кактуса
lcd.print(" "); //обнуляем ее
E1pozX--; //перемещаем влево на один шаг
lcd.setCursor(E1pozX, E1pozY); //выставляем 2ю позицию
lcd.write(2); //отрисовываем кактус
if (E1pozX <= 0) //если кактус дошел до края экрана
{
lcd.setCursor(0,1); //выставляем курсор на край экрана
lcd.print(" "); //обнуляем его
Emeny\_control = 0; //обнуляем функцию рандома
Emeny\_check\_1 = 0; //закрываем доступ к этой части скрипта
E1pozX = 16; // - \/ \/ \/
E1pozY = 1; // - выставляем катус обратно на позицию Х и У
}
}
}
}
void check\_hit\_gg\_1 () //функция получения урона
{
if (E1pozX == GGpozX && E1pozY == GGpozY && hitON == false){ //проверка что координаты Х и Y совпали, что у героя, что у кактуса
LifeCheck -= 1; // минусуем од ХП
hitON = true; // возвращаем проверку и теперь наш герой снова может получать урон
if (LifeCheck <= 0){ // если жизни меньше чем ноль
AnimPlayer = 50; //отключаем срабатывание loop ()
Emeny\_check\_1 = 50; // отключаем случайное срабатывание кактуса
lcd.clear(); //чистим экран
lcd.setCursor(3, 0); //устанавливаем курсор
lcd.print("GAME OVER"); // пишем заветное слово
}
} else { // НО! Если герой и кактус не сошлись в соитие то…
lcd.setCursor(13, 0); // устанавливаем курсор и …
lcd.write(1); // отображение сердечка
lcd.setCursor(14, 0);
lcd.print("="); // это просто равно
lcd.setCursor(15, 0);
lcd.write(3); // отображение батарейки
}
}
void HeartHit () // функция анимации сердечка
{
if (HeartControl == 0 || HeartControl == 2){lcd.createChar(1, Heart\_L);} //если наша переменная покажет ноль или два, мы в ячейку один записываем большое сердце
if (HeartControl == 1 || HeartControl == 3){lcd.createChar(1, Heart\_R);} //если наша переменная покажет один или два, мы в ячейку один записываем малое сердце
if (currentMillis - HeartHitBigCheck >= HeartHitBig) { // время большого зависания удара
if (currentMillis - HeartHitLightCheck >= HeartHitLight) { // время коротких ударов
HeartHitLightCheck = currentMillis; // обнуление контроля времени коротких ударов
if (HeartControl<3){HeartControl++;} // если переменная контроля отрисовки менее трех, то при каждом срабатывании скрипта мы плюсуем один к сумме
else {HeartControl = 0; HeartHitBigCheck = currentMillis;} //но если сумма переменной превысила три, то обнуляем ее и обнуляем счетчик длительного залипания сердца
}
}
}
"--------------------------------------------------------------------------"
```
По подключению. Код та мы сделали, а вот как собрать проводочки и что да куда втыкать, вот это я вам не объяснил. Хотя я и так уверен что более 80% тех, кто решит почитать эту статейку и так уже это знают, но как по мне, статья будет не полная, если я не предоставлю максимум информации.
A5 Дисплей 1602 — SCL
A4 Дисплей 1602 — SDA
A0 ИК датчик
Сейчас я занимаюсь над созданием радио ключа для машины на основе arduino, а на экране 1602 хочу вывести данные датчика влаги и температуры снаружи машины (так как я скоро буду в Москве, искать себе новую работу, мне надо будет знать что твориться за бортом машины так как там очень холодно), часы, вольтметр аккумулятора и туда-же поставить игры (у меня осталось 4 пина свободных, а мне надо еще стооолько туда впихнуть), что бы можно было на светофоре потыкать в эту игру или во вторую, которую я планирую сделать как гоночки старых добрых карманных приставок из 2000х где суть была просто объезжать препятствие и музыку поставить на фон из Rock n Roll Racing. Ухх классика =) и всунуть оптимально это все в одну arduino не используя внешние хранилища данных(чисто челендж), но я уже задействовал ~60 % и если код игры займет максимум 15% — 20%, то музыка… ох…там с этим будут проблемы, весит много, надо оптимизировать, я уже начал собирать трек и умудрился уменьшить вес почти в 10 раз, но я допустил ошибки в построении нот и тонов и теперь мне придется делать все заново. Я скорее всего потом напишу сюда полный вариант с описанием проекта, над которым я сейчас работаю. Надеюсь кому-то что-то новое для размышления я предоставил, если будет все хорошо и время, я продолжу писать статьи. Будут вопросы? Пишите в комментариях.
Все, подписывайтесь, ставьте лайки, следите за новыми выходами статей.
Всем спасибо за внимание, чао-какао!
P.S.: работоспособность игры снять на видео я пока что не могу, умерла камера на телефоне и это очень печально. Но я что-то придумаю и добавлю чуть позже видос в статью.
[**Первая часть статейки ->**](https://habr.com/post/424859/) | https://habr.com/ru/post/425367/ | null | ru | null |
# Настоящие ассоциативные массивы в JavaScript
Использование литерала объекта, как простого средства для хранения пар ключ-значение давно стало обычным делом в JavaScript. Тем не менее, литерал объекта всё же не является настоящим ассоциативным массивом и по этому, в некоторых ситуациях, его использование может привести к неожиданным результатам. Пока JS не предоставляет нативную реализацию ассоциативных массивов (не во всех браузерах, по крайней мере), существует отличная альтернатива объектам, с нужной функциональностью и без подводных камней.
### Проблема с объектами
Проблема заключается в цепочке прототипов. Любой новый объект наследует свойства и методы от Object.prototype, которые могут помешать нам однозначно определить существование ключа. Возьмем для примера метод `toString`, проверка наличия ключа с таким же именем, с помощью оператора `in` приведет к ложноположительному результату:
```
var map = {};
'toString' in map; // true
```
Это происходит потому что оператор `in`, не найдя свойство в экземпляре объекта, смотрит дальше по цепочке прототипов в поисках унаследованных значений. В нашем случае это метод `toString`. Чтобы решить эту проблему существует метод `hasOwnProperty` , который был задуман специально для того, чтобы проверить наличие свойств только в текущем объекте:
```
var map = {};
map.hasOwnProperty('toString'); // false
```
Этот приём отлично работает до тех пор, пока вы не напоретесь на ключ с именем «hasOwnProperty». Перезапись этого метода приведет к тому, что последующие его вызовы будут приводить к непредсказуемым результатам или ошибкам, в зависимости от нового значения:
```
var map = {};
map.hasOwnProperty = 'foo';
map.hasOwnProperty('hasOwnProperty'); // TypeError
```
Быстренько чиним и эту проблему. Для этого воспользуемся другим, нетронутым объект и вызовем его метод `hasOwnProperty` в контексте нашего объекта:
```
var map = {};
map.hasOwnProperty = 'foo';
{}.hasOwnProperty.call(map, 'hasOwnproperty'); // true
```
Вот, этот способ уже работает без проблем, но всё же он накладывает некоторые ограничения, на то как мы будем его использовать. Например, каждый раз, когда вы захотите перечислить свойства своего объекта с помощью `for ... in`, вам придется отфильтровывать всё унаследованное барахло:
```
var map = {};
var has = {}.hasOwnProperty;
for(var key in map){
if(has.call(map, key)){
// do something
}
}
```
Через какое-то время этот способ вас ужасающе утомит. Слава богу есть вариант получше.
### Голые объекты
Секрет создания чистого ассоциативного массива в избавлении от прототипа и всего того багажа, что он тащит с собой. Чтобы это осуществить, воспользуемся методом `Object.create`, [представленного в ES5](http://www.ecma-international.org/ecma-262/5.1/#sec-15.2.3.5). Уникальность этого метода в том, что вы можете явно определить прототип нового объекта. Например создадим обычный объект чуть более наглядно:
```
var obj = {};
// то же самое:
var obj = Object.create(Object.prototype);
```
Помимо того, что вы можете выбрать любой прототип, метод также дает вам возможность не выбирать прототип вовсе, просто передав `null` вместо него:
```
var map = Object.create(null);
map instanceof Object; // false
Object.prototype.isPrototypeOf(map); // false
Object.getPrototypeOf(map); // null
```
Эти голые объекты (или словари) идеально подходят для создания ассоциативных массивов, так как отсутствие `[[Prototype]]` убирает риск наткнуться на конфликт имён. И даже лучше! После того, как мы лишили объект всех унаследованных методов и свойств, любые попытки использовать его не по прямому назначению (хранилище), будут приводить к ошибкам:
```
var map = Object.create(null);
map + ""; // TypeError: Cannot convert object to primitive value
```
Нет ни примитивного значения, ни строкового представления. Голые объекты предназначены лишь для работы в качестве хранилища пар ключ-значение и точка.
Имейте в виду, что метода `hasOwnProperty` тоже больше нет, да он и не нужен, так как оператор `in` теперь прекрасно работает без каких-либо проверок.
```
var map = Object.create(null);
'toString' in map; // false
```
Более того, те утомительные циклы `for ... in` теперь стали гораздо проще. Наконец-то мы можем без опаски писать их так, как они и должны выглядеть:
```
var map = Object.create(null);
for(var key in map){
// do something
}
```
Несмотря на внесенные изменения, мы можем по-прежнему делать с объектами всё что нужно, как то использовать точечную нотацию или квадратные скобочки, превращать их в строку или использовать объект как контекст для любого метода из `Object.prototype`:
```
var map = Object.create(null);
Object.defineProperties(map, {
'foo': {
value: 1,
enumerable: true
},
'bar': {
value: 2,
enumerable: false
}
});
map.foo; // 1
map['bar']; // 2
JSON.stringify(map); // {"foo":1}
{}.hasOwnProperty.call(map, 'foo'); // true
{}.propertyIsEnumerable.call(map, 'bar'); // false
```
Даже различные способы проверки типов по прежнему будут работать:
```
var map = Object.create(null);
typeof map; // object
{}.toString.call(map); // [object Object]
{}.valueOf.call(map); // Object {}
```
Все это делает возможным без проблем заменить обычные объекты, используемые для создания ассоциативных массивов, на голые объекты, как в новых, так и в любых ранее созданных приложениях.
### Заключение
Если говорить о простых хранилищах пар ключ-значение, то голые объекты справятся с этой задачей однозначно лучше обычных объектов, избавив разработчика от всего лишнего. Для более функциональных структур данных придется подождать ES6 (ES2015), который предоставит нам нативные ассоциативные массивы в виде объектов [Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map), [Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) и других. А пока этот радужный момент не настал, голые объекты — лучший выбор. | https://habr.com/ru/post/259529/ | null | ru | null |
# Hetzner dedicated или в поисках дешевого хостинга
Хочу рассказать о том, как я озадачился поиском недорогого хостинга с поддержкой Java.
В начале решил, что неплохо бы купить железку, поставить ее дома, дать ей хороший канал и радоваться жизни. Но потом решил подсчитать примерную ежемесячную стоимость такого решения, и вышло, что 200Вт блок будет кушать ~3-4кВт в месяц (100-150Вт будет кушать железо), и это обойдется в 350-400 руб (у меня газовая плита).
Прибавим сюда хороший канал+ип, и имеем порядка 750 рублей (и это без резервного!).
Итого около 1000 рублей в месяц и еще порядка 8000 рублей уйдет разово на покупку компонентов, которые могут сойти за «файлопомойку» + UPS (>=2000 р) и мы видим что самостоятельно хостить «пару сайтов и почту» становится напряжных делом.
Кто-то предложит окупить это размещением проектов — но кто согласится платить на хостинг, которые висит дай-то бог на 30 мегабитах, при этом имеет шансы быть в offline из-за того, что кто-то перерезал провод в щитке, или у провайдера «опять сгорел dns».
Начал поиск я с матушки России и нашел хостинг от [brim.ru](http://brim.ru/hosting/vps.html) (через Хабропоиск), пообщался с суппортом, и предлагаемые условия, мягко говоря, ~~маловаты~~ стандартны.
*6. Память (базовые 256Мб) выделяется на
аккаунт (ядро, службы, приложения).
Расширение возможно — стоимость услуги:
100 руб/мес за 64Мб
7. Аккаунт существует на RAID 1 массиве.
Бэкапирование данных и/или образа
аккаунта не производится.*
цена 500 рублей в месяц, бекапы они не делают + есть ratio на трафик, то есть свои же бекапы себе же и будут портить жизнь (просто скачивая их) и в 256 мегабайтах Java не развернутся, как не толкайся (хотя я уверен, что мне напишут как выжать максимум из этого объема памяти, но для почты+jsp+php+ftp+DB это несерьезно).
#### Смотрим шире
Потолкавшись на скудном рынке с более заоблачными ценами я был заинтригован уймой предложений от 1.5$ в месяц и выше. Вышел на [mochahost.com](http://mochahost.com/) (не заметить трудно, ибо гугл пиарит его при любом запросе вида*java hosting*), который за 7 долларов готовый был предложить мне золотые горы, sftp и tomcat, безлимитный траффик и такое же место.
Что я могу сказать о них… там есть только задержка при коннекте на сервер, жутные лаги всего динамического, включая cPanel и ужасную техподдержку. Java на тарифе с Java они включать только по заявке в суппорт, активация аккаунта занимает 6+ часов. Возможно кому-то повезет с ними больше… если жить рядом с ДЦ… или вроде того.
Единственное их предназначение — это хостить почту. На минимальном тарифе можно обслуживать 1 домен и на нем почтовые аккаунты и всего за «доллар-девяносто-пять».
Пободавшить с суппортом (да-да-да! я в них верил, вернее в те 20$ которые там оставил) sftp так и не дали (всучили SSL), обработка JSP занимала целую вечность (секунда реакции, причем не в первый раз, а уже после того, как томкат ее «сжевал», JSP использует net.Socket).
#### Они ближе чем мы думали..
И я вернулся снова на темную дорожку поиска хостера. Яндекс вывел меня на разные русские ресурсы (Хабру в том числе), Гугл на зарубежные, но так же я вышел на VDS хостинг, и первое название что я увидел это было [Hetzner](http://www.hetzner.de/). Прочитав про него статьи, так же прочитав их Вики, просмотрев как пользователи здешнего портала без особых проблем ставили туда ФриБСД или любой образ из installimage я ими не на шутку заинтересовался.
Для начала заказал себе план VQ12, 1Гб памяти, 40 Гб места, линукс на выбор (и виндовс тоже) и 2 Тб траффика на 100 мегабитах.
Взяв уже готовый из коробки debian6@32, я почувствовал какова пропасть межну shared хостингом и (виртуальная машина, но все таки..) VDS. Поставил там nginx+tomcat+MySQL и начал радоваться жизни и всего за 12.9евро-19% = 10.84 евро (так как я русский, я VAT не плачу).
Далее были Dovecot+Postfix+sasl, сертификаты, база пользователей в MySQL, письма летять, логи пишутся, порты закрыты, ssh уехал с 22… Все было замечательно. И тарифный план ~430 рублей в месяц замечателен, но не хватает процессорной мощности.
Система бекапа сделана мною так, что в начале контент пакуется (часть со сжатием `7z a`, часть без `7z a -mx0`) в 7z, а следом он шифруется открытым ключем через gpg, размер ключа 4096, скидыватся в папку, которая привязана к поддомену в nginx.
Далее я дома запускаю `wget -r --no-check-certificate ....` и цепляю \*\*\*.7z.gpg, ну и в конце расшифровываю.
Вот в моменты шифрования я очень резко ощутил, как «процессор» зашкаливает на 100% и при этом почта на сервер начитает идти очень туго, jsp медлит, а roundcube бьет головой стену (можно было ограничить ресурсы для gpg, но помимо процессора мне понадобилось *need mooore free space*, об этом чуть ниже).
К тому же в тот момент я определился четко, что я буду размещать, и места в 40 Гб оказалось недостаточно (вернее через месяц-два такой момент мог возникнуть, ~30 Гб это почтовые аккаунты).
#### Все как у «взлослых»
Мой выбор пал на Dedicated «сервера». Почему «сервера», а не сервера? Потому, что они собраны на обычном железе, которое можно купить в любом магазине и которое вполне доступно. Был соблазн перейти на тариф EQ4, но для моих нужд 8Гб памяти и 1.5Тб места было как-то выше-крыши. Тем более на четверть дешевле были тарифы, которые меня устраивали.
И так я купил X3 *(икс-три)*. Из маленьких плюсов: обнаружил 5600+ процессор вместо 4200+ и 2 винта по 400Гб вместо «трехсоток». На текущий момент производительности системы хватает для решения задач, а месте для хранения нужных мне данных (и жадной почты в т.ч.). Жесткие работают в софтовом режиме RAID-1, так что к моим бекапам добавилось дополнительно зеркало. На него поставил в начале debian6@64, но процессы стали есть в 1.5-2 раза больше памяти, но пряник тоже был — по тесту `7z b` он выдает на 300 попугаев больше. В итоге был установлен debian6@32, диск размечен под нужды:
`PART swap swap 4G
PART /boot ext4 512M
PART /var ext4 32G
PART / ext4 16G
PART /usr ext4 all`, в качестве *админ сервера железного* я еще не волшебник, но, надеюсь, разметка не очернит общей информативности поста. var ограничил, так как туда по дефолту пишу логи, на корень на «всякий случай» 16 гигов, свап=2хпамять (обмусоливание этой темы было на [linux.org.ru](http://www.linux.org.ru/polls/polls/3748189)), а весь контент хранится в /usr
На данный момент полет сервера нормальный и я доволен как слон.
В заключении хочу сообщить, что я крайне не согласен с теми [авторами](http://habrahabr.ru/blogs/hosting/91466/), кто говорит (миф#5), что хостинг на магазинном железе это надувательство и детский сад. От себя хочу заметить, что множество задач успешно решаются на простом процессоре с 2-4Мб кеша и 2-4-мя адрами, и за мощности xeon'а, и за ECC, и за шустрый SAS, если их отсутствие не критично для проекта — переплачивать не надо.
Сервер VQ12 был готов за полчаса, сервер X3 был готов за час с небольшим.
#### Тестирование производительности
Ниже приклепляю небольшой тест производительности этих двух тарифных планов (увы, как не ~~гуглил~~ хабрил, никто тестов по этому немцу не выкладывал).
##### VQ12
`--> hdparm -tT /dev/sda
/dev/sda:
Timing cached reads: 16732 MB in 2.00 seconds = 8375.75 MB/sec
Timing buffered disk reads: 482 MB in 3.01 seconds = 160.37 MB/sec
===========
--> time echo '2 1000000 ^ p'|dc
real 0m5.592s
user 0m5.056s
sys 0m0.024s
===========
--> wget mirror.yandex.ru/debian-cd/6.0.0-live/i386/iso-hybrid/debian-live-6.0.0-i386-standard.iso
2011-03-21 22:06:50 (5.36 MB/s) - “debian-live-6.0.0-i386-standard.iso” saved [232783872/232783872]
===========
--> time taskset 0xFFFFFFFF 7z a test.7z debian-live-6.0.0-i386-standard.iso
7-Zip 9.04 beta Copyright (c) 1999-2009 Igor Pavlov 2009-05-30
p7zip Version 9.04 (locale=en_US.UTF-8,Utf16=on,HugeFiles=on,1 CPU)
Scanning
Creating archive test.7z
Compressing debian-live-6.0.0-i386-standard.iso
Everything is Ok
real 2m54.989s
user 2m44.754s
sys 0m8.989s
===========
--> taskset 0xFFFFFFFF 7z b
7-Zip 9.04 beta Copyright (c) 1999-2009 Igor Pavlov 2009-05-30
p7zip Version 9.04 (locale=en_US.UTF-8,Utf16=on,HugeFiles=on,1 CPU)
RAM size: 1010 MB, # CPU hardware threads: 1
RAM usage: 419 MB, # Benchmark threads: 1
Dict Compressing | Decompressing
Speed Usage R/U Rating | Speed Usage R/U Rating
KB/s % MIPS MIPS | KB/s % MIPS MIPS
22: 1607 100 1568 1563 | 19696 100 1778 1778
23: 1897 100 1933 1932 | 19965 100 1833 1828
24: 1788 100 1924 1922 | 20066 100 1865 1862
25: 1252 99 1439 1430 | 19535 100 1830 1837
----------------------------------------------------------------
Avr: 100 1716 1712 100 1827 1826
Tot: 100 1771 1769
===========
--> grep -m 4 -e "model name" -e "MHz" -e "cache size" -e "bogomips" /proc/cpuinfo
model name : QEMU Virtual CPU version 0.13.0
cpu MHz : 3073.982
cache size : 4096 KB
bogomips : 6147.96`
##### и X3 тариф
`--> hdparm -tT /dev/md4
/dev/md4:
Timing cached reads: 2148 MB in 2.00 seconds = 1074.50 MB/sec
Timing buffered disk reads: 220 MB in 3.02 seconds = 72.82 MB/sec
===========
--> time taskset 0xFFFFFFFF echo '2 1000000 ^ p'|dc
real 0m7.430s
user 0m6.660s
sys 0m0.036s
===========
--> wget mirror.yandex.ru/debian-cd/6.0.0-live/i386/iso-hybrid/debian-live-6.0.0-i386-standard.iso
2011-03-21 21:57:47 (6.45 MB/s) - “debian-live-6.0.0-i386-standard.iso” saved [232783872/232783872]
===========
--> time taskset 0xFFFFFFFF 7z a test.7z debian-live-6.0.0-i386-standard.iso
7-Zip 9.04 beta Copyright (c) 1999-2009 Igor Pavlov 2009-05-30
p7zip Version 9.04 (locale=en_US.UTF-8,Utf16=on,HugeFiles=on,2 CPUs)
Scanning
Creating archive test.7z
Compressing debian-live-6.0.0-i386-standard.iso
Everything is Ok
real 1m17.403s
user 2m29.109s
sys 0m1.452s
===========
--> taskset 0xFFFFFFFF 7z b
7-Zip 9.04 beta Copyright (c) 1999-2009 Igor Pavlov 2009-05-30
p7zip Version 9.04 (locale=en_US.UTF-8,Utf16=on,HugeFiles=on,2 CPUs)
RAM size: 1993 MB, # CPU hardware threads: 2
RAM usage: 425 MB, # Benchmark threads: 2
Dict Compressing | Decompressing
Speed Usage R/U Rating | Speed Usage R/U Rating
KB/s % MIPS MIPS | KB/s % MIPS MIPS
22: 3037 170 1736 2955 | 42922 200 1937 3875
23: 3077 176 1778 3135 | 42357 200 1941 3878
24: 3061 182 1808 3291 | 41719 200 1939 3871
25: 3023 178 1941 3452 | 41133 200 1936 3868
----------------------------------------------------------------
Avr: 177 1816 3208 200 1938 3873
Tot: 188 1877 3541
===========
--> grep -m 4 -e "model name" -e "MHz" -e "cache size" -e "bogomips" /proc/cpuinfo
model name : AMD Athlon(tm) 64 X2 Dual Core Processor 5600+
cpu MHz : 2800.000
cache size : 1024 KB
bogomips : 5599.72`
#### Дополнение:
taskset 0xFFFFFFFF cmd — это значит, что для обработки cmd будут задействаны все процессорные ядра.
time — чтобы узнать затраченное время.
1 раз скорость на VDS была 10Мб в сек при скачивании образа с яндекса, пруфа к сожалению нет.
Оба сервера находятся в территориально в одном и том же месте (была задан вопрос, так как меня интересовало, не потеря ли я пинг ~60-65 и хороший канал с Россией при смене тарифа и сервера): *your VQ-server is in DC12, your X3 is in DC13.
It is the same location*. | https://habr.com/ru/post/116017/ | null | ru | null |
# Настраиваем приватный Docker-репозиторий
 Docker одна из горячих тем в разработке. Большинство новых проектов строится именно на Docker. Как минимум, он отлично зарекомендовал себя для распространения ПО, например, наша система поиска по документам [Ambar](https://github.com/RD17/ambar) устанавливается с помощью `docker-compose`.
В начале работы над Ambar мы использовали публичный docker-репозиторий, но с ростом проекта и появлением enterprise версии мы задумались над созданием собственного приватного репозитория. В данной статье мы поделимся своим опытом развертывания селф-хостед репозитория: пошагово опишем весь процесс, попытаемся обойти все подводные камни.
Локальный docker-репозиторий
----------------------------
Итак, простейший Docker-репозиторий можно поднять одной командой
```
docker run -d -p 5000:5000 --restart=always --name registry registry:2
```
Для проверки репозитория зальем в него образ ubuntu.
1. Сначала скачаем образ с официального репозитория и добавим ему тег `localhost:5000/ubuntu`.
2. Запушим образ в наш новый репозиторий: `docker push localhost:5000/ubuntu`.
Хорошо, теперь мы умеем работать с локальным docker-репозиторием. Чтобы каждый раз не вспоминать команду запуска репозитория давайте создадим `docker-compose.yml` файл:
```
registry:
restart: always
image: registry:2
ports:
- 5000:5000
volumes:
- /path/data:/var/lib/registry /* раздел который будет использоваться как хранилище для вашего репозитория*/
```
Чтобы запустить репозиторий достаточно ввести команду `docker-compose up -d` в директории с `docker-compose` файлом. С локальным репозиторием разобрались, перейдем к настройке SSL.
Настройка SSL
-------------
Зачем нужен SSL? Docker-репозиторий который доступен из интернета должен работать только через защищенное https соединение. Есть возможность обойти это ограничение, использовать самоподписанные сертификаты, но как показывает практика это работает через раз и легче один раз настроить все правильно, благо для тех у кого нет SSL сертификата я расскажу как использовать [Letsencrypt](https://letsencrypt.org/getting-started/). Стоит упомянуть что SSL является обязательным условием для работы аутентификации в репозитории.
Если у вас есть SSL сертификат — указываем путь к нему в docker-compose файле, смотрите листинг ниже.
```
registry:
restart: always
image: registry:2
ports:
- 5000:5000
environment:
REGISTRY_HTTP_TLS_CERTIFICATE: /certs/domain.crt
REGISTRY_HTTP_TLS_KEY: /certs/domain.key
volumes:
- /path/data:/var/lib/registry
- /path/certs:/certs /* папка где хранитcя сертификат */
```
Если же SSL сертификата нет — лучший выход использовать Letsencrypt. В последних версиях docker он работает из коробки без предварительного создания сертификатов, правда рабочего примера я нигде не нашел, поэтому приведу его здесь.
```
registry:
restart: always
image: registry:2
ports:
- 443:5000 /* важно поменять порт с на 443, иначе letsencrypt работать не будет */
environment:
REGISTRY_HTTP_TLS_LETSENCRYPT_CACHEFILE: /cache.letsencrypt /* файл в котором будет храниться кэш letsencrypt*/
REGISTRY_HTTP_TLS_LETSENCRYPT_EMAIL: hello@rdseventeen.com /* email, который будет использоваться для создания учетной записи в letsencrypt */
volumes:
- /path/data:/var/lib/registry
```
Стоит обратить внимание на то что для корректной работы Letsencrypt необходимо поменять порт с 5000 на 443. Расположение кеша Letsencrypt может быть любым.
Для тестирования нашего репозитория выполним следующие команды:
```
docker pull ubuntu
docker tag ubuntu myregistrydomain.com:443/ubuntu
docker push myregistrydomain.com:443/ubuntu
docker pull myregistrydomain.com:443/ubuntu
```
Настраиваем аутентификацию
--------------------------
Защитим наш репозиторий паролем. Для этого необходимо создать файл с паролями и указать его docker-репозиторию. Следующая команда создаст пользователя `testuser` с паролем `testpassword`, поместит их в файл и сохранит его в path/auth/htpasswd.
```
docker run --entrypoint htpasswd registry:2 -Bbn testuser testpassword > path/auth/htpasswd
```
В docker-compose укажем путь к файлу с паролями и использование basic аутентификации
```
registry:
restart: always
image: registry:2
ports:
- 443:5000
environment:
REGISTRY_HTTP_TLS_LETSENCRYPT_CACHEFILE: /cache.letsencrypt
REGISTRY_HTTP_TLS_LETSENCRYPT_EMAIL: hello@rdseventeen.com
REGISTRY_AUTH: htpasswd
REGISTRY_AUTH_HTPASSWD_PATH: /auth/htpasswd
REGISTRY_AUTH_HTPASSWD_REALM: Registry Realm
volumes:
- /path/data:/var/lib/registry
- /path/auth:/auth
```
Для того чтобы изменения вступили в силу необходимо перезапустить docker-репозиторий. Используем команду `docker-compose restart`. Логинимся в созданный репозиторий с помощью команды `docker login myregistrydomain.com:443`. После этого наш репозиторий будет доступен для скачивания хранящихся в нём образов.
Итог
----
В статье мы рассмотрели создание приватного docker-репозитория. Для глубокого изучения темы рекомендую ознакомиться с [официальным мануалом](https://docs.docker.com/registry/deploying/) и [списком настроек репозитория](https://docs.docker.com/registry/configuration/).
Спасибо за внимание! | https://habr.com/ru/post/320884/ | null | ru | null |
# 5 неочевидных возможностей FastAPI: упрощаем работу с бэкендом на Python
API (Application Programming Interface) — технология, позволяющая соединить функциональность разных компьютерных программ. API можно сравнить с официантом, который получает от клиента заказ из ограниченных пунктов меню, передает его на кухню («системе»), а после приготовления, возвращает готовые «блюда» заказчику.
Почти все, с чем мы сталкиваемся в интернете, имеет отношение к API, а точнее к версиям этого программного интерфейса, использующим для работы HTTP-запросы. Когда мы хотим узнать прогноз погоды, интерфейс браузера или мобильного приложения вызывает API Яндекс.Погоды или API Gismeteo. Когда прокладываем кратчайший маршрут из одного места в другое, Яндекс.Карты вызывают соответствующее API.
Пользовательские API-интерфейсы могут быть реализованы на Python с использованием нескольких фреймворков. В этой статье остановимся на особенностях работы с одним из самых популярных вариантов — платформой FastAPI, библиотеки которой активно используют такие технологические гиганты, как Microsoft, Netflix, Uber. Речь пойдет о некоторых расширенных функциях FastAPI, которые могут использовать в своих проектах те разработчики, у кого уже есть базовые знания о фреймворке.
### Почему FastAPI
FastAPI — современная, высокопроизводительная веб-инфраструктура для создания готовых к эксплуатации HTTP API-серверов с помощью Python 3+. Производительность FastAPI можно сравнить с NodeJS и Go, поэтому он считается одним из самых быстрых фреймворков Python. Структура разработки очень похожа на Flask, который де-факто является базовым вариантом для всех, кто начинает веб-разработку с использованием Python.
FastAPI прост в использовании, хорошо задокументирован и обладает встроенными валидацией, сериализацией и асинхронностью «из коробки». Фреймворк предлагает все стандартные функции для создания API, но не ограничивается этим. Инструмент обладает большой гибкостью и множеством полезных функций (например, поддержкой обратного монтирования WSGI), которые остаются вне поля внимания большинства пользователей.
### Включите Flask, Django, Dash или любой другой WSGI
FastAPI — веб-фреймворк, использующий клиент-серверный протокол ASGI (Asynchronous Server Gateway Interface), который дает доступ к функциям параллельного выполнения кода. Но, с помощью [связки](https://fastapi.tiangolo.com/deployment/server-workers/) совместимых по рабочим классам HTTP-сервера Gunicorn и ASGI-сервера Uvicorn, FastAPI также поддерживает протокол WSGI (Web Server Gateway Interface) с последовательной обработкой запросов.
FastAPI позволяет монтировать любые WSGI-приложения, например, на фреймворках Dash, Flask, Django или CherryPy, внутри приложения FastAPI. На корневом уровне у вас может быть основное приложение FastAPI, дополненное WSGI-приложениями (например, на Flask), которые будут обрабатывать все запросы для этого конкретного пути.
Один из вариантов практической реализации этой функциональности — монтирование plotly-dash в качестве промежуточного программного обеспечения WSGI. Dash — популярный веб-фреймворк для визуализации данных на базе графиков plotly, включающий набор компонентов для работы с HTML и Bootstrap.
Я смонтировал сервер dash для маршрутизации панели инструментов моего веб-сайта. Это позволило отделить логику взаимодействия дашборда с основным приложением FastAPI, а также обеспечило гибкость отключения панели мониторинга в любое время, когда нагрузка на сервер возрастает.
Ниже приведен пример абстрактной реализации монтирования промежуточного ПО WSGI, которое я сделал для одного из проектов.
Файл *dashboard.py* с кодом сервера Plotly dash:
```
from dash import html
from dash import dcc
import dash_bootstrap_components as dbc
import dash
dash_app = dash.Dash(__name__,
requests_pathname_prefix='/dashboard/', title='Kaustubh Demo')
header = dbc.Row(
dbc.Col(
[
html.Div(style={"height": 30}),
html.H1("Demo", className="text-center"),
]
),
className="mb-4",
)
dash_app.layout = dbc.Container(
[
header,
],
fluid=True,
className="bg-light",
)
```
Чтобы включить Dash-сервер в качестве независимого приложения в FastAPI, просто оберните объект приложения WSGI в класс WSGIMiddleware и передайте этот обернутый объект в качестве параметра в функции монтирования корневого объекта FastAPI.
Функция монтирования также принимает путь, по которому следует использовать это приложение. Например, в приведенном ниже файле main.py, сервер дашборда plotly-dash в FastAPI будет смонтирован по пути «/dashboard»:
```
from fastapi import FastAPI
from fastapi.middleware.wsgi import WSGIMiddleware
from demo_dash import dash_app
import uvicorn
app = FastAPI()
app.mount("/dashboard", WSGIMiddleware(dash_app.server))
@app.get('/')
def index():
return "Hello"
if __name__ == "__main__":
uvicorn.run("main:app", host='127.0.0.1', port=8000, reload=True)
```
При реализации подобного сценария все запросы к панели управления будут перенаправлены на сервер dash.
Примеры логов из моего проекта, где показано перенаправление маршрута к панели управления на сервер Dash.### Смонтируйте отдельные приложения FastAPI для разных маршрутов
Правила монтирования приложений WSGI позволяют монтировать внутри одного приложения FastAPI несколько других самостоятельных приложений. Каждое подобное субприложение FastAPI будет иметь свою документацию, работать независимо от других приложений и будет обрабатывать свои запросы, зависящие от пути.
Чтобы реализовать подобную возможность, просто создайте файл первого субприложения (apiv1.py), как показано ниже:
```
from fastapi import FastAPI
apiv1 = FastAPI()
@apiv1.get('/returnName')
def index():
return {"Name": "Kaustubh demo"}
```
Теперь создайте файл второго субприложения (apiv2.py):
```
from fastapi import FastAPI
apiv2 = FastAPI()
@apiv2.get('/returnLocation')
def index():
return {"Location": "India"}
```
Теперь мы можем смонтировать оба этих субприложения в главном приложении (master.py) с помощью импорта объектов:
```
from fastapi import FastAPI
from apiv1 import apiv1
from apiv2 import apiv2
import uvicorn
app = FastAPI()
app.mount("/api/v1", apiv1)
app.mount("/api/v2", apiv2)
@app.get('/')
def index():
return "Hello"
if __name__ == "__main__":
uvicorn.run("master:app", host='127.0.0.1', port=8000, reload=True)
```
Если вы делаете запросы к эндпоинтам соответствующих путей, запрос будет обрабатываться этими субприложениями.
Здесь оба запроса обслуживались соответствующими приложениями.Удобство метода заключается в том, что он не требует промежуточного программного обеспечения.
### Разделите маршруты FastAPI на разные файлы
Обычно по мере того, как приложение укрупняется, управлять всеми маршрутами в одном месте становится неудобно и менее эффективно. Иногда могут происходить перекрытия или маршруты дублируются, последствия чего «всплывают» значительно позже. А можете ли вы представить систему, в которой есть возможность группировать маршруты в разные файловые структуры и легко ими управлять?
FastAPI имеет собственную систему API-маршрутизации. API-роуты (APIRouters) можно рассматривать как мини-приложения FastAPI, которые являются частью более крупного приложения. Это позволяет разбить большие маршруты приложений на небольшие блоки API-роутов и смонтировать их в основном приложении.
> **Обратите внимание!** Эти API-роуты не являются независимыми, как те, что мы видели в двух предыдущих разделах, а входят в основное приложение как составная часть. Поэтому все маршруты от API-роутов будут перечислены в основной документации приложения.
>
>
API-роуты могут иметь отдельные префиксы для операций пути, тегов, зависимостей и ответов. Чтобы реализовать это, нужно импортировать класс APIRouter из FastAPI, а затем использовать его объект для создания маршрутов, как в обычном приложении FastAPI.
Для примера предположим, что мы создаем систему управления библиотекой и хотим обрабатывать данные книг и новелл (рассказов) отдельно.
Реализуем это через применение APIRouter в файле book.py (для книг):
```
from fastapi import APIRouter
bookroute = APIRouter()
@bookroute.get('/info')
def books():
return {"detail": "This book info is from the book APIRouter",
"name": "Hello",
"ISBN": "32DS3"}
```
А этот код — пример использования APIRouter в файле novel.py (для новелл):
```
from fastapi import APIRouter
novelroute = APIRouter()
@novelroute.get('/info')
def novels():
return {"detail": "This novel info is from the novel APIRouter",
"name": "I am good",
"publication": "Kaustubh"}
```
Чтобы включить оба маршрутизатора в основное приложение, импортируем объекты APIRouter и передадим их в функцию include\_router основного объекта приложения FastAPI. Мы также добавим префиксы для этих маршрутизаторов, чтобы одни и те же эндпоинты на обоих маршрутизаторах не конфликтовали.
Пример кода для включения двух API-роутов (book.py и novel.py) в основное приложение:
```
from fastapi import FastAPI
from book import bookroute
from novel import novelroute
import uvicorn
app = FastAPI()
app.include_router(bookroute, prefix="/book")
app.include_router(novelroute, prefix="/novel")
@app.get('/')
def index():
return "Hello"
if __name__ == "__main__":
uvicorn.run("demo:app", host='127.0.0.1', port=8000, reload=True)
```
Если вы обратитесь к эндпоинтам книг «/book/info» и новелл «/novel/info», то получите разные ответы в зависимости от того, как обработались эти входные данные в API-роутах.
Эндпоинт книги в APIRouter.Эндпоинт новеллы в APIRouter.Таким образом, может быть несколько API-роутов для обработки параметров, в зависимости от того, какой тип операции нужно выполнить для разных групп эндпоинтов.
### Добавьте шаблоны Jinja и статические файлы
Возможности FastAPI не ограничиваются лишь созданием API. С помощью фреймворка можно также обрабатывать статические файлы (например, HTML, CSS, JS) и включать механизм шаблонов модуля Jinja, как это реализовано в Flask. Потенциально это означает, что с помощью FastAPI можно создать полноценный веб-сайт.
Возьмем для примера Flask. В этом фреймворке предусмотрена стандартная папка «templates», где можно хранить все файлы HTML с шаблонизатором Jinja. В основном приложении для возврата этих шаблонов с данными для заполнения можно напрямую использовать функцию render\_template.
В FastAPI процесс остается примерно тем же, но с небольшими изменениями. Рассмотрим его по шагам:
1. Для начала нужно создать объект для шаблонов Jinja с указанием пути к папке шаблонов. В FastAPI нет ограничений на имя папки — ее можно назвать как угодно, главное указать путь к ней. Для реализации нужно импортировать класс Jinja2Templates из модуля шаблонов FastAPI и создать объект для этого класса с путем к папке.
2. Затем нужно указать «response\_class» в методе маршрута FastAPI (например, GET, POST) в качестве класса HTMLResponse. Этот класс можно импортировать из модуля fastapi.responses. Также необходимо создать параметр запроса типа класса Request («Запрос») в функции декоратора. Этот класс также можно импортировать из модуля fastapi.responses.
3. Чтобы отобразить и предоставить данные этим шаблонам при достижении соответствующих эндпоинтов, необходимо вернуть функцию «TemplateResponse» объекта класса Jinja2Templates. Эта функция принимает имя шаблона HTML и контекстный словарь. Словарь должен иметь ключ Request («Запрос») со значением в качестве параметра запроса, созданного в функции декоратора. Данные, которые будут отправлены в шаблоны Jinja, могут быть добавлены в этот контекстный словарь как пара ключ-значение.
Так выглядит реализация использования шаблонов Jinja для FastAPI в виде кода:
```
from fastapi import FastAPI, Request
from fastapi.templating import Jinja2Templates
from fastapi.responses import HTMLResponse
import uvicorn
app = FastAPI()
templates = Jinja2Templates(directory="demo")
@app.get('/', response_class=HTMLResponse)
def index(request: Request):
return templates.TemplateResponse("demo.html", {"request": request, "title": "Kaustubh Demo", "body_content": "This is the demo for using FastAPI with Jinja templates"})
if __name__ == "__main__":
uvicorn.run("demo2:app", host='127.0.0.1', port=8000, reload=True)
```
Теперь в шаблонах HTML появится возможность заполнить переменные в соответствии с синтаксисом движка Jinja — с помощью имен, используемых в качестве ключей в контекстном словаре.
```
{{title}}
{{body\_content}}
```
Запустите приложение FastAPI, и вы получите следующий вывод:
Вывод для шаблона Jinja с кодом FastAPI.Чтобы включить все изображения, файлы JS и CSS в HTML, во Flask нужно использовать функцию url\_for и указать в имени папки атрибут «static», за которым следует параметр имени файла «filename».
В FastAPI алгоритм гораздо проще:
1. Создайте объект для класса StaticFiles из модуля статических файлов FastAPI и укажите путь к папке для статического файла. Опять же, нет никаких ограничений на имя папки.
2. Смонтируйте объект статических файлов по одному из путей (чтобы избежать путаницы, предпочтительно выбрать «static») и назначьте ему имя, которое будет использоваться внутри FastAPI.
Я добавил логику для статических файлов в тот же код, который используется для обслуживания файлов Jinja:
```
from fastapi import FastAPI, Request
from fastapi.templating import Jinja2Templates
from fastapi.staticfiles import StaticFiles
from fastapi.responses import HTMLResponse
import uvicorn
app = FastAPI()
staticfiles = StaticFiles(directory="demo/toServe")
app.mount("/static", staticfiles, name="static")
templates = Jinja2Templates(directory="demo")
@app.get('/', response_class=HTMLResponse)
def index(request: Request):
return templates.TemplateResponse("demo.html", {"request": request, "title": "Kaustubh Demo", "body_content": "This is the demo for using FastAPI with Jinja templates"})
if __name__ == "__main__":
uvicorn.run("demo3:app", host='127.0.0.1', port=8000, reload=True)
```
На примере выше я показал, что, используя возможность обрабатывать статические файлы и включать механизм шаблонов Jinja, вы сможете создать полноценный веб-сайт с поддержкой FastAPI.
### Используйте модель обработки конфигурации из Flask
Те, кто давно используют Flask, знают о такой функции веб-фреймворка, как конфигурация приложений. С ее помощью можно определить некоторые параметры приложения, которые будут доступны из любой его части. Обычно они включают переменные среды.
В Flask все конфигурации хранятся в атрибуте config — подклассе структуры данных словаря, который находится в объекте класса. Это особенно полезно, когда нужно жестко запрограммировать некоторые части приложения и иметь возможность вызывать их в любом месте.
Во Flask параметры конфигурации приложения определяются достаточно просто:
```
from flask import Flask
app = Flask(__name__)
app.config['appName'] = 'Kaustubh Demo'
@app.route('/')
def index():
return "Hello: {}".format(app.config['appName'])
if __name__ == "__main__":
app.run(debug=True)
```
В FastAPI подобная функциональность не поддерживается. Хотя распространено мнение, что в этом случае можно использовать состояние приложения, по [предложению](https://github.com/tiangolo/fastapi/issues/508#issuecomment-584245852) создателя FastAPI Себастьяна Рамиреса (aka tiangolo), APIRouter не будет иметь доступа к этому состоянию. Из-за этого, даже если вы сохраните некую конфигурацию в состоянии, она не будет использоваться всеми частями приложения и, в конечном счете, будет бесполезна.
Простой обходной путь, предложенный tiangolo, — использовать класс BaseSettings библиотеки Pydantic и создать модель для этих параметров. Этот класс предлагает функции проверки и аннотации типов, что выгодно отличает его от обычных переменных среды, где могут обрабатываться только значения строкового типа.
Чтобы получить подобный функционал в приложении FastAPI, просто импортируйте класс BaseSettings из Pydantic и создайте подкласс для ваших настроек/конфигураций. Так как мы имеем дело с классами Pydantic, можно добавлять значения по умолчанию, Field() и многое другое. Позвольте мне представить вам пример для реализации этого.
Ниже приведен пример импорта BaseSettings из Pydantic в файле config.py:
```
from pydantic import BaseSettings
class Settings(BaseSettings):
appName: str = "Kaustubh Demo"
openapi_url: str = ''
```
Здесь я определил «openapi\_url» как пустую строку. Это отключит генерацию документов для приложения FastAPI.
В основном файле приложения создайте объект для модели конфигурации и получите доступ к параметрам настроек, как если бы имели дело со структурой данных словарного типа:
```
from fastapi import FastAPI
from config import Settings
import uvicorn
setting = Settings()
app = FastAPI(openapi_url=setting.openapi_url)
@app.get('/')
def index():
return "Hello: {}".format(setting.appName)
if __name__ == "__main__":
uvicorn.run("fastapi_config:app", host='127.0.0.1', port=8000, reload=True)
```
Использование этой модели в качестве глобальной конфигурации устраняет зависимость от FastAPI при настройке отдельных частей приложения.
### Заключение
В этом кратком обзоре я описал все расширенные варианты использования FastAPI, с которыми сталкивался при разработке своих проектов. Тех, кто желает узнать больше об этих концепциях, а также найти собственные продвинутые варианты использования фреймворка, следует обратиться к [официальному источнику](https://fastapi.tiangolo.com/) знаний о нем. Потенциал этого инструмента способен дать многим разработчикам шанс повысить эффективность работы и творчески разнообразить свой привычный инструментарий.
---
НЛО прилетело и оставило здесь промокод для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**. | https://habr.com/ru/post/714688/ | null | ru | null |
# Kali Linux 2.0
Прошло уже более двух лет с момента выхода дистрибутива Kali 1.0. Сегодня вышла 2.0 версия этого дистрибутива.
Краткий экскурс: Kali linux представляет из себя дистрибутив, содержащий множество утилит для проведения тестирования на проникновение — от анализа уязвимостей веб-приложений, до взлома сетей и сервисов и закрепления в системе. Ранее этот дистрибутив был известен под названием Backtrack.
Обновление коснулось, прежде всего внешнего вида дистрибутива и стабильности работы:
* Основа: ядро 4.0, визуальный интерфейс Gnome 3.14.
* Дистрибутив: Debian Jessie
* Обновления: поддержка режима rolling distribution (rolling release).
* Актуальность: мониторинг и обновление входящих в дистрибутив утилит.
* Рабочее пространство: новый стиль, состав меню и интерфейс пользователя.
Как и предшествующая версия, новый дистрибутив мульти-платформенный и поддерживает следующие экосистемы: x32, x64, ARM. Существуют как Live дистрибутивы, так и образы виртуальных машин, а также готовые установочные наборы.
Для того чтобы обновиться с Kali 1.0 на 2.0 нужно подкорректировать файл source.list и запустить dist-upgrade.
```
cat << EOF > /etc/apt/sources.list
deb http://http.kali.org/kali sana main non-free contrib
deb http://security.kali.org/kali-security/ sana/updates main contrib non-free
EOF
apt-get update
apt-get dist-upgrade #необходимо немного подождать
reboot
```
[Скачать Kali Linux 2.0](https://defcon.ru/infosec-news/1121)
Для русскоязычных специалистов, желающих пройти подготовку в области этичного хакинга с использованием дистрибутива Kali Linux 2.0 рекомендуем ознакомиться с программой начальной ([Zero Security: A](https://www.pentestit.ru/study/zerosecurity-a)) и профессиональной ([Корпоративные лаборатории](https://www.pentestit.ru/labs/corp-lab)) подготовки от PENTESTIT. | https://habr.com/ru/post/264541/ | null | ru | null |
# Как обрабатывать alert, prompt и confirm в Selenium 4
В этом посте рассмотрим обработку модальных окон alert, prompt и confirm в Selenium.
### О чем вообще речь?
На странице <https://the-internet.herokuapp.com/javascript_alerts> приведены примеры трех видов модальных всплывающих окон в JavaScript: alert, prompt и confirm. При нажатии на кнопки появляются соответствующие окна.
### Давайте посмотрим, как работать с ними в Selenium 4
```
package test;
import java.time.Duration;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.Chormedriver;
public class alert {
public static void main(String[] args){
WebDriverManager.chromedriver().setup();
WebDriver driver = new ChromeDriver();
driver.manage().timeouts().implicitWwait(Duration.ofSeconds(10));
driver.get("https://the-internet.herokuapp.com/javascript_alerts");
//this is js alerts
driver.findElement(By.xpath("//button[@onclick='jsAlert()']")).click();
Alert alerts1 = driver.switchTo().alert();
System.out.println(alert1.getText());
alert1.accept();
if(driver.getPageSource().contains("sucessfully clicked an alert"))
System.out.println("sucessfully clicked an alert");
//this is js confirm
driver.findElement(By.xpath("//button[@onclick='jsConfirm()']")).click();
Alert alerts2 = driver.switchTo().alert();
System.out.println(alert2.getText());
alerts2.dismiss();
if(driver.getPageSource().contains("you clicked: Cancel"))
System.out.println("you clicked: Cancel");
//js Prompt
driver.findElement(By.xpath("//button[@onclick='jsPrompt()']")).click();
Alert alerts3 = driver.switchTo().alert();
System.out.println(alert3.getText());
alerts2.sendKeys("this is selenium 4");
alert3.accept();
if(driver.getPageSource().contains("you entered: this is selenium 4"))
System.out.println("you entered: this is selenium 4");
driver.close();
driver.quit();
}
}
```
### Разберемся, что здесь происходит
Начинаем с запуска браузера Chrome
```
WebDriver driver = new ChromeDriver();
```
И переходим на страницу <https://the-internet.herokuapp.com/javascript_alerts>.
Далее по очереди нажимаем кнопки показа всплывающих сообщений и обрабатываем эти события. Начинаем с alert.
```
driver.findElement(By.xpath("//button[@onclick='jsAlert()']")).click();
```
Кнопку для алерта находим по тэгу button и значению свойства onclick. Кликаем по кнопке и получаем модальное сообщение. Далее переключаемся на него, выполнив `driver.switchTo().alert()`, и сохраняем объект алерта в переменную alert1.
```
Alert alert1 = driver.switchTo().alert();
```
Для закрытия алерта выполняем `alert1.accept()`.
Также после закрытия окон будем проверять текст на странице. Например, при закрытии алерта, появляющегося при нажатии кнопки "Click for JS Alert" на странице должно появиться сообщение "You successfully clicked an alert" (Вы успешно кликнули на алерт).
```
if(driver.getPageSource().contains("sucessfully clicked an alert"))
System.out.println("sucessfully clicked an alert")
```
То же самое делаем для JS Confirm, но на этот раз нажмем "Отмена", вызвав метод `dismiss()`.
```
driver.findElement(By.xpath("//button[@onclick='jsConfirm()']")).click();
Alert alert2 = driver.switchTo().alert();
System.out.println(alert2.getText());
alert2.dismiss();
```
Проверяем сообщение "You clicked: Cancel" (Вы нажали: Отмена).
```
if(driver.getPageSource().contains("you clicked: Cancel"))
System.out.println("you clicked: Cancel");
```
Теперь давайте посмотрим на окно JS Prompt.
```
driver.findElement(By.xpath("//button[@onclick='jsPrompt()']")).click();
Alert alert3 = driver.switchTo().alert();
System.out.println(alert3.getText());
```
При клике на кнопку "Click for JS Prompt" появляется окно с текстовым полем, в которое мы вводим текст.
```
alert3.sendKeys("this is selenium 4");
alert3.accept();
```
И проверяем, сообщение на странице - "You entered: this is selenium 4" (Вы ввели: this is selenium 4)
```
if(driver.getPageSource().contains("you entered: this is selenium 4"))
System.out.println("you entered: this is selenium 4");
```
#### Ссылки
[Selenium / Documentation / WebDriver](https://www.selenium.dev/documentation/webdriver/)
---
> Народная мудрость гласит: Любишь запросы по API отправлять, умей и json парсить! Приходите на открытое занятие, на котором познакомимся с фреймворком RestAssured, позволяющий написать автотесты на API, и JsonSchemaValidator для проверки ответа от сервера. Регистрация открыта [по ссылке.](https://otus.pw/GRhL/)
>
> | https://habr.com/ru/post/696988/ | null | ru | null |
# Digital art и искусственный интеллект — симбиоз цифр и искусства
Рис.1 Vox-модель c графическими паттернамиВ качестве предисловия оговорюсь, что на Хабре я впервые, решил представить свою дебют на этой платформе, так сказать. Речь здесь не пойдёт о рисовании картин с использованием AI и графических паттернов. Скорее наоборот, превращение классического изобразительного исксства в многочисленную последовательность нейронных сетей в итоговым кодом в заключительном виде. Расскажу предысторию. В начале этого года, случайным образом, попало в моё поле зрения одно заманчивое словосочетание - digital art. И так как я в теме crypto уже давненько, я не смел не поинтересоваться, каким образом искусство (будь то живопись или музыка) коррелирует с криптой, и как это происходит (и для чего))) на просторах блокчейна. В итоге ознакомления с этой идеей, и не только идеей, но и инфраструктурой NFT (Non-Fungible-Token, невзаимозаменяемый цифровой актив), я с радостью обнаружил что уже хочу создать что-то подобное, но в своём, авторском исполнении. Парой слов опишу, что зверёк по имени НФТ это хэшированное изображение в любом формате, записанное в сети блокчейн в формате, являющегося аналогом ERC-721 в сети Ethereum (для тех кто ещё не в курсе темы). Задуманному быть конечно, но сказать легко, а вот сделать - труднее. Особенно, когда делаешь что-то впервые. Начал я с изучения подобных платформ на просторах всемирной паутины, начиная с крупнейших маркетплейсов [opensea.io](http://opensea.io), [makersplace.com](http://makersplace.com), и не очень крупных, [pixeos.art](http://gallery.pixeos.art), [ghostmarket.io](http://ghostmarket.io) и много много других.
Кроме маркетплейсов, я обнаружил чисто minting-платформы, как правило тематические, т.е. они занимаются только созданием NFT карточек и как-правило одного направления. Криптокотики всякие (с них всё и началось!), Криптопанки и прочая фауна. Нашлось кроме всего пару аутсайдеров, которые вовсе создавали неформатные NFT, с прицелом на автоматическое масштабирование за счёт пользователей, к примеру на одной из платформ за NFT контент принимаются уникальные ссылки в интернете, на другой - регистрируются домены, а заодно и снимок с NFT. Не буду сильно углубляться в обозревание ежедневно растущего формата цифровых активов NFT, а лучше наконец-то перейду к своей задумке.
Задумка была очень простая - любые начинающие или маститые художники (как digital, так и классические, с полотнами и красками -прим. автора) регистрируются на моей платформе, сканируют и заливают свой контент, после чего получают бесплатно цифровую копию своего произведения в виде NFT-токена. Условную бесплатность таких преобразований может обеспечить блокчейны с почти 0 стоимостью транзакций, к примеру Binance Smart Chain.
Платформа позиционируется на крупных и не очень маркетплейсах, что по сути является бесконечной выставкой арт-изделий для исходного создателя на мировом рынке картин! Чем не мечта для автора произведений, отдельных галерей разных художников? Мечтать не вредно, как говориться. Рынок этот растёт не по годам, а по месяцам по моим наблюдениям, что можно заметить на знаменитом мониторинге [dappradar.com](http://dappradar.com) Если отбросить пока все аспекты юридического и маркетингово характера, а оставить лишь техническую область решения поставленной задачи, всё равно лбом бьёшься об реальность существующей (и будущей, глаза боятся :() конкуренции.. Поэтому было решено сделать не просто платформу с названием N, а платформу со своим, уникальным оттенком как в арт, так и в техно смысле. Немного подумав было решено внедрить в процесс вышеописанного алгоритма искусственный интеллект. Это даст платформе во-первых свой уникальный почерк, свою фишку, во-вторых уникальную особенность самостоятельно оценивать стиль написания, применяемые техники прорисовки и качество написания графического произведения. Вплоть до уровня профессионализма самого художника, даже если проходя мимо, взял случайно кисть маэстро и намалевал сходу что-то непонятное. Как это воплотить при помощи существующих библиотек AI? Легко, потребуются лишь века на обучение нашего машинального эксперта.. Это в идеале, а для запуска платформы я рассчитывал сделать это за пару месяцев, что было не лишено оптимизма, как показала практика.
Рис.2 Пример нахождения критериев по включению определённых паттернов в картине типа скетч*Ну теперь обо всём по-порядку..*
*Во-первых,* необходимо сразу было встать на путь истинный (лучший) и выбрать самую наработанную и в то же время не требующую чрезмерных ресурсов платформу. Выбор пал на использование tensors, исходя из поставленной задачи и многогранности дальнейших ответвлений. В итоге были отобраны 2 наиболее развитые библиотеки TensorFlow 2х и PyTorch (библиотеки AI от Facebook). Сделал бинарный классификатор на Python 3.x, что заняло совсем немного времени, и началось самое интересное - процесс первичного обучения.
```
from torch.utils.data import Dataset, DataLoader
import argparse
from skimage import io
from skimage.color import gray2rgb, rgba2rgb
from skimage.util import img_as_ubyte
import numpy as np
import albumentations
import torch, os
import random, time, pickle
from tqdm import tqdm
from effnetv2 import effnetv2_s
import matplotlib.pyplot as plt
from PIL import Image
Image.MAX_IMAGE_PIXELS = 512**3
print("Start with parameters:")
if __name__ == '__main__':
parser = argparse.ArgumentParser()
# папка с исходными данными / source folder with data
parser.add_argument('--data_folder', type=str, default='data')
# число эпох обучения / number epoches
parser.add_argument('--num_epochs', type=int, default=150)
# файл для сохранения весов лучшей модели / best weights file
parser.add_argument('--best_weights', type=str, default='./best_weights.pth')
# файл для сохранения весов модели на последней итерации обучения / last weights file
parser.add_argument('--last_weights', type=str, default='./last_weights.pth')
# файл визуализации тренировки / visualization of training process
parser.add_argument('--viz_file', type=str, default='./train_val_learn.png')
# коэффициент обучения / learning rate
parser.add_argument('--lr', type=float, default=1e-4)
# размер партти для обучения / batch size
parser.add_argument('--batch_size', type=str, default=4)
# размер изображения при обучении / image size
parser.add_argument('--image_size', type=int, default=528)
# парсинг параметров / parsing of parameters
opt = parser.parse_args()
print(opt)
```
*Во-вторых*, необходимо как следует обучить созданный скрипт, в идеале эпох десять (эпоха - цикл обучения, где за исходных массив берём 10000 экземпляров каждого класса). Здесь кроется самое зёрнышко всей затеи, чем качественней будут исходные данные и сам процесс, тем правильней будет дальнейшая оценка вводныхданных, меньше процент ошибок. А вводные данные в моём случае - реальные произведения искусства. Не могу даже представить, сколько стилей написания картин существует в современном арте. А техники написания, инструменты (кисть, карандаш, мозайка, уголь, пиксели наконец), а школы современного и классического исксусства, а состояние исходного макета? Оригинал, копия, репродукция и прочие нюансы. По самым приблизительным расчётам, такой набор обучающих циклов будет достигать сотни, если не тысячи, и годы по времени их претворения, дальнейшего тестирования.. Я решил для тестовой версии программы модуля использовать лишь 3 простых шага: 1) отфильтровать фото это или не фото (скан с полотна, цифровое произведение, иное), 2) отфильтровать по признаку наличия цветности или его отсутствия (цветное или ч.б), 3) отсортировать по признаку наличия на изображении живой материи или её отсутствия (наличие людей, животных, растений). Была реализована модель EfficientNetV2 на рабочем разрешении 528х528px Сеть может быть обучена в 3 -х вариантах. В моём варианте сеть была обучена в варианте small.
файл [effnetv2.py](http://effnetv2.py) - описывает структуру модели на pytorch
crt\_[ftable.py](http://ftable.py) - скрипт, который запускается первым для генерации таблиц обучения, валидации и классов
Данные должны быть в папке data. в подпапке photo - фото, в подпапке nphoto - не фото
Скрипт [train.py](http://train.py) - главный скрипт для обучения, все его параметры описаны внутри
Скрипт [eval.py](http://eval.py) - скрипт для демострации "раскладки" файлов из папки input в папку output
last\_weights.pth - это веса модели, сохраненные на последней эпохи
best\_weights.pth - веса, при которых достигалась наименьшая ошибка по валидации.
Достигнута точность модели на валидации в 98%. Задачи обучения и валидации проходили последовательно, сначала прогонялся массив фото-нефото, потом цвет-нецвет и в завершении живое-неживое. Про мелкие баги и сбои я решил не освещать, но скажу сразу что столкнулся с игнором скрипта многих типов картинок tif, png и прочие в самом начале, пришлось добавлять форматы для исходных файлов вручную.
*Продолжение следует..* | https://habr.com/ru/post/648507/ | null | ru | null |
# Лень, нетерпение и самомнение — три главных добродетели программиста. С днем рождения, Ларри Уолл
*«Мне кажется, я иногда вижу сны на Perl`e»*
— Ларри Уолл
1. Ларри всегда по определению прав по поводу того, как Perl должен себя вести. Это значит, что у него финальное право вето на основные функциональные возможности.
2. Ларри позволительно менять свое мнение по любому вопросу спустя какое-то время, независимо от того, использовал ли он Правило 1.
Уяснили? Ларри всегда прав, даже когда ошибается.
Компактная биография Ларри выглядит вот так ([Geek-код](https://ru.wikipedia.org/wiki/Geek-%D0%BA%D0%BE%D0%B4)): GC/CS/E/H/IT/L/M/MU/PA/P/S/SS/TW/O d(+++)>+ s: a+>++>+++$ C++++$ UBAHS\*++++$ P+++++(--)$ L !E? W+>++ N+++@ K+++>++++++@ w$ !O M->+ V--() PS+(-) PE(++) Y+ PGP->+ t+() 5 X? R>\* tv@ b++>+++ DI+++ D? G(-) e++>+++@ h----() r+++ y++++ ([расшифровка](https://habrahabr.ru/company/edison/blog/310938/#1))
Ларри, как потомственный пастор, в детстве мечтал стать служителем церкви. Но пришлось идти в ИТ. Студетнтом он 3 годаработал в компьютерном центре университета. После универа, вместе с женой работали переводчиками Библии, изучали лингвистику, в надежде на то, что где-нибудь в Африке обнаружется племя со своим языком, но без письменности, и они разработают под этот язык письменность и одарят туземцев. В роли туземцев, спустя годы, оказались программисты.
Из-за денег, Ларри успел поработать в Unisys, NASA (JPL) и O'Reilly.
Из-за лени, нетерпения и самомнения Ларри написал [rn](https://en.wikipedia.org/wiki/Rn_(newsreader)) (популярный клиент для Usenet) и утилиту [patch](https://ru.wikipedia.org/wiki/Patch_(UNIX)) (под UNIX). Чтобы стать пожизненным великодушным диктаторм, он написал язык Perl.
Ларри верит в типологию Майерс-Бриггс ([INFP](http://www.personalitypage.com/INFP.html)), а еще он двукратный мировой чемпион по запутанному коду на С.
> [](https://www.edsd.ru/ "EDISON Software - web-development")
>
> Компания EDISON присоединяется к поздравлениям.
>
>
>
> [](https://www.edsd.ru/ru/o_kompanii/novosti/sovety-yunioram)
>
> Следуя принципам Ларри Уолла о максимальном содействии всеобщему счастью, с радостью делимся [советами для юниоров, как достичь вершин в искусстве программирования](https://www.edsd.ru/ru/o_kompanii/novosti/sovety-yunioram).
>
>
>
> Ещё советуем почитать рекомендации [как инженеру получить необходимый опыт](https://www.edsd.ru/ru/o_kompanii/novosti/kak-inzheneru-poluchit-neobhodimyj-opyt).
Perl
----
> *«Большая часть в изучении языка Perl — это изучение того как Ларри (автор языка) мыслит. Следовательно, как только вы сможете мыслить также, как это делает Ларри, вы будете знать, что должен делать Perl в каждом случае. Но пока вы учитесь, следует порой заглядывать в документацию.»*
**«There’s More Than One Way To Do It»** («Есть больше одного способа сделать это») — девиз языка Perl. Этот принцип с самого начала имелся в виду при создании данного языка программирования. В соответствии с этой идеей синтаксис языка предоставляет программисту множество возможностей для записи одного и того же алгоритма, позволяя выбирать ту из них, которая кажется наиболее удобной и эффективной в данном конкретном случае. С одной стороны, это упрощает написание кода — нужно знать лишь один способ из многих, с другой — усложняет чтение чужого кода, т.к. для этого нужно знать все способы, которые могут встретиться.
Логотипом Perl 6 выбрали весёленькую бабочку. Как (полушутя) пояснил Уолл на конференции в октябре 2015 года, это было сделано специально для того, чтобы сделать язык привлекательным для 7-летних девочек.
Немного перлов от Ларри
-----------------------
«Путешествие в тысячу миль продолжается со второго шага.»
«Настоящие программисты могут написать ассемблерный код на любом языке.»
«Теперь основным приоритетом станет исправление ошибок, которые случайно могут быть приняты за новые возможности.» (про Perl 6.0.0)
«И существует мета-мета, мета-мета-мета цель. Это, конечно, наслаждаться жизнью. Когда ты молод, то наслаждаться жизнью это значит „я наслаждаюсь жизнью“. Когда ты становишься чуть старше, как я, то начинаешь наслаждаться помогая другим людям наслаждаться жизнью. Ну и тут есть баланс.»
«Истинное величие измеряется в количестве свободы, которую вы даете другим, а не в количестве людей, которых заставляете сделать то, что хотите.»
«Мы все согласны с необходимостью компромисса. Мы просто не можем согласиться на компромисс, когда это необходимо.»
International Obfuscated C Code Contest (IOCCC)
-----------------------------------------------
> *If you want to program in C, program in C. It's a nice language. I use it occasionally...*
«Международный Конкурс запутывания кода на С» — конкурс программирования, в котором задачей участников является написание максимально запутанного кода на языке С.
Ларри выиграл дважды.
* Grand prize in most well-rounded in confusion (1986/wall/wall.c)
* Most Useful Obfuscation (1987/wall/wall.c)
**1986**
```
#define _c(C)_ (C)&('|'+3):c_()(C)>>('\n'-3) __; /**/
#define C char*
#define keyboard ",,B3-u;.(&*5., /(b*(1\036!a%\031m,,,,,\r\n"
#define main(o,oo)oo(o){
#define _ ;case
C
#define c_(cc)c cc=
#define C_(sand)_O(sand)witch
o=keyboard;
#define __ ;break;
C
ccc(
cc)
C
cc;
{
C
cccc=
cc;int
#ifndef lint
#define keyboard "dijs QH.soav Vdtnsaoh DmfpaksoQz;kkt oa, -dijs"
#endif
c;
main(;c_(=(*cc);*cc++)c,for);
#define _O(s)s
main(0xb+(c>>5),C_(s))
_'\v'
:__ _'\f':
main(c,C_(s));
_c(8098)_c(6055)_c(14779)_c(10682)
#define O_(O)_O(O)stem(ccc(
_c(15276)_c(11196)_c(15150)
#define _C ;return
_c(11070)_c(15663)_c(11583)
}
__
default
:c_(+)o[c&__LINE__-007];
main(c_(-)'-'-1,C_(s))_
0214
:_
0216
:c_(+)025 _
0207
:c_(-)4 _
0233
:c_(+)' '-1;
}}c_(&)'z'+5;
}_C cccc;
}main(,cc)
C
#define O write(1,
c="O";
O_(sy) keyboard));
main(;;,for);
read(0,
c,1);*
c_(&)'~'+1
;O ccc(
c),
'\0');
main(*c,
C_(s));_
4
:O_(sy)";kkt -oa, dijszdijs QQ"))_C
_
13
:O o+' ',
3
)
#undef main
__ _ 127:O"\b \b",3)__
default
:O
c,1)
__}}}main(){
cc();
# The grand prize in most well-rounded in confusion
Larry Wall
System Development Corporation
Santa Monica
California
US of A
## Judges' comments:
The original version did not have a ';' character in the first line.
This caused a number of System V C pre-preprocessors to gripe about a
syntax error.
This program is a masterpiece of obfuscation and humor. Larry Wall
(the hacker who gave us rn and patch) asks you to compile and consider
the warning message generated by the C compiler. Then execute the
program and type charters into its standard input. You will see why
the compiler documents the program.
Copyright (c) 1986, Landon Curt Noll & Larry Bassel.
All Rights Reserved. Permission for personal, educational or non-profit use is
granted provided this this copyright and notice are included in its entirety
and remains unaltered. All other uses must receive prior permission in writing
from both Landon Curt Noll and Larry Bassel.
```
}
**1987**
```
#define iv 4
#define v ;(void
#define XI(xi)int xi[iv*'V'];
#define L(c,l,i)c(){d(l);m(i);}
#include
int\*cc,c,i,ix='\t',exit(),X='\n'\*'\d';XI(VI)XI(xi)extern(\*vi[])(),(\*
signal())();char\*V,cm,D['x'],M='\n',I,\*gets();L(MV,V,(c+='d',ix))m(x){v)
signal(X/'I',vi[x]);}d(x)char\*x;{v)write(i,x,i);}L(MC,V,M+I)xv(){c>=i?m(
c/M/M+M):(d(&M),m(cm));}L(mi,V+cm,M)L(md,V,M)MM(){c=c\*M%X;V-=cm;m(ix);}
LXX(){gets(D)||(vi[iv])();c=atoi(D);while(c>=X){c-=X;d("m");}V="ivxlcdm"
+iv;m(ix);}LV(){c-=c;while((i=cc[\*D=getchar()])>-I)i?(c?(c>I;cc[-I]-=ix v)close(\*VI);cc[M]-=M;}main(){
(\*vi)();for(;v)write(VI[I],V,M));}l(xl,lx)char\*lx;{v)printf(lx,xl)v)
fflush(stdout);}L(xx,V+I,(c-=X/cm,ix))int(\*vi[])()={ii,li,LXX,LV,exit,l,
d,l,d,xv,MM,md,MC,ml,MV,xx,xx,xx,xx,MV,mi};
# Most Useful Obfuscation
Larry Wall
Unisys - System Development Group Santa Monica
9132 Kester Ave
Panorama City, CA 91402 USA
## Judges' comments:
### Try:
lwall | bc | lwall
input: x\*x
input: c^2
### Also try:
lwall | bc and lwall | cat
What we found amazing was how the flow of control was transferred
between subroutines. Careful inspection will show that the array of
pointers to functions named 'vi' refers to functions which seem to not
be directly called. Even so, these pointers to functions are being
used as an argument to signal. Can you determine why this is being
done and how it is being exploited?
Some compilers complained about this file, so we changed: '=++I' to '= ++I'.
Copyright (c) 1987, Landon Curt Noll & Larry Bassel.
All Rights Reserved. Permission for personal, educational or non-profit use is
granted provided this this copyright and notice are included in its entirety
and remains unaltered. All other uses must receive prior permission in writing
from both Landon Curt Noll and Larry Bassel.
```
Дополнительные материалы
------------------------
* Статья на Хабре — [«История языков программирования: Perl — необычный язык, созданный лингвистом для программистов»](https://habrahabr.ru/post/305402/).
* Статья Ларри — [«Perl, the first postmodern computer language»](http://www.wall.org/~larry/pm.html).
* [Дневник Ларри](http://www.wall.org/~larry/cornea.html) после трансплантации роговицы.
**Decoded Geek Code**
**GEEK TYPE CODE [GC/CS/E/H/IT/L/M/MU/PA/P/S/SS/TW/O]**
Geek of Classics, Geek of Computer Science, Geek of Engineering, Geek of Humanities, Geek of Information Technology, Geek of Literature, Geek of Math, Geek of Music, Geek of Performing Arts, Geek of Philosophy, Geek of Science (Physics, Chemistry, Biology, etc.), Geek of Social Science (Psychology, Sociology, etc.), Geek of Technical Writing, Geek of Other.
**GEEK DRESS CODE [d(+++)>+]**
My tendencies on this issue range from: «I dress a lot like those found in catalog ads. Bland, boring, without life or meaning.», to: «I tend to wear conservative dress such as a business suit or worse, a tie. Good leisure-wear. Slacks, button-shirt, etc. No jeans, tennis shoes, or t-shirts.» But someday I'd like to say: «Good leisure-wear. Slacks, button-shirt, etc. No jeans, tennis shoes, or t-shirts.»
**GEEK SHAPE CODE [s:]**
I'm an average geek.
**GEEK AGE CODE [a+>++>+++$]**
My age is 40-49. But someday I'd like to say: «My age is 50-59.» But someday I'd like to say: «My age is 60 and up. Getting paid for it!»
**GEEK COMPUTERS CODE [C++++$]**
I'll be first in line to get the new cybernetic interface installed into my skull. Getting paid for it!
**GEEK UNIX CODE [UBAHS\*++++$]**
I use BSD, AIX, HPUX, SunOS/Solaris and some other(s) not listed. I am the sysadmin. If you try and crack my machine don't be surprised if the municipal works department gets an «accidental» computer- generated order to put start a new landfill on your front lawn or your quota is reduced to 4K. Getting paid for it!
**GEEK PERL CODE [P+++++(--)$]**
My tendencies on this issue range from: «I am Larry Wall, Tom Christiansen, or Randal Schwartz.», to: «Perl users are sick, twisted programmers who are just showing off.» Getting paid for it!
**GEEK LINUX CODE [L]**
I know what Linux is, but that's about all.
**GEEK EMACS CODE [!E?]**
I refuse to categorize myself on Emacs. Emacs? I don't even know what that is…
**GEEK WORLD WIDE WEB CODE [W+>++]**
I have the latest version of Netscape, and wander the web only when there's something specific I'm looking for. But someday I'd like to say: «I have a homepage. I surf daily. My homepage is advertised in my .signature.»
**GEEK USENET CODE [N+++@]**
I read so many news groups that the next batch of news comes in before I finish reading the last batch, and I have to read for about 2 hours straight before I'm caught up on the morning's news. Then there's the afternoon… But that varies…
**GEEK KIBO CODE [K+++>++++++@]**
I've gotten mail from Kibo. But someday I'd like to say: «I am Kibo. But that varies...»
**GEEK MICROSOFT WINDOWS CODE [w$]**
Getting paid for it!
**GEEK OS/2 CODE [!O]**
I refuse to categorize myself on OS/2.
**GEEK MACINTOSH CODE [M->+]**
Macs suck. All real geeks have a character prompt. But someday I'd like to say: «A Mac has it's uses and I use it quite often.»
**GEEK VMS CODE [V--()]**
My tendencies on this issue range from: «I would rather smash my head repeatedly into a brick wall than suffer the agony of working with VMS. It's reminiscent of a dead and decaying pile of moose droppings. Unix rules the universe.», to: «I've used VMS.»
**GEEK POLITICS & SOCIAL ISSUES CODE [PS+(-)]**
My tendencies on this issue range from: «My whole concept of liberalism is that nobody has the right to tell anybody else what to do, on either side of the political fence. If you don't like it, turn the bloody channel.», to: «Label records! Keep dirty stuff off the TV and the Internet.»
**GEEK POLITICS & ECONOMIC ISSUES CODE [PE(++)]**
My tendencies on this issue range from: «Distrust both government and business.», to: «Keep the government off the backs of businesses. Deregulate as much as possible.»
**GEEK CYPHERPUNKS CODE [Y+]**
I have an interest and concern in privacy issues, but in reality I am not really all that active or vocal.
**GEEK PGP CODE [PGP->+]**
I don't have anything to hide. But someday I'd like to say: "«Finger me for my public key»."
**GEEK STAR TREK CODE [t+()]**
My tendencies on this issue range from: «It's a damn fine TV show and is one of the only things good on television any more.», to: «It's just another TV show.»
**GEEK BABYLON 5 CODE [5]**
I've seen it, I am pretty indifferent to it.
**GEEK X FILES CODE [X?]**
X Files? I don't even know what that is…
**GEEK ROLE-PLAYING CODE [R>\*]**
Role-Playing? That's just something to do to kill a Saturday afternoon. But someday I'd like to say: «I thought life WAS role- playing?»
**GEEK TELEVISION CODE [tv@]**
I watch only the shows that are actually worthwhile, such as those found on PBS. But that varies…
**GEEK BOOKS CODE [b++>+++]**
I find the time to get through at least one new book a month. But someday I'd like to say: «I consume a few books a week as part of a staple diet.»
**GEEK DILBERT CODE [DI+++]**
I am a Dilbert prototype.
**GEEK DOOM CODE [D?]**
Doom? I don't even know what that is…
**THE GEEK CODE [G(-)]**
My tendencies on this issue range from: «I know what the geek code is and even did up this code.», to: «What a tremendous waste of time this Geek Code is.»
**GEEK EDUCATION CODE [e++>+++@]**
Got a Baccalaureate degree. But someday I'd like to say: «Got a Masters degree. But that varies...»
**GEEK HOUSING CODE [h----()]**
My tendencies on this issue range from: «Married with children — Al Bundy can sympathize.», to: «Friends come over to visit every once in a while to talk about Geek things. There is a place for them to sit.»
**GEEK RELATIONSHIPS CODE [r+++]**
Found someone, dated, and am now married.
**GEEK SEX CODE [y++++]**
Male. I have a few little rug rats to prove I've been there. Besides, with kids around, who has time for sex?
[[подробнее про код тут](https://web.archive.org/web/20090220181018/http://geekcode.com/geek.html)]
**UPD**
Одного поздравления оказалось мало, вот [еще вдогонку](https://habrahabr.ru/post/311166/). Там есть клевая цитата:
> *«Я знаю некоторые успешные проекты с демократическими принципами. Но большинство людей не готовы достаточно учиться, чтобы к их мнению можно было прислушиваться.»* | https://habr.com/ru/post/310938/ | null | ru | null |
# Превращаем старый телефон на Android в резервный сервер с помощью UrBackup/Linux Deploy. Часть 1
[](https://habr.com/ru/company/ruvds/blog/564166/)
Сегодня я покажу вам, как запустить полноценный резервный сервер на рутованном телефоне Android с помощью UrBackup и Linux Deploy. Пластиковый мусор уже заполонил все вокруг, а в добавок к нему очередной глобальной эко-проблемой становятся еще и электронные отходы. Так зачем выбрасывать прекрасный, пусть даже потрескавшийся и поношенный, телефон?
К тому же этот старый телефон:
1. Вероятно, даже не настолько стар (покупаете ли вы новый ПК каждые 1-2 года?).
2. Возможно, снабжен 4-8 ядрами и ~4Гб ОЗУ, а также определенно имеет встроенный ИБП.
Подключите к нему внешний винчестер, и он станет отличным кандидатом на резервную систему для всей домашней сети!
> Предупреждение: это проект из разряда «потому что могу». И поскольку здесь мы все-еще работаем с Android, то, помимо ряда ограничений, нам также потребуется обойти несколько препятствий. Это решение станет не самым простым способом создания бэкапа для домашней сети, как и не лучшим вариантом использования UrBackup. И все же! Как только настройка будет завершена, вы получите очень простой способ управления резервными копиями для нескольких машин, а также добавления хранилища.
Список ограничений этой конфигурации
------------------------------------
**Единственным вариантом файловой системы является EXT4.**
Только она одновременно совместима с UrBackup и Android. К сожалению, никакого навороченного сжатия данных на уровне файловой системы.
**Нельзя вызывать systemd напрямую из среды chroot**
Поэтому мы установим простой стартовый скрипт для запуска службы UrBackup, а останавливать эту службу будем с помощью `pkill`. Кроме этого, мы добавим `cronjob@reboot` для ее запуска при загрузке.
**UrBackup больше ориентирована на Windows**
Ее разработчики предлагают полные резервные копии файлов для Linux, но та же функция в отношении создания образов пока находится на стадии беты. Мы же установим стабильную версию UrBackup, то есть резервное копирование образов для клиентов Linux не будет доступно напрямую на сервере. Тем не менее вы сможете создавать образы локально на клиенте и делать бэкап содержащих их директорий. И последнее. Создание резервных образов работает на клиентах Mac, но эта функция также находится на стадии беты. Лично у меня нет серверов под Windows, и я не особо беспокоюсь за свой ноутбук с Windows, поэтому использую UrBackup только для серверов Linux.
**Мы ограничены дистрибутивами, доступными в Linux Deploy, а также версиями этих дистрибутивов**
Я пробовала проделать эту процедуру с Centos 7, Ubuntu 18.04 и Debian 10. Должным образом без ошибок удалось заставить работать только Debian 10. Судя по всему, в этом случае UrBackup также предлагает больше поддержки именно для Debian (ни один другой дистрибутив не имеет доступного для ARM64 пакета `.deb`). Вы без проблем можете пробовать и другие доступные дистрибутивы, но тогда вам придется компилировать пакет установки из их исходного кода. (инструкции можно найти на [странице скачивания](https://www.urbackup.org/download.html#server_debian)).
Надежность и безопасность
-------------------------
**Уязвимость рутованного Android**
Linux Deploy создает для вашего экземпляра Linux контейнер `chroot`. По сути, это песочница, но когда вы даете Linux Deploy root-доступ, то расширяете размер песочницы, охватывая большинство закоулков системы телефона. Самая серьезная уязвимость будет исходить из рутованной ОС Android в связи с недостатком обновляемых патчей безопасности. Некоторые телефоны можно обновлять после получения root-доступа, но тогда после обновления придется делать рутинг повторно.
При условии, что вы отключаете все возможные разрешения и службы, а также избегаете использования интернета из ОС Android, поверхность атаки остается очень узкой (по сути, ограниченной любой оставшейся фоновой службой, не допускающей отключение). Чтобы сохранить устройство в безопасности, следует поддерживать актуальность экземпляра Debian с помощью `apt update && apt upgrade` и рассмотреть вариант установки антивируса, как и на любой другой сервер. И все же, эта конфигурация не отличается высокой безопасностью. Если вам нужна глубокая защита на каждом уровне домашней сети, то она вам не подойдет.
**Надежность подержанного телефона**
Качество сборки всех смартфонов отличается, но в общем их можно назвать очень мощными компьютерами. Если со временем производительность вашего смартфона падает, то взбодрить систему можно с помощью сброса к заводским настройкам. Также имейте в виду, что графика на смартфоне занимает существенный объем вычислительной мощности, и сервер без GUI будет скорее всего работать отлично. Если с вашим телефоном есть какие-то фундаментальные проблемы (питание, загрузка и пр.), то в качестве кандидата на резервный сервер он не сгодится. Это руководство для устройств, которые полноценно сохранили свою функциональность как смартфоны.
**Безопасность батареи**
Постоянное подключение смартфона к сети может сократить срок службы батареи, но само по себе это не опасно. Вообще перезаряжать литиевые аккумуляторы вредно, но в телефонах используются контроллеры заряда, которые останавливают зарядку, когда батарея заполняется. (Подробнее об управлении питанием можно почитать [здесь](https://www.powerelectronics.com/technologies/power-electronics-systems/article/21864155/power-management-chapter-9-batterypower-management-ics)). Причиной же вздутия зачастую служит заводской дефект или чрезмерный нагрев. Если у вас б/у телефон, и вздутие батареи не наблюдается, то скорее всего брака в нем нет.
Для избежания перегрева устройства следует разместить его в хорошо вентилируемом месте, отслеживать загрузку сервера, а также использовать качественную зарядку. Если телефон вдруг нагреется до горяча, отключите его и подумайте об увеличении интервалов между бэкапами, чтобы снизить нагрузку. Если телефон горячий постоянно, то лучше будет подыскать для сервера другое устройство. Как и с любым обычным сервером, добавьте в список его периодического обслуживания аппаратные проверки.
План
----
Если вы все еще здесь, то вот наш план действий:
1. Получить root-права на телефоне. Я не стану вдаваться в подробности по этому пункту, а просто направлю вас к инструкции [Magisk](https://topjohnwu.github.io/Magisk/install.html) (англ.), где все это подробно расписано.
2. Установка Linux Deploy и развертывание Debian Buster.
3. Установка UrBackup Server.
4. Подключение клиентов.
Учтите, что в этом руководстве я буду принимать очень специфичные решения в отношении конфигурации, большинство из которых нацелены на наладку работы с Debian и Android в среде `chroot`.
Требования
----------
**Рутованный телефон Android**
В моем случае используется Pixel 4a (8ЦПУ/6Гб ОЗУ). Конкретная модель телефона большого значения не имеет, но при этом у каждой могут быть свои особенности. Если ваш телефон выпущен в течение последних пяти лет, то он наверняка имеет достаточные характеристики. Если же вы о них не знаете, то лучше уточните. Я рекомендую не менее 4 ЦПУ и 2 Гб ОЗУ. Этого должно быть достаточно для большинства домашних сетей, но вам нужно будет оценить требования в соответствии с планируемым объемом резервного копирования. Также учитывайте, что часть ресурсов будет забирать Android система хоста.
Опять же направлю вас к [Magisk](https://topjohnwu.github.io/Magisk/install.html) для рутинга телефона. Вот некоторые советы:
— Убедитесь, что используете файл `boot.img`, связанный с текущей версией загрузчика вашего телефона.
— Если устройство работает на Android 11, и процедура Magisk не сработала, понизьте версию ОС до Android 10 и повторите попытку. Я убил целый день, воюя с Android 11 на своем Pixel 4a.
— Если вы не хотите использовать именно Magisk, будьте ОЧЕНЬ осторожны с другими аналогичными инструментами. Как показывает практика, многие приложения на рынке оказываются шпионскими или вирусными. Могу посоветовать еще CF-Auto-Root, но скачивать этот инструмент нужно только с проверенного ресурса.
**Приложение Linux Deploy**
Это приложение, которое будет выполнять на вашем Debian-сервере среду `chroot`.
Скачайте последнюю версию с GitHub. Версия в Play store больше не обслуживается.
**Приложение BusyBox**
Это приложение предоставляет утилиты Unix для Linux Deploy. На рынке доступно несколько вариантов Busy Box, но именно данная версия совместима с Linux Deploy.
Скачайте ее с GitHub. Версия в Play store больше не обслуживается.
**Кабель зарядки**
Собственно, для зарядки телефона.
**Хост для подключения к серверу через SSH**
Технически он может находиться на том же телефоне, если установить приложение Termux или SSH, но установка определенно пройдет проще с полноценной клавиатуры.
Дополнительное оборудование (рекомендуется)
-------------------------------------------
Несмотря на то, что, в принципе, бэкапы можно сохранять на SD-карте, делать это НЕ желательно. SD-карты медленнее, менее надежны и не могут обрабатывать процедуру записи в течение длительного времени. Если вы планируете сделать резервную копию на SD-карту, то сразу имейте в виду, что в течение года она даст сбой (а при большом объеме данных даже в течение месяца).
**Внешний HDD/SSD с USB-кабелем**
Размер и скорость записи выбирать вам, но я бы больше внимания уделил надежности, а не объему памяти и скорости. Быстродействие сыграет существенную роль только при большом хранилище (от 100 до 1000Гб). В этом случае польза от высокой скорости записи отразиться на своевременном завершении резервного копирования. Что касается надежности, то здесь большое значение имеет бренд. При использовании дешевых дисков будьте готовы к ошибкам ввода/вывода прямо посреди процесса создания резервных копий. Если вы заранее не уверены, какой конкретно объем хранилища вам потребуется, я рекомендую дождаться Части 2, чтобы отформатировать ваш диск в логический том. Логические тома позволяют легко добавлять объем хранилища, не озадачиваясь переносом данных. Можно начать с небольшого объема раздела и расширить его позднее.
**USB Hub/Dock**
Концентратор должен быть микро-USB или USB-C, в зависимости от того, каким разъемом оборудован телефон. При этом он должен иметь минимум один порт USB для подключения внешнего винчестера и один порт для зарядки, но я также советую выбрать такой, в котором будет ethernet-адаптер. Вы можете работать с сервером по WiFi, но ethernet-соединение будет быстрее и надежнее.
**Ethernet кабель**
В случае работы с сервером по ethernet.
Шаг 1. Установка Linux Deploy и развертывание Debian Buster
-----------------------------------------------------------
**A.** С рутованного телефона перейдите на GitHub и скачайте `.apk` пакеты для [Linux Deploy](https://github.com/meefik/linuxdeploy/releases/tag/2.6.0) и [BusyBox](https://github.com/meefik/busybox/releases/). Установите эти приложения.
**B.** После установки откройте BusyBox. Выберите `Install`. По завершению обратите внимание, куда установилась BusyBox. В данном случае мы видим, что установка произведена в `/system/xbin`. Этот путь вам потребуется позже.
**C.** Откройте Linux Deploy и перейдите в настройки через иконку в нижнем правом углу.
**c.** Настройте следующее:
**Architecture**
Все телефоны Android построены на AARCH64/ARM64. Убедитесь, что указано «arm64» (или «aarch64» для других дистрибутивов).
**Installation path**
По умолчанию им может быть `${EXTERNAL_STORAGE}/linux.img`. Это ваша SD-карта, и вы можете оставить все так, если хотите (работает для Raspberry Pi). Однако, если SD-карты в телефоне нет, или она неверно отформатирована, то установка провалится. Я рекомендую устанавливать во внутреннее хранилище, как сам делаю в этом примере. Полагаю, что вы не станете использовать телефон для чего-то еще, поскольку он должен будет оставаться подключенным постоянно.
**Image size (MB)**
Я советую не менее 15Гб (15 000Мб), но следует убедиться, что у системы Android останется достаточно места для корректного функционирования. Пространство будет взято из внутреннего хранилища, значит у вас может не быть доступно 50Гб, как в моем случае.
**Init system**
Если для этого процесса не установить `sysv`, то `cronjobs` не будут запускаться при загрузке.
**MOUNTS**
Если в дальнейшем вы не собираетесь расширять хранилище, то можете смонтировать внешнее блочное устройство здесь, добавив его путь в точки монтирования. Если же расширение хранилища в ваши планы входит, тогда вы можете подождать публикации Части 2, чтобы разбить его на разделы и отформатировать в логический том.
Все, что вы смонтируете здесь, будет непосредственно доступно при загрузке, но не будет доступно для разбиения по разделам и форматирования. Тем не менее учитывайте, что имя вашего блочного устройства (`/dev/block/sdX`) при перезагрузке телефона может измениться, в случае чего вам понадобится проверить/изменить конфигурацию. Если же вы смонтируете логический том, то его имя уже не изменится, и о проверке вам беспокоиться не придется.
**Как найти путь к внешнему блочному устройству?**
На Android блочные устройства находятся в `/dev/block/sdX` (в противоположность `/dev/sdX`). Чтобы выяснить, какое из `sdX` устройств является внешним блочным устройством, подключите его и выполните на сервере команду `lsblk`. Затем просмотрите все устройства и обратите внимание, какое из них совпадает с вашим (в плане объема/существующих разделов). Если вы подключили устройство после загрузки, то оно скорее всего окажется последним.
> Примечание: после того, как блочное устройство будет смонтировано, перед последующим физическим отключением его необходимо будет сначала размонтировать или отключить сервер. Отсоединение без размонтирования скорее всего приведет к утрате содержащихся на нем данных.
**D.** Вернитесь обратно на экран приветствия и выберите верхнее левое меню. Далее выберите `Settings` и промотайте вниз до `PATH variable`. Именно здесь нужно установить путь установки BusyBox из шага 1.B. После установки `PATH variable` выберите `Update ENV`.
**E.** Вернитесь на экран приветствия и выберите верхнее правое меню. Жмите `Install`. Перед вами отобразится живой лог установки. По завершению в конце лога будет прописано `deploy`. Выберите `START` в нижнем левом углу экрана. Теперь у вас на телефоне запущен сервер Debian!
Шаг 2. Установка сервера UrBackup
---------------------------------
**A.** Подключитесь к только что развернутому серверу по SSH.
IP-адрес будет тот же, что и у телефона, порт будет 22, а авторизоваться вы сможете с помощью учетных данных, установленных в шаге 1.с. Оставшаяся часть руководства предполагает, что вы авторизованы как корневой пользователь. Свой IP можете увидеть, открыв Linux Deploy:
**B.** Обновите систему:
```
apt update && apt upgrade -y && apt install wget
```
**C.** Скачайте пакет `.deb` для UrBackup:
```
wget https://hndl.urbackup.org/Server/2.4.13/urbackup-server_2.4.13_arm64.deb
```
Это последняя стабильная версия на момент написания. Возможные обновления можете посмотреть на [странице скачивания](https://www.urbackup.org/download.html#server_debian).
**D.** Установите пакет:
```
apt install -f ./urbackup-server_2.4.13_arm64.deb
```
В ходе установки система спросит, где должна размещаться резервная директория.
Запомните ее путь для следующего шага. Если вы уже смонтировали хранилище в шаге 1.c, установите в качестве этого пути точку монтирования.
**E.** Создание директории для бэкапа.
В этом примере я установлю директорию как `/mnt/backup`. Если вы смонтировали хранилище ранее, то директория уже будет существовать. Если же нет, создайте ее:
```
mkdir -p /mnt/backup
```
Обновите разрешения:
```
chown urbackup /mnt/backup
```
```
chgrp urbackup /mnt/backup
```
(Так UrBackup сможет производить запись в эту директорию.)
**F.** Установка скрипта запуска.
В среде `chroot` мы не сможем вызывать `systemd`, поэтому потребуется запускать эту службу вручную:
```
/usr/bin/urbackupsrv run --config /etc/default/urbackupsrv --no-consoletime
```
Но вместо того, чтобы вводить это постоянно, мы просто создадим скрипт:
```
nano /usr/bin/urbackupsrv-start
```
Скопируйте его в файл:
```
#!/bin/sh
/usr/bin/urbackupsrv run --config /etc/default/urbackupsrv --no-consoletime
```
Сохраняемся и выходим.
Определите разрешения:
```
chmod 755 /usr/bin/urbackupsrv-start
```
**G.** Запустите службу:
```
urbackupsrv-start
```
Это приведет к появлению лога запуска сервера. Нажатие CTRL-C остановит службу, поэтому откройте еще одну сессию SSH.
Для остановки службы нужно будет просто ее завершить:
```
pkill urbackup
```
**H.** Добавление `cronjobs`.
Поскольку мы не можем «активировать» службу UrBackup стандартным способом, то установим задачу `cron` для запуска при загрузке. В добавок к этому, если вы в дальнейшем отключите внешнее хранилище или перезагрузите телефон, то разрешения для резервной директории могут отмениться. Чтобы гарантировать их установку при загрузке мы добавляем `cronjobs`:
Откройте `crontab`:
```
crontab -e
```
Добавьте эту задачу:
```
@reboot chown urbackup [full/path/to/backup_directory] && chgrp urbackup [full/path/to/backup_directory] && urbackupsrv-start
```
Сохраните и выйдите.
**I.** Перейдите в веб-интерфейс.
В браузере перейдите на порт 55414 сервера: [YOUR\_SERVER\_IP](http://YOUR_SERVER_IP):55414
Все работает!
Шаг 3. Подключение клиентов
---------------------------
**A.** В нижней правой части окна состояния кликните `Add new client`:
**B.** Выберите `Add new Internet client/client behind NAT` и введите имя клиента:
Им должно быть имя хоста нового клиента.
**C.** Установка клиента.
* Для клиентов Windows:
Скачайте установщик по ссылке «Download preconfigured client installer for Windows» и следуйте его инструкциям.
* Для клиентов Linux:
Обратите внимание на «Default authentication key» вверху. Он вам понадобится.
Авторизуйтесь на клиенте и запустите скрипт установки (НЕ запускайте скрипт, предоставленный сервером):
```
TF=$(mktemp) && wget "https://hndl.urbackup.org/Client/2.4.11/UrBackup%20Client%20Linux%202.4.11.sh" -O $TF && sudo sh $TF; rm -f $TF
```
(Проверьте наличие последних версий клиентов [здесь](https://www.urbackup.org/download.html#linux_all_binary)).
В процессе установки скрипт попросит выбрать механизм сохранения снимков состояния. Введите 2 для «LVM — Logical Volume Manager snapshots»:
**Подробнее**
На телефоне с Android единственной реальной альтернативой будет Dattobd. BTRFS в данном случае не поддерживается, а пренебрежение механизмом сохранения снимков системы очень нежелательно (вам придется останавливать на время резервного копирования все службы, взаимодействующие с файлами, выбранными для бэкапа).
Я попробовал использовать dattobd, но постоянно сталкивался с разными ошибками. Учитывайте, что вам нужно будет установить dattobd и на сервер, и на клиентов. При этом сервер и клиенты должны быть с ним совместимы. Для установки dattobd на устройство Android (ARM64) вам придется скомпилировать исходный код, в чем я не преуспел. Тем не менее у вас может оказаться другой случай, в зависимости от модели телефона или используемого дистрибутива. Мне также не удалось установить его в Ubuntu 20.10, при том что с Ubuntu 20.04 все получилось отлично.
По завершению установки убедитесь, что клиент запущен:
```
service urbackupclientbackend status
```
Если не запущен, запустите:
```
service urbackupclientbackend start
```
В завершении подключите клиента к серверу:
```
urbackupclientctl set-settings \
-k internet_mode_enabled -v true \
-k internet_server -v "YOUR_SERVER_IP" \
-k internet_server_port -v "55415" \
-k computername -v "YOUR_CLIENT_NAME" \
-k internet_authkey -v "YOUR_DEFAULT_AUTHENTICATION_KEY"
```
Убедитесь, что именем хоста, настроенным на шаге 3.B, является `YOUR_CLIENT_NAME`, а ранее сгенерированным сервером ключом `YOUR_DEFAULT_AUTHENTICATION_KEY`.
**D.** Настройка сервера.
Вернитесь в веб-интерфейс. Здесь вы можете обнаружить, что клиент не подключен. Кликните `Settings` в верхней панели навигации:
В `Settings` перейдите на вкладку `Internet` и убедитесь, что установлено следующее:
Если у вас все клиенты локальные, то можете убрать галочки `Do image backups over the internet` и `Do full file backups over the internet`.
Промотайте вниз и кликните `Save`.
**E.** Настройка директории резервного копирования:
Здесь же в `Settings` кликните `Client settings`. Отметьте `Separate settings for this client`, а в строке `Default directories to backup` вкладки `File Backups` укажите директории для резервного копирования.
Можно добавить несколько директорий через `;`.
Здесь также настравиваются интервалы резервного копирования.
Кликните `Save` внизу.
Для клиентов Linux это также можно настроить из командной строки клиента:
```
urbackupclientctl add-backupdir -d FILE_PATH
```
Перезапустите сервер:
```
pkill urbackup
```
```
urbackupsrv-start
```
**F.** Вернитесь в веб-интерфейс.
Теперь клиент должен быть подключен. В блоке`File backup status` может отобразиться `No paths to backup configured`, но это нормально. Такое сообщение будет отображаться до завершения первого резервного копирования. Также имейте ввиду, что если вы подключили клиента Linux, то бэкапы образов поддерживаться не будут. Тем не менее вы можете просто сделать резервный образ с клиента Linux и указать директорию этих образов для резервного копирования сервером.
Можно запускать первое резервное копирование!
Продолжение следует...
----------------------
Если вы уже подключили хранилище и довольны конфигурацией, то на этом все. Если же вы хотите добавить хранилищу гибкость, то жду вас в Части 2. LVM (менеджер логических томов) позволяет добавлять или удалять хранилище без необходимости переноса данных на другое устройство хранения. Вы можете просто добавить нужный объем хранилища или удалить его неиспользуемую часть, которую хотите задействовать где-то еще. В Части 2 мы в основном будем работать с LVM. Это хоть и не сложно, но все равно является определенным процессом.
### Советы
**ОС Android**
1. Отключите разрешения для всех служб, для которых это возможно. Разрешения кроются в различных местах настроек, так что уделите время их поиску. Также отключите или деинсталлируйте все приложения, какие можете. Это позволит снизить общую нагрузку на ОС Android.
2. Будьте осторожны с обновлениями Android. При успешном выполнении они скорее всего отменят root-доступ к устройству, и рутинг придется делать повторно. Если же вы хотите произвести обновление, то сохраните резервную копию файла `.img`, который Linux Deploy создала для контейнера Linux. Если в итоге вы полностью зачистите телефон, то достаточно будет переустановить Linux Deploy и сопоставить ее с резервным образом.
3. Поскольку вы не сможете обновлять телефон часто, то следует ограничить использование ОС Android. Не заходите в браузеры и не скачивайте лишние приложения, чтобы ограничить связь устройства с интернетом. Вы можете (даже рекомендуется) поддерживать версию Debian обновленной и использовать интернет по необходимости.
**Linux Deploy**
1. Когда телефон блокируется, Android переводит его в режим простоя. Это замедляет производительность ЦПУ. Чтобы экран был активен постоянно, перейдите в настройки приложения Linux Deploy и отметьте пункт `Wake Lock`. Найти его можно, нажав на верхней левой иконке настроек и перейдя в `Settings`. Обратите внимание, что эта функция действует только, когда приложение открыто.
2. Если вам потребуется перезагрузить образ контейнера, просто убедитесь, что расположение целевого образа (`.img`) установлено в `Installation path` в `Properties`. Найти этот пункт можно через нижнюю левую иконку настроек. Убедитесь, что указанный в свойствах дистрибутив совпадает с дистрибутивом файла `.img`. Если он не совпадает, Linux Deploy перезапишет файл `.img` с настройками из `Properties`. Затем вернитесь на основной экран и выберите из верхнего правого меню `Install`.
**Деинсталляция UrBackup (Linux Server/Client)**
Для деинсталляции сервера UrBackup выполните:
```
apt-get remove --purge urbackup-server
```
Для деинсталляции клиента UrBackup выполните:
```
uninstall_urbackupclient
```
**Удаление клиента UrBackup (неотложное)**
Если вы удалите клиента из веб-интерфейса сервера, то увидите уведомление *«This client is going to be removed… Clients are removed during the cleanup in the cleanup time window»*. Это означает, что он еще не удален, и вам придется подождать, пока сервер не запустит плановую очистку, в ходе которой и произведет удаление. Такой вариант может вас не устроить, если вы работаете над устранением неисправности, и требуется неотложное повторное добавление клиента. Для ручной очистки остановите службу UrBackup из CLI:
```
pkill urbackup
```
Выполните очистку:
```
urbackupsrv cleanup -a 0%
```
И снова запустите UrBackup:
```
urbackupsrv-start
```
**Ошибки резервного копирования**
1. *«Volume group „root“ not found»*
Если вы делаете бэкап директорий внутри контейнера, то в логах сервера может возникнуть ошибка *«Volume group „root“ not found»*, и создание резервной копии также закончится с ошибками. Ничего страшного, если ваши бэкапы остаются нетронутыми. Так как клиент UrBackup запускается из контейнера, он не сможет проследить свой путь до корня хоста.
2. Мгновенный сбой; без логирования ошибок
Если резервное копирование дает мгновенный сбой, то скорее всего проблема с подключением. Проверьте машину клиента и убедитесь, что UrBackup на нем работает без сбоев. Логи клиента располагаются в `/var/log/urbackup.log`. Также можете проверить `service urbackupclientbackend status`. Если вы не можете определить причину проблемы, деинсталлируйте и повторно установите клиента.
3. *«ERROR: No permission to access [Backup Directory]»*
Если вы смонтировали внешнее устройство хранения напрямую и столкнулись с ошибками разрешений, то вам может потребоваться запустить службу от лица root-пользователя. Сначала проверьте разрешения директории бэкапа для пользователя и группы. Если вы не можете изменить разрешения для пользователя “urbackup” и группы “urbackup”, как в шаге 2.E, то сможете определить запуск UrBackup от лица root-пользователя. Для этого измените последнюю строку файла конфигурации (`/etc/default/urbackupsrv`) с `urbackup` на `root` и перезапустите сервер.
4. Ошибки ввода/вывода
Если вы не отсоединяли внешнее устройство хранения и получили ошибки ввода/вывода в процессе резервного копирования, то возможно это устройство повреждено или работает со сбоями. Если перезапуск телефона не решает проблему, скорее всего время подыскать новое блочное устройство.
5. Прочие ошибки
Если вы отклонились от руководства и не выбрали в качестве механизма резервного копирования “LVM”, убедитесь, что клиент и сервер совместимы с выбранной вами альтернативой. К примеру, если на клиенте установлен dattobd, а на сервере нет, резервное копирование провалится.
Остались вопросы по UrBackup? Нужна помощь? Обратитесь к полноценному руководству [Administration Manual](https://www.urbackup.org/administration_manual.html). Это щепетильный проект, и для каждого телефона возникнут свои сложности, так что, помимо обсуждения в комментариях, можете [почитать форумы сообщества UrBackup](https://forums.urbackup.org/).
[](https://ruvds.com/news/read/142?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=prevrashhaem_staryj_telefon_na_android_v_rezervnyj_server_s_pomoshhyu_urbackup/linux_deploy._chast_1)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=prevrashhaem_staryj_telefon_na_android_v_rezervnyj_server_s_pomoshhyu_urbackup/linux_deploy._chast_1) | https://habr.com/ru/post/564166/ | null | ru | null |
# FreeSWITCH пример из жизни…
Доброе время суток %username%.
Хочется за ранее предупредить, всех кто в принципе будет прав, данная система этот как стрельба по воробьям из пушки, но хотелось чего то этакого. Так же некоторые элементы в данной схеме не поднимались с нуля, они уже были и использовались в решении других задач, и их архитектуру рассматривать не будем ( сервер баз данных и HTTP сервера ), возьмем за факт, что эти сервисы зарезервированы должным образом.
На одной из моих работ была поставлена задача, перевод внешних линий с gsm шлюзов ( около 30 ) и наземных линий pri ( 100 линий ) на IP. Также в связи с невозможностью дальнейшего развития АТС Samsung ids-500 ( 2 станции ) установка IP телефонов. На АТС уже было около 600 рабочих телефонов. В текущий момент внешних линий 190.
Основные требования:
* Использование IP телефонов с обычными аналоговыми
* Максимальное резервирование выхода с АТС на IP и обратно.
* Масштабирование, стабильность, управляемость, гибкость
* Управление IP телефонами
Кратко по используемому ПО:
FreeSWITCH — маршрутизация звонков, регистрация абонентов, факсы, в общем все функции PBX
OpenSIPS — балансировка регистраций, звонков на сервера FreeSWITCH, так же при перехвате звонка определяет сервер на который принят звонок и отправляет запрос пользователя на него.
Asterisk — DAHDI карты, логики 0.1%, проброс звонков с АТС на FreeSWITCH и обратно.
Django — раздача конфигураций на сервера ( mod\_xml\_curl ), конфигураций телефонов, и управление всем этим хозяйством.
Рисовать схемы у меня плохо получается, по этому постараюсь описать схему так (писать, как оказалось, у меня тоже не очень получается ). Если будет интересны более подробные детали, отвечу дополнительно.
Оборудование:
=============
2 — физических сервера, в каждом стоит две платы DAHDI с которыми работает Asterisk ( для sip`a используется порт 6060 ). Также на этих же машинах установлен FreeSWITCH. АТС стоят в разных серверных, сервера так же разнесены по этим серверным. Назовем их sip1 и sip2.
1 — виртуалка, через него идет связь с операторами, установлен FreeSWITCH, назовем его sip0
1 — виртуалка, OpenSIPS наш балансировщик.
Логика:
=======
Каждый сервер подключен в каждую АТС по pri, что обеспечивает нам резервирование. При звонке с АТС Asterisk пытается отправить звонок на FreeSWITCH запущенный на данной машине, в случае ошибки отправляем звонок на второй сервер.
Звонки на АТС в принципе идут по подобной логике, с единственным исключением, сначала звонок идет на сервер который стоит рядом с АТС, на которую идет звонок. Т.е если звонок пришел на sip1 а к АТС2 ближе sip2, то звонок сначала отправляем на него.
Все номера АТС у которых есть привязка внешнего номера прописаны в системе, при выходе звонка с sip0 подставляется соответствующий caller id, в случае отсутствия привязки подставляется пилотный номер. Релизовано это в виде переменной прописанной для пользователей out\_number и проверкой в диалплане `${user_data(${caller_id_number}@${domain} var out_number)}`
Для VOIP номеров логика та же.
При внутренних звонках caller name получаем через http запрос **mod\_cidlookup**. Соответствие номер телефона фамилия сотрудника, отдельная история об AD и 1С.
VOIP телефоны — Dlink dph-105, dph-400, grandstream gxp-1405, gxp-2120. Конфигурация на них раздается через http, все параметры настройки берем с базы и на лету формируем необходимый файл конфигурации.
В админке реализован пока минимальный функционал, конфигурация аппаратов — пользователей, cdr, перезагрузка аппаратов, управления диалпланом, небольшая статистика за сутки входящие/исходящие успешные звонки и так же по ошибкам, текущее количество зарегистрированных пользователей и количество активных звонков в разрезе серверов.
sip1 и sip2 используют одну базу для регистрации пользователей, голосовой почты, активных звонков, cdr, хранение переменных.
О маштабируемости и резервировании FreeSWITCH`а можно почитать [Enterprise deployment](http://wiki.freeswitch.org/wiki/Enterprise_deployment)
На данный момент зарегистрированных SIP пользователей — 300, пользователей на АТС — 600. Максимальное количество одновременных звонков на внешние направления 40.
Понимаю данный поток текста не полон и не описывает картину полностью, однако так как постоянно откладывал написание, решил лучше уж написать как могу и если данная тема интересна буду расширять и дополнять. | https://habr.com/ru/post/132868/ | null | ru | null |
# Авторизация с помощью клиентских SSL сертификатов в IOS и Android
Протокол безопасной передачи данных SSL (Secure Sockets Layer) помимо обеспечения безопасной передачи данных так же позволяет реализовать авторизацию клиентов при помощи клиентских SSL сертификатов. Данная статья является практическим руководством по реализации данного вида авторизации в мобильных приложениях на IOS и Android.
Процесс организации работы сервера обеспечивающего такой вид авторизации в статье не рассматривается, однако в конце приведены ссылки по данной тематике.
Процесс авторизации выглядит следующим образом. При переходе клиента в закрытую область сервер запрашивает у клиента сертификат, если проверка прошла успешно то клиент получает доступ к закрытому контенту в ином случае клиент может получить ошибку “**No required SSL certificate was sent**”.
Для организации подключения мы сгенирировали клиентский сертификат, а так же создали запрос на подписание сертификата в результате чего получили файл client.csr. Далее мы отправили данный файл поставщику услуг и получили наш подписанный клиентский сертификат необходимый для аутентификации на удаленном сервере.
Тестирование подключения может быть осуществлено при помощи утилиты curl.
*curl cert client.crt key client.key k [someserive.com](https://someserive.com/)*
Однако стоит заметить, что в последняя версия curl 7.30.0 в OS X сломана и не может быть использована для организации тестирования (<http://curl.haxx.se/mail/archive-2013-10/0036.html>).
Для передачи клиентского сертификата мы будем использовать файл в формате PKCS#12. В файлах PKCS#12 хранятся одновременно и закрытый ключ, и сертификат (разумеется в зашифрованном виде). Примерная организация PKCS#12 файла показана на рисунке.
Сконвертировать Ваш client.crt в файл формата PKCS#12 можно при помощи следующей команды:
*openssl pkcs12 export in client.crt inkey client.key out client.p12*
После того как мы получили файл в формате PKCS#12 можно переходить к разработке и тестированию нашего мобильного приложения. Начнем с IOS.
##### 1. Реализуем IOS версию приложения
Необходимо подключить к Вашему проекту Security.Framework
Для осуществления запроса нам необходимо извлечеть из PKCS#12 цифровой сертификат и ассоциированный с ним приватный ключ (SecIdentityRef). Наличие данного объекта позволит нам получить соответствующий NSURLCredential.
Итак реализуем функецию extractIdentityAndTrust.
```
OSStatus extractIdentityAndTrust(CFDataRef inP12data, SecIdentityRef *identity)
{
OSStatus securityError = errSecSuccess;
CFStringRef password = CFSTR("");
const void *keys[] = { kSecImportExportPassphrase };
const void *values[] = { password };
CFDictionaryRef options = CFDictionaryCreate(NULL, keys, values, 1, NULL, NULL);
CFArrayRef items = CFArrayCreate(NULL, 0, 0, NULL);
securityError = SecPKCS12Import(inP12data, options, &items);
if (securityError == 0) {
CFDictionaryRef myIdentityAndTrust = CFArrayGetValueAtIndex(items, 0);
const void *tempIdentity = NULL;
tempIdentity = CFDictionaryGetValue(myIdentityAndTrust, kSecImportItemIdentity);
*identity = (SecIdentityRef)tempIdentity;
}
if (options) {
CFRelease(options);
}
return securityError;
}
```
Производим извлечение при помощи функции SecPKCS12Import, незабываем указать пароль к серитификату.
Далее реализуем делегат canAuthenticateAgainstProtectionSpace, вызов данного делегата позволяет нам определить свойства сервера, а именно протокол, механизм авторизации. У нас реализация этого делегата будет простой, укажем, что обрабатываем любой способ аутентификации представленный сервером.
```
- (BOOL)connection:(NSURLConnection *)connection canAuthenticateAgainstProtectionSpace:(NSURLProtectionSpace *)protectionSpace
{
return YES;
}
```
Обработаем возможные ошибки:
```
- (void)connection:(NSURLConnection*) connection didFailWithError:(NSError *)error
{
NSLog(@"Did recieve error: %@", [error localizedDescription]);
NSLog(@"%@", [error userInfo]);
}
```
Теперь перейдем к реализации непосредственно механизма аутентификации. Реализуем делегат didRecieveAuthentificationChallenge:
```
- (void)connection:(NSURLConnection *)connection didReceiveAuthenticationChallenge:(NSURLAuthenticationChallenge *)challenge
{
NSLog(@"Authentication challenge");
// load cert
NSString *path = [[NSBundle mainBundle] pathForResource:@"keystore" ofType:@"p12"];
NSData *p12data = [NSData dataWithContentsOfFile:path];
CFDataRef inP12data = (__bridge CFDataRef)p12data;
SecIdentityRef myIdentity;
OSStatus status = extractIdentityAndTrust(inP12data, &myIdentity);
SecCertificateRef myCertificate;
SecIdentityCopyCertificate(myIdentity, &myCertificate);
const void *certs[] = { myCertificate };
CFArrayRef certsArray = CFArrayCreate(NULL, certs, 1, NULL);
NSURLCredential *credential = [NSURLCredential credentialWithIdentity:myIdentity certificates:(__bridge NSArray*)certsArray persistence: NSURLCredentialPersistenceForSession];
[[challenge sender] useCredential:credential forAuthenticationChallenge:challenge];
}
```
Загружаем наш сертификат, извлекаем из него нужные нам данные, создаем NSURLCredential, передаем нужную информацию, сохраняем данные аутентификации только в контексте текущей сессии.
Ну и для полноты картины приведу код подготавливающий NSURLConnection:
```
NSString *key = @"test";
NSError *jsonSerializationError = nil;
NSMutableDictionary *projectDictionary = [NSMutableDictionary dictionaryWithCapacity:1];
[projectDictionary setObject:key forKey:@"test"];
NSData *jsonData = [NSJSONSerialization dataWithJSONObject:projectDictionary options:nil error:&jsonSerializationError];
NSURL *requestUrl = [[NSURL alloc] initWithString:@"https://your_service"];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:requestUrl cachePolicy:NSURLRequestReloadIgnoringCacheData timeoutInterval:60.0];
[request setHTTPMethod:@"POST"];
[request setValue:@"UTF-8" forHTTPHeaderField:@"content-charset"];
[request setValue:@"application/json" forHTTPHeaderField:@"Accept"];
[request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
[request setValue:[NSString stringWithFormat:@"%d", [jsonData length]] forHTTPHeaderField:@"Content-Length"];
[request setHTTPBody: jsonData];
NSURLConnection *connection = [[NSURLConnection alloc] initWithRequest:request delegate:self];
[connection start];
```
Реализацию делегата didReceiveData приводить не буду.
##### 2. Реализуем Android версию приложения
Начну сразу с кода:
```
KeyStore keystore = KeyStore.getInstance("PKCS12");
keystore.load(getResources().openRawResource(R.raw.keystore), "".toCharArray());
SSLSocketFactory sslSocketFactory = new AdditionalKeyStoresSSLSocketFactory(keystore);
HttpParams params = new BasicHttpParams();
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);
HttpProtocolParams.setUseExpectContinue(params, true);
final SchemeRegistry registry = new SchemeRegistry();
registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
registry.register(new Scheme("https", sslSocketFactory, 3123));
ThreadSafeClientConnManager manager = new ThreadSafeClientConnManager(params, registry);
DefaultHttpClient httpclient = new DefaultHttpClient(manager, params);
HttpPost httpPostRequest = new HttpPost("https://your_service");
// datas - array which contains data to send to server
StringEntity se = new StringEntity(datas[0].toString(), HTTP.UTF_8);
// Set HTTP parameters
httpPostRequest.setEntity(se);
httpPostRequest.setHeader("Accept", "application/json");
httpPostRequest.setHeader("Content-Type", "application/json");
HttpResponse response = httpclient.execute(httpPostRequest);
```
Получаем экземпляр соответствующего KeyStore в нашем случае это (PKCS12), загружаем из ресурсов наш сертификат, вторым аргументом указываем пароль. Далее создаем экземпляр SSLSocketFactory, использую собственную реализацию SSLSocketFactory, позволяющую инициализировать SSL контекст с использованием нашего сертификата. Код фабрики приведен чуть ниже. Далее конфигурируем параметры подключения, регистрируем нашу фабрику, указываем порт на который будем посылать запрос, формируем соответсвующий POST и выполняем запрос.
Код фабрики:
```
import java.io.IOException;
import java.net.Socket;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.Arrays;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;
import org.apache.http.conn.ssl.SSLSocketFactory;
/**
* Allows you to trust certificates from additional KeyStores in addition to
* the default KeyStore
*/
public class AdditionalKeyStoresSSLSocketFactory extends SSLSocketFactory {
protected SSLContext sslContext = SSLContext.getInstance("TLS");
public AdditionalKeyStoresSSLSocketFactory(KeyStore keyStore) throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException {
super(null, null, null, null, null, null);
KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
kmf.init(keyStore, "".toCharArray());
sslContext.init(kmf.getKeyManagers(), new TrustManager[]{new ClientKeyStoresTrustManager(keyStore)}, new SecureRandom());
}
@Override
public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException {
return sslContext.getSocketFactory().createSocket(socket, host, port, autoClose);
}
@Override
public Socket createSocket() throws IOException {
return sslContext.getSocketFactory().createSocket();
}
/**
* Based on http://download.oracle.com/javase/1.5.0/docs/guide/security/jsse/JSSERefGuide.html#X509TrustManager
*/
public static class ClientKeyStoresTrustManager implements X509TrustManager {
protected ArrayList x509TrustManagers = new ArrayList();
protected ClientKeyStoresTrustManager(KeyStore... additionalkeyStores) {
final ArrayList factories = new ArrayList();
try {
// The default Trustmanager with default keystore
final TrustManagerFactory original = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
original.init((KeyStore) null);
factories.add(original);
for ( KeyStore keyStore : additionalkeyStores ) {
final TrustManagerFactory additionalCerts = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
additionalCerts.init(keyStore);
factories.add(additionalCerts);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
/\*
\* Iterate over the returned trustmanagers, and hold on
\* to any that are X509TrustManagers
\*/
for (TrustManagerFactory tmf : factories)
for ( TrustManager tm : tmf.getTrustManagers() )
if (tm instanceof X509TrustManager)
x509TrustManagers.add( (X509TrustManager) tm );
if ( x509TrustManagers.size() == 0 )
throw new RuntimeException("Couldn't find any X509TrustManagers");
}
public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
for ( X509TrustManager tm : x509TrustManagers ) {
try {
tm.checkClientTrusted(chain, authType);
return;
} catch ( CertificateException e ) {
}
}
throw new CertificateException();
}
/\*
\* Loop over the trustmanagers until we find one that accepts our server
\*/
public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
for ( X509TrustManager tm : x509TrustManagers ) {
try {
tm.checkServerTrusted(chain, authType);
return;
} catch ( CertificateException e ) {
}
}
throw new CertificateException();
}
public X509Certificate[] getAcceptedIssuers() {
final ArrayList list = new ArrayList();
for ( X509TrustManager tm : x509TrustManagers )
list.addAll(Arrays.asList(tm.getAcceptedIssuers()));
return list.toArray(new X509Certificate[list.size()]);
}
}
}
```
##### Заключение.
Мы рассмотрели как производить авторизацию по SSL с использованием клиентского сертификата.
Полезная информация:
[Certificate, Key, and Trust Services Tasks for iOS](https://developer.apple.com/library/mac/documentation/security/conceptual/certkeytrustprogguide/iPhone_Tasks/iPhone_Tasks.html)
[Описание PKCS12](http://ru.wikipedia.org/wiki/PKCS12)
[Creating .NET web service with client certificate authentication](http://stackoverflow.com/questions/6544653/creating-net-web-service-with-client-certificate-authentication)
[Certificate Authentication in asp.net](http://stackoverflow.com/questions/14933477/certificate-authentication-in-asp-net)
[Java 2-way TLS/SSL (Client Certificates) and PKCS12 vs JKS KeyStores](http://blog.palominolabs.com/2011/10/18/java-2-way-tlsssl-client-certificates-and-pkcs12-vs-jks-keystores/)
Спасибо за внимание! | https://habr.com/ru/post/194530/ | null | ru | null |
# Parallel Extensions для .net 3.5
Количество ядер у процессоров растет год от года. Но многие программы до сих пор умеют использовать только одно. В небольшой заметке хочу рассказать о дополнении к библиотеке `System.Threading`, которое называется *Parallel Extensions*. Это дополнение позволяет на высоком уровне выполнять задачи на всех доступных ядрах/процессорах.
Данная статья является лишь кратким вводным обзором в *Parallel Extensions*. Так же в конце статьи вы найдете ссылки на ресурсы, которые раскрывают тему во всех деталях.
Если интересно, то смело ныряем под кат.
Немного истории
===============
Библиотека *Parallel Extensions* (PE) — совместный проект команды .net и Microsoft Research — впервые увидела свет 29 ноября 2007 года. Она создана для того, чтобы разработчики могли пользоваться современными многоядерными архитектурами, не утруждая себя трудоемким управлением потоками. Программы, написанные с применением библиотеки, автоматически используют все доступные ядра системы. Если же программа будет запущена на старом одноядерном компьютере, то выполнение будет происходить последовательно, практически без потерь в производительности. Таким образом, использование PE раскрывает все преимущества многоядерных технологий, сохраняя работоспособность на одноядерных системах.
Последнее обновление библиотеки было в июне 2008 года. Сейчас она имеет статус *Community Technology Preview* и, скорее всего, войдет в 4 версию .net.
Состав библиотеки
=================
PE состоит из трех основных компонентов:
* Task Parallel Library (TPL) — предоставляет такие императивные методы, как `Parallel.For`, `Parallel.Foreach` и `Parallel.Invoke` для выполнения параллельных вычислений. Вся работа по созданию и завершению потоков, в зависимости от имеющихся процессоров выполняется библиотекой автоматически.
* Parallel LINQ (PLINQ) — надстройка над LINQ to Objects и LINQ to XML, позволяющая выполнять параллельные запросы. В большинстве случаев достаточно в начале запроса написать `AsParallel()` для того, чтобы все последующие операторы выполнялись параллельно. Внутренне использует TPL.
* Coordination Data Structures (CDS) — набор структур, который используется для синхронизации и координации выполнения параллельных задач. Ее мы рассматривать в этой статье не будем.
Хочу предупредить, что эта библиотека не решает вопросов, связанных с потоковой безопасностью объектов. Если вы используете не *ThreadSafe* объекты, то сами должны следить за тем, чтобы объект использовался только одним потоком.
Что будем делать
================
В качестве примера предлагаю взять поиск простых чисел от 2 до заданного предела. Будем все числа из этого интервала проверять следующим статическим методом:
> `public class Prime
> {
> ///
> /// Determines whether the specified candidate is prime.
> ///
> /// The candidate.
> ///
> /// true if the specified candidate is prime; otherwise, false.
> ///
> public static bool IsPrime(int candidate)
> {
> for(int d = 2; d <= candidate/2; d++)
> {
> if(candidate%d == 0)
> return false;
> }
> return candidate > 1;
> }
> }
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/45732/ | null | ru | null |
# Visual Studio 2019 .NET productivity
Your friendly neighborhood .NET productivity team (aka. Roslyn) focuses a lot on improving the .NET coding experience. Sometimes it’s the little refactorings and code fixes that really improve your workflow. You may have seen many [improvements in the previews](https://devblogs.microsoft.com/dotnet/visual-studio-2019-net-productivity/), but for all of you who were eagerly awaiting the GA release here’s a few features you may enjoy!
Tooling improvements
--------------------
I’m most excited about the new Roslyn classification colors. Visual Studio Code colors received high praise so we incorporated similar color schemes into Visual Studio. Your code editor is now just a little more colorful. Key words, user methods, local variables, parameter names, and overloaded operators all get new colors. You can even customize the colors for each syntax classifications in **Tools > Options > Environment > Fonts and Colors**and scroll to ‘User Members’.
[](https://devblogs.microsoft.com/dotnet/wp-content/uploads/sites/10/2020/04/NewColors-1024x742.png)
At the bottom of files in your editor are the document health indicators as well as our code cleanup icon. The document health indicators let you know at a glance how many errors and warnings are present in the file you currently have open. You can click on the code cleanup icon to apply code style rules specified in **Tools > Options** or, if you have an [editorconfig](https://docs.microsoft.com/visualstudio/ide/create-portable-custom-editor-options) file that shares one code style across your team, it will apply styles specified in that file.
You can edit sdk-style project files with a simple double-click! You can also view these project files with preview in [GoToAll](https://docs.microsoft.com/visualstudio/ide/go-to)(Ctrl+t) navigation and search the contents for file references.
Load a subset of projects in your solution with [filtered solutions](https://docs.microsoft.com/visualstudio/ide/filtered-solutions)! You can now unload projects and save a .slnf file that will only open the projects you specified. This helps you get to the code you are interested in quickly without needing to load an entire solution.
[](https://devblogs.microsoft.com/dotnet/wp-content/uploads/sites/10/2020/04/SolutionFilter-1024x521.png)
Find all references categorizes by reference type. You can filter by read/write in the new ‘Kind’ column in the find all references window.
[](https://devblogs.microsoft.com/dotnet/wp-content/uploads/sites/10/2020/04/FAR_ReadWrite-1024x440.png)
Run code style formatting over the entire solution at the command-line with the `[dotnet format](https://github.com/dotnet/format)` global tool.
[Intellicode](http://aka.ms/intellicode) is an extension offering smarter intellisense completion with machine-learning trained models run over 2,000 open source .NET repositories on GitHub.
[](https://devblogs.microsoft.com/dotnet/wp-content/uploads/sites/10/2020/04/Intellicode-1024x554.png)
Now the omnibus of new code fixes and refactorings!
---------------------------------------------------
##### Foreach to LINQ
##### Add missing reference for unimported types
##### Sync namespace and folder name
##### Invert conditional expressions
##### Pull members up dialog for promoting members to an interface
##### Wrap/indent/align parameters/arguments
##### Remove unused expression values and parameters
This is a set of highlights of what’s new in Visual Studio 2019, for a complete list see the [release notes](https://docs.microsoft.com/en-us/visualstudio/releases/2019/release-notes). As always, I would love your feedback via [twitter](https://twitter.com/VisualStudio), on [GitHub](https://github.com/dotnet/roslyn/issues), or in the comments section below. Also, one important thing to note is that to use .NET Core 3.0 Preview you will need to [download and install](https://dotnet.microsoft.com/download/dotnet-core/3.0)the SDK, it is not included with the Visual Studio 2019 installer yet.
##### [Kendra Havens](https://devblogs.microsoft.com/dotnet/author/kendra-havens/)
Program Manager, .NET and Visual Studio | https://habr.com/ru/post/447462/ | null | en | null |
# MIDI-router на Raspberry Pi
Хочу рассказать о том, как решить проблему, которая наверняка знакома любителям аппаратных синтезаторов.
Что делать, если хочется состыковать MIDI-контроллер и синтезатор, но у одного из них есть только USB разъем и нет MIDI? Причем, по понятным причинам хочется все это сделать не используя компьютер.
Я несколько раз перерывал интернет в поисках устройства для этого, но так ничего и не нашел — кроме пары ссылок на пару малотиражных устройств за немалые деньги, которые уже сняты с производства.
В какой-то момент меня осенило: можно же взять Raspberry Pi и сделать все на нем — это самый настоящий компьютер, а на нем такие вещи делаются легко.
Он, наверное, будет слабоват для полноценной обработки звука, но поток сообщений MIDI уж должен прокачать.
[К слову, существует звуковой эффект [процессор для Raspberry Pi](https://blokas.io/modep), но он требует последней модели Raspberry Pi, которая намного дороже, плюс дополнительного шилда, который тоже недешев, и я решил не заморачиваться].
Сказано — сделано. Обзавелся Raspberry Pi самой первой модели и за пару вечеров собрал рабочий прототип. В двух словах как он работает.
### ALSA Midi
Сперва я планировал взять [PureData](http://puredata.info/) и написать для него несложный патч, который будет перекладывать midi-сообщения из одного порта в другой.
Но когда я начал заводить в нем MIDI на линуксе я нашел гораздо более простой подход.
В Linux есть стандартная система звукового ввода-вывода — ALSA. Она поддерживает работу как со звуковыми потоками, так и с MIDI.
Для того, чтобы какая-то программа могла принимать MIDI-сообщениям через ALSA сперва нужно ее подключить к источнику этих сообщений. Но это же именно то, что нам нужно для решения этой задачи! Недолго думая я выкинул PureData и сделал все родными средствами ALSA.
Вот что получилось в итоге.
### aconnect
При подключении MIDI-устройства в систему оно появляется в устройствах ALSA и с ним можно проводить разные операции стандартными командами. Нас интересует команда `aconnect`, которая как раз производит подключение-отключение портов. Подробную документацию на нее можно [прочитать здесь](https://linux.die.net/man/1/aconnect).
Реально же нам нужны всего две операции: вывести список имеющихся устройств и подключить одно устройство к другому:
```
# Вывести список MIDI-устройств, имеющихся в системе
aconnect -l
# Пересылать весь вывод с Arturia Keystep на Xio
aconnect 'Arturia KeyStep 32' 'Xio'
```
Я обернул эти команды systemd-скриптами для автостарта и настроил, чтобы запускались постоянно в цикле, можно посмотреть как я это сделал [здесь](https://github.com/timurb/pimidirouter).
### Альтернативы
Если нужно все же как-то обрабатывать MIDI-поток до пересылки его на выход, можно воспользоваться несколькими вариантами:
* Каким-то из языков обработки звука:
+ [PureData](http://puredata.info) в headless режиме
+ Вероятно, можно использовать [SuperCollider](https://supercollider.github.io/)
+ [ChucK](http://chuck.cs.princeton.edu/)
* [Mididings](http://das.nasophon.de/mididings/)
Если знаете еще варианты — присылайте.
### Upd: Резюме
Через полтора месяца экспериментов резюмирую.
В итоге практика показала, что для передачи нот оно подходит неважно — ноты частенько съезжают и проскакивают.
Для передачи clock более-менее нормально — в синхронизации арпеджиатора управляемого синта с мастер-ритмом косяков я не слышу.
А вот для передачи сообщений контроллеров, похоже, подходит идеально.
Теперь можно подключить Launch Control XL к любому синту.
### Ссылки
Когда я в прошлый раз изучал этот вопрос почему-то мне не удалось ничего найти.
На этот раз нашлось довольно много всего, выложу ссылки сюда, чтобы вам не повторять мой путь, если возникнет такая же проблема.
* <https://www.youtube.com/watch?v=neXswJJcatc>
* <http://forums.synthstrom.com/discussion/1271/usb-host-midi-interface-with-raspberry-zero>
* <https://github.com/nuc/Midi-Connector>
* <https://stimresp.wordpress.com/2016/02/08/using-a-raspberry-pi-as-usb-midi-host/> | https://habr.com/ru/post/440294/ | null | ru | null |
# Кратко о DOCSIS или есть ли жизнь в КТВ?
Собственно аббревиатуру DOCSIS слышали многие, но далеко не все представляют что это и зачем оно нужно. Самые любопытные могли, даже просветится этим вопросом в википедии, но как показывает практика довольно много вопросов все равно остается. Итак, ~~начинаем срывать покровы~~ давайте разберемся с вопросами:
1. что это?
2. кому это нужно?
3. что для этого нужно?
4. как начать?
Слабонервных не желающих вникать в «How it's made?» просьба под хабракат не заглядывать — там ничего интересного нет.
*Итак, начинаем с общей теории.*
Аббревиатурой DOCSIS (Data Over Cable Service Interface Specifications) обозначается стандарт передачи данных по телевизионному кабелю, который был принят в 98 году. Сей стандарт в оригинале предполагает передачу данных до 42/38 Мбит/с в даунстриме (к пользователю) и до 10/9 Мбит/с в апстриме (от пользователя).
У столкнувшихся с технологией впервые часто возникает вопрос – это каждому? Нет – полоса разделяется на всех пользователей, висящих на этих DS/US.
Собственно версий DOCSIS существует несколько:
— DOCSIS 1.0
— DOCSIS 1.1
— DOCSIS 2.0
— DOCSIS 3.0
— EURODOCSIS
Если не пускаться в подробности различия между ними сводятся к QoS, частотам, агрегации каналов, полосе и модуляциям. Собственно все это прямо связано со скоростями и жизнеспособностью в зашумленных сетях.
Далее переходим к стратегическим вопросам и экономической стороне.
*Кому это нужно?*
Нужно это в первую очередь **существующим** операторам КТВ для расширения спектра услуг предоставлением конечным пользователями высокоскоростного доступа в Интернет и сопутствующих навесок (VoIP, IPTV ну или на что фантазии хватит).
Я выделил слово «существующим» и из-за следующего (думаю очевидного соображения).
Развертывать коаксиальную сеть только ради предоставления доступа к Интернетам пользователям с нуля как минимум глупо и экономически не целесообразно, поскольку есть намного более дешевые и быстрые технологии (например FTTB, ADSL, PON). Как пример если вы не оператор КТВ а скажем АТС то опять же строить коаксиальную сеть по всему городу не представляется полезным значительно дешевле податься в ADSL – думаю понятно.
При существующей грамотно построенной коаксиальной сети накрывающей значительную площадь DOCSIS может стать оптимальным стартом, требующим минимальных вмешательств в физику. Особенно в слабозаселенных районах типа частного сектора, где плотность утыкивания муфтами/свичами/боксами на единицу потребителя может оказаться космической в случае FTTB. Опять же в случае многоэтажной застройки (т.н. спальных районах) с наличествующей конкуренцией в виде «домашних сетей» возможно, имеет смысл развертывать параллельную коаксиальной FTTB сеть или раз уже очень хочется использовать HCNA – будет имхо дешевле и перспективней.
*Оборудование*
В общих чертах типичная схема будет выглядеть так:
Собственно из загугленной картинки сразу становится понятно что для того чтобы предоставить оконечному пользователю интернет требуется:
1. облачко в котором живет интернет ;)
2. сервер с установленными сервисами DHCP, TFTP
3. CMTS (Cable Modem Termination System)
4. коаксиальная сеть идущая к абоненту
5. модем и желание подключится у пользователя
Кратко пробежимся по указанным выше пунктам.
1. с интернетом все понятно – допустим он у нас есть
2. сервер будем использовать на чем-то с чем знаком администратор. Предположим что знаком он с FreeBSD/Linux ;)
3. CMTS… бывают разные ~~черные, белые грязные~~ с кратким перечнем производителей можно ознакомится [здесь](http://docsis.org/node/175) Для совсем несведущих это (очень грубо) такой большой и дорогой модем к которому линкуются абонентские модемы.
4. Основным требованием к сети является – обслуживаемость и наличие на усилителях обратного канала. Обслуживаемость – это перманентное вырезание нелегалов и слежение за уровнями сигнала в прямом и обратном каналах. Сезонный шат сигнала может очень существенно подпортить жизнь пользователям и вашей службе поддержки.
5. С кратким перечнем производителей модемов можно ознакомиться [здесь](http://docsis.org/node/176). Docsis модем является довольно специфичным устройством предоставляющий довольно широкие возможности – начиная ограничением пропускной способности абонента прямо на его модеме и заканчивая фильтрами (грубо удаленно управляемым фаерволом).
*С чего начать?*
В последнее время ко мне с завидной регулярностью стучат админы начальство которых, руководствуясь соображениями, изложенными в «Кому это нужно?» купило CMTS (почему-то чаще всего это что-то типа подержанных BSR1000, BSR2000, CiscoUBR) и сказало «засунь интернет в КТВ сеть».
Для людей знакомых уже с Ethernet или ADSL схема работы DOCSIS сети может оказаться не совсем прозрачной а количество телодвижений нужных для того чтобы хотя бы один модем запингался – окончательно упоротым. Довольно сложно что-то сделать не представляя общих принципов того как это должно работать. Первая мысль которая приходит в голову это прикрутить модем напрямую к CMTS и посмотреть что получится. Естественно не получится ничего – модем будет просто светомузыкально мелькать лампочками и все. Больше ничего не случится.
При попытке соединиться модем сканирует весь диапазон частот на тему наличия downstream/upstream и если находит пытается получить адрес посредством DHCP для модема, если адрес получен — модем по TFTP пытается получить специальным образом собранный конфиг для себя родимого, после чего если конфиг нормально прожеван пытается получить по DHCP адрес для CPE (customer-provided equipment) коим являться будет скорее всего сетевая плата либо роутер.
Работать в норме на тестовом стенде оно должно так:
1. CMTS настроена
2. На сервере подняты вышеуказанные сервисы
3. модем подключен через пачку тапов чтобы обеспечить номинальные уровни сигнала для DS/US.
1. На настройке CMTS заострять внимание мы особо не будем, ибо в зависимости от производителя, физических реалий сети и планируемой топологии сети она будет очень сильно разниться. Радует наличие всеобъемлющей документации, которое шло в комплекте со всеми попадавшими ко мне в руки дивайсами – думаю по ней должно быть все более-менее понятно для людей знакомых с cisco-like интерфейсом и общей теорией настройки сетевых устройств.
Минимальные пассы руками которые следует провести над CMTS чтобы она была готова к стендовым испытаниям выглядят как:
— прописываем частоту DS
— прописываем частоты и модуляции для US
— прописываем адрес DHCP сервера который мы будем рилеить
— прописываем secret key для конфигов
— прописываем пароли
— сохраняемся
2. Поднимаем на сервере нужные нам сервисы.
# cd /usr/ports/net/isc-dhcp31-server/ && make install (собираем с поддержкой Option82)
tftpd скорее всего у нас есть по умолчанию, просто раскоментируем его в /etc/inetd.conf
#cd /usr/ports/net-mgmt/docsis && make install
Который нужен нам для генерации бинарных конфигов для DOCSIS-совместимых модемов как гласит pkg-descr.
Допустим CMTS мы настроили как 10.10.10.9 рилеящую DHCP риквесты на сетевую нашего хоста с айпишкой 10.10.10.10 которая смотрит на CMTS. Тогда наш /usr/local/etc/dhcpd.conf должен выглядеть следующим образом
`option domain-name "catv";
option domain-name-servers 10.10.10.10;
default-lease-time 3600;
max-lease-time 43200;
authoritative;
ddns-update-style none;
log-facility local7;
one-lease-per-client true;
deny duplicates;
subnet 10.10.200.0 netmask 255.255.248.0 {
default-lease-time 3600;
max-lease-time 86400;
option domain-name-servers 10.10.10.10;
option subnet-mask 255.255.248.0;
option routers 10.10.200.1;
include "/usr/local/etc/users_dhcp.conf";
}
subnet 10.10.100.0 netmask 255.255.248.0 {
default-lease-time 3600;
option subnet-mask 255.255.248.0;
option routers 10.10.100.1;
server-name "10.10.10.10";
option tftp-server-name "10.10.10.10";
option bootfile-name "cm_config/other.b";
next-server 10.10.10.10;
filename "cm_config/other.b";
option time-servers 10.10.10.10;
option time-offset 2;
include "/usr/local/etc/modems_dhcp.conf";
}`
Из чего должно быть понятно что мы резервируем под модемы сеть 10.10.100/21 и под пользовательские CPE сеть 10.10.200/21
Для простоты работы в будущем хосты для сабнетов мы инклудим из /usr/local/etc/modems\_dhcp.conf и /usr/local/etc/users\_dhcp.conf соответственно. Для начала в /usr/local/etc/modems\_dhcp.conf мы вписываем наш тестовый модем в виде
`host m1002 {
hardware ethernet 00:ff:ff:55:ff:f2;
fixed-address 10.10.100.3;
filename "cm_config/testmodem.b";
}`
А в и /usr/local/etc/users\_dhcp.conf добавляем свой тестовый хост:
`host m10102002 {
hardware ethernet 00:cc:cc:99:aa:ff;
fixed-address 10.10.200.2;
}`
Директива filename должна намекать на то что в ней содержится путь (относительно tftp root который обычно в /tftpboot) к забинареному конфигу модема. В простейшем случае конфиг модема (не пригодный к реальному использованию! For testing purposes only! Achtung!) будет выглядеть следующим образом:
`#cat /tftpboot/cm_source/testing
Main {
NetworkAccess 1;
GlobalPrivacyEnable 0;
UsServiceFlow
{
UsServiceFlowRef 200;
QosParamSetType 7;
MaxRateSustained 0;
SchedulingType 2;
}
DsServiceFlow
{
DsServiceFlowRef 100;
QosParamSetType 7;
TrafficPriority 3;
MaxRateSustained 0;
}
MaxCPE 16;
}`
Теперь нам следует его скомпилить в приемлемый для модема вид при помощи ранее собранной утилиты docsis используя указанный на CMTS secret-key
`#echo "sosecret" > /somewhere/key
#docsis -e /tftpboot/cm_source/testing /somewhere/key /tftpboot/cm_config/testing.b`
Прописываем рауты для сетей модемов, и пользователей на CMTS в rc.conf:
`static_routes="cable modem"
route_cable="10.10.200.0/21 10.10.10.9"
route_modem="10.10.100.0/21 10.10.10.9"`
3. собираем из ~~спичек и желудей~~ пигтейлов и тапов конструкцию объединяющую DS и один из US и обеспечивающую прохождение на модем указанных в документации уровней сигнала.
Если мы все сделали правильно то на CMTS в
`bsr#show cable modem`
Мы увидим что-то типа
`Cable 0/0/D0/U0/C0 431 online 1458 26.0 10.10.100.3 00ff.ff55.fff2`
И соответственно наши тестовый модем и тестовый хост которые как мы помним 10.10.100.3 и 10.10.200.2 должны пингаться.
**Видите как все просто и наглядно? – а вы боялись. =)**
В случае сегментирования сети на множество CMTS для обеспечения повышения отказоустойчивости и быстродействия все выглядит аналогичным образом. И сводиться к разнесению разных сетей по раутам.
Вышеприведенный конфиг не адекватен для реального применения по ряду причин:
Как минимум:
— нету фильтров на изоляцию пользователей
— нету прописанных snmp для сбора статистики
— нету привязки модема к конкретному CPE
Еще хорошо было бы сделать:
— шейпинг канала прямо на устройстве
— учесть особенности различных дивайсов
— отрубить веб-лицо модема, пользователю там делать нечего
— грамотно построить QoS
Изначально я очень хотел написать пошаговый мануал по тому, как сделать не просто чтобы «ходили интернеты» а и по тому, как грамотно их продать конечным пользователям, собственно с примерами конфигов, готовой АСР итд. Но так как писатель из меня честно-говоря никакой — мне банально стыдно показывать свой быдлокод который к тому же довольно узкоспецифичен и в любом случае требует глубокой доводки под конкретного оператора :)
В общих чертах требования к биллингу работающему в DOCSIS сети очень просты:
— уметь считать трафик
— уметь считать деньги
— делать из посчитанных денег трафика гибкие тарифы
— гибко ограничивать пользовательскую полосу
— уметь на лету компилировать конфиги к модемам на каждого пользователя + править хосты dhcpd.
Если с первыми четырьмя пунктами все понятно – и собственно все АСР ими в основном и занимаются, то на последнем следует заострить внимание на последнем. Естественно можно выдать один конфиг на всех, а потом аутентификацию пользователя производить при помощи внутренних механизмов АСР (разношерстные авторизаторы) либо скажем методом PPtP тунелля но это я считаю просто дополнительным костылем и сознательным отказом от очень удобных возможностей предоставляемых технологией.
Думаю сейчас много-много людей скажет, что технология мертва, дорога, не актуальна и потыкают меня мордочкой в FTTB, PON, HCNA. Да я в курсе что такие есть и что например в плотнозаселенных многоэтажках намного цена/скорость порта в десятки раз дешевле с FTTB и что HCNA предоставляет по тому же коаксиалу намного более вкусные скорости при сопоставимой стоимости абонентских железок и отсутствии в необходимости покупки относительно дорогой CMTS. Если интересно могу на пальцах объяснить, почему FTTB в частном секторе это дорого, и почему там же HCNA сводится к «почти FTTB» по стоимости порта а так же почему публика пока еще не готова к PON. Опять же для применения любой пока еще живой технологии всегда есть свои мотивы от «давайте использовать существующую сеть» до «иначе будет слишком дорого и долго». Опять же выбор играть в демпинг и гоняться со скоростями домашних сетей не самый хороший вариант при вышеуказанных ТТХ и собственно козырем DOCSIS провайдера должны быть имхо сервисы предоставляемые по одному кабелю и их качество.
На данном этапе развития DOCSIS 2.0 может в полнее успешно конкурировать с ADSL а 3.0 наступает на пятки остальным как перспективная платформа для Triple Play.
Как всегда в конце статьи я использую свою слабую *отмазку* звучащую как:
«Да я не грамотен, я знаю. Язык не родной, в школе не учили, хотя догадываюсь это слабая отмазка. Если вы воспринимаете пропущенную запятую как личное оскорбление – приношу извинения заранее. Честно – я не хотел»
Как правило, действует ;)
Статья написана по спецзаказу журнала [«Кабельщик»](http://www.cableman.ru/) | https://habr.com/ru/post/102429/ | null | ru | null |
# Способы представления словарей для автоматической обработки текстов
Автоматический анализ текстов практически всегда связан с работой со словарями. Они используются для морфологического анализа, выделения персон (нужны словари личных имен и фамилий) и организаций, а также других объектов.
В общем виде словарь — множество записей вида {строка, данные ассоциированные с этой строкой}.
Например, для морфологического анализа словарь состоит из троек {словоформа, нормальная форма, морфологические характеристики}. При анализе слова «мыла» из предложения «мама мыла раму» надо уметь получать следующие варианты анализа:
| Нормальная форма | Характеристики |
| --- | --- |
| МЫЛО | S (существительное), РОД (родительный падеж), ЕД (единственное число), СРЕД (средний род), НЕОД
(неодушевленность) |
| МЫЛО | S (существительное), ИМ (именительный падеж), МН (множественное число), СРЕД (средний род), НЕОД (неодушевленность) |
| МЫЛО | S (существительное), ВИН (винительный падеж), МН (множественное число), СРЕД (средний род), НЕОД (неодушевленность) |
| МЫТЬ | V (глагол), ПРОШ (прошедшее время), ЕД (единственное число), ИЗЪЯВ (изъявительное наклонение), ЖЕН (женский род), НЕСОВ (несовершенный вид) |
Хеш-таблицы
===========
На первый взгляд все просто. Надо использовать хеш-таблицу и дело с концом. Когда словарь маленький это решение очень просто и эффективно.
Однако, например, морфологический словарь русского языка содержит около 5 млн. словоформ. Получается, что:
* Надо хранить эти 5 млн. словоформ
* Для каждой словоформы должна быть ссылка на множество наборов морфологических характеристик
* Для каждой словоформы хранить ее начальную форму
Такой способ организации данных является неэкономным, поскольку, во-первых, слова склоняются в основном регулярно, и, во-вторых, в случае русского языка в рамках одного словарной статьи можно выделить подгруппы словоформ, в которых сама форма изменяется незначительно, или не изменяется совсем.
Например, слово «стена»:
* ед. ч: «стен**а**»[им], «стен**ы**»[род], «стен**е**»[дат], «стен**у**»[вин], «стен**ой**»[твор], «стен**ою**»[твор], «стен**е**»[предл];
* мн. ч: «стен**ы**»[им], «стен»[род], «стен**ам**»[дат], «стен**ы**»[вин], «стен**ами**»[твор], «стен**ах**»[предл].
Видно, что изменяется только окончание, но в хеш-таблице надо хранить слово целиком.
Можно раздельно храненить основы (неизменяемых частей) и окончания, но в этом случае усложняется проверка слова.
От префиксного дерева к конечным автоматам
==========================================
Для ясности примеров будем рассматривать более простую задачу, когда для каждой словоформы при анализе надо получать только ее морфологические признаки. Как хранить нормальную форму будет описано в конце.
По сравнению с хеш-таблицами, более компактным представлением является префиксное дерево (trie):
Важное замечание — на рисунках не будут показываться наборы признаков, ассоциированные с каждым конечным узлом дерева (или состоянием конечного автомата). Например, на рисунке узел 6, куда мы попадем по строке «стены» на самом деле будут 3 разбора:
* единственное число, родительный падеж;
* множественное число, именительный падеж.;
* множественное число, винительный падеж.
Префиксное дерево можно рассматривать как конечный автомат.
В автомате есть три вида состояний:
* Начальные — те, с которых начинается работа с автоматом. В детерминированном автомате такое состояние одно, но в недетерминированном их может быть несколько. На рисунках это крайнее левое состояние с номером 0.
* Финальные — такие состояния, достижение которых означает, что такое слово в словаре есть. Они обозначаются двойным кругом
* Простые состояния, которые не являются ни начальными, ни финальными
В дальнейшем будут использоваться обозначения:
* строка обозначается как w
* w[i] — i-тый символ данного слова (начиная с 0).
* s[i] — i-тый узел дерева (или состояние автомата), состояния нумеруются неотрицательными целыми числами, так же будем считать, что s[0] — начальное состояние.
* s[i][j] — переход из состояния s[i] по символу j. Считаем, что если переход есть, то такое выражение вернет номер состояния, если нет — то вернет -1.
Приведу базовые алгоритмы для префиксного дерева/конечного автомата.:
```
// вычислить префикс строки в автомате
// и вернуть последовательность (путь) состояний
int[] prefix(w) {
int[] stateList;
// сохраняем и начальное состояние в пути обхода префикса
stateList[0] = 0;
int current = 0;
for(int i = 0; i < length(w); i++) {
int next = s[current][w[i]]
// если перехода нет, то выход
if(next == -1)
break;
stateList[i+1] = next;
}
return stateList;
}
// добавить суффикс к заданному состоянию
// и добавить состояния префикса к stateList
void addSuffix(w, int[] stateList) {
// получить последнее состояние из пути обхода префикса
int current = stateList[length(stateList) - 1];
for(int i = length(stateList) - 1; i < length(w); i++) {
// добавляем новое состояние в автомат
int newState = addState();
// добавить новый переход
s[current][w[i]] = newState;
current = newState;
// сохраним состояние в пути обхода
stateList[i + 1] = current;
}
// установка признака финальности для s[current]
setFinal(current);
}
// добавить новую строку в trie
void add(w) {
// найти максимальный общий префикс
int[] prefixStates = prefix(w);
// добавить оставшийся суффикс в автомат
addSuffix(w, prefixStates)
}
```
Представление префиксного дерева как конечного автомата обладает важными свойствами:
* такой автомат детерминирован — из каждого состояния возможно не более одного перехода по некоторому символу
* в нем нет циклов — при любом способе обхода автомата никакое состояния не посещается более одного раза.
Такой специальный автомат называется DAFSA (deterministic acyclic finite state automaton).
Надо сделать еще одно важное замечание. Для удобства представления и для практического использования будем считать, что состояние описывается не только таблицей переходов, но и данными о финальности состояния. И будем считать, что состояние финально, если в нем такие данные есть, и нет — если они отсутствуют.
Минимальные конечные автоматы
=============================
Использование префиксных деревьев позволяет избавиться от избыточности префиксов. Фактически это означает, что сокращается объем для хранения неизменяемой части слова. Однако, например, в русском языке окончания слова изменяются в основном регулярно.
Например, слова «стрела» и «стена» изменяются одинаково:
СТЕНА: ед. ч: «стена»[им], «стены»[род], «стене»[дат], «стену»[вин], «стеной»[твор], «стеною»[твор], «стене»[предл]; мн. ч: «стены»[им], «стен»[род], «стенам»[дат], «стены»[вин], «стенами»[твор], «стенах»[предл].
СТРЕЛА: ед. ч: «стрела»[им], «стрелы»[род], «стреле»[дат], «стрелу»[вин], «стрелой»[твор], «стрелою»[твор], «стреле»[предл]; мн. ч: «стрелы»[им], «стрел»[род], «стрелам»[дат], «стрелы»[вин], «стрелами»[твор], «стрелах»[предл].
Видно, что состояния 4 и 17, с которых начинаются окончания, у обоих слов эквивалентны. Очевидно, что слов с одинаковыми правилами словоизменения в словаре будет много. А значит можно существенно сократить число состояний.
Собственно, в теории автоматов есть понятие о минимальном автомате – таком автомате, который содержит минимально возможное число состояний, но был бы эквивалентен данному.
Например, для приведенного выше автомата, минимальный выглядит вот так:
Существуют и алгоритмы минимизации конечных автоматов, но все они обладают существенным недостатком — для их работы необходимо построить сначала неминимизированный автомат.
Другим, менее очевидным недостатком, является то, что построенный минимальный автомат не так просто изменять. К нему не подходит простая процедура добавления нового слова, которая используется для префиксного дерева.
Например, мы построили автомат для слов «fox» и «box», а потом минимизировали его.
Если в этот автомат добавить без полного перестроения слово «foxes», то получится следующая картина:
Получается, что в месте с «foxes» добавилось и «boxes», которое мы не добавляли.
В результате схема использования классических алгоритмов минимизации следующая: при любом изменении словаря необходимо:
* Построить префиксное дерево (или дополнительно хранить)
* Минимизировать автомат
Если словарь большой, то эти процедуры могут занимать значительное время и объем памяти.
Инкрементальная минимизация детерминированных ацикличных конечных автоматов
===========================================================================
Решение трудностей с минимизацией автоматов представлено в работе: [Jan Daciuk; Bruce W. Watson; Stoyan Mihov; Richard E. Watson. «Incremental Construction of Minimal Acyclic Finite-State Automata»](http://aclweb.org/anthology-new/J/J00/J00-1002.pdf). В ней представлен алгоритм инкрементальной минимизации детерминированных ацикличных конечных автоматов. Он позволяет изменять уже построенный минимальный автомат. В результате не надо строить полный автомат, а затем его минимизировать.
Опять рассмотрим наш автомат СТЕНА+СТРЕЛА:
Важным понятием алгоритма является «состояния строки» — это последовательность состояний, которая получается при обходе автомата по заданной строке.
Например, при обходе строки «стрелой» получим следующую последовательность состояний [0, 1, 2, 14, 15, 4, 9, 10].
Другим важным понятием этого алгоритма является число переходов в заданное состояние (confluence). Если число переходов более одного, то изменять такое состояние небезопасно. На рисунке это состояние 4: у него 2 входящие стрелки.
Кроме того, алгоритм предполагает, что существует реестр состояний, который позволяет быстро получить состояние, равное данному.
В результате алгоритм добавления слова w выглядит так:
```
void addMinWord(w) {
// найти максимальный префикс w и сохранить его состояния
int[] stateList = commonPrefix(w);
// найти первое состояние с более одним входящим переходом
int confIdx = findConfluence(stateList);
// клонировать его и все последующие состояния
if(confIdx > -1) {
int idx = confIdx;
while(idx < length(stateList)) {
int prev = stateList[idx - 1];
int cloned = cloneState(stateList[idx]);
stateList[idx] = cloned;
// после клонирования самого состояния
// нужно заменить переход с предыдущего на клонированное
s[prev][w[idx - 1]] = cloned;
idx++;
confIdx++;
}
}
// добавить суффикс
addSuffix(w, stateList);
// заменить состояния строки теми, что есть в реестре.
//Если их нет, то добавить в реестр
replaceOrRegister(w, nodeList);
}
void replaceOrRegister(w, int[] stateList) {
int stateIdx = length(stateList) - 1;
int wordIdx = length(w) - 1;
// обходим состояния строки с конца
while(stateIdx > 0) {
int state = stateList[stateIdx];
// получить из реестра состояние, равное state
int regState = registerGet(state);
if(regState == state) {
// если в реестре state уже есть, то переходим к предыдущему
continue;
} else if(regState == -1) {
// если состояния в реестре нет, то добавим его в реестр
registerAdd(state);
} else {
// основная часть, когда в реестре есть состояние, равное state
int in = w[wordIdx];
// корректируем переход
s[stateList[stateIdx - 1]][in] = regState;
// заменяем состояние в пути обхода
stateList[stateIdx] = regState;
// удаляем замененное состояние из автомата
removeState(state);
}
wordIdx--;
stateIdx--;
}
}
```
Иллюстрация работы алгоритма
----------------------------
Рассмотрим простой случай, когда финальность состояние — бинарный признак. Состояние или финально, или нет.
Автомат для строки «fox».
Видно, что автомат минимальный, в реестре находятся все состояния [0,1,2,3]
Добавим к нему слово «box». Поскольку у них нет общего префикса, то добавляем всю строку как суффикс. В результате получим:
Можно заметить что состояния 3 и 6 равны. Заменим 6 на 3:
Теперь видно, что равны 2 и 5. Заменим 5 на 2:
А теперь видно, что равны 1 и 4. Заменим 4 на 1:
Добавим строку «foxes». При вычислении префикса нашли, что состояния [0, 1, 2, 3] — путь префикса.
Кроме того, обнаружили, что в состояние 1 входит более одного перехода. Как результат — надо клонировать состояния 1, 2 и 3 по пути обхода слова «fox», поскольку если просто добавить «foxes» к предыдущему автомату, то будет распознаваться строка «boxes», которую мы не задавали.
Теперь добавим «boxes»:
При добавлении «boxes» автомат стал меньше. Это на первый взгляд неожиданное поведение, когда при добавлении новых строк автомат в действительности уменьшается. Есть и обратное поведение — когда при удалении строки автомат увеличивается.
Для правильной работы алгоритма важно корректно реализовать работу с реестром. Состояние удаляется из реестра при любом его изменении таблицы переходов состояния и признака финальности.
Кроме того, в отличие от обычного множества или таблицы, в добавление/удаление из реестра оперирует точно этим состоянием, а запрос делается на равное.
Практические использование
==========================
Представленный алгоритм используется в проекте [АОТ](http://www.aot.ru) и в [системе ЭТАП-3](http://iitp.ru/ru/science/works/452.htm) для организации быстрого морфологического анализа. При использовании конечных автоматов достигается скорость анализа порядка 1-1.5 млн. слов в секунду. При этом размер автомата без особых ухищрений умещается в 8 Мб.
Ранее описывалось хранение данных строки как признак финальности. Рассмотрим этот подход более подробно.
Хранение данных в состоянии автомата
-------------------------------------
Подход предполагает, что данные строки рассматриваются как некий атомарный объект. Это в свою очередь накладывает ограничения на эффективность минимизации автомата.
Например, процедура построения минимального автомата бессмысленна для идеального хеширования, когда со строкой ассоциировано уникальное число. Потому что в этом случае каждый суффикс будет уникальным, и соответственно, минимизации не будет, поскольку каждое финальное состояние уникально.
Для морфологического анализа в качестве ассоциированных данных можно использовать наборы морфологических характеристик. Это хорошо работает, поскольку таких наборов мало относительно общего количества словоформ. Например в русском языке в зависимости от принятой модели число таких наборов 500-900. А словоформ 4-5 млн.
Однако, эффективность минимизации сходит на нет, если в добавок к характеристикам сохранять и полную нормальную форму. Это происходит потому, что пара {нормальная форма, морфологические характеристики} практически уникальна.
В системе ЭТАП-3 используется именно такой подход для хранения морфологической информации. В самом автомате хранятся только наборы морфологических признаков. А для хранения нормальной формы используется следующий трюк. На этапе построения автомата в качестве входного символа используется не один знак, а два. Например, при добавлении словоформы «стеной» (СТЕНА в творительном падеже) будет добавлена следующая последовательность пар знаков: «с: С», «т: Т», «е: Е», «н: Н», «о: А», «й:\_».
Все словоформы слов «стена» и «стрела» в таком автомате будут выглядеть так:
Такой подход к записи нормальной формы обладает важным достоинством. Он позволяет работать с морфологией в двух направлениях. Можно по словоформе получить ее разбор — анализ. А можно по нормальной форме получить все ее словоформы — синтез.
Недостатком такого подхода является то, что несмотря на то, что для пары знаков автомат является детерминированным, то для входного он уже не является таковым и надо перебирать все переходы из данного состояния. Например состояние m, на рисунке выше. В нем имеется несколько переходов по знаку словоформы «а».
Хранение данных в переходах. Использование аннотаций
-----------------------------------------------------
Другой способ для хранения дополнительных данных был описан в оригинальной работе. Он предполагает изменение самих строк, которые хранятся в автомате.
Предлагается сделующая схема. Вместо целевой строки в автомат записывается расширенная строка, которая состоит из целевой строки, символа начала данных (аннотирующего символа) и самих данных.
Например, в этом случае морфологические характеристики могут быть записаны следующим образом: «стена|+сущ+жен+им, ...», где '|' — аннотирующий символ, а "+cущ", "+жен", "+им" — специальные символы данных.
Этот подход используется в системе АОТ. В ней в качестве данных хранится фактически две ссылки: на морфологические характеристики и на номер правила словоизменения. В результате при анализе можно по словоформе получить как ее морфологические признаки, так и начальную форму.
Особенностью этого подхода является то, что несколько усложняется модель автомата. Символ перехода интерпретируется по-разному в зависимости от того был он до аннотирующего символа или после.
Другой особенностью является то, что для обход по строке несколько усложняется. Во-первых, строка присутствует в автомате, если после ее обхода мы оказываемся в состоянии, из которого есть переход по аннотирующему символу. Во-вторых, необходима процедура сбора всех аннотаций после аннотирующего символа. В третьих, необходима процедура декодирования аннотации.
Оптимизация объема памяти
--------------------------
Для оптимизации объема памяти используется два представления конечных автоматов: один для построения минимального автомата, а другой — для анализа. Разница между ними в том, что автомат для анализа не предполагает изменений и поэтому может быть более эффективно размещен в памяти.
Автомат для анализа состоит из трех структур:1. таблица переходов — пары целых {символ перехода, целевое состояние}
2. индексы начала и конца диапазона переходов состояния
3. таблица данных финальных состояний
Автоматы получаются достаточно компактными. Например, словарь АОТ без особых ухищрений занимает около 8Мб. Полные данные системы морфологического анализа, которые включают в себя не только анализ по словарю, но и предиктивный анализ слова умещаются в 16Мб.
Сами алгоритмы минимизации реализованы в моем проекте на Github: [github.com/kzn/fsa](https://github.com/kzn/fsa) | https://habr.com/ru/post/190694/ | null | ru | null |
# Отладка сложных веб-приложений — эффективная багодробилка на production-серверах
Всем привет!
Сегодня расскажу, как на боевых серверах во время нагрузки, в пыли и грязи, эффективно отлавливать узкие места в производительности больших веб-приложений на PHP, а также искать и устранять «нестандартные» ошибки. Многие из описанных техник мы с успехом применяем на нашем облачном сервисе [«Битрикс24»](http://www.bitrix24.ru).
Информация, надеюсь, пригодится системным администраторам и разработчикам, обслуживающим сложные веб-проекты, а также менеджерам, которые хотят выстроить эффективный и быстрый процесс поиска и устранения узких мест и ошибок проектов на PHP.
#### Миф о полном тестировании
Есть такой добрый и светлый миф из [XP/TDD](http://ru.wikipedia.org/wiki/%D0%AD%D0%BA%D1%81%D1%82%D1%80%D0%B5%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5), что можно покрыть веб-приложение на 100% модульными и функциональными тестами, написать кучу [Selenium](http://seleniumhq.org/)-тестов, кликающих по системе снаружи и без страха вносить в систему доработки и выкладывать на бой через [процесс непрерывной интеграции](http://ru.wikipedia.org/wiki/%D0%9D%D0%B5%D0%BF%D1%80%D0%B5%D1%80%D1%8B%D0%B2%D0%BD%D0%B0%D1%8F_%D0%B8%D0%BD%D1%82%D0%B5%D0%B3%D1%80%D0%B0%D1%86%D0%B8%D1%8F) :-) Это романтика из разряда «любить до гроба и изменить перед смертью», к счастью, далека от реальности и вот почему:
1. Требования к веб-проекту будут постоянно меняться, ПОСТОЯННО, до самого запуска. В теории можно их зафиксировать, конечно, но перед запуском обязательно нарисуется менеджер с улыбкой нациста и словами «срочно, сегодня».
2. Если все покрывать тестами по совести — не хватит программистов и времени, поверьте. Нередко встречаются отклонения типа написания [mock-объектов](http://en.wikipedia.org/wiki/Mock_object) к [API Amazon](http://aws.amazon.com), можно еще системные вызовы операционной системы начать тестировать :-)
3. Если на веб-проекте часто меняется верстка будет сложно, очень сложно поддерживать [Selenium](http://seleniumhq.org/)-тесты в актуальном состоянии
4. Некоторые вещи, например устойчивость сайта под нагрузкой, непросто протестировать. Нужно сломать голову и придумать схему нагрузки, которая похожа на реальную, но она будет все равно другой.
5. Мы интуитивно доверяем… языку программирования, а он может содержать баги, которые появятся совершенно внезапно. Не будем же мы поэтому покрывать тестами PHP?
6. и т.п.
В общем, если вы до сих пор верите, что тесты защитят вас на 100% от проблем и их должно быть в 2 раза больше чем кода, дальше можете не читать — программирование не для романтиков :-)
Тем не менее, и все это понимают, тесты писать нужно. Для ключевых вещей, для системных модулей — нужно писать и поддерживать в актуальном состоянии. Для остальных задач можно написать тест-планы и тестировать «человеческим фактором», прокликивая отделом тестировщиков все страницы веб-решения перед каждым обновлением, тщательно наблюдая за появлением ошибок в логах и собирая фидбек от пользователей.
Таким образом, если ваш проект еще жив и успешно работает в сети, вы скорее всего используете и unit-тесты, и функциональные тесты, и [Selenium](http://seleniumhq.org/), и вариант процесса постоянной интеграции с системой контроля версий и труд тестировщиков. При этом вы понимаете, что ошибки обязательно будут просачиваться на боевые сервера и их нужно научиться быстро находить и устранять. Основная идея тут: и соломку подстелить в разумном количестве и держать эффективное оружие наготове, способное молниеносно срезать голову любому багу или проблеме производительности.
#### Инструменты отладки на PHP
Многие проекты обходятся командой «var\_dump» и «echo» :-), однако, по мере их усложнения, разработчики скорее всего установят на локальных серверах что-то типа [XDebug](http://xdebug.org/) или [Zend Debugger](http://www.ibm.com/developerworks/ru/library/os-php-zenddebug/) — что разумно и действительно упрощает отладку веб-приложения, если научиться этими штуками грамотно пользоваться.
Очень часто оказывается полезным XDebug в [режиме сбора трейса](http://habrahabr.ru/post/31463/). Иногда без трейса отловить ошибку или узкое место в производительности просто невозможно.
Тем не менее, есть одно весомое но — эти инструменты создают серьезную нагрузку на веб-проект и включать их на боевых серверах — опасно. Инструменты помогут вам «вылизать» код на локальных серверах, но «выжить на бою», к сожалению, не помогут.
#### Отладка на бою
##### Логируйте всё
Очень полезно, если нагрузка позволяет, включить на боевых серверах лог-файлы nginx, apache, php-fpm, вести свои лог-файлы бизнес-операций (создание особенных заказов, экспорт из 1С-Битрикс в SAP и т.п.).
Если у вас [веб-кластер](http://www.1c-bitrix.ru/products/cms/features/webcluster.php) или просто много серверов с PHP — попробуйте собирать логи с этих машин на одну машину, где их централизованно мониторить. На [«Битрикс24»](http://www.bitrix24.ru) для этого мы используем [syslog-ng](http://en.wikipedia.org/wiki/Syslog-ng). Имея лог ошибок PHP со всех серверов кластера на одной машине, в одном файле — не придется бегать с вытаращенными глазами по машинам при аварии. Запускаете [screen](http://ru.wikipedia.org/wiki/GNU_Screen) и вы в курсе происходящего.
##### «Боевой» профилировщик — xhprof
К счастью PHP-разработчиков и администраторов, коллеги из Facebook написали и выложили для общей пользы отличный и полезный «боевой» профилировщик — [xhprof](http://pecl.php.net/package/xhprof). Если вы еще не знакомы с этим инструментом — изучите его. Настраивается в 2 клика, а пользы на 5 тонн.
Самое главное — его можно включить на бою, т.к. он практически не создает на нагрузку на PHP (проценты).
Он позволяет увидеть профиль выполнения хита:
А также критический путь — что же тормозило-то на бою:
Причем он хорошо сочетается с встроенным инструментом отладки платформы «Битрикс» (если у вас веб-решение на этой платформе) — xhprof можно запускать на бою в пиках нагрузки, а [монитор производительности](http://www.1c-bitrix.ru/products/cms/features/perfmon.php#tab-intro-link) — когда нагрузка не зашкаливает или на серверах разработки/тестирования.
##### Динамическая трассировка
Если у вас [веб-кластер](http://www.1c-bitrix.ru/products/cms/features/webcluster.php), нередко удобно автоматизировать процесс динамической профилировки. Суть проста — профилировщик постоянно включен, после исполнения страницы мы проверяем время хита и если оно больше, к примеру, 2 секунд, сохраняем трейс в файл. Да, это добавляет лишних 50-100 мс, поэтому можно включать систему при необходимости либо включать по каждому, например, десятому хиту.
```
auto_prepend_file.php:
//Включаем профайлер по переменной или куке, хотя можно включать сразу
if (isset($_GET['profile']) && $_GET['profile']=='Y') {
setcookie("my_profile", "Y");
}
if (isset($_GET['profile']) && $_GET['profile']=='N') {
setcookie("my_profile", "",time() - 3600);
}
if ( !( isset($_GET['profile']) && $_GET['profile']=='N') && ( $_COOKIE['my_profile']=='Y' || ( isset($_GET['profile']) && $_GET['profile']=='Y') ) && extension_loaded('xhprof') ) {
xhprof_enable();
}
```
```
dbconn.php:
//Время выполнения хита получаем из пинбы, но можно в принципе напрямую из PHP (http://php.net/manual/ru/function.microtime.php)
//Forcing storing trace, if req.time > N secs
$profile_force_store = false;
$ar_pinba = pinba_get_info();
if ($ar_pinba['req_time']>2) $profile_force_store=true;
...
if ($profile_force_store || ( !(isset($_GET['profile']) && $_GET['profile']=='N') &&
( $_COOKIE['my_profile']=='Y' || ( isset($_GET['profile']) && $_GET['profile']=='Y' )) && extension_loaded('xhprof') ) {
$xhprof_data = xhprof_disable();
$XHPROF_ROOT = realpath(dirname(__FILE__)."/perf_stat");
include_once $XHPROF_ROOT . "/xhprof_lib/utils/xhprof_lib.php";
include_once $XHPROF_ROOT . "/xhprof_lib/utils/xhprof_runs.php";
// save raw data for this profiler run using default
// implementation of iXHProfRuns.
$xhprof_runs = new XHProfRuns_Default();
// save the run under a namespace "xhprof_foo"
$run_id = $xhprof_runs->save_run($xhprof_data, "xhprof_${_SERVER["HTTP_HOST"]}_".str_replace('/','_',$_SERVER["REQUEST_URI"]));
```
Таким образом, если хит оказался дольше 2 секунд, мы его сохраняем во временную папку на сервере. Затем, на машине мониторинга можно обойти сервера и забрать с них трейсы для централизованного анализа (пример для виртуальных хостов в амазоне):
```
#!/bin/bash
HOSTS=`as-describe-auto-scaling-groups mygroup | grep -i 'INSTANCE' | awk '{ print $2}' | xargs ec2-describe-instances | grep 'INSTANCE' | awk '{print $4}'`
for HOST in $HOSTS ; do
scp -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -p -i /home/trace_loader/.ssh/id_rsa "trace_loader@${HOST}:/tmp/*xhprof*" /my_profiles
done
```
Теперь у вас есть собранные в одном месте трейсы запросов более 2 секунд — написать веб-интерфейсик для их просмотра в отсортированном по дате порядке займет минут 30. Часть бизнес-процесса готова — каждый трейс является фактически ТЗ на оптимизацию веб-приложения, можно подключать к ним специалистов из разработки.
#### Погружаемся глубже — strace
Иногда профилировщик и лог-файлы не позволяют определить причину проблемы. Однако при отладке (XDebug) на серверах разработки воспроизвести проблему — не получается. Остается одно, понять что происходит в момент наступления события на боевом сервере. Тут часто неоценимую помощь оказывает трассировщик системных вызовов, например [strace](http://en.wikipedia.org/wiki/Strace). Только не нужно впадать в ступор при виде системных вызовов Linux — поверьте, немного терпения, 2-3 кружки кофе и вы поймете идею и сможете отлавливать на боевых серверах самые трудноуловимые ошибки и узкие места :-)
Нужно правильно «прицепить» трассировщик к процессам PHP. Процессов часто запущено много, в разных пулах, они постоянно гасятся и поднимаются (нередко для защиты от утечек памяти задают время жизни процесса например в 100 хитов):
`ps aux | grep php
root 24166 0.0 0.0 391512 4128 ? Ss 11:47 0:00 php-fpm: master process (/etc/php-fpm.conf)
nobody 24167 0.0 0.6 409076 48168 ? S 11:47 0:00 php-fpm: pool www1
nobody 24168 0.0 0.4 401736 30780 ? S 11:47 0:00 php-fpm: pool www1
nobody 24169 0.0 0.5 403276 39816 ? S 11:47 0:00 php-fpm: pool www1
nobody 24170 0.0 1.0 420504 83376 ? S 11:47 0:01 php-fpm: pool www1
nobody 24171 0.0 0.6 408396 49884 ? S 11:47 0:00 php-fpm: pool www1
nobody 24172 0.0 0.5 404476 40348 ? S 11:47 0:00 php-fpm: pool www2
nobody 24173 0.0 0.4 404124 35992 ? S 11:47 0:00 php-fpm: pool www2
nobody 24174 0.0 0.5 404852 42400 ? S 11:47 0:00 php-fpm: pool www2
nobody 24175 0.0 0.4 402400 35576 ? S 11:47 0:00 php-fpm: pool www2
nobody 24176 0.0 0.4 403576 35804 ? S 11:47 0:00 php-fpm: pool www2
nobody 24177 0.0 0.7 410676 55488 ? S 11:47 0:00 php-fpm: pool www3
nobody 24178 0.0 0.6 409912 53432 ? S 11:47 0:00 php-fpm: pool www3
nobody 24179 0.1 1.3 435216 106892 ? S 11:47 0:02 php-fpm: pool www3
nobody 24180 0.0 0.7 413492 59956 ? S 11:47 0:00 php-fpm: pool www3
nobody 24181 0.0 0.4 402760 35852 ? S 11:47 0:00 php-fpm: pool www3
nobody 24182 0.0 0.4 401464 37040 ? S 11:47 0:00 php-fpm: pool www4
nobody 24183 0.0 0.5 404476 40268 ? S 11:47 0:00 php-fpm: pool www4
nobody 24184 0.0 0.9 409564 72888 ? S 11:47 0:01 php-fpm: pool www4
nobody 24185 0.0 0.5 404048 40504 ? S 11:47 0:00 php-fpm: pool www4
nobody 24186 0.0 0.5 403004 40296 ? S 11:47 0:00 php-fpm: pool www4`
Чтобы не гоняться за меняющимися идшниками процессов PHP, можно поставить им временно короткое время жизни:
`pm.max_children = 5
pm.start_servers = 5
pm.min_spare_servers = 5
pm.max_spare_servers = 5
**pm.max\_requests = 100**`
и запустить strace так:
strace -p 24166 -f -s 128 -tt -o trace.log
Т.е. мы вешаем его на рутовый процесс и при появлении новых потомков он автоматически начнет их трейсить тоже. Просто.
Теперь желательно в лог файлы PHP начать писать PID процесса, чтобы можно было быстро сопоставить долгий хит из лога с конкретным процессом трейса:
`access.log = /opt/php/var/log/www.access.log
access.format = "%R # %{HTTP_HOST}e # %{HTTP_USER_AGENT}e # %t # %m # %r # %Q%q # %s # %f # %{mili}d # %{kilo}M # %{user}C+%{system}C # **%p**"`
Теперь остается ждать, когда появится жертва, например долгий хит:
`[24-May-2012 11:43:49] WARNING: [pool www1] child 22722, script '/var/www/html/myfile.php' (request: "POST /var/www/html/myfile.php") executing too slow (38.064443 sec), logging
- # mysite.ru # Mozilla/5.0 (Windows NT 6.1; WOW64; rv:12.0) Gecko/20100101 Firefox/12.0 # 24/May/2012:11:43:11 +0400 # POST # /var/www/html/myfile.php # # 200 # /var/www/html/myfile.php # **61131.784** # 6656 # 0.03+0.03 # **22722**`
#### Трактуем системные вызовы
Первое — системные вызовы это низкоуровневые «элементарные» операции, которыми программа общается с операционной системой — на них зиждется все IT-мироздание с разными языками программирования и технологиями и их не очень много (аналогично небольшому числу команд процессора и бесчисленному количеству языков и диалектов выше по стеку). Второе, что нужно понять — команды PHP веб-проекта выполняются строго друг за другом в рамках ОДНОГО ПРОЦЕССА. Поэтому в трейсе нужно отфильтровать процесс подозрительного хита — 22722:
cat trace.log | grep '22722' | less
Время хита известно из лога, осталось посмотреть что творилось при построении страницы и почему висело так долго (трейс немного отредактирован).
Видны запросы к БД и ответы:
`24167 12:47:50.252654 write(6, "u\0\0\0\3select name, name, password ...", 121) = 121
24167 12:47:50.252915 read(6, "pupkin, 123456"..., 16384) = 458`
Обращения к файлам:
`24167 12:47:50.255299 open("/var/www/html/myfile.php", O_RDONLY) = 7`
Взаимодействие с memcached:
`24167 12:47:50.262654 sendto(9, "add mykey 0 55 1\r\n1\r\n", 65, MSG_DONTWAIT, NULL, 0) = 65
24167 12:47:50.263151 recvfrom(9, "STORED\r\n", 8192, MSG_DONTWAIT, NULL, NULL) = 8
...
24167 12:47:50.282681 sendto(9, "delete mykey 0\r\n", 60, MSG_DONTWAIT, NULL, 0) = 60
24167 12:47:50.283998 recvfrom(9, "DELETED\r\n", 8192, MSG_DONTWAIT, NULL, NULL) = 9`
И вот видим, например, почему хит завис:
`22722 11:43:11.487757 sendto(10, "delete mykey 0\r\n", 55, MSG_DONTWAIT, NULL, 0) = 55
22722 11:43:11.487899 poll([{fd=10, events=POLLIN|POLLERR|POLLHUP}], 1, 1000) = 1 ([{fd=10, revents=POLLIN}])
22722 11:43:11.488420 recvfrom(10, "DELETED\r\n", 8192, MSG_DONTWAIT, NULL, NULL) = 9
22722 11:43:11.488569 sendto(10, "delete mykey2 0\r\n", 60, MSG_DONTWAIT, NULL, 0) = 60
22722 11:43:11.488714 poll([{fd=10, events=POLLIN|POLLERR|POLLHUP}], 1, 1000) = 1 ([{fd=10, revents=POLLIN}])
22722 11:43:11.489215 recvfrom(10, "DELETED\r\n", 8192, MSG_DONTWAIT, NULL, NULL) = 9
22722 11:43:11.489351 close(10) = 0
22722 11:43:11.489552 gettimeofday({1337845391, 489591}, NULL) = 0
22722 11:43:11.489695 gettimeofday({1337845391, 489727}, NULL) = 0
22722 11:43:11.489855 nanosleep({0, 100000}, NULL) = 0
22722 11:43:11.490155 nanosleep({0, 200000}, NULL) = 0
22722 11:43:11.490540 nanosleep({0, 400000}, NULL) = 0
22722 11:43:11.491121 nanosleep({0, 800000}, NULL) = 0
22722 11:43:11.492103 nanosleep({0, 1600000}, NULL) = 0
22722 11:43:11.493887 nanosleep({0, 3200000}, NULL) = 0
22722 11:43:11.497269 nanosleep({0, 6400000}, NULL) = 0
22722 11:43:11.503852 nanosleep({0, 12800000}, NULL) = 0
22722 11:43:11.516836 nanosleep({0, 25600000}, NULL) = 0
22722 11:43:11.542620 nanosleep({0, 51200000}, NULL) = 0
22722 11:43:11.594019 nanosleep({0, 102400000}, NULL) = 0
22722 11:43:11.696619 nanosleep({0, 204800000}, NULL) = 0
22722 11:43:11.901622 nanosleep({0, 409600000}, NULL) = 0
22722 11:43:12.311430 nanosleep({0, 819200000},
22722 11:43:13.130867 <... nanosleep resumed> NULL) = 0
22722 11:43:13.131025 nanosleep({1, 638400000},
22722 11:43:14.769688 <... nanosleep resumed> NULL) = 0
22722 11:43:14.770104 nanosleep({1, 638400000},
22722 11:43:16.408860 <... nanosleep resumed> NULL) = 0
22722 11:43:16.409048 nanosleep({1, 638400000},
22722 11:43:18.047808 <... nanosleep resumed> NULL) = 0
22722 11:43:18.048103 nanosleep({1, 638400000},
22722 11:43:19.686947 <... nanosleep resumed> NULL) = 0
22722 11:43:19.687085 nanosleep({1, 638400000},
22724 11:43:20.227224 <... lstat resumed> 0x7fff00adb080) = -1 ENOENT (No such file or directory)
22722 11:43:21.325824 <... nanosleep resumed> NULL) = 0
22722 11:43:21.326219 nanosleep({1, 638400000},
22722 11:43:22.964830 <... nanosleep resumed> NULL) = 0
22722 11:43:22.965126 nanosleep({1, 638400000},
22722 11:43:24.603692 <... nanosleep resumed> NULL) = 0
22722 11:43:24.604117 nanosleep({1, 638400000},
22722 11:43:26.250371 <... nanosleep resumed> NULL) = 0
22722 11:43:26.250580 nanosleep({1, 638400000},
22722 11:43:27.889372 <... nanosleep resumed> NULL) = 0
22722 11:43:27.889614 nanosleep({1, 638400000},
22722 11:43:29.534127 <... nanosleep resumed> NULL) = 0
22722 11:43:29.534313 nanosleep({1, 638400000},
22722 11:43:31.173004 <... nanosleep resumed> NULL) = 0
22722 11:43:31.173273 nanosleep({1, 638400000},
22722 11:43:32.812113 <... nanosleep resumed> NULL) = 0
22722 11:43:32.812531 nanosleep({1, 638400000},
22722 11:43:34.451236 <... nanosleep resumed> NULL) = 0
22722 11:43:34.451554 nanosleep({1, 638400000},
22722 11:43:36.090229 <... nanosleep resumed> NULL) = 0
22722 11:43:36.090317 nanosleep({1, 638400000},
22724 11:43:36.522722 fstat(12,
22723 11:43:36.622833 <... gettimeofday resumed> {1337845416, 622722}, NULL) = 0
22722 11:43:37.729696 <... nanosleep resumed> NULL) = 0
22722 11:43:37.730033 nanosleep({1, 638400000},
22724 11:43:39.322722 gettimeofday(
22722 11:43:39.368671 <... nanosleep resumed> NULL) = 0
22722 11:43:39.368930 nanosleep({1, 638400000},
22722 11:43:41.007574 <... nanosleep resumed> NULL) = 0
22722 11:43:41.007998 nanosleep({1, 638400000},
22722 11:43:42.646895 <... nanosleep resumed> NULL) = 0
22722 11:43:42.647140 nanosleep({1, 638400000},
22720 11:43:43.022722 fstat(12,
22720 11:43:43.622722 munmap(0x7fa1e736a000, 646) = 0
22722 11:43:44.285702 <... nanosleep resumed> NULL) = 0
22722 11:43:44.285973 nanosleep({1, 638400000},
22722 11:43:45.926593 <... nanosleep resumed> NULL) = 0
22722 11:43:45.926793 nanosleep({1, 638400000},
22722 11:43:47.566124 <... nanosleep resumed> NULL) = 0
22722 11:43:47.566344 nanosleep({1, 638400000},
22722 11:43:49.205103 <... nanosleep resumed> NULL) = 0
22722 11:43:49.205311 nanosleep({1, 638400000},
22719 11:43:49.440580 ptrace(PTRACE\_ATTACH, 22722, 0, 0`
Сначала шли обращения к memcached: запись/чтение сокета 10, затем сокет был успешно закрыт («close»=0), затем в коде был вызов usleep в цикле и условие выхода из цикла не срабатывало по причине предварительно закрытого сокета. В результате причину удалось определить — быстро и поправить код.
Не стоит смущаться системных вызовов unix, они просты и прямолинейны. Многие объекты в системе представляются в виде файлов и сокетов. По любому вызову можно быстро получить встроенную информацию:
man 2 open
man 2 sendto
man 2 nanosleep
Если у вас нет этих мануалов, их можно поставить так (на CentOS6):
yum install man-pages
Посмотреть последнюю документацию по системным вызовам можно также в [вебе](http://man7.org/linux/man-pages/dir_section_2.html) или из консоли: «man syscalls».
Потратив немного времени на понимание как работает PHP на уровне операционной системы, вы получите в руки секретное оружие, позволяющее быстро найти и устранить практически любое узкое место высоконагруженного веб-проекта!
#### Итого
1. Мы повторили основные методы и инструменты отладки веб-приложений на PHP любой степени сложности.
2. Рассмотрели варианты организации простого и эффективного бизнес-процесса поиска проблем на боевых серверах.
3. Научились отлавливать «сложные» случаи и узкие места, используя xhprof и strace на «боевых» серверах.
4. Попробовали на вкус системные вызовы linux и научились их трактовать.
Всем удачи, стабильных веб-проектов, надежного хостинга и спокойного безмятежного отпуска! И, конечно, приглашаю всех на наш новый облачный проект, развернутый в амазоне — [«Битрикс24»](http://www.bitrix24.ru/)! | https://habr.com/ru/post/144482/ | null | ru | null |
# Создание stateful навыка для Алисы на serverless функциях Яндекс.Облака и Питоне
Начнём с новостей. Вчера Яндекс.Облако анонсировало запуск сервиса бессерверных вычислений [Yandex Cloud Functions](https://cloud.yandex.ru/services/functions). Это значит: ты пишешь только код своего сервиса (например, веб-приложения или чатбота), а Облако само создаёт и обслуживает виртуальные машины, где он запускается, и даже реплицирует их, если возрастает нагрузка. Думать вообще не надо, очень удобно. И плата идёт только за время вычислений.
Впрочем, кое-кто может вообще не платить. Это — разработчики [внешних навыков Алисы](https://yandex.ru/dev/dialogs/alice/doc/about-docpage/), то есть встроенных в неё чатботов. Написать, захостить и зарегистрировать такой навык может любой разработчик, а с сегодняшнего дня навыки даже не надо хостить — достаточно залить их код в облако в виде [той самой бессерверной функции](https://yandex.ru/blog/dialogs/navyki-alisy-teper-mozhno-razmeschat-v-yandeks-oblake-besplatno-i-prosto).
Но есть пара нюансов. Во-первых, ваш питонячий код может требовать каких-то зависимостей, и затаскивать их в Облако — нетривиально. Во-вторых, любому нормальному чатботу нужно хранить где-то состояние диалога (stateful поэтому); как сделать это в бессерверной функции проще всего? В третьих, а как вообще можно быстро-грязно написать навык для Алисы или вообще какого-то бота с ненулевым сюжетом? Об этих нюансах, собственно, статья.
### Моральная подготовка
Для нетерпеливых: необходимые зависимости я собираю make-файлом перед загрузкой функции в облако, состояние диалога храню в яндексовском Object Storage (оно поддерживает API S3), а для управления диалогом использую собственную библиотеку [tgalice](https://github.com/avidale/tgalice). В итоге получается [такой](https://github.com/avidale/tgalice-yc-serverless-example) демо-навык. А теперь разберём всё это чуть детальнее.
Для чуть менее нетерпеливых: прежде чем погружаться в мою историю про сложности, я очень рекомендую начать с простого. А именно, создать однофайловую функцию-эхобота, зарегистрировать и потестить её в консоли разработчика Диалогов; подробности — в [блоге Диалогов](https://yandex.ru/blog/dialogs/navyki-alisy-teper-mozhno-razmeschat-v-yandeks-oblake-besplatno-i-prosto) и [документации Облака](https://cloud.yandex.ru/docs/functions/solutions/alice-skill). И только потом уже приступать.
Если хочется сразу ощутить, за что мы тут боремся, попросите Алису '[включи навык "айтишный гороскоп"](https://dialogs.yandex.ru/store/skills/bfdd6cd4-ajtishnyj-gorosko)'. Должен произойти примерно следующий диалог:
Алиса: Привет! Вы находитесь в навыке "Айтишный гороскоп". Скажите "Старт", чтобы узнать, что сулят вам звёзды.
Юзер: Старт
А: Пожалуйста, назовите своё имя
Ю: Васисуалий
А: Теперь скажите мне год вашего рождения. Только четыре цифры, ничего лишнего.
Ю: второй
А: Пожалуйста, попробуйте ещё раз. Назовите год вашего рождения — четыре цифры.
Ю: 2002
А: Замечательно! Теперь назовите месяц вашего рождения.
Ю: Феврарь
А: Отлично! Наконец, назовите мне дату вашего рождения — только число, всего одна или две цифры.
Ю: 18
А: Спасибо, Васисуалий! Теперь мы знаем: вам 17 лет, и вы Водолей. Вот это вам, конечно, повезло! Звёзды говорят вам: `а что говорят звёзды, вы узнаете, запустив навык.`
Проблема в том, что для поддержания даже такого простого диалога нужно помнить имя и дату рождения пользователя, а в среде бессерверных функций это нетривиально. Хранить контекст в оперативной памяти или файликом на диске не получится, т.к. Яндекс.Облако может запустить функцию на нескольких виртуальных машинах одновременно и переключаться между ними произвольным образом. Придётся воспользоваться каким-то внешним хранилищем. Выбрано было Object Storage, как довольно недорогое и несложное хранилище прямо в Яндекс.Облаке (т.е. наверное быстрое). В качестве бесплатной альтернативы можно попробовать, например, халявный кусочек [облачной Монги](https://cloud.mongodb.com) где-то далеко. И для Object Storage (он поддерживает интерфейс S3), и для Mongo существуют удобные питоновские обёртки.
Другая проблема — что для хождения и в Object Storage, и в MongoDB, и в любую другую базу или хранилище данных, нужны какие-то внешние зависимости, которые нужно залить на Yandex Functions вместе с кодом своей функции. И хотелось бы делать это удобно. Совсем удобно (типа как на heroku), увы, не получится, но какой-то базовый комфорт можно создать, написав скрипт для сборки окружения (make-файл).
### Как запустить навык-гороскоп
1. Подготовиться: зайти на какую-нибудь машинку с линуксом. В принципе, с Windows тоже, наверное, можно работать, но с запуском make-файла тогда придётся поколдовать. И в любом случае, вам понадобится установленный Python не ниже 3.6.
2. Склонировать себе с гитхаба [пример гороскопного навыка](https://github.com/avidale/tgalice-yc-serverless-example).
3. Зарегистрироваться в Я.Облаке: <https://cloud.yandex.ru>
4. Создать себе два бакета в [Object Storage](https://cloud.yandex.ru/docs/storage/), назвать их любым именем `{BUCKET NAME}` и `tgalice-test-cold-storage` (вот это второе имя сейчас захардкожено в `main.py` моего примера). Первый бакет нужен будет только для деплоя, второй — для хранения состояний диалога.
5. Создать [сервисный аккаунт](https://cloud.yandex.ru/docs/iam/concepts/users/service-accounts), дать ему роль `editor`, и получить к нему статические креденшалы `{KEY ID}` и `{KEY VALUE}` — их будем использовать для записи состояния диалога. Всё это нужно, чтобы функция из Я.Облака могла получить доступ к хранилищу из Я.Облака. Когда-нибудь, надеюсь, авторизация станет автоматической, но пока — так.
6. (Не обязательно) установить [интерфейс командной строки](https://cloud.yandex.ru/docs/cli/quickstart) `yc`. Создать функцию можно и через веб-интерфейс, но CLI хорош тем, что всякие нововведения появляются в нём быстрее.
7. Теперь можно, собственно, подготовить сборку зависимостей: запустить в командной строке из папки с примером навыка `make all`. Установится куча библиотек (в основном, как обычно, ненужных) в папку `dist`.
8. Ручками залить в Object Storage (в бакет `{BUCKET NAME}`) получившийся на предыдущем шаге архив `dist.zip`. При желании, можно сделать это и из командной строки, например, используя [AWS CLI](https://cloud.yandex.ru/docs/storage/instruments/aws-cli).
9. Создать бессерверную функцию через веб-интерфейс или используя утилиту `yc`. Для утилиты команда будет выглядеть вот так:
```
yc serverless function version create\
--function-name=horoscope\
--environment=AWS_ACCESS_KEY_ID={KEY ID},AWS_SECRET_ACCESS_KEY={KEY VALUE}\
--runtime=python37\
--package-bucket-name={BUCKET NAME}\
--package-object-name=dist.zip\
--entrypoint=main.alice_handler\
--memory=128M\
--execution-timeout=3s
```
При ручном создании функции все параметры заполняются аналогично.
Теперь созданную вами функцию можно тестировать через консоль разработчика, а потом дорабатывать и публиковать навык.
### Что там под капотом
Make-файл на самом деле содержит в себе довольно простой скрипт для установки зависимостей и их укладки в архив `dist.zip`, приблизительно такой:
```
mkdir -p dist/
pip3 install -r requirements.txt --target dist/
cp main.py dist/main.py
cp form.yaml dist/form.yaml
cd dist && zip --exclude '*.pyc' -r ../dist.zip ./*
```
Остальное — несколько простых инструментов, завёрнутых в библиотеку `tgalice`. Процесс заполнения данных о юзере описывается конфигом `form.yaml`:
```
form_name: 'horoscope_form'
start:
regexp: 'старт|нач(ать|ни)'
suggests:
- Старт
fields:
- name: 'name'
question: Пожалуйста, назовите своё имя.
- name: 'year'
question: Теперь скажите мне год вашего рождения. Только четыре цифры, ничего лишнего.
validate_regexp: '^[0-9]{4}$'
validate_message: Пожалуйста, попробуйте ещё раз. Назовите год вашего рождения - четыре цифры.
- name: 'month'
question: Замечательно! Теперь назовите месяц вашего рождения.
options:
- январь
...
- декабрь
validate_message: То, что вы назвали, не похоже на месяц. Пожалуйста, назовите месяц вашего рождения, без других слов.
- name: 'day'
question: Отлично! Наконец, назовите мне дату вашего рождения - только число, всего одна или две цифры.
validate_regexp: '[0123]?\d$'
validate_message: Пожалуйста, попробуйте ещё раз. Вам нужно назвать число своего рождения (например, двадцатое); это одна или две цифры.
```
Работу по разбору этого конфига и вычислению финального результата берёт на себя питонячий класс
```
class CheckableFormFiller(tgalice.dialog_manager.form_filling.FormFillingDialogManager):
SIGNS = {
'январь': 'Козерог',
...
}
def handle_completed_form(self, form, user_object, ctx):
response = tgalice.dialog_manager.base.Response(
text='Спасибо, {}! Теперь мы знаем: вам {} лет, и вы {}. \n'
'Вот это вам, конечно, повезло! Звёзды говорят вам: {}'.format(
form['fields']['name'],
2019 - int(form['fields']['year']),
self.SIGNS[form['fields']['month']],
random.choice(FORECASTS),
),
user_object=user_object,
)
return response
```
Точнее, базовый класс `FormFillingDialogManager` занимается заполнением "формы", а метод дочернего класса `handle_completed_form` говорит, что делать, когда она готова.
Кроме этого основного потока диалога пользователя надо ещё попривествовать, а также выдать справку по команде "помощь" и выпустить из навыка по команде "выход". Для этого в `tgalice` также есть шаблон, поэтому целиковый диалоговый менеджер составлен из кусочков:
```
dm = tgalice.dialog_manager.CascadeDialogManager(
tgalice.dialog_manager.GreetAndHelpDialogManager(
greeting_message=DEFAULT_MESSAGE,
help_message=DEFAULT_MESSAGE,
exit_message='До свидания, приходите в навык "Айтишный гороскоп" ещё!'
),
CheckableFormFiller(`form.yaml`, default_message=DEFAULT_MESSAGE)
)
```
`CascadeDialogManager` работает просто: пробует применить к текущему состоянию диалога все свои составляющие по очереди, и выбирает первую уместную.
В качестве ответа на каждое сообщение диалоговый менеджер возвращает питонячий объект `Response`, который дальше можно сконвертировать в голый текст, или в сообщение в Алисе или Телеграме — смотря где бот запущен; в нём же содержится и изменённое состояние диалога, которое нужно сохранить. Всей этой кухней занимается ещё один класс, `DialogConnector`, поэтому непосредственный скрипт для запуска навыка на Yandex Functions выглядит так:
```
...
session = boto3.session.Session()
s3 = session.client(
service_name='s3',
endpoint_url='https://storage.yandexcloud.net',
aws_access_key_id=os.environ['AWS_ACCESS_KEY_ID'],
aws_secret_access_key=os.environ['AWS_SECRET_ACCESS_KEY'],
region_name='ru-central1',
)
storage = tgalice.session_storage.S3BasedStorage(s3_client=s3, bucket_name='tgalice-test-cold-storage')
connector = tgalice.dialog_connector.DialogConnector(dialog_manager=dm, storage=storage)
alice_handler = connector.serverless_alice_handler
```
Как видите, большая часть этого кода создаёт подключение к S3-интерфейсу Object Storage. Как непосредственно используется это подключение, можно почитать [в коде tgalice](https://github.com/avidale/tgalice/blob/1e6e37fa86a9a4a904d3e209ab59b59899df3c05/tgalice/storage/session_storage.py#L80).
Последняя строчка создаёт функцию `alice_handler` — ту самую, которую мы велели дёргать Яндекс.Облаку, когда задавали параметр `--entrypoint=main.alice_handler`.
Вот, собственно, и всё. Make-файлы для сборки, S3-подобное Object Storage для хранения контекста, и питонячья библиотека `tgalice`. Вкупе с бессерверными функциями и выразительностью питона этого достаточно для разработки навыка здорового человека.
Вы можете спросить, зачем нужна понадобилось создавать `tgalice`? Весь скучный код, перекладывающий JSON'ы из запроса в ответ и из хранилища в память и обратно, лежит в ней. Там же лежит применялка регулярок, функция для понимания того, что "феврарь" похоже на "февраль", и прочее NLU для бедных. По моей задумке, этого уже должно быть достаточно, чтобы можно было набрасывать прототипы навыков в yaml-файлах, не слишком отвлекаясь на технические детали.
Если хочется более серьёзного NLU, можно прикрутить к своему навыку [Rasa](https://rasa.com/) или [DeepPavlov](http://docs.deeppavlov.ai/en/master/), но для их настройки потребуются дополнительные пляски с бубном, особенно на serverless. Если совсем не хочется кодить, стоит воспользоваться визуальным конструктором типа [Aimylogic](https://aimylogic.com/). Создавая tgalice, я думал о каком-то промежуточном пути. Посмотрим, что из этого получится.
Ну а нынче вступайте в [чат разработчиков алисьих навыков](https://t.me/yadialogschat), читайте [документацию](https://yandex.ru/dev/dialogs/alice/doc), и создавайте замечательные [навыки](https://dialogs.yandex.ru/store)! | https://habr.com/ru/post/469723/ | null | ru | null |
# Ahead-of-Time компиляция и Blazor
В .NET 6 запланирована поддержка AOT компиляции для Blazor WebAssembly приложений. Давайте попробуем запустить в Preview 2 версии.
Анонса и инструкций пока что нету. Поэтому и решено написать этот пост.
Краткая справка
---------------
Немного восстановим в памяти.
Blazor - Single Page Application веб-фреймворк от Майкрософт. Отличительная особенность: за динамику отвечает C#, а не привычный нам JavaScript.
Существует две версии:
**Blazor Server**. Код запускается на сервере, страница рендерится на сервере. Через веб-сокеты передаем измененную часть страницы и с помощью JS обновляем html в браузере. Здесь нам AOT не интересен.
**Blazor WebAssembly.** В браузере на WebAssembly запускается порезанная версия Mono. А уже на Mono запускается наше .NET приложение. Рендеринг страницы и вся логика в браузере. Сервер нужен только чтобы отдать скомпилированную статику.
Пытливый читатель сразу предположит, что наверняка мы теряем в скорости из-за дополнительной прослойки WebAssembly-Mono-Наше приложение. И будет прав! Именно для этого нам и нужна Ahead-of-Time компиляция, которая позволяет из .NET приложения сразу скомпилировать версию для WebAssembly.
Инструкция по запуску
---------------------
Здесь нам важно использовать именно указанные версии. Потому что шаг влево, шаг вправо - не работает. И не всегда получается разобраться почему. Если вы читаете этот пост сильно позже марта 2021, то вероятно стоит поэкспериментировать с более свежими версиями.
Я все делал на Windows. В теории на других ОС тоже должно работать.
Устанавливаем [SDK 6.0.100-preview.2](https://dotnet.microsoft.com/download/dotnet/6.0). Просто скачать и запустить установщик.
Устанавливаем [Emscripten](https://emscripten.org/). Это как раз и есть компилятор в WebAssembly.
Шаги для установки:
```
git clone https://github.com/emscripten-core/emsdk.git
cd emsdk
emsdk install 2.0.12
emsdk activate 2.0.12
emsdk_env.bat
```
Теперь консоль можно закрыть и в Environment Variables надо добавить EMSDK\_PATH с путем до папки emsdk.
[Инструкция для установки на других ОС](https://emscripten.org/docs/getting_started/downloads.html#installation-instructions-using-the-emsdk-recommended). Версию 2.0.12 используем [по совету](https://gist.github.com/pranavkm/1ca9eca9605ebc89161cb33e02e74e85).
Ставим пакет [dotnet-install-blazoraot](https://www.nuget.org/packages/dotnet-install-blazoraot/6.0.0-preview.2.21154.6). Этот пакет как раз подружит dotnet и emscripten.
```
dotnet tool install -g dotnet-install-blazoraot --version 6.0.0-*
dotnet install-blazoraot
```
В одном из пакетов есть баг, он уже пофикшен в репозитории, но еще не выпущен. Так что пока что придется подправить локально.
В файле C:\Program Files\dotnet\packs\Microsoft.NET.Runtime.WebAssembly.Sdk\6.0.0-preview.2.21154.6\Sdk\WasmApp.targets меняем строчку 244 на:
С подготовкой мы закончили. Можем создать первое приложение:
```
mkdir myapp
cd myapp
dotnet new blazorwasm
```
И нам надо сконфигурировать RunAOTCompilation в csproj:
```
net6.0
true
```
AOT компиляция будет работать только во время публикации. Поэтому публикуем приложение:
```
dotnet publish
```
Первые впечатления
------------------
Компиляция занимает значительное время. Нечто простое всего несколько минут. А вот один далеко не самый большой проект у меня компилируется полчаса.
Скомпилированный dotnet.wasm файл даже для дефолтного приложения 15 мб. Я легко получал и 50 и 60 мб. Это ожидаемо.
Элементарные события, например, клики на кнопки срабатывают, но в консоль сыпят ошибками. Асинхронные обработчики не работают. Пока что не получилось разобраться почему. Присоединяйтесь :)
НО! Скорость действительно заметно быстрее.
Я сделал эксперимент с одной из вычислительных задач: поиск простого числа. С AOT выходит в 3 раза меньше времени!
Для желающих самостоятельно проверить есть два одинаковых приложения.
→ [Версия с AOT](https://aot-blazor.github.io/aot/)
→ [Версия без AOT](https://aot-blazor.github.io/noaot/)
Заключение
----------
Чуда не случилось. Придется оптимизировать имеющийся код :)
Вся эта история еще в самом начале пути. В ближайшие полгода, думаю, не стоит рассчитывать на легкий способ увеличить производительность своих приложений.
Но эксперимент очень интересный. Посмотрим, куда приведет и что получится. | https://habr.com/ru/post/548132/ | null | ru | null |
# Пишем PHP extension
А давайте сегодня взглянем на PHP немного с другой точки зрения, и напишем к нему расширение. Так как на эту тему уже были публикации на Хабре ([здесь](http://habrahabr.ru/blogs/php/98862/) и [здесь](http://habrahabr.ru/blogs/php/75388/)), то не будем углубляться в причины того, для чего это может оказаться полезным и для чего может быть использовано на практике. Эта статья расскажет, как собирать простые расширения под Windows с использованием Visual C++ и под Debian с использованием GCC. Также я постараюсь немного осветить работу с PHP-массивами внутри расширений и провести сравнение производительности алгоритма, написанного на native PHP и использующего код, написанный на C.
Компиляция под Win32
--------------------
Итак, начнем с Windows. [Как известно](https://wiki.php.net/internals/windows/stepbystepbuild), разработчики PHP используют Visual C++ 9 или Visual Studio 2008 для компиляции своего детища под Windows. Поэтому мы будем использовать Visual Studio 2008, бесплатная [Express](http://www.microsoft.com/express/download/) версия тоже подойдет, как впрочем, наверное, и более поздние и ранние версии студии.
Что нам потребуется:* Скомпилированные бинарники PHP 5.3, которые можно взять [здесь](http://windows.php.net/download),
* Исходники PHP 5.3, которые можно [скачать с сайта](http://php.net/downloads.php) или вытянуть из [общедоступного SVN](https://svn.php.net/repository/php/php-src/branches/PHP_5_3),
* Желание поэкспериментировать и немного терпения.
Для начала создадим проект типа Win32 Console Application и выберем DLL в Application type. Теперь нам придется настроить все зависимости и пути для линковщика:* Щелкните правой кнопкой мыши в Solution Explorer'e и выберите Properties > C/C++ > General > Additional Include Directories. Сюда мы добавим директории, в которых лежат распакованные исходники и заголовочные файлы PHP. Конкретно нужны будут:
```
php-5.3.6
php-5.3.6\main
php-5.3.6\TSRM
php-5.3.6\Zend
```
* Теперь добавим preprocessor definitions, которые нужны для корректного выбора платформы и компиляции модуля. Выбираем Configuration Properties > C/C++ > Preprocessor > Preprocessor Definitions, и добавляем туда следующее:
```
PHP_WIN32
ZEND_WIN32
ZTS=1
ZEND_DEBUG=0
```
* Затем укажем линковщику где можно найти необходимые библиотеки. Выбираем Configuration Properties > Linker > General > Additional Library Directories. Там выбираем директорию \div из бинарников PHP. Должно получиться что-то такое: «D:\Program Files\php-5.3.6-Win32-VC9-x86\dev».
* Теперь укажем конкретную либу для линковщика. Идем в Configuration Properties > Linker > Input > Additional Dependencies, и вписываем туда php5ts.lib, которая находится в той самой \dev директории, которую мы указали в предыдущем шаге.
* Для избегания некоторых проблем компиляции, добавим директиву /FORCE:MULTIPLE в Configuration Properties > Linker > Command Line. Подробнее о ней можно прочитать на сайте [MSDN](http://msdn.microsoft.com/en-us/library/70abkas3.aspx).
* И, наконец, можно указать, куда сохранять скомпилированную dll. Для этого перейдем в Configuration Properties > Linker > General > Output Filename и укажем там путь к папке \ext установленного PHP. Должно получиться что-нибудь такое: «D:\Program Files\php-5.3.6-Win32-VC9-x86\ext\$(ProjectName).dll».
Найдем в проекте файл stdafx.h и заменим его содержимое на следующее:
```
#ifndef STDAFX
#define STDAFX
#define PHP_COMPILER_ID "VC9" // эту опцию мы указываем для совместимости с PHP, скомпилированным Visual C++ 9.0
#include "zend_config.w32.h"
#include "php.h"
#endif
```
Если вы попытаетесь скомпилировать проект на данном этапе, вы получите ошибку, говорящую о том, что отсутствует main\config.w32.h. Его можно получить либо запустив скрипт main\configure.bat, либо можно выдернуть его из исходников, например версии PHP 5.2. При этом не забываем отредактировать в этом файле все пути и раскомментировать директиву "#define HAVE\_SOCKLEN\_T". Теперь проект должен скомпилироваться без ошибок.
Теперь давайте напишем hello world, добавим в наш cpp файл следующее:
```
PHP_FUNCTION(test);
const zend_function_entry test_functions[] = {
PHP_FE(test, NULL)
{NULL, NULL, NULL}
};
zend_module_entry test_module_entry = {
STANDARD_MODULE_HEADER, // #if ZEND_MODULE_API_NO >= 20010901
"test", // название модуля
test_functions, // указываем экспортируемые функции
NULL, // PHP_MINIT(test), Module Initialization
NULL, // PHP_MSHUTDOWN(test), Module Shutdown
NULL, // PHP_RINIT(test), Request Initialization
NULL, // PHP_RSHUTDOWN(test), Request Shutdown
NULL, // PHP_MINFO(test), Module Info (для phpinfo())
"0.1", // версия нашего модуля
STANDARD_MODULE_PROPERTIES
};
ZEND_GET_MODULE(test)
PHP_FUNCTION(test)
{
RETURN_STRING("hello habr", 1); // возвращаем PHP-строку, второй параметр указывает, нужно ли копировать строку в памяти или нет
}
```
Теперь подключим этот модуль в PHP и попробуем запустить что-нибудь такое:
```
php -r "test();"
```
На что мы должны получить ответ «hello habr».
Компиляция под \*nix
--------------------
В \*nix'ах все оказалось как всегда проще. Я покажу на примере Debian, думаю, что под другими системами процесс не будет отличаться.
Нам потребуется:* Иметь установленный PHP на машине,
* Иметь установленный PHP-dev. Для этого нужно выполнить всего одну команду:
```
apt-get install php5-dev
```
Давайте создадим где-нибудь директорию для нашего расширения. Ну например /test. Там создадим два пустых файла:
```
config.m4
test.c
```
Первый нужен для магической компиляции расширения, а во втором будет его исходный код. В config.m4 напишем следующее:
```
PHP_ARG_ENABLE(test, Enable test support)
if test "$PHP_TEST" = "yes"; then
AC_DEFINE(HAVE_TEST, 1, [You have test extension])
PHP_NEW_EXTENSION(test, test.c, $ext_shared)
fi
```
Внутри test.c добавьте
```
#include "php.h"
```
И после этой сроки скопируйте содержимое cpp-файла из Windows-версии.
Теперь идем в консоль и:
```
# phpize // команда сгенерирует необходимые файлы для следующего шага
# ./configure // сгенерируется makefile
# make // компилируем
# make install // устанавливаем .so в директорию с PHP расширениями
```
На этом все. Теперь можно открыть php.ini, добавить там свое расширение:
```
extension=test.so
```
И проверить его работоспособность командой
```
php -r "test();"
```
Обработка аргументов и возвращаемые значения
--------------------------------------------
Для начала посмотрим, как можно принимать аргументы:
```
char* text;
int text_length;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &text, &text_lenght) == FAILURE) {
return;
}
```
Третий параметр указывает ожидаемый тип ([здесь](http://devzone.zend.com/article/1022#Heading2) можно просмотреть все варианты), в данном случае это char\* или int. Также по ссылке можно найти варианты комбинирования типов и указания количества аргументов. Все следующие параметры являются переменными, в которые будут записаны переданные значения. При передаче строки передается сама строка и ее длина.
Если количество аргументов, переданных в вашу функцию, не совпадает, будет выброшен E\_WARNING, при этом вы можете возвратить какое-либо значение, например, сообщение об ошибке.
Возвращать можно как простые типы, так и сложные. Давайте познакомимся с формированием возвращаемого массива. Для указания того, что будет возвращен массив, его нужно проинициализировать:
```
array_init(result);
```
Для добавления значений в массив необходимо использовать функции, зависящие от того, какой индекс и значение добавляется в массив. Например:
```
add_next_index_long(result, 42); // $result[] = 42;
add_assoc_bool(result, "foo", 1); // $result['foo'] = true;
add_next_index_null(result); // $result[] = NULL;
```
Полный список функций можно найти [здесь](http://devzone.zend.com/article/1022#Heading5)
Если кого-то заинтересует, я могу в следующей статье рассмотреть пример работы с объектами (классический пример расширения на объектах — mysqli). [Тут](http://devzone.zend.com/article/4486-Wrapping-C-Classes-in-a-PHP-Extension) есть очень хорошая статья на эту тему.
Производительность
------------------
Для проверки производительности я выбрал несколько синтетический пример: подсчет вхождения каждого символа в строку. Другими словами, мы должны получить функцию, которая принимает строку в качестве параметра, и отдает массив, в котором указано количество употреблений каждого символа в данной строке. Этот пример продемонстрирует работу с большими строками.
У меня получилась такая реализация, сильно не пинайте за код, я все-таки больше пишу на PHP, чем на C:
```
PHP_FUNCTION(calculate_chars) {
char* text;
int text_length;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &text, &text_length) == FAILURE) {
return;
}
array_init(return_array);
int table[256] = { 0 };
for (int i = 0; i < text_length; i++) {
table[((unsigned char*)text)[i]]++;
}
char str[2];
str[1] = '\0';
for (int i = 0; i < 256; i++) {
if (table[i]) {
str[0] = (char)i;
add_assoc_long(return_array, str, table[i]);
}
}
}
```
Этот код выдает следующий результат:
```
user> php -r "print_r( calculate_chars('example') );"
Array
(
[a] => 1
[e] => 2
[l] => 1
[m] => 1
[p] => 1
[x] => 1
}
```
А теперь давайте сравним скорость выполнения этого кода и аналогичного на native PHP:
```
$map = array();
for ($i = 0; $i < $length; $i++) {
$char = $text[$i];
if (isset($map[$char])) {
$map[$char]++;
} else {
$map[$char] = 1;
}
}
```
Сравнивать я буду время выполнения обоих решений с помощью функции [microtime](http://php.net/manual/en/function.microtime.php). Возьмем строку в 100 символов, строку в 5000 символов, и строку в 69000 символов (я взял книгу A Message from the Sea, написанную Чарльзом Диккенсом, надеюсь, что он мне это простит), и для каждого варианта прогоним оба решения по несколько тысяч раз. Результаты приведены в таблице ниже. Тестирование проводилось на моем не самом сильном домашнем ноутбуке и VDS с Debian на борту, и да, я отчетливо понимаю, что результаты могут зависеть от конфигурации, от версии операционной системы, PHP, атмосферного давления и направления ветра, но я хотел показать лишь примерные цифры.
Полный код тестового скрипта можно скачать [здесь](http://dmitriy-tarasov.ru/shared/blogs/php_module/tests.zip). Исходники и бинарники самих расширений можно скачать [здесь (win)](http://dmitriy-tarasov.ru/shared/blogs/php_module/win32.zip) и [здесь (nix)](http://dmitriy-tarasov.ru/shared/blogs/php_module/nix.tgz).
| | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| | Кол-во итераций | PHP code / Win32 | PHP code / Debian | PHP extension / Win32 | PHP extension / Debian | Win32 выигрыш | Debian выигрыш |
| 1. Строка 100 символов | 1000000 | 84.7566 сек | 72.5617 сек | 8.4750 сек | 4.4175 сек | в 10 раз | в 16.43 раз |
| 2. Строка 5000 символов | 10000 | 39.1012 сек | 31.7541 сек | 0.5001 сек | 0.134 сек | в 78.19 раз | в 236.98 раз |
| 3. Строка 69000 символов | 1000 | 52.3378 сек | 44.0647 сек | 0.4875 сек | 0.0763 сек | в 107.36 раз | в 577.51 раз |
Выводы
------
Если судить о производительности модуля по сравнению с интерпретируемым кодом, то мы видим, что ощутимые результаты можно получить на больших объемах данных и на малых количествах итераций. То есть, для часто использующихся, однако, не очень ресурсоемких алгоритмов не имеет смысла вынесение их в компилируемый код. Но для алгоритмов, работающих с большими объемами данных, это может иметь практический смысл. Также, опираясь на мои измерения, можно заметить, что результаты работы PHP-кода сравнимы на разных системах (напомню, что это были две разные машины), а вот результаты работы расширения очень сильно отличаются. Из этого лично я делаю вывод, что существуют какие-то особенности компиляции, которые мне не известны. Впрочем, я сильно сомневаюсь, что кто-то использует Windows-сервера для PHP-проектов. Хотя я также очень сомневаюсь, что кто-то прямо сейчас побежит переписывать что-то на С, эта статья все-таки больше just for fun, чем руководство к действию. Просто я хотел показать, что написать PHP extension очень просто, и иногда может быть очень полезно.
**UPD1. Сравнение с count\_chars**
В комментах задали интересный вопрос: что если сравнить с производительностью функции count\_chars?
Я увеличил количество итераций в сто раз, и прогнал тот же самый тест, но уже с использованием этой функции. Можно увидеть, что на Debian результаты почти сравнялись, а под Windows наблюдается интересная ситуация: чем больше объем данных, тем больше мой модуль сливает в производительности. Напомню, что идея теста была не в том, чтобы написать велосипед, а в том, чтобы взять алгоритм для работы с большими объемами данных.
| | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| | Кол-во итераций | count\_chars / Win32 | count\_chars / Debian | extension / Win32 | extension / Debian | Win32 выигрыш | Debian выигрыш |
| 1. Строка 100 символов | 10000000 | 67.5245 сек | 47.8104 сек | 81.8185 сек | 43.8091 сек | в 0.83 раз | в 1.09 раз |
| 2. Строка 5000 символов | 1000000 | 22.4693 сек | 12.8959 сек | 47.2514 сек | 12.9577 сек | в 0.48 раз | в 0.99 раз |
| 3. Строка 69000 символов | 100000 | 15.0681 сек | 7.661 сек | 46.9598 сек | 7.7387 сек | в 0.32 раз | в 0.99 раз |
Материалы
---------
* PHP at the Core: A Hacker's Guide to the Zend Engine, [php.net](http://www.php.net/manual/en/internals2.structure.php)
* Compiling shared PECL extensions with phpize, [php.net](http://php.net/manual/en/install.pecl.phpize.php)
* Creating a PHP Extension for Windows using Microsoft Visual C++ 2008, [talkphp.com](http://www.talkphp.com/vbarticles.php?do=article&articleid=49)
* Extension Writing Part I: Introduction to PHP and Zend, [devzone.zend.com](http://devzone.zend.com/article/1021)
* Extension Writing Part II: Parameters, Arrays, and ZVALs, [devzone.zend.com](http://devzone.zend.com/article/1022)
* Wrapping C++ Classes in a PHP Extension, [devzone.zend.com](http://devzone.zend.com/article/4486-Wrapping-C-Classes-in-a-PHP-Extension) | https://habr.com/ru/post/125597/ | null | ru | null |
# Отладка Grunt-задания в WebStorm
*Вообще-то у меня PhpStorm, но, думаю, все будет работать и в WebStorm.*
Запускаем в командной строке
```
cd
node --debug-brk=64005 $(which grunt) img2base64
```
*Где **img2base64** — название нужного задания. Можно опустить этот параметр, чтобы запустились все задания.*
Получаем **debugger listening on port 64005**
Далее в **WebStorm**: Run → Edit configurations… → + → Node JS Remote Debug. Задаем название конфигурации (например, grunt), Host: 127.0.0.1, Debug port: 64005 (*порт можно задавать любой от 1025 до 65535, главное везде один и тот же*). Нажимаем OK.
Задаем точку останова (breakpoint) и нажимаем кнопку **Debug**.
Профит!
Вот как выглядит окно при отладке
###### Полезные ссылки
Отладка в WebStorm (в любой IDE от JetBrains) — <http://www.jetbrains.com/webstorm/webhelp/running-and-debugging-node-js.html>
Отладка в браузере (Google Chrome или другой на WebKit) — <https://github.com/dannycoates/node-inspector> | https://habr.com/ru/post/170441/ | null | ru | null |
# Распаковка Huawei TaiShan 2280v2
Серверы с процессорами на архитектуре arm64 старательно входят в нашу жизнь. В этой статье мы покажем распаковку, установку и небольшой тест нового сервера TaiShan 2280v2.
Распаковка
----------
Сервер прибыл к нам в ничем не примечательной коробке. На боках коробки нанесен логотип Huawei, а также знаки тары и упаковки. Сверху можно видеть инструкцию по правильному извлечению сервера из коробки. Приступим к распаковке!
Сервер обернут в слой антистатического материала и уложен между слоями пенопласта. В общем, стандартная упаковка для сервера.
В маленькой коробочке можно найти салазки, два болта и два кабеля питания Schuko-C13. Салазки выглядят достаточно простыми, но о них мы поговорим позднее.
Сверху на сервере нанесена информация о данном сервере, а также доступы к BMC-модулю и в BIOS. Серийный номер представлен одномерным штрих-кодом, а QR-код содержит ссылку на сайт технической поддержки.
Снимем крышку сервера и заглянем внутрь.
Что внутри?
-----------
Крышку сервера удерживает специальная защелка, которую можно зафиксировать в закрытом состоянии крестовой отверткой. Открытие защелки приводит к сдвигу крышки сервера, после чего крышка снимается без особых проблем.
Сервер поставляется в готовой конфигурации под названием **TaiShan 2280 V2 512G Standard Configuration** в следующей комплектации:
* 2x Kunpeng 920 (архитектура ARM64, 64 ядра, базовая частота 2.6 ГГц);
* 16x DDR4-2933 32GB (суммарно 512 ГБ);
* 12x SAS HDD 1200GB;
* аппаратный RAID-контроллер Avago 3508 с источником резервного питания на базе ионистора;
* 2x сетевая карта с четырьмя 1GE портами;
* 2x сетевая карта с четырьмя 10GE/25GE SFP+ портами;
* 2x блок питания 2000 ватт;
* корпус Rackmount 2U.
> Материнская плата сервера реализует стандарт PCI Express 4.0, что позволяет использовать всю мощь 4x 25GE сетевых карт.
В присланной нам конфигурации сервера пустуют 16 слотов оперативной памяти. Физически процессор Kunpeng 920 поддерживает до 2 ТБ оперативной памяти, что позволяет установить 32 планки памяти по 128 ГБ каждая, расширив общий объем оперативной памяти до 4 ТБ в одной аппаратной платформе.
На процессорах стоят съемные радиаторы без собственных вентиляторов. Вопреки ожиданиям процессоры распаяны на материнскую плату (BGA) и в случае выхода из строя могут быть заменены только в сервисном центре при помощи специального оборудования.
А теперь соберем сервер обратно и перейдём к монтажу в стойку.
Монтаж
------
В первую очередь в стойку монтируются салазки. Салазки — это простые полки, на которые укладывается сервер. С одной стороны, такое решение очень простое и удобное, однако обслужить сервер без вытаскивания его из стойки не представляется возможным.
На фоне остальных серверов TaiShan цепляет внимание плоской передней панелью и зелено-черной цветовой гаммой. Отдельно хочется отметить, что производитель чутко относится к маркировке установленного в сервере оборудования. На каждой дисковой салазке указана необходимая информация об установленном диске, а под VGA-портом нанесена пиктограмма, обозначающая порядок нумерации дисков.
VGA-порт и 2 порта USB на передней панели — приятный бонус от производителя в дополнение к основным VGA + 2 USB на задней панели. На задней панели также можно найти порт для IPMI, отмеченный как MGMT, и COM-порт в RJ-45 исполнении, отмеченный как IOIOI.
Первичная настройка
-------------------
В ходе первичной настройки выполняется изменение настроек входа в BIOS и настройка IPMI. Huawei пропагандирует безопасность, поэтому BIOS и IPMI защищены паролями, отличными от привычных всем admin/admin. При первом входе BIOS предупреждает, что пароль по умолчанию ненадежный и его нужно сменить.
Huawei BIOS Setup Utility схож по интерфейсу с Aptio Setup Utility, применяемой в серверах компании SuperMicro. Здесь не встретишь ни переключателя для технологии Hyper-Threading, ни Legacy-режима.
Веб-интерфейс BMC-модуля предлагает три поля для ввода вместо ожидаемых двух. Войти в интерфейс можно как по локальному логину-паролю, так и аутентификацией через удаленный LDAP-сервер.
IPMI предоставляет множество возможностей для управления сервером:
* RMCP;
* RMCP+;
* VNC;
* KVM;
* SNMP.
По умолчанию метод RMCP, используемый в ipmitool отключен по соображениям безопасности. Для KVM-доступа iBMC предлагает два решения:
* «классический» Java-апплет;
* HTML5-консоль.
Так как процессоры ARM позиционируются как энергоэффективные, на главной странице веб-интерфейса iBMC можно видеть блок «Energy Efficiency», который показывает не только сколько энергии мы сэкономили, используя данный сервер, но сколько килограммов углекислого газа не попало в атмосферу.
> Несмотря на внушительную мощность блоков питания, в режиме простоя сервер потребляет **340 ватт**, а под полной нагрузкой всего **440 ватт**.
Использование
-------------
Следующий важный этап — установка операционной системы. Под архитектуру arm64 существует множество популярных дистрибутивов Linux, однако лишь наиболее современные версии устанавливаются и корректно работают на сервере. Вот список операционных систем, которые нам удалось запустить:
* Ubuntu 19.10;
* CentOS 8.1.
* Simply Linux 9.
> Во время подготовки статьи вышла новость, что российская компания «Базальт СПО» выпустила новую версию операционной системы Simply Linux. [Заявлено](https://www.cnews.ru/news/top/2020-04-08_rossiyane_vypustili_legkij), что Simply Linux поддерживает процессоры Kunpeng 920. Несмотря на то, что основное применение этой ОС — Desktop, мы не упустили возможность проверить ее работу на нашем сервере и остались довольны результатом.
Архитектура процессора, его главная особенность, пока что поддерживается не всеми приложениями. Большинство программного обеспечения ориентировано на повсеместно распространенную архитектуру x86\_64, а версии, портированные для arm64, чаще всего заметно отстают по функционалу.
> Huawei рекомендует использовать [EulerOS](https://developer.huaweicloud.com/ict/en/site-euleros/euleros), коммерческий дистрибутив Linux на базе CentOS, так как данный дистрибутив изначально полностью поддерживает функционал серверов TaiShan. Существует бесплатная версия EulerOS — [OpenEuler](https://openeuler.org/en/).
Известные бенчмарки, такие как GeekBench 5 и PassMark CPU Mark пока не работают с архитектурой arm64, поэтому для сравнения производительности были взяты «повседневные» задачи в виде распаковки, компиляции программ и вычисления числа π.
Конкурентом из мира x86\_64 взят двухсокетный сервер с Intel® Xeon® Gold 5218. Приводим технические характеристики серверов:
| | | |
| --- | --- | --- |
| **Характеристика** | **TaiShan 2280v2** | **Intel® Xeon® Gold 5218** |
| Процессор | 2x Kunpeng 920 (64 ядра, 64 потока, 2.6 ГГц) | 2x Intel® Xeon® Gold 5218 (16 ядер, 32 потока 2.3 ГГц) |
| Оперативная память | 16x DDR4-2933 32GB | 12x DDR4-2933 32GB |
| Диски | 12x HDD 1.2TB | 2x HDD 1TB |
Все тесты проводятся на операционной системе Ubuntu 19.10. Перед выполнением тестов все компоненты системы были обновлены командой full-upgrade.
Первым тестом сравниваем производительность в «одиночном зачете»: вычисление ста миллионов знаков числа π на одном ядре. В APT-репозиториях Ubuntu есть программа, решающая эту проблему: утилита pi.
Следующий этап тестирования — основательный «прогрев» сервера компиляцией всех программ проекта LLVM. В качестве компилируемого выбран [LLVM monorepo 10.0.0](https://github.com/llvm/llvm-project/releases/download/llvmorg-10.0.0/llvm-project-10.0.0.tar.xz), а компиляторами выступают **gcc** и **g++ версии 9.2.1**, поставляемые с пакетом **build-essentials**. Так как мы испытываем серверы, то при конфигурировании сборки добавим ключ **-Ofast**:
```
cmake -G"Unix Makefiles" ../llvm/ -DCMAKE_C_FLAGS=-Ofast -DCMAKE_CXX_FLAGS=-Ofast -DLLVM_ENABLE_PROJECTS="clang;clang-tools-extra;libcxx;libcxxabi;libunwind;lldb;compiler-rt;lld;polly;debuginfo-tests"
```
Это включит максимальную оптимизацию, проводимую во время компиляции, и дополнительно нагрузит испытуемые серверы. Компиляция запускается параллельно на всех доступных потоках.
После компиляции можно заняться перекодированием видео. Самая известная утилита командной строки, ffmpeg, обладает специальным режимом бенчмаркинга. В тестировании участвовал ffmpeg версии 4.1.4, а в качестве входного файла взят мультфильм [Big Buck Bunny 3D в высоком разрешении](http://distribution.bbb3d.renderfarming.net/video/mp4/bbb_sunflower_2160p_30fps_normal.mp4).
```
ffmpeg -i ./bbb_sunflower_2160p_30fps_normal.mp4 -f null - -benchmark
```
Все значения в результатах тестов — время, затраченное на успешное выполнение задачи.
| | | |
| --- | --- | --- |
| **Характеристика** | **2x Kunpeng 920** | **2x Intel® Xeon® Gold 5218** |
| Общее количество ядер/потоков | 128/128 | 32/64 |
| Базовая частота, ГГц | 2.60 | 2.30 |
| Максимальная частота, ГГц | 2.60 | 3.90 |
| Вычисление числа π | 5m 40.627s | 3m 18.613s |
| Сборка LLVM 10 | 19m 29.863s | 22m 39.474s |
| Перекодирование видео ffmpeg | 1m 3.196s | 44.401s |
Легко заметить, что основное преимущество представителя архитектуры x86\_64 — частота 3.9 ГГц, достигаемая с помощью технологии Intel® Turbo Boost. Процессор на архитектуре arm64 берет количеством ядер, а не частотой.
Как и ожидалось, при вычислении числа π в один поток количество ядер никак не помогает. Тем не менее, при компиляции больших проектов ситуация изменяется.
Заключение
----------
С физической точки зрения сервер TaiShan 2280v2 отличается вниманием к удобству эксплуатации и безопасности. Наличие PCI Express 4.0 является отдельным плюсом данной конфигурации.
При использовании сервера могут возникнуть проблемы с программным обеспечением под архитектуру arm64, однако, эти проблемы являются специфичными для каждого конкретного пользователя.
> Хотите протестировать весь функционал сервера на собственных задачах? TaiShan 2280v2 уже доступен [в нашей Selectel Lab](http://slc.tl/gEGhy). | https://habr.com/ru/post/496228/ | null | ru | null |
# Антипаттерны тестирования ПО
Введение
========
Есть несколько статей об антипаттернах разработки ПО. Но большинство из них говорят о деталях на уровне кода и фокусируются на конкретной технологии или языке программирования.
В этой статье я хочу сделать шаг назад и перечислить высокоуровневые антипаттерны тестирования, общие для всех. Надеюсь, вы узнаете некоторые из них независимо от языка программирования.
Терминология
============
К сожалению, в тестировании пока не выработали общую терминологию. Если спросить сотню разработчиков, в чём разница между интеграционным, сквозным и компонентным тестом, то получите сто разных ответов. Для этой статьи ограничимся такой пирамидой тестов:
Если не видели пирамиду тестов, настоятельно рекомендую ознакомиться с ней. Вот некоторые хорошие статьи для начала:
* [«Забытый слой пирамиды автоматических тестов»](https://www.mountaingoatsoftware.com/blog/the-forgotten-layer-of-the-test-automation-pyramid) (Майк Кон, 2009)
* [«Пирамида тестов»](https://martinfowler.com/bliki/TestPyramid.html) (Мартин Фаулер, 2012)
* [«Блог отдела тестирования Google»](https://testing.googleblog.com/2015/04/just-say-no-to-more-end-to-end-tests.html) (Google, 2015)
* [«Пирамида тестов на практике»](https://habr.com/post/358950/) (Хэм Фокке, 2018)
Пирамида тестов сама заслуживает отдельного обсуждения, особенно по количеству тестов, необходимых для каждой категории. Здесь я просто ссылаюсь на неё, чтобы определить две низшие категории тестов. Обратите внимание, что в этой статье *не* упоминаются тесты пользовательского интерфейса (верхняя часть пирамиды) — в основном, для краткости и потому что у них собственные специфические антипаттерны.
Поэтому определим две основные категории тестов: *модульные* (юнит-тесты) и *интеграционные*.
| Тесты | Цель | Требует | Скорость | Сложность | Нужна настройка |
| --- | --- | --- | --- | --- | --- |
| Юнит-тесты | класс/метод | исходный код | очень быстро | низкая | нет |
| Интеграционные тесты | компонент/сервис | часть работающей системы | медленно | средняя | да |
**Юнит-тесты** более широко известны как по названию, так и по своему значению. Эти тесты сопровождают исходный код и обладают прямым доступ к нему. Обычно они выполняются с помощью [фреймворка xUnit](https://en.wikipedia.org/wiki/XUnit) или аналогичной библиотеки. Юнит-тесты работают непосредственно на исходнике и имеют полное представление обо всём. Тестируется один класс/метод/функция (или наименьшая рабочая единицей для этой конкретной функциональности), а всё остальное имитируется/заменяется.
**Интеграционные тесты** (также именуемые сервисными тестами или даже компонентными тестами) фокусируются на целом компоненте. Это может быть набор классов/методов/функций, модуль, подсистема или даже само приложение. Они проверяют компонент путём передачи ему входных данных и изучения выдачи. Обычно требуется какое-то предварительное развёртывание или настройка. Внешние системы можно полностью имитировать или заменить (например, используя СУБД в памяти вместо реальной), а реальные внешние зависимости используются по ситуации. В сравнении с юнит-тестами требуются более специализированные инструменты либо для подготовки тестовой среды, либо для взаимодействия с ней.
Вторая категория страдает от размытого определения. Именно здесь больше всего споров о названиях. «Область» интеграционных тестов также весьма противоречива, особенно по характеру доступа к приложению (тестирование в [чёрном](https://en.wikipedia.org/wiki/Black-box_testing) или [белом](https://en.wikipedia.org/wiki/White-box_testing) ящике; разрешены [mock-объекты](https://en.wikipedia.org/wiki/Mock_object) или нет).
Основное практическое правило таково: если тест…
* использует базу данных,
* использует сеть для вызова другого компонента/приложения,
* использует внешнюю систему (например, очередь или почтовый сервер),
* читает/записывает файлы или выполняет другие операции ввода-вывода,
* полагается не на исходный код, а на бинарник приложения,
… то это интеграционный, а не модульный тест.
Разобравшись с терминами, можно погрузиться в список антипаттернов. Их порядок примерно соответствует их распространённости. Самые частые проблемы перечислены в начале.
Список антипаттернов тестирования ПО
====================================
1. [Модульные тесты без интеграционных](#1)
2. [Интеграционные тесты без модульных](#2)
3. [Неправильный тип тестов](#3)
4. [Тестирование не той функциональности](#4)
5. [Тестирование внутренней реализации](#5)
6. [Чрезмерное внимание покрытию тестами](#6)
7. [Ненадёжные или медленные тесты](#7)
8. [Запуск тестов вручную](#8)
9. [Недостаточное внимание коду теста](#9)
10. [Отказ писать тесты для новых багов из продакшна](#10)
11. [Отношение к TDD как к религии](#11)
12. [Написание тестов без предварительного чтения документации](#12)
13. [Плохое отношение к тестированию по незнанию](#13)
Антипаттерн 1. Модульные тесты без интеграционных
=================================================
Эта классическая проблема для малых и средних компаний. Для приложения создаются только юнит-тесты (основание пирамиды) — и больше ничего. Обычно отсутствие интеграционных тестов вызвано одной из следующих проблем:
1. У компании нет разработчиков-сеньоров. Есть только джуниоры, только что окончившие колледж. Они встречали лишь модульные тесты.
2. В какой-то момент интеграционные тесты существовали, но от них отказались, потому что они вызывали больше проблем, чем приносили пользы. Юнит-тесты гораздо проще в обслуживании, поэтому оставили только их.
3. Рабочая среда приложения слишком «сложна» для настройки. Характеристики «испытаны» в продакшне.
Не могу ничего сказать о первом пункте. В каждой эффективной команде должен быть своего рода наставник/лидер, который показывает хорошие практики другим разработчикам. Вторая проблема подробно освещена в антипаттернах [5](#5), [7](#7) и [8](#8).
Это подводит нас к последнему вопросу — сложной настройке тестовой среды. Не поймите меня неправильно, некоторые приложения *действительно* сложно тестировать. Однажды мне пришлось работать с набором приложений REST, которому требовалось специальное оборудование на хосте. Это оборудование существовало только в продакшне, что очень осложняло интеграционные тесты. Но это крайний случай.
Для заурядного веб- или серверного приложения, создаваемого типичной компанией, настройка тестовой среды не должна стать проблемой. С появлением виртуальных машин, а в последнее время контейнеров, сейчас это проще чем когда-либо. В основном, если вы пытаетесь протестировать приложение, которое трудно настроить, то сначала нужно исправить процесс настройки, прежде чем заниматься самими тестами.
Но почему вообще интеграционные тесты так важны?
Дело в том, что некоторые типы проблем могут обнаружить *только* интеграционные тесты. Канонический пример — всё, что связано с операциями СУБД. Транзакции, триггеры и любые хранимые процедуры БД можно проверить только с помощью интеграционных тестов, которые их затрагивают. Любые подключения к другим модулям, разработанным вами или внешними командами, требуют интеграционных тестов (они же контрактные тесты). Любые тесты для проверки производительности, являются интеграционными тестами по определению. Вот краткий обзор того, почему нам нужны интеграционные тесты:
| Тип проблемы | Определяется юнит-тестами | Определяется интеграционными тестами |
| --- | --- | --- |
| Основная бизнес-логика | да | да |
| Проблемы интеграции компонентов | нет | да |
| Транзакции | нет | да |
| Триггеры/процедуры БД | нет | да |
| Неправильные контракты с другими модулями/API | нет | да |
| Неправильные контракты с другими системами | нет | да |
| Производительность/таймауты | нет | да |
| Взаимные/самоустраняемые блокировки | возможно | да |
| Перекрёстные проблемы безопасности | нет | да |
Обычно любая перекрёстная проблема приложения требует интеграционных тестов. С учётом нынешнего помешательства на микросервисах интеграционные тесты становятся ещё более важными, поскольку теперь у вас появляются контракты между собственными службами. Если эти службы разрабатываются другими группами, необходимо автоматически проверить, не нарушены ли интерфейсные контракты. Это можно покрыть только интеграционными тестами.
Подводя итог, если вы не создаёте что-то чрезвычайно изолированное (например, утилиту командной строки Linux), то вам реально **нужны** интеграционные тесты, чтобы найти проблемы, не найденные юнит-тестами.
Антипаттерн 2. Интеграционные тесты без модульных
=================================================
Это противоположность предыдущему антипаттерну. Она чаще встречается в крупных компаниях и больших корпоративных проектах. Почти всегда такая ситуация связана с разработчиками, которые считают, что юнит-тесты не имеют реальной ценности, а отловить регрессии способны лишь интеграционные тесты. Многие опытные разработчики считают модульные тесты пустой тратой времени. Обычно если их порасспрашивать, то обнаружится, что когда-то в прошлом менеджеры потребовали увеличить покрытие кода тестами (см. [антипаттерн 6](#6)) и заставили их писать тривиальные юнит-тесты.
Действительно, теоретически в проекте *могут* быть только интеграционные тесты. Но на практике такое тестирование очень дорого обойдётся (по времени как разработки, так и сборки). В таблице из предыдущего раздела мы видели, что интеграционные тесты тоже могут находить ошибки бизнес-логики и поэтому способны «заменять» модульные тесты. Но жизнеспособна ли такая стратегия в долгосрочной перспективе?
### Интеграционные тесты сложны
Рассмотрим пример. Предположим, что у нас сервис с четырьмя такими методами/классами/функциями.
Число на каждом модуле обозначает его [цикломатическую сложность](https://en.wikipedia.org/wiki/Cyclomatic_complexity) то есть количество линейно независимых маршрутов через эту часть программного кода.
Разработчик Мэри действует по учебнику и хочет написать юнит-тесты для этого сервиса (потому что она понимает важность юнит-тестов). Сколько тестов нужно написать, чтобы полностью охватить все возможные сценарии?
Очевидно, можно написать 2+5+3+2 = 12 изолированных юнит-тестов, которые полностью охватывают **бизнес-логику** этих модулей. Помните, что это количество только для одного сервиса, а у приложения, над которым работает Мэри, несколько сервисов.
Разработчик Джо «Ворчун» не верит в ценность юнит-тестов. Он считает, что это пустая трата времени, и решает писать только интеграционные тесты для данного модуля. Сколько? Он начинает смотреть на все возможные маршруты через все части сервиса.
Опять же, должно быть очевидно, что возможно 2\*5\*3\*2 = 60 маршрутов кода. Значит ли это, что Джо на самом деле напишет 60 интеграционных тестов? Конечно нет! Он будет хитрить. Сначала попробует выбрать подмножество интеграционных тестов, которые кажутся «репрезентативными». Это «репрезентативное» подмножество обеспечит достаточное покрытие с минимальным количеством усилий.
В теории всё просто, но на практике быстро возникнет проблема. В реальности эти 60 сценариев создаются не одинаково. Некоторые из них — пограничные случаи. Например, через модуль C проходит три маршрута кода. Один из них — очень частный случай. Его можно воссоздать только если C получит специфические входные данные из компонента B, который сам по себе является пограничным случаем и может быть получен только специальными входными данными из компонента A. Значит, этот конкретный сценарий может потребовать очень сложной настройки для выбора входных данных, которые вызовут специальное условие на компоненте C.
С другой стороны, Мэри просто воссоздаст пограничный случай с помощью простого модульного теста без дополнительной сложности.
Значит, Мэри будет писать *только* юнит-тесты? В конце концов, это приведет ее к [антипаттерну 1](#1). Чтобы избежать этого, она напишет и модульные, и интеграционные тесты. Сохранит все модульные тесты для реальной бизнес-логики, а затем напишет один-два интеграционных теста для проверки, что остальная часть системы работает должным образом (т. е. части, которые помогают этим модулям выполнять свою работу).
Интеграционные тесты должны сосредоточиться на остальных компонентах. Саму бизнес-логику могут обрабатывать юнит-тесты. Интеграционные тесты Мэри сфокусируются на сериализации/десериализации, коммуникациях с очередью и БД системы.
В итоге количество интеграционных тестов значительно меньше, чем количество юнит-тестов, что соответствует форме пирамиды тестов из первого раздела этой статьи.
### Интеграционные тесты медленные
Вторая большая проблема интеграционных тестов — их скорость. Как правило, интеграционный тест выполняется на порядок медленнее юнит-теста. Модульному тесту нужен только исходный код приложения и больше ничего. Они почти всегда ограничен по нагрузке на CPU. С другой стороны, интеграционные тесты могут производить операции ввода-вывода с внешними системами, так что их гораздо труднее оптимизировать.
Чтобы получить представление о разнице по времени, предположим следующие цифры.
* Каждый юнит-тест занимает 60 мс (в среднем).
* Каждый интеграционный тест занимает 800 мс (в среднем).
* В приложении 40 сервисов, как показано в предыдущем разделе.
* Мэри пишет 10 модульных тестов и 2 интеграционных теста для каждого сервиса.
* Джо пишет 12 интеграционных тестов для каждого сервиса.
Теперь посчитаем. Обратите внимание, что Джо якобы нашёл идеальное подмножество интеграционных тестов, которые дают то же покрытие кода, что у Мэри (в реальности будет не так).
| Время выполнения | Имея только интеграционные тесты (Джо) | Имея юнит-тесты и интеграционные тесты (Мэри) |
| --- | --- | --- |
| Только юнит-тесты | N/A | 24 секунды |
| Только интеграционные тесты | 6,4 минуты | 64 секунды |
| Все тесты | 6,4 минуты | 1,4 минуты |
Разница в общем времени работы огромна. Ожидание одной минуты после каждого изменения кода значительно отличается от ожидания целых шести минут. И предположение в 800 мс для каждого интеграционного теста чрезвычайно консервативно. Я видел наборы интеграционных тестов, где один тест занимает несколько минут.
Подводя итог, попытка использовать *только* интеграционные тесты для покрытия бизнес-логики — огромная потеря времени. Даже если автоматизировать тесты с помощью CI, цикл обратной связи (от коммита до получения результата теста) всё равно очень долгий.
### Интеграционные тесты сложнее отладить, чем модульные тесты
Последняя причина, почему не рекомендуется ограничиваться только интеграционными тестами (без модульных) — это количество времени на отладку неудачного теста. Поскольку интеграционный тест по определению тестирует несколько программных компонентов, сбой может быть вызван *любым* из протестированных компонентов. Выявить проблему тем сложнее, чем больше задействовано компонентов.
При сбое интеграционного теста необходимо понимать причину сбоя и как её исправить. Сложность и охват интеграционных тестов делают их чрезвычайно трудными для отладки. Опять же в качестве примера предположим, что для вашего приложения сделаны только интеграционные тесты. Скажем, это типичный интернет-магазин.
Ваш коллега (или вы) присылает новый коммит, который инициирует запуск интеграционных тестов со следующим результатом:
Как разработчик вы смотрите на результат и видите, что интеграционный тест с названием «Клиент покупает товар» не проходит. В контексте приложения интернет-магазина это не очень хорошо. Есть много причин, по которым этот тест может не проходить.
Никак невозможно узнать причину сбоя теста, не погрузившись в логи и метрики тестовой среды (предполагая, что они помогут точно определить проблему). В некоторых случаях (и более сложных приложениях) единственный способ подлинной отладки интеграционного теста — извлечение кода, воссоздание тестовой среды на локальной машине, а затем запуск интеграционных тестов и попытка воспроизвести сбой в локальной среде разработки.
Теперь представьте, что над этим приложением вы работаете вместе с Мэри, поэтому у вас есть как интеграционные, так и модульные тесты. Ваши коллеги присылают коммиты, вы запускаете все тесты и получаете следующее:
Теперь не прошли два теста:
* «Клиент покупает товар» не проходит как раньше (интеграционный тест).
* «Тест специальной скидки» тоже не проходит (юнит-тест).
Теперь очень легко понять, где искать проблему. Можно перейти непосредственно к исходному коду функциональности скидки, найти ошибку и исправить её — и в 99% случаев интеграционный тест тоже будет отлажен.
Сбой юнит-теста *до или вместе* с интеграционным — гораздо более безболезненный процесс, когда нужно найти ошибку.
### Краткий вывод, зачем нужны юнит-тесты
Это был самый длинный раздел этой статьи, но я считаю его очень важным. Подведём итог: хотя *теоретически* можно использовать только интеграционные тесты, *на практике*
1. Юнит-тесты легче поддерживать.
2. Юнит-тесты легко воспроизводят пограничные случаи и редкие ситуации.
3. Юнит-тесты выполняются гораздо быстрее интеграционных тестов.
4. Сбойные юнит-тесты легче исправить, чем интеграционные.
Если у вас есть только интеграционные тесты, то вы впустую тратите и время разработки, и деньги компании. Нужны как модульные, так и интеграционные тесты одновременно. Они не взаимоисключающие. В сети есть несколько статей, которые пропагандируют использование только одного типа тестов. Все эти статьи распространяют дезинформацию. Печально, но это так.
Антипаттерн 3. Неправильный тип тестов
======================================
Теперь мы поняли, почему нужны оба вида тестов (модульные *и* интеграционные). Нужно определиться, *сколько* тестов нужно в каждой категории.
Здесь нет твёрдого и чёткого правила. Всё зависит от вашего приложения. Важно понять, что придётся потратить некоторое время, чтобы понять, какой тип тестов более ценный для *вашего* приложения. Пирамида тестов — лишь предположение о количестве тестов. Она предполагает, что вы пишете коммерческое веб-приложение, но это не всегда так. Рассмотрим несколько примеров:
### Пример: утилита командной строки Linux
Ваше приложение — утилита командной строки. Он берёт файлы одного формата (например, CSV), выполняет некоторые преобразования и экспортирует в другой формат (например, JSON). Приложение автономное, не общается ни с какими другими системами и не использует сеть. Преобразования представляют собой сложные математические процессы, которые имеют решающее значение для правильной работы приложения (они всегда должны выполняться правильно, независимо от скорости работы).
Что нужно для такого примера:
* Множество юнит-тестов для математических вычислений.
* Некоторые интеграционные тесты для чтения CSV и записи JSON.
* Никаких тестов GUI, потому что графический интерфейс отсутствует.
Вот как выглядит «пирамида» тестов для такого проекта:
Тут доминируют юнит-тесты, а получившаяся форма **не** является пирамидой.
### Пример: управление платежами
Вы добавляете новое приложение, которое внедрится в большую коллекцию существующих корпоративных систем. Приложение представляет собой платёжный шлюз, который обрабатывает платёжную информацию для внешней системы. Это новое приложение должно вести журнал всех транзакций во внешней БД, оно должно общаться с внешними платёжными провайдерами (Paypal, Stripe, WorldPay и др.), а также отправлять платёжные данные в ещё одну систему, которая выписывает счета.
Что нужно для такого примера:
* Почти никаких юнит-тестов, потому что нет бизнес-логики.
* Много интеграционных тестов для внешних коммуникаций, хранилища БД, системы выставления счетов.
* Никаких тестов GUI, потому что графический интерфейс отсутствует.
Вот как выглядит «пирамида» тестов для такого проекта:
Интеграционные тесты тут доминируют, а получившаяся форма опять **не** является пирамидой.
### Пример: конструктор сайтов
Вы работаете над совершенно новым стартапом, который разработал революционный способ создания сайтов: единственный в своем роде конструктор веб-приложений в браузере.
Приложение представляет собой графический конструктор с набором всех возможных элементов HTML, которые можно добавить на веб-страницу, и библиотеку готовых шаблонов. Есть возможность покупки новых шаблонов на рынке. Конструктор очень дружественный, позволяет перетаскивать компоненты на страницу, изменять их размер, редактировать свойства, изменять цвета и внешний вид.
Что нужно для этого надуманного примера:
* Почти никаких юнит-тестов, потому что нет бизнес-логики.
* Несколько интеграционных тестов для взаимодействия с рынком.
* Очень много тестов GUI, чтобы удостовериться в надлежащей работе графического интерфейса.
Вот как выглядит «пирамида» тестов для такого проекта:
Здесь доминируют тесты UI, а получившаяся форма опять **не** является пирамидой.
Эти крайние ситуации показывают, что разным приложениям требуется разное сочетание тестов. Я лично видел приложения для управления платежами без интеграционных тестов, а также конструкторы веб-сайтов без тестов UI.
В интернете можно найти статьи (я не собираюсь на них ссылаться), которые называют конкретное соотношение интеграционных тестов, юнит-тестов и тестов UI. Все эти статьи основаны на предположениях, которые могут *не подойти* вашему проекту.
Антипаттерн 4. Тестирование не той функциональности
===================================================
В предыдущих разделах мы описали типы и количество тестов, необходимых для вашего приложения. Следующий логический шаг — объяснить, какую именно функциональность нужно протестировать.
Теоретически, конечной целью является покрыть 100% кода. На практике эту цель трудно достичь и она не гарантирует отсутствие багов.
В некоторых случаях действительно реально проверить *всю* функциональность приложения. Если вы начинаете проект с нуля и работаете в небольшой команде, которая правильно действует и учитывает усилия, необходимые для тестов, то совершенно нормально покрыть тестами всю добавляемую функциональность (потому что для существующего кода уже есть тесты).
Но не всем разработчикам так повезло. В большинстве случаев вы наследуете существующее приложение с минимальным количеством тестов (или вообще без них!). Если вы работает в большой и устоявшейся компании, то работа с legacy-кодом — скорее правило, чем исключение.
В идеале вам дадут достаточно времени для написания тестов как для нового, так и для существующего кода legacy-приложения. Эту романтическую идею, вероятно, отвергнет менеджер проекта, более заинтересованный в добавлении новых функций, чем в тестировании/рефакторинге. Придётся расставить приоритеты и найти баланс между добавлением новой функциональности (по просьбе начальства) и расширением существующего набора тестов.
Так что именно будем тестировать? На чём сосредоточить усилия? Несколько раз я видел, как разработчики тратят драгоценное время на написание юнит-тестов, не имеющих практически никакого значения для общей стабильности приложения. Канонический пример бесполезного тестирования — тривиальные тесты, которые проверяют модель данных приложения.
Покрытие кода подробно анализируется в отдельном [антипаттерне](#6). В этом же разделе поговорим о «важности» кода и как она связана с тестами.
Если попросить любого разработчика показать исходники любого приложения, то он, вероятно, откроет IDE или репозиторий кода в браузере и покажет отдельные папки.
Это физическая модель кода. Она показывает папки в файловой системе, содержащие исходный код. Хотя эта иерархия отлично подходит для работы с самим кодом, к сожалению, она не показывает важность. Плоский список папок подразумевает, что все содержащиеся в них компоненты кода имеют одинаковое значение.
Это не так, поскольку различные компоненты кода оказывают различное влияние на общую функциональность приложения. В качестве краткого примера предположим, что вы пишете приложение интернет-магазина и в продакшне возникли две ошибки:
1. Клиенты не могут расплатиться по товарам из корзины, что остановило все продажи.
2. Клиенты получают неправильные рекомендации при просмотре продуктов.
Хотя обе ошибки подлежат исправлению, у первой явно больший приоритет. Поэтому если вам досталось приложение интернет-магазина вообще без тестов, следует написать новые тесты, непосредственно проверяющие функциональность корзины, а не механизм рекомендаций. Несмотря на то, что механизм рекомендаций и корзина могут находиться в папках одного уровня в файловой системе, при тестировании у них разная важность.
Если обобщить, то в любом среднем/большом приложении рано или поздно у разработчика возникает иное представление кода — ментальная модель.
Здесь показаны три слоя кода, но в зависимости от размера приложения их может быть больше. Это:
1. Критический код — код с частыми сбоями, куда вносится большинство новых функций и который важен на пользователей.
2. Основной код с периодическими сбоями, небольшим количеством новых функций и средним влиянием на пользователей.
3. Другой код с редкими сбоями, малым количеством новых функций и минимальным влиянием на пользователей.
Такую ментальную модель следует держать в голове всякий раз при написании нового теста ПО. Задайтесь вопросом, относится ли функциональность, для которой вы пишете тесты, к *критическому* или *основному* коду. Если да, то пишите тест. Если нет, то может есть смысл потратить время на что-нибудь другое (например, на другой баг).
Концепция степени важности кода также хорошо помогает ответить на вечный вопрос: какое покрытие кода достаточно для приложения? Для ответа нужно или самому знать уровни важности кода приложения, или спросить у того, кто знает. Когда вы обладаете этой информацией, то ответ очевиден: попробуйте написать тесты, покрывающие 100% **критического кода**. Если вы уже сделали это, то попробуйте написать тесты, покрывающие 100% **основного кода**. Однако [не рекомендуется](#6) пытаться покрыть тестами 100% общего кода.
Важно отметить, что критический код — всегда лишь небольшое подмножество общего. Таким образом, если критический код составляет, скажем, 20% от общего, то покрытие тестами 20% общего кода — уже хороший первый шаг для уменьшения количества багов в продакшне.
В общем, пишите модульные и интеграционные тесты для кода, который:
* часто ломается
* часто изменяется
* критичен для бизнеса
Если есть время для дальнейшего расширения набора тестов, то убедитесь, что осознаёте уменьшение эффекта от них, прежде чем тратить время на тесты с небольшой или нулевой важностью.
Антипаттерн 5. Тестирование внутренней реализации
=================================================
Больше тестов — всегда хорошо. Верно?
Неверно! Ещё нужно убедиться, что тесты на самом деле правильно структурированы. Наличие неправильно написанных тестов наносит двойной ущерб:
* Сначала они тратят драгоценное время разработчика при написании.
* Затем они тратят ещё больше времени, когда приходится их переделывать (при добавлении новой функции).
Строго говоря, [тестовый код похож на любой другой код](#9). В какой-то момент потребуется рефакторинг, чтобы постепенно его улучшать. Но если вы регулярно меняете существующие тесты при добавлении новых функций, то *ваши тесты тестируют не то, что должны*.
Я видел, как компании запускают новые проекты и думают, что на этот раз всё сделают правильно — они начинают писать *много* тестов, чтобы покрыть всю функциональность. Через некоторое время добавляют новую функцию, а для неё нужно изменить несколько существующих тестов. Затем добавляют ещё одну функцию и обновляют *ещё больше* тестов. Вскоре объём усилий на рефакторинг/исправление существующих тестов фактически превышает время, необходимое для реализации самой функции.
В таких ситуациях некоторые разработчики просто сдаются. Они заявляют, что тесты — пустая трата времени, и отказываются от существующего набора тестов, чтобы полностью сосредоточиться на новых функциях. В некоторых исключительных случаях даже релизы задерживаются из-за непрохождения тестов.
Конечно, здесь проблема в плохом качестве тестов. Если они постоянно нуждаются в рефакторинге, то налицо слишком тесная связь с основным кодом. К сожалению, чтобы выявить такие «неправильно» написанные тесты, требуется определённый опыт.
Изменение большого количества существующих тестов при появлении новой функции — это только *симптом*. Настоящая проблема в том, что тесты проверяют внутреннюю реализацию, а это всегда сценарий катастрофы. В нескольких руководствах по тестированию ПО делается попытка объяснить эту концепцию, но мало кто демонстрирует её на ясных примерах.
В начале статьи я обещал, что не буду говорить о конкретном языке программирования, и сдержу обещание. Здесь иллюстрации показывают структуру данных вашего любимого языка. Думайте о них как о структурах/объектах/классах, которые содержат поля/значения.
Допустим, объект Customer в приложении интернет-магазина выглядит следующим образом:
Тип Customer принимает только два значения, где `0` означает «гость», а `1` означает «зарегистрированный пользователь». Разработчики смотрят на объект и пишут десять юнит-тестов для проверки «гостей» и десять для «зарегистрированных пользователей». И когда я говорю «для проверки», то имею в виду, что тесты **проверяют это конкретное поле в этом конкретном объекте**.
Проходит время, и менеджеры принимают решение, что для филиалов необходим новый тип пользователя со значением `2`. Разработчики добавляют ещё десять тестов для филиалов. Наконец, добавлен ещё один тип пользователя под названием “premium customer" — и разработчики добавляют ещё десять тестов.
На данный момент у нас 40 тестов в четырёх категориях, и все они проверяют эти конкретные поля. (Числа вымышленные, пример только для демонстрации. В реальном проекте может быть десять взаимосвязанных полей в шести вложенных объектах и 200 тестов).
Если вы опытный разработчик, то можете представить дальнейшее развитие событий. Приходят новые требования:
1. Для зарегистрированных пользователей нужно сохранять ещё электронную почту.
2. Для пользователей в филиалах нужно сохранять ещё название компании.
3. Премиум-пользователям теперь начисляются бонусные баллы.
Объект клиента изменяется следующим образом:
Теперь у нас четыре объекта, связанные с внешними ключами, а все 40 тестов сразу ломаются, потому что проверяемое ими поле больше не существует.
*Конечно, в этом тривиальном примере можно просто сохранить существующее поле, чтобы не нарушать обратную совместимость с тестами.* В реальном приложении такое не всегда возможно. Иногда обратная совместимость по сути означает, что нужно сохранить и старый, и новый код (до/после новой функции), что сильно раздует его. Также обратите внимание, что сохранение старого кода просто ради юнит-тестов — само по себе явный антипаттерн.
Когда такое происходит в реальной ситуации, разработчики просят дополнительное время на исправление тестов. Затем менеджеры проектов заявляют, что юнит-тесты — пустая трата времени, потому что они мешают внедрению нового функционала. Потом вся команда отказывается от набора тестов, быстро отключив сбойные тесты.
Здесь основная проблема не в тестировании, а в качестве тестов. Вместо внутренней реализации следует тестировать ожидаемое поведение. В нашем простом примере вместо тестирования непосредственно внутренней структуры объекта нужно в каждом случае проверять точное бизнес-требование. Вот как следует реализовать те же тесты:
Здесь тесты вообще не проверяют внутреннюю структуру объекта. Они проверяют только его взаимодействие с другими объектами/методами/функциями. Если необходимо, другие объекты/методы/функции следует имитировать. Обратите внимание, что каждый тип теста напрямую соответствует конкретному бизнес-требованию, а не технической реализации (что всегда является хорошей практикой).
При изменении внутренней реализации объекта код верификации тестов остаётся прежним. Может измениться только код настройки для каждого теста, который должен централизованно храниться в одной вспомогательной функции `createSampleCustomer()` или в чём-то подобном (подробнее см. [антипаттерн 9](#9)).
Конечно, теоретически сами верифицированные объекты могут измениться. На практике же нереально **одновременное** изменение `loginAsGuest()`, `register()`, `showAffiliateSales()` и `getPremiumDiscount()`. В реалистичном сценарии потребуется рефакторинг десяти тестов вместо сорока.
Подводя итог, если вы постоянно исправляете существующие тесты по мере добавления новых функций, это означает, что ваши тесты тесно связаны с внутренней реализацией.
Антипаттерн 6. Чрезмерное внимание покрытию тестами
===================================================
Покрытие кода — любимая метрика в индустрии. Между разработчиками и менеджерами проектов [идут](https://softwareengineering.stackexchange.com/questions/1380/how-much-code-coverage-is-enough) [бесконечные](https://martinfowler.com/bliki/TestCoverage.html) [дискуссии](https://testing.googleblog.com/2010/07/code-coverage-goal-80-and-no-less.html) по поводу необходимого покрытия кода тестами.
Все любят говорить о покрытии, потому что это понятный легко измеримый показатель. В большинстве языков программирования и фреймворков тестирования есть простые инструменты для его отображения.
*Позвольте выдать маленький секрет*: покрытие кода — совершенно бесполезная метрика. Не существует «правильного» показателя. Это вопрос-ловушка. У вас может быть проект со 100% покрытием кода, в котором по-прежнему остаются баги и проблемы. В реальности нужно следить за другими метриками — хорошо известными показателям CTM (Codepipes Testing Metrics).
### Метрики CTM
Вот определение CTM, если вы с ними не знакомы:
| Название метрики | Описание | Идеальное значение | Обычное значение | Проблемное значение |
| --- | --- | --- | --- | --- |
| PDWT | Процент разработчиков, пишущих тесты | 100% | 20%-70% | Любое меньше 100% |
| PBCNT | Процент багов, приводящих к созданию новых тестов | 100% | 0%-5% | Любое меньше 100% |
| PTVB | Процент тестов, проверящих поведение | 100% | 10% | Любое меньше 100% |
| PTD | Процент детерминированных тестов | 100% | 50%-80% | Любое меньше 100% |
**PDWT** (процент разработчиков, пишущих тесты) — вероятно, самый важный показатель. Нет смысла говорить об антипаттернах тестирования ПО, если у вас вообще нет тестов. Все разработчики в команде должны писать тесты. Любую новую функцию можно объявлять *сделанной* только если она сопровождается одним или несколькими тестами.
**PBCNT** (процент багов, приводящих к созданию новых тестов). Каждый баг в продакшне — отличный повод для написания нового теста, проверяющего соответствующее исправление. Любой баг должен появиться в продакшне не более одного раза. Если ваш проект страдает от появления повторных багов даже после их первоначального «исправления», то команда действительно выиграет от использования этой метрики. Более подробно об этом см. в [антипаттерне 10](#10).
**PTVB** (процент тестов, которые проверяют поведение, а не реализацию). Тесно связанные тесты пожирают массу времени при рефакторинге основного кода. Эта тема уже обсуждалась в [антипаттерне 5](#5).
**PTD** (процент детерминированных тестов от общего числа). Тесты должны завершаться ошибкой только в том случае, если что-то не так с бизнес-кодом. Если тесты периодически ломаются без видимой причины — этой огромная проблема, которая обсуждается в [антипаттерне 7](#7).
Если после прочтения о метриках вы по-прежнему настаиваете на установке жёсткого показателя для покрытия кода, я дам вам число **20%**. Это число должно использоваться как эмпирическое правило, основанное на [законе Парето](https://en.wikipedia.org/wiki/Pareto_principle). 20% вашего кода вызывает 80% ваших ошибок, так что если вы действительно хотите начать писать тесты, то хорошо будет начать в первую очередь с этого кода. Совет также хорошо согласуется с [антипаттерном 4](#4), где я предлагаю писать тесты в первую очередь для критического кода.
*Не* пытайтесь достичь 100% общего покрытия. Это хорошо звучит в теории, но почти всегда является пустой тратой времени:
* вы впустую потратите силы, потому что переход с уровня 80% на 100% гораздо сложнее, чем с 0% до 20%;
* увеличение покрытия кода приводит к уменьшению отдачи.
В любом нетривиальном приложении есть определенные сценарии, для запуска которых требуются сложные юнит-тесты. Усилия, требуемые для написания таких тестов, как правило, перевешивают риск того, что эти сценарии реализуются в продакшне (если это вообще когда-нибудь произойдёт).
Если вы работали с любым большим приложением, то должны знать: после достижения 70% или 80% покрытия становится очень трудно писать полезные тесты для остального кода.
Как мы уже видели в описании [антипаттерна 4](#4), некоторые маршруты кода в реальности никогда не сбоят в продакшне, поэтому для них не рекомендуется писать тесты. Лучше потратить время на внедрение фактического функционала.
Если для проекта стоит условие определённого процента покрытия кода тестами, то разработчиков обычно заставляют тестировать тривиальный код или писать тесты, которые просто проверяют базовый язык программирования. Это огромная трата времени, и как разработчик вы обязаны пожаловаться руководству на такие необоснованные требования.
Подводя итог, покрытие кода тестами **нельзя** использовать как показатель качества софтверного проекта.
Антипаттерн 7. Ненадёжные или медленные тесты
=============================================
Конкретно этот антипаттерн [уже](https://martinfowler.com/articles/nonDeterminism.html) [неоднократно](https://testing.googleblog.com/2016/05/flaky-tests-at-google-and-how-we.html) [подробно](https://testing.googleblog.com/2017/04/where-do-our-flaky-tests-come-from.html) [обсуждался](https://semaphoreci.com/community/tutorials/how-to-deal-with-and-eliminate-flaky-tests), так что я только дополню.
Поскольку тесты ПО выступают ранним индикатором регрессий, они всегда должны работать надёжно. Провал теста обязан стать причиной беспокойства, а ответственные за соответствующий билд должны начать проверку, почему тест не прошёл.
Этот подход работает только с тестами, которые падают детерминированным образом. Если тест иногда сбоит, а иногда проходит (без каких-либо изменений кода между проверками), то он ненадёжен и дискредитирует всё тестирование. Это наносит двойной ущерб:
* Разработчики больше не доверяют тестам и начинают их игнорировать.
* Сбои даже нормальных тестов становится сложно обнаружить в море недетерминированных результатов.
О неудачном тесте следует чётко информировать всех членов команды, поскольку он меняет статус всей сборки. С другой стороны, при наличии ненадёжных тестов трудно понять, то ли происходят новые сбои, то ли это результат старых ненадёжных тестов.
Даже небольшого количества ненадёжных тестов достаточно, чтобы разрушить доверие к остальным. Например, у вас пять ненадёжных тестов, вы прогнали новый билд через тесты и получили три сбоя. Непонятно, всё в порядке или у вас появились три регрессии.
Аналогичная проблема с очень медленными тестами. Разработчикам нужна быстрая обратная связь по результатам каждого коммита (это обсуждается также в следующем разделе), поэтому медленные тесты они в итоге будут игнорировать или вообще не станут запускать.
На практике ненадёжные и медленные тесты почти всегда являются интеграционными и/или тестами пользовательского интерфейса. По мере подъёма по пирамиде тестов вероятность появления ненадёжных тестов значительно возрастает. Известно, что если тест обрабатывает события браузера, то его трудно сделать детерминированным. Источниками ненадёжности могут выступать многие факторы, но обычно виновата среда тестирования и её требования.
Основная защита от ненадёжных и медленных тестов — изолировать их в отдельном наборе тестов (при условии, что они неисправимы). В интернете есть много ресурсов о том, как исправить такие тесты на любом языке программирования, так что нет смысла объяснять это здесь.
Подводя итог, у вас должен быть абсолютно надёжный набор тестов, пусть это будет лишь подмножество всего набора тестов. Если тест из этого набора не проходит, то проблема однозначно с кодом. Любой сбой такого теста означает, что код нельзя пускать в продакшн.
Антипаттерн 8. Запуск тестов вручную
====================================
В разных организациях используются разные типы тестов. Юнит-тесты, нагрузочные, тесты приёма пользователей (UAT) — это типичные категории тестовых наборов, которые *могут* выполняться перед выпуском кода в продакшн.
В идеале все тесты выполняются автоматически без вмешательства человека. Если это невозможно, то хотя бы тесты, которые проверяют корректность кода (т.е. модульные и интеграционные тесты), **должны** выполняться автоматически. Таким образом, разработчики максимально оперативно получают обратную связь по коду. Функцию очень легко исправить, когда код свеж у вас в голове и вы ещё не переключили контекст на другую функцию.
Раньше самым длительным этапом жизненного цикла ПО было развёртывание приложения. В облаке машины создаются по запросу (в виде VM или контейнеров), так что время подготовки новой машины сократилось до нескольких минут или секунд. Такой сдвиг парадигмы застал врасплох многие компании, которые оказались не готовы к столь частым циклам. Большинство существующих практик сосредоточены на длительных циклах выпуска. Ожидать определённого времени релиза с ручной «отмашкой» — одна из устаревших практик, от которых следует отказаться, если компания стремится к быстрым деплоям.
Быстрое развёртывание подразумевает доверие к каждому деплою. Доверие к автоматическому деплою требует высокой степени уверенности в коде. Хотя есть несколько способов получить эту уверенность, но первая линия защиты — ваши тесты ПО. Однако наличие набора тестов с быстрым поиском регрессий — это лишь полдела. Второе необходимое условие — *автоматическое* выполнение тестов (возможно, после каждого коммита).
Многие компании *думают*, что у них внедрена непрерывная поставка и/или развёртывание. На самом деле это не так. Практика истинной CI/CD означает, что *в любой момент времени* существует версия кода, готовая к развёртыванию. Это значит, что релиз-кандидат *уже* протестирован. Поэтому наличие «готового» пакета, который ещё не получил отмашку — это не настоящая CI/CD.
Большинство компаний поняли, что человеческое участие вызывает ошибки и задержки, но по-прежнему остались компании, где запуск тестов является полуавтоматическим процессом. Под «полуавтоматическим» подразумевается то, что сам набор тестов может быть автоматизирован, но люди выполняют некоторые задачи по обслуживанию, такие как подготовка тестовой среды или очистка тестовых данных по завершению тестов. Это антипаттерн, потому что это не настоящая автоматизация. **Все** аспекты тестирования должны быть автоматизированы.
Имея доступ к виртуальным машинам или контейнерам, очень легко по запросу создавать различные тестовые среды. Создание тестовой среды на лету по каждому запросу должно стать стандартной практикой в вашей организации. Это означает, что каждая новая функция тестируется отдельно. Проблемный компонент (т.е. вызывающий сбой тестов) не должен блокировать деплой остальных.
Простой способ понять уровень автоматизации тестирования в компании — понаблюдать за рутинной работой сотрудников отделов QA/тестирования. В идеальном случае тестировщики просто создают новые тесты, которые добавляются в существующий набор. Они не запускают их вручную. Набор тестов выполняется сервером сборки.
Подводя итог, тестирование должно всё время происходить за кулисами. Разработчики узнают результат теста для своей конкретной функции через 5−15 минут после коммита. Тестеры создают новые тесты и проводят рефакторинг существующих тестов, но не запускают их вручную.
Антипаттерн 9. Недостаточное внимание коду теста
================================================
Опытный разработчик всегда сначала потратит некоторое время на упорядочивание кода в уме, прежде чем приступать к написанию. Относительно дизайна кода есть несколько принципов, а некоторые из них так важны, что им посвящены даже отдельные статьи в Википедии. Вот некоторые примеры:
* [DRY](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)
* [KISS](https://en.wikipedia.org/wiki/KISS_principle)
* [SOLID](https://en.wikipedia.org/wiki/SOLID_(object-oriented_design))
Возможно, первый принцип самый важный, поскольку он заставляет установить для кода единственный источник истины, который повторно используется в нескольких функциях. В зависимости от языка программирования вы также можете использовать некоторые другие рекомендации и шаблоны проектирования. Могут быть отдельные рекомендации, принятые специально в вашей команде.
Однако по какой-то неизвестной причине некоторые разработчики не применяют те же принципы к коду тестов ПО. Я видел проекты, где код функций отлично спроектирован, но код тестов страдает от огромных объёмов дублирования, жёстко закодированных переменных, фрагментов копипаста и других ошибок, которые считались бы непростительными в основном коде.
Не имеет смысла рассматривать тестовый код как второсортный, ведь в долгосрочной перспективе весь код нужно обслуживать. В будущем тесты придётся обновлять и перерабатывать. Их переменные и структура изменятся. Если вы пишете тесты, не задумываясь об их дизайне, то создаёте дополнительный технический долг, который добавится к уже существующему в основном коде.
Попробуйте писать тесты с тем же вниманием, которое уделяете коду компонентов. Здесь нужно использовать все те же техники рефакторинга. Для начала:
* Весь код теста должен быть централизованным. Таким же образом все тесты должны выдавать тестовые данные.
* Сложные сегменты верификации следует извлечь в общую для данной области библиотеку.
* Часто используемые имитации и эмуляции не следует копировать копипастом.
* Код инициализации теста должен быть общим для аналогичных тестов.
Если вы используете инструменты статического анализа, форматирования исходного кода или качества кода, настройте их для обработки тестового кода тоже.
Подводя итог, разрабатывайте тесты настолько же тщательно, как и основной код компонента.
Антипаттерн 10. Отказ писать тесты для новых багов из продакшна
===============================================================
Одна из задач тестирования — найти регрессии. Как мы видели в [антипаттерне 4](#4), в большинстве приложений есть «критическая» часть кода, где появляется большинство багов. Когда вы исправляете ошибку, то нужно убедиться, что она не повторится. Один из лучших способов гарантировать это — написать тест для исправления (либо юнит-тест, либо интеграционный, либо оба).
Ошибки, которые просачиваются в продакшн — идеальные кандидаты для написания тестов:
* они показывают отсутствие тестирования в данной области, поскольку баг уже попал в продакшн;
* если вы напишете тест для этой ошибки, то он защитит и будущие релизы.
Я всегда поражаюсь, когда команды разработчиков (даже с солидной стратегией тестирования) не пишут тест на ошибку, найденную *в продакшне*. Они исправляют код и сразу исправляют ошибку. По какой-то странной причине многие разработчики предполагают, что написание тестов имеет значение только при добавлении новой функции.
Сложно представить что-то более далёкое от истины. Я бы даже сказал, что тесты, которые вытекают из реальных ошибок, более ценны, чем тесты, которые добавляются как часть новой разработки. В конце концов, вы никогда не знаете, как часто новая функция будет сбоить в производстве (возможно, она принадлежит некритическому коду, который никогда не будет сбоить). Соответствующий тест хорош, но его ценность сомнительна.
А вот тест, который вы пишете для реальной ошибки, очень ценный. Он не только проверяет правильность исправления, но и гарантирует, что оно всегда будет действовать, даже после рефакторинга в данной области.
Если вы присоединитесь к legacy-проекту без тестов, то это и самый очевидный способ начать внедрение полезного тестирования. Вместо того, чтобы пытаться угадать, какой код покрыть тестами, просто обратите внимание на существующие баги — и напишите тесты для них. Через некоторое время тесты охватят критическую часть кода, так как по определению все ваши тесты проверяют то, что часто сбоит. Одна из [предложенных мною метрик](#14) отображает эти усилия.
Единственный случай, когда допустимо отказаться от теста — если ошибка в рабочей среде не связана с кодом и происходит из самой среды. Например, неправильную конфигурацию подсистемы балансировки нагрузки нельзя исправить с помощью юнит-теста.
Подводя итог, если вы не уверены в том, какой код тестировать, посмотрите на ошибки, которые попадают в продакшн.
Антипаттерн 11. Отношение к TDD как к религии
=============================================
TDD означает [разработку через тестирование](https://en.wikipedia.org/wiki/Test-driven_development). Как и все предыдущие методологии, она хороша на бумаге до тех пор, пока консультанты не начинают доказывать, что это единственно верное решение. На момент написания данной статьи такая практика постепенно прекращается, но я решил упомянуть о ней для полноты (поскольку корпоративный мир особенно страдает от этого антипаттерна).
Вообще говоря, когда дело доходит до тестирования программного обеспечения:
1. тесты можно писать *перед* соответствующим кодом;
2. тесты можно писать *одновременно* с соответствующим кодом;
3. тесты можно писать *после* соответствующего кода;
4. можно вообще не писать тесты для конкретного кода.
Один из основных принципов TDD — всегда следовать варианту 1 (написание тестов перед кодом реализации). В целом это хорошая практика, но не всегда *лучшая*.
Написание тестов перед кодом подразумевает, что вы уверены в окончательном API, а это не всегда так. Может, у вас есть чёткая спецификация и вы знаете точные сигнатуры всех методов, которые следует реализовать. Но в других случаях вы можете просто с чем-то экспериментировать или написать код **в направлении** решения, а не сразу окончательный вариант.
С практической точки зрения тому же стартапу рано слепо следовать TDD. Если вы работаете в стартапе, то ваш код может меняться так быстро, что TDD мало поможет. Вы можете даже отбросить код и начинать сначала, пока не напишете «правильный» вариант. Написание тестов после кода реализации — совершенно правильная стратегия в таком случае.
Отсутствие тестов вообще (вариант 4) тоже допустим. Как мы видели в [антипаттерне 4](#4), некоторый код вообще не нуждается в тестировании. Написание тестов для тривиального кода как «положено по TDD» ничего вам не даст.
Навязчивая идея апологетов TDD об обязательном написании сначала тестов нанесла огромный ущерб [психическому здоровью здравомыслящих разработчиков](https://softwareengineering.stackexchange.com/questions/98485/tdd-negative-experience). Об этой одержимости уже неоднократно говорили, так что надеюсь мне не нужно повторяться (поиск по ключевым словам «TDD дерьмо/глупо/мертво»).
Тут я хочу признаться, что несколько раз и сам работал по следующему сценарию:
1. Сначала реализация основного компонента.
2. Затем написание теста.
3. Запуск теста — успешно.
4. Комментирование критических частей кода компонента.
5. Запуск теста — сбой.
6. Удаление комментариев, возвращение кода в исходное состояние.
7. Запуск теста — снова успех.
8. Коммит.
Подводя итог, TDD — это хорошая идея, но не нужно постоянно следовать ей. Если вы работаете в компании из списка Fortune 500 с кучей бизнес-аналитиков и получаете чёткие спецификации, что конкретно нужно реализовать, тогда TDD *может* быть полезен.
С другой стороны, если вы просто играетесь дома с новым фреймворком в выходной день и пытаетесь понять, как он работает, то *необязательно* следовать TDD.
Антипаттерн 12. Написание тестов без предварительного чтения документации
=========================================================================
Профессионал хорошо знает свой рабочий инструмент. Возможно, в начале проекта придётся потратить дополнительное время, чтобы детально изучить технологии, которые вы собираетесь использовать. Постоянно выходят новые веб-фреймворки, и всегда полезно знать все возможности, которые можно применить для написания эффективного и лаконичного кода. Затраченное время вернётся сторицей.
С таким же уважением надо относиться к тестам. Поскольку некоторые разработчики рассматривают тесты как нечто второстепенное (см. также [антипаттерн 9](#9)), они никогда не стараются узнать в деталях, на что способен их фреймворк тестирования. Копипаст кода из других проектов и примеров на первый взгляд работает, но не так должен вести себя профессионал.
К сожалению, такая картина встречается слишком часто. Люди пишут несколько «вспомогательных функций» и «утилит» для тестов, не понимая, что во фреймворке эта функция либо встроена, либо подключается с помощью внешних модулей.
Такие утилиты затрудняют понимание тестов (особенно для джуниоров), поскольку наполнены «внутренними» знаниями, которые не распространяются на другие проекты/компании. Несколько раз я заменял «умные внутренние решения для тестирования» стандартными готовыми библиотеками, которые делают то же самое стандартизированным образом.
Следует потратить некоторое время и узнать о возможностях своего тестового фреймворка. Например, как он работает с:
* параметризованными тестами;
* имитациями и эмуляциями;
* тестовыми настройками и демонтажом (teardown);
* категоризацией текстов;
* обусловленным выполнением тестов.
Если вы работаете над типичным веб-приложением, то следует произвести минимальное исследование и изучить лучшие практики в отношении:
* генераторов тестовых данных;
* клиентских HTTP-библиотек;
* серверов для HTTP-имитации;
* мутационного тестирования и фаззинга;
* очистки/отката БД;
* нагрузочного тестирования и так далее.
Не нужно заново изобретать колесо. Это относится и к тестированию кода. Возможно, в некоторых пограничных ситуациях ваше приложение — действительно уникальная жемчужина и нуждается в некоей особой утилите для основного кода. Но могу поспорить, что модульные и интеграционные тесты у вас совершенно обычные, так что написание особых утилит тестирования — сомнительная практика.
Антипаттерн 13. Плохое отношение к тестированию по незнанию
===========================================================
Хотя данный антипаттерн я упоминаю последним, но именно он заставил меня написать эту статью. Меня всегда разочаровывает, когда на конференциях и митапах я встречаю людей, которые «гордо» заявляют, что *все тесты — пустая трата времени* и что их приложение отлично работает вообще без тестов. Ещё чаще встречаются те, кто против определённого типа тестирования (обычно против модульных или интеграционных тестов), как мы видели в антипаттернах [1](#1) или [2](#2).
Когда я встречаю таких людей, то люблю расспрашивать их и узнавать истинные причины, стоящие за ненавистью к тестам. И всегда это сводится к антипаттернам. Или они работали в компаниях с медленными тестами ([антипаттерн 7](#7)), или тестам требовался постоянный рефакторинг ([антипаттерн 5](#5)). Их «задолбали» необоснованные требования покрыть тестами 100% кода ([антипаттерн 6](#6)) или фанатики TDD ([антипаттерн 11](#11)), которые пытались навязать всей команде собственное искажённое понимание TDD.
Если вы один из таких людей, я действительно вам чувствую. Знаю, насколько тяжело работать в компании с неправильной организацией процесса.
Плохой опыт тестирования в прошлом не должен мешать вашей объективной оценке, когда дело доходит до тестирования следующего проекта, который начинается с нуля. Попытайтесь объективно взглянуть на свою команду, свой проект и понять, применимы ли к вам какие-либо антипаттерны. Если да, то просто тестирование проводится неправильно и никакое количество тестов не исправит ваше приложение. Печально, но это так.
Одно дело, когда ваша команда страдает от плохих практик тестирования, а другое — внушать джуниорам мысль, что «тестирование — пустая трата времени». Пожалуйста, не делайте этого. Существуют компании, которые не страдают **ни от каких** антипаттернов, упомянутых в статье. Попробуйте их найти! | https://habr.com/ru/post/358178/ | null | ru | null |
# Зонд Atlas RIPE
На конференции ENOG-4 мое внимание привлек стол, на котором лежали коробочки с наклейкой RIPE NCC, портом RJ-45 и хвостом USB. Вот такие:
Я был не в курсе что это и для чего нужно, по этому подошел и спросил. Оказалось, что это сетевой зонд Atlas RIPE, который можно взять с собой, пройдя регистрацию на [atlas.ripe.net](https://atlas.ripe.net). «Надо брать!», подумал я. Ведь нельзя пройти мимо такой милой железочки.
Дома я начал использование устройства, воткнув его, согласно инструкции, USB-шнурком в маршрутизатор, чтобы было питание, а в RJ-45 патчкорд до свича:
Зонд почти зразу весело замигал огоньками, показывая, что есть линк и пакеты ходят. Что, собственно, зонд делает:
* Пинг первых двух хопов, которые он видит. В моем случае это мой роутер и маршрутизатор провайдера;
* Пинг корневых DNS'ов;
* Выполняет пинги по заданию ~~во имя Луны~~ на пользу обществу и хозяину;
Сам зонд получает настройки по DHCP, не имеет интерфейса, открытых портов и о нем ничего путного не знает nmap (MAC-адрес я изменил):
```
[root@storage ~]# ping 192.168.2.236
PING 192.168.2.236 (192.168.2.236) 56(84) bytes of data.
64 bytes from 192.168.2.236: icmp_req=1 ttl=64 time=0.992 ms
64 bytes from 192.168.2.236: icmp_req=2 ttl=64 time=0.742 ms
64 bytes from 192.168.2.236: icmp_req=3 ttl=64 time=0.736 ms
^C
--- 192.168.2.236 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2002ms
rtt min/avg/max/mdev = 0.736/0.823/0.992/0.121 ms
[root@storage ~]# nmap -O 192.168.2.236
Starting Nmap 6.01 ( http://nmap.org ) at 2012-10-25 20:47 MSK
Nmap scan report for 192.168.2.236
Host is up (0.0022s latency).
All 1000 scanned ports on 192.168.2.236 are closed
MAC Address: 11:11:11:11:11:11 (Lantronix)
Too many fingerprints match this host to give specific OS details
Network Distance: 1 hop
OS detection performed. Please report any incorrect results at http://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 3.40 seconds
[root@storage ~]#
```
Интерфейс есть на сайте [atlas.ripe.net/atlas/myprobes.html](https://atlas.ripe.net/atlas/myprobes.html). Там можно посмотреть статус своего зонда и графики, которые он нарисовал:
Кроме статистики по собственному подключению, можно создавать запросы к чужим зондам на пинг (и некоторые другие операции) на нужные хосты, отобрав чужие зонды по критерию (например, страна). Это, естественно, не бесплатно, тратятся RIPE credits, которые зарабатываются аптаймом и участием в чужих запросах (подробнее, можно прочитать здесь: [atlas.ripe.net/doc/udm#the-credit-system](https://atlas.ripe.net/doc/udm#the-credit-system)).
Разбирать зонд я не стал, так как это повредило бы красивые наклеечки, фото разобранных легко можно найти в сети. Вот альбом на фликре по теме: [www.flickr.com/photos/hellercom/6854396415/in/photostream](http://www.flickr.com/photos/hellercom/6854396415/in/photostream/).
Вот и все!
UPDATE:
Хабраэффект в действии!
 | https://habr.com/ru/post/156155/ | null | ru | null |
# First DI: Первый DI на интерфейсах для Typescript приложений
Делюсь одной из своих библиотек которая называется First DI. Она уже много лет помогает мне решить проблему внедрения зависимостей в браузерных приложениях для таких библиотек как React, Preact, Mithril и другие. При написании First DI за основу была взята идеология DI библиотек языков C# и Java, такие как autofac, java spring autowired, ninject и другие. И точно так как библиотеки из этих языков First DI работает опираясь на рефлексию и интерфейсы Typescript.
### Для чего нужен DI?
Если говорить коротко, то Dependecy Injection (далее DI) является одной из основных частей для построения Чистой Архитектуры. Которая позволяет подменять любую часть программы на другую реализацию этой части программы. А DI является инструментом внедрения и подмены частей программы.
В частности он позволяет:
* Подменять реализации логики индивидуально для каждой платформы. Например в браузере показывать уведомления через Notifications API, а при сборке мобильных приложений подменять на уведомления через API мобильной платформы.
* Подменять реализацию логики в различных окружениях. Например в продуктовом контуре может использоваться платёжный шлюз или система рассылки уведомлений недоступная с локальной машины разработчика. Тем самым вместо реальных платежей или рассылки на этапе разработке логику можно заменить заглушкой.
* Подменять источник получения данных. Например вместо реального запроса на сервер подсунуть заранее подготовленные данные для тестирования бизнес логики или верстки на соответствие макетам.
* и еще много полезных применений, но сейчас не об этом...
Для начало подготовим инструменты к работе.
### Подготовка к использованию
Для использования необходимо сделать всего 3 простых вещи:
1. Подключить полифил [reflect-metadata](https://www.npmjs.com/package/reflect-metadata).
2. В файле tsconfig включить опции emitDecoratorMetadata и experimentalDecorators. Первая позволяет генерировать рефлексию, вторая включает поддержку декораторов
3. Создать любой пустой декоратор, например *const reflection = (...\_params: Object[]): void => {}* или воспользоваться готовым из библиотеки.
Теперь продемонстрирую использование в самом просто виде.
### Простое использование
Для примера возьмем программу написанную с использованием Чистой Архитектуры:
```
import { autowired, override, reflection } from "first-di";
@reflection // typescript сгенерирует рефлексию
class ProdRepository { // реализация для продакшена
public async getData(): Promise {
return await Promise.resolve("production");
}
}
@reflection
class MockRepository { // реализация для тестов с тем же интерфейсом
public async getData(): Promise {
return await Promise.resolve("mock");
}
}
@reflection
class ProdService {
constructor(private readonly prodRepository: ProdRepository) { }
public async getData(): Promise {
return await this.prodRepository.getData();
}
}
class ProdController { // компонент в React, Preact, Mithril и др.
@autowired() // внедрение зависимости
private readonly prodService!: ProdService;
// constructor используют библиотеки, такие как React, Preact, Mithril
// поэтому инъекция через конструктор не производится
public async getData(): Promise {
return await this.prodService.getData();
}
}
if (process.env.NODE\_ENV === "test") { // переопределение реализаций для тестов
override(ProdRepository, MockRepository);
}
const controllerInstance = new ProdController(); // создание экземпляра фреймворком
const data = await controllerInstance.getData();
if (process.env.NODE\_ENV === "test") {
assert.strictEqual(data, "mock"); // тестовые данные
} else {
assert.strictEqual(data, "production"); // продуктовые данные
}
```
В Чистую Архитектуру надо добавить всего 2 строчки кода, autowired и override для того что бы DI начал работать. И вот программа уже имеет реализацию для продакшена и реализацию для тестирования.
Так как First DI писался в первую очередь для клиентский приложений, то по умолчанию зависимости будут реализованы в виде Singleton. Для того, что бы глобально поменять это поведение, существуют опции по умолчанию, а также параметры для декоратора autowired и метода override().
Поменять можно следующим образом:
```
// Вариант 1 глобально
import { DI, AutowiredLifetimes } from "first-di";
DI.defaultOptions.lifeTime = AutowiredLifetimes.PER_INSTANCE;
// Вариант 2 в декораторе
import { autowired, AutowiredLifetimes } from "first-di";
@autowired({lifeTime: AutowiredLifetimes.PER_INSTANCE})
private readonly prodService!: ProdService;
// Вариант 3 при переопределении
import { override, AutowiredLifetimes } from "first-di";
override(ProdRepository, MockRepository, {lifeTime: AutowiredLifetimes.PER_INSTANCE});
```
Это самый простой путь для использования DI. Но в энтерпрайзе вместо конкретных реализаций используются интерфейсы, которые представляют из себя контракт для реализаций которые будут внедрены. Для этого есть второй режим работы.
### Профессиональное использование
Для профессионального использования заменим конкретные реализации на интерфейсы. Но typescript не генерирует код для работы интерфейсов в рантайме. К счастью есть простое решение, для понимания необходимо вспомнить теорию… что такое интерфейс? Это полностью абстрактный класс!
К счастью typescript поддерживает полностью абстрактные классы, генерирует код для рантайма, и позволяет использовать абстрактные классы для описания типов.
Воспользуемся этой информацией и напишем энтерпрайзную программу:
```
import { autowired, override, reflection } from "first-di";
abstract class AbstractRepository { // абстрактный класс вместо интерфейса
abstract getData(): Promise;
}
@reflection
class ProdRepository implements AbstractRepository {
public async getData(): Promise {
return await Promise.resolve("production");
}
}
@reflection
class MockRepository implements AbstractRepository {
public async getData(): Promise {
return await Promise.resolve("mock");
}
}
abstract class AbstractService { // абстрактный класс вместо интерфейса
abstract getData(): Promise;
}
@reflection
class ProdService implements AbstractService {
private readonly prodRepository: AbstractRepository;
constructor(prodRepository: AbstractRepository) {
this.prodRepository = prodRepository;
}
public async getData(): Promise {
return await this.prodRepository.getData();
}
}
class ProdController { // компонент в React, Preact, Mithril и др.
@autowired()
private readonly prodService!: AbstractService;
// constructor используют библиотеки, такие как React, Preact, Mithril
// поэтому инъекция через конструктор не производится
public async getData(): Promise {
return await this.prodService.getData();
}
}
override(AbstractService, ProdService);
if (process.env.NODE\_ENV === "test") {
override(AbstractRepository, MockRepository);
} else {
override(AbstractRepository, ProdRepository);
}
const controllerInstance = new ProdController();
const data = await controllerInstance.getData();
if (process.env.NODE\_ENV === "test") {
assert.strictEqual(data, "mock");
} else {
assert.strictEqual(data, "production");
}
```
Теперь у нас готовая Профессиональная программа, которая не имеет дефолтной реализации, а все контракты подменяются реализациями уже на этапе сборки приложения.
Вот так просто можно внедрить DI в ваше приложение. А те кто писал на C# и Java смогут пользоваться уже имеющимся опытом и в веб разработке.
### Другие возможности
Использование нескольких копий DI:
```
import { DI } from "first-di";
import { ProductionService } from "../services/ProductionService";
const scopeA = new DI();
const scopeB = new DI();
export class Controller {
@scopeA.autowired()
private readonly serviceScopeA!: ProductionService;
@scopeB.autowired()
private readonly serviceScopeB!: ProductionService;
// constructor используют библиотеки, такие как React, Preact, Mithril
// поэтому инъекция через конструктор не производится
public async getDataScopeA(): Promise {
return await this.serviceScopeA.getData();
}
public async getDataScopeB(): Promise {
return await this.serviceScopeB.getData();
}
}
```
Расширяемость, можно написать свой DI:
```
import { DI } from "first-di";
class MyDI extends DI {
// extended method
public getAllSingletons(): IterableIterator {
return this.singletonsList.values();
}
}
```
И еще много интересных возможностей описаны в [репозитории на GitHub](https://github.com/LabEG/first-di).
### Почему написан свой, а не использован имеющийся?
Причина простая — когда писался этот DI альтернатив не было. Это было время когда angular 1 уже был не актуален, а angular 2 еще не собирался выходить. В Javascript только появились классы, а в typescript рефлексия. Кстати говоря появление рефлексии стало основным толчком к действию.
InversifyJS — даже в текущем виде меня не устраивает. Слишком много бойлерплейта. К тому же регистрация по строке или символу на проч убивает возможность рефакторинга зависимостей.
### Понравилось?
Если вам понравился этот DI помогите сделать его более популярным. Экспериментируйте с ним, присылайте реквесты, ставьте звездочки. [Репозиторий на GitHub](https://github.com/LabEG/first-di). | https://habr.com/ru/post/496860/ | null | ru | null |
# Принципы эмуляции на основе CHIP-8
Считается, что прежде чем начинать эмулировать сложные системы, нужно начать с чего-то простого, например с Chip-8. В этой статье я попытаюсь рассмотреть все аспекты того, как можно написать свою реализацию этого языка в виртуальной машине. Пойдет совсем любой язык программирования, но из-за простоты я выберу Delphi.
Подождите, не кидайтесь сразу в редактор, сначала потребуется ручка и блокнот, куда мы запишем всю важную для себя информацию. Начинается все с ее поиска. Прежде всего, это конечно Google. После получаса хождения по ссылкам мы можем увидеть, как много реализаций уже написано под любую систему, выбирай не хочу, но мы не будем подсматривать в чужие исходники, а напишем свое.
#### Историческая справка
CHIP-8 это языковой интерпретатор, которые использовался в конце 70-ых, начале 80-ых на некоторых маленьких коммерческих компьютерах, таких как RCA's TELMAC 1800 и COSMAC VIP, и дешевых «создай-сам» компьютеров того времени как ETI 660 и DREAM 6800…
CHIP-8 позволял легко программировать игры. TELMAC 1800 и COSMAC VIP базировались на RCA CDP-1802 процессорах. Оба шли с аудио кассетой содержащей более 12 игр, датированных 1977 годом. У интерпретатора было менее 40 команд, включавших математические, управление потоком данных, графикой и звуком.
Интерпретатор должен был быть очень маленьким, из-за лимитов памяти в этих компьютерах: COSMAC VIP имел 2Kb (но мог быть расширен до 32Kb), а TELMAC имел 4Kb. CHIP-8 был длиной всего в 512 байт.
Простота языка позволяла создать Pong, Brix, Invaders и Tank в которые мы играли в самом начале видео игр. Хороший программист мог поместить эти игры в менее чем 256 байт.
Вот короткая история о CHIP-8 одного из пользователей DREAM-6800:
"*...the DREAM и ETI 660 появились в Австралийских Электронных Журналах как проекты к сборке. Объединяло эти компьютеры и их невероятно низкая цена (около $100), использование шестнадцатеричной клавиатуры, способность воспроизводить очень ограниченную графику 64 x 32 пикселей (ETI 660 могла получить 64 x 48 или 64 x 64 при ее модификации) передаваемую на телевизор, около одного килобайта оперативной памяти, и способность запускать псевдо язык высокого уровня, называемый CHIP-8 (разработанный RCA для демонстрации графики COSMAC, как мне кажется).
…
Как то однажды мой старший брат собрал DREAM 6800. Что это был за компьютер! Вместе со статьями по сборке DREAM & ETI 660 были горы листингов игр для CHIP-8. Некоторые игры были менее 200 байт или около того, так что ввод их не занял бы вечность. И это были классные игры. Они не были медленными. Так CHIP-8 был очень хорошо разработан для классических TV игр.*"
Пол Хайтер (Автор CHIP-8 интерпретатора для Amiga)
Позднее CHIP-8 использовался в начале 90-ых на калькуляторах HP48, потому что не существовало способа писать на нем игры быстрее. Почти все оригинальные игры от CHIP-8 работали и с CHIP48 интерпретатором, но было написано и множество новых.
Потом была выпущена новая версия языка — SUPER-CHIP. Он имел все возможности стандартного, но мог уже оперировать разрешением 128х64.
#### Архитектура
Все программы в CHIP-8 начинаются по адресу 200h, исключая ETI-660, у которого начало в 600h. Так сделано, потому что по адресу 000h-1FFh располагается сам интерпретатор языка.
Вся память полностью адресуема и доступна. Так как инструкции занимаю 16-бит, они обычно имеют четные адреса, а в случае если какие-то 8 бит вставлены внутри кода, их адреса становятся нечетными.
Исходя из 12 бит, используемых на адрес памяти, можно посчитать, что максимальный объем памяти без ухищрений мог составлять 4096 байт (000h-FFFh). Однако адреса F00h-FFFh занимает видео память, а EA0h-EFFh используется для хранения стека и внутренних переменных CHIP-8.
Интерпретатор использует 16 регистров общего назначения объемом в 8 бит. Они имеются как V0..VF. Причем VF используется в качестве флага для арифметических операций, в случае переноса, и детектора коллизий при рисовании спрайтов.
Так же есть 1 адресный регистр (I) размером 16 бит. Так как памяти всего 4 килобайта, интерпретатор использовал лишь его младшие 12 бит. Однако старшие 4 бита могли быть использованы для функции загрузки шрифта, так как шрифт располагался по адресу 8110.
Помимо регистров существовало 2 таймера. Один – таймер задержки, и один – звуковой таймер. Оба имели длину в 8 бит и уменьшали свое содержимое 60 раз в секунду, если не были в тот момент нулевыми. То есть имели частоту в 60 герц. Если звуковой таймер имел значение отличное от нуля, он воспроизводил звук.
Размерность стека осталась неизвестной, однако приято делать ее в 16 уровней(2х16 байт).
Графика отрисовывается спрайтами 8 на 1..15 пикселей, которые кодируются байтами. Начало координат в верхнем левом углу и начинается в точке 0. Все координаты положительные и считаются методом остатка от деления на 64 или 32 соответственно. Вывод на экран производится в режиме XOR. Если один или более пикселей очищаются (меняют свой цвет с 1 на 0) регистр VF устанавливается в 01h и в 00h в противном случае. Chip-8 имеет 4х5 пикселей шрифт, содержащий символы 0-9 и A-F.
Для наглядности рассмотрим пример спрайта и его кодирование. Возьмем спрайт 8х5.
Получим следующий набор байт: `С0 A0 С0 A0 С0`
Что бы стало совсем понятно возьмем еще 1 спрайт 8х8.
Спрайт займет 8 байт и будет иметь следующую структуру: `С0 60 30 18 0С 06 03`
Клавиатура для CHIP-8 16-ая и имеет такой внешний вид:
Об удобстве и целесообразности такой клавиатуры можно только спорить и рассуждать. Но отходить от оригинала мы не будем, потому что все разрабатывалось именно под такую клавиатуру.
#### Система команд
Следует сразу сказать что в качестве NNN мы будем обозначать адрес, KK – 8 битная константа, X и Y – 4 битные константы.
Теперь рассмотрим список команд.
0NNN Syscall nnn Вызов инструкции машинной инструкции процессора 1802 с кодом NNN.
00CN\* scdown n Скролирование экрана вниз на N строк.
00FB\* Scright Скролирование экрана на 4 пикселя вправо
00FС\* Scleft Скролирование экрана на 4 пикселя влево
00FD\* Выход из эмулятора
00FE\* Low Установить графический режим CHIP-8 (64x32)
00FF\* High Установить графический режим SUPER CHIP (128x64)
00E0 Cls Очистить экран
00EE Rts Вернуться из подпрограммы
1NNN jmp nnn Перевести выполнение программы на адрес NNN
2NNN jsr nnn Вызов функции по адресу NNN. Предыдущий адрес помещается в стек.
3XKK skeq vx,kk Пропустить следующую инструкцию (2 байта) если VX=KK
4XKK skne vx,kk Пропустить следующую инструкцию (2 байта) если VX<>KK
5XY0 skeq vx,vy Пропустить следующую инструкцию если VX=VY
6XKK mov vx,kk Записать KK в регистр VX
7XKK add vx,kk Записать VX+KK в регистр VX (По информации с Wikipedia и других источников не воздействует на флаг)
8XY0 mov vx,vy В VX записать значение регистра VY
8XY1 or vx,vy VX = VX OR VY.
8XY2 and vx,vy VX = VX AND VY
8XY3 xor vx,vy VX = VX XOR VY (недокументированна в оригинальных документах)
8XY4 add vx,vy VX = VX + VY. В VF = перенос (carry).
8XY5 sub vx,vy VX = VX – VY. (\*) VF = NOT borrow.
8X06 shr vx VX = VX SHR 1 (VX=VX/2), VF = перенос
8XY7 sub vy,vx VX = VY — VX, VF = not borrow (\*) (недокументирована в оригинальных документах)
8XYE shl vx VX = VX SHL 1 (VX=VX\*2), VF = перенос
9XY0 skne vx,vy Пропустить следующую инструкцию если VX <> VY
ANNN mov I,nnn I = NNN
BNNN Jmi NNN Перевести выполнение программы на NNN + V0
CXKK Rand vx,kk VX = (случайное число 0..255) AND KK
DXYN Draw vx,vy,n Отрисовать спрайт высотой N (при N=0 считать N=16) и шириной 8 по координатам (VX,VY) начинающийся в памяти по адресу содержащемуся в регистре I. VF = collision.
EX9E Skpr vx Пропустить следующую инструкцию, если клавиша с номером содежащимся в VX нажата.
EXA1 Skup vx Пропустить следующую инструкцию, если клавиша с номером содежащимся в VX не нажата.
FX07 Gdelay vx VX = Delay timer
FX0A Key vx Ждем нажатия кнопки и складываем ее в VX.
FX15 Sdelay vx Delay timer = VX
FX18 Ssound vx Sound timer = VX
FX1E Add I,vx I = I + VX
FX29 Font vx Поместить в I адрес спрайта шрифта 4 x 5 шестнадцатеричного символа содержащегося в VX
FX33 Bcd vx Поместить BCD представление VX в память по адресам I..I+2. Например если в VX содержится 4Fh то в памяти будет записано 00h 07h 09h то есть десятичное представление 4Fh
FX55 Save vx Сохраняет регистры V0...VX в памяти, начинающейся по адресу I
FX65 Load vx Загружает регистры V0...VX из памяти, начинающейся по адресу I
FX75\* Ssave vx Сохраняет V0...VX (X<8) в HP48 flags
FX85\* Sload vx Загружает V0...VX (X<8) из HP48 flags
\* — значит команда актуальна только для SUPER CHIP интерпретатора.
(\*): Когда происходит VX — VY, VF устанавливается в отрицание заема. Это значит что если VX больше или равно VY, VF будет установлено в 01, так как заем = 0. If VX меньше чем VY, VF устанавливается в 00, так как заем = 1.
#### Подготовка базовых спрайтов
Пользуясь листочком бумаги и ручкой, набросаем спрайты шрифта. Получится примерно вот такой набор:
Пользуясь им, запишем байты значения каждого спрайта.
#### Принципы эмуляции
Считается, что вся эмуляция должна происходить в цикле, примерно такого типа.
> Repeat
>
> //do emulation
>
> Until quit\_pr;
Здесь quit\_pr – считается признаком остановки эмуляции, и изменяться может не только снаружи, но и изнутри эмуляции.
Одним из самых важных моментов, которые следует соблюдать, является соблюдение частот работы оборудования и оптимизация. Если неверно описать эмуляцию даже такого простого языка как CHIP-8 можно получить очень низкую производительность и крайне высокие затраты процессорного времени, правильная же эмуляция даст достаточную производительность при минимальных затратах.
Используя Delphi, я решил разработать эмуляцию системы в качестве класса и дал ему название «TCpu1802», на основе модели процессора, использовавшегося внутри данной системы. Рассмотрим основную для него процедуру run.
> procedure tcpu1802.run;
>
> begin
>
> delaytimer.Enabled:=true;
>
> soundtimer.Enabled:=true;
>
> drawtimer.Enabled:=true;
>
> work:=true;
>
> repeat
>
> useopcode;
>
> if cpumulty<>0 then
>
> if (round(cycle) mod (2))=0 then sleep(cpumulty);
>
> application.ProcessMessages;
>
> until work=false;
>
> delaytimer.Enabled:=false;
>
> soundtimer.Enabled:=false;
>
> drawtimer.Enabled:=false;
>
> end;
>
>
>
>
Сначала, при запуске, мы активируем два стандартных для CHIP-8 таймера и один, введенный самостоятельно, для перерисовки экрана. Cycle – переменная содержащая текущий цикл команд, вызов каждой команды увеличивает cycle на единицу. Каждое второе действие мы будем пытаться приостанавливать работу интерпретатора на cpumulty миллисекунд. Это необходимо для того, что бы не происходило превышение скорости.
Таймеры Soundtimer и Drawtimer имеют интервал 17 миллисекунд, то есть работают с частотой 58,82 герца, что максимально приближено к оригиналу.
Задержку Drawtimer делаем равной 10 миллисекунд. То есть в среднем отрисовка будет выполняться каждую 3-4 команды интерпретатора. Выделение на таймер сделано для того что бы не засорять процесс выполнения интерпретатора и позволяет штатными средствами выполнить распараллеливание процессов.
Посмотрим на список переменных, который нам понадобится для выполнения самой эмуляции:
> keycode:byte; // код нажатой клавиши
>
> memory:array[0..8191] of byte; // 8 килобайт оперативной памяти, выделено из-за расположения шрифтов
>
> stack:array[0..255] of word; // стек
>
> stacksize:byte; // текущий развер стека
>
> videoarray:array[0..2047] of boolean; //видео массив
>
> mask:array[0..2047] of boolean; // маска видео массива
>
> Vreg:array[0..15] of byte; // - регистры V0..VF
>
> Ireg:word; // 2 byte адресный регистр
>
> CodeSender:word; //расположение следующего opcode в памяти
>
> sound:boolean; // воспроизводится ли сейчас звук?
Согласно архитектуре видеопамять располагается в том же объеме оперативной памяти, что и все остальное, однако, постоянные чтение и запись туда, рассматривая байты и анализируя их, заняла бы много процессорных ресурсов и является нецелесообразной, однако, допуская что какая то программа может что то читать непосредственно оттуда, в случае если происходит чтение из той области памяти, мы можем просто вызывать дополнительную процедуру, названную mirrorvideomem, позволяющую записать туда текущее содержимое видеопамяти. Такое решение эффективно, хоть и вызывает несколько большее использование оперативной памяти. Аналогично происходит и процедура mirrorstack.
> procedure tcpu1802.mirrorvideomem;
>
> var
>
> i,j:integer;
>
> tmp:byte;
>
> begin
>
> if (Ireg>=$F00) and (Ireg<=$FFF) then
>
> begin
>
> for i:=0 to 255 do
>
> begin
>
> tmp:=0;
>
> for j:=0 to 7 do
>
> begin
>
> if videoarray[i\*j] then tmp:=tmp+1;
>
> tmp:=tmp shl 1;
>
> end;
>
> memory[$F00+i]:=tmp;
>
> end;
>
> end;
>
> end;
>
>
>
>
>
> procedure tcpu1802.mirrorstack;
>
> var
>
> n,i:integer;
>
> begin
>
> if (Ireg>=$EA0) and (Ireg<=$EFF) then
>
> begin
>
> if stacksize>12 then n:=11 else n:=stacksize-1;
>
> for i:=0 to n do
>
> begin
>
> memory[$EFF-i\*2]:=stack[i] div 256;
>
> memory[$EFF-i\*2+1]:=stack[i] mod 256;
>
> end;
>
> end;
>
> end;
>
>
Прежде чем писать процессор можно заметить, что каждая команда условно разбивается на 4 раздела по 4 бита. Для работы с ними введен тип данных opcode (type opcode = array[0..3] of byte;).
Не буду останавливаться на преобразовании и чтении очередных данных из памяти, однако, обращу внимание на структуру процедуры run, выполняющей эмуляцию. Она в целях оптимизации использует не «if then else», а «case», и более того ряд команд позволяет использовать их с помощью ассемблера, что еще больше ускоряет работу эмуляции. Вот пример такой команды:
> if op[3]=1 then
>
> begin
>
> tmp:=Vreg[op[1]];
>
> tmp2:=Vreg[op[2]];
>
> asm
>
> mov ah,[tmp]
>
> or ah,[tmp2];
>
> mov [tmp],ah;
>
> end;
>
> Vreg[op[1]]:=tmp;
>
> used:=true;
>
> codesender:=codesender+2;
>
> end;
Теперь, рассмотрев все моменты эмуляции, можно написать собственную эмуляцию CHIP-8. Надеюсь, моя статья вам понравилась и была полезна. Спасибо за чтение.
Используемые статьи:
[A CHIP-8 / SCHIP emulator
By David WINTER (HPMANIAC)](http://www.pdc.kth.se/~lfo/chip8/CHIP8.htm)
[Wikipedia](http://en.wikipedia.org/wiki/CHIP-8)
Исходник модуля:
[исходник](http://dl.dropbox.com/u/5679066/cpu1802.pas)
Именно за нее я получил приглашение от пользователя [nsinreal](https://geektimes.ru/users/nsinreal/), за что ему огромное спасибо.
Просьба не считать «копипастом» [статьи](http://tronix286.habrahabr.ru/blog/100907/), появившейся за час до опубликования этой, вследствие того что не мог отправить. Прошу считать что мы не видели статьи друг-друга, в следствие разного содержания модулей и разного подхода к эмуляции, заранее спасибо. | https://habr.com/ru/post/100916/ | null | ru | null |
# Throwable exception и ошибки в php7
В прошлом, обрабатывать фатальные ошибки было практически невозможно. Обработчик, установленный `set_error_handler` вызван не будет, скрипт просто будет завершен.
В PHP 7 при возникновении фатальных ошибок (E\_ERROR) и фатальных ошибок с возможностью обработки (E\_RECOVERABLE\_ERROR) будет выброшен exception, а не произойдет завершение скрипта. Но определенные ошибки, например «out of memory», по прежнему приведут к остановке. Не перехваченные ошибки в PHP 7, будут «фатальны», так же как и в php 5.\*.
> Обратите внимание, что другие виды ошибок, такие как warinng и notice остаются без изменения в php 7.
Исключения выброшенные из E\_ERROR и E\_RECOVERABLE\_ERROR не наследуются от *Exception*. Это разделение было сделано, чтобы предотвратить обработку этих ошибок кодом, написанным под 5.\*. Исключения для фатальных ошибок теперь являются экземпляром нового класса: *Error*. Как и любые другие исключения, *Error* может отловлен, обработан и выполнен *finally* блок.
##### Throwable
Оба класса, и Error и Exception реализуют новый интерфейс *Throwable*.
Новая иерархия исключения состоит в следующем:
```
interface Throwable
|- Exception implements Throwable
|- ...
|- Error implements Throwable
|- TypeError extends Error
|- ParseError extends Error
|- AssertionError extends Error
```
Если *Throwable* определить в коде PHP 7, то выглядит это так:
```
interface Throwable
{
public function getMessage(): string;
public function getCode(): int;
public function getFile(): string;
public function getLine(): int;
public function getTrace(): array;
public function getTraceAsString(): string;
public function getPrevious(): Throwable;
public function __toString(): string;
}
```
Этот интерфейс должен быть знаком. Методы *Throwable* практически идентичны методам *Exception*. Разница лишь в том, что *Throwable::getPrevious()* может вернуть любой экземпляр *Throwable*, а не просто *Exception*. Конструкторы *Exception* и *Error* принимают любой экземпляр *Throwable* как предыдущее исключение.
*Throwable* может быть использован в блоке *try/catch* для отлова и *Exception* и *Error* (и любых других возможных в будущем исключений). Помните, что хорошей практикой является «ловля» исключений определенным классом исключений и обработка каждого типа отдельно. Но и иногда требуется отлавливать любое исключение. В PHP 7 *try/catch* блок для всех исключений должен использовать *Throwable* вместо *Exception*.
```
try {
// Code that may throw an Exception or Error.
} catch (Throwable $t) {
// Handle exception
}
```
Пользовательские классы не могут реализовывать *Throwable*. Это было сделано для предсказуемости: только экземпляры *Exception* или *Error* могут быть брошены. Кроме того, исключения содержат информацию о том, где объект был создан в *stack trace*. В пользовательских классах нет необходимых параметров, для хранения этой информации.
##### Error
Практически все ошибки (E\_ERROR, E\_RECOVERABLE\_ERROR) в PHP 5.x, в PHP 7 выбрасывается экземпляром *Error*. Как и любые другие исключения, *Error* может быть пойман используя try/catch блок.
```
try {
$undefined->method(); // Throws an Error object in PHP 7.
} catch (Error $e) {
// Handle error
}
```
Большинство ошибок, которые были «фатальны» в PHP 5.x в PHP 7 буду выбрасывать простые Error объекты, но некоторые будут выбрасывать объекты подклассов: *TypeError*, *ParseError* и *AssertionError*.
##### TypeError
Экземпляр *TypeError* выбрасывается, когда аргументы метода или возвращаемое значение не совпадает с объявленным типом.
```
function add(int $left, int $right)
{
return $left + $right;
}
try {
$value = add('left', 'right');
} catch (TypeError $e) {
echo $e->getMessage(), "\n";
}
//Result:
//Argument 1 passed to add() must be of the type integer, string given
```
##### ParseError
*ParseError* выбрасывается, когда подключаемый (путем *include/require*) файл или код в *eval* содержит ошибки синтаксиса.
```
try {
require 'file-with-parse-error.php';
} catch (ParseError $e) {
echo $e->getMessage(), "\n";
}
```
##### AssertionError
Когда условие, заданное методом *assert()* не выполняется, выбрасывается *AssertionError*:
```
ini_set('zend.assertions', 1);
ini_set('assert.exception', 1);
$test = 1;
assert($test === 0);
```
```
Fatal error: Uncaught AssertionError: assert($test === 0)
```
Метод *assert()* выполняется и выбрасывается *AssertionError* только, если они включены в настройках: *zend.assertions = 1* и *assert.exception = 1*.
##### Использование Error в своём коде
Мы можем использовать класс *Error*, а также расширить *Error*, создав собственную иерархию класса *Error*. Это порождает вопрос: какие исключение должен выбрасывать *Exception*, а какие *Error*?
*Error* должен использоваться для указания проблем в коде, требующих внимания программиста (такие как неправильный тип входящих данных и синтаксические ошибки). *Exception* должен использоваться, когда исключение может «безопасно» обработаться, и выполнение программы может продолжиться.
Поскольку, объекты *Error* не могут быть обработаны во время выполнения программы, «ловля» *Error* должна быть редкостью. В целом, *Error* должны быть пойманы только для логирования их, необходимой «чистки данных», и отображения ошибки для пользователя.
##### Ловим исключения и в PHP 5.x и в PHP 7
Чтобы поймать исключения и в php 5.x и в php 7, используя один код, используем несколько блоков *catch*, ловим *Throwable* первым, затем *Exception*. После того, как поддержка PHP 5.x не потребуется, можно просто удалить блок ловли *Exception*.
```
try {
// Code that may throw an Exception or Error.
} catch (Throwable $t) {
// Executed only in PHP 7, will not match in PHP 5.x
} catch (Exception $e) {
// Executed only in PHP 5.x, will not be reached in PHP 7
}
``` | https://habr.com/ru/post/261451/ | null | ru | null |
# Телеграм бот для поддержки своими руками
Представьте, что у вас есть свой канал в Телеге. Допустим, вы высказываете непопулярную политическую точку зрения и, соответственно, ловите хейт в личку со стороны читателей и проходящих мимо.
Или, например, вы продаете что-то через свой канал. Клиентов так много, что один "продажник" (=вы) не справляется. Или поддержка вашего бизнеса отвечает всем в публичном чате, который прикреплен к вашему каналу. Но многие стесняются задать вопросы, так как их могут увидеть, поэтому пишут в личку, что не масштабируется.
Проблем много, а решение одно: сделать Телеграм бот, который будет работать посредником между вашими клиентами и командой поддержки.
> ***Мое мнение****: это самый лучшее применение телеграм ботов за всю историю их существования. На втором месте - рассылка закрытой информации через бота только проплатившим пользователям.*
>
>
Самый популярный конструктор таких ботов - Livegrambot. Он позволяет сделать тоже самое, но при этом бот будет писать вашим пользователям "я сделан через Livegrambot", выпрашивая деньги у вас. Будучи [умелым создателем Телеграм ботов](https://t.me/danokhlopkov/205), я решил сделать свой аналог, но уже с открытым исходным кодом и легким способом запустить его бесплатно на бесплатные серверы.
Ниже я расскажу, как в 1 клик запустить такого бота и как он технически устроен.
**TL;DR:** Код выложил сюда: <https://github.com/ohld/telegram-support-bot>
#### Юзер стори или как с этим ботом работать.
Действующие лица:
* Ваши **Пользователи** (читатели канала, клиенты),
* Закрытый **Чат** Поддержки (где сидят те, кто будет отвечать на вопросы Пользователей),
* **Бот** (которому Пользователи будут писать свои вопросы).
Вот так это все будет работать:
1. Вы публикуете ссылку на **Бота**,
2. **Пользователи** пишут в него свои вопросы,
3. **Бот** пересылает их сообщения в ваш **Чат** Поддержки,
4. В этом чате вы или ваши помощники отвечают на сообщение (через reply),
5. **Бот** пересылает ответ обратно пользователю от своего лица, скрывая аккаунт отвечающего.
Такая схема неплохо масштабируется: достаточно нанять больше Агентов поддержки, и все Пользователи получат свои ответы вовремя и через бота.
#### Как это все запустить? Желательно, без навыков.
Планируя дизраптнуть платный аналог, необходимо продумать онбординг. Большинству проще заплатить, чем самому разбираться в коде, технологии и деплое. К счастью, я фанат Heroku, а именно там можно бесплатно хостить свой код, нажав всего одну кнопку.
В [README.md](https://github.com/ohld/telegram-support-bot) я добавил волшебную кнопку от Heroku, которая поможет запустить код из репозитория. После нажатия, при наличии аккаунта на Heroku (который можно создать также по 1 кнопке), вы увидите такую картину:
Heroku уже понял, какие данные нужно запросить у вас, у создателя, чтобы все завелось автоматически. Давайте пройдемся по этим параметрам:
- **App name**: название приложения в системе Heroku. Можно придумать любое.
- **Choose a region**: где Хероку запустит ваш код. Можно выбрать любое место.
- `HEROKU_APP_NAME`: впишите сюда тоже самое, что указали выше в App name (это важно для того, чтобы завести тг бота через вебхуки).
- `TELEGRAM_SUPPORT_CHAT_ID`: айдишник чата, куда Телеграм бот будет пересылать сообщения пользователей. Как узнать его - смотрите ниже.
- `TELEGRAM_TOKEN`: токен вашего бота, который можно получить у [BotFather](https://t.me/botfather).
Как узнать TELEGRAM*SUPPORT*CHAT\_ID
Способов много, но самый простой - это добавить [вот этого бота](https://t.me/ShowJsonBot) в ваш созданный приватный чат. Этот бот возвращает все данные, которые ему присылает Телеграм, в частности событие "меня добавили в чат", откуда вы и сможете извлечь `chat_id`.
#### Как реализовать такого бота?
Ниже будет много технической информации. Мы же на Хабре, поэтому я решил добавить этот раздел для любителей разобраться в коде и при необходимости его адаптировать. Это раздел можно спокойно пропустить, если хотите.
Примеры кода я буду писать на языке Python и использовать библиотеку `python-telegram-bot`. Итогда я буду вставлять ссылки на GitHub ([гит](https://github.com/ohld/telegram-support-bot/)), чтобы легко можно было найти этот кусок кода в моем репозитории.
Хендлеры (обработчики событий)
Для нашей задумки необходимы всего 3 хендлера ([гит](https://github.com/ohld/telegram-support-bot/blob/main/handlers.py#L55)):
```
from telegram.ext import Updater
from telegram.ext import CommandHandler, MessageHandler, Filters
updater = Updater(TELEGRAM_TOKEN)
dp = updater.dispatcher
# Для приветственного сообщения и для "к вам подключился {username}"
dp.add_handler(CommandHandler('start', start))
# Для пересылки из бота в чат поддержки
dp.add_handler(MessageHandler(Filters.chat_type.private, forward_to_chat))
# Для пересылки ответа из чата обратно пользователю
dp.add_handler(MessageHandler(Filters.chat(TELEGRAM_SUPPORT_CHAT_ID) & Filters.reply, forward_to_user))
```
С командой */start* все понятно. Юзер нажал - прислать приветственное сообщение - прислать в чат поддержки о том, что подключился новый юзер ([гит](https://github.com/ohld/telegram-support-bot/blob/main/handlers.py#L6)).
```
def start(update, context):
update.message.reply_text(WELCOME_MESSAGE)
user_info = update.message.from_user.to_dict()
context.bot.send_message(
chat_id=TELEGRAM_SUPPORT_CHAT_ID,
text=f"? Connected {user_info}.",
)
```
В случае пересылки ботом сообщения пользователя из лички в чат поддержки, тоже все просто ([гит](https://github.com/ohld/telegram-support-bot/blob/main/handlers.py#L19)):
```
def forward_to_chat(update, context):
update.message.forward(chat_id=TELEGRAM_SUPPORT_CHAT_ID)
```
В случае отправление ответа (reply) на пересланное сообщение, необходимо скопировать содержимое сообщения и отправить его от лица бота. Если аналогично сделать `.forward`, то будет виден отправитель. А тут как раз недавно в [Telegram Bot API](https://core.telegram.org/bots/api#copymessage) добавили возможность удобно копировать содержимое сообщения ([гит](https://github.com/ohld/telegram-support-bot/blob/main/handlers.py#L30)):
```
def forward_to_user(update, context):
user_id = update.message.reply_to_message.forward_from.id
context.bot.copy_message(
message_id=update.message.message_id,
chat_id=user_id,
from_chat_id=update.message.chat_id
)
```
Бесплатный деплой на Heroku
Чтобы захостить это все бесплатно на Heroku, бот должен быть запущен в режиме **Webhook**, а не Pooling. Разница их в том, что вебхук "слушает новые сообщения от Телеги", а пулинг "периодически запрашивает". Чтобы запрашивать, сервер должен работать постоянно (условно, каждую секунду запрашивать у серверов Телеграмма новые сообщения, которые кто-то написал в бот). Однако, в случае с вебхуками, сервер может просто ждать, когда серверы Телеграмма сами отправят нам новые обновления бота.
Этот факт критически важен, если мы хотим бесплатно пользоваться услугами Heroku (который по факту дает нам свои серверы в аренду). Хероку любит "усыплять" простаивающие машины, которые пробуждаются в момент нового входящего запроса. Именно новые сообщения от серверов Телеграмма и будут пробуждать наш сервер тогда, когда необходимо переслать пользовательское сообщение из лички бота в наш чат поддержки.
Для того, чтобы настроить Webhook, необходимо поднять вебсервер, который будет слушать входящие сообщения по endpoint. Сказать Телеграму: "присылай события бота мне на сервер - по этому адресу". Также нужно как-нибудь защититься от злоумышленников, которые могут отправить на наш вебсервер событие, прикинувшись сервером телеги. Также телеграм требует, чтобы все работало https.
Звучит сложно, однако Heroku автоматически и бесплатно обеспечит https, а вебсервер для вебхука уже встроен в библиотеку `python-telegram-bot`. Если добавить секретный токен вашего бота в URL, по которому вы будете слушать события от Телеги, то можно защититься от стороннего вмешательства.
Вот как можно запустить Телеграм бот в webhook-режиме ([гит](https://github.com/ohld/telegram-support-bot/blob/main/main.py)) через эту библиотеку:
```
# запускаем слушающий вебсервер
updater.start_webhook(
listen="0.0.0.0",
port=PORT, # HEROKU требует, чтобы порт вебсервера задавался через переменные окружения
url_path=TELEGRAM_TOKEN # добавляем секретное значение в адрес, который слушаем
)
# говорим Телеграму: "присылай события бота по этому адресу"
updater.bot.set_webhook(f"https://{HEROKU_APP_NAME}.herokuapp.com/{TELEGRAM_TOKEN}")
updater.idle()
```
Помните, мы отдельно задавали переменную окружения `HEROKU_APP_NAME` , куда копипастили название нашей Heroku App? Дело в том, что эта переменная используется в адресе, по которому Heroku запускает наш вебсервер. Но при этом, имя приложения Хероку нельзя получить изнутри, поэтому решение "скопипастить название App Name в отдельную переменную окружения" для меня звучит норм.
Что дальше?
Допустим, вы запустили бота, у вас уже много клиентов и вы хотите усовершенствовать функционал телеграм бота. Что можно сделать?
Во-первых, можно сохранять список пользователей, которые как-нибудь контактировали с ботом. Это пригодится как для выстраивания воронок, так и для массовой рассылки им сообщения через бота. Во-вторых, можно улучшить сервис со стороны агентов поддержки: в сообщения добавить кнопки с ссылками на CRM, спрашивать у пользователей качество ответа, выводить больше информации о подключенном юзере и запрашивать у них контакты.
---
Спасибо за просмотр. Теперь вы знаете, как можно сделать и бесплатно задеплоить Телеграм бота поддержки. Полный код проекта (вместе с волшебной кнопкой "задеплой это на хероку") лежит [тут](https://github.com/ohld/telegram-support-bot/). В своем [Телеграм канале](https://t.me/danokhlopkov) я делюсь опытом разработки больших телеграм ботов, делюсь датасетами и продуктовой аналитикой. Заходите.
А какие другие популярные юзкейсы Телеграм ботов вы бы выделили? Напишите в комментариях. | https://habr.com/ru/post/539766/ | null | ru | null |
# Постепенно вводим TypeScript в ваш проект на React
Привет, Хабр!
В последнее время в области front-end особую популярность приобретает комбинация React+TypeScript. Соответственно, возрастает актуальность грамотной миграции с JavaScript на TypeScript, желательно в сжатые сроки. Сегодня мы хотели бы обсудить с вами именно эту тему.
Как безопасно собирать и вводить компоненты React TypeScript в ваш проект React JS.
Почему может потребоваться миграция с JS на TS? Причин на то может быть огромное множество, но суть не в этом. (Гипотетический) факт заключается в следующем: вам необходимо приступить к использованию TypeScript, и нужен легкий путь внедрения его в ваш проект. Мало того, все это нужно как-то сделать, не нарушив структуры всего имеющегося кода, и убедив команду в необходимости такого перехода.
Здесь будет продемонстрирован постепенный рефакторинг: **как встраивать компоненты React в другую базу кода, а затем при помощи Bit безопасно вводить их в уже работающее приложение React на JavaScript**.
#### Безопасное встраивание компонентов TS в проект на JS при помощи Bit
Существует множество способов перейти с React JS на React TS. Суть данной статьи – показать, как это делается поступательно. Аналогичный метод применим и в других случаях.
Базовая идея заключается в том, чтобы выжать максимум из компонентов React + при помощи Bit изолировать их друг от друга в собственной среде разработки Bit. В совокупности это позволяет собирать компоненты TS и безопасно вводить их в полнофункциональное приложение React JS.
[Bit](https://github.com/teambit/bit) – это опенсорсный инструмент для извлечения компонентов из репозиториев Git. Bit позволяет собирать компоненты TS вне проекта, написанного на JS, выделяя под каждый автономную изолированную среду разработки, которая может работать и в других проектах, независимо от их конфигураций. Затем вы можете просто версионировать и «бит-импортировать» эти компоненты в ваш проект на JS, и они будут работать.
Наряду с Bit существует [Bit.dev](https://bit.dev) – удаленный хаб, в котором можно хранить эти компоненты, чтобы затем использовать повторно. Мы будем держать в Bit.dev компоненты TS, а оттуда станем вводить их в наш проект на React JS.
*Пример: поиск разделяемых компонентов React в bit.dev*
#### Пример использования
Для целей этой статьи разберем пример, который в мире фронтенда сравним с классическим “hello world”: речь пойдет о приложении для планирования дел.
Не волнуйтесь, я не собираюсь рассказывать вам, как написать такое приложение для React. Предполагаю, вы уже умеете это делать и, будем честны, тема уже далеко не новая, так что увольте.
Но я воспользуюсь вот этим приложением в качестве примера – можете с полным правом делать его форк или, как минимум, откройте ссылку и посмотрите весь его код.
[github.com/deleteman/react-todo-demo](https://github.com/deleteman/react-todo-demo)
Данная база кода состоит из следующих компонентов:
**TodoList**: это главный компонент, отображаемый в форме поля для ввода текста с самой обычной кнопкой. Все находится в форме, после отправки которой текст добавляется в список, поддерживаемый основным приложением. Код этого компонента очень прост:
```
import React, { Component } from 'react'
class TodoList extends Component {
render() {
return (
Add Task
)
}
}
export default TodoList
```
**TodoItems**: очень простой списковый компонент, используемый для вывода внутреннего списка элементов, добавленных через предыдущий компонент. Каждый из элементов кликабелен, и после нажатия на него он удаляется из списка. Код также весьма прост:
```
import React, { Component } from 'react'
class TodoItems extends Component {
createTasks(item) {
return - this.props.deleteItem(item.key)}>{item.text}
}
render() {
const todoEntries = this.props.entries || []
const listItems = todoEntries.map(this.createTasks.bind(this))
return {listItems}
}
}
export default TodoItems
```
В обоих случаях соответствующие методы принимаются как свойства (Props) из главного компонента App. Полный код этого компонента приведен здесь.
Согласен, это приложение очень простое, но, еще раз подчеркну, потенциально на его месте может быть любое приложение React, над которым вы работаете в настоящий момент – и внезапно получаете задачу приступить к миграции на TypeScript. Что же делать?
* Вариант #1: Утерев слезы, начинаете переписывать всю базу исходного кода.
* Вариант #2: Переименовываете все ваши файлы .js в .ts, настраиваете нужные шаги в сборочном процессе и умываете руки.
* Вариант #3: Вы решаете, что действительно пора перейти к постепенной миграции всего старого кода, а весь новый код писать уже непосредственно на TypeScript.
Я хочу подробнее обсудить вариант #3, но, в принципе, не отказываю вам в том, что в одном и том же приложении у вас могут сосуществовать компоненты, написанные как на чистом JavaScript, так и на TypeScript.
#### Вводим TypeScript
Итак, в качестве примера предположим, что нам поручено добавить кнопку-переключатель (toggle) к каждому компоненту в нашем списке дел. После нажатия на элемент его необходимо переключить в фоновом режиме.
Ничего сверхъестественного, но, как вы помните, нас в данном случае интересует процесс, а не код как таковой.
Итак, мы не будем пытаться добавлять TypeScript в уже имеющийся у вас настроенный проект, чтобы случайно не сломать имеющуюся у вас сборку на несколько жней, а создадим совершенно новый проект, воспользовавшись чистым TypeScript:
```
$ npx create-react-app ts-components --template typescript
```
Обратите внимание: для использования npx нужна только новая версия NPM, и она включается в процесс установки в версии [5.2.0](https://github.com/npm/npm/releases/tag/v5.2.0) и выше.
Точно как и ранее, в таком случае создается шаблон для проекта, но на этот раз в качестве базового языка мы используем TypeScript.
Плюс простой компонент-переключатель, пригодный для вставки в другой проект, не привнося при этом дополнительных зависимостей. Если вам интересно, как это делается, почитайте следующую статью о том, как писать [компоненты для многократного использования](https://blog.bitsrc.io/cross-repo-collaboration-with-reusable-react-components-abbb94179ab4).
```
import React, {useState} from 'react';
interface IActionProps {
action: (status:boolean) => void,
buttonText?: string
}
const Toggle = ({action, buttonText="Toggle"}: IActionProps) => {
const [isSelected, setSelected] = useState(false)
return (
{
setSelected(!isSelected)
action(isSelected)
}} >{buttonText}
)
}
export default Toggle
```
Теперь, когда этот компонент написан, можно воспользоваться Bit (это опенсорсный инструмент для версионирования и публикации отдельных компонентов), чтобы извлечь данный конкретный компонент и поделиться им, чтобы впоследствии его можно было импортировать из нашего проекта, основанного на JavaScript.
```
// Устанавливаем Bit и инициализируем рабочее пространство в директории проекта
$ yarn global add bit-bin
$ bit init --package-manager yarn// входим в систему (после того, как создадим аккаует и коллекцию в bit.dev)
$ bit login// добавляем все компоненты
$ bit add src/components/Toggle.tsx // конфигурируем компоненты (чтобы открепить компоненты от env)
$ bit import bit.envs/compilers/react-typescript --compiler// тегируем и экспортируем
$ bit tag –all
```
Так вы сконфигурируете ваш проект и настроите в нем новый компонент Toggle (переключатель) таким образом, чтобы его можно было разделять с другими проектами. Но, прежде, чем сможете сделать это на практике, вам необходимо залогиниться в Bit.dev (это хаб компонентов — сайт с реестром и документацией, дополняющий Bit в качестве площадки для публикации и предварительного просмотра компонентов).
Войдя в систему, просто создайте новую коллекцию под названием “toggler”, сделайте ее публичной, а затем в окне терминала выполните следующую команду:
```
$ bit export user-name.toggler
```
Если “user-name” – действительно ваше имя пользователя, то в результате будет экспортирован компонент, и вы сможете увидеть его на Bit.dev. Он должен будет выглядеть примерно так:
Обратите внимание, как по умолчанию программа создает образец файла `index.js`, чтобы протестировать компонент. При этом, содержимое, записываемое в этот файл по умолчанию, может оказаться неидеальным, поэтому платформа позволяет с легкостью добавлять в него дополнительный код, благодаря которому другим станет понятно, как использовать ваш публичный компонент в своем коде.
Например, здесь я обновил мой файл-образец, добавив пояснения о том, как использовать компонент [Toggler](https://bit.dev/deleteman/toggler/toggle?example=5e37fe2839af2a001a29fd72) (только не забудьте нажать кнопку “Save”, когда закончите!):
Теперь давайте рассмотрим, как импортировать этот новый компонент в ваше собственное React-приложение на основе JS.
#### Импорт внешнего компонента
Bit берет на себя компиляцию вашего кода TypeScript в JavaScript благодаря добавленному нами компилятору. Это решает все наши проблемы, и все, что нам осталось – добавить этот компонент в ваш проект в качестве зависимости.
Для всех целей я использовал здесь Yarn, но вы с тем же успехом могли бы воспользоваться NPM, все, что для этого нужно:
```
$ yarn add @bit/your-username.your-collection.your-component
```
В моем случае этот код превращается в:
```
$ yarn add @bit/deleteman.toggler.toggle
```
Обратите внимание: **вы не сможете устанавливать компоненты, не войдя в систему** (помните часть о `$ bit login` в этом руководстве?). Если вы хотели бы установить компоненты из реестра Bit, то нужно сконфигурировать реестр вручную, вот так:
```
$ npm config set '@bit:registry' https://node.bit.dev
```
Таким образом ваш компонент TypeScript (уже скомпилированный в JavaScript) включится в проект, и вы сможете ссылаться на этот компонент их вашего кода следующим образом:
```
import React, { Component, useState } from 'react'
import Toggle from '@bit/deleteman.toggler.toggle';
const TodoItem = ({text, itemKey}) => {
const [iClass, setIClass] = useState("white")
const toggleBackground = status => {
setIClass(status ? "white" : "black")
}
const toggleProps = {
action: toggleBackground,
buttonText: "Select"
}
return - {text}
}
export default TodoItem
```
Обратите внимание на строку 2, где я импортирую внешний компонент, который собираюсь использовать в составе оператора возврата. Ничего сложного, не требуется вносить никаких дополнительных конфигурационных изменений ни в вашем проекте, ни где бы то ни было.
Поздравляю, теперь у вас есть рабочий проект, в котором используется как TypeScript, так и JavaScript, потенциально этого можно было сделать так, что вы бы этого даже не заметили!
Как я уже упоминал выше, [полный код проекта выложен на GitHub](https://github.com/deleteman/react-todo-demo)!
#### Заключение
Если вас интересует миграция на TypeScript, либо вы просто хотите с ней поэкспериментировать и посмотреть, как она сработает, то именно таким образом удобно постепенно вводить язык в существующий проект, не рискуя обрушить весь процесс сборки.
Уделите внимание Bit и посмотрите Bit.dev, найдите там другие компоненты, написанные одновременно на JavaScript и TypeScript, чтобы понять, как их пишут другие! | https://habr.com/ru/post/504384/ | null | ru | null |
# Когда-то я внедрял ClickHouse в стартапе, где даже алерты мониторили индийцы — это был Дикий Запад
Однажды я работал дата-инженером в стартапе. Он быстро рос и в какой-то момент решился на покупку одной крупной компании. Там было больше сотни сотрудников — оказалось, почти все из Индии. Пока наши разработчики возились с экзотическим кодом, не поддающимся расшифровке с наскока, мое внимание привлек индийский отдел мониторинга.
Чтобы мониторить сеть и сервера, можно использовать самый разный софт. Главное — быть уверенным: если что-то пойдет не так, то сработает алерт. Вы увидите уведомление и успеете все починить. У них же было свое представление о мониторинге. Представьте, несколько комнат со столами, стульями и огромными плазмами на стенах, внутри сидят почти два десятка человек. На каждый монитор выведены разноцветные графики и рядом приклеены бумажки с номерами телефонов.
Работа этих двадцати людей заключалась в том, чтобы сидеть и смотреть на графики, а если линия вдруг окажется выше приклеенного рядом стикера — звонить по номеру телефона, который там написан, и бить тревогу. Вот они сидели и не отрываясь следили.
Покупка компании обошлась недорого, но содержание такой инфраструктуры стоило заоблачных денег. Индусы использовали дорогущую Vertica, где, кроме оплаты железа, нужно было еще отстегивать за лицензию. Мы решили попробовать переезд на ClickHouse. Это практически бесплатный аналог Vertica. Оба продукта работают по схожему принципу: колоночное СУБД с шардированием, с партиционированием данных.
И это было то еще приключение.
---
### Киллер-фича ClickHouse — конечно, экономия денег
Как раз то, что нам было нужно. ClickHouse умеет писать миллионы ивентов в секунду и также быстро читать. Если правильно организовать агрегационную таблицу в ClickHouse, она будет выполняться за минуту, когда в классических агрегационных базах (например, PostgreSQL) запрос выполняется час.
Я загорелся ClickHouse на одном кейсе, когда провел тест на сжатие с новенькими кодеками: тот же DoubleDelta ужал наши полуслучайные последовательности в пять раз! И ClickHouse не смущает количество данных, если подобрать правильный ключ сортировки и степень детализации индекса в настройках MergeTree.
В результате увидел, что данные, которые на HDFS занимали гигабайты, в ClickHouse уместились в 700 с хвостиком мегабайт, а скорость запросов по ним была на порядок выше. Особенно, когда получается удачно переписать стандартный «хакерский» SQL-запрос на тыщу строк во что-то максимально понятное ClickHouse, с использованием корректных встроенных функций, массивов, агрегатов и других подходящих альтернатив.
Но в то время у инструмента был большой минус — высокий порог вхождения. Результат комбинации маленького на тот момент комьюнити, не сильно выходящего за пределы СНГ, фундаментальных отличий ClickHouse от «обычных» СУБД и невнятной документации. Приходилось проводить личные опыты: грузить в него TSBS и экспериментировать с функциями, разными версиями, настройками движков и так далее — доходило даже до флагов компиляции. Драйвер существовал для галочки — он использовал http-протоколы ненативно, просто обертка над Rest клиентом.
ClickHouse постепенно допиливался, было много багов, не хватало множества критических фич, альтернативами удобнее пользоваться и легче поддерживать, но они все обходятся в разы дороже. Кликхаус опенсорсный и мощный, но в нем не разберешься без стакана. Он похож на стереотипную русскую вещь — неидеальный, шероховатый, дешевый. Но сжатие и скорость работы все перекрывают.
---
### Как построить бэкенд так, чтобы ничего не падало, не сжирало тонну денег, могло хранить и обеспечивать доступ к отчетам?
При условии, что есть миллиарды строк данных, терабайты, километры.
Компания занималась монетизацией пираток. Человек пиратил андроид-приложение, не платил за него, но видел рекламу. Для того, чтобы посчитать клиента по биллингу, посмотреть, сколько он накликал рекламы, компания начала собирать статистику. До моего прихода там были написаны собственное SDK и бэкенд. PHP принимал JSON ивент, его парсили и писали в MySQL. Никаких пулов соединений не было, пришел ивент — открыли и записали.
Когда нагрузка стала расти (несколько тысяч событий в секунду), эта система перестала вывозить. Бэкенд-разработчик узнал про Hadoop, HDFS и решил его применить. Собрали кластер из нескольких машин. Идея была такой: просто пишем JSON-файлы, запихиваем в Hive. И вот уже все считается и работает.
Когда ребята начали мигрировать биллинг на Hive, поняли, что у них резко вырос чек за кластер. Все хранилось в виде несжатых JSON-файлов. К тому же HDFS и Hadoop не были заточены на риал-тайм вычисления. Приходилось планировать любую джобу заранее. Ставили на всю ночь, утром видели результат в виде огромной кучи неструктурированных данных, которые лежат прямо в тексте. И все это за деньги! Скорость никакая, запрос делать долго, на выходе — свалка. Это никого не устраивало.Когда я начал выяснять, как устроена текущая архитектура проекта, то оказалось, что Spark используется в автономном режиме на нескольких узлах, что выглядело подозрительным и специфичным. Разобравшись в скрипте запуска, я понял, что текущие настройки приводили к тому, что узлы грузились на все двести, а RDD все равно читались в один поток.
После некоторого разбирательства я выяснил, что это было сделано не из-за каких-то архитектурных ограничений. Тот же относительно большой HDFS был корректно настроен как кластер, с резервированием — нареканий по этой части инфраструктуры и железа не было.
Тем не менее, при правильном распараллеливании джобы на выходе получались не совсем корректные данные. Документация по коду, как это традиционно в наших краях, была устаревшая, поэтому пришлось максимально сосредоточиться, чтобы эффективно раскурить текущие исходники на Java, понять желаемую бизнес-логику и починить багу. В итоге получилось совершенно новое приложение на Scala, которое работало настолько лучше, что отдел инфраструктуры смог спланировать снижение стоимости поддержки бэкенда в тысячи долларов!
И наконец мы начали добавлять запись в ClickHouse. Исходный код сервера будет достаточно понятным любому, кто знает C++. Он также иногда покрыт тестами, а если и нет, то зачастую можно найти тест, реализующий схожий кейс. Так что в итоге у нас появился свой отказоустойчивый драйвер на Scala, работавший по TCP, в бинарном Native формате, учитывающий конфигурацию кластера и позволявший нам максимально эффективно писать в несколько потоков.
Я решил еще доработать бэкенд и рискнул — убрал HDFS. Поставил нормальный кластер Kafka, бэкенд стал писать в нее, из Kafka все читалось консьюмером и писалось в ClickHouse. При этом я не исключил кластер HDFS из схемы совсем, сделав из него подобие бэкапа: данные залетали и в урезанный HDFS тоже.
В какой-то момент встала задача переводить все остальные сервисы и отчеты на работу с ClickHouse. Большинство было переведено в процессе создания нового приложения, но оставалось еще много работы касательно того, куда эти данные планировалось в дальнейшем интегрировать.
### Но главная проблема оказалась не в самом ClickHouse — а в том, что никто не мог сходу в нем разобраться
Если для того, чтобы научиться эффективно писать в ClickHouse и создать production-ready сервис, достаточно было только моих вложений, то с запросами и, в целом, с полноценным использованием DWH ситуация обстояла несколько иначе.
По опыту получалось, что задачи, которые отдел аналитики и разработчики раньше могли решить «с наскока» в каком-нибудь Hive или MySQL, в ClickHouse так сходу не решались – где-то функцию надо использовать, где-то JOIN из-за дистрибуции данных некорректный и т.д.
И хорошо еще, если разработчик заподозрил неладное с запросом и обратился, если не к документации, то хотя бы в чат. Но бывало и так, что ошибки при переносе оставались скрытыми. В таких случаях все выяснялось уже тогда, когда было слишком поздно – данные либо попадали в отчеты, либо так или иначе светились в клиентских кабинетах.
Конечно, такое можно сказать про любые относительно молодые технологии. Но в нашем случае также были баги, когда по документации и отзывам запрос должен работать, а он приводил к падению сервера или некорректному результату.
Например, можно вспомнить раннюю поддержку UUID, когда запрос вида:
```
```
SELECT * FROM db PREWHERE uuid != '00000000-0000-0000-0000-000000000000'
```
```
Приводил к segfault.
Или когда можно было случайно потерять данные в процессе дедупликации реплицированных партиций. Уникальных случаев у комьюнити наберется ого-го! Поэтому получается, что иногда даже полезнее и достаточно искать свою проблему именно в GitHub, в Issues, по ключевым словам.
---
### А потом оказалось, что данные из ClickHouse слишком трудно визуализировать
Тот же Hive предлагал инструменты, которые позволяли писать запросы и делать визуализацию. Поначалу мы использовали Tabix. Это довольно примитивный клиент, он ходит напрямую в ClickHouse и отображает в браузере результат в виде таблички и простых графиков. Но в итоге взяли инструмент поинтереснее. Redash как раз выкатил бета-версию поддержки ClickHouse.
Параллельно у нас появилась часть данных на базе Redshift. В какой-то момент компания предложила брать данные из ClickHouse и перекладывать в Redshift (который, по сути, обычный SQL и можно использовать инструменты желанной визуализации). Но идея отпала сама собой — я просто посчитал, сколько будет стоить кластер Redshift, который поддержит такой поток данных с ClickHouse. Мы тратили около тысячи долларов, если бы заморочились с Redshift — платили бы все 30 тысяч. Поэтому продолжили работать с ClickHouse через Redash.
Но все пошло прахом, когда мы решили прикрутить к ClickHouse Tableau и в итоге влетели на 70 тысяч долларов!
Tableau — это известная визуализация для баз данных. Когда мы решили это провернуть, официальной поддержки ClickHouse там не было. Зато у них была поддержка PostgreSQL. Какой-то безумец подсказал, что в PostgreSQL можно писать кастомные скрипты и протоколы форвардинга. Через питоний скрипт скрестить ClickHouse и PostgreSQL и добиться визуализации в Tableau! Это была очередная провальная идея. Данные шли только с PostgreSQL. Смысла в этом не было никакого.
Но наш аналитик настаивал. Ему нравился Tableau — красивый, понятный, никаких тебе запросов SQL делать не надо, все кнопочками. И нам его все же купили. Потратили около 70 штук и принялись танцевать с бубном вокруг покупки.
Мы даже созвонились с продажниками из Tableau и убеждали их подружить свой продукт с новейшей российской технологией. Уже тогда было понятно, что ClickHouse потихоньку завоюет весь мир. Они лишь вежливо выслушали нас. Что забавно, недавно Tableau сделал кое-какую поддержку драйвера для ClickHouse. Не прошло и двух лет!
Перевести отчеты с Redash на Tableau у нас так и не получилось — деньги улетели на ветер. Хорошо, что к тому моменту часть сотрудников освоила ClickHouse — я потихоньку всех обучал. Оказалось, что он удобен для андроид-разработчиков и предлагает даже больше возможностей, чем красавчик Tableau.
---
Самая большая проблема ClickHouse — в нем никто не шарит. Там много подводных камней, которые нигде не описаны. Хорошая технология с плохой документацией.
Потребность в использовании есть, но разбираться, как это работает — времени нет. Поэтому и случаются разные казусы, вроде целых компаний, которые зарабатывают на консалтинге по ClickHouse.
Сейчас он стал сильно проще, но это по-прежнему не тот продукт, которым можно пользоваться сразу из коробки. Зато когда он таким станет — всяким Vertica и Redshift можно будет сворачивать свой бизнес. | https://habr.com/ru/post/537138/ | null | ru | null |
# JupyterHub или как перестать бояться pip install
### …или рассказ о self service на JupyterHub для дата саентистов
Всем привет, сегодня я расскажу о том, как мы переехали на наш велосипед в виде JupyterHub, и он оказался удобным. У нас в компании работают ~20 дата саентистов и в своей работе они используют множество Open Source-инструментов: Airflow, Hadoop, Hive, Spark и т.д. Но в данной статье речь пойдет исключительно о JupyterHub, точнее говоря о боли, которая преследовала администраторов, и как мы успешно ее побороли.
Почему мы выбрали JupyterHub
----------------------------
[JupyterHub](https://jupyter.org/hub) — это тот же Jupyter, только ставится он на отдельный сервер и работает как клиент-серверное веб-приложение.
Преимущества тут очевидны:
* Вам не нужно беспокоиться об установке Jupyter’а и его окружения;
* Не тратятся локальные ресурсы на вычисления;
* Серверные мощности обычно выше локальных.
Но есть и недостатки:
* Ресурсы сервера делятся на всех пользователей. По сути кто первый – того и тапки;
* Одна среда на всех: вы будете пользоваться только тем ПО, которое установлено на сервере.
* Обновление через боль. Установка нового ПО или обновление существующего требует согласования со **всеми** пользователями JupyterHub’а.
*Просто представьте насколько задача усложнится, если на ваших серверах нет интернета. А политика безопасности настолько забюрократизирована, что процедура установки ПО будет съедать всё ваше время.*
В игру вступает Kernel
----------------------
Частично вышеописанные проблемы решаются с помощью kernel’ов — виртуальных сред (venv). Вы устанавливаете в них необходимые пакеты, затем переносите их на JupyterHub, после чего данное ядро становится доступным для выбора в интерфейсе лэптопа. А весь код, написанный на лэптопе, будет работать именно в этом окружении.
Но на практике оказалось, что kernel’ы оказались еще бо́льшей бедой: их также необходимо поддерживать и регулярно обновлять, плюс со временем они обрастали зависимостями и legacy-кодом. А до бесконечности создавать новые kernel’ы невозможно.
Все это вызывало негатив со всех сторон: дата саентисты не могли получить своевременный доступ к нужному ПО. А администраторам приходилось постоянно что-то досогласовывать, устанавливать и переустанавливать. Так продолжать мы не могли, поэтому мы решили оптимизировать работу дата саентистов.
Что придумали
-------------
Чтобы избавить саентистов (и админов) от боли, мы поставили перед собой следующие цели:
1. Установить/обновить любое ПО можно без привлечения администраторов;
2. Установить/обновить ПО можно в любой момент;
3. Установленное одним пользователем ПО не должно влиять на работу остальных пользователей;
4. Установленное ПО не должно негативно влиять на сервер в целом.
После исследования мы решили использовать связку Jupyterhub + Docker, а kernel’ы собирать в GitLab CICD, чтобы затем доставлять их на сервера Jupyterhub.
Схема работыСхема работы следующая: для каждого пользователя в GitLab создана отдельная папка и, когда пользователю необходимо создать новый kernel, он:
1. Создает в своей папке новый проект (папку);
2. Создает файл requirements.json и описывает в нем:
2.1 Название kernel’а
2.2 Имя docker-образа (скачивается из DockerHub’а, либо с нашего локального репозитория, где хранятся наши кастомные образы).
2.3 Python-библиотеки для установки и их версии
3. В случае необходимости редактирует Dockerfile;
4. Запускает CICD-процесс, в котором:
4.1 Собирается ядро;
4.2 Выполняются команды из Dockerfile.
4.3 Устанавливаются библиотеки из requirements.json.
4.4 Ядро копируется на сервер JupyterHub.
Новое ядро сразу становится доступными для работы в JupyterHub’е. А в случае необходимости дата саентист самостоятельно правит параметры своего ядра и пересобирает его.
Что это нам дало
----------------
Теперь большая часть работы выполняется дата саентистами без привлечения администраторов. После 10 тысяч сборок kernel’ов мы сэкономили массу времени на процедурах согласований и самой установке.
Эффективность обоих сторон увеличилась, а админы привлекаются крайне редко —только для решения сложных вопросов. Цели 1 и 2 выполнены.
Доступ в интернет для скачивания библиотек мы реализовали посредством прокси-сервера, с которого разрешено обращаться только к репозиторию pip. Все ПО работает исключительно внутри контейнера. Что бы там не произошло — это никак не повлияет на работу других пользователей. Так мы закрыли вопрос с целями 3 и 4.
А теперь пара технических моментов:
Пример конфига ядра
-------------------
kernel.json
```
{
"argv": [
"/usr/bin/docker",
"run",
"--network=host",
"--rm",
"-v",
"{connection_file}:/connection-spec",
"-v",
"/home/anikishin/work:/root/work",
"************/docker/registry/anikishin_dataflow:latest",
"python",
"-m",
"ipykernel_launcher",
"-f",
"/connection-spec"
],
"display_name": "anikishin_dataflow",
"language": "python",
"env": {}
}
```
Использование --network=host объясняется тем, что во время работы pyspark на машине открывается случайный порт и кластер Hadoop должен иметь доступ к клиенту.
Пример сборки ядра
```
$ LOGIN=`echo "${GITLAB_USER_LOGIN}" | awk '{print tolower($0)}'`
$ echo -e "export PATH_TO_KERNEL=/${LOGIN}/${KERNEL}\nLOGIN=${LOGIN}\nKERNEL=${KERNEL}" >.env
$ source ./.env
$ PYTHON_VERSION=`/bin/python3 ${CI_PROJECT_DIR}/parser.py ${CI_PROJECT_DIR}/${PATH_TO_KERNEL}/requirements.json python_version`
$ sed "s/PYTHON_VERSION/${PYTHON_VERSION}/g" ${CI_PROJECT_DIR}/${PATH_TO_KERNEL}/Dockerfile
FROM python:3.8-slim
WORKDIR /root/work
COPY requirements.txt /tmp/requirements.txt
RUN pip install --upgrade -r /tmp/requirements.txt$ sed -i "s/PYTHON_VERSION/${PYTHON_VERSION}/g" ${CI_PROJECT_DIR}/${PATH_TO_KERNEL}/Dockerfile
$ /bin/python3 ${CI_PROJECT_DIR}/parser.py ${CI_PROJECT_DIR}/${PATH_TO_KERNEL}/requirements.json libs > ${CI_PROJECT_DIR}/${PATH_TO_KERNEL}/requirements.txt
$ echo "IMAGE_NAME=`/bin/python3 ${CI_PROJECT_DIR}/parser.py ${CI_PROJECT_DIR}/${PATH_TO_KERNEL}/requirements.json image_name`" >> ./.env
$ echo "IMAGE_VERSION=`/bin/python3 ${CI_PROJECT_DIR}/parser.py ${CI_PROJECT_DIR}/${PATH_TO_KERNEL}/requirements.json image_version`" >> ./.env
$ source ./.env
$ docker build --no-cache -t ************:5005/docker/registry/${LOGIN}_${IMAGE_NAME}:${IMAGE_VERSION} ${CI_PROJECT_DIR}/${PATH_TO_KERNEL}/
Step 1/4 : FROM python:3.8-slim
3.8-slim: Pulling from library/python
42c077c10790: Already exists
f63e77b7563a: Pulling fs layer
5215613c2da8: Pulling fs layer
9ca2d4523a14: Pulling fs layer
e97cee5830c4: Pulling fs layer
e97cee5830c4: Waiting
9ca2d4523a14: Verifying Checksum
9ca2d4523a14: Download complete
f63e77b7563a: Verifying Checksum
f63e77b7563a: Download complete
5215613c2da8: Verifying Checksum
5215613c2da8: Download complete
f63e77b7563a: Pull complete
5215613c2da8: Pull complete
9ca2d4523a14: Pull complete
e97cee5830c4: Verifying Checksum
e97cee5830c4: Download complete
e97cee5830c4: Pull complete
Digest: sha256:0e07cc072353e6b10de910d8acffa020a42467112ae6610aa90d6a3c56a74911
Status: Downloaded newer image for python:3.8-slim
---> 61c56c60bb49
Step 2/4 : WORKDIR /root/work
---> Running in 4baf6a21fb37
Removing intermediate container 4baf6a21fb37
---> 0f5165f4c567
Step 3/4 : COPY requirements.txt /tmp/requirements.txt
---> 40490bed96d2
Step 4/4 : RUN pip install --upgrade -r /tmp/requirements.txt
---> Running in a79389decbc4
Collecting ipykernel
Downloading ipykernel-6.13.1-py3-none-any.whl (133 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 133.2/133.2 KB 1.4 MB/s eta 0:00:00
Collecting ipython
Downloading ipython-8.4.0-py3-none-any.whl (750 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 750.8/750.8 KB 7.4 MB/s eta 0:00:00
Collecting numpy
Downloading numpy-1.22.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (16.9 MB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 16.9/16.9 MB 50.1 MB/s eta 0:00:00
Collecting psutil
Downloading psutil-5.9.1-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (284 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 284.7/284.7 KB 24.1 MB/s eta 0:00:00
Collecting tornado>=6.1
Downloading tornado-6.1-cp38-cp38-manylinux2010_x86_64.whl (427 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 427.5/427.5 KB 38.0 MB/s eta 0:00:00
Collecting packaging
Downloading packaging-21.3-py3-none-any.whl (40 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 40.8/40.8 KB 5.0 MB/s eta 0:00:00
Collecting matplotlib-inline>=0.1
Downloading matplotlib_inline-0.1.3-py3-none-any.whl (8.2 kB)
Collecting nest-asyncio
Downloading nest_asyncio-1.5.5-py3-none-any.whl (5.2 kB)
Collecting debugpy>=1.0
Downloading debugpy-1.6.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl (1.8 MB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 1.8/1.8 MB 71.2 MB/s eta 0:00:00
Collecting traitlets>=5.1.0
Downloading traitlets-5.2.2.post1-py3-none-any.whl (106 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 106.8/106.8 KB 18.8 MB/s eta 0:00:00
Collecting jupyter-client>=6.1.12
Downloading jupyter_client-7.3.3-py3-none-any.whl (131 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 132.0/132.0 KB 18.9 MB/s eta 0:00:00
Collecting pygments>=2.4.0
Downloading Pygments-2.12.0-py3-none-any.whl (1.1 MB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 1.1/1.1 MB 68.7 MB/s eta 0:00:00
Collecting backcall
Downloading backcall-0.2.0-py2.py3-none-any.whl (11 kB)
Collecting pickleshare
Downloading pickleshare-0.7.5-py2.py3-none-any.whl (6.9 kB)
Collecting prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0
Downloading prompt_toolkit-3.0.29-py3-none-any.whl (381 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 381.5/381.5 KB 41.8 MB/s eta 0:00:00
Collecting pexpect>4.3
Downloading pexpect-4.8.0-py2.py3-none-any.whl (59 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 59.0/59.0 KB 12.4 MB/s eta 0:00:00
Collecting decorator
Downloading decorator-5.1.1-py3-none-any.whl (9.1 kB)
Collecting jedi>=0.16
Downloading jedi-0.18.1-py2.py3-none-any.whl (1.6 MB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 1.6/1.6 MB 82.1 MB/s eta 0:00:00
Requirement already satisfied: setuptools>=18.5 in /usr/local/lib/python3.8/site-packages (from ipython->-r /tmp/requirements.txt (line 2)) (57.5.0)
Collecting stack-data
Downloading stack_data-0.2.0-py3-none-any.whl (21 kB)
Collecting parso<0.9.0,>=0.8.0
Downloading parso-0.8.3-py2.py3-none-any.whl (100 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 100.8/100.8 KB 23.1 MB/s eta 0:00:00
Collecting python-dateutil>=2.8.2
Downloading python_dateutil-2.8.2-py2.py3-none-any.whl (247 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 247.7/247.7 KB 36.0 MB/s eta 0:00:00
Collecting jupyter-core>=4.9.2
Downloading jupyter_core-4.10.0-py3-none-any.whl (87 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 87.3/87.3 KB 21.7 MB/s eta 0:00:00
Collecting entrypoints
Downloading entrypoints-0.4-py3-none-any.whl (5.3 kB)
Collecting pyzmq>=23.0
Downloading pyzmq-23.1.0-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (1.1 MB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 1.1/1.1 MB 68.4 MB/s eta 0:00:00
Collecting ptyprocess>=0.5
Downloading ptyprocess-0.7.0-py2.py3-none-any.whl (13 kB)
Collecting wcwidth
Downloading wcwidth-0.2.5-py2.py3-none-any.whl (30 kB)
Collecting pyparsing!=3.0.5,>=2.0.2
Downloading pyparsing-3.0.9-py3-none-any.whl (98 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 98.3/98.3 KB 19.7 MB/s eta 0:00:00
Collecting executing
Downloading executing-0.8.3-py2.py3-none-any.whl (16 kB)
Collecting asttokens
Downloading asttokens-2.0.5-py2.py3-none-any.whl (20 kB)
Collecting pure-eval
Downloading pure_eval-0.2.2-py3-none-any.whl (11 kB)
Collecting six>=1.5
Downloading six-1.16.0-py2.py3-none-any.whl (11 kB)
Installing collected packages: wcwidth, pure-eval, ptyprocess, pickleshare, executing, backcall, traitlets, tornado, six, pyzmq, pyparsing, pygments, psutil, prompt-toolkit, pexpect, parso, numpy, nest-asyncio, entrypoints, decorator, debugpy, python-dateutil, packaging, matplotlib-inline, jupyter-core, jedi, asttokens, stack-data, jupyter-client, ipython, ipykernel
Successfully installed asttokens-2.0.5 backcall-0.2.0 debugpy-1.6.0 decorator-5.1.1 entrypoints-0.4 executing-0.8.3 ipykernel-6.13.1 ipython-8.4.0 jedi-0.18.1 jupyter-client-7.3.3 jupyter-core-4.10.0 matplotlib-inline-0.1.3 nest-asyncio-1.5.5 numpy-1.22.4 packaging-21.3 parso-0.8.3 pexpect-4.8.0 pickleshare-0.7.5 prompt-toolkit-3.0.29 psutil-5.9.1 ptyprocess-0.7.0 pure-eval-0.2.2 pygments-2.12.0 pyparsing-3.0.9 python-dateutil-2.8.2 pyzmq-23.1.0 six-1.16.0 stack-data-0.2.0 tornado-6.1 traitlets-5.2.2.post1 wcwidth-0.2.5
WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv
WARNING: You are using pip version 22.0.4; however, version 22.1.2 is available.
You should consider upgrading via the '/usr/local/bin/python -m pip install --upgrade pip' command.
Removing intermediate container a79389decbc4
---> 942cfb92669c
Successfully built 942cfb92669c
Successfully tagged ************:5005/docker/registry/anikishin_proj3:latest
$ docker push ************:5005/docker/registry/${LOGIN}_${IMAGE_NAME}:${IMAGE_VERSION}
The push refers to repository [************:5005/docker/registry/anikishin_proj3]
ca238036b879: Preparing
5083b2b128f1: Preparing
92487648c84b: Preparing
9df5b2f53554: Preparing
590db2877d9d: Preparing
3d5419adeeb6: Preparing
2c9f341968bc: Preparing
ad6562704f37: Preparing
2c9f341968bc: Waiting
3d5419adeeb6: Waiting
ad6562704f37: Waiting
92487648c84b: Pushed
5083b2b128f1: Pushed
590db2877d9d: Pushed
2c9f341968bc: Pushed
9df5b2f53554: Pushed
3d5419adeeb6: Pushed
ca238036b879: Pushed
latest: digest: sha256:bc36a9bcc6be914a9b7f8ee6ea6c940409f32c57a528c521651442235309239a size: 1996
Running after_script
00:00
Saving cache
00:00
Uploading artifacts for successful job
00:00
Uploading artifacts...
Runtime platform arch=amd64 os=linux pid=27359 revision=c5874a4b version=12.10.2
./.env: found 1 matching files
Uploading artifacts to coordinator... ok id=38302 responseStatus=201 Created token=************
Job succeeded
```
Какие проблемы могут возникнуть
-------------------------------
У нас все получилось не сразу. По пути возникали проблемы, из-за которых мы не смогли быстро перейти на новую схему:
#### 1. Нет онбординга
Понадобилось некоторое время на обучение дата саентистов работе с докер-образами;
Изначально у коллег не было понимания, что данные в контейнере не сохранятся если их не писать в специальную директорию. Плюс ваши дата саентисты должны знать, что простого pip install может оказаться недостаточно: в контейнере должны быть установлены дополнительные зависимости, если этого требует Python-модуль.
Решение: сделайте инструкцию, проводите онбординг новых сотрудников, помогайте в случае проблем со сборкой кернелов.
#### 2. Сохранность данных
Поскольку kernel’ы работают в докер-образах, то их перезагрузка приводит к потере всех сохраненных данных.
Решение: создайте отдельную общую папку на сервере, которая монтируется к докер-образу и в которую сохраняются все необходимые дата саентисту артефакты.
#### 3. Ограничение ресурсов
Без лимитов и рычагов один дата саентист может навалить такую нагрузку, что другие не смогут нормально работать:
Это один контейнер с kernel.
И так может случиться не один раз
Решение: мониторьте нагрузку по CPU\RAM. Когда получаете алерт определяйте кто грузит машину и ~~идите наказывать виновника~~ попросите коллегу сбавить обороты.
#### 4. Версионность
Как мы пришли к тегу #latest: изначально мы планировали версионировать все создаваемые докер-образы. Но дата саентисты стали делать такое множество версий своих образов, что в результате место в Docker registry быстро закончилось.
Решение: используйте версионность только для продуктивных процессов.
Планы на развитие
-----------------
Резюмируя: мы получили современное решение, дата саентисты больше не дергают админов, они рады что могут самостоятельно править свои kernel в любое время, не прибегая к помощи со стороны.
Сейчас мы думаем о том, как реализовать удобное и гибкое ограничение ресурсов для контейнеров. Если у вас есть идеи как это сделать — напишите в комментариях. | https://habr.com/ru/post/689596/ | null | ru | null |
# Решаем задачу Best Reverser с PHDays 9
Здравствуйте!
Меня зовут Марат Гаянов, я хочу поделиться с вами моим решением задачи с конкурса [Best Reverser](https://www.phdays.com/ru/program/contests/best-reverser/), показать, как сделать кейген для этого кейса.
Описание
--------
В этом конкурсе участникам предоставляется ROM игры для Sega Mega Drive ([best\_reverser\_phd9\_rom\_v4.bin](https://www.phdays.com/upload/ru/program/contests/best_reverser_phd9_rom_v4.bin)).
Задача: подобрать такой ключ, который в паре с email-адресом участника будет признан валидным.
Итак, решение…
Инструменты
-----------
* IDA Pro 6.8
* [Плагин smd\_ida\_tools](https://github.com/lab313ru/smd_ida_tools)
Проверка длины ключа
--------------------
Программа принимает не всякий ключ: нужно заполнить поле целиком, это 16 символов. Если ключ короче, то вы увидите сообщение: «Wrong length! Try again…».
Попробуем найти эту строчку в программе, для чего воспользуемся бинарным поиском(Alt-B). Что мы найдем?
Найдем не только эту, но и рядом остальные служебные строки: «Wrong key! Try again…» и «YOU ARE THE BEST REVERSER!».
Ярлыки `WRONG_LENGTH_MSG`, `YOU_ARE_THE_BEST_MSG` и `WRONG_KEY_MSG` поставил я, чтобы было удобно.
Поставим брейк на чтение адреса `0x0000FDFA` — выясним, кто работает с сообщением «Wrong length! Try again…». И запустим отладчик(он несколько раз остановится еще до того как можно будет вводить ключ, просто жмем F9 на каждой остановке). Вводим свой email, ключ `ABCD`.
Отладчик приводит на `0x00006FF0 tst.b (a1)+`:
Ничего интересного в самом блоке нет. Гораздо интереснее, кто передает управление сюда. Смотрим колл стэк:
Жмем и попадем сюда — на инструкцию `0x00001D2A jsr (sub_6FC0).l`:
Видим, что все возможные сообщения нашлись в одном месте. Но давайте узнаем, откуда передается управление в блок `WRONG_KEY_LEN_CASE_1D1C`. Не будем ставить брейки, просто наведем курсор на стрелку, идущую к блоку. Вызывающий расположился на адресе `0x000017DE loc_17DE`(который я переименую в `CHECK_KEY_LEN`):
Поставим брейк на адрес `0x000017EC cmpi.b 0x20 (a0, d0.l)`(инструкция в этом контексте смотрит, нет ли пустого символа в конце массива символов ключа), перезапустимся, снова введем почту и ключ `ABCD`. Отладчик останавливается и показывает, что по адресу `0x00FF01C7`(хранящемуся в этот момент в регистре `a0`) находится введенный ключ:
Это хорошая находка, через нее мы выцепим вообще все. Но сначала разметим байты ключа для удобства:
Прокрутив вверх с этого места, увидим что почта хранится рядом с ключом:
Мы погружаемся все глубже и глубже, и пришло время найти критерий правильности ключа. Вернее, первой половины ключа.
Критерий правильности первой половины ключа
-------------------------------------------
### Предварительные вычисления
Логично предположить, что сразу после проверки длины последуют другие операции с ключом. Рассмотрим блок сразу за проверкой:
В этом блоке идет предварительная работа. Функция `get_hash_2b`(в оригинале было `sub_1526`) вызывается дважды. Сначала ей передается адрес первого байта ключа(регистр `a0` содержит адрес `KEY_BYTE_0`), во второй раз — пятого(`KEY_BYTE_4`).
Я назвал функцию так, потому что она считает что-то типа хэша размером 2 байта. Это самое понятное название, которое я подобрал.
Саму функцию рассматривать я не буду, а сразу напишу ее на питоне. Она делает простые вещи, но ее описание со скринами займет много места.
Самое важное, что о ней нужно сказать: на вход подается начальный адрес, а работа идет над 4-мя байтами от этого адреса. То есть подали на вход первый байт ключа, а функция будет работать с 1,2,3,4-ым. Подали пятый, функция работает с 5,6,7,8-ым. Иными словами, в этом блоке идут вычисления над первой половиной ключа. Результат пишется в регистр `d0`.
Итак, функция `get_hash_2b`:
```
# key_4s - четыре символа ключа
def get_hash_2b(key_4s):
# Правило преобразования байта
def transform(b):
# numbers -.
if b <= 0x39:
r = b - 0x30
# Letter case and @
else:
# @ABCDEF
if b <= 0x46:
r = b - 0x37
else:
# WXYZ
if b >= 0x57:
r = b - 0x57
# GHIJKLMNOPQRSTUV
else:
r = 0xff - (0x57 - b) + 1 # a9+b
return r
# Перевод в байты
key_4b = bytearray(key_4s, encoding="ascii")
# Каждый байт аргумента трансформируется
codes = [transform(b) for b in key_4b]
# А здесь они просто склеиваются
part0 = (codes[0] & 0xff) << 0xc
part1 = (codes[1] << 0x8) & 0xf00
part2 = (codes[2] << 0x4) & 0xf0
hash_2b = (part0 | part1) & 0xffff
hash_2b = (hash_2b | part2) & 0xffff
hash_2b = (hash_2b | (codes[3] & 0xf))
return hash_2b
```
Сразу напишем функцию декодирования хэша:
```
# Возвращает строку из 4-х символов
def decode_hash_4s(hash_2b):
# Правило преобразования байта
def transform(b):
if b <= 0x9:
return b + 0x30
if b <= 0xF:
return b + 0x37
if b >= 0x0:
return b + 0x57
return b - 0xa9
# Нарезаем отдельные байты из переданного хэша и переводи
b0 = transform(hash_2b >> 12)
b1 = transform((hash_2b & 0xfff) >> 8)
b2 = transform((hash_2b & 0xff) >> 4)
b3 = transform(hash_2b & 0xf)
# Склеиваем
key_4s = [chr(b0), chr(b1), chr(b2), chr(b3)]
key_4s = "".join(key_4s)
return key_4s
```
Лучше функцию декодирования я не придумал, и она не совсем правильная. Поэтому я буду ее проверять так(не прямо сейчас, а значительно позже):
```
key_4s == decode_hash_4s(get_hash_2b(key_4s))
```
Проверим работу `get_hash_2b`. Нас интересует состояние регистра `d0` после выполнения функции. Ставим брейки на `0x000017FE`, `0x00001808`, ключ вводим `ABCDEFGHIJKLMNOP`.
В регистр `d0` заносятся значения `0xABCD`, `0xEF01`. А что выдаст `get_hash_2b`?
```
>>> first_hash = get_hash_2b("ABCD")
>>> hex(first_hash)
0xabcd
>>> second_hash = get_hash_2b("EFGH")
>>> hex(second_hash)
0xef01
```
Проверка пройдена.
Далее производится `xor eor.w d0, d5`, результат заносится в `d5`:
```
>>> hex(0xabcd ^ 0xef01)
0x44cc
```
В получении такого хэша `0x44CC` и состоят предварительные вычисления. Далее все только усложняется.
### Куда уплывает хэш
Нам никак не пройти дальше, если мы не узнаем как программа работает с хэшем. Наверняка он перемещается из `d5` в память, т.к. регистр пригодится где-нибудь еще. Отыскать такое событие мы можем через трассировку(наблюдая за `d5`), но не ручную, а автоматическую. Поможет такой скрипт:
```
#include
static main()
{
auto d5\_val;
auto i;
for(;;)
{
StepOver();
GetDebuggerEvent(WFNE\_SUSP, -1);
d5\_val = GetRegValue("d5");
// Ловим факт изменения d5
if (d5\_val != 0xFFFF44CC){
break;
}
}
}
```
Напомню, что мы сейчас находимся на последнем брейке `0x00001808 eor.w d0, d5`. Вставляем скрипт(`Shift-F2`), жмем `Run`
Скрипт остановится на инструкции `0x00001C94 move.b (a0, a1.l), d5`, но к этому моменту `d5` уже очищен. Однако мы видим, что значение из `d5` перемещается инструкцией `0x00001C56 move.w d5,a6`: оно пишется в память по адресу `0x00FF0D46`(2 байта).
**Запомним: хэш хранится по адресу `0x00FF0D46`.**
Отловим инструкции, которые читают из `0x00FF0D46-0x00FF0D47`(ставим брейк на чтение). Попались 4 блока:
Как выбрать из них правильный/правильные?
Возвращаемся в начало:
Этот блок определяет, пойдет ли программа в `LOSER_CASE` или в `WINNER_CASE`:
Видим, что в регистре `d1` должен быть ноль для победы.
Где ставится ноль? Просто прокрутим наверх:
Если в блоке `loc_1EEC` выполняется условие:
```
*(a6 + 0x24) == *(a6 + 0x22)
```
то мы получим ноль в `d5`.
Если мы поставим брейк на инструкцию `0x00001F16 beq.w loc_20EA`, то увидим, что `a6 + 0x24 = 0x00FF0D6A` и там хранится значение `0x4840`. А в `a6 + 0x22 = 0x00FF0D68` хранится `0xCB4C`.
Если мы будем вводить разные ключи, почты, то увидим, что `0xCB4C - константа`. **Первая половина ключа будет принята, только если в `0x00FF0D6A` будет тоже `0xCB4C`. Это критерий правильности первой половины ключа.**
Узнаем, какие блоки пишут в `0x00FF0D6A` — ставим брейк на запись, снова вводим почту и ключ.
И вот этот блок `loc_EAC` мы обнаружим(на самом деле их 3, но первые два просто обнуляют `0x00FF0D6A`):
Этот блок принадлежит функции `sub_E3E`.
Через колл стэк выясняем, что функция `sub_E3E` вызывается в блоках `loc_1F94`, `loc_203E`:
Помните, мы нашли 4 блока ранее? `loc_1F94` мы там видели — это начало главного алгоритма обработки ключа.
Первый важный цикл loc\_1F94
----------------------------
То, что `loc_1F94` является циклом видно из кода: он выполняется `d4` раз (см. инструкцию `0x00001FBA d4,loc_1F94`):
На что обратить внимание:
1. Есть функция `sub_5EC`.
2. Инструкция 0x00001FB4 jsr (a0) вызывает функцию sub\_E3E(это можно увидеть простой трассировкой).
Что здесь происходит:
1. Функция `sub_5EC` пишет результат своего выполнения в регистр `d0`(этому посвящена отдельный раздел ниже).
2. В регистр `d1` сохраняется байт по адресу `sp+0x33`(`0x00FFFF79`, говорит нам отладчик), он равен второму байту из адреса хэша ключа(`0x00FF0D47`). Это легко доказать, если поставить брейк на запись по адресу `0x00FFFF79`: он сработает на инструкции `0x00001F94 move.b 1(a2), 0x2F(sp)`. В регистре `a2` в этот момент хранится адрес `0x00FF0D46` — адрес хэша, то есть `0x1(a2) = 0x00FF0D46 + 1` — адрес второго байта хэша.
3. В регистр `d0` пишется `d0^d1`.
4. Получившийся результат xor'a отдается в функцию `sub_E3E`, поведение которой зависит от своих прежних вычислений(показано ниже).
5. Повторить.
Сколько же раз этот цикл выполняется?
Выясним это. Запустим такой скрипт:
```
#include
static main()
{
auto pc\_val, d4\_val, counter=0;
while(pc\_val != 0x00001F16)
{
StepOver();
GetDebuggerEvent(WFNE\_SUSP, -1);
pc\_val = GetRegValue("pc");
if (pc\_val == 0x00001F92){
counter++;
d4\_val = GetRegValue("d4");
print(d4\_val);
}
}
print(counter);
}
```
`0x00001F92 subq.l 0x1,d4` — здесь определяется, что будет в `d4` непосредственно перед циклом:
Разбираемся с функцией sub\_5EC.
### sub\_5EC
Значимый кусок кода:
где `0x2c(a2)` всегда `0x00FF1D74`.
Этот кусок можно переписать так на псевдокоде:
```
d0 = a2 + 0x2C
*(a2+0x2C) = *(a2+0x2C) + 1 #*(0x00FF1D74) = *(0x00FF1D74) + 1
result = *(d0) & 0xFF
```
То есть 4 байта из `0x00FF1D74` являются адресом, т.к. с ними обращаются как с указателем.
Как переписать функцию `sub_5EC` на питоне?
1. Либо сделать дамп памяти и работать с ним.
2. Либо просто записать все выдаваемые значения.
Второй способ мне нравится больше, но что, если при разных данных авторизации выдаваемые значения разные? Проверим это.
Поможет в этом скрипт:
```
#include
static main()
{
auto pc\_val=0, d0\_val;
while(pc\_val != 0x00001F16){
pc\_val = GetRegValue("pc");
if (pc\_val == 0x00001F9C)
StepInto();
else
StepOver();
GetDebuggerEvent(WFNE\_SUSP, -1);
if (pc\_val == 0x00000674){
d0\_val = GetRegValue("d0") & 0xFF;
print(d0\_val);
}
}
}
```
Я просто сравнивал выводы в консоль при разных ключах, почтах.
Запустив скрипт несколько раз при разных ключах, мы увидим, что функция `sub_5EC` всегда возвращает очередное значение из массива:
```
def sub_5EC_gen():
dump = [0x92, 0x8A, 0xDC, 0xDC, 0x94, 0x3B, 0xE4, 0xE4,
0xFC, 0xB3, 0xDC, 0xEE, 0xF4, 0xB4, 0xDC, 0xDE,
0xFE, 0x68, 0x4A, 0xBD, 0x91, 0xD5, 0x0A, 0x27,
0xED, 0xFF, 0xC2, 0xA5, 0xD6, 0xBF, 0xDE, 0xFA,
0xA6, 0x72, 0xBF, 0x1A, 0xF6, 0xFA, 0xE4, 0xE7,
0xFA, 0xF7, 0xF6, 0xD6, 0x91, 0xB4, 0xB4, 0xB5,
0xB4, 0xF4, 0xA4, 0xF4, 0xF4, 0xB7, 0xF6, 0x09,
0x20, 0xB7, 0x86, 0xF6, 0xE6, 0xF4, 0xE4, 0xC6,
0xFE, 0xF6, 0x9D, 0x11, 0xD4, 0xFF, 0xB5, 0x68,
0x4A, 0xB8, 0xD4, 0xF7, 0xAE, 0xFF, 0x1C, 0xB7,
0x4C, 0xBF, 0xAD, 0x72, 0x4B, 0xBF, 0xAA, 0x3D,
0xB5, 0x7D, 0xB5, 0x3D, 0xB9, 0x7D, 0xD9, 0x7D,
0xB1, 0x13, 0xE1, 0xE1, 0x02, 0x15, 0xB3, 0xA3,
0xB3, 0x88, 0x9E, 0x2C, 0xB0, 0x8F]
l = len(dump)
offset = 0
while offset < l:
yield dump[offset]
offset += 1
```
Итак, функция `sub_5EC` готова.
На очереди `sub_E3E`.
### sub\_E3E
Значимый кусок кода:
Расшифруем:
```
Эта конструкция выдает адрес, куда сохранять d2, который сейчас содержит входной аргумент.
Регистр a2 хранит значение 0xFF0D46, a2 + 0x34 = 0xFF0D7A
d0 = *(a2 + 0x34)
*(a2 + 0x34) = *(a2 + 0x34) + 1
Входной аргумент сохраняется, в регистре a0 адрес этого сохранения
a0 = d0
*(a0) = d2
Здесь вычисляется некий offset, который сохраняется в регистре d2.
Регистр a2 хранит значение 0xFF0D46, a2 + 0x24 = 0xFF0D6A - это место, где хранится
предыдущий результат функции(см. конец) либо 0x00000000, если функция вызывается впервые
d0 = *(a2 + 0x24)
d2 = d0 ^ d2
d2 = d2 & 0xFF
d2 = d2 + d2
Вытаскиваются какие-то 2 байта по адресу 0x00011FC0 + d2, это область ROM, поэтому
содержимое 0x00011FC0 + d2 постоянно
a0 = 0x00011FC0
d2 = *(a0 + d2)
Предыдущий результат этой функции сдвигается на 8 бит
d0 = d0 >> 8
Результат
d2 = d0 ^ d2
Записывается текущий результат функции
*(a2 + 0x24) = d2
```
Функция `sub_E3E` сводится к таким шагам:
1. Сохранить входной аргумент в массив.
2. Рассчитать смещение offset.
3. Вытащить 2 байта по адресу `0x00011FC0 + offset`(ROM).
4. Результат = `(предыдущий результат >> 8) ^ (2 байта 0x00011FC0 + offset)`.
Представим функцию `sub_E3E` в таком виде:
```
def sub_E3E(prev_sub_E3E_result, d2, d2_storage):
def calc_offset():
return 2 * ((prev_sub_E3E_result ^ d2) & 0xff)
d2_storage.append(d2)
offset = calc_offset()
with open("dump_00011FC0", 'rb') as f:
dump_00011FC0_4096b = f.read()
some = dump_00011FC0_4096b[offset:offset + 2]
some = int.from_bytes(some, byteorder="big")
prev_sub_E3E_result = prev_sub_E3E_result >> 8
return prev_sub_E3E_result ^ some
```
`dump_00011FC0` — это просто файл, куда я сохранил 4096 байт из `[0x00011FC0:00011FC0+4096]`.
Активность около 1FC4
---------------------
Адрес `0x00001FC4` мы еще не видели, но его легко найти, потому что блок идет почти сразу за первым циклом.
Этот блок меняет содержимое по адресу `0x00FF0D46` (регистр `a2`), а именно там хранится хэш ключа, поэтому мы сейчас и изучаем этот блок. Посмотрим, что здесь происходит.
1. Условие, которое определяет, будет выбрана левая или правая ветка, такое: `(хэш первой половины ключа) & 0b1 != 0`. То есть проверяется первый бит хэша.
2. Если присмотреться к обоим веткам, станет видно:
* В обоих случаях происходит сдвиг вправо на 1 бит.
* В левой ветке над хэшем производится операция `ИЛИ 0x8000`.
* В обоих случаях по адресу `0x00FF0D46` записывается обработанное значение хэша, то есть хэш заменяется на новое значение.
* Дальнейшие вычисления некритичны, потому что, грубо говоря, нет операций записи в `(a2)` (нет инструкции, где вторым операндом был бы `(a2)`).
Представим блок так:
```
def transform(hash_2b):
new = hash_2b >> 1
if hash_2b & 0b1 != 0:
new = new | 0x8000
return new
```
Второй важный цикл loc\_203E
----------------------------
`loc_203E` — цикл, т.к. `0x0000206C bne.s loc_203E`.
Этот цикл досчитывает хэш и вот его главная особенность: `jsr (a0)` — это вызов функции `sub_E3E`, которую мы уже рассмотрели — она опирается на предыдущий результат своей же работы и на некий входной аргумент(выше он передавался через регистр `d2`, а здесь через `d0`).
Давайте выясним, что передается ей через регистр `d0`.
Мы уже встречались с конструкцией `0x34(a2)` — туда функция `sub_E3E` сохраняет переданный аргумент. Значит, в этом цикле используются ранее переданные аргументы. Но не все.
Расшифруем часть кода:
```
Здесь берется 2 байта из адреса a2+0x1C
move.w 0x1C(a2), d0
Инвертируется
neg.l d0
В регистр a0 пишется адрес последнего сохраненного аргумента функции sub_E3E
movea.l 0x34(a2), a0
Наконец, в d0 пишутся 2 байта по адресу a0-d0(вычитание потому что d0 инвертирован)
move.b (a0, d0.l), d0
```
Суть сводится к простому действию: на каждой итерации взять `d0` сохраненный аргумент с конца массива. То есть если в `d0` хранится 4, то берем четвертый с конца элемент.
Раз так, то какие конкретно принимает значения `d0`? Здесь я обошелся без скриптов, а просто выписал их, поставив брейк на начало этого блока. Вот они: `0x04, 0x04, 0x04, 0x1C, 0x1A, 0x1A, 0x06, 0x42, 0x02`.
Теперь у нас есть все, чтобы написать полную функцию вычисления хэша ключа.
Полная функция вычисления хэша
------------------------------
```
def finish_hash(hash_2b):
# Правило преобразования хэша
def transform(hash_2b):
new = hash_2b >> 1
if hash_2b & 0b1 != 0:
new = new | 0x8000
return new
main_cycle_counter = [17, 2, 2, 3, 4, 38, 10, 30, 4]
second_cycle_counter = [2, 2, 2, 2, 2, 4, 2, 4, 28]
counters = list(zip(main_cycle_counter, second_cycle_counter))
d2_storage = []
storage_offsets = [0x04, 0x04, 0x04, 0x1C, 0x1A, 0x1A, 0x06, 0x42, 0x02]
prev_sub_E3E_result = 0x0000
sub_5EC = sub_5EC_gen()
for i in range(9):
c = counters[i]
for _ in range(c[0]):
d0 = next(sub_5EC)
d1 = hash_2b & 0xff
d2 = d0 ^ d1
curr_sub_E3E_result = sub_E3E(prev_sub_E3E_result, d2, d2_storage)
prev_sub_E3E_result = curr_sub_E3E_result
storage_offset = storage_offsets.pop(0)
for _ in range(c[1]):
d2 = d2_storage[-storage_offset]
curr_sub_E3E_result = sub_E3E(prev_sub_E3E_result, d2, d2_storage)
prev_sub_E3E_result = curr_sub_E3E_result
hash_2b = transform(hash_2b)
return curr_sub_E3E_result
```
### Проверка работоспособности
1. В отладчике ставим брейк на адрес `0x0000180A move.l 0x1000,(sp)` (сразу после вычисления хэша).
2. Брейк на адрес `0x00001F16 beq.w loc_20EA`(сравнение окончательного хэша с константой `0xCB4C`).
3. В программе вводим ключ `ABCDEFGHIJKLMNOP`, жмем `Enter`.
4. Отладчик останавливается на `0x0000180A`, и мы видим, что в регистр `d5` записалось значение `0xFFFF44CC`, `0x44CC` — первый хэш.
5. Запускаем отладчик дальше.
6. Останавливаемся на `0x00001F16` и видим, что по адресу `0x00FF0D6A` лежит `0x4840` — окончательный хэш
7. Теперь проверям нашу функцию finish\_hash(hash\_2b):
```
>>> r = finish_hash(0x44CC)
>>> print(hex(r))
0x4840
```
Ищем правильный ключ 1
----------------------
Правильный ключ — этот ключ, у которого окончательный хэш равен `0xCB4C`(выясняли выше). Отсюда вопрос: каким должен быть первый хэш, чтобы окончательный стал `0xCB4C`?
Теперь это просто выяснить:
```
def find_CB4C():
result = []
for hash_2b in range(0xFFFF+1):
final_hash = finish_hash(hash_2b)
if final_hash == 0xCB4C:
result.append(hash_2b)
return result
>>> r = find_CB4C()
>>> print(r)
```
Вывод программы говорит о том, что вариант один: первый хэш должен быть `0xFEDC`.
Какие символы нам нужны, чтобы их первый хэш был `0xFEDC`?
Так как `0xFEDC = хэш_первых_4_символов ^ хэш_вторых_4_символов`, то найти нужно только `хэш_первых_4_символов`, потому что `хэш_вторых_4_символов = хэш_первых_4_символов ^ 0xFEDC`. А затем декодировать оба хэша.
Алгоритм такой:
```
def get_first_half():
from collections import deque
from random import randint
def get_pairs():
pairs = []
for i in range(0xFFFF + 1):
pair = (i, i ^ 0xFEDC)
pairs.append(pair)
pairs = deque(pairs)
pairs.rotate(randint(0, 0xFFFF))
return list(pairs)
pairs = get_pairs()
for pair in pairs:
key_4s_0 = decode_hash_4s(pair[0])
key_4s_1 = decode_hash_4s(pair[1])
hash_2b_0 = get_hash_2b(key_4s_0)
hash_2b_1 = get_hash_2b(key_4s_1)
if hash_2b_0 == pair[0] and hash_2b_1 == pair[1]:
return key_4s_0, key_4s_1
```
Вариантов куча, выбирайте любой.
Ищем правильный ключ 2
----------------------
Первая половина ключа готова, что со второй?
Эта самая легкая часть.
Ответственный кусок кода располагается на `0x00FF2012`, до него я добрался ручной трассировкой, начав с адреса `0x00001F16 beg.w loc_20EA`(валидация первой половины ключа). В регистре `a0` находится адрес почты, `loc_FF2012` является циклом, т.к. `bne.s loc_FF2012`. Он выполняется до тех пор, пока есть `*(a0+d0)`(очередной байт почты).
А инструкция `jsr (a3)` вызывает уже знакомую функцию `get_hash_2b`, которая теперь работает со второй половиной ключа.
Сделаем код понятнее:
```
while(d1 != 0x20){
Подсчитывается длина почты
d2++
d1 = d1 & 0xFF
Подсчитывается сумма байтов почты
d3 = d3 + d1
d0 = 0
d0 = d2
Очередной байт почты
d1 = *(a0+d0)
}
d0 = get_hash_2b(key_byte_8)
d3 = d0^d3
d0 = get_hash_2b(key_byte_12)
d2 = d2 - 1
d2 = d2 << 8
d2 = d0^d2
if (d2 == d3)
success_branch
```
В регистре `d2` — `(длина почты-1) << 8`. В `d3` — сумма байтов символов почты.
Критерий корректности получается таким: `третья_четверть_ключа ^ d2 == последняя_четверть_ключа_2 ^ d3`.
Напишем функцию подбора второй половины ключа:
```
def get_second_half(email):
from collections import deque
from random import randint
def get_koeff():
k1 = sum([ord(c) for c in email])
k2 = (len(email) - 1) << 8
return k1, k2
def get_pairs(k1, k2):
pairs = []
for a in range(0xFFFF + 1):
pair = (a, (a ^ k1) ^ k2)
pairs.append(pair)
pairs = deque(pairs)
pairs.rotate(randint(0, 0xFFFF))
return list(pairs)
k1, k2 = get_koeff()
pairs = get_pairs(k1, k2)
for pair in pairs:
key_4s_0 = decode_hash_4s(pair[0])
key_4s_1 = decode_hash_4s(pair[1])
hash_2b_0 = get_hash_2b(key_4s_0)
hash_2b_1 = get_hash_2b(key_4s_1)
if hash_2b_0 == pair[0] and hash_2b_1 == pair[1]:
return key_4s_0, key_4s_1
```
Кейген
------
Почта обязательно капсом.
```
def keygen(email):
first_half = get_first_half()
second_half = get_second_half(email)
return "".join(first_half) + "".join(second_half)
>>> email = "M.GAYANOV@GMAIL.COM"
>>> print(keygen(email))
2A4FD493BA32AD75
```
Спасибо за внимание! Весь код доступен [здесь](https://github.com/mgayanov/PHDays9_Best_Reverser). | https://habr.com/ru/post/453194/ | null | ru | null |
# Unity: What is a Coroutine and why is there an IEnumerator
The title of the article is a question I was asked in an interview for a Middle position. In this article, we will look at Unity coroutines, what they are, and at the same time we will capture the topic of Enumerator \ Enumerable in C # and a little secret of foreach. The article should be very useful for beginners.
And so, as everyone knows, the method that represents Coroutine in Unity looks like this:
```
IEnumerator Coroutine()
{
yield return null;
}
```
Some information about coroutines in Unity and IEnumeratorAs a return object after yield return can be:
* new WaitForEndOfFrame() - stops execution until the end of the next frame
* new WaitForFixedUpdate() - stops execution until the next physics engine frame.
* new WaitForSeconds(float x) - stops execution for x seconds of game time (can be changed via [Time.timeScale](https://translate.google.com/website?sl=ru&tl=en&hl=ru&client=webapp&u=https://docs.unity3d.com/ScriptReference/Time-timeScale.html) )
* new WaitForSecondsRealtime(float x) - stops execution for x seconds of real time
* new WaitUntil(Func) - suspends the coroutine execution until the supplied delegate evaluates to true.
* new WaitWhile(Func) - inverse of WaitUntil, continues execution when Func returns false
* null - Same as WaitForEndOfFrame(), but execution continues at the beginning of the next. frame
* break - ends the coroutine
* StartCoroutine() - execution stops until the moment when the newly started coroutine ends.
You can start a coroutine via StartCoroutine(Coroutine()).
Coroutines are not asynchronous, they run on the main thread of the application, the same as drawing frames, instantiating objects, etc., if you block the thread in the coroutine, the whole application will stop, coroutines with asynchrony would use "IAsyncEnumerator", which Unity does not support. The coroutine allows you to stretch the execution over several frames, so as not to load 1 frame with large calculations. Unity provides the UnityWebRequest type for Http requests that can be made "asynchronously" in multiple frames, which may appear to be "asynchronous", in fact it is a wrapper over a native asynchronous HttpClient that provides some information synchronously, by the type of the isDone field, which renders - whether the request has ended or the response is still pending, but the request itself is asynchronous.
IEnumerator is C#'s standard implementation of the iterator pattern, which contains syntactic sugar for storing state.
It returns an IEnumerator and has an unusual return with yield.
yield return is a component of IEnumerator, this bundle is converted, at compilation, into a state machine that saves the position in the code, waits for the MoveNext command from IEnumerator and continues execution until the next yield return or the end of the method, more details can be found on [the microsoft site.](https://translate.google.com/website?sl=ru&tl=en&hl=ru&client=webapp&u=https://docs.microsoft.com/ru-ru/dotnet/csharp/language-reference/keywords/yield)
The IEnumerator interface contains the following elements:
```
public interface IEnumerator
{
object Current { get; }
bool MoveNext();
void Reset();
}
```
Under the hood of Unity, this is handled something like this: Unity receives an IEnumerator, which is passed through StartCoroutine(IEnumerator), immediately calls MoveNext, in order for the code to reach the first yield return, it is worth clarifying here that when such a method is called, the execution of the code inside the method does not start independently, and you need to call MoveNext, this can be checked with a simple script, which is presented under this paragraph, and then if Unity receives an object of type YieldInstruction in Current, then it executes the instruction and calls MoveNext again, that is, the method can return any type, and if it not a YieldInstruction, then Unity will treat it as yield return null.
```
private IEnumerator _coroutine;
// Start is called before the first frame update
void Start()
{
_coroutine = Coroutine();
}
// Update is called once per frame
void Update()
{
if (Time.time > 5)
_coroutine.MoveNext();
}
IEnumerator Coroutine()
{
while (true)
{
Debug.Log(Time.time);
yield return null;
}
}
```
 The log shows that the method was called for the first time at the 5th second, according to the condition in Update()Great, we covered the main point, namely what is IEnumerator and how it works. Now let's look at this case:
Let's describe a class that inherits the IEnumerator interface
```
class TestEnumerator : IEnumerator
{
public object Current => new WaitForSeconds(1);
public bool MoveNext()
{
Debug.Log(Time.time);
return true;
}
public void Reset()
{
}
/// This class is equivalent to the following coroutine:
/// IEnumerator Coroutine()
/// {
/// while(true){
/// Debug.Log(Time.time);
/// yield return new WaitForSeconds(1);
/// }
/// }
}
```
And now we can use it in the following way:
```
void Start()
{
StartCoroutine(new TestEnumerator());
}
```
Performs the same as a coroutine methodAnd so, we have considered IEnumerator and coroutines, here you can consider different use cases for a long time, but at the root there remains the transfer of IEnumerator in any form to the StartCoroutine method.
Now I propose to consider IEnumerable, this interface is inherited by the native C# array, List from System.Generic and other similar types, its whole essence lies in the fact that it contains the GetEnumerator method, which returns an IEnumerator:
```
public interface IEnumerable
{
[DispId(-4)]
IEnumerator GetEnumerator();
}
```
Let's implement a simple example:
```
class TestEnumerable : IEnumerable
{
public IEnumerator GetEnumerator()
{
return new TestEnumerator();
}
}
```
And now, we can do the following:
```
IEnumerator Coroutine()
{
foreach (var delay in new TestEnumerable())
{
Debug.Log($"{Time.time}");
yield return delay;
}
}
```
You can see that the time is displayed twice in the log, this is due to the fact that we still have Debug in the TestEnumerator in the MoveNext method.There are many usages for this, for example, you can add a random delay time to the TestEnumerator:
```
class TestEnumerator : IEnumerator
{
public object Current => new WaitForSeconds(_currDelay);
private float _currDelay;
public bool MoveNext()
{
_currDelay = Random.Range(1.0f, 3.0f);
return true;
}
public void Reset()
{
}
}
```
The time between logs is not the sameAnd some magic for beginners: foreach does not require that the object returned by GetEnumerator implement IEnumerable, most importantly, that the type after "in" has GetEnumerator() method, and returns a type with Current property and MoveNext() method, that is, we can do so:
```
class TestEnumerator // Here was inheritance from IEnumerator
{
public object Current => new WaitForSeconds(_currDelay);
private float _currDelay;
public bool MoveNext()
{
_currDelay = Random.Range(1.0f, 3.0f);
return true;
}
// There was the Reset method from IEnumerator, it's no longer needed :)
}
class TestEnumerable // Here was inheritance from IEnumerable
{
// The return type was IEnumerator
public TestEnumerator GetEnumerator()
{
return new TestEnumerator();
}
}
```
As you can see, there is no inheritance anywhere and no mention of IEnumerable and IEnumerator, but we can also use the following code:
```
IEnumerator Coroutine()
{
foreach (var delay in new TestEnumerable())
{
Debug.Log($"{Time.time}");
yield return delay;
}
}
```
Everything works the same and without errorsAnd so, having analyzed the coroutines, IEnumerator, IEnumerable and foreach, you should see an example of using this knowledge in practice:
More convenient to use CoroutineHere I wanted to describe the implementation of a coroutine with a CancelationToken and start / end events with the ability to pause execution, but I was late, and there is a ready-made solution on github, I advise you to study, although I do not completely agree with the implementation:
[unity-task-manager/TaskManager.cs at master AdamRamberg/unity-task-manager (github.com)](https://translate.google.com/website?sl=ru&tl=en&hl=ru&client=webapp&u=https://github.com/AdamRamberg/unity-task-manager/blob/master/Assets/UnityTaskManager/TaskManager.cs)
I would be grateful for criticism and comments, I also advise you to look at my other articles.
Translated for TechNation GlobalTalent Visa. | https://habr.com/ru/post/684938/ | null | en | null |
# Вслед за солнцем. О гелиотропии и подвижности солнечных батарей
Солнечные батареи кажутся мне одним из самых интересных изобретений XIX века, значительно опередивших свое время. В них сочетается простейшая, бионическая по сути идея (будем ловить солнечную энергию напрямую, как это делается в солнечных листьях) и монструозная материально-техническая составляющая, пока во многом девальвирующая эту идею. Солнечные батареи оказались громоздким, недолговечным и уязвимым источником энергии. А с учетом мер по их переработке и захоронению они, к тому же, и не слишком экологичны. Но, в конце концов, солнечные батареи отлично прижились как на «Мире», так и на МКС – поскольку лучше всего подходят для работы в космосе. Ведь там нет ни облачности, ни пыли, ни снега, а главное – нет иных источников энергии, зато круглый год светит солнце, и лучи его не рассеиваются в атмосфере за неимением таковой. Но на поверхности Земли технология солнечных батарей по-прежнему страдает от множества «детских болезней». Интересное направление НИОКР, значительно повышающее эффективность солнечных батарей – дальнейшее обогащение их подлинно растительными чертами. Правильная солнечная батарея должна быть гелиотропом – то есть, поворачиваться в течение суток, следуя за солнцем. Также она должна сворачиваться в плохую погоду, как цветок. Именно о таких разработках пойдет речь под катом.
Исторический контекст
---------------------
В течение XIX века вместе со множеством исследований в области электричества развивалась и фотохимия. В 1839 году Александр Эдмон Беккерель открыл фотогальванический эффект, [показав](https://www.nkj.ru/archive/articles/14813/), что свет может напрямую превращаться в электричество. Разумеется, эффективность такого преобразования зависит от улавливающего материала. Первый рабочий образец солнечной батареи был создан в 1883 году американским инженером Чарльзом Фриттсом, изготовившим из селена первую миниатюрную солнечную панель. При этом он опирался на случайное открытие другого американского ученого, Уиллоби Смита, в 1873 году участвовавшего в прокладке трансатлантического телеграфного кабеля и обнаружившего, что электропроводность селеновых стержней возрастает, если на них падает свет. КПД селеновой батареи Фриттса составлял 1%.
Тем не менее, такие устройства оставались лабораторными изысками вплоть до 1912 года, когда ими занялся итальянский химик армянского происхождения Джакомо Луиджи Чамичан. Тогда, выступая на 8-м Международном химическом конгрессе, он заявил:
«На засушливых землях будут возникать промышленные колонии без дымящихся труб; леса стеклянных трубок будут распространяться на равнинах, и стеклянные здания будут расти везде; внутри них будут проходить фотохимические процессы, которые до настоящего времени были неведомой тайной растений, но всё это будет освоено человеческой цивилизацией, которая будет знать, как получить ещё более обильные плоды… И если в недалёком будущем запасы угля будут полностью исчерпаны, цивилизация не пропадёт, а будет существовать до тех пор, пока светит солнце!»
Таким образом, еще до первой мировой войны осознавалась важность солнца в качестве источника энергии, но широкое использование солнечных батарей оставалось невозможным до решения, как минимум, двух фундаментальных проблем:
1. Повышения фотохимической эффективности фотоэлемента.
2. Коррекции отражательных показателей батареи, так, чтобы она поглощала достаточное количество света, но при этом не перегревалась.
Кратко остановлюсь на том, из чего состоит современная солнечная батарея.
Солнечная батарея является многослойной конструкцией, состоящей (сверху вниз) из следующих элементов:
1) Рама
2) Закаленное стекло
3) Шинопроводы (электропроводящие полоски)
4) Фотоэлемент на основе кремния. Как правило, изготавливается из кварца
5) Алюминиевая подложка
6) Распределительная коробка
Итак, в 1948 году инженеры «Bell Laboratories» Кельвин Соулзер Фуллер, Дэрил Чейпин и Джеральд Пирсон продемонстрировали первую коммерчески выгодную модель солнечной батареи с КПД 6%. Уже в 1958 году солнечными батареями были оснащены первые космические аппараты – американский «Авангард-1» и советский «Спутник-3». К началу XXI века (в 2007 году) компания General Electric добилась от солнечных батарей КПД 16% и более, но фундаментальные проблемы до сих пор не позволяют этим устройствам полноценно заменить ТЭЦ и прочие генераторы электричества, работающие на ископаемом топливе. В жарких засушливых областях, которые мечтал застелить солнечными батареями Чамичан, просто живет не так много людей и не развернуто серьезной промышленности, которую можно было бы питать солнечной энергией. А в густонаселенных областях умеренного пояса не хватает свободных площадей под солнечные батареи. Кроме того, чтобы сравниться с растениями в эффективности сбора солнечной энергии, необходимо реализовать [искусственный фотосинтез](https://scientificrussia.ru/articles/razrabotana-sistema-iskusstvennogo-fotosinteza) или его аналог, возможно – приблизить фотоэлементы по свойствам к искусственным хлоропластам, которые улавливали бы свет в максимально широком спектре.
Оптимизация солнечной энергетики
--------------------------------
О недостатках солнечных панелей сказано немало, в частности, на [Хабре](https://habr.com/ru/post/580864/) и в [отраслевых](https://hbr-russia.ru/innovatsii/trendy/875463/) [источниках](https://oilcapital.ru/article/general/20-12-2021/chto-tormozit-solnechnuyu-energetiku). Они связаны преимущественно с 1) присутствием токсичных веществ в составе панелей 2) сложностью переработки панелей – в особенности по сравнению с тем, чтобы просто отвезти их на свалку, 3) крайней неравномерностью инсоляции – в некоторых регионах панели будут простаивать из-за облачности, а в других – перегреваться и требовать дополнительного отвода тепла. Тем не менее, как указал уважаемый @leventov в [комментарии](https://habr.com/ru/post/580864/#comment_23540754) к вышеупомянутой хабростатье, все это – вызовы, требующие решения, но не отменяющие перспектив солнечной энергетики как отрасли. Действительно, солнечные электростанции, развернутые в регионах с жаркой и безоблачной погодой, могли бы обеспечивать энергией потребителей из умеренных широт. Великобритания [готова инвестировать](https://www.energy-storage.news/morocco-uk-power-project-solar-wind-and-5gw-of-battery-energy-storage/) в солнечные электростанции в Марокко, проложив из Африки на свою территорию кабели длиной более 2500 км, чтобы к 2030 году примерно на 8% покрыть маррокансккой солнечной энергией собственные потребности в электричестве. Что касается охлаждения солнечных батарей, было бы удобно обеспечивать охлаждение за счет морской воды, и для этого развертывать солнечные фермы на искусственных островах, статью о которых я уже [публиковал](https://habr.com/ru/post/550594/) на Хабре. Кроме упомянутого в той статье «энергетического острова», возводимого Данией в Северном море, существует аналогичный [голландский проект](https://www.theguardian.com/world/2019/apr/21/dutch-engineers-build-worlds-biggest-sun-seeking-solar-farm): остров близ Амстердама на 73500 солнечных панелей, который позволит обеспечить энергией около 8500 домохозяйств. Отличие этого острова от более ранних проектов – в использовании [солнечного трекера](https://rusveter.ru/informaciya/solnechnye-batarei-dlya-doma/colnechnyj-treker).
Солнечные трекеры
-----------------
Несмотря на прогнозы Чамичана, до сих пор не реализованы региональные мегапроекты с полями солнечных батарей в жарких незаселенных пустынях. Препятствий на пути у таких проектов немало — они связаны как с затруднениями при доставке выработанного электричества к потребителю, так и с техническим обслуживанием панелей, и даже с тем, что для их эксплуатации нужна сильная освещенность, но не слишком сильная жара. Подробнее о том, почему Сахара пока не застелена солнечными панелями, рассказано в следующем видео (на английском языке):
Поэтому пока мы наблюдаем не горизонтальное масштабирование солнечных панелей, а распределение их по домохозяйствам. Как правило, полотно обычной солнечной панели устанавливается на (скатной) крыше и запитывает дом по [следующему принципу](https://recyclemag.ru/article/kak-ustroeny-i-rabotajut-solnechnye-batarei):
В этой схеме обратим внимание на то, что батарея обеспечивает дом как постоянным, так и переменным током, а также дает энергию в аккумулятор. Таким образом, в интересах владельца батареи, чтобы она накапливала энергию на протяжении всего светлого времени суток. Поэтому желательно делать панель подвижной, чтобы ее положение относительно солнца можно было менять. Именно для этого и применяются солнечные трекеры.
Можно исходить из того, что солнце движется относительно конкретной точки земной поверхности строго с востока на запад, и чем ближе к экватору – тем точнее это допущение. Но в относительно высоких широтах солнце может визуально располагаться в северном или южном полушарии неба. Следовательно, положение солнца можно отслеживать по двум осям: в направлении зенит-надир (по долготе) или по азимуту (по широте). Вот как это выглядит:
По состоянию на 2018 год в США солнечными трекерами было оснащено [70% всех новых солнечных батарей](https://www.solarpowerworldonline.com/2019/12/berkeley-lab-utility-scale-solar-report-shows-florida-led-country-in-2018-installations/). Ценность таких устройств стала расти с удешевлением солнечных панелей. Следовательно, частный владелец может позволить себе такое солнечное полотно, от положения которого принципиально зависит объем вырабатываемой энергии.
Все существующие солнечные трекеры можно разделить на две обширные категории: одноосные и двухосные. В то время, как некоторые одноосные трекеры ориентированы только по угловой высоте солнца, другие могут отслеживать только движение солнца с востока на запад. Двухосные трекеры, в свою очередь, отслеживают солнце в обоих этих направлениях сразу.
Следовательно, двухосный трекер может значительно улучшить энергетический выход от панели, поскольку она будет практически всегда расположена перпендикулярно к падающим на нее лучам. Такие трекеры могут работать на основе фоторезистора, на основе отслеживания тени, на основе алгоритмов, либо с участием человека, который корректирует положение панели вручную. [Вот как это делается](https://rusveter.ru/informaciya/solnechnye-batarei-dlya-doma/colnechnyj-treker) с солнечной панелью российской компании «Русветер»:
В принципе, солнечный трекер для домашней солнечной панели является несложным электронным устройством, который можно самостоятельно собрать из Arduino. [Здесь](https://www.electronicshub.org/sun-tracking-solar-panel/) описана полноценная модель солнечного трекера для настольной солнечной панели:
Вот ее принципиальная схема, в которую входят:
* Солнечная панель
* Микроконтроллер ATmega328
* Два фоторезистора (LDR)
* Три потенциометра 10KΩ
* Сервопривод
* Чип 16MHz
* Два фарфоровых конденсатора на 22 пФ
* Кнопка «Пуск»
* Макетная плата
* Картон
* Провода
Вот код с логикой работы солнечного трекера, взят из репозитория [elktros](https://gist.github.com/elktros/3deabec4a261deae22273de59bd041f8#file-sun_tracking_solar_panel-ino).
```
#include
Servo myservo;
int ldr1 = 4;
int ldr2 = 5;
int val1;
int val2;
int pos=90;
void setup()
{
myservo.attach(11);
Serial.begin(9600);
myservo.write(pos);
}
void loop()
{
val1 = analogRead(ldr1);
val2 = analogRead(ldr2);
val1 = map(val1, 0, 1023, 0, 180);
val2 = map(val2, 0, 1023, 0, 180);
if(val1 > (val2+50))
{
if(pos<180)
pos=pos+1;
myservo.write(pos);
Serial.println("backward");
delay(10);
}
else if(val2 > (val1+50))
{
if(pos>0)
pos=pos-1;
myservo.write(pos);
Serial.println("forward");
delay(10);
}
}
```
Приведенные примеры подтверждают, что при распределенном подходе к установке солнечных батарей (по потребностям каждого домохозяйства) подвижность солнечных батарей и их работа по гелиотропному принципу (следование за солнцем в суточном и сезонном ритме) приобретают принципиальное значение. Рассмотрим несколько наиболее ярких архитектурно-технических находок, реализующих такую гелиотропию.
Это вращающийся солнечный дом. Его построил для себя во Фрайбурге немецкий архитектор и экоактивист Рольф Диш. На снимке заметно, что на крыше дома установлены солнечные панели. Сам дом в течение года медленно вращается, подставляя панели солнцу, но и они сами по себе являются подвижными и могут автоматически менять угол, исходя из данных солнечного трекера.
Солнечные панели этого дома с расчетной мощностью 6,6 кВт каждая производят примерно в 5-6 раз больше энергии, чем требуется на обеспечение здания, поэтому дом даже позволяет запасать избыточную энергию. Батареи вращаются независимо от здания не только для оптимизации освещенности, но и для того, чтобы они могли противостоять сильному ветру.
Более совершенным решением является австрийская разработка [Smartflower](https://smartflower.com/).
Это мобильная система, которая может устанавливаться во дворе или на крыше. Ее солнечные панели складываются или раскрываются подобно цветку. Устройство работает без выделенного солнечного трекера; солнце отслеживается по GPS, мощность базового образца составляет 3,2 кВт. Умный цветок реагирует на облачность, силу ветра и на наступление ночи (частично или полностью сворачивая лепестки в зависимости от погоды или времени суток). Работает при температуре лопастей от -20 до +60 градусов. Также цветок обладает функцией самоочищения. Производитель предлагает три разновидности этой установки:
1. корпоративная (энергетическая «клумба» может опоясывать производственный комплекс и управляться как в ручном режиме, так и автономно, по показаниям датчиков)
2. домашняя. Поскольку на крыше или во дворе можно установить один-два умных цветка, они рассчитаны на аккумулирование энергии, в первую очередь в качестве резервного источника энергии, не предполагающего отключение дома от коммунальных электросетей
3. автомобильная. Облегченная установка действует исключительно как аккумулятор и зарядка для электромобиля. Вот как она действует в динамике:
Еще одна альтернатива плоской солнечной батарее, появившаяся в 2022 году – это вращающийся солнечный конус V3Solar. Он работает вот так:
Такой прибор генерирует на 20% больше солнечной энергии, чем плоская солнечная панель. Более того, за счет быстрого вращения конус не перегревается и, соответственно, фотоэлементы не выгорают, дольше сохраняя работоспособность. Вообще V3Solar обладает следующими преимуществами:
* Благодаря вращению, в конусе возникает «стробоскопический» эффект. Из-за этого фотоэлементы конуса быстрее отдают электроны и, следовательно, производят больше электричества.
* Фотоэлементы оснащены специальной оптикой. С одной стороны, стекло защищает фотоэлементы от перегрева, но, кроме того, состав стекла подобран так, чтобы фотоэлементы улавливали солнечную энергию в максимально широком спектре.
* При помощи обычного инвертора конус может генерировать переменный ток.
* Конус V3Solar устойчив сам по себе. Соответственно, не требуется никакой рамы или опор, на которые он бы устанавливался. Его можно установить на ровной поверхности и просто подключить проводами к тому устройству, которое мы собираемся запитывать, а также заземлить такую батарею.
Представленная картина позволяет предположить, что магистральное развитие солнечных батарей направлено в сторону их компактификации, а не расширения. В целом эти устройства все сильнее напоминают умные подсолнечники. Возможно, со временем солнечные батареи будут слагаться из все более мелких (и даже миниатюрных) фрагментов, напоминающих лепестки или соты. Это позволило бы легко ремонтировать их, не выводя из эксплуатацию всю установку, а также аккумулировать энергию, защищать фотоэлементы от снега или града и адаптивно подходить к изменению инсоляции. В условиях глобального потепления и непредсказуемого изменения метеорологии «умные цветы» и «солнечные конусы» могут превратиться в целый класс всепогодных энергетических установок. | https://habr.com/ru/post/665950/ | null | ru | null |
# Как Magento 2 взаимодействует с Vue Storefront
Привет! Меня зовут Павел и я занимаюсь бэкенд разработкой. Как уже писал [AndreyHabr](https://habr.com/ru/users/andreyhabr/), многие из наших проектов основаны на стеке [Adobe Magento 2](https://magento.com/) (для краткости далее я буду называть ее M2) в качестве бэкенда и [Vue Storefront](https://www.vuestorefront.io/) (VS) в качестве фронтенда.
Я не буду подробно останавливаться на архитектуре стека VS/M2 — мы уже [писали](https://habr.com/ru/company/rshb/blog/518746/) об этом ранее. Предлагаю ознакомиться с данной статьей для более полного понимания изложенного ниже.
Сегодня я расскажу о взаимодействии с VS изнутри M2: посмотрим на реализацию индексеров, обсудим особенности их работы, после чего я кратко расскажу как создать свой индексер для кастомной сущности.
Погнали!
Модули интеграции
-----------------
Официальные модули интеграции M2 и VS разрабатывает компания Divante. Модули представлены в их [репозитории на Github](https://github.com/DivanteLtd) и распространяются под [лицензией MIT](https://opensource.org/licenses/MIT). Пакет интеграционных модулей включает в себя:
* Divante\_ReviewApi;
* Divante\_VsbridgeIndexerCore;
* Divante\_VsbridgeIndexerCatalog;
* Divante\_VsbridgeIndexerCms;
* Divante\_VsbridgeIndexerTax;
* Divante\_VsbridgeIndexerReview;
* Divante\_VsbridgeIndexerAgreement;
* Divante\_VsbridgeDownloadable.
Несложно догадаться, что все модули кроме первого занимаются индексацией различных сущностей с целью размещения их в Elasticsearch, используемый VS в качестве хранилища сущностей. Модуль `Divante_ReviewApi` реализует API для работы с отзывами (создание, удаление, получение коллекций).
Из коробки модули обеспечивают индексацию следующих сущностей:
* Категории и продукты каталога;
* CMS страницы и блоки;
* Отзывы;
* Налоги;
* Соглашения;
* Ссылки на скачиваемые продукты.
Из этого следует, что связка M2 и VS прямо после установки способна выполнять все базовые задачи интернет-магазина и требует минимальной настройки для начала применения.
Индексируем!
------------
Посмотрим вблизи на реализацию индексеров. Для примера возьмем индексер CMS Page из стандартной поставки Divante. В целом, индексеры VSBridge работают на тех же принципах, что и другие индексеры в M2.
Объявляется новый индексер:
```
Vsbridge Cms Page Indexer
Update Cms Pages in Elastic
```
*etc/indexer.xml*
Где объявляется **класс-индексер**. Данный класс реализует общий для всех индексеров интерфейс `\Magento\Framework\Indexer\ActionInterface`, поэтому функционально схож с остальными индексерами M2. Его задача — запуск индексации в разных ситуациях. Здесь нас интересует свойство `$cmsPageAction`, содержащее Action класс, извлекающий сущности для индексации:
```
public function execute($ids)
{
$stores = $this->storeManager->getStores();
foreach ($stores as $store) {
$this->indexHandler->saveIndex($this->cmsPageAction->rebuild($store->getId(), $ids), $store);
$this->indexHandler->cleanUpByTransactionKey($store, $ids);
$this->cacheProcessor->cleanCacheByTags($store->getId(), ['cmsPage']);
}
}
```
*Model/Indexer/CmsPage.php*
**Action класс** содержит единственный метод rebuild, который получает коллекцию и готовит ее для индексации:
```
public function rebuild($storeId = 1, array $pageIds = [])
{
$lastPageId = 0;
do {
$cmsPages = $this->resourceModel->loadPages($storeId, $pageIds, $lastPageId);
foreach ($cmsPages as $pageData) {
$lastPageId = (int)$pageData['page_id'];
$pageData['id'] = $lastPageId;
$pageData['content'] = $pageData['content'];
$pageData['active'] = (bool)$pageData['is_active'];
if (isset($pageData['sort_order'])) {
$pageData['sort_order'] = (int)$pageData['sort_order'];
}
unset($pageData['creation_time'], $pageData['update_time'], $pageData['page_id']);
unset($pageData['created_in']);
unset($pageData['is_active'], $pageData['custom_theme'], $pageData['website_root']);
yield $lastPageId => $pageData;
}
} while (!empty($cmsPages));
}
```
*Model/Indexer/Action/CmsPage.php*
Обратите внимание, что коллекция элементов извлекается методом loadPages **ресурсной модели** следующим образом:
```
public function loadPages($storeId = 1, array $pageIds = [], $fromId = 0, $limit = 1000)
{
$metaData = $this->getCmsPageMetaData();
$linkFieldId = $metaData->getLinkField();
$select = $this->getConnection()->select()->from(['cms_page' => $metaData->getEntityTable()]);
$select->join(
['store_table' => $this->resource->getTableName('cms_page_store')],
"cms_page.$linkFieldId = store_table.$linkFieldId",
[]
)->group("cms_page.$linkFieldId");
$select->where(
'store_table.store_id IN (?)',
[
Store::DEFAULT_STORE_ID,
$storeId,
]
);
if (!empty($pageIds)) {
$select->where('cms_page.page_id IN (?)', $pageIds);
}
$select->where('is_active = ?', 1);
$select->where('cms_page.page_id > ?', $fromId)
->limit($limit)
->order('cms_page.page_id');
return $this->getConnection()->fetchAll($select);
}
```
*Model/ResourceModel/CmsPage.php*
Данный метод может извлекать данные итеративно, коллекциями по 1000 элементов, либо только определенный набор элементов с IDs, указанными в переменной $pageIds.
Полученную коллекцию **IndexHandler** класса Indexer сохраняет в базу elasticsearch:
```
public function saveIndex(Traversable $documents, StoreInterface $store)
{
try {
$index = $this->getIndex($store);
$storeId = (int)$store->getId();
$batchSize = $this->indexOperations->getBatchIndexingSize();
foreach ($this->batch->getItems($documents, $batchSize) as $docs) {
foreach ($index->getDataProviders() as $dataProvider) {
if (!empty($docs)) {
$docs = $dataProvider->addData($docs, $storeId);
}
}
if (!empty($docs)) {
$bulkRequest = $this->indexOperations->createBulk()->addDocuments(
$index->getName(),
$index->getType(),
$docs
);
$this->indexOperations->optimizeEsIndexing($storeId, $index->getName());
$response = $this->indexOperations->executeBulk($storeId, $bulkRequest);
$this->indexOperations->cleanAfterOptimizeEsIndexing($storeId, $index->getName());
$this->bulkLogger->log($response);
}
$docs = null;
}
if ($index->isNew()) {
$this->indexOperations->switchIndexer($store->getId(), $index->getName(), $index->getIdentifier());
}
$this->indexOperations->refreshIndex($store->getId(), $index);
} catch (ConnectionDisabledException $exception) {
// do nothing, ES indexer disabled in configuration
} catch (ConnectionUnhealthyException $exception) {
$this->indexerLogger->error($exception->getMessage());
$this->indexOperations->cleanAfterOptimizeEsIndexing($storeId, $index->getName());
throw $exception;
}
}
```
*Модуль Divante\_VsbridgeIndexerCore: Indexer/GenericIndexerHandler.php*
На этом этапе важно упомянуть **класс Mapper**, который задает типы полей объекта для elasticsearch.
```
public function getMappingProperties()
{
$properties = [
'id' => ['type' => FieldInterface::TYPE_LONG],
'active' => ['type' => FieldInterface::TYPE_BOOLEAN],
'sort_order' => ['type' => FieldInterface::TYPE_LONG],
//compatible with product/category attribute mapping
'page_layout' => ['type' => FieldInterface::TYPE_KEYWORD],
'identifier' => ['type' => FieldInterface::TYPE_KEYWORD],
];
foreach ($this->textFields as $field) {
$properties[$field] = ['type' => FieldInterface::TYPE_TEXT];
}
$mappingObject = new \Magento\Framework\DataObject();
$mappingObject->setData('properties', $properties);
$this->eventManager->dispatch(
'elasticsearch_cms_page_mapping_properties',
['mapping' => $mappingObject]
);
return $mappingObject->getData();
}
```
*Index/Mapping/CmsPage.php*
Это может быть необходимо, в том числе, если поле должно участвовать в полнотекстовом поиске — в этом случае полю надо задать тип `keyword`.
Данный класс используется в файле `vsbridge_indices.xml`, который задает идентификатор индекса и класс Mapper для полей объектов в индексе:
```
Divante\VsbridgeIndexerCms\Model\Indexer\DataProvider\Page\ContentData
```
*etc/vsbridge\_indices.xml*
Полная индексация элементов производится путем выполнения команды `bin/magento indexer:reindex`, которая последовательно запускает все индексеры М2. Также можно запустить конкретный индексер, указав его идентификатор в параметрах команды: `bin/magento indexer:reindex` .
Из описанной процедуры индексации следуют несколько важных выводов:
* Объект в elasticsearch *не обязан* полностью отражать объект в БД M2. Его можно сократить, убрав некоторые поля, или наоборот дополнить — к примеру, на этапе выборки приджоинить таблицу с дополнительными данными. Также данные можно модифицировать после выборки. Это дает свободу и удобство при размещении объектов в elasticsearch, например если нужно разрешать поля с foreign ключами в их значения;
* Объект для индексации *не обязательно доставать из базы* — он может быть взят откуда угодно, к примеру, получен через запрос к внешнему источнику;
* Выборку *можно производить посредством стандартных инструментов М2*, например через репозитории или коллекции, а не сырым запросом в БД, как в примере выше.
Актуализация данных в elasticsearch
-----------------------------------
Конечно же, запускать полную реиндексацию каждый раз, когда какой либо объект меняется в базе, было бы расточительно. Для отслеживания изменения объектов в базе и их актуализацией в elasticsearch следит механизм M2, который называется **mview**. Данный механизм состоит из триггеров в таблице, за которой производится наблюдение, индексной таблицы в которой фиксируются ID измененных сущностей, а также cron-задачи, которая считывает ID измененных сущностей из индексной таблицы и запускает индексер с указанием этих ID (вспомним, что метод `loadPages` ресурсной модели может принимать в качестве аргумента массив ID). Рассмотрим каждый из элементов механизма подробнее.
Создание триггеров инициируется созданием файла *mview.xml*:
```
```
*etc/mview.xml*
После присвоения индексеру статуса *Scheduled* указанная в файле таблица приобретает триггеры на добавление, изменение и удаление объектов в таблице. ID модифицированного объекта добавляется индексную таблицу с указанием версии изменений:
Крон-задача один раз в минуту (по умолчанию) делает выборку из этих таблиц, составляет массив ID измененных объектов, после чего запускает соответствующий индексер. Таким образом, данные в elasticsearch постоянно сохраняют актуальность максимально экономичным способом.
Добавляем индексер для своей сущности
-------------------------------------
Главным достоинством этого механизма является способность к расширению. Представим, что у нас есть сущность, которую необходимо разместить в эластике. Назовем ее whiteRabbit. Создадим для ее индексации стандартный M2 модуль, после чего создадим свой индексер:
```
xml version="1.0" encoding="UTF-8"?
White Rabbits Indexer
Update White Rabbits in Elastic
```
*etc/indexer.xml*
А также сразу зададим таблицу за которой будем следить и идентификатор индекса, в котором будут храниться наши объекты:
```
xml version="1.0" encoding="UTF-8"?
```
*etc/mview.xml*
```
xml version="1.0" encoding="UTF-8"?
```
*etc/vsbridge\_indices.xml*
Создадим индексер, маппер и экшен:
```
php
namespace RSHB\WhiteRabbit\Model\Indexer;
use Divante\VsbridgeIndexerCore\Indexer\StoreManager;
use Exception;
use Magento\Framework\Indexer\ActionInterface as IndexerActionInterface;
use Magento\Framework\Mview\ActionInterface as MviewActionInterface;
use Divante\VsbridgeIndexerCore\Indexer\GenericIndexerHandler as IndexerHandler;
use RSHB\WhiteRabbit\Model\Indexer\Action\WhiteRabbit as WhiteRabbitAction;
/**
* Class WhiteRabbit
* @package RSHB\WhiteRabbit\Model\Indexer
*/
class WhiteRabbit implements IndexerActionInterface, MviewActionInterface
{
/**
* @var IndexerHandler
*/
private $indexHandler;
/**
* @var WhiteRabbitAction
*/
private $WhiteRabbitAction;
/**
* @var StoreManager
*/
private $storeManager;
/**
* WhiteRabbit constructor.
* @param IndexerHandler $indexerHandler
* @param WhiteRabbitAction $action
* @param StoreManager $storeManager
*/
public function __construct(
IndexerHandler $indexerHandler,
WhiteRabbitAction $action,
StoreManager $storeManager
) {
$this-indexHandler = $indexerHandler;
$this->whiteRabbitAction = $action;
$this->storeManager = $storeManager;
}
/**
* @inheritdoc
* @throws Exception
*/
public function execute($ids)
{
$stores = $this->storeManager->getStores();
foreach ($stores as $store) {
$this->indexHandler->saveIndex($this->whiteRabbitAction->rebuild($ids), $store);
$this->indexHandler->cleanUpByTransactionKey($store, $ids);
}
}
/**
* @inheritdoc
* @throws Exception
*/
public function executeFull()
{
$stores = $this->storeManager->getStores();
foreach ($stores as $store) {
$this->indexHandler->saveIndex($this->whiteRabbitAction->rebuild(), $store);
$this->indexHandler->cleanUpByTransactionKey($store);
}
}
/**
* @inheritdoc
* @throws Exception
*/
public function executeList(array $ids)
{
$this->execute($ids);
}
/**
* @inheritdoc
* @throws Exception
*/
public function executeRow($id)
{
$this->execute([$id]);
}
}
```
*Model/Indexer/WhiteRabbit.php*
```
php
namespace RSHB\WhiteRabbit\Index\Mapping;
use Divante\VsbridgeIndexerCore\Api\Mapping\FieldInterface;
use Divante\VsbridgeIndexerCore\Api\MappingInterface;
use Magento\Framework\DataObject;
use Magento\Framework\Event\ManagerInterface as EventManager;
/**
* Class WhiteRabbit
* @package RSHB\WhiteRabbit\Index\Mapping
*/
class WhiteRabbit implements MappingInterface
{
/**
* @var EventManager
*/
private $eventManager;
/**
* WhiteRabbit constructor.
* @param EventManager $eventManager
*/
public function __construct(
EventManager $eventManager
) {
$this-eventManager = $eventManager;
}
/**
* @inheritdoc
*/
public function getMappingProperties()
{
$properties = [
'id' => ['type' => FieldInterface::TYPE_LONG]
];
$mappingObject = new DataObject();
$mappingObject->setData('properties', $properties);
$this->eventManager->dispatch(
'elasticsearch_white_rabbit_mapping_properties',
['mapping' => $mappingObject]
);
return $mappingObject->getData();
}
}
```
*Index/Mapping/WhiteRabbit.php*
```
php
namespace RSHB\WhiteRabbit\Model\Indexer\Action;
use RSHB\WhiteRabbit\Model\ResourceModel\WhiteRabbit as WhiteRabbitResource;
use Traversable;
/**
* Class WhiteRabbit
* @package RSHB\WhiteRabbit\Model\Indexer\Action
*/
class WhiteRabbit
{
/**
* @var WhiteRabbitResource
*/
private $resourceModel;
public function __construct(
WhiteRabbitResource $resourceModel
) {
$this-resourceModel = $resourceModel;
}
/**
* Rebuild
*
* @param array $ids
* @return Traversable
*/
public function rebuild(array $ids = [])
{
$lastId = 0;
do {
$rabbits = $this->resourceModel->load($ids, $lastId);
foreach ($rabbits as $rabbit) {
$lastId = (int)$rabbit['id'];
$rabbitData['id'] = $lastId;
$rabbitData = $rabbit;
yield $lastId => $rabbitData;
}
} while (!empty($rabbits));
}
}
```
*Model/Indexer/Action/WhiteRabbit.php*
А также ресурсную модель:
```
php
namespace RSHB\WhiteRabbit\Model\ResourceModel;
use Magento\Framework\App\ResourceConnection;
use Magento\Framework\DB\Adapter\AdapterInterface;
/**
* Class WhiteRabbit
* @package RSHB\WhiteRabbit\Model\ResourceModel
*/
class WhiteRabbit
{
/**
* @var ResourceConnection
*/
private $resource;
/**
* Organization constructor.
* @param ResourceConnection $resourceConnection
*/
public function __construct(
ResourceConnection $resourceConnection
) {
$this-resource = $resourceConnection;
}
/**
* @param array $ids
* @param int $fromId
* @param int $limit
* @return array
*/
public function load($ids, $fromId, $limit = 1000)
{
$select = $this->getConnection()->select()->from('rshb_white_rabbit');
if (!empty($ids)) {
$select->where('id IN (?)', $ids);
}
$select->where('id > ?', $fromId)
->order('id')
->limit($limit);
return $this->getConnection()->fetchAll($select);
}
/**
* @return AdapterInterface
*/
private function getConnection()
{
return $this->resource->getConnection();
}
}
```
*Model/ResourceModel/WhiteRabbit.php*
Не забудем указать идентификатор индекса для класса IndexerHandler, для чего воспользуемся виртуальным типом:
```
...
white\_rabbit
white\_rabbit
vue\_storefront\_white\_rabbit
RSHB\WhiteRabbit\Indexer\WhiteRabbitIndexOperationsVirtual
...
```
*etc/di.xml*
И, в качестве последнего штриха, создадим дата патч, который включит для нашего вновь созданного индексера режим индексации по крону:
```
php
namespace RSHB\WhiteRabbit\Setup\Patch\Data;
use Exception;
use Magento\Framework\Indexer\IndexerRegistry;
use Magento\Framework\Setup\Patch\DataPatchInterface;
use Psr\Log\LoggerInterface;
/**
* Class SetWhiteRabbitIndexerScheduleMode
* @package RSHB\WhiteRabbit\Setup\Patch\Data
*/
class SetWhiteRabbitIndexerScheduleMode implements DataPatchInterface
{
/**
* @var LoggerInterface
*/
private $logger;
/**
* @var IndexerRegistry
*/
private $indexerRegistry;
/**
* SetWhiteRabbitIndexerScheduleMode constructor.
* @param LoggerInterface $logger
* @param IndexerRegistry $indexerRegistry
*/
public function __construct(
LoggerInterface $logger,
IndexerRegistry $indexerRegistry
) {
$this-logger = $logger;
$this->indexerRegistry = $indexerRegistry;
}
/**
* @return DataPatchInterface|void
*/
public function apply()
{
try {
$indexer = $this->indexerRegistry->get('vsbridge_white_rabbit_indexer');
$indexer->setScheduled(true);
} catch (Exception $e) {
$this->logger->critical($e);
}
}
/**
* @inheritDoc
*/
public static function getDependencies()
{
return [];
}
/**
* @inheritDoc
*/
public function getAliases()
{
return [];
}
}
```
*Setup/Patch/Data/SetWhiteRabbitIndexerScheduleMode.php*
На этом наш индексер готов.
Подведение итогов
-----------------
Механизм индексации данных позволяет действовать M2 и VS автономно, обеспечивая слабую связанность и, как следствие, повышение надежности и быстродействия. Гибкий механизм масштабирования позволяет использовать elasticsearch для хранения разнообразной информации, а скорость выборки и поиска позволяет фонтенду работать быстро.
Напоследок хотелось бы заострить внимание на некоторых нюансах работы индексеров, с которыми мы сталкиваись в процессе работы:
* Если у объекта меняется набор полей или их типы, необходимо удалить индекс из ealasticsearch и запустить полную индексацию. Это происходит по причине несоответствия типов полей новых объектов с теми, что уже есть в индексе;
* Индексация не запустится, если данные в таблицу попадают при помощи дампа. В этом случае также нужно запустить индексацию вручную;
* Если в процессе индексации в объект elasticsearch включаются данные из другого объекта (к примеру, разрешается foreign ключ в его значение при помощи join`а таблицы) то необходимо отслеживать изменения этой таблицы и обеспечивать внесение в индексную таблицу ID элементов, для которых изменились данные, связанные foreign ключами.
На этом все. Пишите код с удовольствием, используйте правильные решения и да пребудет с вами сила. | https://habr.com/ru/post/521692/ | null | ru | null |
# Как хотел срубить бабла с корпорации добра
У меня чудесная IT работа в русской провинции.
К тому же приличная зарплата. Даже по столичным меркам.
Несмотря на это, перед сном я мечтаю. Среди алчных мечт — получать какие-нибудь небольшие деньги за ничего-не-делание.
Ну, чтобы я спал, а денежка шла.
Доллар за день.
И доллар за ночь. Глядишь, за год можно положить под елку очередному сыну очередной iPad (=365\*2$).
Понятно, для осуществления мечты нужно иметь Xcode+iPhone. Или Eclipse+Droid. Или VS+Mozart.
Мечты сбываются.
Но не сразу.
#### Лирическое отступление
Предупреждаю, я страшный игроман. Играл во все, что шевелится.
В футбол, perl, хоккей, BlockOut2, теннис, Descent, php, преферанс, objective-C, бридж, mysql, деберц, тотализатор Евро 2012.
Ставлю на Италию против Испании 100 рублей, кто принимает?
Однако, для игры на рабочем месте мне не хватало пасьянса. Для расслабления и тренировки мозгов. Быстрого, интересного, и чтобы сравнить свой IQ с другими.
Так я придумал Саровские Башни и впервые сделал сайт для коллективной очно-заочной игры.
Программист из меня никакой по части аккуратности, и здесь я опасаюсь разбудить настоящих хабра-охотников за утечками памяти.
Мне от них уже изрядно доставалось. Пожалуйста, ребята, потише.
В результате на моей странице появилось около 100 фанатов игры, с которыми мы уже 5-ый год рубимся в башни.
О монетизации я не думал, или думал лениво.
#### Как я вступил в Google
В 2008 году мне неожиданно пришел бесплатный сертификат от Google на 1200 рублей.
За эти деньги Google предлагал рекламировать сайт или образ жизни или что-новый-хозяин-нужно.
Здорово, подумал я, и попал на 400 рублей. Потому что для активации сертификата на свой Google AdSence счет надо было положить деньги.
Развод небольшой. И я раскошелился.
Тем более, кроме рекламы, Google предложил разместить баннеры на сайте.
-Вот!-подумал я. Отыграю на рекламе чужих сервисов свои 400 рублей и буду счастлив.
За пару недель прокрутки баннеров на мой счет упало 2 доллара.
-Ура!-размечтался я о ящике пива.
-Хрен! — сказал Google и забанил мой аккаунт.
Типа я читер. И нечестно кликаю.
Я обиделся и снял баннеры.
#### Телефон ворвался в мою жизнь
Через 2 года я сделал Башни для iPhone и заработал на iAd рекламе много денег.
Никаких претензий Apple мне не выдвигал. Лишь попросил переставить баннер наверх экрана.
Несмотря на финансовый и моральный успех, обиду на Google за те 2 доллара и 400 рублей я затаил.
Прошел еще год. Я написал советскую игрушку Чапаева.
Бесплатную конечно, она же на русском языке.
В нее сыграло 100 000 человек. iAd денег не принес — он в России и Европе не работает.
А Вы не знали? Странно. Откуда у Вас приглашение на Хабр?
И я снова завел аккаунт в Google AdMob.
Разместил баннеры в игре. Ненавязчиво. В феврале 2012.
И бабосы пошли. От 5 до 10 баксов в день.
#### Статистика от Admob
В апреле 2012 накопилось более 500 долларов. Я держал паузу. Google не выдержал и прислал письмо.
#### Бабосы пошли
```
Congratulations!
We have begun processing a payment for you, totaling $396.45.
This payment is for all unpaid earnings accumulated through the end of March 2012.
You will notice that $396.45 has been deducted from your pending earnings to reflect this payment.
If you are an international publisher being paid by check, please allow up to 5 weeks for your check to be delivered.
All checks are sent by standard US Postal Service mail,and there can be some delay in international delivery.
Given the additional processing time that checks require, we strongly suggest that publishers switch payment methods to either PayPal or ACH/Wire.
Because payment processing has now begun, it is not possible to stop this pending payment or to change your payment information.
If there is an error in the payment information you've entered that needs to be corrected, please contact us through the Contact tool on admob.com.
Regards,
The AdMob Team
```
-Ура! — прошептал я.
-Хрен! — сказал Google и забанил мой аккаунт на следующий день.
#### Хренасе
```
Your account has been disabled for invalid activity or repeated policy violations.
Some examples include recurring manual clicks or impressions, violation of our content policies which can be found here,
robots,
automated click and impression generating tools,
third-party services that generate clicks or impressions such as pay-to-click, pay-to-surf, autosurf, and click-exchange programs,
or any deceptive software.
```
Я удивился. Но не обиделся, а перешел на другую рекламную площадку. Smaato.
Прошло 2 недели на одобрение новой версии Чапая в appStore.
Еще 4 дня на одобрение Smaato.
Еще 2 недели набирал статистику и получил взад вожделенные 400 рублей.
#### Неделя статистики SMAATO
От Smaato падает ежедневно 2 доллара.
Деньги небольшие.
Но я не жадный.
К тому же таких приложений у меня 50 штук. Перевожу их на Smaato, и надеюсь все будет тип-топ.
Чего и Вам желаю.
А Google еще помирится со мной. Ведь он корпорация добра.
P.S. Ушел смотреть Испания-Италия. Forza ragazzi.
P.S.S. Вот куча [Чапаевых в appStore](http://www.appannie.com/search/?q=chapay). Мой — со звездой. | https://habr.com/ru/post/145609/ | null | ru | null |
# В поисках компактного FizzBuzz на Python
source: http://www.mwctoys.com/REVIEW\_010413a.htmПришло время оживить преданный забвению FizzBuzz. Попробуем найти самое компактное решение FizzBuzz на Python.
---
### Условие задачи
Напишите программу, печатающую числа от 1 до 100. Вместо чисел кратных трём, программа должна печатать 'Fizz'. Вместо чисел кратных пяти - 'Buzz'. Если число кратно и трём, и пяти, программа должна печатать 'FizzBuzz'.
### Основа
Начнём со стандартного, классического решения:
```
for i in range(1, 101):
if i%3==0 and i%5==0:
print('FizzBuzz')
elif i%3==0:
print('Fizz')
elif i%5==0:
print('Buzz')
else:
print(i)
```
**Укладываем стандартное решение в стандартный однострочник**
```
print('\n'.join('FizzBuzz' if i%3==0 and i%5==0 else 'Fizz' if i%3==0 else 'Buzz' if i%5==0 else str(i) for i in range(1, 101)))
```
**Избавляемся от Join, приручаем Print**
```
[print('FizzBuzz' if i%3==0 and i%5==0 else 'Fizz' if i%3==0 else 'Buzz' if i%5==0 else i) for i in range(1, 101)]
```
**Добавляем срез, укрощаем if else**
```
[print('FizzBuzz'[4 if i%3 else 0:4 if i%5 else 8] or i) for i in range(1, 101)]
```
**Оптимизируем срез, избавляемся от if else**
```
[print('FizzBuzz'[i*i%3*4:8--i**4%5] or i) for i in range(1, 101)]
```
Сократили неплохо. Но, похоже с этой вариацией дальше не продвинуться. Пробуем иной вариант.
**Заменяем срез конкатенацией, вертаем оператор modulo**
```
[print('Fizz'*(i%3==0)+'Buzz'*(i%5==0) or i) for i in range(1, 101)]
```
**Оптимизируем решение. Выравниваем по длине со срезом**
```
[print((i%3<1)*'Fizz'+(i%5<1)*'Buzz' or i) for i in range(1, 101)]
```
**Уходим в отрыв. Модифицируем окончательный вариант**
```
[print(i%3//2*'Fizz'+i%5//4*'Buzz' or i+1) for i in range(100)]
```
---
### А что по скорости?
```
print('\n'.join('FizzBuzz' if i%3==0 and i%5==0 else 'Fizz' if i%3==0 else 'Buzz' if i%5==0 else str(i) for i in range(1, 101))) # 2.53 msec
[print('FizzBuzz' if i%3==0 and i%5==0 else 'Fizz' if i%3==0 else 'Buzz' if i%5==0 else i) for i in range(1, 101)] # 8.11 msec
[print('FizzBuzz'[4 if i%3 else 0:4 if i%5 else 8] or i) for i in range(1, 101)] # 8.43 msec
[print('FizzBuzz'[i*i%3*4:8--i**4%5] or i) for i in range(1, 101)] # 8.31 msec
[print('Fizz'*(i%3==0)+'Buzz'*(i%5==0) or i) for i in range(1, 101)] # 8.38 msec
[print((i%3<1)*'Fizz'+(i%5<1)*'Buzz' or i) for i in range(1, 101)] # 8.4 msec
[print(i%3//2*'Fizz'+i%5//4*'Buzz' or i+1) for i in range(100)] # 8.49 msec
```
Методика расчёта: python -m timeit "выражение"
---
### Вместо заключения
Помимо этой статьи, на Хабре мною опубликованы ещё пара статей на тему Python однострочников. Если интересно, ознакомиться можно по ссылкам ниже:
* [5++ способов в одну строку на Python решить первую задачу Проекта Эйлера](https://habr.com/ru/post/585176/)
* [Занимательные фигуры на Python в одну строку](https://habr.com/ru/post/591591/)
Всем спасибо. | https://habr.com/ru/post/593489/ | null | ru | null |
# Разработка приложений на Ruby on Rails в Visual Studio
Речь сегодня пойдет о том, как разрабатывать и отлаживать приложения на всеми уже давно любимом фрэймворке Ruby on Rails. Для ~~всех~~ меня лично с первого дня знакомства с Rails привычно стало использование следующей связки:
— Ubuntu
— Rvm
— Gedit + terminal (в качестве среды разработки)
Но сегодня хотелось бы поговорить о разработке на рельсах именно под ~~виндой~~ Windows в лучшей ~~объективно~~ по моему мнению среде разработки на сегодняшний день MS Visual Studio. Кому интересно прошу под кат.
Уверен что многие ценители рельсов начнут ~~блевать~~ негативно реагировать подумав о разработке под виндой. Тем не менее считаю данный пост имеет место быть. Сразу оговорюсь не являюсь сторонником не винды, ни иксов. Много лет разрабатывал на C#, пару лет пишу на Rails. Итак приступим.
#### Установка
1. Первое что нам нужно будет сделать, это скачать и установить Visual Studio, 2010 или 2012, я лично предпочитаю десятую. У меня она уже была установлена на виртуалке, поэтому на этом шаге мы останавливаться не будем
2. Дальше идем по ссылке и скачиваем [«ruby in steel»](http://www.sapphiresteel.com/downloads/ris/install.exe). После того как скачали и запустили вылезет замечательное окошко в котором нужно выбрать все три галочки и ~~наслаждаться процессом установки~~
ждать пока installer скачает из интернета порядка 200 MB, потом установит все это дело. Процесс это как оказалось не быстрый, особо нервные на этом отрезке могут сходить попить кофе и покурить.
.
#### Первый проект
Итак, после того как мы наконец дождались окончания установки, попробуем создать первый проект: Файл -> Создать-> Проект
После часового ожидания в надежде, что все заработает получил подарок в виде следующей ошибки:
Думаю это практически нормально, ожидать что под виндой все заведется с первого раза было наверно наивно. Ошибка нам собственно говорит о том что у нас не стоят рельсы, хотя предполагалось, что «ruby in steel» сделает все за нас. Итак:
* Идем в командную строку
* Переходим в директорию C:\Ruby192\bin
* Набираем команду gem list, видим что установлены только два гема и ни один из них не rails
* Набираем команду gem install rails и ждем ~~с моря погоды~~ еще около получаса.
Дождались, новая ошибка:
`ERROR: Error installing rails:
The 'json' native gem requires installed build tools.
Please update your PATH to include build tools or download the DevKit
from 'http://rubyinstaller.org/downloads' and follow the instructions
at 'http://github.com/oneclick/rubyinstaller/wiki/Development-Kit'`
Идем на <http://rubyinstaller.org/downloads> и ~~бьемся головой о стену~~ качаем DevKit. После загрузки распаковываем архив в папку C:\DevKit, запускаем ruby консоль и выполняем следующие команды
* ruby dk.rb init
* ruby dk.rb review
* ruby dk.rb install
Теперь можем спокойно установить рельсы. После успешной установки, снова пытаемся создать проект:
Тут выбираем СУБД на свое усмотрении, после установки DevKit особых проблем не должно быть вне зависимости от выбранной СУБД. Я предпочел выбрать SQLite поскольку винда на виртуалке чистая и установлена только Visual Studio. Итак выбираем название будущей базы нашего приложения и ~~жмякаем~~ нажимаем далее.
Наше приложение готово, в верхней левой части окна появилось замечательная панель, команды на которой можно добавлять.
Все прелести разработки в Visual Studio на C# теперь доступны и для рельсов, а пользоваться магией Rails теперь еще удобнее.
Более подробнее и содержательней возможности разработки на рельсах в Visual Studio в видео ниже
#### Итог
Плюсы steel in ruby
* Удобная IDE
* Полноценная пошаговая отладка
* Простота перехода с других языков поддерживаемых Visual Studio
* Бесплатный триал 60 дней
Минусы steel in ruby
* Неизбежное шаманство при установке
* Цена 249$
Всем кто дочитал спасибо за внимание, если кому было полезно значит не зря было потрачено время. | https://habr.com/ru/post/174103/ | null | ru | null |
# Новая операция кибершпионажа FinFisher: атаки MitM на уровне провайдера?
ESET выявила новые операции с применением шпионской программы FinFisher, также известной как FinSpy, некогда продаваемой правительственным структурам по всему миру. Помимо технических доработок FinFisher, зафиксирован новый, ранее неизвестный вектор заражения, указывающий на возможное участие в схеме крупного интернет-провайдера (ISP).
У [FinFisher](https://en.wikipedia.org/wiki/FinFisher) широкий набор возможностей для слежки через веб-камеру и микрофон, а также функции кейлоггинга и кражи файлов. Что отличает FinFisher от других инструментов слежки, так это противоречивая информация о его внедрении. FinFisher позиционируют как инструмент правоохранительных органов, считается, что [он используется диктатурами](https://citizenlab.ca/2013/03/you-only-click-twice-finfishers-global-proliferation-2/). Мы обнаружили последние версии FinFisher в семи странах. Назвать их, к сожалению, не сможем, чтобы никого не подвергать опасности.
### Заражение целей
В кампаниях FinFisher используют различные механизмы заражения, включая целевой фишинг, установку вручную при наличии физического доступа к устройствам, [уязвимости нулевого дня](https://www.fireeye.com/blog/threat-research/2017/09/zero-day-used-to-distribute-finspy.html) и watering hole атаки – заражение сайтов, которые предположительно посещают потенциальные жертвы (схема использовалась для распространения мобильной версии FinFisher).
Новое и наиболее тревожное в последних кампаниях FinFisher – появление схемы man-in-the-middle, где указанный «man» с большой долей вероятности находится на уровне интернет-провайдера. Мы видели использование этого вектора в двух странах, где обнаружена последняя версия FinFisher (в остальных пяти странах используются традиционные векторы заражения).
Когда пользователь (объект слежки) собирается скачать одно из популярных легитимных приложений, его перенаправляют на версию программы, зараженную FinFisher. Мы видели троянизированные версии WhatsApp, Skype, Avast, WinRAR, VLC Player и некоторых других программ. Важно отметить, что теоретически таким образом можно использовать любое легитимное приложение.
Атака начинается, когда пользователь ищет на легитимных сайтах одно из упомянутых приложений. Когда он нажимает на ссылку для скачивания, его браузер получает модифицированную ссылку, которая перенаправляет его на троянизированный установщик, размещенный на сервере атакующих. После скачивания и исполнения на устройстве пользователя появится не только легитимное приложение, но и шпионское ПО FinFisher.
*Рисунок 1. Механизм заражения последними версиями FinFisher*
Переадресация осуществляется путем подмены легитимной ссылки вредоносной.
Модифицированная вредоносная ссылка доставляется в браузер пользователя с помощью кода ответа на статус перенаправления HTTP 307 Temporary Redirect (запрошенное содержимое временно перемещено по новому адресу). Процесс переадресации невидим для пользователя.
*Рисунок 2. Детальное описание механизма заражения*
### FinFisher: работа вне зоны видимости
Последняя версия FinFisher была технически улучшена, авторы сфокусировались на обеспечении скрытности. Шпионское ПО использует кастомную виртуализацию кода для защиты большинства компонентов, включая драйвер, работающий в режиме ядра. Кроме того, в коде предусмотрены приемы анти-дизассемблирования. Мы обнаружили в FinFisher анти-отладочные, анти-эмуляционные и анти-виртуализационные приемы.
После преодоления первого уровня защиты (анти-дизассемблирование), следующий уровень — виртуализация кода. В диспетчере виртуальной машины 34 обработчика; почти все исполнение шпионского ПО производится в интерпретаторе, что добавляет еще один уровень защиты, с которым придется иметь дело в ходе анализа.
*Рисунок 3. Визуализация многочисленных обработчиков, затрудняющих анализ кода*
В следующем отчете мы представим более детальный технический анализ последней версии FinFisher.
### Особый подход к пользователям, заинтересованным в конфиденциальности
В ходе анализа недавних кампаний мы обнаружили интересный образец – FinFisher, замаскированный под исполняемый файл под названием Threema. Он может быть использован для атак на пользователей, обеспокоенных вопросами приватности, – легитимное приложение Threema обеспечивает безопасный обмен мгновенными сообщениями со сквозным шифрованием. Есть некая ирония в том, что пользователь, стремящийся к конфиденциальности, своими руками загружает файл и запускает процесс слежки.
Акцент на пользователей, интересующихся шифрованием, не ограничивается мессенджерами. В ходе исследования мы обнаружили установочный файл, зараженный FinFisher, в некогда очень популярном ПО для шифрования диска TrueCrypt.
### Кто он – man-in-the-middle?
Технически можно предположить, что man-in-the-middle участвует в атаке на одном из этапов пути от целевого компьютера до легитимного сервера (как вариант, это может быть скомпрометированная точка Wi-Fi). Однако географическое распределение последних версий FinFisher, обнаруженных ESET, позволяет предположить, что атаки MitM производятся на более высоком уровне, и наиболее вероятный вариант – участие интернет-провайдера (ISP).
Это предположение подтверждает ряд фактов. Во-первых, согласно утекшим в сеть материалам, [опубликованным WikiLeaks](https://wikileaks.org/spyfiles4/documents/FinFly-ISP-Catalog.pdf), разработчик FinFisher предлагал решение под названием «FinFly ISP» для развертывания в сетях ISP с функциями, напоминающими те, что нужны для атак MitM. Во-вторых, способ заражения (переадресация HTTP 307) применяется идентичным образом в обеих странах, где происходило заражение. Маловероятно, что данные схемы разработаны и/или предоставлены разными источниками. В-третьих, все пораженные цели в пределах страны используют услуги одного интернет-провайдера. Наконец, тот же метод и формат переадресации используется провайдерами для фильтрации интернет-контента как минимум в одной из этих стран.
Использование техники MitM на уровне провайдера, о котором говорится в утекшем в сеть документе, до сих пор нигде не обнаруживалось – до сегодняшнего дня. Если эта информация подтвердится, новые атаки с FinFisher – начало новых, беспрецедентных по техникам, методам и охвату операций кибершпионажа.
### Мой компьютер заражен?
Все продукты ESET обнаруживают и блокируют эту угрозу как Win32/FinSpy.AA и Win32/FinSpy.AB. При помощи [ESET Online Scanner](https://www.eset.com/ng/home/products/online-scanner/) вы можете проверить компьютер на наличие угрозы и удалить ее при обнаружении. Пользователи ESET защищены автоматически.
### Индикаторы компрометации
**Имена обнаружения ESET:**
Win32/FinSpy.AA
Win32/FinSpy.AB
**Переадресация:**
HTTP/1.1 307 Temporary Redirect\r\nLocation:\r\nConnection: close\r\n\r\n
**Список адресов URL, обнаруженных в процессе исследования:**
`hxxp://108.61.165.27/setup/TrueCrypt-7.2.rar
hxxp://download.downloading.shop/pcdownload.php?a=dad2f8ed616d2bfe2e9320a821f0ee39
hxxp://download.downloading.shop/pcdownload.php?a=84619b1b3dc8266bc8878d2478168baa
hxxp://download.downloading.shop/pcdownload.php?a=ddba855c17da36d61bcab45b042884be
hxxp://download.downloading.shop/pcdownload.php?a=d16ef6194a95d4c8324c2e6673be7352
hxxp://download.downloading.shop/pcdownload.php?a=95207e8f706510116847d39c32415d98
hxxp://download.downloading.shop/pcdownload.php?a=43f02726664a3b30e20e39eb866fb1f8
hxxp://download.downloading.shop/pcdownload.php?a=cb858365d08ebfb029083d9e4dcf57c2
hxxp://download.downloading.shop/pcdownload.php?a=8f8383592ba080b81e45a8913a360b27
hxxp://download.downloading.shop/pcdownload.php?a=e916ba5c43e3dd6adb0d835947576123
hxxp://download.downloading.shop/pcdownload.php?a=96362220acc8190dcd5323437d513215
hxxp://download.downloading.shop/pcdownload.php?a=84162502fa8a838943bd82dc936f1459
hxxp://download.downloading.shop/pcdownload.php?a=974b73ee3c206283b6ee4e170551d1f7
hxxp://download.downloading.shop/pcdownload.php?a=cd32a3477c67defde88ce8929014573d
hxxp://download.downloading.shop/pcdownload.php?a=36a5c94ffd487ccd60c9b0db4ae822cf
hxxp://download.downloading.shop/pcdownload.php?a=0ebb764617253fab56d2dd49b0830914
hxxp://download.downloading.shop/pcdownload.php?a=f35e058c83bc0ae6e6c4dffa82f5f7e7
hxxp://download.downloading.shop/pcdownload.php?a=64f09230fd56149307b35e9665c6fe4c
hxxp://download.downloading.shop/pcdownload.php?a=b3cc01341cb00d91bcc7d2b38cedc064
hxxp://download.downloading.shop/pcdownload.php?a=5fc0440e395125bd9d4c318935a6b2b0
hxxp://download.downloading.shop/pcdownload.php?a=5ca93ad295c9bce5e083faab2e2ac97a
hxxp://download.downloading.shop/pcdownload.php?a=f761984bb5803640aff60b9bc2e53db7
hxxp://download.downloading.shop/pcdownload.php?a=5ca93ad295c9bce5e083faab2e2ac97a
hxxp://download.downloading.shop/pcdownload.php?a=514893fa5f3f4e899d2e89e1c59096f3
hxxp://download.downloading.shop/pcdownload.php?a=a700af6b8a49f0e1a91c48508894a47c
hxxp://download.downloading.shop/pcdownload.php?a=36a5c94ffd487ccd60c9b0db4ae822cf
hxxp://download.downloading.shop/pcdownload.php?a=a700af6b8a49f0e1a91c48508894a47c
hxxp://download.downloading.shop/pcdownload.php?a=395ce676d1ebc1048004daad855fb3c4
hxxp://download.downloading.shop/pcdownload.php?a=cd32a3477c67defde88ce8929014573d
hxxp://download.downloading.shop/pcdownload.php?a=49d6d828308e99fede1f79f82df797e9
hxxp://download.downloading.shop/pcdownload.php?a=d16ef6194a95d4c8324c2e6673be7352`
**Образцы (SHA-1)**
`ca08793c08b1344ca67dc339a0fb45e06bdf3e2f
417072b246af74647897978902f7d903562e0f6f
c4d1fb784fcd252d13058dbb947645a902fc8935
e3f183e67c818f4e693b69748962eecda53f7f88
d9294b86b3976ddf89b66b8051ccf98cfae2e312
a6d14b104744188f80c6c6b368b589e0bd361607
417072b246af74647897978902f7d903562e0f6f
f82d18656341793c0a6b9204a68605232f0c39e7
df76eda3c1f9005fb392a637381db39cceb2e6a8
5f51084a4b81b40a8fcf485b0808f97ba3b0f6af
4b41f36da7e5bc1353d4077c3b7ef945ddd09130
1098ba4f3da4795f25715ce74c556e3f9dac61fc
d3c65377d39e97ab019f7f00458036ee0c7509a7
c0ad9c242c533effd50b51e94874514a5b9f2219
a16ef7d96a72a24e2a645d5e3758c7d8e6469a55
c33fe4c286845a175ee0d83db6d234fe24dd2864
cfa8fb7c9c3737a8a525562853659b1e0b4d1ba8
9fc71853d3e6ac843bd36ce9297e398507e5b2bd
66eccea3e8901f6d5151b49bca53c126f086e437
400e4f843ff93df95145554b2d574a9abf24653f
fb4a4143d4f32b0af4c2f6f59c8d91504d670b41
f326479a4aacc2aaf86b364b78ed5b1b0def1fbe
275e76fc462b865fe1af32f5f15b41a37496dd97
df4b8c4b485d916c3cadd963f91f7fa9f509723f` | https://habr.com/ru/post/338422/ | null | ru | null |
# Связный список в Swift
Сегодня мы поговорим, что такое связный список, что делает его таким особенным, как он работает, чем он отличается от обычного массива ([о котором я подробно писал в прошлой статье](https://habr.com/ru/post/665536/)), и попутно мы увидим, как связные списки хороши для решения определенного класса задач.
Прежде чем мы рассмотрим, что такое связный список, давайте посмотрим, какую проблему он пытается решить. Как бы ни были хороши массивы, есть несколько вещей, которые они не могут сделать.
Во-первых, они медленные, когда дело доходит до вставки спереди, каждый раз, когда нам нужно сделать эту вставку, нам нужно скопировать все наверх, а это занимает линейное время, O(n).Во-вторых, массивы занимают место. Иногда очень много. Каждый раз, когда мы создаем массив, нам нужно указать его размер, и, если он очень большой, мы не используем все это пространство, это может быть расточительно.
Для определенного класса задач нам нужна структура данных, которая очень быстро добавляет элементы вперед, А так же может уменьшаться и увеличиваться и где не нужно указывать размер заранее. На сцену выходит связный список.
**Свя́зный спи́сок** — базовая динамическая структура данных в информатике, состоящая из [узлов](https://ru.wikipedia.org/wiki/%D0%A3%D0%B7%D0%B5%D0%BB_(%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0)), содержащих [данные](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%BB%D0%B5_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85_(%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0)) и [ссылки](https://ru.wikipedia.org/wiki/%D0%A1%D1%81%D1%8B%D0%BB%D0%BA%D0%B0_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)) («связки») на следующий и/или предыдущий узел списка. Принципиальным преимуществом перед [массивом](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%81%D1%81%D0%B8%D0%B2_(%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)) является структурная гибкость: порядок элементов связного списка может не совпадать с порядком расположения элементов данных в памяти компьютера, а порядок обхода списка всегда явно задаётся его внутренними связями.
Эти узлы можно представить себе как вагоны в поезде. Первый узел в списке, называемый "голова"(head), — это место, где мы добавляем элементы в начало нашего списка. Последний узел в списке, "хвост"(tail), он всегда указывает на nil. А все остальное в поезде — это просто связующий вагон с указателем, указывающим на следующий вагон в поезде. В коде это выглядит следующим образом:
```
class Node {
var data: Int
var next: Node?
init(_ data: Int, _ next: Node? = nil) {
self.data = data
self.next = next
}
}
```
ПодробнееСначала мы можем представить узел как класс и определить два необходимых нам типа данных, data и text, как int. А next будет следующей ссылкой в узле. Node в данном случае необязателен, потому что это может быть nil, который будет представлять хвост нашего связанного списка. Затем у нас есть простой инициализатор. Обратите внимание, что данные здесь могут быть любыми. В данном случае мы выбрали int, но это может быть строка или любой другой тип данных.
Теперь создаем класс LinkedList
```
class LinkList {
private var head: Node?
func addFront(_ data: Int) {
let newNode = Node(data)
newNode.next = head
head = newNode
}
func getFirst() -> Int? {
if head == nil {
return nil
}
return head!.data
}
func addBack(_ data: Int) {
let newNode = Node(data)
if head == nil {
head = newNode
return
}
var node = head!
while(node.next != nil) {
node = node.next!
}
node.next = newNode
}
func getLast() -> Int? {
if head == nil {
return nil
}
var node = head!
while(node.next != nil) {
node = node.next!
}
return node.data
}
func insert(position: Int, data: Int) {
if position == 0 {
addFront(data)
return
}
let newNode = Node(data)
var currentNode = head
for _ in 0..
```
Пройдем по каждому методу и посмотри как он работает.
addFront
--------
Главная особенность каждого связного списка - это добавление элемента в начало списка. Мы создаем новый узел, указываем его на head, а затем берем указатель head и указываем его на новый узел. И когда мы это делаем, мы получаем новый узел, вставленный в начало нашего связанного списка. В коде это будет выглядеть следующим образом.
```
func addFront(_ data: Int) {
let newNode = Node(data)
newNode.next = head
head = newNode
}
```
ПодробнееСначала принимаем переданные данные и создаем наш новый узел. Затем мы возьмем наш новый узел nodes.next и направим его в head. Мы просто перенаправляем этот указатель на новый узел. В итоге получим новый узел на передней панели.
Эта способность добавлять спереди - постоянное время. O(1) И это то, чего не может сделать массив. Вы не можете добавить новый элемент в массив за постоянное время. Для этого требуется O(n). Метод отлично подходит когда вам нужно быстро добавить что-то на передний план. Следующее, что вы увидите во многих связанных списках - это метод Get First.
```
func getFirst() -> Int? {
if head == nil {
return nil
}
return head!.data
}
```
ПодробнееДавайте посмотрим, как он работает. Мы хотим получить первый элемент нашего связанного списка. На самом деле, мы просто проверяем две вещи. Во-первых, является ли наш связный список пустым или нулевым? Мы можем определить, пуст ли связанный список, посмотрев на его голову, проверив, равна ли она nil, и если да, то просто вернули nil. Но если у нас есть данные и мы знаем, что head не равна nil, мы можем спуститься, использовать return и просто вернуть данные.
Так мы получим самый первый элемент нашего связного списка, потому что это фронт, который также является O(1). Очень, очень быстро. Далее давайте посмотрим, как мы можем добавить что-то в конец нашего списка с помощью функции Add Back.
addBack
-------
Добавление в конец работает следующим образом. Допустим, мы хотим добавить узел в самый конец, сначала мы создадим наш новый узел. Мы можем сделать проверку в начале. Если бы head был равен nil, мы могли бы просто указать head на новый узел, и все было бы готово. Это был бы одноэлементный связный список. Но если в связанном списке есть другие элементы, то нам нужно пройтись по списку до конца. Мы узнаем, что в конце, когда следующая из самых последних записей будет равна nil. Так мы поймем, что находимся в хвосте. Указываем его следующую точку на новый узел. Теперь у нас есть новый узел, добавленный в хвост. В коде это выглядит следующим образом:
```
func addBack(_ data: Int) {
let newNode = Node(data)
if head == nil {
head = newNode
return
}
var node = head!
while(node.next != nil) {
node = node.next!
}
node.next = newNode
}
```
ПодробнееНовый узел newNode, который мы хотим создать на основе переданных данных. Если head равна nil, мы просто возьмем этот head, направим ее на новый узел и вернемся. У нас получился одноэлементный связный список. Но если в нем есть другие элементы, и head не равен nil, мы создадим новую переменную node, направим ее на head, а затем просто начнем идти по списк, пока node.next не станет равен nil. Когла следующий указатель равен nil, мы поймем, что находимся в хвосте. Тогда просто берем этот узел next, указываем его на новый узел.
Теперь обратите внимание, что всякий раз, когда вы видите этот цикл while в связанном списке, скорость операции будет O(n). Вы уже знаете что в массиве эта операция происходит быстрее.
Метод *getLast*можно разобрать по аналогии:
```
func getLast() -> Int? {
if head == nil {
return nil
}
var node = head!
while(node.next != nil) {
node = node.next!
}
return node.data
}
```
ПодробнееИсходя из того, что мы делали ранее, получение последнего будет очень похожим. Сначала, мы можем просто проверить, равна ли head нулю. Если да, то у нас пустой связный список, поэтому мы можем просто вернуть nil. Но если у нас есть данные в начале, мы можем пройтись по списку. Пройдем по списку пока не попадем в хвост, где next равен nil, а затем просто вернем эти данные.
Insert
------
Как мы будем вставлять данные в определенную позицию нашего связного списка? Вставка - это как ходьба, только мы должны остановиться в том месте, куда хотим вставить узел, и манипулировать указателями, чтобы они указывали на наш новый узел. Нам не нужно делать никаких сдвигов или копирования. Нам просто идти по списку и манипулировать указателями. Как только мы это сделаем, наш новый узел окажется в нужном месте, прямо посередине. В коде это будет выглядеть следующим образом:
```
func insert(position: Int, data: Int) {
if position == 0 {
addFront(data)
return
}
let newNode = Node(data)
var currentNode = head
for _ in 0..
```
ПодробнееСначала мы проверим, находимся ли мы в самом начале связанного списка. Если да, то мы можем просто взять данные и добавить их в начало. Больше здесь ничего делать не нужно. Если мы не находимся в начале списка, мы делаем то же самое, что и раньше. Создаем новый узел, определяем переменную current node, равную head, и проходим по связанному списку. Теперь обратите внимание, что мы проходим его немного по-другому. Вместо того чтобы использовать цикл while и просто постоянно проверяя next на наличие nil, в данном случае мы хотим перейти к определенной позиции минус один, постоянно переходя к текущей позиции node.next.
deleteFirst
-----------
Когда речь идет об удалении элементов из связанного списка, все очень похоже. Вместо того чтобы вставлять элементы, мы собираемся их пропустить. Давайте рассмотрим метод deleteFirst. Чтобы удалить первый элемент или пропустить самую первую node в нашем связанном списке, все, что нам нужно сделать, это взять head и переназначить head на head.next. Это, по сути, приведет к тому, что head будет указывать на первый элемент, в данном случае на самый первый элемент 1, и пропустит его, заставив его указатель перейти к head.next. В данном случае на элемент два. Очень быстро, без хождения по списку, время O(1). В коде это буквально одна строка.
```
func deleteFirst() {
head = head?.next
}
```
ПодробнееМы просто переходим к head, и если в head есть значение, присваиваем его next.
deleteLast
----------
По сути, здесь мы можем использовать предыдущий и следующий узлы, чтобы понять, где мы находимся в нашем цикле. А затем, если мы каким-то образом отслеживаем предыдущий узел в конце, мы можем назначить этот предыдущий узел не для указания на следующий узел. Мы можем пропустить его и указать на nil. Поэтому, по сути, нам нужно выполнить цикл до конца, захватить этот последний узел, а затем присвоить его nill.
```
func deleteLast() {
if head?.next == nil {
head = nil
return
}
var nextNode = head
var previousNode: Node?
while(nextNode?.next != nil) {
previousNode = nextNode
nextNode = nextNode?.next
}
previousNode?.next = nil
}
```
ПодробнееПрежде всего, вы захотите дойти до самого конца, используя тот же трюк, что и раньше, назначив следующий узел равным head и просто итерируя до конца. Здесь нам не нужна проверка if head nil. Если head равен nil, мы просто не будем никуда переходить. Мы выполняем цикл, пока не дойдем до самого конца, постоянно переходя к следующему узлу. Previos node - это то, как мы можем отслеживать предыдущий узел до того, который находится в конце. Таким образом, когда мы добираемся до конца и следующий узел находится в самом конце. мы можем пропустить этот самый последний узел просто изменяя точку next предыдущего узла и присваивая ей значение nil.
Delete at position
------------------
Мы просто переходим к тому месту, где хотим выполнить удаление, а затем пропускаем его, просто переназначая следующий указатель предыдущего узла. . Обратите внимание, что это линейная задача, имеет время выполнения O(n), и в коде она будет выглядеть следующим образом.
```
func delete(data: Int) {
if head == nil { return }
if head!.data == data {
head = head?.next
}
let current = head
while current?.next != nil {
if current?.next?.data == data {
current?.next = current?.next?.next
return
}
}
}
```
ПодробнееСначала мы хотим проверить нашу позицию и убедиться, что мы находимся на самом первом элементе нашего связанного списка. Если да, то мы можем просто удалить первый элемент и вернуться. В противном случае мы проделаем тот же трюк, что и с delete last. Мы возьмем наш nextNode и присвоим его head, но мы будем отслеживать предыдущий узел, присвоив ему переменную, а затем перейдем к нашей позиции. Мы будем постоянно обновлять предыдущий узел. Мы будем переходить к тому месту в списке, где нам нужно быть. А затем, как только мы окажемся там, мы просто перейдем к следующему, взяв точку next узла и указав ее на точку next предыдущего узла.
Итак, прежде чем мы завершим нашу работу и рассмотрим, как связанные списки используются в реальном мире, рассмотрим эти два метода *isEmpty* и *clear*.
```
var isEmpty: Bool {
return head == nil
}
```
Если head равен nil, то мы знаем, что у нас пустой связный список. Супер простое вычисление O(1).
```
func clear() {
head = nil
}
```
Как очистить связный список? Простой способ очистить связный список - это просто взять его head и установить ее равной nil. Здесь у нас может быть сколько угодно элементов связного списка, но если просто присвоить head = nil, то все они исчезнут.
Применение
----------
Связанные списки используются повсеместно в реальном мире. Например связанные списки используются в фреймворке UIKit компании Apple. UIKit с использованием Responder Chain. Для тех из вас, кто не знаком с responder chain, это то, что обеспечивает работу практически всех элементов управления iOS на вашем телефоне. Когда вы создаете приложение, с окном и представлениями, за кулисами есть механизм, который запускает события через эту цепочку ответчиков, и это, по сути, связанный список. Если вам когда-либо приходилось работать с клавиатурой в iOS и вам приходилось отказываться от first responder, то это, по сути, означает, что это вью должно, сделать себя первым, кто будет реагировать в случае прикосновения к экрану. И этот механизм цепочки ответчиков сам по себе является связным списком. [Подробнее про Responder Chain.](https://habr.com/ru/post/464463/)
Отличие от массива
------------------
Хорошо, прежде чем мы закончим, давайте просто быстро сравним и поговорим о различиях между связанными списками и массивами. В чем разница?
Во-первых, связанные списки очень быстры, когда мы выполняем операции на фронте. Так что вставка спереди, удаление спереди, получение элемента спереди - все это O(1), очень быстрое преимущество связанных списков. Другое преимущество связных списков - нам не нужно заранее определять их размер. Они могут динамически расти по мере необходимости. Просто путем добавления к задней части. Они могут вырасти до любого размера и всегда будут именно того размера, который нужен. Никакой напрасной траты памяти.
Недостатки связного списка - отсутствие случайного доступа.Вот где массив действительно выигрывает. Возможность использовать индекс и переходить к любому элементу массива за время O(1) очень быстра. Именно поэтому массивы так популярны. Также get и set в связанном списке выполняются за O(n). Если у вас есть цикл или цикл while, в котором нам нужно пройтись по связному списку, знайте, что эта операция будет O(n).
Но связные списки часто используются в стеках и очередях, потому что когда вы попадаете в стеки и очереди, вы увидите, что многие операции мы выполняем на самом первом или переднем элементе, и это только одно место, где вы часто видите связные списки.
Заключение
----------
Итак, когда речь заходит о связных списках, вот что вам нужно знать для технического собеседования.
Все, что находится впереди, O(1), добавить впереди, получить первым, удалить первым, если кто-то спросит вас, в чем преимущество связного списка?
Он действительно хорош в операциях на фронте, O(1).
Каждый раз, когда вам нужно пройтись по чему-либо в любой структуре данных, это O(n).
В связаном списке addLast/getLast/deleteLast - все эти операции будут O(n).
Всегда правильный размер, и как мы уже говорили, нет случайного доступа. | https://habr.com/ru/post/713162/ | null | ru | null |
# Как устроены технические стажировки Авито
Несколько раз в год мы набираем стажёров в технический департамент Авито. Они работают от шести месяцев до года и решают боевые задачи. По итогам большинство стажёров переходят в штат.
Нас зовут Станислав Юрков и Ирина Мулёва, мы набираем стажёров и помогаем им в процессе обучения. В статье мы расскажем, как устроены технические стажировки и ответим на частые вопросы кандидатов.
На какие направления мы нанимаем стажёров
-----------------------------------------
Авито берёт стажёров по направлениям Frontend, Backend, Mobile под iOS и Android, а также в Quality Assurance. В 2020-2021 году больше всего внимания мы планируем уделить направлениям Backend и Frontend, так что расскажите о нас заинтересованным друзьям.
У нас уже открыты несколько стажёрских позиций, но каждый месяц будут добавляться новые. Все вакансии опубликованы [на отдельной странице](https://start.avito.ru/).
Кроме разработчиков, мы периодически ищем стажёров-аналитиков по направлениям BI и Data Science. О них в этой статье мы рассказывать не будем, но актуальные позиции тоже будут появляться по общей ссылке выше.
Условия стажировки
------------------
Сейчас мы собеседуем и адаптируем новых сотрудников удалённо. Работаем тоже из дома. За 2020 год, несмотря на коронавирус, мы наняли 11 стажёров в технический департамент и уже перевели в штат некоторых из них. Иногда мы устраиваем встречи в офисе небольшим составом, чтобы у людей была возможность познакомиться лично, но основная коммуникация происходит онлайн.
Наша стажировка будет интересна старшекурсникам и недавним выпускникам технических вузов, которые хотят прокачать свои навыки и получить опыт работы в высоконагруженном проекте.
У каждого стажёра есть персональный наставник — инженер Авито. Этот человек ставит задачи, помогает с их решением, обучает новому и принимает результат работы. Наставник всегда из той же функции, что и стажёр, то есть если вы пришли во фронтенд, вам будет помогать опытный фронтендер.
С первого дня стажёры включены в командные процессы. Мы даём боевые задачи и не боимся передавать ответственность. Сейчас сайтом и приложением Авито пользуются более 50 миллионов человек каждый месяц, так что наши стажёры всегда могут справедливо похвастаться, что приложили руку к работе по-настоящему большого сервиса.
Стажировка длится от шести месяцев до года. По нашим наблюдениям, это оптимальный срок для того, чтобы разобраться в инструментах, вникнуть в задачи и раскрыть свой потенциал. Стажёры работают 20 часов в неделю по гибкому графику — работать можно и днём, и вечером, главное заранее договориться о графике со своим наставником.
Разработка в большинстве команд ведётся по Scrum, поэтому есть ежедневные общие встречи для синхронизации по задачам, а также встречи по планированию и грумингу задач, демо и ретроспективы. Стажёру по возможности стоит участвовать в них, чтобы лучше адаптироваться в команде и глубже погрузиться в процессы разработки.
Техническая стажировка оплачивается. Мы платим 40 000 рублей до вычета налога — это 34 800 рублей на карту в месяц. У стажёров других направлений размеры оплаты отличаются, поэтому уточняйте их на собеседовании.
Стажировка записывается в трудовую книжку, а если стажёр переходит в штат на полный рабочий день, мы засчитываем её за испытательный срок. Для того, чтобы стажёр стал штатным сотрудником, должны совпасть сразу несколько факторов: уровень знаний и компетенций, возможность работать полный день, наличие открытой вакансии и бюджета на нового сотрудника.
Мы хотим, чтобы как можно больше стажёров становились сотрудниками Авито и делаем для этого всё возможное. Но если обстоятельства не совпадают, мы готовы дать рекомендацию и отзыв для будущего работодателя и будем рады вернуться к общению в будущем.
Как попасть на стажировку
-------------------------
Когда появляются вакансии для стажёров, мы публикуем их [на специальном лендинге.](https://start.avito.ru/tech) Кандидату нужно выбрать интересующую позицию, выполнить тестовое задание и заполнить форму заявки.
Студенты 3-4 курса технических специальностей обычно справляются с нашими отборочными заданиями: для них хватает базовых знаний в программировании и умения искать информацию. Недавним выпускникам и кандидатам с другим бэкграундом тоже можно откликаться на стажировки.
Посмотреть примеры тестовых можно в нашем аккаунте на Гитхабе:
* [Задание на позицию стажёра-бэкендера](https://github.com/avito-tech/geo-backend-trainee-assignment/blob/main/README.md) в команду Geo.
* [Задание на позицию iOS-стажёра](https://github.com/avito-tech/internship) в команду VAS.
Мы проверяем выполненные задания вместе с инженерами и приглашаем понравившихся кандидатов на онлайн-интервью. Интервью проходит в два этапа. На первом мы проверяем технические знания кандидата, задаём вопросы по теории и даём задачи. Это занимает час-полтора. Кандидатов, которые успешно проходят эту секцию, мы приглашаем на HR-интервью с тимлидом, рекрутером направления и куратором стажировки. Здесь разговор будет посвящен целям и интересам кандидата в профессиональном развитии. Кандидатов, с которыми мы совпадаем по взглядам и ожиданиям, мы приглашаем выйти на стажировку.
Минутка статистики
------------------
Мы посчитали цифры по стажировке в команды, которые создают продукты для частных пользователей, одного из наборов 2019 года. Среди кандидатов было много хороших начинающих специалистов, которых мы не смогли взять, так как количество вакансий ограничено, но мы надеемся, что у нас ещё появится возможность поработать вместе в будущем. Также не всем стажёрам подошёл график и другие условия — это стоит учитывать при подсчёте своих шансов.
* Заявки с выполненными тестовыми заданиями: 150.
* Собеседования: 50.
* Выбрали стажёров в технологические команды: 7.
Большинство стажёров из прошлого набора уже работают в штате джуниор-разработчиками.
Что говорят стажёры о программе
-------------------------------
> **Аделина Загитова, QA и backend-стажёр, перешла в штат**
>
>
>
> Я искала хорошую подработку по профессии, где можно набраться опыта параллельно с учёбой. Кроме Авито рассматривала Яндекс, Хоум Кредит Банк, Лабораторию Касперского, Wildberries. Выбрала Авито, потому что со мной провели отлично продуманное собеседование и предложили самые удобные условия работы.
>
>
>
> Стажировка дала мне много:
>
> * я узнала про скрам и научилась ему;
> * поднатаскала в себе командные ценности;
> * научилась говорить о сложностях, проблемах и решать их не одна;
> * прокачалась в тестировании, это отличный поинт для будущего разработчика;
> * узнала, что значит работать в большом проекте и научилась этому;
> * больше узнала об Андроиде и его инструментах разработки — теперь стало понятно, как работает большое сложное приложение;
> * стала уверенней в себе.
>
>
>
>
>
> Я стажировалась сначала в QA, затем перешла на стажировку по Андроиду. Стажировка была классной и в одной, и в другой функции. Тестирование — неотъемлемая часть разработки конечного продукта, которая нужна каждому разработчику. Я немного знала о тестировании, по большей части — теорию. Но благодаря своей наставнице смогла прокачаться в этом на практике, что мне сильно помогает сейчас.
>
>
>
> На четвёртом курсе, пока шла вторая часть моей стажировки, в университете был курс по Андроиду. В тот момент мне стало интересно заниматься именно разработкой под Андроид, и коллеги поддержали меня. Так я перешла на свою вторую стажировку в Авито, при этом я тоже делала тестовое задание и проходила собеседование. На второй стажировке я начала прокачивать свою вовлечённость в продукт, потому что работала непосредственно с приложением Авито.
>
>
>
> В общем, стажировки были абсолютно разными, и обе дали мне много всего положительного, что помогает мне сейчас как разработчику.
> **Владимир Нюхтилин, iOS-стажёр, перешёл в штат**
>
>
>
> Я считаю, что возможностью попасть в такую компанию как Авито, точно нужно пользоваться. Программа стажировки как раз про это.
>
>
>
> Мне было важно получить как можно больше «боевого» опыта, найти осознанные ответы на вопросы из разряда «а почему делают именно так» и «что действительно важно, а чем в реальности можно пренебречь». Безусловно, понимание устройства рабочего процесса большой компании — дело не одного дня и даже месяца. Но постепенно у каждого нового сотрудника находятся ответы на те самые вопросы, и, безусловно, этому способствует внутренняя атмосфера, которая царит в Авито.
>
> Новичку здесь готов помочь каждый. А стажёра ещё и наставляет опытный ментор, который не только объясняет тонкости рабочего процесса, но и помогает тебе развиваться как специалисту.
>
>
>
> По моим наблюдениям, программа стажировок отлажена на 150% благодаря многим тонкостям, и она постоянно развивается, как и всё здесь. Я получил большой опыт в Авито и продолжаю работать над собой, решая задачи, которые стоят в целях моей команды. Поэтому на вопрос «Что именно дала мне стажировка в Авито?» я бы ответил так: «Возможность для отличного, если не лучшего, старта карьеры в IT».
> **Никита Васильев, backend-стажёр, перешёл в штат**
>
>
>
> На мой взгляд, формат длительной стажировки на половину рабочего дня оптимален, поскольку позволяет погрузиться в работу и хорошо подходит для совмещения с учебой в вузе. В течение этого времени ты успеваешь понять как логику своих задач, так и особенности взаимодействия с другими людьми в процессе их решения, получаешь все инфраструктурные навыки для работы, параллельно постепенно подтягивая свои «отстающие» скиллы.
>
>
>
> В Авито я первый раз столкнулся с большим проектом, который работает с высокими нагрузками и имеет несколько деплоев каждый день. На меня вылилось огромное количество новой информации, которую пришлось укладывать в голове. Стажировка — отличный шанс узнать и нарисовать для себя полную картину того, как ± должен быть построен процесс разработки.
> **Артём Ольков, стажёр в Security, перешёл в штат**
>
>
>
> Стажировка представляет большую ценность, в первую очередь для тех, кто только начинает карьерный путь в IT. В ходе стажировки приобретается то, что нельзя получить вне реальных проектов: опыт и умение работать в команде.
>
>
>
> Когда я только пришёл на стажёрскую программу, то ожидал, что смогу поработать над интересными задачами в дружной команде, повысить уровень не только hard, но и soft skills, окунуться в жизнь крупной, высокотехнологичной компании. Но программа превзошла даже мои, как я думал, завышенные ожидания. В Авито я освоил новые технологии, которыми никогда не пользовался, познакомился с множеством увлечённых своим делом людей и сформировал для себя дальнейший вектор развития.
> **Константин Голик, frontend-стажёр, перешёл в штат**
>
>
>
> Одна из главных проблем студента-программиста — это оторванность от промышленной разработки. Ты пишешь сложные программы, но при этом не имеешь ни малейшего понятия о том, чем будешь заниматься на работе. В этом, как по мне, и есть вся ценность стажировки в Авито. Она позволяет плавно погрузиться в коммерческую разработку и стать частью команды. Все мои ожидания от стажировки оправдались, я набил руку на своем стеке технологий и понял все процессы разработки. Особенно круто, что более опытные коллеги всегда готовы помочь с возникающими вопросами.
Что говорят наставники
----------------------
> **Ионов Владимир, Teamlead**
>
>
>
> Как только мы узнали о стартовавшей в Авито стажёрской программе, сразу захотели взять себе в команду стажёра-фронтендера. Причин было две. Во-первых, в нашей команде хорошая экспертность по проведению технических интервью. Во-вторых, наш Senior Frontend разработчик хотел попробовать себя в роли наставника. И мы верили, что если он передаст хотя бы часть своего опыта стажёру за время стажировки, то это будет очень ценное приобретение для юнита.
>
>
>
> Мы разработали тестовое задание, разместили его на сайте и стали ждать. Уже через полторы недели у нас было более 20 тестовых работ от желающих попасть на стажировку. Сюрпризом стало то, что ребята выбрали разные фреймворки, поэтому на запуск, разбор и оценку выполненных проектов мы потратили больше времени, чем планировали. Уже после трёх склонированных репозиториев мы начали составлять рейтинг проектов, чтобы пригласить авторов лучших работ в офис на интервью.
>
>
>
> Первое же интервью показало, что мы сильно недооценили современных студентов. Кандидат оказался очень хорошо подкован теоретически и смог решить простые задачи за короткое время. Чтобы нащупать границу познаний в web-разработке, нам пришлось дать ему несколько задач, которые мы решаем с кандидатами на вакансии junior/middle. К нашему удивлению, с некоторыми из них он справился. После этого мы пересмотрели план интервью, включив в него задачи и теоретические вопросы разной степени сложности.
>
>
>
> По итогу шести встреч с кандидатами в стажёры мы пришли к выводу, что большинство откликнувшихся на вакансию имеют очень крепкие теоретические знания. Но «своего» стажёра мы к тому моменту уже выбрали. Он продемонстрировал очень крепкую теоретическую базу, хорошо знал браузерное API и быстро писал код. Ну и конечно же, «горящие глаза» выделяли его среди других. Уже на второй неделе работы в команде стажёр сверстал свой первый лендинг, который доступен и сейчас.
>
>
>
> Параллельно с отбором кандидатов во фронтенд, нам предложили посмотреть iOS-стажёра, который уже прошёл все технические этапы отбора в другой команде. На первой же очной встрече стало ясно, что он подходит нам по духу: кандидат быстро нашёл общий язык с наставником и продемонстрировал сильное желание развиваться в разработке iOS-приложений. В итоге мы сделали ему предложение пройти стажировку в нашей команде.
>
>
>
> Забавно совпало, что стажёры вышли в один день, а в нашей команде появилось сразу четыре новых роли: два стажёра и два наставника.
>
>
>
> Сейчас, спустя полгода стажировки, стажёры выполняют продуктовые задачи вместе с командой. Технический уровень ребят существенно вырос, а коммуникационные навыки позволяют им решать все рабочие вопросы самостоятельно, практически без помощи наставников. Мы очень довольны своим выбором и готовим ребят к выходу в штат на полную ставку.
> **Костас Кряров, Senior Frontend Engineer**
>
>
>
> Ещё до того, как я взял стажёра, у меня были неверные ожидания. Мне казалось, что это довольно просто — надо показывать, как делать задачи. На самом деле всё оказалось намного сложнее и интереснее. Во-первых, нужно грамотно и чётко формулировать задачи с пояснениями, почему эта задача важна, чему стажёр научится, выполнив её. Во-вторых, нужно было постоянно работать с мотивацией стажёра, чтобы задачи были интересными и соответствовали его уровню.
>
>
>
> Наставничество научило меня отцовскому духу. Я очень хотел, чтобы стажёру понравилось у нас в команде и компании в целом, чтобы комфортно работалось.
>
>
>
> Мы даём стажёрам разные задачи. Сначала довольно простые, чтобы человек пощупал наши процессы, code-review и прочее. С развитием стажёра, задачи становятся сложнее:
>
> 1. Вёрстка лендинга с нуля.
> 2. Рефакторинг тестов, чтобы стажёр научился работать с `jest` и нашими внутренними библиотеками, связанными с тестированием.
> 3. Интеграция новой функциональности в React-Redux приложение.
> 4. У моего стажёра была интересная задача на исследование рендеринга графа статусов на svg или canvas, учитывая положение рёбер и вершин графа.
>
>
>
>
> **Артём Пескишев, Senior Mobile Engineer**
>
>
>
> Для наставника работа со стажёром — это отличный способ прокачать свои управленческие навыки. Если у наставника до этого не было менеджерского опыта, то достаточно интересно оказаться по ту сторону баррикад. Приходится учится тому, как правильно работать с мотивацией подчинённых, с процессом обучения и интеграции нового, как правило без опыта работы, сотрудника в команду и её процессы.
>
>
>
> В первое время я давал достаточно простые «гигиенические» задачи, и не ограничивал стажёра по времени. Как правило, это были баги, которые позволяли новому сотруднику поковыряться в проекте, изучить разные модули, понять, как устроен код и как с ним работать.
>
>
>
> Потом я дал более интересную задачу — встроить интерактивную заглушку для аватарки на экране контактных данных. Она позволила стажёру познакомиться с механизмом А/Б тестирования и научиться тому, как создавать новые модули, закрывать свой код фича тоглами. Стажёр в итоге разработал фичу, которой пользуются тысячи людей на сайте и которую он может показать друзьям, использующим Авито. Когда я увидел, что задачи решаются в установленные сроки, стал давать те, что напрямую влияют на цели компании, например, редизайн экранов размещения объявления.
>
>
>
> Мой стажёр быстро вник в проект, и спустя пару месяцев уже был полноценным участником команды, который работал над задачами наравне со всеми, планировал свою работу и выполнял её в заданные сроки.
Вместо вывода
-------------
Если у вас остались вопросы по техническим стажировкам в Авито — задавайте их в комментариях к статье. | https://habr.com/ru/post/492584/ | null | ru | null |
# Оптимизация OS X для продления жизни SSD
Привет, Geektimes! Если вы купили SSD и заинтересованы в том, чтобы твердотельный накопитель прослужил как можно дольше, то добро пожаловать под кат.
[](http://geektimes.ru/company/ocz/blog/265746/)
Хоть компания OCZ и предоставляет пятилетнюю гарантию на SSD серии Vector и Vertex, вы в состоянии увеличить срок службы самостоятельно. И без сторонних утилит – только с помощью «Терминала» и других стандартных инструментов OS X.
Поскольку SSD имеют ограниченное количество циклов перезаписи, немаловажно беречь накопитель от дополнительного износа, которому способствуют кэши, режим гибернации, файл подкачки и так далее. Эти и многие другие процессы можно оптимизировать в системе и заметно отсрочить время, когда число циклов перезаписи приблизится к максимальному.
Отключение гибернации
---------------------
Важный шаг к оптимизации OS X для работы с SSD. При включенной гибернации данные оперативной памяти оказываются на накопителе каждый раз при отключении компьютера. Удобно, если у ноутбука внезапно сядет аккумулятор, но также сильно изнашивает диск, особенно SSD. Так что после отключения гибернации вы приобретете заметно больше, чем потеряете.
Открываем «Терминал» и вводим команду для проверки режима гибернации:
```
sudo pmset -g | grep hibernatemode > ~/Desktop/current_mode.txt
```
Затем обязательно вводим пароль от своей учетной записи.
После этого на рабочем столе появится файл с информацией, которая впоследствии поможет вам вновь активировать гибернацию, если появится такое желание.
Затем вводим команду непосредственно для отключения гибернации:
```
sudo pmset -a hibernatemode 0
```
Для её повторной активации нужно будет сменить значение параметра hibernatemode с 0 на то число, которое указано в файле current\_mode.txt (в нашем случае это 3).
Осталось только удалить остаточный файл при помощи команды, размещенной ниже, а затем перезагрузить Mac.
```
sudo rm /private/var/vm/sleepimage
```
Перенос файлов на HDD
---------------------
Захламлять SSD мусором и мелкими неважными файлами не рекомендуется, поэтому все лишнее с накопителя лучше удалить. Лучше всего, если на вашем Mac установлен и SSD, и HDD: тогда на последнем можно разместить папку пользователя, разгрузив тем самым твердотельный накопитель.
Сделать это можно в системных настройках. Открываем раздел «Пользователи и группы», снимаем защиту паролем администратора и правым кликом по имени пользователя выбираем «Дополнительные параметры».
В графе «Папка пользователя» изменяем путь до неё и отправляем на HDD.
Отключение noatime
------------------
Полезная функция для сокращения количества циклов перезаписи. Она записывает последний доступ к файлу на диске, и ничего критичного не произойдет, если её отключить. А вот SSD, наоборот, скажет вам спасибо.
В папке **/Library/LaunchDaemons/** создаём файл **com.hdd.noatime.plist** со следующим содержимым:
```
xml version="1.0" encoding="UTF-8"?
Label
com.hdd.noatime
ProgramArguments
mount
-vuwo
noatime
/
RunAtLoad
```
Снимаем защиту с файла и даем права на него с помощью этой команды:
```
sudo chown root:wheel /Library/LaunchDaemons/com.hdd.noatime.plist
```
Перезагружаем Mac и проверяем работоспособность:
```
mount | grep noatime
```
Но и это лишь малая часть способов оптимизации OS X для SSD.
Включение TRIM
--------------
С релизом OS X El Capitan стали доступны многие утилиты, в том числе и бесплатные, которые прекрасно справляются с активацией TRIM, отключая электронную подпись расширений ядра (.kext). О некоторых из них мы не так давно говорили, и самая простая в освоении – Chameleon SSD Optimizer. Просто скачиваете программу, запускаете её и наделяете правами администратора, после чего активируете TRIM и перезагружаете компьютер. Пожалуй, главное преимущество этой утилиты – она бесплатная.
Диски, не спать!
----------------
Поскольку SSD и так отличаются низким энергопотреблением, лишний раз переводить их в режим сна не стоит. Даже при питании ноутбука от аккумулятора включать эту функцию нецелесообразно, поэтому лучше её отключить в разделе «Экономия энергии» системных настроек, причем сделать это и для аккумулятора, и для сетевого адаптера.
И тем более не нужно, чтобы Mac выполнял резервное копирование, находясь в режиме сна – он отлично справляется с этим в режиме активной работы. Выключите Power Nap при питании от аккумулятора и сетевого адаптера.
Отключаем кэширование
---------------------
Для повышения срока службы твердотельного накопителя многие советуют отключить дефолтный в OS X поиск Spotlight, поскольку он индексирует содержимое диска и способствует износу SSD. Современные накопители, как правило, устойчивы к этому и адаптированы под использование поискового инструмента, тем более многие владельцы Mac не представляют свой рабочий процесс без Spotlight. А вот кэширование в браузере, будь то Safari или Chrome, отключить стоит. В Safari меню отключения расположено во вкладке «Разработка».
Если же вы уверены, что Spotlight сильно увеличивает нагрузку на SSD, а оставаться без поиска не хочется: зайдите в системные настройки – Spotlight и настройте поиск по отдельным категориям, исключив все лишнее.
Держите диск в чистоте
----------------------
Как ни странно, лучший способ продлить срок жизни SSD – не захламлять его. Выполняйте резервное копирование Time Machine раз в день и очищайте компьютер от лишних файлов, особенно тех, которые Mac относит к категории «Другое».
Где они могут храниться? Как вариант – резервные копии, созданные программой iTunes. Держите бэкапы в облаке, а с компьютера такое лучше удалить. Сюда же относятся кэши и временные файлы, но их намного удобнее чистить [сторонними утилитами](http://geektimes.ru/company/ocz/blog/264454/) вроде CleanMyMac, DaisyDisk, MacClean и так далее.
Отключение Sudden Motion Sensor
-------------------------------
Забудьте про SMS – он нужен был для HDD и блокировки головки диска, но у SSD крутящихся элементов нет, за счет чего они заметно компактнее. Это ненужная служба, которая никак не влияет на износ твердотельного накопителя, однако при этом лежит мертвым грузом. Проще всего отключить её при помощи «Терминала»:
```
sudo pmset -a sms 0
```
Проверить отключение Sudden Motion Sensor можно другой командой:
```
-sudo pmset -g
```
Включить SMS обратно можно, изменив значение параметра sms с 0 на 1.
Очистка загрузочного кэша
-------------------------
Немаловажно, если вы заметили, что Mac с твердотельным накопителем на борту стал перезагружаться более 15 секунд. Здесь на помощь вновь приходит «Терминал» и одна-единственная команда (потребуется ввести пароль администратора):
```
sudo kextcache -system-caches
```
Отключение FileVault
--------------------
До релиза OS X Mavericks многие пользователи Mac с SSD жаловались на то, что с включенным шифрованием диск работал заметно медленнее. Затем, когда Apple перевела все свои компьютеры на твердотельные диски, функция была оптимизирована и на работоспособности системы никак не отражается. Тем не менее для накопителя это лишние «нервы», поэтому если вы не агент 007 или служащий госкорпорации, можете вполне обойтись стандартным паролем.
Отключение локальной Time Machine
---------------------------------
Если у вас нет дополнительного диска для резервных копий Time Machine, система создает бэкап прямо на SSD. Это не столько влияет на износ самого накопителя, сколько занимает на нем лишнее место. Чтобы отключить создание локальных резервных копий, достаточно ввести в «Терминал» одну команду:
```
sudo tmutil disable local
```
Нужно ли это?
-------------
Вообще, многие согласятся, что «смертность» SSD от износа несколько преувеличена – современные накопители (в том числе от OCZ) прослужат вам долго даже при соблюдении элементарных основ, но многие предпочитают лишний раз перестраховываться и делают это не зря. Если же с диском возникнут какие-либо проблемы, их можно быстро выявить с утилитой [SSD Guru](http://geektimes.ru/company/ocz/blog/248052/) и найти решение. | https://habr.com/ru/post/386517/ | null | ru | null |
# Добавление Quartz в Spring Boot
*И снова здравствуйте. Специально для студентов курса [«Разработчик на Spring Framework»](https://otus.pw/G4SU/) подготовили перевод интересной статьи.*
---
В моей статье [«Specifications to the Rescue»](https://dzone.com/articles/specifications-to-the-rescue) я показал как можно использовать JPA Specification в Spring Boot для реализации фильтрации в RESTful API. Затем в статье [«Testing those Specifications»](https://dzone.com/articles/testing-those-specifications) было показано как протестировать эти самые спецификации.
Следующим шагом я решил продемонстрировать, как добавить планировщик заданий в это же приложение Spring Boot.
### Планировщик заданий Quartz
Команда Spring продолжает облегчать разработку на Java, предоставляя различные Spring Boot Starter, подключаемые через простую maven-зависимость.
В этой статье я сконцентрируюсь на стартере [Quartz Scheduler](http://www.quartz-scheduler.org/), который можно добавить в проект Spring Boot с помощью следующей зависимости:
```
org.springframework.boot
spring-boot-starter-quartz
```
Реализация довольно проста и описана [здесь](https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-quartz.html). Полный список текущих Spring Boot Starter вы можете посмотреть [здесь](https://github.com/spring-projects/spring-boot/tree/master/spring-boot-project/spring-boot-starters).
### Настройка
Используя работу, опубликованную [Дэвидом Киссом](https://github.com/davidkiss), первым этапом будет добавление автосвязывания для заданий Quartz:
```
public final class AutowiringSpringBeanJobFactory extends SpringBeanJobFactory implements ApplicationContextAware {
private transient AutowireCapableBeanFactory beanFactory;
@Override
public void setApplicationContext(final ApplicationContext context) {
beanFactory = context.getAutowireCapableBeanFactory();
}
@Override
protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
final Object job = super.createJobInstance(bundle);
beanFactory.autowireBean(job);
return job;
}
}
```
Далее добавляем базовую конфигурацию Quartz:
```
@Configuration
public class QuartzConfig {
private ApplicationContext applicationContext;
private DataSource dataSource;
public QuartzConfig(ApplicationContext applicationContext, DataSource dataSource) {
this.applicationContext = applicationContext;
this.dataSource = dataSource;
}
@Bean
public SpringBeanJobFactory springBeanJobFactory() {
AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
jobFactory.setApplicationContext(applicationContext);
return jobFactory;
}
@Bean
public SchedulerFactoryBean scheduler(Trigger... triggers) {
SchedulerFactoryBean schedulerFactory = new SchedulerFactoryBean();
Properties properties = new Properties();
properties.setProperty("org.quartz.scheduler.instanceName", "MyInstanceName");
properties.setProperty("org.quartz.scheduler.instanceId", "Instance1");
schedulerFactory.setOverwriteExistingJobs(true);
schedulerFactory.setAutoStartup(true);
schedulerFactory.setQuartzProperties(properties);
schedulerFactory.setDataSource(dataSource);
schedulerFactory.setJobFactory(springBeanJobFactory());
schedulerFactory.setWaitForJobsToCompleteOnShutdown(true);
if (ArrayUtils.isNotEmpty(triggers)) {
schedulerFactory.setTriggers(triggers);
}
return schedulerFactory;
}
}
```
Можно вынести свойства, используемые в методе `scheduler()`, наружу, но я специально решил упростить этот пример.
Затем добавляются статические методы, обеспечивающие программный способ создания заданий и триггеров:
```
@Slf4j
@Configuration
public class QuartzConfig {
...
static SimpleTriggerFactoryBean createTrigger(JobDetail jobDetail, long pollFrequencyMs, String triggerName) {
log.debug("createTrigger(jobDetail={}, pollFrequencyMs={}, triggerName={})", jobDetail.toString(), pollFrequencyMs, triggerName);
SimpleTriggerFactoryBean factoryBean = new SimpleTriggerFactoryBean();
factoryBean.setJobDetail(jobDetail);
factoryBean.setStartDelay(0L);
factoryBean.setRepeatInterval(pollFrequencyMs);
factoryBean.setName(triggerName);
factoryBean.setRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY);
factoryBean.setMisfireInstruction(SimpleTrigger.MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT);
return factoryBean;
}
static CronTriggerFactoryBean createCronTrigger(JobDetail jobDetail, String cronExpression, String triggerName) {
log.debug("createCronTrigger(jobDetail={}, cronExpression={}, triggerName={})", jobDetail.toString(), cronExpression, triggerName);
// To fix an issue with time-based cron jobs
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
CronTriggerFactoryBean factoryBean = new CronTriggerFactoryBean();
factoryBean.setJobDetail(jobDetail);
factoryBean.setCronExpression(cronExpression);
factoryBean.setStartTime(calendar.getTime());
factoryBean.setStartDelay(0L);
factoryBean.setName(triggerName);
factoryBean.setMisfireInstruction(CronTrigger.MISFIRE_INSTRUCTION_DO_NOTHING);
return factoryBean;
}
static JobDetailFactoryBean createJobDetail(Class jobClass, String jobName) {
log.debug("createJobDetail(jobClass={}, jobName={})", jobClass.getName(), jobName);
JobDetailFactoryBean factoryBean = new JobDetailFactoryBean();
factoryBean.setName(jobName);
factoryBean.setJobClass(jobClass);
factoryBean.setDurability(true);
return factoryBean;
}
}
```
Метод `createJobDetail()` — это простой и полезный метод для создания заданий.
Для триггеров существуют два варианта: на основе CRON и простые триггеры.
### Сервисы
Теперь базовый планировщик Quartz готов к запуску заданий в нашем Spring Boot — приложении. Далее создадим несколько примеров сервисов, которые будут запускаться планировщиком.
Первый сервис отображает простую статистику членства. Если вы помните, пример в первоначальном проекте был связан с фитнес-клубом. В классе `MemberService` создаем метод `memberStats()`:
```
public void memberStats() {
List members = memberRepository.findAll();
int activeCount = 0;
int inactiveCount = 0;
int registeredForClassesCount = 0;
int notRegisteredForClassesCount = 0;
for (Member member : members) {
if (member.isActive()) {
activeCount++;
if (CollectionUtils.isNotEmpty(member.getMemberClasses())) {
registeredForClassesCount++;
} else {
notRegisteredForClassesCount++;
}
} else {
inactiveCount++;
}
}
log.info("Member Statics:");
log.info("==============");
log.info("Active member count: {}", activeCount);
log.info(" - Registered for Classes count: {}", registeredForClassesCount);
log.info(" - Not registered for Classes count: {}", notRegisteredForClassesCount);
log.info("Inactive member count: {}", inactiveCount);
log.info("==========================");
}
```
Для отслеживания интересов в классах фитнес-клуба создаем в `MemberClassService` метод `classStats()`:
```
public void classStats() {
List memberClasses = classRepository.findAll();
Map memberClassesMap = memberClasses
.stream()
.collect(Collectors.toMap(MemberClass::getName, c -> 0));
List members = memberRepository.findAll();
for (Member member : members) {
if (CollectionUtils.isNotEmpty(member.getMemberClasses())) {
for (MemberClass memberClass : member.getMemberClasses()) {
memberClassesMap.merge(memberClass.getName(), 1, Integer::sum);
}
}
}
log.info("Class Statics:");
log.info("=============");
memberClassesMap.forEach((k,v) -> log.info("{}: {}", k, v));
log.info("==========================");
}
```
### Задания
Для запуска кода сервисов необходимо создать соответствующие задания (Job). Для `MemberService` я создал класс задания `MemberStatsJob`:
```
@Slf4j
@Component
@DisallowConcurrentExecution
public class MemberStatsJob implements Job {
@Autowired
private MemberService memberService;
@Override
public void execute(JobExecutionContext context) {
log.info("Job ** {} ** starting @ {}", context.getJobDetail().getKey().getName(), context.getFireTime());
memberService.memberStats();
log.info("Job ** {} ** completed. Next job scheduled @ {}", context.getJobDetail().getKey().getName(), context.getNextFireTime());
}
}
```
Для сервиса `MemberClassService` был создан класс `MemberClassStatsJob`:
```
@Slf4j
@Component
@DisallowConcurrentExecution
public class MemberClassStatsJob implements Job {
@Autowired
MemberClassService memberClassService;
@Override
public void execute(JobExecutionContext context) {
log.info("Job ** {} ** starting @ {}", context.getJobDetail().getKey().getName(), context.getFireTime());
memberClassService.classStats();
log.info("Job ** {} ** completed. Next job scheduled @ {}", context.getJobDetail().getKey().getName(), context.getNextFireTime());
}
}
```
### Расписание заданий
В этом проекте мы хотим, чтобы все задания были запланированы при запуске Spring Boot сервера. Для этого я создал класс `QuartzSubmitJobs`, который включает в себя четыре простых метода. Два метода создают новые задания, а два метода — соответствующие триггеры.
```
@Configuration
public class QuartzSubmitJobs {
private static final String CRON_EVERY_FIVE_MINUTES = "0 0/5 * ? * * *";
@Bean(name = "memberStats")
public JobDetailFactoryBean jobMemberStats() {
return QuartzConfig.createJobDetail(MemberStatsJob.class, "Member Statistics Job");
}
@Bean(name = "memberStatsTrigger")
public SimpleTriggerFactoryBean triggerMemberStats(@Qualifier("memberStats") JobDetail jobDetail) {
return QuartzConfig.createTrigger(jobDetail, 60000, "Member Statistics Trigger");
}
@Bean(name = "memberClassStats")
public JobDetailFactoryBean jobMemberClassStats() {
return QuartzConfig.createJobDetail(MemberClassStatsJob.class, "Class Statistics Job");
}
@Bean(name = "memberClassStatsTrigger")
public CronTriggerFactoryBean triggerMemberClassStats(@Qualifier("memberClassStats") JobDetail jobDetail) {
return QuartzConfig.createCronTrigger(jobDetail, CRON_EVERY_FIVE_MINUTES, "Class Statistics Trigger");
}
}
```
### Запуск Spring Boot
Когда все готово, можно запустить Spring Boot сервер и увидеть инициализацию Quartz:
```
2019-07-14 14:36:51.651 org.quartz.impl.StdSchedulerFactory : Quartz scheduler 'MyInstanceName' initialized from an externally provided properties instance.
2019-07-14 14:36:51.651 org.quartz.impl.StdSchedulerFactory : Quartz scheduler version: 2.3.0
2019-07-14 14:36:51.651 org.quartz.core.QuartzScheduler : JobFactory set to: com.gitlab.johnjvester.jpaspec.config.AutowiringSpringBeanJobFactory@79ecc507
2019-07-14 14:36:51.851 o.s.s.concurrent.ThreadPoolTaskExecutor : Initializing ExecutorService 'applicationTaskExecutor'
2019-07-14 14:36:51.901 aWebConfiguration$JpaWebMvcConfiguration : spring.jpa.open-in-view is enabled by default. Therefore, database queries may be performed during view rendering. Explicitly configure spring.jpa.open-in-view to disable this warning
2019-07-14 14:36:52.051 o.s.s.quartz.SchedulerFactoryBean : Starting Quartz Scheduler now
2019-07-14 14:36:52.054 o.s.s.quartz.LocalDataSourceJobStore : Freed 0 triggers from 'acquired' / 'blocked' state.
2019-07-14 14:36:52.056 o.s.s.quartz.LocalDataSourceJobStore : Recovering 0 jobs that were in-progress at the time of the last shut-down.
2019-07-14 14:36:52.056 o.s.s.quartz.LocalDataSourceJobStore : Recovery complete.
2019-07-14 14:36:52.056 o.s.s.quartz.LocalDataSourceJobStore : Removed 0 'complete' triggers.
2019-07-14 14:36:52.058 o.s.s.quartz.LocalDataSourceJobStore : Removed 0 stale fired job entries.
2019-07-14 14:36:52.058 org.quartz.core.QuartzScheduler : Scheduler MyInstanceName_$_Instance1 started.
```
И запуск задания `memberStats()`:
```
2019-07-14 14:36:52.096 c.g.j.jpaspec.jobs.MemberStatsJob : Job ** Member Statistics Job ** starting @ Sun Jul 14 14:36:52 EDT 2019
2019-07-14 14:36:52.217 c.g.j.jpaspec.service.MemberService : Member Statics:
2019-07-14 14:36:52.217 c.g.j.jpaspec.service.MemberService : ==============
2019-07-14 14:36:52.217 c.g.j.jpaspec.service.MemberService : Active member count: 7
2019-07-14 14:36:52.217 c.g.j.jpaspec.service.MemberService : - Registered for Classes count: 6
2019-07-14 14:36:52.217 c.g.j.jpaspec.service.MemberService : - Not registered for Classes count: 1
2019-07-14 14:36:52.217 c.g.j.jpaspec.service.MemberService : Inactive member count: 3
2019-07-14 14:36:52.217 c.g.j.jpaspec.service.MemberService : ==========================
2019-07-14 14:36:52.219 c.g.j.jpaspec.jobs.MemberStatsJob : Job ** Member Statistics Job ** completed. Next job scheduled @ Sun Jul 14 14:37:51 EDT 2019
```
А затем выполнение задания `classStats()`:
```
2019-07-14 14:40:00.006 c.g.j.jpaspec.jobs.MemberClassStatsJob : Job ** Class Statistics Job ** starting @ Sun Jul 14 14:40:00 EDT 2019
2019-07-14 14:40:00.021 c.g.j.j.service.MemberClassService : Class Statics:
2019-07-14 14:40:00.022 c.g.j.j.service.MemberClassService : =============
2019-07-14 14:40:00.022 c.g.j.j.service.MemberClassService : Tennis: 4
2019-07-14 14:40:00.022 c.g.j.j.service.MemberClassService : FitCore 2000: 3
2019-07-14 14:40:00.022 c.g.j.j.service.MemberClassService : Spin: 2
2019-07-14 14:40:00.022 c.g.j.j.service.MemberClassService : Swimming: 4
2019-07-14 14:40:00.022 c.g.j.j.service.MemberClassService : New Class: 0
2019-07-14 14:40:00.022 c.g.j.j.service.MemberClassService : Basketball: 2
2019-07-14 14:40:00.022 c.g.j.j.service.MemberClassService : ==========================
2019-07-14 14:40:00.022 c.g.j.jpaspec.jobs.MemberClassStatsJob : Job ** Class Statistics Job ** completed. Next job scheduled @ Sun Jul 14 14:45:00 EDT 2019
```
### Заключение
В приведенном выше примере я использовал существующий проект на Spring Boot и без особых усилий добавил в него планировщик Quartz. Я создал сервисные методы, которые выполняли простой анализ данных. Эти сервисные методы были запущены классами заданий. Наконец, задания и триггеры были запланированы для запуска.
Полный исходный код можно найти [здесь](https://gitlab.com/johnjvester/jpa-spec-with-quartz).
В [следующей статье](https://dzone.com/articles/adding-a-restful-api-for-the-quartz-scheduler) я покажу как добавить RESTful API для просмотра информации о настройках Quartz. | https://habr.com/ru/post/475996/ | null | ru | null |
# Генерация текста на русском по шаблонам
Когда я только начинал работать над своей текстовой игрой, решил, что одной из её главных фич должны стать красивые художественные описания действий героев. Отчасти хотел «сэкономить», поскольку в графику не умел. Экономии не получилось, зато получилась Python библиотека ([github](https://github.com/the-tale/utg), [pypi](https://pypi.org/project/UTG/)) для генерации текстов с учётом зависимости слов и их грамматических особенностей.
Например, из шаблона:
> **[Hero] [проходил|hero]** мимо неприметного двора и вдруг **[заметил|hero]** играющих детей. Они бегали с деревянными мечами, посохами и масками чудовищ. Внезапно один из играющих остановился, выставил **[игрушечный|hero.weapon|вн] [hero.weapon|вн]**, выкрикнул: «**[Я|hero] [великий|hero] [Hero]**! Получай!» — и бросился на «бестий». Они упали наземь, задрыгали руками-ногами, а после встали, сняли маски и засмеялись. **[Хмыкнул|hero]** и **[сам|hero] [Hero]**, но не **[стал|hero]** выходить к малышне.
Мы можем получить такой текст (жирным выделены изменяющиеся слова):
> **Халлр** **проходил** мимо неприметного двора и вдруг **заметил** играющих детей. Они бегали с деревянными мечами, посохами и масками чудовищ. Внезапно один из играющих остановился, **выставил игрушечную золочёную шпагу**, выкрикнул: «**Я великий Халлр**! Получай!» — и бросился на «бестий». Они упали наземь, задрыгали руками-ногами, а после встали, сняли маски и засмеялись. **Хмыкнул** и **сам Халлр**, но не **стал** выходить к малышне.
Или такой:
> **Фиевара** **проходила** мимо неприметного двора и вдруг **заметила** играющих детей. Они бегали с деревянными мечами, посохами и масками чудовищ. Внезапно один из играющих остановился, **выставил игрушечный катар**, выкрикнул: «**Я великая Фиевара**! Получай!» — и бросился на «бестий». Они упали наземь, задрыгали руками-ногами, а после встали, сняли маски и засмеялись. **Хмыкнула** и **сама Фиевара**, но не **стала** выходить к малышне.
**Пара оговорок****Оговорка 1**. Я не лингвист и библиотека писалась «чтобы работала», а не «чтобы точно соответствовала всем правилам языка». Поэтому заранее извиняюсь за неточности в терминологии или неполную трактовку правил русского языка.
**Оговорка 2**. Библиотека разрабатывалась около 5 лет назад, сейчас могли появиться (или дорасти до нормального состояния) альтернативные средства генерации текста. Например, что-нибудь интересное может быть в софте для локализации.
О сложности генерации текстов
-----------------------------
Русский язык сложен во многих своих аспектах. В частности, слова имеют большое количество морфологических форм. Например, прилагательные могут иметь полную и краткую формы, изменяются по роду, числу, падежу, одушевлённости и степени сравнения. Выбор же конкретной формы зависит от других слов в предложении. Мы говорим «красивая женщина», но «красивый мужчина». Слово «красивый» в данном случае зависит от слов «мужчина» / «женщина» — его форма определяется родом главного слова.
Поэтому сложности начинаются уже когда мы пытаемся обратиться к кому-то с учётом его пола. При составлении текстов для сайтов, писем, игр приходится либо придумывать очень аккуратные формулировки (избегающие пола пользователя), либо писать сразу несколько текстов, либо использовать разной степени универсальности языки разметки.
Я же хотел чего-то большего, чем простая зависимость от пола игрока, да ещё и чтобы пользователи сами могли добавлять новые тексты (а «средний» пользователь довольно безграмотен, как мы все знаем :-) ). Поэтому, не найдя подходящий софт, решил делать его самостоятельно.
Возможности библиотеки
----------------------
UTG (universal text generator — не очень скромное название) позволяет создавать шаблоны для генерации текста с указанием:
* переменных (например, имени персонажа);
* зависимостей слов от переменных (например, прилагательного от существительного);
* Зависимостей одних переменных от других;
* Явных свойств слов и переменных (например, можно указать, что имя персонажа вставляется в родительском падеже);
При формировании текста по шаблону:
* На зависимые слова переносятся необходимые свойства главного слова. Например, на прилагательное переносится род существительного.
* Согласуется форма зависимых слов с числительными (с учётом формы зависимых слов).
* Модифицируются предлоги если необходимо (например, обо мне / о тебе), предлог для этого должен быть размечен.
Дополнительно реализованы:
* Словарь для хранения необходимых слов.
* Хранилище шаблонов для их хранения по типу и выбора случайного.
Библиотека «знает» о существовании существительных, прилагательных, местоимений, глаголов, причастий, чисел, предлогов и «цитат» (неизменяемого текста).
При этом учитываются следующие свойства слов: часть речи, падеж, одушевлённость, число, род, форма глагола, время, лицо, вид, категория прилагательного, степень прилагательного, категория местоимения, залог, форма предлога, форма прилагательного, форма причастия, форма существительного (кроме нормальной формы у существительных есть [счётная](https://ru.wikipedia.org/wiki/%D0%A1%D1%87%D1%91%D1%82%D0%BD%D0%B0%D1%8F_%D1%84%D0%BE%D1%80%D0%BC%D0%B0)).
Формат шаблонов и пример использования
--------------------------------------
Давайте разберём простой шаблон:
> Вчера **[mob] [укусил|mob] [hero|вн]**.
В зависимости от значений переменных, шаблон может отобразиться как такой фразой:
> Вчера гиена укусила Халлра.
так и такой:
> Вчера светлячки укусили привидение.
Рассмотрим шаблон подробнее:
* `Вчера` — обычный текст.
* `[mob]` — переменная, вместо которой подставится название монстра.
* `[укусил|mob]` — слово, зависимое от переменной, часть его свойств будет изменяться в зависимости от свойств названия монстра (например, число). Генератор текста автоматически распознаёт свойства формы слова и пытается их сохранить (например, будет распознано и сохранено прошедшее время, поэтому указывать его не надо).
* `[hero|вн]` — переменная, вместо которой подставится имя героя. Дополнительно указано, что имя должно быть в винительном падеже.
**Больше примеров шаблонов**Некоторые технические примеры можно найти в [тестах](https://github.com/the-tale/utg/blob/master/utg/tests/test_templates.py).
Если вам интересно большее количество примеров, вы можете увидеть их на сайте игрушки. Ссылку на неё можно найти покопавшись у меня в профиле, либо написав в личку.
И переменные и зависимые слова в шаблоне выделяются одинаково и имеют следующий формат:
* `[` — открывающая квадратная скобка.
* `слово` — зависимое слово или идентификатор переменной. Генератор сначала проверяет наличие переменной с таким именем, если такой переменной нет, то слово ищется в словаре.
* `|` — вертикальная черта — разделитель, нужен если указываем дополнительные свойства.
* `имя переменной` — переменная, от которой зависит форма слова, может отсутствовать.
* `|` — вертикальная черта — разделитель, нужен если указываем дополнительные свойства.
* `свойства слова через запятую` — описание требуемой формы слова (падеж, род и так далее). Их список можно найти на страницах проекта в github и pypi.
* `]` — закрывающая квадратная скобка.
Дополнительных свойств можно указывать сколько угодно, применяться они будут в порядке определения, например:
`[переменная 1|переменная 2|вн,мр|переменная 3|прш,ед,од]`
В большинстве случаев хватает следующих форматов:
* `[переменная]` — вставить переменную в нормальной форме (например, существительное в именительном падеже единственного числа).
* `[переменная|свойства]` — вставить переменную с указанными свойствами.
* `[слово|переменная]` — вставить слово, согласовав его с переменной (например, прилагательное «красивый» с существительным по роду и падежу).
* `[слово|переменная|свойства]` — вставить слово, согласовав его с переменной и указав дополнительные свойства.
Обратите внимание:
* Указание свойств для слов и переменных действует только в месте вставки, поэтому, чтобы получить словосочетание «красивого героя» мы должны указать винительный падеж явно для двух слов: `[красивый|hero|вн] [hero|вн]`.
* Генератор текста умеет «угадывать» свойства слова по его форме, например, во фразе `[hero] [побежал|hero]` можно не указывать время глагола.
* Свойства, указанные позже, затирают свойства, указанные ранее. Например, во фразе `[красивого|hero] [hero|вн]` не будет установлен винительный падеж прилагательного, так как он заменится именительным падежом переменной hero.
* Перечень свойств слов можно найти на страницах библиотеки в github и pypi.
**Пример с кодом**Требуется Python 3
Установка
```
pip install utg
python -m unittest discover utg
```
Код.
```
from utg import relations as r
from utg import dictionary
from utg import words
from utg import templates
from utg import constructors
#######################################
# описываем существительное для словаря
#######################################
coins_forms = [# единственнео число
'монета', 'монеты', 'монете', 'монету', 'монетой', 'монете',
# множественное число
'монеты', 'монет', 'монетам', 'монеты', 'монетами', 'монетах',
# счётное число (заполнено для пример,
# может быть заполнено методом autofill_missed_forms)
'монеты', 'монет', 'монетам', 'монеты', 'монетами', 'монетах']
# свойства: неодушевлённое, женский род
coins_properties = words.Properties(r.ANIMALITY.INANIMATE, r.GENDER.FEMININE)
# Для создания слова указывается его тип, формы и свойства
coins_word = words.Word(type=r.WORD_TYPE.NOUN,
forms=coins_forms,
properties=coins_properties)
# Формы слова должны быть указаны в фиксированном порядке.
# Если вы хотите автоматизировать создание слов,
# найти порядок форм слова и их свойства можно в переменных:
# - utg.data.WORDS_CACHES
# - utg.data.INVERTED_WORDS_CACHES
##############################
# описываем глагол для словаря
##############################
# описываем только нужны нам формы слова
# (порядок важен и определён в utg.data.WORDS_CACHES[r.WORD_TYPE.VERB])
action_forms = (['подарить', 'подарил', 'подарило', 'подарила', 'подарили'] +
[''] * 15)
# свойства: совершенный, прямой залог
action_properties = words.Properties(r.ASPECT.PERFECTIVE, r.VOICE.DIRECT)
action_word = words.Word(type=r.WORD_TYPE.VERB,
forms=action_forms,
properties=action_properties)
# заполняем пропущенные формы на основе введённых (выбираются наиболее близкие)
action_word.autofill_missed_forms()
##############################################
# создаём словарь для использования в шаблонах
##############################################
test_dictionary = dictionary.Dictionary(words=[coins_word, action_word])
################
# создаём шаблон
################
template = templates.Template()
# externals — внешние переменные, не обязаны быть в словаре
template.parse('[Npc] [подарил|npc] [hero|дт] [coins] [монета|coins|вн].',
externals=('hero', 'npc', 'coins'))
##############################
# описываем внешние переменные
##############################
hero_forms = ['герой', 'героя', 'герою', 'героя', 'героем', 'герое',
'герои', 'героев', 'героям', 'героев', 'героями', 'героях',
'герои', 'героев', 'героям', 'героев', 'героями', 'героях']
# свойства: одушевлённый, мужской род
hero_properties = words.Properties(r.ANIMALITY.ANIMATE, r.GENDER.MASCULINE)
hero = words.WordForm(words.Word(type=r.WORD_TYPE.NOUN,
forms=hero_forms,
properties=hero_properties))
npc_forms = ['русалка', 'русалки', 'русалке', 'русалку', 'русалкой', 'русалке',
'русалки', 'русалок', 'русалкам', 'русалок', 'русалками', 'русалках',
'русалки', 'русалок', 'русалкам', 'русалок', 'русалками', 'русалках']
# свойства: одушевлённое, женский род
npc_properties = words.Properties(r.ANIMALITY.ANIMATE, r.GENDER.FEMININE)
npc = words.WordForm(words.Word(type=r.WORD_TYPE.NOUN,
forms=npc_forms,
properties=npc_properties))
##########################
# осуществляем подстановку
##########################
result = template.substitute(externals={'hero': hero,
'npc': npc,
'coins': constructors.construct_integer(125)},
dictionary=test_dictionary)
##########################
# Проверяем
##########################
result == 'Русалка подарила герою 125 монет.'
```
О словарях
----------
Как вы могли заметить, UTG требует формирование словаря. Делается это «руками» так как в момент разработки:
* Общедоступных качественных морфологических словарей я не нашёл.
* Библиотека [pymorphy](https://github.com/kmike/pymorphy2) была ещё первой версии и довольно часто косячила (особенно с винительным падежом), из-за чего пришлось от неё отказаться.
Если вы захотите использовать генератор с большим количеством слов, прежде чем вбивать их вручную, попробуйте воспользоваться pymorphy2, либо поищите готовый словарь и экспортируйте из него.
Итого
-----
Надеюсь, библиотека окажется полезной.
Если у вас есть идеи по её развитию (а ещё лучше, желание в нём участвовать) — пишите в личку, делайте pull requests, постите баги на гитхаб. | https://habr.com/ru/post/471278/ | null | ru | null |
# Создание документации в .NET
Качественная документация – неотъемлемая часть успешного программного продукта. Создание полного и понятного описания всех функций и возможностей программы и программного компонента требует немало сил и терпения. В данной статье я рассмотрю некоторые практические аспекты создания документации для .NET компонентов.
Предположим, что у нас готова или почти готова некоторая .NET библиотека для разработчиков (они же конечные пользователи). API библиотеки безупречен, количество багов впечатляюще мало, да и вообще это не библиотека, а просто кладезь совершенного кода. Дело за малым – объяснить пользователям, как работать с этим замечательным продуктом.
Есть разные подходы к написанию документации. Некоторые команды предпочитают начинать создание документации в момент начала создания продукта. Другие откладывают написание мануалов на окончание работ. В некоторых командах документацию пишут специальные люди, которые ходят от разработчика к разработчику и от менеджера к менеджеру, аккумулируя знания о продукте. Во многих небольших командах таких специальных людей нет, а потому документацию часто пишет разработчик или разработчики. Кто-то использует сторонние средства вроде Help & Manual, в которых, как в заправском текстовом редакторе, можно создавать очень сложную верстку и на выходе получать документацию в многообразии форматов. Многие используют другой подход, широко пропагандируемый в последнее время – написание документации прямо в коде программы/библиотеки.
Я в своей работе использовал и сторонние средства, и встроенные. Начинал писать документацию и сразу, и в последний момент. В итоге я для себя решил, что документацию лучше начинать писать во второй половине создания продукта, так как чем ближе к завершению, тем более стабилен API, набор возможностей и т.п., а значит, реже придется корректировать документацию. Написание документации прямо в коде тоже, в конечном счете, оказалось удобнее, чем в сторонних программах, хотя поначалу казалось совсем наоборот. Эта статья как раз о том, как писать документацию прямо в коде.
#### Описываем API
Компиляторы C# и VB.NET умеют распознавать комментарии, оформленные специальным образом (xml комментарии) и при необходимости создавать xml файл, который можно потом использовать для создания документации. Чтобы воспользоваться этой возможностью необходимо описать все публичные классы и методы с помощью xml комментариев. Выглядит это примерно так:
> ///
>
> /// Gets the R component from ABGR value returned by
>
> /// ReadRGBAImage.
>
> ///
>
> /// The ABGR value.
>
> /// The R component from ABGR value.
>
> public static int GetR(int abgr)
>
> {
>
> return (abgr & 0xff);
>
> }
По умолчанию создание xml-файла из комментариев отключено. Его нужно включить в свойствах проекта на вкладке Build.
В результате при компиляции, в дополнение к файлу вашей сборки, будет сгенерирован xml-файл, который содержит все xml-комментарии из кода (в том числе комментарии к непубличным структурам). Этот файл уже сам по себе полезен тем, что если его положить рядом со сборкой (вашей dll), то это позволит функции IntelliSense в Visual Studio отображать описания для методов в момент набора пользователем кода. Вот пример того, как это будет выглядеть для функции GetR, показанной выше:
Однако в большинстве случаев сгенерированный xml-файл содержит комментарии к внутренним структурам, которые пользователям не нужно или нельзя видеть. Ниже я напишу, как автоматически очистить xml-файл так, чтобы в нем остались только описания к публичным методам.
Я не буду подробно рассматривать все xml-теги, а лишь попробую кратко описать наиболее часто используемые.
Тег ***summary*** служит для краткого описания назначения класса, интерфейса, перечисления (enum), методов и свойств класса или интерфейса и членов перечисления. Тег ***param*** позволяет описать параметр, принимаемый функцией. Этот тег нужно использовать для каждого принимаемого параметра. Тег ***returns*** используется для описания возвращаемого значения функции. Тег ***value*** полезен для описания значения, которое принимает и/или возвращает некоторое свойство. В некотором смысле тег value является аналогом тега returns.
> ///
>
> /// Gets the font ascent.
>
> ///
>
> /// The font ascent.
>
> /// Ascent is the maximum height above the baseline reached
>
> /// by glyphs in this font, excluding the height of glyphs for
>
> /// accented characters.
>
> public short Ascent
>
> {
>
> get
>
> {
>
> return Impl.Ascent;
>
> }
>
> }
Очень полезным (и, к сожалению, часто игнорируемым) является тег ***remarks***, который позволяет указать примечания к описываемой сущности. Этот тег можно использовать практически везде кроме описания членов перечисления. На самом деле для членов перечисления тоже можно, но в документации, оформленной в стиле vs2005, этих примечаний просто не будет видно, что уменьшает полезность таких примечаний.
Приведу еще несколько практических замечаний/рекомендаций.
Скачайте и установите расширение для Visual Studio под названием [GhostDoc](http://submain.com/products/ghostdoc.aspx). Это расширение работает во всех версия студии (начиная с версии 2005) и сильно упрощает создание xml комментариев. По нажатию на Ctrl-Shift-D это расширение вставляет описание сущности, на которой в данный момент стоит курсор. Вставляются все необходимые теги, и генерируется текст описания на основе, например, названия метода и названия его параметров. Часто остается лишь откорректировать и дополнить сгенерированный текст.
Недостаток написания документации прямо в коде в том, что комментариев порой больше, чем кода, что может сильно затруднять чтение кода. Для обхода этой проблемы очень удобным оказывается полное разделение публичного интерфейса и реализации.
Если у вас есть несколько перегруженных методов, то при генерации документации для них будет создана отдельная страница ([вот пример](http://msdn.microsoft.com/en-us/library/system.drawing.graphics.drawstring.aspx) такой страницы). Текст для этой страницы нужно указать в теге overloads в описании одного из перегруженных методов.
> ///
>
> /// Saves the font bytes to the specified stream.
>
> ///
>
> /// The stream to save font bytes to.
>
> /// Saves the font bytes to a file or a stream.
>
> public void Save(Stream stream)
>
> {
>
> Impl.Save(stream);
>
> }
Если вы хотите в описании одного метода дать ссылку на другой метод или тип, то нужно использовать конструкцию вида `Текст ссылки`, где X – необязательный префикс, обозначающий тип сущности (T для класса, M для метода, P для свойства, O для группы перегруженных методов), а MEMBER – полная или частичная спецификация сущности. Частичную спецификацию и отсутствующий префикс можно использовать, например, для ссылок между двумя методами одного класса или между двумя сущностями одного пространства имен (namespace).
Пример использования частичной спецификации (PdfFontEmbedStyle находится в одном пространстве имен с PdfFont):
> public sealed class PdfFont
>
> {
>
> …
>
> ///
>
> /// Gets or sets the value that specifies
>
> /// how this font is embedded into the document.
>
> ///
>
> /// The value that specifies
>
> /// how this font is embedded into the document.
>
> public PdfFontEmbedStyle EmbedStyle
>
> {
>
> get
>
> {
>
> return Impl.EmbedStyle;
>
> }
>
> set
>
> {
>
> Impl.EmbedStyle = value;
>
> }
>
> }
>
> }
Если вы ссылаетесь на сущность из другого пространства имен, на группу перегруженных методов или на какой-то определенный метод из группы перегруженных методов, то нужно обязательно использовать полную спецификацию. Примеры полной спецификации:
* ссылка на свойство
* ссылка на метод
* ссылка на группу перегруженных методов
* ссылка на класс
Как видите, в полной спецификации указываются и параметры метода, что позволяет однозначно определить ссылку, но усложняет написание ссылок. Можно сэкономить ручной труд, если копировать полные спецификации из ранее скомпилированного xml-файла.
Со ссылками на группу перегруженных методов связана одна неприятность. Visual Studio требует, чтобы такие ссылки были вида `O:XXX.YYY`, в то время как Sandcastle Help File Builder требует, чтобы такие ссылки были вида `Overload:XXX.YYY`. Для решения этой проблемы я использую простой скрипт, который вызывается на Post-build event и заменяет в xml-файле `O:` на `Overload:`, что вполне терпимо.
Для ссылки на некоторую внешнюю статью вашей документации (не связанную с описанием API) или на некоторый ресурс в Интернет используйте старый добрый тег с атрибутом href. Например, `[Текст ссылки](54cbd23d-dc55-44b9-921f-3a06efc2f6ce.htm)` или `[Текст ссылки](http://site.com/page.html)`. В первом примере имя документа с внешней статьей представлено в форме “TOPIC\_ID.htm”. О том, что такое topic id, речь пойдет далее.
Более глубоко ознакомиться с документированием кода с помощью xml комментариев можно в этих статьях:
* Recommended Tags for Documentation Comments (C# Programming Guide)
[msdn.microsoft.com/en-us/library/5ast78ax.aspx](http://msdn.microsoft.com/en-us/library/5ast78ax.aspx)
* XML Documentation Comments Guide (Детальное руководство с примерами)
[www.dynicity.com/products/XMLDocComments.aspx](http://www.dynicity.com/products/XMLDocComments.aspx)
* XML документация в C#
[habrahabr.ru/blogs/net/41514](http://habrahabr.ru/blogs/net/41514/)
* C# and XML Source Code Documentation
[www.codeproject.com/KB/XML/csharpcodedocumentation.aspx?msg=1679454](http://www.codeproject.com/KB/XML/csharpcodedocumentation.aspx?msg=1679454)
#### Генерируем файл документации
После того, как xml-описание вашего компонента готово, можно сгенерировать файл документации. Я предпочитаю для этого использовать связку Sandcastle + Sandcastle Help File Builder (SHFB). Замечу, что некоторым больше по душе DocProject. Для этого требуется:
1. Скачать и установить Sandcastle
[sandcastle.codeplex.com](http://sandcastle.codeplex.com/)
2. Скачать и установить Sandcastle Help File Builder
[shfb.codeplex.com](http://shfb.codeplex.com/)
3. Скачать и применить патч для стилей, используемых Sandcastle
[sandcastlestyles.codeplex.com](http://sandcastlestyles.codeplex.com/)
4. Если у вас возникнут проблемы со сборкой документации в формате HTML Help, то нужно проверить, что itircl.dll присутствует в системе и зарегистрирована. Обычно эта dll лежит в System32, регистрировать ее нужно через regsvr32. Подробнее написано тут:
[frogleg.mvps.org/helptechnologies/htmlhelp/hhtips.html#hhc6003](http://frogleg.mvps.org/helptechnologies/htmlhelp/hhtips.html#hhc6003)
Приступаем к сборке документации в формате chm. Для этого запускаем Sandcastle Help File Builder и настраиваем Project Properties. В свойстве “ComponentConfigurations” можно настроить дополнительные компоненты, используемые при сборке. Если вы не знаете, какие компоненты вам могут быть нужны, то можно выбрать все компоненты. В любом случае я рекомендую всегда использовать IntelliSense Component, так как он автоматически создает копию входного xml-файла, очищенную от всех непубличных комментариев. Именно результат работы этого компонента нужно давать пользователям, а не тот xml-файл, который создаст компилятор.
Также я рекомендую сразу поменять следующие свойства:
* секция Build: FrameworkVersion
* секции Help File: CopyrightHref, CopyrightText, FeedbackEMailAddress, FeedbackEMailLinkText, HelpTitle, HtmlHelpName
* секция Paths: OutputPath
Далее в окне Project Explorer добавляем Documentation Sources. Рекомендую выбирать здесь конкретную сборку и xml файл с комментариями для нее, а не файл C#/VB.NET проекта. Если выбрать файл проекта, то иногда возникает проблема с тем, что изменения в xml-комментариях не отражаются в документации. Кто в этом виноват, я не знаю.
Еще один важный шаг – описать пространства имен (namespace-ы) в SHFB. Xml комментарии в коде не работают для namespace-ов, поэтому нужно это сделать вручную. Тут поможет секция Comments и свойство NamespaceSummaries в ней. В описании namespace-ов можно использовать стандартные html теги.
Настройка проекта завершена, пришло время построить сhm-файл. Выбираем Documentation->Build Project, и, если все было сделано правильно, то получаем красивый файл документации в стиле MSDN.
Полезные ссылки по теме:
* Подробное описание настроек SHFB
[www.codeproject.com/KB/cs/SandcastleBuilder.aspx](http://www.codeproject.com/KB/cs/SandcastleBuilder.aspx)
* Обзор SHFB на ХабраХабре
[habrahabr.ru/blogs/net/68227](http://habrahabr.ru/blogs/net/68227/)
* Сравнение Sandcastle и DocProject
[stackoverflow.com/questions/319632/docproject-vs-sandcastle-help-file-builder-gui](http://stackoverflow.com/questions/319632/docproject-vs-sandcastle-help-file-builder-gui)
#### Пишем статьи
Однако не стоит останавливаться на достигнутом – одного описания API вашего компонента не достаточно для полноценной документации. Хорошая документация обычно содержит дополнительные статьи, примеры, FAQ и т.п.
В окне Project Explorer добавляем новый элемент Content Layout – это описание (с указанием взаиморасположения) того, что входит в документацию. В окне Content Layout добавляются новые статьи (topics). Каждая статья описывается в MAML формате (.aml файлы), это xml-based формат. Sandcastle Help File Builder поставляется с набором предопределенных шаблонов, что значительно упрощает дебют в написании статей. Я в основном использую шаблон *Conceptual*, реже – *Walkthrough*.
Описание каждой статьи начинается с указания topic id – уникального идентификатора. На основе этого идентификатора генерируется html файл, который позже попадет в chm. Генерируемый html-файл именуется в форме “TOPIC\_ID.htm”. Данный topic id используется также для ссылок на статью из других статей или xml-комментариев в коде.
При создании статьи предлагается ее сохранить в файл с именем “TOPIC\_ID.aml”. Можно и нужно при создании сразу указать нормальное имя для файла.
Рассмотрим некоторые элементы управления в SHFB, которые полезны при редактировании статей.
| | |
| --- | --- |
| Default topic | Устанавливает стартовую страницу документации (будет показываться при
открытии документации. |
| API insertion point | Устанавливает положение, в которое будет вставлено описание API,
сгенерированное из xml-файла. В зависимости от того, какой вариант выбран,
описание API будет вставлено
либо перед, либо после, либо как дочерний элемент помеченного таким образом
элемента. |
| Preview topic | Предварительный просмотр текущей статьи. |
| image | Вставка ссылки на статью в документации. Используйте topic id в
качестве адреса. |
| SHFB tags | Вставка стандартных тегов для разметки статьи. |
Окно Entity Reference (на картинке расположено справа) можно использовать для вставки ссылок на описание функций/методов и т.п. сущностей из кода. Такой способ вставки ссылок не очень удобен на мой взгляд, так как нужно сначала открыть текст статьи, потом открыть окно Entity Reference, потом в этом окне написать часть или полное названия сущности, потом найти в списке нужную строку и дважды кликнуть на нее. Все это приведет к тому, что в статью вставится ссылка в позиции курсора. Я предпочитаю писать ссылки руками, а текст для ссылок находить в build log-е (лог от предыдущего билда можно открыть в текстовом редакторе).
Для вставки кода в статью используется тег `. Например:
> <code language="cs">
>
> private void helloWorld()
>
> {
>
> Console.WriteLine(”Hello World!”);
>
> }
>
> code>
Для вставки изображений необходимо проделать следующее:
1. В окне Project Explorer выбираем Add, потом Existing Item и выбираем нужную картинку.
2. В свойствах добавленного файла меняем BuildAction на Image, а свойство ImageId – на удобное название (будет использоваться в ссылках на это изображение).
Далее можно использовать изображение в статьях так:
> href="ImageId" placement="center" /></mediaLink>
К сожалению, в текущей версии SHFB редактор далек от совершенства. Например, теги не закрываются автоматически, очень много действий приходится делать мышью (нет хоткеев), не для всех стандартных тегов есть соответствующие элементы на тулбаре. Парадоксально, но мне для большинства действий с aml-файлами удобнее использовать Visual Studio. Разумеется, можно использовать и любой другой удобный xml-редактор для написания статей.
Я описал решение основных потребностей при написании статей для документации. Если вы хотите лучше изучить тему, то рекомендую следующие ссылки:
* Обзор MAML формата
[davesexton.com/blog/blogs/blog/archive/2008/05/24/maml-migration-the-next-step-in-the-evolution-of-help-authoring.aspx](http://davesexton.com/blog/blogs/blog/archive/2008/05/24/maml-migration-the-next-step-in-the-evolution-of-help-authoring.aspx)
* Подробное описание MAML формата
[sandcastlestyles.codeplex.com/releases/view/17333](http://sandcastlestyles.codeplex.com/releases/view/17333)
* Различные примеры оформления документации с помощью SHFB
[www.codeproject.com/KB/winhelp/SandcastleConceptual.aspx](http://www.codeproject.com/KB/winhelp/SandcastleConceptual.aspx)
* Как создавать статьи из HTML, а не MAML
[habrahabr.ru/blogs/net/68227](http://habrahabr.ru/blogs/net/68227/)
* Как вставлять диаграммы классов в документацию
[habrahabr.ru/blogs/net/73790](http://habrahabr.ru/blogs/net/73790/)
#### Интеграция в процесс сборки
Можно включить файл проекта (*.shfbproj) от Sandcastle Help File Builder в solution Visual Studio, однако в настоящее время нет возможности использовать его как полноценный проект. То есть вы не сможете увидеть содержимое такого проекта, проект лишь добавится в группу Solution Items.
Добавление осуществляется следующим образом:
1. Для solution выбираете Add->Existing Item…, добавляете проект документации. Будет добавлен в папку Solution Items.
2. Щелкаете по добавленному элементу правой кнопкой мыши и выбираете Open With… В открывшемся диалоге добавляете ”Sandcastle Help File Builder GUI” и устанавливаете его в качестве редактора по умолчанию.
После этого проект документации можно будет открывать из Visual Studio.
Более полезна сборка документации из командной строки. Такую сборку можно делать на Post-Build event или в других случаях. Собрать документацию из командной строки очень просто следующей командой:
`%SystemRoot%\Microsoft.NET\Framework\v3.5\MSBuild.exe" /p:Configuration=Release Help.shfbproj`
В этой строке Help.shfbproj – название проекта документации.
Надеюсь, эта статья поможет вам начать писать документацию к вашим проектам (если вы еще этого не делаете) за что ваши пользователи наверняка скажут вам спасибо. Успехов вам в написании документации!` | https://habr.com/ru/post/102177/ | null | ru | null |
# Polygonal Mesh to B-Rep Solid Conversion: Algorithm Details and C++ Code Samples
Boundary representation (B-rep) is the primary method of representing modeled objects in most geometric kernels, including our C3D Modeler kernel. The core algorithms that edit models, such as applying fillet operations, performing cutting operations, and obtaining flat projections require the precision of B-rep representations. The rapidly growing variety of 3D data in polygonal formats makes the task of model transformations from polygons into boundary representation increasingly relevant. As a result, we developed a new SDK, C3D B-Shaper, which is part of our C3D Toolkit.
Using a triangulation algorithm (known as tessellation) on a model's boundary representation is relatively easy. Building polygonal (tessellated) representations is useful for visualization purposes and for doing geometric calculations.
The reverse transformation — from the polygonal representation to B-rep — faces, however, a series of issues related to the complexity in recognizing different types of surfaces, including free-form ones. As well, there is the problem of noise in polygonal models that appear typically as the result of 3D scanning.
The general process by which C3D B-Shaper transforms models from polygonal to B-rep formats consists of three stages: segmentation, reconstruction of surfaces, and b-rep model construction. The transformation process is iterative: if users are for any reason unhappy with the results, then corrections can be made during the segmentation and surface reconstruction stages.
*Transforming a polygonal representation into a B-rep*
Before initiating the process of b-rep transformation, however, we improve the quality of the source polygonal mesh by applying the following fixes: coordinate the directions of normals in adjacent polygons; eliminate holes; and apply smoothing algorithms to noisy mesh sources, if any.
Segmenting the Polygonal Model
==============================
The first stage of transformation is segmenting the polygonal model. We classify the mesh polygon into subsets (segments). Information about the normals at each mesh vertex makes it possible to perform a first-order segmentation and then carry out the initial mesh splitting, as well as classify areas as flat or highly curved. The initial mesh splitting is based on defining «sharp» edges. These are the edges between two triangular polygons where the angle between their average normals exceeds a predefined value.
A second-order segmentation analyzes the mesh based on its main curvature, which is sufficient for classifying elementary surfaces. When calculating curvatures at mesh vertices, we use the results of Meyer's work (Mark Meyer, Mathieu Desbrun, Peter Schroder, and Alan H. Barr, «Discrete Differential-Geometry Operators for Triangulated 2-Manifolds,» Visualization and Mathematics III, 2003) in defining a discrete differential operator for triangulated regions: a set of adjacent vertices (related to a given vertex via an edge) is considered for each initial mesh vertex. Next, a discrete operator *K* is calculated for the vertex. Based on the operator, the average normal, mean *KH*, and Gaussian *KG* curvatures are defined at the mesh vertex.
*Defining discrete differential operators for triangulated regions*
In this way the curvature tensor is calculated for each mesh vertex, from which the principal curvature values *K1* and *K2* and principal curvature directions are extracted.
Mesh vertices are classified by the values of their principal curvatures *K1* and *K2*, and then are calculated for them. The vertex classification algorithm is based on k-means, i.e., minimizing the total squared deviation of cluster points from the centers of the clusters. The resulting output from the algorithm contains a mesh vertex associated with a cluster  and a pair of curvatures (cluster-center — L. Guillaume, «Curvature Tensor Based Triangle Mesh Segmentation with Boundary Rectification,» Proceedings Computer Graphics International (CGI), 2004).
*Classifying polygonal mesh vertices in the curvature space*
Once we finish classifying the vertices of the polygonal mesh, we go on to classifying the polygons. To start this procedure, we choose a triangular polygon whose curvature may be considered fully defined. This is one whose three vertices are within a single cluster, or has two vertices on a sharp edge. The polygon is labeled as a new segment and becomes the starting point for a recursive procedure that expands the segment: for each triangular polygon, adjacent polygons are considered as long as the edge between them is not «sharp.» When an adjacent polygon vertex, which is opposite to a common edge, is on a sharp edge or belongs to the same cluster, the polygon is added to the segment. The process is repeated until all of the polygons making up the mesh gone.
*Polygonal mesh segmentation*
Once the segment-creation procedure is complete, another algorithm stitches adjacent segments together to eliminate the over-segmentation of the mesh.
Surface-type Recognition
========================
The second stage is surface recognition. Each segment must be approximated by a surface with a precision determined by the system or by users.
Firstly, the principal curvature values of the segments are used to determine if it is at all possible to describe the segment’s form by one of the following elementary surfaces:
* Plane: *k1* = *k2* = 0
* Sphere: *k1* = *k2* = *K* > 0
* Cylinder: *k1* = *K* > 0, *k2* = 0
* Cone: *k1* ∈ [*a*, *b*], *k2* = 0
* Toroid: *k1* = *K*, *k2* ∈ [*a*, *b*]
To create elementary surfaces, we fit simple geometric objects onto sets of points using the appropriate algorithm. For instance, to fit a circle and a sphere onto a set of points, the method of least squares is used; to fit a plane, the principal component analysis is used. The system ensures that each reconstructed surface is related to a segment within a predefined precision of recognition.
The figure below illustrates recognized surfaces by color: planes are shown in blue, cylinders are in red, spheres in green, cones yellow, and toroids violet.
*Source polygonal mesh (left) and segmented mesh (right) with recognized surface segments*
If no elementary surface is able to describe the segment, then the system attempts to recognize an extrusion surface or a revolution surface.
When the system ultimately fails to find an analytical surface by which to describe the segment form, a NURBS surface is created for it.
B-rep Model Creation
====================
The final stage of the transformation is to create the B-rep model based on the segmentation and reconstructed surface data. An adjacency graph is created from the segmented regions to represent the model’s topology, and forms the basis for creating the resulting B-rep model. B-rep models are assembled in a fully automatic mode, in contrast to the preceding stages:
* B-rep edges are created from intersection curves of adjacent reconstructed surfaces
* B-rep faces are constructed by bounded recognized surfaces and B-rep edges
It is, however, not always possible to create a shell with the correct topology. For instance, take two surfaces such as a cylinder and a plane that are nearly tangent to one other in space. Due to the tolerance specified for the reconstructed surfaces, they may not intersect at all. As a result, the created shell may have defects. Users can eliminate defects by correcting the surface parameters.
Types of Polygonal Models
=========================
There are numerous sources of polygonal models available online:
* Online catalogs and databases offer 3D models in polygonal formats like STL, VRML, and OBJ from 3D Warehouse, Cults 3D, and so on
* Files that result from 3D scanning
* Output from the topological optimization of models using CAE algorithms
Polygonal models from these sources can be divided into two groups: models that were triangulated (meshed) from B-rep objects, and all other models. A pair of features specific to the first group is the absence of polygonal mesh noise and the domination of analytical surfaces. This means that models from the first group can be easily transformed into b-reps in fully automated mode or with minimal user effort.
Polygonal meshes of models in the second group have noise, contain organic surfaces, and so they more likely require the interactive participation of users.
Thus we provide two modes for operating C3D B-Shape, fully automatic and interactive. Users can switch between recognition modes, and manage surface types during the reconstruction process. Selecting a mode can depend on the purpose of performing the transformation: users may sometimes want to disregard the topological connectivity of the resulting shell, or its overall correctness. This is often the case when optimizing displaying in BIM applications, in which users are adding custom interior elements to the architectural model.
On the other hand, reverse engineering tasks require the most accurate copy possible of the source models so that the resulting model has a correct topology. So, it is necessary to predefine the precision of, say, cylinders' co-axiality or the tangency of two surfaces. In these kinds of cases, the participation of users in the transformation process is crucial.
C3D B-Shaper’s automatic transformation employs the following functions that use as input data the source mesh and transformation settings:
```
MbResultType ConvertMeshToShell( MbMesh & mesh,
MbFaceShell *& shell,
const MbMeshProcessorValues & params );
MbResultType ConvertCollectionToShell( MbCollection & collection,
MbFaceShell *& shell,
const MbMeshProcessorValues & params );
```
One of the transformation settings is a recognition-precision value that sets the maximum tolerance for distances between segment vertices and recognized surfaces. The precision can be absolute or relative. When using relative precision, the deviations of faces from mesh bodies are measured relative to the model’s size.
The MbMeshProcessor interface class offers advanced options for managing the segmentation and recognition of surfaces:
```
class MbMeshProcessor {
..
public:
// Mesh rectification.
void SetUseMeshSmoothing( bool useSmoothing );
// Mesh segmentation management.
const MbCollection & GetSegmentedMesh();
MbResultType SegmentMesh( bool createSurfaces = true );
void ResetSegmentation();
void UniteSegments( size_t firstSegmentIdx, size_t secondSegmentIdx );
MbResultType SegmentMeshBySeparators( const std::vector> & sep );
// Surface recognition management.
void FitSurfaceToSegment( size\_t idxSegment );
void FitSurfaceToSegment( size\_t idxSegment, MbeSpaceType surfaceType );
const MbSurface \* GetSegmentSurface( size\_t idxSegment ) const;
// B-rep shell construction.
MbResultType CreateBRepShell( MbFaceShell \*& pShell );
..
}
```
To, for example, correct the results from automatic segmentation, C3D B-Shaper offers tools for merging and dividing segments, and so on. Users can fit surfaces of given types onto the selected segment, as well as modify the parameters of recognized surfaces.
Summary
=======
The result of C3D B-Shaper’s transformation algorithms is illustrated by the figures below, in which a complex 3D model is successfully transformed from its polygonal mesh representation to a boundary-representation solid.
*Polygonal mesh (left) and B-rep model (right) converted with C3D B-Shaper*
Our aim is to create a powerful SDK for transforming models from polygonal to B-rep, and so development of C3D B-Shaper continues. Some of the things we are working on include advancing the automatic segmentation algorithms, developing tools for segmentation editing, improving the construction of free-form NURBS surfaces, and upping the quality of B-rep shell assemblies.
Customers who use the C3D geometric kernel are also a factor in driving the development of C3D B-Shaper.
Developers are welcome to test C3D B-Shaper as part of the C3D Toolkit or as a standalone component.
[](https://habrastorage.org/webt/k8/za/vg/k8zavgo-xihodwssql3y-aqlmam.jpeg) By Andrey Tumanin, Software Development Lead at C3D Labs | https://habr.com/ru/post/465237/ | null | en | null |
# Как автоматизировать рутинные операции с помощью Jupyter, Python и Selenium
Привет, Хабр! Меня зовут Николай Суворов, я [руководитель направления в МТС Digital](https://career.habr.com/companies/mts/vacancies). Занимаюсь продуктом [МТС Premium](https://premium.mts.ru/) – это единая подписка на сервисы МТС и партнеров. Сегодня я расскажу о нашем опыте создания робота для автоматизации повторяющихся действий сотрудников с помощью **Jupyter, Python и Selenium**. Статья будет интересна прежде всего менеджерам, которые хотят оптимизировать свою работу. Разработчикам мой текст будет полезен с точки зрения понимания возможностей по ускорению повторяющихся действий в интерфейсах. Весь необходимый код – ниже.
### Зачем автоматизировать рутину
Началась эта история так – на одном из грумингов координатор проектов Настя уставшим голосом сказала, что может приступить к своим прямым обязанностям только после того как заведет пару сотен промокодов в течение пары часов. А после такого сил и мотивации работать дальше может и не остаться.
Вообще, современные люди в основной своей массе не любят однообразную работу. Они считают ее скучной и демотивирующей, хотят разнообразных увлекательных задач. Но если мы говорим о крупных компаниях, то одни и те же операции, повторяемые ежедневно, по сумме затраченного времени могут быть точно оценены в рублях. И иной раз в результате таких расчетов получаются просто астрономические цифры.
Часть рутинных операций можно устранить при помощи **грамотного UX**. Но бывает и так, что требуется постоянно повторять одни и те же действия и в самых продуманных интерфейсах. Даже с кнопкой «копировать» или «создать по шаблону» рутинное действие не всегда происходит быстрее. Кроме того, при ручных операциях с увеличением количества задач возрастает и вероятность ошибки. Особенно, если дело касается цифр, дат, опций. Менеджер забыл поставить опцию отмены промокода в определённый день – и код становится вечным. Узнаем мы об этом только потом, читая еженедельный отчёт по активациям кодов. И это – совсем не единичный случай.
**UX/CX-анализ** – дело хлопотное и затратное, но доработки, ускоряющие выявленные повторяющиеся операции, обойдутся еще дороже. Их надо проаналитить, закодить, оттестировать, зарелизить. Между выявлением проблемы и ее устранением могут пройти месяцы и даже годы. И все это время компания продолжит тратить ресурсы на повторяющиеся однообразные операции, которые будут выполнять [всё возрастающее количество ассистентов](https://habr.com/ru/post/316028/).
### Как одному сотруднику завести 204 промокода за 2 часа
Итак, вернемся к нашему координатору проектов. Суть ее задачи состояла в том, чтобы через особый интерфейс в 17 подписках завести по 12 промокодов, которые затем идут в некую базу данных, где для каждого такого кода генерируются тысячи уникальных кодов. Такова архитектура, менять ее мы не можем.
Кроме того, необходимо к каждому коду указать даты его действия, размер предоставляемой скидки, название для облегчения поиска среди других кодов. Сам код нужно придумать, следуя специальному соглашению о нейминге. Помножив 17 на 12 – **получаем 204 кода**. На каждый тратим около 1-2 минут. Итого, в лучшем случае, уйдет 3,5 часа. А в реальности эта работа займет – **5-6 часов**, которые уйдут на нажатия кнопок в интерфейсе и ввод данных в текстовые поля. Кажется, что это слишком простая работа для целого координатора проектов. Но такой работы много и кому-то надо ее выполнить, причем очень быстро. Зачастую бизнес ожидает, что коды будут заведены в тот же день, даже если задача поступает в 17:00.
Да, мы могли бы поставить задачу на аналитику по автоматизации конкретного действия по заведению промокодов. Но система, куда они вводятся, имеет свой релизный цикл, а бэклог забит до конца следующего года. И это, мягко говоря, не самая приоритетная задача по соотношению пользы/затрат. Промокоды нужны конкретно нашему продукту, а у системы их более 50.
Промокоды были придуманы нами неожиданно. Понятное дело, что система не может дорабатываться под «хотелки» команды каждого отдельного продукта по мере придумывания сотрудниками новых фич. Итогом наших прений была работа координатора проектов над задачей по ручному заведению **200+ промокодов 2-3 раза в неделю**.
С этим определенно нужно было что-то делать. Мы очень ценим нашу Настю и не хотели бы, чтобы она ушла из команды по причине того, что больше некому делать рутинную работу. Поплыли другие задачи, которые имели непосредственное отношение к нашему менеджеру. Она просто не успевала ими заниматься. Ситуация осложнялась тем, что наша команда разработки была занята непосредственно продуктом. Мы не могли тратить время на автоматизацию рутинных задач менеджера. Все, что мы могли – использовать имеющиеся знания других менеджеров в области прикладной разработки на Python.
### Как нам помог Jupyter, Python и Selenium
При помощи связки **Jupyter+Python+Selenium** можно в 4-5 раз ускорить известные, повторяемые изо дня в день, операции в интерфейсах. **Selenium** – известный продукт для симуляции действий в интерфейсах и тестирования. **Python** – простейший язык, доступный для освоения даже младшим школьникам. **Jupyter** – лучший инструмент моделирования алгоритмов. Для разработки мы использовали окружение [Anaconda](https://www.anaconda.com/products/distribution), поскольку оно сразу дает почти весь нужный инструментарий в готовом виде. Повозиться пришлось только с [установкой Selenium и его драйвера для Google Chrome](https://habr.com/ru/post/494544/). Но про это написано множество статей и руководств, поэтому повторяться не будем.
Jupyter похвалю отдельно, ибо это гениальный инструмент. Разработка с его помощью ускоряется в несколько раз за счет того, что мы не поднимаем окружение под новый проект, а можем «на коленке» сразу пробовать алгоритм **в рамках блокнота**, в котором до этого делали вообще другую задачу.
Мы не думаем о тестировании – блокнот сам по себе инструмент тестирования гипотез о работе алгоритма. Мы тут же устанавливаем все нужные модули и смотрим справку всех функций, которые нас интересуют, описываем алгоритм словами, на языке разметки Markdown. Не знаю, как для разработчиков, а для менеджеров ничего лучше не придумано. Пожалуй, [визуальное zero-code программирование](https://habr.com/ru/post/587648/) посложнее будет. И оно менее гибкое, если нужен только бэк.
Все блоки кода, приведенные ниже, можно класть в отдельные блоки Jupyter. Так нагляднее и проще тестировать каждый отдельный кусок. Да и результаты выполнения сохраняются. Но это может как помочь, так и сыграть с нами злую шутку. Важно помнить эту особенность и перезапускать блоки со свойствами для робота в случае внесения любых изменений в них.
Сначала заводим свойства для нашего робота:
```
#Логин и пароль нашей Большой системы (в которой заводим промокоды)
lg = "oursuperman"
ps = "qwerty1234"
#Настройки промо-кампании общие
promoActionName = 'Всемирный день благодарности за хорошие продукты'
campaign_num = '003432' #Общий номер промокампании для облегчения поиска
campaign_length = '45' #Длительность промокампании
campaign_tariff_period = '45' #Через сколько начинаем брать деньги (да, это разные параметры)
tariff_category = '0 ₽' #Пока действует промокод не берём с клиента ни копейки
campaign_period_start = '20.10.2022' #Дата начала промокампании
campaign_period_stop = '28.10.2022' #Дата окончания
promocodes_generated = [] #Сюда будем складывать наши промики для статистики
#А тут у нас будут настройки промокампании по подпискам (те самые 17 подписок)
subs_to_promo = [
{
'name':'МТС некая подписка 1',
'prefix':'N',
'num_promocodes':1
},
{
'name':'МТС некая подписка 2',
'prefix':'N',
'num_promocodes':1
}
]
```
Далее пишем основные функции, которые будем использовать из раза в раз:
```
def openContent(content_obj):
#Открываем нужную подписку
url = f"https://our.domain/subs/{content_obj['content_id']}"
driver.get(url)
def processContent(content_obj):
#Скролл вниз
driver.find_element(By.TAG_NAME, "body").send_keys(Keys.PAGE_DOWN)
#Открываем расхлоп "Промоакции"
promo_block = driver.find_element(By.XPATH, "//span[text()=' Промоакции ']")
promo_block.find_element(By.CSS_SELECTOR, "button").click()
def createPromocode(num_promocode):
#Создаём новую промоакцию
promo_block = driver.find_element(By.XPATH, "//span[text()=' Промоакции ']")
promo_block.find_element(By.CSS_SELECTOR, "button.inserted").click()
def setFieldsPromocode(num_promocode):
#Выставляем свойства промоакции
f_dateRange = driver.find_element(By.NAME, "dateRange")
f_dateRange.click()
sleep(1) #Обязательно делаем паузы, чтобы было время прогрузиться элементам
f_dateRange.send_keys(campaign_period_start) #Тут просто печатаем символы в поля ввода
f_dateRange.send_keys(campaign_period_stop)
#Добавляем название кампании
f_promoActionName = driver.find_element(By.NAME, "promoActionName")
f_promoActionName.find_element(By.CSS_SELECTOR, "input.input_111").send_keys(f"{promoActionName}_{num_promocode}")
#Добавляем длительность
f_period = driver.find_element(By.NAME, "period")
f_period.find_element(By.CSS_SELECTOR, "input.input_222").send_keys(campaign_length)
#Добавляем период тарификации
f_tarifficationPeriod = driver.find_element(By.NAME, "tarifficationPeriod")
f_tarifficationPeriod.find_element(By.CSS_SELECTOR, "input.input_333").send_keys(campaign_tariff_period)
#Формируем текст промо-кода
promocode = ""
#Просто собираем текстовую строку. Проще конечно по шаблону, но тут нагляднее процесс сборки
promocode += content_obj["prefix"] + "_"
#... тут много всего в части соблюдения нашего соглашения о нейминге
promocode += campaign_num + "_"
promocode += str(num_promocode)
#Добавляем текст промокода
f_promoActionName = driver.find_element(By.NAME, "promoCode")
f_promoActionName.find_element(By.CSS_SELECTOR, "input.input_444").send_keys(promocode)
return promocode
```
Далее открываем браузер и логинимся при помощи Selenium:
```
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.by import By
from time import sleep
#Открываем сайт Большой системы (в которой заводим промокоды) при помощи драйвера Selenium
url = "https://big.system.domain"
driver = webdriver.Chrome(executable_path=r"C:\Chrome\DriverPath\chromedriver.exe")
driver.get(url)
#Обязательно ждём пока загрузится URL
sleep(5)
#Находим все нужные поля. Я для этого использовал XPath (см. режим разработчика в Google Chrome и правой кнопкой мыши по нужному нам элементу, там Copy Xpath)
login = "/html/body/div[2]/app-input/div/input"
password = "/html/body/div[2]/app-input-password/div/input"
btn_enter = "/html/body/app-form/form/input"
login_control = driver.find_element(By.XPATH, login)
password_control = driver.find_element(By.XPATH, password)
btn_enter = driver.find_element(By.XPATH, btn_enter)
#Логинимся
login_control.clear()
login_control.send_keys(lg)
password_control.clear()
password_control.send_keys(ps)
sleep(3)
btn_enter.click()
```
И в завершение, основная логика работы робота по заведению промокодов через интерфейс Большой системы:
```
#Цикл перебора подписок, в которых мы хотим завести промокоды (см. первый блок с настройками)
for content in list(range(0,len(subs_to_promo))):
content_obj = subs_to_promo[content]
#Тут уже вызываем описанную нами ранее функцию (см. второй блок с функциями)
openContent(content_obj)
#Всегда даём страничке прогрузиться
sleep(3)
#Задача этой функции открыть все нужные расхлопы на странице. У вас может быть по другому
processContent(content_obj)
sleep(3)
for num_promocode in list(range(1, content_obj['num_promocodes']+1)):
createPromocode(num_promocode)
#Добавляем сгенерированный и положенный нами промокод для статистики
promocodes_generated.append(setFieldsPromocode(num_promocode))
#Нажимаем кнопку "Создать"
driver.find_element(By.XPATH, f"//button[text()='Создать']").click()
sleep(8)
#В конце выводим список сгенерированных промокодов
print("Список промокодов:")
for code in promocodes_generated:
print(code)
```
### Заключение
Созданный «на коленке» робот **ускорил выполнение задачи** по заведению промокодов в несколько раз. Собственно, вся работа координатора Насти теперь сводится к тому, что она внимательно выставляет нужные настройки и следит за работой алгоритма.
Если что-то идет не так – всегда можно остановить выполнение и начать с того места на котором остановились. Это же Jupyter, он позволяет такие вещи. Выглядит просто, но оно работает и реально экономит время на другие задачи, много времени.
Ранее для автоматизации рутины я использовал [AutoIt](https://habr.com/ru/post/316028/), но этот продукт почти заброшен, он не развивается. Драйверы к браузерам перестали работать. Поэтому пришлось быстро осваивать Selenium, но оно того стоило. Его возможности гораздо шире. А Python мне намного привычнее языка, используемого в AutoIt.
Рекомендую всем менеджерам, у которых есть рутинные и затратные операции, последовать нашему примеру. Время потраченное на то, чтобы разобраться со всем этим, в долгосроке окупится многократно. А освободившиеся часы можно потратить на творческую работу и новые интересные задачи.
Спасибо за уделенное статье время! Надеюсь, вы сможете применить наш метод на практике и он поможет вам сделать работу более разнообразной и продуктивной. **Если у вас есть вопросы, замечания или опыт решения подобных задач – жду вас в комментариях!** | https://habr.com/ru/post/695696/ | null | ru | null |
# Почему, зачем и когда нужно использовать ValueTask
Этот перевод появился благодаря хорошему комментарию [0x1000000](https://habr.com/ru/users/0x1000000/).
В .NET Framework 4 появилось пространство System.Threading.Tasks, а с ним и класс Task. Этот тип и порождённый от него Task долго дожидались, пока их признают стандартами в .NET в роли ключевых аспектов модели асинхронного программирования, которая была представлена в C# 5 с его операторами async/await. В этой статье я расскажу о новых типах ValueTask/ValueTask, разработанных для улучшения производительности асинхронных методов в случаях, когда издержки на выделение памяти нужно принимать во внимание.
### Task
Task выступает в разных ролях, но основная – это “обещание” (promise), объект, представляющий возможное завершение некоторой операции. Вы инициируете операцию и получаете для неё объект Task, который будет выполнен, когда операция завершится, что может произойти в синхронном режиме как составная часть инициализации операции (например, получение данных, которые уже в буфере), в асинхронном режиме с выполнением в момент, когда вы получаете Task (получение данных не из буфера, но очень быстро), или в асинхронном режиме, но после того, как Task уже у вас (получение данных с удалённого ресурса). Так как операция может завершиться асинхронно, вы или блокируете поток выполнения, ожидая результата (что часто делает бессмысленным асинхронность вызова), или создаёте функцию обратного вызова (callback), которая будет активизирована после завершения операции. В .Net 4 создание callbackа реализовано методами ContinueWith объекта Task, которые явно демонстрируют эту модель, принимая функцию-делегат (delegate), чтобы запустить её после исполнения Task:
```
SomeOperationAsync().ContinueWith(task =>
{
try
{
TResult result = task.Result;
UseResult(result);
}
catch (Exception e)
{
HandleException(e);
}
});
```
Но в .NET Framework 4.5 и C# 5 объекты Task могут быть просто вызваны оператором await, что делает простым получение результата асинхронной операции, и генерированным кодом, который оптимизирован для вышеупомянутых вариантов, правильно отработает во всех случаях завершения операции в синхронном режиме, быстром асинхронном или асинхронном с выполнением callbacka:
```
TResult result = await SomeOperationAsync();
UseResult(result);
```
Task является очень гибким классом и это даёт ряд преимуществ. Например, вы можете выполнить await несколько раз для любого количества потребителей одновременно. Вы можете положить его в коллекцию (dictionary) для повторных await в будущем, чтобы использовать его как кеш результатов асинхронных вызовов. Вы можете заблокировать выполнение, ожидая завершения Task, если такое понадобится. И вы можете написать и применить разнообразные операции над объектами Task (иногда их называют «комбинаторами»), например, «когда любая» (“when any”) для асинхронного ожидания первого завершения из нескольких Task.
Но эта гибкость становится лишней в наиболее часто встречающемся случае: просто вызвать асинхронную операцию и дождаться выполнения задачи:
```
TResult result = await SomeOperationAsync();
UseResult(result);
```
Здесь нам не понадобится ждать выполнения несколько раз. Нам не нужно обеспечить конкуррентность ожиданий. Нам не нужно выполнять синхронную блокировку. Мы не будем писать комбинаторы. Мы просто ждём выполнения promise асинхронной операции. В конце концов, это так, как мы пишем синхронный код (например, TResult result = SomeOperation();), и это обычным образом переводится на язык async/await.
Более того, у Task есть потенциальная слабая сторона, особенно когда создаётся большое количество его экземпляров, а большая пропускная способность и производительность являются ключевыми требованиями – Task является классом. Это означает, что любая операция, которой понадобился Task, вынуждена создавать и размещать объект, а чем больше объектов создаётся, тем больше работы для сборщика мусора (GC), и на эту работу расходуются ресурсы, которые мы могли бы потратить на что-то более полезное.
Среда выполнения и системные библиотеки помогают смягчать эту проблему во многих ситуациях. Например, если мы напишем такой метод:
```
public async Task WriteAsync(byte value)
{
if (_bufferedCount == _buffer.Length)
{
await FlushAsync();
}
_buffer[_bufferedCount++] = value;
}
```
как правило, в буфере будет достаточно свободного пространства, и операция выполнится синхронно. Когда это произойдёт, не нужно ничего делать с Task, который должен быть возвращён, так как возвращаемое значение отсутствует, это использование Task как эквивалент синхронного метода, возвращающего пустое значение (void). Поэтому среда может просто кешировать один необобщённый (non-generic) Task и использовать его снова и снова как результат выполнения для любого async метода, который завершается синхронно (этот кешированный синглтон можно получить через Task.CompletedTask). Или, например, вы пишете:
```
public async Task MoveNextAsync()
{
if (\_bufferedCount == 0)
{
await FillBuffer();
}
return \_bufferedCount > 0;
}
```
и в общем случае ожидаете, что данные уже в буфере, так что метод просто проверит значение \_bufferedCount, увидит, что оно больше 0, и вернёт true; и только если данных в буфере ещё нет, нужно выполнить асинхронную операцию. И так как есть только два возможных результата типа Boolean (true и false), существует только два возможных Task объекта, которые нужны для представления этих результатов, среда может кешировать эти объекты и возвращать их с соответствующим значением без выделения памяти. Только в случае асинхронного завершения методу понадобится создать новый Task, потому что его будет нужно вернуть до того, как станет известен результат операции.
Среда обеспечивает кеширование и для некоторых других типов, но нереально кешировать все возможные типы. Например, следующий метод:
```
public async Task ReadNextByteAsync()
{
if (\_bufferedCount == 0)
{
await FillBuffer();
}
if (\_bufferedCount == 0)
{
return -1;
}
\_bufferedCount--;
return \_buffer[\_position++];
}
```
также будет часто выполняться синхронно. Но в отличие от варианта с результатом типа Boolean этот метод возвращает Int32, который имеет порядка 4 миллиардов значений, и кеширование всех вариантов Task потребует сотни гигабайт памяти. Среда обеспечивает небольшой кеш для Task, но сильно ограниченного набора значений, например, если этот метод завершится синхронно (данные уже в буфере) с возвращаемым значением 4, это будет кешированный Task, но если возвращается значение 42, то нужно будет создать новый Task, подобно вызову Task.FromResult(42).
Многие методы библиотеки пытаются сгладить это путём обеспечения собственного кеша. Например, перегрузка в.NET Framework 4.5 метода MemoryStream.ReadAsync всегда завершается синхронно, так как читает данные из памяти. ReadAsync возвращаетTask, где результат типа Int32 показывает сколько байт было прочитано. Этот метод часто используется в цикле, часто с одним и тем же требуемым количеством байтов при каждом вызове, и часто эта потребность удовлетворяется в полном объёме. Так что для повторных вызовов ReadAsync обоснованно ожидать, что Task будет синхронно возвращаться с таким же значением, как и в прошлом вызове. Поэтому MemoryStream создаёт кеш для одного объекта, который вернулся в последнем успешном вызове. И в следующем вызове, если результат повторится, он вернёт кешированный объект, а если нет, создаст новый с Task.FromResult, сохранит в кеш и вернёт его.
И всё же есть множество других случаев, когда операция выполняется синхронно, но объект Task вынужденно создаётся.
#### ValueTask и синхронное выполнение
Всё это потребовало реализации в .NET Core 2.0 нового типа, который доступен в предыдущих версиях .NET в пакете NuGet System.Threading.Tasks.Extensions: ValueTask.
ValueTask создан в .NET Core 2.0 как структура, способная обернуть как TResult, так и Task. Это означает, что её можно возвращать из async метода, и, если этот метод выполнится синхронно и успешно, никакого объекта в куче размещать не надо: вы можете просто инициализировать эту структуру ValueTask значением TResult и вернуть. Только в случае асинхронного выполнения объект Task будет размещён, а ValueTask обернёт его (чтобы минимизировать размер структуры и оптимизировать случай успешного исполнения, async метод, который завершается с неподдерживаемым исключением, также будет размещать Task, так что ValueTask так же просто обернёт Task, а не будет таскать с собой дополнительное поле для хранения Exception).
Исходя из этого, метод наподобие MemoryStream.ReadAsync, но возвращающий ValueTask, не должен заниматься кешированием, а вместо этого может быть написан так:
```
public override ValueTask ReadAsync(byte[] buffer, int offset, int count)
{
try
{
int bytesRead = Read(buffer, offset, count);
return new ValueTask(bytesRead);
}
catch (Exception e)
{
return new ValueTask(Task.FromException(e));
}
}
```
#### ValueTask и асинхронное выполнение
Возможность написать async метод, который способен завершиться синхронно без необходимости дополнительного размещения для результата, это большая победа. Вот почему ValueTask был добавлен в .NET Core 2.0, и новые методы, которые вероятно будут использоваться в приложениях, требующих производительности, теперь объявляются с возвращением ValueTask вместо Task. Например, когда мы добавили новую перегрузку ReadAsync класса Stream в .NET Core 2.1, для того чтобы иметь возможность передавать Memory вместо byte[], мы возвращаем в нём тип ValueTask. В таком виде объекты Stream (в которых очень часто метод ReadAsync исполняется синхронно, как в ранее приведённом примере для MemoryStream) могут использоваться со значительно меньшим выделением памяти.
Однако, когда мы работаем с сервисами с очень высокой пропускной способностью, мы по-прежнему хотим избежать выделения памяти насколько вообще это возможно, а это означает уменьшение и устранение выделения памяти также и по маршруту асинхронного исполнения.
В модели await для любой операции, завершающейся асинхронно, нам необходима способность вернуть объект, который представляет возможное завершение операции: вызывающему необходима переадресация callbackа, который будет инициирован по завершению операции, и это требует наличия уникального объекта в куче, который может послужить как канал передачи для этой конкретной операции. Это, в то же время, не означает ничего будет ли этот объект использован повторно после завершения операции. Если этот объект может быть использован повторно, API может организовать кеш для одного или нескольких таких объектов, и применять его для последовательных операций, в смысле не использовать один и тот же объект для нескольких промежуточных async операций, но использовать для неконкуррентного доступа.
В .NET Core 2.1 класс ValueTaskбыл доработан для поддержки подобной работы с пулами и повторного использования. Вместо того, чтобы просто оборачивать TResult или Task, доработанный класс может оборачивать новый интерфейс IValueTaskSource. Этот интерфейс обеспечивает основную функциональность, которая требуется для сопровождения асинхронной операции объектом ValueTask так же, как это делает Task:
```
public interface IValueTaskSource
{
ValueTaskSourceStatus GetStatus(short token);
void OnCompleted(Action continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags);
TResult GetResult(short token);
}
```
Метод GetStatus используется, чтобы реализовать свойства подобные ValueTask.IsCompleted, которое возвращает информацию выполняется асинхронная операция или завершена, и как завершена (успешно или нет). Метод OnCompleted используется ожидающим объектом для присоединения callbackа, чтобы продолжить выполнение с точки await, когда операция завершится. А метод GetResult нужен для получения результата операции, так что после окончания операции вызвавший метод может получить объект TResult или передать любое исключение, которое было выброшено.
Большинству разработчиков этот интерфейс не нужен: методы просто возвращают объект ValueTask, который может быть создан как обёртка объекта, реализующего этот интерфейс, и вызывающий метод будет останется в неведении. Этот интерфейс для разработчиков, которым требуется избежать выделения памяти при использовании API, критичного к производительности.
Существует несколько примеров такого API в .NET Core 2.1. Наиболее известные методы — это Socket.ReceiveAsync и Socket.SendAsync с новыми перегрузками, добавленными в 2.1, например
```
public ValueTask ReceiveAsync(Memory buffer, SocketFlags socketFlags, CancellationToken cancellationToken = default);
```
Эта перегрузка возвращает ValueTask. Если операция завершается синхронно, она может просто вернуть ValueTask с соответствующим значением:
```
int result = …;
return new ValueTask(result);
```
При асинхронном завершении она может использовать объект из пула, который реализует интерфейс:
```
IValueTaskSource vts = …;
return new ValueTask(vts);
```
Реализация Socket поддерживает один такой объект в пуле для приёма, и один для передачи, так как не может быть для каждого направления более одного объекта, ожидающего выполнения в один момент времени. Эти перегрузки не выделяют памяти, даже в случае асинхронного исполнения операции. Это поведение проявляется далее в классе NetworkStream.
Например, в .NET Core 2.1 Stream предоставляет:
```
public virtual ValueTask ReadAsync(Memory buffer, CancellationToken cancellationToken);
```
который переопределяется в NetworkStream. Метод NetworkStream.ReadAsync просто использует метод Socket.ReceiveAsync, так что выигрыш в Socket транслируется в NetworkStream, и NetworkStream.ReadAsync фактически тоже не выделяет памяти.
#### Необобщённый ValueTask
Когда ValueTask появился в .NET Core 2.0, в нём оптимизирован был только случай синхронного выполнения, для того чтобы исключить размещение объекта Task, если значение TResult уже готово. Это означало, что необобщённый класс ValueTask был не нужен: для случая синхронного выполнения синглтон Task.CompletedTask мог быть просто возвращён из метода, и это делалось средой неявно в async методах, возвращающих Task.
Тем не менее, с получением асинхронных операций без выделения памяти использование необобщённого ValueTask снова стало актуальным. В .NET Core 2.1 мы представили необобщённые ValueTask и IValueTaskSource. Они обеспечивают прямые эквиваленты для обобщённых версий, для аналогичного использования, только с пустым возвращаемым значением.
#### Реализация IValueTaskSource/IValueTaskSource
Большинство разработчиков не должно реализовывать эти интерфейсы. К тому же это не так уж легко. Если вы решите сделать это, несколько реализаций в .NET Core 2.1 могут послужить отправной точкой, например:
* AwaitableSocketAsyncEventArgs
* AsyncOperation
* DefaultPipeReader
Чтобы сделать это легче, в .NET Core 3.0 мы планируем представить всю необходимую логику, включённую в тип ManualResetValueTaskSourceCore, структуру, которая может быть встроена в другой объект, который реализует IValueTaskSource и/или IValueTaskSource, чтобы можно делегировать в эту структуру основную часть функциональности. Об этом можно больше узнать из <https://github.com/dotnet/corefx/issues/32664> в репозитории dotnet/corefx.
#### Паттерны применения ValueTasks
На первый взгляд область применения ValueTask и ValueTask намного более ограничена, чем Task и Task. Это хорошо, и даже ожидаемо, так как основной способ их применения – просто использование с оператором await.
Однако, так как они могут оборачивать объекты, которые повторно используются, существуют значительные ограничения по их применению в сравнении с Task и Task, если отклониться от обычного способа простого await. В общих случаях, следующие операции никогда не должны выполняться с ValueTask/ValueTask:
* **Повторное ожидание ValueTask/ValueTask** Объект результата может уже быть утилизирован и использоваться в другой операции. Напротив, Task/Task никогда не переходит из завершённого состояния в незавершённое, поэтому вы можете повторно ожидать его столько раз, сколько потребуется, и получать один и тот же результат каждый раз.
* **Параллельное ожидание ValueTask/ValueTask** Объект результата ожидает обработки только одним callbackом от одного потребителя в один момент времени, и попытка его ожидания из разных потоков одновременно может легко привести к гонкам и трудноуловимым ошибкам программы. Кроме того, это также более специфичный случай предыдущей недопустимой операции «повторное ожидание». В сравнении с этим, Task/Task обеспечивает любое количество параллельных awaitов.
* **Использование .GetAwaiter().GetResult(), когда операция ещё не завершилась** Реализация IValueTaskSource/IValueTaskSource не нуждается в поддержке блокировки до окончания операции, и, скорее всего, не сделает этого, так что такая операция определённо приведёт к гонкам и вероятно будет выполнена не так, как ожидает вызывающий метод. Task/Task блокирует вызывающий поток пока задача не будет выполнена.
Если получили ValueTask или ValueTask, но необходимо выполнить одну из этих трёх операций, вы можете использовать .AsTask(), получить Task/Task и после этого работать с полученным объектом. После этого вы больше не сможете использовать тот ValueTask/ValueTask.
Короче говоря, правило таково: при применении ValueTask/ValueTask вы должны или await его непосредственно (возможно с .ConfigureAwait(false)) или вызвать AsTask() и больше его не использовать:
```
// Дан такой метод, возвращающий ValueTask
public ValueTask SomeValueTaskReturningMethodAsync();
...
// GOOD
int result = await SomeValueTaskReturningMethodAsync();
// GOOD
int result = await SomeValueTaskReturningMethodAsync().ConfigureAwait(false);
// GOOD
Task t = SomeValueTaskReturningMethodAsync().AsTask();
// WARNING
ValueTask vt = SomeValueTaskReturningMethodAsync();
// сохранение экземпляра локально делает это потенциально небезопасным,
// но может быть безвредным
// BAD: await несколько раз
ValueTask vt = SomeValueTaskReturningMethodAsync();
int result = await vt;
int result2 = await vt;
// BAD: await параллельно (и по определению несколько раз)
ValueTask vt = SomeValueTaskReturningMethodAsync();
Task.Run(async () => await vt);
Task.Run(async () => await vt);
// BAD: использование GetAwaiter().GetResult(), если неизвестно о завершении
ValueTask vt = SomeValueTaskReturningMethodAsync();
int result = vt.GetAwaiter().GetResult();
```
Есть ещё один продвинутый паттерн, который программисты могут применять, надеюсь, только после аккуратного измерения и получения существенных преимуществ. Классы ValueTask/ValueTask имеют несколько свойств, которые сообщают о текущем состоянии операции, например, свойство IsCompleted возвращает true, если операция выполнилась (то есть, больше не выполняется и завершилась успешно или не успешно), а свойство IsCompletedSuccessfully возвращает true, только если завершилась успешно (при ожидании и получении результата не выбросило исключения). Для самых напряжённых потоков выполнения, там, где разработчик хочет избежать затрат, которые появляются при асинхронном режиме, эти свойства могут быть проверены перед операцией, которая фактически разрушит объект ValueTask/ValueTask, например await, .AsTask(). Например, в реализации SocketsHttpHandler в .NET Core 2.1 код выполняет чтение из соединения и получает ValueTask. Если эта операция выполнится синхронно, нам не стоит беспокоиться о досрочном прерывании операции. Но если она выполняется асинхронно, мы должны подцепить обработку прерывание, чтобы запрос прерывания разорвал соединение. Так как это очень напряжённый участок кода, если профилирование покажет необходимость в следующем небольшом изменении, его можно структурировать так:
```
int bytesRead;
{
ValueTask readTask = \_connection.ReadAsync(buffer);
if (readTask.IsCompletedSuccessfully)
{
bytesRead = readTask.Result;
}
else
{
using (\_connection.RegisterCancellation())
{
bytesRead = await readTask;
}
}
}
```
#### Должен ли каждый новый метод асинхронного API возвращать ValueTask/ValueTask?
Если ответить кратко: нет, по умолчанию стоит по-прежнему выбирать Task/Task.
Как подчёркивать выше, Task и Task использовать правильно легче, чем ValueTask и ValueTask, и до тех пор, пока требования производительность не перевешивают требования практичности, Task и Task предпочтительны. Кроме того, есть небольшие затраты, связанные с возвращением ValueTask вместо Task, то есть, микробенчмарки показывают, что await Task выполняется быстрее, чем await ValueTask. Так что, если вы используете кеширование задач, например, ваш метод возвращает Task или Task, для производительности стоит остаться с Task или Task. Объекты ValueTask/ValueTask занимают в памяти несколько слов, поэтому, когда они ожидаются, и поля для них резервируются в вызывающей async метод машине состояний, они будут занимать в ней больше памяти.
И всё-таки ValueTask/ValueTask будут отличным выбором когда: а) вы ожидаете, что вызывать ваш метод будут только с await, б) затраты на выделение памяти критичны для вашей разработки, в) синхронное выполнение будет происходить часто, или вы сможете эффективно повторно использовать объекты при асинхронном выполнении. При добавлении абстрактных, виртуальных или интерфейсных методов вы должны рассмотреть будут ли так же выполняться эти условия при перегрузке/реализации этих методов.
#### Что дальше с ValueTask и ValueTask?
Для системных библиотек .NET мы будем продолжать работать с методами, возвращающими Task/Task, но методы, возвращающие ValueTask/ValueTask, так же будут добавляться там, где это необходимо. Один ключевой пример таких методов – это новый IAsyncEnumerator, который должен появиться в .NET Core 3.0. IEnumerator имеет метод MoveNext, который возвращает bool, и его асинхронный аналог IAsyncEnumerator предоставляет метод MoveNextAsync. Когда мы начали его разрабатывать, думали, что он должен возвращать Task, который может быть очень эффективен кешированными задачами при частом завершении в синхронном режиме. Однако, в виду того, как разнообразны могут быть асинхронные перечислимые типы, как разнообразны могут быть реализации этого интерфейса (и для некоторых из них очень критичны проблемы производительности и выделения памяти), и что основным способом их использования будет await в конструкции foreach, мы остановились на варианте с ValueTask. Это позволит операциям с синхронным завершением выполняться быстро, а для асинхронного завершения будет доступна возможность экономии памяти. И на самом деле компилятор C# использует эти преимущества, когда создаёт асинхронные итераторы, реализуя их без выделения памяти, если это возможно. | https://habr.com/ru/post/458828/ | null | ru | null |
# Экспорт метрик в Prometheus из логов PostgreSQL с помощью Vector
В этой статье я хочу рассказать о не совсем обычном использовании логов — о получении из лог-файлов метрик для Prometheus. Это может быть полезно, когда существующие экспортеры не предоставляют нужные метрики, а писать свой экспортер не хочется или очень затратно.
Один из наших клиентов пришел с задачей оперативно получать информацию о запросах из приложения к базе данных PostgreSQL, завершившихся с ошибкой, но не вносить при этом каких-либо изменений в кодовую базу приложения. Просмотрев существующие экспортеры для PostgreSQL и не найдя там подходящих метрик, по которым можно было бы отправить сообщение об ошибке, мы решили, что нужно самим сделать такую метрику.
Подготовка логов
----------------
Технически задача свелась к парсингу лог-файла, выделению метрики по полученным данным, записи метрики в Prometheus и настройки алертинга. К сожалению, PostgreSQL до 15 версии не поддерживает «из коробки» популярный формат структурированных логов JSON. Приносить для этого сторонние модули в production-окружение не хотелось, как и писать лог в формате CSV. Зато была возможность структурировать формат вывода в конфигурационном файле. Клиентом использовался следующий формат лога:
```
# postgresql.conf
log_line_prefix = '%m %p %u@%d from %h [vxid:%v txid:%x] [%i] '
```
Где:
* `%m` – time stamp, включая миллисекунды;
* `%p` – Process ID;
* `%u` – имя пользователя;
* `%d` – имя базы данных.
Подробнее о том, за что отвечают другие переменные и какую еще информацию возможно записать в лог, написано [в документации к PostgreSQL](https://www.postgresql.org/docs/14/runtime-config-logging.html). В итоге получается приблизительно такая строка:
```
2022-05-12 07:33:54.285 UTC 2672031 @ from [vxid: txid:0] [] LOG: checkpoint complete: wrote 64 buffers (0.0%); 0 WAL file(s) added, 0 removed, 10 recycled; write=6.266
s, sync=0.004 s, total=6.285 s; sync files=10, longest=0.003 s, average=0.001 s; distance=163840 kB, estimate=163844 kB
```
Поиск оптимального решения
--------------------------
Для получения метрики из логов и ее доставки в Prometheus мы пробовали использовать [fluentd,](https://docs.fluentd.org/) [promtail](https://grafana.com/docs/loki/latest/clients/promtail/) и [Vector](https://vector.dev/docs/).
У fluentd существует обширная система плагинов на все случаи жизни. Например, есть [fluent-plugin-prometheus](https://github.com/fluent/fluent-plugin-prometheus) для преобразования данных в формат метрик и доставки их в Prometheus. Однако после выпуска v2.0.0 в начале прошлого года проект развивается очень неторопливо. Поэтому, несмотря на то, что мы любим fluentd и часто его используем, в этот раз мы решили взять что-нибудь другое.
Первоначально выбор пал на promtail. Он умеет парсить текстовый файл лога (включая многострочные логи), обрабатывать его исходя из поставленной задачи (в том числе и выделять метрики), а также фильтровать содержимое по заданным параметрам.
Для теста был написан конфигурационный файл, в котором считались строчки лога. Вот пример стадии обработки лога:
```
pipeline_stages:
- multiline:
firstline: '^\[\d{4}-\d{2}-\d{2} \d{1,2}:\d{2}:\d{2}\]'
- regex:
expression: '^(?P\[\d{4}-\d{2}-\d{2} \d{1,2}:\d{2}:\d{2}\]) (?P(?s:.\*))$'
- metrics:
log\_lines\_total:
type: Counter
description: "total number of log lines"
prefix: pg\_custom\_
max\_idle\_duration: 24h
config:
match\_all: true
action: inc
log\_bytes\_total:
type: Counter
description: "total bytes of log lines"
prefix: pg\_custom\_
max\_idle\_duration: 24h
config:
match\_all: true
count\_entry\_bytes: true
action: add
```
Конфигурация прекрасно работала, однако мы упустили один важный момент. Promtail требует обязательным параметром в конфигурации указание адреса Loki — инструмента для агрегации логов, разрабатываемого Grafana. Без указания этого параметра он просто не запускается. Устанавливать клиенту еще и Loki нам показалось нецелесообразным.
> Если очень хочется все-таки использовать promtail, можно вместо Loki указать адрес любого веб-сервера (например, nginx), который на любой запрос будет отдавать код ответа 200. Однако использовать подобный хак в production-окружении мы **не рекомендуем**.
>
>
Последним мы попробовали Vector, и он нам подошел.
Парсинг логов и их отправка в Prometheus с помощью Vector
---------------------------------------------------------
Для того, чтобы получать данные от Vector в Prometheus, необходимо установить его на хосты, где находятся лог-файлы, которые нужно парсить, а затем настроить конфигурацию. Сделать это можно, например, с помощью Ansible:
```
# playbook-vector.yaml
---
- name: Setup vector
hosts:
- pg
become: yes
vars:
arch: amd64
version: 0.18.1
vector_template: files/40-vector.toml
vector_config_file: /etc/vector/vector.toml
tasks:
- name: Setup install vector
become: yes
apt:
deb: "https://packages.timber.io/vector/{{ version }}/vector-{{ version }}-{{ arch }}.deb"
install_recommends: yes
notify:
- restart vector
- name: Copy config
copy:
src: "{{ vector_template }}"
dest: "{{ vector_config_file }}"
mode: 0644
owner: vector
group: vector
notify: restart vector
- name: Start Vector
service:
state: started
enabled: yes
name: vector
handlers:
- name: restart vector
service:
state: restarted
daemon_reload: yes
name: vector
```
Vector настраивается с помощью конфигурационного файла в формате TOML. Укажем, откуда будет читаться лог-файл, и его тип:
```
# vector.toml
[sources.postgres_logs.multiline]
start_pattern = '^\d{4}-[0-1]\d-[0-3]\d \d+:\d+:\d+\.\d+ [A-Z]{3}'
mode = "halt_before"
condition_pattern = '^\d{4}-[0-1]\d-[0-3]\d \d+:\d+:\d+\.\d+ [A-Z]{3}'
timeout_ms = 1000
```
Мод `halt_before` означает, что Vector будет считать все последующие строки после `condition_pattern`, не начинающиеся с него, одним сообщением.
Существуют и другие варианты `multiline.mode` — например, `half_with`, когда в сообщение включаются все последовательные строки вплоть до первой строки, соответствующей шаблону `condition_pattern`.
Далее парсим сообщение, используя [Vector Transform Language](https://vector.dev/docs/reference/vrl):
```
# vector.toml
[transforms.postgres_remap]
type = "remap"
inputs = [ "postgres_logs" ]
source = """
. |= parse_regex!(.message, r'^(?P\\d{4}-[0-1]\\d-[0-3]\\d \\d+:\\d+:\\d+\\.\\d+ [A-Z]{3}) (?P\\d+) (?P(\\[\\w+\\]@\\w+|@|\\w+@\\w+)) from (?P(\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}|\\[\\w+\\]|\\s\*)) (?P\\[\\w+:.+:\\d+\\]) (?P(\\[\\]|\\[\\w.+\\])) (?P.\*[A-Z]): (?P.\*)$')
del(.timestamp)
message\_parts, err = split(.message, ", ", limit: 2)
structured = parse\_key\_value(message\_parts[1], key\_value\_delimiter: ":", field\_delimiter: ",") ?? {}
message = message\_parts[0]
. = merge(., structured)
del(."please try the setup again")
del(.message)"""
```
Здесь мы сделали следующее:
* указали источник логов;
* задали регулярное выражение, которым будем парсить сообщение лога;
* удалили ненужные поля;
* разбили сообщение по разделителю «**,** »;
* записали результат в массив `map`, обработали его и получили на выходе JSON, с полями которого можно работать дальше.
Теперь отфильтруем сообщения об ошибках:
```
# vector.toml
[transforms.postgres_filter]
type = "filter"
inputs = [ "postgres_remap" ]
condition = '.level == "ERROR" || .level == "FATAL"'
```
Под фильтр попадают сообщения с уровнем, равным `ERROR` или `FATAL`.
Из отфильтрованных сообщений лога создаем метрику. Указываем тип метрики, поле, из которого она будет браться, даем ей понятное имя и навешиваем дополнительные лейблы.
```
# vector.toml
[transforms.postgres_metric]
type = "log_to_metric"
inputs = [ "postgres_filter" ]
[[transforms.postgres_metric.metrics]]
type = "counter"
field = "level"
name = "error_total"
namespace = "pg_log"
[transforms.postgres_metric.metrics.tags]
level = "{{level}}"
host = "{{host}}"
```
На последнем этапе публикуем экспортер, откуда Prometheus будет забирать наши метрики.
```
[sinks.postgres_export_metric]
type = "prometheus_exporter"
inputs = [ "postgres_metric" ]
address = "0.0.0.0:9598"
default_namespace = "pg_log"
```
Настройка алертинга на основании полученных метрик
--------------------------------------------------
Для получения метрик с нового экспортера настраиваем обычный target в Prometheus:
```
scrape_configs:
- job_name: custom-pg-log-exporter
static_configs:
- targets: ['10.10.10.2:9598', '10.10.10.3:9598', '10.10.10.4:9598']
```
Теперь на основе полученной метрики создаем правило, которое Alertmanager будет обрабатывать согласно настройкам своей маршрутизации:
```
- alert: PgErrorCountChangeWarning
expr: |
increase(pg_log_error_total{level="ERROR"}[30m]) > 0
for: 10m
labels:
severity: warning
annotations:
summary: The amount of errors in pg host {{$labels.host}} log has changed to {{$value}}
description: |
Появились ошибки в логах PostgreSQL на сервере {{$labels.host}}.
- alert: PgErrorCountChangeCritical
expr: |
increase(pg_log_error_total{level="FATAL"}[30m]) > 0
for: 10m
labels:
severity: critical
annotations:
summary: The amount of fatal errors in pg host {{$labels.host}} log has changed to {{$value}}
description: |
Появились фатальные ошибки в логах PostgreSQL на сервере {{$labels.host}}.
```
Здесь мы вычисляем прирост временного ряда вектора значений `pg_log_error_total` за 30 минут. Если это значение больше нуля — счетчик изменился, отправляем алерт, после чего его получатель может смотреть в логи PostgreSQL, что же именно там произошло.
Заключение
----------
Мы рассмотрели на примере простого счетчика ошибок, как можно настроить сбор метрик из текстового лога. Если нужные метрики не предоставляются существующими экспортерами и нет возможности менять код приложения, это может быть сравнительно простым выходом из положения.
Кроме удобства конфигурирования на наш выбор повлияли широкие возможности Vector, которые позволяют широко его использовать для различных задач, и его [высокая производительность](https://medium.com/ibm-cloud/log-collectors-performance-benchmarking-8c5218a08fea) для более эффективного использования имеющихся ресурсов. Для отладки пайплайнов лога и просмотра метрик самого Vector можно использовать CLI-утилиту *vector top*, которая выводит информацию в красивом TUI-интерфейсе.
Помимо простого счетчика Vector можно настроить и для парсинга логов медленных запросов базы данных, после чего обработать их с помощью VRL, [агрегировать](https://vector.dev/docs/reference/configuration/transforms/aggregate/), перевести в метрику и выводить, например, топ 10 запросов в Grafana. А для аудита по безопасности — собирать логи подключений, создавая метрики на основании полученных данных. В общем, применений может быть множество, и тут все зависит от существующих потребностей.
Мы также выбрали Vector для своей платформы Deckhouse (модуль [log-shipper](https://deckhouse.io/ru/documentation/v1/modules/460-log-shipper/)), доверив ему доставку логов из Pod’ов Kubernetes-кластеров в одно из хранилищ (Loki, Elasticsearch или Logstash). А по мере необходимости и возможности — даже [участвуем](https://twitter.com/deckhouseio/status/1549293205518430208) в разработке этого проекта.
P.S.
----
Читайте также в нашем блоге:
* [«Логи в Kubernetes (и не только) сегодня: ожидания и реальность»](https://habr.com/ru/company/flant/blog/480946/);
* [«Мониторинг PostgreSQL. Расшифровка аудиочата Data Egret и Okmeter»](https://habr.com/ru/company/flant/blog/568924/);
* [«Мониторинг и Kubernetes»](https://habr.com/company/flant/blog/412901/) *(обзор и видео доклада)*. | https://habr.com/ru/post/678046/ | null | ru | null |
# Тестирование выгрузки 200 000 товаров на сайт из 1С
В одном из проектов перед нами стояла задача выгрузки из 1С на сайт большого количества товаров с периодичностью 2 раза в день. Хотим поделиться опытом, полученным при проведении нагрузочного тестирования проекта.
Мы изучили несколько статей на Хабре:
<http://habrahabr.ru/post/77593/>
<http://habrahabr.ru/company/ontico/blog/95060/>
<http://habrahabr.ru/post/113914/>
Сначала предстояло решить три вопроса:
* Что тестировать?
* Как проводить мониторинг полученных результатов?
* Как тестировать?
Начнем по порядку.
#### Что тестировать?
Наш стенд состоит из трёх основных элементов:
* Сервера 1С (Intel@Core i3-2125, 8 GB RAM)
* модуля PHP для обработки данных, пришедших из платформы 1С на сайт (Back-end REST Service)
* веб-интерфейса сайта
Основной функционал системы заключается в обмене xml-сообщениями между 1С и модулем обработки данных (REST), находящемся на сервере приложений. Модуль обработки получает данные из 1С и записывает их в базу данных. Веб–интерфейс сайта работает с базой данных.
#### Как проводить мониторинг полученных результатов?
В качестве средства мониторинга был выбран [Zabbix](http://zabix.com) — наиболее доступная система, которая отличается простотой в установке и использовании. Zabbix позволил нам не только наблюдать за процессом тестирования в режиме real-time, но и вести статистику, исходя из которой мы можем прогнозировать нагрузку и рассчитать значение показателей [RPO](http://en.wikipedia.org/wiki/Recovery_point_objective) (Recovery Point Objective) и [RTO](http://en.wikipedia.org/wiki/Recovery_time_objective) (Recovery Time Objective), а также доступность системы ([Agreed Service Time](http://www.iemag.ru/analitics/detail.php?ID=18099)).
#### Как тестировать?
Поскольку в системе можно выделить две основные части, постараемся выявить возможные изъяны именно в них. Первая — это взаимодействие шлюза 1С и обработчика XML в вебе. Вторая — это взаимодействие пользователя с базой данных через веб-интерфейс.
Итак, приступим:
1. **Тестирование обмена 1С-Сайт**
Для начала примем во внимание то, что самое “узкое” место обмена можно будет обнаружить при первой выгрузке всех необходимых для работы системы объектов из базы 1С в веб. Так как под рукой не было базы 1С с достаточным количеством объектов, мы написали скрипт для создания расширенного списка номенклатуры и контрагентов в 1С с сохранением всех необходимых связей. В результате работы скрипта в базе появилось 200 тыс. объектов.
Выгружаемые объекты имели структуру следующего вида:
```
<Номенклатура>
<ИД>8729
<ВремяИзменения>2012-12-17T10:46:15 <Ссылка>c9358c28-f33f-11e1-b5e6-00155d002500 <ПометкаУдаления>0
<Артикул/>
<Наименование>Лопата <Родитель>e8a71fc3-55bc-11d9-848a-00112f43529a <ЭтоГруппа>0 <НаименованиеПолное>Лопата
<Комментарий/>
<Каталог>e61d7694-cffa-11e1-99dc-0030678e0763
```
Всего подобных структур около 32.
Итак, настроив обмен и проверив всё ещё раз, начинаем полную выгрузку из 1С в веб и смотрим графики.
**Результаты:** Первоначальная выгрузка товаров продолжалась в около 9 часов. “Узким” местом, при выгрузке из 1С большого количества данных, является производительность шлюза 1С, которая напрямую связана с мощностями сервера и ограничениями платформы. Также выявили проблему обмена, с которой предстоит разобраться в кратчайшие сроки — отсутствие выгрузки с 23:00 до 02:00.
Следующим этапом тестирования будет создание идеального стенда с неограниченными мощностями сервера 1С и «широким» каналом связи. Тестирование показало, что на данном этапе нужно уделить отдельное внимание оптимизации кода 1С и протестировать двусторонний обмен в разных режимах нагрузки. В ближайшем будущем намечено комплексное исследование этого вопроса, по итогам которого будет написана 2-я статья.
2. **Тестирование веб-интерфейса**
Цель данного тестирования — подсчет количества одновременно работающих пользователей, которых может эффективно обслуживать система.
Для начала определимся с понятием “эффективно”. Будем считать, что “эффективность” достигается в случае, когда время загрузки произвольной страницы составляет не более одной секунды.
Время ping до нашего тестового сервера не превышает 55ms.
Для нагрузочного тестирования решили использовать такие системы как Apache Benchmark и Tsung.
**Apache Benchmark**
100 пользователей, 10 из которых одновременно осуществляют запрос, используя поисковую систему сайта.
```
ab -n 100 -c 10 -u putdata.txt -e search.csv Адрес_сайта
```
Putdata.txt – содержит слова, которые вводятся в поисковую форму. Результат записывает search.csv файл.
**Результат:** 98% запросов обработались в пределах 1 секунды.
**Tsung**
1. Создадим сценарий, используя утилиту tsung-record. Tsung-record записывает действия клиента через прокси-сервер — Tsung Proxy. Остаётся прописать адрес прокси-сервера в браузере -127.0.0.1 и порт 8090, который будет слушать запросы.
И в терминале выполним команду *tsung-record–star*
2. Открываем браузер и выполняем обычные действия пользователя:
● Просматриваем категории товаров;
● Осуществляем заказ товаров;
● Пользуемся поиском;
● Добавляем новый товар в заказ;
Завершив работу в браузере, останавливаем tsung-recorder командой stop.
3. В результате был создан файл, содержащий в себе Get запросы:
```
```
4. Создаем сценарий тестирования. Tsung позволяет создать несколько сценариев, а также задать IP-адреса клиентов в том случае, если стоит распределитель нагрузки.
```
xml version="1.0"?
//Раздел servers для схемы с балансировщиком нагрузки, включен сюда, потому что tsung ругается 571- fatal: {failed\_validation,{no\_xml\_element,server}} если не определён.
**//Сессия которая была записана ранее (в предыдущем пункте).**
```
5. Каждую секунду 10 новых пользователей выполняли сценарий:
После выполнения нагрузочного тестирования можно сгенерировать отчет по логам, используя команду tsung-report.
Графики в Zabbix(время с 14:30 – 14:50):
**Результат:** Система стабильно работает с 300-ми пользователями, одновременно работающими с ее интерфейсом. При этом время формирования страницы для каждого пользователя не превышает 1 секунды.
Полученные результаты на данном этапе развития, на наш взгляд, вполне допустимы для систем данного рода. Однако мы выявили ряд важных проблем, требующих решения и ещё раз убедились в необходимости усовершенствования системы. | https://habr.com/ru/post/163285/ | null | ru | null |
# «Прокачиваем» notepad.exe
Какая ассоциация связана у Вас с клавишей F5? Обновление страницы в браузере? Копирование файла из одной директории в другую? Запуск приложения из Visual Studio? А вот авторы notepad.exe подошли к этому вопросу довольно оригинально — по нажатию клавиши F5 происходит добавление текущей даты и времени в место, куда в этот момент указывает курсор. Всё было бы круто, если бы в notepad.exe была такая популярная и вполне естественная для большинства текстовых редакторов фича, как перечитывание содержимого текущего файла, которая, казалось бы, и должна быть назначена на F5 / Ctrl-R или ещё какой-нибудь общепринятый хоткей.
Мы можем ждать, пока её реализуют Microsoft, выбрать другой текстовый редактор (ведь это не единственное ограничение по функционалу стандартного notepad.exe) или… Взять в руки дизассемблер, отладчик и редактор PE-файлов.
Как протекал процесс, и что из этого вышло, читайте под катом (осторожно, **много скриншотов**). Перед прочтением данной статьи также **настоятельно** рекомендую ознакомиться с [предыдущими](http://habrahabr.ru/users/nikitatrophimov/topics/).
Чтобы не иметь дело с теми же неудобствами, с которыми мы столкнулись в [предыдущей статье](http://habrahabr.ru/post/261233/), давайте для начала отключим использование [ASLR](https://en.wikipedia.org/wiki/Address_space_layout_randomization). Согласно вики, ASLR (Address space layout randomization) — это технология, при использовании которой случайным образом изменяется расположение в адресном пространстве процесса важных структур, а именно: образа исполняемого файла, подгружаемых библиотек, кучи и стека. Именно из-за неё в прошлый раз перезапуск приложения и приводил к изменению уже найденных нами ранее адресов. Если Вы используете Windows XP или более старую ОС, то можете с лёгкостью пропустить то, о чём будет рассказано в нескольких следующих абзацах, ведь ASLR на тот момент ещё не было.
Отключить использование ASLR можно как глобально (для этого необходимо добавить / отредактировать значение опции «MoveImages», хранящейся в реестре по адресу «HKEY\_LOCAL\_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management», чтобы сделать её равной нулю), так и локально, т.е. для конкретного исполняемого файла. Последний вариант выглядит более привлекательным, особенно если речь идёт не о виртуальной машине, а о реальной системе, так что давайте остановимся на нём.
Копируем notepad.exe в любую отличную от "%WINDIR%\System32" директорию, скачиваем, разархивируем и запускаем [PE Tools](http://sourceforge.net/projects/pe-tools/), нажимаем Alt-1 и выбираем скопированный ранее notepad.exe:
Нажимаем на кнопку «Optional Header» и смотрим на поле DLL Flags, которое в нашем случае равно 0x8140:
Значение в этом поле является результатом выполнения операции битового «OR» для констант, перечисленных в [официальной документации](https://msdn.microsoft.com/en-us/library/windows/desktop/ms680339(v=vs.85).aspx) на MSDN. Несложно заметить, что наш бинарник обладает следующими характеристиками:
> IMAGE\_DLLCHARACTERISTICS\_TERMINAL\_SERVER\_AWARE
>
> 0x8000
>
> The image is terminal server aware
>
>
>
> IMAGE\_DLLCHARACTERISTICS\_NX\_COMPAT
>
> 0x0100
>
> The image is compatible with data execution prevention (DEP)
>
>
>
> IMAGE\_DLLCHARACTERISTICS\_DYNAMIC\_BASE
>
> 0x0040
>
> The DLL can be relocated at load time
Обратили внимание на последнее значение? Что ж, это именно то, что нас интересует. Меняем 0x8140 на 0x8100, нажимаем «Ok» в обоих окнах и приступаем к отладке.
На какие этапы можно условно разделить наш патчинг notepad.exe?
* Поиск адреса, по которому хранится путь до текущего файла
* Поиск процедуры считывания содержимого файла
* Поиск кода, отвечающего за обработку нажатия клавиши F5
* Собственно, написание самого патча
Открываем notepad.exe в [OllyDbg](http://www.ollydbg.de/) и приступаем к первому этапу.
Подойти к поиску адреса, по которому хранится путь до текущего файла, можно сразу с нескольких сторон. Можно, например, отыскать процедуру, которая занимается открытием файла (вероятнее всего, в случае успеха она сохраняет путь до файла по какому-то адресу), а можно посмотреть на реализацию алгоритма сохранения файла (очевидно, он должен знать либо хэндл текущего файла, либо путь до него). Предлагаю остановиться на втором варианте.
Надеясь, что файл при сохранении каждый раз открывается заново, ставим бряки на вызовы WinAPI-функции [CreateFileW](https://msdn.microsoft.com/en-us/library/windows/desktop/aa363858(v=vs.85).aspx):
Нажимаем Ctrl-S, выбираем имя файла (в моём случае это «C:\helper.txt») и останавливаемся на следующем месте:
Посмотрим, откуда и с какими аргументами нас позвали:
Если посмотреть, на что указывает адрес, переданный в качестве второго аргумента (right-click по строке с данным аргументом -> Follow address in stack), то мы увидим как раз наш путь:
Давайте посмотрим на код, находящийся перед вызовом исследуемой нами процедуры, чтобы понять, откуда и как именно к нам попал этот адрес:
Как Вы видите, адрес, по которому хранится путь до файла, содержится в **EBP-8**. Давайте снова нажмём Ctrl-S и посмотрим, куда мы попадём на этот раз (ведь теперь программа уже знает путь до файла, что может поменять ход работы приложения):
Итак, мы оказались на том же самом бряке, что и раньше, однако позвали нас уже из другого места:
На этот раз адрес, по которому содержится путь до файла, хранится в регистре **EBX**. С момента начала текущего case-блока (обратите внимание на комментарий несколькими инструкциями раньше выделенного места) значение данного регистра не изменяется, что означает, что искать оригинальный адрес надо где-то раньше. Смотрим, какие инструкции ссылаются на начало данного case-блока (left-click по адресу **0x01004D5D** -> Ctrl-R):
Раз такое обращение всего одно, прыгаем на него по нажатию клавиши Enter и сразу же видим, откуда в **EBX** появляется данный адрес:
Итак, мы поняли, что по адресу **0x0100CAE0** хранится путь до текущего файла. Что дальше? А дальше мы должны найти процедуру, ответственную за считывание содержимого файла.
Очевидно, что она также будет вызывать **CreateFileW** (вместо этого мы могли бы перехватить вызов функции [GetOpenFileName](https://msdn.microsoft.com/en-us/library/windows/desktop/ms646927(v=vs.85).aspx), но её нет в списке межмодульных вызовов — видимо, вместо неё используется Common Item Dialog API, которое рекомендуется на MSDN). Нажимаем Ctrl-O, выбираем любой файл (я выбрал тот же самый) и, не успев сделать двойной клик мышью, оказываемся на бряке по адресу **0x01006E8C**:
Проделываем то же самое несколько раз, прежде чем убрать данный бряк и надеяться на остальные. И правда, после того, как был убран бряк по указанному ранее адресу, мы всё же смогли сделать двойной клик по интересующему нас файлу, в результате чего сработала точка останова уже совершенно в другом месте:
Итак, наша задача — выяснить, каким образом и какую именно процедуру необходимо вызвать, чтобы успешно перечитать интересующий нас файл. Ставим бряк на адрес, с которого нас позвали
, нажимаем F9, и… Он тут же срабатывает! Ничего, снова нажимаем F9, пытаемся передать фокус окну notepad.exe и видим, что бряк снова срабатывает. Да что ж такое! Давайте посмотрим на начало процедуры, которую вызывает данный CALL:
Обратите внимание на единственный комментарий — судя по кол-ву обрабатываемых значений и тому, что мы наблюдаем на практике, данная процедура служит для реакции на любое выполняемое пользователем действие, будь то передача окну notepad.exe фокуса или открытие файла. Видимо, после нажатия Ctrl-O программа не выполняет никакого **CALL'а**, а лишь переходит на соответствующий case-блок при помощи операции условного перехода. Давайте уберём данный бряк, ещё раз попытаемся открыть файл и найдём ближайшую к бряку, стоящему на месте вызова **CreateFileW**, инструкцию, к которой есть обращения в коде. Ею оказалась инструкция по адресу **0x01004DF5**:
Ставим бряки на оба обращения, проделываем те же самые действия и оказываемся тут:
Ставим бряк на начало данного case'а, снова открываем тот же самый файл и пытаемся понять, что тут происходит:
```
; Зануляем значение в регистре EDI
01003ECC > \33FF XOR EDI,EDI ; Case 2 of switch 01001824
; Вызываем процедуру проверки изменений в текущем файле
; Если они были, отобразится диалоговое окно с предложением сохранить изменения в файл
01003ECE . 57 PUSH EDI
01003ECF . E8 90D7FFFF CALL notepad.01001664
; Проверяем возвращаемое значение
; EAX == 1, если изменений не было / пользователь нажал клавишу Save / Don't Save, EAX == 0, если была нажата кнопка Cancel
01003ED4 . 85C0 TEST EAX,EAX
; Если нажали Cancel, то дальнейшее нас уже не интересует, переходим в другой case
01003ED6 .^ 0F84 8ED9FFFF JE notepad.0100186A
; Перемещаем нечто с адреса 0x100C00C в EAX и затем в EBP-10
01003EDC . A1 0CC00001 MOV EAX,DWORD PTR DS:[100C00C]
01003EE1 . 8945 F0 MOV DWORD PTR SS:[EBP-10],EAX
; Вызываем процедуру отображения диалогового окна с просьбой выбрать файл
01003EE4 . 8D45 F8 LEA EAX,DWORD PTR SS:[EBP-8]
01003EE7 . 50 PUSH EAX ; /Arg2
01003EE8 . FF75 F4 PUSH DWORD PTR SS:[EBP-C] ; |Arg1
01003EEB . E8 31000000 CALL notepad.01003F21 ; \notepad.01003F21
; В результате вызова данной процедуры в EBP-8 будет храниться путь до открываемого файла
; EAX == 0 в случае успеха и 0x800704C7 в случае нажаия кнопки Cancel
01003EF0 . 8BF0 MOV ESI,EAX
01003EF2 . 3BF7 CMP ESI,EDI
; Один из прыжков на интересующую нас процедуру
01003EF4 . 0F8D FB0E0000 JGE notepad.01004DF5
01003EFA . 81FE C7040780 CMP ESI,800704C7
01003F00 . 0F85 DC0E0000 JNZ notepad.01004DE2
01003F06 > 3BF7 CMP ESI,EDI
01003F08 . 0F8D E70E0000 JGE notepad.01004DF5
01003F0E > 8B45 F0 MOV EAX,DWORD PTR SS:[EBP-10]
01003F11 . A3 0CC00001 MOV DWORD PTR DS:[100C00C],EAX
01003F16 . 56 PUSH ESI
01003F17 .^ E9 A2FCFFFF JMP notepad.01003BBE
```
Теперь давайте посмотрим, какие регистры и адреса использует код по адресу **0x01004DF5**, чтобы понять, какое «окружение» необходимо для его корректной работы:
Разумеется, данный код обращается к **EBP-8**, по которому, как Вы помните, хранится путь до открываемого файла. Помимо этого, ему также важно значение регистра **EDI**, который используется в качестве аргументов для параметров **hTemplateFile** и **pSecurity**. Первое мы можем достать из адреса **0x0100CAE0**, а в обозначенные параметры можно просто передать ноль.
Теперь давайте найдём код, отвечающий за обработку нажатия клавиши F5. Для этого предлагаю поставить бряк на вызовы функций, отвечающих за получение текущего времени. Наиболее популярные из них — [GetSystemTime](https://msdn.microsoft.com/en-us/library/windows/desktop/ms724390(v=vs.85).aspx) и [GetLocalTime](https://msdn.microsoft.com/en-us/library/windows/desktop/ms724338(v=vs.85).aspx). Первой нет в списке межмодульных вызовов, а вот вторая вызывается сразу из двух мест:
Ставим бряки, нажимаем F5 и оказываемся тут:
Прыгаем на место вызова текущей процедуры и попадаем практически в самое начало ещё одного case-блока, который, очевидно, и отвечает за обработку нажатия F5:
Отлично. Ищем место для нашего code cave'а и пишем (разумеется, адреса могут отличаться):
```
0100BEB3 33FF XOR EDI,EDI
0100BEB5 C745 F8 E0CA0>MOV DWORD PTR SS:[EBP-8],notepad.0100CAE0 ; UNICODE "C:\helper.txt"
0100BEBC A1 0CC00001 MOV EAX,DWORD PTR DS:[100C00C]
0100BEC1 8945 F0 MOV DWORD PTR SS:[EBP-10],EAX
0100BEC4 ^ E9 2C8FFFFF JMP notepad.01004DF5
```
Вставляем по адресу **0x0100447B** прыжок на наш code cave:
Нажимаем F9, снова жмём F5 и наблюдаем следующую картину:
Как видите, мы упали где-то в недрах функции [CoTaskMemFree](https://msdn.microsoft.com/en-us/library/windows/desktop/ms680722(v=vs.85).aspx). Обратите внимание на аргумент, переданный этой функции — да-да, это адрес нашей строки с путём до файла. Значит, память под неё необходимо выделять при помощи [CoTaskMemAlloc](https://msdn.microsoft.com/en-us/library/windows/desktop/ms692727(v=vs.85).aspx). В этом нам может помочь функция [SHStrDup](https://msdn.microsoft.com/en-us/library/windows/desktop/bb759924(v=vs.85).aspx), которая создаёт дупликат переданной ей строки, выделив память под неё при помощи **CoTaskMemAlloc**.
Перезапускаем notepad.exe и ищем адрес функции **SHStrDupW** в IAT. Для этого смотрим на вызов любой другой WinAPI-функции в модуле:
Следовательно, адрес функции [GetDlgItemTextW](https://msdn.microsoft.com/en-us/library/windows/desktop/ms645489(v=vs.85).aspx) в IAT — **0x010012A4**. Прыгаем на него и ищем нашу **SHStrDupW**:
Получается, её вызов можно оформить в виде инструкции **CALL DWORD PTR DS:[010013B4]**. Тогда пишем следующий код (проверка на наличие ошибок опущена):
```
0100BFA5 . 33FF XOR EDI,EDI
0100BFA7 . 8D45 F8 LEA EAX,DWORD PTR SS:[EBP-8]
0100BFAA . 50 PUSH EAX ; /pTarget
0100BFAB . 68 E0CA0001 PUSH notepad.0100CAE0 ; |Source = "C:\helper.txt"
0100BFB0 . FF15 B4130001 CALL DWORD PTR DS:[<&SHLWAPI.SHStrDupW>] ; \SHStrDupW
0100BFB6 . A1 0CC00001 MOV EAX,DWORD PTR DS:[100C00C]
0100BFBB . 8945 F0 MOV DWORD PTR SS:[EBP-10],EAX
0100BFBE .^ E9 328EFFFF JMP notepad.01004DF5
```
Открываем наш файл «C:\helper.txt», убеждаемся, что он пустой, редактируем и сохраняем его в другой копии notepad.exe, нажимаем F5 в отлаживаемой нами версии, и… Файл обновляется!
Давайте сохраним наши изменения в исполняемый файл. Делаем right-click по окну CPU -> Copy to executable -> All modifications -> Copy all и видим:
Получается, что мы вылезли за физические границы исполняемого файла. Давайте взглянем на границы секций в PE Tools (кнопка «Sections»)
и поместим наш code cave в какое-нибудь другое место. Для получения верхней «границы» области для «безболезненного» патча мы должны сложить Virtual Offset секции .text, куда мы собираемся положить наш патч, её Raw Size и Image Base, т.е. Virtual Offset (**0x00001000**) + Raw Size (**0x0000A800**) + Image Base (**0x01000000**) = **0x0100B800**. Поместим его, например, по адресу **0x0100B6CF** и попытаемся сохранить изменения ещё раз (right-click по окну CPU -> Copy to executable -> All modifications -> Copy all -> right-click на появившемся окне -> Save file).
Проверяем получившийся исполняемый файл на работоспособность и убеждаемся, что всё ведёт себя так, как и ожидается.
### Послесловие
Цель данной статьи — в очередной раз продемонстрировать возможность добавления собственного функционала в существующие программы, не имея при этом на руках исходных кодов. А теперь возвращайтесь к своим vim'ам / emacs'ам / Notepad++ / etc, но помните — если Вы встретите баг или обратите внимание на отсутствие какого-либо функционала в редакторе с закрытым кодом, теперь Вы знаете, что надо делать.
Спасибо за внимание, и снова надеюсь, что статья оказалась кому-нибудь полезной. | https://habr.com/ru/post/261507/ | null | ru | null |
# Адаптивная навигация: куда деть меню на смартфонах
Адаптировать свой сайт под мобильные устройства уже пытаются очень многие. Используют новые возможности CSS3 и на простых сайтах и на куда более сложных. В процессе возникают некоторые сложности, причем одной из важнейших является поведение меню сайта при просмотре на маленьких экранах. Решают данную проблему, как выяснилось, несколькими способами. Для меня же данная задача недавно стала особенно актуальной, поэтому я слежу за материалами в сети, касающимися адаптивного дизайна. И недавно я наткнулся на хороший анализ существующих паттернов адаптивной навигации.
Так как я имею отношение к опен-сорсному адаптивному HTML5-шаблону Simpliste, то решил *все существующие возможности работы с навигацией* испробовать на практике. Но кроме получения собственного опыта, мне удалось создать несколько наглядных примеров, доступных для использования любым желающим, а также подготовить описание процесса, с которым приглашаю вас ознакомиться.
Сама статья, заинтересовавшая меня и подтолкнувшая к действию, называется [Responsive Navigation Patterns](http://bradfrostweb.com/blog/web/responsive-nav-patterns/). На нее я и буду опираться, а в качестве примеров будут выступать страницы шаблона Simpliste с реализацией паттернов и полным описанием того, как добиться такого же результата.
Существует несколько подходов к адаптивной навигации. Рассмотрим их по порядку.
1. Навигация вверху или оставляем все как есть
----------------------------------------------
Самый очевидный и самый распространенный способ. Нужно только позаботиться о том, чтобы все вместилось в ширину экрана и не выпирало. В структуре HTML не меняется ничего, но ссылки меню могут получить немного измененные стили, возможны разного рода вариации с внешним видом ссылок, которые могут упрощаться, центрироваться, заменяться иконками или подрожать внешнему виду интерфейсов мобильных устройств.
Такой подход используется в темах оформления Simpliste.
##### Преимущества
Достигается проще всего. Не нужно использовать Javascript (и нет зависимости от него), не нужно невероятных маневров с CSS.
##### Недостатки
Проблема может начаться тогда, когда количество пунктов меню слишком велико. Во-первых, высота блока навигации может стать такой, что он полностью перекроет содержимое сайта на первой странице и пользователю придется «листать» сайт вниз, чтобы добраться до нужной ему информации. И так на каждой странице сайта. Во-вторых, возникает вопрос многоуровневых меню. Если их просто выстроить одно под другим, то возвращаемся к проблеме высоты блока навигации. В-третьих, если все заранее не предусмотреть, то добавление новых пунктов меню может вызвать неприятное «съезжание» и переносы.
##### Примеры
[](http://oliverrussell.com) [](http://brasseriecayman.com)
2. Ссылка на футер, к навигации
-------------------------------
[Демо](http://cssr.ru/simpliste/_xtensions/snippets/responsive_navigation/footer_anchor.html) с полным описанием.
Этот метод не так распространен. Суть его в том, что в шапке создается ссылка, которая на широких мониторах скрывается, а отображается при необходимости на мобильных устройствах. Эта ссылка-якорь ведет к меню, которое находится в футере сайта. При этом само меню либо позиционируется с помощью CSS, либо дублируется в шапке и футере, тогда меню в шапке скрывается на малых разрешениях. В качестве ссылки можно использовать как текст, так и какую-нибудь понятную иконку.
##### Достоинства
Остается единственная ссылка в шапке, которая занимает очень мало места. Нет зависимости от скриптов.
##### Недостатки
Придется дописывать дополнительный CSS код, чтобы либо перемещать меню из футера вверх на настольных компьютерах (с помощью position:absolute или position:fixed), либо прятать меню в шапке на мобильных устройствах, если оно дублирует меню футера. Кроме того, ощущение от резкого «прыжка» при перемещении по такой ссылке может застать пользователя врасплох.
##### Пример
[](http://contentsmagazine.com)
3. Выпадающий список () вместо навигации
----------------------------------------
[Демо](http://cssr.ru/simpliste/_xtensions/snippets/responsive_navigation/select_menu.html) с полным описанием.
Такой подход распространяется все больше. Здесь используется Javascript, который «пробегается» по всем пунктам меню, создавая из них список . То есть навигацией станет интерфейсный элемент, поддерживаемый операционной системой посетителя.
Процесс написания скрипта для такого меню был подробно описан в [статье на Smashing Magazine](http://coding.smashingmagazine.com/2012/02/13/progressive-and-responsive-navigation/). Но можно воспользоваться готовым [плагином jQuery](https://github.com/mattkersley/Responsive-Menu), как я и сделал в собственном решении.
##### Достоинства
Выгладит компактно. Узнаваемо как элемент навигации и привычно пользователю. Для сайтов со сложной навигацией и вложенными меню может стать отличным решением.
##### Недостатки
Сложно будет заставить элемент интерфейса мобильной ОС выглядеть так, как хочется вам. На разных устройствах внешний вид и поведение будут несколько отличаться. Зависимость от Javascript. Неудобство при навигации действительно больших размеров, когда все пункты выстраиваются в длинный однообразный ряд, хотя вложенность уровней сохраняется.
##### Примеры
[](http://performancemarketingawards.co.uk) [](http://expositio.de)
4. Раскрывающееся меню
----------------------
[Демо](http://cssr.ru/simpliste/_xtensions/snippets/responsive_navigation/toggle_menu.html) с полным описанием.
Этот подход тоже достаточно популярен. Особенно учитывая возможность экспериментировать с дизайном. Суть его в том, что в мобильной версии меню прячется, но остается ссылка или кнопка, нажав на которую можно раскрыть навигацию. Работает все с помощью Javascript. Можно сравнить подход со ссылкой на футер, но в данном случае меню возникает там же, где пользователь нажал на кнопку, то есть вверху страницы. Как вариант, пару самых главных ссылок можно оставить, а при нажатии на кнопку раскрывать остальные.
Существует [готовое решение](http://jasonweaver.name/lab/flexiblenavigation/), работающее с jQuery. Но мне оно показалось сложным для персонализации. Поэтому был написан свой код для jQuery, который не настолько сложен и при желании его *можно легко переделать* либо в чистый Javascript, либо в какой-то более приспособленный для мобильных устройств код. Но тесты на [эмуляторах](http://www.browserstack.com/) показали, что мое решение вполне рабочее.
```
var menuText = "Menu";
$(
function(){
$("body").addClass("js");
$(".menu_main").prepend("["+ menuText +"](#)");
$(".menu_main li:has(ul)").addClass("menu_parent");
$(".link_nav").click(
function(){
$(".menu_main > ul").toggleClass("menu_expanded");
$(this).toggleClass("menu_parent_exp");
return false;
}
)
$(".menu_parent").click(
function(){
$(this).find(">ul").toggleClass("menu_expanded");
$(this).toggleClass("menu_parent_exp");
return false;
}
)
}
)
```
Скриптом создается ссылка, которая будет раскрывать предварительно скрытое меню. Посмотреть в деле и взять необходимые стили можно в [демо](http://cssr.ru/simpliste/_xtensions/snippets/responsive_navigation/toggle_menu.html).
##### Достоинства
Выглядеть может так, как пожелаете. Пользователя никуда не перебрасывает. Для вложенных меню есть возможность создавать иерархии с раскрытием при нажатии.
##### Недостатки
Зависимость от Javascript. Возможные проблемы с производительностью, если потребуется анимировать меню.
##### Примеры
[](http://it.eku.edu) [](http://neovada.com) [](http://thunderboltgames.com) [](http://webdagene.no)
5. Выезжающее меню со сдвигом контента
--------------------------------------
[Демо](http://cssr.ru/simpliste/_xtensions/snippets/responsive_navigation/side_flyout.html) с полным описанием.
Данный вариант был описан как отдельный подход. Но на самом деле это скорее вариация раскрывающегося меню. Суть его в том, что при клике на ссылку или кнопку меню не просто раскрывается, но выезжает с края окна браузера, сдвигая при этом контент за предел окна.
Готового решения найти не получилось, поэтому было создано свое.
```
$(
function(){
$("body").addClass("js");
$(".link_nav").click(
function(){
$("body").toggleClass("mobile_nav");
}
);
}
)
```
На самом деле, не много скриптов.
Основную работу выполняет CSS. При изменении класса тега body *меняется положение меню*, которое спозиционировано через position:fixed, а контент приобретает *дополнительный отступ слева*, уступая место меню. В браузерах Webkit удалось даже добиться анимации через CSS transitions, то есть в айфонах и андроидах меню будет эффектно выезжать. Опять же, посмотреть и взять необходимые стили можно в [демо](http://cssr.ru/simpliste/_xtensions/snippets/responsive_navigation/side_flyout.html).
Есть недостаток, который нужно описать отдельно. Когда в меню слишком много пунктов, то меню с position:fixed будет «съедаться» нижним краем. В таком случае помогает использование position:absolute, но происходит «прыжок» к началу сайта после клика на кнопку-ссылку.
##### Достоинства
Интересное решение, возможность экспериментировать с внешним видом. Контекст не теряется, так как контент, хоть и прикрыт краем окна, но все же виден.
##### Недостатки
Зависимость от Javascript, необходимость настраивать CSS. position:fixed поддерживается не во всех старых версиях мобильных устройств (там будет position:absolute), описанная выше проблема с высотой меню.
##### Пример
[](http://barackobama.com)
6. Вариации
-----------
Существуют различные вариации, как в подходе к навигации, так и в ее оформлении и в функционале.
Можно просто ставить меню в футере, без ссылок на него. Можно прятать меню вообще (что не рекомендуется). Можно экспериментировать с раскрывающимся меню, например давая пользователям возможность [вытянуть его](http://inspectelement.com/tutorials/pull-down-for-navigation-a-responsive-solution/). Никто не мешает совместить выезжающую с краю навигацию с раскрытием пунктов вложенных меню.
> Все приведенные демо являются частью расширений *xtensions* для HTML5-шаблона [Simpliste](http://simpliste.ru), который можно [бесплатно скачать](https://github.com/rafikov/Simpliste/zipball/master) и использовать в собственных проектах.
>
> | https://habr.com/ru/post/140801/ | null | ru | null |
# Расширения Firefox — Работа с настройками
Сегодня я хотел бы рассказать о том, как можно реализовать систему настроек для своего расширения. Начиная с определения опций и заканчивая добавлением в ваше расширение возможности менять настройки с помощью созданных вами диалоговых окон.
Первую статью, надеюсь из будущего цикла моих статей, можно найти [здесь](http://habrahabr.ru/blogs/firefox/71839/).
Система настроек расширений в Firefox имеет очень простую структуру. Наберите в адресной строке about:config, и вы увидите все настройки не только самого браузера, но и всех установленных расширений. Тут же их можно изменить под свои нужды.
Чтобы ваше расширение имело собственный набор настроек, нужно создать каталог `defaults/preferences` (если он ранее не был создан) и поместить туда .js-файл с настройками. Вот пример такого файла.
> `1. pref("extensions.sample.username", "Joe");
> 2. pref("extensions.sample.sort", 2);
> 3. pref("extensions.sample.showAdvanced", true);
> \* This source code was highlighted with Source Code Highlighter.`
Таким образом, мы создали набор настроек по-умолчанию. Перезапустите Firefox. Теперь просмотреть, а также изменить значения этих параметров можно на странице `about:config`.
Чтение настроек
---------------
Следующий отрывок кода показывает, как получить доступ к настройкам:
> `1. init : function()
> 2. {
> 3. this.prefs = Components.classes["@mozilla.org/preferences-service;1"]
> 4. .getService(Components.interfaces.nsIPrefService)
> 5. .getBranch("extensions.sample.");
> 6. this.prefs.QueryInterface(Components.interfaces.nsIPrefBranch2);
> 7. this.prefs.addObserver("", this, false);
> 8. }
> \* This source code was highlighted with Source Code Highlighter.`
Последняя строка функции `init` указывает, что все события, связанные с изменением настроек, должны посылаться нашему объекту.
Итак, теперь переменная `this.prefs` ссылается на объект с интерфейсом [nsIPrefBranch](https://developer.mozilla.org/en/NsIPrefBranch). Прочитать значения какой либо опции можно следующим образом:
> `1. this.prefs.getCharPref("username");
> \* This source code was highlighted with Source Code Highlighter.`
Т.к. при инициализации объекта настроек мы указали в качестве пространства имен `extensions.sample.`, то будет прочитана опция `extensions.sample.username`, которую мы создали ранее.
Дополнительно о методах предоставляемых интерфейсом `nsIPrefBranch` можно прочитать [тут](https://developer.mozilla.org/en/NsIPrefBranch).
Изменение настроек
------------------
Для изменения настроек вашего расширения есть возможность создать диалоговое окно, в котором можно будет отобразить нужные вам опции, и пользователь сможет менять их значения на нужные ему.
Создайте файл `options.xul` в каталоге `chrome/content` и добавьте в него следующее содержимое:
> `1. </fontxml version="1.0"?>
> 2. </fontxml-stylesheet href="chrome://global/skin/" type="text/css"?>
> 3. <prefwindow id="test-prefs"
> 4. title="Test options"
> 5. xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
> 6. <prefpane id="test-pane" label="Test Settings">
> 7. <preferences>
> 8. <preference id="pref\_username" name="extensions.sample.username" type="string"/>
> 9. preferences>
> 10. <hbox align="center">
> 11. <label control="username" value="Username: "/>
> 12. <textbox preference="pref\_username" id="username" maxlength="24"/>
> 13. hbox>
> 14. prefpane>
> 15. prefwindow>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь по порядку:
* — является контейнером для элементов управления диалогового окна, также этот элемент содержит ссылки на настройки компонента
* — содержит ссылки на опции вашего компонента
* — ссылка на опцию. В параметре `name` указывается имя опции, в параметре `type` тип этой опции (`string`, `int` или `boolean`), параметр `id` задает идентификатор настройки внутри диалогового окна, по которому уже элементы управления будут сами считывать и записывать значения настроек (посмотрите на атрибут `preference` элемента `textbox`)
* Далее следуют элементы управления диалогового окна, с помощью которых можно изменить опции вашего расширения
Если вы создали этот файл для уже установленного расширения, то необходимо это расширение удалить и установить заново, чтобы кнопка «Настройка» стала доступной.
И последнее, о чем я хотел рассказать — это реакция расширения на какие-либо изменения его настроек. В самом начале мы указали, что хотим обрабатывать все сообщения, связанные с изменением настроек. Вот пример функции, которая может с этим справиться:
> `1. observe: function(subject, topic, data)
> 2. {
> 3. if (topic != "nsPref:changed")
> 4. {
> 5. return;
> 6. }
> 7.
> 8. switch(data)
> 9. {
> 10. case "username":
> 11. alert(this.getUserName());
> 12. break;
> 13. }
> 14. }
> \* This source code was highlighted with Source Code Highlighter.`
Коротко о входных параметрах:
1. `subject` — ссылка на измененный объект или событие (подробней [тут](https://developer.mozilla.org/en/nsIObserver))
2. `topic` — указывает на тип события, нас в данном случае интересует «nsPref:changed»
3. `data` — это данные, передаваемые вместе с событием, в нашем случае это будет имя опции, которую изменили
Это необходимый минимум для работы с настройками расширений, более подробно можно об этом узнать по предоставленным мною ссылкам или на сайте [developer.mozilla.org](https://developer.mozilla.org/).
Исходники примера можно взять [здесь](http://daemon.deagnostic.ru/exts/first.zip). | https://habr.com/ru/post/72117/ | null | ru | null |
# Пасхальные яйца и Open Source
> «Пасхальное яйцо» (англ. Easter Egg) — секрет в компьютерной игре, фильме или программном обеспечении, заложенный создателями. Отличие пасхального яйца в игре от обычного игрового секрета состоит в том, что его содержание, как правило, не вписывается в общую концепцию, выглядит в контексте неправдоподобно, нелепо, и зачастую является внешней ссылкой. Пасхальные яйца играют роль своеобразных шуток для внимательных игроков или зрителей. ([wiki](https://ru.wikipedia.org/wiki/%D0%9F%D0%B0%D1%81%D1%85%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D1%8F%D0%B9%D1%86%D0%BE_(%D0%B2%D0%B8%D1%80%D1%82%D1%83%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5)))
Пасхальные яйца бывают разные. Например широко известна команда `apt-get moo`, которая рисует корову в консоли:
```
(__)
(oo)
/------\/
/ | ||
* /\---/\
~~ ~~
...."Have you mooed today?"...
```
Пожалуй все согласятся с тем, что `apt-get moo` не является деструктивной функцией. Эта пасхалка может показаться смешной, или же нет, а то и вовсе неуместной, но она наверняка вам ничего не сломает. Также можно посмотреть [некоторые другие пасхалки в linux](https://www.digitalocean.com/community/tutorials/top-10-linux-easter-eggs).
В этой статье я бы хотел остановиться на одной конкретной пасхалке. А конкретно о "christmas" в [ant-design](https://github.com/ant-design/ant-design/issues/13849). Это неплохая UI библиотека контролов для React-экосистемы. Про неё можно было бы написать отдельную статью, но сейчас не об этом.
Открыв сегодня проект с применением этой библиотеки я увидел нечто странное:
У всех кнопок атрибут title превратился в "хо-хо-хо", а ключевые кнопки получили снежную шапку. Достигнуто это было за счёт [этого коммита](https://github.com/ant-design/ant-design/commit/00aebeb9756afecc884ad48486084836b9a2707a) с применением класса "christmas" и кастомным стилем на этот счёт.
```
const isChristmas = now.getMonth() === 11 && now.getDate() === 25;
const classes = classNames(prefixCls, className, {
// ...
christmas: isChristmas,
});
// ...
const title= isChristmas ? 'Ho Ho Ho!' : rest.title;
```
Поначалу я засмеялся. Полез в код. Посмеялся ещё раз. Посмотрел на дату. А потом вспомнил про production. Хм, да-да. Рождественское настроение доехало и туда.
Полез гуглить, как же так. Может быть мне стоило прописать какой-нибудь ключ аля env? Наткнулся [на этот issue](https://github.com/ant-design/ant-design/issues/13849), с извинениями от автора:
> About the christmas egg in antd, it is derived from my commit 00aebeb at Sep 10th. This implementation will make primary button snowy with native tooltip Ho Ho Ho! at the specificed day of Dec 25th. It is a complete stupid decision of my own and very sorry to everyone that get involved.
>
>
>
> Are there other eggs in antd's code. No.
>
>
>
> Are there same events would happen in future? No, I promise. We are open source project, please supervise us like this time, like always.
После обновления проблема ушла. Автор проблему признаёт и раскаивается. Свой поступок называет "stupid decision".
Отмечу, что библиотека имеет 38 тысяч звёзд и 13 тысяч форков. И она правда неплоха.
Собственно в комментариях хочу поднять вопрос: а что вы думаете о пасхальных яйцах в публичных проектах? Допустимы ли они? Какими они могут быть? Скажем тащить 2 MiB шуточную-картинку с мемом ― однозначно перебор. А нарисовать ASCII корову? Где проходит та самая грань? Уместен ли юмор в open source? | https://habr.com/ru/post/434288/ | null | ru | null |
# Детектирование округлостей на изображении средствами MATLAB
В этом топике я приведу альтернативный подход к задаче, решенной товарищем [VasG](https://habrahabr.ru/users/vasg/) [тут](http://habrahabr.ru/blogs/algorithm/114249/). Как заметили в комментариях, задачу обнаружения округлостей на изображении можно было решить при помощи MATLAB Image Processing Toolbox, что я и сделал. MATLAB радует меня очень сильной документацией с большим количеством наглядных примеров; а также удобством m-языка, за счет которого сильно сокращается время реализации вычислительных решений. Конечно, есть и минусы — в частности алгоритмы работают медленно, — но для данной задачи это не существенно. Отмечу только, что из m-языка довольно просто можно получить C-код, который будет работать гораздо быстрее.
Я старался писать с нуля, исходя из формулировки задачи и не пользуясь алгоритмическими наработками [VasG](https://habrahabr.ru/users/vasg/). Естественно, в силу простоты задачи решения очень похожи. В хелпе MATLAB'а по Image Processing Toolbox обнаружился набор демок, посвященных детектированию объектов и в частности поиску круглых форм, что мне очень помогло. Далее приводится код полученного алгоритма на m-языке:
`img = imread('kkk.jpg');
grayimg = rgb2gray(img);
grayimg = imadjust(grayimg);
bw = edge(grayimg,'canny', 0.15, 2);
bw = imfill(bw,'holes');
se = strel('disk',1);
bw = imopen(bw,se);
[B,L] = bwboundaries(bw);
stats = regionprops(L,'Centroid','EquivDiameter');
figure, imshow(img)
hold on
for k = 1:length(B)
boundary = B{k};
radius = stats(k).EquivDiameter/2;
xc = stats(k).Centroid(1);
yc = stats(k).Centroid(2);
theta = 0:0.01:2*pi;
Xfit = radius*cos(theta) + xc;
Yfit = radius*sin(theta) + yc;
plot(Xfit, Yfit, 'g');
text(boundary(1,2)-15,boundary(1,1)+15, num2str(radius,3),'Color','y',...
'FontSize',8);
end`
Заметьте, в нем всего 30 строчек. Из них половина реализует красивый вывод результата. Давайте разберем код.
**img = imread('kkk.jpg');** — открываем наше изображение. Я использовал изображение из статьи [VasG](https://habrahabr.ru/users/vasg/).
**grayimg = rgb2gray(img);** — переводим изображение в оттенки серого.
**grayimg = imadjust(grayimg);** — контрастируем.
**bw = edge(grayimg,'canny', 0.15, 2);** — выделяем границы методом Канни. Функция **edge** предлагает возможность использования алгоритмов Собеля, Робертса, Прюитта и некоторых других, но я, как и [VasG](https://habrahabr.ru/users/vasg/), остановил свой выбор на Канни, потому что он, как мне кажется, работает лучше всего. Параметры подбирались эмпирически, чтобы выделялись границы всех объектов на изображении.
**bw = imfill(bw,'holes');** — заливаем замкнутые области на изображении.
Далее необходимо избавиться от тонких линий.
**se = strel('disk',1);** — формируем структурный элемент, крест 3 на 3.
**bw = imopen(bw,se);** — морфологическое открытие, тонкие линии исчезают.
**[B,L] = bwboundaries(bw);** — данная функция выдает два результата. **B** — ячеечный массив размера P х 1, где P — кол-во объектов на изображении. Элементы массива B — матрицы размером Q х 2, где Q — количество пикселей, принадлежащих границе соответствующего объекта. Строки матрицы Q — координаты этих граничных пикселей. **L** — матрица, размер которой равен размеру изображения, содержащая неотрицательные числа, которые соответствуют замкнутым областям. Регион с номером k на матрице L обозначается элементами со значением k. Фону соответствует 0.
**stats = regionprops(L,'Centroid','EquivDiameter');** — эта функция создает массив структур **stats**, поля элеметнов которого **Centroid** и **EquivDiameter** содержат соответственно координаты центра области и (в нашем случае) диаметр области.
Собственно задача решена. Дальше реализуется вывод результатов.
Результаты аналогичны тем, что были получены [VasG](https://habrahabr.ru/users/vasg/) с точностью до коэффициентов некоторых функций. Времени на реализацию было потрачено примерно столько же, сколько на оформление данной статьи, примерно около часа. [VasG](https://habrahabr.ru/users/vasg/), насколько понятно по статье, потратил на порядок больше времени. У меня довольно большой опыт работы с MATLAB, но я считаю, даже если человек не знаком с m-языком, за рабочий день можно разобраться в системе и написать подобную реализацию. Таким образом налицо высокая скорость реализации решений прикладных задач в системе MATLAB. Советую [VasG](https://habrahabr.ru/users/vasg/), а также другим научным сотрудникам и инженерам оценить для себя систему MATLAB в действии!
**upd.** Заменил пару imerode+imdilate на imopen. Спасибо [ScayTrase](https://habrahabr.ru/users/scaytrase/). | https://habr.com/ru/post/114335/ | null | ru | null |
# Новая уязвимость Wordpress — возможна DOS атака
Свежая уязвимость в Wordpress которая позволяет провести DOS атаку на блог жертвы используя файл wp-trackback.php
Для исправления этой уязвимости необходимо добавить следующий код в файл functions.php, который находится в папке шаблона блога:
`function ft_stop_trackback_dos_attacks(){
global $pagenow;
if ( 'wp-trackback.php' == $pagenow ){
// DoS attack fix.
if ( isset($_POST['charset']) ){
$charset = $_POST['charset'];
if ( strlen($charset) > 50 ) { die; }
}
}
}
add_action('init','ft_stop_trackback_dos_attacks');`
Если у вас нет возможности или знаний, для того, чтобы прописать данный код в вашем блоге, скачайте и установите [плагин](http://fullthrottledevelopment.com/wp-content/uploads/2009/10/ft-stop-trackback-dos-attacks.php1.zip) который исправляет эту уязвимость.
Эксплоит уязвимости: [jarraltech.com/2009/10/new-0-day-wordpress-exploit](http://jarraltech.com/2009/10/new-0-day-wordpress-exploit/)
Источник: [blogproblog.com/wp-trackback\_dos\_attack](http://blogproblog.com/wp-trackback_dos_attack/) | https://habr.com/ru/post/72911/ | null | ru | null |
# Руководство по SEO JavaScript-сайтов. Часть 2. Проблемы, эксперименты и рекомендации
В [первой части](https://habrahabr.ru/company/ruvds/blog/350976/) перевода этой статьи мы говорили о том, как веб-мастер может взглянуть на свой ресурс глазами Google, и о том, над чем стоит поработать, если то, что увидит разработчик сайта, окажется не тем, чего он ждёт.
[](https://habrahabr.ru/company/ruvds/blog/351058/)
Сегодня, во второй части перевода, Томаш Рудски расскажет о наиболее распространённых SEO-ошибках, которым подвержены сайты, основанные на JavaScript, обсудит последствия грядущего отказа Google от механизма AJAX-сканирования, поговорит о предварительном рендеринге и об изоморфном JavaScript, поделится результатами экспериментов по индексированию. Здесь, кроме того, он затронет тему особенностей ранжирования сайтов различных видов и предложит вспомнить о том, что помимо Google есть и другие поисковики, которым тоже приходится сталкиваться с веб-страницами, основанными на JS.
О ресурсах, необходимых для успешного формирования страницы
-----------------------------------------------------------
Если, по вашему мнению, Googlebot вполне сможет обработать некую страницу, но при этом оказывается, что данная страница не индексируется так, как нужно, проверьте, чтобы внешние и внутренние ресурсы (JS-библиотеки, например), требуемые для формирования страницы, были доступны поисковому роботу. Если он не сможет что-то загрузить и правильно воссоздать страницу, об её индексировании можно и не говорить.
О периодическом использовании Google Search Console
---------------------------------------------------
Если вы вдруг столкнулись со значительным падением рейтинга сайта, который до этого работал стабильно и надёжно, рекомендую воспользоваться описанными ранее средствами Fetch и Render для того, чтобы проверить, в состоянии ли Google правильно обработать ваш сайт.
В общем случае, полезно время от времени использовать Fetch и Render на произвольном наборе страниц сайта для того, чтобы проверить возможность его правильной обработки поисковиком.
*Список ресурсов, заблокированных с помощью Robots.txt*
Опасное событие onClick
-----------------------
Помните о том, что Googlebot — это не настоящий пользователь, поэтому примите как должное то, что он не «щёлкает мышью» по ссылкам и кнопкам и не заполняет формы. У этого факта есть немало практических последствий:
* Если у вас имеется интернет-магазин и некие тексты скрыты под кнопками вроде «Подробнее…», но при этом они не присутствуют в DOM до щелчка по соответствующей кнопке, Google эти тексты не прочтёт. Это же имеет отношение и к ссылкам, появляющимся по такому же принципу в меню.
* Все ссылки должны содержать параметр `href`. Если вы полагаетесь только на событие `onClick`, Google такие ссылки не воспримет.
Это [подтверждает](https://groups.google.com/forum/#!forum/js-sites-wg) и Джон Мюллер:
*Комментарий Джона Мюллера, подтверждающий вышесказанное*
В одном из моих предыдущих [материалов](https://www.elephate.com/blog/chrome-41-key-to-website-rendering/), который посвящён использованию Chrome 41 для исследования сайтов, имеется краткое руководство, демонстрирующее процесс проверки меню на предмет доступности его для системы индексирования Google. Советую с этим материалом ознакомиться.
Использование значков # в ссылках
---------------------------------
Всё ещё распространена практика, в соответствии с которой JS-фреймворки создают URL-адреса со знаком `#`. Существует реальная опасность того, что Googlebot не обработает подобные ссылки.
Вот несколько примеров:
* Плохой URL: example.com/#/crisis-center/
* Плохой URL: example.com#URL
* Хороший URL: example.com/crisis-center/
Обратите внимание на то, что это не относится к URL с последовательностью символов `#!` (так называемый hashbang).
Возможно вы решите, что всё это не имеет особого значения. Действительно — большое дело — всего один дополнительный символ в адресе. Однако, это очень важно.
Позволю себе в очередной раз процитировать Джона Мюллера:
«(…) С нашей точки зрения, если мы видим тут нечто вроде знака #, это означает, что то, что идёт за ним, возможно, неважно. По большей части, индексируя содержимое, мы подобные вещи игнорируем (…). Когда вам нужно сделать так, чтобы это содержимое действительно появилось в поиске, важно, чтобы вы использовали ссылки, выглядящие более статично».
В итоге можно сказать, что веб-разработчикам стоит постараться, чтобы их ссылки не выглядели как нечто вроде `example.com/resource#dsfsd`. При использовании фреймворков, формирующих такие ссылки, стоит обратиться к их документации. Например, Angular 1 по умолчанию, использует адреса, в которых применяются знаки `#`. Исправить это можно, соответствующим образом [настроив](https://scotch.io/tutorials/pretty-urls-in-angularjs-removing-the-hashtag) `$locationProvider`. А вот, например, Angular 2 и без дополнительных настроек использует ссылки, которые хорошо понимает Googlebot.
О медленных скриптах и медленных API
------------------------------------
Многие сайты, основанные на JavaScript испытывают проблемы с индексированием из-за того, что Google приходится слишком долго ждать результатов работы скриптов (имеется в виду ожидание их загрузки, разбора, выполнения). Медленные скрипты могут означать, что Googlebot быстро исчерпает бюджет сканирования вашего сайта. Добейтесь того, чтобы ваши скрипты были быстрыми, и Google не приходилось бы слишком долго ждать их загрузки. Тем, кто хочет узнать подробности об этом, рекомендую ознакомиться с [этим материалом](https://developers.google.com/web/fundamentals/performance/critical-rendering-path/optimizing-critical-rendering-path?hl=ru), посвящённым оптимизации процесса визуализации страниц.
Плохая поисковая оптимизация и SEO с учётом особенностей сайтов, основанных на JavaScript
-----------------------------------------------------------------------------------------
Хочу поднять здесь проблему, которая может повлиять даже самую лучшую поисковую оптимизацию сайтов.
*Традиционный подход к SEO и SEO с учётом особенностей JS*
Важно помнить, что SEO с учётом особенностей JavaScript выполняется на базе традиционной поисковой оптимизации. Невозможно хорошо оптимизировать сайт с учётом особенностей JS, не добившись достойной оптимизации в обычном смысле этого слова. Иногда, когда вы сталкиваетесь с проблемой SEO, вашим первым ощущением может стать то, что это связано с JS, хотя, на самом деле, проблема — в традиционной поисковой оптимизации.
Не буду вдаваться в подробности подобных ситуаций, так как это уже отлично объяснил Джастин Бриггс в своём материале «[Core Principles of SEO for JavaScript](https://www.briggsby.com/dealing-with-javascript-for-seo/)», в разделе «Confusing Bad SEO with JavaScript Limitations». Рекомендую почитать эту полезную статью.
Со второго квартала 2018 года Googlebot не будет использовать AJAX-сканирование
-------------------------------------------------------------------------------
Компания Google сообщила о том, что со второго квартала 2018 года она больше не будет использовать AJAX-сканирование (AJAX Crawling Scheme). Значит ли это, что Google прекратит индексировать сайты, используя Ajax (асинхронный JavaScript)? Нет, это не так.
Стоит сказать о том, что AJAX-сканирование появилось в те времена, когда компания Google поняла, что всё больше и больше сайтов использует JS, но не могла правильно обрабатывать такие сайты. Для того, чтобы решить эту проблему, веб-мастерам предложили создавать особые версии страниц, предназначенные для поискового робота и не содержащие JS-скриптов. К адресам этих страниц надо было добавлять `_=escaped_fragment_=`.
На практике это выглядит так: пользователи работают с полноценным и приятно выглядящим вариантом `example.com`, а Googlebot посещает не такой симпатичный эквивалент сайта, к которому ведёт ссылка вида `example.com?_=escaped_fragment_=` (это, кстати сказать, всё ещё очень популярный подход подготовки материалов для ботов).
Вот как это работает (изображение взято из блога Google).
*Разные версии сайта для пользователей и для ботов*
Благодаря такому подходу веб-мастера получили возможность убить двух зайцев одним выстрелом: и пользователи довольны, и поисковый робот счастлив. Пользователи видят версию сайта, оснащённую возможностями JavaScript, а поисковые системы могут правильно индексировать страницы этого сайта, так как им достаются лишь обычные HTML и CSS.
О проблемах AJAX-сканирования
-----------------------------
Проблемы Ajax Crawling Scheme заключаются в том, что так как пользователи и поисковые роботы получают разные версии сайта, очень сложно анализировать неполадки, связанные с индексированием сайтов. Кроме того, у некоторых веб-мастеров возникали проблемы с предварительной подготовкой версий страниц, предназначенных для поискового робота.
Именно поэтому Google сообщила, что начиная со второго квартала 2018 года веб-мастерам больше не нужно создавать две разные версии веб-сайта:
*Сообщение об отключении AJAX-сканирования*
Как это повлияет на веб-разработчиков?
1. Google теперь будет формировать страницы сайтов своими средствами. Это означает, что разработчикам необходимо обеспечить то, чтобы у Google была техническая возможность сделать это.
2. Googlebot прекратит посещать ссылки, содержащие `_=escaped_fragment_=` и начнёт запрашивать те же материалы, которые предназначены для обычных пользователей.
Кроме того, разработчикам понадобится найти способ сделать свои сайты доступными для Bing и других поисковых систем, которые пока далеко позади Google в деле обработки сайтов, основанных на JavaScript. Среди возможных решений можно отметить серверный рендеринг (универсальный JavaScript), или, как ни странно, продолжение использования старого AJAX-сканирования для Bingbot. Об этом мы поговорим ниже.
Будет ли Google использовать самый современный браузер для обработки страниц?
-----------------------------------------------------------------------------
Сейчас неясно, планирует ли Google обновлять свою службу обработки сайтов с целью поддержки самых свежих технологий. Нам остаётся лишь надеяться на то, что это будет сделано.
Как быть тем, кто не хочет, чтобы Google обрабатывал его страницы, основанные на JS, а довольствовался лишь заранее подготовленными страницами?
-----------------------------------------------------------------------------------------------------------------------------------------------
Я много об этом думал, и именно поэтому решил спросить Джона Мюллера на форуме, посвящённом JavaScript SEO, о том, могу ли я обнаружить Googlebot по `User-Agent` и просто отдать ему заранее подготовленную версию сайта.
*Вопрос Джону Мюллеру о версии сайта, подготовленной специально для Googlebot*
Вот что он ответил:
*Ответ Джона Мюллера*
Джон согласен с тем, что разработчик можете узнать, что его сайт сканирует Googlebot, проверяя заголовок `User-Agent` и отдать ему заранее подготовленный HTML-снимок страницы. Вдобавок к этому он советует регулярно проверять снимки страниц для того, чтобы быть уверенным в том, что предварительный рендеринг страниц работает правильно.
Не забудьте про Bing!
---------------------
Представим себе, что Googlebot идеально обрабатывает сайты, основанные на JS-фреймворках и с ним у вас нет никаких сложностей. Значит ли это, что можно забыть обо всех проблемах, связанных с индексированием таких сайтов? К сожалению — не значит. Вспомним о поисковике Bing, который, в США, применяет около трети интернет-пользователей.
В настоящее время разумно будет считать, что Bing вообще не занимается обработкой JavaScript (ходят слухи, что Bing обрабатывает JS на страницах с высоким рейтингом, но мне не удалось найти ни одного подтверждения этим слухам).
Позвольте мне рассказать об одном интересном исследовании.
Angular.io — это официальный веб-сайт Angular 2+. Некоторые страницы этого сайта созданы в виде одностраничных приложений. Это означает, что их исходный HTML-код не содержит никакого контента. После загрузки такой страницы подгружается внешний JS-файл, средствами которого и формируется наполнение страниц.
*Сайт Angular.io*
Возникает такое ощущение, что Bing не видит содержимого этого сайта!
*Bing не видит содержимого сайта Angular.io*
Этот сайт занимает вторую позицию по ключевому слову «Angular» в Bing.
Как насчёт запроса «Angular 4». Снова — вторая позиция, ниже сайта AngularJS.org (это — официальный сайт Angular 1). По запросу «Angular 5» — опять вторая позиция.
Если вам нужны доказательства того, что Bing не может работать с Angular.io — попытайтесь найти какой-нибудь фрагмент текста с этого сайта, воспользовавшись командой `site`. У вас ничего не получится.
*Выбор фрагмента текста для проверки*
*Текст, при поиске по сайту, не найден*
По мне, так это странно. Получается, что официальный сайт Angular 2 не может быть нормально просканирован и проиндексирован роботом Bingbot.
А как насчёт Яндекса? Angular.io даже не входит в топ-50 результатов при поиске по слову «Angular» в Яндексе!
*Сайт Angular.io в Яндексе*
В Твиттере я [обратился](https://twitter.com/TomekRudzki/status/951735118258933760) к команде Angular.io, задал им вопрос о том, планируют ли они что-то делать для того, чтобы их сайт могли индексировать поисковые системы вроде Bing, но они, на момент написания этого материала, пока не ответили мне.
Собственно говоря, из вышесказанного можно сделать вывод о том, что, в стремлении внедрять на свои сайты новые веб-технологии не стоит забывать о Bing и о других поисковиках. Тут можно порекомендовать два подхода: изоморфный JavaScript и предварительный рендеринг.
Предварительный рендеринг и изоморфный JavaScript
-------------------------------------------------
Когда вы замечаете, что Google испытывает сложности с индексацией вашего сайта, рендеринг которого выполняется на клиенте, вы можете рассмотреть возможность использования предварительного рендеринга или преобразования сайта в изоморфное JavaScript-приложение.
Какой из подходов лучше?
* Предварительный рендеринг применяется в тех случаях, когда вы замечаете, что поисковые роботы не в состоянии правильно сформировать страницы вашего веб-сайта и вы выполняете эту операцию самостоятельно. Когда робот посещает ваш сайт, вы просто отдаёте ему HTML-копии страниц (они не содержат JS-кода). В то же время, пользователи получают версии страниц, оснащённых возможностями JS. Копии страниц используются лишь ботами, но не обычными пользователями. Для предварительного рендеринга страниц вы можете применять внешние сервисы (вроде prerender.io), или использовать инструменты вроде PhantomJS или Chrome без пользовательского интерфейса на своих серверах.
* [Изоморфный JavaScript](https://www.searchenginejournal.com/javascript-seo-like-peanut-butter-and-jelly-thanks-to-isomorphic-js/183337/) — это ещё один популярный поход. При его применении и поисковая система, и пользователи, при первой загрузке страницы, получают все необходимые данные. Затем загружаются JS-скрипты, которые работают уже с этими, предварительно загруженными, данными. Это хорошо и для обычных пользователей, и для поисковых систем. Данный вариант рекомендуется к использованию, его поддерживает даже Google.
*Google рекомендует изоморфный JavaScript*
Однако тут есть одна проблема, которая заключается в том, что многие разработчики не могут правильно создавать изоморфные JavaScript-приложения.
Если вас привлекает серверный рендеринг — посмотрите документацию по используемому вами JS-фреймворку. Например, в случае с Angular вы можете применить [Angular Universal](https://universal.angular.io/). Если вы работаете с React — почитайте [документацию](https://reactjs.org/docs/react-dom-server.html) и посмотрите этот [учебный курс](https://www.udemy.com/server-side-rendering-with-react-and-redux/) на Udemy.
React 16 (он вышел в ноябре) принёс в сферу серверного рендеринга [множество улучшений](https://hackernoon.com/whats-new-with-server-side-rendering-in-react-16-9b0d78585d67). Одно из таких улучшений — функция `RenderToNodeStream`, которая упрощает весь процесс серверного рендеринга.
Если говорить об общем подходе к серверному рендерингу, то хотелось бы отметить одну важную рекомендацию. Она заключается в том, что если нужно, чтобы сайт рендерился на сервере, разработчикам следует избегать использования функций, которые напрямую воздействуют на DOM.
Всегда, когда это возможно, дважды подумайте прежде чем работать напрямую с DOM. Если вам нужно взаимодействие с DOM браузера — воспользуйтесь Angular Renderer или абстракцией рендеринга.
Одинаково ли Googlebot обрабатывает HTML и JS-сайты?
----------------------------------------------------
Мы, в Elephate, провели некоторые эксперименты для того, чтобы выяснить, насколько глубоко Googlebot может продвинуться в обнаружении ссылок и в переходах по ним в случае сканирования сайтов, использующих лишь HTML, и сайтов, основанных на JavaScript.
Исследование дало поразительные результаты. В случае HTML-сайта Googlebot смог проиндексировать все страницы. Однако, при обработке сайта, основанного на JS, вполне обычной была ситуация, когда Googlebot не добрался даже до его второго уровня. Мы повторили эксперимент на пяти различных доменах, но результат всегда был одним и тем же.
*Эксперимент по индексированию HTML-сайтов и сайтов, основанных на JS*
Бартош Горалевич обратился к Джону Мюллеру из Google, и задал ему вопрос об источниках проблемы. Джон подтвердил, что Google видит ссылки, сгенерированные средствами JavaScript, но «[Googlebot не стремится их сканировать](https://groups.google.com/forum/#!topic/js-sites-wg/o96vcANs7Yo)». Он [добавил](https://groups.google.com/forum/#!topic/js-sites-wg/o96vcANs7Yo): «Мы не сканируем все URL, или сканируем все их быстро, особенно когда наш алгоритм не уверен в ценности URL. Ценность контента — неоднозначный аспект тестовых сайтов».
Если вы хотите углубиться в эту тему, рекомендую взглянуть на [этот материал](https://www.elephate.com/blog/everything-you-know-about-javascript-indexing-is-wrong/).
Подробности об эксперименте по индексированию тестовых сайтов
-------------------------------------------------------------
Хочу поделиться некоторыми моими идеями относительно вышеописанного эксперимента. Так, нужно отметить, что хотя исследуемые сайты были созданы лишь в экспериментальных целях, к их наполнению применялся один и тот же подход. А именно, их тексты были созданы средствами [Articoolo](http://articoolo.com/) — интересного генератора контента, основанного на технологиях искусственного интеллекта. Он выдаёт довольно хорошие тексты, которые определённо лучше моей писанины.
Googlebot получал два очень похожих веб-сайта и сканировал лишь один из них, предпочитая HTML-сайт сайту, на котором применяется JS. Почему это так? Выдвину несколько предположений:
* Гипотеза №1. Алгоритмы Google классифицировали оба сайта как тестовые, после чего назначили им фиксированное время выполнения. Скажем, это может быть что-то вроде индексирования 6-ти страниц, или 20 секунд рабочего времени (загрузка всех ресурсов и формирование страниц).
* Гипотеза №2. Googlebot классифицировал оба сайта как тестовые. В случае с JS-сайтом он отметил, что загрузка ресурсов занимает слишком много времени, поэтому просто не стал его сканировать.
На вышеупомянутые веб-сайты имеется множество высококачественных реальных ссылок. Многие люди охотно делились ссылками на них в интернете. Кроме того, на них поступал органический трафик. И тут возникает вопрос о том, как отличить тестовый сайт от реального. Это непростая задача.
Есть немалая вероятность того, что если вы создадите новый сайт, который рендерится на клиенте, вы попадёте в точно такую же ситуацию, как и мы. Googlebot, в таком случае, просто не станет его сканировать. Именно тут заканчивается теория и начинаются реальные проблемы. Кроме того, главная проблема здесь заключается в том, что нет практически ни одного примера из реальной жизни, когда веб-сайт, или интернет-магазин, или страница компании, на которых применяется клиентский рендеринг, занимают высокую позицию в поисковой выдаче. Поэтому я не могу гарантировать того, что ваш сайт, наполненный возможностями JavaScript, получит столь же высокую позицию в поиске, как и его HTML-эквивалент.
Вы можете решить, что, наверняка, большинство SEO-специалистов это и так знают, и большие компании могут направить определённые средства на борьбу с этими проблемами. Однако, как насчёт небольших компаний, у которых нет средств и знаний? Это может представлять реальную опасность для чего-то вроде сайтов маленьких семейных ресторанов, которые используют визуализацию на стороне клиента.
Итоги
-----
Подведём краткие итоги, обобщив в следующем списке выводы и рекомендации:
* Google использует Chrome 41 для рендеринга веб-сайтов. Эта версия Chrome была выпущена в 2015-м году, поэтому она не поддерживает все современные возможности JavaScript. Вы можете использовать Chrome 41 для того, чтобы проверить, сможет ли Google правильно обрабатывать ваши страницы. Подробности об использовании Chrome 41 можно найти [здесь](https://www.elephate.com/blog/chrome-41-key-to-website-rendering/).
* Обычно недостаточно анализировать лишь исходный HTML-код страниц сайта. Вместо этого следует взглянуть на DOM.
* Google — это единственная поисковая система, которая широко применяет рендеринг JavaScript.
* Не следует использовать кэш Google для проверки того, как Google индексирует содержимое страниц. Анализируя кэш, можно лишь увидеть то, как ваш браузер интерпретирует HTML-данные, которые собрал Googlebot. Это не имеет отношения к тому, как Google обрабатывает эти данные перед индексированием.
* Регулярно используйте инструменты Fetch и Render. Однако не полагайтесь на их тайм-ауты. При индексировании могут применяться совершенно другие тайм-ауты.
* Освойте команду `site`.
* Обеспечьте присутствие пунктов меню в DOM ещё до того, как пользователь вызывает это меню щелчком мыши.
* Алгоритмы Google пытаются определить ценность ресурса с точки зрения целесообразности обработки этого ресурса для формирования страницы. Если, по мнению этих алгоритмов, ресурс ценности не представляет, Googlebot, возможно, не станет его загружать.
* Веб-разработчикам стоит стремиться к тому, чтобы обеспечить скорость выполнения скриптов (множество экспериментов указывают на то, что Google вряд ли станет ждать результатов выполнения скрипта, включая этап загрузки, более 5 секунд). Кроме того, постарайтесь оптимизировать скрипты. Как правило, большинство скриптов можно улучшать и улучшать!
* Если Google не может сформировать страницу, используя JavaScript, он может решить проиндексировать изначально загруженный HTML. Это может очень плохо сказаться на одностраничных приложениях, так как Google, при таком подходе, проиндексирует пустую страницу.
* Нет практически ни одного реального примера сайта, применяющего рендеринг средствами клиента, который занимает высокие позиции в поисковой выдаче. Как вы думаете, почему?
С точки зрения SEO неясно, обрабатывает ли (и ранжирует ли!) Google страницы, основанные на JavaScript так же, как страницы, где используется только HTML. Зная это, очевидно то, что SEO-специалисты и разработчики только начинают подходить к пониманию того, как сделать современные JS-фреймворки такими, чтобы сайты, построенные на их основе, нормально обрабатывались бы поисковыми роботами. Поэтому важно помнить о том, что в сфере SEO для JavaScript-сайтов нет некоего универсального свода правил. Каждый веб-сайт своеобразен. В итоге же можно сказать, что если вы хотите создать сайт, вовсю использующий возможности современного JavaScript, убедитесь в том, что ваши разработчики и специалисты в области SEO знают свою работу.
**Уважаемые читатели!** Сталкивались ли вы, в личной практике, с проблемами индексации сайтов, основанных на JS-фреймворках?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/351058/ | null | ru | null |
# Разработка игр с помощью Unity и 3D-камеры Intel RealSense
Процесс создания компьютерных игр включает набор стандартных задач, с которыми постоянно приходится сталкиваться разработчикам. Это, к примеру, учет физических законов, столкновение объектов, запуск событий (звуковые сигналы, подсчет очков и т. п.) и ответ на действия игроков, использующих джойстик, мышь и клавиатуру. Реализация этих функций для каждой целевой платформы в отдельности может отнять очень много времени. Чтобы этого избежать, разработчики используют игровой движок с поддержкой стандартной функциональности. Это позволяет уделять больше внимания сложным задачам.
[Unity 3D](https://unity3d.com/) — отличное кроссплатформенное решение от Unity Technologies. Оно предназначено для разработки игр для компьютеров, игровых консолей, мобильных устройств и веб-браузеров. В Unity 3D предусмотрена поддержка различных языков программирования, например C++, C#, Unity Script (похож на JavaScript) и Boo.
Эта статья предназначена как для начинающих специалистов, так и для экспертов. Чтобы помочь тем, кто никогда раньше не работал с Unity, мы начнем с небольшого примера применения этого продукта. Затем я расскажу, как использовать [Intel RealSense SDK](https://software.intel.com/en-us/intel-realsense-sdk) и [3D-камеру Intel RealSense](http://www.intel.com/content/www/us/en/architecture-and-technology/realsense-3d-camera.html) для отслеживания жестов и как создать простую игру на C#.
Для работы вам потребуется Visual Studio, Unity, Intel RealSense SDK и 3D-камера Intel RealSense.
Загрузка, установка и настройка Visual Studio
---------------------------------------------
[Загрузите](http://unity3d.com/get-unity/download) бесплатную версию Unity. Она работает под ОС Microsoft Windows\* и Apple Mac\* OS X\*. Чтобы завершить установку, пройдите бесплатную регистрацию.
Программа, приведенная в этой статье для примера, написана на языке C#. В качестве кроссплатформенной интегрированной среды разработки в Unity по умолчанию используется [MonoDevelop](http://www.monodevelop.com/). Unity также можно использовать с [Microsoft Visual Studio](https://www.visualstudio.com/), что особенно удобно для разработчиков .NET. Для начала нужно подключить Visual Studio к Unity. В раскрывающемся меню выберите **Edit -> Preferences…**. На экране появится окно настроек. Выберите **External Tools** на панели с левой стороны (рис. 1). Нажмите MonoDevelop рядом с полем External Script Editor и выберите файл .exe Visual Studio, нажав кнопку **Browse…**. Установите Visual Studio, используя настройки по умолчанию. Путь к файлу запуска программы должен быть следующим.
**C:\Program Files (x86)\Microsoft Visual Studio 12.0\Common7\IDE\devenv.exe**.
Это все, что требуется для подключения.
*Рисунок 1. Выбор Visual Studio\* в Unity\**
#### Среда
Перейдем к настройкам среды Unity. Главный экран состоит из нескольких окон. Вы можете разместить их вручную или выбрать стандартное расположение. Мы выбрали ориентацию **Tall** в раскрывающемся меню **Layout** в правом верхнем углу экрана.
*Рисунок 2. Выбор положения окна*
#### Окно построения сцены и окно игры
Первое большое окно (рис. 3) предназначено для построения сцены, то есть для размещения объектов игры. Обычно для него используется 3D-формат. Чтобы изменить положение объекта сцены, достаточно его перетащить. Сразу над главным экраном расположена вкладка игры. На ней показано готовое изображение, каким его увидит пользователь.
*Рисунок 3. Окно построения сцены*
*Рисунок 4. Окно игры*
#### Окно иерархии
В окне иерархии (рис. 5) представлен список используемых объектов, например предметы из самой игры, камеры, средства освещения сцены, элементы интерфейса и аудиозаписи. Чтобы создать новые объекты, используйте меню **GameObject** или окно **Create**.
*Рисунок 5. Окно иерархии*
#### Окно свойств
При выборе объекта в окне иерархии на экране появится окно его свойств (рис. 6). Их набор можно расширить, добавив в него дополнительные элементы. Для этого нужно нажать кнопку **Add Component**. Например, объекту можно назначить свойства твердого тела, чтобы в игре на него действовала гравитация.
*Рисунок 6. Окно свойств*
#### Окно проекта
Список файлов проекта, например сцен и объектов игры, аудиозаписей, изображений и сценариев, представлен в окне проекта (рис. 7). При выборе файла на экране появится информация о его свойствах и окно предварительного просмотра. Если два раза щелкнуть файл сценария, он откроется в соответствующей среде разработки.
Рисунок 7. Окно проекта
Создание простой игры
---------------------
В начале 70-х Нолан Бушнелл, основатель Atari, выпустил игру, которая впоследствии стала очень популярной. Она называлась [Pong](http://www.slate.com/articles/technology/technology/2014/10/the_invention_of_pong_how_nolan_bushnell_launched_the_video_game_industry.html) и представляла собой простейший симулятор настольного тенниса. Игра заключалась в следующем. По экрану движется мячик. Каждый игрок управляет ракеткой, перемещая ее по вертикали. Если кому-то не удается отбить мяч, его соперник получает одно очко. Давайте разберемся, как реализовать эту игру с помощью Unity.
Чтобы создать новый проект, нажмите **File -> New Project**. Назовите его **PingPongUnity**.
*Рисунок 8. Создание нового проекта*
#### Ракетки
Для начала создадим ракетки. В окне иерархии нажмите **Create -> 3D Object -> Cube**. Чтобы изменить форму и расположение ракеток, выберите созданный куб и укажите нужные параметры в окне настроек. В нашем примере мы назвали объект **Paddle1** и изменили его форму (см. графу Transform). Укажите следующие значения в графе **scale** **X: 0.5, Y:3, Z:1**. Укажите следующие координаты в графе **Position X: -9, Y: 1, Z: 0**. Таким образом мы создали первую ракетку. В окне иерархии нажмите правой кнопкой мыши на ракетку и в контекстном меню выберите **Duplicate**. На экране появится копия созданной ракетки. Осталось только переименовать ее в **Paddle2** и изменить значение **X** в графе **Position** на **9**.
Чтобы ракетки двигались согласно физическим законам, нам придется добавить компонент **RigidBody**, нажав кнопку **Add Components** для каждой из них. Так мы сможем управлять движением ракеток и их столкновением с мячом. Пока что наш мячик просто пролетает сквозь ракетку, а не отскакивает от нее. Это не совсем то, что требуется. Чтобы избежать этого, следует установить определенные ограничения на свойства объектов. Те объекты, которые будут удовлетворять указанным ограничениям, назовем **RigidBody**. Ракетки могут двигаться только вверх и вниз, так что в графе **Freeze Rotation** нужно выбрать **x**, **y** и **z**, а в графе **Freeze Position** — только **x**.
*Рисунок 9. Ракетки*
#### Стенки
Для этой игры также нужно создать две стенки (верхнюю и нижнюю), чтобы мячик отскакивал от них и не улетал за границы поля. Для этого нам снова понадобятся кубические объекты. В окне иерархии еще раз нажмите **Create -> 3D Object -> Cube**. Назовите созданный объект **WallBelow**. Он будет чуть длиннее ракеток, поэтому в графе **scale** укажите следующие значения **X: 23, Y: 1, Z: 1**. В графе **Position** укажите следующее **X: 0, Y: -5, Z: 0**.
Чтобы создать вторую стенку, достаточно скопировать первую и переименовать ее в **WallAbove**. Теперь просто измените значение **Y-Position** на **7**.
*Рисунок 10. Стенки*
#### Мячик
Осталось создать последний, самый важный объект игры — мячик. В наборе стандартных форм, представленном в Unity, уже есть нужная. В окне иерархии нажмите **Create -> 3D Object -> Sphere**. Измените название на **Ball**, в графе **Position** укажите следующие значения **X: 0, Y: 1, Z: 0**. Чтобы мячик двигался нужным образом, необходимо включить ограничения **RigidBody**, нажав на кнопку **Add Components**, и снять галочку **Use gravity**.
*Рисунок 11. Мячик*
#### Изменение угла обзора и освещение сцены
Пока что ракурс выбран неудачно. Чтобы это исправить, нужно изменить настройки камеры. В окне иерархии выберите стандартную камеру **Main Camera**. Переключите формат обзора с 3D на 2D. Это можно сделать в разделе **Projection**. Вместо **Perspective (3D)** выберите **Orthographic (2D)**. Теперь на экране представлена вертикальная проекция сцены. Измените значение параметра **Size** на **10**.
Если требуется повернуть камеру, нажмите значок осей координат.
*Рисунок 12. Поворот камеры можно включить, нажав на значок осей координат*
Мы установили все необходимые настройки камеры. Однако сцена остается слишком темной. Чтобы добавить освещение, откройте окно иерархии и нажмите Create -> Light -> Directional Light. Все изменения отображены в окне игры.
*Рисунок 13. Окно игры*
#### Давайте запустим мячик!
Поле готово, но все объекты пока замерли на месте. Если сейчас начать игру, мячик свалится вниз и этим все закончится. Чтобы это исправить, достаточно добавить в игру несколько строк кода на C#. Нажмите кнопку **Create** в окне проекта и создайте новый файл сценария под названием Ball для программы на языке C#. Перетащите его на мячик в окне иерархии или в окне отображения сцены, чтобы связать с объектом игры. Теперь при выборе мячика в окне свойств появится информация о файле сценария.
По двойному щелчку файла C# откроется выбранная среда разработки (MonoDevelop или Microsoft Visual Studio). Каждый вновь созданный файл содержит автоматически реализованный стандартный класс. Он называется MonoBehavior и является интерфейсом для Unity API. Метод **Start** выполняет инициализацию и подготовку к началу игры. Игровая среда, как телевизор, обрабатывает несколько изображений в секунду. Одно изображение называется кадром. Метод **Update** запускается каждый раз перед показом кадра. Таким образом реализуется то, что мы называем циклом игры. То есть игровые объекты могут действовать независимо от действий игрока.
В нашем случае требуется установить направление движения мячика в начале игры. Это можно сделать в методе **Start**. См. фрагмент программы ниже.
```
using UnityEngine;
public class Ball : MonoBehaviour
{
private float _x;
private float _y;
// Инициализация
void Start ()
{
_x = GetRandomPositionValue();
_y = GetRandomPositionValue();
GetComponent().velocity = new Vector3(Random.Range(5,10) \* \_x, Random.Range(5,10) \* \_y, 0);
Debug.Log("x: " + \_x);
Debug.Log("y: " + \_y);
}
private float GetRandomPositionValue()
{
if (Random.Range(0, 2) == 0)
{
return -1;
}
return 1;
}
// Обновление вызывается один раз за кадр
void Update ()
{
}
}
```
*Фрагмент кода 1. Выбор направления движения мячика. Реализация на языке C#*
Раздел компонентов — самая содержательная часть реализации. Для каждой игровой логики предусмотрен свой компонент. В приведенном фрагменте кода для доступа к компоненту **Rigidbody** текущего объекта игры используется метод **GetComponent**. **Rigidbody** отвечает за действие на объект сил гравитации. В программе мы создаем новый вектор **Vector3** и присваиваем его **velocity** (скорость, свойство Rigidbody). Координаты вектора задаются случайным образом.
Запуская игру еще раз, мы видим, что мячик теперь падает в произвольном направлении. Сталкиваясь со стенкой, он начинает двигаться вбок, а нам нужно, чтобы он отскакивал.
Давайте воспользуемся разделом **Physic Material** и выберем для мячика необходимые физические свойства. В окне проекта нажмите кнопку **Create**. Укажите имя **Bouncy**. Осталось только изменить некоторые свойства, чтобы добиться нужной прыгучести мячика. В окне свойств установите значение 0 для параметров **Dynamic Friction** и **Static Friction**. Для **Bounciness** укажите **1**. Значение **Friction Combine** должно быть минимально, а **Bounce Combine** — максимально.
*Рисунок 14. Настройка физических свойств материала*
Чтобы применить выбранные настройки к объектам игры, нужно сделать следующее. Нажмите **Edit -> Project Settings -> Physics**. Перетащите набор свойств под названием **Bouncy** в набор стандартных свойств **Default material**. Для параметра **Bounce Threshold** установите значение **0.1**. Теперь мячик будет прыгать как резиновый.
*Рисунок 15. Настройка свойств Bouncy в окне PhysicsManager*
#### Управление ракетками при помощи жестов
Игра почти готова. Все объекты находятся на своих местах, и мячик движется, как мы и хотели. Осталось только научиться управлять ракетками. Для этого лучше всего использовать 3D-камеру — новейшее устройство ввода, которое уже широко используют с Microsoft Xbox\* и Kinect\*, а также встраивают в некоторые новые модели Ultrabook. 3D-камера не так дорого стоит, так что не упустите возможность ее приобрести. Для программной реализации вам потребуется [Intel RealSense SDK](https://software.intel.com/en-us/intel-realsense-sdk). Этот комплект можно загрузить бесплатно. Примеры работы с Unity находятся в Intel RealSense SDK. Посмотрите их после завершения установки.
*Рисунок 16. Примеры из Intel RealSense SDK*
В Unity 3D предусмотрена поддержка подключаемых модулей сторонних производителей, а также Intel RealSense SDK. Чтобы подключить Intel RealSense SDK, добавьте в проект файлы SDK DLL. В окне Unity нажмите **Assets -> Import package -> custom package...**. Затем выберите файл RSUnityToolkit.unitypackage, расположенный по адресу C:\Program files (x 86) \Intel\RSSDK\framework\Unity. На экране появится диалоговое окно (см. рис. 17). По умолчанию выбраны все файлы. Чтобы снять выбор, нажмите None. Затем выберите только папку подключаемых модулей. При работе с 64-разрядными системами импортированные файлы DLL также нужно будет заменить вручную. Они находятся в папке **C:\Program Files (x86)\Intel\RSSDK\bin\x64**.
*Рисунок 17. Подключение Intel RealSense SDK к Unity\* с помощью функции импорта пакета*
После подключения можно перейти к реализации управления ракетками. Создадим еще один файл C#. Для этого нажмите кнопку **Create** в окне проекта. Назовите файл **Paddle**. Для управления обеими ракетками достаточно одного общего экземпляра. Это существенный момент, поскольку 3D-камера Intel RealSense не поддерживает подключение к нескольким экземплярам. Поэтому, чтобы подключить новый файл, достаточно перетащить его на объект main camera в окне иерархии.
После этого дважды нажмите файл **Paddles.cs**. Хотя он подключен к главной камере, для работы нам понадобятся объекты игры, соответствующие ракеткам. В Unity подключение нескольких объектов игры определяется в их свойствах. В C# пришлось бы определять дополнительные свойства с помощью **get** и **set**, что в Unity делать совсем не обязательно. Нужно только создать для каждой ракетки переменную типа **GameObject** с модификатором доступа public, как показано в примере ниже. Теперь, чтобы подключить объекты игры, достаточно перетащить их в свойства созданных ракеток.
```
public class Paddles : MonoBehaviour
{
public GameObject Paddle1;
public GameObject Paddle2;
..
```
*Фрагмент 2. Автоматически определяемые свойства*
Для подключения камеры в Intel RealSense SDK реализован класс **PXCMSenseManager**. Функция **Start** будет вызвана только один раз, так что в ней лучше всего выполнять все подготовительные действия. Именно поэтому мы выбрали функцию **Start** для инициализации класса **PXCMSenseManager**. Распознавание жестов реализовано в модуле **QueryHand**, к которому мы обращаемся в программе. Для распознавания лица и голоса требуется отдельный модуль. Объявление экземпляра модуля (переменная **\_pxcmSenseManager**) вынесено за пределы функции **Start**. См. фрагмент программы ниже.
```
public class Paddles : MonoBehaviour
{
public GameObject Paddle1;
public GameObject Paddle2;
private PXCMSenseManager _pxcmSenseManager;
private PXCMHandModule _pxcmHandModule;
// Инициализация
private void Start()
{
_pxcmSenseManager = PXCMSenseManager.CreateInstance();
if (_pxcmSenseManager == null)
{
Debug.LogError("SenseManager Initialization Failed");
}
else
{
pxcmStatus pxcmResult = _pxcmSenseManager.EnableHand();
if (pxcmResult != pxcmStatus.PXCM_STATUS_NO_ERROR)
{
Debug.LogError("EnableHand: " + pxcmResult);
}
else
{
_pxcmHandModule = _pxcmSenseManager.QueryHand();
_pxcmSenseManager.Init();
PXCMHandConfiguration configuration = _pxcmHandModule.CreateActiveConfiguration();
configuration.EnableAllGestures();
configuration.ApplyChanges();
configuration.Dispose();
}
}
}
...
```
*Фрагмент кода 3. Подключение 3D-камеры Intel RealSense*
Обработка очереди данных, поступающих с камеры, выполняется в функции Update (на каждом шаге цикла игры), так что мы можем определить, распознает камера руку или нет. В нашей реализации левая рука управляет левой ракеткой, правая — правой. Обработка действий для обеих рук полностью совпадает, поэтому мы создадим отдельную функцию **MoveBall** и будем передавать ей доступ к данным о левой или правой руке в качестве параметра.
Если игрок завершает игру или начинает заново, требуется отключить связанный с камерой экземпляр. Для этого будем использовать функцию **OnDisable**, к которой автоматически обратится Unity.
```
// Обновление вызывается один раз за кадр
private void Update()
{
if (_pxcmSenseManager == null)
{
return;
}
_pxcmSenseManager.AcquireFrame(false, 0);
_pxcmHandModule = _pxcmSenseManager.QueryHand();
PXCMHandData handData = _pxcmHandModule.CreateOutput();
handData.Update();
MoveBall(handData, PXCMHandData.AccessOrderType.ACCESS_ORDER_LEFT_HANDS, Paddle1);
MoveBall(handData, PXCMHandData.AccessOrderType.ACCESS_ORDER_RIGHT_HANDS, Paddle2);
_pxcmSenseManager.ReleaseFrame();
}
private void MoveBall(PXCMHandData handData, PXCMHandData.AccessOrderType accessOrderType, GameObject gameObject)
{
PXCMHandData.IHand pxcmHandData;
if (handData.QueryHandData(accessOrderType, 0, out pxcmHandData) ==
pxcmStatus.PXCM_STATUS_NO_ERROR)
{
PXCMHandData.JointData jointData;
if (pxcmHandData.QueryTrackedJoint(PXCMHandData.JointType.JOINT_CENTER, out jointData) ==
pxcmStatus.PXCM_STATUS_NO_ERROR)
{
gameObject.GetComponent().velocity = new Vector3(-9, jointData.positionWorld.y\*100f, 0);
}
}
}
private void OnDisable()
{
\_pxcmHandModule.Dispose();
\_pxcmSenseManager.Dispose();
}
}
```
*Фрагмент кода 4. Управление ракетками при помощи жестов*
#### Перезапуск игры
Мы создали объекты, написали программу, теперь настало время поиграть. Ракетка начнет перемещаться, если движение руки удалось распознать в пределах 1–5 метров от камеры. Ударившись о ракетку, мячик отскочит и будет двигаться в обратном направлении. Если мячик не коснется ракетки и вылетит за пределы поля, вернуть его уже не удастся. В этом случае логично было бы запускать игру заново.
Для этого достаточно дописать всего несколько строчек кода в наш файл **Ball.cs**. Добавим проверку наличия мячика на поле в функцию **Update**. Если мячик пропадет из вида, функция **Application.LoadLevel** перезапустит игру, как показано в программе ниже.
```
private bool _loaded;
// Обновление вызывается один раз за кадр
void Update ()
{
if (GetComponent().isVisible)
{
\_loaded = true;
}
if (!GetComponent().isVisible && \_loaded)
{
Application.LoadLevel(Application.loadedLevel);
}
}
```
*Фрагмент кода 5. Ball.cs: запуск новой игры, когда мячик пропадает из вида*
#### Публикация игры
Мы не зря старались и создали первую версию игры. Поделиться ей с другими очень просто. Нажмите **File | Build Settings** (Ctrg + Shift + B). На экране появится диалоговое окно сборки. В нем предложен огромный выбор самых разных платформ. Мы будем использовать ОС Windows (архитектура x86\_64). Чтобы запустить компилятор и создать файл \*.exe для Windows, достаточно нажать **Build**. После этого, чтобы начать игру, потребуется 3D-камера Intel RealSense с установленным драйвером.
*Рисунок 18. Компиляция игры и создание файла \*.exe*
#### Теперь ваша очередь
Мы научились создавать простейшую игру с помощью Unity, но есть еще столько способов ее улучшить! Попробуйте доработать ее, добавьте подсчет очков, звуки и спецэффекты. Загрузите видео на YouTube\* и напишите мне по электронной почте, чтобы похвастаться своими успехами. Я уверен, у вас получится отличная игра. На этом все, настало время поиграть!
*Рисунок 19. Игра*
*Рисунок 20. Интерфейс игры* | https://habr.com/ru/post/264577/ | null | ru | null |
# Тональное качество вибраций, или Почему барабаны не прямоугольные?
У науки есть огромное, бесконечное число достоинств, и одно из них состоит в том, что именно она способна кратко, точно и ёмко ответить на самые неожиданные в своей простоте, детские вопросы. Например: «Почему барабан круглый?» Если у вас есть дети или вы сами в детстве задавались этим вопросом, то в этом переводе, которым мы решили поделиться к старту флагманского [курса о Data Science](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=240621), вы найдёте два ответа: первый — подробный, в формулах, второй — краткий, понятный ребёнку ответ.
---
Я всегда был очарован тем, как свойства любой формы волны связаны с тем, как мы их воспринимаем. Особенно форма волн и формы, от которых волны исходят. Мы знаем, что звук — это механическая волна и для её распространения нужна среда. Источник вибрации перемещает молекулы воздуха колебаниями, вызывающими сжатие и разрежение (области высокого и низкого давления). Эти изменения давления взаимодействуют с нашей барабанной перепонкой, и мы воспринимаем звук. Итак, если все виды вибраций вызывают вибрацию только молекул воздуха, то в свойствах формы волны должно быть что-то особенное, что помогает нам различать два звука. Что заставляет гитару звучать иначе, чем пианино, или почему мой голос отличается от вашего.
Я рассмотрю эту проблему с двух точек зрения. В первом подходе я сравниваю два реальных образца из разных инструментов и анализирую их свойства. Во втором — я работаю с нуля и показываю, как решения волновых уравнений в различных сценариях проявляются в этих свойствах, которые мы воспринимаем.
Рис. 1. Визуализация звука пианино, нота ля первой октавыПианино — это струнный инструмент. Вибрации начинаются с удара молотка по его струнам. Такое же поведение наблюдается и на графике формы волны. Молоток создаёт высокую импульсную силу на струнах, и в результате происходит внезапное увеличение амплитуды. Со временем амплитуда и, следовательно, громкость сигнала затухают.
Рис. 2. Скрипка, ля первой октавы, ля диез, си первой октавыНа рисунке визуализированы звуки скрипичных нот [включая полутон в середине, который по историческим причинам не считается нотой с формальной точки зрения, поэтому в названии вы видите диапазон A4-B4, все звуки в нём не обозначены] с возрастающей частотой. Частотные характеристики не фиксируются на графике формы волны, но формы отличаются от пианино. В отличие от пианино амплитуда всех нот постепенно увеличивается, так как звук издаётся смычком, который мягко трётся о струну. И уменьшение амплитуды происходит тоже резко, поскольку скрипач приглушает одну струну, играя на другой. И поэтому мы не слышим никакого протяжного звука или какой-то филировки, как мы называем это в музыке.
Чтобы найти больше различий в звуке, мы должны перейти в область частот. Лучший способ увидеть такие различия — спектрограмма, т. е. визуальное представление спектра частот по мере изменения сигнала во времени. Для создания спектрограммы аудиосигнал разбивается на более мелкие сегменты, и к каждому из этих сегментов может применяться быстрое преобразование Фурье. Давайте вначале рассмотрим простую синусоидальную волну с частотой 440 Гц.
*Синусоидальная волна с частотой 440 Гц*
Тон синусоидальной волны и тон пианино находятся точно в одной и той же высоте, на частоте 440 Гц. Однако синусоидальную волну *слушать* не так интересно. Звучит как просто непрерывный тон звука без какой-либо динамики или насыщенности. Хотя многие интересные звуки возможно получить путём интерференции и применения преобразований на синусоидах. Синтезатор — это устройство, позволяющее вам сделать это.
```
import numpy as np
import matplotlib.pyplot as plt
import librosa, librosa.display
sr = 22050 # sample rate
T = 2.0 # seconds
t = np.linspace(0, T, int(T*sr)) # time variable
x = 0.5*np.sin(2*np.pi*440*t)
def plot_spectrogram(signal, name):
spectrogram = librosa.amplitude_to_db(np.abs(librosa.stft(signal)))
plt.figure(figsize=(10, 5))
librosa.display.specshow(spectrogram, y_axis="log")
plt.colorbar(format="%+2.0f dB")
plt.title(f"Log-frequency power spectrogram for {name}")
plt.xlabel("Time")
plt.show()
plot_spectrogram(x, 'sine wave')
```
Рис. 3. Спектрограмма синусоидальной волны при 440 ГцНаблюдая спектрограмму синусоидальной волны, можно обнаружить, что единственная присутствующая частота составляет 440 Гц.
```
piano, srp = librosa.load('Piano.mf.A4_trimmed.wav')
violin, srv = librosa.load('Violin.arco.mf.sulA.A4B4.wav')
plot_spectrogram(piano, 'piano')
plot_spectrogram(violin, 'violin')
```
Рис. 4. Спектрограмма фортепиано, нота ля первой октавыПостроив спектрограмму пианино, мы увидим, что наиболее доминирующая частота составляет 440 Гц, но в то же время присутствует множество других частот. Они известны как обертоны, и для одной вибрирующей струны можно показать, что эти обертоны на самом деле являются целыми кратными основной частоте, в данном случае 440 Гц.
Рис. 5. Спектрограмма скрипичных нотВ случае скрипки на спектрограмме та же история. Есть основная частота, а затем — обертоны во всех трёх сыгранных нотах. Количество обертонов намного выше, чем на спектрограмме пианино. И это одна из причин того, почему пианино звучит иначе, чем скрипка, хотя оба они являются струнными инструментами. Основная частота увеличивается по мере перехода от первой ноты к третьей сыгранной ноте. Также здесь обертоны — целые числа, кратные основной частоте.
Таким образом, можно сказать, что частота обертонов имеет какое-то отношение к тональному качеству звука. Играя одну ноту на струнном инструменте, мы видим, что в звуке присутствуют кратные основной частоте целые числа. Если эти обертоны не находятся в целых кратных числах или в определённых соотношениях частот (как, например, когда на множестве клавиш исполняются аккорды), человеческому уху трудно различить, имеет ли звук какое-либо тональное качество или нет.
Вернёмся к первоначальному вопросу. Почему большинство барабанов круглой формы? От *табла, конго, бонго* до обычной ударной установки — всё круглое. Что такого особенного в круглой или прямоугольной форме? Чтобы разобраться в этом, нам придётся взглянуть на вибрации, исходящие от прямоугольной мембраны, и посмотреть, сможем ли мы что-то обобщить.
Предположим, что мембрана установлена в плоскости *xy*, а *u(x, y, t)* — вертикальный прогиб мембраны относительно положения равновесия *(x, y)* во времени *t*. При постоянном *t* поверхность *z = u(x, y, t)* задаёт форму мембраны в момент *t*.
Рассмотрим натянутую мембрану, закреплённую на прямоугольной раме длиной *a* и шириной *b*. Чтобы изучить её колебания, нужно решить задачу о начальном значении.
Здесь уравнения (2) и (3) — граничные значения, а уравнения (4) и (5) — начальные значения. Чтобы найти простые решения, мы можем воспользоваться разделением переменных, удовлетворяющих гомогенным граничным условиям, а затем применить принцип суперпозиции для построения серии решений, удовлетворяющих также и начальным условиям. Мы можем искать решения вида *u (x, y, t) = X (x)Y (y)T (t).* Подставив формулу в уравнение (1), получаем:
Поскольку обе стороны уравнения — функции независимых переменных, они должны быть равны константе.
Компонент времени упорядочен, но компоненты пространства снова содержат функции несвязанных переменных с обеих сторон уравнения. Можно приравнять их к константе, вот так:
Имея ввиду C = A-B, эти уравнения можно переписать так:
Теперь решения этих двух однородных дифференциалов могут быть либо суммой экспоненциальных функций, либо суммой синусоид, в зависимости от *знака* *B* и *C*. Поскольку волны периодичны по своей природе, а мембрана в определённом месте не может просто продолжать увеличиваться, чтобы решение было периодическим по своей природе, B и C должны быть положительными константами.
λₘₙ в формуле известны как **характерные частоты** мембраны. Теперь точное решение волнового уравнения можно записать в виде произведения *X (x), Y (y)* и *T (t)*, а коэффициенты возможно оценить при помощи свойств ряда Фурье. Нас больше интересует не поиск точного решения волнового уравнения, а выяснение звучания обертонов таких частотных характеристик. Если ради простоты предположить, что мембрана квадратная, то a = b, следовательно:
Здесь мы ясно видим, что в отличие от вибрирующей струны высшие обертоны не являются целыми кратными основной частоты. Вот почему вибрирующая струна обладает тональным качеством, а исходящий от прямоугольной мембраны звук не является тональным. Когда происходит произвольный удар в прямоугольный барабан, в процессе одновременно представлено множество мод колебаний, но различные слышимые частоты не являются целыми кратными одной и той же частоты.
Круглая мембрана — это немного другая история. При помощи аналогичных вычислений можно показать, что на самом деле обертоны — это целые кратные основной частоты. Более подробную информацию можно найти в этой замечательной [книге](https://www.wiley.com/en-us/Partial+Differential+Equations%3A+An+Introduction%2C+2nd+Edition-p-9780470054567) по дифференциальным уравнениям.
Перед тем как играть на индийских классических ударных инструментах, таких как *табла, пахавадж* и т. д., музыкант *настраивает* эти инструменты на мажорную гамму, в которой будет исполняться вокальное или инструментальное произведение. Он натягивает или ослабляет круглую мембрану, на которой будет играть. Всё это возможно ещё и потому, что конструкция мембраны позволяет ей обладать тональным качеством — а значит, её можно настраивать. Если бы мембрана имела прямоугольную форму, настроить её было бы невозможно. Такие инструменты имеют многовековую историю, их круглая форма — не случайность!
Эта статья напоминает, что с помощью анализа данных, а также зная математические формулировки тех или иных процессов, можно смотреть на эти процессы с различных точек зрения и отвечать на неожиданные в своей простоте вопросы. Если вам интересно работать с данными, выявлять неочевидное, то вы можете обратить внимание на наш флагманский [курс Data Science](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=240621), где можно не только освоить профессию дата-сайентиста с нуля, но и прокачать ваши навыки в ней.
[Узнайте](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=240621), как прокачаться и в других специальностях или освоить их с нуля:
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=240621)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=240621)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=150621)
Другие профессии и курсы**ПРОФЕССИИ**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=240621)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=240621)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=240621)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=240621)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=240621)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=240621)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=240621)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=240621)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=240621)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=240621)
**КУРСЫ**
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=240621)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=240621)
* [Курс «Математика для Data Science»](https://skillfactory.ru/math-stat-for-ds#syllabus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MAT&utm_term=regular&utm_content=240621)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=240621)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=240621)
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=240621)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=240621)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=240621) | https://habr.com/ru/post/564456/ | null | ru | null |
# Использование mapbox-gl в React и Next.js
Введение
--------
В данной статье я хочу описать известные мне способы встраивания `mapbox-gl` в `React` приложение, на примере создания простого веб приложения содержащего карту на `Next.js` с использованием `Typescript`, код компонента карты можно также использовать в любом любом приложении на `React`
Эта статья входит в цикл статей
Управление состоянием mapbox-gl в ReactОписание проблемыВ процессе моей работы в geoalert.io я не раз сталкивался с проблемой управления со...[habr.com](https://habr.com/ru/post/565216/)Я рассмотрю несколько вариантов реализации на примере создания функционального компонента карты:
* Имплементация с хранением инстанса карты внутри `React` компонента
* Хранение инстанса карты вне `React`
Справка по сниппетам с кодом
----------------------------
> Для комфортного чтения данной статьи Вам необходимо иметь базовые знания `React`, `Typescript` и `CSS`
>
>
> Все сниппеты с кодом будут с использованием `Typescript`, использование типизации в javascript является лучшей практикой, поэтому я принципиально ее придерживаюсь там где это возможно, прошу прощения если вы ее не знакомы с ним, [вот замечательный курс от egghead.io где вы сможете с ним ознакомиться](https://egghead.io/courses/up-and-running-with-typescript)
>
>
> Я предпочитаю импортировать `React` как `import * as React from "react"` подробнее об этом можно почитать в [замечательном артикле от Kent C. Dodds](https://epicreact.dev/importing-react-through-the-ages/)
>
>
> Если в коде встречается `// ...` это необходимо читать как места с пропущенным повторяющимся кодом
>
>
Подготовка окружения
--------------------
Прежде всего создадим новый проект на `Next.js` по шаблону `Typescript`
```
npx create-next-app --typescript my-awesome-app
```
Откроем папку проекта и установим так же `mapbox-gl` с типами для `Typescript`
```
cd my-awesome-app
npm install --save mapbox-gl && npm install -D @types/mapbox-gl
```
Так же нам потребуется [accessToken](https://docs.mapbox.com/help/getting-started/access-tokens/) для `mapbox-gl` поместим его в переменной окружения чтобы не хранить его непосредственно в коде приложения
```
touch .env.local
echo NEXT_PUBLIC_MAPBOX_TOKEN=<ваш_токен> >> .env.local
```
Так должен выглядеть ваш файл с [переменной окружения для](https://nextjs.org/docs/basic-features/environment-variables) `Next.js`
**.env.local**
```
NEXT_PUBLIC_MAPBOX_TOKEN=<ваш_токен>
```
Имплементация в виде функционального компонента React
-----------------------------------------------------
### Подготовка стилей
Удалим лишние стили и обновим глобальный файл стилей
```
rm styles/Home.module.css
```
**styles/global.css**
```
html,
body,
#__next {
padding: 0;
margin: 0;
width: 100%;
height: 100%;
}
* {
box-sizing: border-box;
}
```
Чтобы высота содержимого приложения равнялась `100%` высоты окна, зададим свойства `width` и `height` равные `100%` для `html` и `body`
Высоту так же необходимо указать для элемента с `css` селектором `#__next` так как в `Next.js` приложении корневым элементом является `...`
### Подготовка компонента карты
**components/mapbox-map.tsx**
```
import * as React from "react";
import mapboxgl from "mapbox-gl";
import "mapbox-gl/dist/mapbox-gl.css";
// импортируем стили mapbox-gl чтобы карта отображалась коррекно
function MapboxMap() {
// здесь будет хранится инстанс карты после инициализации
const [map, setMap] = React.useState();
// React ref для хранения ссылки на DOM ноду который будет
// использоваться как обязательный параметр `container`
// при инициализации карты `mapbox-gl`
// по-умолчанию будет содержать `null`
const mapNode = React.useRef(null);
React.useEffect(() => {
const node = mapNode.current;
// если объект window не найден,
// то есть компонент рендерится на сервере
// или dom node не инициализирована, то ничего не делаем
if (typeof window === "undefined" || node === null) return;
// иначе создаем инстанс карты передавая ему ссылку на DOM ноду
// а также accessToken для mapbox
const mapboxMap = new mapboxgl.Map({
container: node,
accessToken: process.env.NEXT\_PUBLIC\_MAPBOX\_TOKEN,
style: "mapbox://styles/mapbox/streets-v11",
center: [-74.5, 40],
zoom: 9,
});
// и сохраняем созданный объект карты в React.useState
setMap(mapboxMap);
// чтобы избежать утечки памяти удаляем инстанс карты
// когда компонент будет демонтирован
return () => {
mapboxMap.remove();
};
}, []);
return ;
}
export default MapboxMap
```
Описание параметров инициализации `mapbox-gl` можно посмотреть в документации
Map | Mapbox GL JS[docs.mapbox.com](https://docs.mapbox.com/mapbox-gl-js/api/map/)Далее импортируем его в главную страницу приложения и запустим проект
**pages/index.tsx**
```
import MapboxMap from "../components/mapbox-map";
function App() {
return ;
}
export default App;
```
```
npm run dev
```
Открыв <http://localhost:3000> видим полноэкранную веб-карту
### Что можно сделать лучше
В предложенной реализации не хватает нескольких полезных фичей
* **Параметры инициализации карты** - при использовании компонента карты логичным выглядит иметь возможность передать ему через `props` начальные параметры отображения карты
* Д**оступ к инстансу карты из других компонентов - п**омимо самой веб-карты в приложении как правило содержатся другие компоненты для которых необходимо иметь доступ напрямую к инстансу карты
* **Нотификация о готовности карты** - загрузка карты занимает некоторое время, пока пользователь ожидает открытия карты, для улучшения пользовательского опыта, можно показывать скелетон или загрузочный экран со спиннером. Для этих целей было бы удобно иметь коллбек срабатывающий после того как карта полностью загружена
Пример с загрузкой карты в моем приложении <https://app.mapflow.ai>
Улучшенный компонент карты
--------------------------
Давайте имплементируем все эти возможности, сначала добавим `props` для компонента веб-карты
```
interface MapboxMapProps {
initialOptions?: Omit;
onCreated?(map: mapboxgl.Map): void;
onLoaded?(map: mapboxgl.Map): void;
onRemoved?(): void;
}
function MapboxMap({
initialOptions = {},
onCreated,
onLoaded,
onRemoved,
}: MapboxMapProps) {
// ...
```
Используемые `props`
* **initialOptions** - [параметры инициализации карты](https://www.notion.so/mapbox-gl-React-Next-js-fac7c457b2da4d0aa8a0a2579e7e10c8), свойство `container` интерфейса `MapboxOptions` в данному случае не потребуется, чтобы исключить его используем [утилитарный тип](https://www.typescriptlang.org/docs/handbook/utility-types.html) `Omit`
* **onCreated** - коллбек вызываемый по событию создания инстанса карты
* **onLoaded** - коллбек вызываемый по событию полной загрузки карты
* **onRemoved** - коллбек вызываемый при удалении инстанса карты
Свойство `container` интерфейса `MapboxOptions` в данному случае не потребуется, чтобы исключить его используем [утилитарный тип](https://www.typescriptlang.org/docs/handbook/utility-types.html) `Omit`
Передадим `initialOptions` в аргументы инициализации веб-карты, используя [spread syntax](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/Spread_syntax#spread_%D0%B2_%D0%BB%D0%B8%D1%82%D0%B5%D1%80%D0%B0%D0%BB%D0%B0%D1%85_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%B0), так же установим обработчик события загрузки карты, если коллбек `onMapLoaded`, устанавливаем только в том случае если он был передан в `props` компонента, аналогично для `onMapRemoved`
```
// ...
const mapboxMap = new mapboxgl.Map({
container: node,
accessToken: process.env.NEXT_PUBLIC_MAPBOX_TOKEN,
style: "mapbox://styles/mapbox/streets-v11",
center: [-74.5, 40],
zoom: 9,
...initialOptions,
});
setMap(mapboxMap);
if (onCreated) onCreated(mapboxMap)
// если onLoaded указан, он будет вызван единожды
// по событию загрузка карты
if (onLoaded) mapboxMap.once("load", () => onLoaded(mapboxMap));
return () => {
mapboxMap.remove();
setMap(undefined);
if (onRemoved) onRemoved();
};
// eslint-disable-next-line react-hooks/exhaustive-deps
}, []);
// ...
```
Тут вы можете заметить специальный комментарий для линтера
```
// eslint-disable-next-line react-hooks/exhaustive-deps
```
Согласно общепринятому правилу `react-hooks/exhaustive-deps` мы должны были указать в списке зависимостей для `React.useEffect` добавленные в хук переменные `[initialOptions, onMapLoaded, onMapRemoved]`
В данном случае важно оставить список зависимостей пустым, это позволит не пересоздавать инстанс карты повторно если `initialOptions` или `onMapLoaded` изменятся, подробнее о использовании `React.useEffect` можно почитать по ссылке ниже
A Complete Guide to useEffect[overreacted.io](https://overreacted.io/a-complete-guide-to-useeffect/)В итоге компонент будет выглядеть так
**components/mapbox-map.tsx**
```
import * as React from "react";
import mapboxgl from "mapbox-gl";
import "mapbox-gl/dist/mapbox-gl.css";
interface MapboxMapProps {
initialOptions?: Omit;
onCreated?(map: mapboxgl.Map): void;
onLoaded?(map: mapboxgl.Map): void;
onRemoved?(): void;
}
function MapboxMap({
initialOptions = {},
onCreated,
onLoaded,
onRemoved,
}: MapboxMapProps) {
const [map, setMap] = React.useState();
const mapNode = React.useRef(null);
React.useEffect(() => {
const node = mapNode.current;
if (typeof window === "undefined" || node === null) return;
const mapboxMap = new mapboxgl.Map({
container: node,
accessToken: process.env.NEXT\_PUBLIC\_MAPBOX\_TOKEN,
style: "mapbox://styles/mapbox/streets-v11",
center: [-74.5, 40],
zoom: 9,
...initialOptions,
});
setMap(mapboxMap);
if (onCreated) onCreated(mapboxMap);
if (onLoaded) mapboxMap.once("load", () => onLoaded(mapboxMap));
return () => {
mapboxMap.remove();
setMap(undefined);
if (onRemoved) onRemoved();
};
// eslint-disable-next-line react-hooks/exhaustive-deps
}, []);
return ;
}
export default MapboxMap;
```
Теперь мы можем переопределять стандартные свойства при создании карты и использовать коллбек `onMapLoaded` по событию ее загрузки. Так же мы можем использовать `onMapLoaded` чтобы сохранить ссылку на инстанс карты например в родительском компоненте. Так же мы можем использовать `onMapRemoved` если нам необходимо узнать что инстанс карты был удален.
Воспользуемся этим, укажем координаты центра карты, а так же добавим начальный экран загрузки карты.
Для начала подготовим компонент `MapLoadingHolder` который будет отображаться поверх карты пока она не загружена.
Для экрана загрузки нам так же потребует `svg` иконка, я ее с [Freepic](https://www.freepik.com), предварительно конвертировав ее в jsx формат с помощью <https://svg2jsx.com/>
**components/world-icon.tsx**
```
function WorldIcon({ className = "" }: { className?: string }) {
return (
);
}
export default WorldIcon;
```
**components/map-loading-holder.tsx**
```
import WorldIcon from "../components/world-icon";
function MapLoadingHolder() {
return (
Initializing the map
====================
Icons made by{" "}
[Freepik](https://www.freepik.com "Freepik") {" "}
from{" "}
[www.flaticon.com](https://www.flaticon.com/ "Flaticon")
);
}
export default MapLoadingHolder;
```
Теперь соберем все вместе, поместим приложение в элемент `.app-container`, внутри которого будут абсолютно позиционированный элемент карты помещенный в `map-wrapper` и компонент `MapLoadingHolder`
Добавим так же компонент `...` в нем можно указать мета-теги и `title` для сайта
**pages/index.tsx**
```
import * as React from "react";
import Head from "next/head";
import MapboxMap from "../components/mapbox-map";
import MapLoadingHolder from "../components/map-loading-holder";
function App() {
const [loading, setLoading] = React.useState(true);
const handleMapLoading = () => setLoading(false);
return (
<>
Using mapbox-gl with React and Next.js
{loading && }
);
}
export default App;
```
Внесем соответсвующие изменения в стили, добавим красивый фон для `.loading-holder`, также позиционируем его содержимое по центру, добавим пульсирующую анимацию для иконки, так как фон полупрозрачный, добавим цветную тень `text-shadow: 0px 0px 10px rgba(152, 207, 195, 0.7);` к элементу `Initializing the map
====================`, подробнее об этом можно прочитать в моем посте про текст на цветном фоне
dqunbp[dqunbp.vercel.app](https://dqunbp.vercel.app/posts/text-stroke)**styles/global.css**
```
html,
body,
#__next {
padding: 0;
margin: 0;
width: 100%;
height: 100%;
font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen,
Ubuntu, Cantarell, "Open Sans", "Helvetica Neue", sans-serif;
}
* {
box-sizing: border-box;
}
.app-container {
width: 100%;
height: 100%;
position: relative;
}
.map-wrapper,
.loading-holder {
position: absolute;
height: 100%;
width: 100%;
top: 0;
left: 0;
bottom: 0;
right: 0;
}
.loading-holder {
background: -webkit-linear-gradient(
45deg,
rgba(152, 207, 195, 0.7),
rgb(86, 181, 184)
);
background: -moz-linear-gradient(
45deg,
rgba(152, 207, 195, 0.7),
rgb(86, 181, 184)
);
background: linear-gradient(
45deg,
rgba(152, 207, 195, 0.7),
rgb(86, 181, 184),
0.9
);
display: flex;
justify-content: center;
align-items: center;
flex-direction: column;
}
.loading-holder .icon {
transform: scale(2);
fill: rgba(1, 1, 1, 0.7);
animation: pulse 1.5s ease-in-out infinite;
}
.loading-holder h1 {
margin-top: 4rem;
text-shadow: 0px 0px 10px rgba(152, 207, 195, 0.7);
}
@keyframes pulse {
0% {
transform: scale(2);
}
50% {
transform: scale(2.3);
}
100% {
transform: scale(2);
}
}
```
Теперь при открытии карты мы увидим симпатичный экран загрузки
Ссылки на исходный код и запущенное приложение
dqunbp/using-mapbox-gl-with-react[github.com](https://github.com/dqunbp/using-mapbox-gl-with-react)Using mapbox-gl with React and Next.js[using-mapbox-gl-with-react.vercel.app](https://using-mapbox-gl-with-react.vercel.app)Хранение инстанса карты вне React
---------------------------------
Про то как хранить и использовать инстанс карты `mapbox-gl` вне `React` я расскажу в своей следующей статье | https://habr.com/ru/post/565636/ | null | ru | null |
# Почему стоит использовать тег <picture> вместо <img>
Использование изображений и анимаций в интерфейсах пользователя стало распространённой практикой в современных веб-приложениях. Хотя эти примеры современного дизайна делают упор на повышение удобства работы с приложениями, если изображения не адаптируются ко всем устройствам, то могут возникать проблемы.
Мы, разработчики, должны удовлетворять потребностям пользователей. Но чаще всего мы упускаем мелочи, способные быть очень важными из-за того, что мы ищем решения на более высоких уровнях.
Выбор между тегами `picture` и `img` может показаться мелким решением, но сделав правильный выбор, вы сможете повысить и удобство для пользователя, и производительность.
В этой статье мы расскажем о различиях между тегами `picture` и `img` и объясним, почему тег `picture` более совершенен, чем `img`.
Когда в следующий раз вы будете создавать компонент изображения на React, то воспользуйтесь полученными в этой статье знаниями. Возвращайте подходящий тег в соответствии с полученными свойствами и обрабатывайте все необходимые альтернативы. Благодаря этому вы получите супероптимизированнй компонент изображения, который можно использовать во всех веб-проектах.
Почему тега *img* недостаточно для современных веб-приложений?
==============================================================
Как все мы знаем, тег Img в течение длительного периода времени был одним из фундаментальных элементов HTML, и никто не сомневался в его простоте и применимости.
Однако с появлением устройств, имеющих разные размеры экрана, разрешения и сложные требования, начали возникать вопросы об отзывчивости этого тега и возможности его использования в приложениях, рассчитанных на множество различных устройств.
Все эти вопросы можно сгруппировать в две большие категории:
1. Смена разрешения — проблема передачи изображений меньшего размера для устройств с маленькими экранами.
2. Ориентация графики — проблема отображения различных изображений при разных размерах экрана.
Давайте посмотрим, как решаются эти проблемы и узнаем о дополнительных возможностях тега `picture`.
Смена разрешения при помощи атрибутов `srcset` и `sizes`
========================================================
Как говорилось выше, современные веб-дизайнеры для привлечения пользователей часто используют изображения высокого разрешения. Но мы, разработчики, должны внимательно выбирать подходящий HTML-элемент.
Допустим, вы используете простой тег `Img` для изображений высокого разрешения. В таком случае при запуске приложения одно и то же изображение будет использоваться на каждом устройстве, что приведёт к проблемам с производительностью в устройствах с низким разрешением экрана, например, в мобильных телефонах.
Это может привести к более долгой загрузке изображений и частичной загрузке изображений сверху вниз.
*Проблема загрузки изображения сверху вниз*
Эту проблему можно легко решить тегом `picture` при помощи атрибутов `srcset` и `sizes`.
```
```
Атрибут `srcset` может принимать несколько изображений с соответствующей шириной в пикселях, а браузер использует эти значения для выбора между указанными изображениями. В показанном выше примере есть три версии одного и того же изображения в трёх разных размерах.
Атрибут `sizes` задаёт пространство, которое изображение будет занимать на экране. В показанном выше примере изображение займёт до 1200px, если минимальная ширина экрана равна 1280px.
Тем не менее, рекомендуется не использовать тег `Picture` только для смены разрешения, потому что ту же задачу можно решить с помощью новой версии тега `Img` (имеющей поддержку большего количества браузеров).
```
```
Однако в большинстве случаев нам нужно решать проблему и смены разрешения, и ориентации графики, и лучшим решением для этого является тег `picture`.
Поэтому давайте посмотрим, как можно решить проблему ориентации графики с помощью тега `picture`.
Ориентация графики при помощи атрибута `media`
==============================================
Основной принцип ориентации графики — показ различных изображений на основании размера экрана устройства. В большинстве случаев, изображение замечательно выглядящее на больших экранах, оказывается обрезанным или очень мелким при просмотре на мобильном устройстве.
Мы можем решить эту проблему, создав различные версии изображения для разных размеров экрана. Эти разные версии могут быть альбомными, портретными или любыми другими изменёнными версиями того же изображения.
С помощью тега `picture` мы можем легко обеспечить смену разрешения, воспользовавшись несколькими тегами `source` внутри тега `picture`.
```
```
Затем можно использовать атрибут `media` для задания различных условий среды, в которых будут использоваться эти источники. Также можно использовать атрибуты `srcset` и `sizes` аналогично тому, о чём мы говорили в предыдущем разделе.
В показанном ниже примере демонстрируется полная реализация ориентации графики и смены разрешения при помощи тега `picture`.
```
```
Если экран находится в альбомной ориентации, то браузер будет отображать изображения из первого набора, а если в портретной, то из второго набора. Кроме того, можно использовать атрибут `media` с параметрами `max-width` и `min-width`:
```
```
Последний тег `img` используется для обратной совместимости с браузерами, не поддерживающими теги `picture`.
Использование с частично поддерживаемыми типами изображений
===========================================================
Благодаря быстрому развитию технологий ежедневно появляется множество современных типов изображений. Некоторые из них, например `webp`, `svg` и `avif`, обеспечивают большее удобство для пользователей.
С другой стороны, у некоторых браузеров существуют ограничения в обработке этих современных типов изображений, и если не использовать совместимые типы изображений, это может вызвать проблемы.
Но мы можем с лёгкостью решить эту проблему при помощи тега `Picture`, поскольку он позволяет нам указать внутри несколько источников.
```
```
В показанный выше пример включены три типа изображений в форматах `avif`, `webp` и `png`. Сначала браузер попробует формат `avif`, если не получится, то попробует `webp`. Если браузер не поддерживает ни один из них, то использует изображение `png`.
Ситуация с тегом `picture` стала ещё интереснее, когда разработчики Chrome объявили о том, что «во вкладке Rendering инструментов DevTools появится две новые эмуляции для эмулирования частично поддерживаемых типов изображений».
Начиная с Chrome 88 и далее можно использовать Chrome DevTools для проверки совместимости браузера с типами изображений.
*Использование Chrome DevTools для эмулирования совместимости изображений*
В заключение
============
Хоть мы и говорили о том, насколько лучше тег `picture` по сравнению с тегом `img`, я уверен, что `img` не умер и умрёт ещё не скоро.
Если мы будем с умом использовать имеющиеся у него атрибуты `srcset` и `size`, то можем выжать из тега `img` максимум. Например, можно решить проблему смены разрешения при помощи одного только тега `img`.
С другой стороны, можно использовать тег `picture`, чтобы решить проблемы и смены разрешения, и ориентации графики с помощью запросов условий среды и других атрибутов.
Среди прочих достоинств тега `picture` способность работать с частично поддерживаемыми типами изображений и поддержка Chrome DevTools.
Однако оба эти элемента имеют свои плюсы и минусы. Поэтому нам нужно обдумывать и выбирать наиболее подходящий к нашим требованиям элемент.
---
#### На правах рекламы
**Эпичные серверы** — это [VDS для размещения сайтов](https://vdsina.ru/cloud-servers?partner=habr358) от маленького интернет-магазина на Opencart до серьёзных проектов с огромной аудиторией. Создавайте собственные конфигурации серверов в пару кликов!
Подписывайтесь на [наш чат в Telegram](https://t.me/vdsina).
[](https://vdsina.ru/cloud-servers?partner=habr358) | https://habr.com/ru/post/555736/ | null | ru | null |
# Модификаторы private и private[this] в Scala
В Scala, помимо обычного модификатора доступа private существует также модификатор private[this]. Эти два модификатора довольно похожи друг на друга. К тому же в Java есть только простой private. Поэтому они легко могут вызвать путаницу или убежденность, что простой private — не такой уж и приватный, и везде надо использовать private[this] для пущей защищенности. Но давайте разберемся, как дела обстоят на самом деле.
В статье, для краткости, я буду в основном использовать термин *приватная переменная*. Но фактически, это будет означать *приватное свойство класса или приватный метод класса.*
#### private
Начнем с обычного private. Давайте посмотрим, какой уровень защищенности он нам предоставляет. Проще всего это проверить на примерах. Для запуска кода я использовал scala workseet в Intellij IDEA. Моя версия Scala — 2.11.7.
Допустим, у нас есть класс WithPrivate с приватным полем myPrivateVal и методом, который возвращает значение этого поля:
```
class WithPrivate {
private val myPrivateVal = 5
def show = myPrivateVal
}
```
Попробуем вызвать метод show:
```
val a = new WithPrivate
a.show
```
И видим результат:
> res0: Int = 5
Все как и ожидалось — **можно использовать приватное свойство внутри класса**.
Теперь попробуем обратиться к приватной переменной извне класса:
```
val a = new WithPrivate
a.myPrivateVal
```
Компилятор выдает ошибку:
> Error:(9, 4) value myPrivateVal in class WithPrivate cannot be accessed in A$A86.this.WithPrivate
То есть **мы не можем обратиться к приватной переменной извне класса**.
Проверим, как ведут себя наследники. Попробуем обратиться к приватной переменной внутри наследника:
```
class B extends WithPrivate {
def usePrivate = {
myPrivateVal
}
}
```
Видим ошибку:
> Error:(8, 6) not found: value myPrivateVal
Снова ожидаемый результат — **мы не можем использовать приватные переменные в наследниках**.
Попробуем переопределить приватную переменную в наследнике:
```
class C extends WithPrivate {
override val myPrivateVal = 10
}
```
И снова ошибка:
> Error:(22, 17) value myPrivateVal overrides nothing
Получается, что так делать нельзя. Но что если убрать override:
```
class D extends WithPrivate {
val myPrivateVal = 10
}
val d = new D
d.show
```
В консоли видим:
> res0: Int = 5
То есть переопределения не получилось. Мы просто создали переменную с таким же именем в наследнике. Таким образом, **переопределить приватную переменную в наследнике мы тоже не можем.**
Как видите, поведение модификатора private соответствует тому, как он ведет себя в Java. То есть мнение о том, что обычный private не слишком приватный — ошибочно. Обычный private как минимум обеспечивает такой же уровень закрытости, что и private в Java.
#### private[this]
Следующий на очереди — private[this]. Но перед его рассмотрением я хотел бы напомнить, что вообще означает такая запись:
```
class A {
private[XXX] val someXxxVal = 5
}
```
На месте XXX может быть:
1. *Имя пакета*. В этом случае все классы из пакета XXX имеют доступ к someXxxVal. Эту фичу довольно часто используют внутри библиотек, когда хотят, чтобы свойство или метод были видны только внутри библиотеки и не торчали наружу. Еще это может быть полезно, чтобы добираться до внутреннего состояния объекта в юнит тестах.
2. *Имя класса/объекта*. В этом случае класс/объект XXX будет иметь доступ до someXxxVal.
3. *this*. О нем далее.
Теперь давайте посмотрим, как же ведет себя private[this]. Самый простой способ — применить те же тесты, которые мы уже использовали для обычного private. Не буду снова расписывать каждый случай по отдельности, просто приведу общий листинг:
```
class WithPrivateThis {
private[this] val myPrivateVal = 5
def show = myPrivateVal
}
val a = new WithPrivateThis
// использование приватной переменной внутри класса
a.show
// попробуем обратиться к приватной переменной извне класса
a.myPrivateVal
// попробуем обратиться к приватной переменной внутри наследника
class B extends WithPrivateThis {
def usePrivate = {
myPrivateVal
}
}
// попробуем переопределить приватную переменную в наследнике
class C extends WithPrivateThis {
override val myPrivateVal = 10
}
// попробуем переопределить приватную переменную в наследнике без override
class D extends WithPrivateThis {
val myPrivateVal = 10
}
val d = new D
d.show
```
Если запустить этот код, то можно убедиться, что эти тесты показывают абсолютно аналогичные результаты. То есть **private[this] в данных тестах показывает такое же поведение, что и обычный private**. Но если результаты одинаковые, то зачем вообще нужен private[this]?
#### Но у нас же Scala, а не Java
Дело в том, что тесты, приведенные выше, покрывают только случаи, которые исходят из поведения private в Java. Но для Scala это не все случаи использования private.
Давайте посмотрим на следующий пример:
```
object WithPrivate {
def foo = (new WithPrivate).myPrivateVal
}
class WithPrivate {
private val myPrivateVal = 5
}
WithPrivate.foo
```
Тут мы создали companion object для нашего класса и используем приватную переменную внутри него. Этот пример нормально скомпилируется и покажет результат:
> res0: Int = 5
Попробуем тоже самое с private[this]:
```
object WithPrivateThis {
def foo = (new WithPrivateThis).myPrivateVal
}
class WithPrivateThis {
private[this] val myPrivateVal = 5
}
WithPrivateThis.foo
```
В этом примере компилятор ругнется:
> Error:(13, 36) value myPrivateVal is not a member of A$A113.this.WithPrivateThis
Вот и первое отличие — **в случае с private[this] мы не можем использовать переменную в companion object**. Объект не может получить доступ до myPrivateVal.
Теперь посмотрим на такой случай. Допустим, у нас есть какой-то метод в нашем классе, который на вход принимает экземпляр такого же класса. Что если мы обратимся к приватной переменной в этом объекте?
```
class WithPrivate {
private val myPrivateVal = 5
def withThat(that: WithPrivate) = {
that.myPrivateVal
}
}
val a = new WithPrivate
val b = new WithPrivate
b.withThat(a)
```
В методе withThat мы пытаемся достучаться до приватной переменной другого экземпляра (that) этого же класса (WithPrivate).
Если запустить этот код то вы увидите ожидаемый результат:
> res0: Int = 5
Такой прием часто используется, например, в equals. Если опустить, что у нас myPrivateVal одинаковый для всех экземпляров класса WithPrivate, то для него equals мог бы выглядеть следующим образом:
```
override def equals(obj: Any) = obj match {
case that: WithPrivate ⇒ this.myPrivateVal == that.myPrivateVal
case _ ⇒ false
}
```
Теперь давайте попробуем тоже самое с private[this]:
```
class WithPrivateThis {
private[this] val myPrivateVal = 5
def withThat(that: WithPrivateThis) = {
that.myPrivateVal
}
}
val a = new WithPrivateThis
val b = new WithPrivateThis
b.withThat(a)
```
И что мы видим? Ошибку!
> Error:(21, 11) value myPrivateVal is not a member of A$A151.this.WithPrivateThis
То есть **компилятор не дает нам использовать приватную переменную с private[this] из другого объекта в этом же классе**. И мы не сможем реализовать equals способом, представленным выше для класса WithPrivate.
#### В итоге
Если обобщить два предыдущих примера, то можно сказать, что обычный private можно рассматривать как private[ThisClass], где ThisClass — это класс, в котором объявлена приватная переменная. То есть уровень видимости ограничен текущим классом/объектом. Все экземпляры класса ThisClass и companion object этого класса будут видеть эту приватную переменную.
private[this] следует рассматривать как приватность на уровне конкретного экземпляра класса. То есть мы сможем обратиться к приватной переменной только внутри текущего экземпляра класса. Ни другие эклемпляры класса, ни companion object не имеют доступа до такой приватной переменной. Можно сказать, что private[this] — это более строгий вариант обычного private.
В каких же случаях какой модификатор использовать? Я стараюсь руководствоваться следующими правилами:
* Если у вас мутабельная приватная переменная, которая хранит какое-то состояние, то лучше сделать ее private[this]. Это не даст другим экземплярам класса или компаньону поменять состояние этой переменной, что иногда может быть фатально для общего состояния объекта.
* Если у вас метод, вызов которого меняет состояние объекта, лучше также сделать его private[this].
* Во всех остальных случаях использовать обычный private.
В заключение хочу добавить, что в обычном проекте почти всегда хватает простого private. Если писать код внимательно, то private[this] можно вообще не использовать. Не так много классов имеют методы, которые на вход принимают экземпляры этого же класса. Да и кто будет в таких методах вызывать деструктивные приватные методы или менять приватное состояние в других объектах? То есть если везде пытаться обезопасить себя, обкладываясь private[this], то это может просто не пригодиться при должном уровне дисциплины в коде. При этом активное использование private[this] может быть очень полезно внутри библиотек. | https://habr.com/ru/post/267305/ | null | ru | null |
# Как и зачем собирать Android приложение в docker контейнере
Добрый день, уважаемые читатели.
Я - Владимир, меня зовут девопс. Говорят, что девопс - это болезнь и я это вам сегодня докажу.
Ответа на вопрос "зачем?" вы тут не найдете, это кликбейт, я и сам не знаю. Все происходящее мотивируется девизом "бикоз ай кен".
Если без шуток, то можно прогонять процесс сборки, создавать изолированные тест-кейсы, прогонять через автотесты, SonarQube и прочие SAST-ы
Итак. Дано. Один безумный девопс, один несчастный андроид-разработчик, собирающий апк локально. Ситуация, увы, распространенная.
Часть 1. Dockerfile. Как собрать
--------------------------------
Как решаем. Пишем Dockerfile для дела и Jenkinsfile для понтов, сегодня речь только про Dockerfile.
Для успешного процесса нужно ~~смазать~~ вытащить из разработчика окружение, в котором вся эта радость собирается. Нас интересует версии gradle, jdk, android sdk
Удобнее всего собирать готовым официальным образом <https://hub.docker.com/_/gradle>
При выборе образа обратите внимание на версию gradle и java, gradle имеет debian корни, так что apt-get java на случай, если версии нет готовой. Создаем в корне репы Dockerfile и начинаем его заполнять:
Сразу проверяем, сходятся ли версии gradle и java
```
FROM gradle:6.1.1-jdk11
RUN java -version
RUN gradle -v
```
т..к. Dockerfile лежит в корне репозитория, копируем содержимое в контейнер
```
RUN mkdir /opt/project
COPY . /opt/project
WORKDIR /opt/project
```
Два из трех есть - gradle и jdk установлены, ставим androidsdk.
Есть один нюанс. Для andriodsdk нужно вытащить архивчик с оным. Можно скурлить последнюю версию, а можно ручками [смотреть тут](https://developer.android.com/studio#command-tools).
Как девопс - я бы не хотел возвращаться к обновлению окружения руками, однако могут быть неприятные сюрпризы с новыми версиями androidsdk. Да и не всегда есть нужда в использовании latest. Так что просто укажем имя архива в переменной
```
ARG ANDROID_SDK_VERSION=8092744
ENV ANDROID_SDK_ROOT /opt/android-sdk
```
Скачиваем архив, распаковываем, чистим мусор
```
RUN mkdir -p ${ANDROID_SDK_ROOT}/cmdline-tools && \
wget https://dl.google.com/android/repository/commandlinetools-linux-${ANDROID_SDK_VERSION}_latest.zip && \
unzip *tools*linux*.zip -d ${ANDROID_SDK_ROOT}/cmdline-tools && \
mv ${ANDROID_SDK_ROOT}/cmdline-tools/cmdline-tools ${ANDROID_SDK_ROOT}/cmdline-tools/tools && \
rm *tools*linux*.zip
```
То чувство, когда не успевал начать, а уже почти все готово.
Указываем PATH для androidsdk, куда полезет gradle
```
ENV PATH ${PATH}:${ANDROID_SDK_ROOT}/cmdline-tools/latest/bin:${ANDROID_SDK_ROOT}/cmdline-tools/tools/bin:${ANDROID_SDK_ROOT}/platform-tools:${ANDROID_SDK_ROOT}/emulator
```
Обратите внимание на вторую строчку, где отдельно указаны пакеты androidsdk
В ранних версиях было достаточно установить androidsdk, сейчас же нужно отдельно ставить пакеты\платформы\самовары\блудниц. Никто не мешает поставить сразу весь фарш, нооо...
Но чувство прекрасного говорит, что надо только то, что надо. Как определить какие пакеты собсна нужны? об этом ниже про нюансы
```
RUN yes | sdkmanager --licenses && \
sdkmanager "platforms;android-29" "platforms;android-30" "platforms;android-31" "build-tools;29.0.2" && \
cd /opt/project
```
Ну и последнее, творим магию
```
RUN gradle build
```
Целиком прекрасный Dockerfile
Dockerfile
```
FROM gradle:6.1.1-jdk11
RUN mkdir /opt/project
COPY . /opt/project
WORKDIR /opt/project
ARG ANDROID_SDK_VERSION=8092744
ENV ANDROID_SDK_ROOT /opt/android-sdk
RUN mkdir -p ${ANDROID_SDK_ROOT}/cmdline-tools && \
wget https://dl.google.com/android/repository/commandlinetools-linux-${ANDROID_SDK_VERSION}_latest.zip && \
unzip *tools*linux*.zip -d ${ANDROID_SDK_ROOT}/cmdline-tools && \
mv ${ANDROID_SDK_ROOT}/cmdline-tools/cmdline-tools ${ANDROID_SDK_ROOT}/cmdline-tools/tools && \
rm *tools*linux*.zip
ENV PATH ${PATH}:${ANDROID_SDK_ROOT}/cmdline-tools/latest/bin:${ANDROID_SDK_ROOT}/cmdline-tools/tools/bin:${ANDROID_SDK_ROOT}/platform-tools:${ANDROID_SDK_ROOT}/emulator
RUN yes | sdkmanager --licenses && \
sdkmanager "platforms;android-29" "platforms;android-30" "platforms;android-31" "build-tools;29.0.2" && \
cd /opt/project
RUN gradle build
```
Теперь про нюансы.
------------------
* 1. Как определить пакеты sdkmanager, необходимые к установке?
Можно посмотреть в студии\спросить разраба. скорее всего будет уйма ненужного, так что вариант корнями ведущий в беспощадный ру-девелоп.
последовательно запускаем gradle build без пакетов sdkmanager-a, смотрим, на что ругается - ставим (т.е. добавляем пакеты в строчку 17), повторять до полного самоудовлетворения.
* 2. Как вытащить итоговый apk?
Можно присобачить юзера и volume в Dockerfile, самое очевидное.
Но на мой взгляд есть изящное решение в виде Jenkinsfile, т.к. он чуть более, чем полностью состоит из sh, можно делать то же самое, но руками:
Смысл такой, что
- создаем образ (!) из Dockerfile
docker build .
- контейнер закончил работать и закрылся
статус = exited
- запускаем контейнер с командой, которая сможет продолжить его работу.
docker start build\_apk sleep infinity
- вытаскиваем всю эту радость докером и убираем хвосты
docker cp build\_apk:/path/to/apk/in/docker/container/\*.apk /path/to/home/dir && /
docker stop build\_apk && docker rm build\_apk
```
docker build . -t build_apk
docker run -d build_apk sleep infinity
docker cp build_apk:/path/to/apk/in/docker/container/*.apk /path/to/home/dir
docker stop build_apk && docker rm build_apk
```
Кто то скажет "фу, костыль" и будет прав. Но это решение не претендует на истину в последней инстанции. Это простой и легкий в освоении вариант, который решает тактическую задачу
* 3. Что делать, если мы за прокси?
для wget добавляем ключ "--no-check-certificate"
для sdk manager добавляем ключи "--proxy=http --proxy\_host= --proxy\_port="
```
RUN mkdir -p ${ANDROID_SDK_ROOT}/cmdline-tools && \
wget https://dl.google.com/android/repository/commandlinetools-linux-${ANDROID_SDK_VERSION}_latest.zip --no-check-certificate && \
unzip *tools*linux*.zip -d ${ANDROID_SDK_ROOT}/cmdline-tools && \
mv ${ANDROID_SDK_ROOT}/cmdline-tools/cmdline-tools ${ANDROID_SDK_ROOT}/cmdline-tools/tools && \
rm *tools*linux*.zip
RUN yes | sdkmanager --licenses --proxy=http --proxy_host= --proxy\_port=&& \
sdkmanager --proxy=http --proxy\_host= --proxy\_port= && \
cd /opt/project
```
Не забываем прописать прокси в gradle.properies
```
systemProp.http.proxyHost=
systemProp.http.proxyPort=
systemProp.https.proxyHost=
systemProp.https.proxyPort=
#сходу бонус
#чтобы сборка не обжирались и не падала с ошибкой "плак плак, хатю память"
#выставим ограничение
org.gradle.jvmargs=-Xmx2048m -Dkotlin.daemon.jvm.options\="-Xmx2048M" -XX:MaxPermSize=4096m
```
Если тянем с либы корпоративного репо - то и не забываем указать его же в build.gradle в двух местах!!
```
repositories {
mavenCentral { url "https://corp.repo.example.ru/repository/maven-central/" }
jcenter { url "https://corp.repo.example.ru/repository/jcenter/" }
google { url "https://corp.repo.example.ru/repository/dl.google.com-android/" }
}
allprojects {
repositories {
mavenCentral { url "https://corp.repo.example.ru/repository/maven-central/" }
jcenter { url "https://corp.repo.example.ru/repository/jcenter/" }
google { url "https://corp.repo.example.ru/repository/dl.google.com-android/" }
}
}
```
P.S. Интрига
------------
*Мы ж тут про девопс, а потому мы хотим ~~смузи и женщин~~ автоматизацию.а потому хотим, чтобы после коммита в репу запускалась сборка и итоговая апк вываливалась в какой-никакой общий доступ.Как это сделать красиво - в следующей статье) про простейший nginx и JenkinsТам будет про вывалить версию в версию. Короче, интрига.* | https://habr.com/ru/post/667006/ | null | ru | null |
# Букмарклеты: если XPath недоступен, а селекторов и методов навигации по DOM не хватает
Недавно я пытался написать несколько условно кроссбраузерных букмарклетов с выборками и навигацией средней сложности. Решил ограничиться последними версиями Google Chrome, Firefox и Internet Explorer. Приступив к проверке в последнем браузере, с грустью обнаружил, что даже в IE 11 всё ещё нет поддержки `XPath`.
Вроде бы полная поддержка [обещана в Edge](https://msdn.microsoft.com/en-us/library/ff405926(v=vs.85).aspx): «Microsoft Edge supports the XML Path Language Version 1.0 with no variations or extensions». И уже даже, кажется, реализация [добавлена](https://status.modern.ie/domlevel3xpath?term=XPath) в Internet Explorer Developer Channel ([никто не проверял](https://msdn.microsoft.com/en-us/library/dn722334(v=vs.85).aspx)?). Но это пока недостаточное утешение.
(P.S. Проверка через [виртуальную машину](http://blogs.windows.com/msedgedev/2015/08/17/windows-10-virtual-machines-now-available-on-microsoft-edge-dev/) подтверждает реализацию `XPath` в MS Edge версии 11.00.10240.16397 от 7.22.2015 (по версии файла), она же 20.10240.16384.0 (по информации в настройках)).
Следующим шагом стало обнаружение [библиотеки от Google](https://github.com/google/wicked-good-xpath). Я даже для очистки совести проверил способ с вживлением библиотеки на странички в IE 11 ([по описанному здесь методу](http://habrahabr.ru/company/theonlypage/blog/234427/)) — всё замечательно работает даже на параноидальных сайтах вроде Твиттера (к слову, если вы вдруг не знали, в Firefox всё ещё нельзя запустить букмарклет в Твиттере или, например, в Гитхабе, из-за [до сих пор не исправленного бага](https://bugzilla.mozilla.org/show_bug.cgi?id=866522)). Но метод этот очень громоздкий. Он хорошо подходит для разработки сайтов, но маленькие пользовательские букмарклеты он отягощает лишней асинхронностью, усложнением логики и дополнительным временем на загрузку файла.
Пришлось искать более простые замены для некоторых не хватавших мне инструментов `XPath`.
При этом я старался воздерживаться от некоторых полезных новых методов, которые всё ещё не кроссбраузерны (вроде [`Element.closest()`](https://developer.mozilla.org/en-US/docs/Web/API/Element/closest), для которого, впрочем, есть [полифил](https://github.com/jonathantneal/closest)).
При поиске готовых решений некоторых проблем я натыкался на довольно большие куски кода с циклами, которые трудно было считать компактной заменой. Поэтому я создал на первое время маленький набор небольших функций, который хотелось бы предложить для обсуждения. Дело в том, что я не профессиональный программист, скорее любопытный пользователь, и очень бы не хотелось изобретать уродливый велосипед. Поэтому, если вам известны какие-то более компактные и изящные полифилы, которые можно использовать в небольших букмарклетах, пожалуйста, поделитесь. Если будут идеи, как усовершенствовать эти функции, тоже буду благодарен за советы.
Пока их всего шесть, для тех конкретных возможностей `XPath`, которых мне не хватило. Функции не очень удобны в использовании, для них хорошо было бы реализовать чейнинг (возможность цепочек вызовов), но, насколько я слышал, расширять `DOM` небезопасно, поэтому добавлять их в `Element.prototype` я не решился.
**1. Замена для `/following-sibling::subject[predicate]`**
Скажем, у нас есть дерево элементов:
```
...
...
...
```
И нам нужно добраться от первого `p` до неизвестно какого по счёту соседнего `p` с нужным классом. Можно организовать цикл с проверками всех соседей. А можно всё сделать в условное одно касание. Создаём функцию:
```
function findNextSibling(startNode, endSelector) {
return [].filter.call(document.querySelectorAll(endSelector), function(el) {
return startNode.parentNode === el.parentNode &&
startNode.compareDocumentPosition(el) & Node.DOCUMENT_POSITION_FOLLOWING;
}).shift();
}
```
И потом можем вызывать её вот так:
```
var from = document.querySelector('#point-of-view');
var to = findNextSibling(from, 'p.target')
```
Возможно, это не лучшее решение с точки зрения быстродействия и потребляемых ресурсов (создание и обход больших временных коллекций и массивов), но с точки зрения компактности и удобства, мне кажется, терпимо. Тем более что букмарклеты часто применяются для небольших однократных действий, для которых экономия времени и ресурсов не так критична.
**2. Замена для `/preceding-sibling::subject[predicate]`**
То же самое в обратном порядке (и возвращать будем уже последний элемент массива, он же ближайший из предшествующих):
```
...
...
...
```
```
function findPrevSibling(startNode, endSelector) {
return [].filter.call(document.querySelectorAll(endSelector), function(el) {
return startNode.parentNode === el.parentNode &&
startNode.compareDocumentPosition(el) & Node.DOCUMENT_POSITION_PRECEDING;
}).pop();
}
```
```
var from = document.querySelector('#point-of-view');
var to = findPrevSibling(from, 'p.target')
```
**3. Замена для `/following::subject[predicate]`**
Это задание вроде бы сложнее предыдущего (не так легко обычными способами получить коллекцию элементов, последующих за данным элементом в порядке прямого обхода `DOM`, независимо от отношений иерархии), но реализация по нашему методу будет проще, минус одно условие.
```
...
...
...
...
```
```
function findNext(startNode, endSelector) {
return [].filter.call(document.querySelectorAll(endSelector), function(el) {
return startNode.compareDocumentPosition(el) & Node.DOCUMENT_POSITION_FOLLOWING;
}).shift();
}
```
```
var from = document.querySelector('#point-of-view');
var to = findNext(from, 'p.target')
```
**4. Замена для `/preceding::subject[predicate]`**
В обратном направлении, возвращая последний элемент массива предшествующих элементов:
```
...
...
...
...
```
```
function findPrev(startNode, endSelector) {
return [].filter.call(document.querySelectorAll(endSelector), function(el) {
return startNode.compareDocumentPosition(el) & Node.DOCUMENT_POSITION_PRECEDING;
}).pop();
}
```
```
var from = document.querySelector('#point-of-view');
var to = findPrev(from, 'p.target')
```
**5. Замена для `/ancestor-or-self::subject[predicate]`**
Эта ось часто используется для нахождения нужного инициатора события, поднимающегося снизу вверх, а также для других корректировок (например, нужно добраться до определённого элемента от значения `getSelection().focusNode`, поскольку это свойство часто соответствует текстовому узлу). Можно было бы воспользоваться упомянутым полифилом для `Element.closest()`, но ради единообразия я добавил функцию в стиле предыдущих.
Для обоих случаев функция вернёт один и тот же элемент:
```
[`**ссылка**`](#target)
```
```
[ссылка](#target)
```
```
function findClosestAncestorOrSelf(startNode, endSelector) {
return [].filter.call(document.querySelectorAll(endSelector), function(el) {
return startNode.compareDocumentPosition(el) & Node.DOCUMENT_POSITION_CONTAINS ||
startNode === el;
}).pop();
}
```
```
var from = document.querySelector('#point-of-view');
var to = findClosestAncestorOrSelf(from, 'a')
```
**6. Замена для `/descendant::subject[node-predicate]`**
Это временная упрощённая замена грядущему селектору CSS4 [`:has()`](http://dev.w3.org/csswg/selectors-4/#relational), который всё ещё [не поддерживается ни одним](http://css4-selectors.com/selector/css4/relational-pseudo-class/) из браузеров, [угу](http://css4.rocks/selectors-level-4/relational-pseudo-class.php).
Например, нужно выбрать ссылку, которая содержит элемент `code`, вот такую:
```
...
[просто ссылка](#target)
...
[`ссылка на объяснение свойства или метода`](#target)
...
```
Аргументов прибавится, но всё равно ничего сложного:
```
function findByDescendant(contextNode, subjectSelector, predicateSelector) {
return [].filter.call(contextNode.querySelectorAll(subjectSelector), function(el) {
return el.querySelector(predicateSelector);
}).shift();
}
```
```
var scope = document.querySelector('#point-of-view');
var target = findByDescendant(scope, 'a', 'code')
```
Если немного подредактировать этот метод (убрать конечное `.shift()`), им можно будет получать массивы нужных элементов, а если в качестве `contextNode` задавать `document`, то выборка будет делаться из всего документа.
Вот и всё. Спасибо за потраченное время и простите за возможные ошибки. | https://habr.com/ru/post/262853/ | null | ru | null |
# Управляем Rhythmbox'ом по ssh
Казалось бы, чего тут сложного. Даже сам rhythmbox обладает программой-спутником rhythmbox-client, которая принимает аргументом простые команды утравления этим замечательным проигрывателем. Но не всё так просто, как хотелось бы. При заходе по ssh на удалённую машину, на которой играет rhythmbox и вызыве этой самой программы, например так:
> `user@host:~$ rhythmbox-client --play
>
> (rhythmbox-client:32434): Rhythmbox-WARNING **: dbus-launch failed to autolaunch D-Bus session: Autolaunch error: X11 initialization failed.`
мы видим не самое приятное сообщение. Как минимум, у нас не получается инициализировать Х11.
А мы всего-то и хотели, что включить play в уже запущенном rhythmbox. Хотя мы могли сделать много чего, например:
>
> ```
> user@host:~$ rhythmbox-client --help
> Использование:
> rhythmbox-client [OPTION...]
>
> Опции:
> -?, --help Показать помощь (опции)
>
> Опции Приложения:
> --debug
> --no-start Не запускать новую копию rhythmbox
> --quit Выйти из Rhythmbox
> --no-present Не представлять существующее Rhythmbox окно
> --hide Спрятать Rhythmbox окно
> --next Следующая песня
> --previous Предыдущая песня
> --notify Показать уведомление о текущей песни
> --play Продолжить проигрывание
> --pause Пауза
> --play-pause Переключиться между паузой и проигрыванием
> --play-uri=URI to play Проиграть указанный URI, импортировать его если необходимо
> --enqueue Добавить трек в очередь проигрывания
> --clear-queue Очистить очередь проигрывание перед добавлением трека
> --print-playing Вывести название трека и имя исполнителя текущей композиции
> --print-playing-format Вывести форматированную информацию о треке
> --set-volume Установить громкость (1.0 макс)
> --volume-up Увеличить громкость
> --volume-down Уменьшить громкость
> --print-volume Вывести текущую громкость
> --mute Отключить звук
> --unmute Включить звук
> ```
>
Как видно из списка — опций не то, что бы уж очень много. Скажем, нету переключателя между повтором и случайным/последовательным списком треков. Но это базовый набор команд, которого вполне может хватить, что бы переключить уже порядком поднадоевший трек, к которому всё никак не дотянуться руки стереть вообще с винчестера.
Если, ради эксперимента, мы подключим виртуальный X11 с передачей его по ssh, это делается просто заходом на удалённый host с опцией -X. Т.е. приложение целиком будет выполняться на удалённом хосте (host), а вам по ssh будут передаваться и отрисовываться примитивы X11.
> `user@localhost:~$ ssh -X user@host`
Но таким образом тоже не получается управлять rhythmbox'ом. Просто вызывается копия программы, которая (при слабом канале) будет жутко долго отрисовываться на вашем компьютере, с которого вы делали ssh. Т.е. задача сводиться к тому, что бы запустить rhythmbox и потом управлять им из rhythmbox-client из одного X11 дисплея. Я ~~знаю~~ знал, пожалуй, только один способ как это сделать — запустить всё через screen, который дальше будет висеть, а мы зайдя по ssh сможем подключиться к нему и управлять запущенным rhythmbox'ом. Сейчас же, как подсказал в комментариях уважаемый [KeksSW](https://habrahabr.ru/users/kekssw/), можно запустить команду с переменной окружения DISPLAY=:0, и тогда без проблем выполниться клиентская часть и действительно можно просто управлять rhythmbox'ом по ssh без трюков, которые я дальше рассписываю. Они могут понадобиться если вы решили просто команды управления запихнуть в shortcut'ы.
И так, продолжим.
Потестив весь вышеизложенный план в консоле и убедившись, что всё работает так как и запланировано, пришло время наводить красивости. Например, что бы вызвать не активную сессию screen, с запущенным из неё rhythmbox, нужно выполнить такую вот команду:
> `user@host:~$ /usr/bin/screen -D -m -S box rhythmbox-client`
Два пояснения, я указал прямой путь до screen'а, т.к. у вас он может быть установлен в другое место, или если вы его собирали сами (… хотя тогда я сомневаюсь, что данная публикация будет Вам вообще интересна =). И при отсутствии запущенного rhythmbox'а запуск rhythmbox-client'а приведёт к старту самого проигрывателя (по крайней мере так было у меня на Ubuntu 9.04).
Ну не запускать же каждый раз ручками проигрыватель, правда? Можно написать альяс, который будет это делать. Но если уж совсем по-ленивому, то можно сделать иконку launcher'а на GNOME'вской понельке. И тогда для запуска самого проигрывателя потребуется только лениво дотянуться до мышки, лениво же подвинуть указатель на иконку, ну и уж совсем из последних сил просто восхищаясь своим упорством и целеустремлённостью — кликнуть на неё один раз ( тут главное не перетрудиться… Зачем щёлкать два раза, это же почти в два раза больше работы, так?).
При этом создаётся сессия screen с именем *box*, в нём запускается rhythmbox-client, и сессия деаттачиться (отсоединяется, если быть совсем точным, то она никогда и не присоединяется, а так и возникаем в пассивном режиме).
Пожалуй, самым простым способом создать иконку на панельке является перетаскивание из меню Applications (Приложения) самой иконки rhythmbox'а на панель. Так Вам не придётся мучиться с выбором картинки, а останется только поменять строку кода выполнения на указанный выше. И мы готовы к запускам проигрывателя в отдельной screen сессии.
Далее ещё более интересный трюк. Нам необходимо с другого компьютера зайти на наш host с запущенным на нём rhythmbox'ом и отослать команду в сессию screen'а, по возможности не интерактивно, а совсем даже наоборот, пассивно (через pipe или опцией к screen).
Man screen'а утверждает, что опция -X должна отослать сессии команду на выполнение. Как я не выкручивался — у меня не получалось этого сделать. Пока умные товарищи на linux.org форуме не подсказали, что эта опция передаётся с ещё одним дополнительным аргументом. Например если набрать:
> `user@host:~$ screen -r box -X stuff а тут какой-то совсем странно-непонятный текст для сессии скрина`
то этот текст просто передастся в сессию, как будто вы набирали его с клавиатуры. Но нажать кнопочку Enter за лично Вас так не получиться. Но можно отослать вместо stuff опцию на выполнение команды. И как не сложно догадаться опция будет называться exec. Т.е. в конечном итоге, команда для запуска с локальной машины для изменения трека на следующий на удалённом хосте будет такой:
> `user@host:~$ ssh user@host screen -r box -X exec rhythmbox-client --next`
А можно ещё и присвоить эту команду какой-нибудь быстрой клавише. У меня на Vostro 1500 на передней панеле имеется набор медиа-клавиш, которые я почти не использую на самом компьютере, поэтому решил на них и повесить нужные мне команды.
В принципе это уже всё. Можно только добавить, что если вы не сделали этого раньше, то разрешите доступ к удалённому хосту по ssh без введения пароля каждый раз. Это можно сделать следующим образом:
> `user@host:~$ ssh-copy-id user@host`
У Вас запросится пароль пользователя на удалённом компьютере. Если у Вас уже сгенерированный ключи, то public key будет скопирован с локальной машины в authorized\_keys файл на удалённой машине. Если же выдалась ошибка об отсутствии ключей — можно их быстро создать:
> `user@host:~$ ssh-keygen`
и далее по инструкции. Passphrase лучше не задавать. Так как потом придётся её вводить каждый раз.
На этом всё. Спасибо за внимание.
ЗЫ: надеюсь мой рабочий комп потянет нагрузку с отдачей картинок для хабра. И что бы он это делал не зря, вот динамически прорисовываемая картинка о доступе к контенту на главной и после хабраката. Знаю, что пару дней назад уже один молодой человек что-то подобное мастерил, но я преследую свои цели, да и графики, если честно, были там не ахти. Пока не был включён фильтр по IP, т.е. многократный доступ считается разными посещениями. Далее думаю добавить фильтрацию — это даст лучшее представление о картине происходящего.
ЗЫЫ: После трёх проведённых часов за этим постом понимаю — что единственно ценным в нём является скрипт, рисующий картинку просмотра с главной страницы хабра и число просмотров от людей таки заглянувших под хабракат. Рейтинг получился очень не высоким, но и не упрыгал в минуса. Значит мы получаем очень хорошую точку для статистического анализа. Т.е. многие картинку, количество запросов к которой я и считал, получали через RSS'ы или просто быстро просматривая хабр с утра… можно получить интересную статистику, если собрать такую же информацию с «удачного» топика. Но это в следующий раз, если повезёт =)
ЗЫЫЫ: Ну пожалуй всё. Скрипт, рисующий статистику посещения довёл до состояния бетты. Т.е. он рисует количество запросов в минуту. Как видно, можно отследить попадание поста на главную, отход на вторую страницу и т.д. Здорово! | https://habr.com/ru/post/74544/ | null | ru | null |
# Шаблон Kotlin микросервисов
Для разработчиков не секрет, что создание нового сервиса влечет за собой немало рутиной настройки: билд скрипты, зависимости, тесты, docker, k8s дескрипторы. Раз мы выполняем эту работу, значит текущих шаблонов IDE недостаточно. Под катом мои попытки автоматизировать все до одной кроссплатформенной кнопки "сделать хорошо" сопровождаемые кодом, примерами и финальным результатом.
Если перспективы создания сервисов в один клик с последующим автоматическим деплоем в Digital Ocean звучат заманчиво, значит эта статья для вас.
Начнем создавать наш шаблон и прежде всего рассмотрим организацию сборки. Несмотря на любовь многих к maven за его простоту и декларативность, использовать будем gradle, ибо он современее и позволяет писать скрипт сборки на одном языке с проектом. Помимо самого Kotlin плагина, нам потребуется еще один:
```
plugins {
kotlin("jvm") version "1.4.30"
// Для сборки с портативной jvm
id("org.beryx.runtime") version "1.12.1"
}
```
Из зависимостей, в качестве серверного фреймворка был выбран "родной" для Kotlin [Ktor](https://ktor.io/). Для тестирования используется связка JUnit + Hamkrest с его выразительным DSL, позволяющим писать тесты таким образом:
```
assertThat("xyzzy", startsWith("x") and endsWith("y") and !containsSubstring("a"))
```
Собираем все вместе, ориентируясь на Java 15+
```
dependencies {
implementation("com.github.ajalt.clikt:clikt:3.1.0")
implementation("io.ktor:ktor-server-netty:1.5.1")
testImplementation("org.junit.jupiter:junit-jupiter:5.8.0-M1")
testImplementation("com.natpryce:hamkrest:1.8.0.1")
testImplementation("io.mockk:mockk:1.10.6")
}
application {
mainClass.set("AppKt")
}
tasks {
test {
useJUnitPlatform()
}
compileKotlin {
kotlinOptions.jvmTarget = "15"
}
}
```
В исходный код генерируемый шаблоном по умолчанию добавлен entry-point обработки аргументов командой строки, заготовка для роутинга, и простой тест (заодно служащий примером использования Hamkrest).
Из того что следует отметить, позволил себе небольшую вольность с официальным Kotlin codestyle чуть-чуть поправив его в .editorsconfig:
```
[*.{kt, kts, java, xml, html, js}]
max_line_length = 120
indent_size = 2
continuation_indent_size = 2
```
В первую очередь, это вопрос вкуса, но ещё так в одну строчку помещается больше кода, что помогает избежать переноса в выражениях внутри класса и функции, лямбды, например.
Чтобы собрать приложение используйте команду
```
gradle clean test runtime
```
Портативное приложение (в директории *build/image*) уже можно использовать, запуская традиционным образом через исполняемый файл в *build/image/bin*
Осталось написать Dockerfile, его привожу целиком. Сборка и запуск разделены и производятся в два этапа:
```
# syntax = docker/dockerfile:experimental
FROM gradle:jdk15 as builder
WORKDIR /app
COPY src ./src
COPY build.gradle.kts ./build.gradle.kts
RUN --mount=type=cache,target=./.gradle gradle clean test install
FROM openjdk:15 as backend
WORKDIR /root
COPY --from=builder /app/build/install/app ./
```
Приложение работает в контейнере с jdk (а не с jvm) для удобной диагностики c помощью jstack/jmap и других инструментов поставляемых с jdk.
Сконфигурируем запуск приложения при помощи Docker Compose:
```
version: "3.9"
services:
backend:
build: .
command: bin/app
ports:
- "80:80"
```
Теперь мы можем запускать наш сервис на целевой машине, без дополнительных зависимостей в виде jdk/gradle, при помощи простой команды
```
docker-compose up
```
Как деплоить сервис в облако? Выбрал Digital Ocean из-за дешевой стоимости и простоты управления. Благодаря тому что мы только что сконфигурировали сборку и запуск в контейнере, можно выбрать наш репозиторий с проектом в разделе Apps Platform и... все! Файлы конфигурации Docker будут подцеплены автоматически, мы увидим логи сборки, а после этого получим доступ к веб адресу, логам приложения, консоли управления, простым метрикам потребления памяти и процессорного времени. Выглядит это удовольствие примерно так и стоит 5$ в месяц:
При последующих изменениях в master ветке репозитория, передеплой запустится автоматически, удобно.
Наконец, все описанное в статье, подробно задокументировано в README.md файле шаблона, чтобы после создания проекта, последующая сборка и деплой не вызывали сложностей.
Использовать шаблон чтобы получить готовый репозиторий, можно просто нажав кнопочку `"Use this template"`на GitHub:
[github.com/demidko/Projekt-portable](https://github.com/demidko/Projekt-portable)
Или, если вам нужен вариант с self-executable jar без портативной jvm:
[github.com/demidko/Projekt-jar](https://github.com/demidko/Projekt-jar)
После этого остается только написать логику :) Как и любой подход, этот шаблон не лишен недостатков, поэтому интересно услышать предложения, комментарии и критику. | https://habr.com/ru/post/544538/ | null | ru | null |
# Как я нашел уязвимости в системе баг-трекинга Google и получил $15,600
Вы когда-нибудь слышали о Google Issue Tracker? Наверное, нет, если вы не являетесь сотрудником Google или разработчиком, который недавно сообщил о проблемах в инструментах Google. И я тоже не знал, пока не заметил, что мои сообщения об уязвимостях теперь обрабатываются, путем открытия нового обсуждения, помимо обычных уведомлений по электронной почте.
Поэтому я сразу начал пытаться взломать его.
Так что же это за сайт? Согласно документации, Tracker Issue (также называемая Buganizer System) — это инструмент, используемый компанией Google для отслеживания ошибок и запросов о добавление новых фич во время разработки продукта. Он доступен за пределами Google для использования общественностью и пользователями-партнерами, которым необходимо сотрудничать с командой Google по конкретным проектам.
Другими словами, когда у кого-то проблема (issue) с продуктом Google, он идет в баг-трекер. Имеет смысл, не так ли? Мы, как внешние пользователи, видим только верхушку айсберга: небольшой набор предварительно одобренных категорий и проблем, связанной с добавлением сотрудником Google внешней учетной записи, например, сообщения об уязвимостях. Но сколько информации лежит под поверхностью?
Наблюдая за ID, назначенных на последние опубликованные баги, мы можем легко оценить, сколько применения этот инструмент получает изнутри. В рабочие часы в Mountain View открывается около **2000-3000 проблем** за час. Похоже, утечка данных из этой системы будет иметь большую ценность. Давайте взломаем ее!
> [](https://www.edsd.ru/ "EDISON Software Development Centre")
>
> Подробнее о способах оплаты за разработку, которые мы используем на проектах в EDISON Software Development Centre.
>
>
>
>
### Уязвимость № 1: Получение учетной записи сотрудника Google
Одной из первых вещей, которые я заметил при обнаружении баг-трекера, это возможность участвовать в обсуждениях, отправляя электронные письма на специальный адрес, который выглядит следующим образом:
**buganizer-system**+componentID+issueID@**google.com**
(в котором componentID — это число, представляющее категорию, а issueID — уникальный идентификатор для обсуждения, в котором вы отвечаете)
Это напомнило мне недавнее открытие под названием [Ticket Trick](https://medium.freecodecamp.org/how-i-hacked-hundreds-of-companies-through-their-helpdesk-b7680ddc2d4c), которое позволило хакерам проникнуть в систему чатов организаций, используя такую систему электронной почты.
Учитывая, что это адрес электронной почты @ google.com, я пытался зарегистрироваться в Google Slack, используя его. Страница подтверждения входа, которую я увидел, выглядела очень многообещающе:
Увы, ни одного письма от Slack не пришло.
Следующая вещь о которой я мог подумать — это получить учетную запись Google с доменом **[google](https://habr.com/ru/users/google/).com**, который, надеюсь, предоставит мне дополнительные привилегии в Buganizer. Зарегистрировать такую учетную запись извне Google не получалось:
Тем не менее, я нашел метод обхода этого фильтра: если я зарегистрировался на любом другом поддельном адресе электронной почты, но не смог подтвердить учетную запись, нажав на ссылку, полученную по электронной почте, мне было разрешено менять свой адрес электронной почты без каких-либо ограничений. Используя этот метод, я изменил электронную почту новой учетной записи Google на `buganizer-system+123123+67111111@google.com`.
Вскоре после этого я получил письмо с подтверждением в виде сообщения на соответствующей странице проблем:
Отлично! Я щелкнул на ссылку подтверждения и вошел в систему Tracker Issue и …
Я был перенаправлен на корпоративную страницу входа. И нет, мои учетные данные Google там не принимались. Облом.
Тем не менее, эта учетная запись дала мне много дополнительных преимуществ в других местах по всему Интернету, в том числе возможность [совершить поездку](https://google.ridecell.com/request) (может быть бесплатно?), Поэтому проблема с безопасностью открывала много дверей для злонамеренных пользователей.
Итого: **11 часов** | Вознаграждение: **$3,133.7** | Приоритет: **P1**
### Уязвимость № 2: Получение уведомления о внутренних тикетах
Другая функция баг-трекера, которая привлекла мое внимание, когда я знакомился с пользовательским интерфейсом — возможность отмечать обсуждения. Пометка обсуждения означает, что вас интересует обсуждаемая проблема, и вы хотите получать уведомления по электронной почте, когда кто-то добавляет комментарий.
Интересная вещь, которую я заметил в этой функциональности, заключалась в отсутствии ошибок при попытке отмечать те обсуждения, к которым у меня не было доступа. Правила контроля доступа никогда не применялись в этой конечной точке, поэтому я вошел в свою вторую учетную запись и попытался отметить сообщение об уязвимости из моей основной учетной записи, заменив ID бага в запросе. Затем я увидел это сообщение, что означает, что действие было успешным:
> 1 человек отметил эту проблему.
Означает ли это что я могу легко шпионить за открытыми уязвимостями Google? Я быстро опубликовал комментарий по этой проблеме, чтобы узнать, придет ли уведомление на мой второй аккаунт.
Но опять же, ни одно сообщение не появилось.
По какой-то причине, которую я действительно не помню, я решил провести еще один тест. Поэтому я взял недавний ID бага и экстраполировал несколько тысяч ID, которые должны совпадать с последними ID багов в базе данных. Затем я отметил их все.
В течение нескольких минут мой почтовый ящик выглядел так:
Моя первая мысль при открытии папки «Входящие» была «Джекпот!».
Однако при дальнейшем рассмотрении, в этих обсуждениях не было ничего особо интересного. По-видимому, я мог подслушивать только обсуждения, связанные с переводом, где люди обсуждали лучшие способы передать значение фразы на разных языках.
Я даже решил подождать пару часов и не отправлять сообщение о найденной уязвимости, надеясь, что найду способ повысить уровень серьезности. В конце концов, я понял, что команда безопасности Google, вероятно, будет заинтересована в поиске возможных пивотных методов (pivot methods) и вариантов, поэтому я отослал детали.
Итого: **5 часов** | Вознаграждение: **$5000** | Приоритет: **P0**
### Уязвимость №3: Game over
Когда вы посещаете Tracker Issue в качестве внешнего пользователя, большая часть его функций скрывается, что оставляет вам крайне ограниченные привилегии. Если вы хотите увидеть все классные вещи, которые могут выполнять сотрудники Google, вы можете найти конечные точки API в файлах JavaScript. Некоторые из этих функций полностью отключены, другие просто скрыты в интерфейсе.
При разработке этой ограниченной версии системы кто-то был достаточно хорош, чтобы оставить в методе для нас возможность удаления себя из списка CCs, в случае, если мы потеряем интерес к проблеме или больше не захотим получать электронные письма с информацией о ней. Этого можно добиться, отправив запрос POST следующим образом:
```
POST /action/issues/bulk_edit HTTP/1.1
{
"issueIds":[
67111111,
67111112
],
"actions":[
{
"fieldName":"ccs",
"value":"test@example.com",
"actionType":"REMOVE"
}
]
}
```
Тем не менее, я заметил некоторые недочеты здесь, что могло бы привести к огромной проблеме:
1. **Неправильное управление доступом**: не было явной проверки того, что у текущего пользователя действительно был доступ к проблемам, указанным в `issueIds`, прежде чем пытаться выполнить данное действие.
2. **Скрытый отказ (Silent failure)**: если вы указали адрес электронной почты, который в настоящее время не был включен в список CCs, конечная точка вернет сообщение о том, что письмо было успешно удалено.
3. **Подробное описание проблемы в ответе**: если во время действия не было ошибок, другая часть системы решила, что у пользователя есть соответствующие права доступа. Таким образом, каждая деталь о данном ID бага будет возвращена в теле ответа HTTP.
Теперь я могу просмотреть сведения о каждой проблеме в базе данных, заменив `issueIds` в запросе выше. Бинго!
Я пробовал посмотреть только несколько последовательных ID, а затем атаковал себя из несвязанной учетной записи, чтобы подтвердить серьезность этой проблемы.
Да, я мог смотреть детали сообщений об уязвимостях, а также все остальное, размещенное на Buganizer.
Хуже того, я мог бы вытащить данные сразу о нескольких тикетах в одном запросе, поэтому мониторинг всей внутренней активности в реальном времени, вероятно, не вызвал бы никаких ограничителей скорости.
Я быстро отправил подробные данные о проблеме в Google, и их команда безопасности отключила поврежденную конечную точку спустя час. Впечатляющее время отклика!
Итог: **1 час** | Вознаграждение: **$7500** | Приоритет: **P0**
Когда я впервые начал искать утечку информации, я предположил, что это будет Святым Граалем багов Google, потому что она раскрывает информацию обо всех других ошибках (например, HackerOne [платит минимум 10 000 долларов](https://hackerone.com/security) за что-то подобное).
Но, обнаружив это, я быстро понял, что воздействие будет сведено к минимуму, потому что все опасные уязвимости в любом случае будут нейтрализованы в течение часа.
Я очень доволен полученному вознаграждению, и намерен искать баги в других продуктах от Google.
*Перевод: Вячеслав Букатов* | https://habr.com/ru/post/341752/ | null | ru | null |
# Диспетчер лицензирования LMTOOLS. Вывод списка лицензий для пользователей продуктов Autodesk
Добрый день, уважаемые читатели.
> Я немного дописал сюда информации, потому-что с момента публикации прошло время и я развиваясь, понял свои ошибки, лишь хочу добавить, что это **не инструкция**. Это мой велосипед, который я изобрёл и он едет, хоть и педали крутятся в другую сторону.
Буду предельно краток и разобью статью на пункты.
#### Проблемы организационного характера
Количество пользователей программного продукта AutoCAD превышает количество локальных сетевых лицензий.
1. Количество специалистов работающих в ПО AutoCAD не нормируется никаким внутренним документом.
2. Исходя из пункта №1, отказать в установке программы почти невозможно.
3. Неправильная организация работ ведёт к нехватке лицензий, что приводит к заявкам и звонкам абонентов в службу информационных технологий с данной проблемой.
#### Проблемы технические
1. Отсутствие средств для просмотра списка занимаемых лицензий.
#### Варианты решения
1. Готовое решение поддерживаемое производителем ПО, позволяющее пользователям самостоятельно просматривать список занимаемых лицензий.
2. Разработка любого подходящего решения для вывода отчёта работы диспетчера лицензирования в виде вэб-страницы.
### Принятое решение и реализация
#### Техническое задание
1. Возможность сэкономить на лицензии ОС
2. Вывод списка пользователей занимающих лицензии
#### Реализация работы диспетчера лицензирования
Принято решение самостоятельно реализовать необходимую функцию. Порядок выполнения:
1. Установка и настройка CentOS 7 на сервер виртуализации
2. Установка и запуск Autodesk Network License Manager для Linux
3. Настройка авто запуска утилиты при рестарте ОС
4. Настройка файла параметров (о нём я напишу ниже)
5. Установка локального web-сервера и PHP
#### Реализация вывода списка занимаемых лицензий
1. Создание .sh файла с содержимым приведённым ниже:
```
#! /bin/bash
/opt/flexnetserver/lmutil lmstat -a -c [путь к файлу .lic]> "/var/www/html/log.txt"
```
Он размещается в удобной директории, и настраивается как исполняемый файл.
С помощью данной команды выгружается статус диспетчера лицензирования в файл log.txt
2. Использовал команду
```
watch -n 5 [путь к созданному в п№1 файлу .sh]
```
Это позволяет каждый 5 секунд вызывать ранее созданный bash скрипт.
3. В директории log.txt из п№1, размещается файл index.php со следующим содержимым
```
License server AutoCAD
Список лицензий сервера лицензирования autoCAD
==============================================
php
$log = file\_get\_contents('./log.txt');
$logrp = nl2br($log);
$arraystr = explode(PHP\_EOL,$logrp);
$busy = explode(" ",$arraystr[13]);
echo "На данный момент занято: ".$busy[12]." лицензий<br/
";
$i = 18;
while($i<=37){
//var
$a = $i-17;
$data = explode(" ", $arraystr[$i]);
$time = str\_replace('".$a." ";
echo "".$data[4]." ";
echo "".$data[12]." ";
echo "".$data[11]." ";
echo "".$time."";
echo "
";
$i++;
}
?>
```
#### Итог реализации всех требований
Как выглядит GUI сервера:
Как выглядит веб-страница:
#### Файл параметров .opt
В нём указал
`TIMEOUTALL 14400` — время простоя программы ограничено 4 часами
`MAX_BORROW_HOURS [CODE] 48` — максимальный срок заимствования ограничен 2 днями.
#### Доп. информация
Т.к. в организации используются корректные именные доменные уч. записи сотрудников, по логину очень легко определить специалиста занявшего лицензию.
### Общий результат усилий:
1. Пользователь самостоятельно видит занимаемую лицензию и соответственно снижена нагрузка службы технической поддержки.
2. Внутри коллектива специалистов работающих в ПО без участия тех. поддержки решается вопрос «Кому достанется лицензия?», и в зависимости от приоритета работ освобождается или занимается лицензия.
3. Экономия на лицензировании Windows. | https://habr.com/ru/post/467583/ | null | ru | null |
# 10 итераторов, о которых вы могли не знать
Одним из главных достоинств Python является выразительность кода. Не последнюю роль в этом играет возможность удобной работы с коллекциями и последовательностями различного вида: перебор элементов списка по одному, чтение файла по строкам, обработка всех ключей и значений в словаре. Эти и многие другие подобные задачи в Python помогает решить так называемый *протокол итераторов* (Iterator protocol). Именно этот протокол обеспечивает работу цикла `for`, устанавливает по каким объектам можно *итерироваться*, а по каким нет. Как мы увидим далее, сам язык и стандартная библиотека очень широко используют возможности протокола. В этой статье попробуем отыскать не самые известные, но от этого не менее интересные примеры *итераторов* и *итерируемых объектов*, которые предлагает Python.
0. В качестве вступления
------------------------
Для начала предлагаю освежить в памяти, что же из себя представляет упомянутый *протокол итераторов*. В сущности, протокол определяет два вида объектов. Первый вид — это объекты, которые можно использовать в цикле `for`, поэтому они и называются *итерируемыми* (Iterable). К первому виду принадлежат списки, строки, словари, множества, а также многие другие коллекции. *Итерируемые объекты* вовсе не обязательно должны иметь конечное число элементов, например, последовательность натуральных чисел легко можно использовать в цикле `for` (хотя завершения подобной программы придётся ждать довольно долго):
```
from itertools import count
# Последовательность натуральных чисел
natural_numbers = count(start=1, step=1)
for number in natural_numbers:
print(number) # Напечатает 1, 2, 3, и т.д.
```
Все *итерируемые объекты* объединяет одно важное свойство. Если передать такой объект в функцию `iter`, то она отработает без ошибок и вернёт объект второго вида, который нам интересен в рамках этой статьи.
Как не сложно догадаться по самому названию протокола, этим вторым видом объектов являются *итераторы*. Каждый *итератор* неразрывно связан со своим *итерируемым объектом*. Единственное, что "знает" *итератор* — это какой элемент в *итерируемом объекте* будет следующим при переборе. Этот элемент он и возвращает при вызове функции `next`:
```
# Итерируемый объект
iterable = ["🦆", "🐱", "🦝"]
# Получаем итератор с помощью функции iter
iterator = iter(iterable)
# Перебираем элементы с помощью итератора
print(next(iterator)) # 🦆
print(next(iterator)) # 🐱
print(next(iterator)) # 🦝
# Если следующего элемента не существует,
# то итератор генерирует специальное исключение StopIteration
print(next(iterator)) # 💩
```
Как только *итератор* сгенерировал исключение `StopIteration`, он становится бесполезен. Иногда говорят, что такой *итератор* *исчерпан*. Чтобы заново перебрать элементы *итерируемого объекта* нужно получить новый *итератор* вызовом функции `iter(iterable)`.
Одна важная особенность заключается в том, что каждый *итератор* одновременно является *итерируемым объектом*, его тоже можно использовать в цикле `for`. Вызов функции `iter` с *итератором* просто возвращает этот же *итератор*:
```
iterable = "строка — это тоже итерируемый объект"
iterator = iter(iterable)
# Получение итератора возвращает один и тот же объект
print(iter(iterator) is iterator) # True
# Используем итератор в качестве итерируемого объекта
for letter in iterator:
print(letter) # Напечатает буквы с, т, р, о, и т.д.
```
Из-за того, что *итератор* может быть *исчерпан*, использование одного и того же *итератора* несколько раз может привести к неожиданному результату:
```
# Продолжение предыдущего примера
# Используем итератор второй раз
for letter in iterator:
print(letter) # Не напечатает ничего!
```
*Итераторы* могут использоваться в любом контексте, где ожидается *итерируемый объект*, однако при этом всегда следует помнить про возможность *исчерпания*.
Многие встроенные функции работают с *итерируемыми объектами*. Например, функция `sum` считает сумму всех элементов переданного *итерируемого объекта*. Встроенные функции `map`, `filter`, и `max` тоже работают с любыми *итерируемыми объектами*. И это только малая часть, далее мы увидим ещё больше таких примеров.
Итак, выделим ещё раз наиболее существенные детали:
* *Итерируемый объект* — это любой объект, который можно передать в функцию `iter` и получить *итератор*
* *Итератор* — это любой объект, который можно передать в функцию `next` и получить следующий элемент или исключение `StopIteration`
* Каждый *итератор* также является *итерируемым объектом*
* *Итератор* может быть *исчерпан*
1. Создаём собственный итератор
-------------------------------
Если *протокол итераторов* широко используется в языке и стандартной библиотеке, то должна быть возможность создать свой собственный *итератор*. И, конечно, такая возможность в Python есть. Как уже было сказано выше, *итератор* неразрывно связан со своим *итерируемым объектом*, т.е. с объектом, элементы которого можно перебрать по одному. Чтобы объект нашего класса был *итерируемым*, и функция `iter` корректно работала с ним, можно определить магический метод `__iter__`, который будет возвращать *итератор*. В свою очередь у *итератора* должен быть магический метод `__next__`, тогда его можно будет передать в функцию `next`, и наши классы будут соответствовать протоколу.
Рассмотрим создание *итерируемого объекта* и *итератора* для него на примере очень важной вычислительной задачи по генерации чисел Фибоначчи:
```
class Fibonacci:
"""Наш итерируемый объект."""
def __init__(self, n: int):
self.n = n # Нужное количество чисел Фибоначчи
def __iter__(self):
"""Возвращаем итератор, чтобы соответствовать протоколу."""
return FibonacciIterator(self.n)
class FibonacciIterator:
"""Итератор для перебора чисел Фибоначчи."""
def __init__(self, n: int):
self.n = n # Нужное количество чисел Фибоначчи
self.current, self.next = 0, 1
def __next__(self) -> int:
if self.n <= 0:
# Итератор исчерпан
raise StopIteration()
self.n -= 1
current = self.current
self.current, self.next = self.next, self.next + current
return current
def __iter__(self):
"""
Чтобы соответствовать протоколу, каждый итератор должен
одновременно быть итерируемым объектом.
"""
return self
```
Теперь объекты классов `Fibonacci` и `FibonacciIterator` можно использовать согласно *протоколу итераторов*:
```
# Продолжение предыдущего примера
fibo = Fibonacci(10) # итерируемый объект
iterator = iter(fibo)
print(isinstance(iterator, FibonacciIterator)) # True
print(next(iterator)) # 0
print(next(iterator)) # 1
print(next(iterator)) # 1
print(next(iterator)) # 2
# ... и т.д.
for number in fibo:
print(number) # Напечатает 0, 1, 1, 2, 3, и т.д.
# Сумма первых 10-ти чисел Фибоначчи
print(sum(fibo)) # 88
```
2. Генераторы
-------------
Создание двух классов только для того, чтобы иметь возможность работать с какой-либо последовательностью, скорее всего, не самый практичный способ. И Python предоставляет гораздо более удобную альтернативу. Если в теле обычной функции использовать ключевое слово `yield`, то такая функция перестаёт просто возвращать результат при вызове, а становится *генераторной функцией*. Главное различие здесь в том, что *генераторная функция* описывает, каким образом нужно *сгенерировать* последовательность. При вызове такой функции она всегда возвращает специальный объект, который называется *генератор*. Этот объект хранит своё внутреннее состояние, позволяя вычислять элементы последовательности не все сразу, а по мере необходимости. Работа *генератора* приостанавливается на каждом операторе `yield`, а очередное вычисленное значение последовательности возвращается вызывающей стороне.
```
def fibonacci(n: int):
current, next = 0, 1
for _ in range(n):
yield current # Точка приостановки работы генератора
current, next = next, current + next
```
Думаю, не окажется сюрпризом тот факт, что каждый *генератор* — это *итератор*:
```
# Продолжение предыдущего примера
from collections.abc import Iterator
generator = fibonacci(10)
print(isinstance(generator, Iterator)) # True
# Используем итератор
print(set(generator)) # {0, 1, 2, 3, 5, 8, 13, 21, 34}
```
Помимо ключевого слова `yield` для создания *генераторов* можно использовать выражение `yield from`, что позволяет *генерировать* элементы из любого другого *итерируемого объекта*.
```
from collections.abc import Iterable
def flatten(items: Iterable):
for item in items:
if isinstance(item, Iterable):
yield from flatten(item)
else:
yield item
items = [[0, 1, 2], 3, 4, [[5], [6, 7]], [[[8]]], 9]
print(list(flatten(items))) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
```
Разговор о *генераторах* был бы неполным, если не упомянуть *генераторные выражения* (Generator expressions). Такие выражения позволяют декларативно задать создаваемый итератор и сразу присвоить его какой-либо переменной. Причём, как и в случае обычных *генераторов*, значения последовательности вычисляются не сразу, а по мере необходимости.
```
# Итерируемый объект
iterable = range(10)
# Создаём итератор с помощью генераторного выражения
iterator = (item for item in iterable if item % 2 == 0)
# Оператор in также может работать через протокол итераторов,
# просто перебирая элементы по одному и сравнивая с проверяемым значением
print(8 in iterator) # True
# Но нужно помнить, что итератор может быть исчерпан
print(8 in iterator) # False
```
3. Протокол последовательностей
-------------------------------
Да-да, в Python много всяких полезных протоколов. Так что ещё одним способом определения *итерируемых объектов* является *протокол последовательностей* (Sequence protocol). Чтобы объекты класса поддерживали этот протокол, класс должен определить метод `__getitem__`, который сможет работать с целочисленными аргументами:
```
class SquareNumbers:
def __init__(self, n: int):
self.n = n
def __getitem__(self, index: int):
if index < 0 or index >= self.n:
raise IndexError()
return index * index
square_numbers = SquareNumbers(100)
iterator = iter(square_numbers)
print(next(iterator)) # 0
print(next(iterator)) # 1
print(next(iterator)) # 4
# ... и т.д.
print(list(SquareNumbers(5))) # [0, 1, 4, 9, 16]
```
Без сомнения, довольно интересный способ создать *итератор*, но для чего это может пригодиться на практике — вопрос открытый.
4. Функция iter и два аргумента
-------------------------------
У функции `iter` есть ещё один вариант использования. *Итератор* можно получить, если в `iter` передать первым аргументом обычную функцию, которая при вызове будет возвращать очередной элемент последовательности, а вторым — значение, при возврате которого этой функцией *итерация* должна закончиться. Давайте посмотрим на примере:
```
from random import choice
# Функция choice возвращает случайный элемент из списка
iterator = iter(lambda: choice(["🐼", "🐧", "🙈"]), "🙈")
# Итератор будет работать пока вызов лямбды не вернёт "🙈"
print("".join(iterator)) # Например, 🐧🐼🐼🐧
```
Использование `lambda` в примере необходимо, поскольку переданную в `iter` функцию должно быть можно вызывать без аргументов. Сконструированный таким образом *итератор* для получения следующих элементов вызывает переданную функцию снова и снова до тех пор, пока функция не вернёт значение для остановки, при котором *итератор* генерирует исключение `StopIteration`, и *итерация* заканчивается.
5. Перечисления
---------------
*Перечисление (Enumeration)* — это тип данных, который имеет ограниченное количество значений. Как следует из названия, эти значения *перечисляются* при объявлении типа. Для создания *перечислений* в стандартной библиотеке Python есть специальный модуль `enum`:
```
from enum import Enum, auto
class Color(Enum):
RED = "красный"
GREEN = "зелёный"
BLUE = "синий"
BLACK = "чёрный"
WHITE = "белый"
```
Здесь `Color` является *перечисляемым* типом данных, который состоит из пяти значений: `Color.RED`, `Color.GREEN`, и т.д. Но самое интересное здесь то, что сам `Color` — это тоже *итерируемый объект!*
```
# Продолжение предыдущего примера
from collections.abc import Iterable
print(isinstance(Color, Iterable)) # True
```
*Итератор*, который можно получить от *перечисляемого* типа данных, просто возвращает элементы в порядке их объявления:
```
print([color.value for color in Color])
# Напечатает ["красный", "зелёный", "синий", "чёрный", "белый"]
```
6. Бескрайний мир itertools
---------------------------
Если вдруг вы не знакомы с модулем стандартной библиотеки itertools, то срочно это исправьте! Этот модуль, без сомнения, может изменить вашу жизнь к лучшему (по крайней мере ту её часть, которая непосредственно касается Python). Модуль предоставляет большое количество различных *итераторов*, которые можно комбинировать друг с другом и таким образом решать множество задач связанных с операциями над последовательностями. Большинство функций в модуле itertools принимают один или несколько *итерируемых объектов* в качестве аргументов и возвращают *итератор*, который определённым образом преобразует исходные последовательности в новую последовательность. Разбор всех возможностей *итераторов* модуля itertools занял бы целую статью, так что предлагаю посмотреть только несколько небольших примеров.
Скорее всего вы слышали про одну популярную задачу на собеседованиях, которая называется [FizzBuzz](https://ru.wikipedia.org/wiki/Fizz_buzz). Один из вариантов этой задачи заключается в том, чтобы вывести на экран числа от 1 до 100. При этом если число делится нацело на 3, то вместо самого числа нужно вывести строку `fizz`, если же число делится нацело на 5, то нужно вывести строку `buzz`. Ну а если число делится нацело и на 3, и на 5, то на экран нужно вывести `fizzbuzz`. Посмотрим, как можно было бы решить эту задачу с помощью модуля itertools.
```
from itertools import count, cycle, islice
numbers = count(start=1, step=1)
fizzes = cycle(["", "", "fizz"])
buzzes = cycle(["", "", "", "", "buzz"])
```
С функцией `count` мы уже встречались в одном из примеров выше. *Итератор*, который создаёт эта функция, возвращает последовательность чисел с указанным шагом. Функция `cycle` создаёт бесконечный *итератор*, который перебирает все элементы переданного *итерируемого объекта*, а когда элементы заканчиваются, то *итератор* повторяет цикл и снова возвращает элементы, начиная с первого.
```
# Продолжение предыдущего примера
fizzbuzzes = islice(zip(numbers, fizzes, buzzes), 100)
```
С помощью функции `islice` можно создать *итератор*, смысл работы которого похож на взятие среза списка (`some_list[:100]`), только в отличие от обычных срезов функцию `islice` можно использовать для любых *итерируемых объектов*. Ну а *итератор*, который создаёт встроенная функция `zip`, на каждой *итерации* собирает в кортеж элементы нескольких *итерируемых объектов*, переданных в функцию `zip`.
```
# Продолжение предыдущего примера
for number, fizz, buzz in fizzbuzzes:
# Напечатает 1, 2, fizz, 4, buzz, fizz, ..., 14, fizzbuzz, и т.д.
print(f"{fizz}{buzz}" or number)
```
Другим интересным примером является *итератор*, который создаёт функция `product`. Такое название функции обусловлено тем, что *итератор* возвращает элементы из [*декартова произведения*](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D1%8F%D0%BC%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5) переданных в функцию *итерируемых объектов*. Функция product и создаваемый ею *итератор* позволяют заменить несколько вложенных циклов `for` одним, что в некоторых случаях может помочь сделать код более читаемым.
```
from itertools import product
letters = "abcdefgh"
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
for letter in letters:
for number in numbers:
# Напечатает a1, a2, a3, ..., b1, b2, и т.д
print(f"{letter}{number}")
# Заменяем вложенные циклы одним
for letter, number in product(letters, numbers):
# Напечатает a1, a2, a3, ..., b1, b2, и т.д
print(f"{letter}{number}")
```
Всё это только малая часть возможностей, которые даёт модуль itertools. Если вас заинтересовал этот модуль, то обязательно загляните в [документацию стандартной библиотеки](https://docs.python.org/3/library/itertools.html).
7. Стандартный ввод
-------------------
Для интерактивного взаимодействия с пользователем в командной строке обычно используется функция `input()`, которая блокирует выполнение программы, ожидая ввода пользователя с клавиатуры. После нажатия клавиши Enter введённый пользователем текст можно сохранить в переменную:
```
name = input("Введите ваше имя: ")
# Ожидание ввода ...
print("Ваше имя:", name)
```
Помимо функции `input()` для работы со стандартным потоком ввода в модуле `sys` есть специальный объект `stdin`. С этим объектом можно работать, как с обыкновенным файлом открытым для чтения. Например, можно прочитать строку:
```
import sys
name = sys.stdin.readline().strip()
# Ожидание ввода ...
print("Ваше имя:", name)
```
Интересно, что как и любой открытый файл (вы же знаете, что и по файлу в Python можно *итерироваться*?), объект `stdin` тоже является *итерируемым*. На каждой *итерации* этот объект возвращает очередную строку из стандартного потока ввода. Чтобы наглядно проиллюстрировать эту возможность, воспользуемся механизмом *перенаправления* ввода (в ОС Linux) и одной из самых актуальных задач в современном программировании, а именно подсчётом количества строк в файле:
```
# Файл lc.py
import sys
# Итерируемся по строкам стандартного потока ввода
line_count = sum(1 for line in sys.stdin)
print("Количество строк:", line_count)
```
Создадим какой-нибудь файл для тестирования нашей программы:
```
Файл data.txt
aaa
bbb
ccc
```
Ну и наконец, используем *перенаправление* ввода и нашу программу по прямому назначению:
```
$ python lc.py < data.txt
Количество строк: 4
```
8. Содержимое каталога
----------------------
Раз уж мы немного затронули тему файлов в предыдущем разделе, то стоит её продолжить и рассмотреть модуль pathlib — очень полезный модуль стандартной библиотеки для работы с файловой системой. Pathlib предоставляет класс `Path`, который является абстракцией над путём к файлу в операционной системе. С помощью объектов этого класса можно выполнять множество операций над файлами и каталогами: проверять существование, изменять права доступа, читать содержимое и многое-многое другое. В модуле pathlib остановимся только на одном интересующем нас *итераторе*, который позволяет перебрать содержимое каталога операционной системы.
```
from pathlib import Path
directory = Path("/home/habr/files")
print(directory.is_dir()) # True
# Получаем итератор по содержимому каталога
directory_iterator = directory.iterdir()
text_files = (
# Читаем содержимое каждого текстового файла
path.read_text()
for path in directory_iterator
if (
# Проверяем, что путь ведёт к текстовому файлу
path.is_file() and path.suffix == ".txt"
)
)
# Используем содержимое выбранных текстовых файлов
for text in text_files:
print(text)
```
9. CSV
------
[CSV](https://ru.wikipedia.org/wiki/CSV) — это популярный текстовый формат для представления табличных данных. Каждая строка в таком файле — это одна строка таблицы. Для работы с файлами этого формата в стандартной библиотеке Python есть отдельный модуль (вы всё ещё удивлены?), который так и называется — csv. Ну а раз есть специальный модуль, есть набор табличных строк в CSV файле, то должен быть и *итератор* для перебора этих строк. И, конечно, такой *итератор* в модуле csv есть. Давайте посмотрим следующий пример, файл data.csv выглядит следующим образом:
```
Имя,Возраст,Любимый цвет
Алиса,22,зелёный
Маргарита,29,белый
Арина,13,жёлтый
Полина,31,фиолетовый
```
Первая строка в файле — это названия колонок таблицы, а далее в каждой строке находятся сами табличные данные. Воспользуемся модулем csv для чтения этих данных:
```
import csv
from itertools import islice
columns = ["Имя", "Возраст", "Любимый цвет"]
with open("data.csv", "r") as csv_file:
csv_reader = csv.DictReader(csv_file, columns)
# Получаем итератор по строкам CSV файла
csv_iterator = iter(csv_reader)
# Пропускаем первую строку с названиями колонок
next(csv_iterator)
# Итерируемся по строкам
for row in csv_iterator:
# Напечатает Алиса 22 зелёный, Маргарита 29 белый, и т.д.
print(row["Имя"], row["Возраст"], row["Любимый цвет"])
```
10. Пул процессов
-----------------
Для ускорения сложных вычислительных задач может использоваться одновременное выполнения кода несколькими ядрами процессора. Из-за особенностей интерпретатора Python (пресловутый [GIL](https://ru.wikipedia.org/wiki/%D0%93%D0%BB%D0%BE%D0%B1%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%B1%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D0%BF%D1%80%D0%B5%D1%82%D0%B0%D1%82%D0%BE%D1%80%D0%B0)) параллельные вычисления обычно реализуются через процессы операционной системы. Для работы с процессами в стандартной библиотеке Python существует модуль multiprocessing, в котором нас будет интересовать класс `Pool`, позволяющий легко создать процессы для параллельных вычислений на нескольких ядрах процессора. Предположим, наша сложная вычислительная задача выглядит следующим образом:
```
import time
def do(n: int) -> int:
time.sleep(3) # Доооолгие вычисления ...
return n * n
```
Кроме этого, у нас есть набор входных данных, котырые мы хотим использовать для вычислений:
```
# Продолжение предыдущего примера
tasks = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
```
Как легко посчитать, последовательное вычисление всех задач займёт около 36 секунд:
```
# Продолжение предыдущего примера
t0 = time.perf_counter()
results = list(map(do, tasks))
print(results) # [1, 4, 9, ..., 144]
# Напечатает Время выполнения 36 секунд
print("Время выполнения", int(time.perf_counter() - t0), "секунд")
```
Попробуем ускорить наши вычисления с помощью пула процессов из модуля multiprocessing:
```
# Продолжение предыдущего примера
from multiprocessing import Pool
t0 = time.perf_counter()
# Создаём пул из четырёх процессов
with Pool(processes=4) as pool:
results_iterator = pool.imap(do, tasks)
results = list(results_iterator)
print(results) # [1, 4, 9, ..., 144]
# Напечатает Время выполнения 9 секунд
print("Время выполнения", int(time.perf_counter() - t0), "секунд")
```
Как видно из примера, метод пула процессов `imap` возвращает итератор по результатам вычислений. При этом всю низкоуровневую работу по управлению процессами и распределению задач между ними берёт на себя сам пул, обеспечивая удобный способ работы с параллельными вычислениями.
---
*А знаете ли вы ещё какие-нибудь интересные примеры итераторов и итерируемых объектов в стандартной библиотеке Python? Пишите в комментариях!* | https://habr.com/ru/post/697390/ | null | ru | null |
# «А пошло оно всё!» или снова о Coursera и ему подобных
Привет хабровчанам!
-------------------
Во-первых, спасибо вам, хабровчане! Именно от вас я узнал о таком замечательном проекте, как Coursera.
Как-то классе в 10 я решил, что хочу поступить в один из технических ВУЗов Вены — в этом городе я живу уже достаточно продолжительное время. У меня было какое-то очень общее понимание того, что такое php, mySQL, краем уха слышал о существовании RoR, и мне казалось, что веб-программирование — это крайне круто и что это то, чем мне бы подошло заниматься.
Впоследствии, наслушавшись о своей неорганизованности, сумбурности мышления и рассеянности выбор был сделан в пользу Логистики и Транспортного управления, откуда я в итоге ушёл с оставшимся чувством отвращения к бухгалтерии и праву.
И вот я узнаю о [Coursera](http://coursera.org), заглядываю туда и вижу такую халяву. Откинув старые убеждения о своей непригодности и воскликнув: «А пошло оно всё!» — записался на курс «Learn to Program: The Fundamentals», который начался на прошлой неделе. А вскоре и на несколько других курсов, + «Introduction to Computer Science I» на [edX](http://edx.org)
В своём первом топике хочу написать свои впечатления от первых двух недель курса, и если кому интересно —
---
Собственно «Learn to Program: The Fundamentals» от University of Toronto, первый такого рода курс, который я начал, и пока единственный (жду начала остальных). В этом курсе объясняются некоторые основные понятия и принципы на примере Python.
### Организация курса
Курс длится 7 недель, в начале каждой недели добавляется 7 видеолекций длительностью до 15 минут. К большинству лекций прилагается готовый конспект, + файлы субтитров (которые энтузиасты могут перевести и загрузить). Некоторые видеолекции иногда прерываются и ученику выдаётся от одного до нескольких вопросов по только что прочитанному лектором материалу — фича, которая мне дико понравилась.
В дополнение к этому на каждую неделю даются упражнения, достаточно простые — нужно на странице ответить на multiple или single choice вопросы, где-то ответить на открытый вопрос строкой кода, фразой или числом. За эти упражнения начисляются баллы, которые потом учитываются в итоговой оценке ученика. На каждое упражнение даётся 3 попытки и вопросы не меняются с новой попыткой, так что не получить за них хороший балл сложно.
Раз в две недели даётся задание, которое надо выполнить уже у себя на компьютере и загрузить готовый результат.
В конце — экзамен. Что он будет из себя представлять — я и сам пока не знаю.
### Система оценок
На данном курсе (не знаю пока, как на других) каждое упражнение и задание имеет количество баллов, которое нужно достичь. Оценка за упражнение составляет 5% от итоговой оценки, за «домашку» — 10% за первую и по 15% за две последующие. Итоговый тест — 25%. То есть, допустим, получи я за первое упражнение 6 баллов из 10 — это были бы 3% от итоговой оценки.
### Баги
Были замечены баги, что в упражнениях не принимался правильный на самом деле вариант ответа из-за стоящего в строке кода пробела (который допускается), например:
ответ с пробелами не принимался
```
max(23, 95, 12)
```
а без — вполне
```
max(23,95,12)
```
Хотя допустимо и так, и сяк.
### Маленькие радости
К первой моей домашке, в которой мне требовалось завершить набор функций по данным описаниям, примерам использования и примерам выхлопа после обработки аргументов и определить некоторые функции по описанию в задании, прилагался .py файл с гуем для написанного учеником ~~говно~~кода.
Кроме того, когда был обнаружен баг в упражнении — дали дополнительные две попытки на это упражнение. Таким образом, общее количество возможных попыток увеличилось до 5.
### Эпилог
Собственно вот. Очень рад тому, что наткнулся на Coursera и что всё-таки решил плюнуть и попробовать. Очень хочу всё-таки научиться хоть немного тому, что мне как-то интересно и попробовать в ближайшем будущем поковыряться с игровым движком вроде Blender Game Engine (раз уж с Python начинаем) или jMonkeyEngine (если поучить потом Java). Как сказал Гагарин, «Поехали!»
**P.S.** Спасибо НЛО за приглашение! И прошу прощения, если я накосячил с выбором хабов — мне пока предстоит нормально понять, куда что можно публиковать, а что нет. | https://habr.com/ru/post/153605/ | null | ru | null |
# Как я создаю приложения для браузера прямо в браузере
В 2013 году компания Canonical [пыталась собрать средства на выпуск смартфона Ubuntu Edge](https://habr.com/ru/post/187480). Особенностью продукта должна была стать возможность преобразовывать смартфон в полноценный ПК. Увы, необходимую сумму собрать не удалось, поэтому мечта создать универсальное устройство так и осталась мечтой.
Со своей стороны я давно искал универсальность со стороны программного обеспечения, не железа. Сегодня с уверенностью могу сказать, что нашёл необходимую комбинацию: Git и JavaScript.
Ранее я уже описывал как преимущества браузерных приложений на примере генератора статических сайтов [nCKOB](https://habr.com/ru/post/462685), так и преимущества замены очередного сервера с АПИ на Git для общения с внешним миром на примере приложения учёта трат [ГитБюджет](https://habr.com/ru/post/500234). После выпуска ГитБюджета оставшуюся часть 2020 года я потратил на систему, позволяющую создавать браузерные приложения прямо в браузере. Эту систему я назвал GitJS.
GitJS
=====
Git в новой системе используется для:
* долговременного хранения данных **вне** устройства;
* общения с внешним миром;
* доставки приложения на устройство по HTTP.
Таким образом, на текущий момент Git не используется в качестве контроля версий, лишь как широко распространённая технология хранения с доступом на чтение (HTTP) и запись. Это несколько противоречит первоначальной задумке автора, однако позволяет каждому определить условия хранения своих данных: платно/бесплатно, локально/дистанционно.
Альтернативой Git могло бы стать использование FTP/rsync, но нет ни широко известных и доступных сервисов вроде SourceForge/GitHub/BitBucket/GitLab, ни реализаций для работы с FTP/rsync из браузера вроде [Isomorphic-Git](https://isomorphic-git.org).
JS (вместе с HTML/CSS) используется для:
* интерфейса;
* логики;
* долговременного хранения приложения и данных **на** устройстве.
GitJS состоит из следующих трёх обязательных частей (в порядке исполнения):
1. [Страница HTML](https://gitlab.com/gitjs/gitjs.gitlab.io/-/blob/master/index.html)
* вводит правила GitJS
* имеет крошечный размер для работы на медленных сетях
* запрашивается с веб-сервера при каждом обновлении страницы
* может располагаться локально, чтобы обходиться без Интернета
2. [Правила GitJS](https://bitbucket.org/gitjs/0000/src/master/0000.js)
* представляют из себя код JS
* вводят понятие модулей с их загрузкой, сохранением и исполнением
* вводят понятие черёд: способа оформления кода реактивно-событийно
* запрашиваются страницей HTML лишь при отсутствии или при обновлении
* сохраняются страницей HTML в LocalStorage для ускорения последующих пусков
3. [Пусковой модуль](https://git.opengamestudio.org/kornerr/nPOBEPuTb-JSZip)
* указывается в адресной строке после символа `?`
* исполняется после загрузки правил GitJS
* делает что угодно, например, вводит понятие других модулей, которые нужно загрузить перед началом работы
* в примере по ссылке я проверял библиотеку JSZip
Пусковой модуль может ввести абсолютно любые дополнительные правила к GitJS или же их заменить, поэтому фантазия тут ограничена лишь возможностями браузера: в частности, не удастся удалить все файлы пользователя на диске.
Отдельно повторю, что наличие локальных страницы HTML и веб-сервиса Git позволяет сделать систему независимой от Интернета.
Приложение GitJS №1: редактор модулей GitJS
===========================================
На текущий момент редактор обладает минимальной необходимой функциональностью:
**1.1. Правка текстовых файлов модуля**
**1.2. Публикация изменений в Git**
**Замечание**: пароли хранит браузер.
**1.3. Правка структуры модуля**
**1.4. Открытие ранее загруженного модуля из LocalStorage/IndexedDB**
**1.5. Сохранение изменений локально в LocalStorage/IndexedDB**
Последняя версия редактора [доступна здесь](http://gitjs.org/%F0%9F%93%A6). Первый пуск происходит не быстро, так что наберитесь терпения.
Приложение GitJS №2: пасьянс Маджонг
====================================
Игра на текущий момент обладает следующей функциональностью:
**2.1. Выбор и удаление фишек с поля в соответствии с правилами пасьянса Маджонг**
**2.2. Выбор темы фишек**
**2.3. Выбор раскладки игрового поля**
**2.4. Определение победы и поражения**
Последняя версия игры [доступна здесь](http://gitjs.org/%F0%9F%80%84/1.0.14).
Конечной целью для игры является воспроизведение выпущенного много лет назад [Маджонга](http://opengamestudio.org/ru/game/ogs-mahjong-1.html), который работал лишь на Linux и Windows.
Ограничения
===========
Ограничения GitJS проистекают из ограничений браузеров.
**1. CORS**
Для записи изменений в Git необходимо соблюсти CORS. На текущий момент крупные сервисы [не разрешают невозбранно писать в их Git](https://github.com/isomorphic-git/isomorphic-git#cors-support), поэтому приходится либо использовать прокси, либо поднимать свой Git.
**2. Полноэкранный режим на мобилках**
Нынче в моду вошло схлопывание элементов управления браузеров при перемотке страниц, не помещающихся в экран. В результате выходит, что якобы освобождённые области сверху и снизу всё равно нельзя трогать, т.к. это приводит к возвращению элементов управления и изменению размера области отображения.
В пасьянсе Маджонг эту проблему я обошёл поддержкой портретного режима и возможностью смещать игровое поле влево/вправо. К сожалению, это усложняет игру, т.к. не видно целиком игрового поля.
Планы
=====
Упоминавшийся ранее [nCKOB](http://opengamestudio.org/ru/news/on-the-way-to-durable-applications.html) в этому году станет приложением GitJS, что позволит создавать статические сайты, не покидая браузер. Посмотрим, что из этого выйдет.
ЗЫ: Первым изображением является картина "Баян", написанная Виктором Васнецовым в 1910 году. | https://habr.com/ru/post/539816/ | null | ru | null |
# Раскрашиваем значки от гугла
Дизайн приложения — очень важная часть разработки. Google значительно его упрощает, предоставляя в свободном доступе около 150 готовых значков, заготовленных под разную плотность пикселей. Однако по умолчанию они серого цвета. Сделано это специально для того, чтобы дизайнер сам раскрасил их. Но если мы хотим просто придать значкам некоторый цвет — нет смысла редактировать каждый отдельно. Проще написать скрипт, который сделает работу за нас.
В этой статье будет представлена небольшая программка на Java, которая автоматически раскрашивает все значки в заданный цвет, алгоритм, по которому она работает, а также — архив уже раскрашенных значков, которые вы сразу можете использовать в своих приложениях.
Сразу оговорюсь — вполне возможно, что средствами Adobe Illustrator можно сделать всё то, о чём написано в статье и уже есть готовые скрипты. Но его нет под линуксом и вообще он дорого стоит. Думаю, что пользователи Linux и сторонники свободного ПО оценят мой подход.
Вступление
==========
На сайте [developer.android.com](https://developer.android.com/design/downloads/index.html) любой желающий может скачать архив с ресурсами для дизайна, которые, по заявлению в *NOTICE.TXT*, можно использовать без каких-либо ограничений. Среди них есть значки **Action Bar Icons**. Давайте рассмотрим их более подробно. Есть два набора — для тем **Holo Light** и **Holo Dark**. Соответственно, для тёмной темы значки белые, а для белой — серые. Насколько я понял, исходники для значков находятся в формате Adobe Illustrator (\*.ai). Но для меня эта программа слишком дорого стоит, да и вообще я сторонник свободного ПО. Так что мы будем раскрашивать уже заготовленные png файлы, благо их размер уже скорректирован под разную плотность пикселей.
А зачем?
========
Разумеется, крупной компании будет лучше нанять профессионального дизайнера, который нарисует уникальные иконочки с нуля. Или же доработает существующие. Однако если делать небольшое приложение на заказ — нет смысла вводить новый дизайн. Пользователи Android привыкли к стандартному набору значков, к их очертаниям. Мне кажется, что стоит просто придать этим очертаниям цвет и порадовать пользователя.
Но главная польза от таких значков — когда программист делает программу для себя, и у него нет желания и времени заниматься дизайном. Хочется, чтобы программа выглядела как у всех, но при этом предоставляла какие-то свои уникальные функции. Например, если вы начинающий программист и изучаете Android — будет весьма полезно параллельно с обучением разрабатывать какую-нибудь свою программу и продемонстрировать в ней полученные знания. При этом с раскрашенными значками она будет выглядеть значительно лучше.
Что мы имеем
============
Рассмотрим серый набор значков более подробно. Для каждого значка есть четыре версии, соответствующие разной плотности пикселей. Вы в программе всего лишь используете конечное название — например *R.id.ic\_action\_important*, и Android сам выбирает нужную папку. Это очень удобно и выглядит потрясающе в силу того, что на экранах для мобильных устройств ppi значительно выше, чем на обычном мониторе. Изображение кажется более сглаженным.
Кстати говоря, значки довольно универсальны и их можно использовать не только в Action Bar.
Первая проблема, с которой я столкнулся — нет общего обзора всех значков. Двадцать минут программирования — и уже готов Java-код, который пробегается по каталогам и считывает от туда значки, склеивая их в одну общую картинку. Вот она:
Теперь же — попробуем их раскрасить. Я буду использовать для этих целей десктопную Java. Как бы её не ругали, она предоставляет множество готовых и работающих решений. Будем использовать awt — библиотеки для работы с 2D графикой. Первое, что я сделал — подгрузил картиночку в BufferedImage и прошёлся по каждому пикселю, выделив его 4 составляющие (ARGB). Беглый анализ вывода показал, что картинка по сути использует только один цвет — серый. И в тех местах где само изображение сглажено — просто уменьшен альфа канал.
Исходя из этого, чтобы раскрасить значок — нам нужно всего лишь заменить серый цвет на необходимый, без затрагивания альфа канала. Я попробовал взять звёздочку и раскрасить её в синий цвет, а потом протестировать на моём устройстве — и она отлично там смотрелась!
Программа
=========
Поработав ещё некоторое время, я сделал такой скрипт, который перегоняет все значки из библиотеки в заданный цвет. Правда в каталоге должны быть только значки и папки — ничего лишнего.
Думаю, что большинство Android-разработчиков имело хотя бы небольшой опыт с десктопной Джавой — компиляция и запуск не вызовет трудностей. В принципе, тут всё просто.
**Main.java**
```
import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
public class Main {
static final int COLUMNS_COUNT = 15;
static final String DIR_WITH_GRAY_IMAGES = "E:\\wsys\\prj\\ImagePainter\\test\\gray";
static final String OUTPUT_DIR = "E:\\wsys\\prj\\ImagePainter\\test";
static final Color myColor = new Color(177, 0, 140);//Цвет, в который перекрашиваем
static List fileList = new ArrayList<>();
public static void main(String[] strings) throws Throwable {
painter();
}
private static void outputImages(File dir) {
for (File subDir : dir.listFiles()) {
if (subDir.getName().contains("hdpi")) {
File pngFile = subDir.listFiles()[0];
fileList.add(pngFile);
break;
}
if (subDir.isDirectory()) {
outputImages(subDir);
}
}
}
private static void painter() throws Throwable {
File dirWithImages = new File(DIR\_WITH\_GRAY\_IMAGES);
File outputDir = new File(OUTPUT\_DIR);
String nameFolder = Integer.toHexString(myColor.getRGB());
for (File subDir : dirWithImages.listFiles()) {
for (File drawable : subDir.listFiles()) {
System.out.println(drawable);
for (File pngFile : drawable.listFiles()) {
System.out.println(pngFile);
BufferedImage okImage = handlePngFile(pngFile, myColor);
String partPath = pngFile.getAbsolutePath().replace(dirWithImages.getAbsolutePath(), "");
File newPngPath = new File(outputDir.getAbsolutePath() + "\\" + nameFolder + "\\" + partPath);
newPngPath.mkdirs();
ImageIO.write(okImage, "png", newPngPath);
}
}
}
File targetDir = new File(outputDir, "\\" + nameFolder);
outputImages(targetDir);
ImageIO.write(getComplexImage(), "png", new File(targetDir, "all.png"));
}
private static BufferedImage getComplexImage() {
BufferedImage bufferedImage = new BufferedImage(800, 500, BufferedImage.TYPE\_INT\_ARGB);
Graphics g = bufferedImage.getGraphics();
int i = 0;
int j = 0;
int counter = 0;
try {
for (File pngFile : fileList) {
BufferedImage image = ImageIO.read(pngFile);
g.drawImage(image, i, j, null);
i += image.getWidth();
counter++;
if (counter == COLUMNS\_COUNT) {
i = 0;
counter = 0;
j += image.getHeight();
}
}
} catch (Exception e) {
e.printStackTrace();
}
return bufferedImage;
}
private static BufferedImage handlePngFile(File pngFile, Color myColor) {
try {
BufferedImage image = ImageIO.read(pngFile);
for (int i = 0; i < image.getWidth(); i++) {
for (int j = 0; j < image.getHeight(); j++) {
Color pixelColor = new Color(image.getRGB(i, j), true);
int a = pixelColor.getAlpha();
//a += 50;//Повышаем интенсивность - уменьшаем прозрачность
if (pixelColor.getRed() != 0) {
int r = myColor.getRed();
int g = myColor.getGreen();
int b = myColor.getBlue();
Color newColor = new Color(r, g, b, a);
image.setRGB(i, j, newColor.getRGB());
}
}
}
return image;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
```
Архив и заключение
==================
[Выложил](http://kciray.com/files/zip/Action_Bar_Icon_Pack_Colored.zip) уже перекрашенные в разные цвета значки — пользуйтесь на здоровье! Или же можете разобраться со скриптом и перекрасить в тот цвет, который нужен конкретно вам. И не забывайте о том, что все значки с альфа каналом, соответственно на белом фоне они будут выглядеть более светлыми, чем тот цвет, который вы задали для них.
Кроме того, возникла идея написать скрипт, который существующий большой значок меняет под разные размеры со сглаживанием и распихивает по папкам для разной плотности пикселей. Если нет готовых и бесплатных скриптов, которые это делают в автоматическом режиме — обязательно напишу свой и выложу.
Как выяснилось в комментариях, существует сайт <http://romannurik.github.io/AndroidAssetStudio/index.html> который раскрашивает значки более удобно и предоставляет ещё кучу других функций. Правда он обязует указывать обратную ссылку при использовании и не умеет массово обрабатывать значки, так что в моём подходе тоже имеется какой-то смысл. | https://habr.com/ru/post/226307/ | null | ru | null |
# Автоматизация изменений БД в .NET
Здравствуйте!
Я хотел бы рассказать о проектах [Migrator.Net](http://code.google.com/p/migratordotnet/) и [ECM7.Migrator](http://code.google.com/p/ecm7migrator/).
Migrator.Net — это механизм контроля версий базы данных, похожий на Migrations в Ruby on Rails. Migrator позволяет автоматизировать выполнение операций изменения БД и автоматически ведет учет версий.
Migrator написан на C# и будет удобен, в первую очередь, при использовании в проектах под.NET.
Сначала я сделаю небольшой обзор указанных проектов, а потом постараюсь выделить их «плюсы» и «минусы».
##### Основные принципы
Для изменения БД вы создаете сборку, содержащую «миграции». «Миграции» — это классы, каждый из которых описывает небольшое изменение БД.
При написании классов-«миграций» необходимо унаследоваться от специального базового класса Migration и перекрыть 2 метода:* метод Up задает операции над БД, необходимые для перехода к следующей версии БД (например, создание таблицы);
* метод Down задает операции, необходимые для отмены изменений, выполненных методом Up (например, если в методе Up создается новая таблица, то в методе Down она должна удаляться).
Действия, которые необходимо выполнить над БД, задаются на том языке, на котором вы пишете ваш .NET проект. Имеется специальный framework, содержащий классы и методы для выполнения основных операций над БД. Также есть возможность выполнить произвольный SQL-запрос.
##### Пример миграции
> `[Migration(7)]
>
> public class AbstractTestMigration : Migration
>
> {
>
> override public void Up()
>
> {
>
> Database.AddTable("CustomerAddress",
>
> new Column("customer\_id",
>
> DbType.Int32, ColumnProperty.PrimaryKey),
>
>
>
> new Column("address",
>
> DbType.AnsiString, ColumnProperty.NotNull));
>
> }
>
>
>
> override public void Down()
>
> {
>
> Database.RemoveTable("CustomerAddress");
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Давайте разберем, что тут происходит:1. Мы видим, что наш класс-«миграция» помечен атрибутом *[Migration(7)]*. Параметр атрибута — значение типа long, задающее номер версии БД, на который произойдет переход при выполнении изменений из метода Up.
2. Как мы уже говорили, класс-«миграция» должен быть унаследован от базового класса *Migration*. Также класс-«миграция» должен переопределять методы *Up* и *Down* базовго класса.
3. Базовый класс *Migration* имеет свойство *Database*. Это свойство содержит объект, реализующий интерфейс *ITransformationProvider*. Вызывая методы интерфейса *ITransformationProvider* у объекта *Database* можно выполнять операции над БД. Например, в методе *Down* используется *Database.RemoveTable* для удаления таблицы.
Интерфейс *ITransformationProvider* содержит метод `int ExecuteNonQuery(string sql)`, позволяющий выполнить произвольный SQL-запрос.
##### Способы выполнения изменений
Migrator предоставляет несколько способов запуска на выполнение ваших классов-«миграций». 1. Консольное приложение
2. Task для [NAnt](http://en.wikipedia.org/wiki/NAnt)
3. Task для [MsBuild](http://www.rsdn.ru/article/devtools/msbuild-05.xml)
4. Программное выполнение — выполнение «миграций» из вашей программы через API
Каждый из этих способов получает в качестве параметров тип используемой СУБД, строку подключения и номер версии БД, которую необходимо получить.
##### Поддерживаемые СУБД
Migrator.NET может работать с различными СУБД. При запуске «миграций» на выполнение вместе с параметрами подключения к БД мигратору указывается класс-«диалект», при помощи которого формируются SQL-запросы для конкретной СУБД.
В проекте Migrator.NET есть «диалекты» для следующих СУБД: MySQL, Oracle, SQLite, MS SQL Server (в т.ч. CE), PostgreSQL.
##### Отличия проектов Migrator.Net и ECM7.Migrator
В начале этого поста я упомянул вместе с [Migrator.Net](http://code.google.com/p/migratordotnet/) еще один проект: [ECM7.Migrator](http://code.google.com/p/ecm7migrator/). Сейчас я расскажу о нем подробнее.
Весной этого года мы с коллегами узнали про Migrator.NET. Мы попробовали его использовать и нам очень понравилось. Сейчас я использую мигратор на обеих моих работах (в сумме 3 довольно больших проекта, уже работающих в реальных условиях).
К сожалению, оказалось, что Migrator.NET имеет некоторые неудобства, а также его провайдер для Oracle содержит много ошибок (об этом, кстати, написано на главной странице проекта в google code).
За период с мая по сентябрь в Migrator.NET нами было внесено большое количество изменений: переписано несколько классов т.н. «ядра», исправлено много ошибок в оракловом провайдере, несколько «косметических» доработок, делающих использование мигратора более удобным.
В результате, код, который мы дорабатывали настолько разошелся с кодом оригинального проекта, что решено было сделать отдельный проект. Именно он и выложен в google code под названием [ECM7.Migrator](http://code.google.com/p/ecm7migrator/). Также была частично переведена (и исправлена под новый проект) документация.
Кроме того, за ненадобностью была удалена поддержка PostgreSQL.
##### Чем мигратор может вам помочь
1. С мигратором изменения БД удобно распространять. Нет папки с кучей скриптов, вместо нее единственная dll. Думаю, вы оцените это, если вам нужно будет обновить windows-приложение у нескольких сотен пользователей.
2. Миграции удобно писать: проверка на этапе компиляции, intellisense и т.д. Никто не пишет SQL вручную. Обычно его генерируют через GUI. Часто при этом генерируется куча «левых» команд. С мигратором вы можете полностью все контролировать, не затрачивая на это много времени.
3. Миграции удобно выполнять. Как я уже писал, для мигратора имеются таски для NAnt и MSBuild. С ними вы легко сможете выполнять миграции во время автоматизированной сборки вашего проекта. Кроме того, средства программного выполнения миграций делают возможными такие вещи как обновление структуры БД при старте приложения или создание чистой БД для модульных тестов.
4. Миграции не зависят от СУБД. Если честно, мне ни разу еще не приходилось работать над проектом, который должен поддерживать несколько СУБД. Но, возможно, независимость от СУБД тоже кому-то нужна.
5. В миграции легко добавлять произвольную логику. Например, вы можете в цикле создать кучу таблиц или добавить к названию каждой таблицы некоторый префикс, определяемый в настройках приложения.
##### Недостатки
За время моей работы с мигратором я почувствовал два его недостатка:
1. Если человек не любит работать с программами через командную строку (как и я), то для него будет недостатком отсутствие программы с GUI, позволяющей запустить миграции на выполнение. К счастью, эта проблема быстро решилась написанием bat — файла, запускающего консольное приложение мигратора с нужными параметрами.
2. Второе неудобство заключается в том, что когда я пишу миграцию, я не помню названия уже созданных объектов БД. Эту проблему так и не удалось устранить. При написании миграций смотрю названия в GUI или в файлах hbm (у нас во многих проектах используется NHibernate).
##### Чего не может мигратор
Мигратор не избавляет вас от необходимости продумывать структуру БД. Он не генерирует никаких изменений БД автоматом. Это просто более удобный способ *вручную* задать все действия над БД, а также, более удобный способ их выполнить.
##### Заключение
В общем-то это все, что я хотел рассказать о миграторе. Насколько удачным получился рассказ — решать вам.
Я буду очень рад, если кто-то заинтересуется мигратором. Это будет означать, что труды его разработчиков (а значит, и мои тоже) не пропали зря. Я постараюсь всячески помогать таким людям в использовании мигратора — отвечать на вопросы и оперативно исправлять найденные баги.
Всем спасибо за внимание.
— Примечание
Некоторое время назад здесь уже [обсуждался](http://habrahabr.ru/blogs/net/56175/) проект [octalforty Wizardby](http://code.google.com/p/octalforty-wizardby/). Насколько я понял, это еще один мигратор.
К сожалению, очень кратко ознакомился с данным проектом. Основное отличие, которое бросается в глаза — там «миграции» пишутся на специальном языке.
Если вы использовали Wizardby в реальных условиях, напишите мне. Было бы очень интересно узнать о его достоинствах/недостатках и сравнить его с Migrator.NET. | https://habr.com/ru/post/70884/ | null | ru | null |
# 7 странных особенностей Go
[](https://habr.com/ru/company/skillfactory/blog/522222/)
Когда человек начинает писать на непривычном языке программирования, он всегда обращает внимание на его особенности. Новичку бывает сложно понять причины такого дизайна языка. Своим студентам мы даем необходимый контекст, и постепенно они учатся программировать, учитывая и принимая то, что раньше выводило их из равновесия. Автор статьи разбирает особенности Go, которые смущают начинающих.
---
Сразу скажу, что эта статья: мое личное, полностью субъективное мнение. Список ниже — только небольшая выдержка без каких-либо критериев выбора. Для ясности расскажу о себе: у меня около 20 лет опыта работы, я работал с C, C++, Java, Scala, Python, R (если смотреть на R как на язык).
Я нахожу Go легким в изучении. Наверное, благодаря четко определенному замыслу, который устраняет особенности, подразумевающие сложный синтаксис. Так или иначе, я начинаю список.
1. Нежелательное импортирование и лишние переменные
---------------------------------------------------
Go заставляет придерживаться минимализма. Это означает, что бесполезное импортирование и лишние переменные вызовут ошибку компиляции. Например:
```
import (
"fmt"
"os" //not used
)
func main() {
fmt.Println("Hola")
}
```
Компилятор возвращает:
```
imported and not used: "os"
```
2. Итерация по коллекциям
-------------------------
Функция `range`, используемая при итерации по коллекции, возвращает два значения. Первое значение — это позиция элемента в коллекции. Второе значение — это значение самого элемента.
```
x := [4]string{"one","two","three","four"}
for i, entry := range(x) {
fmt.Printf("Element at position %d is %s\n", i, entry)
}
```
Это очень удобно: на каждой итерации есть два наиболее распространенных значения, с которыми можно работать в своих циклах. Но не всегда нужно два значения. Наверное, вы напишете что-то вроде этого:
```
x := [4]string{"one","two","three","four"}
for i, entry := range(x) {
fmt.Printf("Element %s\n", entry)
}
```
И такой код вызовет ошибку компиляции:
```
i declared but not used
```
Или даже хуже, вы пропустите `i`. Вот так:
```
x := [4]string{"one","two","three","four"}
for entry := range(x) {
fmt.Printf("Element %s\n", entry)
}
```
Это может запутать. В переменной возвращается позиция элемента, но можно ожидать его значение.
```
Element %!s(int=0)
Element %!s(int=1)
Element %!s(int=2)
Element %!s(int=3)
```
Как решить проблему? Нужно просто обозначить неиспользуемую переменную `i` вот так:
```
x := [4]string{"one","two","three","four"}
for _, entry := range(x) {
fmt.Printf("Element %s\n", entry)
}
```
3. Видимость атрибутов
----------------------
Атрибуты видимы, когда начинаются с заглавной буквы. Атрибут, который не начинается с заглавной буквы, не видим. Это просто. Но я постоянно забываю об этом и делаю глупые ошибки.
```
type Message struct {
Text string // This is public
text string // This is private
}
```
4. Что с перегрузкой методов?
-----------------------------
Никакой перегрузки методов нет. Если вы пришли из мира Java, скорее всего вы применяли перегрузку методов. В Golang перегрузки методов нет.
5. А наследование?
------------------
Наследования тоже нет. Эту особенность можно обойти, как описано [здесь](https://golangbot.com/inheritance/). Но я не думаю, что это действительно наследование.
6. Интерфейсы в Go
------------------
В отличие от перегрузки методов и наследования, интерфейсы в Go есть. Вы можете определить их как набор из сигнатур методов. Но они странные в сравнении с интерфейсами в других языках. Почему? Потому что вы не указываете программно, что структура реализует интерфейс. Структура автоматически удовлетворяет интерфейсу, когда реализует перечисленные в интерфейсе методы. Это проще понять на примере:
```
package main
import (
"fmt"
)
type Speaker interface {
SayYourName() string
SayHello(b Speaker) string
}
type HappySpeaker struct {}
func(hs HappySpeaker) SayYourName() string {
return "Happy"
}
func(hs HappySpeaker) SayHello(b Speaker) string {
return fmt.Sprintf("Hello %s!",b.SayYourName())
}
type AngrySpeaker struct {}
func(as AngrySpeaker) SayYourName() string {
return "Angry"
}
func(as AngrySpeaker) SayHello(b Speaker) string {
return fmt.Sprintf("I'm not going to say hello to %s!",b.SayYourName())
}
func main() {
// We have two different structs
happy := HappySpeaker{}
angry := AngrySpeaker{}
// they can say their names
fmt.Println(happy.SayYourName())
fmt.Println(angry.SayYourName())
// But they are also speakers
fmt.Println(happy.SayHello(angry))
fmt.Println(angry.SayHello(happy))
// This is also valid
var mrSpeaker Speaker = happy
fmt.Println(mrSpeaker.SayHello(angry))
}
```
Вполне понятно, что такое поведение языка влияет на код. Интерфейсы в Go — тема для подробной дискуссии. Вы найдете множество обсуждений достоинств и недостатков этой особенности языка.
7. Конструкторы
---------------
В Go нет конструкторов, подобных тем, которые вы найдете в объектно-ориентированном языке. Определение структуры на Go очень похоже на определение структуры в языке C. Но есть одна потенциальная проблема: вы можете пропустить инициализацию атрибутов. В коде ниже у `halfMessage1` и `halfMessage2` пустые атрибуты.
```
import (
"fmt"
)
type Message struct {
MsgA string
MsgB string
}
func(m Message) SayIt() {
fmt.Printf("[%s] - [%s]\n",m.MsgA, m.MsgB)
}
func main() {
fullMessage1 := Message{"hello","bye"}
fullMessage2 := Message{MsgA: "hello", MsgB: "bye"}
halfMessage1 := Message{"hello",""}
halfMessage2 := Message{MsgA: "hello"}
emptyMessage := Message{}
fullMessage1.SayIt()
fullMessage2.SayIt()
halfMessage1.SayIt()
halfMessage2.SayIt()
emptyMessage.SayIt()
}
```
Код выше выведет:
```
[hello] - [bye]
[hello] - [bye]
[hello] - []
[hello] - []
[] - []
```
Потенциально это проблема потому, что у вас могут быть методы, которые ожидают каких-то значений. Смягчить ситуацию можно определением статического конструктора.
```
package main
import (
"fmt"
)
type Message struct {
MsgA string
MsgB string
}
func(m Message) SayIt() {
fmt.Printf("[%s] - [%s]\n",m.MsgA, m.MsgB)
}
func NewMessage(msgA string, msgB string) *Message{
if len(msgA) * len(msgB) == 0 {
return nil
}
return &Message{MsgA: msgA, MsgB: msgB}
}
func main() {
// A correct message
msg1 := NewMessage("hello","bye")
if msg1 != nil {
msg1.SayIt()
} else {
fmt.Println("There was an error")
}
// An incorrect message
msg2 := NewMessage("","")
if msg2 != nil {
msg2.SayIt()
} else {
fmt.Println("There was an error")
}
}
```
Заключение
----------
Это была небольшая выборка особенностей, которые следует учитывать, когда вы программируете на Go. А что в нем показалось вам самым странным при программировании на Go?
> [](https://skillfactory.ru/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_banner&utm_term=regular&utm_content=habr_banner)
>
> Получить востребованную профессию с нуля или Level Up по навыкам и зарплате, можно пройдя онлайн-курсы SkillFactory:
>
>
>
> * [Курс «Backend-разработчик на Go»](https://skillfactory.ru/golang-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GO&utm_term=regular&utm_content=071050)
> * [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=071020)
> * [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=051020)
> * [Курс по JavaScript](https://skillfactory.ru/javascript?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FJS&utm_term=regular&utm_content=051020)
>
>
>
>
> **Eще курсы**
> * [Обучение профессии Data Science с нуля](https://skillfactory.ru/data-scientist?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DST&utm_term=regular&utm_content=051020)
> * [Онлайн-буткемп по Data Science](https://skillfactory.ru/data-science-camp?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSTCAMP&utm_term=regular&utm_content=051020)
> * [Онлайн-буткемп по Data Analytics](https://skillfactory.ru/business-analytics-camp?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DACAMP&utm_term=regular&utm_content=051020)
> * [Профессия аналитика с любым стартовым уровнем](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=051020)
> * [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=051020)
> * [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=051020)
> * [Продвинутый курс «Machine Learning Pro + Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=051020)
> * [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=051020)
> * [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=051020)
> * [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=051020)
> * [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=051020)
> * [Профессия Java-разработчик с нуля](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=051020)
> * [Профессия UX-дизайнер с нуля](https://contented.ru/edu/uxdesigner?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_UXS&utm_term=regular&utm_content=051020)
> * [Профессия Web-дизайнер](https://contented.ru/edu/webdesigner?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WBDS&utm_term=regular&utm_content=051020)
>
>
>
>
>
>
> | https://habr.com/ru/post/522222/ | null | ru | null |
# Самую холодную капельку во Вселенной уронили с высокой колокольни
[](https://habr.com/ru/company/ruvds/blog/583058/)
И остались довольны результатом. Теперь хотят отправить ее на орбиту Земли.
Сегодня мы попробуем разобраться в физике пятого состояния материи и выясним, зачем ее сбрасывать с башни.
Бросание игрушек на пол – одно из самых ранних переживаний детства и источник бесконечной радости. Современная физика, какой мы ее знаем сегодня, также основана на последовательном стремлении к этому наивному удивлению по поводу гравитационного притяжения между материальными телами. Вклад Галилея, Ньютона и Эйнштейна в понимание свободного падения определил очертания современной физики.
Общая теория относительности основана на принципе эквивалентности, который гласит, что при свободном падении все объекты падают с одинаковой скоростью, независимо от их массы, при условии, что единственной действующей силой является гравитация. Это было доказано для больших объектов: легенда гласит, что Галилей сделал это первым, сбросив различные шары с Пизанской башни. Остается неясным, справедлива ли эквивалентность в квантовых масштабах, где эффекты гравитации недостаточно изучены. Выяснение этого может помочь создать квантовую теорию гравитации, одну из самых желанных целей современной физики.
Создать квантовый эквивалент теста Галилея непросто. В 2010 году команда под руководством Эрнста Раселя из Ганноверского университета в Германии наблюдала за квантовым объектом в свободном падении, сбросив конденсат Бозе-Эйнштейна вниз со 146-метровой башни. Конденсат Бозе Эйнштейна – облако охлажденных атомов, которое ведет себя как единый квантовый объект. Попробуем разобраться в физике этого странного состояния материи и выясним, зачем ее сбрасывать с башни.
▍ Немного истории
-----------------
Как иногда хочется бросить все и отправиться в двадцатые годы двадцатого века. Но не для того, чтобы нарушить пространственно-временной континуум рукопожатием с Гитлером или Эйнштейном. Всегда не хватало возможности проникнуться атмосферой научной революции: растоптанными надеждами сохранить [классические модели атома](https://habr.com/ru/post/539210/), отчаянием перед парадоксами [релятивизма](https://habr.com/ru/post/572164/), отвращением к зарождающейся [квантовой механике](https://habr.com/ru/post/560510/).
В ноябре 1924 года Луи де Бройль на защите докторской диссертации изложил идеи о волновых свойствах частиц. Комиссия мыслью не прониклась, а вот научный руководитель, [Поль Ланжевен](https://ru.wikipedia.org/wiki/%D0%9B%D0%B0%D0%BD%D0%B6%D0%B5%D0%B2%D0%B5%D0%BD,_%D0%9F%D0%BE%D0%BB%D1%8C), не позволил работе кануть в небытие: сообщил о ней на Сольвеевском конгрессе и настоял на отправке копии Альберту Эйнштейну. Последний был восхищен и использовал наработки в зарождающейся квантовой статистике. В свою очередь, на идеи де Бройля опирался Эрвин Шредингер, когда выводил свое волновое уравнение в 1926 году.
И подумать только, в декабре того же 1924 года была [опубликована](https://link.springer.com/article/10.1007/BF01327326) статья [Шатьендраната Бозе](https://habr.com/ru/company/cloud_mts/blog/520586/), которая заложила основы [статистики Бозе-Эйнштейна](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B0%D1%82%D0%B8%D1%81%D1%82%D0%B8%D0%BA%D0%B0_%D0%91%D0%BE%D0%B7%D0%B5_%E2%80%94_%D0%AD%D0%B9%D0%BD%D1%88%D1%82%D0%B5%D0%B9%D0%BD%D0%B0). Также, в честь индийского ученого все частицы с целочисленным спином были названы бозонами. В чём разница между [фермионами и бозонами](https://habr.com/ru/post/408557/) на хабре уже обсуждалось. Далее Эйнштейн предсказывает существование того, что мы сегодня называем конденсатом Бозе-Эйнштейна. Однако теория была подвергнута критике [Джорджем Уленбеком](https://ru.wikipedia.org/wiki/%D0%A3%D0%BB%D0%B5%D0%BD%D0%B1%D0%B5%D0%BA,_%D0%94%D0%B6%D0%BE%D1%80%D0%B4%D0%B6_%D0%AE%D0%B4%D0%B6%D0%B8%D0%BD). Критика была в основном принята, так что Эйнштейн и другие физики некоторое время воздерживались от дальнейшего обсуждения этого состояния материи.
С 1935 года [Фриц Лондон](https://ru.wikipedia.org/wiki/%D0%9B%D0%BE%D0%BD%D0%B4%D0%BE%D0%BD,_%D0%A4%D1%80%D0%B8%D1%86) разрабатывает идею «макроскопической волновой функции» для теории сверхпроводимости, а в 37-м он услышал про статью о таинственном конденсате. На волне интереса к сверхтекучести и сверхпроводимости «пятое состояние вещества» тоже удостоилось внимания, так как во всех этих явлениях прослеживалась четкая аналогия. И затем в 50-х и 60-х многие важные теоретики атаковали проблему взаимодействия бозе-конденсированного газа. Это чертовски увлекательно: теория была далеко впереди экспериментов в этой области физики. Вплоть до 1995 года. Именно тогда стало возможно достижение вырожденного состояния для атомов щелочных металлов с помощью лазерного охлаждения. И в 2001 году достигших этого рубежа поощрили Нобелевской премией.
▍ Немного теории
----------------
> Так вот, Билли, когда влажность соприкасается с холодной поверхностью стекла образуются холодные капельки, которые мы называем конденсатом…
>
>
>
> ***Полицейский отряд, 1982***
В квантовой статистике частицы классифицируются на две группы: фермионы с полуцелым значением спина и бозоны с целочисленным спином. В любой квантовой системе два фермиона не могут занимать одно и то же квантовое состояние, а у бозонов таких ограничений нет. Это было в статье "[в чём разница между фермионами и бозонами](https://habr.com/ru/post/408557/)", так что не будем повторяться. К слову, и про принцип Паули был весьма интересный материал: "[Что запрещает принцип Паули?](https://habr.com/ru/company/macloud/blog/555522/)", так что нам уже более-менее привычен мир, в котором поворот на 360 градусов [не возвращает в исходную позицию](https://www.youtube.com/watch?v=ACZC_XEyg9U) (не тождественное преобразование). Забавный пример проявления принципа запрета: чудовищная гравитация перерождающейся звезды [может компенсироваться](https://ru.wikipedia.org/wiki/%D0%92%D1%8B%D1%80%D0%BE%D0%B6%D0%B4%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9_%D0%B3%D0%B0%D0%B7) тем, что какие-то там фермиончики не хотят находиться в одном состоянии. (*Не смогу удержаться от настойчивой рекомендации пройти бесплатный [курс по астрофизике на Лекториуме](https://www.lektorium.tv/astrophysics)*).
Бозоны обделены таким отличительным признаком как полуцелый спин. И волновая функция двух бозонов симметрична относительно их перестановок, ведь они идентичны. Это как если бы вам сказали, что при броске двух монет, вероятность выпадения «орел + решка» [равна 1/3](https://www.oreilly.com/library/view/classic-problems-of/9781118314333/chapter12.html). Совсем другая статистика. Бозоны обходят принцип запрета и при должных условиях могут все вместе занять одно состояние. Где взять бозоны? В первую очередь это частицы связанные с полем, из которых наиболее важным примером является фотон. Эти частицы не сохраняются: при изменении полной энергии поля частицы появляются и исчезают. Во вторых, это составные частицы, содержащие четное число фермионов. Число частиц сохраняется, если энергия не превышает энергию диссоциации (~ МэВ в случае ядра). То есть, достаточно, чтобы взаимодействия между композитами имели гораздо более низкую энергию, чем внутренние энергетические уровни. Также к бозонам можно отнести различные квазичастицы, но лучше пока на них не отвлекаться.
Термин «конденсация» происходит от латинского глагола «condensare», что означает прижиматься, уплотняться. Особенность конденсации Бозе-Эйнштейна заключается в том, что частицы не сближаются друг с другом в реальном пространстве, но они делают это в импульсном пространстве: многие частицы имеют тенденцию конденсироваться в состояние с наименьшим импульсом (соответствующему нулевой скорости), оставаясь при этом делокализованными в пространстве.
[](https://www.science.org/doi/abs/10.1126/science.269.5221.198)
Когда эту иллюстрацию используют в популярных статьях, частенько выбирают минималистичный вариант без стрелочек и подписей, так что информативность теряется. В детстве я так себе и представлял пятое состояние материи – на поверхности флуктуирующей жидкости вырастает холмик сверхтекучего вещества. На самом же деле, это будет маленькая капля парящая в магнитной ловушке, а конденсация происходит именно по скоростям частиц, которые начинают теснится в основном состоянии с минимальной энергией.
Как помнится, в квантовой механике каждая частица с импульсом p имеет длину волны де Бройля *λ = h/p*, где *h* – постоянная Планка. Мы можем думать о *λ* как о типичном размере волнового пакета, связанного с частицей. Если мы рассмотрим процессы, связанные с масштабами, намного превышающими *λ*, то мы можем смело использовать классическую механику. И наоборот, на расстояниях порядка *λ* (или меньше) доминирует квантовая механика.
Вспомним классическую физику: наполним контейнер неидеальным газом и начнем снижать температуру. Плотность газа остается постоянной до тех пор, пока не произойдет конденсация. Поскольку плотность жидкости намного выше, чем у газа, то в дальнейшем плотность газа уменьшается с температурой. То есть, при понижении температуры, молекулы газа уменьшают свою среднюю скорость и начинают сближаться друг с другом, поскольку между ними начинает доминировать притяжение. Происходит фазовый переход из газовой фазы низкой плотности в жидкую фазу более высокой плотности.
При определенных плотностях длины волн де Бройля частиц становятся сопоставимы с расстояниями между ними. Еще одной важной величиной будет характерный масштаб взаимодействия между частицами – расстояние, на котором два бозона начинают ощущать притягательное взаимодействие между друг другом. В эксперименте обычно систему охлаждают, одновременно удаляя некоторые бозоны, так что их среднее расстояние остается достаточно большим, а взаимодействие между ними незначительно. Метод называется [испарительным охлаждением](https://ru.wikipedia.org/wiki/%D0%98%D1%81%D0%BF%D0%B0%D1%80%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D0%BE%D1%85%D0%BB%D0%B0%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5): бозоны с высокими энергиями избирательно удаляются, так что система остывает до нанокельвинов, а плотность поддерживается низкой.
При экстремальном охлаждении бозонов, их длины волны де Бройля становятся больше, и поэтому неопределенность их положения возрастает. И они начинают занимать одно и то же квантовое состояние – основное состояние. Таким образом, у нас получается большое количество бозонов в одном и том же квантовом состоянии. Они неразличимы и делокализованы. Это означает, что мы можем описать систему этих частиц одной макроскопической волновой функцией.
▍ Немного квантмеха
-------------------
Окей, у нас есть одна волновая функция, и она описывает состояние кучи частиц. Нам нужна формула, которая бы отображала динамику бозе-конденсата. Эволюция квантовой системы подчиняется уравнению Шредингера:
Странно, почему адекватные люди не используют шрёдингериан… Конечно, мы могли бы пойти по строгому пути, поднять вторичное квантование и начать играть с уравнением Гейзенберга, но чтоб статья не ушла в рейтинг 18+, будем применять мягкую и интуитивную последовательность преобразований. Для начала, рассмотрим содержимое только что введенного супероператора, опуская для простоты значки вектора:
Гамильтониан многих частиц. Если представлять их себе как стукающиеся шарики, то у нас записано выражение для суммарной энергии системы: кинетических энергий каждого шарика и потенциальных взаимодействий. У шариков есть импульсы и они чувствуют внешнее (external) поле, а также, влияют каждый на друг друга. Взрослые же люди здесь видят лишь операторы действующие на вектор состояния в гильбертовом пространстве.
Зависящее от времени уравнение Шредингера для многих тел является уравнением Эйлера-Лагранжа следующего функционала действия:
Второе тождество заключает в себе суть вариационного принципа Дирака-Френкеля, характеризующегося стационарностью квантового эффективного действия. Вариационный принцип в физике – это альтернативный метод определения состояния или динамики физической системы путем идентификации ее как экстремума (*минимума, максимума или седловой точки*) функции или функционала.
В случае чистого конденсата Бозе-Эйнштейна предполагается, что все бозоны находятся на одной и той же зависящей от времени одночастичной орбитали ([анзац Хартри](http://cmt.dur.ac.uk/sjc/thesis_prt/node23.html))
Для пущей понятности приведены две формы записи: волновые функции и кеты с тензорными произведениями. Данное приближение подразумевает, что частицы независимы и взаимодействуют только через кулоновский потенциал среднего поля. В конце концов у нас будет нелинейная динамика с малыми, но ненулевыми взаимодействиями и энергиями возбуждения.
Теперь начинаем аккуратненько перебирать слагаемые из шрёдингериана:
Здесь мы вспомнили как находить производную произведения. Судьба редко предоставляет случай воспользоваться таким навыком, так что наслаждаемся.
Бозоны независимы и это упрощает задачу: для кинетической энергии и внешнего потенциала получается набор интегралов по объему – по одному на каждую частицу, и каждый записан в наимилейшей «бра-кет»-нотации. А для метаморфозов треугольничков используются [тождества Грина](https://mathworld.wolfram.com/GreensIdentities.html). Даже если непонятно что происходит, следует хотя бы насладиться красотой формул.
Ранее указывалось, что мы работаем с разреженными газами – типичное межатомное расстояние намного больше, чем диапазон потенциального взаимодействия. Как следствие, взаимодействия могут с высокой степенью точности рассматриваться как события рассеяния двух тел. И для разреженного газа бозонов тогда можно использовать псевдо-потенциал Ферми:
Длина рассеяния  измеряет интенсивность взаимодействий между бозонами, а дельта-функция показывает, что взаимодействие частиц включается при «столкновении». Так-то в реальном мире взаимодействия могут действовать далеко, корреляции нет-нет да сохраняются на больших пространственных и временных масштабах, и частенько кажется, что для постижения естества нужно учитывать связь всего со всем. Но почти всегда эти связи имеют пренебрежимо малые порядки малости и тонут в фоновых шумах, так что их можно смело отбрасывать, а астрологи и эзотерики идут лесом.
Ну вот, теперь у нас есть четыре слагаемых шрёдингериана заключенные в «ско» и «бки», и у каждого торчит константа *N*. Избавимся от нее перенормировкой и соберем все вместе:
Получился самый что ни на есть замечательный гроссапитаевскиан! И как известно, из гроссопитаевскиана совершенно непринужденно получается [уравнение Гросса-Питаевского](https://en.wikipedia.org/wiki/Gross%E2%80%93Pitaevskii_equation)
![$\frac{\delta S}{\delta\psi^*} = \left[i\hbar\partial_t-\frac{p^2}{2m}-V_{ext}-\sigma|\psi|^2\right ]\psi\\ i\hbar\frac{\partial\psi}{\partial t}=\left(-\frac{\hbar^2}{2m}\nabla^2+V_{ext}+\sigma|\psi|^2\right )\psi$](https://habrastorage.org/getpro/habr/formulas/65b/00e/e5a/65b00ee5a8f4b4bfe32363737bbf37d0.svg)
Также его называют просто нелинейным уравнением Шрёдингера. Существует множество вариаций данного уравнения отличающихся характером нелинейности (*дополнительные слагаемые высших степеней, логарифмическая нелинейность и т. д.*). Самое интересное, что это уравнение находит применение во многих областях: физика плазмы, нелинейная оптика, квантовая химия, материаловедение, биология и сверхтекучие жидкости. Наиболее интересные применения мы еще рассмотрим в следующих статьях.
▍ Немного кодинга
-----------------
Уравнение Гросса-Питаевского – это уравнение в частных производных. Самым наивным способом его решения будет применение конечных разностей. Есть также более специфичные методы типа схемы Дюфорта-Франкела или релаксации Бессе. Но на первый раз мы позволим себе готовый солвер и не будем заглядывать под капот, а уже в следующей статье разберем всю подноготную.
Для решения уравнения воспользуемся пакетом [QuantumOptics.jl](https://qojulia.org/). Это вычислительная платформа с открытым исходным кодом, созданная для моделирования и исследования открытых квантовых систем. Пакет выполнен на языке [Julia](https://habr.com/ru/hub/julia/) и призван быть интуитивно понятным в использовании с лучшей производительностью, чем у альтернатив, таких как [Quantum Toolbox](https://qutip.org/) в Python или [Quantum Optics Toolbox](https://qo.phy.auckland.ac.nz/toolbox/) в Matlab. В QuantumOptics.jl существуют различные базисы, которые используются для формализации задачи. После определения базиса задаются квантовые объекты, такие как состояния и операторы, которые «знают», в каком базисе они определены. Невозможно по ошибке применить оператор к состоянию, которое не находится в том же базисе. Кроме того, есть возможность применять различные временные эволюции или другие операции к квантовым объектам. Следует отметить, что QuantumOptics.jl поставляется с исчерпывающей и очень полезной документацией со множеством примеров.
Разберем тривиальнейший случай моделирования частицы в гармонической ловушке:
В первую очередь необходимо задать базис. Для частиц есть два распространенных варианта. Мы можем работать в координатном (*реальном*) или импульсном пространстве.
```
using QuantumOptics, PyPlot
m = 1.
ω = 0.5
xmin = -5
xmax = 5
Npoints = 100
b_position = PositionBasis(xmin, xmax, Npoints)
p = momentum(b_position) # Dense operator
x = position(b_position) # Sparse operator
H = p^2/2m + 1/2*m*ω^2*dense(x^2)
```
Пространственный базис определяется диапазоном позиций от  до . Количество точек N в конечном счете определяет размерность базиса. Конечно, мы могли бы также поработать в импульсном пространстве:
```
b_momentum = MomentumBasis(b_position);
p = momentum(b_momentum) # Sparse operator
x = position(b_momentum) # Dense operator
H = dense(p^2)/2m + 1/2*m*ω^2*x^2
```
Однако оба варианта не являются оптимальными, поскольку в реальном пространстве оператор координаты является диагональным, в то время как оператор импульса представляет собой плотную матрицу, и наоборот для пространства импульса. Следовательно, расчет будет масштабироваться как *N²*, где *N* – размерность гильбертова пространства. Обычно используется трюк заключаемый в использовании быстрого преобразования Фурье для преобразования состояния системы между реальным и импульсным пространством. Это позволяет всегда использовать диагональную форму операторов, которая в целом ускоряет вычисления до *N log N*.
Эта идея реализуется оператором *transform*, который выполняет быстрое преобразование Фурье переводя состояние из координатного в импульсное пространство:
```
T_px = transform(b_momentum, b_position)
T_xp = dagger(T_px)
x = position(b_position)
p = momentum(b_momentum)
H_kin = LazyProduct(T_xp, p^2/2m, T_px)
V = ω*x^2
H = LazySum(H_kin, V)
```
Чтобы использовать этот оператор в гамильтониане, нам дополнительно нужна концепция ленивых операторов, которые позволяют откладывать определенные операции на более поздний этап моделирования. Например, *LazyProduct* позволяет выполнять *A\*(B∗x)* вместо *(A∗B)∗x*. Это означает для нашего случая, что произведение матрицы на матрицу не будет вычисляться напрямую, а вместо этого происходит только два умножения матрицы на вектор. То есть, происходит задержка вычислений до тех пор, пока оператор не будет применен к состоянию.
Наконец, мы можем смоделировать эволюцию системы подчиняющуюся уравнению Шредингера
```
x0 = 1.5
p0 = 0
sigma0 = 0.6
Ψ0 = gaussianstate(b_position, x0, p0, sigma0);
# эволюция во времени
T = [0:0.1:3;]
tout, Ψt = timeevolution.schroedinger(T, Ψ0, H);
# иллюстрация плотности вероятности
x_points = samplepoints(b_position)
n = abs.(Ψ0.data).^2
V = ω*x_points.^2
C = maximum(V)/maximum(n)
figure(figsize=(6,3))
xlabel(L"x")
ylabel(L"| \Psi(t) |^2")
plot(x_points, (V.-3)./C, "k--")
for i=1:length(T)
Ψ = Ψt[i]
n .= abs.(Ψ.data).^2
plot(x_points, n, "C0", alpha=0.9*(float(i)/length(T))^8+0.1)
end
```
Уравнение Гросса-Питаевского будет отличаться лишь наличием нелинейности. Аналитическим решением данного уравнения является [солитон](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D0%BB%D0%B8%D1%82%D0%BE%D0%BD), так что добавим возможность сравнения численного решения с аналитикой, завернем все в одну функцию и упростим нагрузку на средства построения графиков выбором из решения фиксированного количества точек.
**Код**
```
using Plots, QuantumOptics
cd(s"C:\Users\User\Desktop\Mycop\plots")
soliton( x, t = 0, x₀=2., A₀=2.0, vx = -4.0 ) =
A₀*exp(im*(vx*x + (A₀^2-vx^2)*0.5*t)) * sech(A₀*(x-x₀-vx*t));
function nlse_qo( psi0, Vext, Nx, Nt; dt = 0.0005, α = 0.5, σ = 1.0,
scale = 128, xbox = (-10, 10) )
dx = (xbox[2]-xbox[1]) / Nx
T = range(0, step = dt, length = Nt)
tcut = Nt ÷ scale
xcut = Nx ÷ scale
xscaled = xcut:xcut:Nx
tscaled = tcut:tcut:Nt
bx = PositionBasis(xbox[1], xbox[2], Nx)
X = samplepoints(bx)
bp = MomentumBasis(bx)
Tpx = transform(bp, bx)
Txp = dagger(Tpx)
p = momentum(bp)
V = Vext( position(bx) )
Hkin = LazyProduct(Txp, α*p^2, Tpx)
Hψ = diagonaloperator( bx, Ket(bx).data ) #∝|ψ|²
Ho = LazySum(Hkin, Hψ, V )
function H(t, ψ)
Hψ.data.nzval .= -σ*abs2.(ψ.data)
return Ho
end
ψo = Ket(bx, psi0.(X))
tout, ψt = timeevolution.schroedinger_dynamic(T, ψo, H)
psi = [ ψ.data[j] for j = xscaled, ψ=ψt[tscaled] ]
psiex = [ psi0(x, j*dt) for x in X[xscaled], j in tscaled ]
return X[xscaled], T[tscaled], psi, psiex
end
@time X0, T0, psi0, psiex = nlse_qo(soliton, x-> 0.0*x, 256, 2^17,
dt = 2e-5, scale = 128, xbox = (-4π, 2π));
contour(T0, X0, real.(psi0), colorbar = true, fill = false)
p1 = xaxis!("t"); yaxis!("x")
plot(T0, [ sum(abs2.( psi0[:,i]-psiex[:,i] ) ) for i ∈ 1:length(T0) ],
lab = "error" )
p2 = xaxis!("t"); yaxis!("∑|ψᵢ-ψᵢᵉˣ|²") # exact
plot(p1, p2, layout = (1,2) )
```
На левом изображении контур решения – путешествие солитона во времени. Первый пуск вычислений идет гораздо дольше: помимо главной джулийской боли *time-for-first-plot* еще приходится ждать разогрева ленивых операторов, зато потом считает как по маслу. Добавим-ка теперь гармонический потенциал:
```
@time X, T, psi5, psiex = nlse_qo(soliton, x-> 0.5*x^2, 256, 2^17,
dt = 4.9e-5, scale = 256, xbox = (-3π, 3π));
contour(T, X, real.(psi5), colorbar = true, fill = true)
xaxis!("t"); yaxis!("x")
```
Солитон зажатый в ловушке! Но красивей будет в динамике
```
Y = 0.5*X.^2
Y /= maximum(Y)
anim = @animate for i ∈ 1:length(T)
psi_i = real.( psi5[:,i] )
psi_i /= maximum(abs.(psi_i))
psabs = abs2.( psi5[:,i] )
psabs /= maximum(psabs)
plot( X, psi_i, line = (2, :red), marker = (5, 0.8, :red) )
plot!(X, Y + psabs, line = (1, :gray), fill = (0, 0.4, :gray) )
plot!(X, Y, line = (3, :dash, :blue), legend = false )
yaxis!((-1, 2))
end
gif(anim, "1d_BEC.gif", fps = 10)
```
*Синее — потенциал, красное — реальная часть комплекснозначного решения, серое — абсолютная часть, зеленое — материальное поощрение за мои старания*
Хороший способ визуализации эмоциональных качелей посредством моделирования динамики солитона в конденсате Бозе-Эйнштейна! Теперь дело за малым – обобщить на двух- и трехмерный случай, задать соответствующие значения параметрам и вперед, моделировать капельки и пузырьки в магнитной ловушке. И что примечательно, результаты очень неплохо согласуются с экспериментами, например, вот череда снимков, где верхняя строка – реальный бозе-конденсат, а нижняя – численное решение уравнения Гросса-Питаевского:
*Ширина каждой рамки 70 мкм. Так как получение изображения разрушительный процесс, то каждому снимку соответствует новый КБЭ*
И теперь пришло время перейти к вопросу, который меня мучает с начальных классов: как делают бозе-конденсаты.
▍ Эксперименты
--------------
Итак, берем разреженный газ бозонов, для чего сойдет рубидий, литий, натрий, гелий, калий, хром или, скажем, иттербий (разумеется, подойдет не всякий изотоп). Мы помним, что частица поглотит фотон, если его частота чётенько соответствует разности между уровнями энергий для состояний, которые эта частица может занимать. Значит, для нашего разреженного газа нейтральных атомов применимо лазерное охлаждение: настраиваем частоту лазера чуть меньше этой разности энергий, и тогда атом рассеивает (поглощает и повторно излучает) фотоны только в том случае, если он движется в направлении лазера (эффект Доплера). Атом, находящийся в состоянии покоя или движущийся в противоположном направлении, не рассеивается. Если резонансный фотон поглощается, атом переизлучает фотон с большей частотой в произвольном направлении и при этом тормозится. Скорость движения падает и газ охлаждается.
Этого хватит, чтобы дойти до температур порядка микрокельвина. В такой ситуации скорость атома будет около нескольких см/с, а медленно движущиеся атомы относительно легко заключить в неоднородную магнитную ловушку. Магнитное поле имеет минимальное значение в центре «магнитной чаши». Атом со спином, параллельным магнитному полю (т. е. атомный магнитный момент полю антипараллелен), притягивается к минимуму; для спина, антипараллельного полю, атом отталкивается от минимума. Частицы стекаются в чашу, потихоньку копошатся, стукаются между собой и те, что поэнергичней, ловушку покидают, тем самым понижая энергию системы. Это аналогично испарению воды – процессу, из-за которого мы чувствуем прохладу выходя из душа.
А дальше можно догнаться радиочастотным принудительным испарительным охлаждением. Резонансное возбуждение переворачивает спины, и определенные атомы (с более высокой энергией) выбрасываются (испаряются). Но стоит помнить, что хотя взаимодействия слабы в полученной испарине, они достаточно сильны для фазового перехода пар-твердое тело при сверхнизких температурах. В условиях теплового равновесия сложно откачивать энергию без разделения фаз. И как сделать, чтобы весь газ вдруг не обратился в лед? Ключ к успеху – метастабильность. Если процесс охлаждения достаточно медленный и «мягкий», можно получить «сверхнасыщенный» пар без образования кристаллической фазы. Для этого необходимо исключить не только взаимодействие со стенками, но и столкновения трех частиц, которые способствуют образованию молекул и, в конечном счете, фазы конденсированного вещества высокой плотности.
И на последнем этапе, для наблюдения за распределением скоростей атомов в системе магнитная ловушка выключается. Атомы оказываются в свободном пространстве, и, поскольку у них есть некоторая остаточная скорость, они просто разлетаются по сторонами, а полученное облако фоткается лазером. Вот и весь эксперимент.
Ладушки, у нас есть облако сотен тысяч атомов композитных бозонов, которые были охлаждены до температуры нанокельвина с помощью лазеров и магнитных полей. При таких температурах все атомы ведут себя вместе как единый квантовый объект. Этот объект обладает такой низкой энергией, что его можно использовать для определения очень низких магнитных полей, свойство, которое используется для исследования новых материалов, таких как нанопроволоки серебра, наноматериалы из нитрида кремния или для исследования [ионных каналов](https://habr.com/ru/post/543440/) в биологических клетках. В общем, КБЭ отличный [квантовый сенсор](https://postnauka.ru/longreads/156089). И такой сенсор можно использовать для гравиметрии.
 В настоящее время гравитационное поле Земли находится под более пристальным вниманием, чем когда-либо прежде. С одной стороны, интересна сложная геодинамика классического гравитационного поля Земли. От приливных движений океанов и потоков атмосферных масс до мельчайших колебаний мгновенных осей вращения Земли из-за движения жидкого ядра, все такие эффекты становятся измеримыми. Это делается либо с помощью наземных гравитометров, которые измеряют зависящее от времени локальное ускорение, либо в космосе, где спутниковые геодезические измерения устанавливают более жесткие ограничения на более высокие мультипольные моменты гравитационного потенциала. Другое направление исследований больше фокусируется на фундаментальных аспектах гравитации, вытекающих из общей теории относительности. И тут эйнштейновский конденсат помогает проверить эйнштейновский принцип эквивалентности.
Ранее отмечалось, что для удержания конденсата БЭ нужно магнитное поле, что применимо к однотипным атомам – поле настраивается под конкретное вещество, а хотелось бы проводить сравнительный анализ смесей. Еще конденсат чувствителен к гравитации, которая выбивает атомы из ловушки и препятствует эффективному охлаждению. Эта чувствительность как раз и позволяет использовать конденсат Бозе-Эйнштейна для сверхчувствительных инерционных акселерометров. Также гравитация уменьшает время наблюдения за облаком квантового газа: после освобождения из магнитной ловушки оно просто падает на стенку испытательной камеры. И в то же время, для изучения гравитации хотелось бы поместить свободно расширяющийся КБЭ в интерферометр, так как интерференционная картина будет частично зависеть от гравитационных эффектов, обусловленных массой атомов. В общем, у нас достаточно оснований, чтобы отправить бозе-газ вместе со всем измерительным оборудованием в свободное падение.
*Схема эксперимента: капсула с оборудованием спускается по шахте с высоты 120 метров*
В 2010 году, охладив газ из атомов рубидия до девяти миллиардных долей градуса выше абсолютного нуля, исследователи спустили экспериментальную капсулу со всем оборудованием и конденсатом по шахте внутри 146-метровой башни, построенной для исследования микрогравитации в Бременском университете в Германии. И так 180 раз по три капли в день. На дне шахты капсулу встречает 8 метров полистироловых шариков – а людей туда прыгать пускают? Короче идея состояла в том, чтобы заставить квантовый объект свободно расширяться во время падения, которое длится около 5 секунд. Но для наблюдения выходит окно в одну секунду, так как часть времени уходит на контроль остаточных колебаний и прочие издержки.
А уже в этом году [удалось получить](https://physics.aps.org/articles/v14/119) долгоживущий квантовый газ с температурой 38 пК – половина десятимиллиардной доли градуса выше абсолютного нуля! Использовалась новая техника 3D-коллимации: ловкое сочетание режима включения-выключения магнитной линзы с коллективным колебательным возбуждением конденсата позволяет увеличить время жизни осциллирующей капли и сохранение низкой температуры. Настраивая как время колебаний при выходе конденсата, так и силу потенциала магнитной линзы, этот новый метод дает возможность конструировать и контролировать форму облака квантового газа, что дает материал живущий несколько десятков секунд. Он пригодится для высокоточного обнаружения гравитационных волн, измерения гравитационной постоянной и приливной силы тяжести, а также для поиска [сверхлегкой темной материи](https://doi.org/10.1103/PhysRevD.93.103520) и строгой проверки принципа эквивалентности Эйнштейна.
Далее стоит обратить внимание на [полноценную интерферометрию](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.110.093602) свободного бозе-конденсата, [полет с 240 километров](https://nplus1.ru/news/2018/10/17/bose-microgravity) и [эксперименты на МКС](https://nplus1.ru/news/2020/06/11/BEC-orbit). А главным рубежом будет тестирование теорий квантовой гравитации, для чего пора накапливать эмпирические данные. И капелька сверхохлажденного квантового газа должна в этом помочь.
#### ▍ Ссылкография
1. Вывод УГП вторичным квантованием смотрим в [Physics of Low-Dimensional Ultracold Bose Gases](https://arxiv.org/abs/1302.0470.pdf), [Solitons in Bose-Einstein Condensates](https://d-nb.info/1079391568/34), [The Gross-Pitaevskii Equation and Bose-Einstein condensates](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.904.3865&rep=rep1&type=pdf), и если запутают коммутаторы, то помощь есть на [stackexchange](https://physics.stackexchange.com/questions/543920/help-with-the-derivation-of-the-gross-pitaevskii-equation), а теорию рассеяния смотрим в [Chapter 3 The Gross-Pitaevskii equation](https://ethz.ch/content/dam/ethz/special-interest/phys/theoretical-physics/cmtm-dam/documents/qg/Chapter_03.pdf).
2. [Quantum Bubbles in Microgravity, Generating Solitons by Phase Engineering of a Bose-Einstein Condensate](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.125.010402) — эксперименты с солитонами в КБЭ.
3. [Testing weakest force with coldest spot](https://link.springer.com/content/pdf/10.1140%2Fepjc%2Fs10052-021-09102-y)
4. [Mathematical Models & Numerical Simulation for Bose-Einstein Condensation](https://cpb-us-w2.wpmucdn.com/blog.nus.edu.sg/dist/4/11813/files/2019/05/Lecture-BEC.pdf)
5. [Bachelor-Thesis 2D Solitons in QuantumOptics.jl](https://www.uibk.ac.at/th-physik/cqed/theses/bachelorthesis_ertel_bernhard.pdf)
6. [Dropping cold quantum gases on Earth over long times and large distances](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.76.063617) 2008 — самая userfriendly статья, что я видел в жизни
7. [Bose-Einstein Condensation in Microgravity](https://www.science.org/doi/abs/10.1126/science.1189164) 2010
8. [Физики впервые получили бозе-конденсат в невесомости](https://nplus1.ru/news/2018/10/17/bose-microgravity) 2018
9. [Бозе-конденсат на МКС показал рекордное время свободного расширения](https://nplus1.ru/news/2020/06/11/BEC-orbit) 2020
10. [Quantum gravity could soon be tested using ultracold atoms](https://physicsworld.com/a/quantum-gravity-could-soon-be-tested-using-ultracold-atoms/) 2021
11. [The Bose-Einstein Condensate and Cold Atom Laboratory](https://epjquantumtechnology.springeropen.com/track/pdf/10.1140/epjqt/s40507-020-00090-8.pdf) 2021
**Намёк**
*sci-hub нынче обитается на [www.sci-hub.ru](https://www.sci-hub.ru)*
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Yermack&utm_content=samuyu_xolodnuyu_kapelku_vo_vselennoj_uronili_s_vysokoj_kolokolni) | https://habr.com/ru/post/583058/ | null | ru | null |
# Flutter. MVVM. Начало
Доброго времени суток, дорогие читатели! Меня зовут [Сурен](https://habr.com/ru/users/avenumDev/), и я разработчик.
Поскольку моя предыдущая статья о том, [как бекендер в мобильную кроссплатформу лез](https://habr.com/ru/company/digdes/blog/588018/), не утонула в минусах, я решил продолжить делиться своим опытом познания данной замечательной технологии =)
Написано немало статей про MVVM, его реализацию на различных технологиях и на Flutter, в частности. Но мне они давались с трудом, и не было понимания, как оно в итоге работает. Возможно, сказывается особенность восприятия “Бекендера” =) Поэтому, если среди читателей есть люди с похожим складом ума, возможно эта статья поможет и Вам понять, что такое MVVM и как его реализовать на Flutter простым способом.
### Для начала немного википедии.
MVVM (Model-View-ViewModel) — шаблон проектирования архитектуры приложения. Пришел на смену шаблону MVC|MVP (Model-View-Controller/Presenter). Актуален для платформ, в которых присутствует концепция «связывания данных», позволяющая связывать данные с визуальными элементами в обе стороны. На схеме это выглядит так:
Где
* **Model** представляет из себя слой бизнес-логики, который включает описание фундаментальных данных, необходимых для работы приложения, и логику работы с ними.
* **View** является графическим интерфейсом. Подписан на изменения ViewModel, а при действиях с интерфейсом вызывает команды ViewModel для изменения данных в Модели.
* **ViewModel** же с одной стороны — абстракция Представления, а с другой — обёртка данных из Модели, подлежащих связыванию. То есть она содержит Модель, преобразованную к Представлению, а также команды, которыми может пользоваться Представление, чтобы влиять на Модель.
### Перейдем к практике.
Для обеспечения “связывания данных” я использую связку Provider+ChangeNotifier. Provider представляет собой смесь Инъекции Зависимостей (Dependency Injection или DI) и управления состоянием, а ChangeNotifier позволяет отслеживать изменения ViewModel и перестраивать наш UI.
Построим простейший ToDoList на данном подходе и попутно будем разбираться, как он работает.
*Внимание! В качестве примера для наглядности и удобства я буду реализовывать каждый виджет в одном файле, то есть и ViewModel, и View(Виджет) и его Model. Но на боевых проектах, особенно если вы работаете в команде, эти сущности нужно разносить по разным файлам.*
Для начала создадим новый проект приложения на flutter. Перед нами откроется чистый проект, представляющий из себя приложение счетчик или кликер.
В main.dart у нас реализован основной метод main(), запускающий приложение MyApp, которое состоит из 1 StatefullWidget - MyHomePage, реализующего счетчик нажатий. Приложение можно запустить и проверить, что все работает.
Но мы собрались делать ToDoList, следовательно пока оставляем main.dart. Создаем рядом новый файл todo\_list\_widget.dart, а в нем классы:
* \_ViewModel, реализующий ChangeNotifier,
* ToDoListWidget, реализующий StatelessWidget,
* \_ModelState, в котором мы будем хранить состояние нашей модели.
todo\_list\_widget.dart
```
class _ModelState {}
class _ViewModel extends ChangeNotifier {}
class ToDoListWidget extends StatelessWidget {
const ToDoListWidget({Key? key}) : super(key: key);
@override
Widget build(BuildContext context) {
var _viewModel = context.watch<_ViewModel>();
return Container();
}
}
```
В Dart символ “\_” перед именем свойства/класса/метода делает его приватным (доступным только в пределах текущего файла .dart).
Добавим файл todo\_item.dart и реализуем в нем класс Модели ToDoItem. Цель — сделать некий список дел, так что свойства нужные нам в данном классе:
* name - наименование задачи (по совместительству ключ),
* done - флаг о выполнении.
Также, чтобы у нас была возможность “редактировать” элементы списка, добавим метод copyWith. Наш класс модели будет выглядеть следующим образом:
Класс ToDoItem
```
class ToDoItem {
final String name;
final bool done;
ToDoItem({
required this.name,
this.done = false,
});
ToDoItem copyWith({
String? name,
bool? done,
}) {
return ToDoItem(
name: name ?? this.name,
done: done ?? this.done,
);
}
}
```
Возвращаемся к основному.
В стейте мы будем хранить список элементов ToDo листа. Для обеспечения иммутабельности список у нас будет “final”, а для редактирования мы будем его копировать, поэтому добавим метод “copyWith”. В нашем случае отдельный стейт выглядит как “бойлерплейт“, но для наглядности и последующего масштабирования он полезен.
После этих манипуляций класс принял следующий вид:
todo\_list\_widget.dart
```
class _ModelState {
final List items;
\_ModelState({
this.items = const [],
});
\_ModelState copyWith({
List? items,
}) {
return \_ModelState(
items: items ?? this.items,
);
}
}
```
Переходим к ViewModel, поскольку задача данного класса — быть прослойкой между интерфейсом и данными. С одной стороны мы должны в нем следить за изменениями модели и дергать перестраивание интерфейса, а с другой — должны иметь методы воздействия на эту модель. Добавим в него private свойство “\_state” и дополним публичным сеттером и геттером. Геттер возвращает приватный стейт, а сеттер заменяет его новым значением и уведомляет прослушивающие виджеты при изменении стейта.
\_ModelState
```
var _state = _ModelState();
_ModelState get state => _state;
set state(_ModelState val) {
_state = _state.copyWith(items: val.items);
notifyListeners();
}
```
“notifyListeners” — метод в классе “ChangeNotifier”, уведомляющий виджетов-слушателей об изменении модели и дающий команду перестроиться.
**Для реализации ToDo списка нам нужны следующие методы:**
Добавления элемента в список
```
addItem(ToDoItem item) {
var list = state.items.toList();
if (list.any((element) => element.name == item.name)) {
throw Error();
} else {
list.add(item);
state = state.copyWith(items: list);
}
}
```
Удаления элемента из списка
```
dellItem(ToDoItem item) {
var list = state.items.toList();
list.removeWhere((element) => element.name == item.name);
state = state.copyWith(items: list);
}
```
Переключения состояния элемента списка
```
toogleItem(ToDoItem item) {
var list = state.items.toList();
var index = list.indexWhere((element) => element.name == item.name);
list[index] = item.copyWith(done: !item.done);
state = state.copyWith(items: list);
}
```
После каждого действия мы вызываем Сеттер стейта для того, чтобы уведомить об изменении слушателей и перестроить стейт.
На первый взгляд основная логика готова, так что перейдем к View (виджету).
Пришло время добавить в проект пакет Provider. Для этого можно либо отредактировать файл *pubspec.yaml,* добавив в него зависимость от пакета Provider, либо выполнив команду в консоли:
**flutter pub add provider** — данная команда, собственно, и добавит зависимость в тот же файл и скачает пакет последней версии.
Чтобы наш виджет мог реагировать на изменение стейта, для начала обернем его в ChangeNotifierProvider. В метод создания мы передаем нашу ViewModel, а в качестве ребенка — наш Виджет. Для таких оберток удобно делать статический метод create внутри виджета, который и инициирует ViewModel и передает ее в виджет ребенка. Теперь для получения доступа к ViewModel внутри билдера виджета, мы можем ее получить через context. Для этого мы и используем пакет Provider.
Виджет ToDoListWidget
```
class ToDoListWidget extends StatelessWidget {
const ToDoListWidget({Key? key}) : super(key: key);
@override
Widget build(BuildContext context) {
var _viewModel = context.watch<_ViewModel>();
return Container();
}
static Widget create() => ChangeNotifierProvider(
create: (_) => _ViewModel(),
child: const ToDoListWidget(),
);
}
```
Метод *watch()* не только отдает нам через провайдер экземпляр модели, которая была инициализирована выше по дереву виджетов, но и добавляет текущий виджет в качестве слушателя изменений в модели. То есть, когда мы в модели вызываем метод notifyListeners, наш виджет-слушатель перестраивается, за счет чего и достигается “связывание данных” между моделью и представлением.
Теперь набросаем простенький интерфейс, аналогичный базовому виджету MyHomePage, но с той лишь разницей, что в качестве тела виджета у нас будет список. В качестве списка будем использовать ListView.builder, поскольку он рендерит только те элементы, которые видны на экране, и в целом удобен.
ToDoListWidget.build
```
@override
Widget build(BuildContext context) {
var _viewModel = context.watch<_ViewModel>();
return Scaffold(
appBar: AppBar(
title: const Text("ToDo List"),
),
body: ListView.builder(
itemBuilder: (_, int index) => ToDoItemWidget(
item: _viewModel.state.items[index],
onDelete: _viewModel.dellItem,
onToogle: _viewModel.toogleItem,
),
itemCount: _viewModel.state.items.length,
),
floatingActionButton: FloatingActionButton(
onPressed: () {
showDialog(
context: context,
builder: (_) => AddTaskDialog(onFinish: _viewModel.addItem),
);
},
tooltip: 'Add task',
child: const Icon(Icons.add),
),
);
}
```
В качестве элемента списка напишем виджет ToDoItemWidget, который отдаст нам CheckboxListTile (элемент списка с чекбоксом), обернутый в Dismissible (для реализации удаления свайпом), и будет пробрасывать 2 делегата: на удаление элемента из списка и на изменение состояния элемента списка (выполнено/не выполнено).
Виджет ToDoItemWidget
```
class ToDoItemWidget extends StatelessWidget {
final ToDoItem item;
final Function(ToDoItem) onDelete;
final Function(ToDoItem) onToogle;
const ToDoItemWidget({
Key? key,
required this.item,
required this.onDelete,
required this.onToogle,
}) : super(key: key);
@override
Widget build(BuildContext context) {
return Dismissible(
background: Container(color: Colors.red),
key: Key(item.name),
onDismissed: (_) {
onDelete(item);
},
child: CheckboxListTile(
value: item.done,
onChanged: (_) {
onToogle(item);
},
title: Text(item.name),
));
}
}
```
Для добавления элемента нам нужно сначала где-то взять название для задачи. Для этого напишем виджет AddTaskDialog. Он представляет из себя AlertDialog с текстовым полем и делегатом, который в случае успеха возвращает нам новенькую задачу, а также сообщает об ошибках через всплывающие уведомления.
AddTaskDialog
```
class AddTaskDialog extends StatelessWidget {
final ValueChanged onFinish;
const AddTaskDialog({
Key? key,
required this.onFinish,
}) : super(key: key);
@override
Widget build(BuildContext context) {
String? text;
return AlertDialog(
title: const Text("Add new Task"),
content: TextField(
autofocus: true,
onChanged: (String \_text) {
text = \_text;
}),
actions: [
TextButton(
child: const Text("Add"),
onPressed: () {
if (text != null) {
try {
onFinish(ToDoItem(name: text!));
Navigator.of(context).pop();
} catch (e) {
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(content: Text("Task ${text!} exist!")));
}
} else {
ScaffoldMessenger.of(context).showSnackBar(
const SnackBar(content: Text("Enter Task name")));
}
},
),
TextButton(
child: const Text("Close"),
onPressed: () {
Navigator.of(context).pop();
},
),
],
);
}
}
```
Всё. Теперь можно собрать и посмотреть, что он делает =)
Все заложенные нами кейсы работают =)
В дальнейшем можно прикрутить sqlite, добавить инициализацию и синхронизацию, и вот — простенький задачник готов (шутка).
Я специально не затронул в данной статье редактирование задач. Если захотите попробовать повторить, Вы сможете это сделать сами =)
[***Ссылка***](https://github.com/avenum/mvvm_todo_list/tree/master/lib) на репозиторий с данным примером.
### В сухом остатке.
Я не утверждаю, что MVVM — это лучший шаблон проектирования для мобильных приложений на Flutter. Это пока первое, что я осознал и принял на вооружение после statefullWidget. Самое главное для меня — это его масштабируемость и применимость для достаточно больших приложений. Плюс он отвечает требованиям Чистой архитектуры. Только прошу, не рассматривайте мой пример как Архитектурный. Я показал в коде на примере приложения для чек-листа, как реализовать данный шаблон. | https://habr.com/ru/post/660411/ | null | ru | null |
# Микровселенная безумия, или Как устроены микрофронтенды в Dodo
*«Микрофронтенды в компании, которая доставляет пиццу? Серьёзно? Зачем? Да и куда? У вас же всего лишь приложенька с каталогом и заказом товара. Какие ещё микрофронтенды?»*
Одно из самых распространённых заблуждений, что нам в Dodo микрофронтенды не нужны. Но сегодня я постараюсь его развеять и рассказать, как мы докатились до такой жизни и какой путь при этом прошли. Усаживайтесь поудобнее, мы начинаем ~~наш цирк~~.
### На самом деле не всё так просто
Вся работа компании построена на огромной системе Dodo IS. Подробнее можно про неё прочитать в [статье](https://habr.com/ru/company/dododev/blog/521614/) нашего СТО [Паши Притчина.](https://habr.com/ru/users/pritchin/) Если вкратце, то это монолит, который состоит из большого количества сервисов. Но командам разработчиков, как правило, удобнее работать с микросервисами, чем с большим монолитом. Отсюда и решение отпиливать их.
Процесс пошёл, сервисы начали отпиливаться, но появился другой вопрос: а *что делать с UI?*
Практически у каждого сервиса есть своя админка. Админки для нескольких сервисов часто лежат рядом, поэтому поначалу весь UI оставляли в самом монолите. Но такой подход терял все профиты от использования микросервисов, так как приходилось менять код сначала в микросервисе, а потом ещё и в монолите. Работа увеличилась бы вдвое. Плюс этот сервис размазывался, не становился таким самостоятельным и зависел бы от кода извне. Ну и писать end-to-end гораздо удобнее, когда фронт и бэк находятся рядом.
Монолитная архитектура несёт в себе некоторые особенности и есть нюансы с доставкой кода до продакшена. Наши релизы на данный момент могут проходить за пару часов, а иногда затягиваются до двух дней или даже больше. И мне, как фронтендеру, совершенно неприемлемо столько ждать, чтобы задеплоить таску, в которой я полгода красил кнопку. Естественно, я могу накатить хотфикс, но такая постоянная практика выглядит не очень православно и добавляет беспокойства релизменам. Да и работать с репозиторием в Х тысяч строк кода и разбираться со всем не самое приятное занятие.
Практически все b2b интерфейсы у нас были написаны на Razor и jQuery. Но очень хотелось идти в ногу со временем, писать новый фронт на современных решениях и по мере возможности переписывать старые на новый стек**.** Микрофронтенды как раз позволяют писать себя на разных технологиях и разводить полнейший зоопарк.
Короче говоря, мы хотели:
* достать интерфейсы из монолита, положить их рядом с отпиленными микросервисами;
* быстро и независимо деплоить каждый интерфейс;
* иметь возможность писать на различных фреймворках, использовать любые сборщики и т.д.
Мы поискали варианты решений наших потребностей и пришли к микрофронтендам.
### Нельзя просто взять и сделать микрофронтенды
Ну для начала, конечно же, мы посмотрели на **Iframe.** Самый простой для реализации вариант: вставляем в него наше приложение и всё.
```
Document
```
Проблемы сразу же возникают, когда подключаешь приложение с другого хоста. Тут вопросы и с CORS, и проксированием, и как шарить cookie. Авторизацию придётся делать в каждом iframe, а если в один будет встроен другой, то там тоже. В общем, слишком много вопросов и нюансов, с которыми можно закопаться на отличненько и не получить профита. Поэтому мы двинули дальше.
На тот момент уже много кто использовал подход с [**Single-spa**](https://single-spa.js.org/). Это удобный фреймворк для создания приложения, которое может объединять в себе дочерние фронтенд-приложения (**appshell** далее). Выглядит базовый конфиг совсем несложным:
```
import { registerApplication, start } from 'single-spa'
registerApplication(
'sharedApp',
() => import('./sharedApp.js'),
location => location.pathname.startsWith('/sharedApp'),
)
start()
```
Регистрируем приложение sharedApp, импортируем и показываем его по маршруту */sharedApp.*
Выглядит неплохо, учитывая, что можно собрать так несколько дочерних приложений в одном и все они будут жить в контексте родительского. Каждое из них может быть написано на разном стеке, жить и деплоиться независимо. Как раз то, что мы и хотели.
Но у нас же ещё есть сами микрофронтенды, и их тоже нужно как-то готовить. Экосистема Single-spa позволяет нам сделать и это. У неё есть библиотеки для создания микрофронтендов на разных фреймворках. Например, [single-spa-react](https://single-spa.js.org/docs/ecosystem-react/).
```
import singleSpaReact from 'single-spa-react';
const App = () => SharedApp
export const { bootstrap, mount, unmount } = singleSpaReact({
React,
ReactDOMClient,
rootComponent: App,
errorBoundary: err => {
return I Knew You Were Trouble
},
})
```
Оборачиваем приложение в метод `singleSpaReact` и экспортируем методы жизненного цикла, необходимые Single-spa для корректной работы.
Соберём наш микрофронтенд каким-либо сборщиком, подсунем его в appshell и всё, живём счастливо? (Нет)
Наши микрофронтенды деплоятся и достаются из blob-storage. Соответственно, импортировать их через относительные пути (с текущего хоста) не получится. Нужно запрашивать их динамически и лениво.
Мы не знаем заранее, где будут храниться бандлы, но хотим их импортировать не по путям, а просто по названиям. С этим может помочь [**Importmap**](https://github.com/WICG/import-maps). Это скрипт с картами импортов, у которых ключи в роли идентификатора (название приложения) и значениями в роли относительных или абсолютных путей на его физическое расположение (какой-нибудь blob-storage, например, Azure).
```
{
"imports": {
"mySharedApp": "https://storage/mySharedApp.432dfgh45.js",
"mySharedApp2": "https://storage/mySharedApp2.123fsd4g.js",
}
}
```
C ними, к сожалению, тогда и до сих пор сохраняются некоторые проблемы. Их поддержку всё ещё не полностью реализовали во всех современных браузерах (например, Safari на iOS). Множественные importmap не поддерживаются в современных браузерах (например, в Chrome). Также есть проблема с external importmap (когда importmap подтягиваются через `src` тега `script`).
```
```
И что же делать в таком случае?
На помощь пришёл [**SystemJS**](https://github.com/systemjs/systemjs). Он позволяет использовать вышеупомянутые importmap, только в формате `systemjs-importmap`, который поддерживают большинство браузеров.
```
{
"imports": {
"mySharedApp": "https://storage/mySharedApp.432dfgh45.js",
"mySharedApp2": "https://storage/mySharedApp2.123fsd4g.js",
}
}
```
Получается, appshell будет выглядеть таким образом:
```
import { registerApplication, start } from 'single-spa'
registerApplication(
'sharedApp',
() => import('mySharedApp'),
location => location.pathname.startsWith('/sharedApp'),
)
start()
```
Кажется, теперь всё хорошо. (Нет)
Так как мы используем для полифила importmap SystemJS**,** мы также будем использовать его для загрузки модулей.
Перепишем импорт микрофронтенда через SystemJS**,** и наш appshell будет выглядеть так:
```
import { registerApplication, start } from 'single-spa'
registerApplication(
'sharedApp',
() => System.import("mySharedApp"),
location => location.pathname.startsWith('/sharedApp'),
)
start()
```
И вот тут пазл сошёлся. 🤌🏼
### Вот такой вышел лунапарк
Мы подумали, обсудили и, чтобы не разводить зоопарк технологий на фронте, выбрали основой нашего UI стека React и всё, что вокруг его основной экосистемы.
Вот что у нас получилось:
* single-spa-react
* single-spa
* SystemJS
* systemjs-importmap.
Код для оборачивания дочерних приложений у нас стандартный, его можно глянуть чуть выше. А вот с appshell решили ещё чуть-чуть поколдовать.
Так как микрофронтендов, встраиваемых в appshell, может быть несколько, перечислять их ручками выглядело не очень симпатишно, поэтому мы решили запилить JSON-файлик, в котором будут перечисляться названия приложений и пути, по которым они будут показываться.
```
{
"sharedApp": "/sharedApp",
"sharedApp2": "/sharedApp2"
}
```
Используем его в appshell.
```
import 'systemjs'
import 'import-map-overrides'
import { registerApplication, start } from 'single-spa'
import rules from './rules.json'
async function init() {
for (const [name, activeWhenUrl] of Object.entries(rules)) {
registerApplication(
name,
() => System.import(name),
() => window.location.pathname.startsWith(activeWhenUrl),
)
}
start()
}
init()
```
Тут мы бегаем по нашему JSON. Скармливаем Single-spaназвание приложения, имя импорта, предварительно подсунув скрипт с systemjs-importmap и локейшен, по которому он будет показываться.
Бонусом прицепили библиотечку [import-map-overrides](https://www.npmjs.com/package/import-map-overrides). Она позволяет динамически изменять url для JS-модулей и сохранять эти переопределения в Local storage. Это очень удобно, когда нужно потыкаться своей сборкой на конкретном окружении, например на проде.
При локальной сборке ещё существует проблема получения реальных данных. Для этого можно использовать проксирование. Но если стенд с авторизацией, то CORS не позволит нам запрашивать данные. `Import-map-overrides` позволяет решить эту проблему, так как авторизационная cookie все равно проставляется по нужному хосту, а мы только переопределяем путь до нашего JS-бандла, что позволяет нам работать локальной сборкой на нужном нам окружении.
Perfecto!🤌🏼
#### Но я уже ощущаю осуждающие комменты, почему мы не посмотрели в сторону Webpack module federation.
Вкратце расскажу, что за лев этот тигр.
[Module federation](https://webpack.js.org/concepts/module-federation/) — плагин webpack, работающий как на стороне родительского приложения, так и дочернего.
Рассмотрим конфиг дочернего:
```
new ModuleFederationPlugin({
name: 'sharedApp',
filename: 'shared.js',
exposes: {
'./App': './src/App',
},
shared: {
react: { singleton: true, requiredVersion: dependencies.react },
'react-dom': {
singleton: true,
requiredVersion: dependencies['react-dom'],
},
},
})
```
В `name` указываем название приложения. В `filename` — имя файла, в которое оно собирается. В `exposes` ключами являются наши будущие импорты, а значениями —физические расположения файлов. В shared можем указать зависимости, которые не требуется подгружать (например, если родительское приложение грузит React, тогда дочернему не нужно ещё раз его выгружать).
Корень нашего приложения должен обязательно подключаться динамически, иначе сначала попытается загрузиться приложение, а потом уже библиотеки, которые мы указали в `shared` выше, в таком случае сборка упадёт.
Точка входа — `index.jsx`
```
import('./bootstrap');
```
`bootstrap.jsx`
```
import { createRoot } from 'react-dom/client';
import React from 'react';
import { App } from '@shared/App';
const container = document.querySelector(`#app`);
if (!container) {
throw new Error('container is not defined');
}
const root = createRoot(container);
root.render();
```
Ну и в App лежит основной контент:
```
const App = () => Hello from shared app;
export default App;
```
Глянем на родителя:
```
new ModuleFederationPlugin({
remotes: {
sharedApp: "shared@http://localhost:666/shared.js",
},
shared: {
react: { singleton: true, requiredVersion: 17 },
'react-dom': {
singleton: true,
requiredVersion: 17,
},
},
})
```
В `remotes` перечисляем дочерние приложения, где ключами являются названия, а в значениях указываем `scope`(shared из дочернего), путь до приложения и сам файл.
Точка входа — `index.js`
```
import('./bootstrap');
```
`bootstrap.js`
```
import { createRoot } from 'react-dom/client';
import React from 'react';
import { App } from './App';
const container = document.querySelector('#root');
const root = createRoot(container);
root.render();
```
В App лежат
```
import { lazy, Suspense } from 'react';
const SharedApp = lazy(() => import('sharedApp');
export const App: FC = () => (
);
```
Выглядит привлекательно: не надо кучи библиотек тянуть, какие-то сингл-спа и импортмапы. Почему нет?
Наш старт с микрофронтендами начался ещё в 2019 году, к тому времени Webpack module federation был только в стадии зарождения. Соответственно, этого варианта у нас по умолчанию не было.
Но справедливости ради замечу, когда мы ресёрчили актуализацию подходов к построению наших микрофронтендов, каких-то киллер-профитов по сравнению с вариантом ниже не обнаружили.
Также есть нюанс, что module federation привязывает к экосистеме webpack. Получается, что appshell и все shared-приложения должны собираться им и только им. Это ограничивало бы нам свободу выбора сборщиков, что определённо является одним из нюансов, которые нужно иметь ввиду. У нас на данный момент есть приложения, которые собирает **vite,** и кто знает, какие ещё быстрые сборщики появятся в будущем.
### Ну и всё, мы молодцы? (Нет)
Микрофронтенды есть, а как их их деплоить, как хранить importmap и обновлять?
Путь был тернист, но таков путь. Умственными и не только усилиями разработали и подход к CD всего этого дела.
Порядок такой:
1. Разработчик коммитит свой код в основную ветку репозитория, в котором лежит микрофронтенд.
2. В GitHub Actions происходит автоматический билд фронта.
3. Сбилженный артефакт выкладываем в приватный blob storage.
Для доставки до прода у нас есть собственный инструмент (script) — **microfrontend-gitops.** Он занимается публикацией микрофронтендов в Azure и обновлением importmap.
Скрипт принимает 3 параметра:
* Environment. Стенд, которым пользуются команды или продакшн стенд;
* Frontend. Тут указывается название appshell, в который мы деплом наш микрофронтенд;
* Bundle. Урл до файла с микрофронтендом, который лежит в Azure.
Для деплоя на продакшен:
1. Дёргаем GitHub Actions на выбранный Environment(см. выше).
2. GHA скачивает и запускает скрипт microfrontend-gitops**.**
3. Скрипт делает коммит в репозиторий, в котором прописаны физические расположения файлов importmap.
4. Скачивается бандл.
5. Обновляются importmap и выкладывается JSON importmap в публичный blob storage.
Схематично весь процесс отображён на скрине ниже.
### Плюсы и минусы такого решения
У нас появился полноценный подход к разработке микрофронтендов, который поддерживается во всех современных браузерах с минимумом бойлерплейта для их организации. Любой может быть написан хоть на React, хоть на Vue— да на всём, чём угодно, встраиваться в любой appshell и использоваться там, где захотим, без особых проблем. Каждый из микрофронтендов минимально завязан на окружение, в котором он будет находиться, и максимально сцеплен на себе. Привет, low coupling high cohesion!
Монолит распиливается. Мы можем экспериментировать с любыми сборщиками, UI-библиотеками, фреймворками и пробовать новые штуки, которые в JS-мире появляются каждый час.
Обновления и доставка интерфейсов до продакшена занимает не более 10 минут. Весь CD происходит автоматически с указанием пары параметров. Плюс всегда можно посмотреть что, кто и когда деплоил через в коммиты в репозиторий с importmap, что очень удобно.
Помимо плюсов есть и минусы, о которых стоит упомянуть.
Так как микрофронтенд должен быть полноценным приложением, мы не делаем код-сплитинг для них. Соответственно, бандлы иногда получаются не самые маленькие, что стоит учитывать для определённых сегментов бизнеса, которым важны метрики first contentful paint, large contentful paint и time to interactive.
Ну и несмотря на удобный CD, всё ещё остаётся проблема с мониторингом микрофронтендов. Какая версия на каком стенде, насколько она отличается от продакшена, на каких стендах микрофронтенд вообще раскатан. Всё это не решённые пока проблемы.
P.S. Мы уже работаем над инструментом по мониторингу и, возможно, о нём ещё расскажем.
### Так мы и жили
Пока в новом проекте к нам одним прекрасным утром не пришел наш тех-лид и такой: «Чуваки, а давайте затащим…»
Продолжение следует… | https://habr.com/ru/post/712320/ | null | ru | null |
# Мастерство Data Science: Автоматизированное конструирование признаков на Python
Машинное обучение все больше переходит от моделей, разработанных вручную, к автоматически оптимизированным пайплайнам с использованием таких инструментов, как [H20](http://docs.h2o.ai/h2o/latest-stable/h2o-docs/automl.html), [TPOT](https://epistasislab.github.io/tpot/) и [auto-sklearn](https://automl.github.io/auto-sklearn/stable/). Эти библиотеки, наряду с такими методами, как [случайный поиск](http://www.jmlr.org/papers/volume13/bergstra12a/bergstra12a.pdf), стремятся упростить выбор модели и настройку частей машинного обучения, находя лучшую модель для набора данных без какого-либо ручного вмешательства. Однако разработка объектов, возможно, [более ценный аспект](https://www.featurelabs.com/blog/secret-to-data-science-success/) пайплайнов машинного обучения, остается почти полностью человеческим трудом.
[Конструирование признаков](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D1%81%D1%82%D1%80%D1%83%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%B8%D0%B7%D0%BD%D0%B0%D0%BA%D0%BE%D0%B2) ([Feature engineering](https://en.wikipedia.org/wiki/Feature_engineering)), также известная как создание признаков (feature creation), представляет собой процесс создания новых признаков из существующих данных для обучения модели машинного обучения. Этот шаг может быть более важным, чем фактическая используемая модель, потому что алгоритм машинного обучения извлекает уроки только из тех данных, которые мы ему предоставляем, и создание признаков, которые имеют отношение к задаче, абсолютно необходимо (см. Превосходную статью [«Несколько полезных вещей, которые необходимо знать о Машинное обучение"](https://homes.cs.washington.edu/~pedrod/papers/cacm12.pdf)).
Как правило, разработка признаков — это длительный ручной процесс, основанный на знании предметной области, интуиции и манипулировании данными. Этот процесс может быть чрезвычайно утомительным, и конечные характеристики будут ограничены как субъективностью человека, так и временем. Автоматизированное проектирование признаков направлено на то, чтобы помочь специалисту по науке о данных, автоматически создавать множество объектов-кандидатов из набора данных, из которого можно выбрать лучшие и использовать для обучения.
В этой статье мы рассмотрим пример использования автоматической разработки признаков с [библиотекой featuretools для Python](https://docs.featuretools.com/#). Мы будем использовать примерный набор данных, чтобы показать основы (следите за будущими публикациями с использованием реальных данных). Полный код из этой статьи [доступен на GitHub](https://github.com/WillKoehrsen/automated-feature-engineering/blob/master/walk_through/Automated_Feature_Engineering.ipynb).
### Основы разработки признаков
[Разработка признаков](https://www.datacamp.com/community/tutorials/feature-engineering-kaggle) означает создание дополнительных признаков из существующих данных, которые часто распределяются по нескольким связанным таблицам. Разработка признаков требует извлечения соответствующей информации из данных и помещения ее в единую таблицу, которую затем можно использовать для обучения модели машинного обучения.
Процесс создания признаков очень трудоемкий, поскольку для создания каждой нового признака обычно требуется несколько шагов, особенно при использовании информации из нескольких таблиц. Мы можем сгруппировать операции создания признаков в две категории: **преобразования** и **агрегации**. Давайте рассмотрим несколько примеров, чтобы увидеть эти концепции в действии.
**Преобразование** действует на одну таблицу (в терминах Python, таблица представляет собой просто Pandas `DataFrame`), создавая новые признаки из одного или нескольких существующих столбцов. Например, если у нас есть таблица клиентов ниже,
мы можем создать признаки, найдя месяц из столбца `joined` или взяв натуральный логарифм из столбца `income`. Это оба преобразования, потому что они используют информацию только из одной таблицы.
С другой стороны, **агрегации** выполняются по таблицам и используют отношение «один ко многим», чтобы группировать наблюдения и затем вычислять статистику. Например, если у нас есть другая таблица с информацией о кредитах клиентов, где у каждого клиента может быть несколько кредитов, мы можем рассчитать такую статистику, как среднее, максимальное и минимальное значения кредита для каждого клиента.
Этот процесс включает в себя группирование таблицы loans по клиенту, вычисление агрегации и последующее объединение полученных данных с данными клиента. Вот как мы могли бы сделать это в Python, используя [язык Pandas](https://pandas.pydata.org/pandas-docs/stable/index.html).
```
import pandas as pd
# Group loans by client id and calculate mean, max, min of loans
stats = loans.groupby('client_id')['loan_amount'].agg(['mean', 'max', 'min'])
stats.columns = ['mean_loan_amount', 'max_loan_amount', 'min_loan_amount']
# Merge with the clients dataframe
stats = clients.merge(stats, left_on = 'client_id', right_index=True, how = 'left')
stats.head(10)
```
Эти операции сами по себе не сложны, но если у нас есть сотни переменных, разбросанных по десяткам таблиц, этот процесс невозможно осуществить вручную. В идеале нам нужно решение, которое может автоматически выполнять преобразования и агрегации для нескольких таблиц и объединять полученные данные в одну таблицу. Несмотря на то, что Pandas — отличный ресурс, есть еще много манипуляций с данными, которые мы хотим сделать вручную! (Подробнее о ручном проектировании признаков можно найти в превосходном справочнике [Python Data Science Handbook](https://jakevdp.github.io/PythonDataScienceHandbook/05.04-feature-engineering.html)).
### Featuretools
К счастью, featuretools — это именно то решение, которое мы ищем. Эта библиотека для Python с открытым исходным кодом автоматически создает множество признаков из набора связанных таблиц. Featuretools основан на методе, известном как «[Deep Feature Synthesis](http://featurelabs1.wpengine.com/wp-content/uploads/2017/12/DSAA_DSM_2015-1.pdf)», который звучит гораздо более впечатляюще, чем на самом деле (название происходит от объединения нескольких признаков, а не потому, что он использует глубокое обучение!).
Глубокий синтез признаков объединяет несколько операций преобразования и агрегирования (которые называются [примитивами признаков](https://docs.featuretools.com/automated_feature_engineering/primitives.html) в словаре FeatureTools) для создания признаков из данных, распределенных по многим таблицам. Как и большинство идей в области машинного обучения, это сложный метод, основанный на простых понятиях. Изучая один строительный блок за один раз, мы можем сформировать хорошее понимание этого мощного метода.
Во-первых, давайте посмотрим на данные из нашего примера. Мы уже видели что-то из набора данных выше, и полный набор таблиц выглядит следующим образом:
* `clients`: базовая информация о клиентах в кредитном объединении. Каждый клиент имеет только одну строку в этом фрейме данных
* `loans`: кредиты, предоставленные клиентам. Каждый кредит имеет только собственную строку в этом фрейме данных, но клиенты могут иметь несколько кредитов.
* `payments`: платежи по кредитам. Каждый платеж имеет только одну строку, но каждый заем будет иметь несколько платежей.
Если у нас есть задача для машинного обучения, такая как прогнозирование того, будет ли клиент погашать будущий кредит, мы захотим объединить всю информацию о клиентах в одну таблицу. Таблицы связаны (через переменные `client_id` и `loan_id`), и мы могли бы использовать серию преобразований и агрегаций, чтобы выполнить этот процесс вручную. Однако вскоре мы увидим, что вместо этого мы можем использовать featuretools для автоматизации процесса.
### Entities и EntitySets (сущности и наборы сущностей)
Первые две концепции featuretools — это **entities** и **entitysets**. Entity — это просто таблица (или `DataFrame`, если вы думаете в Pandas). [EntitySet](https://docs.featuretools.com/loading_data/using_entitysets.html) — это набор таблиц и взаимосвязей между ними. Представьте, что entityset — это просто еще одна структура данных Python со своими собственными методами и атрибутами.
Мы можем создать пустой набор сущностей в featuretools, используя следующее:
```
import featuretools as ft
# Create new entityset
es = ft.EntitySet(id = 'clients')
```
Теперь мы должны добавить сущности. Каждая сущность должна иметь индекс, который является столбцом со всеми уникальными элементами. То есть каждое значение в индексе должно появляться в таблице только один раз. Индексом во фрейме данных `clients` является `client_id`, потому что у каждого клиента есть только одна строка в этом фрейме данных. Мы добавляем сущность с существующим индексом в набор сущностей, используя следующий синтаксис:
```
# Create an entity from the client dataframe
# This dataframe already has an index and a time index
es = es.entity_from_dataframe(entity_id = 'clients', dataframe = clients,
index = 'client_id', time_index = 'joined')
```
Фрейм данных `loans` также имеет уникальный индекс `loan_id`, и синтаксис для добавления его к набору сущностей такой же, как и для `clients`. Однако для фрейма данных платежей нет уникального индекса. Когда мы добавляем эту сущность в набор сущностей, нам нужно передать параметр `make_index = True` и указать имя индекса. Кроме того, хотя featuretools будет автоматически выводить тип данных каждого столбца в сущносте, мы можем переопределить это, передав словарь типов столбцов параметру `variable_types`.
```
# Create an entity from the payments dataframe
# This does not yet have a unique index
es = es.entity_from_dataframe(entity_id = 'payments',
dataframe = payments,
variable_types = {'missed': ft.variable_types.Categorical},
make_index = True,
index = 'payment_id',
time_index = 'payment_date')
```
Для этого фрейма данных, несмотря на то, что `missed` является целым числом, это не [числовая переменная](https://socratic.org/questions/what-is-a-numerical-variable-and-what-is-a-categorical-variable), так как она может принимать только 2 дискретных значения, поэтому мы говорим featuretools что следует рассматривать ее как категориальную переменную. После добавления фреймов данных в набор сущностей мы исследуем любую из них:
Типы столбцов были правильно выведены с указанной модификацией. Далее нам нужно указать, как связаны таблицы в наборе сущностей.
### Связи между таблицами
Лучший способ представить **отношение** между двумя таблицами — это [аналогия родителей и детей](https://stackoverflow.com/questions/7880921/what-is-a-parent-table-and-a-child-table-in-database). Отношение один ко многим: у каждого родителя может быть несколько детей. В области таблиц родительская таблица имеет одну строку для каждого родителя, но дочерняя таблица может иметь несколько строк, соответствующих нескольким дочерним элементам одного и того же родителя.
Например, в нашем наборе данных `clients` фрейм является родительским для `loans` фрейма. Каждый клиент имеет только одну строку в `clients`, но может иметь несколько строк в `loans`. Аналогично, `loans` являются родителями `payments`, потому что каждый заем будет иметь несколько платежей. Родители связаны со своими детьми общей переменной. Когда мы выполняем агрегирование, мы группируем дочернюю таблицу по родительской переменной и вычисляем статистику по дочерним элементам каждого родителя.
Чтобы [формализовать отношения в featuretools](https://docs.featuretools.com/loading_data/using_entitysets.html#adding-a-relationship), нам нужно только указать переменную, которая связывает две таблицы вместе. `clients` и таблица `loans` связаны с помощью переменной `client_id`, а `loans` и `payments` — с помощью `loan_id`. Синтаксис для создания отношения и добавления его в набор сущностей показан ниже:
```
# Relationship between clients and previous loans
r_client_previous = ft.Relationship(es['clients']['client_id'],
es['loans']['client_id'])
# Add the relationship to the entity set
es = es.add_relationship(r_client_previous)
# Relationship between previous loans and previous payments
r_payments = ft.Relationship(es['loans']['loan_id'],
es['payments']['loan_id'])
# Add the relationship to the entity set
es = es.add_relationship(r_payments)
es
```
Набор сущностей теперь содержит три сущности (таблицы) и отношения, которые связывают эти сущности вместе. После добавления сущностей и формализации отношений наш набор сущностей завершен, и мы готовы создавать признаки.
### Примитивы признаков
Прежде чем мы сможем полностью перейти к глубокому синтезу признаков, нам нужно понять [примитивы признаков](https://docs.featuretools.com/automated_feature_engineering/primitives.html). Мы уже знаем, что это такое, но мы просто называем их разными именами! Это просто основные операции, которые мы используем для формирования новых признаков:
* Агрегации: операции, выполненные в отношении «родитель-ребенок» (один-ко-многим), которые группируются по родителям и рассчитывают статистику по детям. Примером является группировка таблицы `loans` по `client_id` и определение максимальной суммы кредита для каждого клиента.
* Преобразования: операции, выполняемые с одной таблицы в один или несколько столбцов. В качестве примера берется разница между двумя столбцами в одной таблице или абсолютное значение столбца.
Новые признаки создаются в featuretools, используя эти примитивы, либо сами по себе, либо в виде нескольких примитивов. Ниже приведен список некоторых примитивов в featuretools (мы также можем [определить кастомные примитивы](https://docs.featuretools.com/guides/advanced_custom_primitives.html)):
Эти примитивы могут быть использованы сами по себе или объединены для создания признаков. Для создания признаков с указанными примитивами мы используем функцию `ft.dfs` (расшифровывается как глубокий синтез признаков). Мы передаем набор сущностей `target_entity`, который представляет собой таблицу, в которую мы хотим добавить признаки, выбранные `trans_primitives` (преобразования) и `agg_primitives` (агрегаты):
```
# Create new features using specified primitives
features, feature_names = ft.dfs(entityset = es, target_entity = 'clients',
agg_primitives = ['mean', 'max', 'percent_true', 'last'],
trans_primitives = ['years', 'month', 'subtract', 'divide'])
```
Результатом является датафрейм новых признаков для каждого клиента (потому что мы сделали клиентов `target_entity`). Например, у нас есть месяц, в котором присоединился каждый клиент, который является примитивом преобразования:
У нас также есть ряд примитивов агрегации, таких как средние суммы платежей для каждого клиента:
Несмотря на то, что мы указали только несколько примитивов, featuretools создал много новых признаков, комбинируя и складывая эти примитивы.
Полный фрейм данных содержит 793 столбца новых признаков!
### Глубокий Синтез Признаков
Теперь у нас есть все для понимания глубокого синтеза признаков (dfs). Фактически, мы уже выполняли dfs в предыдущем вызове функции! Глубокий признак — это просто признак, состоящий из объединения нескольких примитивов, а dfs — это имя процесса, который создает эти признаки. Глубина глубокого признака — это количество примитивов, необходимых для создания признака.
Например, столбец `MEAN (payment.payment_amount)` представляет собой глубокий признак с глубиной 1, поскольку он был создан с использованием одной агрегации. Элемент с глубиной два — это `LAST(loans(MEAN(payment.payment_amount))`. Это делается путем объединения двух агрегаций: LAST (самая последняя) поверх MEAN. Это представляет средний размер платежа по самому последнему кредиту для каждого клиента.
Мы можем составлять признаки на любую глубину, какую захотим, но на практике я никогда не выходил за пределы глубины 2. После этого момента признаки трудно интерпретировать, но я призываю всех, кто заинтересован, [попробовать «углубиться»](http://knowyourmeme.com/memes/we-need-to-go-deeper).
Нам не нужно вручную указывать примитивы, но вместо этого мы можем позволить featuretools автоматически выбирать признаки для нас. Для этого мы используем один и тот же вызов функции `ft.dfs`, но не передаем никакие примитивы:
```
# Perform deep feature synthesis without specifying primitives
features, feature_names = ft.dfs(entityset=es, target_entity='clients',
max_depth = 2)
features.head()
```
Featuretools создал много новых признаков для нас. Хотя этот процесс автоматически создает новые признаки, он не заменит специалиста по Data Science, потому что нам еще предстоит выяснить, что делать со всеми этими признаками. Например, если наша цель состоит в том, чтобы предсказать, будет ли клиент погашать кредит, мы могли бы искать признаки, наиболее соответствующие конкретному результату. Более того, если у нас есть знание предметной области, мы можем использовать его для выбора конкретных примитивов признаков или для [глубокого синтеза признаков-кандидатов](https://docs.featuretools.com/guides/tuning_dfs.html).
### Следующие шаги
Автоматизированное проектирование признаков решило одну проблему, но создало другую: слишком много признаков. Хотя до подбора модели сложно сказать, какие из этих признаков будут важны, скорее всего, не все из них будут иметь отношение к задаче, на которой мы хотим обучать нашу модель. Более того, [слишком большое количество признаков](https://pdfs.semanticscholar.org/a83b/ddb34618cc68f1014ca12eef7f537825d104.pdf) может привести к снижению производительности модели, поскольку менее полезные признаки вытесняют те, которые являются более важными.
Проблема слишком многих признаков известна как [проклятие размерности](https://en.wikipedia.org/wiki/Curse_of_dimensionality#Machine_learning). По мере увеличения числа признаков (размерность данных) модели становится все труднее изучать соответствие между признаками и целями. Фактически, объем данных, необходимых для хорошей работы модели, [масштабируется экспоненциально с количеством признаков](https://stats.stackexchange.com/a/65380/157316).
Проклятие размерности сочетается с [сокращением признаков (также известным как выбор признаков)](https://machinelearningmastery.com/an-introduction-to-feature-selection/): процессом удаления ненужных признаков. Это может принимать различные формы: Principal Component Analysis (PCA), SelectKBest, использование значений признаков из модели или автоматическое кодирование с использованием глубоких нейронных сетей. Однако [сокращение признаков](https://en.wikipedia.org/wiki/Feature_selection) — это отдельная тема для другой статьи. На данный момент мы знаем, что мы можем использовать featuretools для создания множества признаков из множества таблиц с минимальными усилиями!
### Вывод
Как и многие темы в машинном обучении, автоматизированное проектирование признаков с помощью featuretools — сложная концепция, основанная на простых идеях. Используя понятия наборов сущностей, сущностей и отношений, featuretools может выполнять глубокий синтез признаков для создания новых признаков. Глубокий синтез признаков, в свою очередь, объединяет примитивы — **агрегаты**, которые действуют через отношения «один ко многим» между таблицами, и **преобразования**, функции, применяемые к одному или нескольким столбцам в одной таблице, — для создания новых признаков из нескольких таблиц.
Узнайте подробности, как получить востребованную профессию с нуля или Level Up по навыкам и зарплате, пройдя платные онлайн-курсы SkillFactory:
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=ML&utm_term=regular&utm_content=10072001) (12 недель)
* [Обучение профессии Data Science с нуля](https://skillfactory.ru/data-scientist?utm_source=infopartners&utm_medium=habr&utm_campaign=DST&utm_term=regular&utm_content=10072001) (12 месяцев)
* [Профессия аналитика с любым стартовым уровнем](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=SDA&utm_term=regular&utm_content=10072001) (9 месяцев)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=PWS&utm_term=regular&utm_content=10072001) (9 месяцев)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=DEVOPS&utm_term=regular&utm_content=10072001) (12 месяцев)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=WEBDEV&utm_term=regular&utm_content=10072001) (8 месяцев)
### Читать еще
* [Тренды в Data Scienсe 2020](https://habr.com/ru/company/skillfactory/blog/508450/)
* [Data Science умерла. Да здравствует Business Science](https://habr.com/ru/company/skillfactory/blog/508556/)
* [Крутые Data Scientist не тратят время на статистику](https://habr.com/ru/company/skillfactory/blog/507052/)
* [Как стать Data Scientist без онлайн-курсов](https://habr.com/ru/company/skillfactory/blog/507024/)
* [450 бесплатных курсов от Лиги Плюща](https://habr.com/ru/company/skillfactory/blog/503196/)
* [Data Science для гуманитариев: что такое «data»](https://habr.com/ru/company/skillfactory/blog/506798/)
* [Data Scienсe на стероидах: знакомство с Decision Intelligence](https://habr.com/ru/company/skillfactory/blog/506790/) | https://habr.com/ru/post/510420/ | null | ru | null |
# Как я патчил Zabbix
На днях, у меня наконец-то дошли руки до обновления Zabbix.
С момента прочтения статьи [Вышел Zabbix 2.2](http://habrahabr.ru/company/zabbix/blog/201500/) в соответствующем блоге, я не мог дождаться, когда же в Gentoo размаскируют версию 2.2. Практически не было такого нововведения в этой версии, которое бы мне не было интересно и полезно в «быту». Это и мониторинг VMware, и ускорение системы, и улучшения в LLDP, короче практически каждый пункт.
Шли месяцы, а версии 2.2 не было даже в замаскированных.
Иногда я откладываю текучку в сторону и занимаюсь чем-нибудь «параллельным» относительно срочных и важных задач и работ. В этот раз я вспомнил о желании обновить Zabbix до версии 2.2.
Проверил в маскированных\*, ну наконец-то, есть 2.2.5
Ну все, переходим, прошел уже год с момента выпуска, версия stable'е не бывает, так что что бы ни случилось, решим.
Размаскировываем, собираем везде где нужно (основное это конечно сервер и прокси), перезапускаем. Переустанавливаем web интерфейс ииии…
И ничего, идет обновление БД.
Штука это не быстрая, база у меня не маленькая, а потом процесс вообще завис.
Ну думаю, началось, как говорится не успели начать, а уже все плохо.
В логах mysql было Error number 28 means 'No space left on device', места везде было более чем достаточно. Как говорится «при наличии гугла, я богоподобен» (с), не сразу, но удалось найти/догадаться что этот device это ibdata1 и ibdata2, размер которых регулируется параметром innodb\_data\_file\_path. После того как я поменял max с 256M на 512М обновление базы завершилось успешно и сервер стартанул.
На прокси тоже были проблемы, и тоже из-за базы данных. Просто sqlite не обновляется, поэтому останавливаем прокси, удаляем старую базу и запускаем прокси. Как говорится внимательнее читайте Upgrade notes
Конечно за время обновления накопилось много просроченных данных, поэтому проверяем то что можем проверить, что в интерфейсе все показывается, и ждем, пока все устаканится и актуализируется.
Через пару часов, смотрим график:
День начинал становиться томным.
У нас очередь. Откуда?.. Основные просроченные данные с одного из прокси. А что за данные. А данные получаемые по SNMPv3.
Отлично. Были и раньше у меня к этому функционалу вопросы, но все руки не доходили, да была надежда что обновление эти вопросы решит. А тут система становится практически не работоспособной. В свое время, читая о том как люди с помощью одного сервера или прокси мониторят сотни сетевых девайсов я не мог понять в чем же дело? У меня несколько десятков устройств, и все работает на пределе. Уж и БД оптимизирована донельзя, и сервер положен на быстрый датастор, и памяти ему дано немало.
Откатываться назад не хотелось, поэтому было решено во что бы то ни стало попробовать разобраться с проблемой.
Я выбрал один из прокси, за которым больше всего SNMP устройств, и начал разбираться.
Вот что у нас в логах на прокси\*\*:
```
4447:20141218:124053.605 SNMP agent item "ifAdminStatus.["10130"]" on host "co-xx02" failed: first network error, wait for 15 seconds
4468:20141218:124108.270 resuming SNMP agent checks on host "co-xx02": connection restored
```
И так беспорядочно по всем SNMP хостам, с разными итемами.
Сетевых проблем у меня точно нет, но для верности я конечно же по быстрому проверил связность, скорость и логи коммутаторов. Проверяем сам SNMP с помощью snmpwalk причем дергаем вообще все дерево. Никаких проблем.
Гуглим. У кого-то забиты поллеры, у кого-то некорректные таймауты, какой-то баг связанный с этим исправлен в версии 2.2.3. У кого-то хитрая проблема с сетью и теряется UDP. Но это все не наш случай.
Что тогда?..
Интересный факт, если перезагрузить прокси
```
/etc/init.d/zabbix-proxy restart
```
То видно как начинает сокращаться очередь, но потом бах, опять что-то происходит и она моментально вырастает\*\*\*.
Что же происходит?..
Включаем расширенное логирование на zabbix-proxy
DebugLevel=4
Перезапускаем zabbix-proxy и ждем появления ошибок
Теперь вместо Network Error видим более полную информацию
**Выглядит это примерно так**
```
5414:20141218:125955.481 zbx_snmp_get_values() snmp_synch_response() status:1 errstat:-1 mapping_num:94
5414:20141218:125955.481 End of zbx_snmp_get_values():NETWORK_ERROR
5414:20141218:125955.481 End of zbx_snmp_process_standard():NETWORK_ERROR
5414:20141218:125955.481 In zbx_snmp_close_session()
5414:20141218:125955.481 End of zbx_snmp_close_session()
5414:20141218:125955.481 getting SNMP values failed: Cannot connect to "192.168.x.x:161": Too long.
5414:20141218:125955.481 End of get_values_snmp()
5414:20141218:125955.481 In deactivate_host() hostid:10207 itemid:43739 type:6
5414:20141218:125955.481 query [txnlev:1] [begin;]
5414:20141218:125955.481 query [txnlev:1] [update hosts set snmp_errors_from=1418896795,snmp_disable_until=1418896810,snmp_error='Cannot connect to "192.168.x.x:161": Too long.' where hostid=10207]
5414:20141218:125955.481 query [txnlev:1] [commit;]
5414:20141218:125955.481 SNMP agent item "ifOperStatus.["10143"]" on host "co-xx04" failed: first network error, wait for 15 seconds
5414:20141218:125955.481 deactivate_host() errors_from:1418896795 available:1
5414:20141218:125955.482 End of deactivate_host()
```
Статус 1, статус ошибки -1, число элементов 94
Здесь же вывод что это NETWORK\_ERROR
И чуть ниже расшифровка Too long и деактивация хоста. Понятно что если хост деактивирован, данные с него получить нельзя, данные ставятся в очередь, вот и объяснение очереди.
Сразу же заинтересовал параметр errstat
Делаем cat /var/log/zabbix/zabbix\_proxy.log | grep errstat
```
5412:20141218:130351.410 zbx_snmp_get_values() snmp_synch_response() status:0 errstat:0 mapping_num:11
5433:20141218:130351.470 zbx_snmp_get_values() snmp_synch_response() status:1 errstat:-1 mapping_num:94
5430:20141218:130351.476 zbx_snmp_get_values() snmp_synch_response() status:1 errstat:-1 mapping_num:94
5417:20141218:130353.442 zbx_snmp_get_values() snmp_synch_response() status:0 errstat:0 mapping_num:5
5420:20141218:130353.534 zbx_snmp_get_values() snmp_synch_response() status:1 errstat:-1 mapping_num:94
```
**Ага, копаем глубже**Здесь должна быть картинка We need to go deeper, но не будет. Мне кажется она всех достала.
Делаем cat /var/log/zabbix/zabbxi\_proxy.log | grep errstat:-1
```
5416:20141218:130353.540 zbx_snmp_get_values() snmp_synch_response() status:1 errstat:-1 mapping_num:94
5412:20141218:130355.571 zbx_snmp_get_values() snmp_synch_response() status:1 errstat:-1 mapping_num:94
5417:20141218:130355.591 zbx_snmp_get_values() snmp_synch_response() status:1 errstat:-1 mapping_num:94
...
5420:20141218:130453.187 zbx_snmp_get_values() snmp_synch_response() status:1 errstat:-1 mapping_num:94
5412:20141218:130455.206 zbx_snmp_get_values() snmp_synch_response() status:1 errstat:-1 mapping_num:94
5413:20141218:130455.207 zbx_snmp_get_values() snmp_synch_response() status:1 errstat:-1 mapping_num:94
```
Пришло время отключить мониторинг всех устройств за прокси кроме одного, т.к. иначе в логе слишком сложно разбираться. Все равно система в таком виде как сейчас для мониторинга не пригодна.
Отключаем, делаем
cat /var/log/zabbix/zabbxi\_proxy.log | grep mapping\_num
и перезагрузим прокси
Никаких ошибок первое время, да и mapping\_num потихоньку растет от 1 все больше и больше (вырезаны отдельные строчки чтобы показать принцип)
**Можно вечно смотреть за тем как растет mapping\_num**
```
7876:20141218:131251.660 zbx_snmp_get_values() snmp_synch_response() status:0 errstat:0 mapping_num:4
7872:20141218:131251.681 zbx_snmp_get_values() snmp_synch_response() status:0 errstat:0 mapping_num:6
7872:20141218:131251.919 zbx_snmp_get_values() snmp_synch_response() status:0 errstat:0 mapping_num:8
7876:20141218:131251.919 zbx_snmp_get_values() snmp_synch_response() status:0 errstat:0 mapping_num:9
7868:20141218:131351.965 zbx_snmp_get_values() snmp_synch_response() status:0 errstat:0 mapping_num:13
10502:20141218:135237.884 zbx_snmp_get_values() snmp_synch_response() status:0 errstat:0 mapping_num:31
10507:20141218:135238.244 zbx_snmp_get_values() snmp_synch_response() status:0 errstat:0 mapping_num:62
12429:20141218:141637.942 zbx_snmp_get_values() snmp_synch_response() status:0 errstat:0 mapping_num:31
12429:20141218:141637.966 zbx_snmp_get_values() snmp_synch_response() status:0 errstat:0 mapping_num:31
12433:20141218:141651.142 zbx_snmp_get_values() snmp_synch_response() status:1 errstat:-1 mapping_num:94
```
А потом оппа 94, и -1 и too long. Т.е. сразу после запуска прокси тестирует устройства, посылает им SNMP запросы, увеличивая количество итемов в одном запросе. Очередь начинает быстро сокращаться. Потом он (то бишь прокси) доходит до волшебного числа 94, происходит сбой и устройства начинают отключаться заббиксом на 15 секунд, что в свою очередь начинает резко увеличивать очередь.
Как видим, здесь уже совсем не Network error, здесь уже Too long.
Ладно пробуем что-то найти по zabbix snmp too long, ничего.
Опять таймауты, перегрузка поллера… В одном интересном посте была информация, что такая ошибка возникала когда был неверно сформирован OID для итема, так что я дважды проверил все свои OID'ы в том числе через snmpget
Т.е. в итоге гугл мне помочь не смог.
Будем разбираться сами, это полезно.
Итак, что у нас есть?
Как только число итемов становится 94 (т.е. достаточно большим) что-то происходит и система сбивается.
Здесь опять картинка, которой не будет ;)
Пора лезть в код. В gentoo ничего качать не надо, уже все есть, так что я просто распаковал все в рабочую директорию.
Найдем сначала где выводится ошибка. Ищем по errstat
На удивление всего два таких места в файле с говорящим названием checks\_snmp.c
вот эти два места:
со строки 745
```
/* communicate with agent */
status = snmp_synch_response(ss, pdu, &response);
zabbix_log(LOG_LEVEL_DEBUG, "%s() snmp_synch_response() status:%d errstat:%ld max_vars:%d",
__function_name, status, NULL == response ? (long)-1 : response->errstat, max_vars);
```
и со строки 938
```
status = snmp_synch_response(ss, pdu, &response);
zabbix_log(LOG_LEVEL_DEBUG, "%s() snmp_synch_response() status:%d errstat:%ld mapping_num:%d",
__function_name, status, NULL == response ? (long)-1 : response->errstat, mapping_num);
```
Пока нас интересует второй кусок (исходя из того что mapping\_num есть только в нем)
Даже не программист видит, что у нас response NULL, а почему?..
Вспомним, что при errstat:-1, который теперь понятно откуда берется, у нас status:1. Т.е. функция snmp\_synch\_response возвращает 1, а что это значит?..
А это значит STAT\_ERROR (1) (а еще она умеет STAT\_TIMEOUT (2) и STAT\_SUCCESS (0))
Как говорится непонятно, но здорово…
Зайдем с другой стороны, где-то здесь же в этом файле должен быть возврат NETWORK\_ERROR попробуем разобраться где и почему.
Первое же вхождение в функции zbx\_get\_snmp\_response\_error (что как бы намекает)
**Посмотреть код zbx\_get\_snmp\_response\_error**
```
static int zbx_get_snmp_response_error(const struct snmp_session *ss, const DC_INTERFACE *interface, int status,
const struct snmp_pdu *response, char *error, int max_error_len)
{
int ret;
if (STAT_SUCCESS == status)
{
zbx_snprintf(error, max_error_len, "SNMP error: %s", snmp_errstring(response->errstat));
ret = NOTSUPPORTED;
}
else if (STAT_ERROR == status)
{
zbx_snprintf(error, max_error_len, "Cannot connect to \"%s:%hu\": %s.",
interface->addr, interface->port, snmp_api_errstring(ss->s_snmp_errno));
switch (ss->s_snmp_errno)
{
case SNMPERR_UNKNOWN_USER_NAME:
case SNMPERR_UNSUPPORTED_SEC_LEVEL:
case SNMPERR_AUTHENTICATION_FAILURE:
ret = NOTSUPPORTED;
break;
default:
ret = NETWORK_ERROR;
}
}
else if (STAT_TIMEOUT == status)
{
zbx_snprintf(error, max_error_len, "Timeout while connecting to \"%s:%hu\".",
interface->addr, interface->port);
ret = NETWORK_ERROR;
}
else
{
zbx_snprintf(error, max_error_len, "SNMP error: [%d]", status);
ret = NOTSUPPORTED;
}
return ret;
}
```
Ага. Т.е. мы со своим STAT\_ERROR входим в switch где не попадаем ни под одно из приведенных условий, и таким образом получаем NETWORK\_ERROR по дефолту.
Мы уже поняли что этот дефолт дезориентирует нас, нужно выяснить что же это за ошибка на самом деле. Код ошибки хранится в ss->s\_snmp\_errno, добавим вывод переменной в лог.
Программист из меня так себе, так что быстренько с помощью лома и чьей-то матери (с) сляпал патчик, вот такой:
```
diff -urN zabbix-2.2.5/src/zabbix_server/poller/checks_snmp.c zabbix-2.2.5.new/src/zabbix_server/poller/checks_snmp.c
--- zabbix-2.2.5/src/zabbix_server/poller/checks_snmp.c 2014-07-17 17:49:45.000000000 +0400
+++ zabbix-2.2.5.new/src/zabbix_server/poller/checks_snmp.c 2014-10-10 16:38:31.000000000 +0400
@@ -938,7 +938,7 @@
status = snmp_synch_response(ss, pdu, &response);
zabbix_log(LOG_LEVEL_DEBUG, "%s() snmp_synch_response() status:%d errstat:%ld mapping_num:%d",
- __function_name, status, NULL == response ? (long)-1 : response->errstat, mapping_num);
+ __function_name, status, NULL == response ? (STAT_ERROR == status ? (long) ss->s_snmp_errno : (long)-1) : response->errstat, mapping_num);
if (STAT_SUCCESS == status && SNMP_ERR_NOERROR == response->errstat)
{
```
Если статус STAT\_ERROR выводить ss->s\_snmp\_errno
Закинул исходник заббикса в локальный репозиторий, быстро подправил ебилд и вперед.
Компилим, перезапускаем, ждем.
И вот она наша реальная ошибка.
```
11211:20141218:155253.362 zbx_snmp_get_values() snmp_synch_response() status:0 errstat:0 mapping_num:18
11210:20141218:155253.393 zbx_snmp_get_values() snmp_synch_response() status:1 errstat:-5 mapping_num:94
```
Ошибка -5
Смотрим Net-SNMP snmp\_api.h
```
#define SNMPERR_TOO_LONG (-5)
```
Что-то похожее было видно в логах, но по словосочетанию Too Long мы найти ничего не смогли, посмотрим что же это за ошибка и когда возникает.
в snmp\_api.c можно это увидеть
**еще немного кода**
```
/*
* Make sure we don't send something that is bigger than the msgMaxSize
* specified in the received PDU.
*/
if (pdu->version == SNMP_VERSION_3 && session->sndMsgMaxSize != 0 && length > session->sndMsgMaxSize) {
DEBUGMSGTL(("sess_async_send",
"length of packet (%lu) exceeds session maximum (%lu)\n",
(unsigned long)length, (unsigned long)session->sndMsgMaxSize));
session->s_snmp_errno = SNMPERR_TOO_LONG;
SNMP_FREE(pktbuf);
return 0;
}
/*
* Check that the underlying transport is capable of sending a packet as
* large as length.
*/
if (transport->msgMaxSize != 0 && length > transport->msgMaxSize) {
DEBUGMSGTL(("sess_async_send",
"length of packet (%lu) exceeds transport maximum (%lu)\n",
(unsigned long)length, (unsigned long)transport->msgMaxSize));
session->s_snmp_errno = SNMPERR_TOO_LONG;
SNMP_FREE(pktbuf);
return 0;
}
```
Есть всего два варианта:
1. Длина данных которые мы хотим послать больше чем параметр msgMaxSize определенный в полученном PDU
2. Нижележащий транспорт не способен послать пакет такой длины
Возникает вопрос как же пофиксить эту ошибку. Из вышесказанного следует, что нужно искать получаем ли мы msgMaxSize, правильно ли мы это обрабатываем и т.д. и т.п. Но я исходники zabbix вижу в первый раз, а C во второй (ну ладно в третий).
Короче не вызывает энтузиазма… Да и поломать наверное что-нибудь можно будет.
Лирическое отступление:
Надо сказать, что во время разбирательств с этой проблемой, я в том числе наткнулся на информацию о массовой обработке SNMP. Т.е. zabbix одним запросом может запросить множество SNMP элементов данных.
[Подробности SNMP bulk processing](https://www.zabbix.com/documentation/2.2/manual/config/items/itemtypes/snmp#internal_workings_of_bulk_processing)
Суть в том, что zabbix умеет запрашивать до 128 значений одним запросом, но не все устройства способны обработать эти 128 значений за один раз. И в zabbiх используется стратегия поиска максимального значения для каждого конкретного устройства. Мы кстати видели это в логах. Постепенное повышение mapping\_num. Как только zabbix получает ошибку от устройства SNMPERR\_TOO\_BIG он по определенному алгоритму ищет максимальное значение возвращающее результаты без ошибок.
К чему это я.
Механизм обработки ошибки переполнения (назовем его так) в заббиксе есть, надо его всего лишь расширить на еще один случай.
Сам алгоритм расписан под выводом нашей ошибки.
**Опять этот код**
```
else if (1 < mapping_num &&
((STAT_SUCCESS == status && SNMP_ERR_TOOBIG == response->errstat) || STAT_TIMEOUT == status))
{
/* Since we are trying to obtain multiple values from the SNMP agent, the response that it has to */
/* generate might be too big. It seems to be required by the SNMP standard that in such cases the */
/* error status should be set to "tooBig(1)". However, some devices simply do not respond to such */
/* queries and we get a timeout. Moreover, some devices exhibit both behaviors - they either send */
/* "tooBig(1)" or do not respond at all. So what we do is halve the number of variables to query - */
/* it should work in the vast majority of cases, because, since we are now querying "num" values, */
/* we know that querying "num/2" values succeeded previously. The case where it can still fail due */
/* to exceeded maximum response size is if we are now querying values that are unusually large. So */
/* if querying with half the number of the last values does not work either, we resort to querying */
/* values one by one, and the next time configuration cache gives us items to query, it will give */
/* us less. */
if (*min_fail > mapping_num)
*min_fail = mapping_num;
if (0 == level)
{
/* halve the number of items */
int base;
ret = zbx_snmp_get_values(ss, items, oids, results, errcodes, query_and_ignore_type, num / 2,
level + 1, error, max_error_len, max_succeed, min_fail);
if (SUCCEED != ret)
goto exit;
base = num / 2;
ret = zbx_snmp_get_values(ss, items + base, oids + base, results + base, errcodes + base,
NULL == query_and_ignore_type ? NULL : query_and_ignore_type + base, num - base,
level + 1, error, max_error_len, max_succeed, min_fail);
}
else if (1 == level)
{
/* resort to querying items one by one */
for (i = 0; i < num; i++)
{
if (SUCCEED != errcodes[i])
continue;
ret = zbx_snmp_get_values(ss, items + i, oids + i, results + i, errcodes + i,
NULL == query_and_ignore_type ? NULL : query_and_ignore_type + i, 1,
level + 1, error, max_error_len, max_succeed, min_fail);
if (SUCCEED != ret)
goto exit;
}
}
}
```
То есть все просто, нам надо добавить свое условие, не нарушив работу имеющихся. Для этого у нас есть все данные:
* status должен быть STAT\_ERROR
* ss->s\_snmp\_errno должен быть SNMPERR\_TOO\_LONG
Учитываем еще что у нас два таких места (равно как и два вывода в лог-файл) и результирующий патч будет таким:
**Наконец-то**
```
diff -urN zabbix-2.2.5/src/zabbix_server/poller/checks_snmp.c zabbix-2.2.5.new/src/zabbix_server/poller/checks_snmp.c
--- zabbix-2.2.5/src/zabbix_server/poller/checks_snmp.c 2014-07-17 17:49:45.000000000 +0400
+++ zabbix-2.2.5.new/src/zabbix_server/poller/checks_snmp.c 2014-10-10 16:38:31.000000000 +0400
@@ -746,10 +746,10 @@
status = snmp_synch_response(ss, pdu, &response);
zabbix_log(LOG_LEVEL_DEBUG, "%s() snmp_synch_response() status:%d errstat:%ld max_vars:%d",
- __function_name, status, NULL == response ? (long)-1 : response->errstat, max_vars);
+ __function_name, status, NULL == response ? (STAT_ERROR == status ? (long)ss->s_snmp_errno : (long)-1) : response->errstat, max_vars);
if (1 < max_vars &&
- ((STAT_SUCCESS == status && SNMP_ERR_TOOBIG == response->errstat) || STAT_TIMEOUT == status))
+ ((STAT_SUCCESS == status && SNMP_ERR_TOOBIG == response->errstat) || STAT_TIMEOUT == status || (STAT_ERROR == status && SNMPERR_TOO_LONG == ss->s_snmp_errno)))
{
/* The logic of iteratively reducing request size here is the same as in function */
/* zbx_snmp_get_values(). Please refer to the description there for explanation. */
@@ -938,7 +938,7 @@
status = snmp_synch_response(ss, pdu, &response);
zabbix_log(LOG_LEVEL_DEBUG, "%s() snmp_synch_response() status:%d errstat:%ld mapping_num:%d",
- __function_name, status, NULL == response ? (long)-1 : response->errstat, mapping_num);
+ __function_name, status, NULL == response ? (STAT_ERROR == status ? (long) ss->s_snmp_errno : (long)-1) : response->errstat, mapping_num);
if (STAT_SUCCESS == status && SNMP_ERR_NOERROR == response->errstat)
{
@@ -1001,7 +1001,7 @@
}
}
else if (1 < mapping_num &&
- ((STAT_SUCCESS == status && SNMP_ERR_TOOBIG == response->errstat) || STAT_TIMEOUT == status))
+ ((STAT_SUCCESS == status && SNMP_ERR_TOOBIG == response->errstat) || STAT_TIMEOUT == status || (STAT_ERROR == status && SNMPERR_TOO_LONG == ss->s_snmp_errno)))
{
/* Since we are trying to obtain multiple values from the SNMP agent, the response that it has to */
/* generate might be too big. It seems to be required by the SNMP standard that in such cases the */
```
Компилируем, перезапускаем…
И вот результат:
Ошибка Network Error пропала из логов.
Ура!..
#### Послесловие
Конечно, в действительности, поиск ошибки и решения занял больше времени. Пришлось больше ковырять исходники и zabbix и net-snmp, чтобы в итоге остановиться на двух местах в коде.
Но ощущение победы над «косной материей» бесценно.
\* желание накатило 7 октября, а тогда 2.2.5 еще была замаскирована. По случайному совпадению ее размаскировали 10 октября;
\*\* на время не смотрите, для написания статьи сымитировал ситуацию позже. Во время разборок, выдергивать из логов данные совершенно не было времени, поток, куда деваться;
\*\*\* да, да, картинку я тоже смоделировал. Представьте что там где зеленое в начале, там все красное ;) А потом пила во время рестартов.
**2014.12.31 UPD:** По результатам обсуждения статьи, был открыт тикет (thanx to [alexvl](https://habrahabr.ru/users/alexvl/)):
[failure to send SNMPv3 requests that are «Too long» is not handled properly by SNMP bulk](https://support.zabbix.com/browse/ZBX-9163)
Он был успешно закрыт (thanx to Aleksandrs Saveljevs) начиная с версий 2.2.9rc1, 2.4.4rc1, 2.5.0 | https://habr.com/ru/post/240169/ | null | ru | null |
# Ajax-запросы нативными средствами Joomla
Небольшая заметка о том, как делать ajax-запросы штатными средствами без использования дополнительных js-библиотек (jQuery, etc). Joomla 3 и Joomla 4 предоставляют небольшую обёртку для конструирования XMLHttpRequest. В целом синтаксис очень похож на тот же jQuery Ajax, поэтому заменить его будет очень легко.
В страницы можно увидеть core.js, в котором есть немало любопытных функций для работы с фронтом на Joomla. Об одной из них (получение данных из php в js) писалось здесь: [Разработка форм обратной связи для магазинов на Joomla 3](https://habr.com/ru/post/576444/). Для создания ajax-запросов нам пригодится ***Joomla.request***.
Ajax в Joomla - Joomla.request
------------------------------
### Joomla 3
Представим, что Вам нужно просто отправить запрос, не получая никаких данных:
```
Joomla.request({
url: 'index.php?option=com_example&view=example'
})
```
#### Выбор метода запроса (POST или GET)
```
Joomla.request({
url: 'index.php?option=com_example&view=example',
method: 'POST'
})
```
Если выбран метод запроса POST. то автоматически будет отправляться заголовок **X-CSRF-Token** и сам CSRF-токен, который можно и нужно проверить в точке входа.
#### Проверка CSRF-токена в точке входа
Для этого используем метод Session::*checkToken.* В качестве параметра можно указывать как post (это значение по умолчанию), так и get.
```
use Joomla\CMS\Session\Session;
use Joomla\CMS\Language\Text;
Session::checkToken('get') or die(Text::_('JINVALID_TOKEN'));
```
Проверить наличие CSRF-токена на странице можно в консоли браузера:
Joomla.getOptions в консоли браузераЕсли CSRF-токена в Joomla Script options нет, то в PHP можно его добавить с помощью класса HTMLHelper.
```
HTMLHelper::_('form.csrf');
```
#### Установка заголовков ajax-запроса
Есть возможность установки своих заголовков ajax-запроса. Например, заголовка **Cache-Control**, тогда будет корректно работать условная ajax-корзина, каждый раз получая свежие данные. Также можно устанавливать свои уникальные заголовки, если это необходимо.
```
Joomla.request({
url: 'index.php?option=com_example&view=example',
method: 'POST',
headers: {
'Cache-Control' : 'no-cache',
'Your-custom-header' : 'custom-header-value'
}
})
```
#### Отправка данных через ajax в Joomla
Отправка данных на выбранный url происходит [согласно спецификации](https://developer.mozilla.org/ru/docs/Web/API/XMLHttpRequest/send). Чаще всего это или строка или объект. Для того, чтобы данные пришли в удобном виде стоит применить к передаваемому объекту **JSON.stringify**, так же указать заголовок запроса **Content-type:applictation/json**. [Хорошая статья о FormData на learn.javascript.ru в помощь](https://learn.javascript.ru/formdata).
```
Joomla.request({
url: 'index.php?option=com_example&view=example',
method: 'POST',
headers: {
'Cache-Control' : 'no-cache',
'Your-custom-header' : 'custom-header-value',
'Content-Type': 'application/json'
},
data: JSON.stringify({
'key1' : 'value1',
'key2' : 'value2'
})
})
```
Если метод запроса POST, в **data** передается просто строка и не установлен заголовок Content-Type, то он (Content-Type) принимает значение **application/x-www-form-urlencoded.** В php получаем данные следующим образом:
```
use Joomla\CMS\Factory;
$data = Factory::getApplication()->input->json->getArray();
```
#### Callback-функции ajax-запроса в Joomla
* **onBefore**: function(xhr){} - выполняется перед запросом. Запрос не выполнится, если данный callback вернёт false.
* **onSuccess**: function(response, xhr){} - выполняется после успешного завершения запроса. **response** - это *xhr.responseText,*
* **onError**: function(xhr){} - выполняется после неудачного запроса.
```
Joomla.request({
url: 'index.php?option=com_example&view=example',
method: 'POST',
headers: {
'Cache-Control' : 'no-cache',
'Your-custom-header' : 'custom-header-value',
'Content-Type': 'application/json'
},
data: JSON.stringify({
'key1' : 'value1',
'key2' : 'value2'
}),
onBefore: function (xhr){
// Тут делаем что-то до отправки запроса.
// Если вернём false - запрос не выполнится
},
onSuccess: function (response, xhr){
// Тут делаем что-то с результатами
//Проверяем пришли ли ответы
if (response !== ''){
let jshopping_cart = JSON.parse(response);
// И дальше делаем, например, супер-аякс-корзину-под-joomshopping
}
},
onError: function(xhr){
// Тут делаем что-то в случае ошибки запроса.
// Получаем коды ошибок и выводим сообщения о том, что всё грустно.
}
})
```
Запрос обёрнут в try-catch, поэтому если запрос не проходит - смотрим в консоль, там должна логироваться ошибка.
#### Флаг perform
Это значение по умолчанию установлено в true. Если установить в false - запрос не будет выполняться, а так же не будет вызываться callback-функция onBefore. Полезно в тех случаях, когда не нужно в процессе разработки некоторое время дёргать лишний раз сервер.
```
Joomla.request({
url: 'index.php?option=com_example&view=example',
method: 'POST',
headers: {
'Cache-Control' : 'no-cache',
'Your-custom-header' : 'custom-header-value',
'Content-Type': 'application/json'
},
data: JSON.stringify({
'key1' : 'value1',
'key2' : 'value2'
}),
onBefore: function (xhr){
// Тут делаем что-то до отправки запроса.
// Если вернём false - запрос не выполнится
},
onSuccess: function (response, xhr){
// Тут делаем что-то с результатами
//Проверяем пришли ли ответы
if (response !== ''){
let jshopping_cart = JSON.parse(response);
// И дальше делаем, например, супер-аякс-корзину-под-joomshopping
}
},
onError: function(xhr){
// Тут делаем что-то в случае ошибки запроса.
// Получаем коды ошибок и выводим сообщения о том, что всё грустно.
},
perform : false // вся проделанная выше работа бесполезна. Запрос прерван.
})
```
### Joomla 4
В Joomla 4 метод переписан, но для простых смертных всё остается так же. Добавляется лишь ещё одна callback-функция onComplete, которая выполняется в любом случае - как после успешного запроса, так и в случае ошибки.
```
Joomla.request({
url: 'index.php?option=com_example&view=example',
method: 'POST',
headers: {
'Cache-Control' : 'no-cache',
'Your-custom-header' : 'custom-header-value',
'Content-Type': 'application/json'
},
data: JSON.stringify({
'key1' : 'value1',
'key2' : 'value2'
}),
onBefore: function (xhr){
// Тут делаем что-то до отправки запроса.
// Если вернём false - запрос не выполнится
},
onSuccess: function (response, xhr){
// Тут делаем что-то с результатами
//Проверяем пришли ли ответы
if (response !== ''){
let jshopping_cart = JSON.parse(response);
// И дальше делаем, например, супер-аякс-корзину-под-joomshopping
}
},
onError: function(xhr){
// Тут делаем что-то в случае ошибки запроса.
// Получаем коды ошибок и выводим сообщения о том, что всё грустно.
},
onComplete: function (xhr){
// Тут что-то делаем в любом случае после ajax-запроса.
// в не зависимости от результата.
}
});
```
Приветствую аргументированные замечания и пожелания к заметке. | https://habr.com/ru/post/588651/ | null | ru | null |
# Панель оператора (HMI) с шиной I2C для Arduino
В рамках работы с неким ардуино-совместимым оборудованием(о нем в конце) понадобился мне экран с кнопками для управления и отображения текущей информации. То есть, была нужна панель оператора, она же HMI.
Решено было сделать HMI самостоятельно, а в качестве интерфейса использовать «квадратную» шину i2c.
Если интересен процесс разработки и программирования подобных девайсов, добро пожаловать под кат.
Характеристики:
* Дисплей 1602, монохромный 16х2 символов
* 5 кнопок: вверх, вниз, отмена, ввод, редактирование(edit)
* Интерфейс i2c
* Разъем подключения DB9F
* Размеры 155х90х44 мм
Тут возникнут очевидные вопросы:
**Почему не купить готовый шилд?**Конечно, можно было у тех же китайцев купить готовый шилд c дисплеем и клавиатурой и типа такого:
К этому шилду можно припаять 2 платки FC-113 и получится функционально то же самое, что и у меня: дисплей с клавиатурой, работающие по i2c. Цена набора составит от 4$.
Но на этой плате меня не устраивает размер кнопок, а мне хотелось большие, с возможностью установки разноцветных колпачков. Подключать Arduino к HMI мне хотелось не на соплях, а через нормальный разъем DB9F, а значит нужно было делать соединительную плату. А в этом случае какая разница, делать одну плату или две? Кроме того, у меня уже было в запасе несколько дисплеев 1602, а потому мне нужно было потратить всего 1.02$ для покупки на Алиэкспресс платы FC-113 (0.55$) и расширителя портов PCF8574P (0.47$).
Ну а самое главное- если имеешь дело с Ардуино, то самостоятельное изготовление шилдов для него это само собой разумеющееся дело, правда ведь?
**Почему шина i2c, не проще ли кнопки подключить напрямую?**В сфере АСУ ТП, где я работаю, HMI для связи с устройствами используют интерфейсы цифровой передачи данных RS-232,RS-485, CAN и т.д. Поэтому для меня логично, что моя самодельная HMI будет *вся* работать по интерфейсу передачи данных, в данном случае по i2c.
Если бы я смастерил устройство, где дисплей работает по квадратной шине, а кнопки идут напрямую на входа Ардуино, это бы вызывало у меня чувство глубокого неудовлетворения. Как представлю эту картину: из панели торчит отдельно шнурок на интерфейс, отдельно провода на входа, брррр…
Кроме того, различие между платой кнопок, которые идут напрямую ко входам Ардуино, и платой кнопок с интерфейсом i2c, заключается только в микросхеме PCF8574P(0.47$), конденсаторе и двух резисторах.
**Почему кнопки расположены так, а не иначе?**Кнопки у меня слева направо имеют такие функции: вверх, вниз, отмена, ввод, редактирование.
Кнопка «редактирование» отнесена от остальных чуть в сторону для акцентирования своей функции- изменение значений логических параметров(вкл/выкл) или переход в режим редактирования в случае параметров числовых.
Всего кнопок 5, хотя микросхема на плате клавиатуры позволяет подключить до 8 штук.
Достаточно было бы обойтись четырьмя кнопками и функционал бы не пострадал- «ввод» и «редактирование» можно совместить в одной кнопке. Но мне просто жалко стало, что из 8 ног микросхемы расширителя порта половина будет не задействована.
Еще отдельная кнопка «редактирование» может быть полезна, если я решу в одной строке выводить несколько параметров. Тогда этой кнопкой можно будет переключаться между параметрами, указывая, какой именно из них нужно изменить. Примерно так работает кнопка «SET» в популярных китайских HMI OP320.
Если первые две кнопки означают вверх и вниз, то почему бы их не разместить вертикально, как, например, сделано в указанном выше китайском шилде?
Лично для меня удобнее, когда все кнопки находятся по горизонтали, тогда во время работы пальцы перемещаются только в одной плоскости.
#### **Железо**
1. Самодельная соединительная плата с разъемом DB9F. Так, как питание +5V для расширителей портов и дисплея берем с Ардуино, на плате поставил предохранитель 0.1 А.
2. Всем нам хорошо известный дисплей 1602 с припаянной платой FC-113, которая подключает дисплей к шине i2c.
3. Самодельная клавиатурная плата с микросхемой PCF8574P, которая будет читать состояния кнопок и передавать их по шине i2c. Кстати, «дисплейная» плата FC-113 тоже основана на микросхеме PCF8574, только с индексом T, т.е. планарная, а не DIP, как PCF8574P.
Кнопки я поставил 12х12мм с квадратным толкателем- на них можно надеть большие разноцветные колпачки.
**Фото и схемы самодельный плат**
Стоит сказать пару слов про микросхему PCF8574P, на основе которой я сделал клавиатурную плату.
PCF8574P это расширитель портов с интерфейсом i2c. Всего в нем 8 портов, каждый из которых можно сконфигурировать на работу в качестве входа или выхода. Для этой микросхемы и обвязки как таковой не требуется(вспомните, к примеру, max232), я только на всякий случай поставил конденсатор по питанию.
Адрес микросхемы PCF8574P задается с помощью адресных ног A0, A1, A2, которые подтягивают к земле или к питанию через резистор 10 кОм.
На клавиатурной плате я все адресные ноги PCF8574P поставил на землю, поэтому адрес жестко настроен как 0x20 и поменять его нельзя.
Как я уже писал, в качестве разъема для HMI я выбрал DB9F. На него от Ардуино поступают сигналы +5 V, GND, SDA, SCL.
Провод для связи по i2c Ардуино и HMI сделал длинной 1.4 м, работает без глюков.
Платы нарисовал в Sprint Layout 6, методом ЛУТ перенес на текстолит и вытравил в растворе перекиси и лимонной кислоты.
**Немного о травлении**В сети есть много рецептов травления лимонной кислотой плат на фольгированном стеклотекстолите.
Я делал такой раствор: 100 мл перекиси водорода 3%, 50 г лимонной кислоты, 3 чайные ложки соли. Баночку с перекисью подогрел в кастрюле с водой до температуры где-то 70 градусов.
Погружаем плату в раствор рисунком вниз, как рекомендуют при травлении перекисью.
Через пару десятков секунд начинается бурный процесс. Выделяется много пара, вдыхать который не рекомендуется. Наверное.
Потом процесс стихает. Переворачиваем плату.
Готово.
Корпус сделал у друга из оргстекла 4 мм на станке лазерной резки.
**Лирическое отступление по поводу корпуса**Купить готовый корпус или сделать самому? Немного подумав, решил делать сам. Те, что видел в продаже, мне не подходили или по цене, или по эстетическим соображениям, или были на DIN-рейку, что тоже меня не устраивало.
Изначально корпус хотел выпилить из фанеры. Но потом вспомнил, что у меня есть замечательный друг и, по большой для меня радости, директор фирмы по производству спортивных наград. У него имеются всякие там станки, в том числе и для лазерной резки.
Обратился за помощью и друг не отказал- за пару минут лазером нарезали деталей.
Пользуясь случаем, хочу сказать, спасибо тебе, Коля! Иначе мне пришлось бы еще целый день пилить и шлифовать фанеру, а результат едва бы был таким блистательным.
#### **Программирование**
С точки зрения Ардуино, данная HMI представляет из себя 2 устройства, которые работают по шине i2c: дисплей(LCD) с адресом 0x27 и клавиатура с адресом 0x20. Соответственно, работать Arduino будет отдельно с клавиатурой и отдельно с LCD.
Работа с LCD осуществляется через специальную библиотеку «LiquidCrystal\_I2C.h», ее нужно установить в Aduino IDE.
Работа с клавиатурой осуществляется через стандартную библиотеку «Wire.h», которая изначально имеется в Aduino IDE.
Подключаем HMI к Ardiuno.
1. Для начала проверим, видит ли Ардуино наш HMI. Для этого загружаем в нее программу, которая будет сканировать шину i2c на предмет нахождения на ней устройств.
**Скетч 1, сканирование шины i2c**
```
//i2c_scaner
#include
String stringOne;
void setup()
{
Wire.begin();
Serial.begin(9600);
while (!Serial);
}
void loop()
{
byte error, address;
int nDevices;
Serial.println("Scanning...");
nDevices = 0;
for(address = 1; address < 127; address++ )
{
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
String stringOne = String(address, HEX);
Serial.print("0x"); Serial.print(stringOne); Serial.print(" - ");
if(stringOne=="0A") Serial.println("'Motor Driver'");
if(stringOne=="0F") Serial.println("'Motor Driver'");
if(stringOne=="1D") Serial.println("'ADXL345 Input 3-Axis Digital Accelerometer'");
if(stringOne=="1E") Serial.println("'HMC5883 3-Axis Digital Compass'");
if(stringOne=="5A") Serial.println("'Touch Sensor'");
if(stringOne=="5B") Serial.println("'Touch Sensor'");
if(stringOne=="5C") Serial.println("'BH1750FVI digital Light Sensor' OR 'Touch Sensor" );
if(stringOne=="5D") Serial.println("'Touch Sensor'");
if(stringOne=="20") Serial.println("'PCF8574 8-Bit I/O Expander' OR 'LCM1602 LCD Adapter' ");
if(stringOne=="21") Serial.println("'PCF8574 8-Bit I/O Expander'");
if(stringOne=="22") Serial.println("'PCF8574 8-Bit I/O Expander'");
if(stringOne=="23") Serial.println("'PCF8574 8-Bit I/O Expander' OR 'BH1750FVI digital Light Sensor'");
if(stringOne=="24") Serial.println("'PCF8574 8-Bit I/O Expander'");
if(stringOne=="25") Serial.println("'PCF8574 8-Bit I/O Expander'");
if(stringOne=="26") Serial.println("'PCF8574 8-Bit I/O Expander'");
if(stringOne=="27") Serial.println("'PCF8574 8-Bit I/O Expander' OR 'LCM1602 LCD Adapter '");
if(stringOne=="39") Serial.println("'TSL2561 Ambient Light Sensor'");
if(stringOne=="40") Serial.println("'BMP180 barometric pressure sensor'" );
if(stringOne=="48") Serial.println("'ADS1115 Module 16-Bit'");
if(stringOne=="49") Serial.println("'ADS1115 Module 16-Bit' OR 'SPI-to-UART'");
if(stringOne=="4A") Serial.println("'ADS1115 Module 16-Bit'");
if(stringOne=="4B") Serial.println("'ADS1115 Module 16-Bit'");
if(stringOne=="50") Serial.println("'AT24C32 EEPROM'");
if(stringOne=="53") Serial.println("'ADXL345 Input 3-Axis Digital Accelerometer'");
if(stringOne=="68") Serial.println("'DS3231 real-time clock' OR 'MPU-9250 Nine axis sensor module'");
if(stringOne=="7A") Serial.println("'LCD OLED 128x64'");
if(stringOne=="76") Serial.println("'BMP280 barometric pressure sensor'");
if(stringOne=="77") Serial.println("'BMP180 barometric pressure sensor' OR 'BMP280 barometric pressure sensor'");
if(stringOne=="78") Serial.println("'LCD OLED 128x64'" );
nDevices++;
}
else if (error==4)
{
Serial.print("Unknow error at address 0x");
if (address<16)
Serial.print("0");
Serial.println(address,HEX);
}
}
if (nDevices == 0)
Serial.println("No I2C devices found\n");
else
Serial.println("done\n");
delay(5000);
}
```
Во время выполнения этой программы, Ардуино будет писать результаты сканирования шины i2c в последовательный порт. Для просмотра этих данных, в Arduino IDE заходим Инструменты-> Монитор порта.
Видим, что Ардуино на шине i2c определило два устройства с адресами 0x20 и 0x27, это клавиатура и LCD соответственно.
2. Теперь посмотрим, как работает наша клавиатура. Создадим программу, которая будет опрашивать состояние кнопок и выводить его на LCD.
**Скетч 2, вывод на экран состояния кнопок**
```
/*
Вывод на LCD состояния кнопок по шине i2c
LCD подключен через плату FC-113, адрес 0x27
Клавиатура подключена через расширитель портов PCF8574P, адрес 0x20
*/
#include
#include
#define led 13
#define ADDR\_KBRD 0x20
#define ADDR\_LCD 0x27
byte dio\_in;
bool b;
bool key[5];
LiquidCrystal\_I2C lcd(ADDR\_LCD,16,2); // Устанавливаем дисплей
void setup()
{
pinMode(led, OUTPUT);
//
lcd.init();
lcd.backlight();// Включаем подсветку дисплея
//
Wire.begin();
Wire.beginTransmission(ADDR\_KBRD);
Wire.write(B11111111); //Конфигурация всех порты PCF8574P на клавиатуре как входа
Wire.endTransmission();
}
void loop()
{
Wire.requestFrom(ADDR\_KBRD,1);
while (!Wire.available());
byte dio\_in = Wire.read(); //читаем состояние портов PCF8574P(кнопок)
//заполняем массив кнопок значениями их состояний
byte mask=1;
for(int i=0; i<5;i++)
{
key[i]=!(dio\_in & mask);
mask=mask<<1;
}
b=!b;
digitalWrite(led, b); //Мигаем светодиодом на Ардуино
//Вывод состояний кнопок на LCD
lcd.setCursor(0, 0);
lcd.print(String(key[0])+" "+
String(key[1])+" "+
String(key[2])+" "+
String(key[3])+" "+
String(key[4])+" ");
delay(100);
}
```
Клавиатура работает.
3. Наконец можно переходить к тому, ради чего все затевалось- созданию многоуровневого меню в Ардуино. Через меню будем не только смотреть информацию, но и управлять выходами самого Ардуино.
В нете много информации по созданию многоуровневого меню на C++, а для Ардуино даже видел какие-то библиотеки. Но я решил в своей программе написать меню самостоятельно. Во-первых, чем меньше левых библиотек в проекте, тем спокойнее. А во-вторых, это просто.
Получилась у меня очередная вариация древовидного меню. Меню позволяет выводить в каждой строке одновременно статический текст и значение переменной. Например, можно вывести название параметра и его значение.
Для вывода на экран переменных, применяю принцип тегов- определенным образом оформленных текстовых меток в тексте, вместо которых при отображении текста на экране выводится значение.
Параметры можно изменять нажатием кнопки «Edit». Причем, в теге каждого параметра указывается, доступен ли он для редактирования или только для чтения. Если текущий параметр только для чтения, в начале строки указатель будет '\*', если редактирование параметра разрешено, указатель станет '+'.
**Скетч 3, многоуровневое меню**
```
/*
Древовидное меню, работа снопками и LCD по шине i2c
LCD подключен через плату FC-113, адрес 0x27
Клавиатура подключена через расширитель портов PCF8574P, адрес 0x20
*/
#include
#include
#define led 13 //светодиод на плате Ардуно нано; будет мигать, показывая этим, что система не зависла
#define ADDR\_KBRD 0x20
#define ADDR\_LCD 0x27
#define PORT\_D2 2
#define PORT\_D3 3
#define PORT\_D4 4
#define POINT\_ON\_ROOT\_MENU\_ITEM 0 // 0/1= запретить/разрешить вывод указателя позиции(\* или +) на главном экране меню
byte dio\_in;
bool b;
byte i;
//bool переменные, которыми можно управлять из меню
bool BoolVal[9]={0,0,0, 0,0,0, 0,0,0};
#define ValSvet1 BoolVal[0]
#define ValSvet2 BoolVal[1]
#define ValSvet3 BoolVal[2]
#define ValRozetka1 BoolVal[3]
#define ValRozetka2 BoolVal[4]
#define ValRozetka3 BoolVal[5]
#define ValClapan1 BoolVal[6]
#define ValClapan2 BoolVal[7]
#define ValClapan3 BoolVal[8]
//
struct STRUCT\_KEY{
bool StateCur; //Текущее состояние кнопки
bool StateOld; //Состояние кнопки при прошлом опросе
bool Imp; //Было нажатие кнопки (переход из 0 в 1)
};
//кнопки
STRUCT\_KEY Key[5]={0,0,0,
0,0,0,
0,0,0,
0,0,0,
0,0,0
};
//---
/\*Текстовые строки меню
\* Допустимы теги, например:
\* '#A1' bool переменная, где
\* '#'- тип переменной bool,
\* 'A'- адрес(HEX) переменной в массиве BoolVal,
\* '1'- редактирование переменной разрешено
\* при выводе текста, вместо тега автоматически подставляется значение переменной
\*/
String StrNull=" "; //пустая строка
String StrRoot1="COMP-MAN.INFO";
String StrRoot2="PLC-BLOG.COM.UA";
String StrSvet= "СВЕТ"; //Свет
String StrSvet1="СВЕТ 1 #01";
String StrSvet2="СВЕТ 2 #10";
String StrSvet3="СВЕТ 3 #21";
String StrRozetka="РОЗЕТКИ"; //Розетки
String StrRozetka1="РОЗЕТКА 1 #30";
String StrRozetka2="РОЗЕТКА 2 #40";
String StrRozetka3="РОЗЕТКА 3 #50";
String StrClapan="КЛАПАНЫ"; //Клапаны
String StrClapan1="КЛАПАН 1 #60"; //
String StrClapan2="КЛАПАН 2 #70";
String StrClapan3="КЛАПАН 3 #80";
struct MENU\_ITEM //Пункт меню(экран), состоит из 2 строк и координат перехода при нажатии кнопок
{
byte KeyUp; //№ пункта меню, куда переходить по кнопке "вверх"
byte KeyDwn; //№ пункта меню, куда переходить по кнопке "вниз"
byte KeyCancel; //№ пункта меню, куда переходить по кнопке "отмена"(cancel)
byte KeyEnter; //№ пункта меню, куда переходить по кнопке "ввод"(enter)
byte KeyEdit; //кнопка "edit", резерв
String \*pstr1; //указатель на верхнюю строку меню(экрана)
String \*pstr2; //указатель на нижнюю строку меню(экрана)
};
//
MENU\_ITEM Menu[]={0,0,0,1,0, &StrRoot1,&StrRoot2, //0 Главный экран
1,8,0,2,0, &StrSvet,&StrRozetka, //1 СВЕТ
2,3,1,2,0, &StrSvet1,&StrSvet2, //2
2,4,1,3,0, &StrSvet2,&StrSvet3, //3
3,4,1,4,0, &StrSvet3,&StrNull, //4
0,0,0,0,0, &StrNull,&StrNull, //5 РЕЗЕРВ
0,0,0,0,0, &StrNull,&StrNull, //6
0,0,0,0,0, &StrNull,&StrNull, //7
1,15,0,9,0, &StrRozetka,&StrClapan, //8 РОЗЕТКИ
9,10,8,9,0, &StrRozetka1, &StrRozetka2, //9
9,11,8,10,0, &StrRozetka2, &StrRozetka3, //10
10,11,8,11,0, &StrRozetka3, &StrNull, //11
0,0,0,0,0, &StrNull,&StrNull, //12 РЕЗЕРВ
0,0,0,0,0, &StrNull,&StrNull, //13
0,0,0,0,0, &StrNull,&StrNull, //14
8,15,0,16,0, &StrClapan, &StrNull, //15 КЛАПАНЫ
16,17,15,0,0, &StrClapan1,&StrClapan2, //16
16,18,15,0,0, &StrClapan2,&StrClapan3, //17
17,18,15,0,0, &StrClapan3,&StrNull, //18
0,0,0,0,0, &StrNull,&StrNull, //19 РЕЗЕРВ
0,0,0,0,0, &StrNull,&StrNull, //20
0,0,0,0,0, &StrNull,&StrNull, //21
};
byte PosMenu=0; //позиция меню
LiquidCrystal\_I2C lcd(ADDR\_LCD,16,2); // Устанавливаем дисплей
//Чтение состояний кнопок
void ReadKey(byte dio\_in)
{
//заполняем массив кнопок значениями их состояний
byte mask=1;
for(i=0; i<5; i++)
{
Key[i].StateCur=!(dio\_in & mask);
mask=mask<<1;
Key[i].Imp=!Key[i].StateOld & Key[i].StateCur; //определяем нажатие кнопки (переход из 0 в 1)
Key[i].StateOld=Key[i].StateCur;
}
}
/\*
\* Перекодировка UTF-8 русских букв (только заглавных) в коды LCD
\* а то Ардуино выводит их неправильно
\*/
byte MasRus[33][2]= {
144, 0x41, //А
145, 0xa0,
146, 0x42,
147, 0xa1,
148, 0xe0,
149, 0x45,
129, 0xa2,
150, 0xa3,
151, 0xa4,
152, 0xa5,
153, 0xa6,
154, 0x4b,
155, 0xa7,
156, 0x4d,
157, 0x48,
158, 0x4f,
159, 0xa8,
160, 0x50,
161, 0x43,
162, 0x54,
163, 0xa9,
164, 0xaa,
165, 0x58,
166, 0xe1,
167, 0xab,
168, 0xac,
169, 0xe2,
170, 0xad,
171, 0xae,
172, 0xc4,
173, 0xaf,
174, 0xb0,
175, 0xb1 //Я
};
String RusStrLCD(String StrIn)
{
String StrOut="";
byte b1;
byte y;
byte l=StrIn.length();
for(byte i=0; i dec
byte StrHexToByte(char val)
{
byte dec=0;
switch (val) {
case '0':
dec=0;
break;
case '1':
dec=1;
break;
case '2':
dec=2;
break;
case '3':
dec=3;
break;
case '4':
dec=4;
break;
case '5':
dec=5;
break;
case '6':
dec=6;
break;
case '7':
dec=7;
break;
case '8':
dec=8;
break;
case '9':
dec=9;
break;
case 'A':
dec=10;
break;
case 'B':
dec=11;
break;
case 'C':
dec=12;
break;
case 'D':
dec=13;
break;
case 'E':
dec=14;
break;
case 'F':
dec=15;
break;
default:
dec=0;
break;
}
return dec;
}
//Вывод на экран пункта меню
void WriteLCD(byte num)
{
String str[]={"\*"+\*Menu[num].pstr1,\*Menu[num].pstr2};
if (num==0 && POINT\_ON\_ROOT\_MENU\_ITEM==0) //на главном эркане нужно выводить указатель?
str[0].setCharAt(0,' '); //стираем указатель, если нет
//Подставляем значения переменных вместо тегов
byte NumVal;
byte l;
for(byte y=0; y<2; y++)
{
l=str[y].length();
for(i=0; i-1) //так было нажатие?
{
if (KeyImp==4) //Кнопка "Edit"
Edit(PosMenu);
PosMenu=GoMenu((KeyImp));
WriteLCD(PosMenu);
}
b=!b;
digitalWrite(led, b); //Мигаем светодиодом на Ардуино
ValToPort(); //управление выходами
delay(50);
}
```
#### **LCD 1602 и языковой вопрос**
Отдельно нужно затронуть вопрос русификации.
В знакогенераторе некоторых LCD 1602 нет русских букв, а вместо них прошиты японские кракозябры. Перепрошить знакогенератор невозможно. Поэтому придется или писать на экране слова латинскими буквами, или в программе формировать русские буквы самому, т.к. в LCD 1602 есть возможность создавать и хранить в ОЗУ LCD собственные символы. Но, в последнем случае, можно выводить на экран не больше восьми «самодельных» символов за раз.
**Таблицы символов LCD 1602**
В принципе, нет ничего страшного, если писать на LCD русские слова английскими буквами. Вон, даже почтенная французская компания Shneider Electric(та самая, что еще до революции продавала гаубицы царю) за полтора десятилетия не сподобилась внедрить в свои знаменитые программируемые реле Zelio русский язык. Но это не мешает активно торговать ими на просторах всего СНГ. Причем, канальи, испанский и португальский языки ввели.
На многих наших заводах эти Zelio общаются с персоналом фразами типа «NASOS 1 VKL».
Когда непонятно, есть ли русские буквы в конкретном LCD, нужно вывести на экран все символы его знакогенератора. Если кириллица есть, она начинается со 160 позиции.
**Скетч 4, вывод на экран всех символов из таблицы знакогенератора LCD 1602**
```
/*Последовательно выводит на LCD все символы его знакогенератора
* LCD подключен по шине i2c
*/
#include
LiquidCrystal\_I2C lcd(0x27,16,2); // Устанавливаем дисплей
void setup() {
// put your setup code here, to run once:
lcd.init();
lcd.clear();
}
void loop() {
int i,y;
while(1)
{
for (i=0; i < 16; i++)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print(String(i\*16)+" - "+String(i\*16+15));
lcd.setCursor(0,1);
for(y=0;y<16;y++)
lcd.print(char(i\*16+y));
delay(3000);
}
}
}
```
Но даже если ваш LCD 1602 русифицирован, вывести на экран русские слова не так просто. По крайней мере, используя библиотеку «LiquidCrystal\_I2C.h» при работе с LCD по шине i2c.
Если просто выводить русский текст, например инструкцией lcd.print(«Привет!!!»), то вместо «Привет!!!» на экране появится какая-то белиберда.
Это потому, что русские буквы Arduino IDE переводит в двухбайтный код UTF-8, а в LCD все символы однобайтные.
Та же проблема, кстати, наблюдается при передаче русских текстов из Ардуино в монитор порта Arduino IDE. Ардуино передает в последовательный порт русские буквы в двухбайтной кодировке UTF-8, а монитор порта Arduino IDE пытается их читать в однобайтной кодировке Windows-1251 (cp1251). Хотя cp1251 тоже 8-битная, как и кодировка LCD 1602, но с ней не совпадает.
Можно формировать русские тексты через коды символов. К примеру, строку 'ЖК дисплей' на русифицированный LCD получится вывести так:
```
lcd.print("\243K \343\270c\276\273e\271");
```
Но мне такой подход не нравится.
Чтобы корректно отображать русский текст на русифицированных LCD 1602, для Ардуино придумали несколько библиотек. Но почитав отзывы я увидел, что многие жалуются на глюки при их использовании.
Поэтому я в своей программе многоуровневого меню сам написал простую функцию преобразования UTF-8 в коды LCD. Правда, сделал это только для заглавных русских букв, что меня вполне устраивает.
**Функция конвертирования заглавных русских букв UTF-8 в однобайтный код LCD 1602**
```
/*
* Перекодировка UTF-8 русских букв (только заглавных) в коды LCD
* а то Ардуино выводит их неправильно
*/
byte MasRus[33][2]= {
144, 0x41, //А
145, 0xa0,
146, 0x42,
147, 0xa1,
148, 0xe0,
149, 0x45,
129, 0xa2,
150, 0xa3,
151, 0xa4,
152, 0xa5,
153, 0xa6,
154, 0x4b,
155, 0xa7,
156, 0x4d,
157, 0x48,
158, 0x4f,
159, 0xa8,
160, 0x50,
161, 0x43,
162, 0x54,
163, 0xa9,
164, 0xaa,
165, 0x58,
166, 0xe1,
167, 0xab,
168, 0xac,
169, 0xe2,
170, 0xad,
171, 0xae,
172, 0xc4,
173, 0xaf,
174, 0xb0,
175, 0xb1 //Я
};
String RusStrLCD(String StrIn)
{
String StrOut="";
byte b1;
byte y;
byte l=StrIn.length();
for(byte i=0; i
```
На этом про самодельную HMI с шиной i2c у меня все.
Ах да, в начале статьи я писал, что делаю HMI не совсем для Ардуино, а для ардуино-совместимого оборудования. Это я про ПЛК [CONTROLLINO MAXI](https://controllino.biz/), который программируется из среды Arduino IDE (и многих других).
CONTROLLINO MAXI это фактически Arduino + куча шилдов и все оформлено как промышленный ПЛК. Но про него в следующий раз.
**Ссылки**
→ [Архив](http://plc-blog.com.ua/Arduino/HMI-i2c-DIY-2017-02-18.zip) со схемами, скетчами и печатной платой в формате lay6
→ [Ардуино-совместимый ПЛК СONTROLLINO](https://controllino.biz/), работа с которым вдохновила на создание HMI i2c
→ [Расширитель портов PCF8574](http://adatum.ru/pcf8574-kak-legko-uvelichit-chislo-pinov-na-arduino.html) и подключение его к Arduino
→ [Плата FC-113](http://soltau.ru/index.php/arduino/item/372-kak-podklyuchit-lcd-displej-s-i2c-modulem-k-arduino) для работы LCD 1602 по шине i2c и подключение ее к Arduino
→ [Многоуровневое древовидное меню](http://easyelectronics.ru/organizaciya-drevovidnogo-menyu.html), общие принципы создания на Си
→ [Кодировка UTF-8](http://i.voenmeh.ru/kafi5/Kam.loc/inform/UTF-8.htm)
→ [Кодировка Windows-1251](https://ru.wikipedia.org/wiki/Windows-1251) | https://habr.com/ru/post/401587/ | null | ru | null |
# Анализируем время ответа собеседника
С появлением мессенджеров коммуникация перешла на новый уровень — возможность мгновенного доступа к собеседнику воспринимается теперь как должное.
Но замечали ли вы, как на ваши ощущения от общения влияет скорость его ответа? Какое время ответа вообще считается приемлемым?
Можем ли мы сказать, что проявляем неуважение, когда отвечаем на следующий день? Через неделю? Через месяц?
В этой статьей мы не будем отвечать на эти вопросы. Зато без каких-либо глобальных выводов проведем небольшое исследование одного параметра — время ответа собеседником на наши сообщения.
Достаем сырые данные
--------------------
Для исследования в нашем случае лучше всего подойдет Telegram. Прежде всего, потому что у него есть удобный api для Python.
Будем использовать библиотеку telethon (вот ее [документация](https://docs.telethon.dev/en/latest/)).
Код загрузки истории переписки весьма лаконичен:
```
username = ''
user = await client.get\_entity(username)
timestamps\_history = []
offset = 0
has\_messages = True
while has\_messages:
history = await client(GetHistoryRequest(
peer=user,
limit=200,
offset\_date=None,
offset\_id=0,
max\_id=0,
min\_id=0,
add\_offset=offset,
hash=0))
has\_messages = False
for message in history.messages:
has\_messages = True
timestamps\_history.append((message.date, message.out, message.message))
offset += len(history.messages)
if offset % 1000 == 0:
print(offset)
```
Полностью скрипт загрузки и обработки сообщений можно увидеть [здесь](https://github.com/evgenstf/response_timings_research).
Для его выполнения на своей переписке, вам при первом запуске нужно авторизоваться по номеру телефона и коду безопасности.
Telethon возвращает сообщения в удобном формате со всеми необходимыми параметрами: нам нужно время отправки, отправитель и собственно сам текст.
Извлекаем время ответа
----------------------
Есть несколько вариантов величин, которые можно исследовать. Например, можно разделить диалог на реплики — последовательные сообщения от одного отправителя. Тогда в качестве исследуемых времен можно использовать задержки между нашими репликами и собеседника.
Однако более показательными и интересными будут времена ответов на явные вопросы — сообщения содержащие '?' на конце.
Строим распределение
--------------------
Итак, у нас есть измеренные времена ответов собеседника на наши вопросы. Что с этим делать дальше? Самое простое и первое что приходит на ум — посчитать медиану и среднее значение.
```
friend: her median: 73 my median: 38
friend: her mean: 5823.03 my mean: 3841.03
mom: her median: 15 my median: 21
mom: her mean: 352.32 my mean: 77.25
colleague: her median: 20.0 my median: 15
colleague: her mean: 815.08 my mean: 204.84
classmate: his median: 63 my median: 18
classmate: his mean: 2656.09 my mean: 554.58
ex: her median: 35 my median: 18.0
ex: her mean: 586.59 my mean: 999.27
```
Можно видеть, что для разных людей мое личное значение времени реакции различается.
Но, поскольку хочется что-то более, чем два числа, мы построим распределение этого значения:
Из него видна проблема в данных — на больших временах значения довольно сильно разбросаны. Это можно исправить, Попробуем сделать шкалу времени не линейной, а логарифмической. Посколько и в жизни значимость времени ответа логарифмически уменьшается (довольно существенно, ответил ли собеседник через 5 минут или через 10, однако через день эта разница уже не столь значительна).
Ну и в конце для каждой персоны можем добавить аналогичный анализ для времен наших ответов. В целом это может показывать насколько мы более заинтересованы в общении с собеседником, по сравнению с ним. Но куда более точно можно быть уверенным, что заинтересованность в общении прослеживается при сравнении нашей реакции на разных собеседниках.
Можно видеть, что мы отвечаем на вопросы чаще: распределение ответов смещено к 7ми секундам, против 45и у собеседника.
Сравнение с разными людьми
--------------------------
Интересно сравнить, как меняется распределение в зависимости от отношений с человеком.
Ниже приведены несколько примеров:
### Коллега по работе
### Девушка
### Друг
Как и обещали, никаких глобальных выводов не будет. Общайтесь так, как вам комфортно, не оглядываясь на этикет.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=kazakov&utm_content=answer-logs#order) | https://habr.com/ru/post/541750/ | null | ru | null |
# Пишем простой модуль Magisk для Android
Введение
========
Одним вечером я устал менять TTL после перезагрузки устройства и подумал как можно было бы делать это автоматически. Android же Linux и на нем должен быть аналог systemd или он сам. В процессе исследований мой взор пал на Magisk.
На удивление разработать модуль для него было очень просто.
Подготовка
==========
Быстрым гуглением находим [дефолтный модуль Magisk](https://github.com/topjohnwu/magisk-module-installer). Не пугайтесь того что репозиторий Archived. Так задумано. Давайте форкнем его. Это будет наша основа модуля.
```
├── META-INF
│ └── com
│ └── google
│ └── android
│ ├── update-binary
│ └── updater-script
├── README.md
├── common
│ ├── post-fs-data.sh
│ ├── service.sh
│ └── system.prop
├── install.sh
├── module.prop
└── system
└── placeholder
```
Скрипт `install.sh` выполняется в момент установки. Скрипт `post-fs-data.sh` выполняется синхронно с загрузкой перед загрузкой [зиготы](https://www.youtube.com/watch?v=EId85wGrVNw). Скрипт `service.sh` запускается после загрузки системы асинхронно. Подробнее [тут](https://github.com/topjohnwu/Magisk/blob/master/docs/guides.md).
Модифицируем
============
В начале давайте поменяем `module.prop`. Именно там находится служебная информация по модулю. У меня получилось так:
```
id=yotattlfix
name=Yota TTL Fix
version=v1
versionCode=1
author=lionzxy
description=Change TTL on startup to 63
minMagisk=17000
```
В файле `install.sh` нужно, во-первых, выставить в `true` те вещи, которые мы будем использовать:
```
SKIPMOUNT=false
PROPFILE=false
POSTFSDATA=false
LATESTARTSERVICE=true
```
В файле подробнейшие комментарии по каждой строчке, так что разобраться не сложно.
Далее я поправил шапку при установке
```
print_modname() {
ui_print "*******************************"
ui_print " Magisk Yota TTL Fix "
ui_print "*******************************"
}
```
В дополнении, вы можете на этом этапе сделать проверку различных параметров. Тут обычный баш. Скорее всего, вам поможет getprop: `getprop ro.product.device`. Подробнее можете глянуть на своем устройстве в `/system/build.prop` или в гугле.
Ну и добавляем нужный нам код в `common/service.sh`
```
iptables -t mangle -A POSTROUTING -j TTL --ttl-set 63
```
Запускаем
=========
Компилировать ничего не нужно. Просто запакуйте в архив :) Можете воспользоваться Github
Далее открываем Magisk->Modules->Add на нашем аппарате и выбираем наш архив. Если мы попробуем запустить прям так, то увидим странную ошибку.
Пока я не сравнил свой модуль побайтово с рабочим модулем с 4pda, не понял где моя ошибка.
Для теста копируем [исходник](https://github.com/topjohnwu/Magisk/blob/master/scripts/module_installer.sh) к нам в проект. И все заработает
Итого:
Публикация
==========
У Magisk существует каталог модулей. Было бы классно туда попасть.
Все модули хранятся в организации на GitHub [github.com/Magisk-Modules-Repo](https://github.com/Magisk-Modules-Repo/submission)
Чтобы попасть туда нужно следовать ряду условий и создать Issues в [главном репозитории](https://github.com/Magisk-Modules-Repo/submission). Однако будьте готовы что принимать его будут очень и очень долго
 | https://habr.com/ru/post/478288/ | null | ru | null |
# Задача об определении принадлежности точки многоугольнику
Здравствуйте, уважаемые хабравчане!
В процессе разработки приложения под Android, которое предполагает взаимодействие пользователя с графическими примитивами (точками, линиями, эллипсами, прямоугольниками и т.д.), возникла довольно неприятная ситуация: пользователь может задать произвольный многоугольник и сделать его неактивным, однако чтобы в будущем была возможность активировать данный многоугольник и продолжить с ним работь (например, переместить в другое место или добавить/удалить вершины) необходимо для неактивного объекта определить, коснулся ли пользователь данного объекта, т.е. потребовалось решить вопрос о принадлежности точки многоугольнику.
Данная задача широко известна в вычислительной геометриии и я предлагаю вашему вниманию результаты моего исследования данной темы.
##### Введение
В вычислительной геометрии обычно предполагается, что многоугольник простой, т.е. без самопересечений, но проблему рассматривают и для многоугольников сложной формы. Данная задача наиболее часто решается следующими методами:
* методом учёта числа пересечений, который подсчитывает сколько раз луч, выходящий из точки *P*, пересекает границы многоугольника. Если число пересечений нечётно, то объявляется, что точка лежит внутри многоугольника, если чётно – снаружи.
* методом учёта числа оборотов, который подсчитывает число оборотов, которое делает ориентированная граница многоугольника вокруг данной точки *P*. В алгебраической топологии это число называется winding number. Точка считается лежащей снаружи многоугольника только в случае, если число оборотов равно нулю, в противном случае точка лежит внутри контура многоугольника.
Если многоугольник простой (т.е. не имеет самопересечений), то оба метода дают одинаковый результат для всех точек. Однако если многоугольник имеет сложную форму, то методы могут возвращать разные результаты для некоторых точек. Например, если многоугольник пересекается с собой, тогда при использовании метода учёта пересечений точки в регионе пересечения определяются как точки снаружи. Однако те же самые точки будут считаться лежащими внутри многоугольника при использовании метода учёта числа оборотов (см. рисунок).
Метод учёта числа пересечений и его оптимизация подробно описаны в [данной](http://habrahabr.ru/post/161237/) статье, поэтому давайте рассмотрим второй алгоритм решения задачи.
##### Метод учёта числа оборотов
Данный метод точно определяет, лежит ли точка внутри сложного многоугольника, сравнивая, как много раз полигон оборачивается вокруг точки. Точка не принадлежит полигону только в том случае, когда число оборотов (winding number) равно нулю.
Пусть непрерывная двумерная кривая *C* определяется точками *C(u) = C(x(u), y(u))*, где *0 ≤ u ≤ 1* и *C(0) = C(1)*. Также пусть *P* – точка, не лежащая на кривой *C*. Объявим вектор *c(P, u)* (от точки *P* до кривой *C*):
и единичный вектор *w(P, u)*:
,
который даёт непрерывную функцию *W(P): C → S1*, отображая точку *C(u)* кривой *C* к точке *w(P, u)* на единичной окружности *S1 = {(x, y) | x2 + y2 = 1}*. Это отображение может быть представлено в полярных координатах:
,
где *θ(u)* – положительный поворот против часовой стрелки в радианах.
Тогда число оборотов *wn(P, C)* непрерывной кривой *C* вокруг точки *P* равно целому числу раз, когда *W(P)* поворачивает кривую *C* вокруг единичной окружности *S1*. Это соответствует гомотопическому классу *S1* и может быть вычислено через интеграл:
Когда кривая *C* является полигоном с вершинами *V0*, *V1*, …, *Vn = V0*, интеграл сокращается до знаковой суммы углов, под которыми каждое ребро многоугольника *ViVi+1* *противолежит* к точке *P*. Таким образом, если θi равно углу между *PVi* и *PVi+1*, тогда:
 (1)
На рисунке показано, как графически можно представить знаковую сумму углов.
Очевидно, что формула (1) не очень эффективна, поскольку использует требовательную к вычислительным мощностям тригонометрическую функцию арккосинуса. Необходимо заменить эту формулу более эффективной.
##### Оптимизация метода учёта оборотов
Возьмём любую точку *Q* на единичной окружности. Тогда, как кривая *W(P)* оборачивается вокруг *S1*, она проходит точку *Q* определённое количество раз. Если считать (+1), когда кривая проходит *Q* против часовой стрелки, и (-1), когда кривая проходит по часовой стрелке, то накопленная сумма будет общим количество раз, сколько *W(P)* оборачивается вокруг *S1* и равна *wn(P, C)* – числу оборотов непрерывной кривой *C* вокруг точки *P*. Далее, если мы возьмём бесконечный луч *R* с началом в точке *P* и проходящей в направлении вектора *Q*, то пересечение луча *R* и кривой *C* соответствует точке, где *W(P)* проходит *Q*. Для разработки математического аппарата необходимо различать положительные и отрицательные переходы, где *C* пересекает *R* в направлениях справа налево или слева направо. Это можно определить по знаку скалярного произведения вектора нормали к *C* и направление вектора *q = Q*, и необходимо вычислить скалярное произведение для каждого ребра полигона. Для горизонтального луча *R* c началом в точке *P*, достаточно проверки, находится ли конец ребра выше или ниже луча. Если ребро пересекает прямой луч снизу вверх, то пересечение положительно (+1), но если он пересекает ребро сверху вниз, то пересечение отрицательно (-1). Сумма знаков пересечений даёт число оборотов *wn(P, C)*.
Более того, можно избежать вычисления фактической точки пересечения ребра и луча. Для этого достаточно определить, с какой стороны ребро пересекается лучом. Если восходящее ребро пересекает луч справа от точки *P*, то *P* находится левее ребра, т.к. треугольник *ViVi+1P* ориентирован против часовой стрелки. Если нисходящее ребро пересекает луч слева, то точка *P* находится правее ребра, поскольку треугольник *ViVi+1* ориентирован по часовой стрелке.
На рисунке слева изображено восходящее ребро, а справа — нисходящее.
В заключение хотелось бы сказать, что метод учёта оборотов требует полного перебора вершин заданного многоугольника и в этом, на мой взгляд, заключается его недостаток. Однако, он с лихвой компенсируется легкостью реализации и наличием всего двух операций умножения на каждой итерации цикла перебора вершин.
UPD:
##### Реализация
Наверно зря я сразу не приложил исходный код, поэтому исправляюсь.
**Исходный код**
```
public class Polygon {
// Массивы для хранения координат вершин многоугольника
private ArrayList xPoints = new ArrayList();
private ArrayList yPoints = new ArrayList();
// Опустим все get и set методы, как само собой разумеющееся
// Метод, который высчитывает число оборотов кривой
public boolean сontains(float \_pointX, float \_pointY) {
float windingNumber = 0; // Счётчик числа оборотов
float startX = 0;
float startY = 0;
float endX = 0;
float endY = 0;
int count = xPoints.size();
for (int i = 1; i <= count; i++) {
startX = xPoints.get(i - 1);
startY = yPoints.get(i - 1);
if (i == count) {
endX = xPoints.get(0);
endY = yPoints.get(0);
} else {
endX = xPoints.get(i);
endY = yPoints.get(i);
}
if (startY <= \_pointY) {
if (endY > \_pointY) {
// Восходящая грань
if (isLeft(startX, startY, endX, endY, \_pointX, \_pointY) > 0) {
// Точка P слева от грани многоугольника
++windingNumber;
}
}
} else {
if (endY <= \_pointY) {
// Нисходящая грань
if (isLeft(startX, startY, endX, endY, \_pointX, \_pointY) < 0) {
// Точка P справа от грани
--windingNumber;
}
}
}
}
return (windingNumber != 0);
}
// start\* и end\* - координаты точек, представляющих грань. point\* - координаты точки P, которую проверяем
private float isLeft(float \_startX, float \_startY, float \_endX, float \_endY, float \_pointX, float \_pointY) {
return ((\_endX - \_startX) \* (\_pointY - \_startY) - (\_pointX - \_startX) \* (\_endY - \_startY));
}
}
```
**Основной источник:** [GeometryAlgorithms.com](http://geomalgorithms.com/index.html) | https://habr.com/ru/post/169317/ | null | ru | null |
# Книга «Роман с Data Science. Как монетизировать большие данные»
[](https://habr.com/ru/company/piter/blog/556962/) Привет, Хаброжители! Как выжать все из своих данных? Как принимать решения на основе данных? Как организовать анализ данных (data science) внутри компании? Кого нанять аналитиком? Как довести проекты машинного обучения (machine learning) и искусственного интеллекта до топового уровня? На эти и многие другие вопросы Роман Зыков знает ответ, потому что занимается анализом данных почти двадцать лет. В послужном списке Романа — создание с нуля собственной компании с офисами в Европе и Южной Америке, ставшей лидером по применению искусственного интеллекта (AI) на российском рынке. Кроме того, автор книги создал с нуля аналитику в Ozon.ru. Эта книга предназначена для думающих читателей, которые хотят попробовать свои силы в области анализа данных и создавать сервисы на их основе. Она будет вам полезна, если вы менеджер, который хочет ставить задачи аналитике и управлять ею. Если вы инвестор, с ней вам будет легче понять потенциал стартапа. Те, кто «пилит» свой стартап, найдут здесь рекомендации, как выбрать подходящие технологии и набрать команду. А начинающим специалистам книга поможет расширить кругозор и начать применять практики, о которых они раньше не задумывались, и это выделит их среди профессионалов такой непростой и изменчивой области.
### Нужно ли уметь программировать?
Да, нужно. В XXI веке понимать, как использовать программирование в своей работе, желательно каждому человеку. Раньше программирование было доступно только узкому кругу инженеров. Со временем прикладное программирование стало все более доступным, демократичным и удобным.
Я научился программировать самостоятельно в детстве. Отец купил компьютер «Партнер 01.01» в конце 80-х, когда мне было примерно одиннадцать лет, и я начал погружаться в программирование. Вначале освоил язык BASIC, потом уже добрался до ассемблера. Изучал все по книгам — спросить тогда было не у кого. Задел, который был сделан в детстве, мне очень пригодился в жизни. В то время моим главным инструментом был белый мигающий курсор на черном экране, программы приходилось записывать на магнитофон — все это не идет ни в какое сравнение с теми возможностями, которые есть сейчас. Азам программирования научиться не так сложно. Когда моей дочери было пять с половиной лет, я посадил ее за несложный курс по программированию на языке Scratch. С моими небольшими подсказками она прошла этот курс и даже получила сертификат MIT начального уровня.
Прикладное программирование — это то, что позволяет автоматизировать часть функций сотрудника. Первые кандидаты на автоматизацию — повторяющиеся действия.
В аналитике есть два пути. Первый — пользоваться готовыми инструментами (Excel, Tableau, SAS, SPSS и т. д.), где все действия совершаются мышкой, а максимум программирования — написать формулу. Второй — писать на Python, R или SQL. Это два фундаментально разных подхода, но хороший специалист должен владеть обоими. При работе с любой задачей нужно искать баланс между скоростью и качеством. Особенно это актуально для поиска инсайтов. Я встречал и ярых приверженцев программирования, и упрямцев, которые могли пользоваться только мышкой и от силы одной программой. Хороший специалист для каждой задачи подберет свой инструмент. В каком-то случае он напишет программу, в другом сделает все в Excel. А в третьем — совместит оба подхода: на SQL выгрузит данные, обработает датасет в Python, а анализ сделает в сводной (pivot) таблице Excel или Google Docs. Скорость работы такого продвинутого специалиста может быть на порядок больше, чем одностаночника. Знания дают свободу.
Еще будучи студентом, я владел несколькими языками программирования и даже успел поработать полтора года разработчиком ПО. Времена тогда были сложными — я поступил в МФТИ в июне 1998 года, а в августе случился дефолт. Жить на стипендию было невозможно, денег у родителей я брать не хотел. На втором курсе мне повезло, меня взяли разработчиком в одну из компаний при МФТИ — там я углубил знание ассемблера и Си. Через какое-то время я устроился в техническую поддержку компании StatSoft Russia — здесь я прокачал статистический анализ. В Ozon.ru прошел обучение и получил сертификат SAS, а еще очень много писал на SQL. Опыт программирования мне здорово помог — я не боялся чего-то нового, просто брал и делал. Если бы у меня не было такого опыта программирования, в моей жизни не было бы многих интересных вещей, в том числе компании Retail Rocket, которую мы основали с моими партнерами.
### **Датасет**
Датасет — это набор данных, чаще всего в виде таблицы, который был выгружен из хранилища (например, через SQL) или получен иным способом. Таблица состоит из столбцов и строк, обычно именуемых как записи. В машинном обучении сами столбцы бывают независимыми переменными (independent variables), или предикторами (predictors), или чаще фичами (features), и зависимыми переменными (dependent variables, outcome). Такое разделение вы встретите в литературе. Задачей машинного обучения является обучение модели, которая, используя независимые переменные (фичи), сможет правильно предсказать значение зависимой переменной (как правило, в датасете она одна).
Основные два вида переменных — категориальные и количественные. Категориальная (categorical) переменная содержит текст или цифровое кодирование «категории». В свою очередь, она может быть:
* Бинарной (binary) — может принимать только два значения (примеры: да/нет, 0/1).
* Номинальной (nominal) — может принимать больше двух значений (пример: да/нет/не знаю).
* Порядковой (ordinal) — когда порядок имеет значение (пример, ранг спортсмена, номер строки в поисковой выдаче).
Количественная (quantitative) переменная может быть:
* Дискретной (discrete) — значение подсчитано счетом, например, число человек в комнате.
* Непрерывной (continuous) — любое значение из интервала, например, вес коробки, цена товара.
Рассмотрим пример. Есть таблица с ценами на квартиры (зависимая переменная), одна строка (запись) на квартиру, у каждой квартиры есть набор атрибутов (независимы) со следующими столбцами:
* Цена квартиры — непрерывная, зависимая.
* Площадь квартиры — непрерывная.
* Число комнат — дискретная (1, 2, 3, ...).
* Санузел совмещен (да/нет) — бинарная.
* Номер этажа — порядковая или номинальная (зависит от задачи).
* Расстояние до центра — непрерывная.
### **Описательная статистика**
Самое первое действие после выгрузки данных из хранилища — сделать разведочный анализ (exploratory data analysis), куда входит описательная статистика (descriptive statistics) и визуализация данных, возможно, очистка данных через удаление выбросов (outliers).
В описательную статистику обычно входят различные статистики по каждой из переменных во входном датасете:
* Количество непустых значений (non missing values).
* Количество уникальных значений.
* Минимум/максимум.
* Среднее значение.
* Медиана.
* Стандартное отклонение.
* Перцентили (percentiles) — 25 %, 50 % (медиана), 75 %, 95 %.
Не для всех типов переменных их можно посчитать — например, среднее значение можно рассчитать только для количественных переменных. В статистических пакетах и библиотеках статистического анализа уже есть готовые функции, которые считают описательные статистики. Например, в библиотеке pandas для Python есть функция describe, которая сразу выведет несколько статистик для одной или всех переменных датасета:
```
s = pd.Series([4-1, 2, 3])
s.describe()
count 3.0
mean 2.0
std 1.0
min 1.0
25% 1.5
50% 2.0
75% 2.5
max 3.0
```
Хотя эта книга не является учебником по статистике, дам вам несколько полезных советов. Часто в теории подразумевается, что мы работаем с нормально распределенными данными, гистограмма которых выглядит как колокол (рис. 4.1).
Очень рекомендую проверять это предположение хотя бы на глаз. Медиана — значение, которое делит выборку пополам. Например, если 25-й и 75-й перцентиль находятся на разном расстоянии от медианы, это уже говорит о смещенном распределении. Еще один фактор — сильное различие между средним и медианой; в нормальном распределении они практически совпадают. Вы будете часто иметь дело с экспоненциальным распределением, если анализируете поведение клиентов, — например, в Ozon.ru время между последовательными заказами клиента будет иметь экспоненциальное распределение. Среднее и медиана для него отличаются в разы. Поэтому правильная цифра — медиана, значение, которое делит выборку пополам. В примере с Ozon.ru это время, в течение которого 50 % пользователей делают следующий заказ после первого. Медиана также более устойчива к выбросам в данных. Если же вы хотите работать со средними, например, из-за ограничений статистического пакета, да и технически среднее считается быстрее, чем медиана, то в случае экспоненциального распределения можно его обработать натуральным логарифмом. Чтобы вернуться в исходную шкалу данных, нужно полученное среднее обработать обычной экспонентой.
Перцентиль — значение, которое заданная случайная величина не превышает с фиксированной вероятностью. Например, фраза «25-й перцентиль цены товаров равен 150 рублям» означает, что 25 % товаров имеют цену меньше или равную 150 рублям, остальные 75 % товаров дороже 150 рублей.
Для нормального распределения, если известно среднее и стандартное отклонение, есть полезные теоретически выведенные закономерности — 95 % всех значений попадает в интервал на расстоянии двух стандартных отклонений от среднего в обе стороны, то есть ширина интервала составляет четыре сигмы. Возможно, вы слышали такой термин, как Шесть сигм (six sigma, рис. 4.1), — эта цифра характеризует производство без брака. Так вот, этот эмпирический закон следует из нормального распределения: в интервал шести стандартных отклонений вокруг среднего (по три в каждую сторону) укладывается 99.99966 % значений — идеальное качество. Перцентили очень полезны для поиска и удаления выбросов из данных. Например, при анализе экспериментальных данных вы можете принять то, что все данные вне 99-го перцентиля — выбросы, и удалять их.
### **Графики**
Хороший график стоит тысячи слов. Основные виды графиков, которыми пользуюсь я:
* гистограммы;
* диаграмма рассеяния (scatter chart);
* график временного ряда (time series) с линией тренда;
* график «ящики с усами» (box plot, box and whiskers plot).
Гистограмма (рис. 4.2) — наиболее полезный инструмент анализа. Она позволяет визуализировать распределение по частотам появления какого-то значения (для категориальной переменной) или разбить непрерывную переменную на диапазоны (bins). Второе используется чаще, и если к такому графику дополнительно предоставить описательные статистики, то у вас будет полная картина, описывающая интересующую вас переменную. Гистограмма — это простой и интуитивно понятный инструмент.
График диаграммы рассеяния (scatterplot, рис. 4.3) позволяет увидеть зависимость двух переменных друг от друга. Строится он просто: на горизонтальной оси — шкала независимой переменной, на вертикальной оси — шкала зависимой. Значения (записи) отмечаются в виде точек. Также может добавляться линия тренда. В продвинутых статистических пакетах можно интерактивно пометить выбросы.
Графики временных рядов (time series, рис. 4.4) — это почти то же самое, что и диаграмма рассеяния, в которой независимая переменная (на горизонтальной оси) — это время. Обычно из временного ряда можно выделить две компоненты — циклическую и трендовую. Тренд можно построить, зная длину цикла, например, семидневный — это стандартный цикл продаж в продуктовых магазинах, на графике можно увидеть повторяющуюся картинку каждые 7 дней. Далее на график накладывается скользящее среднее с длиной окна, равной циклу, — и вы получаете линию тренда. Практически все статистические пакеты, Excel, Google Sheets умеют это делать. Если нужно получить циклическую компоненту, это делается вычитанием из временного ряда линии тренда. На основе таких простых вычислений строятся простейшие алгоритмы прогнозирования временных рядов.
График «Ящик с усами» (box plot, рис. 4.5) очень интересен; в некоторой степени он дублирует гистограммы, так как тоже показывает оценку распределения.
Он состоит из нескольких элементов: усов, которые обозначают минимум и максимум, ящика, верхний край которого 75-й перцентиль, нижний — 25-й перцентиль. В ящике линия — это медиана, значение «посередине», которая делит выборку пополам. Этот тип графика удобен для сравнения результатов экспериментов или переменных между собой. Пример такого графика ниже (рис. 4.6). Считаю это лучшим способом визуализации результатов тестирования гипотез.
### **Общий подход к визуализации данных**
Визуализация данных нужна для двух вещей: для исследования данных и для того, чтобы объяснить выводы заказчику. Часто для представления результатов используется несколько способов: простой комментарий с парой цифр, Excel или другой формат электронных таблиц, презентация со слайдами. Все эти три способа объединяют вывод и доказательство — то есть объяснение, как к этому выводу пришли. Доказательство бывает удобно выражать в графиках. В 90 % случаев для этого достаточно тех графиков, типы которых были описаны выше.
Исследовательские графики и презентационные отличаются друг от друга. Цель исследовательских — найти закономерность или причину, их, как правило, много, и бывает, что они строятся наугад. Целью презентационных графиков является подведение ЛПР (лица, принимающего решения) к выводам в задаче. Тут важно все — и заголовок слайда, и их простая последовательность, которая ведет к нужному выводу. Важный критерий схемы доказательства вывода — как быстро заказчик поймет и согласится с вами. Необязательно это должна быть презентация. Лично я предпочитаю простой текст — пара предложений с выводами, пара графиков и несколько цифр, доказывающих эти выводы, ничего лишнего.
Джин Желязны, который работает директором по визуальным коммуникациям в McKinsey & Company, в своей книге «Говори на языке диаграмм» утверждает:
«Тип диаграммы определяют вовсе не данные (доллары или проценты) и не те или иные параметры (прибыль, рентабельность или зарплата), а ваша идея — то, что вы хотите в диаграмму вложить».
Рекомендую вам обращать внимание на графики в презентациях и статьях — доказывают ли они выводы автора? Все ли вам нравится в них? Могли бы они быть более убедительными?
А вот что пишет Джин Желязны про слайды в презентациях:
«Широкое распространение компьютерных технологий привело к тому, что сейчас за минуты можно сделать то, на что раньше требовались часы кропотливой работы, — и слайды пекутся как пирожки… пресные и невкусные».
Я делал довольно много докладов: со слайдами и без, короткие, на 5–10 минут, и длинные — на час. Смею вас заверить, что мне намного сложнее сделать убедительный текст для короткого доклада без слайдов, чем презентацию в PowerPoint. Посмотрите на политиков, которые выступают: их задача убеждать, много ли из них показывают слайды на выступлениях? Слово убеждает сильнее, слайды — это всего лишь наглядный материал. И чтобы ваше слово было понятно и убедительно, требуется больше труда, чем для накидывания слайдов. Я себя поймал на том, что при составлении слайдов я думаю о том, как презентация выглядит. А при составлении устного доклада — насколько убедительны мои аргументы, как работать с интонацией, насколько понятна моя мысль. Пожалуйста, подумайте, действительно ли вам нужна презентация? Хотите ли вы превратить совещание в просмотр скучных слайдов вместо принятия решений?
«Совещания должны фокусироваться на кратких письменных отчетах на бумаге, а не на тезисах или обрывочных пунктах списка, проецируемых на стену», — утверждает Эдвард Тафти, видный представитель школы визуализации данных, в своей работе «Когнитивный стиль PowerPoint».
### **Парный анализ данных**
О парном программировании я узнал от разработчиков [30] Retail Rocket. Это техника программирования, при которой исходный код создается парами людей, программирующих одну задачу и сидящих за одним рабочим местом. Один программист сидит за клавиатурой, другой — работает головой, сосредоточен на картине в целом и непрерывно просматривает код, производимый первым программистом. Время от времени они могут меняться местами.
И нам удалось ее адаптировать для нужд аналитики! Аналитика, как и программирование, — творческий процесс. Представьте, что вам нужно построить стену. У вас есть один рабочий. Если вы добавите еще одного — скорость вырастет примерно в два раза. В творческом процессе так не получится. Скорость создания проекта не вырастет в два раза. Да, можно проект декомпозировать, но я сейчас обсуждаю задачу, которая не декомпозируется, и ее должен делать один человек. Парный же подход позволяет многократно ускорить этот процесс. Один человек за клавиатурой, второй сидит рядом. Две головы работают над одной проблемой. Когда я решаю сложные проблемы, я разговариваю сам с собой. Когда разговаривают две головы друг с другом — они ищут причину лучше. Мы используем схему парной работы для следующих задач.
* Когда нужно передать знания одного проекта от одного сотрудника другому, например, был нанят новичок. «Головой» будет сотрудник, который передает знания, «руками» за клавиатурой — кому передают.
* Когда проблема сложная и непонятная. Тогда два опытных сотрудника в паре решат ее намного эффективней одного. Будет сложнее сделать задачу анализа однобоко.
Обычно на планировании мы переносим задачу в категорию парных, если понятно, что она подходит под критерии таковой.
Плюсы парного подхода — время используется намного эффективней, оба человека очень сфокусированы, они друг друга дисциплинируют. Сложные задачи решаются более творчески и на порядок быстрей. Минус — в таком режиме невозможно работать больше нескольких часов, очень сильно устаешь.
### **Технический долг**
Еще одна важная вещь, которой я научился у инженеров Retail Rocket, — работа с техническим долгом (technical debt). Технический долг — это работа со старыми проектами, оптимизация скорости работы, переход на новые версии библиотек, удаление старого программного кода от тестирования гипотез, инженерное упрощение проектов. Все эти задачи занимают добрую треть времени разработки аналитики. Приведу цитату технического директора Retail Rocket Андрея Чижа:
«Я еще не встречал компаний за свою практику (а это более 10 компаний, в которых работал сам, и примерно столько же, с которыми хорошо знаком изнутри), кроме нашей, у которых в бэклоге были бы задачи на удаление функционала, хотя, наверное, такие существуют».
Я тоже не встречал. Видел «болота» программных проектов, где старье мешает создавать новое. Суть технического долга — все, что вы сделали ранее, нужно обслуживать. Это как с ТО автомобиля — его нужно делать регулярно, иначе машина сломается в самый неожиданный момент. Программный код, в который давно не вносились изменения или обновления, — плохой код. Обычно он уже работает по принципу «работает — не трогай». Четыре года назад я общался с разработчиком Bing. Он рассказал, что в архитектуре этого поискового движка есть скомпилированная библиотека, код которой потерян. И никто не знает, как это восстановить. Чем дольше это тянется, тем хуже будут последствия.
Как аналитики Retail Rocket обслуживают технический долг:
* После каждого проекта тестирования гипотез мы удаляем программный код этой гипотезы везде, где только можно. Это избавляет нас от ненужного и неработающего хлама.
* Если происходит обновление каких-либо версий библиотек — мы делаем это с некоторым запозданием, но делаем регулярно. Например, платформу Spark мы апгрейдим регулярно, начиная с версии 1.0.0.
* Если какие-либо компоненты обработки данных работают медленно — ставим задачу и занимаемся ею.
* Если есть какие-то потенциально опасные риски — например, переполнение дисков кластера, тоже ставится соответствующая задача.
Работа с техническим долгом — это путь к качеству. Меня убедила в этом работа в проекте Retail Rocket. С инженерной точки зрения проект сделан как в «лучших домах Калифорнии».
Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/product/roman-s-data-science-kak-monetizirovat-bolshie-dannye?_gs_cttl=120&gs_direct_link=1&gsaid=42817&gsmid=29789&gstid=c)
» [Оглавление](https://www.piter.com/product/roman-s-data-science-kak-monetizirovat-bolshie-dannye#Oglavlenie-1)
» [Отрывок](https://www.piter.com/product/roman-s-data-science-kak-monetizirovat-bolshie-dannye#Otryvok-1)
Для Хаброжителей скидка 25% по купону — **Data Science**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга. | https://habr.com/ru/post/556962/ | null | ru | null |
# Не только Яндексу. Микроразметка на крупнейших сайтах рунета: зачем ею пользуются и почему она пригодится и вам
Мы уже рассказали вам о мире семантической разметки — о том, [какие бывают словари](http://habrahabr.ru/company/yandex/blog/211638/), [почему столько стандартов синтаксиса](http://habrahabr.ru/company/yandex/blog/221881/), а также разобрали, [в каких продуктах она используется](http://habrahabr.ru/company/yandex/blog/229929/).
Теперь мы решили показать, как микроразметка участвует в жизни существующих сайтов: сделали обзор всех возможностей, которые она дает интернет-магазинам, сайтам СМИ и видеохостингам, и узнали, насколько они пользуются спросом у крупнейших проектов рунета.
[](http://habrahabr.ru/company/yandex/blog/246003/)
Люди, которые отвечают за разработку и всю техническую часть таких сайтов, как [Holodilnik.ru](http://holodilnik.ru/), [Ozon.ru](http://www.ozon.ru/), [Lenta.ru](http://lenta.ru), [Interfax.ru](http://interfax.ru) и [Ivi.ru](http://ivi.ru), ответили на вопросы о том, как на практике происходит внедрение микроразметки и каких результатов она позволяет добиться. А мы со своей стороны рассказали, какие типы мы бы порекомендовали таким сайтам и для чего.
#### Интернет-магазины
##### Денис Егоров, руководитель направления интернет-маркетинга [Holodilnik.ru](http://holodilnik.ru/):
> На сайте holodilnik.ru мы решили внедрить сразу два типа разметки, [Open Graph](http://ogp.me/) и [Schema.org/Product](http://schema.org/Product). Причина такого выбора проста — один из этих типов поддерживает поисковик на «Я», а второй — поисковик на «G»:) Внедрять ее было достаточно легко, и о своем выборе нам не пришлось пожалеть.
>
>
>
> 
>
>
>
> Конечно, многие сейчас задаются вопросом, какова эффективность того или иного внедрения, в том числе и какова эффективность внедрения мироразметки — на все нужны ресурсы, которые потом должны себя оправдать. Вопрос этот, действительно, интересен. На момент внедрения мы считали микроразметку необходимым улучшением, и у нас не было цели напрямую отслеживать ее эффективность. Однако за год, прошедший с момента ее внедрения, мы получили следующее: глубина просмотра посетителей из поисковиков выросла почти в 2 раза, при этом показатель отказов снизился в 3-4 раза. Количество же достижения цели выросло на 20-30%. Согласитесь, это неплохой показатель. И хотя, конечно, мы не связываем весь этот рост только с внедрением одной лишь микроразметки, значительная доля изменения этих показателей, безусловно, ее заслуга.
##### Андрей Кузьмичёв, руководитель направления поисковой оптимизации [Ozon.ru](http://www.ozon.ru/):
> В Ozon.ru мы внедрили разметку разных стандартов, потому что каждая из них дает выигрыш в чем-то своем: микроформат [hCard](http://microformats.org/wiki/h-card) и [Schema.org](http://schema.org/) дают качественное представление в поисковых системах, а [Open Graph](http://ogp.me/) — в социальных сетях. В общем и целом, благодаря этой разметке наши сниппеты стали более качественными и структурированными.
>
>
>
> 
>
>
>
> На достигнутом мы останавливаться не собираемся, как, видимо, и поисковые системы. Чем больше новых типов микроразметки они начинают учитывать, тем больше у магазинов становиться возможностей как-то выделиться на поиске. Так, недавно стала учитываться разметка [Schema.org/Product](http://schema.org/Product) по новой [партнерской программе Яндекса для разметки товаров](http://webmaster.ya.ru/replies.xml?item_no=19453). Однако для некоторых категорий мы будем использовать семантическую разметку товаров совместно с программой [«Товары и цены»](http://help.yandex.ru/webmaster/goods-prices/shop-owners.xml), которая пока иногда дает преимущества по скорости обновления данных о продуктах. И такая задача уже стоит у наших программистов.
Типичный сайт Интернет-магазина состоит из страниц с товарами, каталогом, контактами и информацией о доставке. Разметив страницы с товарами и контактами, можно улучшить свое представление в поисковых системах.
Для страниц с товарами в Schema.org существует большой тип [Schema.org/Product](http://schema.org/Product), с помощью которого можно подробно описать практически любую вещь. Благодаря такой разметке в Яндексе формируются [структурированные сниппеты с описанием товара и ценой](http://help.yandex.ru/webmaster/supported-schemas/goods-prices.xml).
Для формирования таких сниппетов нужны указанные поля [name](https://schema.org/name), [description](https://schema.org/description), [price](https://schema.org/price) и [priceCurrency](https://schema.org/priceCurrency):
```
массажёр Beurer MG 81
======================
Массажер Beurer MG81 - это современный, элегантный и многофункциональный прибор. Крупные массажные головки эргономичной формы выполняют глубокий вибрационный (ударный) массаж на любом участке тела. Дополнительно массируемый участок тела можно прогреть инфракрасным нагревательным элементом. Также возможно подключить 2 разные массажные насадки. Вибромассажер с инфракрасным излучателем может проводить массаж с различной интенсивностью. Вы можете проводить массаж и самостоятельно, и с помощью другого человека. Длинный сетевой шнур позволяет проводить сеанс массажа в удобном месте независимо от расположения розетки. Также у массажера удобная и не скользящая ручка для простого и надежного применения.
3320
руб.
```
Большое влияние на решение о покупке оказывают отзывы. Если у вас есть отзывы, мы рекомендуем добавить специальную разметку: в [Product](http://schema.org/Product) для этого есть свойство [AggregateRating](http://schema.org/aggregateRating), а в микроформатах есть тип [hReview](http://microformats.org/wiki/h-review).
В Google на основе разметки формируются [специальные сниппеты](https://support.google.com/webmasters/answer/146645?hl=ru).
Для этого необходимо указать значение поля [AggregateRating](http://schema.org/AggregateRating):
```
"Смартфон Apple iPhone 6 4.7" 16Gb Space Gray
==============================================
```
Для страницы с контактами подходит разметка [Organization](http://schema.org/Organization) от Schema.org или микроформат [hCard](http://microformats.org/wiki/h-card). C их помощью можно участвовать в [партнерской программе Яндекса](http://help.yandex.ru/webmaster/addresses-organizations/organization-info.xml): попасть в справочник и улучшить ответы не только в поиске, но и на Яндекс.Картах.
При использовании микроформата необходимо указать название организации, адрес и телефон:
```
Онлайн-мегамаркет OZON.ru: год за годом
Офис в Москве
125252
, г.
Москва,
Чапаевский переулок, д. 14
```
И, на наш взгляд, на всех страницах стоит использовать [Open Graph](http://ogp.me/), чтобы покупатели могли наглядно делиться вашим интернет-магазином и его товарами у себя на страницах и в личных сообщениях.
Для формирования превью достаточно разметки названия, краткого описания и картинки.
```
```
Для страницы с перечнем товаров можно добавить разметку [ItemList](http://schema.org/ItemList), чтобы получить специальный [остров с каталогом](http://help.yandex.ru/webmaster/interactive-answers/template/catalogue.xml):
Разметка полей [name](https://schema.org/name), [description](https://schema.org/description), [image](https://schema.org/image), [url](http://schema.org/url) нужна для формирования таблицы, а для указания цен [offers.priceCurrency](https://schema.org/priceCurrency), [offers.price](https://schema.org/price).
```
Сковороды Rondell
==================
{{totalModelsCount}}
{{currentModelsCount}}
```
*Платформа «Острова» находится на стадии бета-тестирования*
Учитывая, что сайты могут предлагать разные товары, эти типы разметки подойдут всем интернет-магазинам, у кого есть страницы с описанием и ценой для каждого товара.
#### СМИ
##### Александр Ломакин, технический директор [Lenta.ru](http://lenta.ru):
> В Lenta.ru мы используем три типа семантической разметки: это [Open Graph](http://ogp.me/), [Twitter Cards](https://dev.twitter.com/cards/overview) и [Schema.org](http://schema.org/).
>
> С первыми двумя стандартами от Facebook и Twitter все просто — наши материалы достаточно много «шерят» и «лайкают», поэтому в социальных сетях они должны выглядеть ничуть не хуже, чем на основном сайте. С помощью разметки мы это контролируем, размечая фотографию, заголовок, и краткое описание.
>
>
>
> 
>
>
>
> Со [Schema.org](http://schema.org/) все несколько иначе. Помимо того, чтобы наш сайт красиво отображался в результатах поиска, мы хотим помогать поисковым системам получать и правильно индексировать структурированные данные.
>
>
>
> В итоге наши материалы стали заметнее как в социальных сетях, так и в результатах выдачи поисковых систем. Но, что самое главное, мы получили дополнительный трафик. Честно говоря, я не понимаю, почему большое количество ресурсов забивают и не используют микроразметку. Ведь даже на такой большой сайт, как [Lenta.ru](http://lenta.ru), добавить разметку очень просто. Поэтому мы не хотим останавливаться на имеющейся разметке и в ближайшем будущем планируем внедрить еще один тип — микроформат [hNews](http://microformats.org/wiki/hNews), который сделает наши материалы более читабельными в сервисах типа [Readability](https://www.readability.com/).
##### Михаил Воблов, руководитель разработки [Interfax.ru](http://www.interfax.ru/):
> Мы задумались над внедрением микроразметки в тот момент, когда осознали важность социальных сетей, в частности, Facebook, и трафика, который от них поступает. Научиться отображать там наши материалы в удобной форме — с правильной картинкой и с нужной текстовой вставкой, — вот какая задача перед нами стояла. И она решалась при помощи [Open Graph](http://ogp.me/), именно поэтому этот тип стал первой внедренной разметкой на нашем сайте.
>
>
>
> 
>
>
>
> Теперь же мы задумываемся над тем, как нам еще может помочь микроразметка, в частности, уже для улучшения представленности на поиске. Возможность давать развернутую информацию и хороший лид на [карточке новости](http://help.yandex.ru/webmaster/interactive-answers/template/article.xml) — это то, что может привлечь нам новую аудиторию. Для такой карточки достаточно указать с помощью Schema.org название, текст и изображение и получить расширенный ответ.
>
>
На сайтах СМИ содержатся страницы с разными видами контента — как текстами, так и мультимедийными материалами.
На все страницы статей, новостей и репортажей, на наш взгляд, крайне важно добавить [Open Graph](http://ogp.me/) — как правило, на отдельные новости ссылаются и пользователи, и группы в своих постах. По тем же причинам рекомендуем использовать [Twitter Cards](https://dev.twitter.com/cards/overview).
```
```
Для новостных сводок и различных текстов подходит разметка [CreativeWork](http://schema.org/CreativeWork), с помощью которой в Яндексе строится [структурированный сниппет](http://help.yandex.ru/webmaster/supported-schemas/other-content.xml) и остров с карточкой новости.
Можно указать автора, заголовок и краткое содержание. В данном случае остров строится на основе заголовка и содержания:
```
Детский театральный фестиваль "Большая перемена" открывается в Москве
=====================================================================
Традиционно программа фестиваля состоит из основной и специальной программ. Если основную афишу формируют из зарубежных и российских спектаклей, то в дополнительную входят мастер-классы и встречи, тема которых - театральные технологии и искусство для детей.
```
*Платформа «Острова» находится на стадии бета-тестирования*
На страницу с контактами можно добавить разметку [Organization](http://schema.org/Organization) или [hCard](http://microformats.org/wiki/h-card).
#### Видеохостинги
##### Денис Чудинов, руководитель направления оптимизации [Ivi.ru](http://ivi.ru):
> Мы начали задумываться над внедрением микроразметки лишь в 2012 году, в то время как Яндекс еще в 2010 году стал учитывать первые типы микроразметки. Но лучше поздно, чем никогда :) Однако оказалось, что и в 2012 году в Рунете не было практически никаких примеров ее использования, все были только наслышаны о ней, но совершенно не понимали, как и что внедрять. Поэтому учиться приходилось на собственном опыте: нам ничего не оставалось делать, как самим рассматривать разные варианты, изучать документацию имеющихся стандартов и подсматривать у западных коллег. В общем, экспериментировали. В итоге решили внедрить два типа: [Open Graph](http://ogp.me/) и [Schema.org/Movie](http://schema.org/Movie), так как они помогают передавать данные поисковым системам и красиво отображаться в социальных сетях.
>
>
>
> Для нас это внедрение проходило непросто как с точки зрения разработки, так и с точки зрения понимания, зачем она нужна — на тот момент было не очень очевидно, что даст микроразметка. В общем было ясно только то, [Open Graph](http://ogp.me/) нужен для социальных сетей, а [Schema.org](http://schema.org) для поисковиков. Кроме того, на тот момент у нас не было отдельной метрики для измерения эффективности разметки, да и не очень было понятно, как эффект именно от ее внедрения можно измерить. Однако прошло немного времени, и мы стали замечать, что из текста сниппетов в Яндексе стали пропадать «левые тексты», они стали более информативными. И это же стали замечать наши пользователи, что не могло наc не радовать.
>
>
>
> 
>
>
>
> Сейчас мы продолжаем внедрение микроразметки, в этот раз уже с куда более четкими целями и метриками — чтобы подключиться к [обновленной](http://webmaster.ya.ru/replies.xml?item_no=17989) [партнерской программе Яндекс.Видео](http://help.yandex.ru/webmaster/video/owners.xml), так как ожидаем после этого существенного увеличения количества посещений с этого сервиса.
Все видеоматериалы можно подробно описать с помощью типа [VideoObject](http://schema.org/VideoObject) от Schema.org или [расширения Open Graph](http://help.yandex.ru/webmaster/video/open-graph-markup.xml) от Яндекса. Разметка позволит участвовать в партнерских программах [Яндекса](http://help.yandex.ru/webmaster/video/owners.xml) и [Google](https://support.google.com/webmasters/answer/2413309?hl=ru&ref_topic=4603851) и хорошо отображаться как в результатах большого поиска, так и в поиске агрегаторов видео.
В разметке указываются данные видео: название, длина, номер серии и так далее.
```
```
А с помощью разметки [Schema.org/Movie](http://schema.org/Movie) можно получить структурированные сниппеты с описанием фильмов в Яндексе:
Для этого необходимо разметить подробную информацию о фильме:
```
Кавказская пленница, или Новые приключения Шурика
=================================================
режиссер [Леонид Гайдай](/name/191587/) |
* [Александр Демьяненко](/name/284624/)
* [Наталья Варлей](/name/192726/)
Отправившись в одну из горных республик собирать фольклор, герой фильма Шурик влюбляется в симпатичную девушку; спортсменку, отличницу, и просто красавицу. Но ее неожиданно похищают, чтобы насильно выдать замуж. Наивный Шурик не сразу смог сообразить, что творится у него под носом, однако затем отважно ринулся освобождать кавказскую пленницу
```
Пользователи могут искать фильмы не только по названию, но и по другим параметрам — жанру, режиссеру или актерскому составу. Такая разметка поможет находить нужные результаты на вашем сайте.
На данный момент 30% страниц, известных Яндексу, имеют семантическую разметку. Ответы представителей сайтов — небольшая, но очень показательная часть опыта использования разметки. Если у вас он тоже есть — делитесь в комментариях!
Мы благодарим наших партнеров за ответы и содействие в составлении этой статьи.
На этом серия обучающих постов, посвященных семантической разметке, подходит к концу. Мы писали о различных [словарях](http://habrahabr.ru/company/yandex/blog/211638/) и о [стандартах синтаксиса](http://habrahabr.ru/company/yandex/blog/221881/), о [продуктах на основе разметки](http://habrahabr.ru/company/yandex/blog/229929/), а в этой статье рассмотрели живые примеры сайтов Рунета, использующих и рекомендующих разметку.
Надеемся, что эти статьи помогли вам понять, что из себя представляет семантическая разметка и какую пользу может принести вам. В свою очередь, мы, команда семантического веба в Яндексе, будем продолжать создавать продукты и инструменты, способные помочь в работе с семантической разметкой, и продолжать писать о ней. | https://habr.com/ru/post/246003/ | null | ru | null |
# Эволюция Docker. Часть 2.1
Вступление
----------
v0.1.0Данная статья является второй, в цикле по истории развития и изучению исходного кода Docker. В ней мы разберем, что представлял собой первый публичный релиз от 23 марта 2013 года.
Изначально я планировал уложить весь материал, посвященный этой версии, в одной статье, но в процессе стало ясно, что она получается слишком большой, поэтому я решил разделить ее на две. В текущей части (2.1) будет рассмотрена лишь общая структура и начальный код, а последующая часть (2.2) будет посвящена принципу работы и коду конкретных команд.
Некоторые части кода уже были разобраны в [первой статье](https://habr.com/ru/post/573828/), так что для полноты восприятия, рекомендую начать с нее, а также пятиминутной презентации [The Future of Linux Containers](https://www.youtube.com/watch?v=wW9CAH9nSLs), на которой и была представлена первая версия Docker.
Docker v0.1.0
-------------
Все действия будут выполняться, как и ранее, на Windows 10 и Vagrant с Ubuntu 20.04. Начнем с установки требуемых пакетов:
```
sudo apt-get update && sudo apt-get -y install lxc libarchive-tools curl golang git debootstrap tree
```
Клонируем репозиторий и перейдем на версию v0.1.0:
```
cd /home/vagrant && git clone https://github.com/docker/engine.git && cd ./engine
git checkout -f v0.1.0 && git log | head -n 5 && tree
HEAD is now at 57e2126a02 Bumped version to 0.1.0
commit 57e2126a02f8b96b0542df7f6a573233d8419bb1
Author: Solomon Hykes
Date: Sat Mar 23 17:48:18 2013 -0700
Bumped version to 0.1.0
.
├── AUTHORS
├── LICENSE
├── NOTICE
├── README.md
├── Vagrantfile
├── archive.go
├── archive\_test.go
├── auth
│ ├── auth.go
│ └── auth\_test.go
├── changes.go
├── commands.go
├── container.go
├── container\_test.go
├── contrib
│ ├── README
│ ├── install.sh
│ └── mkimage-busybox.sh
├── deb
│ ├── Makefile -> ../Makefile
│ ├── Makefile.deb
│ ├── README.md -> ../README.md
│ ├── debian
│ │ ├── changelog
│ │ ├── compat
│ │ ├── control
│ │ ├── copyright
│ │ ├── docs
│ │ ├── rules
│ │ └── source
│ │ └── format
│ └── etc
│ ├── docker-dev.upstart
│ └── docker.upstart
├── docker
│ └── docker.go
├── docs
│ ├── README.md
│ └── images-repositories-push-pull.md
├── graph.go
├── graph\_test.go
├── image.go
├── lxc\_template.go
├── mount.go
├── mount\_darwin.go
├── mount\_linux.go
├── network.go
├── network\_test.go
├── puppet
│ ├── manifests
│ │ └── quantal64.pp
│ └── modules
│ └── docker
│ ├── manifests
│ │ └── init.pp
│ └── templates
│ ├── dockerd.conf
│ └── profile
├── rcli
│ ├── http.go
│ ├── tcp.go
│ └── types.go
├── registry.go
├── runtime.go
├── runtime\_test.go
├── state.go
├── sysinit.go
├── tags.go
├── term
│ ├── term.go
│ ├── termios\_darwin.go
│ └── termios\_linux.go
├── utils.go
└── utils\_test.go
16 directories, 58 files
```
Как можно заметить, со времени первого коммита файлов заметно прибавилось. Директории deb и puppet мы опустим, так как они нас мало интересуют.
Для начала попробуем скомпилировать и запустить данную версию программы:
```
go mod init github.com/dotcloud/docker && cd docker && go build docker.go
go: creating new go.mod: module github.com/dotcloud/docker
go: finding github.com/kr/pty v1.1.8
go: downloading github.com/kr/pty v1.1.8
go: extracting github.com/kr/pty v1.1.8
go: downloading github.com/creack/pty v1.1.7
go: extracting github.com/creack/pty v1.1.7
go: finding github.com/creack/pty v1.1.7
```
```
vagrant@ubuntu-focal:/vagrant/engine/docker$ sudo ./docker version
docker version
Version:0.1.0
vagrant@ubuntu-focal:~/engine/docker$ sudo ./docker help
Usage: docker COMMAND [arg...]
A self-sufficient runtime for linux containers.
Commands:
run Run a command in a container
ps Display a list of containers
import Create a new filesystem image from the contents of a tarball
attach Attach to a running container
commit Create a new image from a container's changes
history Show the history of an image
diff Inspect changes on a container's filesystem
images List images
info Display system-wide information
inspect Return low-level information on a container
kill Kill a running container
login Register or Login to the docker registry server
logs Fetch the logs of a container
port Lookup the public-facing port which is NAT-ed to PRIVATE_PORT
ps List containers
pull Pull an image or a repository to the docker registry server
push Push an image or a repository to the docker registry server
restart Restart a running container
rm Remove a container
rmi Remove an image
run Run a command in a new container
start Start a stopped container
stop Stop a running container
export Stream the contents of a container as a tar archive
version Show the docker version information
wait Block until a container stops, then print its exit code
```
Уже в первой версии имеется знакомый нам функционал для работы с контейнерами, образами, историей, репозиторием, сетевыми портами и тп.
К сожалению, воспользоваться репозиторием для скачивания образа не получится, так как с тех пор формат и сам репозиторий поменялись, а для запуска контейнера нужно будет применить патч для lxc шаблона. Но во второй части, мы вручную создадим образ при помощи утилиты debootstrap, применим патч, после чего импортируем и запустим контейнер. А пока приступим к изучению кода.
Entry point
-----------
Главной точкой входа, является функция main в файле docker/docker.go:
```
func main() {
if docker.SelfPath() == "/sbin/init" {
// Running in init mode
docker.SysInit()
return
}
// FIXME: Switch d and D ? (to be more sshd like)
fl_daemon := flag.Bool("d", false, "Daemon mode")
fl_debug := flag.Bool("D", false, "Debug mode")
flag.Parse()
rcli.DEBUG_FLAG = *fl_debug
if *fl_daemon {
if flag.NArg() != 0 {
flag.Usage()
return
}
if err := daemon(); err != nil {
log.Fatal(err)
}
} else {
if err := runCommand(flag.Args()); err != nil {
log.Fatal(err)
}
}
}
```
В самом начале функции находится, как может показаться, довольно странная проверка. Запускаемый файл проверяется на соответствие с /sbin/init. В следующей части, когда мы перейдем к функции запуска контейнера, будет видно, что исполняемый файл docker, монтируется в точку /sbin/init, запускаемого lxc контейнера, а функция docker.SysInit() из файла sysinit.go производит настройку окружения и последующий запуск требуемого процесса в контейнере. На данном этапе мы пропустим эту часть.
```
// Sys Init code
// This code is run INSIDE the container and is responsible for setting
// up the environment before running the actual process
func SysInit() {
if len(os.Args) <= 1 {
fmt.Println("You should not invoke docker-init manually")
os.Exit(1)
}
var u = flag.String("u", "", "username or uid")
var gw = flag.String("g", "", "gateway address")
flag.Parse()
setupNetworking(*gw)
changeUser(*u)
executeProgram(flag.Arg(0), flag.Args())
}
```
Далее в зависимости от флага -d, докер может запускаться в режиме демона работая по сетевому сокету или выполнять команды локально.
```
func daemon() error {
service, err := docker.NewServer()
if err != nil {
return err
}
return rcli.ListenAndServe("tcp", "127.0.0.1:4242", service)
}
```
Функция daemon стартует простой tcp сервер на порту 4242, принимает соединения, читает и выполняет команды переданные в json формате. Его код можно найти в файле rcli/tcp.go:
```
// Listen on `addr`, using protocol `proto`, for incoming rcli calls,
// and pass them to `service`.
func ListenAndServe(proto, addr string, service Service) error {
listener, err := net.Listen(proto, addr)
if err != nil {
return err
}
log.Printf("Listening for RCLI/%s on %s\n", proto, addr)
defer listener.Close()
for {
if conn, err := listener.Accept(); err != nil {
return err
} else {
go func() {
if DEBUG_FLAG {
CLIENT_SOCKET = conn
}
if err := Serve(conn, service); err != nil {
log.Printf("Error: " + err.Error() + "\n")
fmt.Fprintf(conn, "Error: "+err.Error()+"\n")
}
conn.Close()
}()
}
}
return nil
}
// Parse an rcli call on a new connection, and pass it to `service` if it
// is valid.
func Serve(conn io.ReadWriter, service Service) error {
r := bufio.NewReader(conn)
var args []string
if line, err := r.ReadString('\n'); err != nil {
return err
} else if err := json.Unmarshal([]byte(line), &args); err != nil {
return err
} else {
return call(service, ioutil.NopCloser(r), conn, args...)
}
return nil
}
// FIXME: For reverse compatibility
func call(service Service, stdin io.ReadCloser, stdout io.Writer, args ...string) error {
return LocalCall(service, stdin, stdout, args...)
}
```
В случае же запуска докера без флага -d выполнение переходит к функции runCommand:
```
func runCommand(args []string) error {
var oldState *term.State
var err error
if term.IsTerminal(0) && os.Getenv("NORAW") == "" {
oldState, err = term.MakeRaw(0)
if err != nil {
return err
}
defer term.Restore(0, oldState)
}
// FIXME: we want to use unix sockets here, but net.UnixConn doesn't expose
// CloseWrite(), which we need to cleanly signal that stdin is closed without
// closing the connection.
// See http://code.google.com/p/go/issues/detail?id=3345
if conn, err := rcli.Call("tcp", "127.0.0.1:4242", args...); err == nil {
receive_stdout := docker.Go(func() error {
_, err := io.Copy(os.Stdout, conn)
return err
})
send_stdin := docker.Go(func() error {
_, err := io.Copy(conn, os.Stdin)
if err := conn.CloseWrite(); err != nil {
log.Printf("Couldn't send EOF: " + err.Error())
}
return err
})
if err := <-receive_stdout; err != nil {
return err
}
if !term.IsTerminal(0) {
if err := <-send_stdin; err != nil {
return err
}
}
} else {
service, err := docker.NewServer()
if err != nil {
return err
}
if err := rcli.LocalCall(service, os.Stdin, os.Stdout, args...); err != nil {
return err
}
}
if oldState != nil {
term.Restore(0, oldState)
}
return nil
}
```
В самом начале происходит перевод терминала в raw режим. Весь функционал, отвечающий за работу с терминалом, находится в папке term.
Далее идет попытка подключения и отправка команды демону функцией rcli.Call из файла rcli/tcp.go (демон должен быть запущен заранее с флагом -d):
```
// Connect to a remote endpoint using protocol `proto` and address `addr`,
// issue a single call, and return the result.
// `proto` may be "tcp", "unix", etc. See the `net` package for available protocols.
func Call(proto, addr string, args ...string) (*net.TCPConn, error) {
cmd, err := json.Marshal(args)
if err != nil {
return nil, err
}
conn, err := net.Dial(proto, addr)
if err != nil {
return nil, err
}
if _, err := fmt.Fprintln(conn, string(cmd)); err != nil {
return nil, err
}
return conn.(*net.TCPConn), nil
}
```
В случае, если попытка не удалась, команда выполняется локально при помощи вызова LocalCall и структуры возвращаемой функцией docker.NewServer, которая находится в файле commands.go:
```
func NewServer() (*Server, error) {
rand.Seed(time.Now().UTC().UnixNano())
if runtime.GOARCH != "amd64" {
log.Fatalf("The docker runtime currently only supports amd64 (not %s). This will change in the future. Aborting.", runtime.GOARCH)
}
runtime, err := NewRuntime()
if err != nil {
return nil, err
}
srv := &Server{
runtime: runtime,
}
return srv, nil
}
type Server struct {
runtime *Runtime
}
```
Мы вернемся к структуре Server и Runtime немного позже, а сперва посмотрим на функцию LocalCall из файла rcli/types.go:
```
func LocalCall(service Service, stdin io.ReadCloser, stdout io.Writer, args ...string) error {
if len(args) == 0 {
args = []string{"help"}
}
flags := flag.NewFlagSet("main", flag.ContinueOnError)
flags.SetOutput(stdout)
flags.Usage = func() { stdout.Write([]byte(service.Help())) }
if err := flags.Parse(args); err != nil {
return err
}
cmd := flags.Arg(0)
log.Printf("%s\n", strings.Join(append(append([]string{service.Name()}, cmd), flags.Args()[1:]...), " "))
if cmd == "" {
cmd = "help"
}
method := getMethod(service, cmd)
if method != nil {
return method(stdin, stdout, flags.Args()[1:]...)
}
return errors.New("No such command: " + cmd)
}
```
В ней происходит разбор аргументов и выполнение команды, полученной из getMethod, который использует рефлексию структуры Server для вычисления метода соответствующего переданной команде по шаблону "Cmd" + MethodName:
```
func getMethod(service Service, name string) Cmd {
if name == "help" {
return func(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
if len(args) == 0 {
stdout.Write([]byte(service.Help()))
} else {
if method := getMethod(service, args[0]); method == nil {
return errors.New("No such command: " + args[0])
} else {
method(stdin, stdout, "--help")
}
}
return nil
}
}
methodName := "Cmd" + strings.ToUpper(name[:1]) + strings.ToLower(name[1:])
method, exists := reflect.TypeOf(service).MethodByName(methodName)
if !exists {
return nil
}
return func(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
ret := method.Func.CallSlice([]reflect.Value{
reflect.ValueOf(service),
reflect.ValueOf(stdin),
reflect.ValueOf(stdout),
reflect.ValueOf(args),
})[0].Interface()
if ret == nil {
return nil
}
return ret.(error)
}
}
```
Все доступные методы лежат в файле commands.go, их разбором мы займемся во второй части, а пока вернемся к функции NewRuntime вызываемой в функции docker.NewServer. Она содержится в файле runtime.go и которая возвращает структуру Runtime сохраняемую в структуре Server:
```
func NewRuntime() (*Runtime, error) {
return NewRuntimeFromDirectory("/var/lib/docker")
}
func NewRuntimeFromDirectory(root string) (*Runtime, error) {
runtime_repo := path.Join(root, "containers")
if err := os.MkdirAll(runtime_repo, 0700); err != nil && !os.IsExist(err) {
return nil, err
}
g, err := NewGraph(path.Join(root, "graph"))
if err != nil {
return nil, err
}
repositories, err := NewTagStore(path.Join(root, "repositories"), g)
if err != nil {
return nil, fmt.Errorf("Couldn't create Tag store: %s", err)
}
netManager, err := newNetworkManager(networkBridgeIface)
if err != nil {
return nil, err
}
authConfig, err := auth.LoadConfig(root)
if err != nil && authConfig == nil {
// If the auth file does not exist, keep going
return nil, err
}
runtime := &Runtime{
root: root,
repository: runtime_repo,
containers: list.New(),
networkManager: netManager,
graph: g,
repositories: repositories,
authConfig: authConfig,
}
if err := runtime.restore(); err != nil {
return nil, err
}
return runtime, nil
}
```
Как можно заметить, часть этого функционала раньше находилась в файле docker.go, который мы разобрали в первой статье. Теперь же сюда добавлены и новые структуры:
* graph (NewGraph) - отвечает за работу со слоями и зависимостями образа. Файл graph.go
* networkManager (newNetworkManager) - отвечает за весь сетевой стек. Файл network.go
* repositories (NewTagStore) - отвечает за локальный репозиторий и работу с метками (tags) образов. Файл tags.go
* authConfig (auth.LoadConfig) - отвечает за хранение данных для авторизации на удаленном репозитории образов. Файл auth/auth.go
Работу метода restore мы также разбирали в первой части. Принцип остался прежним, изменения коснулись лишь процедуры инициализации существующих контейнеров:
```
func (runtime *Runtime) restore() error {
dir, err := ioutil.ReadDir(runtime.repository)
if err != nil {
return err
}
for _, v := range dir {
id := v.Name()
container, err := runtime.Load(id)
if err != nil {
Debugf("Failed to load container %v: %v", id, err)
continue
}
Debugf("Loaded container %v", container.Id)
}
return nil
}
func (runtime *Runtime) Load(id string) (*Container, error) {
container := &Container{root: runtime.containerRoot(id)}
if err := container.FromDisk(); err != nil {
return nil, err
}
if container.Id != id {
return container, fmt.Errorf("Container %s is stored at %s", container.Id, id)
}
if err := runtime.Register(container); err != nil {
return nil, err
}
return container, nil
}
func (container *Container) FromDisk() error {
data, err := ioutil.ReadFile(container.jsonPath())
if err != nil {
return err
}
// Load container settings
if err := json.Unmarshal(data, container); err != nil {
return err
}
return nil
}
```
В первой части мне пришлось делать небольшой патч, теперь же метод Register осуществляет полную инициализацию контейнера:
```
// Register makes a container object usable by the runtime as
func (runtime \*Runtime) Register(container \*Container) error {
if container.runtime != nil || runtime.Exists(container.Id) {
return fmt.Errorf("Container is already loaded")
}
if err := validateId(container.Id); err != nil {
return err
}
container.runtime = runtime
// Setup state lock (formerly in newState()
lock := new(sync.Mutex)
container.State.stateChangeLock = lock
container.State.stateChangeCond = sync.NewCond(lock)
// Attach to stdout and stderr
container.stderr = newWriteBroadcaster()
container.stdout = newWriteBroadcaster()
// Attach to stdin
if container.Config.OpenStdin {
container.stdin, container.stdinPipe = io.Pipe()
} else {
container.stdinPipe = NopWriteCloser(ioutil.Discard) // Silently drop stdin
}
// Setup logging of stdout and stderr to disk
if err := runtime.LogToDisk(container.stdout, container.logPath("stdout")); err != nil {
return err
}
if err := runtime.LogToDisk(container.stderr, container.logPath("stderr")); err != nil {
return err
}
// done
runtime.containers.PushBack(container)
return nil
}
```
Функционал writeBroadcaster, State знакомый нам из первой части, остался без изменения, добавилась лишь заглушка для stdin:
```
type nopWriteCloser struct {
io.Writer
}
func (w *nopWriteCloser) Close() error { return nil }
func NopWriteCloser(w io.Writer) io.WriteCloser {
return &nopWriteCloser{w}
}
```
и логирование потоков stdout stderr в файл на диск:
```
func (container *Container) logPath(name string) string {
return path.Join(container.root, fmt.Sprintf("%s-%s.log", container.Id, name))
}
func (runtime *Runtime) LogToDisk(src *writeBroadcaster, dst string) error {
log, err := os.OpenFile(dst, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0600)
if err != nil {
return err
}
src.AddWriter(NopWriteCloser(log))
return nil
}
```
На этом, думаю, можно завершить общую частью и перейти непосредственно к разбору кода команд.
Заключение
----------
В [следующей части](https://habr.com/ru/post/575256/) мы подробно рассмотрим код отвечающий за работу с контейнерами, образами, репозиторием, сетевым стеком, а также создадим образ вручную и запустим контейнер на его основе. | https://habr.com/ru/post/574750/ | null | ru | null |
# Тесты на знание Python, PHP, Golang и DevOps: разбор викторины AvitoQuiz на Highload
Конференция Highload++ 2017 отгремела, и это было круто — как всегда. Мы пересматриваем доклады, вовсю пользуемся опытом, которым с нами поделились коллеги, и с удовольствием вспоминаем разные активности, которые проводились вне зоны докладов.
На нашем стенде, например, можно было пройти тест на знание одного из языков программирования (Python, Go, PHP) или тест для DevOps и получить красочную тематическую футболку. Сегодня хотим предложить вам ещё раз окунуться в атмосферу конференции и разобрать ответы на самые Highload-задачи из нашего теста. А может, вы сможете решить их, не заглядывая под спойлер?
Enjoy!
Топ-3 вопросов по тематикам
===========================
### Python
**1. Как получить порядок базовых классов, в котором будет производиться поиск нужного метода во время исполнения программы?**
```
cls.get_bases()
```
```
cls.__mro__
```
```
cls.__bro__
```
```
Это невозможно
```
**Верный ответ**
>
> ```
> cls.__mro__
> ```
>
>
>
**2. Как импортировать объект obj из модуля my\_module, если он не указан в `my_module.__all__` последовательности?**
```
Это невозможно
```
```
from my_module import *
```
```
import my_module; obj = my_module.obj
```
```
from my_module import obj
```
**Верный ответ**
>
> ```
> from my_module import obj
> ```
>
>
>
**3. Python 2, что вернёт z[x == y]?**
```
x = x[0] = [0]
y = y[0] = [1]
z = {(2-1, ): 'equal', (1-1, ): 'not equal'}
```
```
equal
```
```
not equal
```
```
RuntimeError
```
```
KeyError
```
**Верный ответ**
>
> ```
> RuntimeError
> ```
>
>
>
### Golang
**1. Выберите верное утверждение для программы, запущенной с GOMAXPROCS=5:**
1. Программа не может создать более пяти потоков ОС.
2. Количество горутин на поток не может превышать пяти.
3. Программа не может одновременно выполняться более чем в пяти потоках ОС.
4. Программа резервирует пять потоков ОС для эксклюзивного выполнения.
**Верный ответ**
> Программа не может одновременно выполняться более чем в пяти потоках ОС.
**2. Как в Go получить прямой доступ к ячейке памяти?**
1. Указатели в Go всегда разыменовываются при использовании, прямой доступ к памяти невозможен.
2. Воспользоваться пакетом unsafe.
3. Использовать встроенную функцию readMemory().
4. Доступ возможен только в специальной системной горутине.
**Верный ответ**
> Воспользоваться пакетом unsafe.
**3. Какая команда пригодится для поиска узких мест в программе?**
```
go tool pprof
```
```
go vet
```
```
go tool objdump
```
```
go profile
```
**Верный ответ**
>
> ```
> go tool pprof
> ```
>
>
>
### PHP
**1. Какой алгоритм используется в PHP для сборки мусора?**
1. Алгоритм Бейкера.
2. Naive mark-and-sweep.
3. Balanced binary trees.
4. Reference counting, tri-color marking.
**Верный ответ**
> Reference counting, tri-color marking.
**2. Что исчезло из PHP в седьмой версии?**
1. Внутренние указатели массива.
2. Поддержка переменных в переменных внутри global.
3. Исключения класса ParseError.
4. Функция list().
**Верный ответ**
> Поддержка переменных в переменных внутри global.
**3. Кто спасёт, если нужно записать HTTP-заголовок после первого вызова echo в коде?**
1. Output Buffering.
2. ACL.
3. SPL.
4. Opcode Cache.
**Верный ответ**
> Output Buffering.
### DevOps
**1. У директории права доступа rwxrwS--t, владелец alice, группа users. ACL не используются. Выберите верное утверждение.**
1. Если пользователь root создаст в этой директории файл, то у этого файла владелец и группа будет root.
2. Пользователь bob, не входящий в группу users, не может просмотреть содержимое файлов в этой директории, но может просмотреть содержимое самой директории.
3. Пользователь alice может удалить из этой директории файл, принадлежащий пользователю root.
4. Пользователь charlie, входящий в группу users, может создать в этой директории новый файл, но не может удалить из неё файл, созданный пользователем alice.
**Верный вариант**
> Пользователь alice может удалить из этой директории файл, принадлежащий пользователю root.
**2. Для чего используются физические адреса в протоколе Ethernet?**
1. Для того, чтобы обмениваться данными с устройствами в других сетях.
2. Для того, чтобы различать кадры (2 сетевой уровень) и пакеты (3 сетевой уровень).
3. Для определения порядка передачи данных в домене коллизий.
4. Для того, чтобы устройства в одной сети могли обмениваться данными.
**Верный ответ**
> Для того, чтобы устройства в одной сети могли обмениваться данными.
**3. Что нужно сделать для того, чтобы nginx повторно резолвил имя backend-сервера в IP с помощью DNS?**
1. Указать DNS-сервера в директиве resolvers, вынести имя backend-сервера в переменную.
2. Указать DNS-сервера в директиве resolvers, вынести имя backend-сервера в upstream.
3. Вынести имя backend-сервера в upstream, добавить в upstream директиву resolve\_dynamic.
4. Указать DNS-сервера в директиве resolvers, после этого nginx автоматически будет повторно резолвить имена backend-серверов.
**Верный вариант**
> Указать DNS-сервера в директиве resolvers, вынести имя backend-сервера в переменную.
Топ участников
==============
Итоги были такие. Тест начали проходить 273 человека. Некоторые не закончили его (нельзя сказать, что им не дало закончить — интересный доклад, сомнение в своих силах или слабая связь). Максимальное количество баллов, которые можно было набрать по всем четырём направлениям — 60.
Ну а вот топ-5 реальных героев. Ребята, знайте — вы круче всех.
1. Святослав Думченко — 39 баллов
2. Вячеслав Злодеев — 37 баллов
3. Владимир Протасов — 24 балла
4. Светлана Шагалина — 24 балла
5. Илья Лебедев — 22 балла
Вот футболки, которые получили 50 лучших по каждому направлению:
А вам удалось решить задачи, не глядя под спойлер? Пишите в комментариях.
И, конечно, до следующих встреч! | https://habr.com/ru/post/346520/ | null | ru | null |
# Возврат значения из powershell invoke-command агенту SQL-Server
При создании собственной методики управления резервными копиями на множестве серверов MS-SQL я потратил кучу времени на изучение механизма передачи значений в powershell при удаленных вызовах, поэтому пишу самому себе памятку, а вдруг кому-то еще пригодится.
Итак, возьмем для начала простейший скрипт и запустим его локально:
```
$exitcode = $args[0]
Write-Host 'Out to host.'
Write-Output 'Out to output.'
Write-Host ('ExitCode: ' + $exitcode)
Write-Output $exitcode
$host.SetShouldExit($exitcode)
```
Для запуска скриптов я буду пользоваться следующим CMD-файлом, каждый раз его приводить не стану:
```
@Echo OFF
PowerShell .\TestOutput1.ps1 1
ECHO ERRORLEVEL=%ERRORLEVEL%
```
На экране мы увидим следующее:
```
Out to host.
Out to output.
ExitCode: 1
1
ERRORLEVEL=1
```
Теперь запустим этот же скрипт через WSMAN (удаленно):
```
Invoke-Command -ComputerName . -ScriptBlock { &'D:\sqlagent\TestOutput1.ps1' $args[0] } -ArgumentList $args[0]
```
И вот вам результат:
```
Out to host.
Out to output.
ExitCode: 2
2
ERRORLEVEL=0
```
Чудесно, Errorlevel куда-то пропал, но нам ведь нужно получить значение из скрипта! Пробуем следующую конструкцию:
```
$res=Invoke-Command -ComputerName . -ScriptBlock { &'D:\sqlagent\TestOutput1.ps1' $args[0] } -ArgumentList $args[0]
```
Тут еще интереснее. Весть вывод в Output куда-то исчез:
```
Out to host.
ExitCode: 2
ERRORLEVEL=0
```
Теперь в качестве лирического отступления отмечу, что если внутри функции Powershell Вы напишете Write-Output или просто выражение без присваивания его какой-либо переменной (а это неявно подразумевает вывод в канал Output), то даже при локальном запуске на экран ничего не будет выведено! Это следствие конвейерной архитектуры powershell — каждая функция имеет собственный конвейер Output, для него создается массив, и все, что в него попадает, считается результатом выполнения функции, оператор Return добавляет возвращаемое значение в этот же конвейер последним элементом и передает управление в вызвавшую функцию. Для иллюстрации выполним локально следующий скрипт:
```
Function Write-Log {
Param( [Parameter(Mandatory=$false, ValueFromPipeline=$true)] [String[]] $OutString = "`r`n" )
Write-Output ("Function: "+$OutString)
Return "ReturnValue"
}
Write-Output ("Main: "+"ParameterValue")
$res = Write-Log "ParameterValue"
$res.GetType()
$res.Length
$res | Foreach-Object { Write-Host ("Main: "+$_) }
```
И вот его результат:
```
Main: ParameterValue
IsPublic IsSerial Name BaseType
-------- -------- ---- --------
True True Object[] System.Array
2
Main: Function: ParameterValue
Main: ReturnValue
```
Главная функция (тело скрипта) также имеет свой конвейер Output, и если мы запустим первый скрипт из CMD, перенаправив вывод в файл,
```
PowerShell .\TestOutput1.ps1 1 > TestOutput1.txt
```
то на экране мы увидим
```
ERRORLEVEL=1
```
а в файле
```
Out to host.
Out to output.
ExitCode: 1
1
```
если же сделаем аналогичный вызов из powershell
```
PS D:\sqlagent> .\TestOutput1.ps1 1 > TestOutput1.txt
```
то на экране будет
```
Out to host.
ExitCode: 1
```
а в файле
```
Out to output.
1
```
Это происходит потому, что CMD запускает powershell, который при отсутствии других указаний смешивает два потока (Host и Output) и отдает их CMD, который отправляет в файл все, что получил, а в случае запуска из powershell эти два потока существуют отдельно, и символ перенаправления влияет только на Output.
Возвращаясь к основной теме, вспомним, что объектная модель .NET внутри powershell полноценно существует в рамках одного компьютера (одной ОС), при удаленном запуске кода через WSMAN передача объектов происходит через XML-сериализацию, что вносит много дополнительного интереса в наши исследования. Продолжим эксперименты запуском следующего кода:
```
$res=Invoke-Command -ComputerName . -ScriptBlock { &'D:\sqlagent\TestOutput1.ps1' $args[0] } -ArgumentList $args[0]
$res.GetType()
$host.SetShouldExit($res)
```
И вот что у нас на экране:
```
Out to host.
ExitCode: 3
IsPublic IsSerial Name BaseType
-------- -------- ---- --------
True True Object[] System.Array
Не удается преобразовать аргумент "exitCode", со значением: "System.Object[]", для "SetShouldExit" в тип "System.Int32": "Не удается преобразовать значение "System.Object[]" типа "System.Object[]" в тип "System
.Int32"."
D:\sqlagent\TestOutput3.ps1:3 знак:1
+ $host.SetShouldExit($res)
+ ~~~~~~~~~~~~~~~~~~~~~~~~~
+ CategoryInfo : NotSpecified: (:) [], MethodException
+ FullyQualifiedErrorId : MethodArgumentConversionInvalidCastArgument
ERRORLEVEL=0
```
Прекрасный результат! Он означает, что при вызове Invoke-Command сохраняется деление конвейеров на два потока (Host и Output), что дает нам надежду на успех. Попробуем оставить в потоке Output только одно значение, для чего изменим самый первый скрипт, который мы запускаем удаленно:
```
$exitcode = $args[0]
Write-Host 'Out to host.'
#Write-Output 'Out to output.'
Write-Host ('ExitCode: ' + $exitcode)
Write-Output $exitcode
$host.SetShouldExit($exitcode)
```
Запустим его так:
```
$res=Invoke-Command -ComputerName . -ScriptBlock { &'D:\sqlagent\TestOutput1.ps1' $args[0] } -ArgumentList $args[0]
$host.SetShouldExit($res)
```
и… ДА, похоже, это победа!
```
Out to host.
ExitCode: 4
IsPublic IsSerial Name BaseType
-------- -------- ---- --------
True True Int32 System.ValueType
ERRORLEVEL=4
```
Попытаемся разобраться, что у нас произошло. Мы вызвали локально powershell, который, в свою очередь, вызвал powershell на удаленном компьютере и выполнил там наш скрипт. Два потока (Host и Output) с удаленной машины были сериализованы и переданы обратно, при этом поток Output при наличии в нем одного цифрового значения был преобразован к типу Int32 и в таком виде передан принимающей стороне, а принимающая сторона использовала его в качестве кода завершения вызывающего powershell-а.
И в качестве последней проверки создадим на сервере SQL задание из одного шага с типом «Операционная система (cmdexec)» с таким текстом:
```
PowerShell -NonInteractive -NoProfile "$res=Invoke-Command -ComputerName BACKUPSERVER -ConfigurationName SQLAgent -ScriptBlock {&'D:\sqlagent\TestOutput1.ps1' 6}; $host.SetShouldExit($res)"
```
УРА! Задание завершилось с ошибкой, текст в журнале:
```
Выполняется от имени пользователя: DOMAIN\agentuser. Out to host. ExitCode: 6. Код завершения процесса 6. Шаг завершился с ошибкой.
```
**Выводы:**
* Избегайте использования Write-Output и указания выражений без присваивания. Помните, что перенос этого кода в другое место скрипта может привести к неожиданным результатам.
* В скриптах, предназначенных не для ручного запуска, а для использования в Ваших механизмах автоматизации, особенно для удаленных вызовов через WINRM, делайте ручную обработку ошибок через Try/Catch, и добивайтесь того, чтобы при любом развитии событий этот скрипт отправил в поток Output ровно одно значение примитивного типа. Если хотите получить классический Errorlevel — это значение должно быть числовым. | https://habr.com/ru/post/504890/ | null | ru | null |
# Google выпустила парсер HTML5 на чистом Си
Удачная возможность для веб-разработчиков выучить язык программирования Си — HTML5-парсер [Gumbo](https://github.com/google/gumbo-parser#gumbo---a-pure-c-html5-parser), реализованный в виде небольшой библиотеки C99 без внешних зависимостей. Парсер создан как строительный блок для создания других инструментов и библиотек, таких как валидаторы, языки шаблонов, инструменты рефакторинга и анализа кода.
Особенности:
* Полная совместимость со [спецификациями HTML5](http://www.whatwg.org/specs/web-apps/current-work/multipage/).
* Устойчивость к некачественным входным данным.
* Простые API, которые могут быть легко обработаны программами на других ЯП.
* Поддержка исходных позиций и указателей в оригинальном коде, при навигации по дереву зависимостей.
* Проходит все тесты [html5lib-0.95](https://github.com/html5lib/html5lib-tests).
* Проверен на более чем 2,5 млрд страниц в индексе Google.
Разработчики не ставят перед собой цели оптимизации парсера для производительности, его писали на Си не для того, чтобы повысить скорость исполнения кода в десятки раз.
В будущем планируется добавить поддержку самых свежих функций HTML5, поддержку парсинга фрагментов кода, полноценные отчёты об ошибках и проч.
Для использования синтаксического анализатора Gumbo, нужно включить файл `gumbo.h`, а затем вызвать `gumbo_parse`.
```
#include "gumbo.h"
int main(int argc, char** argv) {
GumboOutput* output = gumbo_parse(argv[1]);
// Do stuff with output->root
gumbo_destroy_output(&kGumboDefaultOptions, output);
}
```
Примеры полезного использования см. [здесь](https://github.com/google/gumbo-parser/tree/master/examples).
Программа опубликована под лицензией Apache 2. | https://habr.com/ru/post/190044/ | null | ru | null |
# Установка NativeScript на Mac OS
Здравствуйте, уважаемые Хабравчане. Спешу поделиться с Вами своим небольшим опытом в казалось бы простом деле — установить NativeScript на Mac OS.
Недавно нам поступила заявка на изучение NativeScript с целью выявить положительные и отрицательные стороны данной технологии.
Скажу честно, в процессе установки NativeScript на свой Mac я столкнулся с рядом неприятностей. К сожалению, официальный материал на мой любительский взгляд, не содержит полноценного руководства установки, а сторонние ресурсы и без того сбивают с толку, предлагая то один, то другой способы, опять-таки умалчивая о подводных камнях, что приводит в дальнейшем к путанице в зависимостях, повторной переустановке различных пакетов и т.п.
В данной статье я не буду рассказывать о плюсах и минусах, а поговорим мы о банальной установке. Чтобы не мучиться больше никому.
Статья является точной последовательностью действий, актуальной на данный момент (24.04.17)
Предполагаю, что Xcode у вас уже стоит. Если нет, заходим на сайт Apple или устанавливаем из магазина. Итак, приступим…
1. Откройте терминал
2. Введите команду, указанную ниже, для установки пакетного менеджера Brew:
```
/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
```
После установки можно проверить версию пакета, введя команду:
```
brew -v
```
3. Введите команду установики NodeJS (без указания sudo):
```
brew install node
```
Проверить версию NodeJs и NPM можно командами:
```
node -v
```
и
```
npm -v
```
Небольшая ремарка: не ставьте, пожалуйста, NodeJS из пакета с официального сайта! В рамках данной статьи используется Brew. В противном случае Вы рискуете запутаться в зависимостях и что-то не будет «заводиться».
4. Установим Command Line Tools для Xcode, [ссылка](https://developer.apple.com/download/more/).
5. Устанавливаем xcodeproj:
```
sudo gem install xcodeproj
```
6. Устанавливаем CocoaPods
```
sudo gem install cocoapods
```
7. Устанавливаем JDK — [скачиваем](http://www.oracle.com/technetwork/java/javase/downloads/) \*.dmg пакет с сайта Oracle. И устанавливаем.
8. Установим Android, [скачав](https://developer.android.com/studio/index.html) с сайта Android.
9. После установки Android Studio, зайдем в настройки оболочки AndroidStudio и установим дополнительно Android версий 22, 23, 24 и 25 из раздела:
> Appearence & Behavior / System Settings / Android SDK
как показано на рисунке ниже.
10. Затем вводим:
```
echo "export JAVA_HOME=$(/usr/libexec/java_home)" >> ~/.profile
```
и
```
echo "export ANDROID_HOME=$HOME/Library/Android/sdk" >> ~/.profile
```
Таким образом файл `.profile` будет создан или дополнен, если он уже существует.
11. Еще раз введем в консоль:
```
export JAVA_HOME=$(/usr/libexec/java_home)
```
и
```
export ANDROID_HOME=$HOME/Library/Android/sdk
```
Это применит переменные окружения без перезагрузки `bash`.
12. Проверьте переменные:
```
echo $ANDROID_HOME
```
```
echo $JAVA_HOME
```
13. Обязательно выполним команду:
```
sudo xcode-select -r
```
14. Мы подошли к кульминации, а именно к установке самого NativeScript. Вводим команду (без указания sudo):
```
npm install nativescript -g
```
На этом все! Глядя на данный, казалось бы абсолютно ненужный материал, хочется сказать, что именно отсутствие такого материала, заставило меня потратить немало времени и нервов.
Желаю приятного кодинга и успехов в данном направлении.
Дополнительный материал:
1. [Setup your Mac to develop NativeScript Apps](https://hdorgeval.gitbooks.io/setup-your-mac-to-develop-nativescript-apps/content/)
2. [Quick Setup](http://docs.nativescript.org/start/quick-setup)
3. [NativeScript Advanced Setup: macOS](http://docs.nativescript.org/start/ns-setup-os-x) | https://habr.com/ru/post/327508/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.