text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Автоматизация однотипных операций при настройке коммутаторов через telnet без программирования
#### Вступление
Добрый день уважаемые хабражители!
Описанные ниже способ поможет сократить количество рутинной работы при настройке коммутаторов (например Planet, D-Link и др.) в случаях, когда необходимо выполнить несколько десятков — сотен однотипных операций вроде объявления виланов, добавления их на интерфейсы, экспорта конфигурационных файлов на tftp сервер. Безусловно решение далеко не оптимальное и рациональное, но, надеюсь, имеет право на жизнь.
Настройка производится через подключение по протоколу telnet. Увы, не смотря на то что современные свитчи поддерживают ssh и snmp, многие старые железки разумеют только telnet. Способ подойдет для среднего пользователя Windows, не программиста, т.к. используется всего лишь блокнот и пакетные bat файлы (просьба неровнодышащим к параолимпийским играм программистов дальше не читать).
Основной проблемой было найти программу, которая бы позволяла подключаясь к коммутатору по telnet автоматически проходить авторизацию, после чего передавать необходимые команды. Продолжительный поиск по проблеме давал результаты двух типов: код на делфи 15-летней давности и предложения осилить telnet клиент на питоне, что, каюсь, не входило в мои планы.
Чуть позже была найдена небезызвестная [Kitty](http://habrahabr.ru/post/76098/). Документации по программе что кот наплакал и основная часть находится на [сайте](http://www.9bis.net/kitty/?page=Welcome&zone=ru) и [форуме](http://www.9bis.net/kitty/?action=forum&id=0079&zone=ru) без поиска. Подкупило наличие следующих функций: Kitty умеет запускать сохраненные сессии, где можно прописать логин и пароль для авторизации, строку с командами для авто выполнения, а так же путь к файлу со скриптом. Скрипт выполнятся после авторизации, его размер должен быть меньше 4096 байт или около 100 не длинных строк.
#### Подготовка
По умолчанию настройки Kitty хранятся в реестре, что не очень удобно. Создаем **kitty.ini** со следующим содержимым:
```
[KiTTY]
savemode=dir
initdelay=1.0
commanddelay=1.0
bcdelay=5
KittyPath=C:\Windows\System32\putty.exe
```
Где savemode=dir заставляет Kitty хранить сессии в папке Sessions. Задержки в моем случае почти не отличаются от стандартных, их можно и подкрутить, главное, чтобы команды успевали отправляться и отрабатывать.
Копируем **putty.exe**, **kitty.exe** и **kitty.ini** в System32 и выполняем:
```
kitty.exe -convert-dir
```
После этого настройки начинают подтягиваться из kitty.ini, а сессии сохраняются в C:\Windows\System32\Sessions.
Запускаем **kitty.exe** или **kitty.exe -launcher**
#### Создаем сессию
Перед созданием сессии рекомендую сохранить в сессии **Default Settings** оптимальные для себя настройки, в особенности выбрать кодировку **UTF-8** в разделе **Window — Translation**.
Собственно сессия создается и сохраняется как обычно в Putty, только с большим количеством опций. В разделе **Session** выбираем telnet, прописываем host или ip адрес. В разделе **Connection — Data** прописываем логин и пароль для авторизации. Сделать это можно как в специальных полях, так и в строке Command или непосредственно в файле скрипта. Кому как нравится, я перепробовал все варианты. В данном примере опишу случай авторизации через строку Command. Синтаксис:
```
\n отправка символов
\p задержка на одну секунду, можно повторять нужное количество раз
\s05 пауза в секундах, если меньше 10, то пишется с нулем
```
Все зависит от модели коммутатора и указанных в kitty.ini задержек, подбиралось опытным путем:
```
\s05LOGIN\n\pPASSWORD\n\p
```
В строке Login script file указываем путь к файлу скрипта, например **C:\scripts\script.txt**
Возвращаемся в раздел Session, прописываем имя сессии, например **testsession** и сохраняем.
#### Пишем скрипт
В папке с файлом скрипта создаем обычный текстовый документ и сохраняем, например, как **script.bat**. Открываем его в любимом текстовом редакторе и пишем (и не забываем комментировать):
```
@echo off
setlocal enableextensions enabledelayedexpansion
chcp 1251
echo.
echo Пример простого скрипта для добавления виланов на коммутаторе D-Link
::---------------------------------------------------
::Генерирование скрипта на лету
@echo null>>script.txt
DEL script.txt
::---------------------------------------------------
FOR /L %%i IN (100,1,105) DO (
@echo #
@echo create vlan %%i tag %%i
)>>script.txt
@echo #>>script.txt
@echo logout>>script.txt
::---------------------------------------------------
::Запуск скрипта
start /wait kitty.exe -load "testsession"
pause
```
Первая часть скрипта позволяет выводить комментарии на русском языке. Правда для начала в свойствах командной строки нужно выставить шрифт **Lucida Console**. **echo** выводит комментарии при выполнении пакетного файла, **::** двойное двоеточие — комментарии в коде (не употребляйте их в циклах).
Во второй части чистим существующий или не существующий файл, затем записываем в него скрипт. Все что угодно душе и поставленной задаче.
В третьей части запускаем Kitty с параметром **-load «имя\_сессии»**, где **/wait** определяет, что командный файл будет ждать пока завершится выполнение Kitty, а **pause** позволяет увидеть закончилось выполнение c ошибкой или всё в порядке.
Содержимое получившегося текстового файла:
```
#
create vlan 100 tag 100
#
create vlan 101 tag 101
#
create vlan 102 tag 102
#
create vlan 103 tag 103
#
create vlan 104 tag 104
#
create vlan 105 tag 105
#
logout
```
Как можно догадаться при выполнения скрипта Kitty [ожидает строку](http://www.9bis.net/kitty/?page=Logon%20script&zone=ru) оканчивающуюся на # (или любое другое окончание, пример ниже) и отправляет в ответ следующую строку и т.д.
```
::Сохранение конфигурации на коммутаторе Planet
@echo #>>testscript2.txt
@echo copy running-config startup-config>>testscript2.txt
@echo :>>testscript2.txt
@echo Y>>testscript2.txt
@echo #>>testscript2.txt
@echo exit>>testscript2.txt
```
В скрипт можно перенести этап авторизации, а перед логаутом, например, добавить сохранение и экспорт конфигурационного файла.
#### Заключение
Таким образом можно формировать достаточно объемные скрипты и сравнительно быстро их выполнять. Недостатком, конечно же является то, что выполнять их придется частями, но таково ограничение Kitty. Наверняка есть множество других способов решения подобных задач — от загрузки готового конфига на коммутатор, до использования специализированного софта. Спасибо за внимание.
#### P.S.
Так же удобно выполнять команды следующего рода (благо их можно быстренько штамповать как скриптом, так и банально в Excel):
```
start kitty -telnet LOGIN@192.168.0.100 -pass PASSWORD -cmd "<Например какие-нибудь команды>\n\psave\n\plogout"
start kitty -ssh root@192.168.0.1 -pass PASSWORD -cmd "reboot"
```
#### P.P.S.
Пример скрипта с expect:
```
#!/usr/bin/expect -f
set timeout -1
spawn ssh -o PubkeyAuthentication=no LOGIN@IPADDRESS
expect -exact "password: "
sleep 1
send -- "PASSWORD\r"
expect -exact "admin#"
sleep 1
send -- "COMMAND\r"
expect -exact "admin#"
sleep 1
send -- "logout\r"
expect {\$\s*} { interact }
``` | https://habr.com/ru/post/180281/ | null | ru | null |
# Овладение Coordinator Layout
На презентации [Google I/O 15](https://www.youtube.com/watch?v=7V-fIGMDsmE), компания Google представила [новую версию библиотеки поддержки](http://android-developers.blogspot.com.es/2015/05/android-design-support-library.html) которая реализует несколько компонентов, сильно связанных со [спецификациями Material Design](https://www.google.com/design/spec/material-design/introduction.html), среди этих компонентов вы можете найти новые типы ViewGroup такие как `AppbarLayout`, `CollapsingToolbarLayout` и `CoordinatorLayout`.
При правильном комбинировании и настройке данные Viewgroup могут быть очень мощным инструментом, по этому я решил написать статью с некоторыми настройками и советами.
CoordinatorLayout
=================
Как и предполагает его название, цель и философия этой `ViewGroup` является **координация** view элементов, которые находятся внутри него.
Рассмотрим следующую картинку:
В этом примере можем видеть как view элементы размещены друг относительно друга, не прибегая к детальному просмотру, мы видим как одни `View` **зависят** от других. (мы поговорим об этом позже).
Это будет простейшая структура использования `CoordinatorLayout`:
**Посмотреть код**
```
xml version="1.0" encoding="utf-8"?
```
Рассмотрим скелет данного layout. У этого `CoordinatorLayout` имеется только три дочерних элемента: `AppbarLayout`, прокручиваемый `view` и закрепленный `FloatingActionBar`.
**Посмотреть код**
```
```
AppBarLayout
============
Проще говоря, `AppBarLayout` это `LinearLayout` на стероидах, их элементы размещены вертикально, с определенными параметрами элементы могут управлять их поведением, когда содержимое прокручивается.
Это может прозвучать запутано сначала, но как, — «Лучше один раз увидеть, чем сто раз услышать», к вашему вниманию .gif-пример:
В данном случае `AppBarLayout` это синяя view, размещенная под исчезающим изображением, она содержит `Toolbar`, `LinearLayout` с заголовком и подзаголовком и `TabLayout` с несколькими вкладками.
Мы можем управлять поведением элементов `AppbarLayout` с помощью параметров: `layout_scrollFlags`. Значение: `scroll` в данном случае присутствует почти во всех элементах view, если бы этот параметр не был указан ни в одном из элементов *AppbarLayout*, он остался бы неизменным, позволяя *прокручиваемому* контенту проходить позади него.
Со значением: `snap`, мы избегаем попадания в *полу-анимационного-состояния*, это значит, что анимация всегда скрывает или отображает полный размер view.
`LinearLayout` который содержит заголовок и подзаголовок будет всегда отображен при прокручивании вверх, (`enterAlways` значение), и `TabLayout` будет видим всегда так как на него не установлен ни один флаг.
Как видите настоящая мощь `AppbarLayout` определяется должным управлением его флагами прокрутки в определенных view.
**Посмотреть код**
```
```
Все эти параметры доступны в [документации Google Developers](https://developer.android.com/intl/es/reference/android/support/design/widget/AppBarLayout.LayoutParams.html#CONSTANTS). В любом случае, я рекомендую поиграть с примерами. В конце статьи размещены ссылки на репозитории Github с реализацией примеров.
Флаги AppbarLayout
==================
`SCROLL_FLAG_ENTER_ALWAYS`: При использовании флага, view будет прокручиваться вниз не зависимо от других прокручиваемых view.
`SCROLL_FLAG_ENTER_ALWAYS_COLLAPSED`: Дополнительный флаг для 'enterAlways', который изменяет возвращаемый view к изначально прокручиваемому, при исчезновении высоты.
`SCROLL_FLAG_EXIT_UNTIL_COLLAPSED`: При выходе, view будет прокручен до тех пор пока не исчезнет.
`SCROLL_FLAG_SCROLL`: Элемент view будет прокручиваться в направлении события прокрутки.
`SCROLL_FLAG_SNAP`: В конце прокрутки, если view видим только частично, он будет докручен до его ближайшего края.
CoordinatorLayout Behaviors
===========================
Проведем не большой эксперимент, запустим Android Studio (>= 1.4) и создадим проект из шаблона: *Scrolling Activity*, ничего не изменяя, компилирием и вот что мы видим:
При рассмотрении сгенерированного кода, ни макеты layout ни java классы не имеют ничего относящегося к *маштабированию* анимации плавающей кнопки при прокрутке. Почему?
Ответ находится в исходном коде `FloatingActionButton`, с тех пор как Android Studio v1.2 включает java декомпилятор, с помощью `ctrl/cmd + click` мы можем проверить исходный код и посмотреть что происходит:
**Посмотреть код**
```
/*
* Copyright (C) 2015 The Android Open Source Project
*
* Floating action buttons are used for a
* special type of promoted action.
* They are distinguished by a circled icon
* floating above the UI and have special motion behaviors
* related to morphing, launching, and the transferring anchor point.
*
* blah.. blah..
*/
@CoordinatorLayout.DefaultBehavior(
FloatingActionButton.Behavior.class)
public class FloatingActionButton extends ImageButton {
...
public static class Behavior
extends CoordinatorLayout.Behavior {
private boolean updateFabVisibility(
CoordinatorLayout parent, AppBarLayout appBarLayout,
FloatingActionButton child {
if (a long condition) {
// If the anchor's bottom is below the seam,
// we'll animate our FAB out
child.hide();
} else {
// Else, we'll animate our FAB back in
child.show();
}
}
}
...
}
```
За маштабирование анимации отвечает новый элемент, представленый вместе с design library, под названием `Behavior`. В данном случае
```
CoordinatorLayout.Behavior
```
, который зависит от некоторых факторов включая прокрутку, показывать FAB или нет, интересно, не правда ли?
SwipeDismissBehavior
====================
Продолжим углубление в код, если вы посмотрите внутрь пакета виджетов **design support library**, то сможете найти открытй клас под названием: `SwipeDismissBehavior`. С этим новым `Behavior` мы можем очень легко реализовать функцию *свайп для отмены* в наших шаблонах с `CoordinatorLayout`:
**Посмотреть код**
```
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_swipe_behavior);
mCardView = (CardView) findViewById(R.id.swype_card);
final SwipeDismissBehavior swipe
= new SwipeDismissBehavior();
swipe.setSwipeDirection(
SwipeDismissBehavior.SWIPE\_DIRECTION\_ANY);
swipe.setListener(
new SwipeDismissBehavior.OnDismissListener() {
@Override public void onDismiss(View view) {
Toast.makeText(SwipeBehaviorExampleActivity.this,
"Card swiped !!", Toast.LENGTH\_SHORT).show();
}
@Override
public void onDragStateChanged(int state) {}
});
LayoutParams coordinatorParams =
(LayoutParams) mCardView.getLayoutParams();
coordinatorParams.setBehavior(swipe);
}
```
Custom Behaviors
================
Создать свой шаблон поведения (*Behavior*) не так и сложно как может показаться, для начала мы должны принять во внимание несколько основных элементов: **child** и **dependency**.
Child и dependency
==================
**child** это элемент который усиливает поведение, **dependency** — тот кто будет обслуживать его как тригер для взаимодействия с **child** элементом. Посмотрим на пример, **child** — элемент *ImageView*, а *dependency* это *Toolbar*, таким образом, если *Toolbar* движется, *ImageView* тоже движется.
Теперь, когда мы определили концепт, можем поговорить о реализации, первым шагом будет наследование от:
```
CoordinatorLayout.Behavior
```
, значение `T` будет класс который принадлежит view, что необходим нам для координации, в данном случае *ImageView*, после чего мы должны переопределить следующие методы:
* layoutDependsOn
* onDependentViewChanged
Метод: `layoutDependsOn` будет вызван каждый раз когда что-то случится в layout, чтобы вернуть `true`, как только мы определили dependency, в примере, этот метод срабатывает автоматически при прокручивании (т.к. `Toolbar` будет двигаться), таким образом, мы можем подать знак нашему child отреагировать соответствующим образом.
**Посмотреть код**
```
@Override
public boolean layoutDependsOn(
CoordinatorLayout parent,
CircleImageView, child,
View dependency) {
return dependency instanceof Toolbar;
}
```
Всякий раз когда `layoutDependsOn` возвращает `true` будет вызван второй `onDependentViewChanged`. Вот тут-то мы и должны реализовать нашу анимацию, перевод или движения всегда зависят от предоставленной зависимости.
**Посмотреть код**
```
public boolean onDependentViewChanged(
CoordinatorLayout parent,
CircleImageView avatar,
View dependency) {
modifyAvatarDependingDependencyState(avatar, dependency);
}
private void modifyAvatarDependingDependencyState(
CircleImageView avatar, View dependency) {
// avatar.setY(dependency.getY());
// avatar.setBlahBlat(dependency.blah / blah);
}
```
А теперь все вместе:
**Посмотреть код**
```
public static class AvatarImageBehavior
extends
CoordinatorLayout.Behavior {
@Override
public boolean layoutDependsOn(
CoordinatorLayout parent,
CircleImageView, child,
View dependency) {
return dependency instanceof Toolbar;
}
public boolean onDependentViewChanged(
CoordinatorLayout parent,
CircleImageView avatar,
View dependency) {
modifyAvatarDependingDependencyState(avatar, dependency);
}
private void modifyAvatarDependingDependencyState(
CircleImageView avatar, View dependency) {
// avatar.setY(dependency.getY());
// avatar.setBlahBlah(dependency.blah / blah);
}
}
```
**Дополнительные материалы**
[Пример Coordinator Behavior](https://github.com/saulmm/CoordinatorBehaviorExample) — Github
[Примеры Coordinator](https://github.com/saulmm/CoordinatorExamples) — Github
[Введение в coordinator layout на Android](https://lab.getbase.com/introduction-to-coordinator-layout-on-android/) — Grzesiek Gajewski | https://habr.com/ru/post/270121/ | null | ru | null |
# Оптимизация работы с PostgreSQL в Go: от 50 до 5000 RPS
Привет, меня зовут Иван, и я делаю Авито Доставку. Когда пользователь покупает товар с доставкой, мы показываем ему список отделений служб доставки с ценами. Цена доставки может меняться от отделения к отделению. Мы смотрим на область карты, где покупатель ищет товар и информацию по объявлению, например, координаты продавца, вес и размеры товара. И на выходе показываем человеку список отделений с адресами и ценой доставки в каждое из них.
В ходе разработки калькулятора цены доставки возникла такая задача: есть структура базы данных PostgreSQL и запрос к ней от сервиса на Go. Нужно заставить всё это работать достаточно быстро. В итоге нам удалось поднять пропускную способность сервиса с 50 до 5000 RPS и выявить пару нюансов при общении сервиса с базой. Об этом и пойдёт рассказ.
В статье мы не будем разбирать нефункциональные требования к сервису, построение структуры базы или оптимизацию SQL-запроса. Будем считать, что база и запрос свалились на нас в виде входных данных, а требования выставлять не станем — вместо этого будем мониторить пропускную способность и время отклика сервиса.
Структура базы данных
---------------------
[](https://dbdocs.io/iosadchiy/Terminator-for-habr?schema=public&view=relationships&table=receive)
Не нужно искать физический смысл в этих отношениях — это просто две денормализованные сущности, которые нужны для поиска. Строятся они на основе обычной БД в третьей нормальной форме.
Объём данных такой:
* send: ~400 тысяч записей;
* receive: ~160 миллионов записей.
SQL-запрос
----------
```
SELECT r.terminal_id,
r.lat, r.lon,
r.tariff_zone_id,
r.min_term, r.max_term
FROM receive r
INNER JOIN (
SELECT DISTINCT ON (s.provider) provider, tariff_id, s.tag_from_id, Point(s.lat, s.lon) <-> Point (:seller_lat, :seller_lon) AS dist
FROM send s
WHERE
s.lat BETWEEN :seller_leftbot_lat AND :seller_righttop_lat
AND s.lon BETWEEN :seller_leftbot_lon AND :seller_righttop_lon
AND :now BETWEEN s.active_from AND s.active_until
AND s.max_weight > :weight AND s.max_height > :height AND s.max_length > :length AND s.max_width > :width AND s.max_declared_cost > :declared_cost
ORDER BY provider, dist
) AS s USING (tag_from_id)
WHERE
r.lat BETWEEN :buyer_leftbot_lat AND :buyer_righttop_lat
AND r.lon BETWEEN :buyer_leftbot_lon AND :buyer_righttop_lon
AND r.max_weight > :weight AND r.max_height > :height AND r.max_length > :length AND r.max_width > :width AND r.max_declared_cost > :declared_cost
LIMIT :limit;
```
Чтобы запрос работал быстро, нужно создать пару индексов:
```
CREATE INDEX send_idx
ON send(lon, lat, active_from, active_until);
CREATE INDEX receive_idx
ON receive(tag_from_id, lon, lat);
```
Можно спорить, какие поля нужно включать в индексы, а какие — нет. Эту комбинацию мы подобрали через нагрузочные тесты: это некий sweet spot, когда индекс получается относительно лёгким и одновременно даёт нужную производительность.
Порядок полей в индексах тоже важен. Например, долготу (lon) есть смысл ставить в индексе впереди широты (lat): Россия вытянута в широтном направлении, и долгота оказывается более селективна.
[Структура БД и SQL запрос.](https://gist.github.com/iosadchiy/e77e4ae79829bdb2328f1f4b15b06378)
Сервис на Go
------------
В интересах статьи сервис будет максимально упрощён. Он всего лишь:
* разбирает входные данные;
* формирует запрос и шлёт его в БД;
* сериализует ответ базы в JSON и отдаёт его.
В реальности он ещё считает цену на основе tariff\_zone\_id, но суть та же: основная нагрузка ложится на базу данных, в Go происходит минимум действий. Построен сервис на обычном Server из net/http и использует одну горутину на запрос.
Архитектура решения
-------------------
Искать подходящие отделения и считать цены доставки будем на бэкенде. Для повышения надёжности и по юридическим причинам тарифы и методику расчёта цены доставки мы хотим хранить у себя, а не ходить за ценой к подрядчикам. Тарифы будем хранить в унифицированном виде для всех служб доставки.
Для расчёта цены используем отдельный микросервис со своим хранилищем.
В качестве хранилища мы рассматривали Elasticsearch, MongoDB, Sphinx и PostgreSQL. По результатам исследования выбрали PostgreSQL: он закрывает наши потребности и при этом существенно проще в поддержке для нашей компании, your mileage may vary.
Налоги и комиссии в статье рассматривать не будем. Нас интересует только базовая цена доставки от подрядчика.
Тестовый стенд
--------------
Сервис развёрнут в Kubernetes на трёх подах по 500 Мб. База развёрнута в LXC-контейнере с 4 ядрами и 16 Гб памяти. В качестве connection pooler используется pgbouncer, развёрнутый в контейнере с базой.
Это достаточно стандартный для Авито сетап. В реальном сервисе был бы ещё один pgbouncer, развёрнутый внутри каждого пода с сервисом.
План запроса
------------
Посмотрим, как исполняется запрос к базе данных:
В запросе осталась сортировка — оптимизировать её в поиск минимума Постгрес не стал. Это не очень хорошо, но на наших данных максимум может сортироваться около ста записей, обычно — от 20 до 50. Кажется, с этим можно жить.
Основные же затраты идут на поиск по btree-индексу по большой таблице.
Результаты «в лоб»
------------------
Пора уже запустить тест.
*50 RPS / 314 мс для 99-го перцентиля*
Уже на низких RPS появляются подозрительные пики в графике времени отклика. Это видно на среднем графике, по вертикальной шкале время в миллисекундах. 70 RPS сервис не держит совсем. Надо это оптимизировать.
Подход к оптимизации
--------------------
Оптимизация — это цикл из нескольких шагов:
1. Определить цели и индикаторы. Чего хотим и как будем измерять успех.
2. Создать тестовые данные. В нашем случае — заполнить базу и сгенерировать ленту запросов к сервису.
3. Добиться полной нагрузки одного из ресурсов, увидеть узкое место.
4. Расширить узкое место.
5. Повторять до достижения целей.
Наши цели — 200 RPS минимум, лучше 500 RPS. Индикаторы — пропускная способность сервиса и время отклика.
Тестовые данные — это важно
---------------------------
Мы старались по максимуму использовать реальные данные. Использовали их, где получалось, для наполнения базы, добавив шум. Для создания ленты запросов собрали реальные запросы с прода. Где это было невозможно, использовали генератор. Было ясно, что любые предположения, не основанные на реальных данных, будут снижать надёжность результатов тестов.
Изначально мы использовали ленту в 20 тысяч запросов. И довольно быстро удалось добиться такого результата:
Тут сервис держит 1000 RPS при 52.5 мс. Всё красиво, кроме скачков времени отклика, но давайте попробуем потестировать ту же конфигурацию на ленте в 150 тысяч запросов:
Уже на 200 RPS сервис заваливается. Запросы отваливаются по таймауту, появляются 500-ки. Оказывается, предыдущий тест врёт примерно в 10 раз по пропускной способности.
Похоже, для ленты в 20 тысяч запросов использовалась лишь часть данных в таблицах. PostgreSQL смог всё закэшировать и работал быстро. Для ленты в 150 тысяч требовалось больше данных из таблиц, в кэш они не поместились, и быстродействие упало.
Получается, не уделив достаточно внимания входным данным, легко испортить всё нагрузочное тестирование.
Переезд на pgx/v4
-----------------
Скачки времени отклика на графиках выше намекают на наличие проблем в подключении сервиса к базе.
До сих пор мы использовали библиотеку pgx третьей версии и не ограничивали размер пула соединений. Если уж оптимизировать эту часть, то давайте переедем на четвёртую версию и уже на ней будем всё настраивать. Тем более, про неё есть много хороших отзывов.
Переехали, ограничили пул до 10 соединений. Пробуем:
Стало лучше, но принципиально ничего не изменилось. В чём дело? Смотрим метрики pgbouncer’а:
Синий — число активных клиентских соединений (cl\_active), красные точки — число клиентских соединений, которым не досталось серверного соединения (cl\_waiting, правая шкала, снимается раз в 30 секунд).
Видно, что число активных соединений под нагрузкой катастрофически падает. Как выяснилось, так проявлялся один из багов в pgx/v4. Как мы искали для него решение, я уже рассказывал [в статье про починку pgx.](https://habr.com/ru/company/avito/blog/519610/)
Откат на pgx/v3
---------------
На тот момент баг в pgx/v4 еще не был исправлен, и мы воспользовались воркэраундом: откатились на третью версию и отключили отмены запросов.
Сильно лучше не стало, но самые хорошие новости ждали нас в метриках pgbouncer:
Число активных соединений растёт до максимума под нагрузкой — здесь пул ограничен до 12 — и не падает до конца теста.
С этого момента мы стали собирать ещё и результаты закрытых тестов. Закрытый тест — это когда задаётся не скорость подачи запросов, а общее число запросов в системе. Это более щадящий режим, но он удобнее для отладки производительности, т.к. даёт меньше шума.
*130 RPS при 20 параллельных запросах*
В метриках контейнера с базой мы увидели полку в операциях ввода-вывода:
Жёлтое — это число операций чтения (растёт вниз). Мы выбрали всю квоту контейнера на операции чтения, то есть нам удалось, наконец-то нормально нагрузить базу.
Масштабируем базу по диску
--------------------------
Проверим, является ли узким местом диск. Увеличиваем квоту контейнера в 8 раз, смотрим:
*Открытый тест: 500 RPS / 109 мс*
*Закрытый тест: 745 RPS*
В закрытом тесте пропускная способность выросла со 130 RPS до 745 — почти линейный рост. Значит, мы действительно упираемся в диск.
Оценим предел вертикального масштабирования. Снимаем с контейнера ограничение на операции ввода-вывода вообще:
*Открытый тест: 3000 RPS / 602 мс*
*Закрытый тест (20 инстансов): 2980 RPS / 62 мс*
Заметим, что закрытому тесту явно не хватает 20 параллельных запросов, чтобы нагрузить сервис. Мы съели вообще весь диск на всём сервере с базой:
*Зелёное — число операций чтения (растёт вниз)*
Конечно, в продакшене так себя вести нельзя: придут злые девопсы и будут нас ругать. Вообще, упираться в диск очень не хочется: его сложно масштабировать, мы будем мешать соседям по серверу, а они будут мешать нам.
Попытаемся уместить данные в память, чтобы диск перестал быть узким местом.
Масштабируем базу по памяти
---------------------------
Смотрим размеры наших таблиц и индексов:
```
SELECT
pg_size_pretty( pg_total_relation_size('send')) send,
pg_size_pretty(pg_indexes_size('send')) send_indexes,
pg_size_pretty( pg_total_relation_size('receive')) receive,
pg_size_pretty(pg_indexes_size('receive')) receive_indexes;
```
Видим 21 Гб данных и 6 Гб индексов. Это существенно больше полезного объёма данных, но тут Постгресу виднее.
Нужно подобрать конфигурацию базы, которая могла бы вместить 27 Гб в памяти. В Авито используются несколько типовых конфигураций PostgreSQL: они хорошо изучены, а параметры в них согласуются друг с другом. Никто не запрещает кастомизировать конфигурацию под потребности конкретного сервиса, но начинать лучше с одной из готовых конфигураций.
Смотрим список конфигураций и находим вот такую:
*8 ядер, 64 Гб памяти, effective\_cache\_size 48 Гб*
effective\_cache\_size — это не настоящий размер кэша, это просто параметр планировщика, чтобы тот представлял, на сколько памяти ему рассчитывать. Можно здесь хоть петабайт поставить — размер кэша не увеличится. Просто планировщик будет предпочитать алгоритмы, которые хорошо работают с данными в памяти. Но всё же этот параметр в типовой конфигурации наши DBA выбрали не случайно: он учитывает разные кэши, доступные базе, в том числе кэш операционной системы. В общем, надо пробовать:
*Открытый тест: 4000 RPS / 165 мс*
*Закрытый тест (100 инстансов): 5440 RPS / 106 мс*
*Операции чтения (зелёное) — на нуле, операции записи (жёлтое) — в незначительных количествах*
Диск больше не является узким местом и, прямо скажем, бездельничает.
*Утилизация CPU — полностью загружены все 8 ядер*
Теперь мы упираемся в процессор. Это хорошо: масштабировать его относительно просто, а мешать мы никому не будем.
Единственное, что смущает, — большая разница в результатах открытого и закрытого тестов. Это может свидетельствовать о проблемах с соединениями. Смотрим метрики pgbouncer, и точно:
Опять cl\_waiting подскочил. В этот раз, правда, cl\_acitve (жёлтое) не падает, а cl\_waiting (красные точки, правая шкала) не поднимается выше 12.
Ну, это просто ошибка в конфигурации базы. Размер пула должен быть 24, именно такой пул выставлен в сервисе. А на стороне базы он остался равным 12. Исправляем, смотрим:
*Открытый тест: 5000 RPS / 140 мс
Закрытый тест (100 инстансов): 5440 RPS / 94 мс*
Вот теперь хорошо. В закрытом тесте результаты те же, а вот в открытом пропускная способность выросла с 4000 до 5000 RPS. Стоит отметить, что нет никакого смысла использовать больше соединений, чем размер пула БД: это лишь портит производительность. Впрочем, это наблюдение заслуживает более пристального изучения.
Куда делась 1000 RPS
--------------------
Итак, превышение размера пула сервиса над размером пула БД в два раза ведёт к потере 20% пропускной способности (с 5000 RPS до 4000 RPS). Почему? И почему в закрытом тесте разница не видна?
Давайте разберём, что вообще происходит, когда сервис выполняет запрос через pgx. Вот мы посылаем некий запрос:
```
rows, err := h.db.QueryContext(ctx, `SELECT 1`)
```
h.db — это пул соединений. Внутри QueryContext происходит Pool.Acquire(), который захватывает конкретное соединение для выполнения нашего запроса. Соединений на всех не хватает, требуется синхронизация, для чего [используется sync.Cond](https://github.com/jackc/puddle/blob/master/pool.go#L258):
```
func (p *Pool) Acquire(ctx context.Context) (*Resource, error) {
//...
p.cond.Wait()
//...
```
sync.Cond внутри — это пара атомиков, мьютекс и очередь на связном списке (см. [notifyList](https://golang.org/src/runtime/sema.go), который [используется под капотом](https://golang.org/src/sync/cond.go) у sync.Cond), то есть издержки на синхронизацию здесь минимальны. Горутина просто записывает себя в конец очереди и паркуется, ожидая, пока рантайм её разбудит. К тому же всё это происходит на стороне сервиса, который не является узким местом в нашем случае.
```
type notifyList struct {
wait uint32
notify uint32
lock mutex
head *sudog
tail *sudog
}
```
```
type Cond struct {
//...
notify notifyList
//...
}
```
*sync.Cond внутри сделан как очередь*
Теперь представим, что пул сервиса больше, чем пул базы данных. У pgbouncer’а появляются 24 клиентских соединения, но только 12 серверных. Он вынужден жонглировать клиентскими соединениями, подключая их к серверным поочередно. Это [дорогая операция](https://github.com/pgbouncer/pgbouncer/blob/3646fc0c637aafca2003e255f796222a7c7cdd3c/src/objects.c#L624), т.к. нужно менять состояние серверного соединения. В частности, [установить новые переменные](https://github.com/pgbouncer/pgbouncer/blob/044082be9d6bc6577fe5700db917b3f48d20b87a/src/varcache.c#L117), что требует общения с базой через сокет по протоколу. И всё это происходит, в нашем случае, в контейнере с базой, то есть мультиплексирование отъедает ресурсы у базы, которая и так является узким местом.
```
/* link if found, otherwise put into wait queue */
bool find_server(PgSocket *client)
{
//...
/* send var changes */
if (server) {
res = varcache_apply(server, client, &varchange);
//...
}
//...
if (server) {
if (varchange) {
server->setting_vars = 1;
server->ready = 0;
res = false; /* don't process client data yet */
if (!sbuf_pause(&client->sbuf))
disconnect_client(client, true, "pause failed");
//...
```
*Переключение соединений может потребовать общения с сервером по сети*
Видимо, в этом и кроется причина потери производительности: мультиплексирование соединений на pgbouncer’е под нагрузкой — зло.
Разница результатов открытого и закрытого тестов
------------------------------------------------
Почему разница не заметна в закрытом тесте, у меня точного ответа нет, но есть рабочая гипотеза.
Судя по коду [find\_server()](https://github.com/pgbouncer/pgbouncer/blob/3646fc0c637aafca2003e255f796222a7c7cdd3c/src/objects.c#L624), pgbouncer не стремится любой ценой подключить соединение к серверному. Нашлось свободное серверное соединение — хорошо, подключим. Нет — придётся подождать. Этакая кооперативная многозадачность, в которой соединения не очень хотят кооперироваться.
Получается, активное клиентское соединение, в котором без остановки выполняются запросы, может довольно долго не освобождать серверное соединение. А запрос, попавший на неактивное соединение, будет долго ждать своей очереди.
Пока запросов в системе мало, как в закрытом тесте, это роли не играет: запросам хватает таймаута, чтобы дождаться своей очереди. В открытом тесте запросов в системе в разы больше, они выстраиваются в очередь на захват соединения в pgx и тратят там большую часть таймаута. На захват серверного соединения в pgbouncer времени не остается. Происходит таймаут и 500-я ошибка.
Но это лишь правдоподобные рассуждения, хорошо бы их проверить. Когда-нибудь потом.
Запуск на холодную
------------------
Мы добились хорошей производительности в стационарном режиме за счёт размещения данных в памяти. Но как поведёт себя сервис в ситуации, когда данных в памяти нет, например, после аварии?
Перезагружаем сервис и сервер с базой, смотрим:
Разогнались до 5000 RPS за 10 секунд, примерно за минуту — до максимума. Значит, никакие механизмы прогрева кэша нам не нужны, можно сразу подавать боевой трафик.
Переезд pgx/v4, попытка номер два
---------------------------------
Раз уж появился фикс для четвёртой версии, надо его попробовать в деле. Обновляем библиотеку:
*Открытый тест: 5000 RPS / 217 мс, 5300 RPS / 645 мс
Закрытый тест: 5370 RPS / 43 мс*
По производительности примерно то же самое, что и в третьей версии. Разница в том, как сервис деградирует при заведомо запредельной нагрузке. С четвёртой версией это происходит медленнее.
Подбор размера пула в сервисе
-----------------------------
Как мы увидели, ограничение размера пула сервиса оказывает весьма существенное влияние на производительность. К сожалению, часто пул не ограничивают вообще. Из-за этого сервис держит меньшую нагрузку, чем мог бы, возникают мистические таймауты под штатной нагрузкой, а в некоторых случаях может серьёзно деградировать производительность базы данных.
Общее число соединений есть смысл выбирать в интервале от числа ядер, доступных базе, до ограничения на число серверных соединений у pgbouncer (каким его выбрать — вопрос для DBA).
При числе соединений меньше числа ядер база остаётся незагруженной, т.к. в Постгресе каждое соединение обслуживается отдельным процессом, который максимум может нагрузить одно ядро. Если соединений больше, чем максимальное число серверных соединений, начнётся мультиплексирование.
Конечно, эти соображения пригодны, когда нет долгих транзакций и медленных выборок из базы, которые надолго занимают соединение. Если они у вас есть, стоит подумать, как от них избавиться. Кроме того, опасно именно переключение соединений под нагрузкой. Задачи, работающие в разное время, например, сервис с пиковым трафиком днем и ночной крон, могут использовать полный пул каждая: мультиплексирования будет немного.
Не забываем
-----------
### Закрывать результат
Это обсуждали множество раз, но тем не менее. Даже если в документации к библиотеке написано, что [закрывать Rows необязательно](https://pkg.go.dev/github.com/jackc/pgx?tab=doc#hdr-Query_Interface), лучше всё же закрыть самому через defer.
```
rows, err := conn.Query(...)
if err != nil {
return err
}
defer rows.Close() // лучше закрыть принудительно
for rows.Next() {
// ...
}
if rows.Err() != nil {
return err
}
```
Как только внутри цикла по rows.Next() случится паника или мы сами добавим туда выход из цикла — rows останется незакрытым. Незакрытый результат — это соединение, которое не может быть использовано другими запросами, но занимает место в пуле. Его придется убивать по таймауту и заменять на новое, а это долго.
### Быстрые транзакции
Применительно к pgbouncer: медленные транзакции забивают серверный пул.
Долгая транзакция вызывает те же проблемы, что и незакрытый результат: соединение невозможно использовать ни для чего другого.
Особенно опасны незакрытые транзакции, а это ошибка, которую в Go сделать довольно легко. Если pool\_mode установлен в transaction, как это сделано у нас, то незакрытая транзакция надолго занимает собой соединение, в нашем случае на два часа.
Медленные же транзакции часто можно без больших затрат разделить на несколько быстрых. Если же это невозможно, то стоит подумать об отдельной реплике базы для них.
### Keepalive
Keepalive — это фича, которую не стоит включать бездумно. Она полезна, когда входящих соединений мало, например, если к вам ходят другие ваши сервисы и вы можете контролировать, сколько соединений они создают. При бесконтрольном создании соединений под высокой нагрузкой у сервиса окажется множество незакрытых соединений. Каждое из них отъест свои 2-4 Кб, и будет плохо.
### Проверять гипотезы практикой
В вопросах производительности запросто можно получить противоположный ожидаемому результат. Слишком много факторов вмешиваются в процесс. Любое своё предположение желательно проверять на железе и с цифрами.
TL;DR, или выводы
-----------------
1. Прокачали сервис от 50 до 5000 RPS, не применяя никакой особой магии.
2. Мультиплексирование соединений в pgbouncer’е под нагрузкой — зло.
3. Использовать в сервисе пул большего размера, чем в базе данных — вредно.
4. Выработать привычку делать транзакции быстрыми и закрывать результаты БД.
Благодарности
-------------
Кроме меня над задачей работали коллеги из Доставки: Кирилл Любаев, Александр Кузнецов, Алексей Власов.
И огромное спасибо всем, кто помогал:
* Андрею Аксёнову — за идеи, что гео-индексы здесь не нужны, что инты рулят и вообще, проще — лучше.
* Павлу Андрееву, нашему DBA-инженеру, — за терпение и оптимизацию на стороне PostgreSQL. | https://habr.com/ru/post/525294/ | null | ru | null |
# Опыт применения технологии Рутокен для регистрации и авторизации пользователей в системе (часть 4)
Добрый день!
Итак, мы разобрались, каким образом будет происходить аутентификация пользователей в системе, а так же создали свой локальный удостоверяющий центр с корневым приватным ключом и корневым сертификатом. Теперь пора перейти к работе непосредственно с Рутокеном. Напомню, что работать мы будем с Рутокеном из клиентской части приложения через Рутокен плагин.
Надеюсь, что драйвера для Рутокена и Рутокен плагин уже установлены на вашем компьютере. Если нет, то предлагаю еще раз ознакомиться с [первой частью статьи](https://habr.com/ru/post/506450/).
Общая документация, как работать с Рутокен плагин находится по ссылкам:
[Встраивание Рутокен ЭЦП 2.0 через Рутокен Плагин](https://dev.rutoken.ru/pages/viewpage.action?pageId=15269905)
[Руководство Разработчика Версия 4.4.1](https://dev.rutoken.ru/pages/viewpage.action?pageId=57147607)
Если вы начнете читать документацию, то у вас может возникнуть вопрос (по крайней мере так было у меня). Что за объект такой plugin? Где его взять, чтобы потом применять к нему всякого рода функции из документации. Разбираясь с данной проблемой, я совершенно случайно [попал на эту страницу](https://dev.rutoken.ru/pages/viewpage.action?pageId=30113795)
Там есть пример кода, как раз из которого у меня и удалось получить этот самый объект.
Тут приведу код, который тупо надо скопировать к себе, после чего вы сможете работать с документацией:
**Открыть код**
```
let rutoken = (function (my) {
let loadCallbacks = [];
let pluginMimeType = "application/x-rutoken-pki";
let extension = window["C3B7563B-BF85-45B7-88FC-7CFF1BD3C2DB"];
function isFunction(obj) {
return !!(obj && obj.call && obj.apply);
}
function proxyMember(target, member) {
if (isFunction(target[member])) {
return function () {
return target[member].apply(target, arguments);
};
} else {
return target[member];
}
}
function returnPromise(promise) {
return function () {
return promise;
};
}
function initialize() {
my.ready = Promise.resolve(true);
my.isExtensionInstalled = returnPromise(Promise.resolve(false));
my.isPluginInstalled = returnPromise(Promise.resolve(true));
my.loadPlugin = loadPlugin;
window.rutokenLoaded = onPluginLoaded;
}
function initializeExtension() {
let readyPromise = extension.initialize().then(function () {
return extension.isPluginInstalled();
}).then(function (result) {
my.isExtensionInstalled = returnPromise(Promise.resolve(true));
my.isPluginInstalled = proxyMember(extension, "isPluginInstalled");
if (result) {
pluginMimeType = "application/x-rutoken-plugin";
my.loadPlugin = loadChromePlugin;
}
return true;
});
my.ready = readyPromise;
}
function initializeWithoutPlugin() {
my.ready = Promise.resolve(true);
my.isExtensionInstalled = returnPromise(Promise.resolve(false));
my.isPluginInstalled = returnPromise(Promise.resolve(false));
}
function loadPlugin() {
let obj = document.createElement("object");
obj.style.setProperty("visibility", "hidden", "important");
obj.style.setProperty("width", "0px", "important");
obj.style.setProperty("height", "0px", "important");
obj.style.setProperty("margin", "0px", "important");
obj.style.setProperty("padding", "0px", "important");
obj.style.setProperty("border-style", "none", "important");
obj.style.setProperty("border-width", "0px", "important");
obj.style.setProperty("max-width", "0px", "important");
obj.style.setProperty("max-height", "0px", "important");
// onload callback must be set before type attribute in IE earlier than 11.
obj.innerHTML = "";
// Just after setting type attribute before function returns promise
// FireBreath uses onload callback to execute it with a small delay.
// So it must be valid, but it will be called a little bit later.
// In other browsers plugin will be initialized only after appending
// an element to the document.
obj.setAttribute("type", pluginMimeType);
document.body.appendChild(obj);
let promise = new Promise(function (resolve, reject) {
loadCallbacks.push(resolve);
});
return promise;
}
function loadChromePlugin() {
return extension.loadPlugin().then(function (plugin) {
return resolveObject(plugin);
}).then(function (resolvedPlugin) {
resolvedPlugin.wrapWithOldInterface = wrapNewPluginWithOldInterface;
return resolvedPlugin;
});
}
function onPluginLoaded(plugin, error) {
wrapOldPluginWithNewInterface(plugin).then(function (wrappedPlugin) {
if (loadCallbacks.length == 0) {
throw "Internal error";
}
let callback = loadCallbacks.shift();
callback(wrappedPlugin);
});
}
function resolveObject(obj) {
let resolvedObject = {};
let promises = [];
for (var m in obj) {
(function (m) {
if (isFunction(obj[m].then)) {
promises.push(obj[m].then(function (result) {
return resolveObject(result).then(function (resolvedProperty) {
if (isFunction(resolvedProperty)) {
resolvedObject[m] = proxyMember(obj, m);
} else {
resolvedObject[m] = resolvedProperty;
}
});
}));
} else {
resolvedObject[m] = obj[m];
}
})(m);
}
if (promises.length == 0) {
return new Promise(function (resolve) {
resolve(obj);
});
} else {
return Promise.all(promises).then(function () {
return resolvedObject;
});
}
}
function wrapNewPluginWithOldInterface() {
let wrappedPlugin = {};
for (var m in this) {
if (isFunction(this[m])) {
wrappedPlugin[m] = (function (plugin, member) {
return function () {
var successCallback = arguments[arguments.length - 2];
var errorCallback = arguments[arguments.length - 1];
var args = Array.prototype.slice.call(arguments, 0, -2);
return member.apply(plugin, args).then(function (result) {
successCallback(result);
}, function (error) {
errorCallback(error.message);
});
};
})(this, this[m]);
} else {
wrappedPlugin[m] = this[m];
}
}
return new Promise(function (resolve) {
resolve(wrappedPlugin);
});
}
function wrapOldPluginWithOldInterface() {
let unwrappedPlugin = {originalObject: this.originalObject};
for (let m in this.originalObject) {
unwrappedPlugin[m] = proxyMember(this.originalObject, m);
}
return new Promise(function (resolve) {
resolve(unwrappedPlugin);
});
}
function wrapOldPluginWithNewInterface(plugin) {
let wrappedPlugin = {
originalObject: plugin,
wrapWithOldInterface: wrapOldPluginWithOldInterface
};
for (let m in plugin) {
if (isFunction(plugin[m])) {
wrappedPlugin[m] = (function (plugin, member) {
return function () {
let args = Array.prototype.slice.call(arguments);
return new Promise(function (resolve, reject) {
args.push(resolve, reject);
member.apply(plugin, args);
});
};
})(plugin, plugin[m]);
} else {
wrappedPlugin[m] = plugin[m];
}
}
return new Promise(function (resolve) {
resolve(wrappedPlugin);
});
}
if (extension) {
initializeExtension();
} else if (navigator.mimeTypes && navigator.mimeTypes[pluginMimeType]) {
initialize();
} else {
try {
let plugin = new ActiveXObject("Aktiv.CryptoPlugin");
initialize();
} catch (e) {
initializeWithoutPlugin();
}
}
return my;
}({}));
rutoken.ready
// Проверка установки расширение 'Адаптера Рутокен Плагина' в Google Chrome
.then(function () {
if (window.chrome || typeof InstallTrigger !== 'undefined') {
return rutoken.isExtensionInstalled();
} else {
console.log("расширение 'Адаптер Рутокен Плагина' не найдено. Установите адаптер рутокена в браузер");
return Promise.resolve(true);
}
})
// Проверка установки Рутокен Плагина
.then(function (result) {
if (result) {
console.log("расширение 'Адаптер Рутокен Плагина' найдено");
return rutoken.isPluginInstalled();
} else {
return Promise.reject("Не удаётся найти расширение 'Адаптер Рутокен Плагина'");
}
})
// Загрузка плагина
.then(function (result) {
if (result) {
console.log("Рутокен плагин найден");
return rutoken.loadPlugin();
} else {
return Promise.reject("Не удаётся найти Плагин");
}
})
//Можно начинать работать с плагином
.then(function (plugin_) {
plugin = plugin_;
if (!plugin) {
console.log("Не удаётся загрузить Рутокен Плагин");
return Promise.reject("Не удаётся загрузить Плагин");
} else {
console.log("Рутокен плагин загружен успешно");
return plugin.enumerateDevices()
}
})
```
Чтобы успешно использовать Рутокен плагин и вообще понимать, как работает этот код, нужно разобраться, что такое Promise. Есть [отличная статья](https://learn.javascript.ru/promise) на эту тему, в которой имеется все что нужно для понимания Promise.
Напомню, что для нашей задачи необходимо сначала создать ключевую пару на Рутокене, а затем сформировать запрос на сертификат, который после этого будет отправлен на сервер для получения сертификата.
Для написания своих клиентский приложения я использую фреймворк Ext Js, но это абсолютно не важно. Уверен, что понять весь этот код можно и без знания Ext Js.
Перейдем к реализации. Для начала нужно получить соединение с Рутокеном. Для этого был создан класс, который будет за это отвечать:
**Открыть реализацию Rutoken.rutoken.ConnectToDevice**
```
Ext.define('Rutoken.rutoken.ConnectToDevice', {
connectToDevice: function (rutoken) {
rutoken = rutoken.getRutoken();
return rutoken.ready
// Проверка установки расширение 'Адаптера Рутокен Плагина' в Google Chrome
.then(function () {
if (window.chrome || typeof InstallTrigger !== 'undefined') {
return rutoken.isExtensionInstalled();
} else {
console.log("расширение 'Адаптер Рутокен Плагина' не найдено. Установите адаптер рутокена в браузер");
return Promise.resolve(true);
}
})
// Проверка установки Рутокен Плагина
.then(function (result) {
if (result) {
console.log("расширение 'Адаптер Рутокен Плагина' найдено");
return rutoken.isPluginInstalled();
} else {
return Promise.reject("Не удаётся найти расширение 'Адаптер Рутокен Плагина'");
}
})
// Загрузка плагина
.then(function (result) {
if (result) {
console.log("Рутокен плагин найден");
return rutoken.loadPlugin();
} else {
return Promise.reject("Не удаётся найти Плагин");
}
})
//Можно начинать работать с плагином
.then(function (plugin_) {
plugin = plugin_;
if (!plugin) {
console.log("Не удаётся загрузить Рутокен Плагин");
return Promise.reject("Не удаётся загрузить Плагин");
} else {
console.log("Рутокен плагин загружен успешно");
return plugin.enumerateDevices()
}
})
//Попытка обнаружить рутокен в компьютере
.then(function (devices) {
if (devices.length > 0) {
console.log("Рутокен обнаружен");
return Promise.resolve(devices[0]);
} else {
console.log("Рутокен НЕ обнаружен");
return Promise.reject("Рутокен не обнаружен");
}
})
//Получение информации об рутокене, который подключен к компьютеру
.then(function (device_) {
device = device_;
return plugin.getDeviceInfo(device, plugin.TOKEN_INFO_IS_LOGGED_IN);
})
// Логин на первый токен в списке устройств PIN-кодом по умолчанию
.then(function (isLoggedIn) {
if (isLoggedIn) {
return Promise.resolve();
} else {
return plugin.login(device, "12345678");
}
})
//Вернуть список, состоящий из плагина и номера первого рутокена,
//который подключен к компьютеру
.then(function () {
return [plugin, device];
})
}
});
```
Для работы с этим классом просто нужно создать его объект, а потом вызвать функцию connectToDevice. В результате эта функция возвращает список, состоящий из плагина и номера первого Рутокена. Функция connectToDevice принимает параметр rutoken. Этот объект получается копированием части содержимого кода, приведенного в начале статьи:
**Открыть реализацию Rutoken.rutoken.RutokenInit**
```
Ext.define("Rutoken.rutoken.RutokenInit", {
config: {
rutoken: undefined,
},
constructor: function(){
let rutoken = (function (my) {
let loadCallbacks = [];
let pluginMimeType = "application/x-rutoken-pki";
let extension = window["C3B7563B-BF85-45B7-88FC-7CFF1BD3C2DB"];
function isFunction(obj) {
return !!(obj && obj.call && obj.apply);
}
function proxyMember(target, member) {
if (isFunction(target[member])) {
return function () {
return target[member].apply(target, arguments);
};
} else {
return target[member];
}
}
function returnPromise(promise) {
return function () {
return promise;
};
}
function initialize() {
my.ready = Promise.resolve(true);
my.isExtensionInstalled = returnPromise(Promise.resolve(false));
my.isPluginInstalled = returnPromise(Promise.resolve(true));
my.loadPlugin = loadPlugin;
window.rutokenLoaded = onPluginLoaded;
}
function initializeExtension() {
let readyPromise = extension.initialize().then(function () {
return extension.isPluginInstalled();
}).then(function (result) {
my.isExtensionInstalled = returnPromise(Promise.resolve(true));
my.isPluginInstalled = proxyMember(extension, "isPluginInstalled");
if (result) {
pluginMimeType = "application/x-rutoken-plugin";
my.loadPlugin = loadChromePlugin;
}
return true;
});
my.ready = readyPromise;
}
function initializeWithoutPlugin() {
my.ready = Promise.resolve(true);
my.isExtensionInstalled = returnPromise(Promise.resolve(false));
my.isPluginInstalled = returnPromise(Promise.resolve(false));
}
function loadPlugin() {
let obj = document.createElement("object");
obj.style.setProperty("visibility", "hidden", "important");
obj.style.setProperty("width", "0px", "important");
obj.style.setProperty("height", "0px", "important");
obj.style.setProperty("margin", "0px", "important");
obj.style.setProperty("padding", "0px", "important");
obj.style.setProperty("border-style", "none", "important");
obj.style.setProperty("border-width", "0px", "important");
obj.style.setProperty("max-width", "0px", "important");
obj.style.setProperty("max-height", "0px", "important");
// onload callback must be set before type attribute in IE earlier than 11.
obj.innerHTML = "";
// Just after setting type attribute before function returns promise
// FireBreath uses onload callback to execute it with a small delay.
// So it must be valid, but it will be called a little bit later.
// In other browsers plugin will be initialized only after appending
// an element to the document.
obj.setAttribute("type", pluginMimeType);
document.body.appendChild(obj);
let promise = new Promise(function (resolve, reject) {
loadCallbacks.push(resolve);
});
return promise;
}
function loadChromePlugin() {
return extension.loadPlugin().then(function (plugin) {
return resolveObject(plugin);
}).then(function (resolvedPlugin) {
resolvedPlugin.wrapWithOldInterface = wrapNewPluginWithOldInterface;
return resolvedPlugin;
});
}
function onPluginLoaded(plugin, error) {
wrapOldPluginWithNewInterface(plugin).then(function (wrappedPlugin) {
if (loadCallbacks.length == 0) {
throw "Internal error";
}
let callback = loadCallbacks.shift();
callback(wrappedPlugin);
});
}
function resolveObject(obj) {
let resolvedObject = {};
let promises = [];
for (var m in obj) {
(function (m) {
if (isFunction(obj[m].then)) {
promises.push(obj[m].then(function (result) {
return resolveObject(result).then(function (resolvedProperty) {
if (isFunction(resolvedProperty)) {
resolvedObject[m] = proxyMember(obj, m);
} else {
resolvedObject[m] = resolvedProperty;
}
});
}));
} else {
resolvedObject[m] = obj[m];
}
})(m);
}
if (promises.length == 0) {
return new Promise(function (resolve) {
resolve(obj);
});
} else {
return Promise.all(promises).then(function () {
return resolvedObject;
});
}
}
function wrapNewPluginWithOldInterface() {
let wrappedPlugin = {};
for (var m in this) {
if (isFunction(this[m])) {
wrappedPlugin[m] = (function (plugin, member) {
return function () {
var successCallback = arguments[arguments.length - 2];
var errorCallback = arguments[arguments.length - 1];
var args = Array.prototype.slice.call(arguments, 0, -2);
return member.apply(plugin, args).then(function (result) {
successCallback(result);
}, function (error) {
errorCallback(error.message);
});
};
})(this, this[m]);
} else {
wrappedPlugin[m] = this[m];
}
}
return new Promise(function (resolve) {
resolve(wrappedPlugin);
});
}
function wrapOldPluginWithOldInterface() {
let unwrappedPlugin = {originalObject: this.originalObject};
for (let m in this.originalObject) {
unwrappedPlugin[m] = proxyMember(this.originalObject, m);
}
return new Promise(function (resolve) {
resolve(unwrappedPlugin);
});
}
function wrapOldPluginWithNewInterface(plugin) {
let wrappedPlugin = {
originalObject: plugin,
wrapWithOldInterface: wrapOldPluginWithOldInterface
};
for (let m in plugin) {
if (isFunction(plugin[m])) {
wrappedPlugin[m] = (function (plugin, member) {
return function () {
let args = Array.prototype.slice.call(arguments);
return new Promise(function (resolve, reject) {
args.push(resolve, reject);
member.apply(plugin, args);
});
};
})(plugin, plugin[m]);
} else {
wrappedPlugin[m] = plugin[m];
}
}
return new Promise(function (resolve) {
resolve(wrappedPlugin);
});
}
if (extension) {
initializeExtension();
} else if (navigator.mimeTypes && navigator.mimeTypes[pluginMimeType]) {
initialize();
} else {
try {
let plugin = new ActiveXObject("Aktiv.CryptoPlugin");
initialize();
} catch (e) {
initializeWithoutPlugin();
}
}
return my;
}({}));
this.setRutoken(rutoken);
}
});
```
Таким образом, нужно создать объект данного класса и подставить его в функцию connectToDevice класса Rutoken.rutoken.ConnectToDevice, код которого был приведен ранее. Это действие я делаю в следующем классе, который отвечает за регистрацию пользователя:
**Открыть реализацию Rutoken.rutoken.RutokenRegistration**
```
Ext.define('Rutoken.rutoken.RutokenRegistration', {
registration: function (rutoken, device, scope) {
return device.connectToDevice(rutoken)
//Получаем исходные данные для проведения регистрации
.then(function (pluginWithDeviceIndex) {
values = scope.lookupReference('regForm').getValues();
plugin = pluginWithDeviceIndex[0];
deviceIndex = pluginWithDeviceIndex[1];
host = 'http://localhost:8080/';
createCrtDataPrefix = 'createCrtData';
registrationPrefix = 'registration';
})
//Получаем список сертификатов с рутокена
.then(function () {
return plugin.enumerateCertificates(deviceIndex, plugin.CERT_CATEGORY_USER);
})
//Проверяем существование ключевой пары на рутокене
.then(function (crts) {
if (crts.length > 0) {
throw "Certificate already exist on rutoken";
}
})
//Создаем ключевую пару на рутокене по GOST3410_2012_256
.then(function () {
let option = {
"publicKeyAlgorithm": plugin.PUBLIC_KEY_ALGORITHM_GOST3410_2012_256
};
return plugin.generateKeyPair(deviceIndex, undefined, "", option);
})
//Формируем запрос createPkcs10 на выдачу сертификата
.then(function (keyPair) {
let subject = [
{
rdn: "countryName",
value: "RU"
}
, {
rdn: "stateOrProvinceName",
value: "Russia"
}
, {
rdn: "localityName",
value: "Saint-Petersburg"
}
, {
rdn: "streetAddress",
value: "street"
}
, {
rdn: "organizationName",
value: "Eurica"
}
, {
rdn: "organizationalUnitName",
value: "Rutoken"
}
, {
rdn: "title",
value: "инженер"
}
, {
rdn: "commonName",
value: `${values.name} ${values.surname}`
}
, {
rdn: "postalAddress",
value: "postal address"
}
, {
rdn: "pseudonym",
value: "инженер123"
}
, {
rdn: "surname",
value: `${values.surname}`
}
, {
rdn: "givenName",
value: "given name"
}
, {
rdn: "emailAddress",
value: `${values.email}`
}
];
let keyUsageVal = [
"digitalSignature"
, "nonRepudiation"
, "keyEncipherment"
, "dataEncipherment"
, "keyAgreement"
, "keyCertSign"
, "cRLSign"
, "encipherOnly"
, "decipherOnly"
];
let extKeyUsageVal = [
"emailProtection"
, "clientAuth"
, "serverAuth"
, "codeSigning"
, "timeStamping"
, "msCodeInd"
, "msCodeCom"
, "msCTLSign"
, "1.3.6.1.5.5.7.3.9" // OSCP
, "1.2.643.2.2.34.6" // CryptoPro RA user
];
let certificatePolicies = [
"1.2.643.100.113.1", // КС1
"1.2.643.100.113.2", // КС2
"1.2.643.100.113.3", // КС3
"1.2.643.100.113.4", // КВ1
"1.2.643.100.113.5", // КВ2
"1.2.643.100.113.6" // КА1
];
let extensions = {
"keyUsage": keyUsageVal,
"extKeyUsage": extKeyUsageVal,
"certificatePolicies": certificatePolicies
};
let options = {
"subjectSignTool": 'СКЗИ "РУТОКЕН ЭЦП"',
"hashAlgorithm": plugin.HASH_TYPE_GOST3411_12_256,
"customExtensions": [
{
oid: "1.3.6.1.4.1.311.21.7",
value: "MA0GCCqFAwICLgAIAgEB",
criticality: false
}
],
};
return plugin.createPkcs10(deviceIndex, keyPair, subject, extensions, options);
})
//создаем объект pkcs10Message для отправки на сервер
.then(function (pkcs10Request) {
let pkcs10Message = Ext.create('Rutoken.model.RuTokenPkcs10Message');
pkcs10Message.requestPkcs10Message = pkcs10Request;
return pkcs10Message;
})
//отправляем pkcs10Message на сервер для формирования сертификата
.then(function (pkcs10Message) {
return new Promise(function (resolve, reject) {
Ext.Ajax.request({
method: 'POST',
jsonData: Ext.encode(pkcs10Message),
url: `${host}${createCrtDataPrefix}`,
scope: this,
headers: {
'accept': 'application/json',
},
success: function (response) {
let crt = Ext.decode(response.responseText);
plugin.importCertificate(deviceIndex, crt.responseCertificateMessage, plugin.CERT_CATEGORY_USER);
console.log('Certificate was saved successful');
resolve(crt);
},
failures: function (response) {
console.log('Failure Pkcs10 request');
reject(response.status);
}
});
});
});
}
});
```
В качестве параметров функция registration получает объекты классов Rutoken.rutoken.RutokenInit (rutoken), Rutoken.rutoken.ConnectToDevice (device), третьим параметром передается scope на ViewController, чтобы у меня была возможность работать с данными с формы (рассмотрение данной части выходит за рамки статьи).
Считаю, что код имеет достаточное количество комментариев, чтобы можно было понять, как он работает. Обращу внимание только на некоторые моменты.
Во-первых, обратите внимание на часть кода помеченную комментарием «Формируем запрос createPkcs10 на выдачу сертификата». Рассмотрим переменную subject. Она представляет собой ассоциативный массив, который содержит в себе данные пользователя. Эти данные потом будут отражаться в самом сертификате. Дело в том, что по умолчанию можно менять только значения этого массива, но нельзя добавлять новые или удалять старые элементы этого массива. Обратите на это внимание, иначе ваша функция для создания запроса работать не будет.
Во-вторых, хочу обратить внимание на то, что алгоритм, с помощью которого формируется ключевая пара (в моем случае PUBLIC\_KEY\_ALGORITHM\_GOST3410\_2012\_256), должен соответствовать алгоритму хеширования в переменной options (в моем случае это «hashAlgorithm»: plugin.HASH\_TYPE\_GOST3411\_12\_256). Если будете использовать другой алгоритм создания ключевой пары, то алгоритм хеширования должен быть соответствующий. В противном случае ваша функция для создания запроса также работать не будет.
После формирования запроса на создание сертификата, происходит отправка этого запроса на сервер, и в ответ приходит сам сертификат, который успешно импортируется на Рутокен.
Отлично! Мы произвели регистрацию пользователя в системе. Теперь мы имеем на своем Рутокене сертификат с неэкспортируемой ключевой парой, а также удостоверяющий центр знает о сертификате, который записан на Рутокене, так как он сам его выдал с помощью первой команды, описанной [в данной статье](https://habr.com/ru/post/507166/).
Перейдем к авторизации пользователя. Алгоритм процесса авторизации описан [тут](https://habr.com/ru/post/506450/).
Для программного описания процесса авторизации мной был создан класс Rutoken.rutoken.RutokenAuthorization:
**Открыть реализацию Rutoken.rutoken.RutokenAuthorization**
```
Ext.define('Rutoken.rutoken.RutokenAuthorization', {
reference: "ruTokenAuthorization",
authorization: function (rutoken, device, scope) {
return device.connectToDevice(rutoken)
//Получаем исходные данные для проведения аутентификации
.then(function (pluginWithDeviceIndex) {
plugin = pluginWithDeviceIndex[0];
deviceIndex = pluginWithDeviceIndex[1];
values = scope.lookupReference('authForm').getValues();
host = 'http://localhost:8080/';
prefixSalt = 'get-authentication-salt';
prefixAuthentication = 'authentication';
prefixLogin = 'login';
})
//Делаем запрос на аутентификацию на сервер и получаем случайную строку salt
.then(function () {
return new Promise(function (resolve, reject) {
Ext.Ajax.request({
method: 'POST',
jsonData: "",
url: `${host}${prefixSalt}`,
scope: this,
headers: {
'accept': 'application/json',
},
success: function (response) {
console.log(`Success ${host}${prefixSalt} request`);
resolve(Ext.decode(response.responseText));
},
failures: function (response) {
console.log(`Failure ${host}${prefixSalt} request`);
reject(response.status);
}
});
});
})
.then(function (responseData) {
salt = responseData;
})
//Получаем список сертификатов с рутокена
.then(function () {
return plugin.enumerateCertificates(deviceIndex, plugin.CERT_CATEGORY_USER);
})
//Формируем запрос на аутентификацию. Для этого используем только первый сертификат.
//На устройстве должен быть только один сертификат привязанный к ключевой паре.
.then(function (crts) {
return plugin.authenticate(deviceIndex, crts[0], salt.salt);
})
//Корректируем запрос на аутентификацию для правильного понимания запроса сервером
.then(function (auth) {
auth = "-----BEGIN CMS-----\n" + auth + "-----END CMS-----";
return auth;
})
//Формирум объект authenticateMessage для отправки его на сервер
.then(function (auth) {
let authenticateMessage = Ext.create("Rutoken.model.RuTokenAuthenticateMessage");
authenticateMessage.authenticateMessage = auth;
return authenticateMessage;
})
//Отправляем запрос authenticateMessage на сервер
.then(function (authenticateMessage) {
return new Promise(function (resolve, reject) {
Ext.Ajax.request({
method: 'POST',
jsonData: Ext.encode(authenticateMessage),
url: `${host}${prefixAuthentication}`,
scope: this,
headers: {
'accept': 'application/json',
},
success: function (response) {
console.log(`Success ${host}${prefixAuthentication} request`);
resolve(Ext.decode(response.responseText).authorizationSuccess);
},
failures: function (response) {
console.log(`Failure ${host}${prefixAuthentication} request`);
reject(response.status);
}
});
});
});
},
});
```
В результате мы получим объект authorizationSuccess с логическим значением, которое говорит о том, что прошла ли наша авторизация успешно или нет.
В заключение приведу [полезную ссылку](https://aktivco.github.io/rutoken-plugin-demo/), которая поможет вам протестировать работоспособность функций Рутокен плагина.
Надеюсь, этот цикл статей был полезен для вас, желаю удачи и спасибо за внимание! | https://habr.com/ru/post/506934/ | null | ru | null |
# Модифицируем Python за 6 минут
Всем доброго и неумолимо наступающего!
Этот крайне насыщенный год подходит к своему завершению и у нас остался последний курс, который мы запускаем в этом году — "[Разработчик full-stack на Python](https://otus.pw/HqQW/)", чему, собственно, и посвящаем заметку, которая хоть и проскочила мимо основной программы, но показалась небезынтересной в целом.
Поехали
-------
На этой неделе я сделал мой первый [pull-request](https://github.com/python/cpython/pull/1069) в основной проект CPython. Его отклонили :-( Но чтобы не тратить полностью свое время, я поделюсь своими выводами о том, как работает CPython и покажу вам как легко изменить синтаксис Python.
Я собираюсь показать вам как добавить новую **фичу** в синтаксис Python. Эта фича — оператор инкремента/декремента, стандартный оператор для большинства языков. Чтобы убедиться — откройте REPL и попробуйте:
Уровень 1: PEP
--------------
Изменению синтаксиса Python предшествует заявка с описанием причин, дизайна и поведения вносимых изменений. Все изменения языка обсуждаются основной командой Python и одобряются BDFL. Операторы инкремента не утверждены (и, вероятно, никогда не будут), что даёт нам хорошую возможность потренироваться.
Уровень 2: Грамматика
---------------------
Файл [Grammar](https://github.com/python/cpython/blob/v3.6.1/Grammar/Grammar) — это простой текстовый файл, описывающий все элементы языка Python. Его использует не только CPython, но и другие реализации, такие как PyPy, чтобы сохранить последовательность и согласовать типы языковой семантики.
Внутри эти ключи образуют токены, которые разбираются лексером. Когда вы вводите `make -j`, команда преобразует их в набор перечислений и констант в C-хедерах. Это позволяет ссылаться на них в дальнейшем.
```
stmt: simple_stmt | compound_stmt
simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
# ...
pass_stmt: 'pass'
flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt
break_stmt: 'break'
continue_stmt: 'continue'
# ..
import_as_name: NAME ['as' NAME]
```
Таким образом, `simple_stmt` — это простое выражение, оно может иметь точку с запятой или не иметь, например, когда вы вводите `import pdb; pdb.set_trace()`, и заканчиваться в новой строке NEWLINE. `Pass_stmt` — пропуск слова, `break_stmt` — прерывание работы. Просто, не так ли?
Давайте добавим выражения инкремента и декремента: то, чего не существует в языке. Это был бы еще один вариант структуры выражения, наряду с операторами yield, расширенным и стандартным присвоением, т.е. foo=1.
```
# Добавляем выражения инкремента и декремента
expr_stmt: testlist_star_expr (annassign | augassign (yield_expr|testlist) |
('=' (yield_expr|testlist_star_expr))* | incr_stmt | decr_stmt)
annassign: ':' test ['=' test]
testlist_star_expr: (test|star_expr) (',' (test|star_expr))* [',']
augassign: ('+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' |
'<<=' | '>>=' | '**=' | '//=')
# Для нормальных и аннотированных присвоений, дополнительных ограничений навязываемых интерпретатором
del_stmt: 'del' exprlist
# Новые выражения
incr_stmt: '++'
decr_stmt: '--'
```
Мы добавляем его в список возможных малых выражений (это станет очевидным в AST). `Incr_stmt` будет нашим методом инкремента и `decr_stmt` будет декрементом. Оба следуют за NAME (имя переменной) и образуют малое автономное выражение. Когда мы соберем проект Python, он сгенерирует компоненты для нас (не сейчас).
Если вы запустите Python с опцией -d и попробуете это, вы должны получить:
```
Token /’++’ … Illegal token
```
Что такое токен? Давайте выясним…
Уровень 3: Лексер
-----------------
Есть четыре шага, которые делает Python, когда вы вызываете return: лексический анализ, синтаксический анализ, компиляция и интерпретация. Лексический анализ разбивает строку кода, которую вы только что ввели, на токены. Лексер CPython называется `tokenizer.c`. Он имеет функции, которые читают из файла (например, `python file.py`) [строку](https://github.com/python/cpython/blob/v3.6.1/Parser/tokenizer.c#L809-L824) (например, REPL). Он также обрабатывает специальный комментарий для кодировки в верхней части файлов и анализирует ваш файл как UTF-8 и т. д. Он обрабатывает вложенность, ключевые слова async и yield, обнаруживает наборы и кортежи присвоений, но только грамматически. Он не знает, что это за вещи или что с ними делать. Его волнует только текст.
Например, код, который позволяет использовать `o`-нотацию для восьмеричных значений, находится в [токенизаторе](https://github.com/python/cpython/blob/v3.6.1/Parser/tokenizer.c#L1635-L1652). Код, который на самом деле создает восьмеричные значения, находится в компиляторе.
Давайте добавим две вещи в Parser/tokenizer.c: новые токены `INCREMENT` и `DECREMENT`, — это ключи, которые возвращаются токенизатором для каждой части кода.
```
/* Имена токенов */
const char *_PyParser_TokenNames[] = {
"ENDMARKER",
"NAME",
"NUMBER",
...
"INCREMENT",
"DECREMENT",
...
```
Затем мы добавляем проверку, чтобы вернуть токен `INCREMENT` или `DECREMENT`, каждый раз, когда видим ++ или --. Уже существует функция для двухсимвольных операторов, поэтому мы расширяем ее в соответствии с нашим случаем.
```
@@ -1175,11 +1177,13 @@ PyToken_TwoChars(int c1, int c2)
break;
case '+':
switch (c2) {
+ case '+': return INCREMENT;
case '=': return PLUSEQUAL;
}
break;
case '-':
switch (c2) {
+ case '-': return DECREMENT;
case '=': return MINEQUAL;
case '>': return RARROW;
}
```
Они определены в `token.h`
```
#define INCREMENT 58
#define DECREMENT 59
```
Теперь, когда мы запускаем Python с -d и пытаемся выполнить наш оператор, мы видим:
```
It’s a token we know - Успех!
```
Уровень 4: Парсер
-----------------
Парсер принимает эти токены и генерирует структуру, которая показывает их взаимосвязь друг с другом. Для Python и многих других языков это абстрактное синтаксическое дерево (или AST). Затем компилятор принимает AST и превращает его в один (или более) объект кода. Наконец, интерпретатор принимает каждый объект кода, который выполняет код, представляемый им.
Представьте свой код в виде дерева. Верхний уровень — это корень, функция может быть веткой, класс — тоже ветка и методы класса ответвляются от нее. Выражения — это листья на ветке.
AST определяется в `ast.py` и `ast.c`. `ast.c` — это файл, который нам нужно изменить. Код AST разбит на методы, которые обрабатывают типы токенов, `ast_for_stmt` обрабатывает операторы, `ast_for_expr` обрабатывает выражения. Мы помещаем `incr_stmt` и `decr_stmt` как возможные выражения. Они почти идентичны расширенным выражениям, например, test += 1, но нет правого выражения (1), оно неявно.
Это код, который нам нужно добавить для инкремента и декремента.
```
static stmt_ty
ast_for_expr_stmt(struct compiling *c, const node *n)
{
...
else if ((TYPE(CHILD(n, 1)) == incr_stmt) || (TYPE(CHILD(n, 1)) == decr_stmt)) {
expr_ty expr1, expr2;
node *ch = CHILD(n, 0);
operator_ty operator;
switch (TYPE(CHILD(n, 1))){
case incr_stmt:
operator = Add;
break;
case decr_stmt:
operator = Subtract;
break;
}
expr1 = ast_for_testlist(c, ch);
if (!expr1) {
return NULL;
}
switch (expr1->kind) {
case Name_kind:
if (forbidden_name(c, expr1->v.Name.id, n, 0)) {
return NULL;
}
expr1->v.Name.ctx = Store;
break;
default:
ast_error(c, ch,
"illegal target for increment/decrement");
return NULL;
}
// Создаем PyObject для числа 1
PyObject *pynum = parsenumber(c, "1");
if (PyArena_AddPyObject(c->c_arena, pynum) < 0) {
Py_DECREF(pynum);
return NULL;
}
// Создаем это как выражение в той же строке и смещении как ++/--
expr2 = Num(pynum, LINENO(n), n->n_col_offset, c->c_arena);
return AugAssign(expr1, operator, expr2, LINENO(n), n->n_col_offset, c->c_arena);
```
Это возвращает расширенное присваивание — вместо нового типа выражения с постоянным значением 1. Оператором является либо Add, либо Sub(tract) в зависимости от типа токена `incr_stmt` или `decr_stmt`. Возвращаясь к Python REPL после компиляции, мы можем увидеть наш новый оператор!
В REPL вы можете попробовать `ast.parse ("test=1; test++).body[1]`, и вы увидите возвращаемый тип `AugAssign`. AST только что преобразовал оператор в выражение, которое может быть обработано компилятором. Функция `AugAssign` устанавливает поле `Kind`, которое используется компилятором.
Уровень 5: Компилятор
---------------------
Затем компилятор берет дерево синтаксиса и «посещает» каждую ветвь. У компилятора CPython есть метод для посещения оператора, который называется `compile_visit_stmt`. Это просто большой оператор switch, определяющий вид оператора. У нас был тип `AugAssign`, поэтому он обращается к `compiler_augassign` для обработки деталей. Затем эта функция преобразует наше утверждение в набор байт-кодов. Это промежуточный язык между машинным кодом (01010101) и деревом синтаксиса. *Последовательность байтового кода — это то, что кэшируется в .pyc-файлах.*
```
static int
compiler_augassign(struct compiler *c, stmt_ty s)
{
expr_ty e = s->v.AugAssign.target;
expr_ty auge;
assert(s->kind == AugAssign_kind);
switch (e->kind) {
...
case Name_kind:
if (!compiler_nameop(c, e->v.Name.id, Load))
return 0;
VISIT(c, expr, s->v.AugAssign.value);
ADDOP(c, inplace_binop(c, s->v.AugAssign.op));
return compiler_nameop(c, e->v.Name.id, Store);
```
Результатом будет VISIT (значение нагрузки — для нас 1), ADDOP (добавить операцию двоичного операционного кода в зависимости от оператора (вычесть, добавить)) и STORE\_NAME (сохранить результат ADDOP для имени). Эти методы отвечают более конкретными байт-кодами.
Если вы загрузите модуль `dis`, вы сможете увидеть байт-код:
Уровень 6: Интерпретатор
------------------------
Финальным уровнем является интерпретатор. Он берет последовательность байт-кодов и преобразует ее в машинные операции. Вот почему Python.exe и Python для Mac и Linux — все отдельные исполняемые файлы. Некоторым байт-кодам нужна конкретная обработка и проверка ОС. API-интерфейс потоковой обработки, например, должен работать с API-интерфейсом GNU/Linux, который очень отличается от потоков Windows.
```
Вот и все!
```
Для дальнейшего чтения.
Если вас интересуют интерпретаторы, я рассказал о Pyjion, архитектуре плагина для CPython, которая стала [PEP523](https://www.python.org/dev/peps/pep-0523/)
Если вы все еще хотите поиграть, я запушил код на [GitHub](https://github.com/tonybaloney/cpython/commit/fd7c20c3a3a02b4f2dae8ec7a90448627aa0d757) вместе с моими изменениями в токенизаторе ожидания.
THE END
Как всегда ждём вопросы, комментарии, замечания. | https://habr.com/ru/post/345526/ | null | ru | null |
# Самые быстрые числа с плавающей запятой на диком западе
В процессе реализации одной «считалки» возникла проблема с повышенной точностью вычислений. Расчетный алгоритм работал быстро на стандартных числах с плавающей запятой, но когда подключались библиотеки для точных вычислений, все начинало дико тормозить. В этой статье будут рассмотрены алгоритмы расширения чисел с плавающей запятой с помощью мультикомпонентного подхода, благодаря которому удалось достичь ускорения, так как float арифметика реализована на кристалле цп. Данный подход будет полезен для более точного вычисления численной производной, обращение матриц, обрезке полигонов или других геометрических задач. Так возможна эмуляции 64bit float на видеокартах, которые их не поддерживают.
### Введение
Как завещал нам еще Никлуас Вирт хранить числа в 0 и 1, так мы их в них и храним. И ничего, что человеки живут в десятичной системе исчисления, и обычные казалось бы числа 0.1 и 0.3 не представимы в двоичной системе конечной дробью? Мы же испытываем культурный шок когда производим над ними вычисления. Кончено, предпринимаются [попытки](http://dec64.com/) создания библиотек для процессоров на основе десятичной системы и [IEEE](https://en.wikipedia.org/wiki/Decimal_floating_point#IEEE_754-2008_encoding) даже стандартизировал форматы.
Но пока мы везде учитываем бинарность хранения и проводим все денежные вычисление с библиотеками для точного вычисления, такими как bignumber, что приводит к потере производительности. Асики считают крипту, а в процессорах и так мало места для этой вашей десятичной арифметики, считают маркетологи. Поэтому мультикомпонентный подход, когда число хранится в виде непреобразованной суммы чисел, это удобный трюк и активно развивающаяся сфера в области теоретической информатики. Хотя умножать правильно, без потери точности еще научился Деккер в 1971, готовые к применению библиотеки появились значительно позже (MPFR, QD) и не во всех языках, видимо так как не все поддерживали стандарты IEEE, а строгие доказательства погрешности вычислений и того позже, например в 2017 для double-word арифметики.
### Double-word арифметика
В чем суть? В бородатые времена, когда еще не было стандартов для плавающих чисел, что бы избежать проблем с реализацией их округления, Møller придумал, а Knuth в последствии доказал, что существует свободное от ошибок суммирование. Выполняющееся таким образом
```
function quickTwoSum(a, b) {
let s = a + b;
let z = s - a;
let e = b - z;
return [s, e];
}
```
В данном алгоритме предполагалось, что если , то точная их сумма представима в виде суммы двух чисел  и можно хранить их парой для последующих вычислений, а вычитание сводится к сложению с отрицательным числом.
В последствии Dekker показал, что если используются числа с плавающей запятой, использующие округление к ближайшему четному числу (round-to-nearest ties to even, что вообще является правильной процедурой, не приводящей к большим погрешностям в процессе долгих вычислений и стандартом по IEEE), то существует алгоритм умножения, свободный от ошибок.
```
function twoMult(a, b) {
let A = split(a);
let B = split(b);
let r1 = a * b;
let t1 = -r1 + A[0] * B[0];
let t2 = t1 + A[0] * B[1];
let t3 = t2 + A[1] * B[0];
return [r1, t3 + A[1] * B[1]];
}
```
где split() это алгоритм господина Veltkamp'а для разделения числа
```
let splitter = Math.pow(2, 27) + 1;
function split(a) {
let t = splitter * a;
let d = a - t;
let xh = t + d;
let xl = a - xh;
return [xh, xl];
}
```
использующий константу , которую приравнивают чуть больше половины длины мантиссы, что не приводит к переполнению чисел в процессе умножения и разделяет мантиссу на две половины. Например при длине слова в 64-bit, длина мантиссы равна 53 и тогда s=27.
Таким образом Dekker привел почти полный набор, необходимый для вычисления в double-word арифметике. Так как там еще было указано как умножать, делить и возводить в квадрат два double-word числа.
У него был везде «заинлайнен» алгоритм quickTwoSum для суммирования двух double-word, и использовалась проверка . На современных процессорах, как описано в [4], дешевле использовать дополнительные операции с числами, чем ветвление алгоритма. Поэтому следующий алгоритм, сейчас более уместен для сложения двух single-word чисел
```
function twoSum(a, b) {
let s = a + b;
let a1 = s - b;
let b1 = s - a1;
let da = a - a1;
let db = b - b1;
return [s, da + db];
}
```
А вот так производится суммирование и умножение double-word чисел.
```
function add22(X, Y) {
let S = twoSum(X[0], Y[0]);
let E = twoSum(X[1], Y[1]);
let c = S[1] + E[0];
let V = quickTwoSum(S[0], c);
let w = V[1] + E[1];
return quickTwoSum(V[0], w);
}
function mul22(X, Y) {
let S = twoMult(X[0], Y[0]);
S[1] += X[0] * Y[1] + X[1] * Y[0];
return quickTwoSum(S[0], S[1]);
}
```
Вообще говоря, самый полный и точный список алгоритмов для double-word арифметики, теоретические границы ошибок и практическая реализация описана в ссылке [3] от 2017 года. Поэтому если заинтересовало, настоятельно рекомендую идти сразу туда. И вообще, в [6] приведен алгоритм для quadruple-word, а в [5] для мультикомпонентного расширения произвольной длины. Только вот там, после каждой операции используется процесс ренормализации, что не всегда оптимально для малых размеров, а точность вычислений в QD не определена строго. Вообще стоит задумываться о границах применимости данных подходов, конечно.
### Страшилки javascript-a. Сравнение decimal.js vs bignumber.js vs big.js.
Так получилось что почти все библиотеки для точных вычислений в js написаны одним человеком. Создается иллюзия выбора, хотя они почти все одинаковые. В добавок в документации явно не указано, что если вы не будете округлять числа после каждой операции умножения/деления, то размер вашего числа будет все время удваиваться, и сложность алгоритма может вырасти в легкую в x3500. Например вот так может выглядеть сравнение их времени вычисления, если вы не округляли числа.
То есть вы выставляете точность в 32 знак после запятой и… Упс у вас уже 64 знака, 128. Мы считаем очень точно! 256, 512… Но я выставлял 32!.. 1024, 2048… Как то так появляется overhead в 3500 раз. В документации указано, что если у вас научные вычисления, то вероятно вам лучше подойдет decimal.js. Хотя по факту, если просто периодически округлять, для научных вычислений Bignumber.js работает чуть шустрее (см. рис. 1). Кому то нужно считать сотые доли копеек, если их нельзя выдать сдачей? Есть ли какой то кейс, когда надо хранить больше указных чисел и не выкрутится еще несколькими дополнительными знаками? Как оно возьмет синус от такого числа-монстра, когда строгую точность сходимости ряда тейлора для произвольных чисел никто не знает. Вообщем есть не безосновательные подозрения, что там можно увеличить скорость расчета, используя алгоритмы умножения Шёнхаге — Штрассена и нахождения синуса с Cordic вычислениями, например.
### Double.js
~~Мне бы хотелось сказать, конечно, что Double.js считает быстро и точно. Но это не совсем так, то есть быстрее в 10 раз то оно считает, да вот не всегда точно. Например 0.3-0.1 оно умеет обрабатывать, переходя в удвоенное хранение и обратно. Но вот число Pi распарсить с удвоенной точностью в почти 32 знака и обратно у него не выходит. Образуется ошибка на 16-м, как будто происходит переполнение. Вообщем, я призываю js сообщество общими усилиями попробовать решить проблему парсинга, так как я застрял. Пробовал парсить поцифренно и делить в двойной точности, как в QD, делить пачками по 16 цифр и делить в двойной точности, сплитить мантиссу используя Big.js как в одной из либ Julia. Сейчас я грешу на баг в .parseFloat(), так как IEEE стандарты с округлением к ближайшему целому поддерживаются еще с ECMAScript 1. Хотя конечно можно попробовать забиндить двоичный buffer и наблюдать за каждым 0 и 1. Вообщем, если получится разрешить данную проблему, тогда можно будет тогда сделать вычисления с произвольной точностью с ускорением в x10-x20 от bignumber.js. Впрочем множество Мандельброта оно уже сейчас рендерит качественно, и можно использовать ее для геометрических задач.~~
Спустя год, я вернулся сюда и все таки пофиксил проблему с парсингом. Проблема была всего лишь в не достаточной точности, при умножении на 10^(-n). Все алгоритмы были пересмотрены с нуля, и сейчас выполняются с пугающей точностью и скоростью.
Вот ссылка на [либу](https://github.com/), там есть интерактивный benchmark и песочица, где можно с ней поиграть.
### Используемые источники
1. O. Møller. *Quasi double precision in floating-point arithmetic.*, 1965.
2. Theodorus Dekker. *A floating-point technique for extending the available precision*, 1971. [[Viewer](https://gdz.sub.uni-goettingen.de/id/PPN362160546_0018?tify=%7B%22pages%22:%5B230%5D,%22panX%22:0.306,%22panY%22:0.754,%22view%22:%22info%22,%22zoom%22:0.39%7D)]
3. Mioara Joldes, Jean-Michel Muller, Valentina Popescu. *Tight and rigourous error bounds for basic building blocks of double-word arithmetic*, 2017. [[PDF](https://hal.archives-ouvertes.fr/hal-01351529v3/document)]
4. Muller, J.-M. Brisebarre, N. de Dinechin, etc. Handbook of Floating-Point Arithmetic, Chapter 14, 2010.
5. Jonathan Shewchuk. *Robust Adaptive Floating-Point Geometric Predicates*, 1964. [[PDF](https://people.eecs.berkeley.edu/~jrs/papers/robust-predicates.pdf)]
6. Yozo Hida, Xiaoye Li, David Bailey. *Library for Double-Double and Quad-Double Arithmetic*, 2000. [[PDF](http://web.mit.edu/tabbott/Public/quaddouble-debian/qd-2.3.4-old/docs/qd.pdf)] | https://habr.com/ru/post/423469/ | null | ru | null |
# «Новые Былины». Едим слона по частям
В этой статье я буду настраивать рабочее окружение для разработки игры "Былины", а также выполню разбиение самой игры на части, пригодные для использования в OpenFaaS. Все манипуляции буду делать на Linux, Kubernetes буду разворачивать в minikube с использованием VirtualBox. В моей рабочей машине 2 процессорных ядра и 12гб оперативной памяти, в качестве системного диска я применяю SSD. В качестве основной системы для разработки буду использовать debian 8, с установленными пакетами emacs, sudo, git и virtualbox, все остальное установлю путем скачивания из GitHub и других источников. Эти приложения будем устанавливать в /usr/local/bin, если не указано другое. Приступим!
Подготовка рабочего окружения
-----------------------------
### Установка Go
Следуем инструкциям с официального сайта:
```
$ curl -L0 https://dl.google.com/go/go1.13.5.linux-amd64.tar.gz -o go.tar.gz
$ sudo tar -C /usr/local -xzf go.tar.gz
$ echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.profile
```
Проверяем работоспособность:
```
$ mkdir -p ~/go/src/hello && cd ~/go/src/hello
$ echo 'package main
import "fmt"
func main() {
fmt.Printf("hello, world\n")
}' > hello.go
$ go build
$ ./hello
hello, world
```
### Установка faas-cli
Следуем инструкциям с официального сайта:
```
$ curl -sSL https://cli.openfaas.com | sudo -E sh
x86_64
Downloading package https://github.com/openfaas/faas-cli/releases/download/0.11.3/faas-cli as /tmp/faas-cli
Download complete.
Running with sufficient permissions to attempt to move faas-cli to /usr/local/bin
New version of faas-cli installed to /usr/local/bin
Creating alias 'faas' for 'faas-cli'.
___ _____ ____
/ _ \ _ __ ___ _ __ | ___|_ _ __ _/ ___|
| | | | '_ \ / _ \ '_ \| |_ / _` |/ _` \___ \
| |_| | |_) | __/ | | | _| (_| | (_| |___) |
\___/| .__/ \___|_| |_|_| \__,_|\__,_|____/
|_|
CLI:
commit: 73004c23e5a4d3fdb7352f953247473477477a64
version: 0.11.3
```
Дополнительно можно подключить работу bash-completion:
```
faas-cli completion --shell bash | sudo tee /etc/bash_completion.d/faas-cli
```
### Установка и настройка Kubernetes
Для разработки достаточно minikube, так что установим его и kubelet в /usr/local/bin, для установки приложений также установим helm:
```
$ curl https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64 -o minikube && chmod +x minikube && sudo mv minikube /usr/local/bin/
$ curl https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl -o kubectl && chmod +x kubectl && sudo mv kubectl /usr/local/bin/
$ curl https://get.helm.sh/helm-v3.0.2-linux-amd64.tar.gz | tar -xzvf - linux-amd64/helm --strip-components=1; sudo mv helm /usr/local/bin
```
Запускаем minikube:
```
$ minikube start
minikube v1.6.2 on Debian 8.11
Automatically selected the 'virtualbox' driver (alternates: [])
Downloading VM boot image ...
> minikube-v1.6.0.iso.sha256: 65 B / 65 B [--------------] 100.00% ? p/s 0s
> minikube-v1.6.0.iso: 150.93 MiB / 150.93 MiB [-] 100.00% 5.67 MiB p/s 27s
Creating virtualbox VM (CPUs=2, Memory=8192MB, Disk=20000MB) ...
Preparing Kubernetes v1.17.0 on Docker '19.03.5' ...
Downloading kubeadm v1.17.0
Downloading kubelet v1.17.0
Pulling images ...
Launching Kubernetes ... Waiting for cluster to come online ...
Done! kubectl is now configured to use "minikube"
```
Проверяем:
```
$ kubectl get pods --all-namespaces
NAMESPACE NAME READY STATUS RESTARTS AGE
kube-system coredns-6955765f44-knlcb 1/1 Running 0 29m
kube-system coredns-6955765f44-t9cpn 1/1 Running 0 29m
kube-system etcd-minikube 1/1 Running 0 28m
kube-system kube-addon-manager-minikube 1/1 Running 0 28m
kube-system kube-apiserver-minikube 1/1 Running 0 28m
kube-system kube-controller-manager-minikube 1/1 Running 0 28m
kube-system kube-proxy-hv2wc 1/1 Running 0 29m
kube-system kube-scheduler-minikube 1/1 Running 0 28m
kube-system storage-provisioner 1/1 Running 1 29m
```
### Установка OpenFaaS
Разработчики рекомендуют создать 2 namespace для работы:
```
$ kubectl apply -f https://raw.githubusercontent.com/openfaas/faas-netes/master/namespaces.yml
namespace/openfaas created
namespace/openfaas-fn created
```
Добавляем репозиторий для helm:
```
$ helm repo add openfaas https://openfaas.github.io/faas-netes/
"openfaas" has been added to your repositories
```
В чарте есть возможность задать пароль перед установкой, воспользуемся ею и сохраним данные доступа в виде секрета k8s:
```
$ PASSWORD=verysecurerandompasswordstring
$ kubectl -n openfaas create secret generic basic-auth --from-literal=basic-auth-user=admin --from-literal=basic-auth-password="$PASSWORD"
secret/basic-auth created
```
Выполняем развертывание:
```
$ helm repo update
Hang tight while we grab the latest from your chart repositories...
...Successfully got an update from the "openfaas" chart repository
Update Complete. Happy Helming!
$ helm upgrade openfaas --install openfaas/openfaas --namespace openfaas --set functionNamespace=openfaas-fn --set generateBasicAuth=false
Release "openfaas" does not exist. Installing it now.
NAME: openfaas
LAST DEPLOYED: Fri Dec 25 10:28:22 2019
NAMESPACE: openfaas
STATUS: deployed
REVISION: 1
TEST SUITE: None
NOTES:
To verify that openfaas has started, run:
kubectl -n openfaas get deployments -l "release=openfaas, app=openfaas"
```
Спустя некоторое время запускаем предложенную команду:
```
$ kubectl -n openfaas get deployments -l "release=openfaas, app=openfaas"
NAME READY UP-TO-DATE AVAILABLE AGE
alertmanager 1/1 1 1 114s
basic-auth-plugin 1/1 1 1 114s
faas-idler 1/1 1 1 114s
gateway 1/1 1 1 114s
nats 1/1 1 1 114s
prometheus 1/1 1 1 114s
queue-worker 1/1 1 1 114s
```
Проверяем работоспособность:
```
$ kubectl rollout status -n openfaas deploy/gateway
deployment "gateway" successfully rolled out
$ kubectl port-forward -n openfaas svc/gateway 8080:8080 &
[1] 6985
Forwarding from 127.0.0.1:8080 -> 8080
$ echo -n $PASSWORD | faas-cli login --username admin --password-stdin
Calling the OpenFaaS server to validate the credentials...
Handling connection for 8080
WARNING! Communication is not secure, please consider using HTTPS. Letsencrypt.org offers free SSL/TLS certificates.
credentials saved for admin http://127.0.0.1:8080
$ faas-cli list
Function Invocations Replicas
```
### Установка Mongodb
Ставим все с использованием helm:
```
$ helm repo add stable https://kubernetes-charts.storage.googleapis.com/
"stable" has been added to your repositories
$ helm install stable/mongodb --generate-name
NAME: mongodb-1577466908
LAST DEPLOYED: Fri Dec 25 11:15:11 2019
NAMESPACE: default
STATUS: deployed
REVISION: 1
TEST SUITE: None
NOTES:
** Please be patient while the chart is being deployed **
MongoDB can be accessed via port 27017 on the following DNS name from within your cluster:
mongodb-1577466908.default.svc.cluster.local
To get the root password run:
export MONGODB_ROOT_PASSWORD=$(kubectl get secret --namespace default mongodb-1577466908 -o jsonpath="{.data.mongodb-root-password}" | base64 --decode)
To connect to your database run the following command:
kubectl run --namespace default mongodb-1577466908-client --rm --tty -i --restart='Never' --image bitnami/mongodb --command -- mongo admin --host mongodb-1577466908 --authenticationDatabase admin -u root -p $MONGODB_ROOT_PASSWORD
To connect to your database from outside the cluster execute the following commands:
kubectl port-forward --namespace default svc/mongodb-1577466908 27017:27017 &
mongo --host 127.0.0.1 --authenticationDatabase admin -p $MONGODB_ROOT_PASSWORD
```
Проверяем:
```
kubectl run --namespace default mongodb-1577466908-client --rm --tty -i --restart='Never' --image bitnami/mongodb --command -- mongo admin --host mongodb-1577466908 --authenticationDatabase admin -u root -p $(kubectl get secret --namespace default mongodb-1577466908 -o jsonpath="{.data.mongodb-root-password}" | base64 --decode)
If you don't see a command prompt, try pressing enter.
> db.version();
4.0.14
```
Жмем ctrl+D для выхода из контейнера.
### Настройка emacs
В принципе, все было уже настроено по [этой статье](http://reangdblog.blogspot.com/2016/06/emacs-ide-go.html), так что не буду подробно расписывать.
Разбиение игры на функции
-------------------------
Взаимодействие с функциями осуществляется посредством протокола http, сквозная аутентификация между разными функциями обеспечивается JWT. Для хранения токенов, а также состояния игры, данных игроков, последовательностей ходов всех игр и другой информации используется mongodb. Давайте рассмотрим детальнее наиболее интересные функции.
### Регистрация
На входе этой функции — JSON с игровым псевдонимом и паролем. При вызове этой функции выполняется проверка отсутствия этого псевдонима в базе данных, при успешной проверке — вставка псевдонима и хэша пароля в базу. Регистрация необходима для активного участия в игре.
### Вход
На входе функции — JSON с игровым псевдонимом и паролем, при наличии псевдонима в базе и успешной проверке пароля с сохраненным ранее в базе возвращается JWT, который надо передавать другим функциям при их вызове. Также выполняется вставка в базу разных служебных записей, к примеру времени последнего входа и т.п.
### Просмотр списка игр
Любой неавторизованный пользователь может запросить список всех игр, кроме активных. Авторизованный пользователь также видит и список активных игр. Результат функции — JSON, содержащий списки игр (идентификатор игры, человекочитаемое имя и т.п.).
### Создание игры
Функция работает только с авторизованными пользователями, на входе принимается максимальное число игроков, а также параметры игры (например, каких персонажей активировать в этой игре, максимальное число игроков и т.п.). Отдельным параметром игры является наличие пароля на присоединение, что позволяет создать непубличные игры. По-умолчанию создается публичная игра. Результатом выполнения функции является JSON, в котором есть поле успешности создания, уникальный идентификатор игры, а также другие параметры.
### Присоединение к игре
Функция работает только с авторизованными пользователями, на входе — идентификатор игры и ее пароль, если это непубличная игра, на выходе — JSON с параметрами игры. Авторизованный пользователь, присоединившийся к игре, а также создатель игры далее зовутся участниками игры.
### Просмотр событий игры
Любой неавторизованный пользователь может запросить список событий неактивных игр, а авторизованный — получить список событий и любой активной игры. Дополнительным параметром функции может передаваться номер события, который уже есть у пользователя. В этом случае в списке вернутся только те события, которые произошли позднее. Периодически запуская эту функцию авторизованный пользователь смотрит, что происходит в игре. Также эта функция возвращает запрос на действие, на которое пользователь может отреагировать с помощью функции отправки события игры.
### Отправка события игры
Функция работает только для участников игры: реализуется возможность запустить игру, сделать ход, проголосовать, написать текстовое сообщение, которое отображается в списке событий игры и т.п.
Авторизованный пользователь, создавший игру, запускает раздачу ролей всем участникам игры, включая себя, они должны подтвердить свою роль с помощью этой же функции. Как только все роли подтверждены, игра автоматически переходит в режим ночи.
### Статистика игры
Функция работает только для участников игры, показывает состояние игры, список и число игроков (псевдонимы), роли и их статус (сделан ход, или нет), а также другую информацию. Как и для предыдущей функции, все работает только для участников игры.
### Периодически запускаемые функции
Если игра не была запущена в течение некоторого времени, указанного при создании игры — она будет автоматически удалена из списка активных игр с помощью функции зачистки.
Еще одна периодическая задача — принудительное переключение режима игры с ночи в день и обратно для игр, у которых этого не произошло во время хода (к примеру, игрок, которому надо отреагировать на игровое событие, не прислал свое решение по каким-либо причинам).
Анонс
-----
* [Введение](https://habr.com/ru/company/southbridge/blog/482010/)
* Установка окружения для разработки, разбиение задачи на функции
* Работы над backend
* Работы над frontend
* Настройка CI\CD, организация тестирования
* Запуск пробного сеанса игры
* Итоги | https://habr.com/ru/post/482752/ | null | ru | null |
# Поиск и решение проблем масштабируемости на примере многоядерных процессоров Intel Core 2 (часть 2)
Продолжение статьи: [часть 1](http://habrahabr.ru/blogs/hi/107620/), [часть 3](http://habrahabr.ru/blogs/hi/107622/), [часть 4](http://habrahabr.ru/blogs/hi/107624/)
#### Эффективность использования кэш-линий
Пункты 1.1 и 1.2 освещают одну из самых основных проблем: использование только части адресного пространства в кэш-линии. А это не только увеличивает трафик по шине, но и снижает эффективность процессорных КЭШей. Если за время нахождения в КЭШе используется только часть кэш-линии, то приложение значительно снижает размер своего КЭШа. Пункт 1.1 ссылается на практику компиляторов располагать элементы структур в памяти согласно их размеру. Так, если первым элементом структуры является «char», за ним следует 4-х байтовый «int», то компилятор добавит между этими элементами еще 3 байта, чтобы расположить их по 4-х байтной сетке.
Пункт 1.2 кажется говорит сам за себя, однако это один из самых главных источников высокого трафика по шине. Существует множество путей обнаружения этой проблемы. В приложениях с преобладанием циклов эффективность можно грубо прикинуть, посчитав сколько раз исполняются основные циклы и сколько байт данных они используют каждую итерацию посредством статического анализа ассемблерного листинга. В результате получаем максимальное количество байт, используемое в цикле. Измерив количество кэш-линий проходящих по шине во время циклов и умножив это число на 64, получим трафик по шине, инициируемый в циклах. Теперь, если разделить число байт потребляемое в цикле (из анализа листинга) на общее число байт, передаваемых по шине, получим грубую оценку эффективности использования шины.
Чтобы узнать сколько раз выполняется цикл, усредните число событий INST\_RETIRED.ANY\_P по командам цикла. Это будет количество исполнений базисного блока. Само событие не равномерно распределяется по базисному блоку; однако полное количество будет верно для «достаточно большой» области. Общее количество для приложения верно, но «длинные» команды покажут гораздо большее число этого события, чем команды немедленно прежде или после их в пределах того же самого блока. В цикле с доминирующим потоком через несколько базисных блоков событие должно быть усреднено по всем его базисным блокам, предполагая, что из статистического анализа ассемблерного листинга можно продемонстрировать, что фактически они все выполняются равное число раз. С собранными данными это можно сделать в VTune Analyzer. Просто подсветите все команды в цикле, чтобы отобразить сумму по ним. Посчитайте число команд в подсвеченной области. Умножьте сумму INST\_RETIRED.ANY\_P на значение «Выборка После Значения» (Sampling After Value, SAV) и разделите на число команд. Это и будет полное количество итераций цикла.
Эта методика позволяет также определить усредненное количество итераций внутреннего цикла, необходимо разделить количество выполнений внутреннего цикла на количество выполнений базисных блоков перед или после цикла. Результат крайне неточен, если количество итераций внутреннего цикла будет намного больше 100, но весьма точен для малых циклов. Однако, в то время как методика неточна для большого количества итераций, в целом полезно знать, что итераций много.
Простой контроль загрузки и выгрузки в память поможет оценить общек количество байтов, использованных за итерацию. Есть, конечно, риск завысить эту оценку из-за идентичных указателей, особенно рассматривая множество циклов.
Общее количество использованных кэш-линий измеряется событием BUS\_TRANS\_BURST.SELF.
Вскоре будет доступна другая статья, с более детальным рассмотрением анализа доступа к данным.
В случаях, где только малая часть данных, переданных по шине, фактически используется в часто исполняемых циклах, есть несколько способов улучшить использование шины и, таким образом, производительность одного потока или нескольких параллельных. Наиболее очевидное решение — разбить данные согласно их фактическому использованию, организовывая их в параллельные массивы или связные списки структур. В общем случае, только некоторое подмножество данных каждой структуры используется многократно, большая же часть используется лишь иногда. В большом приложении полностью реорганизовать формат данных может быть чрезвычайно трудно. В таком случае, часто используемые данные можно скопировать в удобный, упакованный массив структур, содержащий только часто используемые элементы. Это позволит часто исполняемым циклам программы генерировать минимальный трафик по шине при выполнении. Более агрессивная оптимизация включила бы «разворачивание» формата данных по 2, в случае чисел с плавающей запятой двойной точности, или по 4, если все данные – целые (int) или с плавающей запятой одинарной точности (float). Это откроет путь для чрезвычайно эффективного использования набора инструкций Intel Streaming SIMD Extension 3 (SSE3), так как инструкции упаковки данных в этом случае не потребуются. Возможно даже было бы неплохо добавить несколько элементов-пустышек в конце массива, чтобы гарантировать размер массива равный четному множителю 2 или 4.
Может оказаться, что лучше использовать структуры массивов, а не массивы структур, если доминирующим шаблоном доступа является последовательный доступ по массиву списку, поскольку это гарантирует, что все байты кэш-линий будут использованы.
#### Выгрузка мимо КЭШа
Компиляторы избегают генерировать инструкции потоковой выгрузки мимо КЭШа в случаях, когда количество итераций цикла присваивания данных неизвестно. Например, в простой функции TRIAD, представленной ниже, значение len не известно на момент трансляции.
```
double TRIAD(int len, double a1, double * a, double *b, double*c, double*d){
int i;
for(i=0; i
```
Большинство трансляторов будет использовать обычные инструкции выгрузки или упакованные инструкции выгрузки SSE для массива «a». Это вызовет запрос на монопольное использование кэш-линии, что удваивает полосу пропускания, необходимую для этого массива. Если же массив не требуется немедленно или слишком велик, чтобы поместиться в КЭШе целиком, то трафик можно сократить вдвое. В примере выше, если количество итераций “len” умноженное на 8, больше чем размер КЭШа последнего уровня (LLC), деленный на 3, то первая кэш-линия для массива «a» будет выгружена из КЭШа еще до окончания цикла. Чтобы гарантировать, что компилятор Intel сгенерирует оптимальный код для большого количества итераций, нужно выровнять массивы по 16 байт и затем изменить цикл, добавив две директивы pragma сразу перед ним.
```
#pragm vector aligned
#pragma vector nontemporal
for(i=0; i
```
Также очень важна чрезмерная предварительная выборка кэш-линий. Плохо закодированные программные предвыборки могут усилить трафик по шине. Убедитесь, что вы не делаете предвыборку кэш-линий, которые потом не будут использоваться. Интервал предвыборки также должен быть достаточно большим, чтобы фактически загрузить строку в кэш до ее использования. Команды загрузки, которые ссылаются на кэш-линии все еще подгружаемые программной предвыборкой, инкрементируют счетчик события LOAD\_HIT\_PRE. Таким образом, это весьма просто обнаружить.
В ядре процессоров Intel Core 2 есть 4 аппаратных блока предвыборки. Два для работы с кэшем второго уровня (L2) способом, аналогичным ранее виденным в процессорах Pentium 4. Еще 2 дополнительных аппаратных блока предвыборки, работают с кэшем данных первого уровня (L1): это блок потоковой предвыборки и блок предвыборки, который ищет шаговые шаблоны, связанные с определенными адресами инструкций (IP). Как правило, в системе включены два блока предвыборки для КЭШа L2 и блок предвыборки IP L1D, но не блок потоковой предвыборки L1D. В целях анализа может быть полезно отключить эти блоки. Обычно это можно сделать в настройках параметров BIOS, в подразделе «cpu options» (опции процессора). Искать следует по ключевым словам «prefetch» и «adjency» – обычно эти пункты и надо менять.
Чтобы определить, какие аппаратные блоки предвыборки включены, можно использовать события производительности. Событие L2\_LD.SELF.PREFETCH считает кэш-линии загруженные в КЭШ L2, блоком предвыборки L2. Появление события L1D\_PREFETCH.REQUESTS говорит о включенных блоках предвыборки КЭШа данных L1.
Чтобы определить число неиспользуемых кэш-линий, запрашиваемых аппаратным блоком предвыборки, запустите программу 2 раза, с включенными и с выключенными блоками предвыборки. Измерьте общее количество кэш-линий, которые переданы с событием BUS\_TRANS\_BURST.SELF. Если есть существенное различие между этими двумя значениями, используйте VTune Analyzer, чтобы точно определить где это происходит в исходном коде. Частые причины тому:
1. вложенные циклы с малым количествами итераций и большими шагами во внешних циклах;
2. вложенные циклы с противоположными направлениями движения по данным (внешний цикл идет вперед с большим шагом, внутренний цикл идет назад с маленьким шагом).
Аппаратная предвыборка обычно управляется внутренним циклом, таким образом, в первом случае предварительно загруженные строки будут за пределом адресации внутреннего цикла, и не будут использоваться следующей итерацией внешнего цикла. Во втором случае блок предвыборки может попытаться загрузить уже использованные строки, то есть будет абсолютно бесполезен. Эта ситуация очень распространена в итерационных решателях и в большинстве случаев может быть исправлена простым изменением направления внутреннего цикла и некоторых требуемых указателей. В обоих случаях, вероятно, будет потребляться множество кэш-линий, запрашиваемых инструкциями загрузки и выгрузки. Это можно проверить с помощью события MEM\_LOAD\_RETIRED.L2\_LINE\_MISS, считающего только загрузки, и события L2\_LD.SELF.DEMAND, считающее и загрузки и выгрузки в кэш-линии, включая также запросы, сделанные блоками предвыборки L1.
Разбиение данных на блоки — стандартное решение при недостатке пропускной способности, оно обычно предлагается без какого-либо намека на то, как же его фактически реализовать. Легче сказать, чем сделать. Однако, есть некоторая зависимость между декомпозицией данных и разбиением на блоки, и этим можно воспользоваться в некоторых случаях. Декомпозицию данных можно выполнить таким образом, чтобы получилось два уровня иерархии. Внешний уровень предполагает разбиение «один набор данных на ядро», и в тоже время на один процесс или поток, в зависимости от применяемой декомпозиции процесса счета, openmp это, явная организация поточной обработки или MPI, например. «Набор данных на ядро» можно делить дальше, согласно той же стратегии, подразделяя на “виртуальных узлы”, чей размер определяется размером КЭШа последнего уровня. Эту стратегию следует рассматривать на ранних этапах проектирования алгоритма, поскольку она может значительно увеличить возможности масштабирования.
#### Чрезмерная загруженность дисковой подсистемы
Чрезмерная загруженность совместно используемого диска для программы означает, что время, проводимое программой в ожидании доступа к дисковой подсистеме, с числом используемых ядер начинает преобладать во времени исполнения самого приложения. Это легко заметить в режиме просмотра модулей в VTune Performance Analyzer, просто сравнивая, какая часть времени исполнения проходит в дисковом драйвере с увеличением числа ядер. Для хорошо масштабирующегося приложения (фиксированный или линейно увеличивающийся объем работы) эта часть должна быть постоянной. Конечно, на это стоит обращать внимание, только если (возросшее) время доступа к диску существенно.
Вариации в поведении означают, что несколько компонент мешают друг другу при доступе к диску. Это может случиться, например, из-за различных операций, вызывающих ошибочные движения дисковых головок, что мешает последовательному доступу, являющемуся самым эффективным.
В случаях, где доступ к диску не фиксирован, почти всегда лучше организовывать его очередность во времени, оставляя остальные ядра занятыми другими делами. Таким образом, разбросав фазы доступа к диску для отдельных потоков или процессов можно избежать чрезмерную загруженность дисковой подсистемы. | https://habr.com/ru/post/107621/ | null | ru | null |
# Лучший Pull Request
Относительно недавно мне посчастливилось присоединиться к команде разработки Bitbucket Server в Atlassian (до сентября [он был известен как Stash](https://confluence.atlassian.com/display/BitbucketServer/Bitbucket+rebrand+FAQ "en: Bitbucket rebrand FAQ")). В какой-то момент мне стало любопытно, как этот продукт освещён на Хабре, и к моему удивлению, нашлось лишь несколько заметок о нём, подавляющее большинство которых на сегодняшний день уже устарело.
В связи с этим я решил опробовать себя в роли рассказчика и затронуть техническую сторону Bitbucket. Прошу не рассматривать моё намерение как попытку рекламы, ибо я совершенно не преследую эту цель. Если эта статья обнаружит интерес со стороны читателей, я буду рад развивать тему и постараюсь ответить на возникающие вопросы.
Позвольте начать с перевода статьи Тима Петтерсена [«A better pull request»](https://developer.atlassian.com/blog/2015/01/a-better-pull-request/) о том, как должен выглядеть pull request, чтобы наиболее эффективно решать возложенную на него задачу.
**Небольшое отступление по поводу терминов**В любой русскоязычной технической статье, касающейся систем контроля версий (как, впрочем, большинства любых связанных с IT тем), автор сталкивается с необходимостью использования специфичных терминов, которые могут быть или не быть переведены на русский. В жизни большинство этих терминов не переводится и используется при вербальном общении «как есть», то есть, по сути, транслитерируется. В письменной же форме их, строго говоря, следует переводить, однако в этом случае термины зачастую совершенно перестают быть созвучными англоязычным версиям, что сильно затрудняет их восприятие читателями.
Мне хотелось бы пользоваться привычными названиями и в письменной речи, однако некоторые термины я не буду даже транслитерировать, поскольку, на мой взгляд, они становятся слишком корявыми, и потому оставлю их в английском написании, — прошу понять и простить. С другой стороны, я открыт критике и предложениям, поэтому если вы считаете, что есть лучший способ выразить тот или иной термин, прошу делиться этими мыслями. Спасибо.
---
Если вы используете Git, то наверняка пользуетесь и pull request-ами. Они в той или иной форме существуют с момента появления распределённых систем управления версиями. До того, как Bitbucket и GitHub предложили удобный веб-интерфейс, pull request мог представлять собой простое письмо от Алисы с просьбой забрать какие-то изменения из её репозитория. Если они были стóящими, вы могли выполнить несколько команд, чтобы влить эти изменения в вашу основную ветку *master*:
```
$ git remote add alice git://bitbucket.org/alice/bleak.git
$ git checkout master
$ git pull alice master
```
Разумеется, включать изменения от Алисы в *master* не глядя — это далеко не лучшая идея: ведь *master* содержит код, который вы собираетесь поставлять клиентам, а потому наверняка хотите внимательно следить за тем, что в него попадает. Более правильный путь, чем простое включение изменений в *master*, — это сначала влить их в отдельную ветку и проанализировать перед тем, как cливать в *master*:
```
$ git fetch alice
$ git diff master...alice/master
```
Приведённая команда [**git diff** с синтаксисом трёх точек](https://git-scm.com/docs/git-diff) (в дальнейшем **«triple dot» git diff**) покажет изменения между вершиной ветки **alice/branch** и её **merge base** — общим предком с локальной веткой *master*, иначе говоря, с точкой расхождения истории коммитов этих веток. В сущности, это будут ровно те изменения, которые Алиса просит нас включить в основную ветку.
**git diff master...alice/master** эквивалентен **git diff A B**
На первый взгляд, это кажется разумным способом проверки изменений pull request-а. Действительно, на момент написания статьи, именно такой алгоритм сравнения применяется в реализации pull request-ов в большинстве инструментов, предоставляющих хостинг git-репозиториев.
Несмотря на это, есть несколько проблем в использовании **«triple dot» git diff** для анализа изменений pull request-а. В реальном проекте основная ветка, скорее всего, будет сильно отличаться от любой ветки функциональности (в дальнейшем *feature-ветка*). Работа над задачами ведётся в отдельных ветках, которые по окончании вливаются в *master*. Когда *master* продвигается вперёд, простой **git diff** от вершины *feature-ветки* до её *merge base* уже недостаточен для отображения настоящего различия между этими ветками: он покажет разницу вершины *feature-ветки* лишь с одним из предыдущих состояний *master*.
Ветка *master* продвигается за счёт вливания новых изменений. Результат **git diff master...alice/master** не отражает этих изменений *master*.
Почему же невозможность увидеть эти изменения в ходе анализа pull request-а является проблемой? Тому есть две причины.
### Конфликты слияния (merge conflicts)
С первой проблемой вы наверняка регулярно сталкиваетесь — конфликты слияния. Если в вашей *feature-ветке* вы измените файл, который в то же время был изменён в *master*, **git diff** по-прежнему будет отображать только изменения, сделанные вами в *feature-ветке*. Однако при попытке выполнить **git merge** вы столкнётесь с ошибкой: git расставит маркеры конфликтов в файлах вашей рабочей копии, поскольку сливаемые ветки имеют противоречивые изменения, — такие, которые git не в состоянии разрешить даже с помощью продвинутых стратегий слияния.
Конфликт слияния
Вряд ли кому-то нравится заниматься разрешением конфликтов слияния, но они являются данностью любой системы контроля версий, — по крайней мере, из тех, которые не поддерживают блокирование на уровне файла (которое, в свою очередь, имеет ряд своих проблем).
Однако конфликты слияния — это меньшая неприятность, с которой вы можете столкнуться при использовании **«triple dot» git diff** для pull request-ов, по сравнению с другой проблемой: особый тип *логического конфликта* будет успешно слит, но сможет внести коварную ошибку в кодовую базу.
### Логические конфликты, остающиеся незамеченными во время слияния
Если разработчики модифицируют разные части одного и того же файла в разных ветках, появляется вероятность того, что они создадут такой конфликт. В некоторых случаях разные изменения, которые исправно работают по отдельности и отлично сливаются безо всяких конфликтов с точки зрения системы контроля версий, могут внести логическую ошибку в код, будучи применёнными вместе.
Это может произойти различными путями, однако самым распространённым является вариант, когда два разработчика случайно замечают и исправляют одну и ту же ошибку в двух разных ветках. Представьте, что приведённый ниже код на javascript вычисляет стоимость авиабилета:
```
// flat fees and taxes
var customsFee = 5.5;
var immigrationFee = 7;
var federalTransportTax = .025;
function calculateAirfare(baseFare) {
var fare = baseFare;
fare += immigrationFee;
fare *= (1 + federalTransportTax);
return fare;
}
```
Здесь содержится очевидная ошибка: автор забыл включить в расчёт таможенный сбор!
Теперь представьте двух разработчиков, Алису и Боба, каждый из которых заметил эту ошибку и исправил её независимо от другого в своей ветке.
Алиса добавила строку для учёта **customsFee** перед **immigrationFee**:
```
function calculateAirfare(baseFare) {
var fare = baseFare;
+++ fare += customsFee; // Fixed it! Phew. Glad we didn't ship that! - Alice
fare += immigrationFee;
fare *= (1 + federalTransportTax);
return fare;
}
```
Боб сделал аналогичную правку, однако поместил её после **immigrationFee**:
```
function calculateAirfare(baseFare) {
var fare = baseFare;
fare += immigrationFee;
+++ fare += customsFee; // Fixed it! Gee, lucky I caught that one. - Bob
fare *= (1 + federalTransportTax);
return fare;
}
```
Поскольку в каждой из этих веток были изменены разные строки кода, слияние обеих с *master* пройдёт успешно одно за другим. Однако теперь *master* будет содержать обе добавленные строки, а значит, клиенты будут дважды платить таможенный сбор:
```
function calculateAirfare(baseFare) {
var fare = baseFare;
fare += customsFee; // Fixed it! Phew. Glad we didn't ship that! - Alice
fare += immigrationFee;
fare += customsFee; // Fixed it! Gee, lucky I caught that one. - Bob
fare *= (1 + federalTransportTax);
return fare;
}
```
(Это, разумеется, надуманный пример, однако дублированный код или логика могут вызвать весьма серьёзные проблемы: к примеру, [дыру в реализации SSL/TLS в iOS](https://www.imperialviolet.org/2014/02/22/applebug.html).)
Предположим, что вы сначала слили в *master* изменения pull request-а Алисы. Вот что показал бы pull request Боба, если бы вы использовали **«triple dot» git diff**:
```
function calculateAirfare(baseFare) {
var fare = baseFare;
fare += immigrationFee;
+++ fare += customsFee; // Fixed it! Gee, lucky I caught that one. - Bob
fare *= (1 + federalTransportTax);
return fare;
}
```
Поскольку вы анализируете изменения по сравнению с общим предком, нет никакого предупреждения об угрозе ошибки, которая случится, когда вы нажмёте на кнопку слияния.
На самом же деле, при анализе pull request-а вы хотели бы видеть, как *master* изменится после слияния изменений из ветки Боба:
```
function calculateAirfare(baseFare) {
var fare = baseFare;
fare += customsFee; // Fixed it! Phew. Glad we didn't ship that! - Alice
fare += immigrationFee;
+++ fare += customsFee; // Fixed it! Gee, lucky I caught that one. - Bob
fare *= (1 + federalTransportTax);
return fare;
}
```
Здесь явно обозначена проблема. Рецензент pull request-а, будем надеяться, заметит дублированную строчку и уведомит Боба о том, что код нужно доработать, и тем самым предотвратит попадание серьёзной ошибки в *master* и, в конечном счёте, в готовый продукт.
Таким образом мы решили реализовать показ изменений в pull request-ах в Bitbucket. При просмотре pull request-а вы видите, как на самом деле будет выглядеть результат слияния (т.е. фактически, результирующий коммит). Чтобы осуществить это, мы производим настоящее слияние веток и показываем разницу между получившимся коммитом и верхушкой целевой ветки pull request-а:
**git diff C D**, где **D** — это коммит, получившийся в результате слияния, показывает все различия между двумя ветками
Если вам интересно, я разместил одинаковый репозиторий на нескольких хостингах, чтобы вы сами смогли увидеть описанную разницу между алгоритмами сравнения:
* Pull request на [GitHub со сравнением **«triple dot» git diff**](https://github.com/kannonboy/abpr/pull/2/files)
* Pull request на [GitLab со сравнением **«triple dot» git diff**](https://gitlab.com/kannonboy/abpr/merge_requests/2/diffs)
* Pull request на [Bitbucket со сравнением, использующим **коммит слияния**](https://bitbucket.org/tpettersen/abpr/pull-request/2/fixed-a-bug-that-would-charge-2x/diff)
Сравнение на основе коммита слияния, используемое в Bitbucket, показывает фактические изменения, которые будут применены, когда вы выполните слияние. Загвоздка в том, что этот алгоритм сложнее в реализации и требует значительно больше ресурсов для выполнения.
### Продвижение веток
Во-первых, коммит слияния **D** на самом деле ещё не существует, а его создание — относительно дорогой процесс. Во-вторых, недостаточно просто создать коммит **D** и на этом закончить: **B** и **C**, родительские коммиты для нашего коммита слияния, могут поменяться в любое время. Мы называем изменение любого из родительских коммитов *пересмотром* (rescope) pull request-а, поскольку оно, по сути, модифицирует тот набор изменений, который будет применён в результате слияния pull request-а. Если ваш pull request нацелен на нагруженную ветку вроде *master*, он наверняка пересматривается очень часто.
Коммиты слияния создаются каждый раз, когда любая из веток pull request-а изменяется
Фактически, каждый раз когда кто-то коммитит или сливает pull request в *master* или *feature-ветку*, Bitbucket должен создать новый коммит слияния, чтобы показать актуальную разницу между ветками в pull request-е.
### Обработка конфликтов слияния
Другая проблема при выполнении слияния для отображения разницы меджу ветками в pull request-е заключается в том, что время от времени вам придётся иметь дело с конфликтами слияния. Поскольку git сервер работает в неинтерактивном режиме, разрешать такие конфликты будет некому. Это ещё больше усложняет задачу, но на деле оказывается преимуществом. В Bitbucket мы действительно включаем маркеры конфликтов в коммит слияния **D**, а затем помечаем их при отображении разницы между ветками, чтобы явно указать вам на то, что pull request содержит конфликты:
Зелёные строки добавлены, красные — удалены, а жёлтые означают конфликт
Таким образом, мы не только заранее выявляем, что pull request содержит конфликт, но и позволяем рецензентам обсудить, как именно он должен быть разрешён. Поскольку конфликт всегда затрагивает, как минимум, две стороны, мы считаем, что pull request — это лучшее место для нахождения подходящего способа его разрешения.
Несмотря на дополнительную сложность реализации и ресурсоёмкость используемого подхода, я считаю, что выбранный нами в Bitbucket подход предоставляет наиболее точную и практичную разницу между ветками pull request-а.
---
Автор оригинальной статьи — Тим Петтерсен, участвовал в разработке JIRA, FishEye/Crucible и Stash. С начала 2013 года он рассказывает о процессах разработки, git, непрерывной интеграции и поставке (continuous integration/deployment) и инструментах Atlassian для разработчиков, особенно о Bitbucket. Тим регулярно публикует заметки об этих и других вещах в Twitter под псевдонимом [@kannonboy](https://twitter.com/kannonboy).
Надеюсь, что эта статья оказалась интересной. Буду рад ответить на вопросы и комментарии. | https://habr.com/ru/post/272531/ | null | ru | null |
# Nokia N900. Продолжаем разбираться или «Hack your Nokia N900»
Добрый день уважаемый читатель. Продолжаю свой цикл статей о Nokia N900. [Вот](http://habrahabr.ru/blogs/nokia/88129/), [вот](http://habrahabr.ru/blogs/nokia/85393/) и [вот](http://habrahabr.ru/blogs/nokia/82319/) — предыдущие мои публикации.
Сегодня продолжим изучение аппарата, и сегодняшняя тема — это хак. Мы будем лезть в разные штуки и менять разные вещи, которые не предусмотрены для изменения разработчиками. Это делается очень легко и подвластно даже обычному пользователю, если у него будет желание. Я не буду рассказывать как пропатчить ядро или увести аппарат в высокопроизводительный режим, просто покажу несколько полезный улучшений, которые могут пригодиться каждому.
Предупреждение: автор не несет ответственности за причиненные повреждения вашему аппарату в процессе следования данным инструкциям. Вы все делаете на свой страх и риск.
Надеюсь не очень напугал? Могу сказать, что убить аппарат до такого состояния, что Вы не сможете его восстановить — практически нереально(но возможно!!! я знаю один случай). Но даже если у Вас получиться, то 99% сервисный центр Вам поможет. Но главное правило — будьте осторожны и читайте сначала, а потом делайте, и делайте аккуратно и обращайте пристальное внимание на последовательность действий, а главное на то, что выделено красным цветом (не зря же я это выделял).
### Разбираем и собираем N900.
На заглавной страничке отображен процесс разобранного N900. Есть официальный сервисное руководство. Но на публичном доступе оно не доступно. Раздается сервисным центрам, на сколько я знаю. Но в сети валяются экземпляры и вы можете их найти при желании: ключевые слова Nokia, Service Manual RX-51. Выложить я не имею права это — противоречит копирайту:
> Reproduction, transfer, distribution or storage of part or all of the contents in this document in
>
> any form without the prior written permission of Nokia is prohibited.
>
>
Переводится приблизительно так: копирование, передача, распространение и хранение частей или всего содержимого этого документа в любой форме без предварительного согласия компании Nokia ЗАПРЕЩЕНО.
Картинку я взял не с этого документа, а [вот отсюда](http://maemocentral.com/2009/11/30/download-the-n900-service-manual-see-the-n900-get-disassembled/), достаточно популярный и распространенный ресурс, и лично от них я получил разрешение на перепубликацию (они уверяют, что обладают правами публикации этого изображения и имеют право разрешить перепубликовать). Но при первом же обращении с указанием на неправомерность распространение данной информации от представителей компании Nokia я уберу эту картинку.
Ну так вот в этом документе все описано с картинками и от разборки других аппаратов особенно не отличается.
Прошу свои извинения за то что не могу выложить документ, а собственную инструкцию сделать не могу, уж очень свой аппарат жалко для этого разбирать :-).
### Перепрошивка N900.
В предыдущих публикациях я описывал много интересных приложений и многие из них находятся в репозиториях extra-testing и даже extra-devel. Это значит что эти приложения не только не гарантируют, что работать будут стабильно, они еще не гарантируют что они не поломают Вам телефон :-) Плюс к этому некоторые инструкции их этой публикации могут сделать из вашего N900 кирпич. Поэтому я сначала решил показать как восстановить аппарат в таком случае.
В качестве дополнительного материала на русском языке можете посмотреть [перевод Maemo.org Wiki на Fruct](http://wiki.fruct.org/index.php?title=%D0%9F%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0_Flasher_3.5).
Nokia в этом плане молодцы и перепрошить N900 можно на любой ОС (имею ввиду большую тройку Linux/MacOS/Windows, а не действительно все ОС :-) ).
Что нам нужно:
1. Инструмент для прошивки — flasher.
[качаем тут](http://tablets-dev.nokia.com/maemo-dev-env-downloads.php).
вот такие файлики нас там интересуют (версии могут отличаться, так как могут появиться следующие версии, но названия должны остаться теми-же либо похожими):
maemo\_flasher-3.5\_2.5.2.2.exe — версия для Windows 7, XP, Vista.
maemo\_flasher-3.5\_2.5.2.2.tar.gz — версия для Линукса.
maemo\_flasher-3.5\_2.5.2.2\_i386.deb — версия для Debian семейств линуксов.
maemo\_flasher-3.5\_2.5.2.2\_i386.dmg — версия для Intel Mac OS.
maemo\_flasher-3.5\_2.5.2.2\_ppc.dmg — версия для PPC Mac OS.
2. Качаем отсюда образ образ корневой системы и, если нужно, образ eMMC(это та память, которая 32 ГБ).
[tablets-dev.nokia.com/nokia\_N900.php](http://tablets-dev.nokia.com/nokia_N900.php)">Качаем по этой ссылке.
Там нужно ввести IMEI.
Он находится под батарейкой или в «Параметры»->«О продукте». Там в всплывающем окне последняя строчка.
Также можно его разобыть, если ввести на клавиатуре телефона \*#06#.
Потом принимаем лицензионное соглашение, нажав кнопку «I accept».
Нас интересует вот этот файл: RX-51\_2009SE\_3.2010.02-8\_PR\_COMBINED\_MR0\_ARM.bin или более поздний, если будет (выбирайте регион «Европа», так как Африка и Штаты не подходят, за исключением случаев, если телефон у вас был куплен именно там).
И вот этот RX-51\_2009SE\_1.2009.41-1.VANILLA\_PR\_EMMC\_MR0\_ARM.bin, если вы надумали перепрошить eMMC.
Еще, на продаваемом аппарате предзалиты карты того региона в котором он продается, а в этом образе никаких карт нет, но это не страшно, можно восмользоваться Map Loader'ом, для устранения этой неприятности. Зачем это может понадобиться я расскажу ниже, но если вы не знаете, нужно ли вам это, то значит не нужно.
##### Замечания по установке flasher на Linux.
Если у вас 64-разрядный Debian линукс и вы ставите из deb файла, то нужно выполнить вот такую команду в директории, куда вы сохранили пакет
> sudo dpkg -i --force-architecture ./maemo\_flasher-3.5\_2.5.2.2\_i386.deb
>
>
##### Замечания по установке flasher на Mac OS.
Тут ничего делать не нужно, единственное, что нужно знать, так это то, что flasher можно найти в /usr/bin.
##### Замечания по установке flasher на Windows.
Пакет по умолчанию поставиться в %Program Files%/maemo/.
В Windows 7 необходимо отключить проверку подписи драйверов. Сделать это просто.
Заходим в меню «Пуск» и выбираем программу cmd. По ней правой клавишей и «Запустить от Администратора».
В окне интерпретатора вводим такие вот команды:
> bcdedit.exe -set loadoptions DDISABLE\_INTEGRITY\_CHECKS
>
> bcdedit.exe -set TESTSIGNING ON
>
>
В результате должно появиться что-то типа такого:
Немного про прошивку eMMC. Это флэш образ, в дереве каталогов он находится в /home/user/MyDocs. Перепрошивка может потребоваться только в том случае, если вы хотите получить девственно чистый аппарат или у вас девелоперская версия телефона. Если нужно просто перепрошить кирпич, то не нужно прошивать eMMC!!!
Все делается с консоли и абсолютно одинаково работает на всех вышеуказанных ОС. Единственная проблема может возникнуть с Windows 7. Но я об этом напишу чуть ниже.
Предупреждение: Зарядите телефон полностью, будет очень плохо, если батарея сядет во время прошивки. Во время прошивки аппарат не заряжается по USB!!!
Итак, мы все скачали, установили утилиту flasher. Запускаем консоль (под виндой — командный интерпретатор cmd, но я его все равно буду называть консолью :-)).
И в консоли пишем такие вот слова:
> Windows:
>
> cd "%ProgramFiles%\maemo\flasher-3.5"
>
> flasher-3.5.exe -F RX-51\_2009SE\_3.2010.02-8\_PR\_COMBINED\_MR0\_ARM.bin -f -R
>
>
>
> Linux:
>
> sudo flasher-3.5 -F RX-51\_2009SE\_3.2010.02-8\_PR\_COMBINED\_MR0\_ARM.bin -f -R
>
>
>
> MacOS:
>
> sudo /usr/bin/flasher-3.5 -F RX-51\_2009SE\_3.2010.02-8\_PR\_COMBINED\_MR0\_ARM.bin -f -R
>
>
В результате получим вот такую надпись:
> Suitable USB device not found, waiting
>
>
0. Если Вы собираетесь перепрошить eMMC, то заблаговременно отсоедините заднюю крышку и подденьте чем-нибудь батарейку (только не переусердствуйте, чтоб она не выпала во время перепрошивки ).
1.Если устройство подключено по USB, то отключите его.
2. Выключите его (при выключении с подключенным USB аппарат полностью не выключается, так что следуйте шагу номер 1).
3. Зажимаем кнопку «u» на клавиатуре и подключите USB шнур.
4. Должен появиться логотип Nokia (иногда на очень блеклом фоне, с очень слабой подсветкой, реже на ярком белом фоне) и в правом углу верхнем значек USB.
Если Вы все сделали правильно то пойдут бежать надписи, сообщающие о различных этапах прошивки.
Устройство уйдет в перезагружку. На это перепрошивка закончена. Просто все, не правда ли?
Если вы собираетесь прошивать eMMC, то в этот момент нужно выдернуть батарейку, предотвратив загрузку ОС.
Прошивать eMMC можно только после прошивки rootfs и НИ В КОЕМ СЛУЧАЕ НЕЛЬЗЯ ПЕРЕГРУЖАТЬСЯ МЕЖДУ ПРОШИВКОЙ ROOTFS И EMMC ОБРАЗА !!!!.
Теперь для желающих прошить eMMC.
и выполняем те-же команды, что и выше, только шьем уже другой образ:
> Windows:
>
> cd "%ProgramFiles%\maemo\flasher-3.5"
>
> flasher-3.5.exe -F RX-51\_2009SE\_1.2009.41-1.VANILLA\_PR\_EMMC\_MR0\_ARM.bin -f -R
>
>
>
> Linux:
>
> sudo flasher-3.5 -F RX-51\_2009SE\_1.2009.41-1.VANILLA\_PR\_EMMC\_MR0\_ARM.bin -f -R
>
>
>
> MacOS:
>
> sudo /usr/bin/flasher-3.5 -F RX-51\_2009SE\_1.2009.41-1.VANILLA\_PR\_EMMC\_MR0\_ARM.bin -f -R
>
>
Появиться опять надпись об отсутсвующем устройстве:
> flasher v2.5.2 (Oct 21 2009)
>
>
>
> Image 'mmc', size 241163 kB
>
> Version RX-51\_2009SE\_1.2009.41-1.VANILLA
>
> Suitable USB device not found, waiting.
>
>
Вставляем USB кабель в устройство и ждем пока пройдет процесс.
Вставляем назад батарейку и просто подключаем USB без кнопки «u».
Выглядеть он будет вот таким образом:
> USB device found found at bus 001, device address 006.
>
> Found device RX-51, hardware revision 2101
>
> NOLO version 1.4.13
>
> Version of 'sw-release': RX-51\_2009SE\_1.2009.42-11.002\_PR\_002
>
> Booting device into flash mode.
>
> Suitable USB device not found, waiting.
>
> USB device found found at bus 001, device address 007.
>
> Raw data transfer EP found at EP2.
>
> [writing 74 % 179200 / 241163 kB 13180 kB/s]
>
> Image(s) flashed successfully in 26.848 s (8982 kB/s)!
>
>
У меня процесс занял чуть меньше минуты. После этого устройство уйдет в перезагрузку. Все готово.
##### Проблемы и пути их решения.
Если у вас сообщение на \*nix'ах «Permission denied» (если вы взяли flasher из tar.gz), тогда сделайте так
> chmod +x ./flasher-3.5
>
>
Если в \*nix'ах у вас появилось сообщение «Error claiming USB interface: Device or resource busy», тогда выполните команду
> sudo modprobe -r cdc\_phonet
>
>
Flasher не может найти устройство, тогда проделайте следующее:
* выключите N900
* выньте батарейку
* запустите flasher
* подключите USB шнурок
* вставьте батарейку
В общем с прошивкой разобрались, процесс легкий и безгеморойный (по крайней мере я не встретил трудностей под MacOS 10.6, Linux Ubuntu 9.10 и Windows XP).
### Тюним раскладку клавиатуры.
Зачем это может понадобиться?
1. Если вам не нравиться текущая раскладка (например вы пишете на Python'e на устройстве и Вас раздражает отсутствие "=" на клавиатуре, приходится каждый раз вызывать таблицу дополнительных символов) или хотите добавить пару символов.
2. Если у вас «серый» телефон и «синенькие» символы не совпадают с символами в русской раскладке, плюс в буржуйских версиях 4 стрелочки, а в русской 2. Из-за этого начинается конфуз. Я купил серый аппарат именно по той причине, что английские буквы больше гравированных русских и это очень и очень удобно. Но столкнулся с проблемой несоответствия дополнительных символов. Начиная от точки с запятой и заканчивая знаком доллара и скобок.
Вот так выглядит русская клавиатура:
А вот так выглядит гравированная буржуйская:
Как видите не совпадает.
Ну решение оказалось копеешным.
Все что нужно, это поменять раскладку. В N900 применяется стандартное X-расширение xkb. Файл с настройкой раскладок можно найти: /usr/share/X11/xkb/symbols/nokia\_vndr/rx-51
Подробно о формате файла и настройках xkb можно посмотреть [тут](http://hektor.umcs.lublin.pl/~mikosmul/computing/articles/custom-keyboard-layouts-xkb.html), [тут](http://pascal.tsu.ru/en/xkb/gram-symbols.html) и [тут](http://www.charvolant.org/~doug/xkb/).
Там очень много букв, так что опишу тут не очень подробно, но достаточно, чтоб можно было менять на свое усмотрение.
Итак, если открыть этот файл, то он большой, чтоб его перепечатывать. Расскажу об основных частях.
За основу любой раскладки взята английская — базовая, вот так выглядит эта секция:
> `1. partial hidden alphanumeric\_keys
> 2. xkb\_symbols "english\_base" {
> 3.
> 4. // 1. row
> 5. key { [ q, Q, 1, 1 ] };
> 6. key { [ w, W, 2, 2 ] };
> 7. key { [ e, E, 3, 3 ] };
> 8. key { [ r, R, 4, 4 ] };
> 9. key { [ t, T, 5, 5 ] };
> 10. key { [ y, Y, 6, 6 ] };
> 11. key { [ u, U, 7, 7 ] };
> 12. key { [ i, I, 8, 8 ] };
> 13. key { [ o, O, 9, 9 ] };
> 14. key { [ p, P, 0, 0 ] };
> 15. key { [ comma, semicolon, equal, equal ] };
> 16.
> 17. // 2. row
> 18. key { [ a, A, asterisk, asterisk ] };
> 19. key { [ s, S, plus, plus ] };
> 20. key { [ d, D, numbersign, numbersign ] };
> 21. key { [ f, F, minus, minus ] };
> 22. key { [ g, G, underscore, underscore ] };
> 23. key { [ h, H, parenleft, parenleft ] };
> 24. key { [ j, J, parenright, parenright ] };
> 25. key { [ k, K, ampersand, ampersand ] };
> 26. key { [ l, L, exclam, exclam ] };
> 27. key { [ period, colon, question, question ] };
> 28.
> 29. // 3. row
> 30. key { [ z, Z, sterling, sterling ] };
> 31. key { [ x, X, dollar, dollar ] };
> 32. key { [ c, C, EuroSign, EuroSign ] };
> 33. key { [ v, V, slash, slash ] };
> 34. key { [ b, B, backslash, backslash ] };
> 35. key { [ n, N, quotedbl, quotedbl ] };
> 36. key { [ m, M, apostrophe, apostrophe ] };
> 37. key { [ space, space, at, at ] };
> 38. };
> \* This source code was highlighted with Source Code Highlighter.`
Тут используется 4 уровня. Каждая запись — это символ, комментариями они отделены на ряды на клавиатуре. В данной раскладке используется 4 уровня (4 разных значения можно получить с помощью одной кнопки). Итак как переключаются эти уровни:
**Shift(на клавиатуре стрелка вверх)** — увеличивает на один уровень в любом случае. Нужно либо держать, либо нажать один раз и любая следующая клавиша увеличит значение при нажатии на уровень, либо два раза нажать — получится Caps Lock режим, то есть все последующие нажатия кнопок будут увеличены на один уровень.
**Fn(синяя стрелка на клавиатуре)** — увеличивает на два уровня вверх. В комбинации с Shift увеличивает на три уровня вверх.
Итак получаем, чтоб получить из таблицы символов нужный символ, согласно таблице, для примера возьмем первую кнопку:
> `1. key { [ q, Q, 1, 1 ] };
> \* This source code was highlighted with Source Code Highlighter.`
* чтоб получить **первый** уровень, то есть символ **«q»** — нужно просто нажать кнопку
* чтоб получить **второй** уровень, то есть символ **«Q»** — нужно нажать Shift и кнопку
* чтоб получить **третий** уровень, то есть символ **«1»** — нужно нажать Fn и кнопку
* чтоб получить **четвертый** уровень, то есть символ **«1»** — нужно нажать Shift, Fn и кнопку
«А как-же переключение раскладки?» — спросите Вы. А все просто. Давайте посмотрим на секцию с русской раскладкой:
> `1. partial alphanumeric\_keys
> 2. xkb\_symbols "ru" {
> 3. include "nokia\_vndr/rx-51(english\_base)"
> 4. include "nokia\_vndr/rx-51(arrows\_2btns)"
> 5.
> 6. name[Group1] = "Russian";
> 7.
> 8. key.type[Group1] = "EIGHT\_LEVEL\_SEMIALPHABETIC";
> 9.
> 10. // 1. row
> 11. key { [ q, Q, 1, 1, Cyrillic\_shorti, Cyrillic\_SHORTI, 1, 1 ] };
> 12. key { [ w, W, 2, 2, Cyrillic\_tse, Cyrillic\_TSE, 2, 2 ] };
> 13. key { [ e, E, 3, 3, Cyrillic\_u, Cyrillic\_U, 3, 3 ] };
> 14. key { [ r, R, 4, 4, Cyrillic\_ka, Cyrillic\_KA, 4, 4 ] };
> 15. key { [ t, T, 5, 5, Cyrillic\_ie, Cyrillic\_IE, 5, 5 ] };
> 16. key { [ y, Y, 6, 6, Cyrillic\_en, Cyrillic\_EN, 6, 6 ] };
> 17. key { [ u, U, 7, 7, Cyrillic\_ghe, Cyrillic\_GHE, 7, 7 ] };
> 18. key { [ i, I, 8, 8, Cyrillic\_sha, Cyrillic\_SHA, 8, 8 ] };
> 19. key { [ o, O, 9, 9, Cyrillic\_shcha, Cyrillic\_SHCHA, 9, 9 ] };
> 20. key { [ p, P, 0, 0, Cyrillic\_ze, Cyrillic\_ZE, 0, 0 ] };
> 21. key { [ Cyrillic\_ha, Cyrillic\_HA, Cyrillic\_hardsign, Cyrillic\_HARDSIGN, Cyrillic\_ha, Cyrillic\_HA, Cyrillic\_hardsign, Cyrillic\_HARDSIGN ] };
> 22.
> 23. // 2. row
> 24. key { [ a, A, asterisk, asterisk, Cyrillic\_ef, Cyrillic\_EF, asterisk, asterisk ] };
> 25. key { [ s, S, plus, plus, Cyrillic\_yeru, Cyrillic\_YERU, plus, plus ] };
> 26. key { [ d, D, numbersign, numbersign, Cyrillic\_ve, Cyrillic\_VE, numbersign, numbersign ] };
> 27. key { [ f, F, minus, minus, Cyrillic\_a, Cyrillic\_A, minus, minus ] };
> 28. key { [ g, G, underscore, underscore, Cyrillic\_pe, Cyrillic\_PE, underscore, underscore ] };
> 29. key { [ h, H, exclam, exclam, Cyrillic\_er, Cyrillic\_ER, exclam, exclam ] };
> 30. key { [ j, J, question, question, Cyrillic\_o, Cyrillic\_O, question, question ] };
> 31. key { [ k, K, semicolon, semicolon, Cyrillic\_el, Cyrillic\_EL, semicolon, semicolon ] };
> 32. key { [ l, L, colon, colon, Cyrillic\_de, Cyrillic\_DE, colon, colon ] };
> 33. key { [ comma, comma, comma, comma, Cyrillic\_zhe, Cyrillic\_ZHE, comma, comma ] };
> 34. key { [ period, period, period, period, Cyrillic\_e, Cyrillic\_E, period, period ] };
> 35.
> 36. // 3. row
> 37. key { [ z, Z, dollar, dollar, Cyrillic\_ya, Cyrillic\_YA, dollar, dollar ] };
> 38. key { [ x, X, EuroSign, EuroSign, Cyrillic\_che, Cyrillic\_CHE, EuroSign, EuroSign ] };
> 39. key { [ c, C, slash, slash, Cyrillic\_es, Cyrillic\_ES, slash, slash ] };
> 40. key { [ v, V, parenleft, parenleft, Cyrillic\_em, Cyrillic\_EM, parenleft, parenleft ] };
> 41. key { [ b, B, parenright, parenright, Cyrillic\_i, Cyrillic\_I, parenright, parenright ] };
> 42. key { [ n, N, quotedbl, quotedbl, Cyrillic\_te, Cyrillic\_TE, quotedbl, quotedbl ] };
> 43. key { [ m, M, apostrophe, apostrophe, Cyrillic\_softsign, Cyrillic\_SOFTSIGN, apostrophe, apostrophe ] };
> 44. key { [ Cyrillic\_be, Cyrillic\_BE, Cyrillic\_yu, Cyrillic\_YU, Cyrillic\_be, Cyrillic\_BE, Cyrillic\_yu, Cyrillic\_YU ] };
> 45. };
> \* This source code was highlighted with Source Code Highlighter.`
Первое, что бросается в глаза — это количество уровней. В данном случае их 8, а не 4. Все логично. На уровне 1-4 располагается английская раскладка, а на уровнях 5-8 — русская. Об этом так-же говорит вот эта запись:
> `1. key.type[Group1] = "EIGHT\_LEVEL\_SEMIALPHABETIC";
> \* This source code was highlighted with Source Code Highlighter.`
Для повышения или понижения уровня используется комбинация Ctrl+Пробел. Для пользователей она известна как переключение раскладки, что и есть повышения уровня на 4. Когда вы переключили раскладку на русскую (тем самым повысив все дальнейшие нажатия на 4) то клавиши Shift и Fn работают по тому-же принципу:
* уровень 5 — просто нажатие кнопки
* уровень 6 — Shift + нажатие
* уровень 7 — Atl + нажатие
* уровень 8 — Fn,Shify + нажатие
Но есть одно ограничение, чтоб вы не написали в уровнях 7 и 8, значения все равно будут браться с уровней 3,4. Но лучше в уровнях 7 и 8 все-же записать самому те-же значения что и для 3 и 4, во избежании возможных проблем.
Второе, на что нужно обратить внимание — это вот эта запись:
> `1. include "nokia\_vndr/rx-51(arrows\_2btns)"
> \* This source code was highlighted with Source Code Highlighter.`
Она подключает 2-х кнопочный курсор (что мне не нравиться и плюс у меня на клавишах 4 кнопки курсора).
Давайте рассмотрим секцию с кнопочками:
> `1. partial hidden alphanumeric\_keys
> 2. xkb\_symbols "arrows\_2btns" {
> 3. // rx-51 specific arrows mapping
> 4. // normal 2nd level must not be enumerated to allow text selection with Shift key
> 5. key { type[Group1] = "PC\_FN\_LEVEL2", symbols[Group1] = [ Left, Up ] };
> 6. key { type[Group1] = "PC\_FN\_LEVEL2", symbols[Group1] = [ Right, Down ] };
> 7. };
> 8.
> 9. partial hidden alphanumeric\_keys
> 10. xkb\_symbols "arrows\_4btns" {
> 11. // standard arrows mapping
> 12. // normal 2nd level must not be enumerated to allow text selection with Shift key
> 13. key { type[Group1] = "ONE\_LEVEL", symbols[Group1] = [ Up ] };
> 14. key { type[Group1] = "ONE\_LEVEL", symbols[Group1] = [ Left ] };
> 15. key { type[Group1] = "ONE\_LEVEL", symbols[Group1] = [ Down ] };
> 16. key { type[Group1] = "ONE\_LEVEL", symbols[Group1] = [ Right ] };
> 17. };
> \* This source code was highlighted with Source Code Highlighter.`
Первая секция **«arrows\_2btns»** используется в русской раскладке и еще в ряде других, где на клавиатуре только две клавиши отведены для курсора. Свойство type[Group1] = «PC\_FN\_LEVEL2» — как раз и определяет то, что на клавише две функции. Во второй секции **«arrows\_4btns»** 4 клавиши отведены на курсор и на каждой клавише всего по одной функции (как же расточительно :-) ), об этом говорит атрибут type[Group1] = «ONE\_LEVEL».
Вот тут можно разогнаться по полной, можно повесить на курсор 6 значений при двойной раскладке, что я и сделал, вот ниже мой вариант:
> `1. partial hidden alphanumeric\_keys
> 2. xkb\_symbols "arrows\_rule" {
> 3. // standard arrows mapping
> 4. // normal 2nd level must not be enumerated to allow text selection with Shift key
> 5. key { type[Group1] = "EIGHT\_LEVEL\_SEMIALPHABETIC", symbols[Group1] = [ Up, Up, Cyrillic\_e, Cyrillic\_E, Up, Up, Cyrillic\_e, Cyrillic\_E ] };
> 6. key { type[Group1] = "EIGHT\_LEVEL\_SEMIALPHABETIC", symbols[Group1] = [ Left, Left, Cyrillic\_be, Cyrillic\_BE, Left, Left, Cyrillic\_be, Cyrillic\_BE ] };
> 7. key { type[Group1] = "EIGHT\_LEVEL\_SEMIALPHABETIC", symbols[Group1] = [ Down, Down, Cyrillic\_yu, Cyrillic\_YU, Down, Down, Cyrillic\_yu, Cyrillic\_YU ] };
> 8. key { type[Group1] = "EIGHT\_LEVEL\_SEMIALPHABETIC", symbols[Group1] = [ Right, Right, Cyrillic\_hardsign, Cyrillic\_HARDSIGN, Right, Right, Cyrillic\_hardsign, Cyrillic\_HARDSIGN ] };
> 9. };
> \* This source code was highlighted with Source Code Highlighter.`
В моем варианте в русской и английской раскладке курсор остается курсором. Fn позволяет печатать русские буквы, которые у меня не влезли в обычные кнопки — **Э, Б, Ю, Ъ**. Комбинация Fn с Shift печатают заглавные и прописные символы. Из-за вышеуказанных ограничений 3,4 и 7,8 уровней русские буквы будут печататься при любой раскладке, но не велика потеря. Теперь кнопки курсора несут 3-х функциональную нагрузку (стрелка и большая и маленькая буква). Если учитывать, что есть комбинации с Ctrl + стрелка дает Home, End, PgUp, и PgDwn с соответствующей стрелкой, получаем 4 функции вместо 2-х, как в оригинале.
В добавок ко всему, я изменил саму секцию «ru», теперь у меня на «серой» клавиатуре синие кнопки (Fn — комбинации) совпадают с тем, что написано на клавиатуре. Спорными оказались несколько кнопок.
,;=ЧЪ — сильно много функций, все не влазит. Я убрал твердый знак и перенес его на стрелку вправо. Еще один недостаток, запятая, только в английской раскладке, думаю перенести ее вместо знака фунтов стерлингов в русской раскладке.
.:? Ж — ну тут все влезло, только точка опять присутствует только в английской раскладке, можно перенести ее вместо знака доллара или евро.
<курсор влево>БЮ — хочется, чтоб курсор оставался всегда курсором и буквы можно было использовать как заглавные так и прописные. С такими требованиями не влазит это все на одну клавишу. Поэтому перенес на <курсор клавишу вниз>
мой вариант можно сказать у меня с сайта вот по [этой ссылке](http://erudenko.com/N900/rx-51). Там лежит файлик rx-51.
Файл располагается в **/usr/share/X11/xkb/symbols/nokia\_vndr**.
Скопируйте новый вариант файла (мой или свой) в любое место на устройстве и из xterm нужно выполнить такие вот команды:
> sudo gainroot
>
> cp /usr/share/X11/xkb/symbols/nokia\_vndr/rx-51 /usr/share/X11/xkb/symbols/nokia\_vndr/rx-5.bak
>
> cp /home/user/MyDocs/rx-51 /usr/share/X11/xkb/symbols/nokia\_vndr/rx-51
>
> setxkbmap ru
>
>
Будьте предельно внимательны, если вы положите плохой файл rx-51 и перезагрузите устройство, то оно не сможет загрузиться и придется перепрошивать устройство.
В общем отличный простой способ изменить раскладку по Вашему усмотрению. Например тем, кто работает часто в консоли, было бы полезно добавить «пайп» "|". Ну и так далее.
Чтоб закрыть тему с кнопками, отмечу, что также можно поменять и таблицу дополнительных символов, которая появляется при нажатии на Fn+Ctrl. Но тут уже все не так просто. Сложность в том, что эти символы хранятся в бинарном виде. И для того, чтоб сформировать собственную таблицу, необходимо собрать специальный компилятор этого формата, написать свою конфигурацию, скомпилировать.
Для заинтересовавшихся, вот [ссылка на Maemo Wiki](http://wiki.maemo.org/Special_characters_view).
### Освобождаем место на RootFS
Вот эта проблема для меня была сюрпризом. Rootfs — корневая файловая система, где находится ядро и самое необходимое (модули ядра, файлы конфигурации системы) для запуска системы. Располагается Rootf естественно в напаянном NAND Flash, а не на eMMC. Чтоб было понятно, небольшой экскурс по типам памяти.
NOR-flash — тип флэш памяти, который позволяет получить байт с произвольного места (random-access for reading), и большим плюсом является выполнение программ прям из адресного пространства NOR — execute in place (XIP). Недостаток — цена. Обычно используется для хранения настроек и разной мелочи. Энергонезависимая память. Кратко — что-то вроде энергонезависимой RAM. Ну и в последнее время NOR сильно отстает от NAND по объему информации.
NAND — значительно дешевле NOR. Скорость записи в NAND намного быстрее чем в NOR. Но основной недостаток — это то, что NAND блочное устройство и читать с него можно только блоками (в зависимости от микросхемы это может быть 512/2048/4096 байт). SD/MMC карты — это как раз представители NAND.
И для ясности еще один термин — SoC — System on Chip. Переводится как «система в одной микросхеме» или «Система на кристале».
Чтоб не распыляться, [вот определение и характеристики термина](http://ru.wikipedia.org/wiki/SoC).
Таким образом в «голом» N900 у нас такие вот такие вот виды памяти:
* 256 Mb DDR — используется как пространства для выполнения программ, так как мы уже разобрались, что с NAND выполнять программы нельзя. Располагаются внутри SoC.
* 256 Mb NAND — используется для rootfs, ниже подробней опишу. Располагается в SoC.
* 32 Гб eMMC — используется для всего остального, напаяна на плату.
* до 16 Гб microSD Slot — слот для установки дополнительной памяти, официально написано, что поддерживается 16 Гб, но так как появились уже 32Гб экземпляры, то я лично опробовал и могу сказать, что работает. Видимо на момент написания харрактеристик еще и в планах не было выпуска карт объемом больше 16 Гб. Есть вероятность что и карта 64 Гб будет работать, если она выйдет конечно. Но нужно проверять.
Сначала отмечю, что корень и загрузчик с ядром располагаются в 256Mb NAND. Ниже опишу подробней.
32Гб eMMC разбита на 3 раздела:
* 2 Гб раздел ext3, смонтирован как /home. Тут лежат настройки программ и разная мелочь. Также сюда ведет ссылка /opt (в /home/opt), сюда устанавливаются программы размером большим 500Кб (в старых прошивках, хотя все зависит от разработчику, куда захочет, туда и засунет, и я рекомендую туда именно устанавливать свое ПО).
* 768 Мб, как swap-раздел.
* Оставшиеся 27Гб отформатированы как VFAT и смонтированы в /home/user/MyDocs. Сюда программы не устанавливаются, потому-что этот раздел размонтируется, когда вы подключаете устройство к компьютеру, для того, чтоб его моно было подключить как внешний накопитель. Кстати, никто не мешает Вам его конвертировать/переформатировать в ext3 например, но к Windows Вы сможете подключить устройство только с помощью дополнительного ПО (портированного FUSE и ext3fs драйвера в нем, например)
Ну а теперь подробней про rootfs. Весь 256Mb NAND отформатирован как UBIFS. UBIFS — это замена популярному JFFS2. Разница в том, что UBIFS умеет кэшировать и на больших объемах получается хороший прирост производительности. Недостаток, что UBIFS сложнее (он работает поверх UBI, который работает поверх MTD), а JFFS2 работает напрямую с NAND. Ну еще UBIFS появился только в 2007 году и работает с ядром начиная с версии 2.6.27. Именно поэтому практически во всех встраиваемых устройствах используется JFFS2. Но инженеры из Nokia приняли смелое решение использовать UBIFS. Подробней об этой файловой системе можно почитать [здесь](http://www.linux-mtd.infradead.org/doc/ubifs.html#L_rednote) и [здесь](http://www.linux-mtd.infradead.org/doc/ubifs.html#L_overview).
В NAND располагается загрузчик, ядро и корневая директория — "/" плюс разные системные файлы, необходимы для загрузки. На «голом» устройстве должно быть около 100Мб свободно. Проблема в том, что если вы подключаете много репозиториев, то кэш apt'а раздувается очень сильно. Плюс некоторые библиотеки тоже устанавливаются в rootfs и у меня уже через неделю rootfs переполнился. Это очень печально и приходится предпринимать дополнительные действия по предотвращению этого. При переполнении rootfs система начинает тормозить и обновление каталогов приложений невозможно (некуда сохранять кэш).
В идеале все что можно лучше перенести в VFAT, но это опасно, так как он отмонтируется при подключении к компу. Можно все перетащить в /home, как это сделано для /opt. Именно на этом и основывается мой метод.
Состояние заполненности можно проверить, выполнив команду в терминале:
> df -h
>
>
Самый простой способ все перенести — это создать скрипт с вот таким содержимым:
> `#!/bin/sh
>
> # Nokia N900 Maemo 5 Script to free up space on rootfs
>
> # ignoring errors when creating dirs that may already exist
>
>
>
> # Moving ?? icons to /home/opt
>
> mkdir -p /home/opt/usr/share/icons 2> /dev/null
>
> cp -r /usr/share/icons/\* /home/opt/usr/share/icons
>
> rm -r /usr/share/icons
>
> ln -s /home/opt/usr/share/icons /usr/share/icons
>
>
>
> # Moving video on start-up to /home/opt
>
> mkdir -p /home/opt/usr/share/hildon-welcome 2> /dev/null
>
> cp -r /usr/share/hildon-welcome/\* /home/opt/usr/share/hildon-welcome
>
> rm -r /usr/share/hildon-welcome
>
> ln -s /home/opt/usr/share/hildon-welcome /usr/share/hildon-welcome
>
>
>
> # ??
>
> mkdir -p /home/opt/usr/share/pixmaps 2> /dev/null
>
> cp -r /usr/share/pixmaps/\* /home/opt/usr/share/pixmaps
>
> rm -r /usr/share/pixmaps
>
> ln -s /home/opt/usr/share/pixmaps /usr/share/pixmaps
>
>
>
> # Moving 'apt cache' to /home/opt - Valid until Bug 5746 is fixed.
>
> mkdir -p /home/opt/var/cache/apt 2> /dev/null
>
> cp -r /var/cache/apt/\* /home/opt/var/cache/apt
>
> rm -r /var/cache/apt
>
> ln -s /home/opt/var/cache/apt /var/cache/apt
>
>
>
> # Moving locales Source
>
> mv /usr/share/locale /opt
>
> ln -s /opt/locale /usr/share/locale
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
например вы создали файл с именем free\_my\_rootfs.sh
выполните в консоли:
> chmod +x free\_my\_rootfs.sh
>
> ./free\_my\_rootfs.sh
>
>
Этот скрипт переносит иконки, видео «рукопожатие» стартующее при включении, кэш apt'a и локали системы.
Дополнительно можно еще перетащить питон «optify python» (если перевести, то «перетащить python в /opt»):
> sudo gainroot
>
> apt-get install pymaemo-optify
>
> apt-get clean
>
>
Приложение «Карты» тоже хранятся в rootfs (сами карты кэшируются на самый большой раздел), можно сделать так:
> sudo gainroot
>
> mv /usr/share/nokia-maps /home/opt/
>
> ln -s /home/opt/nokia-maps /usr/share/nokia-maps
>
>
Можно еще переместить движок MicroB:
> sudo gainroot
>
> mv /usr/share/microb-engine /home/opt
>
> ln -s /home/opt/microb-engine /usr/share/microb-engine
>
>
Ну и можно переместить учебник по пользованию N900:
> sudo gainroot
>
> mv /usr/share/tutorial-applet /home/opt
>
> ln -s /home/opt/tutorial-applet /usr/share/tutorial-applet
>
>
Темы тоже живут в rootfs, но переносить их не очень безопасно, можно получить «кирпич» и придется перепрошивать устройство. Просто возьмите за правило держать парочку тем и удалять те, которым в ближайшее время пользоваться не будете.
Ну вот вроде это все должно Вам помочь. Есть другой метод, очень брутальный, но для настоящих гиков. Заключается он в том, что нужно создать еще один раздел (уменьшив 27 Гб VFAT раздел) и засунуть все туда. Подробное описание [этого метода можно найти здесь](http://wiki.maemo.org/User:Tanner#Safely_free_some_space_on_rootfs). Там еще есть умный скрипт, который проверяет перемещены ли уже данные и в конце покажет сколько места он спас на rootfs. Но пользоваться этим методом новичкам не рекомендую.
Ну и главное, в следующей прошивк | https://habr.com/ru/post/89651/ | null | ru | null |
# App Extensions на IOS, а в частности — Action Extension
Всем доброго времени суток!
Сегодня у меня выдался выходной на работе, который я решил посветить, собственно, рассказу о том, какая новая информация залетела в мою головушку.
Для затравки, хочу сделать небольшую ремарку - тема, которую я попытаюсь сегодня чуточку осветить - очень обширная, поэтому я не стану охватывать необъятное, а опишу то, с чем непосредственно я и столкнулся.
Итак, в чем состояло мое ТЗ - Пользователь запускает Action Extension на какой-либо странице в Safari или другом браузере. Адрес страницы отправляется на back вместе с данными из User Defaults, в ответ получает URL, который тут же открывает.
Итого, проблемы, которые необходимо решить:
1. Создание самого App Extension
2. "Присоединение" его к основному приложению
3. Получение адреса изначально страницы для последующей отправки
4. Собственно, открытие URL (да, да, у App Extensions с этим есть небольшая заковырка)
Создать App Extension, как бы "удивительно" это не прозвучало, очень просто) В "таргетах" есть специальная кнопка)
И затем перед вами откроется все то многообразие, которое для вас приберегли Купертиновцы) К слову, подробнее о каждом можно узнать из [официальной документации](https://developer.apple.com/app-extensions/). На мой весьма испорченный вкус, там весьма недурно описано каждое из расширений)
Второй этап - коннект приложения с его расширением - это хорошо описано в [данной статье](https://habr.com/ru/company/mobileup/blog/441890/) под заголовком Обмен Данными: App Groups
Пытаться рассказать об этом лучше я уже не стану, лишь продублирую весь маршрут: через Apple Developer Account создаем AppGroup (да, понадобится аккаунт разработчика), там получаем айди созданной группы, которую указываем в Capabilities у каждого таргета.
Затем, так как в моем ТЗ требовалось использовать те данные, которые хранились в UserDefaults, для правильной работы App Extension нужно было немного поменять синтаксис записи и чтения из UD.
```
//Запись в основном приложении
UserDefaults.standard.set(self.TTT, forKey: "...")
// TTT - значение, которое нужно записать
//Чтение в основном приложении
let userDefaults = UserDefaults(suiteName: "Ваш group id")
var ZZZ = userDefaults!.string(forKey: "...")
//в ZZZ записываем данные из UD
//Чтение в AppExtension
let userDefaults = UserDefaults(suiteName: "Ваш group id")
let ZZZ = userDefaults!.string(forKey: "...")
//С записью в AppExtension думаю разберетесь)
```
Третьим этапом в повестке было получение url той страницы, на которой пользователь находился, когда вызвал наше расширение. Для этого нужна некая штуковина, которая называется, если не ошибаюсь, JavaScript Injection.
Простыми словами, для того чтобы AppExtension мог каким-либо образом взаимодействовать с данными, которые находятся на странице, нужно использовать небольшой кусок кода на JS, который жестко регламентируется Apple и, как мне сообщил знакомый разработчик на JS/React - код этот из доисторических времен (ну это так, для общего образования)
Итак, вид этой "инжекции" таков:
```
var GetURL = function() {};
GetURL.prototype = {
run: function(arguments) {
arguments.completionFunction({ "URL" : document.URL });
},
finalize: function(arguments) {
var message = arguments["statusMessage"];
if (message) {
alert(message);
}
}
};
var ExtensionPreprocessingJS = new GetURL;
```
В arguments.completionFunction можно получать не только URL, но и другие параметры, к примеру, заголовок страницы. для этого добавим
```
parameters.completionFunction({"URL": document.URL, "title": document.title });
```
Теперь для того, чтобы использовать свежеполученный url внутри AppExtension:
```
self.Pageurl = javaScriptValues["URL"] as String
```
Затем можно использовать его как вашей душе угодно!)
Остался последний пункт - открытие url) Да, если прошерстить документацию Apple по AppExtensions - вы найдете что-то вроде "Расширения не поддерживают метод open()". Придется выкручиваться, но выкрутас совсем несложный)
```
func openUrl(url: URL?) {
let selector = sel_registerName("openURL:")
var responder = self as UIResponder?
while let r = responder, !r.responds(to: selector) {
responder = r.next
}
_ = responder?.perform(selector, with: url)
}
```
Вот, собственно и решение. При помощи данной функции можно, к примеру, открывать основное приложение (через deep linking).
Что же, пожалуй, на этом закончу. Добавлю лишь одно размышление, к которому пришел, пока работал с данной фичей. AppExtensions имеют на самом деле весьма и весьма большой потенциал, но, судя по всему, и Купертиновцы, и рядовые разработчики, как-то подзабили на все что связано с расширениями. Это одновременно и расстраивает, и радует - если у Apple руки когда-нибудь все таки дойдут - скорее всего это будет что-то почти революционное!)
Спасибо и удачи во всех начинаниях! | https://habr.com/ru/post/646299/ | null | ru | null |
# Новая программная модель чейнкода Hyperledger Fabric
Не так давно был выпущен [первый релиз](https://github.com/hyperledger/fabric-contract-api-go/releases/tag/v1.0.0) **fabric-contract-api-go** — реализации новой программной модели чейнкода по [RFC 0001](https://github.com/hyperledger/fabric-rfcs/blob/master/text/0001-chaincode-go-new-programming-model.md). Давайте разберемся, что это и как этим пользоваться.
[Вот здесь](https://github.com/VadimInshakov/new-programming-model-tutorial) я подготовил репозиторий с простой Fabric-сетью, где пиры запускаются в dev-режиме. Следуйте инструкциям из репозитория, чтобы запустить сеть, и возвращайтесь (это займет не более 5 минут).
Теперь, когда у вас запущена сеть и установлен чейнкод, давайте посмотрим на внутренности чейнкода, работающего в новой модели.
В [SimpleContract.go](https://github.com/VadimInshakov/new-programming-model-tutorial/blob/master/chaincode/SimpleContract.go) мы импортируем модуль с новым API:
`github.com/hyperledger/fabric-contract-api-go/contractapi`
Далее описываем наш контракт с помощью структуры *SimpleContract*, в которую встраивается структура *Contract*:
```
type SimpleContract struct {
contractapi.Contract
}
```
Встраивать *Contract* нужно обязательно, чтобы наш контракт удовлетворял интерфейсу [ContractInterface](https://github.com/hyperledger/fabric-contract-api-go/blob/master/contractapi/contract.go#L31). Здесь следует сделать оговорку и сказать, что контракт != чейнкод. Чейнкод — это контейнер неопределенного множества контрактов. Чейнкод хранит свои контракты в мапе, как видно в данном листинге:
```
type ContractChaincode struct {
DefaultContract string
contracts map[string]contractChaincodeContract
metadata metadata.ContractChaincodeMetadata
Info metadata.InfoMetadata
TransactionSerializer serializer.TransactionSerializer
}
```
Map *contracts* используется внутри *Invoke* для роутинга запросов:
```
func (cc *ContractChaincode) Invoke(stub shim.ChaincodeStubInterface) peer.Response {
nsFcn, params := stub.GetFunctionAndParameters()
li := strings.LastIndex(nsFcn, ":")
var ns string
var fn string
if li == -1 {
ns = cc.DefaultContract
fn = nsFcn
} else {
ns = nsFcn[:li]
fn = nsFcn[li+1:]
}
...
nsContract := cc.contracts[ns]
...
successReturn, successIFace, errorReturn = nsContract.functions[fn].Call(ctx, transactionSchema, &cc.metadata.Components, serializer, params...)
...
return shim.Success([]byte(successReturn))
}
```
Итак, вернемся к SimpleContract. Все методы должны иметь параметр *ctx*, удовлетворяющий интерфейсу [TransactionContextInterface](https://github.com/hyperledger/fabric-contract-api-go/blob/master/contractapi/transaction_context.go#L15). По умолчанию все методы [получают](https://github.com/hyperledger/fabric-contract-api-go/blob/master/contractapi/contract.go#L122) стандартный [TransactionContext](https://github.com/hyperledger/fabric-contract-api-go/blob/master/contractapi/transaction_context.go#L41), которого в большинстве случаев достаточно.
Этот контекст позволяет нам работать с *ClientIdentity*, например, так:
```
func (sc *SimpleContract) Whois(ctx contractapi.TransactionContextInterface) (string, error) {
return ctx.GetClientIdentity().GetID()
}
```
Или получить уже знакомый нам **stub** (shim.ChaincodeStubInterface), чтобы выполнять все привычные действия для взаимодействия с леджером:
```
func (sc *SimpleContract) Write(ctx contractapi.TransactionContextInterface, key string, value []byte) error {
return ctx.GetStub().PutState(key, value)
}
```
Но! В коде нашего демонстрационного репозитория вы можете видеть совсем другой контекст в методах:
```
func (sc *SimpleContract) Create(ctx CustomTransactionContextInterface, key string, value string) error {
existing := ctx.GetData()
if existing != nil {
return fmt.Errorf("Cannot create world state pair with key %s. Already exists", key)
}
err := ctx.GetStub().PutState(key, []byte(value))
if err != nil {
return errors.New("Unable to interact with world state")
}
return nil
}
```
Это кастомный контекст. Он создается очень просто. Обратите внимание на [context.go](https://github.com/VadimInshakov/new-programming-model-tutorial/blob/master/chaincode/context.go) из нашего репозитория:
1. Объявляем интерфейс, совместимый с *contractapi.TransactionContextInterface*
```
type CustomTransactionContextInterface interface {
contractapi.TransactionContextInterface
GetData() []byte
SetData([]byte)
}
```
2. Структуру, в которую встраиваем *contractapi.TransactionContext*
```
type CustomTransactionContext struct {
contractapi.TransactionContext
data []byte
}
```
3. Реализуем объявленные методы
```
// GetData return set data
func (ctc *CustomTransactionContext) GetData() []byte {
return ctc.data
}
// SetData provide a value for data
func (ctc *CustomTransactionContext) SetData(data []byte) {
ctc.data = data
}
```
Теперь при инциализации контракта просто передаем данную структуру как хендлер:
```
simpleContract := new(SimpleContract)
simpleContract.TransactionContextHandler = new(CustomTransactionContext)
```
А все методы нашего контракта теперь вместо *ctx contractapi.TransactionContextInterface* принимают *ctx CustomTransactionContextInterface*.
Кастомный контекст необходим для прокидывания состояния через **транзакционные хуки**. Транзакционные хуки — это красивое название для middleware, срабатывающего до или после вызова метода контракта.
Пример хука, который перед вызовом метода достает из леджера значение ключа, переданного первым параметром в транзакции:
***SimpleContract.go***
```
func GetWorldState(ctx CustomTransactionContextInterface) error {
_, params := ctx.GetStub().GetFunctionAndParameters()
if len(params) < 1 {
return errors.New("Missing key for world state")
}
existing, err := ctx.GetStub().GetState(params[0])
if err != nil {
return errors.New("Unable to interact with world state")
}
ctx.SetData(existing)
return nil
}
```
***main.go***
```
simpleContract.BeforeTransaction = GetWorldState
```
Теперь мы можем получать значение запрошенного ключа в методах немного лаконичнее:
***SimpleContract.go***
```
func (sc *SimpleContract) Read(ctx CustomTransactionContextInterface, key string) (string, error) {
existing := ctx.GetData()
if existing == nil {
return "", fmt.Errorf("Cannot read world state pair with key %s. Does not exist", key)
}
return string(existing), nil
}
```
Хук после вызова метода почти идентичен, за исключением того, что кроме контекста он принимает пустой интерфейс (зачем он нужен, разберемся далее):
***YetAnotherContract.go***
```
func After(ctx contractapi.TransactionContextInterface, beforeValue interface{}) error {
fmt.Println(ctx.GetStub().GetTxID())
fmt.Println("beforeValue", beforeValue)
return nil
}
```
Данный хук выводит id транзакции и **значение, которое вернул метод перед хуком**. Чтобы проверить этот постхук, вы можете зайти в CLI контейнер и вызвать метод контракта:
`docker exec -it cli sh
peer chaincode query -n mycc -c '{"Args":["YetAnotherContract:SayHi"]}' -C myc`
Переключитесь в терминал, в котором запущен чейнкод, вывод будет примерно таким:
> e503e98e4c71285722f244a481fbcbf0ff4120adcd2f9067089104e5c3ed0efe # txid
>
> beforeValue Hi there # значение из предыдущего метода
>
>
Что если мы хотим обрабатывать запросы с несуществующим именем функции? Для этого у любого контракта есть поле *UnknownTransaction*:
***unknown\_handler.go***
```
func UnknownTransactionHandler(ctx CustomTransactionContextInterface) error {
fcn, args := ctx.GetStub().GetFunctionAndParameters()
return fmt.Errorf("Invalid function %s passed with args %v", fcn, args)
}
```
***main.go***
```
simpleContract.UnknownTransaction = UnknownTransactionHandler
```
Это можно тоже проверить через CLI:
`docker exec -it cli sh
peer chaincode query -n mycc -c '{"Args":["BadRequest", "BadKey"]}' -C myc`
Вывод:
> Error: endorsement failure during query. response: status:500 message:«Invalid function BadRequest passed with args [BadKey]»
Чтобы чейнкод запустился на пире, мы должны как и раньше вызвать метод *Start()*, перед этим передав в чейнкод все наши контракты:
***main.go***
```
cc, err := contractapi.NewChaincode(simpleContract, yetAnotherContract)
if err != nil {
panic(err.Error())
}
if err := cc.Start(); err != nil {
panic(err.Error())
}
```
### Итого
В новой модели чейнкода решена проблема роутинга, middleware, сериализации возвращаемых значений, десериализации строковых аргументов (можно использовать любые типы кроме *interface{}*). Теперь остается ждать реализации новой модели для Go SDK.
Спасибо за внимание.
[Часть вторая](https://habr.com/ru/post/496872/) | https://habr.com/ru/post/494880/ | null | ru | null |
# Выпущен Rust 1.4
Честно по графику встречаем [Rust 1.4](https://www.rust-lang.org/downloads.html). Релиз вобрал в себя 1200 патчей с момента последнего релиза. Основное внимание уделили стабилизации языка, а это уже серьёзный аргумент, в пользу того, что язык приобрёл понятные формы, синтаксис и стандартную библиотеку.
Это первый стабильный релиз, который идёт в двух ABI ([Application Binary Interface](https://ru.wikipedia.org/wiki/%D0%94%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D1%8B%D0%B9_%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D1%84%D0%B5%D0%B9%D1%81_%D0%BF%D1%80%D0%B8%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B9)), кроме привычного GNU toolchain добавлена поддержка MSVC. Последний доступен пока в 64-битной версии, но я пользовался 32-х битным в nightly версии намного раньше, хотя официальная поддержка намечена на версию 1.6. Как бонус: теперь корректно обрабатывается перенос строки в windows-стиле, например, в [BufRead](https://doc.rust-lang.org/std/io/trait.BufRead.html#method.lines).
**Из других особенностей:**
Можно использовать псевдонимы в множественном импорте:
```
use foo::{bar as kitten, baz as puppy}
```
Окончательно доломали:
```
pub extern crate
```
Это хорошая новость, так как экспорт внутреннего крейта, как минимум нарушает закон Деметры. Если нужно использовать структуру внутреннего крейта, ещё лучше явно экспортировать. А зачем это вообще нужно?! Если вы используете с внешней библиотекой разные версии крейтов, и попробуете её «накормить» инородным типом (например, набор полей в структуре поменялся), то всё сломается.
Исправлены ошибки с ([пример](http://is.gd/NCYC59), пока не залили 1.4 можно увидеть разницу на Stable)
```
&'static mut
```
Статическое время жизни было не так хорошо проработано ранее, и можно было обмануть строгие правила компилятора с правами на переменную.
Много изменений сделали в стандартной библиотеке. В основном по стабилизации, но есть некоторые улучшения, например, HashMap теперь реализует трейт Extend. Ещё std::io::copy теперь умеет работать с типами, размер которых неизвестен при компиляции.
Cargo стал немного разговорчивее:
```
[cargo]$ cargo update
Updating registry `https://github.com/rust-lang/crates.io-index`
Updating libc v0.1.8 -> v0.1.10
Updating memchr v0.1.3 -> v0.1.5
Updating num v0.1.26 -> v0.1.27
Updating rand v0.3.9 -> v0.3.10
Updating rustc-serialize v0.3.15 -> v0.3.16
```
Кстати, я обновляю зависимости своих проектов раз в неделю, и всегда появляется что-то новое, это приятно, чувствуешь, что сообщество Rust живёт и развивается, но главное, от этого больше ничего не ломается.
Следующий релиз намечен на **10 декабря 2015**: в этом году Дед Мороз принесёт подарки программистам на Rust чуть раньше ) | https://habr.com/ru/post/269809/ | null | ru | null |
# Пишем симулятор медленных соединений на Go
В этой статье я хочу показать, как просто в Go можно делать достаточно сложные вещи, и какую мощь в себе несут интерфейсы. Речь пойдет о симуляции медленного соединения — но, в отличие от популярных решений в виде правил для iptables, мы реализуем это на стороне кода — так, чтобы можно было легко использовать, к примеру, в тестах.
Ничего сложного тут не будет, и ради большей наглядности я записал ascii-анимации (с помощью сервиса [asciinema](https://asciinema.org)), но, надеюсь, будет познавательно.
#### Интерфейсы
Интерфейсы — это специальный тип в системе типов Go, позволяющий описывать поведение объекта. Любой статический тип, для которого определены методы (поведение) неявно реализует интерфейс, который описывает эти методы. Самый известный пример — интерфейс из стандартной библиотеки io.Reader:
```
// Reader is the interface that wraps the basic Read method.
// ...
type Reader interface {
Read(p []byte) (n int, err error)
}
```
Любая структура, для которой вы определите метод Read([]byte) (int, error) — может использоваться как io.Reader.
Простая идея, не кажущаяся поначалу слишком ценной и мощной, принимает совсем другой вид, когда интерфейсы используются другими библиотеками. Для демонстрации этого стандартная библиотека и io.Reader — идеальные кандидаты.
#### Вывод в консоль
Итак, начнем с простейшего применения Reader-а — выведем строчку в stdout. Конечно, для этой задачи лучше использовать функции из пакета fmt, но мы же хотим продемонстрировать работу Reader-а. Поэтому создадим переменную типа strings.Reader (которая реализует io.Reader) и, с помощью функции io.Copy() — которая, как раз тоже работает с io.Reader, скопируем это в os.Stdout (которая, в свою очередь, имплементирует io.Writer).
```
package main
import (
"io"
"os"
"strings"
)
func main() {
r := strings.NewReader("Not very long line...")
io.Copy(os.Stdout, r)
}
```
А теперь, используя композицию (composition), создадим свой тип SlowReader, который будет читать из оригинального Reader-а по одному символу с задержкой, скажем, в 100 миллисекунд — таким образом, обеспечивая скорость 10 байт в секунду.
```
// SlowReader reads 10 chars per second
type SlowReader struct {
r io.Reader
}
func (sr SlowReader) Read(p []byte) (int, error) {
time.Sleep(100 * time.Millisecond)
return sr.r.Read(p[:1])
}
```
Что такое p[:1], надеюсь, объяснять не нужно — просто новый slice, состоящий из 1 первого символа от оргинального slice-а.
Всё что нам остается — это использовать наш strings.Reader в качестве оригинального io.Reader-а, и передать в io.Copy() медленный SlowReader! Посмотрите, как просто и круто одновременно.
(ascii-каст открывается в новом окне, js-скрипты на хабре запрещено встраивать)
[](https://asciinema.org/a/16707)
Вы уже должны начать подозревать, что этот простой SlowReader можно использовать не только для вывода на экран. Также можно добавить параметр вроде delay. А еще лучше — вынести SlowReader в отдельный package, чтобы было легко использовать в дальнейших примерах. Немного причешем код.
#### Причёсываем код
Создадим директорию test/habr/slow и перенесем код туда:
```
package slow
import (
"io"
"time"
)
type SlowReader struct {
delay time.Duration
r io.Reader
}
func (sr SlowReader) Read(p []byte) (int, error) {
time.Sleep(sr.delay)
return sr.r.Read(p[:1])
}
func NewReader(r io.Reader, bps int) io.Reader {
delay := time.Second / time.Duration(bps)
return SlowReader{
r: r,
delay: delay,
}
}
```
Или, кому интересно смотреть ascii-касты, вот так — выносим в отдельный package:
[](https://asciinema.org/a/16708)
И добавляем параметр delay типа time.Duration:
[](https://asciinema.org/a/16710)
(Правильнее было бы, после выноса кода в отдельный пакет, назвать тип Reader — чтобы было slow.Reader, а не slow.SlowReader, но скринкаст уже записан так).
#### Чтение из файла
А теперь, практически без усилий, проверим наш SlowReader для медленного чтения из файлов. Получив переменную типа \*os.File, которая хранит в себе дескриптор открытого файла, но при этом реализует интерфейс io.Reader — мы можем работать с файлом точно также, как и ранее со strings.Reader.
```
package main
import (
"io"
"os"
"test/habr/slow"
)
func main() {
file, err := os.Open("test.txt")
if err != nil {
panic(err)
}
defer file.Close() // close file on exit
r := slow.NewReader(file, 5) // 5 bps
io.Copy(os.Stdout, r)
}
```
Или так:
[](https://asciinema.org/a/16713)
#### Декодируем JSON
Но с чтением из файла — это слишком просто. Давайте рассмотрим пример чуть интереснее — JSON-декодер из стандартной библиотеки. Хотя для удобства пакет [encoding/json](http://golang.org/pkg/encoding/json/) предоставляет функцию json.Unmarshal(), он также позволяет работать с io.Reader с помощью json.Decoder — с ним можно десериализовать потоковые данные в json-формате.
Мы возьмем простую json-encoded строку и будем её «медленно читать» с помощью нашего SlowReader-а — а json.Decoder выдаст готовый объект только после того, как дойдут все байты. Чтобы это было очевидно, мы добавим в функцию slow.SlowReader.Read() вывод на экран каждого прочитанного символа:
```
package main
import (
"encoding/json"
"fmt"
"strings"
"test/habr/slow"
)
func main() {
sr := strings.NewReader(`{"value": "some text", "id": 42}`) // encoded json
r := slow.NewReader(sr, 5)
dec := json.NewDecoder(r)
type Sample struct {
Value string `json:"value"`
ID int64 `json:"id"`
}
var sample Sample
err := dec.Decode(&sample)
if err != nil {
panic(err)
}
fmt.Println("Decoded JSON value:", sample)
}
```
Это же в ascii-касте:
[](https://asciinema.org/a/16715)
Если на вас ещё не свалилось осознание возможностей, которые даёт нам такая простая концепция интерфейсов, то идём дальше — собственно, приходим к теме поста — используем наш SlowReader для того, чтобы медленно скачивать страницу из интернета.
#### «Медленный» HTTP-клиент
Вас уже не должно удивлять, что io.Reader используется в стандартной библиотеке повсевместно — для всего, что умеет что-либо откуда-либо читать. Чтение из сети не исключение — io.Reader используется на нескольких уровнях, и спрятан под капотом такого, вроде бы, простого однострочного вызова http.Get(url string).
Для начала напишем стандартный код для HTTP GET запроса и выведем ответ в консоль:
```
package main
import (
"io"
"net/http"
"os"
)
func main() {
resp, err := http.Get("http://golang.org")
if err != nil {
panic(err)
}
defer resp.Body.Close()
io.Copy(os.Stdout, resp.Body)
}
```
Для тех, кто ещё не успел познакомиться с net/http-библиотекой — несколько объяснений. http.Get() — это обертка для метода Get() реализованного для типа http.Client — но в этой обёртке используется «подходящая для большинства случаев» уже иницилизированная переменная под названием DefaultClient. Собственно, Client дальше выполняет всю пыльную работу, в том числе и читает из сети с помощью объекта типа Transport, который в свою очередь использует более низкоуровневый объект типа net.Conn. Поначалу это может показаться запутанным, но, на самом деле, это достаточно легко изучается простым чтением исходников библиотеки — вот что-что, а стандартная библиотека в Go, в отличие от большинства других языков — это образцовый код, на котором можно (и нужно) учиться Go и брать с него пример.
Чуть ранее я упомянул про «io.Reader используется на нескольких уровнях» и это действительно так — к примеру resp.Body — это тоже io.Reader, но нам он не интересен, потому что нам интересно симулировать не тормознутый браузер, а медленное соединение — значит нужно найти io.Reader, который читает из сети. И это, забегая вперед, переменная типа net.Conn — а значит именно её нам и нужно переопределить для нашего кастомного http-клиента. Мы это можем сделать с помощью встраивания (embedding):
```
type SlowConn struct {
net.Conn // embedding
r slow.SlowReader // in ascii-cast I use io.Reader here, but this one a bit better
}
// SlowConn is also io.Reader!
func (sc SlowConn) Read(p []byte) (int, error) {
return sc.r.Read(p)
}
```
Самое сложное тут заключается в том, чтобы всё-таки немного глубже разобраться в пакетах net и net/http из стандартной библиотеки, и правильно создать наш http.Client, использующий медленный io.Reader. Но, в результате ничего сложного — надеюсь, на скринкасте видна логика, по мере того, как я поглядываю в код стандартной библиотеки.
В итоге получается следующий клиент (для реального кода это лучше вынести в отдельную функцию и чуть причесать, но для proof-of-concept примера сойдет):
```
client := http.Client{
Transport: &http.Transport{
Dial: func(network, address string) (net.Conn, error) {
conn, err := net.Dial(network, address)
if err != nil {
return nil, err
}
return SlowConn{conn, slow.NewReader(conn, 100)}, nil
},
},
}
```
Ну а теперь склеиваем это всё вместе и смотрим результат:
[](https://asciinema.org/a/16717)
В конце видно, что HTTP-заголовки выводятся в консоль нормально, а текст, собственно, страницы выводится с удвоением каждого символа — это нормально, поскольку мы выводим resp.Body с помощью io.Copy() и при этом наша, чуть модифицированная, реализация SlowReader.Read() выводит каждый символ тоже.
#### Заключение
Как говорилось в начале статьи, интерфейсы — чрезвычайно мощный инструментарий, да и сама идея разделения типов для свойств и для поведения — очень правильная. Но по-настоящему эта мощь проявляется, когда интерфейсы действительно используются по назначению в разных библиотеках. Это позволяет соединять очень разный функционал, и использовать чужой код для вещей, о которых оригинальный автор мог даже не подозревать. И речь не только о стандартных интерфейсах — внутри больших проектов интерфейсы дают огромную гибкость и модульность.
#### Ссылки
Поскольку идея этого поста была нагло утянута из твиттера Francesc Campoy, то только одна ссылка :)
[twitter.com/francesc/status/563310996845244416](https://twitter.com/francesc/status/563310996845244416) | https://habr.com/ru/post/251095/ | null | ru | null |
# Основы JAX-RS
#### Введение
Выросло данное API из [JSR 311: JAX-RS: The Java API for RESTful Web Services](http://jcp.org/en/jsr/summary?id=311 "JSR 311: JAX-RS: The Java API for RESTful Web Services") и вошло в Java EE 6 (планировалось в Java EE 5). Как видно из названия, предназначено оно для разработки RESTful веб-сервисов.
Основная цель данной статьи — познакомить читателя с основами JAX-RS API. Изначально я планировал написать о некоторых проблемах работы форм при использование JAX-RS сервиса. Не обнаружив на Хабре почти ничего, касающегося данной технологии понял, что введением к статье отделаться не удастся.
Будут представлены основы JAX-RS API, реализация от JBoss и дано небольшое введение в клиентскую часть фреймворка Resteasy.
Представлено оно набором классов в *javax.ws.rs.\**, в случае современных AppServer'ов предоставляемое окружением (можно использовать `provided` в [maven](http://maven.apache.org/ "Apache Maven"). Для приложений в сервлет-контейнерах есть несколько реализаций:
* [Apache CXF](http://cxf.apache.org/ "Apache CXF") (используется в Virgo — наследнице Spring dm Server),
* [Sun/Oracle Jersey](http://jersey.java.net/ "Sun/Oracle Jersey") (текущая RI, используется в GlassFish),
* [JBoss Resteasy](http://www.jboss.org/resteasy/ "JBoss Resteasy") (используется в JBoss AS 7),
* [Restlet](http://www.restlet.org/ "Restlet").
Эта технология позволяет экспортировать методы произвольного бина, используя специальный сервлет, предоставляемый реализаций JAX-RS. Приведу пример. Для использования в клиентской части выделим интерфейс:
```
package com.example;
import javax.ws.rs.*;
@Path("/")
public interface RestService {
@GET
@Path("echo")
String echo(@QueryParam("q") String original);
}
```
И реализацию:
```
package com.example;
import javax.enterprise.ApplicationScoped;
import javax.ws.rs.*;
@ApplicationScoped
@Path("/")
public class Rest implements RestService{
@GET
@Path("echo")
@Override
public String echo(@QueryParam("q") String original) {
return original;
}
}
```
Как к самому бину, так к его методам добавляются аннотации, описывающие его поведение: `@Path`, например, указывает относительный или абсолютный путь к данному ресурсу; группа аннотаций `@GET`, `@POST`, `@PUT`, `@DELETE` отвечает за тип `HTTP` запроса релевантный этому методу.
#### Сериализация
Очевидно, что для передачи произвольных данных, необходима сериализация — перевод данных из объектного представления в набор байт. Дальнейшее повествование я буду вести с оглядкой на Resteasy.
В этом случае для сериализации/десериализации используются специальные провайдеры. Аннотации `@Produces` и `@Consumes` используются для указания MIME-type содержимого результата/данных. Соответственно класс данных должен быть аннотирован [JAXB](http://jcp.org/en/jsr/summary?id=jaxb "JSR 222: Java Architecture for XML Binding (JAXB) 2.0"). Стандартными провайдерами в JBoss AS 7 являются resteasy-jaxb-provider (xml-маршаллер/анмаршаллер) и resteasy-jettison-provider (json). Эти два провайдера позволяют интергрироваться с большим количество внешних сервисов, предоставлять XML и JSON API наружу.
#### Нестандартные ответы
Что делать, если мы хотим вернуть нестандартный ответ или HTTP код? При Exception'е из аннотированного JAX-RS метода результатом будет 500 ошибка. Для кастомизации достаточно возвращаемым типом указать `javax.ws.rs.core.Response`:
```
@GET
@Path("file/get/{name}")
Response getFile(@PathParam("file") String fileName) {
if(!Files.exists(Paths.get(fileName)) {
return Response.status(422).entity("I'm a teapot");
} else {
Response.Builder response = Response.ok();
response.header("X-Some-Server-Header", "value");
response.entity(new StreamingOutput() {
@Override
public void write(OutputStream outputStream) throws IOException, WebApplicationException {
Files.copy(Paths.get(fileName), outputStream);
}
});
return response.build();
}
}
```
#### Клиентский фреймворк
Вторым приятным моментом JBoss Resteasy является наличие удобного клиентского фреймворка. Работа с ним возможна на разных уровнях абстракции: начиная от низкоуровневых `ClientRequest`, `ClientResponse` и заканчивая генерацией прокси-объектов по аннотированному JAX-RS интерфейсу. Для примера, используя интерфейс `RestService` из первого примера:
```
RestService service = ProxyFactory.create(RestService.class, "http://localhost:8080/example");
log.info(service.echo("test message"));
```
Но иногда этого недостаточно. Например в этом случае при ошибке на стороне сервера прокси генерирует исключение. Для более низкоуровневой работы может использоваться `ClientRequest`/`ClientResponse`, использующие apache httpcomponents (в Resteasy 2.3.x.GA) или apache-httpclient (в 2.2.x.GA). Пример использования выглядит следующим образом:
```
ClientRequest request = new ClientRequest(url);
request.header("X-Additional-Header", "header value");
// варьируется в зависимости от метода: GET, POST, PUT, DELETE
ClientResponse response = request.get(String.class);
if(response.getCode() == 200) {
String result = response.getEntity();
log.info(result);
}
```
**UPD:** В случае использования клиенткого фреймворка необходимо один раз при запуске программы его инициализировать следующим образом:
```
RegisterBuiltin.register(ResteasyProviderFactory.getInstance());
```
Такой подход позволяет установить произвольные поля, тело запроса и т. п.
Одной возникающей в этом случае проблеме будет посвящена следующая статья.
**UPD:** Продолжение см. [тут](http://habrahabr.ru/post/140270/) | https://habr.com/ru/post/140181/ | null | ru | null |
# Did It Have to Take So Long to Find a Bug?
Have you ever wondered which type of project demonstrates higher code quality – open-source or proprietary? Our blog posts may seem to suggest that bugs tend to concentrate in open-source projects. But that's not quite true. Bugs can be found in any project, no matter the manner of storage. As for the code quality, it tends to be higher in those projects where developers care about and work on it. In this small post, you will learn about a bug that took two years to fix, although it could have been done in just five minutes.
The chronology
--------------
[Minetest](https://github.com/minetest/minetest) is an open-source cross-platform game engine about 200 thousand lines of C, C++, and Lua code long. It allows creating various game modes in voxel space, with multiplayer mode support and easy modding.
On November 10, 2018, [Issue #7852](https://github.com/minetest/minetest/issues/7852) — *item\_image\_button[]: button too small* was opened in the project's bug tracker.
This is how it goes:
> The button is too small resulting in the image exceeding its borders. Button should be the same size as inventory slots. See example below (using width and height of 1).
The report was accompanied by a screenshot:
In this screenshot, you can see that the images slightly exceed the borders of the buttons. The bug was reported way back in 2018, yet the cause behind it was discovered only this year, 2020.
Publication of a technical article "[PVS-Studio: analyzing pull requests in Azure DevOps using self-hosted agents](https://www.viva64.com/en/b/0751/)" in July 2020 was the next piece of this wonderful story. As an example of how the analyzer can be integrated with Azure DevOps, we chose that very game, Minetest. The article discusses a number of bugs, but here we are interested in one specific warning:
[V636](https://www.viva64.com/en/w/v636/) The 'rect.getHeight() / 16' expression was implicitly cast from 'int' type to 'float' type. Consider utilizing an explicit type cast to avoid the loss of a fractional part. An example: double A = (double)(X) / Y;. hud.cpp 771
```
void drawItemStack(....)
{
float barheight = rect.getHeight() / 16;
float barpad_x = rect.getWidth() / 16;
float barpad_y = rect.getHeight() / 16;
core::rect progressrect(
rect.UpperLeftCorner.X + barpad\_x,
rect.LowerRightCorner.Y - barpad\_y - barheight,
rect.LowerRightCorner.X - barpad\_x,
rect.LowerRightCorner.Y - barpad\_y);
}
```
When dividing the width and height values by 16, the fractional part of the resulting value is truncated since this is an integer division.
Almost half a year since, the game's developers finally learned about the results of our check, and [Issue 10726](https://github.com/minetest/minetest/issues/10726) — *Fix errors found by professional static code analyzer* was opened, where a link was discovered between this bug and the old [Issue #7852](https://github.com/minetest/minetest/issues/7852). It was that very truncation that distorted the buttons' size.
The moral
---------
The use of static code analyzers helps save a huge amount of time on bug detection. You can argue all you want about this bug being a minor issue, but I can tell you from our experience that its life cycle is typical of just any bug, no matter how critical it is.
Suppose it had been a serious bug indeed. The developers would have focused all their effort on finding and fixing it, which would have taken them an hour or so. But the analyzer would have found it in a couple of minutes anyway.
So, the moral of this story is that projects in development could greatly benefit from automated bug-detection methods. Such tools as PVS-Studio should be viewed as a complement to peer code review rather than a replacement of it. | https://habr.com/ru/post/534136/ | null | en | null |
# STM32 fast start. Часть 2 Hello World на HAL, отладка в Atollic TrueSTUDIO
В прошлый раз мы осваивали создание нового проекта при помощи STM CubeMX первую часть можно найти [здесь.](https://habr.com/ru/post/442162/)
Для тех, кому лень перечитывать — закончилось все тем, что пустой проект успешно собрался.
В данной части напишем простейший пример Hello World на HAL, посмотрим как запускать и пользоваться отладчиком, ну и выясним, сколько же памяти кушает наша программа, которая в этой части будет написана на HAL.
За основу берем все тот же пустой проект, который инициализировали в прошлой части.
Для того, чтобы помигать светодиодом — нам необходимо придерживаться следующего алгоритма:
1. Установить на ножке микроконтроллера состояние, инверсное текущему. То есть был 0 — ставим 1, был 1 — ставим 0 и тд.
2. Подождать N количество микросекунд и вернутся к шагу 1.
Для того чтобы выполнить первый пункт — нам необходимо указать компилятору к какому пину и порту подключен светодиод и какой функцией делать инверсию его состояния.
Сначала найдем, куда мы подключили светодиод.
В файле main.c, сразу после вступительных комментариев, которые нам любезно написала компания ST — имеется строчка, для подключения заголовочного файл main.h
Нажимаем на эту строку правой кнопкой и находим пункт Open Declaration
Нажав на него — мы переместимся в файл main.h
Где найдем наши декларированные названия пинов и портов.
Помните, в первой части при инициализации вывода светодиода PC13 — мы заполняли поле User Label и вписывали туда CLOCK\_LED?
STM32CubeMX при генерации проекта учел наши пожелания и теперь вместо абстрактных GPIO\_PIN\_13 и GPIOC мы можем обращаться к своему светодиоду через более понятные для восприятия CLOCK\_LED\_Pin и CLOCK\_LED\_GPIO\_Port.
С тем — чем будем управлять — разобрались.
Теперь ищем функцию, которая умеет менять состояние нашего GPIO на противоположное.
Для этого в дереве проекта в левой части экрана — находим файл:
```
Drivers -> STM32F1xx_HAL_Driver -> Inc -> stm32f1xx_hal_gpio.h
```
В нем очень много всего, но нам нужны описания функций, которые идут в блоке /\* Exported functions \*/
Находим там функцию
```
void HAL_GPIO_TogglePin(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin);
```
Это как раз то, что нам необходимо.
Чтобы светодиод мигал постоянно — необходимо разместить вызов нашей функции в main в теле основного цикла программы.
А для того, чтобы различать мигания — добавить после этого задержку при помощи функции HAL\_Delay(500);
В данном случае задержка будет 500мс.
Кстати, функция HAL\_Delay описана так же в
```
Drivers -> STM32F1xx_HAL_Driver -> Inc
```
только в файле stm32f1xx\_hal.h
То есть чтобы помигать светодиодом — нам потребовалось написать всего 2 строчки кода.
Если мы сделали все правильно — можно попробовать запустить отладчик и посмотреть как выполняется программа.
Перемещаться по коду программы можно при помощи кнопок F5 и F6
При этом кнопка F6 шагает только по вызовам функций, а кнопка F5 позволяет зайти в вызываемую функцию и посмотреть что же происходит внутри.
Единственное, если вы не хотите наловить глюков при отладке — советую отключить оптимизацию. Делается это через меню Project -> Properties
Значение Optimization Level необходимо установить в None(-O0)
После остановки отладки — контроллер перезапустит код еще раз и будет выполнять его циклически.
По итогу должна получится примерно такая картина
#### Подведем итоги
Использование HAL позволило реализовать данную задачу путем написания всего 2-х строчек кода.
Но за упрощение работы пришлось заплатить памятью
1.54 КБ оперативы и 4.69 КБ флеша.
Напомню, оптимизация отключена, то есть «-O0»
Много это или мало?
На этот вопрос можно будет с уверенностью ответить только в следующих частях статьи.
Оригинал статьи как всегда в [моем блоге](http://multimake.ru/stm32-fast-start-%d1%87%d0%b0%d1%81%d1%82%d1%8c-2-hello-world-%d0%bd%d0%b0-hal-%d0%be%d1%82%d0%bb%d0%b0%d0%b4%d0%ba%d0%b0-%d0%b2-atollic-truestudio/). | https://habr.com/ru/post/481436/ | null | ru | null |
# Производительность upsert'ов в MongoDB
В nosql-базе [MongoDB](http://www.mongodb.org) есть аналог mysql'ного [INSERT… ON DUPLICATE KEY UPDATE](http://dev.mysql.com/doc/refman/5.1/en/insert-on-duplicate.html) — upsert'ы (UPdate or inSERT).
Насколько быстро это делает mongodb?
Вопрос не праздный, так как при upsert'ах выполняются две операции — чтение и запись. Наличие индексов ускоряет чтение, но замедляет запись. Кто из них сильнее ускоряет, а кто круче замедляет?
`upd: добавлен еще один график`
### Фокусируемся на UPdate
#### Результаты
#### Комментарии
Я рассмотрел случай, когда в документе есть массив и туда идет активная запись. Пример — комментарии блога:
```
db.blog.insert({
title: "new post",
content: "Hello world!
",
comments: [ ]
});
```
Каждый комментарий — это объект типа:
```
NEW_COMMENT = {
content: "Thanks! Great article! Peshi is4o!",
author: "vasily@example.com"
}
```
На графике показана производительность операции `db.blog.update({title: "new post"}, {"$push": {comments: NEW_COMMENT}}, **true**)` (последний параметр включает режим upsert) в зависимости от размера массива `blog.comments` и наличия индекса на `blog.title`.
### Фокусируемся на inSERT
### Результаты
### Комментарии
Тот же случай, но заголовок поста все время генерируем случайным образом. Смысл — частый постинг новых статей через upsert.
Видно, что при небольшом числе записей (маленькая база) индекс не нужен. Зато при росте базы и увеличении числа экстентов индекс начинает здорово помогать и дает стабильную скорость записи.
### Итоги
Мой вердикт upsert'ам таков: можно использовать когда нельзя сказать точно чего больше — изменений документов или добавление новых, либо их соотношение около 50/50. В моем окружении запись «в лоб» идет со скоростью 10К документов в секунду.
Экспериментаторам: обратите внимание на размер документа, сколько экстентов он занимает (nscanned). При росте числа экстентов будет картина как на первом графике, но более круто деградировать. | https://habr.com/ru/post/85804/ | null | ru | null |
# Пишем простую виртуальную машину на Python
Привет! Сейчас расскажу как написать простую виртуальную машину на Python. Надеюсь кто-то найдет эту статью интересной.
Мы не будем реализовывать парсер и компилятор, а сделаем пока что только машину-интерпретатор нашего ассемблера.
У нас будет стековая машина, и она будет использовать два стека:
* стек значений, куда будут складываться/забираться временные значения вычислений и результаты вызова функций
* стек вызовов, куда мы будем запоминать, в какое место кода нужно вернуться после завершения функции
Сам код будет представлять собой list из команд, которые тоже являются list'ами:
```
code = [
['val', 2], # положить 2 на стек
['val', 3], # положить 3 на стек
['get', '*'], # положить на стек значение переменной с названием * (функция умножения)
['call', 2], # взять с вершины стека функцию и вызвать ее с 2 аргументами со стека (они тоже вынимаются), результат функции кладется на стек
['get', 'puts'], # положить функцию печати
['call', 1], # напечатать
]
```
Реализуем машину в виде функции:
```
# ops - список команд
# env - окружение в котором исполняется код
def vm(ops, env={}):
# нам нужен класс замыкания, чтобы мы могли понять что на стеке действительно лежит функция
class closure:
# pc - "адрес" кода функции (индекс первой команды в ops)
# env - окружение в котором было создано замыкание
def __init__(self, pc, env):
self.pc, self.env = pc, env
# pc - индекс следующей исполняемой команды
# stack - стек значений
# fstack (frame stack) - стек вызовов функций
pc, stack, fstack = 0, [], []
```
Перед тем как запустить основной цикл интерпретатора, нам нужно вычислить индексы метод в коде. Меткой у нас будет специальная команда label: `['label', 'label-name']`
```
labels = {op[1]: index for index, op in enumerate(ops) if op[0] == 'label'}
```
Основной цикл:
```
while pc < len(ops):
# берем текущую команду и ее аргументы, увеличиваем указатель
op, args, pc = ops[pc][0], ops[pc][1:], pc + 1
arg = args[0] if args else None
# игнорировать команду label
if op == 'label':
pass
# положить знаение аргумента на стек
elif op == 'val':
stack.append(arg)
# присовить значение переменной либо положить значение переменной на стек
elif op == 'set' or op == 'get':
```
Здесь нужно чуть рассказать об устройстве окружений. У нас они являются объектами dict, в ключах которого хранятся названия переменных, а в значениях значения + в ключе '' (пустая строка) хранится «указатель» на родительское окружение. Поэтму чтобы найти окружение в котором была определена нужная нам переменная, мы должны искать сначала в текущем окружении, и если не нашли, то искать в родительском и так далее:
```
e = env
while e is not None and arg not in e:
e = e[''] if '' in e else None # ключа '' может и не быть, это значит что нет родительского окружения
# изменить значение переменной, если таковая была была определена, либо определить ее в текущем окружении
if op == 'set': (env if e is None else e)[arg] = stack.pop()
# положить на стек значение, либо вывести предупреждение о неопределенной переменной
elif op == 'get':
if e: stack.append(e[arg])
else: print('undefined variable %s' % arg)
```
В нашей виртуальной машине будет возможность передавать и возвращать функции из функций, соответственно, будем реализовывать замыкания. Самым простым способом. Когда мы будем встречать команду создания новой функции, эта функция будет запоминать в каком окружении (ассоциативном массиве *переменная: значение*) она была создана. Таким образом мы сможем писать такое на нашем языке высокого уровня (который будет компилироваться в байткод для нашей машины):
```
make-person = fn(name, age) {
return fn() { // запомнила значения name и age
print name, age++;
};
};
vasya = make-person("Vasily", 20);
petya = make-person("Peter", 24);
vasya(); // Vasily 20
vasya(); // Vasily 21
petya(); // Peter 24
petya(); // Peter 25
```
Созданием замыкания у нас будет заниматься команда `fn`. Все чт она делает: кладет на стек объект класса `closure`, у котором указаны адрес кода фукнции (на самом деле адрес метки с названием нужной фукнции) и текущее окружение.
```
elif op == 'fn':
stack.append(closure(labels[arg], env))
```
Теперь о вызовах функций.
Фукнции у нас могут быть двух типов:
* встроенные функции, например +, -, sin, cos
* определенные в коде
Обрабатываться они будут по-разному:
* встроенная функция просто вызывается виртуальной машиной и результат фукнции кладется на стек.
* чтобы вызвать определенную пользоватем фукнцию мы должны запомнить место, куда должно вернуться управление после того как фукнция закончит свое выполнение. Короче это означает мы должны сохранить значение pc и env на стеке вызовов, изменить pc на «адрес» кода функции, создать новое (локальное) окружение, в котором будет работать фукнция, родительским окружением укажем окружение, запомненное во время создания замыкания
Во время вызова функций мы будем указывать кол-во переданных аргументов n, а наш интерпретатор возьмет n элементов со стека, сделает из них массив и положит в стек, таким образом у нас функции могут принимать любое кол-во аргументов. Функции в своем коде сами будут должны разбирать массив аргументов и устанавливать соответствующие переменные.
Команда ret возвращает управление в место откуда она была вызвана.
```
# простой вызов либо вызов в хвостовой позиции
elif op == 'call' or op == 'tcall':
# берем функцию
fn = stack.pop()
# если указано кол-во аргументов то мы должны сделать из них массив
if args and arg:
stack.append(popn(arg))
# определенная в коде функция
if isinstance(fn, closure):
# если это вызов фукнции в нехвостовой позиции, то запомнить куда вернуть управление
if op == 'call':
fstack.append((pc, env))
# перейти в код фукнции
pc, env = fn.pc, {'': fn.env}
# встроенная функция
elif hasattr(fn, '__call__'):
stack.append(fn(stack.pop()))
# команда разбора аргументов
elif op == 'args':
vals = stack.pop()
if len(args) != len(vals): print 'warning: wrong arguments count: %d expected, %d given' % (len(args), len(vals))
env.update(dict(zip(args, vals)))
# return
elif op == 'ret':
# если return встретился на верхнем уровне, это означает конец выполнения программы
if not fstack: break
# возвращаем управление куда надо
pc, env = fstack.pop()
```
Полный код с лексером (для удобства) и тестовым примером: [gist.github.com/Butjok/a531316e2a32576974d2](https://gist.github.com/Butjok/a531316e2a32576974d2) | https://habr.com/ru/post/270797/ | null | ru | null |
# Quarkus: модернизация приложений на примере helloworld из JBoss EAP Quickstart
Привет всем в этом блоге, и с вами четвертый пост из серии про Quarkus! (Кстати, смотрите наш вебинар [«Это Quarkus – Kubernetes native Java фреймворк»](https://primetime.bluejeans.com/a2m/events/playback/61a77eb5-53ae-4dff-9ea6-92a9d66caf9d). Покажем, как начать «с нуля» или перенести готовые решения)
[Предыдущий пост](https://habr.com/ru/company/redhatrussia/blog/497504/) был о том, как Quarkus объединяет MicroProfile и Spring. Напомним, что [Quarkus](https://quarkus.io/) позиционируется как «сверхбыстрая субатомная Java», он же «Kubernetes-ориентированный Java-стек, заточенный под GraalVM и OpenJDK HotSpot и собранный из лучших библиотек и стандартов». Сегодня мы покажем, как модернизировать уже имеющиеся Java-приложения, задействуя возможности Quarkus, на примере [приложения helloworld из репозитория Red Hat JBoss Enterprise Application Platform (JBoss EAP) Quickstart](https://github.com/jboss-developer/jboss-eap-quickstarts/tree/7.2.0.GA/helloworld), в котором используются поддерживаемые в Quarkus технологии CDI и Servlet 3.
Здесь важно отметить, что и Quarkus, и JBoss EAP делают упор на том, чтобы использовать инструменты, максимально построенные на базе стандартов. У вас нет приложения, работающего на JBoss EAP? Не проблема, его можно легко перенести с текущего сервера приложений на JBoss EAP с помощью [Red Hat Application Migration Toolkit](https://developers.redhat.com/products/rhamt). После чего финальная и рабочая версия модернизированного кода будет доступна в репозитории [github.com/mrizzi/jboss-eap-quickstarts/tree/quarkus](https://github.com/mrizzi/jboss-eap-quickstarts/tree/quarkus), в модуле [helloworld](https://github.com/mrizzi/jboss-eap-quickstarts/tree/quarkus/helloworld).
При написании этого поста использовались [руководства по Quarkus](https://quarkus.io/guides/), в основном [Creating Your First Application](https://quarkus.io/guides/getting-started-guide) и Building a [Native Executable](https://quarkus.io/guides/building-native-image-guide.html).
### Обзаводимся кодом
Первым делом создадим локальный клон репозитория [JBoss EAP quickstarts](https://github.com/jboss-developer/jboss-eap-quickstarts):
```
$ git clone https://github.com/jboss-developer/jboss-eap-quickstarts.git
Cloning into 'jboss-eap-quickstarts'...
remote: Enumerating objects: 148133, done.
remote: Total 148133 (delta 0), reused 0 (delta 0), pack-reused 148133
Receiving objects: 100% (148133/148133), 59.90 MiB | 7.62 MiB/s, done.
Resolving deltas: 100% (66476/66476), done.
$ cd jboss-eap-quickstarts/helloworld/
```
### Смотрим, как работает исходный helloworld
Собственно, суть этого приложения понятна из названия, но мы будем модернизировать его код строго научно. Поэтому для начала посмотрим на это приложение в исходном его виде.
**Разворачиваем helloworld**
1. Открываем терминал и переходим в корень папки JBoss EAP (его можно загрузить [здесь](https://developers.redhat.com/products/eap/download)), то есть в папку EAP\_HOME.
2. Запускаем сервер JBoss EAP с дефолтным профилем:
```
$ EAP_HOME/bin/standalone.sh
```
**Примечание:** на Windows для запуска используется сценарий EAP\_HOME\bin\standalone.bat.
Через пару секунд в логе должно появится примерно следующее:
```
[org.jboss.as] (Controller Boot Thread) WFLYSRV0025: JBoss EAP 7.2.0.GA (WildFly Core 6.0.11.Final-redhat-00001) started in 3315ms - Started 306 of 527 services (321 services are lazy, passive or on-demand)
```
3. Открываем в браузере [127.0.0.1](http://127.0.0.1):8080 и видим вот это:
*Рис. 1. Домашняя страница JBoss EAP.*
4. Следуем инструкциям в руководстве [Build and Deploy the Quickstart](https://github.com/jboss-developer/jboss-eap-quickstarts#build-and-deploy-the-quickstart): разворачиваем helloworld и выполняем (из корневой папки проекта) следующую команду:
```
$ mvn clean install wildfly:deploy
```
После успешного выполнения этой команды в логе увидим примерно следующее:
```
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 8.224 s
```
Итак, первое развертывание приложения helloworld на JBoss EAP заняло чуть больше 8 секунд.
**Тестируем helloworld**
Действуя строго по руководству [Access the Application](https://github.com/jboss-developer/jboss-eap-quickstarts/tree/7.2.0.GA/helloworld#access-the-application), открываем в браузере [127.0.0.1](http://127.0.0.1):8080/helloworld и видим вот что:
*Рис. 2. Исходный Hello World из JBoss EAP.*
**Вносим изменения**
Меняем входной параметр createHelloMessage(String name) c World на Marco:
```
writer.println("" + helloService.createHelloMessage("Marco") + "
================================================
");
```
Опять выполняем следующую команду:
```
$ mvn clean install wildfly:deploy
```
Затем обновляем страницу в браузере и видим, что текст изменился:
*Рис. 3. Hello Marco в JBoss EAP.*
**Откатываем развертывание helloworld и завершаем работу JBoss EAP**
Это необязательно, но если вы хотите отменить развертывание, то это можно сделать следующей командой:
```
$ mvn clean install wildfly:undeploy
```
Чтобы завершить работу экземпляра JBoss EAP, просто нажмите Ctrl+C в окне терминала.
### Модернизируем helloworld
Теперь займемся модернизацией исходного приложения helloworld.
**Создаем новую ветку**
Создаем новую рабочую ветку после того, как закончится выполнение проекта quickstart:
```
$ git checkout -b quarkus 7.2.0.GA
```
**Меняем файл pom.xml**
Приложение мы начнем менять с файла pom.xml. Чтобы Quarkus мог вставлять в него XML-блоки, выполним следующую команду в папке helloworld:
```
$ mvn io.quarkus:quarkus-maven-plugin:0.23.2:create
```
При написании этой статьи использовалась версия 0.23.2. У Quarkus часто выходят новые версии, узнать, какая версия является самой последней, можно на сайте [github.com/quarkusio/quarkus/releases/latest](https://github.com/quarkusio/quarkus/releases/latest/).
Приведенная выше команда вставит в pom.xml следующие элементы:
* Свойство , задающее используемую версию Quarkus.
* Блок для импорта Quarkus BOM (bill of materials), чтобы не добавлять версию для каждой зависимости Quarkus.
* Плагин quarkus-maven-plugin, отвечающий за упаковку приложения и предоставляющий режим development mode.
* Профиль native для создания исполняемых файлов приложения.
Кроме того, в pom.xml мы вручную вносим следующие изменения:
1. Вытаскиваем тег из блока и размещаем его выше тега . Поскольку на следующем шаге мы удалим блок , то надо сохранить .
2. Удаляем блок , поскольку при работе с Quarkus этому приложению больше не понадобится родительский pom от JBoss.
3. Добавляем тег и размещаем его под тегом . Номер версии можно указать какой хотите.
4. Удаляем тег , поскольку это приложение больше не WAR, а обычный JAR.
5. Модифицируем следующие зависимости:
1. Меняем зависимость javax.enterprise:cdi-api на io.quarkus:quarkus-arc, удаляя provided, поскольку (согласно докам) это Quarkus-расширение обеспечивает injection зависимости CDI.
2. Меняем зависимость org.jboss.spec.javax.servlet:jboss-servlet-api\_4.0\_spec на io.quarkus:quarkus-undertow, удаляя provided, поскольку (согласно докам) это Quarkus-расширение обеспечивает поддержку servlet’ов.
3. Удаляем зависимость org.jboss.spec.javax.annotation:jboss-annotations-api\_1.3\_spec, поскольку они идет в комплекте с зависимостями, которые мы только что изменили.
Версия файла pom.xml со всеми изменениями лежит по адресу [github.com/mrizzi/jboss-eap-quickstarts/blob/quarkus/helloworld/pom.xml](https://github.com/mrizzi/jboss-eap-quickstarts/blob/quarkus/helloworld/pom.xml).
Обратите внимание, что приведенная выше команда mvn io.quarkus:quarkus-maven-plugin:0.23.2:create не только меняет файл pom.xml, но и добавляет в проект ряд компонентов, а именно, следующие файлы и папки:
* Файл mvnw and mvnw.cmd и папку .mvn: Maven Wrapper позволяет запускать проекты Maven заданной версии Maven без установки этой самой версии.
* Папка docker (в каталоге src/main/): здесь лежат примеры файлов Dockerfile для режимов native и jvm (вместе с файлом .dockerignore).
* Папка resources (в каталоге src/main/): здесь лежит пустой файл application.properties и образец стартовой страницы Quarkus index.html (подробнее см. Run the modernized helloworld ).
**Запускаем helloworld**
Чтобы протестировать приложение, используем quarkus:dev, который запускает Quarkus в режиме development mode (подробнее см. вот этот раздел в руководстве по [Development Mode](https://quarkus.io/guides/getting-started-guide#development-mode)).
**Примечание:** этот шаг ожидаемо приведет к ошибке, поскольку мы внесли еще не все необходимые изменения.
Теперь запускаем команду, чтобы проверить, как это сработает:
```
$ ./mvnw compile quarkus:dev
[INFO] Scanning for projects...
[INFO]
[INFO] ----------------< org.jboss.eap.quickstarts:helloworld >----------------
[INFO] Building Quickstart: helloworld quarkus
[INFO] --------------------------------[ war ]---------------------------------
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ helloworld ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 2 resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ helloworld ---
[INFO] Nothing to compile - all classes are up to date
[INFO]
[INFO] --- quarkus-maven-plugin:0.23.2:dev (default-cli) @ helloworld ---
Listening for transport dt_socket at address: 5005
INFO [io.qua.dep.QuarkusAugmentor] Beginning quarkus augmentation
INFO [org.jbo.threads] JBoss Threads version 3.0.0.Final
ERROR [io.qua.dev.DevModeMain] Failed to start quarkus: java.lang.RuntimeException: io.quarkus.builder.BuildException: Build failure: Build failed due to errors
[error]: Build step io.quarkus.arc.deployment.ArcProcessor#validate threw an exception: javax.enterprise.inject.spi.DeploymentException: javax.enterprise.inject.UnsatisfiedResolutionException: Unsatisfied dependency for type org.jboss.as.quickstarts.helloworld.HelloService and qualifiers [@Default]
- java member: org.jboss.as.quickstarts.helloworld.HelloWorldServlet#helloService
- declared on CLASS bean [types=[javax.servlet.ServletConfig, java.io.Serializable, org.jboss.as.quickstarts.helloworld.HelloWorldServlet, javax.servlet.GenericServlet, javax.servlet.Servlet, java.lang.Object, javax.servlet.http.HttpServlet], qualifiers=[@Default, @Any], target=org.jboss.as.quickstarts.helloworld.HelloWorldServlet]
at io.quarkus.arc.processor.BeanDeployment.processErrors(BeanDeployment.java:841)
at io.quarkus.arc.processor.BeanDeployment.init(BeanDeployment.java:214)
at io.quarkus.arc.processor.BeanProcessor.initialize(BeanProcessor.java:106)
at io.quarkus.arc.deployment.ArcProcessor.validate(ArcProcessor.java:249)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at io.quarkus.deployment.ExtensionLoader$1.execute(ExtensionLoader.java:780)
at io.quarkus.builder.BuildContext.run(BuildContext.java:415)
at org.jboss.threads.ContextClassLoaderSavingRunnable.run(ContextClassLoaderSavingRunnable.java:35)
at org.jboss.threads.EnhancedQueueExecutor.safeRun(EnhancedQueueExecutor.java:2011)
at org.jboss.threads.EnhancedQueueExecutor$ThreadBody.doRunTask(EnhancedQueueExecutor.java:1535)
at org.jboss.threads.EnhancedQueueExecutor$ThreadBody.run(EnhancedQueueExecutor.java:1426)
at java.lang.Thread.run(Thread.java:748)
at org.jboss.threads.JBossThread.run(JBossThread.java:479)
Caused by: javax.enterprise.inject.UnsatisfiedResolutionException: Unsatisfied dependency for type org.jboss.as.quickstarts.helloworld.HelloService and qualifiers [@Default]
- java member: org.jboss.as.quickstarts.helloworld.HelloWorldServlet#helloService
- declared on CLASS bean [types=[javax.servlet.ServletConfig, java.io.Serializable, org.jboss.as.quickstarts.helloworld.HelloWorldServlet, javax.servlet.GenericServlet, javax.servlet.Servlet, java.lang.Object, javax.servlet.http.HttpServlet], qualifiers=[@Default, @Any], target=org.jboss.as.quickstarts.helloworld.HelloWorldServlet]
at io.quarkus.arc.processor.Beans.resolveInjectionPoint(Beans.java:428)
at io.quarkus.arc.processor.BeanInfo.init(BeanInfo.java:371)
at io.quarkus.arc.processor.BeanDeployment.init(BeanDeployment.java:206)
... 14 more
```
Так, не работает… А почему?
Исключение UnsatisfiedResolutionException указывает на класс HelloService, который является членом класса HelloWorldServlet (java member: org.jboss.as.quickstarts.helloworld.HelloWorldServlet#helloService). Проблема в том, что HelloWorldServlet нужен инжектированный экземпляр HelloService, а его не получается найти (хотя оба этих класса и находятся в одном и том же пакете).
Самое время вернуться к [документации](https://quarkus.io/guides/) и почитать, как в Quarkus работает [Inject](https://habr.com/ru/users/inject/), а следовательно, и [Contexts and Dependency Injection](https://quarkus.io/guides/cdi-reference) (CDI). Поэтому открываем руководство Contexts and Dependency Injection и в разделе [Bean Discovery](https://quarkus.io/guides/cdi-reference#bean_discovery) читаем: «Bean-класс, у которого нет определяющей bean аннотации, не ищется».
Смотрим класс HelloService – в нем действительно нет такой аннотации. Поэтому ее надо добавить, чтобы Quarkus мог искать и находить bean. И поскольку это stateless-объект, мы вполне можем добавить аннотацию @ApplicationScoped следующим образом:
```
@ApplicationScoped
public class HelloService {
```
**Примечание:** здесь среда разработки может попросить вас добавить требуемый пакет (см. строку ниже), и это придется сделать вручную, вот так:
```
import javax.enterprise.context.ApplicationScoped;
```
Если сомневаетесь, какую область scope надо использовать в том случае, когда для исходного bean’а она не задана вообще, проштудируйте документацию [JSR 365: Contexts and Dependency Injection for Java 2.0—Default scope](https://docs.jboss.org/cdi/spec/2.0/cdi-spec.html#default_scope).
Теперь опять пробуем запустить приложение командой ./mvnw compile quarkus:dev:
```
$ ./mvnw compile quarkus:dev
[INFO] Scanning for projects...
[INFO]
[INFO] ----------------< org.jboss.eap.quickstarts:helloworld >----------------
[INFO] Building Quickstart: helloworld quarkus
[INFO] --------------------------------[ war ]---------------------------------
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ helloworld ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 2 resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ helloworld ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 2 source files to /home/mrizzi/git/forked/jboss-eap-quickstarts/helloworld/target/classes
[INFO]
[INFO] --- quarkus-maven-plugin:0.23.2:dev (default-cli) @ helloworld ---
Listening for transport dt_socket at address: 5005
INFO [io.qua.dep.QuarkusAugmentor] (main) Beginning quarkus augmentation
INFO [io.qua.dep.QuarkusAugmentor] (main) Quarkus augmentation completed in 576ms
INFO [io.quarkus] (main) Quarkus 0.23.2 started in 1.083s. Listening on: http://0.0.0.0:8080
INFO [io.quarkus] (main) Profile dev activated. Live Coding activated.
INFO [io.quarkus] (main) Installed features: [cdi]
```
Теперь все проходит без ошибок.
**Запускаем модернизированный helloworld**
Как и написано в логе, открываем в браузере [0.0.0.0](http://0.0.0.0):8080 (стартовая страница Quarkus по умолчанию) и видим вот что:
*Рис. 4. Стартовая страница Quarkus dev.*
В аннотации WebServlet у этого приложения прописано следующее определение контекста:
```
@WebServlet("/HelloWorld")
public class HelloWorldServlet extends HttpServlet {
```
Поэтому идем в браузере на [0.0.0.0](http://0.0.0.0):8080/HelloWorld и видим следующее:
*Рис. 5: Страница The Quarkus dev для приложения Hello World.*
Ну вот, всё работает.
А теперь вносим изменения в код. Обратите внимание, что команда ./mvnw compile quarkus:dev все еще работает, и мы не собираемся ее останавливать. Теперь попробуем применить те же самые – тривиальнейшие – изменения к самому коду и посмотрим, как Quarkus облегчает жизнь разработчику:
```
writer.println("" + helloService.createHelloMessage("Marco") + "
================================================
");
```
Сохраняем файл и затем обновляем веб-страницу, чтобы увидеть надпись Hello Marco, как показано на скрине ниже:
*Рис. 6. Страница Hello Marco в Quarkus dev.*
Теперь проверим вывод в терминале:
```
INFO [io.qua.dev] (vert.x-worker-thread-3) Changed source files detected, recompiling [/home/mrizzi/git/forked/jboss-eap-quickstarts/helloworld/src/main/java/org/jboss/as/quickstarts/helloworld/HelloWorldServlet.java]
INFO [io.quarkus] (vert.x-worker-thread-3) Quarkus stopped in 0.003s
INFO [io.qua.dep.QuarkusAugmentor] (vert.x-worker-thread-3) Beginning quarkus augmentation
INFO [io.qua.dep.QuarkusAugmentor] (vert.x-worker-thread-3) Quarkus augmentation completed in 232ms
INFO [io.quarkus] (vert.x-worker-thread-3) Quarkus 0.23.2 started in 0.257s. Listening on: http://0.0.0.0:8080
INFO [io.quarkus] (vert.x-worker-thread-3) Profile dev activated. Live Coding activated.
INFO [io.quarkus] (vert.x-worker-thread-3) Installed features: [cdi]
INFO [io.qua.dev] (vert.x-worker-thread-3) Hot replace total time: 0.371s
```
Обновление страницы триггернуло детектирование изменений в исходном коде, и Quarkus автоматически выполнил процедуру «стоп-старт». И все это выполнилось всего за 0.371 секунды (вот она, та самая «сверхбыстрая субатомная Java»).
**Выполняем сборку helloworld в пакет JAR**
Теперь, когда код работает как надо, упакуем его следующей командой:
```
$ ./mvnw clean package
```
Эта команда создает два JAR-файла в папке /target: файл helloworld-.jar, который представляет собой стандартный артефакт, собранный Maven-командой вместе классами и ресурсами проекта. И файл helloworld--runner.jar, представляющий собой исполняемый JAR.
Обратите внимание, что это не убер-jar, поскольку все зависимости просто скопированы в папку /target/lib (а не упакованы в файл JAR). Поэтому, чтобы запустить это JAR из другой папки или на другом хосте, туда надо скопировать как сам JAR-файл, так и папку /lib, учитывая что элемент Class-Path в файле MANIFEST.MF в пакете JAR содержит явное перечисление JAR’ов из папки lib.
Чтобы узнать, как создавать приложения убер-jar, обратитесь к руководству [Uber-Jar Creation](https://quarkus.io/guides/maven-tooling#uber-jar-maven).
**Запускаем helloworld, упакованный в JAR**
Теперь можно запускать наш JAR с помощью стандартной команды java:
```
$ java -jar ./target/helloworld--runner.jar
INFO [io.quarkus] (main) Quarkus 0.23.2 started in 0.673s. Listening on: http://0.0.0.0:8080
INFO [io.quarkus] (main) Profile prod activated.
INFO [io.quarkus] (main) Installed features: [cdi]
```
После того, как все это выполнится, зайдите в браузере на [0.0.0.0](http://0.0.0.0):8080 и проверьте, что все работает как надо.
**Собираем helloworld в нативный исполняемый файл**
Итак, наш helloworld работает как standalone-приложение Java, используя зависимости Quarkus. Но можно пойти дальше и превратить его в нативный исполняемый файл.
**Устанавливаем GraalVM**
Прежде всего, для этого надо установить необходимые инструменты:
1. Скачиваем GraalVM 19.2.0.1 с [github.com/oracle/graal/releases/tag/vm-19.2.0.1](https://github.com/oracle/graal/releases/tag/vm-19.2.0.1).
2. Разворачиваем загруженный архив:
```
$ tar xvzf graalvm-ce-linux-amd64-19.2.0.1.tar.gz
```
3. Идем в папку untar.
4. Запускаем приведенную ниже команду, чтобы скачать и добавить нативный образ:
```
$ ./bin/gu install native-image
```
5. Прописываем папку, созданную на шаге 2, в переменную среды GRAALVM\_HOME:
```
$ export GRAALVM_HOME={untar-folder}/graalvm-ce-19.2.0.1)
```
Дополнительные сведения и инструкции по установке на других ОС можно найти в руководстве [Building a Native Executable—Prerequisites](https://quarkus.io/guides/building-native-image-guide.html#prerequisites).
**Выполняем сборку helloworld в нативный исполняемый файл**
Читаем руководство [Building a Native Executable—Producing a native executable](https://quarkus.io/guides/building-native-image-guide.html#producing-a-native-executable): «А теперь создадим нативный исполняемый файл для нашего приложения, чтобы сократить время его запуска и размер на диске. Исполняемый файл будет иметь все необходимое для запуска приложения, включая JVM-машину (вернее, ее усеченную версию, содержащую лишь то, что требуется для выполнения приложения) и само наше приложение».
Чтобы создать нативный исполняемый файл, надо включить native-профиль Maven:
```
$ ./mvnw package -Pnative
```
У нас сборка заняла одну минуту и 10 секунд, а итоговый файл helloworld--runner f был создан в папке /target.
**Запускаем нативный исполняемый файл helloworld**
На предыдущем шаге мы получили исполняемый файл /target/helloworld--runner. Теперь запустим его:
```
$ ./target/helloworld--runner
INFO [io.quarkus] (main) Quarkus 0.23.2 started in 0.006s. Listening on: http://0.0.0.0:8080
INFO [io.quarkus] (main) Profile prod activated.
INFO [io.quarkus] (main) Installed features: [cdi]
```
Опять открываем в браузере [0.0.0.0](http://0.0.0.0):8080 и проверяем, что все работает как надо.
Продолжение следует!
Мы считаем, что рассмотренный в этом посте (пусть и на простейшем примере) метод модернизации Java-приложений с использованием возможностей Quarkus стоит активно применять в реальном жизни. При этом вы, скорее всего, столкнетесь с рядом проблем, решение которых мы частично рассмотрим в следующем посте, где речь пойдет о том, как замерять расход памяти для оценки улучшения производительности, важной части всего процесс модернизации приложений.
При этом вы, скорее всего, столкнетесь с рядом проблем, решение которых мы частично рассмотрим в следующем, заключительном, посте нашей серии про Quarkus. Речь пойдет о том, как замерять расход памяти для оценки улучшения производительности, важной части всего процесса модернизации приложений – это и другое по [ссылке](https://habr.com/ru/company/redhatrussia/blog/501746/). | https://habr.com/ru/post/499524/ | null | ru | null |
# Kotlin и свои почти языковые конструкции
Скорее всего, из разработчиков, пользующихся Java, и в особенности Android-разработчиков многие уже знают про [Kotlin](http://kotlinlang.org/). Если нет, то никогда не поздно узнать. Особенно если Java не устраивает вас чем-то как язык — что наверняка так — или если вы владеете Scala, но и этот язык вам не подходит, что тоже не исключено.
Если кратко, то Kotlin — это статически типизированный язык, ориентирующийся на JVM, Android (компилируется в байт-код Java) и веб (компилируется в JavaScript). JetBrains, разработчик языка, ставили своей целью лаконичный и понятный синтаксис, быструю компиляцию кода и типобезопасность. Язык пока находится в предрелизном состоянии, но всё стремительно движется к релизу.
К слову, после Java «переучиться» на Kotlin не составит никакого труда, в этом поможет и понятный (субъективно) синтаксис, и полная совместимость с кодом на Java в обе стороны, что позволяет Java-программисту использовать весь привычный набор библиотек.
Ещё одной целью разработчиков языка была возможность его гибкого использования, в том числе для создания библиотек, внешне похожих на [DSL](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%B4%D0%BC%D0%B5%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B9_%D1%8F%D0%B7%D1%8B%D0%BA), и собственных конструкций (хороший [пример](http://kotlinlang.org/docs/reference/type-safe-builders.html) типобезопасного builder'а для HTML; [статья](http://habrahabr.ru/post/168571/) про реализацию yield). У Kotlin есть несколько фич, которые позволят решать эти задачи эффективно и красиво. Давайте с ними познакомимся.
### Расширения (Extensions)
В Kotlin есть возможность дополнять функционал произвольного класса, не наследуясь от него, функциями (и свойствами) расширения. Такая же возможность есть, например, в C#. Стоит отметить, что поведение функций расширения отличается от member functions: вызовы функций расширения разрешаются статически, по объявленному типу, а не виртуально.
Пример:
```
fun String.words(): List {
return this.split("\\W".toRegex())
}
//сокращённая запись функции, состоящей только из return statement
fun List.rotate(n: Int): List = drop(n) + take(n)
val str = "a quick brown fox jumps over the lazy dog"
val words = s.words()
val yoda = words.rotate(5)
println(yoda.joinToString(" ") // over the lazy dog a quick brown fox jumps
```
toRegex(), drop(n), take(n) и joinToString(" ") в примере — это тоже функции расширения.
### Альтернативный синтаксис для вызова функций
1. Функцию экземпляра или функцию расширения, имеющую только один аргумент, можно вызывать в инфиксной форме:
```
val squares = (1..100) map { i -> i * i }
//эквивалентно (1..100).map({i -> i * i })
val multOfThree = squares filter { it % 3 == 0 }
//it можно использовать в лямбда-выражении с одним аргументом для его обозначения
```
2. Если последний аргумент функции имеет функциональный тип, то при вызове функции можно соответствующее лямбда-выражение писать за круглыми скобками, просто в фигурных:
```
val list = arrayListOf(1, 2, 3)
with(list) {
add(4)
add(5)
add(6)
removeIf { it % 2 == 0 }
}
//эквивалентно with(list, { ... })
```
### Встраиваемые (inline) функции
В Kotlin есть аннотация `@inline`, которой можно пометить функцию. После этого при компиляции код этой функции, и её функциональных аргументов будет подставляться в места вызова. С одной стороны, это даёт некоторые новые возможности (non-local return, reified generics), с другой — есть ограничение, что функциональные аргументы inline-функции в её теле можно только вызывать или передавать в другие inline-функции. Основной же действие `@inline` — на производительность: происходит меньше вызовов функций и, что важно, не создаются анонимные классы и их объекты для каждого лямбда-выражения.
Большая часть функций расширения из стандартной библиотеки вроде тех же `map` и `filter`.
Небольшой пример:
```
@inline fun Iterable.withEach(action: T.() -> Unit) = forEach { it.action() }
//в теле метода:
var i = 0
val lists = (0..5) map { ArrayList() }
lists.withEach { add(++i) }
```
Несмотря на то, что этот код пестрит лямбда-выражениями, ни одного анонимного класса для них создано не будет, и `i` даже не попадёт в closure. Просто праздник!
Попробуем?
----------
Посмотрим, что мы можем сделать со всем этим арсеналом — предположим, что мы хотим сделать такую ~~довольно бесполезную~~ конструкцию:
```
val a = someInt()
val b = someList()
val c = (a % b.size()) butIf (it < 0) { it + b.size() }
//аналогично (a % b.size()) let { if (it < 0) it + b.size() else it }
```
Прямо так, к сожалению, не получится, но постараемся сделать что-то похожее.
#### Первая попытка: функция с двумя функциональными аргументами
```
fun T.butIf(condition: (T) -> Boolean, thenFunction: (T) -> T): T {
if (condition(this)) {
return thenFunction(this)
}
return this
}
```
Вот так её можно использовать:
```
val c = (a % b.size()).butIf({it < 0}) {it + b.size()}
```
Если сюда добавить inline, должно получиться достаточно эффективно. Позже посмотрим, насколько, а пока попробуем добиться более красивого синтаксиса для этой конструкции.
#### Вторая попытка: красивый синтаксис
```
abstract class _ButIfPrefix
constructor(var originalValue: T) {
abstract fun then(thenFunction: (T) -> T): T
object trueBranch : \_ButIfPrefix(null) {
override final inline fun then(thenFunction: (Any?) -> Any?) = thenFunction(originalValue)
}
object falseBranch : \_ButIfPrefix(null) {
override final inline fun then(thenFunction: (Any?) -> Any?) = originalValue
}
}
fun T.butIf(condition: (T) -> Boolean): \_ButIfPrefix {
val result = (if (condition(this))
\_ButIfPrefix.trueBranch else
\_ButIfPrefix.falseBranch) as \_ButIfPrefix
result.originalValue = this
return result
}
```
Этот вариант не рассчитан на многопоточность! Для использования его в нескольких потоках нужно будет завернуть экземпляры в ThreadLocal, что ещё немного ухудшит производительность.
Здесь будет цепочка из двух инфиксных вызовов, первый — функция расширения на самом объекте, второй — функция экземпляра `_ButIfPrefix`. Пример использования:
```
val c = (a % b.size()) butIf { it < 0 } then { it + b.size() }
```
#### Третья попытка: каррирование
Попробуем так:
```
fun T.butIf0(condition: (T) -> Boolean): ((T) -> T) -> T {
return inner@ { thenFunction ->
return@inner if (condition(this)) thenFunction(this) else this
}
}
```
Использование:
```
val c = (a % b.size()).butIf { it < 0 } ({ it + b.size() })
```
По сравнению с первой попыткой изменилось расположение скобок в вызове. :)
Учитывая inline, мы можем ожидать, что работать этот вариант будет так же, как первый.
Это можно проверить, взглянув на байт-код: у IntelliJ IDEA есть утилита, показывающая байт-код, в который скомпилируется код на Kotlin, на лету, и даже можно посмотреть, как будет отличаться байт-код с `@inline` и без.
Производительность
------------------
Давайте теперь посмотрим, что будет с производительностью нашей конструкции в разных вариантах.
Тестировать будем на таком примере:
```
val range = -20000000..20000000
val list = ArrayList()
//warm-up
for (i in range) {
list add i % 2
}
list.clear()
val timeBefore = System.currentTimeMillis()
for (i in range) {
val z = (i % 2) butIf { it < 0 } then { it + 2 } //и аналоги
list add z
}
println("${System.currentTimeMillis() - timeBefore} ms")
```
Задно добавим к сравнению такой код, который будет эталоном производительности:
```
...
val d = it % 2
val z = if (d < 0) d + 2 else d
...
```
По итогам пятидесятикратного запуска с последующим усреднением времени получилась следующая таблица:
| Реализация | Без inline | C inline |
| --- | --- | --- |
| Эталон | 319 ms |
| I попытка | 406 ms | 348 ms |
| II попытка | 610 ms | 520 ms |
| II попытка с ThreadLocal | 920 ms | 876 ms |
| III попытка | 413 ms | 399 ms |
Как видно, производительность более простых первого и третьего вариантов достаточно близка к эталону, в некоторых случаях читаемость кода можно «купить» за такое увеличение времени работы. Вариант с более красивым синтаксисом устроен сложнее и работает, соответственно, дольше, но если хочется конструкций, совсем похожих на DSL, то и он вполне применим.
### Итого
Kotlin предоставляет действительно гибкие возможности для «кастомизации» языка, но за них иногда будет нужно платить производительностью. Аннотация `@inline` может помочь улучшить ситуацию, если в вашем коде есть функции первого порядка. В любом случае, думаю, у вас найдутся хорошие сценарии применения для всего этого.
Удачи! | https://habr.com/ru/post/266817/ | null | ru | null |
# Нет – взломам серверов! Советы по проверке и защите
Подозреваете, что Linux-сервер взломан? Уверены, что всё в порядке, но на всякий случай хотите повысить уровень безопасности? Если так – вот несколько простых советов, которые помогут проверить систему на предмет взлома и лучше её защитить.
[](https://habrahabr.ru/company/ruvds/blog/314166/)
### Проверка
Для того, чтобы узнать, не взломали ли ваш сервер, скажем, работающий под управлением Ubuntu, стоит кое-что проверить.
#### ▍Данные последнего входа в систему
Выясните данные последнего входа в систему. Делается это с помощью команды lastlog.
```
$>lastlog
```
#### ▍История команд
Взгляните на историю команд, узнайте, когда именно их вводили:
```
$>history
```
Если список команд выводится без даты – настройте соответствующие параметры утилиты history.
#### ▍Журнал auth.log
Следующий способ проверки – просмотр файла /var/log/auth.log. Например, с помощью такой команды:
```
$>sudo vi /var/log/auth.log
```
Здесь можно найти список всех, кто пытался подключиться к серверу по SSH.
#### ▍IP-адреса
Для того, чтобы выяснить IP-адреса, с которых подключались к серверу, воспользуйтесь такой командой:
```
$>zgrep sshd /var/log/auth.log* | grep rhost | sed -re 's/.*rhost=([^ ]+).*/\1/' | sort –u
```
#### ▍Журналы Apache
Проверьте журналы Apache:
```
$>sudo vi /var/log/apache2/access.log
$>sudo vi /var/log/apache2/error.log
```
#### ▍Поиск подозрительных процессов
Если вы уверены в том, что сервер взломан, разыщите процесс злоумышленника. Например, список всех процессов можно получить такой командой:
```
$>ps aux | less
```
#### ▍Список заданий cron
Анализируя сервер на предмет взлома, полезно будет проверить список заданий cron, в который злоумышленник вполне мог добавить что-то своё.
```
$>crontab -l | grep -v ‘^#’
```
Независимо от того, выявила ли проверка попытки взлома, безопасности много не бывает. Поэтому вот – несколько советов по защите сервера.
### Защита
Рекомендации по защите сервера, в основном, касаются отслеживания и блокирования подозрительной активности, а также регулярного обновления программного обеспечения.
#### ▍Запрет входа root-пользователей по SSH
Для повышения уровня безопасности сервера стоит запретить вход root-пользователей по SSH.
```
$>sudo vi /etc/ssh/sshd_config
PermitRootLogin no
```
#### ▍Автоматические обновления
Включите автоматические обновления безопасности с использованием пакета unattended-upgrades. Сначала его надо установить:
```
$>sudo apt-get install unattended-upgrades
```
Следующий шаг – настройка:
```
$>sudo dpkg-reconfigure -plow unattended-upgrades
```
Пакет можно вызвать и самостоятельно:
```
$>sudo unattended-upgrade
```
#### ▍Настройка блокировок
Установите пакет fail2ban. Для того, чтобы блокировать с его помощью подозрительных SSH-пользователей, воспользуйтесь [этим](https://www.digitalocean.com/community/tutorials/how-to-protect-ssh-with-fail2ban-on-ubuntu-12-04) руководством, поле чего [настройте](http://www.the-art-of-web.com/system/fail2ban-log/) систему отчётов.
Для того, чтобы узнать, сколько раз fail2ban заблокировал некий IP-адрес, воспользуйтесь такой командой:
```
$>sudo awk '($(NF-1) = /Ban/){print $NF}' /var/log/fail2ban.log | sort | uniq -c | sort –n
```
Для того, чтобы просмотреть весь файл журнала fail2ban, введите следующее:
```
$>sudo zgrep -h "Ban "/var/log/fail2ban.log* | awk '{print $NF}' | sort | uniq –c
```
Для поиска проблемных подсетей подойдёт такая команда:
```
$>sudo zgrep -h "Ban " /var/log/fail2ban.log* | awk '{print $NF}' | awk -F\. '{print $1"."$2"."}' | sort | uniq -c | sort -n | tail
```
Если анализ файлов журнала показывает, что атаки из некоторой подсети происходят регулярно, её можно заблокировать на постоянной основе. Перед этим, однако, стоит проверить, к какой стране принадлежит подсеть.
Например, вот как заблокировать подключения к sshd-порту из подсети 221.229.\*.\*:
```
$>sudo iptables -I INPUT -p tcp -s 221.229.0.0/255.255.0.0 --dport ssh -j REJECT --reject-with tcp-reset
```
Для того, чтобы узнать о том, что именно было заблокировано правилами iptables, можно воспользоваться такой командой:
```
$>sudo iptables -vnL INPUT --line-numbers
```
Для того, чтобы правила iptables сохранялись после перезагрузки сервера, установите в Ubuntu пакет iptables-persistent.
```
$>sudo apt-get install iptables-persistent
$>cat /etc/iptables/rules.v4
```
Если вы отредактировали правила iptables, используйте такую команду:
```
$>sudo bash -c "iptables-save > /etc/iptables/rules.v4"
```
Файл с правилами не рекомендуется править вручную, так как его формат важен для того, чтобы всё работало как надо.
### Итоги
Мы рассказали о методах проверки Linux-серверов на предмет взлома и об улучшении их защиты. Надеемся, наши советы помогут вам повысить уровень информационной безопасности ваших систем. | https://habr.com/ru/post/314166/ | null | ru | null |
# Виджет хаброметра для Dashboard
Всем хорошего хабрадня!
По мотивам своего [недавнего поста](http://goo.gl/mPfzu) о создании виджетов для дашборда я решил сделать ещё один несложный виджет. Он умеет всего лишь отображать [хаброметр](http://habrometr.ru/) выбранного в настройках пользователя.
[Скачать архив с виджетом](http://goo.gl/mlNRJ)
[Исходники на гитхабе](http://goo.gl/fvJ5u)
Он ну очень простой! Всего лишь одна картинка, загружаемая из сети, и поле ввода имени пользователя. Но при создании всё равно пришлось столкнуться с проблемой — url картинки всегда одинаков, и дашборд её кэширует (установка почему-то не помогла). Но это обходится достаточно просто: к урлу картинки каждый раз добавляется рандомный парамет, к примеру `http://habrometr.ru/habrometr_425x120_alizar.png?rand=1986522`. Спасибо создателю хаброметра [feedbee](https://habrahabr.ru/users/feedbee/) за игнорирование параметров запроса (да и за сам хаброметр)! =)
Я долго сомневался, заслуживает ли такая «поделка» отдельной статьи, но решил, что пусть повисит — может кому пригодится. Кстати, неплохо смотрится рядом с виджетом из моей предыдущей статьи. | https://habr.com/ru/post/141049/ | null | ru | null |
# Ленивый деплой Django проекта UWSGI + NGINX (UBUNTU 20.04)
Здравствуйте!
Хочу представить вам пошаговую инструкцию по деплою django проекта.
Сразу скажу, что используя мою краткую инструкцию вы не поймете механику развертывания. По сути, это просто список команд для деплоя. Тут не будет никаких подробностей касательно работы UWSGI, NGINX и самого Django. Я просто помогу быстро добраться до цели, а цель у нас одна - задеплоить уже наконец этот \*\*\*\* проект!
(Инструкция тестировалась на VPS Ubuntu 20.04 с Django 3.2.8, python3.8, NGINX 1.18.0, UWSGI 2.0.20)
Заходим в консоль линукс сервера и вперед!
`sudo apt update
sudo apt upgrade
sudo apt-get install nginx uwsgi
sudo apt-get install uwsgi-plugin-python3`
Переходим в директорию /var
`cd /var`
Создаем себе внутри папку для дальнейшей работы
`mkdir work
cd work`
Создаем папку под статику и предоставляем пользователю www-data права на неё. (UWSGI и NGINX будут работать от лица www-data)
`mkdir static
chown www-data /var/work/static`
Проверим версию пайтона, установим пакет для вирт. окружения и создадим его
`python3 -V
sudo apt install python3.8-venv
python3 -m venv venv`
Активируем окружение
`. ./venv/bin/activate`
`pip install django` (и другие или загрузите их позже из requirements.txt)
`git clone https://github.com/nick_name/project.git` (или переместите в текущую папку ваш проект любым другим способом)
(В инструкции я использую проект со стандартной архитектурой вида:
`projectname/
...
manage.py
projectname/
...
settings.py
wsgi.py
...`
)
Переходим в файл settings.py вашего проекта джанго и редактируем его.
Необходимо добавить ip вашего сервера в ALLOWED\_HOSTS должно получиться что-то вроде ['1.1.1.1', '127.0.0.1']
добавить STATIC\_ROOT = '/var/work/static'
Вернитесь в папку с manage.py
`cd /var/work/имя вашего проекта`
Далее подготовим сам Django проект. Проведем миграции и соберем статику в папку, которую мы ранее создали в work.
`python3 manage.py makemigrations
python3 manage.py migrate
python3 manage.py collectstatic
python3 manage.py runserver`
Если есть ошибка в проекте - устранить, если не хватает библиотек - установить через pip install
Если ошибок не возникло - ваш Django проект в порядке, если нет, то исправляйте ошибки в нем. Советую сверить ту ли версию Django вы поставили себе на сервер.
Близимся к концу. Виртуальное окружение можно выключить. Сделаем это командой:
`deactivate`
Далее откроем файл nginx.conf и проверим в нем параметр user, он должен быть www-data.
`user www-data;`
`nano /etc/nginx/nginx.conf`
далее создадим и заполним конфиг my\_app (для nginx)
nano /etc/nginx/sites-enabled/my\_app
`server {
listen 81;
server_tokens off;
server_name 0.0.0.0;`
`location / {
include uwsgi_params;
uwsgi_pass unix:///run/uwsgi/app/myapp/socket;
}`
`location /static/ {
alias /var/work/static/;
}`
`}`
далее создадим и заполним конфиг myapp.ini (для uwsgi)
`[uwsgi]
chdir = /var/work/projectname
env = DJANGO_SETTINGS_MODULE = projectname.settings
wsgi-file = /var/work/projectname/projectname/wsgi.py
workers = 1
max-requests = 5000
plugins = python3
home = /var/work/venv
pythonpath = /var/work/venv/lib/python3.8/site-packages
processes = 5
threads = 2
master = true
die-on-term = true
socket = /run/uwsgi/app/myapp/socket
chmod-socket = 664
vacuum = true
uid = www-data
gui = www-data`
!!! Я использую python3 (3.8) если у вас другой, то измените пункты, связанные с python
Или используйте версию 3.8)) !!!
projectname ВЕЗДЕ измените на имя вашего проекта
далее перезапустим uwsgi и nginx
service uwsgi restart
service nginx restart
После перезапуска nginx и uwsgi сайт должен быть доступен по адресу http://IP вашего сервера:81
ГДЕ СМОТРЕТЬ ЛОГИ?
/var/log/nginx
/var/log/uwsgi/app
Надеюсь, это вам помогло. В интернете ничего из того, что я смотрел не работало "из коробки". Каждый раз возникала ошибка то тут, то там.. Ну или это была огромная "простыня" текста, читать которую было слишком долго. Да и после стольких ошибок не было доверия к тем или иным туториалам.
Составив эту инструкцию я создал несколько новых серверов на Ubuntu и протестировал каждый шаг.
Буду рад комментариям. Пишите, если у вас возникли какие-то ошибки! | https://habr.com/ru/post/645757/ | null | ru | null |
# Как я вырос без Кодабры
Двадцать лет назад я написал первую строчку кода: `10 CLS`. Именно так, не здороваясь с миром и не представляя, что меня ждет, я ввел следом `RUN` и электронная машина также бесцеремонно бросила мне первый вызов, стерев все на экране телевизора с насмешкой "ОК". Я был удивлен, но не тому, что могу приказать машине что-то сделать, а тому, что она может мне отвечать. Мне было 7, и это история о непростых отношениях ребенка с компьютером, через призму лет глазами состоявшегося программиста.
Ко времени написания первой программы, я был уже "продвинутым пользователем" бытовой электроникой в доме. Как известно любому ребенку, если что-то имеет кнопки или ручки, то эти кнопки должны быть непременно нажаты, а ручки выкручены до упора. К счастью, мне никто не запрещал заниматься этим вволю и, как и ожидалось, однажды ручек стало недостаточно и в ход пошли болты и шурупы, явив моему взору чудесный мир печатных плат и микросхем. Отец явно одобрял мои наклонности разбирать все подряд и попытался научить меня еще и собирать эти вещи обратно, преподавая основы радиотехники на практике. Мне нравилось паять и собирать простые устройства, но большого успеха я тут не достиг. Физический мир выглядел слишком уж скучно по сравнению с появившейся у меня в то время игровой приставкой Dendy. И здесь я достиг поистине выдающихся успехов.
Важным вкладом игр в развитие компьютерных навыков у ребенка, на мой взгляд, является необходимость постоянного взаимодействия с разными пользовательскими интерфейсами, которые, в отличие от компьютерных программ, во всех играх разные, но выполняют стандартные функции. Это быстро развивает "компьютерную смекалку", подсознательно выделяя те или иные общие шаблоны (например, настройки игры), позволяя со временем достаточно быстро ориентироваться даже на незнакомом экране. И, конечно же, кнопки. Освоив геймпад, ребенок без труда освоит и любую клавиатуру.
Я тратил на приставку почти все свободное время, которое выделяли мне родители на телевизор. Нетрудно понять, что увлечь ребенка чем-то другим, когда у него есть игры, задача не из легких. Но однажды родителям удалось провернуть поистине грандиозную уловку, купив для меня "Обучающий компьютер Сюбор". Особенностью этого устройства было то, что он обладал полноразмерной клавиатурой IBM, являясь по факту тем же Dendy в комплекте с "обучающим картриджем", на котором было записано несколько программ, поддерживающих ввод с этой клавиатуры. Ностальгирующий читатель может перейти по ссылке на сайт "[Железные призраки прошлого](http://www.phantom.sannata.ru/articles/subor.shtml)", чтобы вспомнить эту легендарную приставку. Программы на "обучающем картридже" хоть и были не слишком хорошего качества, но включали в себя целых два интерпретатора языка программирования Basic. Один назывался "G-BASIC", а второй "F-BASIC". Сейчас мне известно, что это были сильно урезанные клоны [Famicom BASIC](https://en.wikipedia.org/wiki/Family_BASIC) и [Applesoft Basic](https://en.wikipedia.org/wiki/Applesoft_BASIC) соответственно. Документация по "F-BASIC" отсутствовала практически полностью, поэтому сколь-нибудь освоить его мне не удалось. "G-BASIC" же оказался достаточно интересной вещью, потому что содержал в себе редактор графики на основе паттернов, словно вырезанных из какой-то версии "Марио" и набор встроенных спрайтов из того же "Марио", которые можно было перемещать и анимировать с помощью кода. Иными словами, на нем можно было написать целую игру!
*фото [20 ВЕК](http://vek-20.ru/)*
К сожалению, это оказалось не совсем правдой. Я научился перемещать спрайты по экрану достаточно быстро, графический редактор тоже не составил каких-либо проблем. Вдоволь наигравшись с примерами из прилагающейся книги, мне захотелось создать свою собственную интерпретацию любимой в то время игры "Green Beret" (известной также как "Rush’n Attack") и тут пришло первое разочарование – нарисовать свой собственный спрайт было нельзя, оператор `SPRITE` работал только со встроенными спрайтами. Марио и его друзья, по очевидным причинам, никак не подходили на роли в игре о вооруженном противостоянии СССР и США. Проявив смекалку, я попытался нарисовать "спецназовца" с помощью ASCII-символов, но эта идея была заведомо провальной. В тот момент "cюбор" практически умер для меня. От безысходности и временного отсутствия новых игр на Dendy, пришлось разобраться с циклами, вводом с клавиатуры и написать программы для решения школьных примеров по математике. К окончанию первого класса школы для меня остались только два загадочных оператора бейсика – `РОКE` и `РЕЕК`, которые были предназначены для записи и чтения данных из памяти. Подсознательно я чувствовал в них какой-то огромный потенциал, так как все еще не оставлял идею нарисовать собственный спрайт и верил в чудо. Но практически полное отсутствие документации и авторитетной помощи сыграли свою роль, и я так и не смог найти реального применения этим операторам, хотя и научился читать память по произвольному адресу и даже мог заставить приставку перезагрузиться, записав что-нибудь в небезопасную область памяти.
Рассуждая сейчас о роли "сюбора" в моем становлении, как программиста, я не придаю ему большого значения. Было трудно воспринимать его, как что-то большее, чем просто очередную игру, при этом не слишком хорошо сделанную. Это был первый опыт встречи с плохим ПО, но он дал толчок к исследованию вопроса, ведь мне тогда уже было известно о "взрослых" компьютерах и на что они способны по сравнению с моим "сюбором". Я читал отцовские журналы "Радио", пролистывая все статьи об электронике и залипая на распечатках 16-ричных дампов программ для микроконтроллеров. Понять было ничего невозможно, но я бы в то время многое отдал за компьютер, в который эти дампы хотя бы можно было вводить.
Моя мечта сбылась аккурат под новый год, но весьма странным образом. Вместо IBM PC/XT c большим монитором и дисководом, я получил невзрачную коробку с очередной "клавиатурой" внутри под названием "Бытовой компьютер [Компаньон-2](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BC%D0%BF%D0%B0%D0%BD%D1%8C%D0%BE%D0%BD_(%D0%BA%D0%BE%D0%BC%D0%BF%D1%8C%D1%8E%D1%82%D0%B5%D1%80))".
"Компаньон" был российским клоном популярного раньше ZX Spectrum, обладал 48 кб оперативной памяти, интерфейсами для подключения джойстиков и магнитофона для сохранения и загрузки данных с магнитной ленты. Как и игровую приставку, его нужно было подключать к телевизору, либо к специальному монитору, которого у меня, конечно, не было. Пришлось повозиться с подключением к телевизору (ТВ-выход на моей модели компьютера оказался сломан), сделать кабель для RGB-интерфейса и найти подходящий магнитофон. И вот спустя какое-то время, экран заморгал приветственным курсором [Sinclair BASIC](https://en.wikipedia.org/wiki/Sinclair_BASIC). Бонусом к компьютеру мне досталась замечательная книжка "[Как написать игру для ZX Spectrum](http://zxpress.ru/book.php?id=3)" и парочка кассет с играми, поэтому к моменту первого успешного включения компьютера, я уже знал, что надо делать. Конечно же запускать игры.
*фото [Retro Tresaures](http://retro-treasures.blogspot.ru/)*
Спустя несколько дней отчаянного перематывания кассет и бесконечного ожидания загрузки больших игр под звуки записанных на пленке нулей и единиц, мчащихся на скорости 1535 бод прямиком в ОЗУ моего компьютера, я осознал, что все игры на "спектруме" абсолютно никчемны по сравнению с Dendy. Эта ситуация вновь оставила меня один на один с бейсиком.
В отличие от "сюбора" с его игрушечным программированием, здесь язык был полноценным, не привязанным к дурацкой графике из "Марио" и с раза в два большим количеством операторов. Пропорционально возможностям, выросла и сложность, а вместе с ней и интерес. Я отлично понимал, что сейчас меня ограничивают только мои собственные знания и навыки, а не сама машина, поэтому пришлось подойти к делу серьезно. Моей целью все еще было написать собственную игру.
Первым делом мне нужны были спрайты и, так как описанной в книге программы "Art Studio" для рисования графики у меня не было, пришлось вооружиться тетрадкой в клеточку. Я поклеточно рисовал нужные спрайты, а потом переносил их на экран через код. Это была поразительно монотонная и сложная работа, в которой очень легко было ошибиться. Но результат был виден сразу и это очень воодушевило. На данном этапе мне даже не требовалось сохранять свои программы, потому что они были "зарисованы" у меня в тетрадке, а я каждый раз набирал код заново, чтобы привыкнуть к новой клавиатуре. На "спектруме" почти все команды бейсика были написаны прямо на клавишах и, обычно, на набор одной команды требовалось только одно нажатие.
Спустя пару недель и тетрадок у меня были спрайты "спецназовца", "врагов", и некоторых декораций. Я даже придумал название для игры, пока рисовал – "Солдат удачи". Суть была стандартная – убить всех врагов. Игрок мог управлять героем и стрелять с помощью джойстика, а враги двигались в хаотичном порядке, пытаясь поразить героя врукопашную. Дополнительную сложность вносили декорации в виде "джунглей", через которые нельзя было пройти и не пролетали пули.
Научить "спецназовца" ходить оказалось простой задачей, код для этого не сильно отличался от "сюборовского", который я уже знал. А вот с врагами возникла первая сложная задача в моей программистской практике. Передвигать спрайты в полностью рандомных направлениях было легко, но от этого игра приобретала слишком уж непредсказуемый характер, не говоря уже о том, что врагам было совершенно наплевать на героя. Пришлось изобретать некое подобие "искусственного интеллекта" для врагов, чтобы играть было интересно. За этим занятием я провел много месяцев, постоянно экспериментируя и меняя логику программы. Чем больше становилась моя программа, тем больше неудобств стал доставлять бейсик с его бесконечными `GO TO` и `PAUSE`. Однажды мне удалось достать вторую книгу из серии "Как написать игру для ZX Spectrum", которая называлась "[Как написать игру на ассемблере для ZX Spectrum](http://zxpress.ru/book.php?id=2)". Это был настоящий хардкор для детских мозгов, но я зачитывался, поражаясь возможностям, которые предоставлял язык ассемблера ZX80.
Была одна проблемка. У меня не было программы транслятора ассемблера и я не мог сразу же практиковаться, читая книгу. Зато у меня был бейсик и те самые `POKE` и `PEEK`, весь потенциал которых я смог осознать только сейчас. Я погрузился в мир памяти, адресов и непредсказуемых последствий. Предостережения в книге о том, что не стоит записывать что попало по адресам, назначение которых не знаешь, меня не слишком останавливали. Первым делом я занялся экспериментами с т.н. "системными переменными" – адресами в памяти, по которым хранились данные для "операционной системы", касающиеся всех сторон жизни компьютера, от клавиатуры до монитора. Из бейсика это было просто, например, вводишь `РОКЕ 23659,0` – и в твоем распоряжении уже весь экран, без системного окна! Стоит ли говорить, насколько улучшилась моя игра после добавления в нее тех возможностей, что давали "системные переменные"? Но помнить адреса и числовые значения, которые можно туда писать, совсем неудобно, не говоря уже о том, что я представить себе не мог, как будут работать примеры ассемблерного кода из книги. Тогда у меня родилась безумная идея – написать транслятор самому. Точнее, я понял, что занимаюсь написанием транслятора ассемблера, гораздо позже, чем приступил к этому. Просто у меня была таблица ассемблерных мнемоник и соответствующих им шестнадцатеричных кодов и я подумал, почему бы не написать программу для перевода из одного в другое, ведь с 16-ричными числами в бейсике я уже умел обращаться.
*Скриншот [Viva Games](http://viva-games.ru/)*
Чем больше я погружался в мир ассемблера, тем больше понимал, как же на самом деле работает мой компьютер и почему он работает именно так, а не иначе. За этим занятием пролетели годы, спустя которые у меня появился "настоящий" компьютер на x86, открыв собой новые горизонты познания. Теперь, благодаря "спекки", я уже точно знал, что с ним делать.
Оглядываясь сейчас на свой первый опыт программирования и на Basic, как первый язык, я не совсем уверен в его положительной оценке. Начиная изучать "большие" языки программирования, я столкнулся с определенными проблемами, вызванными привычкой думать в терминах строк и безусловных переходов, переучиваться было немного мучительно. С ассемблером же ситуация более ясная. Хотя архитектуры x86 и Z80 имеют между собой довольно мало общего, но основополагающие принципы не меняются и эти знания до сих пор помогают мне даже при программировании на языках высокого уровня, так что здесь я совершенно точно не прогадал.
Как вы понимаете, мой путь в программирование едва ли можно назвать стандартным, даже для 90-х годов, в основном из-за специфики оборудования, на котором приходилось учиться. Ведь в то время в России уже были распространены компьютеры на базе x86 и многие мои знакомые программисты начинали свой путь именно на них, не испытывая необходимости в буквальном смысле "ковырять железо" в поисках необходимой функции и писать самому себе редакторы кода. Размышляя над этим, я задаюсь вопросом о современных детях и о том, как изучают программирование они сейчас, спустя почти 50 лет безудержного развития компьютерной техники и проникновения компьютеров буквально во все сферы человеческой жизни. По счастливой случайности, на жизненном пути мне встретились хорошие ребята из "Кодабры", которые и раскрыли некоторые секреты из жизни современных школьников.
Для начала о школе. В мои времена уроки "информатики" в школе выглядели весьма печально, в основном из-за отсутствия действительно компетентных преподавателей и оборудования. Мне было там скучно, а одноклассники просто валяли дурака от того, что ничего не понимали. Чего стоит только программирование в тетрадках. Кто только мог придумать такую глупость? Программирование и компьютеры неразрывно связаны. Можно выполнять код в уме и можно записывать его маркером на окне, но только когда ты уже точно знаешь, как он работает в компьютере, а для этого, естественно, нужен сам компьютер. К счастью, сейчас таких проблем не осталось даже, наверное, в самых отдаленных частях нашей страны. Дети начинают изучать компьютер практически с начальных классов и даже если у них нет дома своего, к 7 классу они все равно станут теми самыми "Операторами ПК". А дальше уже начинается настоящая информатика, качество которой, как и в мои времена, сильно зависит от преподавателя и школы.
У "Кодабры", конечно, таких проблем не бывает, так как все ее преподаватели сами являются профессиональными программистами и строят свои уроки на практике. Я не был удивлен, узнав, что и сейчас самое эффективное преподавание программирования для детей, строится на играх. С появлением Unity, это занятие стало еще более дружелюбным и интересным, а главное, без бейсика – тут для занятий используется С#. Хотя мне сейчас и не приходится часто использовать C# в работе, но нельзя не признать, что на текущий момент это один из весьма удачно спроектированных современных языков программирования. Он не очень подходит для обучения азам, но это и не требуется. Для детей помладше практикуются визуальные языки программирования, такие как [Scratch](https://scratch.mit.edu/). Визуальное программирование – превосходная идея для знакомства с базовыми понятиями в программировании, такими как переменная, условие или цикл, а еще там можно рисовать цветные спрайты!
Немного жаль, что низкоуровневые вещи в последние годы все чаще опускаются при обучении программированию либо рассматриваются по верхам, ведь двигаться с высокого уровня к низкому гораздо сложнее, чем наоборот. Но стремительно набирающие популярность, в том числе и в школьных кругах, Arduino, Raspberry Pi и растущий с каждым днем "интернет вещей", обещают скоро изменить ситуацию в лучшую сторону. При правильном подходе, Arduino может стать "вторым спектрумом" для ребенка, подарить бесценные в будущем знания и занять на множество увлекательных часов.
Я желаю "Кодабре" поскорее создать курсы по низкоуровневому программированию и железу для детей, и приглашаю хабравчан посетить "Фестиваль цифрового творчества для детей и подростков [Digitalfest](http://digitalfest.ru/)" 4 декабря, на котором будет в том числе и секция, посвященная интернету вещей и робототехнике, на которых можно познакомить ребенка с не совсем стандартными компьютерами. | https://habr.com/ru/post/316354/ | null | ru | null |
# Как я организовавывал связку apache+vmware
Продолжительное время на одном из серверов крутиться с десяток сайтов, все они подвержены риску взлома. Так как Apach+php стоит под Windows разграничить права на запись в ту или иную папку нет возможности. Обыкновенной командой можно вообще затереть все файлы на сервере.
Выход нашелся довольно таки простой, а что если разнести пользовательские сайты по виртуальным серверам. И уже если взломают один, то в приделах виртуального сервера пусть и «копашатся», дальше они не вылезут.
На сервер поставил Vmvare Server 2 [vmware.com/products/server](http://vmware.com/products/server/) продукт бесплатный, необходимо лишь зарегистрироваться и на почту прийдет ключ. Позволяет создавать десятки виртуальных машин, управление происходит из под браузера, так что можно управлять серверами из любой точки мира.
Но, встает вопрос, сервера то виртуальны и в интернете они не видны, о них знает лишь главный сервер, на котором они собственно все крутятся, пробросить 80 порт невозможно серверов много да и занят он на основном.
А, решается все довольно просто, в Apache имеется модуль Прокси-сервера, собсвтвенно апач может выступать не только как web, но и proxy сервером, это возможностью я и решил воспользоваться.
Первым делом у регистратора доменного имени прописываем ИП нашего главного сервера, куда будут приходить все запросы.
На главном сервере в конфигурационном файле апача пропишем:
`ServerAdmin webmaster@site.com
DocumentRoot D:/www2/site/
ServerName site.com
ServerAlias www.site.com
ProxyRequests Off
Order deny,allow
Allow from all`
ProxyPass / [site.com](http://site.com/)
ProxyPassReverse / [site.com](http://site.com/)
Собственно в этих строчка мы даем понять апачу, что все запросы, котрые приходят для сайта site.com отправлять, используя встроенный проски сервер, на то же site .com. Но встает вопрос, получается зацикливание. Чтобы этого не было необходимо в файле c:/Windows/System32/drivers/etc/hosts дописать для этого сайта внутренний IP, скажем у меня это выглядит так:
`192.168.2.2 site.com`
Получается, что сначала запрос приходит на основной сервер, по внешнему ИП, потом уже апач смотрит, где есть site.com и получает IP, согласно правилам системы (игнорирует внешние ДНС) смотрит в hosts и запрашивает сайт у внутреннего виртуального сервера. | https://habr.com/ru/post/63556/ | null | ru | null |
# Программирование для PlayStation 2 — старт
Каждый справляет новый год по разному.
Кто-то помнит его, а кто-то нет.
Я стоял на балконе и курил, наблюдая салют. Вобщем-то, я ждал когда запишется диск.
Диск было не жалко ради такого эксперимента – он того стоил.
Это было мое первое приложение под PlayStation 2. Правда, все, что оно умело – это выводить клавиатуру и, с помощью джойстика, печатать, но это был уже прогресс!
Итак, запуск! Работает!
#### Сама суть
Так я начинаю цикл статей по программированию для PlayStation 2
Сначала будет длинная теория.
Потом практика. Поскольку я не профессионал С++ (или С — кому как нравится, но я буду рассказывать на С++), то прошу строго не судить о коде.
Также, по PlayStation 2 SDK желательно использовать Red Hat 6 или выше, однако, я пишу все это под Windows 7. Хоть все и работает криво, но работает – и ладно.
К началу практических экспериментов советую иметь чипованную PlayStation 2 и сетевой кабель. Для моих экспериментов выбрана PlayStation 2 Slim 90006 формата NTSC чипованная и сетевой кабель синего цвета =) (Я не использовал для дебага режим iLink, поскольку драйвера в комплекте идут только под Linux, да и жесткий диск нужен).
#### Официально
Естественно, ваши игры не будут официальными. Даже уверен, что компания Sony может не простить такого разгильдяйства. Официально вы можете купить поддержку, сам SDK и оборудование всего, не соврать бы, за $10 000. Да и дают лицензию не каждому…
Мы с вами люди не богатые, поэтому мы пойдем путем…
#### Неофициально
Неофициально я искал этот SDK несколько суток, качал его две недели (а может и больше), разбирался в куче доков еще больше. На данный момент SDK занимает 608 метров, включая ПО, без Visual Studio 6.
Итак. Для начала нам придется пройти по 13 несложным главам (только в некоторых у меня остались вопросы, в которых я еще разбираюсь, например, карта памяти).
Главы я собираюсь рассказать в следующем порядке:
Controller Library (главы две – это про джойстик и мультитап);
CD(DVD)-ROM Library (игры могут быть как на CD так и на DVD);
Memory Card Library. (карта памяти. Главы две и они очень сложные для понимания);
PS2 Memory Card FileSystem (файловая система FAT карты памяти);
EE Kernel (самая геморройная тема, но стоит знать);
Graphic Library (это будет долго, но этой статьи будут ждать многие – я уверен);
Sound Library (тоже много);
Movie Library (MPEG и IPU);
Network Library (работа с сетью и все с ним связанное);
Hard Disk Library (жесткого диска у меня нет, поэтому рассказывать о ней буду только в теории);
#### Базовые требования
Pentium 3, фиг знает сколько оперативки, но 500 метров думаю хватит.
В определенный момент, когда из теории можно будет выйти, я выложу PlayStation 2 SDK (копейки не докачались, но писать, вроде, не мешает).
Так же, в определенный момент, я начну учиться вместе с вами, поскольку я не осилил пока всю информацию. Предлагаю, пока что, просто писать, а как получится, я выложу SDK и можно будет объединять.
Я использую Metrowerks CodeWarrior 4.2.6.844. Увы, встал PS2 SDK нормально только туда. Компилятором является GCC или Visual Studio 6.
#### Для информации и тех кто «все могу»
На PS2 используется Linux. Если мои догадки правильны, то это «что-то» напоминает мне Red Hat. Естественно, все файлы и команды чувствительны к регистру.
Вы можете использовать потоки, но процессор там один — ARM.
Как вы понимаете, работать придется с байтами. Например, вот что включает в себя ответ на запрос потоков (тип — **DBGP\_EE\_THREADLIST\_DATA**):
* Id – ID потока
* Priority – его приоритет
* Status – статус потока, который может включать в себя следующие виды:
+ THS\_RUN = 0х01 // запущен
+ THS\_READY = 0x02 // готов
+ THS\_WAIT = 0x04 // в ожидании
+ THS\_SUSPEND = 0x08 //приостановлен
+ THS\_WAITSUSPEND = 0xc // в ожидании приостановки (для меня это вообще тайна тайная)
+ THS\_DORMANT = 0x10 // бездействующий поток
* Cause – собственно причина ожидания: 0 – none, 1 – sleep, 2 – sema (т.е. семафор)
* Waited – ID семафора
* Wakeupcount – количество запросов на побудку
* Count – количество раз, когда поток вошел в состояние RUN
* Pc – Счетчик команд
* Sp – Указатель на вершину стека $29 (спасибо [Maccimo](https://habrahabr.ru/users/maccimo/))
* Func – Адрес точки исполнения
* Ra – Адрес точки возврата $31
* reserved [0] – Зарезервированная инфа
* reserved [1] – Зарезервированная инфа.
Ах, да, если поток в состоянии RUN, то в pc, sp и ra находятся текущие значения.
Как видно, программирование на PS2 не самая простая задача. Сравнивать ее с программированием для ПК можно только языком и вызовами стандартных функций. Естественно, на памяти надо экономить. Лишнее надо выгружать. Если вы хотите считать что-то с диска – вам надо передвигать головку непосредственно до чтения – информация может стать неактуальной. Это очень непростое программирования, так что оценивайте свои силы реально.
Вобщем, до следующей статьи. Постараюсь выложить побыстрее…
**P.S.**: Извиняюсь, что не могу выложить PS2 SDK сейчас. Но, надеюсь, к следующей статье все будет.
**Update**: Начал писать первую статью и вспомнил.
Я забыл указать, что используется обычный makefile.
Выглядит он примерно так (взят из первого примера для джойстика):
`SHELL = /bin/sh
TOP = /usr/local/sce/ee
LIBDIR = $(TOP)/lib
INCDIR = $(TOP)/include
TARGET = main
OBJS = crt0.o \
$(TARGET).o
LCFILE = $(LIBDIR)/app.cmd
LIBS = $(LIBDIR)/libgraph.a \
$(LIBDIR)/libdma.a \
$(LIBDIR)/libdev.a \
$(LIBDIR)/libpkt.a \
$(LIBDIR)/libkernl.a \
$(LIBDIR)/libpad.a
PREFIX = ee
AS = $(PREFIX)-gcc
CC = $(PREFIX)-gcc
LD = $(PREFIX)-gcc
DVPASM = $(PREFIX)-dvp-as
OBJDUMP = $(PREFIX)-objdump
RUN = dsedb -r run
RM = /bin/rm -f
CFLAGS = -O2 -Wall -Wa,-al -fno-common
CXXFLAGS = -O2 -Wall -Werror -Wa,-al -fno-exceptions -fno-common
ASFLAGS = -c -xassembler-with-cpp -Wa,-al
DVPASMFLAGS = -g
LDFLAGS = -Wl,-Map,$(TARGET).map -mno-crt0 -L$(LIBDIR) -lm
TMPFLAGS =
.SUFFIXES: .c .s .cc .dsm
all: $(TARGET).elf
$(TARGET).elf: $(OBJS) $(LIBS)
$(LD) -o $@ -T $(LCFILE) $(OBJS) $(LIBS) $(LDFLAGS)
crt0.o: $(LIBDIR)/crt0.s
$(AS) $(ASFLAGS) $(TMPFLAGS) -o $@ $< > $*.lst
.s.o:
$(AS) $(ASFLAGS) $(TMPFLAGS) -I$(INCDIR) -o $@ $< > $*.lst
.dsm.o:
$(DVPASM) $(DVPASMFLAGS) -I$(INCDIR) -o $@ $< > $*.lst
.c.o:
$(CC) $(CFLAGS) $(TMPFLAGS) -I$(INCDIR) -c $< -o $*.o > $*.lst
.cc.o:
$(CC) $(CXXFLAGS) $(TMPFLAGS) -I$(INCDIR) -c $< -o $*.o > $*.lst
run: $(TARGET).elf
$(RUN) $(TARGET).elf
clean:
$(RM) *.o *.map *.lst core *.dis *.elf`
Ваша программа работает с функции main.
Ваш код должен работать в бесконечном цикле, т.е. пустой проект выглядит так:
`#include #include
// прототипы
int main (void);
int main (void)
{
while(1){
//ваш код
}
return 0;
}` | https://habr.com/ru/post/135704/ | null | ru | null |
# Без реле, но и без Ардуины или Драка в песочнице
Да простят меня читатели, но это реплика на реплику. А началось всё с интересной [статьи](http://geektimes.ru/post/258850/), где автор познакомил нас со своей разработкой на базе ATMega8. Понятно, камень этот избыточен для той задачи, которая была на нем реализована, на что и [обратил внимание оппонент](http://geektimes.ru/post/269210/).
Но теперь уже у меня засвербило… гм, в ладонях, и я не мог не попытаться вставить свои пять копеек. Я понимаю, настоящая моя заметка для комментария великовата, а на полноценную статью не тянет, но все же попробую.
Пересказывать содержание предыдущих серий смысла нет, кому интересно — я привел ссылки. Перейдем сразу к сути.
Схема на реле, предложенная уважаемым автором, вызвала у меня некое подобие зубной боли. Возможно потому, что в юности довелось иметь дело с декадно-шаговыми и координатными АТС, после чего я на всю жизнь возненавидел реле. Да, релейные схемы — это просто, да, работать они будут даже в условиях ядерного взрыва, но…
Первое но — надежность
----------------------
Как вы думаете, какие самые ненадежные компоненты электронных схем? Возможно я и ошибаюсь, но по моему опыту это механические контакты и электролитические конденсаторы. Контакты подгорают, окисляются, конденсаторы сохнут. А тут вся схема состоит из контактов и конденсаторов. К тому же в этой схеме полярные конденсаторы включены параллельно обмоткам реле, и в результате при разрыве цепи ЭДС самоиндукции замыкается через что? — правильно — через конденсатор, который в этом случае поработает таким плохоньким диодом. Причем тот оказывается подключенным в обратной полярности. Не думаю, что это пойдет на пользу и так не слишком надежному компоненту.
Второе но — стоимость
---------------------
Сколько стоит одно реле? Поискав на «Али», ничего приличного дешевле одного американского доллара не нашел. Ладно, пусть я не умею искать, возьмем цену 50 центов. Четыре реле (ведь в оригинальной схеме четыре канала) — уже два бакса. Получается только одни реле будут стоить больше, чем вся комплектуха варианта на микроконтроллере, включая сам микроконтроллер. А если в той схеме еще повыбрасывать лишние детали…
Третье но — расширяемость
-------------------------
А вот скажите мне: что мы будем делать с этой схемой, если понадобится ввести в изделие дополнительную функциональность? Нет, я не прошу играть военные марши, а хотя бы и пискнуть зуммером после истечения времени, которое дается игроку на ответ?
Воооот…
Ладно, это была присказка. А теперь к делу. Смотрите схему. Процитирую: «спаять было быстрее чем рисовать».
Одна условно-бесплатная микросхема, три резистора, три конденсатора. Пьезопищалка. И все, практически. Питать это хозяйство можно от трех элементов AA. Без всяких стабилизаторов. В покое потребляет меньше микроампера (power down mode) — можно отказаться от выключателя — еще один ненавистный контакт.
Контроллер AVR AT90S1200 не потому, что он чем-то хорош, просто у меня после одного из древних проектов их осталось с полведра, а так как он давно снят с производства — сейчас уже никуда его не приткнешь. Только в какую-нибудь самоделку. Поэтому и условно-бесплатный. Но, как верно заметил автор [первой статьи](http://geektimes.ru/post/258850/), здесь подойдет любой.
Теперь про программу. Так как в этом контроллере ОЗУ нет (от слова вообще), а стек аппаратный и всего лишь трёхуровневый, ни о каких языках высокого уровня речь не идет. Только Ассемблер, только хардкор…
Посадить кнопки на прерывания тоже не получится. Внешнее прерывание только одно, а знатоков за столом шесть. Что ж, будем опрашивать в цикле. Причем опрашивать все одновременно, дабы не было преимущества ни у одного игрока. Время цикла опроса при частоте тактового генератора 1МГц — 6мкс, то есть мы вылавливаем разницу между нажатиями в 6мкс. Если два игрока нажмут кнопку одновременно, ну вдруг, мало ли — будут засвечены два светодиода. Все честно. Хотя, думаю, вероятность такого события будет очень низка. Но все же, если точность определения лидера в 6мкс недостаточна — можно подключить кварц, прошить фьюз и запустить контроллер на частоте 12МГц. В этом случае частота опроса повысится в 12 раз. Ваш К.О.
Дребезг контактов ни на что не влияет, так как мы реагируем на первый же замеченный спад уровня. После этого следует обработка нажатия, и что уже там творится на кнопке — нас не волнует.
Согласен, разные кнопки с разным временем и характером дребезга могут дать кому-то преимущество в микросекунду-другую, но, по-моему, это уже вылавливание блох.
**Собственно код**
```
;----------------------------------------------------------------------------
;¦ Title : Своя игра. Пример реализации
;¦ Version : 0.0
;¦
;¦ Last updated : 16.01.16
;¦ Target : AT90S1200 1MHz (внутренний RC-генератор)
;+---------------------------------------------------------------------------
.include "1200def.inc"
;¦ Определение регистровых переменных
;+---------------------------------------------------------------------------
.def acc = r20 ; временная переменная
.def temp1 = r21 ; просто локальная переменная
.def temp2 = r22 ; просто локальная переменная
.def temp3 = r23 ; просто локальная переменная
.def temp4 = r24 ; просто локальная переменная
.def temp5 = r25 ; просто локальная переменная
.def temp6 = r26 ; просто локальная переменная
.def temp7 = r27 ; просто локальная переменная
;¦ Определение сигналов в портах
;+---------------------------------------------------------------------------
.equ ini_b = 0b00111111 ; начальные значения PORTB
.equ dir_b = 0b11111111 ; маска направлений 1-out 0-in
; ¦¦¦¦¦¦¦¦
.equ led01 = 0 ;¦¦¦¦¦¦¦+-12(out)
.equ led02 = 1 ;¦¦¦¦¦¦+--13(out)
.equ led03 = 2 ;¦¦¦¦¦+---14(out)
.equ led04 = 3 ;¦¦¦¦+----15(out)
.equ led05 = 4 ;¦¦¦+-----16(out)
.equ led06 = 5 ;¦¦+------17(out) (MOSI)
.equ buzzer1 = 6 ;¦+-------18(out) (MISO)
.equ buzzer2 = 7 ;+--------19(out) (SCK)
.equ ini_d = 0b00111111 ; начальные значения PORTD
.equ dir_d = 0b01000000 ; маска направлений 1-out 0-in
; ¦¦¦¦¦¦¦
.equ key01 = 0 ; ¦¦¦¦¦¦+--2 (in)
.equ key02 = 1 ; ¦¦¦¦¦+---3 (in)
.equ key03 = 2 ; ¦¦¦¦+----6 (in) (INT0)
.equ key04 = 3 ; ¦¦¦+-----7 (in)
.equ key05 = 4 ; ¦¦+------8 (in)
.equ key06 = 5 ; ¦+-------9 (in)
.equ pin11 = 6 ; +--------11(out) не исп.
;¦ Макросы
;¦
;+---------------------------------------------------------------------------
.include "mymacros.inc"
.macro init_ports
ldi acc,dir_b
out DDRB,acc ; настроили порт B на ввод/вывод
ldi acc,ini_b
out PORTB,acc ; вывели в порт
ldi acc,dir_d
out DDRD,acc ; настроили порт D на ввод/вывод
ldi acc,ini_d
out PORTD,acc ; вывели в порт
.endmacro
.macro init_wd
wdr ; reset watchdog timer
ldi acc,0b00001111 ; watchdog разрешен, коэф. деления - 2048
out WDTCR,acc
.endmacro
.macro init_irq ; портит acc
ldi acc,(1<
```
Спасибо за внимание. Если что не так — пишите в личку, исправлю. | https://habr.com/ru/post/367627/ | null | ru | null |
# YouTubeDrive: хранение файлов на YouTube
Хостинг неограниченного размера? Звучит как нечто фантастическое и невозможное по законам природы. Примерно как вечный двигатель. Но что, если такое возможно? (не вечный двигатель, конечно, а неограниченный хостинг).
Если подумать, ведь бесплатное хранилище неограниченного размера предоставляют десятки интернет-сервисов, от соцсетей до фотохостингов. Например, ограничение YouTube на размер одного видеоролика — [12 часов или 256 ГБ](https://support.google.com/youtube/answer/71673?hl=EN), но на количество видеороликов ограничений нет.
Теоретически нескольких видеороликов по 256 ГБ достаточно, чтобы спрятать в них зашифрованную копию своего SSD.
Единственное препятствие — они проверяют форматы файлов при загрузке, чтобы избежать злоупотребления сервисом. То есть чисто теоретически достаточно обойти эту проверку — и проблема решена. Но как её обойти?
Сразу приходит в голову вариант изменить расширение файла. Но сегодня такой вариант не проходит практически ни на одном хостинге, потому что они проверяют метаданные и содержимое файлов. Слишком легко отличить медиафайл от случайного набора бит.
Но что, если использовать методы стеганографии — и внедрять полезную нагрузку непосредственно в нативный медиафайл? И действительно, есть готовые инструменты для решения этой задачи. Вот некоторые из них.
> *Ещё раз подчеркнём — статья носит исключительно образовательный и чисто теоретический характер, материалы описанные в статье не являются руководством к действию и не нарушают законодательство.*
YouTubeDrive
------------
[YouTubeDrive](https://github.com/dzhang314/YouTubeDrive) — это пакет для Mathematica, который перекодирует любые файлы в пиксели RGB. То есть любой поток данных просто транскодируется в видеопоток — а потом обратно. Программа написана пять лет назад чисто для проверки концепции, что такое возможно (PoC).
Промежуточный видеоформат создаётся с единственной целью — для видеохостинга.
То есть схема такая:
```
АРХИВ ФАЙЛОВ → ВИДЕО → YOUTUBE → и обратно АРХИВ ФАЙЛОВ
```
YouTubeDrive написан на Wolfram Language (язык Mathematica). Он кодирует/декодирует произвольные данные, а видео автоматически загружаются и выгружаются с YouTube.
Поскольку YouTube не накладывает никаких ограничений на общее количество видео, которые могут загружать пользователи, это обеспечивает фактически неограниченный хостинг. Правда, такой хостинг чрезвычайно медленный, потому что процедура кодирования/декодирования занимает время сначала на локальном ПК, а затем ещё на YouTube.
Вот [код пакета](https://github.com/dzhang314/YouTubeDrive/blob/master/YouTubeDrive.wl). Разумеется, для его работы должна быть установлена сама программа [Mathematica](https://www.wolfram.com/mathematica/).
YouTubeDrive использует стандартные утилиты [FFmpeg](https://ffmpeg.org/), [youtube-upload](https://github.com/tokland/youtube-upload) и [youtube-dl](https://rg3.github.io/youtube-dl/). Эти программы необходимо загрузить и установить отдельно, а перед первым использованием в пакете `YouTubeDrive.wl` (строчки 75–77) нужно указать места их установки:
```
FFmpegExecutablePath = "FFMPEG_PATH_HERE";
YouTubeUploadExecutablePath = "YOUTUBE-UPLOAD_PATH_HERE";
YouTubeDLExecutablePath = "YOUTUBE-DL_PATH_HERE";
```
Например, таким образом:
```
75 | FFmpegExecutablePath = "C:\\ffmpeg.exe";
76 | YouTubeUploadExecutablePath = Sequence["python",
77 | "C:\\Users\\j0ker\\AppData\\Local\\Programs\\" <>
78 | "Python\\Python35\\Scripts\\youtube-upload.py"];
79 | YouTubeDLExecutablePath = "C:\\youtube-dl.exe";
```
После установки этих программ и изменения конфигурационных файлов можно открыть сам пакет YouTubeDrive.wl в программе Mathematica (через `File` ⇨ `Install...` ⇨ `Package` ⇨ `From File` ⇨ `YouTubeDrive.wl`).
Перед использованием с помощью `youtube-upload` загружаем тестовое видео в свой аккаунт, логинимся в YouTube — и получаем токен `OAuth`. Этот токен аутентификации понадобится для загрузки видеороликов через YouTubeDrive.
Алгоритм работы YouTubeDrive довольно понятен. В пакете две основные функции:
* Функция `YouTubeUpload[bytearr]` кодирует массив данных `bytearr` как простое видео RGB, загружает на YouTube и возвращает ID видео.
По умолчанию кодируется 64×36 пикселя RGB, которые масштабируются в 2304 квадратика 20×20 пикселей кадра 1280×720. Значения RGB только 0 или 255, то есть получается три бита на квадратик. Значения RGB записываются в файлы .PNG, которые с помощью кодека FFmpeg склеиваются в валидный видеоролик MP4, способный пережить дальнейшее транскодирование на сервере YouTube.
```
Monitor[Do[Image`ImportExportDump`ImageWritePNG[
"frame_" <> IntegerString[i, 10, numDigits] <> ".png", frame[i]],
{i, numFrames}], ProgressIndicator[i, {1, numFrames}]];
If[numLeftoverBytes > 0, Image`ImportExportDump`ImageWritePNG[
"frame_" <> IntegerString[numFrames + 1, 10, numDigits] <> ".png",
finalFrame]];
Run[FFmpegExecutablePath,
"-i", "frame_%0" <> ToString[numDigits] <> "d.png",
"-c:v", "libx264", "-preset", "ultrafast",
"-vf", "scale=1280:720", "-sws_flags", "neighbor", "data.mp4"];
procInfo = RunProcess[{YouTubeUploadExecutablePath,
"--title=\"DATA-" <> ToUpperCase@CreateUUID[] <> "\"",
"data.mp4"}];
```
В реальности транскодер YouTube может случайно поменять местами значения отдельных пикселей 0 и 255, поэтому большие квадраты 20×20 выполняют роль механизма коррекции ошибок.
* Вторая функция `YouTubeRetrieve` возвращает видеоролик YouTube с указанным идентификатором `ID videoid`, декодирует его и возвращает полученные данные в видео объекта `ByteArray`:
```
RunProcess[{FFmpegExecutablePath,
"-i", FileNameJoin[{tempDir, videoFile}], "frame_%d.png"}];
numFrames = Max[FromDigits /@ StringTake[FileNames["frame_*.png"], {7, -5}]];
rdata = Monitor[Join @@ Table[ByteArray[FromDigits[#, 2] & /@
Partition[Join @@ classify /@ Join @@ ImagePartition[
First@Image`ImportExportDump`ImageReadPNG[
"frame_" <> ToString[i] <> ".png"], 20], 8]],
{i, numFrames - 1}], ProgressIndicator[i, {1, numFrames - 1}]];
lastParts = Join @@ ImagePartition[First@Image`ImportExportDump`ImageReadPNG[
"frame_" <> ToString[numFrames] <> ".png"], 20];
numPaddedBits = LengthWhile[
Reverse[Join @@ classifyLast /@ lastParts], EqualTo[1 / 2]];
rdata = Join[rdata, ByteArray[FromDigits[#, 2] & /@ Partition[
Drop[Join @@ classify /@ lastParts, -numPaddedBits], 8]]];
```
Вот и всё.
*Примечание*. На самом сервере YouTube обработка маленького видеоролика размером около 10 МБ занимает примерно 5–10 минут. Таким образом, сразу после завершения `YouTubeUpload[bytearr]` файл ещё недоступен для скачивания, нужно немного подождать. Только потом можно запускать вызов `YouTubeRetrieve`.
### Пример использования
Насколько мы поняли, для примера автор программы взял из функции Бесселя простенький `ByteArray` и запустил `YouTubeUpload` из нашего пакета. В программе Mathematica это делается примерно так:
Результат кодирования массива данных объёмом чуть больше 18 КБ в видеоформат [выглядит следующим образом](https://www.youtube.com/watch?v=Fmm1AeYmbNU):
Если интересно, можно скачать видеоролик и посмотреть на него, можно даже расшифровать вручную. Вместо `youtube-dl` для скачивания видео с YouTube сейчас обычно используют более продвинутый форк [yt-dlp](https://github.com/yt-dlp/yt-dlp).
Список доступных форматов:
```
yt-dlp --list-formats "https://www.youtube.com/watch?v=Fmm1AeYmbNU"
[youtube] Fmm1AeYmbNU: Downloading webpage
[youtube] Fmm1AeYmbNU: Downloading android player API JSON
[info] Available formats for Fmm1AeYmbNU:
ID EXT RESOLUTION FPS │ FILESIZE TBR PROTO │ VCODEC VBR ACODEC ABR ASR MORE INFO
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────
sb0 mhtml 48x27 │ mhtml │ images storyboard
139 m4a audio only │ 6.84KiB 54k https │ audio only mp4a.40.5 54k 22050Hz low, m4a_dash
249 webm audio only │ 700.00B 6k https │ audio only opus 6k 48000Hz low, webm_dash
250 webm audio only │ 700.00B 6k https │ audio only opus 6k 48000Hz low, webm_dash
140 m4a audio only │ 15.43KiB 136k https │ audio only mp4a.40.2 136k 44100Hz medium, m4a_dash
251 webm audio only │ 700.00B 6k https │ audio only opus 6k 48000Hz medium, webm_dash
17 3gp 176x144 6 │ 26.54KiB 222k https │ mp4v.20.3 222k mp4a.40.2 0k 22050Hz 144p
394 mp4 256x144 25 │ 25.28KiB 235k https │ av01.0.00M.08 235k video only 144p, mp4_dash
160 mp4 256x144 25 │ 82.20KiB 765k https │ avc1.4d400c 765k video only 144p, mp4_dash
278 webm 256x144 25 │ 72.33KiB 673k https │ vp9 673k video only 144p, webm_dash
395 mp4 426x240 25 │ 66.86KiB 622k https │ av01.0.00M.08 622k video only 240p, mp4_dash
133 mp4 426x240 25 │ 254.76KiB 2371k https │ avc1.4d4015 2371k video only 240p, mp4_dash
242 webm 426x240 25 │ 163.19KiB 1519k https │ vp9 1519k video only 240p, webm_dash
396 mp4 640x360 25 │ 89.98KiB 837k https │ av01.0.01M.08 837k video only 360p, mp4_dash
134 mp4 640x360 25 │ 363.73KiB 3386k https │ avc1.4d401e 3386k video only 360p, mp4_dash
18 mp4 640x360 25 │ ~440.62KiB 3524k https │ avc1.42001E 3524k mp4a.40.2 0k 44100Hz 360p
243 webm 640x360 25 │ 238.27KiB 2218k https │ vp9 2218k video only 360p, webm_dash
397 mp4 854x480 25 │ 116.18KiB 1081k https │ av01.0.04M.08 1081k video only 480p, mp4_dash
135 mp4 854x480 25 │ 469.24KiB 4368k https │ avc1.4d401e 4368k video only 480p, mp4_dash
244 webm 854x480 25 │ 298.72KiB 2780k https │ vp9 2780k video only 480p, webm_dash
398 mp4 1280x720 25 │ 150.16KiB 1397k https │ av01.0.05M.08 1397k video only 720p, mp4_dash
136 mp4 1280x720 25 │ 512.91KiB 4774k https │ avc1.64001f 4774k video only 720p, mp4_dash
22 mp4 1280x720 25 │ ~614.20KiB 4913k https │ avc1.64001F 4913k mp4a.40.2 0k 44100Hz 720p
247 webm 1280x720 25 │ 380.61KiB 3543k https │ vp9 3543k video only 720p, webm_dash
```
Скачиваем формат 22:
```
yt-dlp --format 22 "https://www.youtube.com/watch?v=Fmm1AeYmbNU"
[youtube] Fmm1AeYmbNU: Downloading webpage
[youtube] Fmm1AeYmbNU: Downloading android player API JSON
[info] Fmm1AeYmbNU: Downloading 1 format(s): 22
[download] Destination: DATA-34DFE96A-BFE6-4405-A9E3-CFB9959CD3CA [Fmm1AeYmbNU].mp4
[download] 100% of 527.20KiB in 00:00
```
На этом файле в Mathematica можно запустить функцию `YouTubeRetrieve` из пакета `YouTubeDrive`, которая выполнит обратное преобразование.
Конечно, такая схема кодирования не очень эффективна — примерно 1 минута видео на 1 МБ информации. Этот параметр можно легко увеличить на порядок (до 10 МБ на минуту видео), если вместо квадратов 20×20 внедрить какой-нибудь нормальный [алгоритм коррекции ошибок](https://habr.com/ru/company/first/blog/673582/#:~:text=%D0%98%D1%81%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%B1%D0%B8%D1%82%D1%84%D0%BB%D0%B8%D0%BF%D0%BE%D0%B2).
YouTubeDrive — чисто экспериментальная программа. Автор подчёркивает, что ни в коем случае не поддерживает её использование в промышленных масштабах. Как мы уже сказали, программа написана пять лет назад чисто для доказательства концепции.
YouBit
------
Идея хранилища файлов на YouTube выглядит весьма привлекательно. Два года назад появилась программка [fvid](https://github.com/AlfredoSequeida/fvid), которая кодирует файлы без необходимости устанавливать Mathematica. Из зависимостей ей нужен только FFmpeg и libmagic.
Она работает проще. Кодирование произвольного файла в видеоформат:
```
fvid -i [input file] -e
fvid -i [input file] --framerate 1 -e
fvid -i [input file] --password "xyz" -e
```
Декодирование:
```
fvid -i [input video] -d
```
В продолжение этой темы недавно вышла утилита [YouBit](https://github.com/MeViMo/youbit). Так сказать, последнее достижение прогресса в данной области.
По сравнению с предшественниками — YouBit значительно усовершенствован. Можно сказать, что это новый уровень по качеству кодирования.
Во-первых, здесь автор отказался от использования [цветовой субдискретизации](https://en.wikipedia.org/wiki/Chroma_subsampling), а всю информации кодирует только в канале яркости. В результате получаются чёрно-белые видеоролики, но зато кодирование и декодирование становятся заметно проще — и выполняются быстрее.
В канале яркости пиксели принимают значение от 0 до 255. Соответственно, если мы кодируем в пикселе один бит (параметр `bpp: 1`, то все значения от 128 до 255 воспринимаются как единица, а меньшие значения — как 0. Для примера, если кодировать в одном пикселе два бита (00, 01, 10 или 11), то весь диапазон яркости разбивается на четыре области (0–63, 64–127, 128–191, 192–255) и так далее. Чем больше бит на пиксель, тем меньше размер файла и выше вероятность некорректной расшифровки конкретного бита после транскодирования видео на серверах YouTube.
Во-вторых, автор придумал оригинальный способ оптимизации видеороликов конкретно под специфический энкодер YouTube, чтобы повысить надёжность их последующего декодирования. Правда, теперь для успешного декодирования файлов уже *необходимо* их сначала залить на YouTube, а потом скачать результат.
В-третьих, YouBit работает с видео любого разрешения. Оптимально 1920×1080.
Наконец (в-четвёртых), автор реализовал функцию «нулевых фреймов» — вставки чёрных кадров между кадрами с полезной нагрузкой, что позволяет снизить битрейт примерно на 40% (и размер файла) при кодировании видео на сервере YouTube.
Использование:
```
python -m youbit upload C:/myfile.txt chrome
```
Аргумент `chrome` указывает, из какого браузера YouBit должен извлечь куки для аутентификации на YouTube (соответственно, этот браузер должен авторизоваться на [studio.youtube.com/](https://studio.youtube.com/), открыть сессию и получить куку).
Затем загрузка происходит непосредственно с помощью headless-браузера [Selenium](https://www.selenium.dev/) в фоновом режиме. Очень грамотный подход.
Скачивание и обратное декодирование видео:
```
python -m youbit download https://youtu.be/dQw4w9WgXcQ
```
Декодирование локального видео, скачанного с YouTube:
```
python -m youbit decode C:/myvideo.mp4
```
Все операции можно выполнять через Python API.
[Пример видео](https://www.youtube.com/watch?v=dnhlx48t-h4):
Как мы уже говорили, ограничения YouTube на размер видеоролика — 12 часов или 256 ГБ. Если аккаунт не верифицирован, ограничение 15 минут.
Настройка YouBit по умолчанию на размер одного файла — 9 ГБ, но её можно скорректировать при желании.
Неограниченный хостинг в других местах
--------------------------------------
Неограниченные хранилища файлов предоставляют и другие сервисы, например:
* Telegram (ограничение по размеру файлов 2 ГБ, в платной версии 4 ГБ)
* Соцсети (любые файлы можно хранить под видом видеозаписей и фотографий), обычно там хостинг неограниченного размера
* Habrastorage
Для работы с этими «нетрадиционными хостингами» можно написать свой клиент/файл-менеджер — небольшую программку для закачки файлов через YouBit, чтобы не запускать её вручную.
В идеале хотелось бы добавить туда следующие функции:
* Поддержка разных хостингов (разные соцсети, фото- и видеохостинги), чтобы YouBit копировал видео с нашими файлами не только на YouTube, но и на другие хостинги, которые предоставляют неограниченное дисковое пространство бесплатно.
* Резервное копирование. Поскольку каждая площадка рассматривается как временная, должно быть предусмотрено избыточное дублирование.
* Грамотная синхронизация: обновление новых версий или новых файлов без переписывания всего архива.
Но это в идеале. В минимальном варианте хватит и простого скрипта, который в пакетном режиме просто кодирует через YouBit пару сотен файлов в формат MP4 — и заливает видеофайл на несколько видеохостингов.
Что касается хранения файлов на YouTube (и в других сервисах крупных корпораций) — суть сводится к тому, чтобы использовать инфраструктуру не совсем так, как это предполагается, но при этом совершенно легально. Повторюсь, если пользователь маскирует свои личные файлы под видеоролики и заливает их на публичный хостинг, он никак не нарушает законодательство ни одной страны. В любом случае это не коммерческая программа, а просто теоретический эксперимент, а повторять его или нет — решать вам.
---
НЛО прилетело и оставило здесь промокод для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**. | https://habr.com/ru/post/676282/ | null | ru | null |
# Отслеживание хода выполнения в R
Неважно, отдаем ли мы себе в этом отчет, но когда нужно подождать, мы волнуемся и сгораем от нетерпения. Особенно это касается ожидания «вслепую», т.е. когда неизвестно, сколько же еще придется мучиться. Как выяснил Брэд Аллан Майерс, считающийся изобретателем индикатора состояния в 1980-х, возможность отслеживать ход выполнения во время ожидания может значительно улучшить механизм взаимодействия пользователя с приложением (Майерс, 1985).
*Типичный индикатор состояния от Simeon87 [[GPL](http://www.gnu.org/licenses/gpl.html)], Wikimedia Commons*
Поскольку я программирую на R для исследований в биоинформатике, мой код обычно не для широкой публики, но все же важно, чтобы мои пользователи, то бишь коллеги и исследователи, были счастливы, насколько это возможно. Но отслеживание хода выполнения в R — не самая простая задача. В этой статье представлены несколько возможных решений, в том числе и мое собственное ([pbmcapply](https://cran.r-project.org/package=pbmcapply)).
Вывод на экран
--------------
Самый легкий способ отслеживать ход выполнения в R — периодически выводить процент завершенной на данный момент работы: по умолчанию — на экран, или писать его в какой-то файл с логами где-то на диске. Нет смысла говорить, что это, вероятно, наименее элегантный способ решения, но многие все равно его используют.
Pbapply
-------
Лучшее (и по-прежнему простое) решение — подключить пакет [pbapply](https://cran.r-project.org/web/packages/pbapply/index.html). Если верить информации на [его странице](https://github.com/psolymos/pbapply), пакет очень популярен — 90 тыс. скачиваний. Его легко использовать. Каждый раз, когда собираетесь вызвать apply, вызовите ее *pbapply*-версию. Например:
```
# Некоторые числа, с которыми мы будем работать
nums <- 1:10
# Вызовем sapply, чтобы посчитать квадратный корень этих чисел
sqrt <- sapply(nums, sqrt)
# Теперь посмотрим на ход выполнения с пакетом pbapply
sqrt <- pbsapply(nums, sqrt)
```
Пока числа обрабатываются, будет выводиться периодически обновляющийся индикатор состояния.
*Индикатор состояния, сгенерированный pbapply. Пользователь может увидеть, сколько примерно еще нужно времени, и текущее состояние в виде индикатора.*
Хотя *pbapply* — прекрасный инструмент, и я часто его использую, с ним не удалось отобразить ход выполнения для параллельной версии apply — *mcapply* — до недавнего времени. В сентябре автор *pbapply* добавил в свой пакет поддержку кластеров в простой сети (snow-type — Simple Network Of Workstations — простая сеть рабочих станций) и многоядерного разветвления. Но этот подход предполагает разделение элементов на части и последовательное применение к ним *mcapply*. Один из недостатков этого подхода состоит в том, что если количество элементов сильно превышает количество ядер, нужно вызвать *mcapply* много раз. Вызовы *mcapply*, построенные на основе функции *fork()* в Unix/Linux, очень дороги: разветвление в множество дочерних процессов занимает время и слишком много памяти.
*Обратите внимание, pbapply генерирует много дочерних процессов, а pbmcapply переиспользует их там, где это возможно. Для pbapply/pbmcapply выделено 4 ядра. Код на R можно загрузить [отсюда](https://gist.github.com/kvnkuang/884ac81f5e7d0ff3e262216a230bdc61).*
Pbmcapply
---------
*Pbmcapply* — мое собственное решение проблемы. Оно доступно через пакет [CRAN](https://cran.r-project.org/package=pbmcapply), и его легко использовать:
```
# Установить pbmcapply
install.packages("pbmcapply")
```
Как понятно из названия, я вдохновился пакетом *pbapply*. В отличие от *pbapply*, мое решение не предполагает много вызовов *mcapply*. Вместо этого *pbmcapply* использует пакет *future*.
*Схема pbmcapply. FutureCall() выполняется в отдельном процессе, который потом разветвляется в заданное количество дочерних. Дочерние процессы периодически передают информацию о своем ходе через progressMonitor. Как только progressMonitor получает данные, он выводит состояние на стандартное устройство вывода.*
В компьютерных науках future обозначает объект, который позже будет содержать значение. Это позволяет программе выполнять какой-то код как future и, не дожидаясь вывода, переходить к следующему шагу. В *pbmcapply mcapply* можно поместить во future. Future будет периодически предоставлять информацию о своем состоянии основной программе, которая, в свою очередь, будет отображать индикатор состояния.
Поскольку в *pbmcapply* затраты ресурсов минимальны и нелинейны, получим значительное улучшение производительности, когда количество элементов сильно превышает количество ядер процессора. В качестве иллюстрации используются одно- и многопоточные apply-функции в R. Очевидно, что даже с *pbmcapply*, производительность страдает, поскольку для запуска процесса мониторинга требуется время.
*Сравнение производительности pbapply и pbmcapply. Код на R можно загрузить [отсюда](https://gist.github.com/kvnkuang/dfb7c441ccb141f7e2aa38c85b53c11b). Левая панель показывает затраты ресурсов при вызове каждого из пакетов. Правая панель показывает время на каждый вызов.*
Все имеет свою цену. Наслаждаясь удобством интерактивного отслеживания состояния, помните, это немного замедляет программу.
Заключение
----------
Как и всегда, универсального решения нет. Если ваш основной приоритет — производительность (например, при запуске программы в кластере), возможно, наилучший способ отслеживания хода выполнения — ***print***. Однако, если лишние пару секунд ничего не решают, пожалуйста, воспользуйтесь моим решением ([pbmcapply](https://cran.r-project.org/package=pbmcapply)) или [pbapply](https://cran.r-project.org/package=pbapply), чтобы сделать вашу программу более удобной.
#### Ссылки
Myers, B. A. (1985). The importance of percent-done progress indicators for computer-human interfaces. In ACM SIGCHI Bulletin (Vol. 16, №4, pp. 11–17). ACM. | https://habr.com/ru/post/317314/ | null | ru | null |
# MSBuild — в Open Source на github
Сегодня мы особенно рады сообщить что [MSBuild](https://github.com/Microsoft/msbuild) (наверное, самая часто используемая и самая таинственная по документированности — прим. перев.) — теперь доступен на [github](https://github.com/Microsoft/msbuild) и мы вносим его в список [.NET Foundation](http://)! [The Microsoft Build Engine (MSBuild)](https://github.com/Microsoft/msbuild) — это платформа для построения приложений. Вызывая msbuild на вашем проекте или решении, вы можете организовывать и строить свои продукты в окружениях, где нет установленной MS Visual Studio. Например, MSBuild используется чтобы строить такие Open Source проекты, как [.NET Core Libraries](https://github.com/dotnet/corefx) и [.NET Core Runtime](https://github.com/dotnet/coreclr).
Исходники MSBuild выложены сегодня и практически идентичны с версией, которая поставляется с MS Visual Studio 2015, в которых, однако, можно заметить несколько отличий, так как это — наша первая попытка сделать автономную сборку этого проекта и со временем, когда мы все окончательно сделаем, этих отличий не станет (витиевато помутил воду вилами, — прим. перев.). Имейте ввиду, что в настоящее время вам необходимо иметь установленную MS Visual Studio 2015, чтобы собрать проект MSBuild,
В самое ближайшее время мы добавим поддержку Mac и Linux (возможно, именно с вашей помощью!), так что вы сможете его использовать для построения проектов на базе .NET Core прямо на серверах Linux (я уже представляю агенты TeamCity, установленные на Slackware, которые собирают и деплоют на соседний FreeBSD хостинг ASP.NET 5 приложение… Картина «Приехали»? На мой взгляд — это наше прекрасное будущее, — прим. перев.). Первым делом мы начнем с Mono (т.е. Xamarin для Mac/Android/iOS), с оглядкой на возможность быстрого портирования на .NET Core. И, если признаться, мы только начали портирование. Мы надеемся, что среди вас найдется не мало мотивированных умельцев помочь нам с этой задачей.
С чего начать?
==============
Для начала, необходимо собрать проект MSBuild. Чтобы сделать это, как и говорилось в статье, необходимо установить MS Visual Studio 2015. После чего достаточно выполнить всего три команды (при условии установленного git):
```
git clone https://github.com/Microsoft/msbuild.git
cd msbuild
build.cmd
```
Сборка консольного приложения
=============================
Чтобы собрать приложение, для начала запустите скрипт BuildAndRun.cmd, который мы включили в корень репозитория. Он построит все исходники и создаст копию результата построения (build output) со всем необходимым (имеется ввиду сам msbuild). Т.е., выполните команду:
```
BuildAndCopy.cmd bin\MSBuild true
```
Теперь, чтобы построить простейшее консольное приложение, попробуйте следующие команды:
```
cd ..\
git clone https://github.com/dotnet/corefxlab
.\msbuild\bin\MSBuild\MSBuild.exe .\corefxlab\demos\CoreClrConsoleApplications
\HelloWorld\HelloWorld.csproj
.\corefxlab\demos\CoreClrConsoleApplications\HelloWorld\bin\Debug\HelloWorld.exe
```
Резюмируя
=========
MSBuild — инструмент по умолчанию для построения проектов в Vusial Studio. Через перевод его в Open Source, мы надеемся на фидбэк со стороны сообщества, который сделает его лучшим выбором для любого разработчика .NET на Linux и Mac. | https://habr.com/ru/post/253589/ | null | ru | null |
# Основы теории вычислительных систем: машина с конечным числом состояний
Теория вычислительных систем — это то, что позволяет нам программировать. Однако, можно писать программы и без представления о концепциях, скрывающихся за вычислительными процессами. Не то, чтобы это было плохо — когда мы программируем, то работаем на намного более высоком уровне абстракции. В конце концов, когда мы ведём машину, то концентрируемся только на двух или трёх педалях, переключателе передач и руле. Для повседневной неспешной езды этого более чем достаточно. Однако, если мы хотим управлять автомобилем на пределе его возможностей, то тут нужно знать гораздо больше, чем просто три педали, КПП и руль.
Такой подход справедлив и в программировании. Б*о*льшая часть повседневной мирской работы может быть выполнена при минимальном знании теории вычислительных систем или даже вообще без него. Не нужно понимать теорию категорий, чтобы накидать форму «Контакты» в PHP. Тем не менее, если вы планируете писать код, требующий серьёзных вычислений, то тут уж придётся разобраться с тем, что у этих самых вычислений под капотом.
Цель этой статьи — представить некоторые фундаментальные основы вычислений. Если это окажется интересным, то в дальнейшем я могу написать более продвинутый топик на эту тему, но прямо сейчас я хочу просто рассмотреть логику простейшего абстрактного вычислительного устройства — машины с конечным числом состояний (finite state machine).
### Машина с конечным числом состояний
**Машина с конечным числом состояний** (*finite state machine*, *FSM*), или **конечный автомат** (*finite automaton*) — это математическая абстракция, используемая при проектировании алгоритмов. Говоря простым языком, машина с конечным числом состояний умеет считывать последовательности входных данных. Когда она считывает входной сигнал, то переключается в новое состояние. Куда именно переключится, получив данный сигнал, — заложено в её текущем состоянии. Звучит запутанно, но на самом деле всё очень просто.
Представим устройство, которое читает длинную бумажную ленту. На каждом дюйме этой ленты напечатана буква — *a* или *b*.
Как только устройство считывает букву, оно меняет своё состояние. Вот очень простой граф переходов для такой машины:
Кружки — это состояния, в которых машина может быть. Стрелочки — переходы между ними. Так что, если вы находитесь в состоянии *s* и считываете *a*, то вам необходимо перейти в состояние *q*. А если *b*, то просто остаётесь на месте.
Итак, если изначально мы находимся в состоянии *s* и начинаем читать ленту из первого рисунка слева направо, то сначала будет прочитана *a*, и мы переместимся в состояние *q*, затем *b* — вернёмся обратно в *s*. Следующая *b* оставит нас на месте, а *a* вновь переместит в *q*. Элементарно, но какой в этом смысл?
Оказывается, если пропустить ленту с буквами через FSM, то по её итоговому состоянию можно сделать некоторые выводы о последовательности букв. Для приведённго выше простого конечного автомата финальное состояние *s* означает, что лента закончилась буквой *b*. Если же мы закончили в состоянии *q*, то последней на ленте была буква *a*.
Это может показаться бессмысленным, но существует масса задач, которые можно решить с помощью такого подхода. Простейший пример: определить, содержит ли HTML-страница следующие теги в заданном порядке:
```
```
Машина с конечным числом состояний может перейти в новой состояние, считав ``, потом зациклиться до считывания , зациклиться до считывания` и т.д. Если она успешно придёт к финальному состоянию, то заданные тэги стоят в правильном порядке.
Также конечный автомат может использоваться для представления механизмов парковочного счётчика, автомата с газировкой, автоматизированного газового насоса и тому подобных штук.
### Детерминированная машина с конечным числом состояний (Deterministic Finite State Machine)
Машины с конечным числом состояний, которые мы рассматривали выше, являются **детерминированными**. У них из любого состояния существует только один переход для любого разрешённого входного сигнала. Другими словами, не существует двух различных путей из данного состояния, когда вы считываете, допустим, букву *a*. На первый взгляд такое ограничение кажется глупым.
Что хорошего в наборе решений, если один и тот же сигнал на входе может переместить вас более, чем в одно состояние? Вы же не можете сказать компьютеру: если `x == true`, то выполни doSomethingBig() *или* doSomethingSmall(), не так ли?
Ну, вообще-то, с помощью машины с конечным числом состояний можно провернуть что-то в этом роде. Выход конечного автомата - его финальное состояние. Сначала он проведёт все вычисления, затем прочтёт последнее состояние, и *только тогда* совершится какое-то действие. А в процессе переходов от состояния к состоянию не будет делаться ровным счётом ничего. FSM обрабатывает поступившие данные, и только дойдя до конца и считав конечное состояние, совершает ожидаемое от неё действие (например, наливает газировку). Этот принцип особенно важен, когда дело доходит до недетерминированных машин с конечным числом состояний.
### Недетерминированная машина с конечным числом состояний (Nondeterministic Finite State Machine)
**Недетерминированные машины с конечным числом состояний**, или **недетерминированные конечные автоматы** (*nondeterministic finite automaton*, *NFA*) - это конечные автоматы, у которых входной сигнал для данного состояния может вести более чем в одно последующее состояние. Допустим, например, что мы хотим построить FSM, которая способна распознавать строки букв, начинающиеся с буквы *a*, за которой следует нуль или более букв *b* или нуль или более букв *c*. Условие останова - следующая буква алфавита на входе. Допустимыми строками будут:
* *abbbbbbbbbc*
* *abbbc*
* *acccd*
* *acccccd*
* *ac* (нуль повторений *b*)
* *ad* (нуль повторений *c*)
Итак, надо распознать букву *a* с последующим нулём или более одинаковых букв *b* или *c* и с замыкающей следующей буквой алфавита. Самый простой способ отобразить этот алгоритм с помощью машины с конечным числом состояний представлен ниже. Финальное состояние *t* означает, что строка была принята целиком и соответствует шаблону.
Видите проблему? Находясь в начальной точке *s* мы понятия не имеем, какой из путей выбрать. Если мы прочли только букву *a*, то мы ещё не знаем, идти нам в *q* или в *r*. Существует несколько способов решить эту задачу. Первый из них - откат. Вы просто перебираете все возможные пути и игнорируете или возвращаетесь назад по тем из них, где решение заходит в тупик.
На этом принципе основан алгоритм большинства шахматных программ. Они просматривают все возможности всех возможных ходов на данном этапе и выбирают ту стратегию, которая в данный момент даёт максимальное преимущество над противником.
Другой путь - это преобразовать недетерминированную машину с конечным числом состояний в детерминированную. Существование алгоритма преобразования любой недетерминированного автомата в детерминированный является одним из интереснейших атрибутов NFA. Однако, часто это весьма сложный процесс. К счастью для нас, пример выше достаточно прост. Фактически, всё преобразование можно провести в уме, не прибегая к помощи формального алгоритма.
Машина ниже - детерминированная версия недетерминированной машины на предыдущем рисунке. Здесь конечные состояния *t* или *v* достижимы для любой принятой машиной строки.
Недетерминированная модель имеет четыре состояния и шесть переходов. Детерминированная модель - шесть состояний, десять переходов и два возможных завершения. Разница невелика, однако мы знаем, что сложность имеет свойство расти по экспоненте. И адекватных размеров недетерминированная машина способна вырасти в просто огромную детерминированную.
### Регулярные выражения
Если вы когда-нибудь занимались любым видом программирования, то вы почти наверняка сталкивались с регулярными выражениями (regular expressions). Регулярные выражения и машины с конечным числом состояний функционально эквивалентны. Всё, что можно допустить для (или связать с) регулярным выражением, можно допустить для (или связать с) конечным автоматом. Например, шаблон, который мы разбирали выше, можно связать с
`a(b*c|c*d)`
Регулярные выражения и машины с конечным числом состояний также имеют и одинаковые ограничения. Точнее, они могут принимать или связывать шаблоны, для обработки которых требуется конечный размер памяти. Так какие же типы шаблонов для них недопустимы? Предположим, что мы хотим найти только строки, состоящие из *a* и *b*, где за каким-то количеством букв *a* следует такое же число букв *b*. Другими словами, за *n* *a* следует *n* *b*, где *n* - какое-то число. Примером могут послужить строки:
* ab
* aabb
* aaaaaabbbbbb
* aaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbb
На первый взгляд это выглядит детской задачей для машины с конечным числом состояний. Проблема в том, что вы или быстро выйдете за пределы заданного числа состояний, или вам придётся допустить бесконечное их количество - и в этот момент ваше устройство перестаёт быть машиной с *конечным* числом состояний. Допустим, вы создаёте конечный автомат, который может принять двадцать *a* и следующие за ними двадцать *b*. Он будет прекрасно работать до те пор, пока на вход не придёт строка из двадцати одной *a* и двадцати одной *b*. И тогда вам придётся переписывать вашу машину для обработки более длинных строк. Для любой строки, которую вы можете распознать, всегда есть ещё одна, которая будет лишь немного длиннее, но которую ваша машина уже не способна обработать, не выходя за пределы памяти.
Это положение известно как [лемма о накачке для регулярных языков](http://ru.wikipedia.org/wiki/%D0%9B%D0%B5%D0%BC%D0%BC%D0%B0_%D0%BE_%D0%BD%D0%B0%D0%BA%D0%B0%D1%87%D0%BA%D0%B5_%D0%B4%D0%BB%D1%8F_%D1%80%D0%B5%D0%B3%D1%83%D0%BB%D1%8F%D1%80%D0%BD%D1%8B%D1%85_%D1%8F%D0%B7%D1%8B%D0%BA%D0%BE%D0%B2). Её основная мысль: если ваш шаблон имеет блок, который может быть повторён более, чем один раз, то этот шаблон не является регулярным. Другими словами, ни регулярные выражения, ни машины с конечным числом состояний не могут быть сконструированы так, чтобы распознавать *все* строки, которые можно связать с шаблоном.
Если вы посмотрите внимательнее, то заметите, что тип шаблона, в котором каждая *a* связана с *b*, выглядит очень похоже на HTML, где внутри любой пары тэгов можно заключить произвольное количество других пар тэгов. Вот почему вы можете использовать регулярное выражение или машину с конечным числом состояний для распознавания, содержит ли HTML-страница конкретные `html`, `head` и `body` элементы в правильном порядке, но не можете использовать регулярное выражение, чтобы сказать, является ли HTML-страница целиком корректной или нет. HTML - не регулярный шаблон.
### Машина Тьюринга
Так как же нам распознавать нерегулярные шаблоны? Существует теоретическое устройство, подобное конечному автомату и называемое **машиной Тьюринга** (Turing Machine). Как и у машины с конечным числом состояний, у него имеется бумажная лента, с которой оно считывает информацию. Однако, машина Тьюринга также способна записывать и стирать данные на ленте. Полное объяснение принципов этого устройства займёт больше места, чем у нас здесь имеется, поэтому я обозначу лишь несколько важных моментов, относящихся к нашей дискуссии о машинах с конечным числом состояний и регулярных выражениях.
Машина Тьюринга вычислительно полна, и всё, что в принципе может быть вычислено, может быть вычислено с помощью машины Тьюринга. А благодаря способности записывать данные на ленту с такой же лёгкостью, как и считывать их с ленты, она не ограничена конечным числом состояний. Бумажную ленту можно представить, как имеющую бесконечную длину. Очевидно, что современные компьютеры не обладают бесконечным количеством памяти, однако, они имеют её достаточно, чтобы вы не вышли за предел для тех типов задач, которые они способны обработать.
Машина Тьюринга предоставляет нам воображаемое механическое устройство, позволяющее визуализировать и понять, как работает вычислительный процесс. Это особенно полезно для понимания пределов вычислений. Если это интересно, то в будущем я могу написать отдельную статью о машине Тьюринга.
### Почему это имеет значение?
Так какой во всём этом смысл? Как вышесказанное способно помочь вам при создании очередной PHP-формы? Несмотря на все их ограничения, машины с конечным числом состояний - одна из центральных концепций теории вычислений. В частности, тот факт, что из любого недетермированного конечного автомата, который вы можете спроектировать, возможно получить детерминированный конечный автомат, делающий то же самое. Это ключевой момент, потому что подразумевает, что вы можете спроектировать свой алгоритм, в котором каждый шаг будет наиболее очевидным. А уже имея надлежащий алгоритм, вы сможете легко конвертировать его в ту форму, в которой он будет наиболее эффективен.
Понимание, что машины с конечным числом состояний и регулярные выражения функционально эквивалентны, открывает невероятно интересные способы применения движков регэкспов. Особенно, когда дело доходит до создания бизнес-правил, которые могут быть изменены без перекомпиляции всей системы.
Знание основ теории вычислительных систем позволяет вам брать проблему X, которую вы понятия не имеете как решать, и применять к ней подход: "Я не знаю, как решить X, но я знаю, как решить Y и как привести решение для Y к решению для X. Вот почему теперь я знаю, как решить X".` | https://habr.com/ru/post/169373/ | null | ru | null |
# RE: Занимательная задачка
Копаясь в поиске сайта, наткнулся на [занимательную задачку](http://mako.habrahabr.ru/blog/38728/) и не смог отказать себе в удовольствии потратить 10 минут времени для решения её на полюбившемся мне прологе.
> `*% ((((1?2)?3)?4)?5)?6*
> **solve**(*Formula*) :-
> *Signs* **=** [+, -, \*, //],
> **member**(*Op1*, *Signs*),
> **member**(*Op2*, *Signs*),
> **member**(*Op3*, *Signs*),
> **member**(*Op4*, *Signs*),
> **member**(*Op5*, *Signs*),
> *A* **=**.. [*Op1*, 1, 2],
> *B* **=**.. [*Op2*, *A*, 3],
> *C* **=**.. [*Op3*, *B*, 4],
> *D* **=**.. [*Op4*, *C*, 5],
> *Formula* **=**.. [*Op5*, *D*, 6],
> 35 **=**:**=** *Formula*.` | https://habr.com/ru/post/51644/ | null | ru | null |
# Двоичное кодирование вместо JSON
Кодируйте одни и те же данные гораздо меньшим количеством байт.
### Почему меня это должно волновать
Данные хранятся в памяти в виде структур данных, таких как объекты, списки, массивы и т.д. Но если вы хотите отправить данные по сети или в файле, вам нужно закодировать их в виде последовательности байтов. Перевод из представления в памяти в последовательность байтов называется кодированием, а обратное преобразование – декодированием. Со временем схема данных, обрабатываемых приложением или хранящихся в памяти, может эволюционировать, туда могут добавляться новые поля или удаляться старые. Следовательно, используемая кодировка должна иметь как обратную (новый код должен быть способен читать данные, написанные старым кодом), так и прямую (старый код должен быть способен читать данные, написанные новым кодом) совместимость.
В этой статье мы обсудим различные форматы кодирования, выясним почему двоичное кодирование лучше, чем JSON и XML, и как методы двоичного кодирования поддерживают изменения в схемах данных.
### Типы форматов кодирования
Существует два типа форматов кодирования:
* Текстовые форматы
* Двоичные форматы
### Текстовые форматы
Текстовые форматы в некоторой степени человекочитаемы. Примеры распространенных форматов — JSON, CSV и XML. Текстовые форматы просты в использовании и понимании, но имеют определенные проблемы:
* Текстовые форматы могут быть очень неоднозначны. Например, в XML и CSV нельзя различать строки и числа. JSON может различать строки и числа, но не может различать целые и вещественные числа, а также не задает точности. Это становится проблемой при работе с большими числами. Так, проблема с числами, большими чем 2^53 встречается в Twitter, который использует 64-битное число для идентификации каждого твита. JSON, возвращаемый API Twitter, включает в себя ID твита дважды — в виде JSON-числа и в виде десятичной строки – все из-за того, что JavaScript-приложения не всегда верно распознают числа.
* CSV не имеет схемы данных, возлагая определение значения каждой строки и столбца на приложение.
* Текстовые форматы занимают больше места, чем двоичная кодировка. Например, одна из причин заключается в том, что JSON и XML не имеют схемы, а потому они должны содержать имена полей.
```
{
"userName": "Martin",
"favoriteNumber": 1337,
"interests": ["daydreaming", "hacking"]
}
```
JSON-кодировка этого примера после удаления всех символов пробела занимает 82 байта.
### Двоичное кодирование
Для анализа данных, которые используются только внутри организации, вы можете выбрать более компактный или более быстрый формат. Несмотря на то, что JSON менее многословен, чем XML, оба они все равно занимают много места по сравнению с двоичными форматами. В этой статье мы обсудим три различных бинарных формата кодирования:
1. Thrift
2. Protocol Buffers
3. Avro
Все они обеспечивают эффективную сериализацию данных с использованием схем и имеют инструменты для генерации кода, а также поддерживают работу с разными языками программирования. Все они поддерживают эволюцию схем, обеспечивая как обратную, так и прямую совместимость.
### Thrift и Protocol Buffers
Thrift разработан Facebook, а Protocol Buffers – Google. В обоих случаях для кодирования данных требуется схема. В Thrift схема определяется с помощью собственного языка определения интерфейса (IDL).
```
struct Person {
1: string userName,
2: optional i64 favouriteNumber,
3: list interests
}
```
Эквивалентная схема для Protocol Buffers:
```
message Person {
required string user_name = 1;
optional int64 favourite_number = 2;
repeated string interests = 3;
}
```
Как видите, у каждого поля имеется тип данных и номер тега (1, 2 и 3). У Thrift есть два различных формата двоичной кодировки: BinaryProtocol и CompactProtocol. Двоичный формат прост, как показано ниже, и занимает 59 байт для кодирования данных, приведенных выше.
*Кодирование с использованием двоичного протокола Thrift*
Компактный протокол семантически эквивалентен бинарному, но упаковывает одну и ту же информацию всего в 34 байта. Экономия достигается за счет упаковки типа поля и номера метки в один байт.
*Кодирование с использованием протокола Thrift Compact*
Protocol Buffers кодирует данные аналогично компактному протоколу в Thrift, и после кодирования эти же данные занимают 33 байта.
*Кодирование с использованием Protocol Buffers*
Номера тегов обеспечивают эволюцию схем в Thrift и Protocol Buffers. Если старый код попытается прочитать данные, записанные с новой схемой, он просто проигнорирует поля с новыми номерами тегов. Аналогично, новый код может прочитать данные, записанные по старой схеме, пометив значения как null для пропущенных номеров тегов.
### Avro
Avro отличается от Protocol Buffers и Thrift. Avro также использует схему для определения данных. Схему можно определить, используя IDL Avro (человекочитаемый формат):
```
record Person {
string userName;
union { null, long } favouriteNumber;
array interests;
}
```
Или JSON (более машиночитаемый формат):
```
"type": "record",
"name": "Person",
"fields": [
{"name": "userName", "type": "string"},
{"name": "favouriteNumber", "type": ["null", "long"]},
{"name": "interests", "type": {"type": "array", "items": "string"}}
]
}
```
Обратите внимание, что у полей нет номеров меток. Те же самые данные, закодированные с помощью Avro, занимают всего 32 байта.
Кодирование с помощью Avro.
Как видно из вышеприведенной последовательности байт, поля не могут быть идентифицированы (в Thrift и Protocol Buffers для этого используются метки с номерами), также невозможно определить тип данных поля. Значения просто собираются воедино. Означает ли это, что любое изменение схемы при декодировании будет генерировать некорректные данные? Ключевая идея Avro заключается в том, что схема для записи и чтения не обязательно должна быть одинаковой, но должна быть совместимой. Когда данные декодируются, библиотека Avro решает эту проблему, просматривая обе схемы и транслируя данные из схемы записывающего устройства в схему читающего устройства.
*Устранение различий между схемой читающего и записывающего устройства*
Вы, наверное, думаете о том, как читающее устройство узнает о схеме пишущего. Все дело в сценарии использования кодировки.
1. При передаче больших файлов или данных, записывающее устройство может однократно включить схему в начало файла.
2. В БД с индивидуальными записями каждая строка может быть записана со своей схемой. Самое простое решение – указывать номер версии в начале каждой записи и сохранять список схем.
3. Для отправки записи в сети, читающее и записывающее устройства могут согласовать схему при установке соединения.
Одним из основных преимуществ использования формата Avro является поддержка динамически генерируемых схем. Так как метки с номерами не генерируются, вы можете использовать систему контроля версий для хранения различных записей, закодированных с разными схемами.
### Заключение
В этой статье мы рассмотрели текстовые и двоичные форматы кодирования, обсудили как одни и те же данные могут занимать 82 байта с кодировкой JSON, 33 байта с кодировкой Thrift и Protocol Buffers, и всего 32 байта с помощью кодировки Avro. Двоичные форматы предлагают несколько неоспоримых преимуществ по сравнению с JSON при передаче данных в сети между внутренними службами.
### Ресурсы
Чтобы узнать больше о кодировках и проектировании приложений c интенсивной обработкой данных, я настоятельно рекомендую прочитать книгу Мартина Клеппмана «Designing Data-Intensive Applications».
Узнайте подробности, как получить востребованную профессию с нуля или Level Up по навыкам и зарплате, пройдя платные онлайн-курсы SkillFactory:
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=ML&utm_term=regular&utm_content=07072000) (12 недель)
* [Обучение профессии Data Science с нуля](https://skillfactory.ru/data-scientist?utm_source=infopartners&utm_medium=habr&utm_campaign=DST&utm_term=regular&utm_content=07072000) (12 месяцев)
* [Профессия аналитика с любым стартовым уровнем](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=SDA&utm_term=regular&utm_content=07072000) (9 месяцев)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=PWS&utm_term=regular&utm_content=07072000) (9 месяцев)
### Читать еще
* [Тренды в Data Scienсe 2020](https://habr.com/ru/company/skillfactory/blog/508450/)
* [Data Science умерла. Да здравствует Business Science](https://habr.com/ru/company/skillfactory/blog/508556/)
* [Крутые Data Scientist не тратят время на статистику](https://habr.com/ru/company/skillfactory/blog/507052/)
* [Как стать Data Scientist без онлайн-курсов](https://habr.com/ru/company/skillfactory/blog/507024/)
* [450 бесплатных курсов от Лиги Плюща](https://habr.com/ru/company/skillfactory/blog/503196/)
* [Data Science для гуманитариев: что такое «data»](https://habr.com/ru/company/skillfactory/blog/506798/)
* [Data Scienсe на стероидах: знакомство с Decision Intelligence](https://habr.com/ru/company/skillfactory/blog/506790/) | https://habr.com/ru/post/509902/ | null | ru | null |
# Индикатор искусственного горизонта на HTML5 canvas
Ниже будет представлено воплощение средствами HTML5 одной из необычных идей по визуализации пространственного положения управляемого объекта. Код может использоваться в браузерных играх, имитирующих управление транспортным средством в трехмерном пространстве. Способ представления информации ориентирован на [симуляторы субтеррин](https://habr.com/ru/post/529344/) или других фантастических машин.
Назначение и область применения искусственного горизонта
========================================================
Искусственный горизонт в рассматриваемом здесь узком смысле представляет собой визуализацию наклона объекта относительно местной вертикали, используемую для управления его движением. Наклон определяется значениями двух углов Эйлера, [крена](https://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%B5%D0%BD) и [тангажа](https://ru.wikipedia.org/wiki/%D0%A2%D0%B0%D0%BD%D0%B3%D0%B0%D0%B6). Авиационному термину «тангаж» моряки предпочитают синоним «дифферент».
Родственные искусственному горизонту (но не вполне синонимичные) русскоязычные термины: «авиагоризонт», «пилотажно-командный прибор». В английском языке используются выражения *«attitude indicator»*, *«artificial horizon»* или *«gyro horizon»*.
Известные способы визуализации
==============================
Наибольшее количество работ по поиску удачных решений в области индикации тангажа и крена выполнено в интересах авиации. Этому есть простое объяснение: летчик должен считывать информацию быстро, а любая его ошибка в восприятии пространства грозит стать фатальной.
Большинство известных решений в области индикации крена и тангажа основано на использовании силуэта самолета и специального фона. Общие особенности:
* фон разделен на две части, символизирующие небо и землю, линией, обозначающей горизонт;
* силуэт самолета представляет собой упрощенный «вид сзади», контрастирующий по цвету с фоном;
* угол крена определяется по индикатору как угол между символической линией горизонта и линией, соединяющей законцовки крыла силуэта (обычно для точного считывания присутствует шкала отсчета);
* угол тангажа отсчитывается вдоль шкалы, перпендикулярной условному горизонту по положению контрольной точки в центре силуэта.
Реализованные в массовом производстве системы имеют ряд общих решений:
* информация задается взаимным расположением силуэта и фона;
* изменение угла крена связано с угловым перемещением силуэта относительно фона;
* изменение угла тангажа связано с линейным перемещением силуэта относительно фона.
Но нетрудно догадаться, что реализовать нужное относительное движение можно несколькими различными путями. После множества проб и ошибок прошлого века авиационная эволюция оставила два жизнеспособных сочетания:
1. Неподвижный силуэт, подвижный по крену и тангажу фон. Употребляемые названия: «прямая индикация», «вид с самолета на землю», реже «эгоцентрическая индикация».
2. Подвижный только по крену силуэт, подвижный только по тангажу фон. Употребляемые названия: «обратная индикация» и «вид с земли на самолет», реже «геоцентрическая индикация».
Заметим, что названия п. 2 применяются к системе в целом, но отражают лишь принятый в ней принцип индикации угла крена. Индикация угла тангажа в обеих используемых системах является «прямой» и «эгоцентрической».
В существующих авиационных симуляторах, например, в [Microsoft Flight Simulator](https://ru.wikipedia.org/wiki/Microsoft_Flight_Simulator) и [Digital Combat Simulator](https://ru.wikipedia.org/wiki/Digital_Combat_Simulator), можно оценить в действии оба типа индикации.
Стоит отметить, что не все известные решения вписываются в приведенный выше шаблон. Для примера выхода за обозначенные рамки рассмотрим два патента на изобретения: RU 2561311 и RU 2331848.
Первый патент посвящен «Авиагоризонту с разнесенными по высоте указателями крена и тангажа», его авторы: Путинцев В. И. и Литуев Н. А. Схема ниже взята из патента.
При необходимости можно найти расшифровку обозначений и описание работы в тексте [первоисточника](https://patents.s3.yandex.net/RU2561311C9_20150927.pdf). В целом замысел изобретения довольно прост: идея «вида с земли на самолет» реализуется и по крену, и по тангажу (полный «геоцентризм»), но индикация разделяется на два самостоятельных компонента.
Второе изобретение имеет более сложное название: «Командно-пилотажный прибор логической индикации положения и управления летательным аппаратом в пространстве». Авторы патента: Пленцов А. П. и Законова Н. А. Идея индикации тангажа и крена здесь весьма необычна.
Расшифровка обозначений схемы, описание прибора, сравнение с аналогами и дополнительные схемы с небольшими отличиями в оформлении приведены в [патенте](https://patents.s3.yandex.net/RU2331848C2_20080820.pdf).
Есть одна общая черта с предыдущим изобретением – концепция геоцентризма для обоих каналов. При этом авиагоризонт имеет только один «символ самолета», как на существующих образцах, но это уже не силуэт, а трехмерная модель – «объемный макет». Если движение по крену получается похожим на реализованное в «обратной» индикации, то кабрирования и пикирования на этом приборе выглядят оригинально.
Существует ряд факторов, сдерживающих новаторство в проектировании реальных систем индикации. Например, одно из разумных оснований для консерватизма – стремление к сохранению преемственности приобретенных оператором навыков, в том числе, навыков восприятия информации. Компьютерные игры могут позволить себе гораздо больше креатива, поэтому, не углубляясь в сравнительный анализ решений, возьмем за основу изобретение, выглядящее наиболее эффектным.
Требования к решению
====================
Прежде чем приступить к написанию кода, определим задание:
1. Необходимо написать функцию *drawAttitude()*, рисующую средствами *canvas* индикатор искусственного горизонта на основе изобретения Пленцова А. П. и Законовой Н. А.
2. В качестве аргументов функция принимает контекст *canvas*, координаты центра индикатора, значения углов крена и тангажа в градусах, радиус лицевой части индикатора.
3. Значения угла тангажа ограничены интервалом от минус 30 до плюс 30 градусов.
4. Значения угла крена ограничены интервалом от минус 45 до плюс 45 градусов.
5. В случае выхода значения аргумента за указанные в пп. 3 и 4 пределы индикатор показывает ближайшее разрешенное значение.
Создание функции
================
Код функции включает следующие части:
1. Проверка введенных значений на предмет выхода за ограничения.
2. Перевод значений углов в радианы.
3. Масштабирование характерного размера «макета» и шрифта по значению радиуса индикатора.
4. Рисование компонентов:
а) Корпус индикатора.
б) Макет.
в) Шкалы тангажа и крена.
Приведенная ниже функция написана именно в такой последовательности, а ее части разделены комментариями.
**Полный код**
Код файла *index.html*:
```
Attitude
```
Код файла *attitude.js*:
```
window.onload = function () {
let canvas = document.getElementById("drawingCanvas");
let context = canvas.getContext("2d");
let run = function () {
drawAttitude(context, 320, 240, 30 * Math.sin(performance.now() / 2000), 45 * Math.sin(performance.now() / 5000), 200);
}
let interval = setInterval(run, 1000 / 60);
};
drawAttitude = function (ctx, centreX, centreY, pitch, roll, radius = 100) {
//Проверка значений по ограничениям:
if (pitch > 30) pitch = 30;
if (pitch < -30) pitch = -30;
if (roll > 45) roll = 45;
if (roll < -45) roll = -45;
//перевод в радианы:
roll *= Math.PI / 180;
pitch *= Math.PI / 180;
//размер "макета" и шрифта:
let vehicleSize = radius * 0.8;
ctx.font = Math.round(radius / 8) + "px Arial";
//корпус индикатора и заливка фона:
ctx.lineWidth = 2;
ctx.strokeStyle = "Black";
//нижний полукруг:
ctx.beginPath();
ctx.arc(centreX, centreY, radius, 0, Math.PI, false);
ctx.fillStyle = "Maroon";
ctx.stroke();
ctx.fill();
//верхний полукруг:
ctx.beginPath();
ctx.arc(centreX, centreY, radius, 0, Math.PI, true);
ctx.fillStyle = "SkyBlue";
ctx.stroke();
ctx.fill();
//"макет":
ctx.beginPath();
//цвет:
let topSideIsVisible = (pitch >= 0);
ctx.strokeStyle = topSideIsVisible ? "Orange" : "Brown";
ctx.fillStyle = topSideIsVisible ? "Yellow" : "Red";
ctx.lineWidth = 3;
//контур
//проходит через 4 точки, начиная с задней центральной против часовой стрелки,
//если смотреть сверху:
ctx.moveTo(centreX, centreY - Math.sin(pitch) * vehicleSize / 2);
ctx.lineTo(centreX + vehicleSize * Math.cos(roll), centreY + vehicleSize * Math.sin(roll) * Math.cos(pitch));
ctx.lineTo(centreX, centreY - 2 * Math.sin(pitch) * vehicleSize);
ctx.lineTo(centreX - vehicleSize * Math.cos(roll), centreY - vehicleSize * Math.sin(roll) * Math.cos(pitch));
ctx.lineTo(centreX, centreY - Math.sin(pitch) * vehicleSize / 2);
ctx.stroke();
ctx.fill();
//шкала тангажа:
//верхняя часть:
ctx.beginPath();
ctx.strokeStyle = "Black";
ctx.fillStyle = "Black";
ctx.lineWidth = 1;
//текст:
ctx.fillText(30, centreX - radius * 0.28, centreY - vehicleSize + radius / 20);
ctx.fillText(20, centreX - radius * 0.28, centreY - vehicleSize * 0.684 + radius / 20);
ctx.fillText(10, centreX - radius * 0.28, centreY - vehicleSize * 0.348 + radius / 20);
//метки - линии:
ctx.moveTo(centreX - radius / 10, centreY - vehicleSize);
ctx.lineTo(centreX + radius / 10, centreY - vehicleSize);
ctx.stroke();
ctx.moveTo(centreX - radius / 10, centreY - vehicleSize * 0.684);
ctx.lineTo(centreX + radius / 10, centreY - vehicleSize * 0.684);
ctx.stroke();
ctx.moveTo(centreX - radius / 10, centreY - vehicleSize * 0.348);
ctx.lineTo(centreX + radius / 10, centreY - vehicleSize * 0.348);
ctx.stroke();
//нижняя часть:
ctx.beginPath();
ctx.strokeStyle = "White";
ctx.fillStyle = "White";
//текст:
ctx.fillText(30, centreX - radius * 0.28, centreY + vehicleSize + radius / 20);
ctx.fillText(20, centreX - radius * 0.28, centreY + vehicleSize * 0.684 + radius / 20);
ctx.fillText(10, centreX - radius * 0.28, centreY + vehicleSize * 0.348 + radius / 20);
//метки - линии:
ctx.moveTo(centreX - radius / 10, centreY + vehicleSize);
ctx.lineTo(centreX + radius / 10, centreY + vehicleSize);
ctx.stroke();
ctx.moveTo(centreX - radius / 10, centreY + vehicleSize * 0.684);
ctx.lineTo(centreX + radius / 10, centreY + vehicleSize * 0.684);
ctx.stroke();
ctx.moveTo(centreX - radius / 10, centreY + vehicleSize * 0.348);
ctx.lineTo(centreX + radius / 10, centreY + vehicleSize * 0.348);
ctx.stroke();
//шкала крена:
ctx.lineWidth = 2;
//+-15 градусов:
ctx.fillText(15, centreX + radius * 0.6, centreY + radius * 0.22);
ctx.moveTo(centreX + 0.966 * 0.8 * radius, centreY + 0.259 * 0.8 * radius);
ctx.lineTo(centreX + 0.966 * 0.95 * radius, centreY + 0.259 * 0.95 * radius);
ctx.fillText(15, centreX - radius * 0.75, centreY + radius * 0.22);
ctx.moveTo(centreX - 0.966 * 0.8 * radius, centreY + 0.259 * 0.8 * radius);
ctx.lineTo(centreX - 0.966 * 0.95 * radius, centreY + 0.259 * 0.95 * radius);
//+-30 градусов:
ctx.moveTo(centreX + 0.866 * 0.8 * radius, centreY + 0.5 * 0.8 * radius);
ctx.lineTo(centreX + 0.866 * 0.95 * radius, centreY + 0.5 * 0.95 * radius);
ctx.moveTo(centreX - 0.866 * 0.8 * radius, centreY + 0.5 * 0.8 * radius);
ctx.lineTo(centreX - 0.866 * 0.95 * radius, centreY + 0.5 * 0.95 * radius);
//+-45 градусов:
ctx.moveTo(centreX + 0.707 * 0.8 * radius, centreY + 0.707 * 0.8 * radius);
ctx.lineTo(centreX + 0.707 * 0.95 * radius, centreY + 0.707 * 0.95 * radius);
ctx.moveTo(centreX - 0.707 * 0.8 * radius, centreY + 0.707 * 0.8 * radius);
ctx.lineTo(centreX - 0.707 * 0.95 * radius, centreY + 0.707 * 0.95 * radius);
ctx.stroke();
}
```
Наиболее сложным для понимания представляется код рисования «макета». Рассмотрим его более детально. В качестве макета решено использовать плоскую симметричную фигуру, имеющую в плане форму стрелки.
Верхняя и нижняя поверхности макета отличаются друг от друга по цвету контура и заливки. Выбор текущего цветового решения – первая часть кода.
Далее происходит построение контура фигуры.
Наиболее сложная задача – определение координат проекций вершин фигуры на плоскость *YOZ*. Именно ее решают выражения с тригонометрическими функциями. Обход вершин в коде производится по порядку их нумерации на рисунке.
Самая объемная часть кода посвящена шкалам и подписям. Отметки шкал имеют множество различий: верхние и нижние, левые и правые, с подписями и без. Внушительное количество строк обусловлено написанием «индивидуального» кода каждого элемента.
Для нанесения меток крена используются тригонометрические функции соответствующих углов. Поскольку значения углов каждой метки известны заранее, в коде прописаны готовые значения синусов и косинусов.
Оценивать вид индикатора лучше в динамике. Покажем с помощью новой функции колебания по тангажу и крену. Для максимального разнообразия положений сделаем амплитуды колебаний соответствующими ограничениям индикатора, а периоды – различными и взаимно простыми.
Заключение
==========
Строго говоря, представленный выше код визуализации крена и тангажа следует называть индикацией «по мотивам» изобретения Пленцова А. П. и Законовой Н. А. Некоторые отступления от оригинальных схем сделаны с целью упрощения задачи, другие – для улучшения реализации.
Представленный индикатор далек от идеала в плане дизайна. Не являются оптимальными по какому-либо объективному критерию и принятые ограничения отображаемых значений. Тем не менее, задачу создания демонстратора интересной технологии можно считать решенной. | https://habr.com/ru/post/530334/ | null | ru | null |
# Ещё один инструмент для проверки ваших npm зависимостей — wtfwith
Вы как-нибудь задумывались, сколько версий одной и той же библиотеки затягивает ваша клиентская или серверная сборка? Мне вот в какой-то момент стало интересно. Навскидку найти для этого готовый инструмент не получилось, а смотреть глазами package-lock слишком утомительно. Как мы знаем — в любой непонятной ситуации нужно писать свой npm пакет, поэтому я именно это и сделал… Дальше в посте я рассмотрю результат анализа живого проекта и сделаю пару спорных выводов.
Ну и никак нельзя обойтись без этой классической картинки:
Как работает
------------
В общем-то никакого rocket science — берём package.json и package-lock.json и пробегаем по всем зависимостям, которые там есть, собирая идентичные модули или модули-форки. Форки, ясное дело, приходится прописывать руками, поэтому сейчас в них указан только lodash и undescore. Но вы всегда можете помочь и расширить этот список.
Как использовать
----------------
Модуль [опубликован](https://www.npmjs.com/package/wtfwith) на npm, проще всего запускать при помощи [npx](https://blog.npmjs.org/post/162869356040/introducing-npx-an-npm-package-runner), хотя никто не мешает вам установить его локально или даже глобально. Дальше буду рассматривать вариант с запуском через npx. Для примера возьму один свой старый проект, который по сути является монолитом на ноде (это было ещё до микросервисного бума, а распиливать его потом было лень и нецелесообразно).
1. `npx wtfwith moduleName` (например, `npm wtfwith lodash`) — проверяем количество вхождений какого-то определённого модуля, выводит результаты, если их больше двух. Результат может быть, например, такой:
**пример**`npx wtfwith lodash
npx: installed 3 in 2.047s
Searching for lodash
Checking path /web/xxx/package-lock.json
Huston, we have a problem:
30 versions of lodash:
- 2.4.2 from root, cheerio@0.18.0
- 3.10.1 from xmlbuilder@2.6.4
- 4.0.0 from twilio@3.15.0
- 4.17.4 from graphlib@2.1.1, sway@1.0.0
- 4.17.5 from aws-sdk@2.211.0, xmlbuilder@4.2.1, request-promise-core@1.1.1, requestretry@1.13.0
- lodash.assign:4.2.0 from ioredis@3.2.2
- lodash.bind:4.2.1 from ioredis@3.2.2
- lodash.clone:4.5.0 from ioredis@3.2.2
- lodash.clonedeep:4.5.0 from ioredis@3.2.2
- lodash.defaults:4.2.0 from ioredis@3.2.2
- lodash.difference:4.5.0 from ioredis@3.2.2
- lodash.flatten:4.4.0 from ioredis@3.2.2
- lodash.foreach:4.5.0 from ioredis@3.2.2
- lodash.get:4.4.2 from z-schema@3.18.4
- lodash.includes:4.3.0 from jsonwebtoken@8.2.1
- lodash.isboolean:3.0.3 from jsonwebtoken@8.2.1
- lodash.isempty:4.4.0 from ioredis@3.2.2
- lodash.isequal:4.5.0 from z-schema@3.18.4
- lodash.isinteger:4.0.4 from jsonwebtoken@8.2.1
- lodash.isnumber:3.0.3 from jsonwebtoken@8.2.1
- lodash.isplainobject:4.0.6 from jsonwebtoken@8.2.1
- lodash.isstring:4.0.1 from jsonwebtoken@8.2.1
- lodash.keys:4.2.0 from ioredis@3.2.2
- lodash.noop:3.0.1 from ioredis@3.2.2
- lodash.once:4.1.1 from jsonwebtoken@8.2.1
- lodash.partial:4.2.1 from ioredis@3.2.2
- lodash.pick:4.4.0 from ioredis@3.2.2
- lodash.sample:4.2.1 from ioredis@3.2.2
- lodash.shuffle:4.2.0 from ioredis@3.2.2
- lodash.values:4.3.0 from ioredis@3.2.2
Advice: Sometimes it is good to make a fresh start: rm ./ -rf && git commit -am 'nevermore' && git push origin master`
2. `npx wtfwith everything` (можно просто опустить аргумент и написать «npx wtfwith», но это уныло) — проверяет вообще все зависимости, которых больше, чем две версии. Может быть, например, такой результат:
**Пример**`npx wtfwith lodash
npx: installed 3 in 1.813s
Searching all strange things...
Checking path /web/xxx/package-lock.json
Huston, we have a problem:
30 versions of lodash:
// ну, это вы уже видели
4 versions of punycode:
- 1.2.4 from dkim-signer@0.1.2
- 1.3.2 from url@0.10.3
- 1.4.1 from tough-cookie@2.3.3
- 2.1.0 from uri-js@3.0.2
4 versions of xmlbuilder:
- 0.4.2 from nodemailer@0.7.1, aws-sdk@2.0.5
- 2.6.4 from root, xml2js@0.4.8
- 4.2.1 from aws-sdk@2.211.0, xml2js@0.4.17
- 9.0.1 from twilio@3.15.0
3 versions of xmldom:
- 0.1.19 from xml-crypto@0.10.1
- 0.1.27 from pdf2json@0.6.2
- 0.1.7 from ws.js@2.0.22
3 versions of mime:
- 1.2.11 from mailcomposer@0.2.12
- 1.4.1 from superagent@3.8.0
- 2.3.1 from root
3 versions of sax:
- 0.4.2 from xml2js@0.2.6
- 0.6.1 from xml2js@0.4.8
- 1.2.1 from aws-sdk@2.211.0, xml2js@0.4.17
3 versions of uuid:
- 1.4.2 from root
- 3.1.0 from aws-sdk@2.211.0
- 3.2.1 from request@2.83.0, request@2.85.0, requestretry@1.13.0, twilio@3.15.0
3 versions of xml2js:
- 0.2.6 from nodemailer@0.7.1, aws-sdk@2.0.5
- 0.4.17 from aws-sdk@2.211.0
- 0.4.8 from root
3 versions of moment:
- 2.19.3 from twilio@3.15.0
- 2.20.1 from moment-timezone@0.5.14
- 2.22.1 from root, joi@4.9.0, moment-range@1.0.9, moment-timezone@0.4.0, moment-timezone@0.5.15
3 versions of readable-stream:
- 1.0.34 from match-stream@0.0.2, pullstream@0.4.1, slice-stream@1.0.0, unzip@0.1.11
- 1.1.14 from dicer@0.2.5, ftp@0.3.10, htmlparser2@3.8.3, nodemailer@0.7.1
- 2.3.3 from mysql@2.14.1, superagent@3.8.0
Advice: What about lunch?`
3. Так же можно указать опцию `--dev` — в случае, если вы, например, собираете бандл из дев зависимостей. Хотя для этого лучше использовать фронтовые инструменты для анализа бандлов. Пример использования показывать не буду, команда выглядит как `npx wtfwith everything --dev`, и вы можете себе примерно представить, какой там выходит ад.
Реальные примеры
----------------
Конечно, было бы интересно проанализировать несколько популярных пакетов, что я и сделал.
1. **express** — как ни удивительно, ничего интересного не нашлось.
2. **gulp** — нашлись всякие мелочи:
**смотрим?**`4 versions of kind-of:
- 3.2.2 from is-accessor-descriptor@0.1.6, is-data-descriptor@0.1.4, is-number@3.0.0, make-iterator@1.0.0, object-copy@0.1.0, snapdragon-util@3.0.1, to-object-path@0.3.0
- 4.0.0 from has-values@1.0.0
- 5.1.0 from array-sort@1.0.0, class-utils@0.3.6, is-descriptor@0.1.6, default-compare@1.0.0, expand-brackets@2.1.4, snapdragon@0.8.2, static-extend@0.1.2
- 6.0.2 from braces@2.3.1, is-accessor-descriptor@1.0.0, is-data-descriptor@1.0.0, is-descriptor@1.0.2, micromatch@3.1.10, nanomatch@1.2.9, use@3.1.0
3 versions of define-property:
- 0.2.5 from class-utils@0.3.6, expand-brackets@2.1.4, object-copy@0.1.0, snapdragon@0.8.2, static-extend@0.1.2
- 1.0.0 from base@0.11.2, braces@2.3.1, extglob@2.0.4, snapdragon-node@2.1.1
- 2.0.2 from micromatch@3.1.10, nanomatch@1.2.9, to-regex@3.0.2`
3. **npm** — довольно забавный результат:
**смотрим!**`14 versions of lodash:
- 3.10.1 from cli-table2@0.2.0
- lodash._baseindexof:3.1.0 from root
- lodash._baseuniq:4.6.0 from root
- lodash._bindcallback:3.0.1 from root
- lodash._cacheindexof:3.0.2 from root
- lodash._createcache:3.1.2 from root
- lodash._createset:4.0.3 from lodash._baseuniq@4.6.0
- lodash._getnative:3.9.1 from root, lodash._createcache@3.1.2
- lodash._root:3.0.1 from lodash._baseuniq@4.6.0
- lodash.clonedeep:4.5.0 from root
- lodash.restparam:3.6.1 from root
- lodash.union:4.6.0 from root
- lodash.uniq:4.5.0 from root
- lodash.without:4.4.0 from root
3 versions of mississippi:
- 1.3.1 from make-fetch-happen@2.6.0
- 2.0.0 from cacache@10.0.4
- 3.0.0 from root, pacote@7.6.1
3 versions of pump:
- 1.0.3 from mississippi@1.3.1
- 2.0.1 from mississippi@2.0.0, pumpify@1.4.0
- 3.0.0 from mississippi@3.0.0`
Как минимум, забавно, что npm явно пытается минимизировать использование лодаша, но его целиком затягивает одна из его зависимостей…
Todo
----
Проект писался за вечер на коленке, поэтому есть некоторые количество вещей, которые там не реализованы:
1. Нет работы с shrinkwrap файлом — но это не очень нужно, вы можете просто сгенерить package-lock для проверки;
2. Поддерживается только node 6+. Тоже не очень критично, ведь есть nvm;
3. Не поддерживается лок файл от yarn. Опять же не слишком критично;
4. Наверняка есть некоторое количество багов и неточностей.
В общем, если вам актуален инструмент, то pull requests приветствуются.
Выводы
------
Выглядят результаты не очень красиво, но, если честно, я ожидал больше ада. Судя по всему, многие таки пользуются инструментами для анализа обновлений и защищённости зависимостей.
Из спорных рекомендаций:
1. Я бы не рекомендовал для заведомо бэковых модулей затягивать зависимости вроде лодаша кусками — всё равно кто-то наверняка затянет к себе полную версию библиотеки. Ну и не забывайте про семантическое версионирование — конечно, без точных ограничений версий всё может в какой-то момент сломаться, но это должно решаться фиксацией зависимостей в package-lock и взаимодействием между разработчиками, а не точными ограничениям. То есть, если вы обнаружили breaking change в какой-то своей зависимости, то хорошо бы зайти к автору пакета и сказать, что он неправ — этим вы сэкономите другим много усилий и терабайты места на дисках.
Хотя вот уважаемый мной автор ioredis делает [ровно наоборот](https://github.com/luin/ioredis/pull/494).
2. Стоит периодически пробегать по своим зависимостям и смотреть, что в них есть подозрительного, а затем отписывать issues или делать pull requests в проблемные модули.
Если вам близка проблема обновления зависимостей, то напоследок могу посоветовать несколько полезных инструментов:
1. [npm-check-updates](https://www.npmjs.com/package/npm-check-updates) — быстро смотрим обновления версий пакетов, быстро их ставим. Только аккуратно!
2. [snyk](https://www.npmjs.com/package/snyk) — проверка безопасности пакетов, про него я уже писал [чуть раньше](https://habrahabr.ru/post/347934/).
3. [node security project](https://www.npmjs.com/package/nsp) — ещё один инструмент для проверки безопасности зависимостей, который можно считать родным для экосистемы, потому что его недавно приобрёл npm.
4. В случае, если вы работаете с фронтом, то наверняка используете что-то вроде webpack-bundle-analyzer, который вам расскажет, что именно у вас вышло в результате. Но я с фронтом не работаю, так что здесь внятных рекомендаций дать не могу.
5. Так же полезно иметь всякие бейджики и CI интеграции, которые вам будут наглядно показывать и оповещать, если что-то устарело или стало небезопасным. Примеров бейджиков приводить не буду, их весьма много, и часть вы можете посмотреть на [shields.io](https://shields.io/). Интеграций тоже много, и, если у вас opensource проект, то travis-ci может прогонять практичски любые проверки.
Периодически появляются подобные посты, но время идёт — так что расскажите, какие полезные проверки и инструменты вы используете в своих проектах сейчас. | https://habr.com/ru/post/353912/ | null | ru | null |
# Книга «Head First. Kotlin»
[](https://habr.com/ru/company/piter/blog/473614/)Привет, Хаброжители! У нас вышла книга для изучения Kotlin по методике Head First, выходящей за рамки синтаксиса и инструкций по решению конкретных задач. Эта книга даст вам все необходимое — от азов языка до продвинутых методов. А еще вы сможете попрактиковаться в объектно-ориентированном и функциональном программировании.
Под катом представлен отрывок «Классы данных»
### Работа с данными
Никому не хочется тратить время и заново делать то, что уже было сделано. В большинстве приложений используются классы, предназначенные для хранения данных. Чтобы упростить работу, создатели Kotlin предложили концепцию класса данных. В этой главе вы узнаете, как классы данных помогают писать более элегантный и лаконичный код, о котором раньше можно было только мечтать. Мы рассмотрим вспомогательные функции классов данных и узнаем, как разложить объект данных на компоненты. Заодно расскажем, как значения параметров по умолчанию делают код более гибким, а также познакомим вас с Any — предком всех суперклассов.
### Оператор == вызывает функцию с именем equals
Как вы уже знаете, оператор == может использоваться для проверки равенства. Каждый раз, когда выполняется оператор ==, вызывается функция с именем equals. Каждый объект содержит функцию equals, а реализация этой функции определяет поведение оператора ==.
По умолчанию функция equals для проверки равенства проверяет, содержат ли две переменные ссылки на один и тот же объект.
Чтобы понять принцип работы, представьте две переменные Wolf с именами w1 и w2. Если w1 и w2 содержат ссылки на один объект Wolf, при сравнении их оператором == будет получен результат true:
Но если w1 и w2 содержат ссылки на разные объекты Wolf, сравнение их оператором == дает результат false, даже если объекты содержат одинаковые значения свойств.
Как говорилось ранее, в каждый объект, который вы создаете, автоматически включается функция equals. Но откуда берется эта функция?
### equals наследуется от суперкласса Any
Каждый объект содержит функцию с именем equals, потому что его класс наследует функцию от класса с именем Any. Класс Any является предком всех классов: итоговым суперклассом всего. Каждый класс, который вы определяете, является подклассом Any, и вам не нужно указывать на это в программе. Таким образом, если вы напишете код класса с именем myClass, который выглядит так:
```
class MyClass {
...
}
```
Компилятор автоматически преобразует его к следующему виду:
> Каждый класс является подклассом класса Any и наследует его поведение. Каждый класс ЯВЛЯЕТСЯ подклассом Any, и вам не придется сообщать об этом в программе.
### Важность наследования от Any
Включение Any как итогового суперкласса обладает двумя важными преимуществами:
* **Оно гарантирует, что каждый класс наследует общее поведение.** Класс Any определяет важное поведение, от которого зависит работа системы. А поскольку каждый класс является подклассом Any, это поведение наследуется всеми объектами, которые вы создаете. Так, класс Any определяет функцию с именем equals, а следовательно, эта функция автоматически наследуется всеми объектами.
* **Оно означает, что полиморфизм может использоваться с любыми объектами.** Каждый класс является подклассом Any, поэтому у любого объекта, который вы создаете, класс Any является его итоговым супертипом. Это означает, что вы можете создать функцию с параметрами Any или возвращаемый тип Any, который будет работать с объектами любых типов. Также это означает, что вы можете создавать полиморфные массивы для хранения объектов любого типа, кодом следующего вида:
```
val myArray = arrayOf(Car(), Guitar(), Giraffe())
```
Компилятор замечает, что каждый объект в массиве имеет общий прототип Any, и поэтому создает массив типа Array.
Общее поведение, наследуемое классом Any, стоит рассмотреть поближе.
### Общее поведение, наследуемое от Any
Класс Any определяет несколько функций, наследуемых каждым классом. Вот примеры основных функций и их поведения:
* **equals(any: Any): Boolean**
Проверяет, считаются ли два объекта «равными». По умолчанию функция возвращает true, если используется для проверки одного объекта, или false — для разных объектов. За кулисами функция equals вызывается каждый раз, когда оператор == используется в программе.
```
val w1 = Wolf() val w1 = Wolf()
val w2 = Wolf() val w2 = w1
println(w1.equals(w2)) println(w1.equals(w2))
false (equals возвращает false, true (equals возвращает true,
потому что w1 и w2 потому что w1 и w2
содержат ссылки содержат ссылки на
на разные объекты.) один и тот же объект — то же самое,
что проверка w1 == w2.
```
* **hashCode(): Int**
Возвращает хеш-код для объекта. Хеш-коды часто используются некоторыми структурами данных для эффективного хранения и выборки значений.
```
val w = Wolf()
println(w.hashCode())
```
**523429237** (Значение хеш-кода w)
* **toString(): String**
Возвращает сообщение String, представляющее объект. По умолчанию сообщение содержит имя класса и число, которое нас обычно не интересует.
```
val w = Wolf()
println(w.toString())
```
**Wolf@1f32e575**
> По умолчанию функция equals проверяет, являются ли два объекта одним фактическим объектом.
>
>
>
> Функция equals определяет поведение оператора ==.
Класс Any предоставляет реализацию по умолчанию для всех перечисленных функций, и эти реализации наследуются всеми классами. Однако вы можете переопределить эти реализации, чтобы изменить поведение по умолчанию всех перечисленных функций.
### Простая проверка эквивалентности двух объектов
В некоторых ситуациях требуется изменить реализацию функции equals, чтобы изменить поведение оператора ==.
Допустим, что у вас имеется класс Recipe, который позволяет создавать объекты для хранения кулинарных рецептов. В такой ситуации вы, скорее всего, будете считать два объекта Recipe равными (или эквивалентными), если они содержат описание одного рецепта. Допустим, класс Recipe определяется с двумя свойствами — title и isVegetarian:
```
class Recipe(val title: String, val isVegetarian: Boolean) {
}
```
Оператор == будет возвращать результат true, если он используется для сравнения двух объектов Recipe с одинаковыми свойствами, title и isVegetarian:
```
val r1 = Recipe("Chicken Bhuna", false)
val r2 = Recipe("Chicken Bhuna", false)
```
Хотя вы можете изменить поведение оператора ==, написав дополнительный код для переопределения функции equals, разработчики Kotlin предусмотрели более удобное решение: они создали концепцию класса данных. Посмотрим, что собой представляют эти классы и как они создаются.
### Класс данных позволяет создавать объекты данных
Классом данных называется класс для создания объектов, предназначенных для хранения данных. Он включает средства, полезные при работе с данными, — например, новую реализацию функции equals, которая проверяет, содержат ли два объекта данных одинаковые значения свойств. Если два объекта содержат одинаковые данные, то они могут считаться равными.
Чтобы определить класс данных, поставьте перед обычным определением класса ключевое слово data. Следующий код преобразует класс Recipe, созданный ранее, в класс данных:
```
data class Recipe(val title: String, val isVegetarian: Boolean) {
}
```
Префикс data преобразует обычный класс в класс данных.
### Как создаются объекты на основе класса данных
Объекты классов данных создаются так же, как и объекты обычных классов: вызовом конструктора этого класса. Например, следующий код создает новый объект данных Recipe и присваивает его новой переменной с именем r1:
```
val r1 = Recipe("Chicken Bhuna", false)
```
Классы данных автоматически переопределяют свои функции equals для изменения поведения оператора ==, чтобы равенство объектов проверялось на основании значений свойств каждого объекта. Если, например, вы создадите два объекта Recipe с одинаковыми значениями свойств, сравнение двух объектов оператором == даст результат true, потому что в них хранятся одинаковые данные:
```
val r1 = Recipe("Chicken Bhuna", false)
val r2 = Recipe("Chicken Bhuna", false)
//r1 == r2 равно true
```
r1 и r2 считаются «равными», потому что два объекта Recipe содержат одинаковые данные.
Кроме новой реализации функции equals, унаследованной от суперкласса Any, классы данных
также переопределяют функции hashCode и toString. Посмотрим, как реализуются эти функции.
### Объекты классов переопределяют свое унаследованное поведение
Для работы с данными классу данных необходимы объекты, поэтому он автоматически предоставляет следующие реализации для функций equals, hashCode и toString, унаследованных от суперкласса Any:
### Функция equals сравнивает значения свойств
При определении класса данных его функция equals (а следовательно, и оператор == ) по-прежнему возвращает true, если ссылки указывают на один объект. Но она также возвращает true, если объекты имеют одинаковые значения свойств, определенных в конструкторе:
```
val r1 = Recipe("Chicken Bhuna", false)
val r2 = Recipe("Chicken Bhuna", false)
println(r1.equals(r2))
true
```
> Объекты данных считаются равными, если их свойства содержат одинаковые значения.
### Для равных объектов возвращаются одинаковые значения hashCode
Если два объекта данных считаются равными (другими словами, они имеют одинаковые значения свойств), функция hashCode возвращает для этих объектов одно и то же значение:
```
val r1 = Recipe("Chicken Bhuna", false)
val r2 = Recipe("Chicken Bhuna", false)
println(r1.hashCode())
println(r2.hashCode())
```
**241131113
241131113**
### toString возвращает значения всех свойств
Наконец, функция toString уже не возвращает имя класса, за которым следует число, а возвращает полезную строку со значениями всех свойств, определенными в конструкторе класса данных:
```
val r1 = Recipe("Chicken Bhuna", false)
println(r1.toString())
Recipe(title=Chicken Bhuna, isVegetarian=false)
```
Кроме переопределения функций, унаследованных от суперкласса Any, класс данных также предоставляет дополнительные средства, которые обеспечивают более эффективную работу с данными, например, возможность копирования объектов данных. Посмотрим, как работают эти средства.
### Копирование объектов данных функцией copy
Если вам потребуется создать копию объекта данных, изменяя некоторые из его свойств, но оставить другие свойства в исходном состоянии, воспользуйтесь функцией copy. Для этого функция вызывается для того объекта, который нужно скопировать, и ей передаются имена всех изменяемых свойств с новыми значениями.
Предположим, имеется объект Recipe с именем r1, который определяется в коде примерно так:
```
val r1 = Recipe("Thai Curry", false)
```
Если вы хотите создать копию объекта Recipe, заменяя значение свойства isVegetarian на true, это делается так:
По сути это означает «создать копию объекта r1, изменить значение его свойства isVegetarian на true и присвоить новый объект переменной с именем r2». При этом создается новая копия объекта, а исходный объект остается без изменений.
Кроме функции copy, классы данных также предоставляют набор функций для разбиения объекта данных на набор значений его свойств — этот процесс называется деструктуризацией. Посмотрим, как это делается.
### Классы данных определяют функции componentN...
При определении класса данных компилятор автоматически добавляет в класс набор функций, которые могут использоваться как альтернативный механизм обращения к значениям свойств объекта. Эти функции известны под общим названием функций componentN, где N — количество извлекаемых свойств (в порядке объявления).
Чтобы увидеть, как работают функции componentN, предположим, что имеется следующий объект Recipe:
```
val r = Recipe("Chicken Bhuna", false)
```
Если вы хотите получить значение первого свойства объекта (свойство title), для этого можно вызвать функцию component1() объекта:
```
val title = r.component1()
```
component1() возвращает ссылку, которая содержится в первом свойстве, определенном в конструкторе класса данных.
Функция делает то же самое, что следующий код:
```
val title = r.title
```
Код с функцией получается более универсальным. Чем же именно функции ComponentN так полезны в классах данных?
### … предназначенные для деструктуризации объектов данных
Обобщенные функции componentN полезны прежде всего тем, что они предоставляют простой и удобный способ разбиения объекта данных на значения свойств, или его деструктуризации.
Предположим, что вы хотите взять значения свойств объекта Recipe и присвоить значение каждого его свойства отдельной переменной. Вместо кода
```
val title = r.title
val vegetarian = r.isVegetarian
```
с поочередной обработкой каждого свойства можно использовать следующий код:
```
val (title, vegetarian) = r
```
Присваивает первому свойству r значение title, а второму свойству значение vegetarian.
Этот код означает «создать две переменные, title и vegetarian, и присвоить значение одного из свойств r каждой переменной». Он делает то же самое, что и следующий фрагмент
```
val title = r.component1()
val vegetarian = r.component2()
```
но получается более компактным.
**Оператор === всегда проверяет, ссылаются ли две переменные на один объект.**
Если вы хотите проверить, ссылаются ли две переменные на один объект независимо от их типа, используйте оператор === вместо ==. Оператор === дает результат true тогда (и только тогда), когда две переменные содержат ссылку на один фактический объект. Если у вас имеются две переменные, x и y, и следующее выражение:
```
x === y
```
дает результат true, то вы знаете, что переменные x и y должны ссылаться на один объект.
В отличие от оператора ==, поведение оператора === не зависит от функции equals. Оператор === всегда ведет себя одинаково независимо от разновидности класса.
Теперь, когда вы узнали, как создавать и использовать классы данных, создадим проект для кода Recipe.
### Создание проекта Recipes
Создайте новый проект Kotlin для JVM и присвойте ему имя «Recipes». Затем создайте новый
файл Kotlin с именем Recipes.kt: выделите папку src, откройте меню File и выберите команду
New → Kotlin File/Class. Введите имя файла «Recipes» и выберите вариант File в группе Kind.
Мы добавим в проект новый класс данных с именем Recipe и создадим объекты данных Recipe. Ниже приведен код. Обновите свою версию Recipes.kt и приведите ее в соответствие с нашей:
```
data class Recipe(val title: String, val isVegetarian: Boolean) (Фигурные скобки {} опущены, так как наш класс данных не имеет тела.)
fun main(args: Array) {
val r1 = Recipe("Thai Curry", false)
val r2 = Recipe("Thai Curry", false)
val r3 = r1.copy(title = "Chicken Bhuna") (Создание копии r1 с изменением свойства title)
println("r1 hash code: ${r1.hashCode()}")
println("r2 hash code: ${r2.hashCode()}")
println("r3 hash code: ${r3.hashCode()}")
println("r1 toString: ${r1.toString()}")
println("r1 == r2? ${r1 == r2}")
println("r1 === r2? ${r1 === r2}")
println("r1 == r3? ${r1 == r3}")
val (title, vegetarian) = r1 (Деструктуризация r1)
println("title is $title and vegetarian is $vegetarian")
}
```
Когда вы запустите свой код, в окне вывода IDE отобразится следующий текст:
```
r1 hash code: -135497891
r2 hash code: -135497891
r3 hash code: 241131113
r1 toString: Recipe(title=Thai Curry, isVegetarian=false)
r1 == r2? true
r1 === r2? false
r1 == r3? false
title is Thai Curry and vegetarian is false
```
» Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/new/product/head-first-kotlin?_gs_cttl=120&gs_direct_link=1&gsaid=82744&gsmid=29789&gstid=c)
» [Оглавление](https://storage.piter.com/upload/contents/978544611335/978544611335_X.pdf)
» [Отрывок](https://storage.piter.com/upload/contents/978544611335/978544611335_p.pdf)
Для Хаброжителей скидка 25% по купону — **Kotlin**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга. | https://habr.com/ru/post/473614/ | null | ru | null |
# Легкая верстка в вынужденных местах: хелперы, декораторы, элементы форм
Многие уже знают о том что во вьюхах не рекомендуется использовать логику и вообще какие-либо манипуляции с данными. Для этого подобный код выносят в [декораторы](https://github.com/drapergem/draper), [кастомные элементы формы](https://github.com/plataformatec/simple_form/wiki/Adding-custom-input-components), [компоненты](https://github.com/apotonick/cells) и просто хелперы в конце-концов.
Действительно, при таком подходе view-файлы начинают выглядить лучше. Но кастомные элементы форм и хелперы становятся просто невыносимыми.
Но есть простой и элегантный способ как сделать их чище и проще…
К примеру возьмем кастомный элемент формы `PriceRangeInput`.
```
class PriceRangeInput < SimpleForm::Inputs::Base
def input
output = template.content_tag(:div, class: 'j-price-slider') do
div = ''
div << template.content_tag(:div, class: 'row') do
row = ""
row << template.content_tag(:span, class: 'span3') do
@builder.input(:min_total_price, label: false, input_html: { class: 'input-small j-min-total-price'})
end
row << template.content_tag(:span, class: 'span3') do
@builder.input(:max_total_price, label: false, input_html: { class: 'input-small j-max-total-price'})
end
row.html_safe
end
div << template.content_tag(:div, class: 'row') do
template.content_tag(:span, class: 'span6') do
template.content_tag(:div, class: 'j-slider', :data => :slider_data) do
end
end
end
div.html_safe
end
output.html_safe
end
end
```
Этот элемент легко вызвать из формы:
```
= simple_form_for current_search_form, :url => :search, :method => "get" do |f|
= f.input :price_range, :label => false, :as => :price_range
```
но упростив саму форму, кастомный элемент стало сложно понимать. В его структуре легко запутаться.
### Выход есть
Решение — использовать [Arbre — Ruby Object Oriented HTML Views.](https://github.com/gregbell/arbre)
Он позволяет легко использовать верстку в коде, а также создавать повторно используемые компоненты. Arbre рожден в проекте [acive\_admin](http://activeadmin.info/) и является, по сути, его основой.
### Ближе к делу
Начнем с добавление помощничка в базовый класс элементов форм. Это один из редких примеров уместного monkey patch.
```
class SimpleForm::Inputs::Base
private
def arbre assigns={}, █
Arbre::Context.new assigns.reverse_merge(:builder=>@builder), template, █
end
end
```
Теперь можем зарефакторить элемент формы:
```
def input
arbre slider_data: slider_data do
div class: 'j-price-slider' do
div class: 'row' do
span class: 'span3' do
builder.input :min_total_price, label: false, input_html: { class: 'input-small j-min-total-price'}
end
span class: 'span3' do
builder.input :max_total_price, label: false, input_html: { class: 'input-small j-max-total-price'}
end
end
div class: 'row' do
span class: 'span6' do
div class: 'j-slider', data: slider_data
end
end
end
end
end
```
Убрали все лишнее, оставили только то, что действительно нужно. Код выглядит приятнее и понятнее.
#### Достоинства Arbre
И так подведем краткое резюме.
1. Использование
> Arbre
позволяет избавиться от буфера, для хранение генерируемых тегов:
```
# было
buffer = ''
buffer << template.content_tag(:div, class: 'row') do
...
buffer << template.content_tag(:div, class: 'row') do
buffer.html_safe
# стало
div class: 'row' do
...
div class: 'row' do
...
```
2. Избавляет нас от необходимости применять мусорный `content_tag` в коде и дает возмжоность прямо указывать необходимый тег:
```
# было
template.content_tag(:div, class: 'row')
# стало
div class: 'row'
```
3. И самое интересное — компоненты.
#### Собственные компоненты
Удивительное еще и то, что `Arbre` позволяет легко добавлять собственные элементы и использовать их в любом контексте.
```
class Row < Arbre::Component
builder_method :row
def build(title, attributes = {})
super(attributes.merge class: 'row')
end
end
```
Сразу после обьявления компонент готов к использованию в любом месте arbre-контекста. Теперь вместо:
```
template.content_tag(:div, class: 'row') do
...
```
можно писать
```
row do
...
```
а на выходе получим код:
```
...
```
В общем arbre помогает сделать неизбежное — верстку в коде, более приятным. Рекомендую. | https://habr.com/ru/post/184528/ | null | ru | null |
# Создаем простой gradient background creator на React
*Disclaimer: Безусловно, эта статья для начинающих кодеров на React. Опытный и не очень react-разработчик не найдет тут ничего полезного. Разве что может указать на ошибки(буду благодарен).*
**Построение и декомпозиция проекта.**
Никакой сложной архитектуры и декомпозиции не будет. Цель проекта - показать часто встречаемое применение хука `useState` и связка javascript кода с html элементами в одном компоненте. Всего будем использовать только три файла: `App.js`, `App.css` и `Gradient.js`.
Инициализация и структурирование проекта
----------------------------------------
Создаем react проект при помощи команды в терминале `npx create-react-app myApp`
Ждем инициализацию проекта. После чего, в нашей папке проекта сформировалась дефолтная структура react-проекта. Конечно мы можем создать наш gradient background creator прямо в `App.js`, но так никто не делает и это не разумно, потому что главной особенностью реакта является разбивка элементов сайта на компоненты и вставка их в родительские(или в соседние) компоненты.
Переходим к созданию нашего компонента `Gradient`. В директории `src` создаем папку `components`, а папке `components` создаем файл с типом .js `Gradient.js`. Правильней было бы сделать для каждого компонента свою папку, где будет сам компонент и его стиль, но, поскольку у нас будет только один компонент сделаем так. Прежде чем начать работу с градиентом, вставим его в основной компонент `App.js`:
```
import React from "react";
import './App.css';
import Gradient from "./components/Gradient";
function App() {
return (
);
}
export default App;
```
Теперь переходим в `Gradient.js` и создаем компонент. Сразу же проинициализируем три `useState`. Один будет отвечать за настройку первого цвета для нашего градиента, второй - для второго. Также добавим ещё один `useState` для градуса наклона градиента и константу `cssOutput` для отображения css кода для клиента:
```
const [color1, setColor1] = useState('#5938ff'); //вносим дефолтный цвет для первого
const [color2, setColor2] = useState('#ffe224'); //вносим дефолтный цвет для второго
const [deg, setDeg] = useState(180); //градус по умолчанию будет 180
//вносим переменные, которые мы зададим
const cssOutput = `linear-gradient(${deg}deg, ${color1}, ${color2})`;
```
Не забываем про импорты:
```
import React, { useState } from "react";
import "../App.css";
```
Теперь переходим к html разметке. Создает главный `div` с классом `main`(его стиль будет ниже). В главном дивe будет два чайлда: первые это блок у которого мы будем менять цвет бэкграунда, а второй это блок с инструментами, с которыми мы будем взаимодействовать. К диву с классом градиент добавляем `style` с нашей переменой `cssOutput`(в которую и будут вноситься выбранные нами параметры.
```
return(
)
```
Открываем `App.css` и пишем стили для блоков. Для `background-image` в `body` я взял рандомный mesh gradient с интернета. Класс `.content` я решил выполнить в полупрозрачном стиле и с размытием заднего фона(`backdrop-filter: blur(5px);`)
```
body {
margin: 0px;
padding: 0px;
font-family: Verdana, Geneva, Tahoma, sans-serif;
color: rgba(0, 0, 0, 0.5);
background-image: url("./bg-mesh.png");
}
.main {
display: flex;
flex-direction: column;
justify-content: center;
align-items: center;
}
.gradient{
width: 70vw;
height: 44vh;
border-radius: .4rem;
margin: 20px;
}
.content{
display:flex;
flex-direction: column;
align-items: center;
background: rgba(233, 233, 233, 0.6);
backdrop-filter: blur(5px);
border-radius: .4rem;
padding-left: 200px;
padding-right: 200px;
}
```
Переходим у главному - создание инпутов и их связка со стэйтами, которые мы определили в начале. Все инпуты находятся в блоке `content`, и их всего три: первый цвет, второй и градус наклона цветов. Input с типом `color` - это простая браузерная палитра цветов. Мы выбираем понравившийся нам цвет, `onChange` это видит и вызванная функция `setColor` вносит название цвета в переменную `color`, которая и является `value` инпута. Тоже самое с инпутом для градуса наклона. При помощи типа инпута `range`, мы выбираем градус наклона от 0 до 360 и передаем в переменную `deg`. И в самом конце выводим переменную `cssOutput`, которая отображает css код текущего градиента.
```
CSS Gradient Background Creator
-------------------------------
### Color 1:
setColor1(event.target.value)}
/>
### Color 2:
setColor2(event.target.value)}
/>
Choose a deg:
-------------
setDeg(event.target.value)} />
### {cssOutput}
```
Остальные стили:
```
.pickers{
display: flex;
align-items: center;
}
.pickers h3{
margin: 10px;
}
.range{
width: 60%
}
```
Вот и всё. Мы создали полностью работающий css gradient background creator меньше чем за 8 минут с возможностью менять цвета и наклон градиента в реальном времени наблюдая за блоком с классом `gradient`. Полный код компонента:
```
import React, { useState } from "react";
import "../App.css";
const Gradient = ()=>{
const [color1, setColor1] = useState('#5938ff');
const [color2, setColor2] = useState('#ffe224');
const [deg, setDeg] = useState(180);
const cssOutput = `linear-gradient(${deg}deg, ${color1}, ${color2})`;
return(
CSS Gradient Background Creator
-------------------------------
### Color 1:
setColor1(event.target.value)}
/>
### Color 2:
setColor2(event.target.value)}
/>
Choose a deg:
-------------
setDeg(event.target.value)} />
### {cssOutput}
)
}
export default Gradient;
```
Что ещё можно добавить?
-----------------------
Много чего. Например: возможность скачивать градиент как картинку, добавлять 3 и больше цветов, создавать не только линейный градиент, а и радиальный... В общем много чего. Надеюсь, начинающие react разработчики нашли хоть что-то полезное для себя. | https://habr.com/ru/post/677286/ | null | ru | null |
# Программируем управление освещением по датчикам движения и освещения на Node-RED
В русскоязычном интернете пока мало статей о такой среде программирования как [Node-RED](http://nodered.org/). Данная статья приоткроет тайну завесы об этом продукте и покажет на примере создания алгоритма управления освещением по датчикам движения как просто с помощью Node-RED можно реализовать различные сценарии и правила автоматизации умного дома в полностью в графическом виде без написания какого-либо кода.
Что такое Node-RED
==================
IBM, как и другие большие компании, пытаются занять свою нишу в развивающемся интернете вещей. Обычно это связано с выпуском open-source приложений и продуктов с целью популяризировать свои платные платформы. Например, в IBM платной платформой является Bluemix.
Node-RED – это open-source детище IBM и, как простенько написано на сайте, это инструмент, который служит для связи железа, API и сервисов новыми и интересными способами.
Способы эти основаны на использовании графических линий связи, по которым пересылаются сообщения между узлами. Таким образом связывать различные блоки можно просто мышкой без использования программирования.
Разработка в Node-RED ведется через обыкновенный браузер, само ядро можно запустить на различных платформах – PC, RPi, cloud и т.д.
Node-RED для умного дома
=========================
Я решил попробовать Node-RED для написания сценариев и правил для умного дома. То есть для автоматизации. Сама связь с различными исполнительными устройствами, веб-сервисами и датчиками у меня сделана на OpenHAB. Почему я решил не делать автоматизацию там же? Несколько причин:
— В OpenHAB сценарии и правила пишутся на своем языке. Изучать его только ради одного применения мне не захотелось.
— Сама отладка правил практически невозможна – если правило не работает, сложно разобраться почему
— Я бы хотел, чтобы мои правила были независимы от железа, каналов связи, платформ и самого ПО для коммуникации с устройствами. Чтобы я мог легко перейти на другую платформу УД, например Domoticz, MajorDomo, FHEM и взять мои правила с собой, а не переписывать их заново под новую платформу УД.
Управление Освещением по датчикам движения и освещенности
==========================================================
Итак приступим к реализации. Собственно оригинальная задача проста и тривиальна:
У меня в коридоре есть управляемые LED споты для освещения. Хочу, чтобы свет загорался по движению и выключался сам через 10 секунд.
Немного усложним задачу:
— Свет должен включаться только когда на улице темно
— Интенсивность света должна зависеть от времени – до 9 часов вечера свет должен включаться с полной интенсивностью, а после только на 10%, как подсветка.
Датчики, исполнители и пр. железо
---------------------------------
Сами протоколы и варианты связи с датчиками и актуаторами я описывать здесь не буду. Достаточно сказать, что в моем умном доме все эти протоколы приводятся к одному – MQTT, а через него уже происходит общение с Node-RED.
И так какие же датчики и исполнительные устройства у меня есть?
1. Датчик движения. Публикует сообщение OPEN в топик /myhome/state/Hall\_motion, когда детектирует движение и CLOSED, если в течении 2-х секунд движения нет.
2. Датчик освещенности. Он измеряет яркость уличного освещения в диапазоне 0-1000 Люкс. Публикует раз в минуту сообщение в топик /myhome/state/Lumin\_Hall с уровнем текущей освещенности.
3. Диммер управления LED лампами. Он подписан на топик /myhome/command/Light\_Hall/state. Если записать туда 0 – свет выключится. 100 – включится на максимальную яркость. 1-99 – будут менять интенсивность освещения. Для ночной подсветки достаточно интенсивности 1.
Описание Flow в Node-RED
------------------------
Предполагается, что Node-RED у вас уже установлен. Если нет — перейдите по ссылке выше и установите любой удобный для вас вариант — на компьютер, Raspberry, clowd и т.д. В моем случае Node-RED устновлен на RPi2 (помоему, он даже входит в поставку Raspbian, так что ничего вообще не нужно устанавливать). Данный flow не требует установки каких-либо дополнительных библиотек.
### Входы и выходы
В первую очередь создаем нужные входы и выходы для нашего алгоритма. Это будут MQTT клиенты, подписывающиеся на соответствующие топики. Их перетаскиваем из библиотеки слева и настраиваем.
Примечание: Отображаемые названия блоков можно изменить в их настройках.
Для датчика освещенности создаем узел Hall Light Sensor из MQTT Input:
В его настройке достаточно прописать адрес MQTT брокера и топик.
У меня брокер крутится на той же платформе, поэтому достаточно оставить localhost.
Для датчика движения создаем узел Hall Motion Sensor:
У него все то же самое, только прописываем другой топик /myhome/state/Hall\_motion.
Как можно заметить адрес и параметры брокера этот узел уже перенял из предыдущего, так что по новой их вводить не надо.
Осталось добавить MQTT Output, чтобы сделать выход для LED диммера. Перетаскиваем MQTT Output и называем Hall Light Dimmer.
В параметрах надо опять же только указать нужный топик, в который будут слаться сообщения для управления диммером — /myhome/command/Light\_Hall/state
В результате мы получили три узла для нашего Flow.
Не мешало бы их проверить на функциональность. Это легко.
К Input блокам подключаем Debug output.
А к выходному блоку подключаем Inject Input.
В настройках этого узла надо поменять payload на уровень желаемой яркости светильника. Например в данном случае это 100.
Мы можем путем copy-paste создать несколько идентичных Inject блоков, поменять яркость, и подключить к выходу вот так:
Так тоже будет работать. Пришло время проверить. Тыкаем кнопку Deploy:
Под MQTT узлами у вас должно появиться маленькое сообщение:
Это означает, что они подключились к MQTT брокеру. Если все прошло по плану, то в правой вкладке debug у вас должны начать появляться сообщения от датчиков, а если кликать мышкой по прямоугольникам слева от Inject узлов, должна меняться интенсивность освещения у светильника, подключенного к диммеру. Если все работает, можно идти дальше.
### Цепь управления освещением по датчику движения
Для простоты я буду называть отдельные связанные между собой блоки цепями. В первую очередь попробуем сделать простую цепь, которая бы включала свет по датчику движения и отключала его спустя какое-то время. Для этого согласно концепции Node-RED нам нужно, чтобы нужное сообщение от датчика движения дошло до диммера через определенные блоки и имело определенный текст. Сначала разберемся с включением света.
В первую очередь выделим из всех сообщений от датчика движения сообщение с текстом OPEN — это значит, что движение появилось. Для этого используем блок switch. Подключим его к выходу уже созданного нами блока Hall Motion Sensor.
Настроим его так, чтобы блок пускал на выход только сообщения с текстом OPEN
Как видно из картинки, блок будет сравнивать payload с текстом OPEN и направлять сообщения на выход один, если текст совпадает.
Наш диммер требует, чтобы на вход ему подавались сообщения с нужной яркостью 0...100. Текст OPEN он не поймет. Поэтому используем блок Change, чтобы поменять текст сообщения.
В настройках этого блока записываем требуемое изменение – message payload изменяем на 100 — требуемую интенсивность освещения.
И наконец подключаем это все ко входу нашего диммера:
Если запустить данную цепь, то можно убедиться, что она работает – свет будет включаться по движению. Осталось сделать так, чтобы он еще и выключался.
Для этого используем блок Trigger и подключим его к выходу датчика движения.
Блок триггер позволяет генерировать сообщения с задержкой, а также может быть сброшен определенным сообщением. Настроим его так:
Данная настройка означает, что при поступлении первого сообщения триггер не посылает ничего, но запускает выдержку времени в 8с и по ее истечении посылает сообщение с текстом 0. Также триггер сбрасывается, если ему на вход поступает сообщение с текстом OPEN. Что же это означает в нашем случае?
Предположим что датчик движения выдал сообщение OPEN. Данное сообщение вернет триггер к исходному состоянию без какой либо реакции. Далее через какое-то время датчик движения выдаст сообщение CLOSED. Это сообщение запустит выдержку времени и через 8 секунд после этого триггер выдаст сообщение 0.
Если в течении этой выдержки времени опять поступит сообщение OPEN, то триггер опять вернется к исходному состоянию и будет ждать следующего сообщения(которое логично будет CLOSED). При этом триггер не выдаст никаких сообщений.
То есть таким образом мы создали таймер, который будет служить нам для автоматического отключения света после заданной выдержки. Если вспомнить описание датчика движения, то становится понятным почему здесь задается 8 секунд, а не 10 – 2 секунды добавляется за счет выдержки самого датчика движения.
Осталось подключить выход триггера к диммеру и можно запускать цепь на проверку.
Замечу, что для простоты я выкладываю скриншоты уже отлаженных цепей. Вы же можете обвешать вашу цепь Debug блоками, чтобы разобраться с принципом работы и ваша цепь может выглядеть и вот так:
И в этом нет ничего страшного.
А можно сделать вообще вот так:
И тогда клацая мышкой на прямоугольниках слева от Inject блоков вы можете отладить цепь вообще без железа – на своем лаптопе во время поездки в метро или даже планшете.
### Цепь включения/отключения света в зависимости от яркости уличного освещения
Теперь нам надо сделать так, чтобы свет не включался, если на улице слишком светло. Для этого нам нужно добавить еще одну цепь и слегка изменить основную цепь, чтобы учесть данный фактор.
Сначала возьмем уже знакомый нам switch блок и подключим его к выходу датчика освещенности.
Настройку этого блока сделаем таким образом, чтобы он направлял сообщения от датчика освещения на один из выходов, в зависимости от текущей освещенности.
Условие выше означает, что если освещенность меньше 10 люкс, то сообщение будет направлено на выход 1. А иначе оно пойдет на выход 2. Не забываем, что надо выбрать
Опцию, чтобы сообщение было направлено только на один из выходов.
Исходя из принципа работы логично получается, что если сообщение появилось на первом(верхнем) выходе, нам надо включить детектирование движения, а если на втором, то выключить.
Тут, конечно, возможен 1000 и 1 способ, самый простой из которых – просто блокировать сообщение на включение света от датчика движения, если на улице светло. Реализуем это.
Следует отметить, что в Node-RED механизм исполнения реализован на основе сообщений. Т.е. нет сообщения – нет события, нет и реакции. Это накладывает определенную специфику в случае, если разные сообщения приходят асинхронно, т.е в разные моменты времени. Например в данном случае сообщение от датчика освещения асинхронно по отношению к с сообщениям от датчика движения. Поэтому, чтобы учесть эффект датчика освещения, нам надо запомнить информацию, которая была в его сообщении и затем применить ее в следующий раз, когда придет сообщение от датчика движения.
На помощь в этом случае приходит контекст – поле, где можно хранить информацию во время исполнения flow. Контекст бывает глобальным по отношению ко всей среде, или локальным по отношению к конкретному flow или вообще только по отношению к конкретному блоку.
В нашем случае мы будем использовать контекст, локальный по отношению к данному flow. Т.е. переменные будут видны всем блокам в этом flow. Создадим блок change и подключим его к первому выходу Light Threshold Detector
Как мы помним, на этом выходе появляется сообщение в том случае, если датчик освещенности отрапортовал, что освещение на улице менее 10 Люкс. Рассмотрим конфигурацию блока change
В данном случае мы используем правило Set, чтобы присвоить переменной flow.Light\_enabled значение Yes. Таким образом мы присвоили значение глобальной переменной, которое мы можем использовать в других блоках.
Аналогичным образом создадим второй блок change и подключим его на второй выход.
Его конфигурация будет такой:
Чтобы узнать правильно ли работает такой детектор мы можем создать простую цепь с блоками Inject и Debug.
При этом в настройках блока Inject укажем, что он должен выдавать каждую секунду значение переменной flow.Light\_enabled
Тогда результат работы датчика освещенности можно легко наблюдать в вкладке Debug
Общая цепь включения/отключения света по датчику освещения будет выглядеть следующим образом
Теперь, чтобы учесть этот эффект в цепи управления по датчику движения, нам достаточно вставить switch блок в цепь пути включения света.
И настроить его так, чтобы он пропускал сообщения от датчика движения только, если наша глобальная переменная flow.Light\_enabled имеет значение Yes – т.е. на улице темно.
Готово! Теперь наш flow выглядит вот так:
### Изменение яркости светильника в зависимости от времени
Осталось совсем немного. Мы хотим изменять интенсивность LED светильника. Т.е. если у нас темно, но время до 9 часов вечера, свет должен включаться на полную мощность. Но после девяти – только на малую мощность, как ночная подсветка.
Для этого создадим блок Inject:
Его можно настроить таким образом, чтобы он выдавал сообщение в определенное время. Настроим его на 21:00 каждого дня.
При этом заметим, что выдавать он будет сообщение со значением 1. Это будет нашей нужной интенсивностью подсветки в ночном режиме. Чтобы использовать это значение в цепи управления светом, используем тот же трюк с глобальными переменными. Создадим блок change:
И настроим его так, чтобы переменной flow.Light\_Brightness присваивалось значение из сообщения.
Чтобы возвращать первоначальную яркость по утрам, создадим второй блок inject, который будет выполняться в 6 часов утра и выдавать значение яркости 100. Подключим его туда же.
Таким образом переменной flow.Light\_brightness будет присваиваться значение 1 каждый вечер в 9 часов, и значение 100 каждое утро в 6 часов. Осталось только применить это в основной цепи. Для этого у нас уже есть блок Light Brightness Adjustment:
Для которого нам только нужно изменить настройку, чтобы он присваивал не константу, а значение переменной flow.Light\_brightness.
Финальный результат
-------------------
Итоговый flow, очищенный от отладочных блоков выглядит опрятно и чисто. При создании мы использовали только стандартные блоки из инсталляции Node-RED. На сайте [flows.nodered.org](http://flows.nodered.org/), однако, существует более 800 дополнительных блоков и библиотек, которые позволяют добавить множество различных вещей.
Для тех, кто заинтересовался повторением данного алгоритма, выкладываю flow, который я использовал для отладки:
А также его json код, который можно легко импортировать в любую версию Node-RED и протестировать.
```
[{"id":"5afd41b4.d61318","type":"switch","z":"2384634b.17767c","name":"Movement detected?","property":"payload","propertyType":"msg","rules":[{"t":"eq","v":"OPEN","vt":"str"}],"checkall":"false","outputs":1,"x":562,"y":285,"wires":[["381b0d6d.a0bd7a"]]},{"id":"35bac8e.57dd5b8","type":"trigger","z":"2384634b.17767c","op1":"5","op2":"0","op1type":"nul","op2type":"val","duration":"8","extend":false,"units":"s","reset":"OPEN","name":"Switch off delay","x":750,"y":373,"wires":[["e995e130.1e2118","af1f191f.498098"]]},{"id":"d85623d1.29b058","type":"change","z":"2384634b.17767c","name":"Light Brightness Adjustment","rules":[{"t":"set","p":"payload","pt":"msg","to":"Light_brightness","tot":"flow"}],"action":"","property":"","from":"","to":"","reg":false,"x":1013.9999389648438,"y":284.63330078125,"wires":[["e995e130.1e2118","af1f191f.498098"]]},{"id":"934ff922.ca34f","type":"inject","z":"2384634b.17767c","name":"","topic":"","payload":"OPEN","payloadType":"str","repeat":"","crontab":"","once":false,"x":258.5,"y":408,"wires":[["5afd41b4.d61318"]]},{"id":"ea0e2e99.52a6f8","type":"inject","z":"2384634b.17767c","name":"","topic":"","payload":"CLOSED","payloadType":"str","repeat":"","crontab":"","once":false,"x":269,"y":459,"wires":[["35bac8e.57dd5b8","5afd41b4.d61318"]]},{"id":"4187db59.93c2dc","type":"mqtt in","z":"2384634b.17767c","name":"Hall Light Sensor","topic":"/myhome/state/Lumin_Hall","qos":"2","broker":"bfc8eee2.a46c9","x":243,"y":146,"wires":[["c94e7c4.849f48"]]},{"id":"c94e7c4.849f48","type":"switch","z":"2384634b.17767c","name":"Light Threshold Selector","property":"payload","propertyType":"msg","rules":[{"t":"lt","v":"10","vt":"num"},{"t":"else"}],"checkall":"false","outputs":2,"x":517.3333129882812,"y":145.7166748046875,"wires":[["48e6a07a.962798"],["ca8b6623.f11c7"]]},{"id":"381b0d6d.a0bd7a","type":"switch","z":"2384634b.17767c","name":"Light Enabled?","property":"Light_enabled","propertyType":"flow","rules":[{"t":"eq","v":"Yes","vt":"str"}],"checkall":"true","outputs":1,"x":775.5,"y":285,"wires":[["d85623d1.29b058"]]},{"id":"48e6a07a.962798","type":"change","z":"2384634b.17767c","name":"Enable Light","rules":[{"t":"set","p":"Light_enabled","pt":"flow","to":"Yes","tot":"str"}],"action":"","property":"","from":"","to":"","reg":false,"x":822,"y":109,"wires":[[]]},{"id":"ca8b6623.f11c7","type":"change","z":"2384634b.17767c","name":"Disable Light","rules":[{"t":"set","p":"Light_enabled","pt":"flow","to":"No","tot":"str"}],"action":"","property":"","from":"","to":"","reg":false,"x":824.6666259765625,"y":177.51666259765625,"wires":[[]]},{"id":"b6ea27c1.c33cd","type":"inject","z":"2384634b.17767c","name":"","topic":"","payload":"Light_enabled","payloadType":"flow","repeat":"1","crontab":"","once":false,"x":330.5,"y":678,"wires":[["db66aec8.b3abc"]]},{"id":"db66aec8.b3abc","type":"debug","z":"2384634b.17767c","name":"Light_enabled","active":false,"console":"false","complete":"payload","x":670.5,"y":679,"wires":[]},{"id":"fa4b50b8.e6e0f","type":"inject","z":"2384634b.17767c","name":"","topic":"","payload":"5","payloadType":"num","repeat":"","crontab":"","once":false,"x":233.5,"y":212,"wires":[["c94e7c4.849f48"]]},{"id":"e7b1a39.f9e596","type":"inject","z":"2384634b.17767c","name":"","topic":"","payload":"100","payloadType":"num","repeat":"","crontab":"","once":false,"x":235,"y":266,"wires":[["c94e7c4.849f48"]]},{"id":"4b2f3c6f.de9aac","type":"mqtt in","z":"2384634b.17767c","name":"Hall Motion Sensor","topic":"/myhome/state/Hall_motion","qos":"2","broker":"87b370d1.dd497","x":247,"y":334,"wires":[["5afd41b4.d61318","35bac8e.57dd5b8"]]},{"id":"e995e130.1e2118","type":"mqtt out","z":"2384634b.17767c","name":"Hall Light Dimmer ","topic":"/myhome/command/Light_Hall/state","qos":"0","retain":"true","broker":"87b370d1.dd497","x":1310,"y":315,"wires":[]},{"id":"781e72a7.3c0abc","type":"inject","z":"2384634b.17767c","name":"Reduce Brightness at 21:00","topic":"Night Brightness","payload":"1","payloadType":"str","repeat":"","crontab":"00 21 * * *","once":false,"x":339,"y":517,"wires":[["adbf1e2e.3f5ae"]]},{"id":"aa444315.a48ad8","type":"inject","z":"2384634b.17767c","name":"Normal Brightness at 6:00","topic":"Night Brightness","payload":"50","payloadType":"num","repeat":"","crontab":"00 6 * * *","once":false,"x":349.6666259765625,"y":604.683349609375,"wires":[["adbf1e2e.3f5ae"]]},{"id":"adbf1e2e.3f5ae","type":"change","z":"2384634b.17767c","name":"Light Brightness Adjustment","rules":[{"t":"set","p":"Light_brightness","pt":"flow","to":"payload","tot":"msg"}],"action":"","property":"","from":"","to":"","reg":false,"x":692,"y":554,"wires":[[]]},{"id":"af1f191f.498098","type":"debug","z":"2384634b.17767c","name":"","active":true,"console":"false","complete":"false","x":1303.5,"y":429,"wires":[]},{"id":"bfc8eee2.a46c9","type":"mqtt-broker","z":"2384634b.17767c","broker":"localhost","port":"1883","clientid":"","usetls":false,"verifyservercert":true,"compatmode":true,"keepalive":"60","cleansession":true,"willTopic":"","willQos":"0","willRetain":null,"willPayload":"","birthTopic":"","birthQos":"0","birthRetain":null,"birthPayload":""},{"id":"87b370d1.dd497","type":"mqtt-broker","z":"2384634b.17767c","broker":"localhost","port":"1883","clientid":"","usetls":false,"verifyservercert":true,"compatmode":true,"keepalive":"60","cleansession":true,"willTopic":"","willQos":"0","willRetain":null,"willPayload":"","birthTopic":"","birthQos":"0","birthRetain":null,"birthPayload":""}]
```
Итоги
=====
В данной статье я попытался продемострировать и рассказать как просто можно реализовать повседневные алгоритмы домашней автоматизации в среде Node-RED. Также я постарался показать основные преимущества данной среды программирования, такие как:
— логичное графическое представление связей и функций
— простоту программирования и легкость отладки пользовательских сценариев
— аппаратную и платформенную независимость полученных алгоритмов – данный сценарий будет одинаково хорошо работать и с OpenHAB, и с ioBroker и с любыми другими платформами умного дома, которые поддерживают протокол MQTT.
— простоту обмена готовыми алгоритмами между пользователями благодаря Copy-Paste JSON кода и наличию онлайн платформы для обмена удачными решениями.
Node-RED может и многое другое – например получать погоду из интернета, рассылать уведомления на твиттер или работать с термостатами Nest. И на основе этого можно создать множество других интересных и полезных алгоритмов автоматизации. Но это темы для следующих статей. | https://habr.com/ru/post/396985/ | null | ru | null |
# В помощь маркетологу: пишем автоматическую выгрузку данных из Adfox с визуализацией
В [прошлой статье](http://habrahabr.ru/post/265383/) был рассмотрен пример настройки автоматической выгрузки данных из Яндекс Метрики. Это облегчает регулярную выгрузку, но способ получается полуавтоматическим: надо запускать скрипт, копировать результаты выгрузки к себе и дальше заниматься их оформлением. Посмотрим как можно сделать процесс полностью автоматическим. Для примера будем использовать выгрузку данных их рекламной системы Adfox.
Adfox имеет много готовых отчетов, однако даже простые усложнения требований к отчетности вызывают проблемы. Есть опция настройки регулярных отчетов, однако в большинстве случаев приходится настраивать комбинации выгрузок самому.
В этой статье показано как сделать скрипт, который выгружает CTR всех баннеров, которые доступны аккаунту (сделать это вручную нереально по времени). А также как отобразить это на графике в виде простой HTML-страницы. Т. е. мы последовательно просмотрим все кампании и флайты, возьмем показы и клики по всем баннерам и нарисуем график CTR. Как и в прошлой статье работать будем на инстансах Amazon Web Services, чтобы было универсально и главное бесплатно. Выгрузка данных на PHP, графики рисуем в Highcharts. В коде реализован самый простой способ выгрузки и обработки данных без каких-либо улучшений. В итоге получим ежедневно обновляемую за вчерашний день страницу вида:
Начинаем с создания аккаунта на AWS (если еще нет). Эта процедура подробно описана в документации: [docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-ug.pdf](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-ug.pdf) (до пункта Getting started). Далее мы пройдем этап, описанный в этой же документации в главе «Tutorial: Installing a LAMP Web Server on Amazon Linux»: установим нужные нам для выгрузки и хранения данных PHP и MySQL (в дальнейшем работать с MySQL лучше, чем с текстовыми файлами). Можно конечно обойтись без этого, используя встроенный Python. Запускаем инстанс Amazon Linux (подробности см. [предыдущую статью](http://habrahabr.ru/post/265383/) где мы выбирали инстанс Ubuntu Server). Здесь нам понадобится именно Linux, а не Ubuntu. Чтобы запустить LAMP web server на Ubuntu смотрите документацию: [help.ubuntu.com/community/ApacheMySQLPHP](https://help.ubuntu.com/community/ApacheMySQLPHP). Итак, выбираем инстанс Amazon Linux, проверяем Security Group и убеждаемся что у нас есть приватный ключ. Через пару минут получаем Public DNS нашего инстанса и подсоединяемся к нему через Putty (для Windows) или Terminal для MAC:
Ставим LAMP web server. Выполняем команду проверки, что имеем последние обновления:
$ sudo yum update -y
Ставим PHP подходящей нам версии:
$ sudo yum install -y httpd24 php56 mysql55-server php56-mysqlnd
Запускаем Apache web server:
$ sudo service httpd start
Хотим, чтобы Apache web server стартовал при каждом запуске системы:
$ sudo chkconfig httpd on
Тестируем, что все прошло успешно: копипастим в браузер Public DNS нашего инстанса и получаем следующую страничку:
Сейчас корневой директорией /var/www/ «владеет» пользователь root. Сделаем туда доступ пользователю ec2-user:
Создаем группу «www»:
$ sudo groupadd www
Добавляем пользователя ec2-user в группу www:
$ sudo usermod -a -G www ec2-user
Чтобы изменения вступили в силу закрываем Putty или Terminal (команда exit) и подсоединяемся к инстансу еще раз. Проверяем, что пользователь ec2-user прописан в группе www:
$ groups
ec2-user wheel www
Меняем владельца папки /var/www:
$ sudo chown -R root:www /var/www
Добавляем возможность пользователю ec2-user и другим пользователям из группы www права на изменение папки /var/www:
$ sudo chmod 2775 /var/www
$ find /var/www -type d -exec sudo chmod 2775 {} +
$ find /var/www -type f -exec sudo chmod 0664 {} +
Тестируем, что теперь мы можем создавать PHP-файлы в директории /var/www. Для этого создаем файл phpinfo.php и записываем в него php phpinfo(); ?:
$ echo "php phpinfo(); ?" > /var/www/html/phpinfo.php
Снова в адресной строке браузера копипастим Public DNS нашего инстанса и добавляем "/phpinfo.php". Мы должны получить следующую страницу с конфигурацией PHP:
В целях безопасности удаляем созданный нами файл phpinfo.php:
$ rm /var/www/html/phpinfo.php
Отлично, мы готовы к выгрузке данных из Adfox!
**Выгружаем статистику Adfox**
Документацию к API Adfox можно найти на странице [help.adfox.ru](http://help.adfox.ru/) (ссылка на скачивание в самом низу страницы). В целом документация составлена не очень наглядно, поэтому в общем случае можно использовать следующее правило: если вам нужно получить ссылку для отчета в API, то копируете ссылку из браузера и подставляете в нее логин и пароль + '&isXML=1' для получения данных в формате XML. Если нужны функции поиска или настроек кампаний, то придется смотреть в документации API.
В общем случае запросы к API Adfox сопровождаются логином (как вы заходите в систему) и хэшом SHA-256 от вашего пароля. Сгенерировать хэш к паролю можно на любом сайте по поисковому запросу «sha-256 online». Например, тут: [www.xorbin.com/tools/sha256-hash-calculator](http://www.xorbin.com/tools/sha256-hash-calculator)
Если ваш пароль «12345», то для обращений к API в качестве пароля надо использовать значение «5994471abb01112afcc18159f6cc74b4f511b99806da59b3caf5a9c173cacfc5»:
Наш алгоритм будет состоять из двух шагов:
**Шаг 1**. Получаем список всех доступных нам кампаний.
Возьмем список доступных кампаний. Если кампаний много, то можно ограничиться теми, что были заведены, например, с 1 августа:
[login.adfox.ru/API.php?object=account&action=list&actionObject=superCampaign&dateAddedFrom=2015-08-01&loginAccount=логин&loginPassword=пароль-sha-256&isXML=1](https://login.adfox.ru/API.php?object=account&action=list&actionObject=superCampaign&dateAddedFrom=2015-08-01&loginAccount=логин&loginPassword=пароль-sha-256&isXML=1)
В браузере получим следующий XML-файл:
**Шаг 2**. Для каждой кампании имеем ее название (тэг ) и ID (). Теперь для каждого ID получаем отчет по баннерам (например, для кампании с ID=55555):
[login.adfox.ru/commonReportsOutputForm.php?period=&startDate=начальная-дата&endDate=конечная-дата&criteria=superCampaignBanner&isNewSearch=on&objectName=superCampaign&objectID=55555&ignoreStartDate=off&loginAccount=логин&loginPassword=пароль-sha-256&isXML=1](https://login.adfox.ru/commonReportsOutputForm.php?period=&startDate=начальная-дата&endDate=конечная-дата&criteria=superCampaignBanner&isNewSearch=on&objectName=superCampaign&objectID=55555&ignoreStartDate=off&loginAccount=логин&loginPassword=пароль-sha-256&isXML=1)
Сделаем скрипт, который будет ежедневно делать эту процедуру и записывать данные в файл. Проще всего будет зайти в папку /var/www/html, создать там папку adfox и создать в ней файл daily.php со следующим кодом:
**Код выгрузки данных Adfox**
```
php
// Задаем диапазон дат, за которые выгружаем данные: startDate и endDate
// Формат дат для запросов к Adfox дд.мм.гг
date_default_timezone_set("Europe/Moscow");
//$startDate = '04.09.15';
//$endDate = '04.09.15';
// Для ежедневных выгрузок указываем в качестве даты выгрузки вчерашний день
$startDate = date('d.m.y', strtotime('-1 day'));
$endDate = $startDate;
// Функция getCampaigns показывает доступные данному логину кампании
// Возвращается массив $campIDs с ID и названием кампаний
// В теле запроса в переменной dateAddedFrom можно указать дату создания кампании, чтобы не выгружать все подряд
function getCampaigns() {
$ch = curl_init();
$options = array(
CURLOPT_URL = 'https://login.adfox.ru/API.php?object=account&action=list&actionObject=superCampaign&dateAddedFrom=2015-08-01&loginAccount=логин&loginPassword=пароль-sha-256&isXML=1',
CURLOPT_HEADER => "Content-Type:application/xml",
CURLOPT_HTTPAUTH => CURLAUTH_BASIC,
CURLOPT_SSL_VERIFYPEER => FALSE,
CURLOPT_RETURNTRANSFER => TRUE
);
curl_setopt_array($ch, $options);
$data = curl_exec($ch);
curl_close($ch);
// Можно записать ответ Adfox в файл, чтобы убедиться в его верности
// file_put_contents('request.txt', $data, FILE_APPEND);
// Преобразуем ответ Adfox из XML в массив vals
$parser=xml_parser_create('UTF-8');
xml_parse_into_struct($parser, $data, $vals, $index);
$campIDs = array();
$j = 0;
// Проходим массив vals, выбирая из всех параметров ID и название кампаний и записывая их в массив campIDs
for ($i = 0; $i < count($vals); ++$i) {
if ($vals[$i]["tag"]=="ID") {
$ID = $vals[$i]["value"];
}
if ($vals[$i]["tag"]=="NAME") {
$name = $vals[$i]["value"];
$campIDs[$j]['id'] = $ID;
$campIDs[$j]['name'] = $name;
$j += 1;
}
}
return $campIDs;
}
// Функция getBanners для заданной кампании по ее ID запрашивает отчет по баннерам
// Отчет записывается в массив campReport в виде ID кампании + название флайта - название баннера - показы - клики
function getBanners($id, $startDate, $endDate) {
$ch = curl_init();
$options = array(
CURLOPT_URL => 'https://login.adfox.ru/commonReportsOutputForm.php?period=&startDate='.$startDate.'&endDate='.$endDate.'&criteria=superCampaignBanner&isNewSearch=on&objectName=superCampaign&objectID='.$id.'&ignoreStartDate=off&loginAccount=логин&loginPassword=пароль-sha-256&isXML=1',
CURLOPT_HEADER => "Content-Type:application/xml",
CURLOPT_HTTPAUTH => CURLAUTH_BASIC,
CURLOPT_SSL_VERIFYPEER => FALSE,
CURLOPT_RETURNTRANSFER => TRUE
);
curl_setopt_array($ch, $options);
$data = curl_exec($ch);
curl_close($ch);
//Можно записать ответ Adfox в файл, чтобы убедиться в его верности
//file_put_contents('request.txt', $data, FILE_APPEND);
$parser=xml_parser_create('UTF-8');
xml_parse_into_struct($parser, $data, $vals, $index);
$campReport = array();
$j = 0;
for ($i = 0; $i < count($vals); ++$i) {
if ($vals[$i]["tag"]=="CRITERIA") {
$bannername = $vals[$i]["value"];
}
if ($vals[$i]["tag"]=="FLIGHTNAME") {
$flightname = $vals[$i]["value"];
}
if ($vals[$i]["tag"]=="IMPRESSIONS") {
$impressions = $vals[$i]["value"];
}
if ($vals[$i]["tag"]=="CLICKS") {
$clicks = $vals[$i]["value"];
$campReport[$j]['campaign'] = $id;
$campReport[$j]['flightname'] = $flightname;
$campReport[$j]['bannername'] = $bannername;
$campReport[$j]['impressions'] = $impressions;
$campReport[$j]['clicks'] = $clicks;
$j += 1;
}
}
return $campReport;
}
// Получаем список доступных кампаний
$campIDs = getCampaigns();
// Для каждой кампании запрашиваем отчет по баннерам
for ($i = 0; $i < count($campIDs); ++$i) {
$campReport = getBanners($campIDs[$i]['id'], $startDate, $endDate);
// Для каждого баннера записываем в файл data.txt результат запроса с показами и кликами
// Полный путь файла data.txt нужно указывать для корректной работы автоматической выгрузки Cron
for ($j = 0; $j < count($campReport); ++$j) {
file_put_contents('/var/www/html/adfox/data.txt', $startDate."\t".$campReport[$j]['campaign']."\t".$campReport[$j]['flightname']."\t".$campReport[$j]['bannername']."\t".$campReport[$j]['impressions']."\t".$campReport[$j]['clicks']."\n", FILE_APPEND);
// Пишем в консоли строчку о создании записи (опционально)
echo 'Record created - '.$startDate.' - '.$campReport[$j]['bannername']."\n";
}
}
```
Прогоняем код за несколько дней (например, за 1-4 сентября), подставляя в startDate и endDate даты от 01.09.15 до 04.09.15. В результате в файле data.txt должна накопиться статистика по каждому баннеру за каждый день с 1 по 4 сентября.
Осталось отобразить наши данные на графике и поставить скрипт на автоматическое обновление. Для отрисовки графиков используем [www.highcharts.com/demo/line-basic](http://www.highcharts.com/demo/line-basic). Можно скачать библиотеку на инстанс или обращаться к библиотекам на сайте Highcharts. В примере используется второй вариант. Код всех примеров можно посмотреть на [www.highcharts.com/demo/line-basic](http://www.highcharts.com/demo/line-basic), кликнув под графиком кнопку «EDIT IN JSFIDDLE».
Для корректной работы библиотеки нам понадобится [jQuery](https://jquery.com/). Скачиваем его [с сайта](http://jquery.com/download/) или в сразу в консоли в папку /var/www/html/adfox:
$ wget [code.jquery.com/jquery-1.11.3.js](http://code.jquery.com/jquery-1.11.3.js)
Добавляем код графика в файл report.html:
**Код HTML-страницы с визуализацией**
```
// массив списка баннеров, которые были выгружены в файл data.txt
var banners = [];
// массивы дат, показов и кликов, которые загрузим из файла data.txt
// значения CTR (отношение кликов к показам) рассчитаем
var dates1 = [];
var shows1 = [];
var clicks1 = [];
var ctr1 = [];
var dates2 = [];
var shows2 = [];
var clicks2 = [];
var ctr2 = [];
var dates3 = [];
var shows3 = [];
var clicks3 = [];
var ctr3 = [];
// читаем файл data.txt построчно
$.get("data.txt", function(data){
var lines = data.split("\n");
for (var i = 0, len = lines.length; i < len; i++) {
// проверяем в консоли, что файл прочитан корректно
//console.log(lines[i]);
// разделяем каждую строчку файла на массив из 6 элементов, соответствующих столбцам в data.txt
elements = lines[i].split("\t");
// название баннера это третий по счету столбец, соответственно берет третий элемент массива elements
// (на всякий случай - нумерация элементов массива начинается с 0, а не с 1)
banners.push(elements[2]);
}
// проверяем, что названия баннеров считались корректно
//console.log(banners);
// возьмем уникальные названия баннеров и запишем в массив bannerNames первые 3 названия
Array.prototype.unique = function()
{
var tmp = {}, out = [];
for(var i = 0, n = this.length; i < n; ++i)
{
if(!tmp[this[i]]) { tmp[this[i]] = true; out.push(this[i]); }
}
return out;
}
bannersNames = banners.unique().slice(0, 3);
// проверяем, что получили 3 корректных названия баннеров
//console.log(bannersNames);
// проходим еще раз по файлу data.txt и выбираем даты, показы и клики для баннеров из массива bannerNames
for (var i = 0, len = lines.length; i < len; i++) {
elements = lines[i].split("\t");
// если строчка в файле data.txt относится к первому баннеру, то добавляем в массив дат, показов и кликов значения этой строчки
if (elements[2] == bannersNames[0]) {
dates1.push(elements[0]);
shows1.push(parseInt(elements[4]));
clicks1.push(parseInt(elements[5]));
// toFixed(3) - округляем значения CTR до третьего знака после запятой
if (parseInt(elements[4]) > 0) {
ctr1.push(Number(parseFloat(elements[5] / elements[4] \* 100).toFixed(3)));
} else {
ctr1.push(0);
}
}
// то же самое для второго баннера
if (elements[2] == bannersNames[1]) {
dates2.push(elements[0]);
shows2.push(parseInt(elements[4]));
clicks2.push(parseInt(elements[5]));
if (parseInt(elements[4]) > 0) {
ctr2.push(Number(parseFloat(elements[5] / elements[4] \* 100).toFixed(3)));
} else {
ctr2.push(0);
}
}
// то же самое для третьего баннера
if (elements[2] == bannersNames[2]) {
dates3.push(elements[0]);
shows3.push(parseInt(elements[4]));
clicks3.push(parseInt(elements[5]));
if (parseInt(elements[4]) > 0) {
ctr3.push(Number(parseFloat(elements[5] / elements[4] \* 100).toFixed(3)));
} else {
ctr3.push(0);
}
}
}
// проверяем, что все массивы CTR (которые будут на графике) имеют числовой формат
// например: [0.22, 0.25, 0.30, 0.24]
//console.log(ctr1);
//console.log(ctr2);
//console.log(ctr3);
// отображаем значения CTR на графике
$(function () {
// название блока container должно совпадать с вызываемым в <div id="container"... внизу страницы
$('#container').highcharts({
// заголовок графика
title: {
text: 'Campaign banners CTR',
x: -20 //center
},
// подпись под заголовком
subtitle: {
text: 'Source: ADFOX',
x: -20
},
// в качестве оси абсции берем значения массива дат dates1
xAxis: {
categories: dates1
},
// параметры оси ординат
yAxis: {
title: {
text: 'CTR %'
},
plotLines: [{
value: 0,
width: 1,
color: '#808080'
}]
},
// параметры подсказки при наведении на график
tooltip: {
valueSuffix: '%'
},
// параметры легенды
legend: {
layout: 'vertical',
align: 'right',
verticalAlign: 'middle',
borderWidth: 0
},
// задаем значения, которые хотим отобразить на графике: название баннера и значения CTR из соответствующего массива
series: [{
name: bannersNames[0],
data: ctr1
}, {
name: bannersNames[1],
data: ctr2
}, {
name: bannersNames[2],
data: ctr3
}],
credits: {
enabled: false
}
});
});
});
```
Открываем страницу report.html в браузере, не забывая, что файл лежит в папке adfox:
Осталось поставить наш скрипт на ежедневное обновление (например, в 8:00 по системному времени инстанса, которое можно проверить командой date в консоли). Для этого в консоли выполняем:
$ crontab -e
По умолчанию откроется редактор vim. Для редактирования файла нажмите 'i' (режим редактирования) и добавьте следующую строчку (вставьте в редактор с помощью Shift+Ins):
00 08 \* \* \* /usr/bin/php /var/www/html/adfox/daily.php > /var/www/html/adfox/out
Затем жмем esc (выход из режима редактирования) и набираем ':wq' — сохранить и выйти. В консоли должна отобразиться строчка:
crontab: installing new crontab
Для проверки установки расписания:
$ crontab -l
00 08 \* \* \* /usr/bin/php /var/www/html/adfox/daily.php > /var/www/html/adfox/out
В файле out можно отслеживать результаты работы Cron задач. Например, если возникнут ошибки в ходе выполнения скрипта.
Подробнее про Cron на AWS: [docs.aws.amazon.com/opsworks/latest/userguide/workingcookbook-extend-cron.html](http://docs.aws.amazon.com/opsworks/latest/userguide/workingcookbook-extend-cron.html)
Все готово. Итого у нас есть скрипт, который ежедневно утром обновляет данные по показам и кликам всех доступных нам баннеров за вчерашний день. А также HTML-страница, на которой в любое время можно посмотреть динамику CTR баннеров за последние несколько дней. На AWS есть много возможностей по настройке безопасного доступа к данным. Также при совершенствовании этого подхода можно записывать данные в базу MySQL, с которой гораздо проще работать, чем с текстовыми файлами. Надеюсь этот подход поможет вам сэкономить время при регулярной работе с Adfox. | https://habr.com/ru/post/266307/ | null | ru | null |
# Объединяем Code Coverage от PHPUnit и phpspec
Сегодня та или иная библиотека на Github, у которой нет тестов, уже не воспринимается серьезно. Тесты помогают нам смело делать рефакторинг и быть уверенными, что модуль, класс или функция работают так, как это задумывалось. Они позволяют нам тестировать наш код на разных версиях PHP и выявлять ошибки заранее. Это гарант качества и стабильности вашего кода.
Стремиться к стопроцентному покрытию кода нет никакого смысла, однако понимать в среднем какой процент кода покрыт вашими тестами — хорошая метрика при непрерывном интегрировании.
Мы можем настроить оповещения при падении процента покрытия, например, ниже 50, можем добавлять автоматические комментарии от ботов в пул реквестах, показывать тенденцию изменения Code Coverage на графиках с течением времени и т.д.
Но что делать, если вы используете несколько библиотек для тестирования? Как получить общее покрытие кода?
Тут на помощь приходит библиотека [phpcov](https://github.com/sebastianbergmann/phpcov)
Итак, что мы будем делать при каждом билде (на примере Travis-CI):
* Запускаем тесты PHPUnit, генерируем Code Coverage
* Запускаем тесты phpspec, генерируем Code Coverage
* Объединяем (merge) полученные результаты в единое покрытие
* Сохраняем результаты для последующего анализа и отображения
Для примера, возьмем проект на Symfony3, где используются PHPUnit совместно с phpspec.
Конфигурация тестов PHPUnit может выглядеть следующим образом:
**phpunit.xml**
```
xml version="1.0" encoding="UTF-8"?
tests
src
src/\*Bundle/Resources
src/\*/\*Bundle/Resources
src/\*/Bundle/\*Bundle/Resources
```
Это стандартный конфиг, за исключением нескольких строк:
```
```
Здесь мы говорим, что будет использован PHP формат отчета о покрытии и кладем файл в нужную папку.
Далее похожие действия делаем с phpspec:
```
# phpspec.yml
...
extensions:
PhpSpecCodeCoverage\CodeCoverageExtension:
format:
- php
output:
php: /tmp/coverage_phpspec.cov
```
Осталось запустить это всё дело при каждом билде и смержить результаты:
```
# .travis.yml
...
script:
- bin/phpspec run --format=pretty
- bin/phpunit
- wget https://phar.phpunit.de/phpcov.phar && php phpcov.phar merge /tmp --clover coverage.xml
```
phpcov собирает все данные из вашей папки, объединяет их и сохраняет результат в формате Clover, который можно использовать для отображения покрытия кода, в том числе, и такого бейджа 
Вот и всё. Пишите тесты, рефакторите с удовольствием.
**UPD:** бейджи, комментарии в пул реквестах и многое другое делается с помощью сервиса [codecov.io](https://codecov.io/) (или как альтернатива — [coveralls.io](http://coveralls.io/))
После настройки репозитория, интеграция с Travis-CI делается в одну строку:
```
# .travis.yml
...
after_success:
- bash <(curl -s https://codecov.io/bash)
```
Codecov автоматически возьмет сгенерированный отчет в формате Clover и проанализирует его.
Также, при установке дополнения в браузер, можно прямо на Github видеть, какие строки покрыты тестами, а какие нет:
 | https://habr.com/ru/post/316210/ | null | ru | null |
# Типичное использование Observable объектов в Angular 4
Представляю вашему вниманию типичные варианты использования Observable объектов в компонентах и сервисах Angular 4.
Подписка на параметр роутера и мапинг на другой Observable
----------------------------------------------------------
*Задача:* При открытии страницы `example.com/#/users/42`, по `userId` получить данные пользователя.
*Решение:* При инициализации компоненты `UserDetailsComponent` мы подписываемся на параметры роутера. То есть если `userId` будет меняться — будер срабатывать наша подписка. Используя полученный `userId`, мы из сервиса `userService` получаем `Observable` с данными пользователя.
```
// UserDetailsComponent
ngOnInit() {
this.route.params
.pluck('userId') // получаем userId из параметров
.switchMap(userId => this.userService.getData(userId))
.subscribe(user => this.user = user);
}
```
Подписка на параметр роутера и строку запроса
---------------------------------------------
*Задача:* При открытии страницы `example.com/#/users/42?regionId=13` нужно выполнить функцию `load(userId, regionId)`. Где `userId` мы получаем из роутера, а `regionId` — из параметров запроса.
*Решение:* У нас два источника событий, поэтому воспользуемся функцией [Observable.combineLatest](http://rxmarbles.com/#combineLatest), которая будет срабатывать, когда каждый из источников генерирует событие.
```
ngOnInit() {
Observable.combineLatest(this.route.params, this.route.queryParams)
.subscribe(([params, queryParams]) => { // полученный массив деструктурируем
const userId = params['userId'];
const regionId = queryParams['regionId'];
this.load(userId, regionId);
});
}
```
Обратите внимание, что созданные подписки на роутер, при разрушении объекта удалятся, за этим следит ангуляр, поэтому отписываться от параметров роутера не нужно:
> The Router manages the observables it provides and localizes the subscriptions. The subscriptions are cleaned up when the component is destroyed, protecting against memory leaks, so we don't need to unsubscribe from the route params Observable. [Mark Rajcok](https://stackoverflow.com/questions/38008334/angular2-rxjs-when-should-i-unsubscribe-from-subscription/41177163?noredirect=1#comment69909721_41177163)
Остановка анимации загрузки после окончания выполнения подписки
---------------------------------------------------------------
*Задача:* Показать значок загрузки после начала сохранения данных и скрыть его, когда данные сохранятся или произойдет ошибка.
*Решение:* За отображение загрузчика у нас отвечает переменная `loading`, после нажатия на кнопку, установим ее в `true`. А для установки ее в `false` воспользуемся `Observable.finally` функций, которая выполняется после завершения подписки или если произошла ошибка.
```
save() {
this.loading = true;
this.userService.save(params)
.finally(() => this.loading = false)
.subscribe(user => {
// Успешно сохранили
}, error => {
// Ошибка сохранения
});
}
```
Создание собственного источника событий
---------------------------------------
*Задача:* Создать переменную `lang$` в `configService`, на которую другие компоненты будут подписываться и реагировать, когда язык будет меняться.
*Решение:* Воспользуемся классом `BehaviorSubject` для создания переменной `lang$`;
[Отличия](https://stackoverflow.com/questions/39494058/behaviorsubject-vs-observable) `BehaviorSubject` от `Subject`:
1. `BehaviorSubject` должен инициализироваться с начальным значением;
2. Подписка возвращает последнее значение `Subject`а;
3. Можно получить последнее значение напрямую через функцию `getValue()`.
Создаём переменную `lang$` и сразу инициализируем. Так же добавляем функцию `setLang` для установки языка.
```
// configService
lang$: BehaviorSubject = new BehaviorSubject(DEFAULT\_LANG);
setLang(lang: Language) {
this.lang$.next(this.currentLang); // тут мы поставим
}
```
Подписываеся на изменение языка в компоненте. Переменная `lang$` является "горячим" Observable объектом, то есть подписка требует отписки при разрушении объекта.
```
private subscriptions: Subscription[] = [];
ngOnInit() {
const langSub = this.configService.lang$
.subscribe(() => {
// ...
});
this.subscriptions.push(langSub);
}
ngOnDestroy() {
this.subscriptions
.forEach(s => s.unsubscribe());
}
```
### Использование takeUntil для отписки
Отписываться можно и [более изящным вариантом](https://stackoverflow.com/questions/38008334/angular-rxjs-when-should-i-unsubscribe-from-subscription/41177163#41177163), особенно если в компоненте присутствует больше двух подписок:
```
private ngUnsubscribe: Subject = new Subject();
ngOnInit() {
this.configService.lang$
.takeUntil(this.ngUnsubscribe) // отписка по условию
.subscribe(() => {
// ...
});
}
ngOnDestroy() {
this.ngUnsubscribe.next();
this.ngUnsubscribe.complete();
}
```
То есть, чтобы не терять память на горячих подписках, компонента будет работать до тех пор, пока значение `ngUnsubscribe` не изменится. А изменится оно, когда вызовется `ngOnDestroy`. Плюсы этого варианта в том, что в каждую из подписок достаточно добавить всего одну строчку, чтобы отписка сработала вовремя.
Использование Observable для автокомплита или поиска
----------------------------------------------------
*Задача:* Показывать предложения страниц при вводе данных на форме
*Решение:* Подпишемся на изменение данных формы, возьмём только меняющиеся данные инпута, поставим небольшую задержку, чтобы событий не было слишком много и отправим запрос в википедию. Результат выведем в консоль. Интересный момент в том, что `switchMap` отменит предыдущий запрос, если пришли новые данные. Это очень полезно, для избегания нежалательных эффектов от медленных запросов, если, к например, предпоследний запрос выполнялся 2 секунды, а последий 0.2 секунды, то в консоль выведется результат именно последнего запроса.
```
ngOnInit() {
this.form.valueChanges
.takeUntil(this.ngUnsubscribe) // отписаться после разрушения
.map(form => form['search-input']) // данные инпута
.distinctUntilChanged() // брать измененные данные
.debounceTime(300) // реагировать не сразу
.switchMap(this.wikipediaSearch) // переключить Observable на запрос в Вики
.subscribe(data => console.log(data));
}
wikipediaSearch = (text: string) => {
return Observable
.ajax('https://api.github.com/search/repositories?q=' + text)
.map(e => e.response);
}
```
Кеширование запроса
-------------------
*Задача:* Необходимо закешировать Observable запрос
*Решение:* Воспользуемся связкой `publishReplay` и `refCount`. Первая функция закеширует одно значение функции на 2 секунды, а вторая будет считать созданные подписки. То есть, Observable завершится, когда все подписки будут выполнены. [Тут](https://stackoverflow.com/documentation/rxjs/8247/common-recipes/26490/caching-http-responses#t=201612161544428695958) можно прочитать подробнее.
```
// tagService
private tagsCache$ = this.getTags()
.publishReplay(1, 2000) // кешируем одно значение на 2 секунды
.refCount() // считаем ссылки
.take(1); // берем 1 значение
getCachedTags() {
return tagsCache$;
}
```
Последовательный combineLatest
------------------------------
*Задача:* Критическая ситуация на сервере! Backend команда сообщила, что для корректного обновления продукта нужно выполнять строго последовательно:
1. Обновление данных продукта (заголовок и описание);
2. Обновление списка тегов продукта;
3. Обновление списка категорий продукта;
*Решение:* У нас есть 3 Observable, полученных из `productService`. Воспользуемся `concatMap`:
```
const updateProduct$ = this.productService.update(product);
const updateTags$ = this.productService.updateTags(productId, tagList);
const updateCategories$ = this.productService.updateCategories(productId, categoryList);
Observable
.from([updateProduct$, updateTags$, updateCategories$])
.concatMap(a => a) // выполняем обновление последовательно
.toArray() // Возвращает массив из последовательности
.subscribe(res => console.log(res)); // res содержит массив результатов запросов
```
Загадка на посошок
------------------
Если у вас есть желание немного поупражняться, решите предыдущую задачу, но для создания продукта. То есть сначала создаём продукт, потом обновляем теги, а только потом — категории.
Полезные ссылки
---------------
* Заворожённо посмотреть на шарики: [rxviz.com](https://rxviz.com/examples/basic-interval)
* Потаскать шарики мышкой: [rxmarbles.com](http://rxmarbles.com/) | https://habr.com/ru/post/337512/ | null | ru | null |
# Node.js на службе разработчика электроники: создаём библиотеки микросхем
Всем привет! Сегодня мы поговорим о схемотехнике. А чтобы было интереснее, приплетем сюда Node.js. Внимательный читатель тут же спросит, какая же между ними связь? А такая, что мы попытаемся, используя современные технологии, немного облегчить жизнь тем, кто дружит с паяльником, любит программировать всякие там Arduino/BeagleBoard ну и вообще увлекается электроникой чуть больше, чем на потребительском уровне. Если кратко, то мы попытаемся немного автоматизировать процесс создания библиотеки электронных элементов.
Если стало интересно, то добро пожаловать под кат.
#### Предисловие
У многих из нас иногда возникает непреодолимое желание разработать какое-нибудь электронное устройство. Будь то робот, гаджет или хотя бы шилд для Arduino, который выполняет специфичные, близкие нашему сердцу функции. И приходит время разрабатывать печатную плату. Как обычно происходит этот процесс? Мы продумываем необходимый функционал, подбираем элементную базу, примерно прикидываем структурную и функциональную схему. Затем скачиваем и устанавливаем какую-нибудь EDA-программу (EDA — Electronic Design Automation). Ваяем принципиальную схему, потом разводим печатную плату (некоторые предпочитают автотрассировщики, но настоящие хардкорщики признают только handmade). Заказываем изготовление платы (ну или утюжим сами), покупаем элементы, паяем, запускаем и наслаждаемся нашим новым творением. Ну или мучаемся с ним, тут уж как получится.
Те, для кого этот процесс знаком, думаю, согласятся, что одна из муторных, рутинных и затратных по времени операций, это создание библиотеки необходимых элементов в формате той EDA, в которой вы обычно работаете. Собственно об автоматизации этого процесса далее и пойдет речь.
#### И в чем же соль?
Тот же внимательный читатель снова спросит, но ведь во всех современных EDA уже есть встроенные библиотеки элементов, ну а на случай, если нужного элемента не нашлось, есть соответствующий редактор в составе того же пакета программ. Трудно спорить, но все-таки встроенные библиотеки не охватывают всего многообразия этого мира, а удобство редакторов зачастую оставляет желать лучшего. А если вам нужно оформлять схемы по ГОСТ, то тут библиотеки вам редко помогут (почему-то большинство западных производителей софта нагло игнорируют наши стандарты или банально не знают о них). Зачастую сформированная с любовью за долгие годы библиотека мешает перейти вам на более современный пакет EDA только из-за того, что вам придется проходить весь этот тернистый путь заново.
#### Больше конкретики, Карл
И тогда у меня возникла мысль. Почему бы нам каким-то простым образом не описать электронные компоненты, а генерацию библиотеки доверить машине? Притом предусмотреть какие-нибудь простые, но гибкие средства настройки этого процесса, чтобы конечная библиотека выглядела именно так, как мы этого хотим. В идеале, чтобы мы могли контролировать каждый шаг процесса генерации с возможностью подкручивания того или иного параметра. Проделав настройку один раз, получить результат на всю жизнь. Генерировать библиотеку в формате именно той программы EDA, в которой нам захотелось поработать сегодня.
Так и родился проект под названием QEDA.js. Но перед тем, как начать подробное повествование о нем, пробежимся по терминологии.
С точки зрения разработчика электронный радио элемент (ЭРЭ) в общем случае состоит из условного графического обозначения (УГО) и посадочного места на плате.
*УГО* (иностранцы называют его *schematic symbol*) это изображение элемента, которое используется на принципиальной схеме, и которое позволяет нам отличать резистор от конденсатора, микросхему от разъема ну и так далее.
*Посадочное место* (*land pattern*, *footprint*, иногда *pad layout* в англоязычной терминологии) — это изображение того места на плате, куда элемент будет установлен физически. Есть замечательный стандарт IPC-7351, который регламентирует расчет посадочного места в зависимости от корпуса микросхемы. Собственно он и используется в QEDA.js.
*Позиционное обозначение* (*reference designator*) — идентификатор каждого элемента на схеме/плате, состоящий как правило из букв (характеризуют класс элементов) и цифр (порядковый номер элемента на конкретной схеме). Например C4 это 4-й по счету конденсатор, а VT21 — 21й транзистор.
*Цоколёвка*, или жаргонное *распиновка* (*pinout*) — описание расположения и назначения выводов элемента.
#### Встречайте: QEDA.js
Итак, хватит воды, переходим к сути. Перед тем, как заглянуть под капот, проделаем ряд нехитрых операций.
1. Установим Node.js (если он у вас еще не установлен). Подробности на сайте производителя: [nodejs.org](https://nodejs.org)
2. Установим CoffeeScript (конечно же можно пропустить этот шаг и использовать ванильный JavaScript, но приведенные далее примеры будут написаны именно на CoffeeScript):
```
npm install -g coffee-script
```
3. Установим QEDA.js:
```
npm install -g qeda
```
4. Создадим файл `script.coffee` и наполним его следующими строками:
```
Qeda = require 'qeda'
lib = new Qeda.Library
lib.add 'Altera/5M1270ZT144' # Add Altera MAX V CPLD
lib.add 'Analog/AD9393' # Add Analog Devices HDMI interface
lib.add 'ST/L3GD20H' # Add STMicroelectronics gyroscope
lib.add 'TI/ISO721' # Add Texas Instruments digital isolator
lib.add 'TI/ISO722' # Add Texas Instruments digital isolator
lib.generate 'mylib'
```
5. Выполним скрипт:
```
coffee script.coffee
```
В директории, где был размещен скрипт, появится субдиректория `kicad`, которая собственно и содержит свежеиспечённую библиотеку в формате бесплатной, свободной и открытой EDA-программы под названием KiCad. Вы можете скачать дистрибутив этой программы с официального сайта: [kicad-pcb.org](http://kicad-pcb.org)
Теперь немного вернемся и попытаемся разобраться, что же происходит при выполнении этого скрипта? После подключения модуля QEDA.js и создания объекта — контейнера для наших ЭРЭ, мы добавляем в этот контейнер пару элементов из списка готовых (откроем завесу тайны, фактически это просто YAML-файлы, которые хранятся в [специальном репозитории](https://github.com/qeda/library)). При первом запуске скрипт подкачивает описания этих элементов в поддиректорию `library`. Последняя строка отвечает за генерирование библиотечных файлов в формате KiCad. Это и суть наши целевые файлы, ради которых все затевалось.
Однако с вероятностью 99,(9)% вы не найдёте нужный вам компонент в репозитории готовых элементов (дело в том, что в настоящее время он находится в стадии заполнения). Значит нам нужно научиться добавлять свои элементы.
Что ж, сделаем это! Создадим поддиректорию `library`, если её ещё нет, а в ней создадим файл `dummy.yaml` со следующим содержимым:
```
name: Dummy
pinout:
DIN: 1
~DOUT: 2
Vcc: 3
GND: 4, 5
NC: 6-8
properties:
power: Vcc
ground: GND
in: DIN
out: ~DOUT
nc: NC
inverted: ~DOUT
schematic:
symbol: IC
left: DIN, NC
right: ~DOUT, NC
top: Vcc
bottom: GND
housing:
pattern: SOIC
outline: JEDEC MS-012 AA
```
Создадим файл `custom.coffee` (он должен находиться на одном уровне с директорией `library`) и напишем в нем:
```
Qeda = require 'qeda'
lib = new Qeda.Library
lib.add 'Dummy' # Adding custom element
lib.generate 'dummy'
```
Запускаем:
```
coffee custom.coffee
```
Получаем:
Ну что ж, надеюсь, мне удалось вас немного заинтересовать. Теперь погрузимся немного глубже в происходящие процессы.
Как я уже упоминал выше, вся необходимая и достаточная информация об ЭРЭ содержится в его YAML-описании. В нем отражаются такие параметры, как:
* **Распиновка** (**pinout**) — названия выводов и соответствующие им номера. Номера могут быть перечислены через запятую или заданы диапазоном, причем эти два варианта можно комбинировать. Пример:
```
pinout:
DATA: 1, 3-6, 10
```
Номера могут содержать и буквы (например, для BGA):
```
pinout:
GND: B1, C10-C13, AA1-AC3
```
Так же можно объединять несколько выводов в группу:
```
pinout:
SPI:
CS: 1
CLK: 2
MOSI: 3
MISO: 4
```
Группировать можно и названия выводов, они автоматически преобразуются в список (при этом их количество должно совпадать с количеством номеров справа):
```
pinout:
D16-0, CLK: 1-18
```
* **Свойства выводов** (**properties**) — строго говоря, это тоже часть распиновки, но только не обязательная. Позволяет пролить немного света на тип выводов. Эта информация используется многими EDA-программами как для отображения символа, так и для проведения некоторых проверок (например, чтобы вы не пустили питание на ножку земли).
```
properties:
power: Vcc # Питание
ground: GND # Земля
in: DIN # Вход
out: ~DOUT # Выход
nc: NC # Не подсоединенный вывод
inverted: ~DOUT # Инвертированный сигнал
```
* **Описание УГО** (**schematic**) — указываем скрипт, ответственный за отрисовку элемента плюс некоторые настройки того, как символ должен выглядеть.
```
schematic:
symbol: IC # Отрисовывать будет скрипт 'ic.coffee'
left: DIN, NC # Выводы с левой стороны
right: ~DOUT, NC # Выводы с правой стороны ('NC' будут сбалансированно распределены на обе стороны)
top: Vcc # Выводы сверху
bottom: GND # Выводы снизу
```
* **Описание корпуса** (**housing**) — приводим размеры корпуса или ссылку на файл со стандартными размерами, а также указываем скрипт, который будет отрисовывать посадочное место.
```
housing:
pattern: SOIC # Отрисовывать будет 'soic.coffee'
outline: JEDEC MS-012 AA # Размеры брать из файла 'jedec/ms-012.yaml', группа 'AA'
```
Но можно задать размеры прямо из datasheet:
```
housing:
pattern: SOIC # Отрисовывать будет 'soic.coffee'
pitch: 1.27 # Шаг вывода
bodyWidth: 3.80-4.00 # Ширина корпуса
bodyLength: 4.80-5.00 # Длина корпуса
height: 1.75 # Габаритная высота
leadSpan: 5.80-6.20 # Габаритная ширина (от края до края вывода)
leadLength: 0.40-1.27 # Длина вывода
leadWidth: 0.31-0.51 # Ширина вывода
leadCount: 8 # Количество выводов
```
Ну а что же с ГОСТ? Все просто, немного дополняем код script.coffee:
```
Qeda = require 'qeda'
lib = new Qeda.Library
symbol:
style: 'GOST'
lib.add 'Altera/5M1270ZT144' # Add Altera MAX V CPLD
lib.add 'Analog/AD9393' # Add Analog Devices HDMI interface
lib.add 'ST/L3GD20H' # Add STMicroelectronics gyroscope
lib.add 'TI/ISO721' # Add Texas Instruments digital isolator
lib.add 'TI/ISO722' # Add Texas Instruments digital isolator
lib.generate 'mylib'
```
Запускаем. Для сравнения приведем результат «до и после» для части Altera 5M1270ZT144 (заметьте, что позиционное обозначение так же изменилось в соответствии с ГОСТ):
**До**:
**После**:
Ну и на десерт пара реальных, а не гипотетических примеров результата работы:
**Analog Devices AD9393**ad9393.yaml:
```
name: AD9393
description: Low power HDMI display interface
pinout:
PD: B9
VIDEO:
Rx0+: K5
Rx0-: K4
Rx1+: K8
Rx1-: K7
Rx2+: J10
Rx2-: K10
RxC+: K2
RxC-: K1
OUTPUTS:
D23-0: B6, A6, B5, A5, B4, A4, B3, A3-A1, B1-H2
DCLK: A7
HSOUT: A8
VSOUT: B8
O/E: A9
FILT: D10
Vd: E7, F7
Vdd: D4, D5
PVdd: F9, G9
DVdd: G6, G7
GND: C9, C10, D6, D7, D9, E4, E9, E10, F4, H10, J1, K3, K6, K9
CONTROL:
SCL: B10
SDA: A10
HDCP:
DDC_SCL: H9
DDC_SDA: J9
MCL: G10
MDA: F10
AUDIO:
S/PDIF: J7
I2S0-3, MCLK: J6-J2
SCLK: G4
LRCLK: G5
DE: B7
RTERM: J8
properties:
in: PD, Rx0+, Rx0-, Rx1+, Rx1-, Rx2+, Rx2-, Rx3+, Rx3-, RxC, RxC, SCL, DDC_SCL, MCL, DE
out: D23-0, DCLK, HSOUT, VSOUT, O/E, S/PDIF, I2S0-3, MCLK, SCLK, LRCLK
bidir: SDA, DDC_SDA, MDA
power: Vd, Vdd, PVdd, DVdd
ground: GND
analog: FILT, RTERM
schematic:
symbol: IC
left: PD, VIDEO, FILT, CONTROL, HDCP, AUDIO, DE
right: OUTPUTS, RTERM
top: Vd, Vdd, PVdd, DVdd
bottom: GND
housing:
pattern: BGA
pitch: 0.5
rowCount: 10
columnCount: 10
leadCount: 76
lead: 0.25-0.35
bodyWidth: 5.90-6.10
bodyLength: 5.90-6.10
height: 1.40
keywords: IC, digital, receiver, converter
```
УГО:
Посадочное место:
**STMicroelectronics L3GD20H**l3gd20h.yaml:
```
name: L3GD20H
description: Three-axis digital output gyroscope
pinout:
Vdd_IO: 1
I2C:
SCL: 2
SDA: 3
SA0: 4
SPI:
SPC: 2
SDI: 3
SDO: 4
3WIRE:
SDO: 3
CS: 5
DRDY: 6
INT:
INT1: 7
INT2: 6
DEN: 8
RES: 9-11, 15
GND: 12, 13
Cap: 14
Vdd: 16
properties:
power: Vdd_IO, Vdd
ground: GND, RES
in: CS, DEN
out: INT1-2, SCL, SDO
bidir: SDA
analog: Cap
schematic:
symbol: IC
left: CS, I2C, DEN
right: INT, RES, Cap
top: Vdd_IO, Vdd
bottom: GND
housing:
pattern: QFN
pitch: 0.5
bodyLength: 2.85-3.15
bodyWidth: 2.85-3.15
height: 1
pullBack: 0.1
rowCount: 5
columnCount: 3
leadLength: 0.29-0.41
leadWidth: 0.19-0.31
```
УГО:
Посадочное место:
#### Заключение
Я коснулся лишь малой части API, чтобы статья не получилась чересчур длинной, и не отразил всего многообразия настроек и параметров, которыми можно варьировать.
Что еще предстоит сделать? По сути проект находится сейчас на стадии proof of concept. Сделать надо ещё вагон и маленькую тележку. Что планируется:
* Расширить количество поддерживаемых типов элементов
* Углубить диагностику ошибочных ситуаций
* Пройти весь путь до изготовления платы
* Генерировать 3D-модели
* Поддержать форматы и других EDA-программ
* Наконец-таки все это хорошенько задокументировать
#### Исходный код
Github: <https://github.com/qeda> | https://habr.com/ru/post/271051/ | null | ru | null |
# Odesk-client перестал снимать скриншоты (OS X Lion)?
Если вы зарабатываете деньги через [Odesk](http://www.odesk.com), то после обновления на OS X Lion, скорее всего заметили, что перестали сниматься скриншоты. Выглядит это примерно вот так:
Проблема решается запуском в консоли команды:
`$ defaults write com.odesk.Preferences "TeamCapture.UseCGS" 1`
Надеюсь данный фикс будет полезен, и вам не придется тратить свое драгоценное время на написание тикета в Odesk-Support :) | https://habr.com/ru/post/124631/ | null | ru | null |
# Magento, дополнительный контент на странице Checkout
Нужно добавить две картинки на страницу чекаута, как на этой картинке:
Это оказалось не так просто, как казалось.
Для начала сделаем небольшой файл-шаблончик с нужными картинками. Это файл `app/design/frontend/default/sunnyD/template/callouts/checkout.phtml`:
```
 ?>)
Первая картинка загружается динамически, для чего используется Javascript.
Первая попытка
--------------
Почему бы просто не добавить новый блок в checkout.xml? Для этого можно использовать встроенный блок `core/template`. Он очень удобен для вывода простых шаблонов без логики, ему нужно передать всего один параметр — шаблон, который надо вывести. И, т.к. шаблон простого чекаута состоит из контента и правого блока (шаблон `2columns-right.phtml`), добавить наш новый блок к правой части страницы, как-то так:
```
...
...
...
```
Это даже работает, и на первый взгляд мы имеем именно то что надо — справа появляются наши картинки из шаблона `checkout.phtml`.
Но на второй взгляд, когда нажать кнопку Continue что бы перейти к следующему шагу чекаута, правая часть страницы целиком перезагружается. html для правой страницы приходит в Ajax запросе. Этот html больше не содержит наших картинок.
Вторая попытка
--------------
Ладно, значит нужно поправить возвращаемый html, что бы он содержал наши картинки.
Для этого надо поправить `checkout.xml`, секцию `checkout_onepage_progress`. Нужно добавить наш блок, как мы это делали в секции `checkout_onepage_index`. Но что это? Наших картинок всё-равно нет!
В общем в итоге выяснилось, что к блоку нужно добавить параметр `output` и присвоить ему значение `toHtml`:
```
...
...
```
Да что же это? Теперь после кнопки Continue видно только одну картинку, которая загружается через тэг `img`. Второй картинки, загружаемой через Javascript, не видно. Более того, хотя js код пришёл в ответе от сервера, он пропал из DOM дерева. Какой-то фильтр?
В общем, попытка номер два тоже провалилась.
Успех
-----
Ладно, если не получается показывать обе картинки модифицируя код правой части, возвращаемый с помощью Ajax запроса, попробуем сделать так, что бы шаблон оставался неизменным на протяжении всех шагов чекаута.
Javascript, работающий со страницей чекаута находится в файле `opcheckout.js`. Похоже, что код, который обновляет правую часть страницы, выглядит так:
```
...
reloadProgressBlock: function(){
var updater = new Ajax.Updater($$('.col-right')[0], this.progressUrl, {method: 'get', onFailure: this.ajaxFailure.bind(this)});
},
...
```
Т.е. он берёт первый элемент с классом `col-right` и устанавиливает ему новый html, полученный с сервера.
А вот где элемент с этим классом объявлен — файл `template/page/2columns-right.phtml`:
```
...
php echo $this-getChildHtml('right') ?>
getChildHtml('right') ?>
php echo $this-getChildHtml('images') ?>
<!-- end right --></pre>
Смысл такой. Создаём новый div-обёртку, которая будет содержать правую колонку. Мы не можем назначит ему класс col-right, потому что тогда контент этого дива затрётся. Но мы можем оставить ему класс side-col (который просто установливает ширину колонки, сейчас 195px). И добавляем свойство float: right что бы наш див-обёртка распологался справа.
Затем добавляем внутрь этого дива-обёртки сначала исходную правую часть getChildHtml('right'), затем наш шаблон с картинками getChildHtml('images').
Теперь оба дива могут иметь оригинальные классы side-col и col-right. При переходе между шагами будет обновляться содержимое первого блока с классом col-right, а второй блок с нашими картинками останется нетронутым на протяжении всего чекаута. Что и требовалось.
И ещё — что бы код getChildHtml('images') отработал и отобразил наш блок core/template с шаблоном с картинками, нужно его добавить в checkout.xml внутри reference name="root". И ещё добавить свойство as, равное images. Это images и есть то имя, по которому getChildHtml() найдёт наш блок. Получаем:
```
...
...
...
```
Вот, всего несколько часов работы и страничка чекаута содержит наш допольнительный шаблон. Всё в рамках приличия, ядрёные файлы не модифицированы, все изменения только в папке с пользовательской темой…
```
``` | https://habr.com/ru/post/72493/ | null | ru | null |
# Двенадцать простых начальных шагов разработки модуля для Node.js
![[Аристотель]](https://habrastorage.org/r/w780q1/getpro/habr/post_images/101/328/cf0/101328cf0c1248b20ec5b675fc43a677.jpg)**«Начало — более чем половина всего».**
Это очень древний GTD-принцип: возраст его, вероятно, исчисляется тысячелетиями. (Например, Викицитатник [в настоящее время](https://ru.wikiquote.org/w/index.php?oldid=244331#.D0.9D) приписывает его Аристотелю, хотя и без подтверждающего указания на первоисточник.) Суть его в том, что с чистого листа начинать какой-либо проект бывает очень трудно (и даже приходится заставлять себя); а вот если есть несколько простых начальных шагов, выполнение которых приводит к появлению частично готового проекта, то продолжить работу над ним «по инерции» становится куда проще — так просто, как если бы проект этот ужé был не только начат, но и готов даже более, чем наполовину. А кроме того, когда заранее хорошо знаешь, какими должны быть начальные шаги, то тогда трудно бывает допустить ошибку, совершая их.
Мне довелось сочинить более десятка модулей для Node.js с открытым исходным кодом и опубликовать их в качестве пакетов npm. Чем больше модулей я делал, тем сильнее понимал (в том числе путём проб и ошибок), что начальные шаги для их создания могут быть одинаковыми и даже могут совершаться в одном и том же порядке. Сегодня я публикую этот порядок в надежде на то, что он станет подспорьем в работе программистов, сочиняющих свой код на языке JavaScript для движка Node.
Обратите внимание на то, что каждый из этих шагов довольно прост и логичен.
### Шаг 1. Придумывание имени пакета npm и репозитория
Без имени ничего не получится. Не имея имени для своего проекта, вы не сможете создать для него ни репозиторий на Гитхабе, ни пакет npm.
Заранее убедитесь в том, что имя пакета npm ещё не занято. (Вот пример: если осенью вам вздумается назвать свой пакет «autumn» или «fall», то посещение адресов <https://www.npmjs.org/package/autumn> и <https://www.npmjs.org/package/fall> без труда убедит вас в том, что пакеты npm с такими именами ужé существуют.)
Если именем вашего пакета npm послужит какое-нибудь простое слово или общеизвестный технический термин, то подумайте о том, не прибавить ли префикс «node-» к нему для того, чтобы получить название репозитория. (Например, код пакета [sqlite3](https://www.npmjs.org/package/sqlite3) хранится в репозитории [node-sqlite3](https://github.com/mapbox/node-sqlite3), а код пакета [open](https://www.npmjs.org/package/open) хранится в репозитории [node-open](https://github.com/jjrdn/node-open).) Такое прибавление делается для удобства программистов, работающих над одноимёнными проектами на других языках программирования. (Например, если у кого-нибудь ужé есть проект под именем «open» на Rust, Ruby или Python, то он всё же и репозиторий «node-open» сможет форкнуть невозбранно, а не испытает последствия конфликта имён.)
А короткое ли будет имя у вашего пакета npm или длинное? Если короткое, то его проще вручную набрать (например, в командной строке после «**npm install**»), а если длинное, то его будут копипастить (это действие происходит безошибочнее, но дольше — и поэтому воспринимается как менее удобное). Также учтите, что сайт [nodei.co](https://nodei.co/) выдаёт такие гистограммы со статистикою скачиваний пакета npm, ширина которых зависит от длины имени пакета (чтобы имя целиком могло поместиться на гистограмме). Вот два примера:
![[гистограмма №1: uue]](https://habrastorage.org/r/w1560/getpro/habr/post_images/868/ece/ee6/868eceee623da3c1bacd792decf19e67.png)
![[гистограмма №2: fidonet-jam]](https://habrastorage.org/r/w1560/getpro/habr/post_images/261/b5b/f3b/261b5bf3b9fe1e77b8f02d0128e7ac4a.png)
Для модулей, наделённых слишком длинными именами, рост ширины такой гистограммы может вызвать (и вызовет, непременно вызовет!) необходимость размещения статистики на отдельной строке, а не справа или слева от какой-нибудь другой картинки, когда вы станете подготавливать сводную информацию о своём модуле — даже такую простую, как README на Гитхабе.
### Шаг 2. Придумывание краткого описания
Краткое описание пригодится и при создании проекта на Гитхабе, и позднее (например, при заполнении поля **description** в файле **package.json**).
Лучше всего поместить туда всего одно краткое предложение с описанием того, что делает ваш модуль. Оно будет способствовать поисковой находимости и сопутствовать названию пакета или репозитория на многих сайтах с гиперссылками. Если сделать описание слишком длинным, то оно не поместится [на карточку в Твиттере](http://habrahabr.ru/post/210996/) (и на других сайтах, обрезающих описания по длине); кроме того, даже если поместится, то при беглом чтении списков публика всё равно не станет дочитывать до конца его.
### Шаг 3. Создание репозитория на Гитхабе с автоматически заполненным README-файлом.
Как правило, репозитории модулей Node создаются на Гитхабе; мне попадались и исключения из этого правила, но редко. Поэтому все шаги я стану здесь излагать с расчётом на употребление Гитхаба и Git, а читателям из числа пользователей других DVCS и (или) других хостингов открытого исходного кода предоставляю адаптировать эти шаги для себя самим: дело это не хитрое.
На странице <https://github.com/new> предлагают заполнить имя и описание репозитория (то и другое вы могли придумать на двух предыдущих шагах), а также автоматически создать **README**-файл (описание проекта), файл с текстом **лицензии** (чтобы обозначить, насколько ваш код открыт) и файл **.gitignore** (чтобы затем не закачать в репозиторий никаких лишних, временных, вспомогательных, мусорных файлов).
Когда в репозитории на Гитхабе с самого начала есть хотя бы один файл, то репозиторий можно просто клонировать (например, командою «**git clone**») — это быстрее и проще (примерно в полтора или даже в два раза), чем сперва инициализировать локальный репозиторий (например, командою «**git init**»), а затем руками в настройках прописывать ему адрес гитхабовского репозитория как **origin**.
Но автосозданный Гитхабом файл лицензии зачастую приходится править под себя (например, вместо гитхабовского логина указывать своё полное имя или название организации), да и в автосозданный **.gitignore** вы можете также пожелать чего-нибудь добавить в соответствии со своим представлением о том, какие файлы в репозитории не нужны. Поэтому, если вы создаёте не первый модуль Node в своей жизни, то лучше ограничиться автосозданием одного только файла README, а лицензию и **.gitignore** скопировать в готовом виде из одного из своих прежних модулей. Делать же их заново (пускай и не с нуля, а из результатов гитхабовской автогенерации) — это и [муда](http://traditio-ru.org/wiki/%D0%9C%D1%83%D0%B4%D0%B0) （無駄、 лишняя работа), и напрасное захламление истории правок.
После создания репозитория на Гитхабе не позабудьте внести все те изменения в настройках репозитория, которые считаете необходимыми для него. Например, если мало времени и поэтому некогда приглядывать за вики, то можно отключить в репозитории поддержку вики. А если, например, вы привыкли видеть в списке «Starred» (в списке репозиториев, помеченных звёздами) не только некоторые чужие репозитории, но и все свои репозитории, то тогда можно тотчас же поставить свежесозданному репозиторию его первую звезду.
### Шаг 4. Добавление текстового файла с указанием лицензии
С этим шагом лучше всего не затягивать: чем раньше вы дадите понять, под какою лицензией распространяются все последующие правки, тем лучше.
Как я и говорил на предыдущем шаге, если вы создаёте не первый модуль Node в своей жизни, то можно скопировать файл **LICENSE** из другого модуля, подправить при необходимости год в тексте — и можно коммитить.
Если же вы в первый раз принимаете решение о том, под какой лицензией распространять свой открытый исходный код, то можете последовать примеру сообщества (а в сообществе Node.js, насколько я могу судить, лицензия MIT наиболее популярна, хотя встречаются и исключения из этого правила), или проконсультироваться с сайтом [choosealicense.com](http://choosealicense.com/), или и то, и другое вместе.
### Шаг 5. Добавление файлов **.gitignore** и **.npmignore**.
Как известно, в файле **.gitignore** перечисляются имена тех файлов и каталогов, которые не должны попадать в репозиторий Git, потому что они только напрасно захламляли бы его. К их числу относятся, как правило, архивы и дистрибутивы проекта, логи, базы данных, вспомогательные файлы операционной системы (например, хранилища миниатюр изображений, содержащихся в некотором подкаталоге).
При разработке проекта, в котором один или несколько модулей Node используются в качестве зависимостей, бывает вполне уместно добавить в файл **.gitignore** имя каталога **node\_modules**, потому что соответствие между версией и содержимым пакета npm является однозначным — следовательно, достаточно хранить в своём репозитории Git только файл **package.json** (в котором перечислены имена и версии зависимостей), но не сами необходимые модули.
(Для расширения кругозора упомяну, что Mikeal Rogers [высказывал](http://www.futurealoof.com/posts/nodemodules-in-git.html) и деятельно продвигал совершенно противоположную рекомендацию. Но это случилось **до** того, как в 2014 году соответствие между версией и содержимым пакета npm сделалось [однозначным](http://blog.npmjs.org/post/77758351673/no-more-npm-publish-f).)
Также в файл **.gitignore** полезно добавить имя отчёта **npm-debug.log**, появляющегося в том случае, если при работе с пакетами npm возникла какая-нибудь ошибка.
В итоге файл **.gitignore** приобретает какой-то такой вид:
**.gitignore**
```
# Архивы, дистрибутивы
*.7z
*.dmg
*.gz
*.iso
*.jar
*.rar
*.tar
*.zip
# Базы данных, логи
*.log
*.sql
*.sqlite
# Спецфайлы операционных систем
Thumbs.db
Desktop.ini
.DS_Store*
ehthumbs.db
Icon?
# Модули Node, логи npm
node_modules
npm-debug.log
```
Файл **.npmignore** примерно аналогичен файлу **.gitignore** — но в нём перечисляются имена тех файлов и подкаталогов, которые не должны попасть в npm-пакет вашего модуля.
Я рекомендую скопировать в **.npmignore** всё содержимое вашего **.gitignore**, а затем прибавить к нему название подкаталога **test** или другого такого места, в котором вы собираетесь хранить тесты своего модуля. Тесты чрезвычайно полезны в разработке, поэтому вполне уместны и в репозитории Git — но скачивание и хранение тестов было бы лишним грузом для конечных пользователей вашего модуля, а именно из таковых состоит большинство потребителей npm-пакета.
Как правило, начиная работу над новым модулем Node, можно скопировать файлы **.gitignore** и **.npmignore** в неизменном виде из одного из прежних своих модулей (если только вы создаёте не первый модуль Node в своей жизни). Корректировать их приходится в редких случаях, но надо знать, что такие случаи бывают. (В частности, если какой-нибудь модуль имеет дело с ZIP-архивами, то строчку «**\*.zip**» из файла **.gitignore** неизбежно придётся убрать хотя бы для того, чтобы поместить один или несколько тестовых примеров в репозиторий — и такая необходимость возникла у меня при разработке [модуля для чтения фидонетовских ноудлистов](https://github.com/Mithgol/node-fidonet-nodelist), например.)
### Шаг 6. Описание модуля в README.md, упоминание о лицензии и о неоконченности разработки.
Напоминаю, что на третьем шаге был автоматически создан файл **README**, состоящий только из названия и краткого описания модуля.
Теперь это описание можно несколько пополнить, рассказав о целях и задачах проекта. Кроме того, в отдельном подразделе описания уместно упомянуть тип лицензии (например, MIT или BSD) и имя того файла (как правило, **LICENSE**), в котором лежит полный текст лицензии.
Чтобы попытки практического знакомства читателей с возможностями модуля на этом этапе не вызывали разочарования (а ещё лучше — чтобы такие попытки вообще пока что не происходили), полезно сразу вывесить предупреждающее упоминание о том, что разработка модуля не только не закончена, но и находится на самой ранней стадии.
После такого пополнения файл README годится в качестве первоначального описания первоначальной версии npm-пакета.
Однако, если вам довелось упомянуть в README ещё и планируемое имя пакета, то не торопитесь помещать результаты этого шага в репозиторий (например, git-командою **commit**), а уж тем более не торопитесь публиковать их (например, git-командою **push**) на Гитхабе. Дело в том, что если первоначальная регистрация пакета с запланированным именем (а именно ей мы займёмся на следующем шаге) не удастся, то в README придётся прописывать другое имя (и будет лучше, если это не приведёт к неприятному выбору между засорением и подчисткой истории правок); публикация же на Гитхабе (если она предшествует публикации в npm) и вовсе способна насторожить не только каких-нибудь киберсквоттеров (которые пожелают застолбить указанное имя пакета раньше вас), но и обыкновенных пользователей (которые будут пробовать команду «npm install имя-пакета» и удивляться тому, чего это она не работает как следует).
Вообще же рекомендую считать, что на этом шаге упоминать в README планируемое имя пакета было бы рановато.
### Шаг 7. Сочинение **package.json** и регистрация пакета npm самой начальной версии.
Конечной целью этого шага является регистрация npm-пакета под ранее задуманным именем, чтобы застолбить это имя.
Начать такой шаг приходится созданием файла **package.json** и заполнением сразу нескольких полей объекта внутри него. При этом надо одновременно соблюдать [формат JSON](http://json.org/) и то описание смысла полей, которое приведено [на сайте npm](https://docs.npmjs.com/files/package.json).
Существует команда «**npm init**», которая задаёт вам вопросы о модуле и самостоятельно заполняет **package.json** в соответствии с ответами. Однако я предпочитаю заполнять **package.json** в текстовом редакторе — это позволяет обозревать весь код JSON в чистом виде (не разбавленный вопросами) и притом даёт простую возможность возвратиться на пару строк выше, чтобы подправить или переменить чего-нибудь по мере нужды.
Вообще-то документации, лежащей [на сайте npm](https://docs.npmjs.com/files/package.json), должно хватать всем; но я не утерплю и на Хабрахабре бегло коснусь смысла основных полей, которые в **package.json** помещаются.
Значением для поля «**name**» указывается желаемое имя пакета npm. Его вы могли придумать ранее (на первом шаге).
Значением для поля «**version**» указывается версия пакета в соответствии со стандартом [Semantic Versioning](http://semver.org/). Для регистрации самой начальной версии я рекомендую «**"0.0.1"**».
Значением для поля «**description**» указывается краткое описание пакета. Его вы могли придумать ранее (на втором шаге).
Значением для поля «**keywords**» указывается массив ключевых слов, по которым пакет могут отыскать в поиске по сайту npm. Всякий, кто когда-либо перечислял метки под текстом блогозаписи на Хабрахабре, без труда справится и с этой задачею.
Значением для поля «**license**» указывается строка-идентификатор, соответствующая стандарту [SPDX ID](https://spdx.org/licenses/) и означающая лицензию, выбранную вами для своего кода ранее (на четвёртом шаге).
Значением для поля «**author**» указывается строка (или объект) с именем автора пакета (а также, может быть, с контактными данными). Укажите там себя.
Значением для поля «**repository**» указывается объект, содержащий тип и адрес репозитория.
Значением для поля «**main**» указывается путь к главному файлу кода модуля (это тот самый файл, который из Node будет вызван функцией «**require(**moduleName**)**», если вместо **moduleName** указать имя модуля).
Если модуль подразумевается как утилита, работающая из командной строки, то тогда такому модулю полезным будет в **package.json** свойство «**preferGlobal**» со значением «**true**» (которое будет рекомендовать глобальную установку модуля) и свойство «**bin**» со значением наподобие «**"./moduleName.js"**», содержащим путь к некоторому джаваскрипту (к тому именно, который будет запускаться по команде, совпадающей с именем модуля). Строка «**#!/usr/bin/env node**» должна стать первою в таком джаваскрипте, потому что npm ожидает её увидеть там (даже если установка и последующая работа модуля совершается под Windows).
Код модуля на этом шаге может быть простейшим — например, содержать какой-нибудь «**hello world**» или даже «**"use strict"**».
В описание коммита уместно поместить фразу «пакет зарегистрирован» (или «пакет опубликован») и совершать этот коммит только после того, как команда «**npm publish**» окажется успешною (если окажется). Таким образом, коммит не окажется преждевременным (подача команды «**npm publish**» может выявить одну или несколько простых ошибок, исправление которых только напрасно захламляло бы историю правок).
### Шаг 8. Объяснение установки в README.md
Во время этого шага уместно поместить в файл README.md объяснения, сообщающие будущим пользователям смысл двух команд:
* **npm install имяПакета** — команда, которая установит npm-пакет из хранилища npm,
* **npm install https://github.com/имяПользователя/имяРепозитория/tarball/master** — команда, которая установит модуль из master-ветки гитхабовского репозитория.
Также полезно объяснить будущим пользователям разницу между результатами той и другой команды — например, рассказать о принятом ранее (на пятом шаге) решении хранить тесты только на Гитхабе, а не в npm (чтобы не увеличивать объём npm-пакета).
Можно ещё рассказать, что и последняя версия файла README.md будет только на Гитхабе (если только вы не планируете создавать и публиковать очередную новую версию своего npm-пакета не только после изменений в коде, но также и после изменений в README).
Во время этого же шага можно также получить на сайте [nodei.co](https://nodei.co/) подходящий код информативных статистических счётчиков и гистограмм, указывающих на количество зависимостей и установок модуля, и также поместить их в файл README.md.
### Шаг 9. Самое начало работы над основным кодом модуля
На этом этапе зачаток модуля (то есть какой-нибудь «**hello world**» или даже «**"use strict"**») потихоньку превращается в код, делающий нечто разумное — а значит, содержащий для этой цели одну или несколько функций (или методов объекта, или команд утилиты).
По мере формирования все эти возможности исходного кода следует аккуратно документировать в README.md, чтобы единственной документацией к открытому исходному коду не остался сам код.
Кроме того, как только исходный код достигает этой стадии, так сразу его становится неплохо бы покрыть тестами, проверяющими корректность кода и его поведения. Об этом — следующий шаг.
### Шаг 10. Содействовать тестированию и объяснить его
На этом шаге надобно поместить в README.md понятные сведения о том, как установить и как использовать средства тестирования правильности написания исходного кода (например, JSHint) и его поведения (например, Mocha).
На этом этапе в репозиторий также добавляются конфигурационные файлы для средств тестирования (например, **.jshintrc** для JSHint).
В объекте внутри файла **package.json** заполняется поле **scripts.test** (а если средств тестирования два-три, то также и поля **scripts.pretest** да **scripts.posttest**).
Пример:
```
"scripts": {
"pretest": "jshint имяМодуля.js test/",
"test": "mocha --reporter spec --timeout 60s"
}
```
Начиная от этого шага, перед каждым коммитом желательно убеждаться в том, что команда **npm test** проходит без ошибок. (Чтобы работа этой команды была более осмысленною, при использовании Mocha также следует сочинить хотя бы один тест и поместить его в подкаталог **test/**.)
### Шаг 11. Конфигурирование Travis CI
[Travis CI](http://travis-ci.org/) — это сервис, предоставляющий услугу бесплатного тестирования открытого исходного кода: после каждого коммита он способен автоматически скачивать код с Гитхаба и запускать тесты в различных окружениях, чтобы посмотреть, хорошо ли работает код.
К первоначальному употреблению Travis CI неплохо бы подготовиться, то есть [прочесть документацию](http://docs.travis-ci.com/) и пройти регистрацию.
Подключение же нового джаваскриптового модуля гораздо проще и состоит из двух несложных шагов.
Во-первых, надо зайти по адресу <https://travis-ci.org/profile/> в свой пользовательский профиль. Там появятся переключатели, каждый из которых соответствует одному из репозиториев на Гитхабе; выглядит это как-то так:
![[скриншот]](https://habrastorage.org/r/w1560/getpro/habr/post_images/489/6cf/062/4896cf0624be89081f4be378cd5a7ab4.png)
Переключатель, соответствующий новому модулю, следует дёрнуть во включённое положение.
Во-вторых, сразу после этого надо закоммитить файл **.travis.yml** в корень репозитория. Этот файл описывает окружение, необходимое для запуска тестов. Подробнее о нём вы можете прочесть в документации по Трэвису, но обычное содержание его довольно несложно и выглядит как-то так:
```
language: node_js
node_js:
- "0.10"
- "0.12"
- iojs
before_install:
- "npm install -g npm"
- "npm config set spin false"
before_script:
- "npm install jshint"
- "npm install mocha"
```
В разделе «**language**» вы видите указание «языка» (точнее, движка) Node, а в разделе «**node\_js**» — перечисление версий, в каждой из которых будет тестироваться модуль.
В разделе «**before\_install**» приведены команды, обновляющие **npm** до последней стабильной версии, а также отключающие анимацию крутящегося курсора (которая в логах Travis CI всё равно не отображается, так что нечего тратить на неё время).
В разделе «**before\_script**» приведены команды, устанавливающие средства тестирования (в этом примере — JSHint и Mocha).
### Шаг 12. Добавление индикатора Travis CI в **README.md**.
Travis CI [предоставляет](http://docs.travis-ci.com/user/status-images/) URL картинки, которую можно поместить один раз в README на Гитхабе и затем всякий раз видеть там, успешно ли прошло на Travis CI тестирование итогов последнего коммита.
На сервере [shields.io](http://shields.io/) предоставляется возможность получить несколько другую форму этой картинки — например, изменить объёмность, или закругление краёв, или часть надписи.
### Обобщение метода
Здесь заканчивается список простых начальных шагов разработки модуля для Node.js.
Понятно, надеюсь, что такой метод (то есть возможность придать себе первоначальный импульс, начав работу с воспроизведения ранее подготовленных шагов) годится не только при разработке модулей для Node.
Приведу пример. В статье про [паралич разработчика](http://habrahabr.ru/post/240977/) (которую [PerseptronYar](http://habrahabr.ru/users/perseptronyar/) перевёл) вы могли видеть на Хабрахабре рассказ о том, что всякий современный сайтостроитель, приступая к работе, без промедления оказывается перед неотступною необходимостью раз за разом делать неочевидный выбор между различными возможностями примерно равной привлекательности — наподобие [буриданова осла](https://ru.wikipedia.org/wiki/%D0%91%D1%83%D1%80%D0%B8%D0%B4%D0%B0%D0%BD%D0%BE%D0%B2_%D0%BE%D1%81%D1%91%D0%BB):
> Starting a basic website in 2014:
>
> 1. Install Node
> 2. Install Bower
> 3. Pick CSS framework
> 4. Pick responsive approach
> …
>
> 47. Write some HTML
>
> — I Am Devloper (@iamdevloper) [2 октября 2014](https://twitter.com/iamdevloper/status/517616294909464576)
Вы можете, однако, сильно упростить себе жизнь в дальнейшем, если сумеете не только один раз сделать такой выбор, но и в дальнейшем попросту придерживаться его. Для этого достаточно зафиксировать в письменном виде выбор, сделанный на каждом таком шаге, записать все эти шаги в их готовом виде (то есть, например, не «выбрать CSS framework», а «установить Bootstrap», если выбрали Bootstrap), а затем следовать им при начале каждого нового проекта, если только в промежутке между проектами не объявился повод сознательно попробовать чего-нибудь новенькое (ну, например, вы сможете [отказаться](https://www.reindex.io/blog/you-might-not-need-underscore/) от Underscore.js в пользу новейших возможностей языка JavaScript, когда постепенный переход читателей на новые браузеры обеспечит вам такую возможность). | https://habr.com/ru/post/262057/ | null | ru | null |
# Updated Razor support in Visual Studio Code, now with Blazor support
Some days ago we announced improved Razor tooling support in Visual Studio Code with the latest C# extension. This latest release includes improved Razor diagnostics and support for tag helpers and Blazor apps.
[This article in blog](https://devblogs.microsoft.com/aspnet/updated-razor-support-in-visual-studio-code-now-with-blazor-support/)
Get Started
-----------
To use this preview of Razor support in Visual Studio Code install the following:
* [.NET Core SDK](https://www.microsoft.com/net/download)
* [Visual Studio Code](https://code.visualstudio.com/)
* [C# extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode.csharp)
To try out Visual Studio Code with [Blazor](https://blazor.net/) apps, also install:
* [.NET Core 3.0](https://aka.ms/netcore3download) (Preview 4 or later)
* The latest Blazor CLI templates:
```
dotnet new -i Microsoft.AspNetCore.Blazor.Templates::3.0.0-preview4-19216-03
```
What’s new in this release?
---------------------------
### Improved diagnostics
We’ve improved the Razor diagnostics in Visual Studio Code for a variety of scenarios, including floating `@` characters:
Missing end braces:
And missing end tags in code blocks:
### Tag helpers
Tag helper completions are now supported in ASP.NET Core projects:
As well as completions for tag helper attribute names and values:
### Blazor
Visual Studio Code now works with [Blazor](https://blazor.net/)apps too!
You get completions for components and component parameters:
Also data-binding, event handlers and lots of other Blazor goodies!
Limitations and known issues
----------------------------
This is an alpha release of the Razor tooling for Visual Studio Code, so there are a number of limitations and known issues:
* Razor editing is currently only supported in ASP.NET Core and Blazor projects (no support for ASP.NET projects)
* Limited support for colorization
Note that if you need to disable the Razor tooling:
* Open the Visual Studio Code User Settings: *File* -> *Preferences* -> *Settings*
* Search for “razor”
* Check the “Razor: Disabled” checkbox
Feedback
--------
Please let us know what you think about this latest update to the Razor tooling support in Visual Studio Code by reporting issues in the [Razor.VSCode](https://github.com/aspnet/Razor.VSCode) repo. When reporting Razor tooling related issues please use the “Report a Razor Issue” command in Visual Studio Code to capture all of the relevant longs and diagnostic information. Just run the command and then follow the instructions.
Thanks for trying out Razor in Visual Studio Code!
##### [Daniel Roth](https://devblogs.microsoft.com/aspnet/author/danroth27/)
Principal Program Manager, ASP.NET | https://habr.com/ru/post/449674/ | null | en | null |
# jQuery изнутри — атрибуты, свойства, данные
Последняя за новогодние каникулы, но не последняя в этой серии статья, посвященная внутренностям jQuery. [Прошлая](http://habrahabr.ru/post/164677/) получилась очень быстрой и маленькой, но интерес хабражителей к теме, судя по опросу «стоит ли продолжать?», который висят в каждом посте некоторое время после его создания, не пропадает.
Тема для сегодняшнего поста достаточно большая и я постараюсь рассказать о ней поинтереснее и не слишком поверхностно. Рассмотрим мы сегодня методы [attr](http://api.jquery.com/attr/), [prop](http://api.jquery.com/prop/) и [data](http://api.jquery.com/data/).
Последняя из них — самая интересная и мы отложим ее напоследок.
Все три функции работают через служебную [access](https://github.com/jquery/jquery/blob/1.8.3/src/core.js#L772).
#### jQuery.access
Эта функция напоминает `domManip` из предыдущей главы и нужна для подготовки аргументов, переданных в функцию, а затем — для выполнения указанного callback'а. В нашем случае этот callback — как раз те функции, которые будут производить операции с атрибутами, свойствами и данными.
Для начала, в функции [проверятся](https://github.com/jquery/jquery/blob/1.8.3/src/core.js#L779) наши аргументы и, если это — объект, то он будет «развернут» и для каждого ключа `access` будет вызван отдельно. Образно, эти два варианта — одинаковы:
| | |
| --- | --- |
|
```
$('.user-avatar').attr( {
'alt': 'Аватар',
'title': function(idx, value) {
return 'Пользователь ' + value +
' (' + $(this).data('id') + ')';
}
} );
```
|
```
$('.user-avatar')
.attr('alt', 'Аватар')
.attr('title', function(idx, value) {
return 'Пользователь ' + value +
' (' + $(this).data('id') + ')';
} );
```
|
Дальше для каждого элемента в нашем jQuery-объекте [будет вызван](https://github.com/jquery/jquery/blob/1.8.3/src/core.js#L806) callback для текущего ключа и значения. Как видно из примера выше, функции в значении [тоже поддерживаются](https://github.com/jquery/jquery/blob/1.8.3/src/core.js#L788), в этом случае значение в callback будет расчитано в указанной функции, которая будет вызвана в контексте элемента, в параметры к ней попадут порядковый номер и текущее значение указанного атрибута.
#### Атрибуты и свойства
##### jQuery.fn.attr
Первым делом функция [проверяет тип элемента](https://github.com/jquery/jquery/blob/1.8.3/src/attributes.js#L287), дабы отсечь попытки получить или задать атрибут у `ATTRIBUTE_NODE`, `COMMENT_NODE`, `TEXT_NODE`.
Дальше [идет проверка](https://github.com/jquery/jquery/blob/1.8.3/src/attributes.js#L291) на существование функции с заданным в ключе названии в `jQuery.fn`, но срабатывает эта проверка **только** в случае вызова `jQuery.attr` из `init`. В первой статье был пример на эту тему и я обещал о нем еще поговорить. Так вот, код слева будет «развернут» в код справа:
| | |
| --- | --- |
|
```
$('', {
'title': 'Пользователь',
'text': 'Содержимое ноды',
'appendTo': document.body
} );
```
|
```
$('')
.attr('title', 'Пользователь')
.text('Содержимое ноды')
.appendTo(document.body);
```
|
Не рекомендую делать так с `appendTo` просто потому, что это не очень красиво. Тем не менее, такое возможно для любой функции, которую мы можем найти в `jQuery.fn`. В этом случае `attr` найдет функции [text](http://api.jquery.com/text/) и [appendTo](http://api.jquery.com/appendTo/) и вызовет их вместо продожения своей работы.
Если у элемента не существует вообще такого метода как `getAttribute`, то будет вызван `jQuery.prop` с тем же ключем и значением. Кейс этот довольно узкий и проявляется, судя по [багрепорту](http://bugs.jquery.com/ticket/220), только в старых IE при работе не с HTML, а с XML-документом, который приходит из ajax-запроса, к примеру.
В случае, если значение атрибута передано в функцию и равно `null`, будет вызвана функция [jQuery.removeAttr](http://api.jquery.com/removeAttr/), которая [удалит атрибут](https://github.com/jquery/jquery/blob/1.8.3/src/attributes.js#L357) (или атрибуты, если они были перечислены через пробел) и поставит соответсвующие boolean-свойства, если они есть, в значение `false`.
Дальше значение атрибута будет задано с помощью соответствующего ему хука (если такой найдется) или обычного `setAttribute`, либо будет получено через хук или `getAttribute`.
##### jQuery.fn.prop
Долго задерживаться на этой функции не будем, потому что она работает примерно так же, как и `attr`, только задает свойства элементу напрямую и попутно [нормализует названия](https://github.com/jquery/jquery/blob/1.8.3/src/attributes.js#L436) свойств. Нормализация происходит через служебный объект `jQuery.propFix`, который, опять же, не документирован и использовать его не желательно, тем не менее:
```
jQuery.propFix.validMsg = 'validationMessage';
// результаты будут равны
$('input:first').prop('validMsg') === $('input:first').prop('validationMessage');
```
##### Хуки
Хуки для `attr` (`jQuery.attrHooks`) и `prop` (`jQuery.propHooks`) — это обычные объекты, у которых может быть функция `set` и/или `get`. Занимаются они заданием и получением определенного значения. На примере будет более понятно:
```
Игорь
Дарья
var
SEX\_MALE = 0,
SEX\_FEMALE = 1,
sexClassesMap = {
'user-male': SEX\_MALE,
'user-female': SEX\_FEMALE
};
jQuery.propHooks.usersex = {
get: function(elem) {
var
elementClasses = elem.className.split(/\s+/),
i = elementClasses.length;
for (; i > 0; i--) {
if ('undefined' !== typeof sexClassesMap[elementClasses[i]]) {
return sexClassesMap[elementClasses[i]];
}
}
},
set: function(elem, value) {
var
$element = $(elem),
i;
for (className in sexClassesMap) {
$element.toggleClass(
className,
sexClassesMap[className] === value
);
}
}
}
// пройдет через хук и вернет male
if (SEX\_MALE === $('.user:first').prop('userSex')) {
console.log('первый - мужчина!');
}
// а так мы - можем поменять
$('.user:last').prop('userSex', SEX\_FEMALE);
```
Штука, может быть и удобная, но не документирована. Не используйте ее без крайней нужды.
Для `attr` есть интересный набор хуков [boolHook](https://github.com/jquery/jquery/blob/1.8.3/src/attributes.js#L476), он автоматически применяется ко всем [заранее заданным булевым атрибутам](https://github.com/jquery/jquery/blob/1.8.3/src/attributes.js#L7). Нужен он для того, чтобы делать вот так:
```
> $('').attr('disabled', true)
[]
```
В этом случае хук дополнительно еще и [задаст значение](https://github.com/jquery/jquery/blob/1.8.3/src/attributes.js#L497) свойства `disabled` в `true`.
Так же есть набор `nodeHook`, но это своеобразный набор костылей, который пополняется на этапе инициализации jQuery, при проверках возможностей браузера (например, [здесь](https://github.com/jquery/jquery/blob/1.8.3/src/attributes.js#L517)). В современных браузерах он пустой.
#### Данные
Начнем с того, что вы крупно ошибаетесь, если думаете, что jQuery что-то знает о такой штуке как [dataset](http://www.w3.org/html/wg/drafts/html/master/dom.html#dom-dataset), пришедшей к нам вместе с HTML5. Понятия не имеет, оно нигде не используется в библиотеке, все делается вручную. Тем не менее, свойства, заданные через `dataset` доступны через `jQuery.data` (только если это не объект). А вот если из jQuery что-то задано через `jQuery.data`, доступно через `dataset` оно уже не будет, потому что библиотека все заданные значения хранит в своем кеше. Обо всем по порядку, еще и разобьем главу немножко.
##### namespace
Вскользь упомянем, что в jQuery 1.8.3 `jQuery.fn.data` позволяет работать с так называемыми namespace для данных. Эта возможность помечена как deprecated еще в 1.7, а в 1.9 ее уже нет совсем. Так что если вы используете что-то такое, то у меня для Вас **плохие новости**:
```
$('sometag').on('changeData.users', function(e) {
console.dir(e);
} );
// бабах, тут мы увидим, что обработчик события выполнился
$('sometag').data('id.users', 10);
// а вот тут - данные зададутся, а тот обработчик уже не вызовется
$('sometag').data( {
'id.users': 10
} );
```
Неймспейсы в событиях никуда не деваются и мы их обязательно рассмотрим в будущем.
##### acceptData
`data` работает не со всем, что движется, а только с тем, что проходит проверку функцией [acceptData](https://github.com/jquery/jquery/blob/1.8.3/src/data.js#L210). Только ноды, не `embed`, `applet` или `object` (в этом случае за исключением Flash'а, [определение](https://github.com/jquery/jquery/blob/1.8.3/src/data.js#L21) идет по `classid`).
##### jQuery.cache
Кеш в jQuery пользуется не только `data`. Для нашего случая с данными, в кеш что-то по элементу попадает при задании какого-то значения какому-то ключу. Объект `jQuery.cache` представляет собой обычный нумерованный объект, где ключ — значение `expando`-атрибута элемента. `jQuery.expando` — уникальный идентификатор, определяемый рандомно при инициализации библиотеки. Как только мы хотим записать в кеш что-то, элементу выделяется его порядковый номер (инкремент [глобального счетчика](https://github.com/jquery/jquery/blob/1.8.3/src/core.js#L739) `jQuery.guid`) в кеше, который записывается в свойство элемента. В соответствующий номеру элемент кеша, в раздел «data» будет помещено само значение. На примере будет более понятно:
```
var
$span = $(''),
spanElement = $span[0];
// уникальный идентификатор, после рефреша страницы будет уже другим
console.log(jQuery.expando);
// jQuery18302642508496064693
console.log(spanElement[jQuery.expando]);
// undefined
// задаем данные по ключу id
$span.data('id', 10);
console.log(spanElement[jQuery.expando]);
// 1
console.dir(jQuery.cache[1]);
/\*
Object {
data: Object {
id: 10
}
}
\*/
$span.remove();
console.dir(jQuery.cache[1]);
// undefined
console.dir(jQuery.deletedIds);
// [ 1 ]
```
Помните мельком упомянутую `cleanData` в предыдущей статье? Она как раз [чистит кеш](https://github.com/jquery/jquery/blob/1.8.3/src/manipulation.js#L805) по удаленным элементам, а удаленные порядковые номера сбрасывает в `jQuery.deletedIds`, чтобы потом взять следующий номер [именно оттуда](https://github.com/jquery/jquery/blob/1.8.3/src/data.js#L61) вместо генерации нового.
Что интересно, кеш с данными не для нод задается [прямо внутри](https://github.com/jquery/jquery/blob/1.8.3/src/data.js#L45) и библиотеке в этом случае не надо будет беспокоиться о чистке. У этого внутреннего объекта-кеша попутно задается пустой метод [toJSON](https://github.com/jquery/jquery/blob/1.8.3/src/data.js#L73), дабы он не попал в вывод при сериализации в JSON:
```
var
$strangeObject = $( {
'test': 123
} ),
strangeObject = $strangeObject[0];
$strangeObject.data('id', 10);
console.dir(strangeObject);
/*
Object {
jQuery18309172190900426358: Object {
data: Object {
id: 10
}
toJSON: function () {}
}
test: 123
}
*/
console.log(JSON.stringify(strangeObject, null, 4));
/*
{
"test": 123
}
*/
```
##### camelCase
Все ключи для `data` [преобразуются](https://github.com/jquery/jquery/blob/1.8.3/src/core.js#L557) в camelCase как на чтении, так и на записи (к слову, `dataset` этим похвастаться не может, на ключи с тире он будет ругаться):
```
$('').data('test-me', 10).data('testMe')
// 10
$('').data('testMe', 10).data('test-me')
// 10
```
##### Запись данных
Для записи из ключа библиотека сначала [пытается выделить](https://github.com/jquery/jquery/blob/1.8.3/src/data.js#L255) namespace (то, что после точки), для использования потом в вызове события, о которых мы выше упоминали.
Затем через все тот же `accessData` (вспоминаем поддержку получения значения из функции и пр.) пытается вызвать обработчик события `setData` у элемента, [записывает данные в кеш](https://github.com/jquery/jquery/blob/1.8.3/src/data.js#L101) (вообще jQuery.data — как раз простыня для работы с кешом, о работе которого мы уже узнали чуть выше) и пытается вызвать обработчик события `changeData`.
Для записи множественных данных, по объекту, для каждого ключа-значения дергается `jQuery.data`, то есть запись напрямую, минуя `accessData` и вызов соответствующих событий, что скорее всего баг в библиотеке (должен быть вызов себя, `jQuery.fn.data`). Чинить ничего не надо, в 1.9 переписали этот кусок.
##### Чтение
Чтение элемента так же проходит через `accessData`. Сначала данные [библиотека пытается найти](https://github.com/jquery/jquery/blob/1.8.3/src/data.js#L266) в кеше и, если не нашла, то [пытается найти](https://github.com/jquery/jquery/blob/1.8.3/src/data.js#L293) в data-атрибутах элемента, которые могли уже у него быть заданы вручную.
В этом случае ключ антикемелизируется (ух какое слово, но смысл в том, что testMe будет преобразован в test-me) и по нему [пытается быть получено](https://github.com/jquery/jquery/blob/1.8.3/src/data.js#L300) значение соответствующего data-атрибута (data-test-me для примера из предыдущих скобок) и, если такое найдено, то оно будет распарсено. Если значение — `null` или булево, то оно будет преобразовано в нативное (не строку), а вот если значение атрибута начинается на открытую фигурную скобку, то библиотека [попробует вызвать](https://github.com/jquery/jquery/blob/1.8.3/src/data.js#L309) [jQuery.jsonParse](http://api.jquery.com/jQuery.parseJSON/). Обратите внимание что длинное число (больше 20 знаков) может вернуться и как число, и как строка (за наводку спасибо [Silver\_Clash](https://habrahabr.ru/users/silver_clash/)), в случае, если после преобразования в число и обратно [сравнение с оригиналом](https://github.com/jquery/jquery/blob/1.8.3/src/data.js#L308) не будет пройдено. Полученное значение будет записано в кеш и возвращено разработчику.
[Получение всего набора](https://github.com/jquery/jquery/blob/1.8.3/src/data.js#L226) данных опять отделено от `accessData` и, опять же, не вызовет обработчик события `getData`. В этом случае будет получено все из кеша плюс библиотека пробежится по всем атрибутам элемента, название которых начинается с «data-» и так же запишет их себе в кеш, попутно выставив в кеше флажок `parsedAttrs`, чтобы на следующее получение целиком повторно все атрибуты уже не разбирать.
#### Заключение
Возможно, `data` следовало рассмотреть отдельной статьей от атрибутов и свойств, но тогда статья по ним получилась бы совсем маленькой. А так — самое то, чтобы начать свой первый рабочий день после долгих выходных. Мне получившаяся статья понравилась, так уж сложилось что мне жутко интересно ковырятья в подобном. Надеюсь, понравится и вам.
Как всегда, не стесняйтесь выражать свое мнение о статье, что-то предлагать и спрашивать.
#### Содержание цикла статей
1. [Введение](http://habrahabr.ru/post/164433/)
2. [Парсинг html](http://habrahabr.ru/post/164533/)
3. [Манипуляции с DOM](http://habrahabr.ru/post/164677/)
4. Атрибуты, свойства, данные | https://habr.com/ru/post/164805/ | null | ru | null |
# Говорить нельзя молчать: от яслей до офиса
Неопределенность — всегда неудобно. Особенно это напрягает на работе, где со всех сторон ожидается продуктивность, многозадачность и прочий позитив. Типичная ситуация: сотрудник не знает и тревожится, а руководитель загружен и ему не до ответов. А бывает наоборот: информации так много, что сотрудник её пугается. И для айтишника это более узнаваемая ситуация. Но «недо» или «пере» — все равно тревога.
Убить неопределенность: немного теории
======================================
Мир наш — всё же хаос, и мысль об этом доводит людей до самоубийств. Именно поэтому с самого детства мы пытаемся создать вокруг себя пространство «известных чисел».
Каждый современный родитель знает, что лучший способ иметь спокойного ребенка — это организовать ему рутину. А сюрпризы выдавать только такие, какие он просил. А если нужно что-то поменять, то стоит вместе сделать новый план. И спросить мнения. Хотя бы для вида.
```
— Отличная идея, обязательно сделаем это в следующий раз.
```
И эта схема работает для большинства из нас в любом возрасте. И дома, и тем более на работе. Расскажите мне, поговорите со мной — и я буду спокоен и продуктивен! База. Пиарщикам и маркетологам в формулу добавляют слово «иллюзия». В таком виде оно тоже работает.
К сожалению, этой базе учат не на всех факультетах. И в большинстве случаев нам приходится добираться до определенности самостоятельно: задавать вопросы, тыкаться в «черные ящики», раздражаться от глухонемоты, фантазировать.
> Иногда кажется, что и хаоса-то почти нет, а неопределенность тут как тут. Приходит сотрудник к руководителю и спрашивает: «Какие у меня основные задачи в следующем месяце?». А руководитель ему: «Ну ты чего, мир полон неопределенностей, надо привыкнуть к этому». И это не анекдот.
Детский сад моего ребенка: «недо»
=================================
```
— Почему вы не участвуете в наших конкурсах?
— Почему никто не вызвался на конкурс?
— Почему вы не хотите сдавать на расширение входной группы?
— Почему вы не..?
```
Уже третий год эти вопросы задают в чате воспитатели. И каждый раз какая-то самая нескромная мамочка отвечает: «Ой, а что за конкурс, мы и не знали». А я снова занудно добавляю: «Пожалуйста, информируйте нас об активностях в чат, объявления на стендах мелким шрифтом редко читаются».
Родительские чаты работают уже несколько лет, и это действительно часто удобно. Но задачи, ради которых они создаются (те самые информирование и диалог), решается всегда по-разному.
Есть отличные примеры, я ими горжусь и всем рассказываю. Преподаватель кружка «Вокруг света» после каждого занятия кратко рассказывает, что сегодня изучали дети и какое домашнее задание. Иногда присылает фотографии. И она это делает целый год. Она крутая!
Конечно, я в курсе о загрузке воспитателей. Но ведь при помощи своевременного (!) и полного (!) информирования они куда эффективнее могут привлекать родителей к своим задачам, к задачам группы, без суеты в предпоследний день…
Не нужно еженедельных дашбордов, это вишенки для айтишников. Нужно просто своевременно информировать обо всем важном. И помнить, что своевременно — это, как минимум, два раза: заранее и накануне.
**Что делать?** Основная проблема здесь — это отсутствие этикета работы с чатами. Нет правил. Образовательные учреждения пока еще не успели включить технологии в свои регламенты. Дело времени. Поэтому остается ждать, скромно подсказывать и хвалить первопроходцев.
Управляющая компания моего дома: «недо»
========================================
Стиль управления: мямлить :-) Или игнорировать. Вопросы сыпятся в чат, управляющий отвечает на один из десяти, в официальной группе соц.сети «Вконтакте» отчеты о проделанной работе не выкладываются. Народ тревожится, ведь платежки приходят ежемесячно, а его вопросы игнорятся.
```
— В наших интересах умалчивать информацию, — как бы молча говорит нам наша УК. Ей ничего не говорили про искусство создания иллюзий.
```
Умалчивание всегда создает негатив, из которого рано или поздно рождается революция или какой-то очень прокачанный юрист. Даже если город поделен между УК и это почти монополия.
УК, будь политиком и акцентируй внимание общественности на цвете урны. Главное, чтобы у людей была информация. Чтобы люди знали/считали, что знают о том, что их ждет. Только информация должна быть всегда (!) — разовое отвлечение на урны еще больше нас разозлит.
Вот еще так со мной УК дискутирует:
```
— Кому точно надо, то узнает; увидим героев в лицо.
```
Я идеалист, я предложила своей УК Trello. Trello и ныне там. Хотя вот пресс-секретарь, говорят, в штате есть и конкурсы в VK рубит. Кто-то предлагал Slack. Сегодня протестировала голосование в гугл-опросах. А в субботу таки сходила лично к управляющему, взяла у него интервью и выложила выжимку в чат. Спасение утопающих — дело рук самих утопающих.
Увы, теорию коммуникации не преподают там, где учатся работники ЖКХ, что ж теперь.
Эх, вот бы нам еще Teamer. Базовый, аккуратненький.
**Что делать?** ЖКХ в массе своей — это пока точно не про 21 век, хотя в некоторых хрущевках после капремонта и начинают ставить умные домофоны. Но информирование для них почему-то — это всегда покушение на непрозрачность финансовых потоков, а этого пока совсем никак нельзя. Что делать? Снова: ждать, скромно подсказывать и хвалить первопроходцев.
Моя ИТ-компания: «недо» vs «пере»
==================================
Всё чаще и чаще: «да достали вы меня своими корпоративными порталами, новостями, да еще и в телеграм ко мне лезете!»
И, тсссс, никто уже не помнит, как это было в эпоху «допортала». Потому что было тихо. Кому надо, тот и узнал. И сказал соседу: и понеслось. А если портал уже неделю почти лежит и «зеркала» не работают?!!!
Но наличие портала и стендов, даже геймифицированных, не гарантирует снижения лично-рабочей неопределенности. Потому что:
* **ЧЕЛОВЕЧЕСКИЙ ФАКТОР: «Я ДЕЛО ДЕЛАЮ, А НЕ БОЛТАЮ»**
Бывают такие люди (и они же бывают руководителями, а значит — основными ньюс-мейкерами), которым в силу специфики их характера свойственно присваивать информацию.
Для кого-то ценность — этой информацией поделиться. Так они чувствуют себя полнее, потому что полезны/интересны обществу. А кто-то становится «полнее» от того, что аккумулирует у себя эту информацию. Такие люди выдают ее только по запросу. Иногда — настойчивому. Если такие люди попадают на руководящие и коммуникационные должности, то организовать процесс информирования становится не самой простой задачей.
Еще бывают руководители, которые не видят бизнес-ценности в том, чтобы что-то кому-то сказать. Зачем болтать, дело же движется. А сотрудникам кажется, что их игнорируют.
При этом общий процесс информирования может быть настроен в компании, но человеческий фактор гарантирует пробуксовки.
**Что делать?** Менять ответственного человека. Как правило, отсутствие «чувства информации» не лечится.
* **МУТНОСТЬ БИЗНЕС-ПРОЦЕССА**
Часто все мутности из-за того, что у процесса просто нет владельца: специалиста, который будет формально и неформально «болеть» за эффективность вверенного.
Еще одна частая проблема — это страх перед сложностью организовать сам процесс так, чтобы он действительно был качественным. Описано ли у вас, как работает «черный ящик» с обратной связью?.. А результаты обратной связи видны?.. А вы знаете, какова длительность ключевых контрактов у вашей компании?..
Да, надо смириться, что внедрение процесса информирования может быть дорогим. Как и любого другого. И лучше не изобретать велосипед, а позвать специалистов. Чтобы снизить бюджет.
**Что делать?** Найти владельца для процесса информирования из специалистов по коммуникации и дать ему возможность работать.
* **ПЕРЕГРУЗ ИНФОРМАЦИЕЙ**
Есть большой соблазн настроить процесс информирования один раз и больше его не менять. На изменения в инфосистеме компании с трудом идут прежде всего владельцы бюджета: какая бизнес-ценность в замене зеленых кнопок на красные? В итоге весь визуал и инструментарий сотруднику приедается, а информации с каждым днем становится всё больше. В результате сотрудник просто выключается из потока, игнорируя всё.
```
— Ну тут же написано! — взывать к совести бесполезно, потому что мозг уже фатально устал.
```
**Что делать?** Менять эргономику и чистить контент. Регулярно. Начать с того, что развести информацию на обязательный минимум и всё другое. Вспомнить, что старое доброе каскадирование работает лучше любого портала.
> **ГИГИЕНИЧЕСКИЙ ИНФОУРОВЕНЬ ДЛЯ КОМПАНИЙ <100 СОТРУДНИКОВ**
>
>
>
> В маленьких компаниях руководитель — основное селебрити, владелец бюджетов и большой пример. Поэтому стоит попытаться включить его в процесс информирования на всех уровнях.
>
>
>
> Что делать идеальному руководителю?
>
>
>
> — Вещать: где бизнес был, где сейчас, куда движемся, почему и зачем всё это движение.
>
> — Рассказывать, что конкретного может сделать сотрудник для бизнеса.
>
> — Задавать сотруднику вопрос о том, как тот видит бизнес и себя в бизнесе.
>
>
>
> Всё это регулярно. По итогам вещания публичный meeting notes в виде todo-листа.
>
>
>
> А чтобы это было, нужно пройти 3 шага. Эти шаги могут сделать только фанаты-коммуниканты (по должности или темпераменту).
>
>
>
> 1. Понять, почему руководитель не хочет/не может оценить мощь информирования + донести до него эту ценность.
> 2. Определить формат для информирования и диалога (и владельцев этих активностей!):
>
> — ежемесячные/ежеквартальные встречи-отчеты;
>
> — блог/новости;
>
> — видеоконференции.
> 3. Определить формат оказания внимания сотруднику:
>
> — 1 on 1;
>
> — обеды/курилка;
>
> — «горячие линии».
>
>
>
> Да, снова про базу, извините. К чему мне ваша геймификация с конкурсами, если я не знаю, что с моим проектом через месяц?
Резюме
=======
Чувство неопределенности — это всегда про стресс. Где бы мы его ни словили: дома, на работе, в поисках ценника на заставленной витрине. И мы постоянно ищем золотую середину между «молчать» и «тараторить».
В целом, далеко не везде нужны навороченные и сложно разветвленные порталы и трекеры. Очень часто нужно просто ОДНО специальное место с функциями «публиковать» и «комментировать». Еще «голосовать» бы. И время от времени смотреть на инструмент свежим взглядом и подкручивать. Ну и того, кто бы всё это любил.
Короче, ищу простенький сервис для этих трех задач. Чтоб и в айтишный стартап, и в садик, и в ТСЖ. Закидайте ссылками, пожалуйста! | https://habr.com/ru/post/461771/ | null | ru | null |
# Готовим ASP.NET5, выпуск №2 – повторим азы для самых начинающих
Друзья, перед вами второй выпуск колонки про ASP,NET5, в которой мы знакомимся с разными интересными вещами из мира веб-разработки на новой версии открытой платформы ASP.NET5.
В прошлый раз мы говорили про новые подходы в работе со статическим контентом на платформе. В комментариях возникло предложение поговорить в следующих выпусках про азы для веб-разработчиков, которые только начинают пользоваться ASP.NET и погружаться в тему. Мы прислушались к вам и предлагаем в этом выпуске материал от **Андрея Веселова** ( [StealthDogg](https://habrahabr.ru/users/stealthdogg/)) – эксперта веб-разработки, автора множества статей по теме ASP.NET и Microsoft MVP.
Встречайте введение в азы ASP.NET5 – контроллеры, представления и модели.
> **Примечание.** Данная статья актуальна для финальной версии Visual Studio 2015 с ASP.NET5 Beta5. Для обновления на новые версии ASP.NET воспользуйтесь примечаниями к релизу.
>
>
### Работа с контроллерами
Давайте посмотрим на работу контроллера и действий шаблона MVC на примере небольшого веб-приложения.
> [](https://github.com/vyunev/AspColumnControllerDemo)**Совет!** Вы можете попробовать все самостоятельно или загрузив исходный код из GitHub [https://github.com/vyunev/AspColumnControllerDemo](https://github.com/vyunev/AspColumnControllerDemo "https://github.com/vyunev/AspColumnControllerDemo").
#### Создаем проект
Для этого создадим проект ControllerDemo (Рис.1).
*Рис.1 – Создание проекта веб-приложения ASP,NET5*
В настройках проекта выберем шаблон Empty из раздела ASP.NET 5 Templates (Рис. 2).
*Рис.2 – Выбор шаблона веб-приложения*
После создания проекта в Solution Explorer будут отражены следующие элементы (Рис. 3).
*Рис.3. – Структура шаблона*
Теперь необходимо подключить ASP.NET MVC 6 в проект.
1. В файле project.json укажем зависимость от библиотеки Microsoft.AspNet.Mvc.
```
"dependencies": {
"Microsoft.AspNet.Server.IIS": "1.0.0-beta5",
"Microsoft.AspNet.Server.WebListener": "1.0.0-beta5",
"Microsoft.AspNet.Mvc": "6.0.0-beta5"
},
```
2. Затем необходимо включить ASP.NET MVC 6 в конвейер Owin для обработки запросов и настроить маршрутизацию. Для этого в файле Startup.cs добавим следующие строки:
```
public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
}
public void Configure(IApplicationBuilder app)
{
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller}/{action}/{id?}",
defaults: new { controller = "Home", action = "Index" });
});
}
}
```
Проект подготовлен и можно приступать к созданию контроллеров и действий.
#### Контроллеры и действия
Как правило, контроллеры размещают в специальной папке Controllers. ASP.NET MVC 6 позволяет использовать и другие папки, т.к. ищет их по базовому классу. Однако в данном примере остановимся на классическом варианте расположения файлов. С помощью контекстного меню создадим папку Controllers ("Add > New Folder") и в нее новый класс HomeController ("Add > New item… " и выберем Class).
> **Примечание.** Имя класса контроллера всегда состоит из имени контроллера (в данном случае "Home") и окончания "Controller".
>
>
> **Совет.** В дальнейшем для создания контроллеров можно использовать готовый шаблон MVC Controller Class. Но сейчас, в целях изучения, создадим обычный пустой класс.
>
>
Базовым классом для всех контроллеров веб-приложения является Controller. Поэтому унаследуем созданный класс от него:
```
public class HomeController : Controller
{
}
```
Класс Controller является не только маркером контроллеров, но предоставляет основную функциональность для работы с полученным запросом и формирования ответа. В данный момент стоит отменить такие его свойства, как:
* ViewBag и ViewData — предназначены для передачи произвольных данных в представления;
* Request — содержит данные исходного запроса;
* Response — позволяет создать ответ для клиента.
Кроме того, он предоставляет рад полезных методов, которые будут рассмотрены чуть позднее.
За непосредственную обработку запроса в контроллере отвечает действие, к котором можно выделить следующие части:
1. Указание конкретного типа запроса, используя атрибуты *[HttpGet], [HttpPut], [HttpPost], [HttpPatch], [HttpDelete].* Так же можно указать несколько типов, используя [HttpMethod]. При этом запросы остальных типов будут игнорироваться. Если атрибуты отсутствуют, то действие будет вызвано для любого запроса.
2. *Результат действия* — его тип это реализация IActionResult. Все действия должны вернуть экземпляр класса, реализующий указанный интерфейс. По сути, он отвечает за формирование ответа, который будет отправлен клиенту. Это может быть HTML страница, файл, переадресация или код ошибки.
Базовый класс Controller содержит методы, подходящие в большинстве стандартных случаев:
1. View() — создание ответа (html-страницы) с использованием представления;
2. Content() — предназначен для передачи произвольной текстовой строки клиенту, например, это может быть сгенерированный CSS или JavaScript;
3. File() — позволяет вернуть клиенту файл;
4. Json() — преобразует объект к формату JSON и возвращает его клиенту;
5. Redirect(), RedirectPermanent(), RedirectToAction(), RedirectToRoute() — переадресуют клиента по новому адресу.
3. *Название действия*, по которому будет происходить его вызов. По умолчанию считается, что строка запроса соответствует формату: [www.site.com//](http://www.site.com/%3cController%3e/%3cAction%3e)
4. Метод действия может иметь параметры. Значения для них ASP.NET MVC постарается взять из строки запроса. Сопоставление параметров действия и запроса осуществляется по именам.
5. И наконец, тело метода, в котором подготавливаются необходимые данные и возвращается результат.
Настало время добавить первое действие — Index:
```
public class HomeController : Controller
{
// GET: /Home/
public IActionResult Index()
{
return this.Content("Hello ASP.NET MVC 6.");
}
}
```
Если теперь запустить веб-приложение, то заданная строка "Hello ASP.NET MVC 6." будет отображена в браузере.
Давайте разберем что именно произошло:
* Браузер отправил на сайт запрос вида <http://localhost:[port]/>
\* Примечание: Порт для запуска в режиме отладки автоматически выбирается при создании проекта из свободных.
* Поскольку ни контроллер, ни действие явно не указаны, то маршрутизация ASP.NET MVC использует варианты заданные по умолчанию: Home и Index.
* Был создан экземпляр класса HomeController.
* У него было найдено и выполнено действие Index.
* Метод Index() вызвал метод Content() для формирования ответа, состоящего из указанной строки.
* Механизм ASP.NET MVC получил ответ и переслал его браузеру клиента.
* Браузер отобразил полученную в качестве ответа строку.
Если запрашиваемый контроллер или действие не будут найдены, то будет отправлен ответ "404. Страница не найдена".
Немного усложним и создадим конструктор класса и еще одно действие:
```
public class HomeController : Controller
{
private readonly string _time;
public HomeController()
{
this._time = DateTime.Now.ToString("G");
}
// GET: /Home/
public IActionResult Index()
{
return this.Content("Hello ASP.NET MVC 6");
}
// GET: /Home/Echo/
public IActionResult Echo(string message)
{
return this.Content($"{this._time} > {message}");
}
}
```
Теперь в качестве ответа будет возвращаться время создания контроллера и переданная в запросе строка. Это позволит убедиться, что новый экземпляр HomeController создается при каждом запросе.
Для вызова созданного действия необходимо обратиться по пути, включающий имена контроллера и самого действия. Запустим веб-приложение и введем в браузере следующий адрес:
<http://localhost:[port]/Home/Echo?message=Hello>
#### Асинхронность — это просто
Рассмотрим, как легко ASP.NET MVC 6 позволяет создавать асинхронные методы. Переделаем действие Echo. Для симуляции вызова некого асинхронного метода воспользуемся Task.Delay():
```
public async Task Echo(string message)
{
await Task.Delay(100);
return this.Content($"{this.\_time} > {message}");
}
```
Потребовалось только заменить тип результата с IActionResult на Task и добавить модификатор async. Такое действие может использовать вызовы асинхронных методов, например, для обращения к различным источникам данных или сервисам.
#### Немного практики
И в завершении, два небольших практических задания:
1. Напишите действие, так же выводящее значение параметров, но которые передаются запросе только типа POST.
> **Подсказка.** Для формирования запроса можно использовать обычную HTML страницу с формой. Её файл разместите в уже существующей папке wwwroot, которая предназначена для любого статического содержимого сайта (html страницы, файлы и т.д.)
>
>
2. Создайте действие, которое отвечает только на Get запрос и:
* возвращает файл;
* возвращает объект в формате Json (для простоты можно использовать анонимный класс);
* переадресует на другую страницу.
И не спешите заглядывать в приложенный исходный код, где есть все решения. Постарайтесь сделать это самостоятельно.
### Работа с представлениями
Перейдем к рассмотрению следующей составляющей шаблона MVC — представлений.
> [](https://github.com/vyunev/AspColumnViewDemo)**Совет!** Вы можете попробовать все самостоятельно или загрузив исходный код из GitHub [https://github.com/vyunev/AspColumnViewDemo](https://github.com/vyunev/AspColumnViewDemo "https://github.com/vyunev/AspColumnViewDemo").
#### Создаем веб-приложение с представлением
Для этого создадим пустое ASP.NET MVC веб-приложение ViewDemo, аналогично тому как это было сделано в предыдущей части. Только в этот раз контроллер HomeController будет выглядеть следующим образом:
```
public class HomeController : Controller
{
// GET: /Home/
public IActionResult Index()
{
return this.View();
}
}
```
Метод View() создает результат действия, используя представление. Попробуем запустить проект и сразу получим сообщение об ошибке, т.к. в проекте еще нет представления для действия Index (Рис. 4).
*Рис.4 – Сообщение об ошибке при отсутствующем представлении*
Если внимательно прочитать текст сообщения, то можно заметить, что для представлений существует четко определенное место в структуре проекта. Это папка Views. В ней размещаются вложенные папки с именами соответствующими именам контроллеров. В данном примере это будет Home. И уже в ней хранятся файлы представлений, имена файлов которых, в общем случае, совпадают с названиями действий, для которых они предназначены.
Кроме того, есть специальная папка Views/Shared. В ней размещаются представления доступные для любых действий в проекте.
Создадим указанные выше папки Views и Home. После этого, в последней, с помощью пунктов контекстного меню "Add > New Item …", добавим представление (MVC View Page) с именем Index.cshtml. Расширение cshtml показывает что будет использоваться язык разметки Razor. В результате проект будет выглядеть следующим образом (Рис. 5):
*Рис.5 – Структура проекта с новым представлением*
Добавим в Index.cshtml следующий код:
```
View Demo
=========
```
Запустим веб-приложение. При этом произойдет следующее:
1. Будет вызвано действие Index контроллера Home (как это было описано в предыдущей статье).
2. В действии Index, метод View() будет использовать представление View/Home/Index.cshtml для создания результата (экземпляра класса реализующего IActionResult).
3. Результат действия сформирует HTML код в ответ клиенту (в методе ExecuteResultAsync интерфейса IActionResult).
4. Созданная страница будет отправлена клиенту и отображена его браузером.
Метод View() ищет представление, используя следующие пути:
1. Сначала View/<Имя контроллера>/<имя действия>.cshtml
2. Затем View/Shared/<имя действия>.cshtml
Если оба поиска ничего не принесли, то выводится сообщение об ошибке.
Существует перегрузка метода, позволяющая явно указывать имя представления. Например, вызов
this.View("MyView") будет искать файл View/<Имя контроллера>/MyView.cshtml или View/Shared/MyView.cshtml. Это может быть полезно, например, если действие должно давать различный результат в зависимости от какого-то условия.
Кроме того, существует вариант View(), позволяющий передавать данные в представление. Это будет подробнее рассмотрено далее. А сейчас немного разберем возможности Razor.
#### Язык разметки Razor
Базовые конструкции
Razor допускает следующие конструкции:
* @{ … } — позволяет добавить C# код в тело представления.
* @переменная, @свойство или @метод() — вставляют строковое значение в HTML код. При этом вывод будет экранирован (т.е. если строка содержит теги, то они будут выведены как обычный текст, а не вставлены как теги).
* Разрешены такие управляющие конструкции как:
```
@if { … } else { … }
@switch( … ) { … }
@for( … ) { … }
@foreach( … ) { … }
@while( … ) { … }
```
В них C# код может быть совмещен с HTML кодом, например:
```
@for(int i=0; i<10;i++) {
@i
}
```
Необходимо отметить, что представление по сути является классом, реализующим IRazorPage, со своими свойствами и методами. Например, доступны ViewBag и ViewData, которые содержат значения в которые были добавлены еще в действии.
Так же существует свойство Html, которое предоставляет большое число вспомогательных методов. Вот некоторые из них:
* @Нtml.Raw() — добавляет в HTML код текстовое значение без экранирования.
* @Нtml.CheckBoxFor(), @Нtml.TextBoxFor() и прочие методы для генерации кода различных HTML элементов.
Еще одно вспомогательное свойство — Url. Оно содержит методы для работы с путями в веб-приложении. Наверное, самый востребованный из них это @ Url.Action( … ), который выводит путь до указанного действия указанного контроллера, например: [Home page](@ Url.Action().
Необходимо так же отметить специальный файл Views/\_ViewStart.cshtml. Его наличие не обязательно, но если он присутствует в проекте, то его содержимое выполняется перед каждым представлением. С его помощью можно задать общий для всех представлений шаблон страниц.
#### Шаблоны страниц
Как правило, веб-приложение содержит десятки страниц. Практически каждой из них будет соответствовать свое представление, а значит и свой файл с HTML кодом. При этом многие страницы имеют одинаковый шаблон и различаются лишь частью с основным содержимым (контентом).
Чтобы не вставлять копию HTML кода страницы в каждый файл представления, можно воспользоваться разметкой (layout). Для этого необходимо:
1. Создать файл с общей разметкой в View/Shared
2. В \_ViewStart.cshtml или самом действии указывается файл разметки с помощью свойства Layout.
> *Подсказка: Если шаблон указан и в файле и в представлении, то будет использоваться тот, что задан в представлении. Таким образом можно задать шаблон по умолчанию в \_ViewStart.cshtml, а при необходимости переопределять его в представлении.*
>
>
3. Место, где код представления будет вставлен в шаблон, отмечается вызовом @RenderBody().
Итак, в папке View/Shared создадим файл с шаблоном HTML разметки \_Layout.cshtml (имя может быть произвольным):
```
@this.ViewBag.Title
Menu
@RenderBody()
Footer
```
Так же изменим код представления:
```
@{
this.ViewBag.Title = "Home page";
this.Layout = "~/Views/Shared/_Layout.cshtml";
}
View Demo
=========
```
Как хорошо видно, данный код:
* Создает у ViewBag свойство Title со значением "Home page".
* Устанавливает Layout указывает на используемый шаблон HTML разметки.
Теперь при запуске веб-приложения будет выведена страница с использованием указанного шаблона. В ее заголовок будет вставлена строка "Home page".
#### Секции
Существует возможность для вставки кода из представления в шаблон страницы вне кода блока, создаваемого @RenderBody(). Это секции, которые работают следующим образом:
1. В коде шаблона указываются места для вставки секций с помощью @RenderSection(name, required) или @RenderSectionAsync(name, isRequired). Где name определяет уникальное имя секции, а required — является ли она обязательной.
2. Представления определяют содержимое для секций с помощью конструкции @section name { … }
3. При отсутствии кода для обязательной секции, будет выведено сообщение об ошибке.
Стоит отметить, что секций могут располагаться не только в теле страницы, но и в ее заголовке. Например это можно использовать для подключения внешних JavaScript библиотек, необходимых только на отдельных страницах.
Перейдем к примеру. Определим необязательную секцию в шаблоне страницы
```
@this.ViewBag.Title
Menu
@RenderBody()
Footer
@RenderSection("scripts", required: false)
```
Теперь зададим код для данной секции в представлении. Для наглядности вызовем alert():
```
@{
this.ViewBag.Title = "Home page";
}
View Demo
=========
@section scripts {
alert("Demo");
}
```
Запустим проект и убедимся JavaScript был добавлен на страницу и выполнен.
#### Частичные представления
Еще одна удобная возможность Razor — создание частичных представлений. Это может использоваться как для хранения повторяющихся элементов страниц (всплывающих диалогов, форм и т.д.), так и для логического разделения большой страницы на части.
Использовать частичные представления очень просто:
1. Создать частичное представление как обычное
2. Указать в нем Layout = null, чтобы отменить использование шаблона страницы.
3. Для вставки частичного представления использовать [Html](https://habrahabr.ru/users/html/).Partial() или [Html](https://habrahabr.ru/users/html/).PartialAsync().
Как всегда, перейдем к примеру. В новой папке Views/Shared/Forms создадим файл частичного представления\_ContactForm.cshtml со следующим содержимым:
```
Message: Send
```
Выведем его в представлении Index:
```
@{
this.ViewBag.Title = "Home page";
}
View Demo
=========
@Html.Partial("Forms/_ContactForm")
@section scripts {
alert("Demo");
}
```
Обратите внимание как задан путь до частичного представления. Его поиск идет по общим правилам, и в данном случае путь указан относительно Shared. Файл с ним можно разместить в любой папке внутри View, он при этом надо будет указывать в параметре метода уже полный путь относительно корня сайта. Например, [Html](https://habrahabr.ru/users/html/).Partial("~/Views/Shared/Forms/\_ContactForm")
Остаётся только запустить проект и убедиться в результате.
#### Компоненты представлений (View Components)
Говоря о представлениях, необходимо отменить такое нововведение ASP.NET MVC 6 как компоненты. По сути это развитие идеи частичных представлений путем добавления к ним собственных контроллеров. Однако, прежде необходимо разобраться использованием моделей. И тогда можно будет вернуться к компонентам в следующих частях.
### Работаем с моделями
Созданные в предыдущих частях приложения уже содержат контроллер и представление. Остается рассмотреть как использовать еще один компонент шаблона MVC — модели.
> [](https://github.com/vyunev/AspColumnModelView)**Совет!** Вы можете попробовать все самостоятельно или загрузив исходный код из GitHub [https://github.com/vyunev/AspColumnModelView](https://github.com/vyunev/AspColumnModelView "https://github.com/vyunev/AspColumnModelView").
#### Создаем модель
Воспользуемся созданным в прошлой части приложением ViewDemo и добавим в него работу с моделью.
Для размещения моделей в проекте создадим папку Models. Данное имя является рекомендованным, однако не обязательным. Их код может быть размещен в папках с другими именами. Кроме того, можно использовать вложенные папки для логической группировки классов.
Модель — это простой объект (POCO). Нет необходимости наследовать его от какого-либо класса или реализовывать какой-либо интерфейс. Создадим модель, которая, для примера, будет содержать имя пользователя и текущее время. Для этого добавим в папку Models файл IndexPageModel.cs с следующим кодом:
```
using System;
namespace ViewDemo.Models
{
public class IndexPageModel
{
public string FirstName { get; set; }
public string LastName { get; set; }
public string FullName => $"{this.FirstName} {this.LastName}";
public DateTime CurrentTime { get; set; }
}
}
```
Модель готова. Обратите внимание, что нет ограничений на класс модели. Например, в данном случае присутствует вычисляемое свойство FullName. Однако не стоит увлекаться и переносить логику приложения в модели. Лучше оставлять их максимально простыми, чтобы облегчить дальнейшее сопровождение приложения.
#### Дорабатываем контроллер
Итак, модель уже есть. Необходимо создать ее экземпляр и записать в него какие-нибудь значения. Для простоты воспользуемся константами. Перейдём к контроллеру Home и модифицируем действие Index следующим образом:
```
public IActionResult Index()
{
var model = new IndexPageModel()
{
FirstName = "John",
LastName = "Doe",
CurrentTime = DateTime.Now
};
return View(model);
}
```
Для передачи модели в представление достаточно подставить ее экземпляр в качестве параметра метода View(). В данном примере используются константы для заполнения модели. Разумеется в реальном проекте будет обращение к бизнес-логике приложения и полученный результат будет подставлен в модель.
#### Модифицируем представление
Откроем представление Index.cshtml. В первую очередь необходимо указать, что оно будет использовать определенный класс модели. Для этого в первой строке файла напишем следующее:
*@model ViewDemo.Models.IndexPageModel*
Обратите внимание, что имя класса указано вместе с его пространством имен.
Теперь можно использовать свойство this.Model, в котором будет содержаться переданная модель, указанного типа. Выведем данные на страницу (полный код представления Index.cshtml):
```
@model ViewDemo.Models.IndexPageModel
@{
this.ViewBag.Title = "Home page";
}
Model Demo
==========
**Имя и фамилия:** @this.Model.FullName
**Текущее дата и время:** @this.Model.CurrentTime.ToString()
```
Запустим приложение. При каждом обновлении страницы будет выводиться указанные в контроллере имя, фамилия, а так же текущие дата и время.
Итак, создавать и использовать модели не сложнее чем обычные классы. Всю работу по передачи ее экземпляра в представление берет на себя ASP.NET MVC. Кроме того, в представлении свойство this.Model становится того же типа, что и модель. Это позволяет использовать IntelliSense при создании и редактировании представлений.
### Свежие новости
Как вы уже знаете выпущена Visual Studio 2015 с ASP.NET5 Beta5. Подробности о том, что именно включено в релиз Visual Studio можно почитать в [этом блоге](http://blogs.msdn.com/b/webdev/archive/2015/07/20/announcing-asp-net-4-6-and-asp-net-5-beta-5-in-visual-studio-2015-release.aspx).
Выпущено обновление ASP.NET5 Beta6 с множеством изменений, улучшений и исправлений ошибок. Подробности обновления можно найти [в этом блоге](http://blogs.msdn.com/b/webdev/archive/2015/07/27/announcing-availability-of-asp-net-5-beta-6.aspx). Вы можете загрузить обновление [по этой ссылке](http://www.microsoft.com/en-us/download/details.aspx?id=48222).
Опубликованы [планы](https://www.github.com/aspnet/home/wiki/roadmap) по выпуску релизов платформы в течение ближайших месяцев до выпуска финальной версии ASP.NET5. Согласно им нас ждут версии Beta7 и Beta8, после чего в ноябре мы получим первую версию, готовую к продакшну (RC1), финальная же версия выйдет в первом квартале 2016 года. Подробности каждой версии можно найти [по ссылке](https://github.com/aspnet/home/wiki/roadmap).
[Опубликованы доклады](https://channel9.msdn.com/Events/DevCon/Russia-2015) конференции DevCon 2015, в том числе по веб-разработке и [теме ASP.NET](https://channel9.msdn.com/Events/DevCon/Russia-2015?sort=sequential&direction=desc&term=asp.net#theSessions).
### Полезные ссылки
Самая свежая документация по ASP.NET5 расположена по адресу <http://docs.asp.net/en/latest/>.
Приглашаем вас подключаться к живым трансляциям периодического шоу [ASP.NET 5 Community Standup](https://www.youtube.com/playlist?list=PL0M0zPgJ3HSftTAAHttA3JQU4vOjXFquF), где разработчики из команды Microsoft делятся последними новостями о платформе. Записи доступны [по этой ссылке](https://www.youtube.com/playlist?list=PL0M0zPgJ3HSftTAAHttA3JQU4vOjXFquF).
Познакомьтесь с новой статьей [о разработке ASP.NET-приложений в Visual Studio Code](https://azure.microsoft.com/en-us/documentation/articles/web-sites-create-web-app-using-vscode/) от Эрика Рейтана, в которой подробно изложены интересные аспекты работы с веб-проектами в VS Code.
Изучите основы ASP.NET5 с [новым бесплатным курсом](https://www.microsoftvirtualacademy.com/en-US/training-courses/what-s-new-with-asp-net-5-8478) виртуальной академии Microsoft.
### Авторам
Друзья, если вам интересно поддержать колонку своим собственным материалом, то прошу написать мне на [vyunev@microsoft.com](mailto:vyunev@microsoft.com) для того чтобы обсудить все детали. Мы разыскиваем авторов, которые могут интересно рассказать про ASP.NET и другие темы.
### Об авторе
**Веселов Андрей**
Senior Developer, CodeFirst, Ireland
Сертифицированный разработчик с 15-летним стажем, Microsoft MVP (ASP.Net/IIS). Последние 9 лет занимается веб-разработкой с использованием технологий Microsoft. Сфера основных профессиональных интересов: ASP.NET и Azure. В настоящее время работает в компании CodeFirst в должности Senior Developer. Ведет профессиональный блог.
Twiter: [twitter.com/AndreyVeselov](https://twitter.com/AndreyVeselov)
Facebook: [www.facebook.com/veselov.andrey](https://www.facebook.com/veselov.andrey)
Блог: [andrey.moveax.ru](http://andrey.moveax.ru/) | https://habr.com/ru/post/264271/ | null | ru | null |
# REcollapse: фаззинг с использованием unicode-нормализации
⚠ Дисклеймер ⚠Данный инструмент/метод создан/описан*[/переведён]* исключительно для образовательных и этических целей тестирования. Использование данного инструмента для атаки целей без предварительного взаимного согласия является незаконным. Разработчики *[и переводчики]* не несут никакой ответственности и не отвечают за любое неправильное использование или ущерб, причиненный этим инструментом.
В этом посте я расскажу о технике REcollapse. Я изучал её последние пару лет, чтобы обнаружить до странности простые, но эффективные уязвимости в защищённых объектах. Эта техника может быть использована для захвата учётных записей с нулевым взаимодействием, обнаружения новых обходных путей для брандмауэров веб-приложений и многого другого.
Этот пост преимущественно основан на моём выступлении на [BSidesLisbon 2022](https://bsideslisbon.org/) и посвящён запуску инструмента [REcollapse](https://github.com/0xacb/recollapse), который теперь доступен на GitHub. Это также то, что мы начали исследовать внутри [Ethiack](https://twitter.com/ethiack).
Работа с пользовательским вводом
--------------------------------
Всё начинается с непредвиденного ввода. Современные приложения и API полагаются на валидацию, санацию и нормализацию. Обычно это делается с помощью пользовательских регулярных выражений и широко используемых библиотек, которые проверяют и преобразуют типичные форматы пользовательского ввода, такие как адреса электронной почты, URL и другие.
Вот несколько примеров валидации и санации:
Валидация (Python)
```
>>> re.match(r"^\S+@\S+\.\S+$", "aa.com")
>>> re.match(r"^\S+@\S+\.\S+$", "a@a.com")
```
Санация (PHP)
```
> htmlspecialchars("input'\">alert(1);");
= "input'"><script>alert(1);</script>"
```
Цель всегда состоит в том, чтобы предотвратить сохранение опасного пользовательского ввода. Рассмотрим приложение, которое отвергает специальные символы в `имени` пользователя в конечной точке `/signup`. Злоумышленник не может внедрить полезную нагрузку в `имя`, но это не означает, что в дальнейшем `имя` не будет санировано, что может привести к уязвимостям, таким как XSS. В этом случае мы можем попытаться найти альтернативные конечные точки, которые принимают специальные символы в одном параметре. Именно так я поступил с [@itscachemoney](https://twitter.com/itscachemoney) в 2019 году [в Dropbox](https://dropbox.tech/security/dropbox-bug-bounty-program-has-paid-out-over--1-000-000), или же… мы можем попытаться обойти регулярное выражение "чёрным ящиком", как я покажу ниже в этом посте.
Нормализация же используется для обеспечения единообразия пользовательского ввода. Это удобно для приложений с несколькими учетными записями, чтобы избежать дублирования адресов электронной почты, таких как `a@a.com` / `A@a.COM` / `á@ª.com` и так далее. Разные библиотеки дают различные выходные нормализованные данные, как вы можете видеть в этих примерах, что может быть полезно для определения технологий, используемых бэкендом.
Нормализация (PHP)
```
> iconv("UTF-8", "ASCII//TRANSLIT", "Ãéï°úç");
= "~A'e\"i^0'uc"
```
Нормализация (Python)
```
>>> unidecode.unidecode("Ãéï°úç")
'Aeideguc'
```
Более подробную информацию о нормализации, если вы не знакомы с ней, можно найти здесь: [https://🅂𝖍𝐤ₛᵖ𝒓.ⓜ𝕠𝒃𝓲/🆆🆃🅵/](https://%F0%9F%85%82%F0%9D%96%8D%F0%9D%90%A4%E2%82%9B%E1%B5%96%F0%9D%92%93.%E2%93%9C%F0%9D%95%A0%F0%9D%92%83%F0%9D%93%B2/%F0%9F%86%86%F0%9F%86%83%F0%9F%85%B5/). Однако нормализация в браузере – только вершина айсберга.
В чём проблема?
---------------
Regex обычно заимствуется из StackOverflow, Github или других источников. Разработчики обычно не проверяют их должным образом и иногда вставляют разные регулярные выражения в конечные точки бэкенда. Например, вышеупомянутый регекс `^\S+@\S+.\S+$` не работает правильно при проверке электронной почты:
regex101.comТесты не всегда защищают от ошибок, так как regex может быть специфичен для подмножества возможных случаев. В следующем сценарии инъекция с кавычкой всё ещё проходит через assert:
```
>>> msg = 'Entity "test" is not available'
>>> assert re.match(r'^Entity ".+" is not available$', msg)
>>> msg = 'Entity "">x" is not available'
>>> assert re.match(r'^Entity ".+" is not available$', msg)
================================================================================
```
С GitHub Copilot тоже интересно. Генерация кода для проверки того, является ли URL частью домена из белого списка, даёт следующий результат в Python:
```
def url_is_subdomain(url, domain):
"""Return True if url is a subdomain of domain."""
return re.match(r'^(?:https?://)?(?:[^/]+\.)?%s(?:/.*)?$' % domain, url)
```
Фаззинг этого regex с помощью инструмента REcollapse, представленного ниже, даёт на вход `https://example՟com`, который будет принят как `example.com` в качестве домена, но он преобразуется в `xn--examplecom-ehl` (punycode), что позволяет атакующему обойти валидацию.
Почему нормализация может быть проблемой?
-----------------------------------------
Что касается нормализации, то иногда может возникнуть путаница и дублирование состояний, если нормализация не используется последовательно во всех конечных точках и путях. Допустим, у нас есть жертва с электронной почтой `hildegarde@example.com`. Атакующий может попытаться исследовать все пути с электронной почтой `hil°arde@example.com`.
Нормализация (Python)
```
>>> unidecode.unidecode("hil°arde@example.com")
'hildegarde@example.com'
>>> unidecode.unidecode("victim@exámple.com")
'victim@example.com'
```
Это относится и к доменной части, в результате чего можно получить ссылку восстановления на punycode-домене для `victim@example.com` на `victim@exámple.com`, который разрешается на `victim@xn--exmple-qta.com`, что потенциально может привести к ATO с нулевым взаимодействием.
Это также можно применить к SSO или OAuth, если исходное или целевое приложение нормализует критические идентификаторы, такие как адреса электронной почты.
Мы не одинаковые
----------------
Основные библиотеки regex разных языков программирования могут иметь небольшие различия при обработке одного и того же регулярного выражения. Рассмотрим следующее общее описание знака доллара:
`$` обозначает позицию конца строки или перед терминальным символом в конце строки (если есть)
JavaScript
```
> "aaa".match(/^[a-z]+$/)
[ 'aaa', index: 0, input: 'aaa', groups: undefined ]
> "aaa123".match(/^[a-z]+$/)
null
> "aaa\n".match(/^[a-z]+$/)
null
> "aaa\n123".match(/^[a-z]+$/)
null
```
Python
```
>>> re.match(r"^[a-z]+$", "aaa")
>>> re.match(r"^[a-z]+$", "aaa123")
>>> re.match(r"^[a-z]+$", "aaa\n")
>>> re.match(r"^[a-z]+$", "aaa\n123")
```
Ruby
```
irb(main):001:0> "aaa".match(/^[a-z]+$/)
=> #
irb(main):002:0> "aaa123".match(/^[a-z]+$/)
=> nil
irb(main):003:0> "aaa\n".match(/^[a-z]+$/)
=> #
irb(main):004:0> "aaa\n123".match(/^[a-z]+$/)
=> #
```
Тестирование одних и тех же пар regex и input на разных библиотеках без установки флагов многострочного regex приводит к различному поведению:
Сравнительная таблицаДругая проблема заключается в том, что разработчики обычно хоть и валидируют входные данные, но всё равно используют исходный вариант вместо извлечения совпадающей части. Использование `^` и `$` для проверки начала и конца строки может по прежнему допускать символы новой строки, или же эти проверки могут вовсе отсутствовать.
Техника REcollapse
------------------
Итак, как обойти текущую валидацию или санацию? Кроме того, как мы можем использовать преобразования пользовательского ввода?
Рассмотрим следующий сценарий:
https://example.com/redirect?url=https://legit.example.com ✅
https://example.com/redirect?url=https://evil.com ❌
Мы не можем перенаправить на URL, контролируемый атакующей стороной, с первого взгляда. Перебор полезной нагрузки также не даёт результата. Что мы можем сделать?
* Определить опорные позиции регулярного выражения
+ Начало и конец входной строки
* Определить позиции разделителей
+ До и после специальных символов
* Определить позиции потенциально нормализованных символов
+ Обычно гласные `ª` > `a`
* Фаззить позиции со всеми возможными байтами от %00 до %ff. Здесь вы можете увидеть больше примеров:
* Проанализировать результаты: сортировка по кодам или длине ответов.
### REcollapse
Инструмент REcollapse может генерировать входные данные в соответствии с этими правилами и поддерживает несколько размеров и кодировок подбора. Он также может быть полезен для обхода WAF и слабых средств защиты от уязвимостей. Цель этого инструмента – генерировать полезную нагрузку для тестирования. Фактический фаззинг должен выполняться с помощью других инструментов, таких как [Burp](https://portswigger.net/burp) (intruder), [ffuf](https://github.com/ffuf/ffuf) или подобных. Для перехода любого обхода на новый уровень обычно требуется ручной и творческий подход.
Инструмент опубликован здесь: <https://github.com/0xacb/recollapse>
Ресурсы
-------
Примеры ошибок можно посмотреть на моих слайдах [BSidesLisbon](https://github.com/0xacb/recollapse/blob/main/slides/bsideslisbon_2022_till_recollapse.pdf) или [NahamCon](https://github.com/0xacb/recollapse/blob/main/slides/nahamcon_2022_eu_till_recollapse.pdf).
Видеоролики с более подробными объяснениями были опубликованы на YouTube: [NahamCon 2022 EU](https://www.youtube.com/watch?v=1eLTMKWciic), [BSidesLisbon 2022](https://www.youtube.com/watch?v=nb91qhj5cOE).
Таблица нормализации также доступна здесь: <https://0xacb.com/normalization_table>.
Выводы
------
* Разработчикам: всегда тестируйте и проверяйте свои regex, или полагайтесь на известные библиотеки.
+ Простые модификации ввода могут привести к большому ущербу
* Выполняйте фаззинг путем переворачивания или добавления байтов
+ Тестирование регексов методом "черного ящика" всё ещё не очень распространено
* Поведение регекса может раскрыть информацию о библиотеках и технологиях
* Если что-то валидируется, и вы можете это обойти…
+ Подумайте о влиянии, и вы увидите общую картину!
> Нашли опечатку или неточность в переводе? Выделите и нажмите `CTRL/⌘+Enter`
>
> | https://habr.com/ru/post/714794/ | null | ru | null |
# Разница между асинхронной функцией и функцией, возвращающей промис
Существует небольшая, но довольно важная разница между функцией, которая просто возвращает промис, и функцией, которая была объявлена с помощью ключевого слова **`async`**.
Взгляните на следующий фрагмент кода:
```
function fn(obj) {
const someProp = obj.someProp
return Promise.resolve(someProp)
}
async function asyncFn(obj) {
const someProp = obj.someProp
return Promise.resolve(someProp)
}
asyncFn().catch(err => console.error('Catched')) // => 'Catched'
fn().catch(err => console.error('Catched')) // => TypeError: Cannot read property 'someProp' of undefined
```
Как видите, обе функции имеют одно и то же тело, в котором мы пытаемся получить доступ к свойству аргумента, который не определен в обоих случаях. Единственное различие между этими двумя функциями заключается в том, что **`asyncFn`** объявляется с помощью ключевого слова **`async`**.
Это значит, что JavaScript гарантирует, что функция **`asnycFn`** вернет промис (либо выполнится успешно, либо выполнится с ошибкой), даже если в нем произошла ошибка, в нашем случае блок **`.catch()`** поймает ее.
Однако в случае с функцией **`fn`** движок еще не знает, что функция вернет промис, и поэтому выполнение кода не дойдет до блока **`.catch()`**, ошибка не будет поймана и вывалится в консоль.
Более жизненный пример
----------------------
Я знаю, о чем вы сейчас думаете:
> «Когда же, черт возьми, я совершу такую ошибку?»
Угадал?
Ну, давайте создадим простое приложение, которое делает именно это.
Допустим, у нас есть приложение, созданное с помощью Express и MongoDB, использующее драйвер MongoDB Node.JS. Если вы мне не доверяете, я разместил весь исходный код в [этом репозитории Github](https://github.com/mywebstuff/promise-await-catch), поэтому вы можете клонировать его и запустить локально, но я также продублирую весь код здесь.
Вот наш файл **`app.js`**:
```
// app.js
'use strict'
const express = require('express')
const db = require('./db')
const userModel = require('./models/user-model')
const app = express()
db.connect()
app.get('/users/:id', (req, res) => {
return userModel
.getUserById(req.params.id)
.then(user => res.json(user))
.catch(err => res.status(400).json({ error: 'An error occured' })) // <=== ВОТ ЭТОТ!
})
app.listen(3000, () => console.log('Server is listening'))
```
Внимательно посмотрите на блок **`.catch()`**! Вот где будет (не будет) происходить магия.
Файл **`db.js`** используется для подключения к базе данных mongo:
```
'use strict'
const MongoClient = require('mongodb').MongoClient
const url = 'mongodb://localhost:27017'
const dbName = 'async-promise-test'
const client = new MongoClient(url)
let db
module.exports = {
connect() {
return new Promise((resolve, reject) => {
client.connect(err => {
if (err) return reject(err)
console.log('Connected successfully to server')
db = client.db(dbName)
resolve(db)
})
})
},
getDb() {
return db
}
}
```
И, наконец, у нас есть файл **`user-model.js`**, в котором на данный момент определена только одна функция **`getUserById`**:
```
// models/user-model.js
'use strict'
const ObjectId = require('mongodb').ObjectId
const db = require('../db')
const collectionName = 'users'
module.exports = {
/**
* Get's a user by it's ID
* @param {string} id The id of the user
* @returns {Promise} The user object
\*/
getUserById(id) {
return db
.getDb()
.collection(collectionName)
.findOne({ \_id: new ObjectId(id) })
}
}
```
Если вы снова посмотрите на файл `app.js`, вы увидите, что при переходе по адресу **`localhost:3000/users/`** мы вызываем функцию **`getUserById`**, определенную в файле **`user-model.js`**, передав в качестве запроса параметр **`id`**.
Допустим, вы переходите по следующему адресу: **`localhost:3000/users/1`**. Как думаете, что произойдет дальше?
Ну, если вы ответили: «Я увижу огромную ошибку от MongoClient» — вы были правы. Чтобы быть точнее, вы увидите следующую ошибку: **`Error: Argument passed in must be a single String of 12 bytes or a string of 24 hex characters`**.
И как вы думаете, будет ли вызван блок **`.catch()`** в следующем фрагменте кода?
```
// app.js
// ... код ...
app.get('/users/:id', (req, res) => {
return userModel
.getUserById(req.params.id)
.then(user => res.json(user))
.catch(err => res.status(400).json({ error: 'An error occured' })) // <=== ВОТ ЭТОТ!
})
// ... код ...
```
Нет. Он не будет вызван.
А что произойдет, если вы измените объявление функции на это?
```
module.exports = {
// Обратите внимание, что ключевое слово async должно быть именно тут!
async findById(id) {
return db
.getDb()
.collection(collectionName)
.findOne({ _id: new ObjectId(id) })
}
}
```
Ага, вы начинаете понимать, что к чему. Наш блок **`.catch()`** будет вызван, и мы сможем обработать пойманную ошибку и показать ее пользователю.
Вместо заключения
-----------------
Я надеюсь, что для некоторых из вас эта информация оказалась полезной. Обратите внимание, что этой статьей я не пытаюсь заставить вас всегда использовать асинхронные функции — хотя они довольно крутые. У них есть свои варианты использования, но они по-прежнему являются синтаксическим сахаром над промисами.
Я просто хотел, чтобы вы знали, что иногда промисы могут иметь большое значение, и когда (да, не «если») вы столкнетесь с ошибкой, рассмотренной в этой статье, вы будете знать возможную причину ее появления.
*P.S. Прим. перев.: к оригинальной статье был оставлен полезный комментарий от пользователя Craig P Hicks, который (после замечаний в комментариях) я решил привести тут:*
> Хотел бы обратить внимание на одну деталь, (в моей среде разработки) ошибки, которые происходят в теле **`Promise.resolve({})`** не «ловятся»:
>
>
>
>
> ```
> Promise.resolve((()=>{throw "oops"; })())
> .catch(e=>console("Catched ",e));
> // блок .catch() не срабатывает и ошибка не "ловится"
>
> ```
>
>
> но ошибки, возникающие в теле **`new Promise()`** (*прим. перев.: в оригинале «proper Promise»*), «ловятся»:
>
>
>
>
> ```
> (new Promise((resolve,reject)=>{
> resolve((()=>{throw "oops"})())
> }))
> .catch(e=>console.log("Catched ",e));
> // Catched oops
>
> ```
>
>
> Как насчет этого утверждения:
>
>
>
>
> ```
> async function fn() { }
>
> ```
>
>
> семантически такой вариант эквивалентен этому:
>
>
>
>
> ```
> function fn() {
> return new Promise((resolve,reject)=>{
> resolve({ })
> })
> }
>
> ```
>
>
> Следовательно, фрагмент кода ниже будет отлавливать ошибки, если в будет **`new Promise()`** (*прим. перев.: в оригинале «proper Promise»*):
>
>
>
>
> ```
> function fn() {
> return Promise.resolve({
> ```
>
*Таким образом, чтобы пример из начала статьи «ловил» ошибки в обоих случаях, нужно возвращать в функциях не **`Promise.resolve()`**, а **`new Promise()`**:*
```
function fn(obj) {
return new Promise((resolve, reject) => {
const someProp = obj.someProp;
resolve(someProp);
});
}
async function asyncFn(obj) {
return new Promise((resolve, reject) => {
const someProp = obj.someProp;
resolve(someProp);
});
}
asyncFn().catch(err => console.error("Catched")); // => 'Catched'
fn().catch(err => console.error("Catched")); // => 'Catched'
``` | https://habr.com/ru/post/475260/ | null | ru | null |
# IoT в моей жизни. Как создать умный офис, а также отслеживать рост картофеля у себя в квартире благодаря IoT
Приветствую вас, Хабровчане!
В 2020-м году все мы знаем что такое Интернет Вещей и для чего он нужен. Но как много из нас знакомы с облачными платформами, которые представляют один из наиболее значимых пластов в IoT? Давайте разбираться.
Не секрет, что разношерстность протоколов существенно усложняет процессы подключения умных устройств, их конфигурирования и обработки данных. Подобные проблемы решаются благодаря облачным платформам Интернета Вещей. Сегодня на примере одной из российских платформ Интернета вещей я покажу, как легко подключить устройства с разными протоколами, а также использовать полученную информацию для построения процессов автоматизации.
В платформе, которую я обычно использую для своих задач, уже реализовано взаимодействие с устройствами, работающими по таким протоколам как MQTT, Wialon Combine, Wialon IPS, Galileosky, Modbus и некоторым другим.
Помимо использования представленных протоколов, для устройств, которые не имеют выхода в Интернет, есть возможность написания программных агентов – некоторых посредников между оборудованием и платформой, которые устанавливаются на другом устройстве (например, Raspberry Pi) и соединяются с этим оборудованием.
Допустим, вам требуется обеспечить взаимодействие с устройством, работающим по одному из представленных протоколов. В таком случае будет достаточно совершить три шага:
1. сконфигурировать модель с желаемыми параметрами и командами;
2. создать объект с уникальным идентификатором в платформе;
3. сконфигурировать устройство для подключения к платформе.
Разберем несколько кейсов и посмотрим, как же всё это подключается.
### Кейс №1 Agile-gong
Начну с того, что однажды наша команда всерьез задумалась о том, чтобы автоматизировать рабочие процессы в офисе.
Так, в соответствии с Agile концепцией, в полдень рабочего дня все сотрудники собираются на Daily meeting. Уведомление в Slack о предстоящем собрании в процессе работы легко пропустить да и отвлекаться на часы не очень удобно… Так родилась идея создать Agile-gong – систему автоматизированного звукового оповещения.
Как реализовано? Железо – это NodeMCU (миниатюрный аналог Arduino со встроенным Wi-Fi-модулем), сервопривод и конденсатор. Каждый будний день в 12 часов нужно обеспечить поворот выходного вала сервопривода с ударным оборудованием на конце на угол, достаточный для того, чтобы гонг прозвенел и уведомил всех о подъеме.
Схема подключения железа довольно простая:
Код, зашитый на NodeMCU, обеспечивает:
1. установку Wi-Fi соединения и подключения к платформе по протоколу MQTT;
2. установку начального положения сервопривода в 0 градусов;
3. публикацию сообщений с данными о текущем положении;
4. подписку на команды и поворот сервопривода на угол по команде.
```
#include "Arduino.h"
#include "EspMQTTClient.h" /* https://github.com/plapointe6/EspMQTTClient */
// Servo library
#include
// Object Servo with name myservo
Servo myservo;
int pos;
EspMQTTClient client(
"",
"",
"",
""
);
void setup() {
Serial.begin(9600);
move(0);
}
void onConnectionEstablished() {
Serial.println("connected");
client.subscribe("move", [] (const String& payload) {
int angle = payload.toInt();
if (angle != pos) {
move(angle);
}
client.publish("position", payload);
});
}
void loop() {
client.loop();
}
void move(const int angle)
{
myservo.attach(5);
myservo.write(angle);
delay(800);
myservo.detach();
pos = angle;
}
```
На стороне платформы разработана модель устройства. В ней описываются параметры, которые можно получать от устройства, и команды, которые можно на него отправлять. В интерпретации MQTT-команды – это сообщения для клиента с определенным топиком и данными, в нашем случае в данных находится необходимый угол поворота.
Затем был создан объект с идентификатором, по которому происходит авторизация на платформе. После подключения отображение выглядит следующим образом:
В командах есть вариант отправки команды поворота на угол 0 и 90 градусов.
Теперь необходимо добавить сценарии автоматизации. Создадим автомат, который при наступлении нужного времени будет переходить в состояние поворота на 90 градусов, затем в цикле на конфигурируемое количество повторов совершит необходимое количество ударов и вернется в исходное состояние ожидания 12 часов.
Каждый сценарий автоматизации – это некая блок-схема, задающая логику поведения объекта. Прописав подобный сценарий, можно учитывать все изменения, которые происходят с устройством, и на основании того, какие именно изменения произошли, устройство сможет выполнять соответствующие действия автоматически, без отправки команды пользователем.
Полученный автомат можно использовать не только для конкретно одного устройства.
Например, можно сделать точно такую же систему с гонгом и установить ее еще в одном кабинете вашего офиса. Тогда у вас будет одна и та же модель, два разных объекта и один автомат, запущенный на двух объектах.
### Кейс №2 Датчик углекислого газа
Вторым полезным решением для нас оказалось подключение датчика углекислого газа. Также подключили по MQTT. Опять же, схема сборки железа тривиальная.
Да, кстати, реализацией как первого, так и второго кейса мы занимались в рамках хакатона внутри компании. И никто из нас в работу железа не погружался, да и необходимости в этом не возникало.
Дальше порядок действий такой же. Модель включает параметр ppm (1000 ppm = 0,1% содержания СО2), который передает устройство, но оно не слишком наглядное, поэтому тут же в модели выведен еще один параметр — процент содержания CO2. Он рассчитывается как значение ppm, деленное на 10000.
Здесь вы также можете заметить две команды на включение лампочки. Ее решили использовать для индикации. А управляем мы ей, конечно, из автомата платформы. После подключения устройства отображение параметров следующее. Эти значения принимаются и отображаются в режиме реального времени, но также можно посмотреть прошлые накопленные пакеты в истории или отобразить график изменения параметра за определенный период.
Автомат для этого объекта работает следующим образом. В верхнем состоянии происходит выключение лампочки. В нижнем — запуск таймера на минуту и включение лампочки. Переход из первого состояния во второе происходит по событию получения данных от устройства с выполнением условия, что значение ppm больше 600 единиц. Возврат (переход из второго состояния в первое) происходит по срабатыванию таймера.
У вас может возникнуть два вопроса.
1. А зачем автомат? Не проще ли на самой железке прописать такие условия? Ведь тут все так просто.
2. Зачем тут таймер?
На самом деле, польза от автомата есть даже в таком простом кейсе. Этот датчик с лампочкой на время отладки я положила у себя на столе, и каждый раз, когда приходила на работу, лампочка загоралась, так как значение порога в автомате было довольно низкое. Какое-то время я пробовала разные значения в автомате и в итоге пришла к оптимальному значению в 600 единиц. Для подбора нужного значения мне нужно было просто поменять значение в автомате и сохранить его. Никакой перепрошивки устройства. А если это устройство мы перенесем в кабинет, где нужно поддерживать лучшее состояние воздуха и необходимо частое проветривание, то значение можно опять же просто поменять. Быстро и удобно.
Здесь поставлен таймер на минуту. Это необходимо, чтобы в течение минуты мы находились в состоянии высокого уровня CO2 и не реагировали на то, что какое-то время продолжает приходить высокое значение. Иначе, мы бы постоянно мигали лампочкой, совершая переходы до тех пор, пока состояние воздуха не нормализуется. Вы уже могли догадаться, что сделать переход в начальное состояние можно и по-другому. Также по событию получения данных, но в которых выполняется противоположное условие — ppm<600. Тогда мы будем находиться во втором состоянии ровно до тех пор, пока не придет нормальное значение.
### Кейс №3 СКУД
Наиболее сложным примером будет описание работы с системой контроля и управления доступом, которая представляет собой электронный модуль, предназначенный для управления доступом в помещения, учета времени прохода и событий.
Контроллер обрабатывает информацию, поступающую со считывателя, имеющего выходной интерфейс «Wiegand» и с помощью встроенного реле осуществляет коммутацию исполнительного устройства — электромагнитного замка. У него нет выхода в Интернет и видимой возможности подключения к платформе. Однако у него есть свой протокол обмена данными с компьютером управления, благодаря которому можно отправлять на контроллер команды, такие как считать из контроллера, записать в контроллер, открыть/закрыть замок и другие. Поэтому в данном случае был организован нестандартный подход — использование агента, о котором я упоминала в начале статьи.
Работа по протоколу контроллера была реализована в коде С++ и запущена на исполнение на Raspberry Pi, которая в свою очередь была соединена с контроллером по RS-485 через преобразователь интерфейса. Основная задача программы — осуществить подключение к платформе, сериализировать команды и десериализовать данные, полученные с контроллера. Таким образом, мы смогли с помощью небольшой программной прослойки сделать устройство “умным”.
Модель устройства выглядит следующим образом:
Основная информация с контроллера — это события. На платформу она приходит в формате JSON и включает поля:
* время события,
* код события,
* номер карты сотрудника.
Для разбора JSON-полей по разным параметрам также используется модель.
В интерфейсе объекта это выглядит следующим образом:
А так выглядит интерфейс для отправки команд:
Можно заметить, что есть команда не только на чтение буфера событий, но и на запись новых границ. В памяти контроллера хранятся границы буфера — начало и конец. Когда на устройство приходит команда чтения, считываются эти границы и в этих пределах происходит чтение из буфера событий. Граница конца буфера сдвигается автоматически на контроллере при получении новых событий. А вот начальную границу буфера нужно перезаписать (указав конечную границу после прошедшего чтения), чтобы не прочитать одни и те же данные повторно. Но это необходимо сделать только после того, как данные о событиях были успешно отправлены на платформу. Зафиксировать получение данных и затем отправить команду на перезапись границ также удобно в автомате.
Данный проект нашел свое продолжение в интеграции с нашей внутренней CRM системой, в которой на вкладке информации о сотрудниках всегда видны актуальные сведения о том, кто находится или отсутствует в офисе. Также отображается время входа/выхода из офиса, считается суммарное количество часов в месяц.
Забор данных из платформы производится по RESTful API. API платформы предоставляет возможность работы, взаимодействия и использования сущностей платформы и их данных в таких внешних системах, как веб-порталы, мобильные и веб-приложения или, как в нашем случае, — CRM системах.
Также возникают случаи, когда в компанию пришел гость/доставщик еды или кто-то еще, кому нужно открыть дверь. Чтобы не пользоваться своей картой и тем самым не передать некорректные показания о своем статусе, можно воспользоваться кнопкой “Unlock” на платформе. А если человека нужно встретить у двери, то удобно сделать то же самое из мобильного приложения.
### Кейс №4 Умный огород
Моя личная история с огородом в квартире началась на фоне сумасшедшей паники людей и скупки продуктов. В очередной раз пойдя в магазин и увидев пустые полки там, где должна быть картошка, я решила использовать последнюю найденную картошку в холодильнике не совсем по прямому назначению. Эту картошку я посадила в огромный горшок. С такого наивного эксперимента начался мой огород на подоконнике, который спустя два месяца уже выглядит так:
Так как я не весть какой цветовод, а огороду воды нужно еще больше, чем цветам, довольно быстро я столкнулась с проблемой, что забываю его поливать. Про автоматические системы полива я рассказывать не буду, это слишком заезженная тема, а организовать ее работу качественно довольно сложно. Вместо этого у меня появились следующие идеи:
1. Сделать пуш-уведомление в платформе о том, что влажность почвы у какого-то растения ниже нормы и пора организовать массовый полив каждому по потребностям. Потребности легко понять, установив в каждый горшочек по одному датчику влажности почвы.
2. Сделать аналогичное уведомление о том, что все горшки пора повернуть, так как растения имеют особенность расти по направлению концу, а Солнце только с одной стороны — в окне. То, что я долгое время не поворачивала картошку, привело к тому, что она завалилась на один бок. К тому же она такая огромная, что теперь ее остается только стенкой подпирать.
3. Организовать включение и выключение ультрафиолетовой лампы в темное время суток по планировщику – включать в 18:00, а выключать в 6:00. Сразу хочу заметить, темное время суток — понятие растяжимое в зависимости от времени года. Но мы уже знаем, что для того, чтобы изменить время включения/выключения лампы, достаточно поменять значение в автомате и сохранить его.
Интерфейс будет выглядеть следующим образом:
Автомат для первого случая выглядит следующим образом. Переход в состояние, в котором высылается уведомление, сделан по сложному условию — у одного из растений влажность ниже нормы. Связка между условиями — ИЛИ.
Возврат в исходное состояние происходит по условию — у всех растений влажность почвы выше нормы, связка И.
Автомат для второго случая выглядит следующим образом. Переход осуществляется по планировщику, возврат в исходное состояние — безусловный переход.
И наконец, автомат для последнего случая:
Эти автоматы запущены на одном объекте и работают параллельно.
Пожалуй, это все, что я хотела осветить в своей статье. Основная идея, которую мне хотелось донести, — это то, что работа с платформой Интернета вещей невероятно облегчает создание бизнес-процессов любой сложности, потому что в этом случае нужно изучить всего один интерфейс — интерфейс платформы, который позволяет избежать глубокого погружения в работу железа и его программирования. | https://habr.com/ru/post/504564/ | null | ru | null |
# Установка и сборка образа Angstrom Linux для платы TechNexion Thunder
#### Набор разработчика от TechNexion Thunderpack
Здравствуй уважаемый читатель. Недавно мне довелось поработать с набором для разработчика, тайваньской компании «[TechNexion Ltd](http://technexion.com/)», под названием Thunderpack включающем в себя SOM ([System on module](http://en.wikipedia.org/wiki/Computer-on-module)) [TAO-3530](http://technexion.com/index.php/products/arm-cpu-modules/ti-omap3530/tao-3530) и плату [Thunder](http://technexion.com/index.php/products/arm-cpu-modules/ti-omap3530/thunder).
SOM основан на SoC ([System-on-a-Chip](http://ru.wikipedia.org/wiki/SoC)) [TI OMAP3530](http://ru.wikipedia.org/wiki/Texas_Instruments_OMAP) фирмы Texas Instruments и содержит 256 Мб DDR RAM, 512 Мб NAND Flash, DSP ядро TMS320C64+, а так же может содержать модуль Wireless LAN для поддержки WiFi.
В данном посте я хочу рассказать, про свой опыт работы с данной платой.
И так, начнём.
#### Установка Linux 2.6.37
После беглого прочтения [документации](http://technexion.com/images/downloads/ARM_CPU_Modules/TAO-3530/tao-3530-userguide-097.pdf), сборки и включения Thunder я приступил к установке Linux. Скажу сразу, что через предлагаемый по умолчанию способ установки у меня установить не получилось. Происходил постоянный перезапуск процедуры установки. Поэтому я зашел на сайт TechNexion и скачал, любезно подготовленный и выложенный ими, [образ](http://technexion.com/index.php/support/download-center/arm-cpu-modules/tao-3530) содержащий Linux 2.6.37.
По инструкции указанной в документации (раздел 9.4.1 Create the SD-card with the rescue image in a Windows environment) я подготовил SD-карту для установки Linux 2.6.37 и выполнил установку.
После установки система благополучно загрузилась, но меня ожидало разочарование т.к. сеть не заработала. Начал искать информацию по сетевой карте.
В конце документации на плату приведены схемы на Thunder (раздел 16.2 Thunder baseboard schematics) на схеме видно, что сетевой картой является конвертор USB-Ethernet собранный на контроллере [SMSC LAN9500-ABZJ](http://ww1.microchip.com/downloads/en/DeviceDoc/9500.pdf) фирмы Microchip. Поискав драйвер, в только что установленной системе, я его не обнаружил. Возможно, при сборке его забыли включить.
На сайте TechNexion, помимо готовых образов, выложены исходные коды для сборки образа вручную. Скачав «TAO-3530 Linux 2.6.37 / TI PSP 04.02.00.07 XUKR Source code» оказалось, что драйвер для нужной мне сетевой карты присутствует и включен для сборки. Осталось только пересобрать образ.
#### Сборка образа Angstrom Linux 2.6.37
Сборку образа я выполнял на Ubuntu 12.04, предварительно установив её на VirtualBox. В документации на Thunder разработчики советуют выполнять сборку, используя Toolchain Code Sourcery G++ 2010.09-50 (gcc 4.5.1). Хочу обратить **ВНИМАНИЕ**, что для сборки образа Angstrom Linux 2.6.37, предоставляемого разработчиками TechNexion, следует разворачивать именно **Code Sourcery G++ 2010.09-50**.
Первым делом скачиваем [arm-2010.09-50-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2](ftp://ftp.ru.debian.org/gentoo-distfiles/distfiles/arm-2010.09-50-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2) или с сайта [Mentor Graphics](http://www.mentor.com/embedded-software/sourcery-tools/sourcery-codebench/editions/lite-edition/) и распаковываем в папку /opt/codesourcery.
```
$cd /opt
$sudo mkdir codesourcery
$cd codesourcery
$sudo wget ftp://ftp.ru.debian.org/gentoo-distfiles/distfiles/arm-2010.09-50-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2
$sudo tar xvf arm-2010.09-50-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2
```
Определяем переменные окружения. Для этого в файл /etc/environment дописываем:
```
export ARCH=arm
export CROSS_COMPILE=/opt/codesourcery/arm-2010.09/bin/arm-none-linux-gnueabi-
```
Создаем папку files в корневом каталоге, и копируем в неё исходные коды для создания образа Angstrom Linux 2.6.37.
```
$cd /
$sudo mkdir files
$cd files
$sudo wget http://technexion.com/images/downloads/ARM_CPU_Modules/xukr-20131014-omap3.tar.xz
$sudo tar xvf xukr-20131014-omap3.tar.xz
```
Устанавливаем uboot-mkimage.
```
$sudo apt-get install uboot-mkimage
```
Теперь необходимо перезагрузить систему для того, чтобы работали, нами установленные, переменные окружения.
Осталось подправить конфигурацию ядра для включения необходимых драйверов. Так как я буду собирать образ для платы Thunder, то путь до нужного мне файла конфигурации следующий:
```
/opt/files/xukr-20131014-omap3/kernel/linux-2.6.37-tn/arch/arm/configs/taotdm_defconfig
```
Файл конфигурации нужно открыть в любом удобном редакторе и включить интересующие опции. Я редактировал стандартным редактором файлового менеджера Midnight Commander.
Первое, что я посмотрел в файле конфигурации – это наличие включенного драйвера сетевой карты SMSC95xx.
```
CONFIG_USB_NET_SMSC95XX=y
```
Затем я включил компиляцию usb-serial драйверов.
```
CONFIG_USB_SERIAL=y
```
И включил поддержку самых распространенных чипов usb-serial PL2303 и CP210x.
```
CONFIG_USB_SERIAL_PL2303=y
CONFIG_USB_SERIAL_CP210X=y
```
Закрываем редактор, предварительно сохранив изменения в файле. Теперь всё готово для сборки ядра.
Переходим в каталог xukr-20131014-omap3
```
$cd /opt/files/xukr-20131014-omap3
```
И запускаем скрипт сборки с указанием названия платформы.
```
$sudo ./Build.sh thunder
```
Данный скрипт выполнит построение загрузчика, ядра ОС, копирование всех необходимых файлов в заранее подготовленную файловую структуру и т.п.
Затем очистки исходных кодов от созданных объектных файлов.
```
$sudo ./Clean.sh
```
И скрипт построения образа с указанием названия платформы.
```
$sudo ./mk_nandimg.sh thunder
```
После успешного завершения можете себя поздравить с созданием образа Angstrom Linux 2.6.37. Сам образ будет находиться в папке
/opt/files/xukr-20131014-omap3/build/thunder.
Осталось подготовить установочный SD-диск и установить. Данные действия описаны выше (см. Установка Linux 2.6.37).
После установки собранной системы у меня появилась сеть и поддержка usb-serial устройств.
#### Заключение
Разработчики TechNexion сделали очень удобный процесс сборки и создания образа загрузочного SD-диска не требующий глубоких познаний и опыта по сборке ядра Linux. Подготовленные ими скрипты делают всё в автоматическом режиме.
Единственно, как обычно, документация не успевает за разработчиками. Последний, на момент написания статьи, вариант документации (tao-3530-userguide-097.pdf) содержал описание сборки под старые исходники, который немного отличается.
Спасибо за внимание. В следующей статье я напишу про настройку Eclipse CDT для компиляции программ под arm, запуск приложения на Thunder и отладку программы в Eclipse.
До встречи. | https://habr.com/ru/post/218991/ | null | ru | null |
# Новинки ноября в Opera: версия для планшетов и синхронизация
Сегодня мы хотим рассказать про наши ноябрьские новинки последних дней: новую версию Opera 18 для компьютеров, мобильную Opera 18 для планшетов и обновление Opera Developer 19 — теперь с синхронизацией!
#### Opera 18 для компьютеров
Вместе с очередным циклом обновления Opera для компьютеров, в стабильную версию 18 приехали многие приятные обновления, которые вы могли заметить в Next- и Developer-сборках:
##### Поддержка тем оформления для браузера
В разделе `opera://themes` вы можете управлять встроенными темами и добавлять новые из [каталога расширений Opera](https://addons.opera.com/ru/themes/). Моя самая любимая — [Multicolor Clouds](https://addons.opera.com/en/themes/details/multicolor-clouds/). Подробнее о создании тем читайте в статье «[Themes in Opera 18+](http://dev.opera.com/articles/view/themes-in-opera-18-and-higher/)» на Dev.Opera. Кстати, в Opera 19 на этой же странице появился интерфейс для создания тем прямо в браузере.
На картинке фотография нового офиса Opera Software в Осло, из неё получается отличная осенняя тема.
##### Перетаскивание вкладок между окнами
Теперь вы можете легко перетащить вкладку из одного окна в другое — просто потяните за неё и перенесите в другое окно.
##### Управление поисковыми системами
Кроме списка встроенных поисковиков, вы теперь можете добавлять собственные, назначая для них префиксы, например: **d** для [duckduckgo.com](http://duckduckgo.com).
Теперь достаточно набрать *d пластиковые окна купить* и результат откроется в нужном поисковике, сайте или севисе переводов.
##### WebRTC с камерой и микрофоном
Теперь, когда доступ к `getUserMedia` включён по умолчанию, для работы с камерой и микрофоном вашего устройства больше не нужны плагины или другой софт — всё это умеет браузер.
Интерфейс `getUserMedia` — это часть WebRTC, бесплатного и открытого проекта, который создаёт коммуникацию в реальном времени (Real-Time Communications, RTC) между браузерами с помощью простого JavaScript API.
Убедитесь сами:
* Пригласите друзей в чат [Appear.in](http://appear.in), простую систему видеоконференций на основе WebRTC, которая работает в последних версиях Opera, Chrome и Firefox. Читайте подробнее про [appear.in, WebRTC и AngularJS](http://comoyo.github.io/blog/2013/08/05/video-meetings-in-the-browser-using-webrtc-and-angularjs/).
* Сыграйте в игру [FaceKat](http://shinydemos.com/facekat) с помощью головы! В ней, помимо `getUserMedia`, для определения положения головы используется библиотека [headtrackr](https://github.com/auduno/headtrackr).
* Сделайте пару луков в стиле фотобудки на [Webcam Toy](http://webcamtoy.com/) с помощью `getUserMedia` и WebGL.
Читайте подробнее про техническую сторону `getUserMedia` на Dev.Opera в статье «[Media Capture in mobile browsers](http://dev.opera.com/articles/view/media-capture-in-mobile-browsers/)».
Также обратите внимание, что во время доступа к аудио или видео, на соотв. вкладке появляется значок, напоминающий, что вы что-то транслируете. Даже если вы в этот момент находитесь в другой вкладке, а значит вас случайно не застанут за задумчивым ковырянием в носу.
##### Больше API для расширений
* [chrome.permissions](http://dev.opera.com/extension-docs/permissions.html), [см. руководство](http://dev.opera.com/extension-docs/tut_optional_permissions.html)
* [chrome.browsingData](http://dev.opera.com/extension-docs/browsingData.html), [см. руководство](http://dev.opera.com/extension-docs/tut_removing_browsingdata.html)
* [chrome.contentSettings](http://dev.opera.com/extension-docs/contentSettings.html) [см. руководство](http://dev.opera.com/extension-docs/tut_contentsettings.html)
* [chrome.devtools.inspectedWindow](http://dev.opera.com/extension-docs/devtools.inspectedWindow.html)
* [chrome.devtools.network](http://dev.opera.com/extension-docs/devtools.network.html)
* [chrome.devtools.panels](http://dev.opera.com/extension-docs/devtools.panels.html)
* [chrome.omnibox](http://dev.opera.com/extension-docs/omnibox.html), [см. руководство](http://dev.opera.com/extension-docs/tut_omnibox.html)
* [chrome.pageCapture](http://dev.opera.com/extension-docs/pageCapture.html)
* [chrome.privacy](http://dev.opera.com/extension-docs/privacy.html), [см. руководство](http://dev.opera.com/extension-docs/tut_privacy.html)
* [chrome.types](http://dev.opera.com/extension-docs/types.html)
* [API режима сжатия для расширений](http://dev.opera.com/extension-docs/tut_offroad.html), доступный через `chrome.types`
Читайте подробнее про API для расширений Opera 15+ [в документации](http://dev.opera.com/extension-docs/index.html).
#### Мобильная Opera 18 для планшетов
Младшая, но не менее способная, мобильная Opera тоже обновилась до версии 18 и, кроме исправлений и оптимизаций, получила новый интерфейс для планшетников со вкладками, экспресс-пенелью, режимом сжатия и рекомендациями:
Новая версия приедет к вам, как обычно, в виде обновления [из Google Play](https://play.google.com/store/apps/details?id=com.opera.browser).
#### Opera Developer 19 с синхронизацией
Выход новой стабильной версии Opera для нас — это не только повод показать широкой публике всё, что наконец стало окончательно готово, но и возможность отправить в ветку Developer кое-что совсем новое. Всё новое подряд можно прочитать в [полном списке изменений](http://blogs.opera.com/desktop/changelog19/#b1324.0), а вот самое интересное:
##### Синхронизация
Самая большая новость последнего обновления Opera Developer — это первый работающий интерфейс для синхронизации ваших данных, ранее известный как Opera Link. Теперь вы можете попробовать новую синхронизацию, предварительно включив во флагах `opera://flags#sync`. На данном этапе синхронизируется только эспресс-панель, копилка и ваши поисковые системы, дальше будет больше.
**Обратите, пожалуйста, внимание:**
1. Сервера синхронизации работают в бета-режиме, поэтому ваши данные могут пропасть, повредиться или вовсе перестать обновляться. Пока лучше иметь локальную копию всего, что у вас есть. А если что-то пойдёт не так, то будем рады вашим [подробным багрепортам](https://bugs.opera.com/wizarddesktop/).
2. Лучше не включать синхронизацию в версиях до 19-й, всё равно ничего хорошего не выйдет.
##### Статистика
Возможно Opera Developer попросит вас отправлять нам некоторую статистику использования браузера для того, чтобы сделать браузер ещё лучше. Собранная информация покажет нам как часто вы пользуетесь браузером, как его настраиваете и какие возможности используете. Эти данные помогут нам направить разработку в нужное русло. И, конечно же, никаких персональных данных, вроде имени, положения, IP или посещённых ссылок — всё анонимно и только для развития браузера.
За тем, что будет дальше по-прежнему можно следить [в блоге команды Десктопа](http://blogs.opera.com/desktop/) или здесь, в нашем блоге на Хабре. | https://habr.com/ru/post/202918/ | null | ru | null |
# Создаём процедурные глобусы планет
*Искажения, бесшовный шум и как с ними работать.*
### Генерируем планету
Один из простейших способов генерации планеты — использование шума. Если мы решим выбрать его, то у нас есть пара возможных вариантов. Давайте рассмотрим каждый и определим лучший:
* **Шум Перлина (Perlin Noise)** — самый простой вариант. Шум Перлина был разработан Кеном Перлином в 1983 году, он имеет пару недостатков — визуальные артефакты и довольно низкая по сравнению с другими вариантами скорость при генерации больших изображений.
* **Симплекс-шум (Simplex Noise)** — разработан Кеном Перлином в 2001 году как попытка устранения недостатков шума Перлина; это вполне достойное и быстрое решение, однако обладающее серьёзным недостатком: использование трёхмерного симплекс-шума защищено патентом, что делает его довольно дорогостоящим.
* **Открытый симплекс-шум (Open Simplex Noise)** — был разработан [KDotJPG](http://uniblock.tumblr.com/post/97868843242/noise) с одной простой целью: создать современную и бесплатную версию симплекс-шума, относительно быструю и без искажений.
Из этих трёх лично я предпочитаю Open Simplex Noise, который использую в своих личных проектах. Стоит заметить, что в текущей реализации OpenSimplexNoise для получения простого доступа к [масштабу, октавам и порождающим значениям](http://libnoise.sourceforge.net/glossary/index.html) потребуется дополнительная работа. В Интернете есть множество информации о том, что делает каждый из этих элементов, и я крайне рекомендую вам её изучить. Однако в своей статье я буду говорить не об этом.
*Вот как выглядит Open Simplex Noise с 16 октавами.*
### Бесшовный шум
Шум бесконечен, а значит, если мы просто создадим холст с соотношением сторон 2:1, чтобы получить [равнопромежуточную проекцию](https://en.wikipedia.org/wiki/Equirectangular_projection), то она не будет зацикленной при [наложении на сферу](https://www.maptoglobe.com/) (выражаю благодарность этому потрясающему веб-сайту), а на горизонтальном шве и на полюсах будут огромные отличия.
*Шум, созданный без учёта швов.*
*Заметьте огромные швы, появившиеся при наложении шума на сферу.*
Исправить это можно множеством способов; например, [в этом отличном посте](https://www.redblobgames.com/maps/terrain-from-noise/) Red Blob Games *[[перевод](https://habr.com/ru/post/430384/) на Хабре]* достаточно было просто сгенерировать остров с помощью функции, получающей в качестве переменной расстояние до центра и и задавая на краях высоту 0 для минимизации швов.
Однако нам нужно не это. Мы хотим сгенерировать планету с возможностью существования северного и южного полюсов, а для этого нам понадобятся более сложные математические вычисления.
#### Сферическое наложение
Метод, способный генерировать сферические планеты, заключается в преобразовании декартовых координат нашего холста в сферические координаты, генерации шума на основании этих координат, а затем в преобразовании шума в обратно в декартовы координаты и наложении его на холст.
Однако такая реализация имеет свои ограничения, причины возникновения которых показаны в [потрясающем посте Рона Валстара](http://ronvalstar.nl/creating-tileable-noise-maps). Самое главное — формы континентов в этом случае выглядят чрезвычайно странными и искажёнными, а поэтому мы не будем использовать этот вариант.
*Сферическое наложение шума. Странные формы и искажения делают континенты довольно уродливыми.*
*Зато, по крайней мере, швов больше нет.*
#### Кубическое наложение
В результате я использовал второй способ, взятый из поста Рона Валстара и серии статей acko [Making Worlds](http://acko.net/blog/making-worlds-introduction/). В них описывается генерация глобуса через генерацию куба и его «надувания», как будто он воздушный шар, до тех пор, пока он не пример форму сферы.
*Изображение взято с acko.net. Оно объясняет концепцию кубической карты в простом для визуализации виде.*
Теперь нам нужно просто сгенерировать шесть граней, что достаточно просто, есть множество способов сделать это.
В конце концов я решил создать массив и заполнить его данными. Я преобразовал 2D-координаты холста в 3D-координаты куба, а затем сгенерировал шум для каждой из этих 3D-координат так, чтобы сохранить их в соответствующее значение 2D-координаты.
```
//Z STATIC
for(int y = 0; y < cubeFaceSize; y++) {
for(int x = 0; x < cubeFaceSize * 2; x++) {
//Generates FRONT
if(x < cubeFaceSize) {
cubeMap[cubeFaceSize+x][cubeFaceSize+y] = noise.noise3D(x, y, 0);
}
//Generates BACK
else {
cubeMap[cubeFaceSize*3+(x-cubeFaceSize)][cubeFaceSize+y] = noise.noise3D(cubeFaceSize-(x-cubeFaceSize), y, cubeFaceSize);
}
}
}
//X STATIC
for(int y = 0; y < cubeFaceSize; y++) {
for(int x = 0; x < cubeFaceSize * 2; x++) {
//Generates LEFT
if(x < cubeFaceSize) {
cubeMap[x][cubeFaceSize+y] = noise.noise3D(0, y, cubeFaceSize-x);
}
//Generates RIGHT
else {
cubeMap[cubeFaceSize*2+(x-cubeFaceSize)][cubeFaceSize+y] = noise.noise3D(cubeFaceSize, y, x-cubeFaceSize);
}
}
}
//Y STATIC
for(int y = 0; y < cubeFaceSize * 2; y++) {
for(int x = 0; x < cubeFaceSize; x++) {
//Generates TOP
if(y < cubeFaceSize) {
cubeMap[cubeFaceSize+x][y] = noise.noise3D(x, 0, cubeFaceSize-y);
}
//Generates BOTTOM
else {
cubeMap[cubeFaceSize+x][cubeFaceSize*2+(y-cubeFaceSize)] = noise.noise3D(x, cubeFaceSize, y-cubeFaceSize);
}
}
}
```
Таким образом мы можем создать кубическую карту, которая легко преобразуется в равнопромежуточную проекцию [с помощью замечательного кода, написанного Bartosz](https://stackoverflow.com/a/34427087/10560850).
*Сгенерированная алгоритмом кубическая карта.*
*Равнопромежуточное преобразование кубической карты.*
*Глобус кубической карты, отрендеренный на сайте [maptoglobe.com](https://www.maptoglobe.com/).*
Как видите, равнопромежуточная карта имеет гораздо более красивые формы, а при наложении на сферу она создаёт схожие со сферическим наложением результаты, не имея всех его недостатков. Кстати, равнопромежуточную проекцию можно легко преобразовать разными программами, например, [NASA G.Projector](https://www.giss.nasa.gov/tools/gprojector/), в практически любой тип карты.
В заключение
------------
Генерация целой планеты может показаться устрашающей задачей, и хотя шум при его правильном использовании — это довольно мощный инструмент, он имеет свои проблемы, с которыми люди сталкивались на протяжении многих веков, например, наложение глобуса на 2D-холст с минимальными искажениями.
Предложенное мной решение создаёт очень грубо сгенерированные планеты, не учитывающие тектонических плит, рек, цепочек островов и даже гор, а потому его можно использовать только в качестве демонстрации или как основу для более сложных симуляций.
На самом деле, оно создаёт только матрицу значений в определённом интервале величин. Для изображений в градациях серого это интервал 0-255. Затем значения преобразуются в пиксель, создающий изображение, схожее с первым изображением в градациях серого, или в изображение в интервале от -11000 до 8000 для симуляции разности высот реального мира, после чего пиксели окрашиваются цветами в соответствии с интервалами высот *(например, значения с 0 по 5 окрашиваются в цвет песка для симуляции побережья)*.
> При построении Вселенной Бог использовал математику высшего уровня.
>
>
>
> *— Поль Дирак* | https://habr.com/ru/post/448324/ | null | ru | null |
# XSS на yandex.ru
Вчера один мой друг (LMaster) нашел пассивную XSS на Яндексе. Специально сформированный адрес, переданный жертве, позволяет похитить cookies. Не фильтруется GET-параметр add. Для срабатывания скрипта не требуется никаких действий пользователя.
Запрос:
`_http://www.yandex.ru/?add=3188">&edit=1`
P.S. Сам он не имеет доступа на хабр. Основная [тема](https://r3al.ru/index.php?showtopic=5890&st=0&p=22869&#entry22869).
UPD: Уязвимость закрыта. Об этом уже сообщено в комментариях. Пожалуйста, не создавайте сотни ответов: «Не работает!» | https://habr.com/ru/post/64774/ | null | ru | null |
# 1\. Обучение пользователей основам ИБ. Борьба с фишингом
На сегодняшний день сетевой администратор или инженер ИБ тратит уйму времени и сил, чтобы защитить периметр сети предприятия от различных угроз, осваивает все новые системы предотвращения и мониторинга событий, но даже это не гарантирует ему полной защищенности. Социальная инженерия активно используется злоумышленниками и может нести за собой серьезные последствия.
Как часто вы ловили себя на мысли: “Хорошо бы устроить проверку для персонала на предмет грамотности в ИБ”? К сожалению, мысли упираются в стену непонимания в виде большого числа задач или ограниченности времени рабочего дня. Мы планируем рассказать вам о современных продуктах и технологиях в области автоматизации обучения персонала, которые не будут требовать длительной подготовки для проведения пилотов или внедрения, но обо всем по порядку.
Теоретический фундамент
-----------------------
На сегодняшний день более 80% вредоносных файлов распространяется с помощью почты (данные взяты из отчетов специалистов Check Point за последний год с помощью сервиса Intelligence Reports).
Отчет за последние 30 дней о векторе атак по распространению вредоносных файлов (Россия) - Сheck PointЭто говорит о том, что содержимое в почтовых сообщениях достаточно уязвимо для использования злоумышленниками. Если рассматривать наиболее популярные вредоносные форматы файлов во вложениях (EXE, RTF, DOC), то стоит заметить, что в них, как правило, есть автоматические элементы исполнения кода (скрипты, макросы).
Годовой отчет о форматах файлов в полученных вредоносных сообщениях - Сheck PointКак бороться с данным вектором атак? Проверка почты заключается в использовании инструментов безопасности:
* **Antivirus** - сигнатурное детектирование угроз.
* **Emulation** - песочница, с помощью которой вложения открываются в изолированной среде.
* **Content Awareness** - извлечение активных элементов из документов. Пользователь получает очищенный документ (как правило, в формате PDF).
* **AntiSpam** - проверка домена получателя/отправителя на предмет репутации.
И, по идее, этого достаточно, но существует еще один не менее ценный ресурс для компании - корпоративные и личные данные сотрудников. В последние годы активно растет популярность следующего вида интернет-мошенничества:
**Фишинг** (англ. phishing, от fishing — рыбная ловля, выуживание) — вид интернет-мошенничества. Его цель получить идентификационные данные пользователей. Сюда относятся кража паролей, номеров кредитных карт, банковских счетов и другой конфиденциальной информации.
Злоумышленники совершенствуют способы фишинг-атак, перенаправляют DNS-запросы от популярных сайтов, разворачивают целые кампании с использованием социальной инженерии для рассылки писем.
Таким образом, для защиты вашей корпоративной почты от фишинга рекомендовано применять два подхода, причем их совместное использование приводит к наилучшим результатам:
1. **Технические инструменты защиты**. Как и говорилось ранее, применяются различные технологии по проверке и пересылке только легитимной почты.
2. **Теоретическая подготовка персонала**. Заключается в комплексном тестировании персонала для выявления потенциальных жертв. Далее проводится их переобучение, постоянно фиксируется статистика.
Не доверяй и проверяй
---------------------
Сегодня речь пойдет о втором подходе по предотвращению фишинговых атак, а именно об автоматизированном обучении персонала с целью повышения общего уровня защищенности корпоративных и личных данных. Почему же это может быть так опасно?
**Социальная инженерия** - психологическое манипулирование людьми с целью совершения определенных действий или разглашения конфиденциальной информации (применительно к ИБ).
Схема типового сценария развертывания фишинговой атакиДавайте обратимся к занимательной блок-схеме, кратко отображающей путь по продвижению фишинговой кампании. В ней есть различные этапы:
1. Сбор первичных данных.
В 21 веке трудно найти человека, который не зарегистрирован ни в одной социальной сети или на различных тематических форумах. Естественно, многие из нас оставляют развернутую информацию о себе: место текущей работы, группа для коллег, телефон, почта и т.д. Добавьте к этому персонализированную информацию об интересах человека и вы получите данные для формирования фишингового шаблона. Даже если людей с такой информацией найти не удалось, всегда есть сайт компании, откуда можно подобрать всю интересующую нас информацию (доменную почту, контакты, связи).
2. Запуск кампании.
После того как будет подготовлен “плацдарм”, с помощью бесплатных или платных инструментов вы можете запустить свою собственную таргетированную фишинг-кампанию. В ходе работы рассылки у вас будет копиться статистика: доставленная почта, открытая почта, переход по ссылкам, ввод учетных данных и т.д.
Продукты на рынке
-----------------
Фишинг могут использовать как злоумышленники, так и сотрудники ИБ компании, с целью проведения постоянного аудита поведения сотрудников. Что же нам предлагает рынок бесплатных и коммерческих решений по автоматизированной системе обучения сотрудников компании:
1. [GoPhish](https://getgophish.com/) - опенсорсный проект, позволяющий развернуть фишинговую компанию с целью проверки IT-грамотности ваших сотрудников. К преимуществам я бы отнес простоту развертывания и минимальные системные требования. К недостаткам - отсутствие готовых шаблонов рассылки, отсутствие тестов и обучающих материалов для персонала.
2. [KnowBe4](https://www.knowbe4.com/) - площадка с большим числом доступных продуктов для тестирования персонала.
3. [Phishman](https://phishman.ru/) - автоматизированная система тестирования и обучения сотрудников. Имеет различные версии продуктов, поддерживающих от 10 до более 1000 сотрудников. Курсы обучения включают в себя теорию и практические задания, есть возможность выявления потребностей на основе полученной статистики после фишинговой компании. Решение коммерческое с возможностью триального использования.
4. [Антифишинг](https://www.antiphish.ru/) - автоматизированная система обучения и контроля защищенности. Коммерческий продукт предлагает проведение периодических учебных атак, обучение сотрудников и т.д. В качестве демо-версии продукта предлагается кампания, включающая в себя разворачивание шаблонов и проведение трех учебных атак.
Вышеперечисленные решения лишь часть доступных продуктов на рынке автоматизированного обучения персонала. Конечно же, у каждого есть свои преимущества и недостатки. Сегодня мы познакомимся с [GoPhish](https://getgophish.com/), имитируем фишинговую атаку, изучим доступные опции.
GoPhish
-------
Итак, пришло время для практики. GoPhish был выбран неслучайно: он представляет собой user-friendly инструмент, имеющий следующие особенности:
1. Упрощенная установка и запуск.
2. Поддержка REST API. Позволяет формировать запросы из [документации](https://docs.getgophish.com/api-documentation/) и применять автоматизированные сценарии.
3. Удобный графический интерфейс управления.
4. Кроссплатформенность.
Команда разработчиков подготовила отличный [гайд](https://docs.getgophish.com/user-guide/installation) по развертыванию и настройке GoPhish. На самом деле вам потребуется лишь перейти в [репозиторий](https://github.com/gophish/gophish), скачать ZIP-архив для соответствующей ОС, запустить внутренний бинарный файл, после чего инструмент будет установлен.
ВАЖНАЯ ЗАМЕТКА!
В итоге вы должны получить в терминале информацию о развернутом портале, а также данные для авторизации (актуально для версии старше версии 0.10.1). Не забудьте зафиксировать для себя пароль!
```
msg="Please login with the username admin and the password <ПАРОЛЬ>"
```
Разбираемся с настройкой GoPhish
--------------------------------
После установки в директории приложения будет создан конфигурационный файл (config.json). Опишем параметры для его изменения:
| | | |
| --- | --- | --- |
| **Ключ** | **Значение (по умолчанию)** | **Описание** |
| *admin\_server.listen\_url* | 127.0.0.1:3333 | IP-адрес сервера GoPhish |
| *admin\_server.use\_tls* | false | Используется ли TLS для подключения к серверу GoPhish |
| *admin\_server.cert\_path* | example.crt | Путь к SSL-сертификату для портала администрирования GoPhish |
| *admin\_server.key\_path* | example.key | Путь к приватному SSL-ключу |
| *phish\_server.listen\_url* | 0.0.0.0:80 | IP-адрес и порт размещения фишинговой страницы ( по умолчанию размещается на самом сервере GoPhish по 80 порту) |
--> Перейдите в портал управления. В нашем случае: *https://127.0.0.1:3333*
--> Вам предложат изменить достаточно длинный пароль на более простой или наоборот.
Cоздание профиля отправителяПерейдите во вкладку “Sending Profiles” и укажите данные о пользователе, от которого будет происходить наша рассылка:
**Где:**
| | |
| --- | --- |
| *Name* | Имя отправителя |
| *From* | Почта отправителя |
| *Host* | IP-адрес почтового сервера, с которого будет прослушиваться входящая почта. |
| *Username* | Логин учетной записи пользователя почтового сервера. |
| *Password* | Пароль учетной записи пользователя почтового сервера. |
Также вы можете отправить тестовое сообщение, чтобы убедиться в успехе доставки. Сохраните настройки с помощью кнопки “Save profile”.
Создание группы адресатовДалее следует сформировать группу адресатов “писем счастья”. Перейдите в “User & Groups” → “New Group”. Существует два способа добавления: вручную или импорт CSV файла.
Для второго способа требуется наличие обязательных полей:
* First Name
* Last Name
* Email
* Position
Как пример:
```
First Name,Last Name,Position,Email
Richard,Bourne,CEO,rbourne@morningcatch.ph
Boyd,Jenius,Systems Administrator,bjenius@morningcatch.ph
Haiti,Moreo,Sales & Marketing,hmoreo@morningcatch.ph
```
Создание шаблона фишингового письмаПосле того как мы указали воображаемого злоумышленника и потенциальных жертв, необходимо создать шаблон с сообщением. Для этого перейдите в раздел “Email Templates” → “New Templates”.
При формировании шаблона используется технический и творческий подход, следует указать сообщение от сервиса, который будет знаком пользователям-жертвам или вызовет у них определенную реакцию. Возможные опции:
| | |
| --- | --- |
| *Name* | Название шаблона |
| *Subject* | Тема письма |
| *Text / HTML* | Поле для ввода текста или HTML-кода |
Gophish поддерживает импорт письма, мы же создадим собственное. Для этого имитируем сценарий: пользователь компании получает письмо с предложением об изменении пароля от его корпоративной почты. Далее проанализируем его реакцию и посмотрим на наш “улов”.
В шаблоне будем использовать встроенные переменные. Более подробно с ними можно ознакомиться в вышеупомянутом [гайде](https://docs.getgophish.com/user-guide/installation) в разделе [Template Reference](https://docs.getgophish.com/user-guide/template-reference).
Для начала загрузим следующий текст:
```
{{.FirstName}},
The password for {{.Email}} has expired. Please reset your password here.
Thanks,
IT Team
```
Соответственно, в автоматическом режиме будет подставляться имя пользователя (согласно ранее заданному пункту “New Group”) и указываться его почтовый адрес.
Далее нам следует указать ссылку на наш фишинговый ресурс. Для этого выделим в тексте слово “here” и выберем опцию "Link" на панели управления.
В качестве URL укажем встроенную переменную {{.URL}}, которую мы заполним позже. Она автоматически будет встроена в текст фишингового письма.
Перед сохранением шаблона не забудьте включить опцию "Add Tracking Image". Это добавит медиа-элемент размером 1x1 пиксель, он будет отслеживать факт открытия письма пользователем.
Итак, осталось немного, но прежде резюмируем обязательные шаги после авторизации на портале Gophish:
1. Создать профиль отправителя;
2. Создать группу рассылки, где указать пользователей;
3. Создать шаблон фишингового письма.
Согласитесь, настройка не заняла много времени и мы уже почти готовы к запуску нашей кампании. Остается добавить фишинговую страницу.
Cоздание фишинговой страницыПерейдите во вкладку “Landing Pages”.
Нам предложат указать имя объекта. Есть возможность импорта сайта источника. В нашем примере я попробовал указать рабочий web-портал почтового сервера. Соответственно, он импортировался в виде HTML-кода (пусть и не полностью). Далее идут интересные опции по захвату введенных данных пользователя:
* Capture Submitted Data. Если указанная страница сайта содержит различные формы для ввода, то все данные будут записываться.
* Capture Passwords - захват введенных паролей. Данные записываются в БД GoPhish без шифрования, как есть.
Дополнительно можем использовать опцию “Redirect to”, которая перенаправит пользователя на заданную страницу после ввода учетных данных. Напомню, что мы задали сценарий, когда пользователю предлагается изменить пароль от корпоративной почты. Для этого ему предлагается фейковая страница портала авторизации почты, после чего пользователя можно отправить на любой доступный ресурс компании.
Не забываем сохранить заполненную страницу и переходим в раздел "New Campaign".
Запуск ловли GoPhish
--------------------
Мы указали все необходимые данные. Во вкладке "New Campaign" создадим новую кампанию.
Запуск кампанииГде:
| | |
| --- | --- |
| *Name* | Имя кампании |
| *Email Template* | Шаблон сообщения |
| *Landing Page* | Фишинговая страница |
| *URL* | IP вашего сервера GoPhish (должен иметь сетевую доступность с хостом жертвы) |
| *Launch Date* | Дата старта кампании |
| *Send Emails By* | Дата финиша кампании (рассылка распределяется равномерно) |
| *Sending Profile* | Профиль отправителя |
| *Groups* | Группа получателей рассылки |
После старта мы всегда можем ознакомиться со статистикой, в которой указано: отправленные сообщения, открытые сообщения, переходы по ссылкам, оставленные данные перенос в спам.
Из статистики видим, что 1 сообщение было отправлено, проверим почту со стороны получателя:
Действительно, жертва успешно получила фишинговое письмо с просьбой перейти по ссылке для смены пароля от корпоративного аккаунта. Выполняем запрашиваемые действия, нас отправляет на страницу Landing Pages, что со статистикой?
В итоге наш пользователь перешел по фишинговой ссылке, где потенциально мог оставить данные от своей учетной записи.
*Примечание автора:* процесс ввода данных не фиксировался по причине использования тестового макета, но такая опция есть. При этом содержимое не шифруется и хранится в БД GoPhish, учтите это.
Вместо заключения
-----------------
Сегодня мы с вами затронули актуальную тему о проведение автоматизированного обучения сотрудников с целью защитить их от фишинговых атак и воспитать в них IT-грамотность. В качестве доступного решения был развернут Gophish, который показал себя с хорошей стороны при соотношении времени развертывания и результата. С помощью этого доступного инструмента вы сможете проверить своих сотрудников и составить отчеты по их поведению. Если вас заинтересовал этот продукт, мы предлагаем помощь в его развертывании и проведении аудита ваших сотрудников (sales@tssolution.ru).
Однако, мы не собираемся останавливаться на обзоре одного решения и планируем продолжать цикл, где расскажем про Enterprise-решения для автоматизации процесса обучения и контроля защищенности сотрудников. Оставайтесь с нами и будьте бдительны! | https://habr.com/ru/post/521252/ | null | ru | null |
# GlassRAT: анализ трояна из Китая с помощью RSA Security Analytics и RSA ECAT
Специалистами RSA Research была обнаружена троянская программа GlassRAT для удаленного администрирования (Remote Administration Tool — RAT) с «нулевым уровнем обнаружения», подписанная сертификатом, украденным или полученным от популярного китайского разработчика ПО. Эта вредоносная программа могла избегать обнаружения на протяжении несколько лет. Телеметрия и ограниченные отчеты, не выдерживающие никакой критики, свидетельствуют, что целью GlassRAT являлись китайские граждане, связанные с транснациональными корпорациями. Будучи полностью «прозрачным» для большинства антивирусных продуктов, троянец GlassRAT можно обнаружить с помощью детальной экспертизы, а также с помощью конечных инструментов для обнаружения угроз, таких как RSA Security Analytics и/или RSA ECAT. Также представлены доказательства того, что способ организации командной инфраструктуры сети GlassRAT имеет много общего с другими вредоносными кампаниями, которые ранее были направлены на Азиатские организации геополитического и стратегического значения. Более подробно с этой информацией можно ознакомиться тут: <http://blogs.rsa.com/peering-into-glassrat/>.
### Чем на самом деле является GlassRAT?
GlassRAT это троян, обеспечивающий удаленный доступ (RAT). По-видимому, он оставался незамеченным почти 3 года. GlassRAT использует множество личин, и может похвастаться по-своему очень эффективным, вредоносным дизайном. Его дроппер подписан с помощью скомпрометированного сертификата от доверенного и известного издателя (Центр Сертификации, который выпустил этот сертификат, после независимой экспертизы, подтверждающей злонамеренность подписанного им кода, впоследствии его отозвал). Дроппер удаляет себя после успешной реализации своих задач. Будучи установленным, вредоносный DLL-файл, образно говоря, «летает ниже уровня обнаружения радара» антивируса, обеспечивая злоумышленнику доступ к шелл-коду инфицированной жертвы.
GlassRat впервые привлек внимание RSA Research в феврале 2015, когда команда RSA Incident Respons, специализирующаяся на превентивном предотвращении угроз вторжения в большие корпоративные сети, обнаружила вредоносный трафик при расследовании инцидента в многонациональной корпорации, базирующейся в США. Образец DLL был обнаружен при помощи RSA ECAT на ПК китайского гражданина, проживающего в материковой части Китая.
Обычно организаторы атаки просто заменяют такие низкоуровневые средства, как RAT, сразу после обнаружения, не меняя тактику, процедуры, инфраструктуру или даже сами цели атаки. Однако в данном случае факты свидетельствуют об обратном. Цели атаки отличались как по количеству (их стало гораздо больше), так и по характеристикам (геополитические, вместо традиционных коммерческих).
RSA Research искали возможные сходства с другими, описанными ранее вредоносными программами и способами их работы. Было найдено некоторое сходство кода с другими зловредами, такими как Taidoor (<http://www.trendmicro.com/cloud-content/us/pdfs/security-intelligence/white-papers/wp_the_taidoor_campaign.pdf>)
и Taleret (<https://www.fireeye.com/blog/threat-research/2013/09/evasive-tactics-taidoor-3.html>), но самое интересное совпадение обнаружилось в системе управления инфраструктурой, используемой при атаках на организации геополитического значения (об этом ниже ниже), которые были зафиксированы несколько лет назад.
### Анализ GlassRAT при помощи RSA Security Analytics и RSA ECAT
#### Схема заражения GlassRAT
Начиная расследование атаки после внедрения дроппера и заражения, ECAT автоматически повышает уровень опасности для машины и соответствующего модуля с нуля до одного из максимальных значений в очереди на анализ.
Давайте проанализируем остальную предоставленную ECAT информацию. Нам доступна статистика о текущем содержимом памяти, о хранящихся на диске данных, об аномалиях и сетевом трафике. Всё это позволяет аналитику во время расследования инцидента мгновенно переключить внимание на любую из сущностей, вызывающую подозрение.
#### Дроппер GlassRAT
Существовало два образца вредоносного установщика GlassRAT, известные как «дропперы». Согласно результатам анализа, представленным на сайте VirusTotal, 57 различных антивирусов при обычной проверке не способны были обнаружить оба этих дроппера.
Оба образца дроппера GlassRAT были практически **идентичны по своим функциям и коду**. Первый из образцов был загружен на VirusTotal примерно на четыре часа раньше второго.
Дропперы GlassRAT использовали фирменную иконку Adobe Flash Player и назывались «flash.exe», когда впервые были загружены на VirusTotal — 17 сентября 2015 года.
Двойной клик на троянце вызывает запуск дроппера. Как только ECAT обнаружило, что это потенциально вредоносный файл, он был автоматически загружен в ECAT ConsoleServer для дальнейшего расследования. Через ECAT Modules view, мы видим следующее:
ECAT обнаруживает дроппер и повышает уровень опасности InstantIOC (Indicator of Compromise Score), учитывая подпись кода отозванным сертификатом.
Кроме того, ECAT использует модуль отслеживания сессии для идентификации и установки связей с другими потенциально подозрительными файлами или машинами в вашей среде, которые устанавливали соединения и осуществляли другие подозрительные действия:
* `SVCHOST.exe` запускает `flash.exe`
* `flash.exe` запускает применительно к `updatef.dll` событие “Write to Exectuable”
В ходе установки трояна, дроппер самоуничтожается при помощи встроенной команды:
`“cmd.exe /c erase /F "%s",”`
После обнаружения нового вредоносного файла `updatef.dll`, мы начали его анализировать. Как видно из списка файлов, отсортированных по ECAT Risk Score, дроппер имеет два различных процесса, используемых при установке в пользовательском и привилегированном режимах:
Эти два разных DLL-файла сразу были отмечены как подозрительные и загружены на сервер после обнаружения ECAT-агентом, и получили оценку риска по 1024 балла каждый.
#### Механизм непривилегированной персистентности GlassRAT
`HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Run
Image path: c:\programdata\updatef.dll`
Примечание: файл DLL самом деле пишется в корень `C:\ProgramData`, но в связи с переходом на Windows Vista и более поздние версии Windows, в разделе реестра Autoruns будет отображаться путь `C:\ProgramData\Application Data\`.
Так выглядит непривилегированная персистентность GlassRAT при просмотре через Autoruns tool:
При ручном запуске UAC, по клику правой кнопкой мыши отображаются метаданные, связанные с дроппером:
Примечание: Название программы, указанное в диалоговом окне Контроля Учетных Записей (UAC), совпадает с названием настоящего приложения “500 million-user”, разработанного владельцем сертификата.
#### Механизм привилегированной персистентности GlassRAT
Персистентность троянца GlassRAT обеспечивается благодаря установке в качестве службы «RasAuto» (Remote Access Manager), которая в Windows обычно отключена по умолчанию.
`HKLM\System\CurrentControlSet\Services
RasAuto image path: c:\programdata\application data\updatef.dll`
Механизм персистентности GlassRAT при установке с администраторскими привилегиями:
С помощью ECAT module investigation можно мгновенно определить `updatef.dll` как автозагрузчик, присвоить соответствующий уровень риска, и обнаружить файл и запись в реестре:
Опознав в `updatef.dll` вредоносный файл, мы решили лучше изучить его характеристики: что он из себя представляет, что делает, каковы его отличительные черты и т.д. Для этого воспользовались модулем InstantIOC (IIOCs).
YARA — инструмент для помощи исследователям в идентификации и классификации вредоносных семплов. Сообщение YARA IIOC о заражении было инициировано отдельным YARA-правилом, созданным для GlassRAT, о чем указано под свойствами модуля.
После того, как дроппер и связанные с ним инфицированные DLL-файлы были идентифицированы и выполнены, мы исходили из предположения, что троянец загружается с помощью `svchost.exe` как сервис RasAuto, а при установке в непривилегированном режиме `rundll32.exe` запускает `updatef.dll`.
Через мониторинг сетевого трафика ECAT мы выявили подозрительные соединения с qx.rausers.com через порты 53, 80 и 443. В данном случае ECAT смог определить, что это был модуль `rundll32.exe`, который осуществлял оповещение (а не просто установку связи с `svchost.exe`).
Кроме того, ECAT IIOC пометил `rundll32.exe`, сообщая о потенциальной подаче сигнала, подозрительном доступе к сети и фактическом DNS-трафике от этого процесса.
### Сетевой анализ командного центра GlassRAT с помощью ECAT Security Analytics
Структуры управления GlassRAT были несколько схожи с командными центрами, обнаруженными в 2012 году в других вредоносных кампаниях, целью которых были правительства и военные организации в Тихоокеанском регионе. Кроме того, статической анализ нескольких DLL-файлов GlassRAT выявил запутанность конфигурации хоста командного центра во всех обнаруженных образцах.
`003/064/50/60 : 112.175.x.x`
`chur/gnsxntrdd/odu : bits.foryousee.net`
`012/31/084/353 : 103.20.x.x`
`py/s`trdsr/bnl : qx.rausers.com`
`ly/s`trdsr/bnl : mx.rausers.com`
`yy/s`trdsr/bnl : xx.rausers.com`
Хендшейк между атакующим и жертвой был обнаружен с помощью Security Analytics и нового отдельного парсера Glass RAT Trojan parser, доступного “из коробки” посредством RSA Live. При обнаружении сетевого трафика параметру `glass_rat_c2_handshale_beacon` было присвоено новое мета-значение “Risk: Suspicious”.
Также о хендшейке свидетельствуют подключения к сокету прямого доступа, помеченные как “`unknown service over http port`" и "`unknown service over ssl port`" с мета-значением «Risk: Informational» с мета-значением.
В ходе выполнения хендшейка между зараженным узлом и командным сервером было переслано и обнаружено RSA Security Analytics жестко запрограммированное значение `0x cb ff 5d c9 ad 3f 5b a1 54 13 fe fb 05 c6 22`. Определение трафика и IP-адресов места назначения (dst.ip):
При взаимодействии с командной оболочкой Windows (но не по части сигнализирования), вы также можете использовать следующее правило приложения:
`service = 0 && tcp.dstport = 80 && risk.warning = ‘windows command shell’`
Можно засечь вредоносную активность благодаря сообщениям в консоли (risk.warning: ‘windows command shell’ с использованием неизвестного протокола (service=0) и популярного порта (tcp.dstport = 80)). Но тут возможны ложноположительные срабатывания. | https://habr.com/ru/post/274245/ | null | ru | null |
# Эволюция модульного JavaScript
Скорее всего, когда Брендан Айк проектировал JavaScript, он не представлял, как эволюционирует его проект спустя двадцать лет. На данный момент вышло уже шесть основных спецификаций языка, и работа над его улучшением до сих пор продолжается.
Не будем лукавить: JavaScript никогда не был идеальным языком программирования. Одним из слабых мест в JS была модульность, а точнее её отсутствие. Действительно, зачем в скриптовом языке, который анимирует падающие на странице снежинки и валидирует форму, заботиться об изоляции кода и зависимостях? Ведь всё может прекрасно жить и общаться между собой в одной глобальной области — window.
С течением времени JavaScript трансформировался в язык общего назначения, так его начали использовать для построения сложных приложений в различных средах (браузер, сервер). При этом нельзя было положиться на старые подходы взаимодействия компонентов программы через глобальную область: с ростом объёма кода приложение становилось очень хрупким. Как результат для упрощения процесса разработки создавались различные реализации модульности.
Эта статья появилась в результате общения с участниками TC39 и разработчиками фреймворков, а также чтения исходных кодов, блогов и книг. Мы рассмотрим следующие подходы/форматы: Namespace, Module, Detached Dependency Definitions, Sandbox, Dependency Injection, CommonJS, AMD, UMD, Labeled Modules, YModules и ES2015 Modules. Кроме того, мы восстановим исторический контекст их появления и развития.
Содержание
----------
* [Используемые термины](#defining-the-used-terms)
* [Подробнее о проблемах](#a-little-more-about-problems)
* [Directly Defined Dependencies (1999)](#directly-defined-dependencies-1999)
* [Namespace Pattern (2002)](#the-namespace-pattern-2002)
* [Module Pattern (2003)](#the-module-pattern-2003)
* [Template Defined Dependencies (2006)](#template-defined-dependencies-2006)
* [Comment Defined Dependencies (2006)](#comment-defined-dependencies-2006)
* [Externally Defined Dependencies (2007)](#externally-defined-dependencies-2007)
* [Sandbox Pattern (2009)](#the-sandbox-pattern-2009)
* [Dependency Injection (2009)](#dependency-injection-2009)
* [CommonJS Modules (2009)](#commonjs-modules-2009)
* [AMD (2009)](#amd-2009)
* [UMD (2011)](#umd-2011)
* [Labeled Modules (2012)](#labeled-modules-2012)
* [YModules (2013)](#ymodules-2013)
* [ES2015 Modules (2015)](#es2015-modules-2015)
* [Итого](#conclusion)
Используемые термины
--------------------
Модульность решает [следующие задачи](http://blog.calyptus.eu/seb/2011/10/choosing-a-javascript-module-syntax/): обеспечение поддержки изоляции кода, определение зависимостей между модулями и доставка кода в среду выполнения. Некоторые перечисленные выше подходы решали только одну-две из этих проблем — такие решения мы будем называть «паттернами», а те, где решаются все три задачи, — «модульными системами».
Конкретную структуру исходного кода с определением импортируемых и экспортируемых сущностей (ко второму типу относятся объекты, функции и т. п.) будем называть «форматом модулей».
Под «обособленным определением зависимостей» (detached dependency definition, DDD) будем понимать такие подходы определения зависимостей, которые можно использовать независимо от модульных систем.
Подробнее о проблемах
---------------------
Перед погружением в мир модульности давайте подробнее разберёмся в том, какие проблемы перед нами стоят.
#### Коллизия имён
С момента своего появления JavaScript использовал глобальный объект window как хранилище всех определяемых переменных без ключевого слова `var`. В 1995–1999 годах это было очень удобно по причине малого количества клиентского JavaScript-кода на страницах. Но с увеличением количества кода эта особенность стала приводить к частому возникновению ошибок из-за коллизии имен. Давайте рассмотрим пример:
```
// файл greeting.js
var helloInLang = {
en: 'Hello world!',
es: '¡Hola mundo!',
ru: 'Привет, мир!'
};
function writeHello(lang) {
document.write(helloInLang[lang]);
}
// файл hello.js
function writeHello() {
document.write('The script is broken');
}
```
Когда на страницу подключится `greeting.js`, а затем `hello.js`, мы из-за коллизии вместо приветствия получим сообщение «The script is broken».
Очевидно, что в больших проектах это может вызывать много головной боли. Более того — нельзя быть уверенным, что подключаемые к странице сторонние скрипты ничего не поломают в вашем приложении.
#### Поддержка большой кодовой базы
Ещё один неудобный момент при использовании JavaScript «из коробки» для построения больших приложений — это необходимость явно указывать подключаемые скрипты с помощью тега script.
Если вы заботитесь о том, чтобы исходный код был удобен для поддержки, вы разбиваете его на независимые части. Таким образом, файлов с кодом может оказаться очень много. При большом количестве файлов ручное управление скриптами (то есть определение подключаемых скриптов через тег script) сильно усложняется: необходимо, во-первых, помнить о подключении нужных скриптов к странице, а во-вторых — распределить последовательность тегов script так, чтобы все зависимости между файлами были разрешены.
Directly Defined Dependencies (1999)
------------------------------------
Первой попыткой привнести модульную структуру в JavaScript, а также первой реализацией обособленного определения зависимостей было прямое определение зависимостей в коде (directly defined dependencies). Одним из первых этот паттерн [задействовал](https://twitter.com/erikarvidsson/status/825403889969033216) [Эрик Арвидссон](https://github.com/arv) (ныне участник TC39) в далёком 1999 году.
Эрик тогда работал в стартапе, где создавалась платформа для запуска GUI-приложений в браузере — WebOS (обратите внимание: речь не про webOS от Palm). WebOS была проприетарной платформой — мне не удалось получить её исходный код. Поэтому рассмотрим реализацию паттерна на примере библиотеки Dojo, которую с 2004 года разрабатывали Алекс Рассел и Дилан Скиманн.
Суть прямого определения зависимостей — загружать код модулей (в терминах Dojo — ресурсы) при явном исполнении функции `dojo.require` (которая, кроме того, инициализировала загруженный модуль). При таком подходе зависимости определяются по месту требования, прямо в коде.
Давайте переделаем наш пример с использованием Dojo 1.6:
```
// файл greeting.js
dojo.provide("app.greeting");
app.greeting.helloInLang = {
en: 'Hello world!',
es: '¡Hola mundo!',
ru: 'Привет, мир!'
};
app.greeting.sayHello = function (lang) {
return app.greeting.helloInLang[lang];
};
// файл hello.js
dojo.provide("app.hello");
dojo.require('app.greeting');
app.hello = function(x) {
document.write(app.greeting.sayHello('es'));
};
```
Здесь мы видим, что модули определяются с помощью функции `dojo.provide`, а сама загрузка кода происходит при выполнении функции `dojo.require`. Это довольно простой подход, который использовался в Dojo до версии 1.7 и по сей день используется в [Google Closure Library](https://github.com/google/closure-library).
Namespace Pattern (2002)
------------------------
Первая попытка решения проблемы коллизии имен заключалась во введении соглашений. Например, можно было добавить к именам всех переменных и функций определённый префикс: `myApp_` (`myApp_address`, `myApp_validateUser()`) или какой-нибудь другой. Конечно, кардинально это не меняло ситуацию, так что впоследствии разработчики стали пользоваться ключевой особенностью JavaScript: функции в нём являются объектами первого класса.
Объект первого класса — сущность, которую можно присваивать переменным и свойствам объектов и возвращать из других функций. То есть можно создавать объекты с такими же свойствами-функциями (методами), как у объектов document и window (`document.write()`, `window.alert()`).
Один из первых значимых проектов, где была использована данная возможность, — библиотека UI-элементов Bindows. Над ней в 2002 году начал работать уже знакомый нам Эрик Арвидссон. Вместо префиксов в названиях функций и переменных он воспользовался глобальным объектом, свойства которого содержали данные и логику библиотеки. Таким образом, в значительной степени уменьшилось загрязнение глобальной области. Сейчас подобный паттерн для организации кода известен под названием «Пространство имен» (Namespace Pattern).
Переложим эту идею на наш пример.
```
// файл app.js
var app = {};
// файл greeting.js
app.helloInLang = {
en: 'Hello world!',
es: '¡Hola mundo!',
ru: 'Привет, мир!'
};
// файл hello.js
app.writeHello = function (lang) {
document.write(app.helloInLang[lang]);
```
Как мы видим, логика и данные теперь содержатся в свойствах объекта `app`. Тем самым снижается загрязнение глобальной области, но мы продолжаем иметь доступ к необходимым частям приложения из разных файлов.
На сегодняшний день Namespace Pattern — наверное, самый популярный паттерн, который можно встретить в JS. После Bindows подобная логика появилась в Dojo (2005), YUI (2005) и многих других библиотеках и фреймворках. Стоит отметить, что Эрик [не считает](https://twitter.com/erikarvidsson/status/819368206984826880) себя автором этого подхода, но вспомнить, какой проект вдохновил его на использование паттерна, он, к сожалению, не смог.
Module Pattern (2003)
---------------------
Благодаря Namespace организация кода стала чуть менее беспорядочной, но было очевидно, что этого недостаточно: до сих пор не была решена задача изоляции кода и данных.
Первопроходец в решении указанной задачи — паттерн «Модуль». Идея паттерна — инкапсулировать данные и код с помощью замыкания и сделать их доступными через методы, которые, в свою очередь, доступны извне. Вот базовый пример такого модуля:
```
var greeting = (function () {
var module = {};
var helloInLang = {
en: 'Hello world!',
es: '¡Hola mundo!',
ru: 'Привет, мир!'
};
module.getHello = function (lang) {
return helloInLang[lang];
};
module.writeHello = function (lang) {
document.write(module.getHello(lang))
};
return module;
}());
```
Здесь мы видим самовызывающуюся функцию — такую, которая выполняется сразу после объявления. Она возвращает объект `module`, где есть метод `getHello()`, обращающийся к объекту `helloInLang` через замыкание. Таким образом, `helloInLang` становится недоступен из внешнего мира и мы получаем атомарный кусок кода, который можно вставить в любой другой скрипт без конфликта имён — даже если объект `helloInLang` был объявлен где-то ещё.
В сети первое упоминание этого подхода появилось в 2003 году, когда Ричард Корнфорд привёл [пример](https://groups.google.com/forum/#!msg/comp.lang.javascript/eTzWVa1W_pE/N9lnvRG9WJ8J) модуля в группе comp.lang.javascript в качестве иллюстрации использования замыканий. В 2005–2006 году этот подход взяли на вооружение разработчики фреймворка YUI из Yahoo! под руководством Дугласа Крокфорда. Но наибольший импульс к его распространению был дан в 2008 году, когда Дуглас описал паттерн «Модуль» в своей книге JavaScript Good Parts.
Но и это еще не всё. В статье [«JavaScript Module Pattern: In-Depth»](http://www.adequatelygood.com/JavaScript-Module-Pattern-In-Depth.html) (вот [перевод на Хабрахабре](https://habrahabr.ru/post/117069/)) есть множество разных вариантов реализации модуля. Рекомендую посмотреть.
Template Defined Dependencies (2006)
------------------------------------
Шаблонное определение зависимостей — следующий паттерн в семействе обособленного определения. Самый ранний из найденных мной проектов, где задействован этот подход, — [Prototype 1.4](https://github.com/myshov/history_of_javascript/blob/master/old_libs/prototype-1.4.0/src/prototype.js) (2006), но у меня есть подозрение, что он использовался и в более ранних версиях библиотеки.
Prototype разрабатывался с 2005 года [Сэмом Стивенсеном](https://github.com/sstephenson) как клиентская часть фреймворка Ruby on Rails. Поскольку Сэм много работал с Ruby, неудивительно, что для менеджмента зависимостей между файлами он выбрал обычную шаблонизацию с помощью erb.
Если попробовать обобщить, можно сказать, что в этом паттерне зависимости определяются с помощью включения в целевой файл специальных меток. Здесь могут использоваться как распространенные механизмы шаблонизации (erb, jinja, smarty), так и специальные инструменты сборки, например [borsсhik](https://github.com/borschik/borschik).
При использовании шаблонизированных зависимостей — в отличие от ранее рассмотренных паттернов обособленного определения — обязателен предварительный этап сборки.
Преобразуем наш пример с использованием описанного стиля. Для этого задействуем borsсhik:
```
// файл app.tmp.js
/*borschik:include:../lib/main.js*/
/*borschik:include:../lib/helloInLang.js*/
/*borschik:include:../lib/writeHello.js*/
// файл main.js
var app = {};
// файл helloInLang.js
app.helloInLang = {
en: 'Hello world!',
es: '¡Hola mundo!',
ru: 'Привет, мир!'
};
// файл writeHello.js
app.writeHello = function (lang) {
document.write(app.helloInLang[lang]);
};
```
Здесь файл app.tmp.js определяет подключаемые скрипты и их порядок. Если поразмышлять над примером, станет ясно, что данный подход кардинально не меняет жизнь разработчику. Вместо использования тегов script, просто используются другие метки в js-файле. Иными словами, мы по-прежнему можем что-то забыть или перепутать порядок подключаемых скриптов. Поэтому основное назначение этого подхода — обеспечение сборки единого js-файла из множества других.
Comment Defined Dependencies (2006)
-----------------------------------
Ещё одним подтипом обособленного определения зависимостей является определение зависимостей с помощью комментариев. Оно очень похоже на прямое определение, но в данном случае вместо конструкций языка используются комментарии, где содержится информация о зависимостях модуля.
Приложение, использующее данный подход, должно быть предварительно собрано — как это делалось в 2006 году для сборки [MooTools](https://github.com/mootools/mootools-core/blob/41b0bdedce3adeb921c181145d7c79a8ecbf4763/Plugins/Fxpack.js#L12), которую разрабатывал [Валерио Пройетти](https://github.com/kamicane), — или оно должно на этапе исполнения парсить исходный код и затем загружать все определенные с помощью комментариев зависимости. На базе последнего подхода реализована библиотека [LazyJS](https://github.com/bevacqua/lazyjs) [Николаса Бевакуа](https://github.com/bevacqua).
Вот как будет выглядеть наш пример, если переписать его с использованием LazyJS:
```
// файл helloInLang.js
var helloInLang = {
en: 'Hello world!',
es: '¡Hola mundo!',
ru: 'Привет, мир!'
};
// файл sayHello.js
/*! lazy require scripts/app/helloInLang.js */
function sayHello(lang) {
return helloInLang[lang];
}
// файл hello.js
/*! lazy require scripts/app/sayHello.js */
document.write(sayHello('en'));
```
Самая известная библиотека, где используется указанный подход, — MooTools. LazyJS была интересным экспериментом, но она появилась после CommonJS и AMD и поэтому особого внимания разработчиков не получила.
Externally Defined Dependencies (2007)
--------------------------------------
Давайте рассмотрим последний паттерн в семействе DDD. При внешнем определении зависимостей они все определяются вне основного контекста — например, в конфигурационном файле или в коде как объект или массив. При этом существует этап предподготовки, во время которого происходит инициализация приложения с загрузкой всех зависимостей в корректном порядке — на основе имеющейся о них информации.
Самое раннее использование такого подхода, которое я смог найти, датируется 2007 годом. Речь идёт о библиотеке [MooTools 1.1](https://github.com/mootools/mootools-core/blob/d4b15bdd4061d7012748bc2c9da7e70864e12bbb/scripts.json#L14).
В самом простом случае реализовать наш пример с использованием этого паттерна можно следующим образом (в качестве образца буду использовать собственную экспериментальную реализацию [загрузчика](https://github.com/myshov/eddloader), где задействован нужный паттерн):
```
// файл deps.json
{
"files": {
"main.js": ["sayHello.js"],
"sayHello.js": ["helloInLang.js"],
"helloInLang.js": []
}
}
// файл helloInLang.js
var helloInLang = {
en: 'Hello world!',
es: '¡Hola mundo!',
ru: 'Привет, мир!'
};
// файл sayHello.js
function sayHello(lang) {
return helloInLang[lang];
}
// файл main.js
console.log(sayHello('en'));
```
Файл `deps.json` является тем самым внешним контекстом, где определяются все зависимости. При запуске приложения загрузчик получает файл, считывает из него зависимости, которые определяются в виде массива, загружает их и подключает к странице в корректном порядке.
На данный момент этот подход используется в некоторых библиотеках для создания кастомных сборок, например в [lodash](https://github.com/lodash-archive/lodash-cli/blob/master/lib/mapping.js#L386-L1022).
Sandbox Pattern (2009)
----------------------
Программисты Yahoo!, работавшие над новой модульной системой YUI3, решали проблему использования разных версий библиотеки на одной странице. До YUI3 модульная система во фреймворке реализовывалась комбинацией паттернов Module и Namespace. Очевидно, что при такой схеме корневой объект, содержащий код библиотеки, мог быть только один и, следовательно, использовать несколько версий сразу было затруднительно.
Чтобы решить возникшую проблему, один из разработчиков YUI3 [Адам Мур](https://twitter.com/admo/with_replies) предложил задействовать «Песочницу». Простая реализация модульности с использованием этого паттерна может выглядеть так:
```
// файл sandbox.js
function Sandbox(callback) {
var modules = [];
for (var i in Sandbox.modules) {
modules.push(i);
}
for (var i = 0; i < modules.length; i++) {
this[modules[i]] = Sandbox.modules[modules[i]]();
}
callback(this);
}
// файл greeting.js
Sandbox.modules = Sandbox.modules || {};
Sandbox.modules.greeting = function () {
var helloInLang = {
en: 'Hello world!',
es: '¡Hola mundo!',
ru: 'Привет, мир!'
};
return {
sayHello: function (lang) {
return helloInLang[lang];
}
};
};
// файл app.js
new Sandbox(function(box) {
document.write(box.greeting.sayHello('es'));
});
```
Суть подхода в двух словах — вместо глобального объекта используется глобальный конструктор, а модули в свою очередь могут определяться как его свойства.
«Песочница» послужила интересным решением проблемы модульности, но за пределами YUI3 особого распространения не получила. Если вам хочется узнать больше про Sandbox, рекомендую статью [«Javascript Sandbox Pattern»](https://www.kenneth-truyers.net/2016/04/25/javascript-sandbox-pattern/), а также официальную документацию YUI про создание [новых модулей](http://yuilibrary.com/yui/docs/yui/create.html) библиотеки.
Dependency Injection (2009)
---------------------------
В 2004 году Мартин Фаулер для описания нового механизма коммуникации компонентов в Java ввёл понятие «внедрение зависимостей» ([dependency injection](https://martinfowler.com/articles/injection.html), DI). Основная суть заключается в том, что все зависимости «приходят» извне компонента. Другими словами, компонент не отвечает за инициализацию своих зависимостей, а лишь использует их.
Пять лет спустя [Мишко Хевери](https://github.com/mhevery), бывший сотрудник Sun и Adobe (где он занимался в том числе разработкой на Java), начал проектировать для своего стартапа JavaScript-фреймворк, где ключевым механизмом взаимосвязей компонентов служило внедрение зависимостей. Идея бизнеса не доказала свою эффективность, но исходный код фреймворка решили выложить на домене стартапа getangular.com. Большинство знает, что было потом: компания Google взяла Мишко и его проект под крыло и сейчас Angular — один из самых известных JavaScript-фреймворков.
Модули в Angular реализуются с помощью механизма DI. Однако модульность — не первичное назначение DI: об этом также явно говорит Мишко в ответе на [соответствующий вопрос](http://www.alexrothenberg.com/2013/02/11/the-magic-behind-angularjs-dependency-injection.html#comment-806114100).
Для иллюстрации подхода давайте перепишем наш пример с использованием первой версии Angular (да, пример получился чрезвычайно синтетическим):
```
// файл greeting.js
angular.module('greeter', [])
.value('greeting', {
helloInLang: {
en: 'Hello world!',
es: '¡Hola mundo!',
ru: 'Привет, мир!'
},
sayHello: function(lang) {
return this.helloInLang[lang];
}
});
// файл app.js
angular.module('app', ['greeter'])
.controller('GreetingController', ['$scope', 'greeting', function($scope, greeting) {
$scope.phrase = greeting.sayHello('en');
}]);
```
Если открыть страницу с примером в браузере, то код [магическим образом](http://www.alexrothenberg.com/2013/02/11/the-magic-behind-angularjs-dependency-injection.html) отработает и мы увидим результат на странице.
Сейчас механизм DI используется во фреймворках [Angular 2](https://github.com/angular/angular) и [Slot](https://github.com/2gis/slot). Также существует большое количество библиотек, упрощающих использование этого подхода в приложениях, не зависящих от каких-либо фреймворков.
CommonJS Modules (2009)
-----------------------
Вместе с браузерными JavaScript-движками ещё до появления Node.js разрабатывались [платформы для серверной разработки](https://en.wikipedia.org/wiki/Comparison_of_server-side_JavaScript_solutions), использующие JavaScript как основной язык. Серверные решения ввиду отсутствия соответствующих спецификаций не предоставляли унифицированного API для работы с операционной системой и внешним окружением (файловой системой, сетью, переменными окружения и т. д.), тем самым создавая проблемы с распространением кода. Например, скрипты, написанные для старичка Netscape Enterprise Server, не работали в Rhino и наоборот.
В 2009 году наступил переломный момент — сотрудник Mozilla [Кевин Дангур](https://github.com/dangoor) опубликовал [пост](http://www.blueskyonmars.com/2009/01/29/what-server-side-javascript-needs/) о проблемах с серверным JavaScript. В посте он призвал всех заинтересованных присоединиться к неофициальному комитету для обсуждения и разработки серверного JavaScript API. Проект, над которым началалась работа, был назван ServerJS; но спустя его переименовали в CommonJS.
Работа закипела. Наибольшее внимание разработчиков получила спецификация формата модулей в JavaScript — [CommonJS Modules](http://www.commonjs.org/specs/modules/1.0/) (иногда её называют CJS или просто CommonJS), которая в конечном счёте была реализована в Node.js.
Для демонстрации CommonJS-модуля давайте адаптируем наш модуль следующим образом:
```
// файл greeting.js
var helloInLang = {
en: 'Hello world!',
es: '¡Hola mundo!',
ru: 'Привет, мир!'
};
var sayHello = function (lang) {
return helloInLang[lang];
}
module.exports.sayHello = sayHello;
// файл hello.js
var sayHello = require('./lib/greeting').sayHello;
var phrase = sayHello('en');
console.log(phrase);
```
Здесь мы видим, что для реализации модульности вводятся новые сущности `require` и `exports` (альяс на `module.exports`), которые дают возможность загрузить модуль и предоставить его интерфейс внешнему миру. Стоит заметить, что ни `require`, ни `exports`, ни module не являются ключевыми словами языка — в Node.js они появляются благодаря обёртке, куда заворачиваются все модули, прежде чем отправиться на выполнение в JavaScript-движок:
```
(function (exports, require, module, __filename, __dirname) {
// ...
// Your code is injected here!
// ...
});
```
Спецификация CommonJS определяет только необходимый минимум для интероперабельности модулей в различных средах. Значит, механизмы CommonJS можно расширять. Например, так делает Node.js, добавляя к `require` свойство [main](https://nodejs.org/api/modules.html#modules_accessing_the_main_module), которое указывает на `module`, если файл с модулем был запущен напрямую.
Babel также расширяет `require` при транспиляции модуля с дефолтным экспортом в формате ES2015 Modules (об этой модульной системе поговорим в конце статьи):
```
export default something;
```
Babel преобразует подобный экспорт в CommonJS-модуль, где дефолтное значение экспортируется с помощью соответствующего свойства. То есть, упрощённо, получается следующий код:
```
exports.default = something;
```
Система сборки webpack тоже использует различные расширения, например `require.ensure`, `require.cache`, `require.context`, но их обсуждение лежит вне контекста статьи.
На сегодняшний день CommonJS — самый распространённый формат модулей. Этот формат используется не только в Node.JS — ещё его можно использовать при разработке клиентских веб-приложений, собирая все модули в единый файл с помощью [Browserify](http://browserify.org/) или [webpack](https://webpack.js.org/).
AMD (2009)
----------
Когда разработка спецификации CommonJS шла полным ходом, в рассылке время от времени возникали [бурные обсуждения](https://groups.google.com/forum/#!msg/commonjs/nbpX739RQ5o/SdpVQDtx88AJ) о добавлении в спецификацию возможности асинхронной загрузки модулей. Она позволила бы ускорить загрузку веб-приложений, состоящих из большого количества файлов, и избавиться от необходимости сборки для доставки кода пользователям.
Коллега Кевина по работе в Mozilla [Джеймс Бёрк](https://github.com/jrburke) был одним из самых активных сторонников асинхронной загрузки во всех обсуждениях. Джеймс мог выступать экспертом, поскольку был автором асинхронной модульной системы во фреймворке Dojo 1.7. Кроме того, именно он с 2009 года разрабатывал загрузчик [require.js](http://requirejs.org/).
Основная идея, которую пытался донести Джеймс, — что загрузка модулей не должна осуществляться синхронно (то есть последовательно, один модуль за другим); нужно использовать возможности браузера для параллельной загрузки скриптов. Для реализации всех требований впоследствии он предложил собственный формат модулей, который был назван AMD (Asynchronous Module Definition).
Если переписать наш пример в соответствии с практиками AMD, то мы получим следующий код:
```
// file lib/greeting.js
define(function() {
var helloInLang = {
en: 'Hello world!',
es: '¡Hola mundo!',
ru: 'Привет, мир!'
};
return {
sayHello: function (lang) {
return helloInLang[lang];
}
};
});
// file hello.js
define(['./lib/greeting'], function(greeting) {
var phrase = greeting.sayHello('en');
document.write(phrase);
});
```
Здесь файл hello.js является точкой входа в программу. В нём находится функция `define`, которая объявляет модуль. В качестве первого аргумента в функцию передаётся массив зависимостей. При этом выполнение основного кода модуля, который объявлен как функция вторым аргументом в `define`, будет запущено, только когда загрузятся все зависимости модуля. Именно отложенное выполнение кода каждого модуля в отдельности обеспечивает параллельную загрузку зависимостей в целом.
В 2011 году наступил переломный момент всех дискуссий: Джеймс объявил о создании отдельной рассылки для координации работ по AMD, поскольку консенсус с группой CommonJS за всё это время [достигнут не был](https://groups.google.com/forum/#!msg/commonjs/6CdQpDW4loE/Syh_gxvQ5QUJ).
По личным наблюдениям могу сказать, что AMD всё ещё используется при разработке приложений, однако тенденция перехода к распространению клиентского кода через npm и отказ от bower уводят разработчиков от AMD всё дальше и дальше.
UMD (2011)
----------
На самом деле явное противостояние форматов модулей началось ещё до того, как AMD отделился от CommonJS Modules. Уже тогда в лагере AMD было много разработчиков, которым нравился минимальный порог вхождения для начала работы с модульным кодом. Количество приверженцев CommonJS Modules из-за роста популярности Node.js и появления Browserify тоже росло очень быстро.
Фактически у нас было два стандарта, которые не могли ужиться друг с другом. AMD-модули без модификации кода нельзя было задействовать в средах, реализующих спецификацию CommonJS Modules (Node.js), а модули CommonJS не удавалось использовать с инструментами, поддерживающими AMD: RequireJS, curl.js. Да, впоследствии появилась возможность использовать RequireJS для работы с CommonJS-модулями, но такое положение дел всё равно никого не устраивало. Именно для решения проблемы переносимости кода между разными системами модульности и был разработан паттерн UMD — [Universal Module Definition](https://github.com/umdjs/umd).
Найти настоящего автора паттерна оказалось довольно сложно — пришлось провести небольшое расследование. Сначала я обратился к автору репозитория паттернов UMD на GitHub [Эдди Османи](https://github.com/addyosmani). Он [вывел меня на](https://twitter.com/addyosmani/status/732834573340528640?replies_view=true&cursor=ABAXCjjOKwo) Джеймса Бёрка и [Криса Коваля](https://github.com/kriskowal), а они, в свою очередь, сослались на репозиторий реализации промисов [Q](https://github.com/kriskowal/q).
Со дня своего появления библиотека Q могла работать в разных окружениях: в браузере (при подключении модуля через тег script) и на сервере в Node.js и Narwhal (через CommonJS Modules). Кроме того, Джеймс Бёрк через некоторое время добавил в проект Q поддержку AMD. Затем Эдди Османи систематизировал все похожие шаблоны в одном общем репозитории, который получил название UMD. Результат подобной адаптации кода для разных систем модульности мы сейчас и называем UMD.
Давайте в качестве примера переделаем наш игрушечный модуль для одновременной работы в окружениях CommonJS и AMD:
```
(function(define) {
define(function () {
var helloInLang = {
en: 'Hello world!',
es: '¡Hola mundo!',
ru: 'Привет, мир!'
};
return {
sayHello: function (lang) {
return helloInLang[lang];
}
};
});
}(
typeof module === 'object' && module.exports && typeof define !== 'function' ?
function (factory) { module.exports = factory(); } :
define
));
```
В сердце такой реализации паттерна находится самовызывающаяся функция, аргумент которой принимает разные значения в зависимости от окружения. В качестве аргумента передаётся функция следующего вида:
```
function (factory) {
module.exports = factory();
}
```
Это если код используется как CommonJS-модуль. Если же код используется как AMD-модуль, в качестве аргумента передаётся функция define. Адаптация кода под различные окружения происходит как раз благодаря такой подмене.
Сейчас большинство разработчиков, когда им надо обеспечить возможность использования библиотеки и в браузере, и в Node.js, пользуются именно форматом UMD. Экспорт в UMD применяется в разных популярных библиотеках, например в [moment.js](https://github.com/moment/moment/blob/develop/templates/default.js) и [lodash](https://github.com/lodash-archive/lodash-cli/blob/0f68a3195aa37eca8ab13ce2d53ec4bb310edaf1/lib/listing.js#L49-L52).
Labeled Modules (2012)
----------------------
В 2010 году в комитете ТС39 началась работа над полноценной модульной системой в JavaScript. На тот момент система называлась ES6 Modules. К 2012 году уже стало примерно ясно, каким будет ее окончательный вид. Один из участников комитета, [Себастьян Маркбейдж](https://github.com/sebmarkbage) (на данный момент также ведущий разработчик React), по собственной инициативе подготовил транзитивный формат модулей. Предполагалось, что можно было бы задействовать его в средах, работающих даже с ES3, а впоследствии легко адаптировать приложение, использующее этот формат, под новый стандарт модулей. Формат получил название [Labeled Modules](https://github.com/sebmarkbage/labeled-modules-spec/wiki).
Основная идея — применение [меток](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/label) (labels). Поскольку ключевые слова import и export зарезервированы в языке, метки их использовать не могли и были придуманы соответствующие синонимы: для определения экспорта — exports, для импорта — require.
Как обычно, давайте переделаем наш пример, чтобы показать формат в действии.
```
// файл greeting.js
var helloInLang = {
en: 'Hello world!',
es: '¡Hola mundo!',
ru: 'Привет, мир!'
};
exports: var greeting = {
sayHello: function (lang) {
return helloInLang[lang];
}
};
// файл hello.js
require: './lib/greeting';
var phrase = greeting.sayHello('es');
document.write(phrase);
```
Пример конфига для сборки приложения, использующего Labeled Modules, можно посмотреть [тут](https://github.com/myshov/history_of_javascript/blob/master/4_evolution_of_js_modularity/m_labeled_modules_2012/webpack.config.js).
Как мы видим, получилось довольно элегантно. Но поскольку в 2012 году уже царствовали форматы CommonJS и AMD, конкурировать с ними было тяжело. В итоге, даже когда поддержка Labeled Modules появилась в первом [webpack](https://webpack.github.io/docs/api-in-modules.html), особого распространения среди JS-разработчиков она всё равно не получила.
YModules (2013)
---------------
Как вы наверное догадались по названию Яндекс тоже не сидел сложа руки и сделал свою собственную модульную систему ;). Зачем нам надо было создавать что-то свое, когда можно было воспользоваться существующими форматами CommonJS или AMD? Дело в том, что хотя они и предоставляют возможность определения зависимостей и должный уровень изоляции кода, но для решения наших возникших задач ни CommonJS, ни AMD не подходили.
Было два основных дополнительных требования. Для реализации асинхронных API (например API Яндекс.Карт) нужно было, чтобы JS-модули с асинхронной природой использовались как можно более прозрачно. Кроме того, требовалась возможность использовать модули с [уровнями переопределения БЭМ](https://ru.bem.info/methodology/key-concepts/#%D0%A3%D1%80%D0%BE%D0%B2%D0%B5%D0%BD%D1%8C-%D0%BF%D0%B5%D1%80%D0%B5%D0%BE%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F), иначе говоря — доопределять модули.
В 2013 году команды Карт и БЭМа окончательно выработали спецификацию новой системы, которую впоследствии воплотил в жизнь [Дмитрий Филатов](https://github.com/dfilatov) [dfilatov](https://habrahabr.ru/users/dfilatov/).
Вот реализация нашего примера с помощью [YModules](https://github.com/ymaps/modules):
```
// файл greeting.js
modules.define('greeting', function(provide) {
provide({
helloInLang: {
en: 'Hello world!',
es: '¡Hola mundo!',
ru: 'Привет, мир!'
},
sayHello: function (lang) {
return this.helloInLang[lang];
}
});
});
// файл app.js
modules.require(['greeting'], function(greeting) {
document.write(greeting.sayHello('ru'));
});
// Результат: "Привет, мир!"
```
YModules по своей структуре напоминает AMD. Основное отличие — предоставление интерфейса модуля внешнему миру происходит с помощью специальной функции `provide`, а не `return`.
Указанная особенность позволяет осуществлять «провайд» из блоков асинхронного кода, тем самым скрывая асинхронную природу модуля от внешнего мира. Например, если мы добавим в greeting.js какую-либо асинхронную работу (в данном случае — `setTimeout`), то весь код, где используется этот модуль, останется без изменений:
```
// файл greeting.js
modules.define('greeting', function(provide) {
// откладываем выполнение кода на 1 секунду
setTimeout(function () {
provide({
helloInLang: {
en: 'Hello world!',
es: '¡Hola mundo!',
ru: 'Привет, мир!'
},
sayHello: function (lang) {
return this.helloInLang[lang];
}
});
}, 1000);
});
// файл: app.js
modules.require(['greeting'], function(greeting) {
document.write(greeting.sayHello('ru'));
});
// Результат: "Привет, мир!"
```
Как было сказано выше, ещё одной отличительной чертой YModules является возможность работы с уровнями переопределения. Давайте рассмотрим её немного подробнее.
```
// файл moduleOnLevel1.js
modules.define('greeting', function(provide) {
provide({
helloInLang: {
en: 'Hello world!',
es: '¡Hola mundo!',
ru: 'Привет, мир!'
},
sayHello: function (lang) {
return this.helloInLang[lang];
}
});
});
// файл moduleOnLevel2.js
modules.define('greeting', function(provide, module) {
// переопределяем метод sayHello
module.sayHello = function (lang) {
return module.helloInLang[lang].toUpperCase();
};
provide(module);
});
// файл app.js
modules.require(['greeting'], function(greeting) {
document.write(greeting.sayHello('ru'));
});
// Результат: "ПРИВЕТ, МИР!"
```
Если выполнить этот пример, метод `sayHello` в результате доопределения модуля `greeting` изменится на новый, и текст выводимого сообщения преобразуется к верхнему регистру. Всё благодаря тому, что в YModules при повторной декларации модуля его предыдущая версия будет содержаться в его же последнем аргументе (например, `module` как в примере выше).
На данный момент YModules используется в проектах Яндекса. Ещё это основная модульная система клиентского фреймворка [i-bem.js](https://ru.bem.info/platform/i-bem/).
ES2015 Modules (2015)
---------------------
Комитет разработки ECMAScript (TC39), конечно, наблюдал за всем, что творилось в мире JavaScript. Стало очевидно, что пришло время для серьёзных изменений в языке.
В 2010 году над нативной модульной системой [начал трудиться](http://wiki.ecmascript.org/doku.php?id=harmony:modules&rev=1300916920) директор по стратегическому развитию Mozilla [Дэйв Хёрман](https://github.com/dherman). Работа над спецификацией продолжалась в течение пяти лет, причём Дейв параллельно занимался другими задачами. За это время он успел побывать в роли архитектора и ведущего разработчика в проектах asm.js, emscripten, servo.
И вот, в 2015 году была выпущена спецификация ES2015, которая, в свою очередь, содержала в себе окончательную версию [спецификации модулей](http://www.ecma-international.org/ecma-262/6.0/#sec-modules). Давайте по традиции адаптируем наш пример:
```
// файл lib/greeting.js
const helloInLang = {
en: 'Hello world!',
es: '¡Hola mundo!',
ru: 'Привет, мир!'
};
export const greeting = {
sayHello: function (lang) {
return helloInLang[lang];
}
};
// файл hello.js
import { greeting } from "./lib/greeting";
const phrase = greeting.sayHello("ru");
document.write(phrase);
```
Как мы видим, стандарт вводит абсолютно [новые конструкции языка](https://hacks.mozilla.org/2015/08/es6-in-depth-modules/) для импорта модулей через ключевое слово `import` и для экспорта кода через `export`.
Из-за того, что мы имеем дело с новыми ключевыми словами языка, а также в виду того, что спецификация Module Loader API, отвечающая за поддержку загрузки модулей в различных средах, еще не готова, мы не можем просто так взять и начать использовать новую систему модульности.
Впрочем, ES2015 всё равно применяется в большом количестве проектов. Чтобы начать использовать новый стандарт в мире, где пока ещё правит ES5, можно воспользоваться транспиляцией при помощи [Babel](https://github.com/babel/babel): это довольно распространённая практика.
Итого
-----
Существуют и другие подходы к организации модульности в JS. Некоторые из них могут переплетаться друг с другом, образуя [причудливые формы](http://requirejs.org/docs/api.html#cjsmodule), другие были созданы под [конкретные проекты](https://github.com/Artificial-Engineering/lycheejs/blob/development/projects/pong/source/Main.js#L2-L6), а какие-то создавались в качестве [транзитивного формата](https://github.com/ModuleLoader/es-module-loader/blob/v0.17.0/docs/system-register.md). Описать их все — очень непростая задача, поэтому в статье рассмотрены только более-менее популярные подходы и форматы. Тем не менее, думаю, статья помогла вам систематизировать знания о модульности, узнать о чём-то новом и о тех людях, которые стояли за упомянутыми технологиями.
Не могу не порекомендовать замечательную статью [«Путь JavaScript модуля»](https://habrahabr.ru/post/181536/) Михаила Давыдова, где модульность рассматривается вкупе с загрузчиками и бандлерами, а также приводятся плюсы и минусы всех подходов к организации модульной структуры приложения.
Примеры из статьи доступны на [GitHub](https://github.com/myshov/history_of_javascript/tree/master/4_evolution_of_js_modularity). | https://habr.com/ru/post/192874/ | null | ru | null |
# Миграция Laravel Nova с PostgreSQL на CockroachDB. Наш опыт и решение
Часто бывает, при ближайшем рассмотрении некоторая проблема выявляет более глубокую, погружаясь в решение которой находишь для себя много интересного.
О такой ситуации на одном из наших проектов и пойдет речь.
### Предыстория, описание проявления изначальной проблемы
Прежде всего, с чего все началось. Есть веб-проект, backend часть которого написана с использованием фреймворка Laravel (8.80.0 версии). В качестве админки — Laravel Nova (3.27.0 версия). Используемая СУБД — PostgreSQL. Развертка в production осуществляется посредством Kubernetes. Однажды, в силу определенных причин, было принято решение архитектурно перейти с PostgreSQL на распределенную систему управления базами данных CockroachDB. Процесс миграции был успешен.
Заметим, что изначально пытались подобрать сторонний драйвер для подключения ORM к CockroachDB. Однако выяснили, что это совершенно не требуется и стандартный драйвер pgsql прекрасно работает.
Изначальная проблема не была связана с СУБД в явном виде, а проявилась таким образом: один из ресурсов Nova использует поле со связью BelongsToManyField, предоставляемое пакетом benjacho/belongs-to-many-field, но не суть. В админке, при выборке в данном поле связанной сущности, технически данные связи должны быть записаны в pivot таблицу связи, проще говоря пара первичных ключей, связанных между собой таблиц.
Однако "сырое" значение первичного ключа таблицы, получаемое из базы данных, имеющее примерно такой вид 782610923664375809, округлялось JavaScript на стороне фронтовой части пакета до 782610923664375800. И далее в момент записи в pivot таблицу мы получили ошибку "violates foreign key constraint"
```
local.ERROR: SQLSTATE[23503]: Foreign key violation: 7 ERROR: insert on table "******" violates foreign key constraint "********_id_foreign"
DETAIL: Key (*****_id)=(782610923664375800) is not present in table "******". (SQL: insert into "******" ("***_id", "***_id") values (782611156327727105, 782610923664375800))
```
Что и понятно, так как такого ключа в ней не могло быть. В браузере это выглядело вот так:
"сырое" значение поляокругленное значение поля### Установленная основная причина
Данная проблема точности таких больших чисел в JavaScript, обусловленная природой, плавающей запятой двойной точности IEEE-754, имеет место быть сама [по себе](https://stackoverflow.com/questions/21646800/undesirable-long-number-rounding-in-chrome). Вопрос в том, как ее обойти. Возможно хорошим вариантом было бы на стороне фронта перед использованием полученного значения поля преобразовывать его в строку, но мы от этого отказались по причине того, что невозможно дорабатывать все пакеты вендоров.
> Итак, если размерность значений первичных ключей, определяемая CockroachDB столь велика, возможно ли уменьшить её изначально на стороне СУБД при создании таблицы?
>
>
### И тут началось интересное
У CockroachDB числовой тип данных представлен как INT. Однако, привычная нам размерность Integer, BigInteger есть не что иное, как алиасы на все тот же тип INT, и по сути своей одно и то же. [Вот страница](https://www.cockroachlabs.com/docs/stable/int.html#names-and-aliases) официальной документации на этот счет.
Этот факт подвел нас к тому, что попытка уменьшить размерность первичного ключа в создаваемой таблице путем строгого приведения его типа к unsignedInteger привела к созданию такового в базе все с тем же типом int8. Т.е. с чего начали, к тому и пришли.
### Внутреннее поведение CockroachDB
В принципе, разработчикам CockroachDB все это известно, очевидно архитектура ими выбрана не просто так и способы решения данной ситуации представлены [тут](https://www.cockroachlabs.com/docs/stable/int.html#considerations-for-64-bit-signed-integers).
Все сводится к двум вариантам:
1. Установить сессионную переменную default\_int\_size в значение 4, что соответствует размерности числового типа Integer (int4) и позволит создавать именно эти поля.
2. Установить sql.defaults.default\_int\_size, но уже для всего кластера
Против последнего варианта выступили наши DevOps специалисты, так как в кластере мы можем быть не одни со своей БД.
**Однако на практике было обнаружено следующее:** значение default\_int\_size учитывается при создании таблицы исключительно для обычных полей. Если поле создается нами в коде миграции как первичный ключ (с присущими ограничениями автоинкремента и уникальности), то CockroachDB принудительно определяет его с типом int8. И повлиять на это мы никак не смогли.
### Способы решения проблемы
Всего этого можно было бы избежать, если использовать uuid изначально. Вариант перехода на него мы отклонили по следующим причинам. В первую очередь пришлось бы серьезно перерабатывать 90% проектов. Также наряду с преимуществом существуют и недостатки uuid, например, большее потребление памяти, более низкая скорость работы, ограничения сортировки по первичному ключу.
Вот несколько мнений на этот счет:
[Что лучше и правильнее использовать в качестве первичного ключа: автоинкремент или UUID?](https://ru.stackoverflow.com/questions/1146838/%D0%A7%D1%82%D0%BE-%D0%BB%D1%83%D1%87%D1%88%D0%B5-%D0%B8-%D0%BF%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D1%8C%D0%BD%D0%B5%D0%B5-%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D1%8C-%D0%B2-%D0%BA%D0%B0%D1%87%D0%B5%D1%81%D1%82%D0%B2%D0%B5-%D0%BF%D0%B5%D1%80%D0%B2%D0%B8%D1%87%D0%BD%D0%BE%D0%B3%D0%BE-%D0%BA%D0%BB%D1%8E%D1%87%D0%B0-%D0%B0%D0%B2%D1%82%D0%BE%D0%B8%D0%BD%D0%BA%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D1%82-%D0%B8)
[Про uuid-ы, первичные ключи и базы данных](https://habr.com/ru/post/562936/)
Идею решения вопроса мы почерпнули опять же из официальной документации в той ее части, где объясняется [конструкция первичного ключа](https://www.cockroachlabs.com/docs/v22.1/primary-key.html).
При создании таблицы, в случае, когда первичный ключ не был определен, CockroachDB самостоятельно его создает в виде скрытого "rowid" поля (разумеется все с тем же int8 типом).
Тогда вполне возможно наряду с rowid создать отдельным порядком поле id, необходимого нам unsignedInteger типа (int4), с использованием сессионной переменной default\_int\_size. И далее добавить ему обычные ограничения первичного ключа, такие как автоинкремент и уникальность. Именно это поле id и будет в последствии использоваться ORM в связях таблиц. Вся суть именно в раздельной операции создания поля и последующего наделения его необходимыми свойствами.
Данное решение рабочее, в итоге мы получили id идентификаторы таблиц приемлемой размерности, которые не округляются JavaScript на стороне фронта, с минимальными издержками в виде правок миграций. Примеры кода ORM миграций:
```
// Создание поля id, разделение операций обязательно. Как уже сказал, без определения первичного ключа при создании таблицы, CockroachDB создаст скрытое rowid поле этого ключа
Schema::create('my_table', function (Blueprint $table) {
$table->unsignedInteger('id');
//...
});
Schema::table('my_table', function (Blueprint $table) {
$table->unsignedInteger('id')->unique()->autoIncrement()->change();
});
// В методе down() отката миграции, после создания таблицы, также необходимо удалить ее sequence структуру. Без этого повторная миграция на создание таблицы выдаст ошибку
public function down()
{
Schema::dropIfExists('my_table');
// Драйвер 'cockroach' - это простое копирование в config/database драйвера 'pgsql', один в один
if (config('database.default') === 'cockroach') {
$pdo = DB::getPdo();
try {
$pdo->query('drop sequence my_table_id_seq');
} catch (Exception $e) {
Log::channel('stderr')->info('sequence my_table_id_seq not exist');
}
}
}
// Создание pivot таблицы для связи многие-ко-многим, используемое полем BelongsToManyField в Nova
Schema::create('my_table1_my_table2', function (Blueprint $table) {
// Здесь тип идентификатора не важен, т.к. он не участвует непосредственно в связи
$table->id();
$table->unsignedInteger('my_table1_id')->nullable();
$table->foreign('my_table1_id')->references('id')->on('my_table1')->onDelete('cascade');
$table->unsignedInteger('my_table2_id')->nullable();
$table->foreign('my_table2_id')->references('id')->on('my_table2')->onDelete('cascade');
});
```
Остался вопрос переопределения PostgresConnector через дополнительный сервис провайдер с целью установки сессионной переменной default\_int\_size. Напомним, что мы подключаемся к CockroachDB через PostgeSQL драйвер.
Реализовали это вот так:
```
// app/Database/PostgresConnector
php
namespace App\Database;
use Illuminate\Database\Connectors\PostgresConnector as BaseConnector;
class PostgresConnector extends BaseConnector
{
public function connect(array $config)
{
$pdo = parent::connect($config);
if (config('database.default') === 'cockroach') {
$pdo-query('set default_int_size = 4');
}
return $pdo;
}
}
// app/Providers/DatabaseConnectorProvider
php
namespace App\Providers;
use App\Database\PostgresConnector;
use Illuminate\Support\ServiceProvider;
class DatabaseConnectorProvider extends ServiceProvider
{
public function register()
{
$this-app->bind('db.connector.pgsql', PostgresConnector::class);
}
}
// Регистрируем провайдера в config/app
'providers' => [
//...
App\Providers\DatabaseConnectorProvider::class,
],
```
Вот таким опытом мы поделились с сообществом, надеемся, кому-нибудь пригодится.
Спасибо за внимание! :) | https://habr.com/ru/post/686006/ | null | ru | null |
# AutoCAD Architecture: First project
В линейке продуктов от Autodesk, кроме базового AutoCAD, существует много специализированных продуктов, оптимизированных под различные сферы проектирования. Одним из таких продуктов является AutoCAD Architecture (ACA). Аналогично AutoCAD, для AutoCAD Architecture возможно написание плагинов на .NET. Кроме библиотек от Autodesk для работы с объектами AutoCAD Architecture можно пользоваться C++ библиотекой Teigha Architecture от Open Design Alliance, которая позволяет загружать, отрисовывать и манипулировать архитектурными объектами.
Я хочу написать серию tutorial-ов, демонстрирующих работу с архитектурными объектами с помощью Autodesk .NET API и Teigha Architecture. Начнем с самых азов: соберем и заставим работать упражнение “your first project” из документации к ACA, а затем немного расширим его для использования объектов Autodesk.Aec.Arch.DatabaseServices.Wall.
Для опытных программистов описание покажется длинным, но я считаю что первые шажки стоит описывать детально, чтобы исключить разночтения и дать возможность человеку без особых проблем запустить хотябы простейшее приложение. При дальнейшей работе проблем с ACA .NET API и так будет предостаточно.
Предыдущая моя статья, описывающая основы ACA, ~~пролетела как фанера над Ярославлем~~ попала в Geektimes и доступна здесь: [Введение в AutoCAD Architecture](http://geektimes.ru/post/260364/). Из нее можно получить поверхностное представление о том что такое AutoCAD Architecture, какие объекты в нем реализованы и в чем их особенности.
Писать плагин я буду в VS2010 а проверять работу в ACA 2013 x64. Разные версии ACA могут требовать разные версии .NET Framework, кроме этого плагин, построенный для x32 не подгрузится ACA x64.
### Шаг 1
Создаем проект Visual C# class library под названием AcaSample1 как показано на скриншоте. Версия .NET Framework у нас будет 4.
### Шаг 2
Документация советует сразу добавить в references acmgd.dll и acdbmgd.dll с необходимыми для примера классами из ACA. Эти файлы лежат в корне папки, куда установлен ACA. У меня это C:\Program Files\Autodesk\AutoCAD 2013
Добавим нужные библиотеки как показано на скриншотах ( References -> Add reference -> вкладка browse )
Если все сделано правильно, в списке References появятся две новые библиотеки:
Далее, выделяем два добавленных референса, нажимаем на них правой кнопкой, идем в свойства и ставим им свойсво copy local в false. Это сделать необходимо, чтобы в будущем избежать трудноотлавливаемых глюков. Вот что пишет документация по этому поводу:
> Setting Copy Local to False instructs Microsoft Visual Studio to not include the referenced DLL in the build output for the project. If the referenced DLL is copied to the build output folder, it can cause unexpected results when you load your assembly file in AutoCAD.
### Шаг 3
Попробуем создать код команды так, как это предлагает документация. Сэмпл из ACA почему-то оперирует объектом MText а не архитектурными примитивами. Пройдем по примеру.
Добавляем директивы using:
```
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
```
Добавляем код:
```
[assembly: CommandClass(typeof(AcaSample1.Class1))]
namespace AcaSample1
{
public class Class1
{
[CommandMethod("AdskGreeting")]
public void AdskGreeting()
{
// Get the current document and database, and start a transaction
Document acDoc = Application.DocumentManager.MdiActiveDocument;
Database acCurDb = acDoc.Database; // Starts a new transaction with the Transaction Manager
using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction())
{
// Open the Block table record for read //
BlockTable acBlkTbl;
acBlkTbl = acTrans.GetObject(acCurDb.BlockTableId, OpenMode.ForRead) as BlockTable;
// Open the Block table record Model space for write
BlockTableRecord acBlkTblRec;
acBlkTblRec = acTrans.GetObject(acBlkTbl[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;
/* Creates a new MText object and assigns it a location,
* text value and text style */
MText objText = new MText(); // Specify the insertion point of the MText object
objText.Location = new Autodesk.AutoCAD.Geometry.Point3d(2, 2, 0); // Set the text string for the MText object
objText.Contents = "Greetings, Welcome to the AutoCAD .NET Developer's Guide"; // Set the text style for the MText object
objText.TextStyleId = acCurDb.Textstyle; // Appends the new MText object to model space
acBlkTblRec.AppendEntity(objText); // Appends to new MText object to the active transaction
acTrans.AddNewlyCreatedDBObject(objText, true); // Saves the changes to the database and closes the transaction
acTrans.Commit();
}
}
}
}
```
Здесь AdskGreeting это имя команды. Впоследствии это имя нужно будет вводить в командной строке ACA, чтобы исполнить код функции AdskGreeting()
Пытаемся сбилдить… ну конечно, оно не билдится :)
Причина в том, что нам не хватает референсов, в которых определены CommandClass, CommandMethod и тд – accoremgd.dll
Эта библиотека тоже лежит в корне папки куда установлен ACA. Добавляем этот референс и ставим ему copy local в false:
Пробуем запустить билд: библиотека должна построиться без ошибок. В результате у нас получилась AcaSample1.dll
### Шаг 4
Теперь нам надо обратить внимание на платформу. Например, дефолтная платформа в 2010 студии Debug \ AnyCPU, а у меня стоит Win 7 x64 и ACA x64. При попытке загрузить эту длл ACA x64 выдаст ошибку. Поэтому мне надо поменять целевую платформу:
Перестроим проект. На этом этапе должна получиться библиотека AcaSample1.dll в AcaSample1\AcaSample1\bin\x64\Debug
Документация еще советует проверить target framework
> On the Applications tab, Target Framework drop-down list, select .NET Framework 4.0
но мы его выставляли на первом шаге при создании проекта.
### Шаг 5
Пробуем загрузить наш плагин в ACA и выполнить команду. Открываем ACA 2013 и вводим в командной строке netload ( командную строку можно вызвать комбинацией ctrl + 9, если она скрыта ). Откроется диалоговое окно для выбора плагина ( правда если переменная FILEDIA у вас стоит в 0, то окно не откроется, а будет предложено ввести пусть до dll плагина в командной строке ). Идем в папку с солюшеном, ищем AcaSample1.dll ( у меня это AcaSample1\bin\x64\Debug ) и нажимаем open:
Если ошибок небыло, ACA промолчит. Набираем команду AdskGreeting. Если ошибок небыло, автокад опять промолчит, и, скорее всего, на экране ничего не изменится. Это потому что текст слишком мал или выходит из области, на которую направлена камера. Чтобы его увидеть используем команду zoom extents из панели (вкладка view):
В результате должны увидеть такое:
Ок. С небольшими дополнениями удалось построить и запустить базовый пример из документации к AutoCAD Architecture.
### Шаг 6
Теперь попробуем сделать команду, которая использует собственно объекты ACA. Например, стены. Для этого заменим весь код примера на следующее (код кривоват, использовать только для пробы):
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Geometry;
using Autodesk.Aec.Arch.DatabaseServices;
[assembly: CommandClass(typeof(AcaSample2_Walls.Class1))]
namespace AcaSample2_Walls
{
public class Class1
{
[CommandMethod("CreateHouse")]
public static void CreateHouse()
{
Document acDoc = Application.DocumentManager.MdiActiveDocument;
Database acCurDb = acDoc.Database;
acDoc.Editor.WriteMessage("\n CreateHouse command");
using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction())
{
// Open the Block table record for read
BlockTableRecord acModelSpace = GetModelSpaceRecord(acCurDb, acTrans, OpenMode.ForWrite);
AddWallToModelSpace(new Point3d(0, 0, 0), new Point3d(5000, 0, 0), acModelSpace, acTrans);
AddWallToModelSpace(new Point3d(5000, 0, 0), new Point3d(5000, 5000, 0), acModelSpace, acTrans);
AddWallToModelSpace(new Point3d(5000, 5000, 0), new Point3d(0, 5000, 0), acModelSpace, acTrans);
AddWallToModelSpace(new Point3d(0, 5000, 0), new Point3d(0, 0, 0), acModelSpace, acTrans);
acTrans.Commit();
}
acDoc.SendStringToExecute("_-VIEW _SWISO ", true, false, false);
acDoc.SendStringToExecute("_.zoom _all ", true, false, false);
}
public static BlockTableRecord GetModelSpaceRecord(Database acDb, Transaction acTrans, OpenMode om)
{
// Open the Block table record for read
BlockTable acBlkTbl;
acBlkTbl = acTrans.GetObject(acDb.BlockTableId, OpenMode.ForRead) as BlockTable;
// Open the Block table record Model space for read
BlockTableRecord acBlkTblRec;
acBlkTblRec = acTrans.GetObject(acBlkTbl[BlockTableRecord.ModelSpace], om) as BlockTableRecord;
return acBlkTblRec;
}
private static void AddWallToModelSpace(Point3d ptS, Point3d ptE, BlockTableRecord acModelSpace, Transaction acTrans)
{
Wall w = new Wall();
w.Set(ptS, ptE, new Vector3d(0, 0, 1));
w.BaseHeight = 2500;
w.InstanceWidth = 300;
acModelSpace.AppendEntity(w);
acTrans.AddNewlyCreatedDBObject(w, true);
}
}
}
```
Мы написали новую команду CreateHouse, которая создает «дом» из четырех стен. В данном случае мы уже начали использовать объекты ACA, поэтому добавилась директива
```
using Autodesk.Aec.Arch.DatabaseServices;
```
Aec.Arch — это уже область архитектурных объектов.
Команды
```
acDoc.SendStringToExecute("_-VIEW _SWISO ", true, false, false);
acDoc.SendStringToExecute("_.zoom _all ", true, false, false);
```
поворачивают вид в изометрическую проекцию и делают вызов zoom\_extents, который ранее мы делали руками в UI ACA.
Чтобы построить этот проект в references необходимо добавить библиотеки, в которых реализованы объекты ACA. В данном примере нам потребуются AecBaseMgd.dll и AecArchMgd.dll. Не забудьте также поставить поставить им свойство Copy local в false.
У меня эти библиотеки находятся в C:\Program Files\Autodesk\AutoCAD 2013\ACA\
Все, что начинается на Aec, относится к ACA.
Строим проект, подгружаем его с помощью netload в AutoCAD Architecture 2013 и выполняем команду CreateHouse. Должно получиться так:
Заключение
----------
В данной статье я попробовал дать пошаговую инструкцию к первым попыткам программирования под ACA. Я знаю что тут есть похожие статьи про использование .NET API, но в данном случае мне захотелось изложить все подводящие шаги к использованию архитектурного API.
В следующих статьях я покажу как сделать ваше первое приложение с помощью Teigha Architecture, а затем перейду к разбору того, что же происходит в этих примерах: что такое dwg, что такое база данных куда мы добавляем стены, отличия архитектурных объектов от базовых примитивов автокада в плане работы с ними. Затем надеюсь рассмотреть более общие сценарии: как отрендерить архитектурные объекты в нужном представлении, как получить их геометрию для конвертации в другие форматы, как с ними работать и тд. | https://habr.com/ru/post/265617/ | null | ru | null |
# Патчим прошивку Android за 5 минут
### Задача
Все началось с того, что я захотел установить на планшет Digma Optima 7.61 игру GTA San Andreas. К сожалению, виртуальная SD-карта планшета имеет объем менее 1 Гб, а кэш игры весит порядка 2-3 Гб. На планшете установлен Android 4.4.2 и возможность просто взять и сменить память по умолчанию в нем отсутствует. Так же в нем отсутствует файл /etc/vold.fstab (он есть на более старых версиях андроида, и изменив данный файл с root-правами, можно поменять местами виртуальную и реальную карты памяти).
### Необходимые инструменты
1. Компьютер или ноутбук с ОС Linux.
2. Утилиты adb и fastboot (входят в состав Android SDK, так же, как заметил [tmnhy](https://habrahabr.ru/users/tmnhy/), входят в репозитории как отдельные пакеты).
3. Набор утилит [bootimg\_tools](https://forum.xda-developers.com/attachment.php?attachmentid=2100891&d=1373286397) (нашел [здесь](https://forum.xda-developers.com/showthread.php?t=2319018)).
### Решение
#### 1. Извлекаем с устройства загрузочный образ
— Подключаем устройство к компьютеру через usb-кабель и заходим в shell устройства:
```
adb shell
```
— Где-то в папке **/dev/block** на устройстве нужно найти файл с именем **boot**. У меня он находился по пути **/dev/block/by-name/boot**, но данный путь может различаться на разных устройствах.
— Извлекаем загрузочный образ:
```
dd if=/dev/block/path/to/boot of=/mnt/sdcard/boot-from-device.img
```
— Выходим из shell'а (exit) и извлекаем образ:
```
adb pull /mnt/sdcard/boot-from-device.img
```
#### 2. Затем загрузочный образ нужно разобрать
— Скачиваем и распаковываем bootimg\_tools.
— Добавляем bootimg\_tools в PATH:
```
export PATH=$PATH:/path/to/bootimg_tools
```
— Распаковываем образ:
```
unpack boot-from-device.img
```
— Если все предыдущие шаги сделаны верно, то должна появиться папка **boot-from-device**. Внутри нее должны лежать файлы **zImage** и **ramdisk.cpio.gz**, а так же папка **ramdisk**. Как раз внутри последней лежит содержимое загрузочного образа, которое мы будем патчить.
#### 3. Патчим
Для решения своей задачи я нашел строчку, которую нужно заменить, в файле init.sun8i.rc. Я просто заменил **export EXTERNAL\_STORAGE /mnt/sdcard** на **export EXTERNAL\_STORAGE /mnt/extsd**. Как я понимаю, это как раз и есть то значение, которое возвращает метод **Environment.*getExternalStorageDirectory()*** в Android API. В пользу этого предположения говорит тот факт, что после применения патча приложения начали использовать аппаратную карту памяти вместо виртуальной для хранения своих данных.
#### 4. Заменяем загрузочный образ на устройстве
Я написал для этих целей небольшой скрипт:
```
repack_ramdisk boot-from-device/ramdisk
mkbootimg --kernel boot-from-device/zImage --ramdisk boot-from-device/new-ramdisk.cpio.gz --base 0x40000000 --cmdline 'console=ttyS0,115200 rw init=/init loglevel=4' -o new_boot.img
sudo adb reboot-bootloader
sudo fastboot flash boot new_boot.img
sudo fastboot reboot
```
### Итоги
После проделанных манипуляций игра на планшете успешно заработала.
### P.S.
Все вышеописанное вы проделываете со своим устройством только на свой страх и риск. За превращение вашего девайса в кирпич автор ответственности не несет. | https://habr.com/ru/post/330566/ | null | ru | null |
# Создание Single Page Application на Marko.js — ZSPA Boilerplate
В данной статье вы познакомитесь с [Marko.js](https://markojs.com/) актуальной на данный момент пятой версии. Пару лет назад на Хабре уже была отличная [статья](https://habr.com/ru/post/529320/) (за авторством [apapacy](https://habr.com/ru/users/apapacy/)) о том, как работает этот замечательный реактивный фреймворк, разработанный где-то в недрах eBay.
Что такое Marko.js?Marko.js - это реактивный веб-фреймворк, который позволяет заниматься современной разработкой фронтенд-части вашего сайта или приложения, используя Javascript или TypeScript. По возможностям его в какой-то мере можно сравнить с React. Если кратко, то среди преимуществ Marko - быстрота, простота, легковесность, возможность создания SPA (Single Page Application), SSR (Server-Side Rendering) или изоморфных приложений (объединяющих оба подхода), и многое другое. Недостатков не так много; основным можно считать то, что он не настолько популярен и распространен, как React, Angular или Vue.
В своем комментарии (а это был далекий 2020 год) я предложил написать на Хабр статью, посвященную моему опыту работы с Marko, и вот - как с тем самым котом - время наконец пришло :-)
С 2019 года я использовал Marko.js:
* как основу для большого веб-фреймворка [ZOIA](https://github.com/xtremespb/zoia), на котором уже работает достаточно большое количество сайтов и сервисов;
* как UI для десктопных приложений на Electron;
* и, наконец, не так давно сделал простой, но функциональный boilerplate для удобного создания SPA, названный [ZSPA (ZOIA Single Page Application)](https://github.com/xtremespb/zspa) - о чем и пойдет речь в этой статье.
Почему статья не о "большой" ZOIA?Проект [ZOIA](https://github.com/xtremespb/zoia) активно развивается, и с 2019 года там сделано уже очень много. Но до того, чтобы написать полноценную документацию и допилить тесты, руки все никак не дойдут. Плюс на ZOIA в основном работают "закрытые" или интранет-проекты, а времени на то, чтобы довести до ума сайт и сконфигурировать регулярно обновляемую [демку](https://demo.zoiajs.org) не находится, поэтому для для знакомства с Marko лучше подойдет описание намного более простого boilerplate'а [ZSPA](https://github.com/xtremespb/zspa).
Итак, прежде всего - зачем все это нужно? Все чаще и чаще стала появляться необходимость делать простые сайты, где не требуется серверная логика - такие, как "одностраничники", лендинги и прочие "сайты-визитки". Есть тысяча и один способ сделать что-то подобное, почему бы не появиться ещё одному? При этом хотелось бы, чтобы новоиспеченный "велосипед" удовлетворял следующим требованиям:
* разработка с использованием компонентов (чтобы можно было их переиспользовать);
* высокая скорость загрузки и рендеринга (максимально разбивать всё на чанки и загружать только то, что нужно, используя как возможности современного HTTP протокола, так и старый добрый gzip);
* минимальный размер файлов, никаких лишних мегабайтов ненужных библиотек;
* на выходе должна быть только и исключительно статика, т.е. возможность хостить получившийся сайт буквально в утюге или одноплатнике;
* встроенная интернационализация и роутинг.
Как мне кажется, получилась достаточно красивая реализация перечисленных выше запросов. Для желающих посмотреть на демку - [велком](https://zspa.zoiajs.org/#/), ну а дальше я расскажу, как воспользоваться всем эти великолепием и что для этого потребуется.
Первым делом вам потребуется клонировать репозиторий с [GitHub](https://github.com/xtremespb/zspa):
```
git clone https://github.com/xtremespb/zspa.git
```
Дальше все стандартно, устанавливаем пакеты NPM, которые необходимы для сборки:
```
cd zspa && npm i
```
После чего вы можете запустить процесс сборки, для чего существуют два варианта - режим разработчика (build-dev), который работает быстрее, и режим продакшна (build-production), который максимально оптимизирует все ресурсы:
```
npm run build-production
```
В директории *dist* вы получите готовый сайт, который можно открыть через *index.html*.
Для того, чтобы кастомизировать содержимое, потребуется забраться "под капот" ZSPA, и далее я подробно расскажу, как это сделать, заодно выполню обещание, данное в начале статьи, и познакомлю вас с Marko ;-)
Конфигурация
------------
Сборка ZSPA осуществляется при помощи Webpack 5, а все исходники находятся в директориях *etc* и *src*. Начнем с файлов конфигурации, находящихся в *etc*, там их несколько:
### routes.json
Здесь необходимо разместить роуты, которые используются для навигации по страницам. Под капотом используется библиотека [router5](https://router5.js.org/api-reference), соответственно, подсмотреть синтаксис можно в документации. Но в целом, все понятно интуитивно, и для двух страниц из "демки" используется следующая конфигурация:
```
[{
"name": "home",
"path": ":language<([a-z]{2}-[a-z]{2})?>/",
"defaultParams": {
"language": ""
}
},
{
"name": "license",
"path": ":language<([a-z]{2}-[a-z]{2})?>/license",
"defaultParams": {
"language": ""
}
}]
```
Важным элементом пути (path) является параметр :language, который используется для корректной работы интернационализации, поэтому не следует забывать о нем.
### navigation.json
В этим файле размещается конфигурация, которая используется при рендеринге navbar'а - верхней "менюшке", которая используется для перехода между страницами. Формат этот файла также интуитивно понятен:
```
{
"defaultRoute": "home",
"routes": ["home", "license"]
}
```
В массиве *routes* перечислены все роуты, которые должны отображаться в меню навигации, а в *defaultRoute* - роут по-умолчанию.
### languages.json
Файл необходим для корректной работы интернационализации и представляет собой перечисление доступных для переключения языков:
```
{
"en-us": "English",
"ru-ru": "Русский"
}
```
Каждый идентификатор представлен в формате *xx-xx* для возможности работы с различными языковыми вариантами. Первый язык в этом списке является также языком "по-умолчанию".
### translations
В данной директории содержатся файлы с языковыми константами, используемыми для перевода. Например, локаль русского языка (ru-ru.json) выглядит следующим образом:
```
{
"title": "ZSPA",
"home": "Главная",
"license": "Лицензия"
}
```
Каждый раз, когда вы создаете новую страницу и новый роут для нее, вам необходимо соответствующим образом добавлять в файлы интернационализации ключи для роутов. Допустим, вы добавили новую страницу, создали роут *habr*, в этом случае в файлы *ru-ru.json*, *en-us.json* и т.д. необходимо добавить новый ключ:
```
"habr": "Хабрхабр"
```
Директория *translations/core* содержит файлы перевода, используемые системой, и трогать их не обязательно.
### i18n-loader.js
Данный скрипт используется для динамической загрузки файлов интернационализации. Оператор switch используется для выбора между языками и импорта необходимых языков по запросу. Чтобы Webpack смог правильно разбить код на чанки, необходимо при импорте указать соответствующий комментарий:
```
translationCore = await import(/* webpackChunkName: "lang-core-en-us" */ `./translations/core/en-us.json`);
translationUser = await import(/* webpackChunkName: "lang-en-us" */ `./translations/en-us.json`);
```
Редактировать этот файл нужно только в том случае, если потребуется добавить новую или удалить одну из существующих локалей.
### pages-loader.js
Данный скрипт используется для динамической загрузки компонентов при открытии тех или иных страниц, и он так же, как и *i18nloader.js*, необходим для корректной разбивки сайта на чанки. Файл необходимо редактировать при добавлении новых страниц, он имеет следующий формат:
```
/* eslint-disable import/no-unresolved */
module.exports = {
loadComponent: async route => {
switch (route) {
case "home":
return import(/* webpackChunkName: "page.home" */ "../src/zoia/pages/home");
case "license":
return import(/* webpackChunkName: "page.license" */ "../src/zoia/pages/license");
default:
return import(/* webpackChunkName: "page.404" */ "../src/zoia/errors/404");
}
},
};
```
Для корректной обработки ситуации, когда пользователь обращается к несуществующему роуту, в *default* прописывается импорт компонента *errors/404*.
### bulma.scss
В качестве CSS-фреймворка используется [Bulma](https://bulma.io/). Его просто кастомизировать (при помощи SASS переменных), он обладает большим количеством возможностей, и, самое главное, Bulma - модульный фреймворк, т.е. вы сможете загружать только те компоненты, которые вам потребуются. То, какие компоненты будут использоваться на вашем сайте, вы и можете указать в данном конфигурационном файле. По умолчанию импортируется всё:
```
@import "../node_modules/bulma/sass/elements/_all.sass";
@import "../node_modules/bulma/sass/components/_all.sass";
@import "../node_modules/bulma/sass/form/_all.sass";
@import "../node_modules/bulma/sass/grid/_all.sass";
@import "../node_modules/bulma/sass/helpers/_all.sass";
@import "../node_modules/bulma/sass/layout/_all.sass";
```
Всегда можно закомментировать этот блок и убрать комментарии там, где это действительно нужно.
Исходники
---------
На этом конфигурация завершена, и можно переходить к редактированию исходников, т.е. к директории *src*, имеющей достаточно понятную структуру:
* в директории *favicon* размещаются файлы favicon'ов, тех самых пиктограмм (иконок) сайта, которые отображаются в левой части перед названием страницы (если вы хотите уточнить, что именно будет копироваться из этого перечня - посмотрите на плагин *CopyWebpackPlugin*, используемый в *webpack.config.js* - там перечислены все копируемые в *dist* файлы);
* директория *images* содержит изображения, которые будут использоваться на сайте (по умолчанию там лежит лого ZOIA);
* в директории *misc* располагаются вспомогательные файлы (на данный момент там только *robots.txt*, но в следующих версиях может появиться что-то ещё);
* файл *variables.scss* содержит значения переменных для Bulma (цвета, отступы, шрифты и т.д.), и именно здесь можно начать кастомизацию дизайна;
* в директории *zoia* находятся "исходники" вашего сайта.
Точкой входа в приложение является файл *index.js*. Все, что там происходит - это загрузка файла *index.marko* и его рендеринг:
```
import template from "./index.marko";
(async () => {
template.render({}).then(data => data.appendTo(document.body));
})();
```
Сам файл *index.marko* содержит один-единственный тег:
Особенностью Marko является то, что в точке входа нельзя напрямую размещать какую-либо логику, иначе на странице не будут подгружаться стили. Поэтому подобный workaround с подключением "корневого компонента" является наиболее простым решением проблемы.
Компонент *zoia* находится в директории *src*. Для того, чтобы Marko "знал", где искать компоненты, существуют специальные файлы - *marko.json*, в которых можно перечислить пути для поиска:
```
{
"tags-dir": ["./"]
}
```
Компоненты Marko могут состоять как из одного файла, так из нескольких, что достаточно подробно описано [в документации](https://markojs.com/docs/class-components/). Я рекомендую использовать "однофайловые" компоненты только в случае крайней и осознанной необходимости, а во всех остальных случаях разбивать их на три файла - *index.marko* (собственно, Marko-код компонента), *component.js* (логика компонента, написанная на Javascript) и *style.css* (файл стилей, можно также использовать и формат .scss). Все файлы, кроме *index.marko*, являются опциональными, т.е. компонент может не иметь стилей или логики.
Синтаксис Marko ничем не отличается от обычно HTML, и это является основной "фишкой" этого фреймворка. Т.е. все, что вам потребуется знать для того, чтобы начать делать свои страницы или компоненты - это обычный HTML. Но, в случае необходимости, вы сможете использовать все возможности, которые предоставляет Marko, такие, как [условные операторы и списки](https://markojs.com/docs/conditionals-and-lists/):
```
[Log in](/login)
[Log out](/logout)
Hey ${user.name}!
* ${index}: ${color}
```
Файлы component.js экспортируют класс, который может содержать несколько используемых Marko методов, таких, как *onCreate* и *onMount*:
```
module.exports = class {
async onCreate() {
const state = {
iconWrapOpacity: 0,
};
this.state = state;
await import(/* webpackChunkName: "error500" */ "./error500.scss");
}
onMount() {
setTimeout(() => this.setState("iconWrapOpacity", 1), 100);
}
};
```
Подробнее о классах, используемых Marko, можно почитать [в документации](https://markojs.com/docs/class-components/).
Компонент *zoia*, используемый как точка входа, также является мультифайловым. Файл *zoia/index.marko* используется как основной шаблон страницы, и именно этот файл требуется редактировать для кастомизации дизайна страницы. В свою очередь, файл *zoia/component.js* содержит всю логику, связанную с обработкой событий (переключение языков, нажатие на "бургер" в "мобильной" версии и т.д.).
В директории компонента zoia также содержится несколько "вложенных" компонентов, которые используются для рендеринга:
* *navbar* - навигационная панель, отображаемая сверху;
* *core* - системные компоненты, реализующие функционал интернационализации, роутинга и т.д.;
* *errors* - компоненты, отвечающие за ситуации, связанные с возникновением различных ошибок ("страница не найдена" или "фатальная ошибка");
* *pages* - компоненты, соответствующие роутам, используемым на сайте: именно здесь необходимо размещать страницы с контентом, которые технически будут представлять собой обычные компоненты Marko.
Поскольку страницы представляют собой обычные компоненты, то их структура в простейшем виде может быть представлена в виде обычного HTML (Marko) файла. Но для реализации полноценной многоязычности требуется немного более сложная структура, которую мы рассмотрим на примере главной страницы (компонент *home*).
Итак, компонент *home* имеет следующую структуру:
* index.marko
```
$ const { t } = out.global.i18n;
${t("home")}
============
<${state.currentComponent}/>
```
В начале мы импортируем метод *t*, который, в свою очередь, экспортирует библиотека интернационализации (*src/zoia/core/i18n*). Данный метод необходим для того, чтобы обращаться к загруженным файлам перевода по ключу. Обратите внимание, что непосредственно в коде Marko вы можете использовать Javascript, указав для этого оператор *$* в начале строки.
Для обращения к переменным или функциям в Marko используется синтаксическая конструкция *${...}*, как *${t("home")}* в коде выше - вызов функции *t* для перевода соответствующей строки.
В свою очередь, конструкция *<${state.currentComponent}/>* является т.н. [динамическим тегом](https://markojs.com/docs/syntax/#dynamic-tagname), который подгружает соответствующий компонент в зависимости от значения переменной. Переменная *state* ссылается на состояние компонента, определенное в методе *onCreate* (файл *component.js*):
```
/* eslint-disable import/no-unresolved */
module.exports = class {
onCreate(input, out) {
const state = {
language: out.global.i18n.getLanguage(),
currentComponent: null,
};
this.state = state;
this.i18n = out.global.i18n;
this.parentComponent = input.parentComponent;
}
async loadComponent(language = this.i18n.getLanguage()) {
let component = null;
const timer = this.parentComponent.getAnimationTimer();
try {
switch (language) {
case "ru-ru":
component = await import(/* webpackChunkName: "page.home.ru-ru" */ "./home-ru-ru");
break;
default:
component = await import(/* webpackChunkName: "page.home.en-us" */ "./home-en-us");
}
this.parentComponent.clearAnimationTimer(timer);
} catch {
this.parentComponent.clearAnimationTimer(timer);
this.parentComponent.setState("500", true);
}
this.setState("currentComponent", component);
}
onMount() {
this.loadComponent();
}
async updateLanguage(language) {
if (language !== this.state.language) {
setTimeout(() => {
this.setState("language", language);
});
}
this.loadComponent(language);
}
};
```
Метод *loadComponent* необходим для того, чтобы при смене языка был загружен соответствующий дочерний компонент (в данном случае, это либо *home-ru-ru*, либо *home-en-us*). Используя динамический импорт, мы добиваемся загрузки соответствующего чанка только в том случае, если он в явном виде запрашивается пользователем. Подобный подход позволяет загружать не весь компонент целиком, что экономит трафик, особенно для объемных страниц.
При помощи *this.parentComponent* мы можем обратиться к "родительскому" компоненту и вызвать ряд необходимых методов оттуда:
* в случае долгой загрузки страницы (более 500 мс) на странице отображается анимация загрузки (спиннер);
* в случае ошибки во время загрузки чанка (либо других исключений) отображается содержимое компонента *errors/500*, по умолчанию там иконка робота на темно-сером фоне.
Вызов метода *loadComponent* происходит во время рендеринга (монтирования) страницы в *onMount* и при смене локали (в методе *updateLanguage*, который компонент *zoia* вызывает для каждой страницы).
Таким образом, добавление новой страницы сводится к созданию нового компонента в *src/zoia/pages* и редактированию настроек в *etc*.
Что дальше
----------
А дальше вы можете использовать boilerplate ZSPA так, как посчитаете нужным - например, чтобы сделать свой сайт, или форкнуть в качестве основы для своего проекта. Делайте все, что позволяет лицензия MIT.
Также буду рад любой конструктивной критике, особенно в виде [Issues](https://github.com/xtremespb/zspa/issues), а также вашим Pull Request'ам. Например, будет здорово сделать локализации на другие языки, ничего кроме английского и немецкого я не знаю.
Ну и, разумеется, да начнётся холивар в комментах :) | https://habr.com/ru/post/647641/ | null | ru | null |
# Большие файлы и Sinatra
Недавно столкнулся с интересной проблемой, когда попытка отдать большой файл через `Sinatra::Helpers.send_file` приводила к отжиранию всей оперативной памяти (типичный размер файла — 14Gb).
Исследование показало, что [Sinatra](http://www.sinatrarb.com/) сама читает и отдает файл кусками по 512 байт, но web-сервер thin (а также WEBrick) буферизует вывод в оперативной памяти на своем уровне, что и приводит к таким печальным последствиям.
Для решения проблемы достаточно оказалось перейти на web-сервер [Rainbows](http://rainbows.rubyforge.org/) (web-сервер, базирующийся на коде unicorn, но предназначенный для работы без проксирования, для медленных клиентов и/или сервисов). Но при отдаче больших файлов процесс кушал порядка 30% CPU на одном ядре.
Rainbows позволяет [оптимизировать отдачу файлов](http://rainbows.rubyforge.org/Static_Files.html), используя, к примеру, гем sendfile, который предоставляет соответствующие API операционной системы. Но для этого необходимо, чтобы отдача файла шла через Rack::File API.
В текущей master-ветке Sinatra метод send\_file переписали, используя API Rack::File, поэтому мы можем просто бэкпортировать соответствующий функционал в существующие версии гема Sinatra:
```
if Sinatra::VERSION < '1.3.0' && Rack.release >= '1.3'
# Monkey patch old Sinatra to use Rack::File to serve files.
Sinatra::Helpers.class_eval do
# Got from Sinatra 1.3.0 sources
def send_file(path, opts={})
if opts[:type] or not response['Content-Type']
content_type opts[:type] || File.extname(path), :default => 'application/octet-stream'
end
if opts[:disposition] == 'attachment' || opts[:filename]
attachment opts[:filename] || path
elsif opts[:disposition] == 'inline'
response['Content-Disposition'] = 'inline'
end
last_modified opts[:last_modified] if opts[:last_modified]
file = Rack::File.new nil
file.path = path
result = file.serving env
result[1].each { |k,v| headers[k] ||= v }
halt result[0], result[2]
rescue Errno::ENOENT
not_found
end
end
end
```
При этом файл конфигурации rainbows будет выглядеть примерно так:
```
# try to use sendfile when available
begin
require 'sendfile'
rescue LoadError
end
Rainbows! do
use :ThreadSpawn
end
```
Теперь мы используем эффективную технику отдачи файлов, если в системе установлен гем rack версии 1.3 или выше, и установлен гем sendfile. Кстати, при использовании ruby 1.9 гем sendfile, скорее всего, не потребуется.
P.S.: Если ваш сервис находится за прокси-сервером, то более оптимально использовать возможности, предоставляемые прокси-серверами, к примеру, API [X-Accel-Redirect (nginx)](http://wiki.nginx.org/XSendfile) или X-Sendfile (Lighttpd, Apache). | https://habr.com/ru/post/120305/ | null | ru | null |
# Оптимизация кода для платформы Эльбрус на простых примерах
*"Обычно хакер пишет программы не ради выгоды,
а ради собственного удовольствия. Такая программа
может оказаться полезной, а может остаться
всего лишь игрой интеллекта."
Генри С. Уоррен. Алгоритмические трюки для программистов [1]*
Сегодня мы продолжим наши заметки об Эльбрусе. Первую статью, посвященную запуску и оптимизации системы распознавания паспорта, можно прочитать [тут](https://habrahabr.ru/company/smartengines/blog/304750/).
Однажды мы с коллегами заинтересовались, как самые простые методы оптимизации работают на Эльбрусе.
Процессор Эльбрус имеет VLIW (Very Long Instruction Word) архитектуру — то есть оперирует “широкими” командными словами. Это означает, что компилятор lcc анализирует исходный код программы при компиляции, определяет зависимости между командами и формирует широкие командные слова. В одном таком слове можно уместить до 23 действий, которые будут исполняться одновременно. Если использовать SIMD (Single Instruction Multiple Data), то это число может возрасти до 33 и более операций. Команды в широком слове исполняются параллельно, обеспечивая загрузку всех 6 арифметико-логических устройств на каждом процессоре. Распараллеливание и загрузка всех вычислителей целиком ложится на плечи оптимизирующего компилятора, что позволяет значительно упростить аппаратуру для анализа и исполнения команд и снизить энергопотребление до 45 Вт для Эльбрус-4С [2, 3].
Мы в Smart Engines задались вопросом, как будут работать все привычные оптимизации, такие как, например, развертывание циклов, на столь непривычной платформе с “умным” компилятором.
Мы рассмотрели простые примеры на С++ и сравнили результаты работы на Эльбрус-4С и Intel Core i7-6700K. На Эльбрусе использовался компилятор lcc версии 1.20.17, для Core i7 — Microsoft Visual Studio Community 2015. Для lcc мы использовали флаги компиляции -O3 и -ffast-math.
Для начала, приведем характеристики Эльбрус-4С и Intel Core i7-6700K:
| | Эльбрус-4С | Intel Core i7-6700K |
| --- | --- | --- |
| Архитектура | Эльбрус | Skylake-S |
| Частота, GHz | 0.8 | 4 |
| Число ядер | 4 | 4 (8 c Hyper-Threading) |
| Технологический процесс | 65 nm | 14 nm |
| Cache L1 size, data | 64 Kb | 32 Kb |
| Cache L1 size, instructions | 128 Kb | 32 Kb |
| Cache L2 size | 8 Mb | 1 Mb |
| Cache L3 size | - | 8 Mb |
| Тип оперативной памяти | DDR3-1600 | DDR4-2133 |
| Потребляемая мощность, Вт | 45 | 91 |
Тактовая частота этих процессоров значительно отличается: 800 МГц у Эльбрус-4С и 4 ГГц у Intel Core i7. Также заметим, что Эльбрус имеет другую структуру кэш-памяти: отсутствует L3 кэш, однако размер L2 кэша составляет 8 Mb (по 2 Mb на ядро), в то время как у рассмотренного Core i7 1 Mb (по 0.25 Mb на ядро). L1 кэш на Эльбрусе также больше, особенно кэш инструкций (128 Kb против 32 Kb).
**Пример 1. Развертывание циклов**
Эта оптимизация направлена на уменьшение числа итераций цикла (а значит и уменьшение количества проверок условия выхода из цикла) путем увеличения тела цикла. Такая оптимизация хорошо подходит для простых циклов, которые встречаются практически в каждой программе.
Теперь рассмотрим пример:
```
#define N 64000
unsigned int x = 0;
unsigned int a[N];
for (int i = 0; i < N; ++i)
a[i] = i;
//Оптимизируемый цикл
for (int k = 0; k < N;)
{
x += a[k];
a[k++] = k;
}
```
Последний цикл мы и попробовали развернуть. Результаты замеров времени (для 10000 итераций цикла) приведены в таблице 1. Стоит отметить, что на Эльбрусе использовался 32-битный режим адресации (флаг компилятора -mptr32). Мы также рассчитали время работы на 1 ГГц путем умножения измеренного времени на тактовую частоту процессора в ГГц. Полученная таким образом безразмерная величина позволяет сравнить производительность Эльбрус и Core i7 с учетом различия в тактовой частоте.
Таблица 1. Время работы в зависимости от N — числа развернутых итераций.
| | Эльбрус-4С | Эльбрус-4С | Intel Core i7 | Intel Core i7 |
| --- | --- | --- | --- | --- |
| N | Время, мс | Время в пересчете на 1 ГГц | Время, мс | Время в пересчете на 1 ГГц |
| 1 | 401 | 320 | 255 | 1020 |
| 2 | 400 | 320 | 275 | 1100 |
| 4 | 401 | 320 | 261 | 1044 |
| 8 | 401 | 320 | 247 | 988 |
| 16 | 401 | 320 | 361 | 1444 |
| 32 | 452 | 362 | 262 | 1048 |
| 64 | 451 | 362 | 262 | 1048 |
Можно видеть, что развертывание цикла в данном примере не дает выигрыша во времени работы как на современном Core i7, так и на Эльбрус-4С. В случае совсем простого цикла, который мы рассмотрели, Эльбрус-4С работает эффективнее Core i7 с учетом отношения частот.
**Пример 2. Обработка данных различной длины**
В этом примере мы обрабатываем массив по 1, 4 или 8 байтам. Исходный массив `а` был выровнен на 8 байт.
```
#define MASK1 0xF1
#define MASK4 0xF1F2F3F4
#define MASK8 0xF1F2F3F4F5F6F7F8
for (k = 0; k < n; ++k)
{
а[k] &= MASK1;
}
```
Результаты замеров времени приведены в таблице 2.
Таблица 2. Время работы в зависимости от N — числа обрабатываемых байт.
| | Эльбрус-4С | Эльбрус-4С | Intel Core i7 | Intel Core i7 |
| --- | --- | --- | --- | --- |
| N | Время, мс | Время в пересчете на 1 ГГц | Время, мс | Время в пересчете на 1 ГГц |
| 1 | 2400 | 1920 | 811 | 3244 |
| 4 | 600 | 480 | 201 | 804 |
| 8 | 300 | 240 | 102 | 408 |
Можно видеть, что обработка по 4 и 8 байт работает быстрее как на современном Core i7, так и на Эльбрус-4С, причем времена уменьшаются кратно числу обрабатываемых байт. Кроме того, Эльбрус работает эффективнее Core i7 с учетом отношения частот.
**Пример 3. Использование SIMD**
В этом примере мы решили протестировать интринсики и рассмотрели вычисление скалярного произведения чисел типа `float` при `n = 12800`.
Неоптимизированный цикл:
```
float result = 0.0;
for (int i = 0; i < n; ++i)
{
result += x[i] * y[i];
}
```
С использованием SSE:
```
float *pX = x;
float *pY = y;
__m128 Sum = _mm_setzero_ps();
int num = n / 4;
for (int i = 0; i < num; ++i, pX += 4, pY += 4)
{
Sum = _mm_add_ps(Sum, _mm_mul_ps(_mm_load_ps(pX), _mm_load_ps(pY)));
}
float result = _mm_extract_ps(Sum, 0) + _mm_extract_ps(Sum, 1) + _mm_extract_ps(Sum, 2) + _mm_extract_ps(Sum, 3);
```
С использованием EML [4] (оптимизированная библиотека под Эльбрус):
```
double result;
eml_Vector_DotProd_32F(x, y, n, &result);
```
Результаты замеров времени приведены в таблице 3. Размер SIMD-регистра на Эльбрус-4С составляет 64 бита (instruction set версии 3), что в общем-то соответствует наблюдаемому ускорению в 2 раза между версией без оптимизаций и версией с SIMD. На Core i7 все тоже довольно правдоподобно, мы оперировали 128-битными регистрами, в которые помещается 4 числа типа float. Кроме того, заметно, что Эльбрус без интринсиков работает эффективнее Core i7 с учетом частоты, а вот с интринсиками времена работы практически совпадают.
Таблица 3. Время работы подсчета скалярного произведения.
| | Эльбрус-4С | Эльбрус-4С | Intel Core i7 | Intel Core i7 |
| --- | --- | --- | --- | --- |
| | Время, мс | Время в пересчете на 1 ГГц | Время, мс | Время в пересчете на 1 ГГц |
| Без оптимизации | 263 | 210 | 99 | 396 |
| С SIMD | 110 | 88 | 24 | 96 |
**Пример 4. Подсчет расстояния Хэмминга между двумя массивами**
Здесь мы вычисляли расстояние Хэмминга между двоичным представлением двух массивов, т.е. взяли расстояния Хэмминга между двоичными представлениями соответствующих чисел в массивах и нашли их сумму. Для массивов с 8-битными данными мы использовали побитовое ИСКЛЮЧАЮЩЕЕ ИЛИ и предподсчитанную таблицу расстояний:
```
int result = 0;
for (int i = 0; i < n; ++i)
{
result += popcnt_table[x[i] ^ y[i]];
}
```
Для 32- и 64-битных данных мы использовали побитовое логическое ИСКЛЮЧАЮЩЕЕ ИЛИ и интринсики `_mm_popcnt_u32, _mm_popcnt_u64` на Intel и интринсики `__builtin_e2k_popcnts, __builtin_e2k_popcntd` на Эльбрусе. Общая длина массивов x и y в байтах оставалась неизменной и равной n = 512. Результаты замеров времени приведены в таблице 4.
Таблица 4. Время подсчета расстояния Хэмминга в зависимости от числа обрабатываемых байт N.
| | Эльбрус-4С | Эльбрус-4С | Intel Core i7 | Intel Core i7 |
| --- | --- | --- | --- | --- |
| N | Время, мс | Время в пересчете на 1 ГГц | Время, мс | Время в пересчете на 1 ГГц |
| 1 | 630 | 504 | 155 | 620 |
| 4 | 110 | 88 | 47 | 188 |
| 8 | 76 | 61 | 15 | 60 |
В этом примере мы видим, что интринсики для подсчета числа единиц в 64-битном и 32-битном регистрах и на Эльбрусе, и на Core i7 дают значительное ускорение относительно версии с предподсчитанной таблицей. Кроме того, 32-битная команда popcnt на Эльбрусе работает быстрее, чем на Core i7 с учетом отношения частот. А вот в 64-битной случае времена работы на Core i7 и Эльбрусе сравнялись.
**Пример 5. Устранение зависимости по данным**
Данный пример позаимствован из книги Криса Касперски “Техника оптимизации программ. Эффективное использование памяти” [5]. Он демонстрирует, как устранение зависимости по данным помогает повысить производительность. Массив `a` заполнен нулями, `n = 2097152`.
Пример с зависимостью по данным:
```
int x = 0;
for (size_t a = 0; a < BLOCK_SIZE; a += 8 * sizeof(int))
{
x = *(int *)((char *)p1 + a + 0 * sizeof(int));
a += x;
x = *(int *)((char *)p1 + a + 1 * sizeof(int));
a += x;
x = *(int *)((char *)p1 + a + 2 * sizeof(int));
a += x;
x = *(int *)((char *)p1 + a + 3 * sizeof(int));
a += x;
x = *(int *)((char *)p1 + a + 4 * sizeof(int));
a += x;
x = *(int *)((char *)p1 + a + 5 * sizeof(int));
a += x;
x = *(int *)((char *)p1 + a + 6 * sizeof(int));
a += x;
x = *(int *)((char *)p1 + a + 7 * sizeof(int));
a += x;
}
```
Каждый следующий индекс элемента зависит от значения, вычисленного предыдущей командой, поэтому загрузка элементов из памяти происходит последовательно, после завершения выполнения предыдущей инструкции.
Теперь код без зависимости:
```
int x = 0;
for (size_t a = 0; a < BLOCK_SIZE; a += 8 * sizeof(int))
{
x += *(int *)((char *)p2 + a + 0 * sizeof(int));
x += *(int *)((char *)p2 + a + 1 * sizeof(int));
x += *(int *)((char *)p2 + a + 2 * sizeof(int));
x += *(int *)((char *)p2 + a + 3 * sizeof(int));
x += *(int *)((char *)p2 + a + 4 * sizeof(int));
x += *(int *)((char *)p2 + a + 5 * sizeof(int));
x += *(int *)((char *)p2 + a + 6 * sizeof(int));
x += *(int *)((char *)p2 + a + 7 * sizeof(int));
}
```
Результаты замеров времени приведены в таблице 5. Устранение зависимости по данным работает как на Эльбрусе, так и на Core i7, причем на Core i7 время работы различается примерно в 11 раз, а на Эльбрусе — практически в 20! Код с зависимостью по данным отработал на Эльбрусе медленнее, чем на Core i7 в пересчете на 1 ГГц, а вот без зависимости Эльбрус всего в 4 раза медленнее Core i7 (при различии частот в 5 раз). Такие результаты на Эльбрусе можно объяснить наличием механизма асинхронной подкачки массивов (array prefetch buffer), которая работает эффективно, если подкачиваемые элементы располагаются последовательно.
Таблица 5. Время чтения зависимых и независимых данных.
| | Эльбрус-4С | Эльбрус-4С | Intel Core i7 | Intel Core i7 |
| --- | --- | --- | --- | --- |
| | Время, мс | Время в пересчете на 1 ГГц | Время, мс | Время в пересчете на 1 ГГц |
| Зависимые данные | 605 | 484 | 87 | 348 |
| Независимые данные | 32 | 26 | 8 | 32 |
**Пример 6. Многопоточные вычисления**
Разумеется, мы не могли не рассмотреть такой метод оптимизации, как распараллеливание. Для чистоты эксперимента мы взяли полностью независимые задачи (вычисление скалярного произведения двух массивов типа double). В таблице 6 приведено время последовательной работы N задач (Tпосл), время работы N задач в N потоков (Tпар) и ускорение E:
Таблица 6. Время последовательного и параллельного вычисления скалярного произведения в зависимости от числа задач и потоков N.
| | Эльбрус-4С | Эльбрус-4С | Эльбрус-4С | Intel Core i7 | Intel Core i7 | Intel Core i7 |
| --- | --- | --- | --- | --- | --- | --- |
| N | Tпосл, мс | Tпар, мс | E=Tпосл/Tпар | Tпосл, мс | Tпар, мс | E=Tпосл/Tпар |
| 2 | 2628 | 1316 | 2.00 | 1033 | 500 | 2.07 |
| 4 | 5259 | 1318 | 3.99 | 1994 | 500 | 3.99 |
| 8 | 10513 | 2634 | 3.99 | 3987 | 503 | 7.93 |
| 16 | 21045 | 5268 | 4.00 | 7980 | 1009 | 7.91 |
| 20 | 26321 | 6583 | 4.00 | 9967 | 1263 | 7.89 |
| 32 | 42053 | 10535 | 3.99 | 15948 | 2014 | 7.92 |
| 40 | 52566 | 13170 | 3.99 | 19936 | 2528 | 7.89 |
Видно, что на Core i7 ускорение практически в 8 раз достигается на 8 потоках и дальше варьируется незначительно. На Эльбрусе ускорение в 4 раза достигается на 4 потоках и также с увеличением числа потоков не меняется. Соотношение по скорости между Эльбрус и Core i7 оказалось равным примерно 2.6, в то время как отношение частот равно 5.
**Выводы**
Привычные методы ускорения вычислений вполне работают на Эльбрусе и в этом плане программирование для него не требует специфических знаний и умений. В рассмотренных элементарных примерах для оптимизации кода Эльбрус показал себя просто замечательно с учетом тактовой частоты в 800 МГц и в два раза меньшей потребляемой мощности по сравнению с Core i7.
P.S. А еще мы запустили нашу систему распознавания паспорта на SPARC! Это означает, что теперь мы сможем писать статьи о распознавании на еще одной вычислительной архитектуре.
**Update**. В результаты примера 1 вкралась ошибка, благодаря комментариям [VLev](https://habrahabr.ru/users/vlev/) мы ее обнаружили и исправили. Результаты обновлены.
#### Использованные источники
[1] Генри С. Уоррен, мл. Алгоритмические трюки для программистов. М.: Издательский дом "Вильямс", 2014. ISBN 978-5-8459-1838-3 – 512 С.
[2] <http://www.elbrus.ru/arhitektura_elbrus>.
[3] <http://www.mcst.ru/mikroprocessor-elbrus4s>.
[4] <http://www.mcst.ru/vysokoproizvoditelnye_biblioteki>.
[5] Крис Касперски. “Технологии оптимизации программ. Эффективное использование памяти”. Спб.: БХВ-Петербург, 2003. ISBN 5-94157-232-8 – 464 С. | https://habr.com/ru/post/317672/ | null | ru | null |
# uid.me — сервис личных страниц (технические детали inside)
*Добрый день, Хабр!*
*Мы хотим сделать обзорный пост, посвящённый нашему новому проекту. Обзор затронет как функционал, так и техническую часть, надеемся, это сделает статью интересной как профессиональным разработчикам, так и тем, кто читает Хабр с целью держать руку на пульсе Технологии.*
Тем, кому интересна только техническая сторона проекта — рекомендуем сразу перейти ко [второй части](http://habrahabr.ru/post/204714/#tech).
**ЧАСТЬ 1. Лирическая**
Мы — это команда разработки сервиса личных страниц [uid.me](http://uid.me/).
Личная страница — это, например, вот так:
<http://uid.me/dikaya>
<http://uid.me/pavel_kudinov>
*Тем, кто не знаком с западным аналогом нашего сервиса, следует признаться: проект **uid.me** начинает свою историю как клон-локализация англоязычного сервиса about.me*
**История создания**
Дело было так. Компания сайт-билдер uCoz, в которой мы трудимся, за 8 лет существования накопила в недрах своих дата-центров более 35 млн профилей, созданных веб-мастерами, а также многочисленными посетителями созданных веб-мастерами сайтов, форумов и блогов.
Всех этих людей объединяет глобальная система авторизации uID:
До сегодняшнего дня каждый человек, зарегистрированный в uCoz, имел профиль такого вида:
<http://3707164671.uid.me/>
Проект **about.me** был выбран как лучший существующий прототип индивидуальной страницы для каждого пользователя uCoz, отвечающий, на наш взгляд, современному тренду самовыражения обитателей Сети начала XXI века.
Как и в случае **about.me**, мы даём пользователю:
1. Ставший правилом хорошего тона URL вида **uid.me/имя\_фамилия**, который вполне можно использовать для печати на визитной карточке, указать в качестве домашней страницы в skype, а также упоминать на любом медиа-носителе.
2. Возможность объединить в единый визуальный образ личное фото, фоновое изображение в высоком разрешении, основную информацию о себе (такую как биография и сфера интересов).
3. Конструктор, с помощью которого можно быстро и увлекательно придать своей личной странице уникальный вид и общую визуальную согласованность.
4. И, наконец, самое интересное: сегодня многие из нас активно присутствуют в социальных сетях. Кому-то ближе форматы Facebook и Вконтакте, кто-то ограничивается микроблогами Twitter и Instagram, кое-кто имеет свой популярный канал на Youtube.
И здесь справедливо правило — чем большую социальную активность проявляет человек, тем острее встаёт вопрос: “какую из социальных сетей считать “главной”?”.
Мы предлагаем использовать **uid.me** в качестве своеобразной личной визитной карточки онлайн. Наш сервис позволяет привязать к собственному профилю наиболее распространённые социальные сети, и тогда не придётся выбирать — какую именно ссылку дать при новом ценном знакомстве, указать в профиле skype или поставить в подпись на форуме.
Ваши посты, твиты и фотографии будут автоматически появляться в вашем профиле, причём для отображения будет использован общий вид, а функция “поток” создаст общую ленту событий, объединяя в хронологическом порядке всё происходящее с вами.
Кстати, если вы захотите создать личную страницу на **uid.me**, рекомендуем воспользоваться автоматической регистрацией через социальную сеть. При клике по любой из кнопок “**Войти через**” — личная страница будет мгновенно создана без необходимости вводить регистрационную информацию!
Забегая вперёд, хотим сказать, что тесная интеграция с социальными сетями в ближайшем будущем существенно сместит план развития проекта.
Вторая версия профилей **uid.me**, уже находящаяся в разработке, будет иметь главный фокус именно на функции объединения информации из социальных сетей в единый поток с настраиваемым представлением данных.
В дополнение планируется разработать несколько интересных инфографических виджетов в виде красочных графиков и диаграмм, представляющих информацию о ваших друзьях, путешествиях, музыкальных предпочтениях и прочие интересные занимательные факты, которые система сумеет извлечь из ваших профилей и обработать автоматически.
Возможно, это будет выглядеть как-то так:
**ЧАСТЬ 2. Техническая**
Разрабатывая **uid.me** под крылом uCoz, мы оказались в довольно необычном положении: с одной стороны, весь код проекта предполагалось написать с чистого листа, с другой стороны, в день релиза проект автоматически становился высоконагруженным, так как должен был импортировать в себя более 20 млн профилей, даже с учётом того, что бот-регистрации и совсем уж древние профили не прошли конкурс.
Тем не менее, мы решили сделать всё красиво и с использованием модных технологий, проведя таким образом разведку боем, получив много опыта и потенциальный левелап в итоге.
В качестве слагаемых успеха были выбраны:
0. Nginx. Куда без него.
1. База данных, из коробки решающая вопрос распределения данных на несколько серверов + отказоустойчивость при физическом выпадении сервера из кластера по любой причине. В этом качестве, несмотря на активные холивары, была выбрана MongoDB.
2. Гибкая схема данных, позволяющая без потерь проходить первичную и последующие фазы прототипирования функционала. Опять же помог MongoDB, хотя здесь пришлось заплатить ресурсами за удобство, так что получить главный ответ на вопрос: “BSON — это роскошь, или современное средство передвижения?” — ещё предстоит.
Стоит заметить, что исходная mysql база данных пользовательских профилей при конвертации в MongoDB формат выросла в 5 раз. Однако, каждый профиль при этом обогатился внушительным количеством новых данных, связанных с функционалом **uid.me**, поэтому дело не только в прожорливости гибкой схемы данных BSON.
3. Честно говоря, учитывая современную тенденцию к активному применению динамических JS интерфейсов (а также безмерное уважение к технологическому прорыву, сделанному инженерами Google при разработке V8 Javascript, на порядок обходящему по производительности все существующие скриптовые языки за счёт динамической компиляции в машинный код), закралась шальная мысль применить node.js и замкнуть круг веб-разработки на JavaScript, получив вместе с тем несколько жирных плюшек…
Но решили, что “*один проект — одна новая технология, и нам пока что MongoDB ВОТ ТАК хватает*” (с) Александр Соловьев. Кстати, кто не видел этот [его доклад](http://www.youtube.com/watch?v=R4sTvHXkToQ&list=PLPcgQFk9n9y8HmyTA96ycBxHBhCZJxaFh&index=1) — это хит, рекомендуем всем коллективом!
В итоге, в качестве серверной технологии решили оставить корпоративно-привычный Perl, однако нам удалось набрать вторую космическую скорость, покинуть гравитационное поле fast\_cgi и применить **Mojolicious** — современный автономный и адекватный (не считая автора) веб-фреймворк с роутами, хелперами, бриджами, встроенной поддержкой асинхронных запросов и прочими положенными современному разработчику сладостями.
4. Тотальная асинхронность и кеширование данных при взаимодействии с социальными сетями.
К слову о прототипе проекта — было замечено, что данные из социальных сетей, полученные сервисом about.me, не обновляются, загружаясь лишь единожды — в момент подключения сервиса. Вероятно, опция обновления кеша доступна VIP пользователям, но нам не удалось добиться от about.me обновления информации. Это навело нас на мысли о том, что стоит по возможности как можно более качественно организовать межсерверное взаимодействие и систему кеширования, чтобы минимизировать риск возникновения схожих проблем в будущем.
Практически повсеместно внедрённый **OAuth2** и схожесть в организации API различных социальных сетей дали возможность удачно обобщить взаимодействие.
Конечно, на этапе прототипа вся работа с API была синхронной, но блокировать Hypnotoad воркеры для осуществления API запросов в высоконагруженном проекте — однозначная роскошь и расточительство. К счастью, Mojolicious построен на весьма приличной, как по интерфейсу, так и по реализации, событийной машине, благодаря чему, кстати, каждый воркер в пуле способен параллельно обрабатывать не один (как в случае, скажем, с mod\_perl), а десятки параллельных запросов, конечно, при условии, что те содержат значимое количество асинхронного кода.
К слову, учитывая то, что одним из основных “пугающих” аргументов против примененияnode.js является его тотальная асинхронность, — Mojolicious может послужить отличным ментальным мостом, когда вы начнёте разработку в рамках классической синхронной парадигмы, а закончите, как минимум, имея значительную часть гибридного кода (sync + async). Признаться, теперь мы боимся node.js значительно меньше и надеемся применить его в последующих проектах.
Вообще, **uid.me** делался по принципу “нет велосипедам”, и в жертву Шиве был торжественно принесён целый пласт ископаемых самоделок, возглавляемый широко известным в узких кругах килобайтным макросом “**dw**”, с 2005 года верой и правдой служивший нам и близким нам разработчикам и позволивший в трудный час избежать трансцендентного ужаса DBIx::Class. Светлая память.
И всё же, при разработке **uid.me** родилась одна занимательная поделка — это макрос
```
take { … $take->(‘named_callback_slot_1’) ... } process { my $taken = shift; … },
```
построенный на Mojo::IOLoop->delay и радикально упрощающий весь цикл операций, связанных с организацией именованных каскадных асинхронных API взаимодействий, включая каскадную обработку исключений (при возникновении интереса — пишите в личное, поделимся).
**Возвращаясь к MongoDB**
Применить на практике что-то похожее на NoSQL решение хотелось ещё с тех времён, когда это не было мейнстримом. В рамках тех highload задач, с которыми в то время приходилось сталкиваться, постепенно нарисовалось следующее понимание:
1. Классический LAMP проект стартует с классической SQL БД.
2. Если проект становится популярным, он обретает статус «highload», иначе goto 1.
3. Статус «highload» обязывает нас вплотную задуматься о кешировании, шардировании, репликации и
бекапе того, что хранится в SQL БД.
4. Эволюция схемы данных живого проекта становится тем более болезненной, чем больше данных накоплено, и тем более востребованной, чем более популярным оказался проект.
5. В результате всего этого ORM код начинает выполнять функции mutex, сериализации/десериализации данных для memcached, примитивного шардирования, в особо жестоких ситуациях — патчи обеспечения обратной совместимости схемы данных (ибо позволить себе большой сквозной апдейт данных в реальных условиях удавалось далеко не всегда).
Впрочем, довольно о грустном, на дворе были суровые 2000'е.
Начало 2010'х было озарено появлением нескольких NoSQL решений, которые обещали устранить бОльшую часть проблем растущего highload проекта «из коробки». Появление открытых, готовых к использованию NoSQL решений пророчили многие, но, тем не менее, фактическое обретение прекрасного будущего нас приятно удивило.
Посоветовавшись с более экстремальными в плане новшеств коллегами, мы решили пробовать **MongoDB**.
Изучая новую для себя технологию, мы посчитали логичным применить её возможности по максимуму, надеясь на лучшее (а значит, на серебряную пулю из коробки), рассчитывая, впрочем, откатиться к более классическим техникам в тех местах, где чрезмерная наглость столкнула бы нас с интересными подводными камнями.
Под применением возможностей по максимуму мы подразумеваем следующее:
1. JSON формат хранения данных позволил не возиться с привычными parent/child/x-связями в схеме данных по поводу и без, ограничившись здравым смыслом. В результате вложенная структура основного объекта user оказалось жирной, но удобной. В неё смело вложили кучу флажков, настроек отображения, мелких связанных списков и всего того прочего, что раньше с ходу приводило к созданию пачки около-user'овых SQL таблиц.
2. В модель данных добавили код общего назначения, который на этапе прототипирования интерфейса позволил крайне приятно наращивать JS функционал: по URL /profile/save стало возможным послать любой JSON, который extend'ил объект пользователя новыми данными, например:
```
user.save({
'style.profile.top': '20px',
'style.caption.tags.color': 'rgba(30, 29, 38, 1)',
'info.first_name': 'Павел'
});
```
Все операции, связанные с деятельностью авторизованного пользователя были упакованы в общую функцию отправки с латентным коллектором в 500 мсек, объединяющим различные атомарные правки в общие пакеты.
В результате, client-side разработчики смогли легко расширять структуру объекта user, просто начиная использовать новые поля.
Конечно, после фазы прототипирования, серверная часть /profile/save была снабжена контекстными фильтрами данных, которые отсекали неизвестные поля и фильтровали значения на предмет корректности.
Осталась только одна проблема — в БД могли храниться пользователи, у которых вообще не существовали некоторые поля, так как последний раз они редактировали свой профиль ещё до того, как эти поля возникли. В идеале, хотелось бы иметь default-значения для каждого поля, которые будут магическим образом появляться в любом объекте, извлекаемом из БД.
На уровне ORM добавили forced extend всех извлекаемых данных default значениями для всех несуществующих полей.
Круг замкнулся.
Мы получили возможность динамически расширять структуру объекта, не прибегая к сквозным апдейтам БД, прозрачно работать с ней не только со стороны сервера, но и на client-side, при этом процесс добавления нового оказался довольно приятным, а переход от прототипа к релизу сопровождался ровно двумя действиями:
1. Добавлением правила для данных нового поля в фильтры extend\_rules.
2. Добавлением ожидаемого значения по умолчанию для этого поля в default\_user.
Вот, пожалуй, и всё. Спасибо за внимание, ждём вас в гости!
*P.S. на сладкое, любителям обнажёнки:*
**дамп профиля из mongodb**
```
Using username "www".
MongoDB shell version: 2.4.2
connecting to: uidme
mongos> db.user.find({'uid':'pavel_kudinov'}).pretty();
{
"_id" : ObjectId("519bbb1592762f6d65424301"),
"uid" : "pavel_kudinov",
"email" : "kudinov.pavel@gmail.com",
"uguid" : "2926366677"
"info" : {
"first_name" : "Павел",
"last_name" : "Кудинов",
"headline" : "живой"
"bio" : "в начале был вечер,\nпотом настал я",
"gender" : "male",
"birthday" : "1985-07-03",
"tags" : {
"places" : [ "Ростов-на-Дону" ],
"jobs" : [ "uCoz.ru" ],
"education" : [ "Бодхисаттва" ],
"tags" : [ ]
},
"contacts" : {
"email" : "kudinov.pavel@gmail.com",
"icq" : "",
"skype" : "pavel-kudinov",
"gtalk" : "kudinov.pavel",
"aim" : "",
"phone" : "+7 (928) 167 12 03"
},
"sites" : [
{
"link" : "http://vk.com/kudinovpavel",
"title" : "vk.com/kudinovpavel"
}
],
"bg_pattern" : "",
"background" : {
"medium" : "/img/background/s/r/v/medium_r5vhibyl.jpg",
"full" : "/img/background/s/r/v/full_r5vhibyl.jpg",
"thumb" : "/img/background/s/r/v/thumb_r5vhibyl.jpg"
},
"avatar" : {
"full" : "/img/avatar/full_etpcnfon.jpg",
"thumb" : "/img/avatar/thumb_etpcnfon.jpg"
},
},
"tech" : {
"last_login" : 1385995749,
"theme_id" : 4,
"last_login_ip" : "178.76.238.102",
"ucoz" : {
"reg_time" : "1358928666",
"last_login" : "1367856843",
"langp" : "ru",
"reg_ip" : "2991386214",
"last_admlogin" : "1366901917",
"avatar" : {
"geom" : "-10:0:0.1524",
"file" : "/img/ucoz/29/26/2926366677/.OWyAuYrnAliL.jpg",
"type" : "photo"
},
"location_id" : "177270886"
},
"email_activated" : 1
},
"style" : {
"profile" : {
"width" : "431",
"left" : "50%",
"margin_left" : "-540px",
"hidden_contacts" : [ "phone", "icq", "email", "gtalk", "aim" ],
"shadow" : "false",
"hidden_tags" : [ ],
"text_shadow" : "black_shadow",
"height" : "auto",
"right" : "auto",
"min_height" : "566",
"indent-bottom" : "0",
"hidden_apps" : [ ],
"top" : "77px",
"bgcolor" : "rgba(224, 224, 224, 0.5)"
},
"show_birthday" : "hide",
"show_contacts" : "true",
"editdialog" : {
"left" : 499,
"top" : 82,
"open_tab" : "apps"
},
"avatar" : {
"width" : "208",
"height" : "210"
},
"apporder" : [ "facebook", "instagram", "google", "yandex", "youtube", "vkontakte", "twitter" ],
"show_tags" : "true",
"caption" : {
"sites" : { "color" : "rgba(49, 49, 51, 1)", "font" : "Arial", "size" : "14" },
"name" : { "color" : "rgba(6, 44, 79, 1)", "font" : "Ubuntu", "size" : "55" },
"bio" : { "color" : "rgba(6, 44, 79, 1)", "font" : "PT Sans", "size" : "15" },
"tags" : { "color" : "rgba(30, 29, 38, 1)", "font" : "Arial", "size" : "14" },
"headline" : { "color" : "rgba(6, 44, 79, 1)", "font" : "PT Sans", "size" : "20" }
},
"apptheme" : "t4",
"bg" : {
"left" : "0px",
"right" : "auto",
"margin_left" : "0px",
"top" : "0px",
"bgcolor" : "rgba(0, 0, 0, 1)",
"key" : "fill",
"pattern_opacity" : "0.9"
}
},
}
mongos>
``` | https://habr.com/ru/post/205066/ | null | ru | null |
# Модульный подход к разработке web-приложений с использованием JavaScript: AMD и RequireJS
При разработке приложений с модульной структурой на JavaScript возникает две проблемы:* описание и удовлетворение зависимостей различных частей приложения, необходимость организации подключения зависимостей на серверной стороне;
* экспорт переменных в глобальную область видимости и их коллизия.
Обе эти задачи решаются при использовании подхода [Asynchronous Module Definition](https://github.com/amdjs/amdjs-api/wiki/AMD). Он сводится к описанию модулей функцией define и подключению их с помощью require. На данный момент есть несколько инструментов, реализующих AMD. Я начал своё знакомство с ними с [RequireJS](http://requirejs.org) и был удивлён, насколько удобно и просто можно описывать зависимости модулей. Расскажу, как это работает, на простом примере.
#### Подключение загрузчика
Имеем следующую структуру каталогов:
```
siteroot/
js/
app.js
require.js
jquery.js
mymodule.js
index.html
```
Для начала, подключим в index.html загрузчик. Будем использовать RequireJS:
Отлично, это единственный тег script, который нам нужен. Остальную работу по подключению JS сделает загрузчик. Указанный в data-атрибуте файл (расширение .js для краткости в RequireJS всегда опускается) будет своеобразной точкой входа нашего приложения. В нём мы сможем подключить необходимые модули с помощью require и совершить задуманные действия.
#### Описание модуля
Опишем наш модуль в `/js/module.js` с помощью define:
```
define(
'mymodule',
['jquery'],
function( $ ){
return {
foo : 'bar'
};
}
);
```
Первый аргумент — строка, название модуля, не обязателен. Вторым аргументом передаются зависимости в виде массива строк, также опционально. Третий аргумент — функция-фабрика, которая выполняется только после удовлетворения всех зависимостей (загрузки перечисленных файлов). В неё в качестве аргументов передаются экспортируемые зависимостями переменные. А возвращать она должна сам модуль. В данном случае это объект с одним полем.
#### Использование
В `/js/app.js` подключим нужные модули с помощью JS и выполним свой код:
```
require(
['mymodule', 'jquery'],
function( Module, $ ){
$('body').append( Module.foo );
}
);
```
Module при этом не будет доступна в глобальной области видимости, как и другие переменные, экспортируемые библиотеками из зависимостей. Не смотря на то, что библиотека jQuery с версии 1.7 поддерживает AMD-архитектуру, она является исключением: экспортирует свой доллар в глобальную область видимости. Скорее всего, это сделано для сохранения совместимости с армией плагинов, написанных за многие годы.
#### Конфигурация
RequireJS обладает рядом параметров, которые можно передавать перед использованием. Для этого служит объект `require.config`.
Что делать, если вам необходимо подключить модуль, которая не оформлен в виде AMD и экспортирует переменную в глобальную область видимости? Можно, конечно, модифицировать его исходный код, но это плохая практика. Для описания таких модулей служит параметр `shim`. Можно вручную указать его зависимости и экспортируемую переменную, и он станет частью нашего приложения наравне с другими AMD-парнями:
```
require.config = {
shim: {
'oldmodule' : {
deps: [],
exports: 'OldModule'
}
}
};
```
Теперь можно указывать его в качестве зависимости:
```
require(
['mymodule', 'jquery', 'oldmodule'],
function(){}
);
```
Помимо shim есть ещё много параметров: корневая директория подключения файлов `baseUrl`, псевдонимы для более удобного подключения `paths`, и т.д.
#### Заключение
Надеюсь, концепция AMD зацепила вас, так же, как и меня. Она помогает избежать хаоса при использовании большого количества JS-файлов в разработке, подталкивает к написанию реюзабельного кода, снимает ответственность за подключение файлов с бэкенда. А если у вас реально большое MVC-приложение из пары десятков файлов, то подобная система просто незаменима.
На прощание, приведу несколько ссылок, которые помогут продолжить изучение вопроса:* статья Addy Osmani [Writing Modular JavaScript With AMD, CommonJS & ES Harmony](http://addyosmani.com/writing-modular-js/);
* [официальный сайт RequireJS](http://requirejs.org);
* спецификация [AMD](https://github.com/amdjs/amdjs-api/wiki/AMD).
Исходный код из статьи доступен [в репозитории на GitHub](http://github.com/clslrns/requirejs-test).
Happy hacking! | https://habr.com/ru/post/152833/ | null | ru | null |
# Авторизация из приложения C# на портале BlaBlaCar.ru
Зачем ?
-------
Из кода Вашего приложения Вы можете авторизоваться на любом web-портале. Это может быть нужно когда Вы хотите получить доступ к ресурсам Вашего аккаунта.
Что можно получить на данном портале ?
--------------------------------------
Вы можете получить список Ваших поездок, а можете проверить какие поездки запланированы на всем портале от пункта "A" в пункт "B" на конкретную дату. Вы можете больше.
Что понадобится ?
-----------------
* Локальный прокси-сервер, рекомендую Fiddler - просто и удобно
* Visual Studio
Соберем данные
--------------
Работа web-клиента и web-сервера происходит по протоколу HTTP. Клиент отправляет HTTP запросы в виде заголовков, сервер отправляет ответ в виде заголовков. Это значит что для нашей задачи нужно отправить на сервер несколько запросов чтобы авторизоваться и получить необходимые данные. Чтобы узнать список запросов мы воспользуемся программой Fiddler. После запуска Fiddler откроем любой браузер, перейдем на портал blablacar.ru, авторизуемся и получим список необходимых HTTP-запросов (лишние запросы удалены).
Перейдем к коду. Авторизация.
-----------------------------
Для выполнения HTTP-запросов используется класс HttpWebRequest. Воспользуемся несложными обертками для этого класса: классы GetRequest и PostRequest.
GetRequest
```
public class GetRequest
{
private HttpWebRequest _request;
public void Run(ref CookieContainer cookies)
{
_request = (HttpWebRequest)WebRequest.Create(Address);
_request.Headers.Add("DNT", "1");
_request.Method = "Get";
_request.Accept = Accept;
_request.Host = Host;
if (TurnOffProxy) _request.Proxy = null;
else _request.Proxy = Proxy;
if (UseUnsafeHeaderParsing)
{
var config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
var settings = (SettingsSection)config.GetSection("system.net/settings");
settings.HttpWebRequest.UseUnsafeHeaderParsing = true;
config.Save(ConfigurationSaveMode.Modified);
ConfigurationManager.RefreshSection("system.net/settings");
}
_request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
if (!ContentType.IsEmpty()) _request.ContentType = ContentType;
if (TimeOut > 0)
{
_request.Timeout = TimeOut;
_request.ReadWriteTimeout = TimeOut;
}
else
{
_request.Timeout = 35000;
_request.ReadWriteTimeout = 35000;
}
if (NoCachePolicy == false)
{
var noCachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
_request.CachePolicy = noCachePolicy;
}
foreach (KeyValuePair keyValuePair in Headers)
{
\_request.Headers.Add(keyValuePair.Key, keyValuePair.Value);
}
if (UserAgent == null) \_request.UserAgent = Data.Ie11;
else \_request.UserAgent = UserAgent;
if (AllowAutoRedirect != null)
\_request.AllowAutoRedirect = (bool)AllowAutoRedirect;
if (KeepAlive != null)
\_request.KeepAlive = (bool)KeepAlive;
if (Expect100Continue != null)
\_request.ServicePoint.Expect100Continue = (bool)Expect100Continue;
if (!Referer.IsEmpty())
\_request.Referer = Referer;
\_request.CookieContainer = cookies;
try
{
HttpWebResponse response = (HttpWebResponse)\_request.GetResponse();
if ((response.StatusCode == HttpStatusCode.OK || response.StatusCode == HttpStatusCode.Moved || response.StatusCode == HttpStatusCode.Redirect) && response.ContentType.StartsWith("image", StringComparison.OrdinalIgnoreCase))
{
// if the remote file was found, download oit
using (Stream inputStream = response.GetResponseStream())
{
byte[] buffer = new byte[64000];
int bytesRead;
bytesRead = inputStream.Read(buffer, 0, buffer.Length);
Response = Convert.ToBase64String(buffer, 0, bytesRead);
}
}
else
{
var stream = response.GetResponseStream();
if (stream != null) Response = new StreamReader(stream).ReadToEnd();
ResponseHeaders = response.Headers;
RequestHeaders = \_request.Headers;
}
response.Close();
}
catch (WebException ex)
{
using (var stream = ex.Response.GetResponseStream())
using (var reader = new StreamReader(stream))
{
Response = reader.ReadToEnd();
}
}
catch (Exception ex)
{
}
}
Dictionary Headers = new Dictionary();
public void AddHeader(string headerName, string headerValue)
{
Headers[headerName] = headerValue;
}
public bool NoCachePolicy { get; set; }
public bool AcceptGZipEncoding { get; set; }
public bool UseUnsafeHeaderParsing { get; set; }
public string Address { get; set; }
public string Accept { get; set; }
public string Referer { get; set; }
public string Host { get; set; }
public bool? KeepAlive { get; set; }
public string ContentType { get; set; }
public bool? Expect100Continue { get; set; }
public string Response { get; private set; }
public bool? AllowAutoRedirect { get; set; }
public WebHeaderCollection ResponseHeaders { get; private set; }
public WebHeaderCollection RequestHeaders { get; private set; }
public string UserAgent { get; set; }
public WebProxy Proxy { get; set; }
public bool TurnOffProxy { get; set; }
public int TimeOut { get; set; }
}
```
PostRequest
```
public class PostRequest
{
private HttpWebRequest _request;
public void Run(ref CookieContainer cookies)
{
_request = (HttpWebRequest)WebRequest.Create(Address);
_request.Method = "POST";
_request.Host = Host;
_request.Headers.Add("DNT", "1");
_request.Proxy = Proxy;
_request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
if (TimeOut > 0)
{
_request.Timeout = TimeOut;
_request.ReadWriteTimeout = TimeOut;
}
else
{
_request.Timeout = 90000;
_request.ReadWriteTimeout = 90000;
}
var noCachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
_request.CachePolicy = noCachePolicy;
if (Expect100Continue == true) _request.ServicePoint.Expect100Continue = true;
else _request.ServicePoint.Expect100Continue = false;
_request.ContentType = ContentType;
_request.Accept = Accept;
_request.Referer = Referer;
_request.KeepAlive = KeepAlive;
foreach (KeyValuePair keyValuePair in Headers)
{
\_request.Headers.Add(keyValuePair.Key, keyValuePair.Value);
}
\_request.CookieContainer = cookies;
if (UserAgent == null) \_request.UserAgent = Dom.Catalog.Data.Ie11;
else \_request.UserAgent = UserAgent;
if (AllowAutoRedirect != null)
\_request.AllowAutoRedirect = (bool)AllowAutoRedirect;
byte[] sentData;
if (ByteData != null) sentData = ByteData;
else sentData = Encoding.UTF8.GetBytes(Data);
\_request.ContentLength = sentData.Length;
Stream sendStream = \_request.GetRequestStream();
sendStream.Write(sentData, 0, sentData.Length);
sendStream.Close();
WebResponse response = \_request.GetResponse();
ResponseHeaders = response.Headers;
RequestHeaders = \_request.Headers;
Stream stream = response.GetResponseStream();
if (stream != null)
{
if (ResponseEncoding.IsEmpty()) Response = new StreamReader(stream).ReadToEnd();
else Response = new StreamReader(stream, Encoding.GetEncoding(ResponseEncoding)).ReadToEnd();
}
response.Close();
}
Dictionary Headers = new Dictionary();
public void AddHeader(string headerName, string headerValue)
{
Headers[headerName] = headerValue;
}
public bool NoCachePolicy { get; set; }
public string Response { get; set; }
public string ResponseEncoding { get; set; }
public string Data { get; set; }
public byte[] ByteData { get; set; }
public string Address { get; set; }
public string Accept { get; set; }
public string Host { get; set; }
public string ContentType { get; set; }
public string Referer { get; set; }
public bool KeepAlive { get; set; }
public bool? Expect100Continue { get; set; }
public string UserAgent { get; set; }
public bool? AllowAutoRedirect { get; set; }
public WebHeaderCollection ResponseHeaders { get; private set; }
public WebHeaderCollection RequestHeaders { get; private set; }
public WebProxy Proxy { get; set; }
public int TimeOut { get; set; }
}
```
В переменные user и password необходимо внести значения Вашего аккаунта.
В cookies у нас будут храниться все cookie выполненных запросов.
proxy - это адрес Вашего прокси. Например, "127.0.0.1:8888" - стандартный адрес запущенного Fiddler.
SecurityProtocolType.Tls12 - указание используемого протокола безопасности.
```
var user = "user"; // !!! rewrite value from your account !!!
var password = "password"; // !!! rewrite value from your account !!!
// We keep cookies here
var cookies = new CookieContainer();
// Any proxy, for example Fiddler
var proxy = new WebProxy("127.0.0.1:8888");
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
```
Для выполнения авторизации на портале необходимо получить cookie и некоторые переменные, которые хранятся в результате запроса "https://www.blablacar.ru/".
```
var getRequest = new GetRequest()
{
Address = "https://www.blablacar.ru/",
Accept = "text/html, application/xhtml+xml, image/jxr, */*",
Host = "www.blablacar.ru",
KeepAlive = true,
UserAgent = "Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; rv:11.0) like Gecko",
Proxy = proxy
};
getRequest.Run(ref cookies);
```
Используя нехитрые методы работы с текстом, находим значение переменной "visitorId":
```
var visitorStart = getRequest.Response.IndexOf("visitorId") + 12;
var visitorEnd = getRequest.Response.IndexOf("\"", visitorStart);
var visitorId = getRequest.Response.Substring(visitorStart, visitorEnd - visitorStart);
```
В переменную xCorrelationId необходимо передать случайный GUID.
Теперь все значения готовы чтобы выполнить авторизацию на портале.
```
// Random value
var xCorrelationId = Guid.NewGuid();
// Auth request
var data = $"{{\"login\":\"{user}\",\"password\":\"{password}\",\"rememberMe\":true,\"grant_type\":\"password\"}}";
var postRequest = new PostRequest()
{
Data = data,
Address = $"https://auth.blablacar.ru/secure-token",
Accept = "application/json",
Host = "auth.blablacar.ru",
ContentType = "application/json",
Referer = "https://www.blablacar.ru/login/email",
KeepAlive = true,
Proxy = proxy
};
postRequest.AddHeader("x-client", "SPA|1.0.0");
postRequest.AddHeader("x-correlation-id", xCorrelationId.ToString());
postRequest.AddHeader("x-currency", "RUB");
postRequest.AddHeader("x-forwarded-proto", "https");
postRequest.AddHeader("x-locale", "ru_RU");
postRequest.AddHeader("x-visitor-id", visitorId);
postRequest.AddHeader("Origin", "https://www.blablacar.ru");
postRequest.Run(ref cookies);
```
В ответе на POST-запрос авторизации мы должны получить значение еще одной переменной, назовем ее "bearerCookieValue". Это значение хранится в заголовках "Set-Cookie" ответа.
```
var bearerCookieValue = string.Empty;
var headers = postRequest.ResponseHeaders;
for (int i = 0; i < headers.Count; ++i)
{
string header = headers.GetKey(i);
if (header == "Set-Cookie")
{
var headerValue = headers.GetValues(i)[0];
headerValue = WebUtility.UrlDecode(headerValue);
var accessTokenStart = postRequest.Response.IndexOf("access_token") + 15;
var accessTokenEnd = postRequest.Response.IndexOf("\"", accessTokenStart);
bearerCookieValue = postRequest.Response.Substring(accessTokenStart, accessTokenEnd - accessTokenStart);
}
}
```
Список выполненных поездок
--------------------------
Теперь все готово чтобы выполнять запросы за необходимой информацией. Весь код сформирован на основании просмотренных заголовков запроса/ответа в прокси-сервере Fiddler.
```
getRequest = new GetRequest()
{
Address = "https://edge.blablacar.ru/bookings-and-tripoffers?active=false",
Accept = "application/json",
Host = "edge.blablacar.ru",
KeepAlive = true,
ContentType = "application/json",
Referer = "https://www.blablacar.ru/rides/history",
Proxy = proxy
};
getRequest.AddHeader("x-blablacar-accept-endpoint-version", "2");
getRequest.AddHeader("x-client", "SPA|1.0.0");
getRequest.AddHeader("x-correlation-id", xCorrelationId.ToString());
getRequest.AddHeader("x-currency", "RUB");
getRequest.AddHeader("x-forwarded-proto", "https");
getRequest.AddHeader("x-locale", "ru_RU");
getRequest.AddHeader("x-visitor-id", visitorId);
getRequest.AddHeader("authorization", $"Bearer {bearerCookieValue}");
getRequest.AddHeader("Origin", "https://www.blablacar.ru");
getRequest.Run(ref cookies);
```
Ответ получаем в виде JSON-формата:
Находим список всех поездок на портале
--------------------------------------
В данном примере найдем список всех поездок из Москвы в Санкт-Петербург на 15 декабря 2020 года.
```
var date = "2020-12-15";
var searchUid = Guid.NewGuid();
getRequest = new GetRequest()
{
Address = $"https://edge.blablacar.ru/trip/search?from_coordinates=55.755826%2C37.617299&from_country=RU&to_coordinates=59.931058%2C30.360909&to_country=RU&departure_date={date}&min_departure_time=00%3A00%3A00&requested_seats=1&passenger_gender=UNKNOWN&search_uuid={searchUid}",
Accept = "application/json",
Host = "edge.blablacar.ru",
KeepAlive = true,
ContentType = "application/json",
Referer = "https://www.blablacar.ru/",
Proxy = proxy
};
getRequest.AddHeader("x-blablacar-accept-endpoint-version", "2");
getRequest.AddHeader("x-client", "SPA|1.0.0");
getRequest.AddHeader("x-correlation-id", xCorrelationId.ToString());
getRequest.AddHeader("x-currency", "RUB");
getRequest.AddHeader("x-forwarded-proto", "https");
getRequest.AddHeader("x-locale", "ru_RU");
getRequest.AddHeader("x-visitor-id", visitorId);
getRequest.AddHeader("authorization", $"Bearer {bearerCookieValue}");
getRequest.AddHeader("Origin", "https://www.blablacar.ru");
getRequest.Run(ref cookies);
```
В ответе на запрос получаем JSON-строку с поездками на портале:
Готово
------ | https://habr.com/ru/post/532788/ | null | ru | null |
# Создание движка для блога с помощью Phoenix и Elixir / Часть 7. Добавляем комментарии / Новогодний анонс в заключении
От переводчика: «*Elixir и Phoenix — прекрасный пример того, куда движется современная веб-разработка. Уже сейчас эти инструменты предоставляют качественный доступ к технологиям реального времени для веб-приложений. Сайты с повышенной интерактивностью, многопользовательские браузерные игры, микросервисы — те направления, в которых данные технологии сослужат хорошую службу. Далее представлен перевод серии из 11 статей, подробно описывающих аспекты разработки на фреймворке Феникс казалось бы такой тривиальной вещи, как блоговый движок. Но не спешите кукситься, будет действительно интересно, особенно если статьи побудят вас обратить внимание на Эликсир либо стать его последователями.
В этой части мы подготовим фундамент для комментариев, чтобы затем оживить их с помощью каналов Phoenix.*
На данный момент наше приложение основано на:
* **Elixir**: v1.3.1
* **Phoenix**: v1.2.0
* **Ecto**: v2.0.2
На чём мы остановились
----------------------
Сейчас движок поддерживает использование небольшого Markdown-редактора для украшения постов, так что наша поделка становится похожей на полноценный проект! Однако у нас по-прежнему нет никакого способа получать обратную связь к постам, которые пишем. Хорошая новость: добавить такую возможность довольно просто. Вся работа будет строиться на том, что мы уже успели сделать.
Начнём с простого. Вместо требования зарегистрироваться, будем создавать новые комментарии в статусе ожидания утверждения. Комментарии станут видны на странице поста сразу после проверки, либо при нажатии «Показать неподтверждённые».
Добавляем модель комментариев
-----------------------------
Начнём с добавления модели для комментариев. У комментариев будут:
* Автор (строковый тип)
* Сообщение (текстовый тип)
* Признак одобренного комментария (логический тип, по умолчанию false)
* Пост, к которому относится комментарий (ссылка на таблицу с постами)
Нам не нужен полный набор шаблонов и остальные прелести, так что воспользуемся командой `mix phoenix.gen.model`.
```
mix phoenix.gen.model Comment comments author:string body:text approved:boolean post_id:references:posts
```
Затем проведём миграцию:
```
mix ecto.migrate
```
Связываем комментарии с постами
-------------------------------
В файле `web/models/comment.ex` можно увидеть, что комментарии уже связаны с постами, но не хватает связи в обратную сторону.
Так что добавьте в определение схемы «posts» в файле `web/models/post.ex` следующий код:
```
has_many :comments, Pxblog.Comment
```
После выполнения команды `mix test`, всё должно быть по-прежнему зелёным! Теперь давайте проверим связь между постами и комментариями.
Для этого откройте файл `test/support/factory.ex` и добавьте фабрику Comment. Напишите эту строчку наверх файла, следом за остальными псевдонимами:
```
alias Pxblog.Comment
```
А затем этот код в самый низ:
```
def comment_factory do
%Comment{
author: "Test User",
body: "This is a sample comment",
approved: false,
post: build(:post)
}
end
```
Соответственно, нужно создать несколько тестов, чтобы фабрика стала приносить пользу. Откройте файл `test/models/comment_test.exs` и добавьте в него следующий код:
```
import Pxblog.Factory
# ...
test "creates a comment associated with a post" do
comment = insert(:comment)
assert comment.post_id
end
```
Запустим тесты снова. Они должны остаться зелёными!
Добавление маршрутов для комментариев
-------------------------------------
Начнём с создания основных маршрутов для комментариев. Откройте файл `web/router.ex`:
```
resources "/posts", PostController, only: [] do
resources "/comments", CommentController, only: [:create, :delete, :update]
end
```
Комментарии имеют смысл только в контексте постов, так что вложим их внутрь. При этом, в других маршрутах, которые мы уже определили, посты вложены в пользователей! Не хочется создавать лишних маршрутов для постов, поэтому воспользуемся параметром `only: []`. Затем добавим ресурсы для комментариев, чтобы дать возможность создавать, удалять и обновлять их. `:create` — для добавления комментариев неавторизованными пользователями (создаются неподтверждёнными). `:delete` — позволит автору поста и администраторам удалять комменарии, а `:update` — одобрять их для показа общественности.
Добавляем контроллеры и представления
-------------------------------------
Теперь, когда наши модели настроены, нам нужно создать контроллер с парой методов. Показ комментариев будет реализован через контроллер постов, но создание/обновление/удаление должно быть реализовано в их собственном контроллере. Начнём с создания файла `web/controllers/comment_controller.ex`:
```
defmodule Pxblog.CommentController do
use Pxblog.Web, :controller
end
```
Также создадим представление в файле web/views/comment\_view.ex, как того хочет Phoenix.
```
defmodule Pxblog.CommentView do
use Pxblog.Web, :view
end
```
Теперь вернёмся назад в контроллер и добавим базовую структуру из трёх действий: `create`, `update` и `delete`.
```
def create(conn, _), do: conn
def update(conn, _), do: conn
def delete(conn, _), do: conn
```
Затем нужно создать в новой директории шаблон формы добавления комментария, который разместим на странице показа поста:
```
$ mkdir web/templates/comment
```
Позволяем пользователям оставлять комментарии
---------------------------------------------
Начнём с создания файла `web/templates/comment/form.html.eex`:
```
<%= form_for @changeset, @action, fn f -> %>
<%= if @changeset.action do %>
Oops, something went wrong! Please check the errors below.
<% end %>
<%= label f, :author, class: "control-label" %>
<%= text\_input f, :author, class: "form-control" %>
<%= error\_tag f, :author %>
<%= label f, :body, class: "control-label" %>
<%= textarea f, :body, class: "form-control", id: "body-editor" %>
<%= error\_tag f, :body %>
<%= submit "Submit", class: "btn btn-primary" %>
<% end %>
```
Обычная формочка, тут нечего обсуждать.
Теперь перейдём к файлу `web/templates/post/show.html.eex`, в который добавим связь с этой формой. Обратите внимание, что в этом шаблоне мы используем две переменные `@changeset` и `@action`. Мы вернёмся к этому позже в контроллере `web/controllers/post_controller.ex`. А сейчас продолжим работать с шаблоном. После списка атрибутов поста, добавьте следующую строчку:
```
<%= render Pxblog.CommentView, "form.html", changeset: @comment_changeset, action: post_comment_path(@conn, :create, @post) %>
```
Нам нужно сослаться на «form.html» внутри представления `CommentView`, так что передадим название первым аргументом в вызове `render`. Нам нужно передать туда `@comment_changeset` (который мы пока не определили, но скоро сделаем это) и `@action` — путь для отправки комментариев.
Теперь можем перейти к файлу `web/controllers/post_controller.ex` и сделать так, чтобы всё работало. Измените функцию show в соответствии с кодом:
```
def show(conn, %{"id" => id}) do
post = Repo.get!(assoc(conn.assigns[:user], :posts), id)
comment_changeset = post
|> build_assoc(:comments)
|> Pxblog.Comment.changeset()
render(conn, "show.html", post: post, comment_changeset: comment_changeset)
end
```
Теперь вернёмся к CommentController (файл `web/controllers/comment_controller.ex`) и наполним содержимым функцию create. Прямо перед функциями добавьте следующий код:
```
alias Pxblog.Comment
alias Pxblog.Post
plug :scrub_params, "comment" when action in [:create, :update]
```
Включение update в вызов scrub\_params пригодится нам позже. Теперь перепрыгнем к функции create и разместим в ней следующий код:
```
def create(conn, %{"comment" => comment_params, "post_id" => post_id}) do
post = Repo.get!(Post, post_id) |> Repo.preload([:user, :comments])
changeset = post
|> build_assoc(:comments)
|> Comment.changeset(comment_params)
case Repo.insert(changeset) do
{:ok, _comment} ->
conn
|> put_flash(:info, "Comment created successfully!")
|> redirect(to: user_post_path(conn, :show, post.user, post))
{:error, changeset} ->
render(conn, Pxblog.PostView, "show.html", post: post, user: post.user, comment_changeset: changeset)
end
end
```
Сейчас мы будем создавать комментарий при получении параметров comment\_params и идентификатора поста post\_id, так как они являются обязательными. Сначала забираем связанный пост (не забудьте предзагрузить пользователя и комментарии, так как шаблон скоро начнёт на них ссылаться), на основе которого создадим новый changeset. Для этого начиная с поста, идём по цепочке в функцию `build_assoc` для создания связанной схемы, которую определяем через атом. В нашем случае создаётся связанный `comment`. Результат вместе с comment\_params передаём в функцию Comment.changeset. Остальная часть работает стандартно с одним исключением.
Условие ошибки чуть более сложное, потому что мы используем рендер другого представления. Сначала мы передаём соединение connection, затем связанное представление View (в нашем случае `Pxblog.PostView`), шаблон для рендера и все переменные, используемые в шаблоне: `@post`, `@user`, and `@comment_changeset`. Теперь можно протестировать: если отправить комментарий с ошибками, то вы увидите их список прямо на странице. Если при отправке комментария не будет никаких ошибок, вы получите синее flash-сообщение вверху страницы Мы делаем успехи!
Вывод комментариев
------------------
Теперь нам нужно отображать комментарии на странице поста. Для этого сформируем общий шаблон комментария, который можно использовать в любых местах для разных целей. Создайте файл `web/templates/comment/comment.html.eex` и заполните его следующим:
```
**<%= @comment.author %>**
*<%= @comment.inserted\_at %>*
<%= unless @comment.approved do %>
Approve
<% end %>
Delete
<%= @comment.body %>
```
Здесь всё понятно без объяснений. Кнопки одобрить/удалить пока не подключены. Мы будем решать этот вопрос в следующих частях. Нам также нужно изменить контроллер для предзагрузки комментариев, и включить в шаблон постов show сам список комментариев. Начнём с обновления контроллера. Добавьте строчку в функцию `show` из файла `web/controllers/post_controller.ex` сразу за строчкой с получением постов:
```
post = Repo.get!(assoc(conn.assigns[:user], :posts), id)
|> Repo.preload(:comments)
```
Таким образом мы обеспечим загрузку комментариев как частм поста. Наконец, откройте файл `web/templates/post/show.html.eex` и добавьте раздел шаблона, отображающий комментарии:
```
Comments
--------
<%= for comment <- @post.comments do %>
<%= render Pxblog.CommentView, "comment.html", comment: comment %>
<% end %>
```
Добавляем тесты контроллера
---------------------------
Нельзя останавливаться, пока некоторые условия не покрыты тестами. Нам нужно проверить функцию create на случай успеха и неуспеха, так как по любому из этих путей может пройти выполнение кода.
Создайте файл `test/controllers/comment_controller_test.exs` и приступим:
```
defmodule Pxblog.CommentControllerTest do
use Pxblog.ConnCase
import Pxblog.Factory
@valid_attrs %{author: "Some Person", body: "This is a sample comment"}
@invalid_attrs %{}
setup do
user = insert(:user)
post = insert(:post, user: user)
{:ok, conn: build_conn(), user: user, post: post}
end
test "creates resource and redirects when data is valid", %{conn: conn, post: post} do
conn = post conn, post_comment_path(conn, :create, post), comment: @valid_attrs
assert redirected_to(conn) == user_post_path(conn, :show, post.user, post)
assert Repo.get_by(assoc(post, :comments), @valid_attrs)
end
test "does not create resource and renders errors when data is invalid", %{conn: conn, post: post} do
conn = post conn, post_comment_path(conn, :create, post), comment: @invalid_attrs
assert html_response(conn, 200) =~ "Oops, something went wrong"
end
end
```
Снова воспользуемся фабрикой Pxblog.Factory. Мы также установим две переменных модуля `@valid_attrs` и `@invalid_attrs` точно так же, как мы делали раньше. Добавим блок setup, внутри которого настроим пользователя по умолчанию и пост, с которым будем работать.
Начнём с теста на успешное добавление комментария. Отправляем POST-запрос на вложенный путь с действительными атрибутами и проверяем, что как и ожидалось сработало перенаправление, а комментарий был добавлен к посту.
Теперь сделаем то же самое, но с недействительными данными, и проверим что получили сообщение “Oops, something went wrong” в виде HTML. Готово!
Дальнейшие шаги
---------------
Мы заготовили отличный фундамент для комментариев, который определённо можно продолжать развивать. Например, мы по-прежнему не имеем возможности одобрять и удалять комментарии. В следующих нескольких частях мы ещё немного поработаем над улучшением комментариев перед тем, как переходить на систему живых комментариев на базе каналов Phoenix.
Другие статьи серии
-------------------
1. [Вступление](https://habrahabr.ru/post/311088/)
2. [Авторизация](https://habrahabr.ru/post/313482/)
3. [Добавляем роли](https://habrahabr.ru/post/315252/)
4. [Обрабатываем роли в контроллерах](https://habrahabr.ru/post/316368/)
5. [Подключаем ExMachina](https://habrahabr.ru/post/316996/)
6. [Поддержка Markdown](https://habrahabr.ru/post/317550/)
7. Добавляем комментарии
8. [Заканчиваем с комментариями](https://habrahabr.ru/post/323462/)
9. [Каналы](https://habrahabr.ru/post/332094/)
10. [Тестирование каналов](https://habrahabr.ru/post/333020/)
11. [Заключение](https://habrahabr.ru/post/335048/)
Заключение от Вуншей
--------------------
За два месяца, что у нас было в этом году, удалось сделать первые шаги в популяризации Эликсира. Первым делом [мы основали русскоязычное сообщество Wunsh.ru](https://wunsh.ru), для которого перевели на русский язык полтора десятка самых интересных статей об Эликсире и функциональном программировании.
В начале недели мы обновили сайт и выложили в общий доступ пять статей. Надеемся, они раззадорят вас и убедят попробовать язык. Например, написать простое приложение в зимние каникулы. **Завтра мы разошлём подписчикам полный набор вышедших статей. Поэтому [подпишитесь сегодня](https://wunsh.ru) и приглашайте друзей**. Будем рады такому подарку!
Следующий шаг проекта — написать серьёзное введение для новичков, перевести официальную документацию и подробно ответить на частые вопросы:
* С чего начать?
* Как развернуть проект?
* Каким редактором пользоваться?
* Какие задачи решать?
И другие…
Будущий год будет наполнен стремительным движением самого языка. Его внедрением в российские компании. О языке не просто будут знать, его начнут массово (насколько это возможно) использовать.
Спасибо за то, что заходите в наши материалы. Если вы — подписчик, то приглашайте друзей.
Всех с наступающим! | https://habr.com/ru/post/318790/ | null | ru | null |
# Распознавание с нестандартного микрофона
Некоторые сталкиваются с тем что необходимо распознать речь перевести её в текст и обработать. Проблема описывалась много раз как впрочем и пути её решения так что Google в помощь, но вот я столкнулся на собственном опыте с проблемой которая потребовала нетривиального решения, а именно как заставить распознавать речь с микрофона которые не установлен «по умолчанию». Если вы тоже столкнулись с подобной проблемой то эта статья именно для вас.
Итак что мы имеем — есть два различных движка для распознавания речи в Microsoft Windows (стандартный и Microsoft Speech SDK 11) причём сразу скажу что русский язык поддерживает пока только один из них, а именно Microsoft Speech SDK 11 с установленным русским языком. Если внимательно прочитать документацию по обоим движкам, то видно что в качестве устройства можно выбрать только DefaultInputDevice, но копнув глубже, а именно открыв сборку декомпилятором Telerik JustDecompile я убедился что все классы являются лишь обёрткой над СОМ объектами, а как раз в этих СОМ объектах нужная функция есть. Естественно что как и все программисты я ленивый и работать с СОМ не хотел, поэтому совмести два решения. Итак первое что нам необходима это найти Token нужного нам микрофона для этого существует следующая функция:
```
private SpeechLib.SpObjectToken FindMicByName(string name)
{
if (isot != null)
{
for (int i = 0; i < isot.Count; i++)
{
sot = isot.Item(i);
string desc = sot.GetDescription(1033);
string id = sot.Id;
if (desc.Contains(name) != false)
{
break;
}
}
return sot;
}
else
return null;
}
```
После того как мы получим Token необходимо вызвать приватные методы у класса «движка» распознавания для этого используется следующая функция:
```
public void SetMicByName(string name, ref System.Speech.Recognition.SpeechRecognitionEngine sre)
{
if (isot != null)
{
sre.SetInputToDefaultAudioDevice();
sot = FindMicByName(name);
if (sot != null)
{
FieldInfo fi = sre.GetType().GetField("_sapiRecognizer", BindingFlags.Instance | BindingFlags.NonPublic);
object _sapiRecognizer = fi.GetValue(sre);
MethodInfo mi = _sapiRecognizer.GetType().GetMethod("SetInput", BindingFlags.Instance | BindingFlags.NonPublic);
object[] parms = new object[] { sot, true };
mi.Invoke(_sapiRecognizer, parms);
}
}
}
```
В конце я приведу полный текст вспомогательного класса, который используется в моей разработке, Вы можете использовать его полностью или частично или просто вставить необходимые фрагмента кода себе. Всё это проверенно на Windows 7,8,8.1 ,NET 4.0, 4.5, но думаю что и с другими версиями будет работать также.
```
using System;
using System.Reflection;
namespace RMI.SmartHouse.Service
{
///
/// Позволяет осуществить выбор микрофонов.
///
public class MicSelector : IDisposable
{
#region Приватные поля
private SpeechLib.SpInProcRecoContext _siprc;
private SpeechLib.ISpeechObjectTokens _isot;
private SpeechLib.SpObjectToken _sot;
private bool _isDisposed;
#endregion
#region Конструкторы
///
/// Конструктор по умолчанию.
///
public MicSelector()
{
_siprc = new SpeechLib.SpInProcRecoContext();
_isot = _siprc.Recognizer.GetAudioInputs(null, null);
_sot = null;
}
#endregion
#region Публичные свойства
///
/// Список доступных устройств.
///
public SpeechLib.ISpeechObjectTokens Isot
{
get
{
return _isot;
}
}
#endregion
#region Публичные методы
///
/// Устанавливает выбранный микрофон.
///
/// Имя микрофона.
/// Движок для распознавания.
public void SetMicByName(string name, ref System.Speech.Recognition.SpeechRecognitionEngine sre)
{
if (_isot != null)
{
sre.SetInputToDefaultAudioDevice();
_sot = FindMicByName(name);
if (_sot != null)
{
FieldInfo fi = sre.GetType().GetField("_sapiRecognizer", BindingFlags.Instance | BindingFlags.NonPublic);
if (fi != null)
{
object sapiRecognizer = fi.GetValue(sre);
MethodInfo mi = sapiRecognizer.GetType().GetMethod("SetInput", BindingFlags.Instance | BindingFlags.NonPublic);
object[] parms = { _sot, true };
mi.Invoke(sapiRecognizer, parms);
}
}
}
}
///
/// Устанавливает выбранный микрофон.
///
/// Имя микрофона.
/// Движок для распознавания.
public void SetMicByName(string name, ref Microsoft.Speech.Recognition.SpeechRecognitionEngine sre)
{
if (_isot != null)
{
sre.SetInputToDefaultAudioDevice();
_sot = FindMicByName(name);
if (_sot != null)
{
FieldInfo fi = sre.GetType().GetField("_sapiRecognizer", BindingFlags.Instance | BindingFlags.NonPublic);
if (fi != null)
{
object sapiRecognizer = fi.GetValue(sre);
MethodInfo mi = sapiRecognizer.GetType().GetMethod("SetInput", BindingFlags.Instance | BindingFlags.NonPublic);
object[] parms = { _sot, true };
mi.Invoke(sapiRecognizer, parms);
}
}
}
}
///
/// Обновляет список доступных устройств.
///
/// Список доступных устройств.
public SpeechLib.ISpeechObjectTokens UpdateDeviceList()
{
if (_siprc != null)
{
_isot = _siprc.Recognizer.GetAudioInputs(null, null);
return _isot;
}
return null;
}
///
/// Освобождение ресурсов.
///
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
#endregion
#region Приватные функции
///
/// Освобождение ресурсов.
///
protected virtual void Dispose(bool disposing)
{
if (!_isDisposed)
{
if (disposing)
{
_sot = null;
_isot = null;
_siprc = null;
}
_isDisposed = true;
}
}
///
/// Поиск микрофона по имени.
///
/// Имя для поиска.
/// Токен микрофона.
private SpeechLib.SpObjectToken FindMicByName(string name)
{
if (_isot != null)
{
for (int i = 0; i < _isot.Count; i++)
{
_sot = _isot.Item(i);
string desc = _sot.GetDescription(1033);
if (desc.Contains(name))
{
break;
}
}
return _sot;
}
return null;
}
#endregion
}
}
``` | https://habr.com/ru/post/214635/ | null | ru | null |
# Разрабатываем Telegram-бота для отслеживания фильмов на NodeJS и TypeScript
У вас бывало такое, что вы приходите в кино и смотрите трейлеры перед началом фильма, при этом некоторые из них цепляют вас достаточно сильно и вы даете себе обещание посмотреть этот фильм если не в кинотеатре, то хотя бы позже, когда он станет доступен для скачивания? Смею предположить, что да. Но часто заканчивается это тем, что вы успешно забываете про это и, в лучшем случае, случайно находите этот фильм пролистывая список уже вышедших фильмов.
Я достаточно часто сталкивался с такой проблемой и решил ее созданием Eve — Telegram-бота, который помогает мне не забывать про релизы моих любимых фильмов. Что это, как оно работает и как разрабатывалось вы можете почитать под катом!
* [Предисловие](#foreword)
* [Зачем?](#why)
* [Выбор технологий](#technologies)
* [Telegraf.js](#telegraf)
* [Структура проекта](#structure)
* [Инициализация и запуск](#start)
* [Обрабатываем пользовательский ввод](#userinput)
* [Локализация](#localization)
* [Заключение](#conclusion)
### Предисловие
Данная статья не является подробным гайдом по созданию Telegram-ботов. И хотя по ходу статьи я буду достаточно часто ссылаться на свой проект, целью данного материала является рассказ про разработку в общем, а именно выбор технологий, ключевые моменты и подводные камни, с которыми я столкнулся.
### Зачем?
Итак, как я написал выше, я достаточно часто забываю посмотреть те фильмы, трейлер которых мне понравился. Я долго думал над решением этой проблемы. Первое, что пришло мне в голову — создание нативного приложения для смартфонов, но т.к. я никогда не занимался этим раньше, это заняло бы достаточно много времени и не факт, что конечный результат удовлетворял бы мои потребности, а также потребности потенциальных пользователей.
Следующей идеей было создание PWA. Вполне себе интересный вариант для того, чтобы познакомиться с технологией, но ее я решил оставить на будущее. В то же самое время я достаточно давно пользуюсь Telegram и за все это время у меня скопилось достаточное количество ботов, которые периодически делают мою жизнь немного проще. В конечном счете взвесив все плюсы и минусы, я решил, что данная платформа отлично подойдет для данной идеи.
### Выбор технологий
Если прошерстить Github на предмет наличия Telegram-ботов, то можно увидеть, что большая часть из них написана на Python. Python действительно замечательный язык и отлично подходит для данной идеи, но мне хотелось реализовать данный проект именно на NodeJS + TypeScript. Применив соответствующие фильтры я наткнулся на 2 достаточно популярных инструмента: [node-telegram-bot-api](https://github.com/yagop/node-telegram-bot-api) и [Telegraf.js](https://github.com/telegraf/telegraf).
До этого опыта разработки ботов у меня не было, поэтому при выборе из этих двух было не совсем понятно на какие параметры следует смотреть. В итоге посмотрев документацию и полистав issues к каждой из библиотек, я остановился на Telegraf.js. Решающим фактором стало наличие механизма middlewares, который устроен таким же образом, как и в популярном фреймворке Express.js. Также Telegraf.js имеет более частую историю обновлений и хорошо структурированную документацию, из чего можно предположить, что разработчики прикладывают достаточно усилий для улучшения инструмента. Более того, он содержит тайпинги для TypeScript, что определенно является плюсом для выбранного стека.
### Telegraf.js
Telegraf.js — основная библиотека, на которой был написан проект. Она использует несколько интересных подходов, которые позволяют создавать сложных ботов с сохранением простоты кода. Ниже представлены наиболее интересные механизмы:
* **Middlewares** — да, это те же самые middlewares, которые доступны в Express.js. Когда пользователь что-то отправляет боту, сообщение вначале проходит через все зарегистрированные middlewares, а уже после попадает в контроллер. Middlewares могут модифицировать контекст, а также приостанавливать выполнение запроса, например, если обычный пользователь попытается попасть в область для администраторов. Telegraf.js предоставляет несколько крайне полезных middlewares «из коробки», но также можно использовать и разработанные лично. Именно middlewares считаются киллер-фичей Telegraf.js
* **Sessions** — сессии, которые могут хранить в себе информацию, не привязанную к контроллеру. Можно привести аналогию с глобальными переменными, которые доступны из любого места в боте. Очень удобная вещь, которая используется, например, для локализации. Есть возможность хранить сессии в разных режимах — БД, redis, локальные файлы и т.д.
* **Webooks** — бот может работать в двух режимах — [long polling](https://en.wikipedia.org/wiki/Push_technology#Long_polling) или [Webhooks](https://core.telegram.org/bots/webhooks). И хотя работают они одинаково быстро, все же в production среде лучше использовать второй вариант. Таким образом, боту не нужно будет стучаться на сервер Telegram, вместо этого он сам будет получать все обновления.
**Важно:** обязательным условием для Webhook'ов является поддержка сервером SSL/TLS. Также убедитесь, что порт, на котором запущен Webhook, открыт и доступен извне.
* **Markup** — с помощью этого класса можно научить бота отвечать в markup/markdown разметке. Это важно если вы, например, делаете HTML-игру. Тем не менее в своем проекте я использовал его только для bold/italic текста.
* **Stage** — крайне интересный модуль, который помог мне сохранить нервы и некоторое количество часов разработки. Здесь я расскажу подробнее.
Бот умеет слушать сообщения от пользователя и, в зависимости от типа или содержимого сообщения, перенаправлять его в тот или иной контроллер, который выполнит свою функцию и отправит ответ пользователю. Выглядит это следующим образом:
```
bot.hears('hello', async ctx => {
await ctx.reply('Hello!');
});
```
Работает это просто: если написать боту hello, то он просто ответит Hello! Зная этот аспект работы, попробуем представить, как может работать бот для поиска фильмов:
1. Пользователь пишет, что хочет перейти к поиску фильмов;
2. Пользователь вбивает название фильма;
3. Бот возвращает список фильмов и предлагает пользователю сохранить выбранный фильм в свою библиотеку;
4. ...
Внимание, вопрос! Как бот сможет различать, когда пользователь пишет ему, что хочет начать искать фильм, а когда он пишет само название фильма для поиска?
*Да, можно любой присланный текст принимать за название фильма, но мы же хотим сделать бота с ~~блэкджеком и путанами~~ хорошим интерфейсом.*
И тут в игру вступают сцены (Stages)! Легче всего будет рассказать на примере выше. Когда пользователь говорит, что хочет перейти к поиску фильмов, мы запускаем сцену. Внутри этой сцены стоят свои отдельные обработчики текста — bot.hears(...). Таким образом, все последующие сообщения будут относиться непосредственно к поиску фильмов до тех пор, пока пользователь не напишет сообщение для выхода и не покинет сцену. После этого обработчики внутри этой сцены деактивируются до тех пор, пока пользователь не вернется туда снова. Далее я расскажу, как я использовал сцены, чтобы сделать обработку событий максимально простой.
### Структура проекта
Есть подозрение, что статья получится достаточно объемной, а потому, чтобы не растягивать ее еще больше, я опущу некоторые моменты. Например, чтобы бот начал работать, необходимо начать с получения Telegram Bot API token. Прочитать о том, как это сделать, можно в официальной [документации](https://core.telegram.org/bots/) Telegram или же в [документации](https://telegraf.js.org/#/) к Telegraf.js.
Файловая структура проекта выглядит следующим образом:
**Структура проекта**
Работает это следующим образом:
* **src/controllers** — это и есть те самые сцены, про которые было написано выше. В данном проекте каждая сцена представляет из себя отдельный контроллер, который занимается обработкой соответствующих запросов.
* **src/locales** — переводы для разных языков. Telegraf.js позволяет относительно просто добавить локализацию к боту с использованием middlewares.
* **src/models** — модели для MongoDB.
* **src/types** — тайпинги для TypeScript. К сожалению, не все используемые в проекте библиотеки имеют тайпинги по умолчанию.
* **src/util** — различные функции-помощники, которые используются в разных частях проекта. Здесь можно посмотреть как работает проверка доступности фильма для скачивания, управление сессиями, создание клавиатур, обработчики ошибок и еще много всего интересного.
* **src/bot.ts** — главный файл, где производится вся подготовка и запуск бота.
* **src/telegram.ts** — в данном случае мы создаем объект класса Telegram из библиотеки Telegraf.js. С помощью этого объекта мы можем отправлять пользователям сообщения первыми, используя их ID, а не ждать, пока они что-то напишут. Например, в данном проекте мы отправляем пользователю сообщение о том, что фильм, за которым он следил, уже можно скачать. Конечно же, данный объект предоставляет гораздо больше возможностей.
* **Все остальное** — конфигурации для разных частей проекта, которые не будут рассмотрены в этой статье
### Инициализация и запуск
Когда мы разобрались со структурой проекта, давайте посмотрим, как собственно происходит запуск бота. Опять же, в целях сокращения статьи я не буду вставлять сюда код целиком, а расскажу лишь про главные, на мой взгляд, моменты. Полный код вы можете посмотреть в репозитории, ссылка на который доступна в конце статьи.
Начинается все с подключения к БД, где хранится информация о пользователях и отслеживаемых ими фильмах. После успешного подключения мы регистрируем все используемые в проекте сцены, задаем параметры для локализации и добавляем несколько middlewares — обработку сессий, локализацию, настройку сцен, а также несколько собственных. Одна из них, например, получает всю информацию о пользователе в соответствии с его ID и добавляет ее к контексту, который используется в контроллерах. Наконец, после всех основных приготовлений, мы запускаем бота либо в development (long polling), либо в production (Webhooks) режиме.
**Важно:** если вы используете разные методы получения обновлений (long polling и Webhooks), то при запуске бота в режиме long polling сперва удалите слушающий Webhook с помощью GET запроса на [api.telegram.org/botYOUR\_TOKEN/deleteWebhook](https://api.telegram.org/botYOUR_TOKEN/deleteWebhook). В противном случае бот может работать неправильно.
### Обрабатываем пользовательский ввод
Ура! Бот работает, подключен к базе данных и готов принимать сообщения от пользователей. Но как правильно это сделать?
В первую очередь, пользователям будет удобно пользоваться встроенной Telegram-клавиатурой. По сути, при нажатии на кнопки этой клавиатуры отправляются сообщения с содержимым этих кнопок. Дальше мы просто добавляем обработчики этого текста и выполняем определенные действия.
В файле [bot.ts](https://github.com/dmbaranov/evemovies-bot/blob/master/src/bot.ts#L66) как раз стоят такие обработчики. Так как бот поддерживает два языка, то и кнопки могут содержать разный текст — на русском и английском языках. В telegraf-i18n есть функция match, которая умеет обрабатывать нажатие одной и той же кнопки с разными языками.
Большинство обработчиков в bot.ts выполняют единственную функцию — они запускают пользователя в соответствующую сцену. Так, у нас есть несколько разделов — поиск фильмов, моя коллекция, настройки и контакты. Для каждого из разделов есть своя сцена и своя кнопка, при нажатии на которую пользователь перемещается в соответствующую сцену.
**Важно:** обязательно добавьте обработчик, который будет выпускать пользователя из сцены, иначе они рискуют остаться там навсегда! Также полезным будет сделать одну общую команду (в боте используется /saveme), которая будет добавлена в каждую сцену и в главный файл. Эта команда будет служить выходом из любой сцены, а также сбрасывать пользовательские настройки.
И вот, пользователь хочет перейти к поиску фильмов. Нажатием на соответствующую кнопку мы перемещаем его в сцену поиска. Для удобства, у каждой сцены есть своя папка с файлами, каждый из которых выполняет определенную функцию.
Внутри сцены можно использовать свои middlewares, которые лежат в файле middlewares.ts. Например, используя middleware в сцене поиска, мы можем достаточно просто пробросить всю информацию о фильме в соответствующие методы, а не выполнять одну и ту же функцию каждый раз внутри них.
В Telegram также есть inline-клавиатура. Возможно вы встречали сообщения с голосованиями, под которыми есть несколько полупрозрачных кнопок и при нажатии на одну из них количество голосов меняется. Эти кнопки и есть inline-клавиатура
**Вот как это выглядит у Eve**
В каждой кнопке содержится информация, при нажатии на кнопку она будет передана в соответствующий обработчик. **Размер передаваемой информации не должен превышать 64 байта!** Чтобы научить бота слушать нажатия на кнопки, нам нужно зарегистрировать их с помощью bot.action(/trigger/, callback). В первый параметр попадают все данные, которые были привязаны к кнопке. Я решил использовать нечто вроде Actions из Redux, где к каждой кнопке привязан объект вида {a: actionName, p: payload}. При регистрации listeners мы можем использовать простой RegExp, например: bot.action(/actionName/, callBack). Все обработчики для inline-клавиатуры находятся в файлах actions.ts.
Помимо этого, в некоторых сценах лежат файлы helpers.ts, которые содержат в себе небольшие функции вынесенные туда с целью разгрузить остальные файлы. По большей части там лежат генераторы клавиатур для разных действий со стороны пользователя.
### Локализация
Так как это важная тема, я думаю ее стоит упомянуть отдельно. Как я говорил ранее, Telegraf.js содержит довольно большое количество middlewares, одной из которых является [telegraf-i18n](https://github.com/telegraf/telegraf-i18n). В репозитории присутствует подробная инструкция и особых проблем у меня с этим не возникло, но все же я добавлю пару слов о том, как это работает в данном проекте.
Есть папка locales, где лежат файлы для локализации, которые представляют из себя JSON объект вида { «ключ»: «перевод» }. Далее, везде, где нам нужно использовать разные языки, мы используем метод из этой библиотеки, куда передаем нужный нам перевод по ключу, а на выходе получаем соответствующий перевод. Для хранения информации о выбранном пользователем языке может использоваться сессия. Также еще раз стоит упомянуть про кнопки. В этой же библиотеке есть функция match, поэтому если текст на кнопке меняется в зависимости от языка, то эта функция поможет вам повесить правильный listener.
**Важно:** если вы собираетесь использовать локализацию и писать бота на TypeScript, не забудьте добавить папку с переводами в tsconfig.json, иначе код не скомпилируется. Например:
```
"include": ["src/locales/*.json"]
```
### Заключение
Спасибо что дочитали до конца! В этой статье я постарался максимально подробно описать процесс создания Telegram-бота в целом, без сильной привязки к своему проекту. Я надеюсь, что после прочтения этой статьи, а также изучения исходного кода Eve, вы сможете с легкостью создать бота, который сможет помочь вам.
Как и обещал, исходный код вы можете посмотреть на [GitHub](https://github.com/dmbaranov/evemovies-bot), а попробовать Eve в деле [вот здесь](https://t.me/evemovies_bot). Я буду безмерно благодарен за любую критику и предложения по улучшению.
Отдельно хочу отметить [раздел](https://telegraf.js.org/#/?id=example) в документации Telegraf.js с интересными open source проектами, на которые можно посмотреть и вдохновиться архитектурой и решениями. Я, в свою очередь, хочу отметить один из них — [The Guard Bot](https://github.com/TheDevs-Network/the-guard-bot). Поистине большой и хорошо сделанный бот, откуда я позаимствовал часть решений для своей разработки.
А на данный момент я рассказал все, что хотел, буду рад ответить на ваши вопросы, предложения и комментарии! | https://habr.com/ru/post/443876/ | null | ru | null |
# Настройки Windows 10: часть III, или куда приводят скрипты
Здравствуйте, товарищи! Прошло чуть больше полугода после выхода предыдущей [статьи](https://habr.com/post/465365) о [Windows 10 Sophia Script](https://github.com/farag2/Windows-10-Sophia-Script) — скрипте, который за прошедшие годы стал самым крупным (а их осталось всего два) опенсорс-проектом по персонализации и настройке Windows 10, а также автоматизации рутинных задач. В статье я расскажу, что изменилось с момента релиза версии, описываемой в статье от 29.09.2020, с какими трудностями мы столкнулись, и куда всё движется.
---
Как всё начиналось
------------------
Разработка наброска скрипта берёт своё начало в те далёкие времена, когда после года работы экономистом в отделе проектирования птицефабрики в одной организации я решил перейти в местный отдел IT.
Отдел ITПерейдя на новое место, я предложил автоматизировать настройку пользовательских ОС. Так, через пару недель, появился первый прародитель данного модуля — примитивный .reg-файл для настройки Windows 8.1. Но я и ему был рад, так как всё было в новинку.
Так продолжалось, наверное, год, пока я не понял, что упёрся в тупик и надо менять язык: начал готовить "батник".
В первый день выхода Windows 10 я сразу же "пересел" на неё, поняв, что Windows 8.1 осталась для Microsoft в прошлом. Со временем же "батник" рос, "мужал", разрастался и в какой-то момент даже стал дёргать другой интерпретатор, powershell.exe. Скорость работы падала, и я понимал, что придётся учить PowerShell, так как batch уже не удовлетворяет моим маниакальным запросам автоматизировать всё при настройке ОС.
Как сейчас помню, в феврале 2017 года я сел читать первую статью по запросу "как внести данные в реестр с помощью PowerShell". Уже к лету 2017 года я значительно продвинулся в переписывании всех имеющих функций из "батника" в новый скрипт.
Изначально, конечно, скрипт состоял лишь из одного файла с расширением .ps1. Пользователям приходилось править код и комментировать целые функции, чтобы настроить под себя. То ещё удовольствие было…
Помню, как первый раз почувствовал, что я делаю что-то полезное, когда некто создал issue с просьбой указывать, что я исправляю, когда перезаписываю файлы на GitHub. Пришлось вести журнал изменений.
В таком неспешном темпе разработка шла до августа 2019 года, когда я решил поделиться своими наработками здесь. Хотя я читаю Хабр с года эдак 2007-го, зарегистрировался лишь в 2016-м.
Немного облагородил код (ага, 10 раз), добавил описания на английском языке и накатал крохотную статью о своей pet-разработке. Удивительно, но статью пропустили, она попала в бездну, и я сел ждать.
Мой лик, когда ожидаю приглашенияКак сейчас помню: сижу на сеансе в кинотеатре, и приходит уведомление на почту о новом комментарии к моей статье. Так, стоп! Её одобрили?!
Я не успевал отвечать на комментарии! Это была какая-то эйфория. Какой там фильм?! — меня на Хабр пригласили прямым инвайтом! Фурор! Даже код не обо...ли (а там был кровавый мрак) и вообще любезно приняли.
Мой лик, когда получил приглашениеСамым неожиданным поворотом стало то, что через 5 дней после публикации мне написал некий Дмитрий ([@oz-zo](https://habr.com/users/oz-zo)), прочитавший моё сетование на то, что у меня не хватает знаний, чтобы сделать графическую версию скрипта, даже хотя бы на Windows.Forms. Я был приятно удивлён, что есть ещё один старый безумец. Как выяснилось, старый, но не бесполезный!
Познакомившись, мы запланировали всё сделать примерно за 3 месяца на Windows.Forms, но наше приключение затянулось… больше чем на 1,5 года: лишь в этом месяце мы вышли на финишную прямую по созданию графической версии моего скрипта — [SophiApp](https://github.com/SophiaUI/SophiApp). Но это уже другая история, и, когда будет что показать, я обязательно расскажу, что мы пережили за время разработки, поделившись нашими инфернальными набросками и наработками.
С того времени как я познакомился с Дмитрием, разработка пошла быстрее: он внёс огромный вклад в создание новых функций, которых не было ни у кого: все графические функции с использованием WPF и логику к ним написал именно он; я лишь объяснил, как получать данные.
Иконка Sophia ScriptНемаловажным событием стало также знакомство с Дэвидом из Канады, который решил сделать самостоятельно [графическую надстройку для Sophia Script](https://benchtweakgaming.com/2020/11/12/windows-10-debloat-tool), Sophia Script Wrapper, для повышения удобства редактирования пресет-файла. В текущем варианте пользователь импортирует пресет-файл скрипта, и в программе расставляются радиокнопки в зависимости от закомментированных и раскомментированных функций. Дальше можно настроить под себя и запустить выполнение настроенного пресет-файла.
Хотя Дэвиду уже нормально так, программировать он сел лишь недавно, окончив курсы. Но его программа выполняет ту задачу, для которой её и написали. Одним словом, люди пользуются.
Sophia Script WrapperЧто поменялось в скрипте
------------------------
За время, прошедшее с момента выхода прошлой статьи в сентябре, много воды утекло. Скрипт уже и не узнать. Больше 12 000 строк кода… Самые интересные изыскания пришлись на удаление UWP-приложений и закрепление ярлыков на начальный экран.
Напомню, какие версии Windows 10 поддерживает скрипт на данный момент.
| | | | | |
| --- | --- | --- | --- | --- |
| **Версия** | **Маркетинговое название** | **Билд** | **Архитектура** | **Издания** |
| 21H1 | May 2021 Update | 19043 | x64 | Home/Pro/Enterprise |
| 20H2 | October 2020 Update | 19042 | x64 | Home/Pro/Enterprise |
| 2004 | May 2020 Update | 19041 | x64 | Home/Pro/Enterprise |
| 1809 | LTSC Enterprise 2019 | 17763 | x64 | Enterprise |
А теперь пройдёмся по всем доработанным и новым функциям.
Функции касающиеся манипуляций с UWP-приложениями
-------------------------------------------------
Было/СталоНаверное, вы уже заметили, что список стал локализованным. Также хочется добавить, что список генерируется динамически, загружая лишь установленные пакеты UWP-приложений в соответствии с текущей локализацией. Как это реализовано?
Свойство DisplayName, которое содержит локализованное имя пакета, находится лишь в одном классе (Get-AppxPackage вам никак тут не поможет, к сожалению):
"Windows.Management.Deployment.PackageManager"
```
[Windows.Management.Deployment.PackageManager, Windows.Web, ContentType = WindowsRuntime]::new().FindPackages() | Select-Object -Property DisplayName -ExpandProperty Id | Select-Object -Property Name, DisplayName
```
На выходе вы получите что-то вроде этого (простыню кода прячу под спойлер)
```
Name DisplayName
---- -----------
1527c705-839a-4832-9118-54d4Bd6a0c89
c5e2524a-ea46-4f67-841f-6a9465d9d515 Проводник
E2A4F912-2574-4A75-9BB0-0D023378592B Сопоставитель приложений
F46D4000-FD22-4DB4-AC8E-4E1DDDE828FE Диалоговое окно "Добавить рекомендованные папки"
Microsoft.AAD.BrokerPlugin Учетная запись компании или учебного заведения
Microsoft.AccountsControl Электронная почта и учетные записи
Microsoft.AsyncTextService AsyncTextService
Microsoft.BioEnrollment Настройка Windows Hello
Microsoft.CredDialogHost Диалоговое окно учетных данных
Microsoft.ECApp Управление глазами
Microsoft.LockApp Экран блокировки Windows по умолчанию
Microsoft.MicrosoftEdgeDevToolsClient Клиент средств разработчика для Microsoft Edge
Microsoft.MicrosoftEdge
Microsoft.Win32WebViewHost Веб-средство просмотра классических приложений
Microsoft.Windows.Apprep.ChxApp SmartScreen Защитника Windows
Microsoft.Windows.AssignedAccessLockApp Приложение "Блокировка" при ограниченном доступе
Microsoft.Windows.CallingShellApp Видеозвонки
Microsoft.Windows.CapturePicker CapturePicker
Microsoft.Windows.CloudExperienceHost Ваша учетная запись
Microsoft.Windows.ContentDeliveryManager Содержимое, предоставленное корпорацией Майкрософт
Microsoft.Windows.NarratorQuickStart Экранный диктор
Microsoft.Windows.OOBENetworkCaptivePortal Поток портала авторизации
Microsoft.Windows.OOBENetworkConnectionFlow Последовательность действий при сетевом подключении
Microsoft.Windows.ParentalControls Функции семьи учетных записей Майкрософт
Microsoft.Windows.PeopleExperienceHost Windows Shell Experience
Microsoft.Windows.PinningConfirmationDialog PinningConfirmationDialog
Microsoft.Windows.Search Windows Search
Microsoft.Windows.SecHealthUI Безопасность Windows
Microsoft.Windows.SecureAssessmentBrowser Тестирование
Microsoft.Windows.ShellExperienceHost Windows Shell Experience
Microsoft.Windows.StartMenuExperienceHost Запустить
Microsoft.Windows.XGpuEjectDialog Безопасное извлечение устройства
Microsoft.XboxGameCallableUI Xbox Game UI
MicrosoftWindows.Client.CBS Windows Feature Experience Pack
MicrosoftWindows.UndockedDevKit UDK Package
NcsiUwpApp NcsiUwpApp
Windows.CBSPreview Предварительный просмотр штрихкодов Windows
windows.immersivecontrolpanel Параметры
Windows.PrintDialog PrintDialog
Microsoft.Services.Store.Engagement Microsoft Engagement Framework
Microsoft.Services.Store.Engagement Microsoft Engagement Framework
Microsoft.UI.Xaml.2.0 Microsoft.UI.Xaml.2.0
Microsoft.VCLibs.140.00 Microsoft Visual C++ 2015 UWP Runtime Package
Microsoft.Advertising.Xaml Microsoft Advertising SDK for XAML
Microsoft.NET.Native.Framework.2.2 Microsoft .Net Native Framework Package 2.2
Microsoft.NET.Native.Framework.2.2 Microsoft .Net Native Framework Package 2.2
Microsoft.VCLibs.140.00 Microsoft Visual C++ 2015 UWP Runtime Package
Microsoft.VCLibs.140.00 Microsoft Visual C++ 2015 UWP Runtime Package
Microsoft.NET.Native.Runtime.2.2 Microsoft .Net Native Runtime Package 2.2
Microsoft.NET.Native.Runtime.2.2 Microsoft .Net Native Runtime Package 2.2
Microsoft.VCLibs.140.00.UWPDesktop Microsoft Visual C++ 2015 UWP Desktop Runtime Package
Microsoft.VCLibs.140.00.UWPDesktop Microsoft Visual C++ 2015 UWP Desktop Runtime Package
Microsoft.UI.Xaml.2.1 Microsoft.UI.Xaml.2.1
Microsoft.UI.Xaml.2.1 Microsoft.UI.Xaml.2.1
Microsoft.UI.Xaml.2.0 Microsoft.UI.Xaml.2.0
Microsoft.UI.Xaml.2.3 Microsoft.UI.Xaml.2.3
Microsoft.UI.Xaml.2.3 Microsoft.UI.Xaml.2.3
Microsoft.UI.Xaml.2.4 Microsoft.UI.Xaml.2.4
Microsoft.UI.Xaml.2.4 Microsoft.UI.Xaml.2.4
Microsoft.ScreenSketch Набросок на фрагменте экрана
Microsoft.NET.Native.Framework.1.7 Microsoft .Net Native Framework Package 1.7
Microsoft.NET.Native.Framework.1.7 Microsoft .Net Native Framework Package 1.7
Microsoft.NET.Native.Runtime.1.7 Microsoft .Net Native Runtime Package 1.7
Microsoft.NET.Native.Runtime.1.7 Microsoft .Net Native Runtime Package 1.7
Microsoft.VCLibs.120.00 Microsoft Visual C++ Runtime Package
Microsoft.VCLibs.120.00 Microsoft Visual C++ Runtime Package
Microsoft.VCLibs.140.00.UWPDesktop Microsoft Visual C++ 2015 UWP Desktop Runtime Package
Microsoft.VCLibs.140.00.UWPDesktop Microsoft Visual C++ 2015 UWP Desktop Runtime Package
Microsoft.VCLibs.140.00 Microsoft Visual C++ 2015 UWP Runtime Package
Microsoft.VCLibs.140.00 Microsoft Visual C++ 2015 UWP Runtime Package
Microsoft.WebpImageExtension Расширения для изображений Webp
Microsoft.DesktopAppInstaller Установщик приложения
Microsoft.NET.Native.Framework.2.2 Microsoft .Net Native Framework Package 2.2
Microsoft.NET.Native.Framework.2.2 Microsoft .Net Native Framework Package 2.2
AppUp.IntelGraphicsExperience Центр управления графикой Intel
Microsoft.Windows.StartMenuExperienceHost Запустить
Microsoft.Windows.ShellExperienceHost Windows Shell Experience
Microsoft.Windows.AssignedAccessLockApp Приложение "Блокировка" при ограниченном доступе
Microsoft.WindowsTerminal Windows Terminal
Microsoft.AV1VideoExtension AV1 Video Extension
Microsoft.HEIFImageExtension Расширения для изображений HEIF
Microsoft.Windows.Photos Фотографии (Майкрософт)
Microsoft.UI.Xaml.2.5 Microsoft.UI.Xaml.2.5
Microsoft.UI.Xaml.2.5 Microsoft.UI.Xaml.2.5
Microsoft.WindowsStore Microsoft Store
Microsoft.StorePurchaseApp Узел для покупок в Store
Microsoft.LanguageExperiencePackru-RU Пакет локализованного интерфейса на русском
Microsoft.MicrosoftEdge Microsoft Edge
Microsoft.VP9VideoExtensions Расширения для VP9-видео
MicrosoftWindows.Client.WebExperience Windows Web Experience Pack
Microsoft.WebMediaExtensions Расширения для интернет-мультимедиа
Microsoft.HEVCVideoExtension Расширения для видео HEVC от производителя устройства
MicrosoftWindows.Client.CBS Windows Feature Experience Pack
Microsoft.MicrosoftEdge.Stable Microsoft Edge
```
Первые попытки переписать функцию удаления UWP-пакетовХоть на картинке и не видно, но кнопка "Для всех пользователей" была тоже полностью переписана. Раньше она совершенно неправильно работала. Сейчас же её логика приведена к должному функционалу. По умолчанию при загрузке формы отображается список приложений для текущего пользователя (все системные пакеты и Microsoft Store исключены из списка, так что удалить хоть что-то важное не получится никак, в отличие, кстати, от всех других скриптов в Интернете). При нажатии на кнопку "Для всех пользователей" происходит динамическая перегенерация списка с учётом установленных пакетов во всех учётных записях. То есть вы можете удалить все приложения для текущего пользователя, и форма отобразится пустой, но при запуске функции с ключом "-ForAllUsers" отобразится список пакетов для всех учётных записей.
Как-то меня [попросили](https://github.com/farag2/Windows-10-Sophia-Script/issues/70) добавить поддержку PowerShell 7. И всё это было бы смешно, когда бы не было так грустно…
Во-первых, ни для кого не будет секретом, что, хотя в PowerShell 7 исправили очень много багов, в нынешнем виде очень далёк от финальной версии, ведь там до сих пор даже не работает командлет **Get-ComputerRestorePoint** из коробки. И (в качестве временного решения) Microsoft предложил загружать в сессию недостающие модули из папки PowerShell 5.1, используя аргумент **-UseWindowsPowerShell**.
Таким образом, мне приходится загружать модули Microsoft.PowerShell.Management, PackageManagement, Appx, чтобы воссоздать работоспособность скрипта на PowerShell 7:
```
Import-Module -Name Microsoft.PowerShell.Management, PackageManagement, Appx -UseWindowsPowerShell
```
Во-вторых, код для получения локализованных имен UWP-пакетов не работает в PowerShell 7 вообще, так как Microsoft решил [не включать](https://docs.microsoft.com/en-us/dotnet/core/compatibility/interop/5.0/built-in-support-for-winrt-removed) библиотеки WinRT в релизы PowerShell 7, но вынес разработку на отдельные ресурсы: [WinRT](https://github.com/microsoft/CsWinRT) и [Windows.SDK](https://www.nuget.org/packages/Microsoft.Windows.SDK.NET.Ref). Это упомянул и Steven Lee в [обсуждении](https://github.com/PowerShell/PowerShell/issues/13042#issuecomment-653357546) на GitHub, а также уведомил, что команда PowerShell решила [не включать](https://github.com/PowerShell/PowerShell/issues/13042#issuecomment-655784384) в дальнейшем в релизы эти библиотеки. Поэтому, чтобы вызвать необходимые API, мне приходится хранить в папке две библиотеки по 26 МБ и 284 КБ. Тут остаётся лишь поставить мем с пингвином.
Код для получения локализованных имен UWP-пакетов на PowerShell 7 выглядит так:
```
Add-Type -AssemblyName "$PSScriptRoot\Libraries\WinRT.Runtime.dll"
Add-Type -AssemblyName "$PSScriptRoot\Libraries\Microsoft.Windows.SDK.NET.dll"
$AppxPackages = Get-AppxPackage -PackageTypeFilter Bundle -AllUsers
$PackagesIds = [Windows.Management.Deployment.PackageManager]::new().FindPackages().AdditionalTypeData[[Collections.IEnumerable].TypeHandle] | Select-Object -Property DisplayName -ExpandProperty Id | Select-Object -Property Name, DisplayName
foreach ($AppxPackage in $AppxPackages)
{
$PackageId = $PackagesIds | Where-Object -FilterScript {$_.Name -eq $AppxPackage.Name}
if (-not $PackageId)
{
continue
}
[PSCustomObject]@{
Name = $AppxPackage.Name
PackageFullName = $AppxPackage.PackageFullName
DisplayName = $PackageId.DisplayName
}
}
```
На выходе будет что-то вроде:
```
Name PackageFullName DisplayName
---- --------------- -----------
RealtekSemiconductorCorp.RealtekAudioControl RealtekSemiconductorCorp.RealtekAudioControl_1.1.137.0_neutral_~_dt26b99r8h8gj Realtek Audio Control
Microsoft.MicrosoftStickyNotes Microsoft.MicrosoftStickyNotes_3.7.142.0_neutral_~_8wekyb3d8bbwe Microsoft Sticky Notes
Microsoft.ScreenSketch Microsoft.ScreenSketch_2020.814.2355.0_neutral_~_8wekyb3d8bbwe Набросок на фрагменте экрана
Microsoft.WindowsCalculator Microsoft.WindowsCalculator_2020.2008.2.0_neutral_~_8wekyb3d8bbwe Windows Calculator
AppUp.IntelGraphicsExperience AppUp.IntelGraphicsExperience_1.100.3282.0_neutral_~_8j3eq9eme6ctt Центр управления графикой Intel
Microsoft.MicrosoftSolitaireCollection Microsoft.MicrosoftSolitaireCollection_4.7.10142.0_neutral_~_8wekyb3d8bbwe Microsoft Solitaire Collection
Microsoft.DesktopAppInstaller Microsoft.DesktopAppInstaller_2020.1112.20.0_neutral_~_8wekyb3d8bbwe Установщик приложения
Microsoft.WindowsStore Microsoft.WindowsStore_12101.1001.1413.0_neutral_~_8wekyb3d8bbwe Microsoft Store
Microsoft.Windows.Photos Microsoft.Windows.Photos_2020.20120.4004.0_neutral_~_8wekyb3d8bbwe Фотографии (Майкрософт)
Microsoft.WebMediaExtensions Microsoft.WebMediaExtensions_1.0.40471.0_neutral_~_8wekyb3d8bbwe Расширения для интернет-мультим…
Microsoft.WindowsCamera Microsoft.WindowsCamera_2021.105.10.0_neutral_~_8wekyb3d8bbwe Камера Windows
Microsoft.StorePurchaseApp Microsoft.StorePurchaseApp_12103.1001.813.0_neutral_~_8wekyb3d8bbwe Узел для покупок в Store
Microsoft.WindowsTerminal Microsoft.WindowsTerminal_2021.413.2245.0_neutral_~_8wekyb3d8bbwe Windows Terminal
Microsoft.WindowsTerminalPreview Microsoft.WindowsTerminalPreview_2021.413.2303.0_neutral_~_8wekyb3d8bbwe Windows Terminal Preview
```
Аналогичный подход используется для функции восстановления UWP-приложений. Чтобы восстановить пакет, как известно, необходимо вычленить путь до его манифеста.
Восстановление удаленных UWP-приложений для текущего пользователяКод для получения общего списка всех манифестов выглядит так (можете даже выполнить, если, конечно, не удалили все UWP-приложения):
```
$Bundles = (Get-AppXPackage -PackageTypeFilter Framework -AllUsers).PackageFullName
Get-ChildItem -Path "HKLM:\SOFTWARE\Classes\Local Settings\Software\Microsoft\Windows\CurrentVersion\AppModel\PackageRepository\Packages" | ForEach-Object -Process {
Get-ItemProperty -Path $_.PSPath
} | Where-Object -FilterScript {$_.Path -match "Program Files"} | Where-Object -FilterScript {$_.PSChildName -notin $Bundles} | Where-Object -FilterScript {$_.Path -match "x64"} | ForEach-Object -Process {"$($_.Path)\AppxManifest.xml"}
```
И вы увидите что-то вроде:
```
C:\Program Files\WindowsApps\A025C540.Yandex.Music_4.40.7713.0_x64__vfvw9svesycw6\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.549981C3F5F10_2.2103.17603.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.BingNews_1.0.6.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.BingWeather_1.0.6.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.DesktopAppInstaller_1.11.10771.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.GamingApp_1.0.1.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.GetHelp_10.2102.40951.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.Getstarted_10.2.40751.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.HEIFImageExtension_1.0.40978.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.MicrosoftOfficeHub_18.2008.12711.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.MicrosoftSolitaireCollection_4.9.4072.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.MicrosoftStickyNotes_1.8.15.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.Paint_10.2103.1.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.People_10.1909.12456.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.PowerAutomateDesktop_1.0.31.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.ScreenSketch_11.2103.13.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.SkypeApp_14.53.77.0_x64__kzf8qxf38zg5c\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.StorePurchaseApp_12103.1001.8.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.Todos_0.41.4902.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.VP9VideoExtensions_1.0.40631.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.WebMediaExtensions_1.0.40831.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.WebpImageExtension_1.0.32731.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.Windows.Photos_2021.21030.17018.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.WindowsAlarms_1.0.38.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.WindowsCalculator_10.2103.8.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.WindowsCamera_2020.503.58.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\microsoft.windowscommunicationsapps_16005.13426.20688.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.WindowsFeedbackHub_1.2009.10531.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.WindowsMaps_1.0.27.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.WindowsNotepad_10.2103.6.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.WindowsSoundRecorder_1.0.42.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.WindowsStore_12103.1001.11.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.WindowsTerminal_1.6.10571.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.Xbox.TCUI_1.23.28002.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.XboxGameOverlay_1.54.4001.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.XboxGamingOverlay_5.621.4072.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.XboxIdentityProvider_12.67.21001.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.XboxSpeechToTextOverlay_1.21.13002.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.YourPhone_1.21022.202.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.ZuneMusic_10.21012.10511.0_x64__8wekyb3d8bbwe\AppxManifest.xml
C:\Program Files\WindowsApps\Microsoft.ZuneVideo_10.21021.10311.0_x64__8wekyb3d8bbwe\AppxManifest.xml
PS C:\Windows\system32\WindowsPowerShell\v1.0>
```
Но нам надо сопоставить имя пакета, его локализованное имя в системе и путь до манифеста. Искать будем среди пакетов, которые имеют статус "Staged", то есть готовы к восстановлению.
```
# Тут нельзя напрямую вписать -PackageTypeFilter Bundle, так как иначе не выдается нужное свойство InstallLocation. Только сравнивать с $Bundles
$Bundles = (Get-AppXPackage -PackageTypeFilter Bundle -AllUsers).Name
$AppxPackages = Get-AppxPackage -AllUsers | Where-Object -FilterScript {$_.PackageUserInformation -match "Staged"} | Where-Object -FilterScript {$_.Name -in $Bundles}
$PackagesIds = [Windows.Management.Deployment.PackageManager, Windows.Web, ContentType = WindowsRuntime]::new().FindPackages() | Select-Object -Property DisplayName -ExpandProperty Id | Select-Object -Property Name, DisplayName
foreach ($AppxPackage in $AppxPackages)
{
$PackageId = $PackagesIds | Where-Object -FilterScript {$_.Name -eq $AppxPackage.Name}
if (-not $PackageId)
{
continue
}
[PSCustomObject]@{
Name = $AppxPackage.Name
PackageFullName = $AppxPackage.PackageFullName
DisplayName = $PackageId.DisplayName
AppxManifest = "$($AppxPackage.InstallLocation)\AppxManifest.xml"
}
}
```
Ну, а дальше уже дело техники. Кстати, если вам надо восстановить все возможные пакеты без разбора, то в этом вам поможет.
```
# Re-register all UWP apps
$Bundles = (Get-AppXPackage -PackageTypeFilter Framework -AllUsers).PackageFullName
Get-ChildItem -Path "HKLM:\SOFTWARE\Classes\Local Settings\Software\Microsoft\Windows\CurrentVersion\AppModel\PackageRepository\Packages" | ForEach-Object -Process {
Get-ItemProperty -Path $_.PSPath
} | Where-Object -FilterScript {$_.Path -match "Program Files"} | Where-Object -FilterScript {$_.PSChildName -notin $Bundles} | Where-Object -FilterScript {$_.Path -match "x64"} | ForEach-Object -Process {"$($_.Path)\AppxManifest.xml"} | Add-AppxPackage -Register -ForceApplicationShutdown -ForceUpdateFromAnyVersion -DisableDevelopmentMode -Verbose
# Check for UWP apps updates
Get-CimInstance -Namespace "Root\cimv2\mdm\dmmap" -ClassName "MDM_EnterpriseModernAppManagement_AppManagement01" | Invoke-CimMethod -MethodName UpdateScanMethod
```
Мы специально не хотели хардкодить список приложений как на удаление, так и на восстановление, так это слишком топорно. Одним словом, получить локализованные имена приложений реально. Дмитрий создал форму на WPF и накатал логику. Не знаю, почему, но мне с Дмитрием потребовалась, наверное, пара недель, учтя все возможные и невозможные условия использования, заставить всё работать как надо.
Точно таким же способом можно выводить список локализованных имён компонентов Windows и дополнительных компонентов.
Работает экстремально медленно, но спасает то, что у меня выводится лишь захардоженный список компонентов, которые можно безболезненно отключить (и включить опять, конечно).
```
Get-WindowsOptionalFeature -Online | ForEach-Object -Process {Get-WindowsOptionalFeature -FeatureName $_.FeatureName -Online} | Select-Object -Property FeatureName, DisplayName | Format-Table -AutoSize
```
БылоСталоНаши лики, когда, наконец, всё заработалоИнтернационализация скрипта
---------------------------
На необходимость этой фичи обратил внимание [@FrankSinatra](/users/franksinatra) в [комментариях](https://habr.com/ru/post/521202/#comment_22127592). Интернационализация позволяет избавиться от страшной конструкции вида
```
if ($RU)
{
}
else
{
}
```
Отныне в корне папки скрипта находятся папки с названием кода локализации: например, ru-RU, en-US и так далее, где внутри находится файл локализации вида UnsupportedOSBitness = The script supports Windows 10 x64 only. Получить значение локализации можно командой $PSUICulture.
Соответственно, чтобы это всё заработало, мы импортируем указанные локализационные файлы, сохраняя строки в переменную так, чтобы можно было вызывать их в скрипте:
```
# Sophia.psd1
ConvertFrom-StringData -StringData @'
UnsupportedOSBitness = The script supports Windows 10 x64 only
'@
# Sophia.ps1
Import-LocalizedData -BindingVariable Global:Localization -FileName Sophia
$Localization.UnsupportedOSBitness
```
И в зависимости от текущей локализации системы скрипт сам будет искать нужный файл. И код чище, и людя́м приятнее! Ну, а если необходимой локализации нет, то по умолчанию загружается английская.
На сегодня скрипт локализован на 8 языков: английский, китайский, немецкий, французский, итальянский, русский, украинский, турецкий, испанский и португальский. В будущем всё-таки планирую разместить языковые файлы на [Crowdin](https://crowdin.com), но немного душит жаба платить столько денег за некоммерческий продукт.
Закрепление ярлыков на начальном экране
---------------------------------------
Используется при этом чистый PowerShell. Изначально я использовал стороннюю программу [syspin](https://www.technosys.net/products/utils/pintotaskbar), но возникло желание всё-таки избавиться от неё. Как вы знаете, с выходом Windows 10 October 2018 Microsoft без шума закрыл доступ к API открепления (закрепления) ярлыков от начального экрана и панели задач: отныне это можно сделать лишь вручную.
Ниже приведён пример кода для закрепления (открепления) ярлыка на начальный экран, который когда-то работал. Как можете видеть, в коде используется метод получения локализованной строки, и для этого нам необходимо знать код строки, чтобы вызвать соответствующий пункт контекстного меню. В данном примере, чтобы закрепить ярлык командной строки, мы вызываем строку с кодом **51201**, «Закрепить на начальном экране», из библиотеки **%SystemRoot%\system32\shell32.dll**.
Получить список всех локализованных строк удобнее всего через стороннюю утилиту [ResourcesExtract](https://www.nirsoft.net/utils/resources_extract.html).
Попытка закрепить ярлык командной строки устаревшим методом:
```
# Extract a localized string from shell32.dll
$Signature = @{
Namespace = "WinAPI"
Name = "GetStr"
Language = "CSharp"
MemberDefinition = @"
[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
public static extern IntPtr GetModuleHandle(string lpModuleName);
[DllImport("user32.dll", CharSet = CharSet.Auto)]
internal static extern int LoadString(IntPtr hInstance, uint uID, StringBuilder lpBuffer, int nBufferMax);
public static string GetString(uint strId)
{
IntPtr intPtr = GetModuleHandle("shell32.dll");
StringBuilder sb = new StringBuilder(255);
LoadString(intPtr, strId, sb, sb.Capacity);
return sb.ToString();
}
"@
}
if (-not ("WinAPI.GetStr" -as [type]))
{
Add-Type @Signature -Using System.Text
}
# Pin to Start: 51201
# Unpin from Start: 51394
$LocalizedString = [WinAPI.GetStr]::GetString(51201)
# Trying to pin the Command Prompt shortcut to Start
$Target = Get-Item -Path "$env:APPDATA\Microsoft\Windows\Start Menu\Programs\System Tools\Command Prompt.lnk"
$Shell = New-Object -ComObject Shell.Application
$Folder = $Shell.NameSpace($Target.DirectoryName)
$file = $Folder.ParseName($Target.Name)
$Verb = $File.Verbs() | Where-Object -FilterScript {$_.Name -eq $LocalizedString}
$Verb.DoIt()
```
Сейчас консоль вываливается с ошибкой Access is denied. (Exception from HRESULT: 0x80070005 (E\_ACCESSDENIED).)
Хотя, как можно заметить, API, конечно, отдаёт глагол контекстного меню «**Закрепить на начальном &экране**», но не может его выполнить.
Мы знаем, что текущий макет начального экрана можно выгрузить в формате XML. Но, даже если его настроить должным образом, импортировать макет в профиль текущего пользователя не получится: **Import-StartLayout -LayoutPath D:\Layout.xml** импортирует макеты начального экрана и панели задач только для новых пользователей.
Идея заключается в том, чтобы использовать политику «Макет начального экрана» (Prevent users from customizing their Start Screen), отвечающую за подгрузку предзаготовленного макета в формате XML из определённого места. Таким образом, наш хак будет состоять из следующих пунктов:
* Выгружаем текущий макет начального экрана.
* Парсим XML, добавляя необходимые нам ярлыки (ссылки должны вести на реально существующие ярлыки), и сохраняем.
* С помощью политики временно выключаем возможность редактировать макет начального экрана.
* Перезапускаем меню «Пуск».
* Программно открываем меню «Пуск», чтобы в реестре сохранился его макет.
* Выключаем политику, чтобы можно было редактировать макет начального экрана.
* И открываем меню «Пуск» опять.
Вуаля! В данном примере мы настроили начальный экран на лету, закрепив на него три ярлыка для текущего пользователя: панель управления, устройства и принтеры и PowerShell, причём без перезапуска или выхода из учётной записи.
Код целиком:
```
<#
.SYNOPSIS
Configure the Start tiles
.PARAMETER ControlPanel
Pin the "Control Panel" shortcut to Start
.PARAMETER DevicesPrinters
Pin the "Devices & Printers" shortcut to Start
.PARAMETER PowerShell
Pin the "Windows PowerShell" shortcut to Start
.PARAMETER UnpinAll
Unpin all the Start tiles
.EXAMPLE
.\Pin.ps1 -Tiles ControlPanel, DevicesPrinters, PowerShell
.EXAMPLE
.\Pin.ps1 -UnpinAll
.EXAMPLE
.\Pin.ps1 -UnpinAll -Tiles ControlPanel, DevicesPrinters, PowerShell
.EXAMPLE
.\Pin.ps1 -UnpinAll -Tiles ControlPanel
.EXAMPLE
.\Pin.ps1 -Tiles ControlPanel -UnpinAll
.LINK
https://github.com/farag2/Windows-10-Sophia-Script
.NOTES
Separate arguments with comma
Current user
#>
[CmdletBinding()]
param
(
[Parameter(
Mandatory = $false,
Position = 0
)]
[switch]
$UnpinAll,
[Parameter(
Mandatory = $false,
Position = 1
)]
[ValidateSet("ControlPanel", "DevicesPrinters", "PowerShell")]
[string[]]
$Tiles,
[string]
$StartLayout = "$PSScriptRoot\StartLayout.xml"
)
begin
{
# Unpin all the Start tiles
if ($UnpinAll)
{
Export-StartLayout -Path $StartLayout -UseDesktopApplicationID
[xml]$XML = Get-Content -Path $StartLayout -Encoding UTF8 -Force
$Groups = $XML.LayoutModificationTemplate.DefaultLayoutOverride.StartLayoutCollection.StartLayout.Group
foreach ($Group in $Groups)
{
# Removing all groups inside XML
$Group.ParentNode.RemoveChild($Group) | Out-Null
}
$XML.Save($StartLayout)
}
}
process
{
# Extract strings from shell32.dll using its' number
$Signature = @{
Namespace = "WinAPI"
Name = "GetStr"
Language = "CSharp"
MemberDefinition = @"
[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
public static extern IntPtr GetModuleHandle(string lpModuleName);
[DllImport("user32.dll", CharSet = CharSet.Auto)]
internal static extern int LoadString(IntPtr hInstance, uint uID, StringBuilder lpBuffer, int nBufferMax);
public static string GetString(uint strId)
{
IntPtr intPtr = GetModuleHandle("shell32.dll");
StringBuilder sb = new StringBuilder(255);
LoadString(intPtr, strId, sb, sb.Capacity);
return sb.ToString();
}
"@
}
if (-not ("WinAPI.GetStr" -as [type]))
{
Add-Type @Signature -Using System.Text
}
# Extract the localized "Devices and Printers" string from shell32.dll
$DevicesPrinters = [WinAPI.GetStr]::GetString(30493)
# We need to get the AppID because it's auto generated
$Script:DevicesPrintersAppID = (Get-StartApps | Where-Object -FilterScript {$_.Name -eq $DevicesPrinters}).AppID
$Parameters = @(
# Control Panel hash table
@{
# Special name for Control Panel
Name = "ControlPanel"
Size = "2x2"
Column = 0
Row = 0
AppID = "Microsoft.Windows.ControlPanel"
},
# "Devices & Printers" hash table
@{
# Special name for "Devices & Printers"
Name = "DevicesPrinters"
Size = "2x2"
Column = 2
Row = 0
AppID = $Script:DevicesPrintersAppID
},
# Windows PowerShell hash table
@{
# Special name for Windows PowerShell
Name = "PowerShell"
Size = "2x2"
Column = 4
Row = 0
AppID = "{1AC14E77-02E7-4E5D-B744-2EB1AE5198B7}\WindowsPowerShell\v1.0\powershell.exe"
}
)
# Valid columns to place tiles in
$ValidColumns = @(0, 2, 4)
[string]$StartLayoutNS = "http://schemas.microsoft.com/Start/2014/StartLayout"
# Add pre-configured hastable to XML
function Add-Tile
{
param
(
[string]
$Size,
[int]
$Column,
[int]
$Row,
[string]
$AppID
)
[string]$elementName = "start:DesktopApplicationTile"
[Xml.XmlElement]$Table = $xml.CreateElement($elementName, $StartLayoutNS)
$Table.SetAttribute("Size", $Size)
$Table.SetAttribute("Column", $Column)
$Table.SetAttribute("Row", $Row)
$Table.SetAttribute("DesktopApplicationID", $AppID)
$Table
}
if (-not (Test-Path -Path $StartLayout))
{
# Export the current Start layout
Export-StartLayout -Path $StartLayout -UseDesktopApplicationID
}
[xml]$XML = Get-Content -Path $StartLayout -Encoding UTF8 -Force
foreach ($Tile in $Tiles)
{
switch ($Tile)
{
ControlPanel
{
$ControlPanel = [WinAPI.GetStr]::GetString(12712)
Write-Verbose -Message ("The `"{0}`" shortcut is being pinned to Start" -f $ControlPanel) -Verbose
}
DevicesPrinters
{
$DevicesPrinters = [WinAPI.GetStr]::GetString(30493)
Write-Verbose -Message ("The `"{0}`" shortcut is being pinned to Start" -f $DevicesPrinters) -Verbose
# Create the old-style "Devices and Printers" shortcut in the Start menu
$Shell = New-Object -ComObject Wscript.Shell
$Shortcut = $Shell.CreateShortcut("$env:APPDATA\Microsoft\Windows\Start menu\Programs\System Tools\$DevicesPrinters.lnk")
$Shortcut.TargetPath = "control"
$Shortcut.Arguments = "printers"
$Shortcut.IconLocation = "$env:SystemRoot\system32\DeviceCenter.dll"
$Shortcut.Save()
Start-Sleep -Seconds 3
}
PowerShell
{
Write-Verbose -Message ("The `"{0}`" shortcut is being pinned to Start" -f "Windows PowerShell") -Verbose
}
}
$Parameter = $Parameters | Where-Object -FilterScript {$_.Name -eq $Tile}
$Group = $XML.LayoutModificationTemplate.DefaultLayoutOverride.StartLayoutCollection.StartLayout.Group | Where-Object -FilterScript {$_.Name -eq "Sophia Script"}
# If the "Sophia Script" group exists in Start
if ($Group)
{
$DesktopApplicationID = ($Parameters | Where-Object -FilterScript {$_.Name -eq $Tile}).AppID
if (-not ($Group.DesktopApplicationTile | Where-Object -FilterScript {$_.DesktopApplicationID -eq $DesktopApplicationID}))
{
# Calculate current filled columns
$CurrentColumns = @($Group.DesktopApplicationTile.Column)
# Calculate current free columns and take the first one
$Column = (Compare-Object -ReferenceObject $ValidColumns -DifferenceObject $CurrentColumns).InputObject | Select-Object -First 1
# If filled cells contain desired ones assign the first free column
if ($CurrentColumns -contains $Parameter.Column)
{
$Parameter.Column = $Column
}
$Group.AppendChild((Add-Tile @Parameter)) | Out-Null
}
}
else
{
# Create the "Sophia Script" group
[Xml.XmlElement]$Group = $XML.CreateElement("start:Group", $StartLayoutNS)
$Group.SetAttribute("Name","Sophia Script")
$Group.AppendChild((Add-Tile @Parameter)) | Out-Null
$XML.LayoutModificationTemplate.DefaultLayoutOverride.StartLayoutCollection.StartLayout.AppendChild($Group) | Out-Null
}
}
$XML.Save($StartLayout)
}
end
{
# Temporarily disable changing the Start menu layout
if (-not (Test-Path -Path HKCU:\SOFTWARE\Policies\Microsoft\Windows\Explorer))
{
New-Item -Path HKCU:\SOFTWARE\Policies\Microsoft\Windows\Explorer -Force
}
New-ItemProperty -Path HKCU:\SOFTWARE\Policies\Microsoft\Windows\Explorer -Name LockedStartLayout -Value 1 -Force
New-ItemProperty -Path HKCU:\SOFTWARE\Policies\Microsoft\Windows\Explorer -Name StartLayoutFile -Value $StartLayout -Force
Start-Sleep -Seconds 3
# Restart the Start menu
Stop-Process -Name StartMenuExperienceHost -Force -ErrorAction Ignore
Start-Sleep -Seconds 3
# Open the Start menu to load the new layout
$wshell = New-Object -ComObject WScript.Shell
$wshell.SendKeys("^{ESC}")
Start-Sleep -Seconds 3
# Enable changing the Start menu layout
Remove-ItemProperty -Path HKCU:\SOFTWARE\Policies\Microsoft\Windows\Explorer -Name LockedStartLayout -Force -ErrorAction Ignore
Remove-ItemProperty -Path HKCU:\SOFTWARE\Policies\Microsoft\Windows\Explorer -Name StartLayoutFile -Force -ErrorAction Ignore
Remove-Item -Path $StartLayout -Force
Stop-Process -Name StartMenuExperienceHost -Force -ErrorAction Ignore
Start-Sleep -Seconds 3
# Open the Start menu to load the new layout
$wshell = New-Object -ComObject WScript.Shell
$wshell.SendKeys("^{ESC}")
}
```
Создаваемые задания в планировщике заданий
------------------------------------------
Для начала разберём две задачи по автоматизации очистки папок %TEMP% и %SystemRoot%\SoftwareDistribution\Download. Эти папки полезно очищать по расписанию, чтобы они не разрастались. На текущий момент папка временных файлов самоочищается раз в 60 дней, а папка, куда скачиваются установочные файлы для обновлений, — раз в 90 дней.
По завершении задания были добавлены нативные всплывающие тосты, так сказать, из информационно-эстетических соображений.
Windows 10 позволяет генерировать такие тосты очень просто. Пример всплывающего тоста, как на картинке выше:
```
[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
[Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType = WindowsRuntime] | Out-Null
[xml]$ToastTemplate = @"
Уведомление
Кэш обновлений Windows успешно удален
"@
$ToastXml = [Windows.Data.Xml.Dom.XmlDocument]::New()
$ToastXml.LoadXml($ToastTemplate.OuterXml)
$ToastMessage = [Windows.UI.Notifications.ToastNotification]::New($ToastXML)
[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier("windows.immersivecontrolpanel_cw5n1h2txyewy!microsoft.windows.immersivecontrolpanel").Show($ToastMessage)
```
В вызове CreateToastNotifier можно указывать приложение, иконка которого будет отображаться в верхнем левом углу тоста и которое будет открываться при нажатии на тост. В данном случае я использовал windows.immersivecontrolpanel\_cw5n1h2txyewy!microsoft.windows.immersivecontrolpanel — "Настройки". Но вы вольны указать любые приложения. Узнать список всех установленных приложений и их AppID нам поможет команда Get-StartApps.
Напомню, что задача по очистке папки для временных файлов удаляет лишь файлы старше суток:
```
Get-ChildItem -Path $env:TEMP -Recurse -Force | Where-Object {$_.CreationTime -lt (Get-Date).AddDays(-1)} | Remove-Item -Recurse -Force
```
А задача по очистке папки %SystemRoot%\SoftwareDistribution\Download ждёт остановку службы wuauserv (Центр обновления Windows), чтобы в дальнейшем очистить папку
```
(Get-Service -Name wuauserv).WaitForStatus('Stopped', '01:00:00')
```
С заданием по запуску очистки диска и DISM с аргументами всё гораздо веселее. Изначально стояла задача просто запускать предзаготовленный пресет настроек для очистки диска и очистку ненужных обновлений, используя DISM: dism.exe /Online /English /Cleanup-Image /StartComponentCleanup /NoRestart.
Но пришлось решать, как заставить задание запускать очистку диска, сворачивать его окно, а потом также минимизировать окно консоли с запущенным DISM.
Сложность состоит в том, что при запуске очистки диска сначала открывается первое окошко со сканированием того, что можно очистить, потом оно закрывается, и только после этого открывается новое окошко (с новым MainWindowHandle) уже непосредственно с очисткой.
Если первое окошко достаточно легко свернуть:
```
$ProcessInfo = New-Object -TypeName System.Diagnostics.ProcessStartInfo
$ProcessInfo.FileName = "$env:SystemRoot\system32\cleanmgr.exe"
$ProcessInfo.Arguments = "/sagerun:1337"
$ProcessInfo.UseShellExecute = $true
$ProcessInfo.WindowStyle = [System.Diagnostics.ProcessWindowStyle]::Minimized
```
То над тем, как свернуть второе, я поломал голову, конечно. После многих попыток хоть за что-то зацепиться, я понял, что:
только MainWindowHandle окна может помочь
```
Get-Process -Name cleanmgr | Stop-Process -Force
Get-Process -Name Dism | Stop-Process -Force
Get-Process -Name DismHost | Stop-Process -Force
$ProcessInfo = New-Object -TypeName System.Diagnostics.ProcessStartInfo
$ProcessInfo.FileName = "$env:SystemRoot\system32\cleanmgr.exe"
$ProcessInfo.Arguments = "/sagerun:1337"
$ProcessInfo.UseShellExecute = $true
$ProcessInfo.WindowStyle = [System.Diagnostics.ProcessWindowStyle]::Minimized
$Process = New-Object -TypeName System.Diagnostics.Process
$Process.StartInfo = $ProcessInfo
$Process.Start() | Out-Null
Start-Sleep -Seconds 3
[int]$SourceMainWindowHandle = (Get-Process -Name cleanmgr | Where-Object -FilterScript {$_.PriorityClass -eq "BelowNormal"}).MainWindowHandle
function MinimizeWindow
{
[CmdletBinding()]
param
(
[Parameter(Mandatory = $true)]
$Process
)
$ShowWindowAsync = @{
Namespace = "WinAPI"
Name = "Win32ShowWindowAsync"
Language = "CSharp"
MemberDefinition = @'
[DllImport("user32.dll")]
public static extern bool ShowWindowAsync(IntPtr hWnd, int nCmdShow);
'@
}
if (-not ("WinAPI.Win32ShowWindowAsync" -as [type]))
{
Add-Type @ShowWindowAsync
}
$MainWindowHandle = (Get-Process -Name $Process | Where-Object -FilterScript {$_.PriorityClass -eq "BelowNormal"}).MainWindowHandle
[WinAPI.Win32ShowWindowAsync]::ShowWindowAsync($MainWindowHandle, 2)
}
while ($true)
{
[int]$CurrentMainWindowHandle = (Get-Process -Name cleanmgr | Where-Object -FilterScript {$_.PriorityClass -eq "BelowNormal"}).MainWindowHandle
if ($SourceMainWindowHandle -ne $CurrentMainWindowHandle)
{
MinimizeWindow -Process cleanmgr
break
}
Start-Sleep -Milliseconds 5
}
$ProcessInfo = New-Object -TypeName System.Diagnostics.ProcessStartInfo
$ProcessInfo.FileName = "$env:SystemRoot\system32\dism.exe"
$ProcessInfo.Arguments = "/Online /English /Cleanup-Image /StartComponentCleanup /NoRestart"
$ProcessInfo.UseShellExecute = $true
$ProcessInfo.WindowStyle = [System.Diagnostics.ProcessWindowStyle]::Minimized
$Process = New-Object -TypeName System.Diagnostics.Process
$Process.StartInfo = $ProcessInfo
$Process.Start() | Out-Null
```
Как видно из кода, $SourceMainWindowHandle первого окна ждёт, пока появится $CurrentMainWindowHandle второго окна, и, если, они не равны, то можно минимизировать новое окно. Дальше уже можно запускать DISM с ключами.
Но на этом я не остановился. Понял, что, возможно, пользователю будет неудобно, что за него решают, когда запускается такая задача (которая иногда может потребовать достаточное количество времени). Поэтому пришла идея сделать интерактивный всплывающий тост!
Как видно на скриншоте, пользователю предоставляются на выбор 3 варианта развития событий: отложить вопрос на 1, 30 минут или 4 часа, полностью отклонить предложение (тогда задача запустится через 30 дней) или запустить.
Как устроено это окно. Это всё тот же тост, но, чтобы создать кнопку, запускающую что-либо, кроме открытия страницы в браузере, необходимо сначала зарегистрировать новый протокол. В примере ниже показывается, как я регистрирую протокол WindowsCleanup:
```
if (-not (Test-Path -Path Registry::HKEY_CLASSES_ROOT\WindowsCleanup))
{
New-Item -Path Registry::HKEY_CLASSES_ROOT\WindowsCleanup -Force
}
New-ItemProperty -Path Registry::HKEY_CLASSES_ROOT\WindowsCleanup -Name "(default)" -PropertyType String -Value "URL:WindowsCleanup" -Force
New-ItemProperty -Path Registry::HKEY_CLASSES_ROOT\WindowsCleanup -Name "URL Protocol" -Value "" -Force
New-ItemProperty -Path Registry::HKEY_CLASSES_ROOT\WindowsCleanup -Name EditFlags -PropertyType DWord -Value 2162688 -Force
if (-not (Test-Path -Path Registry::HKEY_CLASSES_ROOT\shell\open\command))
{
New-item -Path Registry::HKEY_CLASSES_ROOT\WindowsCleanup\shell\open\command -Force
}
# If "Run" clicked run the "Windows Cleanup" task
New-ItemProperty -Path Registry::HKEY_CLASSES_ROOT\WindowsCleanup\shell\open\command -Name "(default)" -PropertyType String -Value 'powershell.exe -Command "& {Start-ScheduledTask -TaskPath ''\Sophia Script\'' -TaskName ''Windows Cleanup''}"' -Force
```
А потом привязываю его на кнопку запуска:
Всё вместе выглядит так:
```
# Persist the Settings notifications to prevent to immediately disappear from Action Center
if (-not (Test-Path -Path "HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Notifications\Settings\windows.immersivecontrolpanel_cw5n1h2txyewy!microsoft.windows.immersivecontrolpanel"))
{
New-Item -Path "HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Notifications\Settings\windows.immersivecontrolpanel_cw5n1h2txyewy!microsoft.windows.immersivecontrolpanel" -Force
}
New-ItemProperty -Path "HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Notifications\Settings\windows.immersivecontrolpanel_cw5n1h2txyewy!microsoft.windows.immersivecontrolpanel" -Name ShowInActionCenter -PropertyType DWord -Value 1 -Force
# Register the "WindowsCleanup" protocol to be able to run the scheduled task upon clicking on the "Run" button
if (-not (Test-Path -Path Registry::HKEY_CLASSES_ROOT\WindowsCleanup))
{
New-Item -Path Registry::HKEY_CLASSES_ROOT\WindowsCleanup -Force
}
New-ItemProperty -Path Registry::HKEY_CLASSES_ROOT\WindowsCleanup -Name "(default)" -PropertyType String -Value "URL:WindowsCleanup" -Force
New-ItemProperty -Path Registry::HKEY_CLASSES_ROOT\WindowsCleanup -Name "URL Protocol" -Value "" -Force
New-ItemProperty -Path Registry::HKEY_CLASSES_ROOT\WindowsCleanup -Name EditFlags -PropertyType DWord -Value 2162688 -Force
if (-not (Test-Path -Path Registry::HKEY_CLASSES_ROOT\shell\open\command))
{
New-item -Path Registry::HKEY_CLASSES_ROOT\WindowsCleanup\shell\open\command -Force
}
# If "Run" clicked run the "Windows Cleanup" task
New-ItemProperty -Path Registry::HKEY_CLASSES_ROOT\WindowsCleanup\shell\open\command -Name "(default)" -PropertyType String -Value 'powershell.exe -Command "& {Start-ScheduledTask -TaskPath ''\Sophia Script\'' -TaskName ''Windows Cleanup''}"' -Force
[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
[Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType = WindowsRuntime] | Out-Null
[xml]$ToastTemplate = @"
$($Localization.CleanupTaskNotificationTitle)
$($Localization.CleanupTaskNotificationEventTitle)
$($Localization.CleanupTaskNotificationEvent)
"@
$ToastXml = [Windows.Data.Xml.Dom.XmlDocument]::New()
$ToastXml.LoadXml($ToastTemplate.OuterXml)
$ToastMessage = [Windows.UI.Notifications.ToastNotification]::New($ToastXML)
[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier("windows.immersivecontrolpanel_cw5n1h2txyewy!microsoft.windows.immersivecontrolpanel").Show($ToastMessage)
```
Функция ассоциации файлов
-------------------------
Как известно, начиная с Windows 8 невозможно самостоятельно ассоциировать какое-либо расширение с программой, [не вычислив](https://stackoverflow.com/a/49256437/8315671) правильный хэш. Как выяснилось, Microsoft проводит манипуляции с захардоженной строкой "User Choice set via Windows User Experience {D18B6DD5-6124-4341-9318-804003BAFA0B}".
Пользователь [Danyfirex](https://github.com/DanysysTeam/PS-SFTA/commits?author=Danyfirex) смог [реализовать](https://github.com/DanysysTeam/PS-SFTA) правильное вычисление хэш-суммы на чистом PowerShell, но, к сожалению, после проведённых тестов выяснилось, что сам PowerShell 5.1 считает его неправильно, поэтому я вынужден был использовать код другого [разработчика](https://github.com/default-username-was-already-taken/set-fileassoc) с алгоритмом, реализованным на чистом C#. Крайне быстро! Функция огромная, поэтому просто оставлю просто [ссылку](https://github.com/farag2/Windows-10-Sophia-Script/blob/97b8a5f033996b8a6310172d17d138d2c695e4ac/Sophia/PowerShell%205.1/Sophia.psm1#L6844) на код.
Автоматизация установки бесплатного расширения для встроенного UWP-приложения Фотографии
----------------------------------------------------------------------------------------
Еще одна забавная, но крайне полезная функция даёт возможность открывать файлы формата .heic и .heif.
Расширение крайне полезное, так как все современные телефоны умеют делать фотографии в формате HEIC, но по умолчанию Windows 10 не умеет открывать такие файлы, предлагая [купить](https://www.microsoft.com/store/productId/9NMZLZ57R3T7) расширение в Microsoft Store по цене в 0,99 $. Но мало кто знает, что есть скрытая [страница](https://www.microsoft.com/store/productId/9n4wgh0z6vhq) от поиска этого же самого расширения, но предназначенного для OEM-производителей. Эту же страницу можно открыть вручную, выполнив через Win+R или через PowerShell: ms-windows-store://pdp/?ProductId=9n4wgh0z6vhq
Для скачивания установочного пакета на помощь приходит всеми известный сайт <https://store.rg-adguard.net>. Он позволяет, зная ID страницы, получать временные прямые ссылки на установочные пакеты. Значит, можно распарсить.
```
$API = "https://store.rg-adguard.net/api/GetFiles"
# HEVC Video Extensions from Device Manufacturer
$ProductURL = "https://www.microsoft.com/store/productId/9n4wgh0z6vhq"
$Body = @{
"type" = "url"
"url" = $ProductURL
"ring" = "Retail"
"lang" = "en-US"
}
$Raw = Invoke-RestMethod -Method Post -Uri $API -ContentType 'application/x-www-form-urlencoded' -Body $Body
# Parsing the page
$Raw | Select-String -Pattern '|.\*)"\s.\*>(?.\*)<\/a>' -AllMatches | ForEach-Object -Process {$\_.Matches} | ForEach-Object -Process {
$TempURL = $\_.Groups[1].Value
$Package = $\_.Groups[2].Value
if ($Package -like "Microsoft.HEVCVideoExtension\_\*\_x64\_\_8wekyb3d8bbwe.appx")
{
[PSCustomObject]@{
PackageName = $Package
PackageURL = $TempURL
}
}
}
```
Дальше уже дело техники сохранить и установить скачанный пакет.
Автопродление имен функций по введённым буквам, содержащимся в названии функции или её аргумента
------------------------------------------------------------------------------------------------
Это последняя значимая функция, добавленная в версию 5.10. Пользователи попросили добавить автопродление функций и их аргументов с помощью табуляции, вводя буквы, содержащиеся в названии функции или её аргументов.
Проблема в том, что до этого была лишь возможность вручную указывать функции и их аргументы а-ля .\Sophia.ps1 -Functions "DiagTrackService -Disable", "DiagnosticDataLevel -Minimal", UninstallUWPApps.
То есть ни о каком автопродлении речи и не шло: пользователю приходилось или запоминать имя функции и её аргумент, или копировать вручную данную комбинацию из пресет-файла. То ли дело сейчас!
Чтобы заработала сия шайтан-машина, пришлось прибегнуть к [Register-ArgumentCompleter](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/register-argumentcompleter).
Весь код сосредоточен в отдельном файле, и не получится его поместить в текущий пресет-файл: файл необходимо вызывать с использованием [dot sourcing](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_scripts#script-scope-and-dot-sourcing). Одним словом, пришлось в [ScriptBlock](https://github.com/farag2/Windows-10-Sophia-Script/blob/b2a6389e43f5301bc081a1ef6c0f86c8cbc77d9a/Sophia/PowerShell%205.1/Functions.ps1#L83) для argumentcompleter перебирать все возможные варианты конструкций вида "функция-аргумент" и просто "функция", если у последней нет собственного аргумента.
Теперь, чтобы вызвать, допустим, функцию по удалению UWP-приложений, можно ввести (после загрузки Functions.ps1) So -Fu uwp.
Крайне жутко выглядит, но стало гораздо удобнее.
Ну, а закончу рассказ на том, что даже сборка прикрепляемых архивов на странице [релизов](https://github.com/farag2/Windows-10-Sophia-Script/releases/latest) стала осуществляться с помощью [конфига](https://github.com/farag2/Windows-10-Sophia-Script/blob/master/.github/workflows/Sophia.yml) Github Actions. Как можно заметить, для создания архива под версию для PowerShell 7 приходится выкачивать две библиотеки с ресурсов Microsoft, так как загрузить файлы больше 25 МБ в репозиторий невозможно. Автоматизируй автоматизацию!
Итоги
-----
Это были крайне плодотворные полгода. У нас такое ощущение, что мы прошли PowerShell на уровне "Ultra Violence". Ну, а что дальше? Параллельно я прорабатываю вариант, как реализовать, используя текущий паттерн взаимодействия пользователя со скриптом, настройку офлайновых образов WIM. Но главный приоритет для нас сейчас, конечно, — разработка [SophiApp](https://github.com/SophiaUI/SophiApp).
Цель проекта — показать, как, по нашему мнению, должен выглядеть, чувствоваться и каким функционалом обладать так называемый твикер для Windows 10. Идей — просто огромное количество! Хотя у нас нет опыта в разработке и нас всего лишь двое, а весь код на SophiApp пишет в одиночку Дмитрий, возможно, летом уже появится первый рабочий билд. Но это уже совсем другая история.
Хочу выразить огромную благодарность также пользователям [forum.ru-board](https://forum.ru-board.com) [westlife](https://forum.ru-board.com/profile.cgi?action=show&member=westlife) и [iNNOKENTIY21](https://forum.ru-board.com/profile.cgi?action=show&member=iNNOKENTIY21): ребят, без вашей помощи и подсказок, всё было бы по-другому! А логотип нарисовала художница [tea\_head](https://twitter.com/tea_head_/status/1347630659989336064), за что ей тоже спасибо. Скрины, использованные в материале, взяты из мультфильма [Коргот-варвар](https://www.kinopoisk.ru/film/405456/). [Группа](https://t.me/sophia_chat) в Telegram. Любите Windows 10, настраивайте её с умом и до новых встреч!
А если хотите прокачать себя, например получить навыки [пентестера](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=220421) и зарабатывать на уязвимостях, или подтянуть знания [алгоритмов и структур данных](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=220421) — приходите учиться в SkillFactory, будет сложно, но интересно!
[Узнайте](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=230421), как прокачаться и в других специальностях или освоить их с нуля:
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=230421)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=230421)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=230421)
Другие профессии и курсы**ПРОФЕССИИ**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=230421)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=230421)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=230421)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=230421)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=230421)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=230421)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=230421)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=230421)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=230421)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=230421)
**КУРСЫ**
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=230421)
* [Курс "Machine Learning и Deep Learning"](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=230421)
* [Курс "Математика для Data Science"](https://skillfactory.ru/math-stat-for-ds#syllabus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MAT&utm_term=regular&utm_content=230421)
* [Курс "Математика и Machine Learning для Data Science"](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=230421)
* [Курс "Python для веб-разработки"](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=230421)
* [Курс "Алгоритмы и структуры данных"](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=230421)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=230421)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=230421) | https://habr.com/ru/post/553800/ | null | ru | null |
# Делаем из Linux From Scratch свой универсальный дистрибутив
Так уж случилось, что пару лет назад по долгу службы на команду разработчиков, к которой я отношусь, свалилась неожиданная задача — разработка системы управления оборудованием (в этом-то как-раз неожиданности нет, ибо направление разработок такое) с управляющим PC под Linux.
Разработки линуксовой части велись (да и ведутся) под Ubuntu, в среде Code::Blocks. Но, как показала практика, для качественной работы нужно что-то гораздо более легкое с гарантированным временем отклика. Для работы было достаточно консоли, так как задачи организации пользовательского интерфейса решались на подключаемом по TCP/IP удаленном компьютере.
Тогда и пришла идея использовать дистрибутив Linux собственной сборки, чем (сборкой дистрибутива), собственно, в свободное время я и занялся. Выбор пал на LFS. Про то что такое LFS уже неоднократно писали даже на Хабре, я же опишу решение нескольких дополнительных (кроме простенького Linux'а) задач, вставших передо мной в нашем конкретном случае.
Поначалу такая задача была одна — использовать real-time ядро.
Однако дальше, когда идея USB-флешки с дистрибутивом, пришлась всем по душе, то появились задачи размножения флешек и запуска системы на различных компьютерах (тестовых стендов много, имея свою флешку суешь в карман и иди к любому). Вот тут и появились проблемы — LFS не обладает 100% переносимостью с одного компьютера на другой. Для ее адаптации к конкретному компьютеру нужно править некоторые скрипты, что в условиях команды вчерашних Windows-кодеров проблематично (на виртуалку с Ubuntu некоторые пересели, но консоль и скрипты — это беда). Размножение системы также требует повторения некоторых манипуляций, проделываемых в процессе сборки (тот же GRUB установить).
Естественно, решение всех задач есть на просторах интернета, но, думаю, сбор некоторой информации в одном месте никому не помешает.
Итак, конкретные задачи были следующие…
##### 1. Использование ядра Linux с real-time патчем
Это была одна из самых легких задач. Процесс сборки прошел по книге [LFS](http://www.linuxfromscratch.org/lfs/) с единственным исключением — вместо штатного для книги ядра было взято 2.6.33.9 и [RT-патч](ftp://ftp.kernel.org/pub/linux/kernel/projects/rt/patch-2.6.33.9-rt31.bz2) для него. Везде, где происходили манипуляции с ядром (установка Linux Headers и ядра непосредственно), работаем с нашей пропатченной версией.
Также не лишним будет сказать, что дистрибутив собирался без подключения swap-раздела (2Гб ОЗУ это в нашем случае — выше крыши, наличие swap не желательно по причине его негативного влияния на гарантированное время отклика, да и для флешки он крайне губителен) и представлял собой один единственный раздел ext2fs.
##### 2. Автоматический вход в систему (в условиях разработки безопасность нам не важна, да и систему пускаем под рутом по ряду причин)
Идея автоматического входа была взята [отсюда](http://littlesvr.ca/linux-stuff/articles/autologinconsole/autologinconsole.php).
Был создан файл autologin.c следующего содержания:
```
int main()
{
execlp("login", "login", "-f", "root", 0);
}
```
Далее файл был скомпилирован командой:
`gcc autologin.c -o /usr/local/sbin/autologin`
Далее было решено, что двух консолей с автоматическим входом хватит (одна для запуска системы, другая для всего остального, если понадобится).
В файле /etc/inittab строчки:
`1:2345:respawn:/sbin/agetty tty1 9600
2:2345:respawn:/sbin/agetty tty2 9600`
были заменены на:
`1:2345:respawn:/sbin/agetty -n -l /usr/local/sbin/autologin tty1 9600
2:2345:respawn:/sbin/agetty -n -l /usr/local/sbin/autologin tty2 9600`
После этого никаких проблем с автоматическим входом не было, поэтому никаких дополнительных манипуляций со скриптами не было.
#### 3. Отвязывание системы от порядка подключения дисков
У разных BIOS свои заморочки. Одни, например, считают, что первым является тот диск, с которого мы загружаемся. В этом случае наша флешка будет sda. Другие считают, что сначала должны идти жесткие диски, а потом другие устройства. В этом случае наша флешка будет иметь имя sdb, sdc и так далее.
В результате, то система не может загрузиться с диска, которого нет, то корневой каталог не может быть смонтирован по той причине, что в /etc/fstab указан не тот диск.
Все решается либо исправлением /boot/grub/grub.cfg и /etc/fstab под конкретную машину или использованием для загрузки и монтирования не имени диска (sda, sdb и т. д.), а UUID файловой системы, который для данной файловой системы на флешке будет уникален и, что самое главное — постоянен.
Проблема в том, что GRUB работать с UUID умеет, а ядро — нет, то есть напрямую монтировать корневую систему по UUID (не зная имени устройства) невозможно. Это не баг, а следствие идейных соображений Линуса Торвальдса, поэтому на такую возможность и в будущем надеяться не стоит. Тем не менее пути обхода есть — это [initramfs](http://en.gentoo-wiki.com/wiki/Initramfs).
Initramfs — временная файловая система, помогающая в загрузке и монтировании файловых систем настоящей системы.
В стандартную сборку LFS initramfs не входит, поэтому для ее построения воспользуемся рекомендациями из [Gentoo Wiki](http://en.gentoo-wiki.com/wiki/Initramfs) и некоторыми собственными соображениями (вариант из Gentoo Wiki без изменений в моем случае проблему с именами дисков не решил, да и не заработал толком).
Для создания простейшей initramfs системы, монтирующей нашу основную по UUID нужна простейшая командная оболочка (shell) и скрипт init. Полный набор утилит командной строки достаточно громоздок для initramfs, поэтому часто для этой цели применяется [busybox](http://www.busybox.net/), который при скромных размерах и требованиях реализует некоторые, наиболее часто используемые утилиты.
Забираем последнюю версию busybox:
````
cd sources
wget http://busybox.net/downloads/busybox-1.18.4.tar.bz2
````
Распаковываем и конфигурируем:
`tar jxf busybox-1.18.4.tar.bz2
cd busybox-1.18.4
make menuconfig`
Конфигурирование производится при помощи меню (наподобие ядра Linux). В принципе, стандартной конфигурации хватает для наших нужд, но, на всякий случай, стоит проверить, что подключены следующие возможности:
Support for devfs — поддержка devfs для работы с /dev.
Build Busybox as a static library (no shared libraries) — статическая компоновка, чтобы не тянуть за собой кучу so-библиотек.
Support version 2.6.x Linux kernels — поддержка ядер линейки 2.6.
А также поддержка функциональности утилит: sh, cat, cut, findfs, mount, umount, sleep, echo, switch\_root.
Компилируем:
`make`
Теперь собираем дерево каталогов нашей файловой системы:
`mkdir /usr/src/initramfs
cd /usr/src/initramfs
mkdir -p bin lib dev etc mnt/root proc root sbin sys
cp -a /dev/{null,console} /usr/src/initramfs/dev/`
Копируем busybox и создаем линки на утилиты:
`cp /sources/busybox-1.18.4/busybox ./bin/
cd bin
ln -s busybox sh
ln -s busybox cat
ln -s busybox cut
ln -s busybox findfs
ln -s busybox mount
ln -s busybox umount
ln -s busybox sleep
ln -s busybox switch_root
cd ..`
Осталось написать скрипт init:
```
#!/bin/sh
# Монтируем файловые системы proc и sysfs
mount -t proc none /proc
mount -t sysfs none /sys
# USB-устройства инициализируются ядром не сразу
# На всякий случай ждем 10 секунд, иначе корневой раздел не будет найден
sleep 10
# Монтируем файловую систему устройств
mount -t devtmpfs none /dev
# Ищем по UUID имя корневого диска и монтируем систему
for cmd in $(cat /proc/cmdline) ; do
case $cmd in
root=*)
uuid=$(echo $cmd | cut -d= -f3)
mount -o ro $(findfs UUID="$uuid") /mnt/root
;;
esac
done
# Размонтируем все примонтированные файловые системы
umount /dev
umount /proc
umount /sys
# Загружаем основную систему
exec switch_root /mnt/root /sbin/init
```
Делаем наш скрипт исполняемым:
`chmod +x /usr/src/initramfs/init`
Собираем нашу временную файловую систему в архив:
`cd /usr/src/initramfs
find . -print0 | cpio --null -ov --format=newc | gzip -9 > /boot/initrd.img-2.6.33-rt31`
Обратим внимание на имя файла — оно должно соответствовать имени ядра (это нужно, чтобы GRUB его правильно подцепил). То есть, если ядро имеет имя vmlinux-2.6.33-rt31, то initramfs должен иметь имя initrd.img-2.6.33-rt31.
Теперь при выполнении grub-mkconfig GRUB обнаружит initramfs, а также включит в конфигурацию UUID корневой системы. Для проверки можно поправить /boot/grub/grub.cfg руками. Например конфигурацию:
`menuentry "Linux 2.6.33-rt31" --class gnu-linux --class gnu --class os {
insmod ext2
set root='(hd0,1)'
search --no-floppy --fs-uuid --set 47029df8-8567-417d-b813-eedfe1ff8b0f
linux /boot/vmlinux-2.6.33-rt31 root=/dev/sda1 ro
}`
исправим на:
`menuentry "Linux 2.6.33-rt31" --class gnu-linux --class gnu --class os {
insmod ext2
set root='(hd0,1)'
search --no-floppy --fs-uuid --set 47029df8-8567-417d-b813-eedfe1ff8b0f
linux /boot/vmlinux-2.6.33-rt31 root=UUID=47029df8-8567-417d-b813-eedfe1ff8b0f ro
initrd /boot/initrd.img-2.6.33-rt31
}`
UUID файловой системы можно узнать так (например, для /dev/sdb1):
`blkid -p -o udev /dev/sdb1`
Осталось поправить /etc/fstab, заменив строчку:
`/dev/sda1 / ext2 defaults 1 1`
на
`UUID= 47029df8-8567-417d-b813-eedfe1ff8b0f / ext2 defaults 1 1`
Также следует заметить, что для всех манипуляций выше необходимо, чтобы в ядре была включена поддержка devtmpfs (CONFIG\_DEVTMPFS=y) и initramfs (CONFIG\_BLK\_DEV\_INITRD=y).
##### 4. Отвязывание системы от сетевой карты
Если в компьютере установлено более одной сетевой платы, то при параллельной загрузке модулей ядра не гарантируется постоянное назначение имен этим платам. Например, есть две платы. Плата\_1 имеет имя интерфейса в системе eth0, Плата\_2 — eth1. При очередной перезагрузке может получиться так, что Плата\_1 станет eth1, а Плата\_2 — eth0.
С этой целью в LFS производится привязка имени к конкретной плате. При загрузке на другом компьютере очень велика вероятность, что сеть не поднимется.
В моем конкретном случае плата на всех компьютерах одна и IP — статический (связь только с терминальным компьютером напрямую).
Поднятие сетевого интерфейса в LFS осуществляется скриптом /etc/rc.d/init.d/network. Допишем скрипт так, чтобы каждый раз при загрузке генерировался конфигурационный файл /etc/udev/rules.d/70-persistent-net.rules и при завершении работы этот файл удалялся. Подозреваю, что есть метод проще, но найденный метод заработал, а копаться в принципах работы Udev времени и особого желания на момент сборки системы не было.
В начало раздела start команды case добавляем:
```
for NIC in /sys/class/net/*
do
INTERFACE=${NIC##*/} udevadm test --action=add $NIC
done
```
А в конец секции stop (непосредственно перед ;;) добавляем:
```
rm /etc/udev/rules.d/70-persistent-net.rules
```
Теперь при загрузке на любой системе имя сетевого интерфейса будет eth0 (кроме самых экзотических случаев) и сеть будет подниматься. Разумеется, каталог /etc/sysconfig/network-devices/ifconfig.eth0 с файлом ipv4 должен существовать. Содержимое этого файла описано в книге LFS.
##### 5. Написание скрипта, производящего инсталляцию LFS на любую флешку
Осталось последнее — сделать архив системы и скрипт, который будет ее устанавливать на произвольный носитель.
Загружаемся в другой системе (не с флешки), монтируем флешку, например в /mnt/usb-os. Архивируем содержимое:
`cd /mnt/usb-os
tar -cvjf ~/pack.tar.bz2 *`
Пишем скрипт для установки install\_usb-os.sh. В качестве параметра скрипт принимает имя устройства, на котором необходимо развернуть систему (например /dev/sdb). Скрипт сам создаст необходимый раздел и файловую систему (/dev/sdb1, если указано имя /dev/sdb), распакует архив и установит GRUB.
**Запускаться он должен с правами root и, на самом деле, очень опасен.
В случае неверного указания имени устройства могут быть уничтожены все данные на рабочем диске!**
```
#!/bin/sh
# Проверяем, существует ли параметр с именем устройства
if [ "x${1}" = "x" ] ; then
echo "Usage: install_usb-os device_name"
exit
fi
# Размонтируем раздел, если вдруг был примонтирован
umount ${1}1
# Создаем временный каталог для монтирования
if [ ! -e /mnt/USBOSTmp ]; then
mkdir /mnt/USBOSTmp
fi
# Создаем MBR, первичный раздел размером с диск
echo "Building partitions..."
parted -s ${1} mklabel msdos
parted -s ${1} unit % mkpart primary ext2 0 100
# Форматируем раздел и монтируем его в наш временный каталог
echo "Preparing filesystem..."
mkfs -t ext2 ${1}1
mount -t ext2 ${1}1 /mnt/USBOSTmp
# Распаковываем архив
echo "Unpacking distributive..."
tar -xvf ./pack.tar.bz2 -C /mnt/USBOSTmp
# Создаем правильные ноды console и null
# (те, что распаковываются из архива, почему-то оказываются неверными)
mknod -m 600 /mnt/USBOSTmp/dev/console c 5 1
mknod -m 666 /mnt/USBOSTmp/dev/null c 1 3
# Монтируем виртуальные файловые системы (устройств и т.д.)
echo "Mounting necessary file systems..."
mount -v --bind /dev /mnt/USBOSTmp/dev
mount -vt devpts devpts /mnt/USBOSTmp/dev/pts
mount -vt tmpfs shm /mnt/USBOSTmp/dev/shm
mount -vt proc proc /mnt/USBOSTmp/proc
mount -vt sysfs sysfs /mnt/USBOSTmp/sys
# Добываем UUID нашего раздела на флешке и записываем не нее
# файл fstab
uu=`blkid -p -o value ${1}1 | grep -`
echo "Writing fstab for uuid=$uu..."
cat > /mnt/USBOSTmp/tmp/fstab << "EOF"
proc /proc proc defaults 0 0
sysfs /sys sysfs defaults 0 0
devpts /dev/pts devpts gid=4,mode=620 0 0
tmpfs /dev/shm tmpfs defaults 0 0
EOF
echo "UUID=$uu / ext2 defaults 1 1" >> /mnt/USBOSTmp/tmp/fstab
# Записываем на флешку скрипт, который должен быть запущен
# когда корневым каталогом является корень флешки
# В этом скрипте происходит конфигурирование и установка GRUB
cat > /mnt/USBOSTmp/tmp/update.sh << "EOF"
echo "Starting internal update script for $H_DEV ..."
mv -v /tmp/fstab /etc/fstab
grub-mkconfig -o /boot/grub/grub.cfg
echo "Updating mbr $H_DEV2..."
grub-setup $H_DEV2
EOF
# Делаем его исполняемым
chmod +x /mnt/USBOSTmp/tmp/update.sh
# Запускаем скрипт в другом root-окружении,
# когда корневым каталогом является корень флешки
echo "Running update..."
chroot /mnt/AxiOMATmp/ /usr/bin/env -i HOME=/root TERM="$TERM" PS1='\u:\w\$ ' PATH=/bin:/usr/bin:/sbin:/usr/sbin H_DEV=${1}1 H_DEV2=${1} /tmp/update.sh
# Убираем все лишнее, размонтируем файловые системы
rm -v /mnt/USBOSTmp/tmp/update.sh
umount -v /mnt/USBOSTmp/dev/pts
umount -v /mnt/USBOSTmp/dev/shm
umount -v /mnt/USBOSTmp/dev
umount -v /mnt/USBOSTmp/proc
umount -v /mnt/USBOSTmp/sys
umount ${1}1
rm -rvf /mnt/USBOSTmp
echo "Installation finished!"
```
Теперь сделаем наш скрипт исполняемым:
`chmod +x install_usb-os.sh`
Размещаем архив pack.tar.bz2 в каталоге со скриптом и инсталлятор готов! | https://habr.com/ru/post/122179/ | null | ru | null |
# Структура блогов
Создать некоторую структуру блогов (иерархию, например) на основе смыловой нагрузки.
Объясню суть идее на примере:
Есть блоги:
[OS Inferno](http://www.habrahabr.ru/blog/os_inferno/) [Haiku OS](http://www.habrahabr.ru/blog/haiku/)
[Операционные системы](http://www.habrahabr.ru/blog/os/)
Ссылки на них выглядят следующим образом:
```www.habrahabr.ru/blog/os_inferno
www.habrahabr.ru/blog/haiku
www.habrahabr.ru/blog/os
Очевидно, что первые два блога являются частными случаями третьего. Следует их "поместить" эти два блога в третий и получить такой вид ссылок:
www.habrahabr.ru/blog/os/os_inferno
www.habrahabr.ru/blog/os/haiku
www.habrahabr.ru/blog/os
Более того, в самом описании блога про ОС указать явное существование более узких блогов. Более того возможно не единственное представление ссылки, т.е. блог может становиться подблогом не одного конкретно блога. Опять же, на примере (http://www.habrahabr.ru/blog/firefox/):
www.habrahabr.ru/blog/open_source/firefox
www.habrahabr.ru/blog/browsers/firefox``` | https://habr.com/ru/post/8965/ | null | ru | null |
# Exposable паттерн. Независимые инжекции путём экспанирования
*Disposable* паттерн (интерфейс *IDisposable*) предполагает возможность высвобождения некоторых ресурсов, занимаемых объектом, путём вызова метода *Dispose*, ещё до того момента, когда все ссылки на экземпляр будут утрачены и сборщик мусора утилизирует его (хотя для надёжности вызов *Dispose* часто дублируется в финализаторе).
Но существует также обратный *Exposable* паттерн, когда ссылка на объект становится доступной до момента его полной инициализации. То есть экземпляр уже присутствует в памяти, частично проинициализирован и другие объекты ссылаются на него, но, чтобы окончательно подготовить его к работе, нужно выполнить вызов метода *Expose*. Опять же данный вызов допустимо выполнять в конструкторе, что диаметрально вызову *Dispose* в финализаторе.
Само по себе наличие такой обратной симметрии выглядит красиво и естественно, но где это может пригодиться на практике постараемся раскрыть в этой статье.
Для справки, в *C#* существует директива *using* — синтаксический сахар для безопасного вызова метода *Dispose*.
```
using(var context = new Context())
{
// statements
}
```
эквивалентно
```
var context = new Context();
try
{
// statements
}
finally
{
if (context != null) context .Dispose();
}
```
с той лишь разницей, что в первом случае переменная *context* становится *read-only*.
**Unit of Work + Disposable + Exposable = Renewable Unit**
*Dispose*-паттерну часто сопутствует паттерн *Unit of Work*, когда объекты предназначены для одноразового использовании, а время их жизни обычно короткое. То есть они создаются, тут же используются и затем сразу же освобождают занятые ресурсы, становясь непригодными для дальнейшего употребления.
Например, такой механизм часто применяется для доступа к сущностям базы данных через ORM-фреймворки.
```
using(var context = new DbContext(ConnectionString))
{
persons =context.Persons.Where(p=>p.Age > minAge).ToList();
}
```
Открывается соединение к БД, совершается нужный запрос, а затем оно сразу закрывается. Держать соединение постоянно открытым считается плохой практикой, поскольку зачастую ресурс соединений ограничен, а также соединения автоматически закрываются после определённого интервала бездействия.
Всё хорошо, но если у нас сервер с неравномерной нагрузкой, то в часы-пик на запросы пользователей будут создаваться огромные количества таких экземпляров объектов *DbContext*, что начнёт оказывать влияние на потребляемую сервером память и быстродействие, поскольку сборщик мусора станет вызываться чаще.
Здесь может помочь совместное использование паттернов *Disposable* и *Exposable*. Вместо того, чтобы постоянно создавать и удалять объекты достаточно создать один объект, а затем в нём же занимать и освобождать ресурсы.
```
context.Expose();
persons = context.Persons.Where(p=>p.Age > minAge).ToList();
context.Dispose();
```
Конечно, этот код не станет работать с существующими фреймворками, поскольку в них не предусмотрен метод *Expose*, но важно показать именно сам принцип — объекты можно использовать повторно, а необходимые ресурсы возобновлять динамически.
*\* Как заметили в комментария, возможно, это не самый удачный пример, поскольку прирост производительности достаточно спорный. Но чтобы лучше уловить суть рассматриваемого паттерна приведём следующие рассуждения.*
В обычном понимании *Disposable* — деинициализация и полный отказ от объекта. Однако ссылка на него вполне может оставаться и после вызова *Dispose*. Зачастую обращение к большинству свойств и методов вызовет исключение, если программист это предусмотрел, но экземпляр обычно запросто можно использовать в качестве ключа, вызывать *ToString*, *Equals* и некоторые другие методы. Так почему бы не расширить понимание паттерна *Disposable*? Пусть *Dispose* приводит объект в дежурное состояние, когда он занимает меньше ресурсов, в спящий режим! Но тогда должен существовать и метод выводящий из этого состояния — *Expose*. Всё очень закономерно и логично. То есть мы получили некоторое обобщение паттерна *Disposable*, а сценарий с отказом от объекта — это лишь его частный случай.
**Независимые инжекции путём экспанирования (*Independent Injections via Exposable Pattern*)**
*Важно!* Для полного понимания нижесказанного очень рекомендуется загрузить [исходные коды](http://makeloft.by/ru/tools) ([резервная ссылка](https://onedrive.live.com/redir.aspx?cid=c8d6e2f8053ddcfb&resid=C8D6E2F8053DDCFB!9067&parId=C8D6E2F8053DDCFB!103&authkey=!ABlu12Phn1wctHI)) библиотеки *Aero Framework* с примером текстового редактора *Sparrow*, а также желательно ознакомиться с серией предыдущих статей.
[Расширения привязки и xaml-разметки на примере локализации](http://habrahabr.ru/post/254115/)
[Инжекторы контекста xaml](http://habrahabr.ru/post/254373/)
[Командно-ориентированная навигация в xaml-приложениях](http://habrahabr.ru/post/254615/)
[Совершенствуем xaml: Bindable Converters, Switch Converter, Sets](http://habrahabr.ru/post/254731/)
[Сахарные инжекции в C#](http://habrahabr.ru/post/255759/)
[Context Model Pattern via Aero Framework](http://habrahabr.ru/post/251347/)
Классический способ инжектирование вью-моделей в конструктор с помощью *unit*-контейнеров выглядит так:
```
public class ProductsViewModel : BaseViewModel
{
public virtual void ProductsViewModel(SettingsViewModel settingsViewModel)
{
// using of settingsViewModel
}
}
public class SettingsViewModel : BaseViewModel
{
public virtual void SettingsViewModel(ProductsViewModel productsViewModel)
{
// using of productsViewModel
}
}
```
Но такой код вызовет исключение, поскольку невозможно проинициализировать *ProductsViewModel* пока не создана *SettingsViewModel* и наоборот.
Однако использование *Exposable*-паттерна в библиотеке *Aero Framework* позволяет элегантно решить проблему замкнутых зависимостей:
```
public class ProductsViewModel : ContextObject, IExposable
{
public virtual void Expose()
{
var settingsViewModel = Store.Get();
this[Context.Get("AnyCommand")].Executed += (sender, args) =>
{
// safe using of settingsViewModel
}
}
}
public class SettingsViewModel : ContextObject, IExposable
{
public virtual void Expose()
{
var productsViewModel = Store.Get();
this[Context.Get("AnyCommand")].Executed += (sender, args) =>
{
// safe using of productsViewModel
}
}
}
```
Вкупе с механизмом сохранения состояния (*Smart State*, о котором чуть ниже) это даёт возможность безопасно проинициализировать обе вью-модели, ссылающиеся друг на друга, то есть реализовать *принцип независимых прямых инжекций*.
**Умное состояние (*Smart State*)**
Теперь мы подошли к весьма необычному, но в то же время полезному механизму сохранения состояния. *Aero Framework* позволяет очень изящно и непревзойденно лаконично решать задачи подобного рода.
Запустите десктоп-версию редактора *Sparrow*, который является примером приложения к библиотеке. Перед вами обычное окно, которое можно перетащить или изменить в размерах (визуальное состояние). Также можно создать несколько вкладок либо открыть текстовые файлы, а затем отредактировать в них текст (логическое состояние).
После этого закройте редактор (нажмите крестик на окне) и запустите его снова. Программа запустится ровно в том же визуальном и логическом состоянии, в котором её закрыли, то есть размеры и положение окна будут прежними, останутся открытыми рабочие вкладки и даже текст в них будет в таким же, каким его оставили при закрытии! Между тем исходные коды вью-моделей на первый взгляд не содержат никакой вспомогательной логики для сохранения состояния, как так получилось?
При внимательном расмотрении вы, возможно, заметите, что вью-модели в примере приложения *Sparrow* отмечены атрибутом *DataContract*, а некоторые свойства атрибутом *DataMember*, что позволяет применять механизмы сериализации и десериализации для сохранения и восстановления логического состояния.
Всё, что нужно для этого выполнить, это проинициализировать необходимым образом фреймворк во время запуска приложения:
```
Unity.AppStorage = new AppStorage();
Unity.App = new AppAssistent();
```
По умолчанию сериализация происходит в файлы, но легко можно создать свою имплементацию и сохранять сериализованные объекты, например, в базу данных. Для этого нужно унаследоваться от интерфейса *Unity.IApplication* (по умолчанию имплементируется *AppStorage*). Что касается интерфейса *Unity.IApplication* (*AppAssistent*), то он необходим для культурных настроек при сериализации и в большинстве случаев можно ограничиться его стандартной реализацией.
Для сохранения состояния любого объекта, поддерживающего сериализацию, достаточно вызвать аттачед-метод *Snapshot*, либо воспользоваться вызовом *Store.Snapshot*, если объект находится в общем контейнере.
Мы разобрались с сохранением логического состояния, но ведь зачастую возникает необходимость хранения и визуального, к примеру, размеров и положения окон, состояния контролов и других параметров. Фреймворк предлагает нестандартное, но невероятно удобное решение. Что если хранить такие параметры в контекстных объектах (вью-моделях), но не в виде отдельных свойств для сериализации, а неявно, в виде словаря, где ключом является имя «мнимого» свойства?
На основе данной концепции родилась идея *smart*-свойств. Значение *smart*-свойства должно быть доступно через индексатор по имени-ключу, как в словаре, а классический *get* или *set* являются опциональными и могут отсутствовать! Эта функциональность реализована в классе *SmartObject*, от которого наследуется *ContextObject*, расширяя её.
Достаточно всего лишь написать в десктоп-версии:
```
public class AppViewModel : SmartObject // ContextObject
{}
```
```
```
после чего размеры и положение окна будут автоматически сохраняться при выходе из приложения и в точности восстанавливаться при запуске! Согласитесь, это поразительная лаконичность для решения такого рода задачи. Во вью-модели или код-бехаин не пришлось писать ни одной дополнительной строчки кода.
\* О небольших нюансах и ограничениях некоторых других *xaml*-платформ, а также способах из обхода следует смотреть оригинальную статью [Context Model Pattern via Aero Framework](http://habrahabr.ru/post/251347/).
Благодаря механизму полиморфизма валидация значений свойств с помощью имплементации интерфейса *IDataErrorInfo*, также использующего индексатор, очень изящно вписывается в концепцию смарт-состояния.
**Итоги**
Может показаться, что мы отклонились от основной темы, но это не так. Все, описанные в этой и предыдущих статьях, механизмы вместе с использованием паттерна *Exposable* позволяют создавать очень чистые и лаконичные вью-модели.
```
public class HelloViewModel : ContextObject, IExposable
{
public string Message
{
get { return Get(() => Message); }
set { Set(() => Message, value); }
}
public virtual void Expose()
{
this[() => Message].PropertyChanged += (sender, args) => Context.Make.RaiseCanExecuteChanged();
this[Context.Show].CanExecute += (sender, args) => args.CanExecute = !string.IsNullOrEmpty(Message);
this[Context.Show].Executed += async (sender, args) =>
{
await MessageService.ShowAsync(Message);
};
}
}
```
То есть запросто может получиться так, что во вью-модели объявлено несколько свойств и только один метод *Expose*, а весь остальной функционал описыватся лямбда-выражениями! А если планируется дальнейшее наследование, то следует просто отметить метод модификатором *virtual* . | https://habr.com/ru/post/256629/ | null | ru | null |
# Пишем бота на JavaScript для Minecraft (1.8-1.18) / Часть 10-14
Здравствуйте, уважаемые читатели Хабра! Продолжаем писать бота для Minecraft(1.8 - 1.18) с помощью библиотеки mineflayer. С прошлыми уроками можете ознакомиться [ТУТ](https://habr.com/ru/post/695372/).
Часть 10 (Взаимодействие с коровами)
------------------------------------
Создаём асинхронную функцию `async function startMilking().` После чего нашему объекту присваиваем фильтр. С помощью фильтра, определяем является ли корова взрослой. Если будет детёнышем, то бот молоко собрать не сможет. А также ставим дистанцию с которой бот будет собирать молоко, ставим < 5 блоков: e.position.distanceTo(bot.entity.position) < 5
```
bot.on('spawn', async function () {
await startMilking()
async function startMilking() {
setTimeout(async function () {
let nearbyCows = Object.values(bot.entities).filter(e => e.name == 'cow' && e.position.distanceTo(bot.entity.position) < 5 && !e.metadata[16]);
let cow = nearbyCows[Math.floor(Math.random() * nearbyCows.length)];
await bot.lookAt(cow.position, false)
let empty_bucket = bot.inventory.items().filter(item => item.name == 'bucket')[0];
// Необязательный вывод в консоль
if (!empty_bucket) {
console.log('[Предупреждение] В моем инвентаре нет пустого ведра');
return startMilking();
await startMilking();
}, 2000)
}
});
```
Часть 11 (Значения еды, здоровья, опыта, уровня)
------------------------------------------------
Введя в чат: Здоровье, Еда, Опыт, Уровень , будет выведено соответствующее сообщение.
```
bot.on('chat', function (username, message) {
if (message === "Здоровье") {
bot.chat('У меня ' + bot.health.toFixed(0) + ' здоровье')
}
if (message === "Еда") {
bot.chat(`У меня ` + bot.food + ` еды`)
}
if (message === "Опыт") {
bot.chat("У меня " + bot.experience.points.toFixed(0) + " опыта")
}
if (message === "Уровень") {
bot.chat('У меня ' + bot.experience.level.toFixed(0) + ' уровень')
}
});
```
Часть 12 (Автоматическая экипировка тотема)
-------------------------------------------
Для начала необходимо установить плагин командой : `npm i mineflayer-auto-totem --save.`
Весь код:
```
bot.loadPlugin(autototem)
bot.on("physicsTick",async() =>{bot.autototem.equip()})
```
Возможно у вас возник вопрос, как данный плагин работает? Если у бота значение здоровья будет равняться 0 , то выполнится метод equip() и тотем автоматически появится в руке бота. Так будет до тех пор, пока все тотемы не закончатся.
Часть 13 (Радар)
----------------
Красным маркером отмечен бот, а зелёным игрок.
Напишем следующий код:
```
const radarPlugin = require('mineflayer-radar')(mineflayer);
radarPlugin(bot, options);
```
После чего нажимаем ПКМ на `'mineflayer-radar',` и выбираем первый пункт, чтобы установить плагин. Запустим нашего бота и в консоль будет выведен порт для подключения, запоминаем его. В моём случае это 22355.
Переходим в браузер и пишем localhost:22355. Радар успешно работает.
Часть 14 (Web-инвентарь)
------------------------
Для начала скачаем плагин, впишем в терминал `npm install mineflayer-web-inventory.`
`const inventoryViewer = require('mineflayer-web-inventory')`
`inventoryViewer(bot)`
После запуска бота пишем в браузере localhost:3000 и наблюдаем за инвентарём. Также можно изменить параметры плагина, используя следующий код.
```
let options = { port: PORT,webPath: PATH,express: EXPRESS,app: APP, http: HTTP,io: IO,startOnLoad: BOOLEAN,windowUpdateDebounceTime: INT}
inventoryViewer(bot, options)
``` | https://habr.com/ru/post/701056/ | null | ru | null |
# Ответственный подход к JavaScript-разработке, часть 2
В апреле этого года мы опубликовали перевод [первого материала](https://habr.com/ru/company/ruvds/blog/447576/) из цикла, посвящённого ответственному подходу к JavaScript-разработке. Там автор размышлял о современных веб-технологиях и об их рациональном использовании. Теперь мы предлагаем вам перевод второй статьи из этого цикла. Она посвящена некоторым техническим деталям, касающимся устройства веб-проектов.
[](https://habr.com/ru/company/ruvds/blog/460797/)
Есть идея
---------
Вы и ваша команда с энтузиазмом продвигали идею полной перестройки устаревающего веб-сайта компании. Ваши просьбы дошли до руководства, даже попали в поле зрения тех, кто находится на самом верху. Вам дали зелёный свет. Ваша команда с воодушевлением принялась за работу, привлекая к ней дизайнеров, копирайтеров и других специалистов. Вскоре вы выкатили новый код.
Работа над ним началась совершенно невинно. Команда `npm install` тут, команда `npm install` там. Не успели вы оглянуться, как продакшн-зависимости уже устанавливались так, будто разработка проекта — это дикая пьянка, а вы — тот, кого совершенно не заботит то, что будет завтрашним утром.
Потом вы запустились.
Но, в отличие от последствий самой безумной попойки, страшное началось не следующим утром. К сожалению — не следующим утром. Расплата пришла через месяцы. Она приняла неприятную форму лёгкой тошноты и головной боли владельцев компании и менеджеров среднего звена, которые задавались вопросом о том, почему после запуска нового сайта упали конверсии и доходы. Потом бедствие набрало обороты. Случилось это тогда, когда технический директор вернулся с выходных, которые он провёл где-то за городом. Он интересовался тем, почему сайт компании так медленно загружается (если вообще загружается) на его телефоне.
Раньше хорошо было всем. Теперь же настали другие, мрачные времена. Встречайте своё первое похмелье после употребления большой дозы JavaScript.
Это — не ваша вина
------------------
В то время как вы пытались справиться с адским похмельем, слова, вроде «Я же тебе говорил», прозвучали бы для вас как заслуженный выговор. А если бы вы способны были бы в то время драться — они могли бы послужить поводом для драки.
Когда дело доходит до последствий необдуманного применения JavaScript — можно осуждать всё и вся. Но искать виновных — это пустая трата времени. Само устройство современного веба требует от компаний решать задачи быстрее, чем их конкуренты. Подобное давление означает, что мы, стремясь как можно сильнее повысить свою продуктивность, скорее всего, ухватимся за всё что угодно. Это означает, что мы, с большой долей вероятности (хотя это и нельзя назвать неизбежным), будем создавать приложения, в которых будет немало излишеств, и, скорее всего, будем использовать паттерны, вредящие производительности и доступности приложений.
Веб-разработка — это непростое занятие. Это — долгая работа. Её редко выполняют хорошо с первой попытки. Самое лучшее в этой работе, однако, это то, что мы не обязаны всё делать идеально в самом её начале. Мы можем вносить в проекты улучшения после их запуска, и, собственно говоря, этому и посвящён данный материал, второй в серии статей об ответственном подходе к JS-разработке. Совершенство — это цель весьма отдалённая. Пока же давайте справимся с JavaScript-похмельем, улучшив, так сказать, *скриптуацию*
на сайте в ближайшей перспективе.
Разбираемся с распространёнными проблемами
------------------------------------------
Это может показаться чем-то вроде механического подхода к решению проблем, но сначала стоит пройтись по списку типичных неприятностей и способов борьбы с ними. В больших командах разработчиков о подобных вещах часто забывают. Особенно это касается тех команд, которые работают с несколькими репозиториями или не используют оптимизированный шаблон для своих проектов.
### ▍Примените алгоритм tree shaking
Для начала проверьте — настроены ли используемые вами инструменты на реализацию алгоритма [tree shaking](https://developer.mozilla.org/en-US/docs/Glossary/Tree_shaking). Если вы с этим понятием раньше не сталкивались — взгляните на этот [мой](https://developers.google.com/web/fundamentals/performance/optimizing-javascript/tree-shaking/) материал, написанный в прошлом году. Если пояснить работу этого алгоритма в двух словах, то можно сказать, что благодаря его использованию в состав продакшн-сборок приложения не включают те пакеты, которые, хотя и импортированы в проект, в нём не используются.
Реализация алгоритма tree shaking — это стандартная возможность современных бандлеров — таких, как [webpack](https://webpack.js.org/), [Rollup](https://rollupjs.org/) или [Parcel](https://parceljs.org/). [Grunt](https://gruntjs.com/) или [gulp](https://gulpjs.com/) — это менеджеры задач. Они этим не занимаются. Менеджер задач, в отличие от бандлера, не создаёт [граф зависимостей](https://webpack.js.org/concepts/dependency-graph/). Менеджер задач занимается, с использованием необходимых плагинов, выполнением отдельных манипуляций над передаваемыми ему файлами. Функционал менеджеров задач можно расширять с помощью плагинов, наделяя их возможностями обрабатывать JavaScript с использованием бандлеров. Если расширение возможностей менеджера задач в подобном направлении кажется вам проблематичной задачей — то вам, вероятно, нужно вручную проверять кодовую базу и убирать из неё неиспользуемый код.
Для того чтобы алгоритм tree shaking мог бы работать эффективно, необходимо выполнение следующих условий:
1. Код приложения и установленные пакеты должны быть представлены в виде [модулей ES6](https://ponyfoo.com/articles/es6-modules-in-depth). Применение алгоритма tree shaking для [CommonJS](https://en.wikipedia.org/wiki/CommonJS)-модулей практически невозможно.
2. Ваш бандлер не должен трансформировать ES6-модули в модули какого-то другого формата во время сборки проекта. Если это происходит в цепочках инструментов, в которых используется Babel, то в [@Babel/present-env](https://babeljs.io/docs/en/babel-preset-env) должна присутствовать настройка [modules: false](https://babeljs.io/docs/en/babel-preset-env#modules). Это приведёт к тому, что ES6-код не будет конвертироваться в код, в котором используется CommonJS.
Если вдруг при сборке вашего проекта алгоритм tree shaking не применяется — включение этого механизма может улучшить ситуацию. Конечно, эффективность этого алгоритма варьируется от проекта к проекту. Кроме того, возможность его применения зависит от того, имеют ли импортируемые модули [побочные эффекты](https://en.wikipedia.org/wiki/Side_effect_(computer_science)). Это может повлиять на возможность бандлера избавляться от включения в сборку ненужных импортированных модулей.
### ▍Разделите код на части
Весьма вероятно, что вы уже используете некую разновидность [разделения кода](https://developers.google.com/web/fundamentals/performance/optimizing-javascript/code-splitting/). Однако вам стоит проверить то, как именно это делается. Вне зависимости от того, как именно вы разделяете код, я хочу предложить вам задать себе следующие два весьма ценных вопроса:
1. Удаляете ли вы [дублирующийся код](https://developers.google.com/web/fundamentals/performance/optimizing-javascript/code-splitting/#removing_duplicate_code) из [входных точек](https://webpack.js.org/concepts/entry-points/)?
2. Выполняете ли вы ленивую загрузку всего, что можно загрузить таким способом, с помощью [динамических импортов](https://developers.google.com/web/updates/2017/11/dynamic-import)?
Эти вопросы важны из-за того, что уменьшение объёма избыточного кода — это принципиально значимый элемент производительности. Ленивая загрузка кода также повышает производительность, снижая объём JavaScript-кода, который входит в состав страницы и загружается при её загрузке. Если говорить об анализе проекта на предмет наличия в нём избыточного кода, то для этого можно воспользоваться неким инструментом вроде Bundle Buddy. Если у вашего проекта с этим проблема — данное средство позволит вам об этом узнать.
*Средство Bundle Buddy может проверить сведения о webpack-компиляции и выяснить то, как много одинакового кода используется в ваших бандлах*
Если же говорить о ленивой загрузке материалов, то тут некоторую сложность может представлять выяснение того, где стоит искать возможности по применению этой оптимизации. Когда я исследую существующий проект на предмет возможности применения ленивой загрузки, я ищу в кодовой базе те места, которые подразумевают взаимодействия пользователя с кодом. Это могут быть, например обработчики событий мыши или клавиатуры, а также прочие подобные вещи. Любой код, для запуска которого необходимы некие действия пользователя, является хорошим кандидатом на применение к нему динамической команды `import()`.
Конечно, загрузка скриптов по запросу несёт в себе риск заметных задержек перехода системы в интерактивный режим. Ведь, прежде чем программа сможет взаимодействовать с пользователем в интерактивном режиме, нужно загрузить соответствующий скрипт. Если объём передаваемых данных вас не беспокоит — рассмотрите возможность применения подсказки по ресурсам [rel=prefetch](https://www.w3.org/TR/resource-hints/#prefetch) для загрузки подобных скриптов с низким приоритетом. Такие ресурсы не будут соперничать за полосу пропускания с критически важными ресурсами. Если браузер пользователя [поддерживает](https://caniuse.com/#feat=link-rel-prefetch) `rel=prefetch` — использование этой подсказки пойдёт только на пользу. Если нет — ничего страшного не произойдёт, так как браузеры просто игнорируют разметку, которую они не понимают.
### ▍Используйте опцию webpack externals для пометки ресурсов, расположенных на чужих серверах
В идеале вы должны хостить на собственных серверах как можно больше зависимостей своего сайта. Если же по каким-то причинам вы, без вариантов, должны загружать зависимости с чужих серверов — помещайте их в блок [externals](https://webpack.js.org/configuration/externals/) в настройках webpack. Если этого не сделать, это может означать, что посетители вашего сайта будут загружать и код, который вы размещаете у себя, и тот же самый код с чужих серверов.
Взглянем на гипотетическую ситуацию, в которой подобное может вашему ресурсу навредить. Предположим, ваш сайт загружает библиотеку Lodash с общедоступного CDN-ресурса. Вы, кроме того, установили Lodash в проект для целей локальной разработки. Однако если вы не укажете в настройках webpack то, что Lodash — это внешняя зависимость, то ваш продакшн код будет загружать библиотеку из CDN, но она, в то же время, будет включена и в состав бандла, который размещён на вашем сервере.
Если вы хорошо знакомы с бандлерами, то всё это может показаться вам прописными истинами. Но я видел, как на эти вещи не обращают внимания. Поэтому не жалейте времени на то, чтобы дважды проверить свой проект на вышеописанные проблемы.
Если вы не считаете нужным самостоятельно хостить свои зависимости, созданные сторонними разработчиками, тогда рассмотрите возможность использования с ними подсказок [dns-prefetch](https://css-tricks.com/prefetching-preloading-prebrowsing/#article-header-id-0), [preconnect](https://css-tricks.com/prefetching-preloading-prebrowsing/#article-header-id-1), или, возможно, даже [preload](https://www.smashingmagazine.com/2016/02/preload-what-is-it-good-for/). Это способно снизить показатель сайта [TTI](https://developers.google.com/web/tools/lighthouse/audits/time-to-interactive) (Time To Interactive, время до первой интерактивности). А если для вывода содержимого сайта необходимы возможности JavaScript — то и индекс скорости загрузки ([Speed Index](https://sites.google.com/a/webpagetest.org/docs/using-webpagetest/metrics/speed-index)) сайта.
Альтернативные библиотеки меньшего размера и снижение дополнительной нагрузки на системы пользователей
------------------------------------------------------------------------------------------------------
То, что называют «[Userland JavaScript](https://nodejs.org/en/knowledge/getting-started/what-is-node-core-verus-userland/)» (JS-библиотеки, разработанные пользователями), похоже на неприлично огромную кондитерскую. Всё это опенсорсное великолепие и разнообразие внушает нам, разработчикам, священный трепет. Фреймворки и библиотеки позволяют нам расширять наши приложения, быстро оснащая их возможностями, помогающими решать самые разные задачи. Если бы нам пришлось реализовывать тот же функционал самостоятельно — это отнимало бы очень много сил и времени.
Хотя лично я являюсь сторонником агрессивной минимизации использования в своих проектах клиентских фреймворков и библиотек, я не могу не признавать их огромной ценности и полезности. Но, несмотря на это, мы, когда дело доходит до установки в проект новых зависимостей, должны относиться к каждой из них с изрядной долей подозрительности. Если мы уже создали и запустили что-то, работа чего зависит от множества установленных зависимостей, то это значит, что мы смирились с той дополнительной нагрузкой на систему, которую всё это создаёт. Вероятно, справиться с этой проблемой, оптимизировав свои разработки, могут лишь разработчики пакетов. Так ли это?
Возможно это так, а возможно — нет. Это зависит от используемых зависимостей. Например, React — чрезвычайно популярная библиотека. Но [Preact](https://preactjs.com/) — [очень маленькая](https://bundlephobia.com/result?p=preact@8.4.2) альтернатива React, которая даёт разработчику практически те же API и сохраняет совместимость с множеством дополнений для React. [Luxon](https://moment.github.io/luxon/) и [date-fns](https://date-fns.org/) — это альтернативы [moment.js](https://momentjs.com/), гораздо более компактные, чем эта библиотека, которая [не так уж и мала](https://bundlephobia.com/result?p=moment).
В библиотеках вроде [Lodash](https://lodash.com/) можно найти множество полезных методов. Но некоторые из них легко заменить на стандартные методы ES6. Например, метод Lodash [compact](https://lodash.com/docs/4.17.11#compact), можно заменить на стандартный метод массивов [filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter). [Многие](https://github.com/you-dont-need/You-Dont-Need-Lodash-Underscore#_chunk) другие методы Lodash тоже можно спокойно заменить на стандартные. Плюс такой замены заключается в том, что мы получаем те же возможности, что и с использованием библиотеки, но избавляемся от довольно крупной зависимости.
Чем бы вы ни пользовались, общая идея остаётся одной и той же: поинтересуйтесь — есть ли у того, что вы выбрали, более компактные альтернативы. Узнайте, можно ли решить те же задачи стандартными средствами языка. Возможно, вы окажетесь приятно удивлены тем, как мало вам придётся приложить усилий для того, чтобы серьёзно сократить размеры приложения и тот объём ненужной нагрузки, которое оно оказывает на системы пользователей.
Пользуйтесь технологиями дифференциальной загрузки скриптов
-----------------------------------------------------------
Велика вероятность того, что в вашей цепочке инструментов присутствует Babel. Это средство применяется для трансформации исходного кода, соответствующего стандарту ES6, в код, который могут выполнять устаревшие браузеры. Означает ли это, что мы обречены отдавать огромные бандлы даже тем браузерам, которые в них не нуждаются, до тех пор, пока все старые браузеры просто не исчезнут? [Конечно нет](https://philipwalton.com/articles/deploying-es2015-code-in-production-today/)! Дифференциальная загрузка ресурсов помогает обойти эту проблему путём создания на основе ES6-кода двух разных сборок:
* Первая сборка включает все преобразования кода и полифиллы, необходимые вашему сайту для работы в устаревших браузерах. Вероятно, сейчас вы отдаёте клиентам именно эту сборку.
* Вторая сборка либо содержит минимум преобразований кода и полифиллов, либо обходится вовсе без них. Она рассчитана на современные браузеры. Это та сборка, которой у вас, возможно, нет. Как минимум — пока нет.
Для того чтобы воспользоваться технологией дифференциальной загрузки сборок, придётся немного поработать. Не буду тут вдаваться в подробности — дам лучше [ссылку](https://calendar.perfplanet.com/2018/doing-differential-serving-in-2019/) на мой материал, в котором рассмотрен один из способов реализации этой технологии. Суть этого всего заключается в том, что вы можете модифицировать свою конфигурацию сборки так, чтобы в ходе сборки проекта создавалась бы дополнительная версия JS-бандла вашего сайта. Этот дополнительный бандл будет меньше основного. Он будет предназначен только для современных браузеров. Самое приятное здесь то, что такой подход позволяет добиться оптимизации размеров бандла и при этом не пожертвовать абсолютно ничем из возможностей проекта. В зависимости от кода приложения экономия на размере бандла может оказаться весьма значительной.
*Анализ бандла, предназначенного для устаревших браузеров (слева), и бандла, рассчитанного на новые браузеры (справа). Исследование бандлов проведено с помощью webpack-bundle-analyzer. [Вот](https://alistapart.com/wp-content/uploads/2019/06/diff-serving-bundles.jpg) полноразмерная версия этого изображения.*
Легче всего отдавать разные бандлы разным браузерам с использованием следующего приёма. Он хорошо работает в современных браузерах:
```
```
К несчастью, у этого подхода есть недостатки. Устаревшие браузеры вроде IE11, и даже сравнительно современные — такие, как Edge версий 15-18, загрузят оба бандла. Если вы готовы с этим смириться — тогда пользуйтесь этим приёмом и ни о чём не беспокойтесь.
С другой стороны, вам нужно что-то придумать в том случае, если вас беспокоит [воздействие](https://gist.github.com/jakub-g/5fc11af85a061ca29cc84892f1059fec) на производительность вашего приложения того факта, что старым браузерам приходится загружать оба бандла. Вот одно потенциальное решение этой проблемы, в котором используется внедрение скриптов (вместо тега | https://habr.com/ru/post/460797/ | null | ru | null |
# Оптимизация JavaScript и jQuery из-под HTML и CSS при разработке сайта
Доброго времени суток, Хабражители. Хочу поделиться неким опытом (советами) при работе с JavaScript + jQuery (по сути, вместо jQuery можете подставить любой другой JS фреймворк). Статья будет интересна новичкам JS и jQuery, но и ~~динозаврам~~ опытным проходить мимо не стоит, в ней вполне можно найти полезную информацию. В основном, в статье я привожу не однозначные случаи, но и место для «стоТыщРазПовтор» я счёл уместным.
#### Инициализация
Сплошь и рядом встречаю загрузку JS файлов в теге ``. В большинстве случаев - это не корректно! Почему? В этом случае JS начинает загружаться до загрузки HTML, и как следствие клиент дольше ждёт загрузки информации за которой он пришёл. Размещение скриптов в оправдано только в тех случаях, когда JS используется в качестве контроллера (к примеру, всё содержимое на странице мы достаём поблочно через AJAX запросы, в зависимости от URL или Hash). Если не используем, то гораздо лучше вставлять скрипты перед зыкрытием тэга` . JS начнёт загружаться только после того, как посетитель увидит страницу.
Размещение инициализации скриптов непосредственно перед закрытием тега` практически не влияет на «начало» работы скриптов. В большинстве случаев используют `jQuery( document ).ready( function () { ... }`, что в свою очередь всё равно запускает скрипты только после загрузки HTML. Это как закупаться бензином до того, как купили автомобиль.
#### Inline JavaScript в HTML коде
Это ужасно!
* Во-первых, это некрасиво, неуклюже и со старта похоже на костыль.
* Во-вторых, инлаин скриптинг плохо контролируется через JS контроллеры (сюда я отношу как редактирование кода, так и функциональность по типу `callback()`).
* И наконец, эти скрипты не могут быть автоматически минифицированы и сжаты (gzip), что скажется на производительности продакшн сервера.
#### Селекторы
Тема стара как мир, первым результатом в поисковике на запрос об оптимизации выдаст статью про селекторы. И тем не менее, из раза в раз, на это просто забивают. Как говориться, повторение — мать учения.
Селекторы сильно сказываются на производительности сраницы. К примеру из моей недавной практики, всего из-за одного селектора коллеги в тонне скриптов, сайт буквально висел 8-10 секунд. Для выбора инпута формы, использовался `jQuery( 'input[name="some-specific-name"]' )` и это на странице с ~ 10 формами и ~ 300 полями… Замена этого селектора на ID — и, вуаля, ~~висяк~~ response time упал до 60-90 мс.
Буду краток: всегда используйте ID в селекторе. Если нет такой возможности, используйте ID родительского элемента, а только затем другой (класс, тег или атрибут).
```
jQuery( '#element-id' ); // Это супер
jQuery( '#parent-element-id .needed-class-name' ); // Это хорошо
jQuery( '#parent-element-id a' ); // Можно конечно и так
```
Используйте `.filter()`, чтобы отфильтровать элементы, вместо перебора `.each()`
Для выбора первых, последних или определённых элементов используйте `.first()`, `.last()`, `.eq( index )`
**Как это относится к HTML или CSS?**Всё предельно просто, ведь селекторы из JavaScript или jQuery напрямую зависят от разметки страницы. Как быть в случае, когда в вёрстке нет ни единого класса и идентификатора (мистика, конечно, но как понятный пример должен сойти).
#### Анимация
Думаю уместным здесь будет упомянуть про очереди анимаций и одновременной анимации нескольких элементов — так как, это приоритарная оптимизация, но ~~копипастить~~ вдаваться в подробности не стану, ибо поисковик выдаст всю нужную информацию по этим пунктам (в футере приведу ссылочки).
Маргин (`margin` — CSS свойство) — вот первый враг анимаций.
Как-то приходилось мне разрабатывать проект с дикой анимацией и своеобразным UI (Блочный сайт, где каждый блок может быть увеличенным или приближенным. Т.е. приближение заменяет переход по ссылке, а уменьшенный вид, это что-то вроде полноэкранной навигации. Плюс размытие элементов в уменьшенном виде, плюс тач ивенты на переходы, навигация на клавиатуре, слайды, карусели, плавное появление всплывающих окон и т.д.). В кратце, **ну просто всё** движется одновременно.
Плавное передвижение огромных и при этом ~~отзумленых~~ уменьшенных изображений — это уже не всегда просто. А если таких изображений 13, и все нужно анимировать одновременно (эффект размытия)? Это полноценный вывих мозга. Тут, собственно, и был найден самый злостный враг — `margin`. Поскольку элементы распологались лесенкой (с разными отступами), то было необходимо использовать либо `margin`, либо `padding`, либо `left`. Методом тыка и множественных переборов, в моём случае отказ от `margin` поднял FPS с ~20 до ~35 (Opera, Firefox, IE 7,8. Chrome и так показывал 100).
Как однозначное правило выносить это не стану, только как совет, на что можно обратить внимание.
Спасибо за внимание и потраченное время, на этом всё.
##### Подвал
Узнать больше о [jQuery Очередях [ENG]](http://dyn.com/blog/why-jquery-queue-should-be-your-new-best-friend/)
Узнать больше о [jQuery анимации нескольких элементов [ENG]](http://www.benknowscode.com/2012/09/animating-multiple-elements_1805.html) | https://habr.com/ru/post/196580/ | null | ru | null |
# Эластичные шаблоны
[](http://www.voprosoff.net/test/)
Большинство дизайнов ориентировано на использование фиксированных значений при верстке: ширина и высота блоков, размер шрифта. Это позволяет сверстанному шаблону «не разваливаться» при изменении масштабов просмотра и сохранять свойство кроссбраузерности. Однако в этом есть один большой минус – при большом разрешении экрана маленькие фиксированные блоки теряются на большой площади и остаются незамеченными. Тут даже не спасет «резиновая» верстка, т.к. сайт будет выглядеть еще более нечитабельным, например на 19'' мониторах при разрешении большем 1280 по ширине. Для меня это актуально, т.к. на ноутбуке 17'' с разрешением 1400х800 просматривать «резиновый» сайт очень неудобно. И желание оставаться на таком сайте отпадает быстро. Существует ли способ, позволяющий управлять масштабами не только текста, но и всего сайта?
### Задача
Первое, что сразу приходит в голову – это управление масштабированием в настройках браузера. К счастью, данную функцию поддерживает большинство современных браузеров, за исключением IE6 и FireFox (на удивление). Они позволяют управлять лишь масштабами текста, при этом в IE6 размер шрифта должен быть указан не в px. При выборе самого крупного шрифта мы столкнемся с такой проблемой, что сайт просто «развалится» и будет выглядеть совершенно нечитабельно.
Таким образом, наша задача – сделать эластичным не только текст, но и содержащие его блоки.
### Реализация
Особенность верстки эластичного шаблона в том, что **все величины** **должны быть указаны** не в пикселях (px) и не в процентах, а **в em**.
Почему неэффективно использование значений в процентах? Потому что, использование десятых и сотых долей в значении воспринимается не всеми браузерами. В то время как для em величин можно указывать 3 знака после запятой и каждая цифра будет учитываться.
Применение em позволяет делать любые элементы эластичными и забыть о том, что где-то наш текст может «уехать» за рамки того или иного блока. Многие из вас уже наверное читали статьи о том, как перейти с px на em. Но, думаю, повторение никому не повредит :)
Стоит отметить, что создание эластичного шаблона потребует много расчетов, а именно – перевода привычных нам пикселей в em. Поэтому, стоит вооружиться калькулятором :)
По умолчанию 1em равен величине шрифта, который мы укажем у элемента body. Если величина шрифта не задана, то большинство браузеров автоматически устанавливают размер 16px, тогда и 1em = 16px. Отсюда:
0.5em = 8px
10em = 160px и т.д.
И как уже многие, наверное, знают: 0,625em (62,5%) = 10px. Это удобная точка отсчета.
Прописываем правила:
> `html{ font-size:100%; } /*необходимо для IE*/
>
> body{ background:#eee;
>
> font-size: 0.625em;
>
> font-family:Arial;
>
> text-align:center}`
**Теперь 1em будет равен 10px.**
Формула для конвертации px в em будет очень проста:
Где, X – значение в px, которое нужно конвертировать, а Y – соответствующее значение в em.
Т.к. мы хотим сделать эластичным не только шрифт, но и весь контент, то нам придется отказаться от назначения величины шрифта у основных структурных блоков. Причина в том, что назначив блоку размер шрифта, нам придется пересчитывать его ширину в em по другой формуле – уже не относительно величины родительского значения (10px), а от величины шрифта этого блока (12px). Поэтому внутри блока мы будем использовать например элемент p.
Теперь можно заняться непосредственно структурой, например, такой:
> `Пример "эластичной" верстки
> ===========================
>
>
>
>  Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia.
>
> Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia.`
Нам нужно прописать правила для элементов H1, P, IMG и блока wrap. Для последнего установим ширину в 600px, предварительно переведя в em:
600px/10 = 60em.
> `#wrap{
>
> width: 60em;
>
> margin: 1.5em auto; /* 15px/10 =1.5em*/
>
> border: 0.1em solid #ccc; /* 1px/10 =0.1em*/
>
> background: #fff;
>
> text-align: left;
>
> }`
Для заголовка назначим размер шрифта, эквивалентный 16px, а для абзацев 12px
> `h1{
>
> font-size: 1.6em; /* 16px/10 =1.6em*/
>
> margin: 0.833em; /* 10px/16 =0.833em*/
>
> font-weight: 300;
>
> }
>
>
>
> p{
>
> font-size: 1.2em;
>
> line-height: 1.333em; /* 16px/12 =1.33em*/
>
> margin-bottom: 1.25em; /* 15px/12 =1.25em*/
>
> }`
Не забудем также, что габариты картинок теперь тоже надо указывать в em. Но это не проблема, когда формула преобразований так проста. Присвоим элементу img следующме правила:
> `img {
>
> width: 8.333em; /* 100px/12 =8.33em 12 – у блока p*/
>
> height: 8.333em;
>
> margin:0 0.833em 0.833em 0; /* 10px/12 =0.833em*/
>
> }`
[**Посмотреть пример**](http://jontangerine.com/silo/css/elastic-layout/)
### Итоги
В примере приведено 2 блока. Нижний из них, пример привычной нам верстки в px. Однако, разницу вы увидите лишь в IE и FireFox, т.к. Opera будет одинаково отображать увеличение масштаба для обоих примеров верстки.
**Масштаб шрифта самый крупный**
**Масштаб шрифта самый мелкий**
Как видите, преимущества эластичной верстки налицо. Теперь масштабируется не только текст, но и целиком блок, тем самым мы создали нечто подобное функции масштабирования в Opera и IE7. А значит, теперь можно с легкостью создать полностью эластичный шаблон для сайта, который не будет зависеть от фиксированных значений. Что позволит нам управлять масштабами не только текста, а сайта в целом и в IE и в FireFox.
Конечно, не каждому хочется сидеть с калькулятором и тратить время на расчеты. Но если того требует изначальная задача, то, надеюсь, мой пример вам пригодиться.
via [Jon Tan *gerine*](http://jontangerine.com/log/2007/09/the-incredible-em-and-elastic-layouts-with-css) | https://habr.com/ru/post/21209/ | null | ru | null |
# Строим систему распознавания лиц на основе Golang и OpenCV
OpenCV — библиотека, разработанная для проектов по компьютерному зрению. Ей уже около 20 лет. Я использовал ее еще в колледже и до сих пор применяю для своих проектов на C++ и Python, поскольку она имеет неплохую поддержку этих языков.
Но когда я начал изучать и использовать Go, мне стало интересно, можно ли применить OpenCV для работы с этим языком. В то время уже существовали примеры и туториалы по интеграции, но мне показалось, что они слишком сложные. Чуть позже мне в руки попался враппер, созданный командой The Hybrid Group. В этой статье я покажу, как начать с GoCV, разработав простую систему распознавания лиц с каскадами Хаара (Haar Cascades).
> **Skillbox рекомендует:** Практический курс [«Python-разработчик с нуля»](https://skillbox.ru/python/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=PTNDEV&utm_content=articles&utm_term=govideo).
>
>
>
> **Напоминаем:** *для всех читателей «Хабра» — скидка 10 000 рублей при записи на любой курс Skillbox по промокоду «Хабр».*
>
>
**Что потребуется:**
* Go;
* OpenCV (ссылки на установщик ниже);
* веб- или обычная видеокамера.
**Установка**
* Linux: [gocv.io/getting-started/linux](https://gocv.io/getting-started/linux/)
* macOS: [gocv.io/getting-started/macos](https://gocv.io/getting-started/macos/)
* Windows: [gocv.io/getting-started/windows](https://gocv.io/getting-started/windows/)
### Пример 1
В первом примере мы попробуем создать приложение, которое открывает окно с демонстрацией видеопотока камеры.
Сначала надо импортировать библиотеки, нужные для работы.
*import (
“log”
“gocv.io/x/gocv”
)*
После этого нужно создать объект VideoCapture с использованием функции VideoCaptureDevice. Последняя дает возможность захватывать видеопоток с помощью камеры. В функции используется целое число в качестве параметра (он представляет ID устройства).
```
webcam, err := gocv.VideoCaptureDevice(0)
if err != nil { log.Fatalf(“error opening web cam: %v”, err)
}
defer webcam.Close()
```
Теперь нужно создать n-мерную матрицу. Она будет хранить изображения, считанные с камеры.
```
img := gocv.NewMat()
defer img.Close()
```
Для отображения видеопотока нужно создать окно — это можно сделать с помощью функции NewWindow.
```
window := gocv.NewWindow(“webcamwindow”)
defer window.Close()
```
Теперь перейдем к самой интересной части.
Поскольку видео представляет собой непрерывный поток кадров-изображений, нам нужно будет создать бесконечный цикл для бесконечного считывания видеопотока камеры. Для этого нужен метод Read типа VideoCapture. Он будет ожидать тип Mat (матрица, которую мы создали выше), возвращая логическое значение, указывающее, был ли кадр из VideoCapture считан успешно или нет.
```
for {
if ok := webcam.Read(&img); !ok || img.Empty( {
log.Println(“Unable to read from the webcam”) continue
}
.
.
.
}
```
Теперь нужно отобразить фрейм в созданном окне. Пауза для перехода к следующему фрейму — 50 мс.
*window.IMShow(img)
window.WaitKey(50)*
После запуска приложения откроется окно с видеопотоком с камеры.
```
package main
import (
"log"
"gocv.io/x/gocv"
)
func main() {
webcam, err := gocv.VideoCaptureDevice(0)
if err != nil {
log.Fatalf("error opening device: %v", err)
}
defer webcam.Close()
img := gocv.NewMat()
defer img.Close()
window := gocv.NewWindow("webcamwindow")
defer window.Close()
for {
if ok := webcam.Read(&img); !ok || img.Empty() {
log.Println("Unable to read from the webcam")
continue
}
window.IMShow(img)
window.WaitKey(50)
}
}
```
### Пример 2
В этом примере давайте воспользуемся предыдущим примером и построим систему по распознаванию лиц на основе Haar Cascades (каскады Хаара).
Каскады Хаара — это каскадные классификаторы, которые обучаются на основе техники вейвлетов Хаара. Они анализируют пиксели в изображении, чтобы обнаружить определенные признаки. Чтобы узнать больше о Haar Cascades, можно пройти по ссылкам ниже.
[Viola-Jones object detection framework](https://www.cs.ubc.ca/~lowe/425/slides/13-ViolaJones.pdf?source=post_page---------------------------)
[Cascading classifiers](https://en.wikipedia.org/wiki/Cascading_classifiers?source=post_page---------------------------)
[Haar-like feature](https://en.wikipedia.org/wiki/Haar-like_feature?source=post_page---------------------------)
Скачать уже обученные каскады [можно здесь](https://github.com/opencv/opencv/tree/master/data/haarcascades?source=post_page---------------------------). В текущем примере каскады будут использоваться для идентификации лица человека в фас.
Для того чтобы сделать это, нужно создать классификатор и скормить ему уже обученный файл (выше дана ссылка). Я уже загрузил файл pencv\_haarcascade\_frontalface\_default.xml в директорию, где расположена наша программа.
```
harrcascade := “opencv_haarcascade_frontalface_default.xml”classifier := gocv.NewCascadeClassifier()classifier.Load(harrcascade)
defer classifier.Close()
```
Для обнаружения лиц на изображении нужно воспользоваться методом [DetectMultiScale](https://github.com/hybridgroup/gocv/blob/master/objdetect.go?source=post_page---------------------------#L51). Эта функция принимает кадр (тип Mat), который был только что считан с видеопотока камеры, и возвращает массив типа Rectangle. Размер массива представляет количество лиц, которые классификатор смог обнаружить в кадре. Затем, чтобы убедиться, что мы видим то, что он нашел, давайте пройдемся по списку прямоугольников и выведем объект Rectangle на консоль, создав границу вокруг обнаруженного прямоугольника. Это можно сделать при помощи функции Rectangle. Она будет принимать Mat, считанный камерой, объект Rectangle, который был возвращен методом DetectMultiScale, цвет и толщину для границы.
```
for _, r := range rects {
fmt.Println(“detected”, r)
gocv.Rectangle(&img, r, color, 2)
}
```
```
package main
import (
"fmt"
"image/color"
"log"
"gocv.io/x/gocv"
)
func main() {
webcam, err := gocv.VideoCaptureDevice(0)
if err != nil {
log.Fatalf("error opening web cam: %v", err)
}
defer webcam.Close()
img := gocv.NewMat()
defer img.Close()
window := gocv.NewWindow("webcamwindow")
defer window.Close()
harrcascade := "opencv_haarcascade_frontalface_default.xml"
classifier := gocv.NewCascadeClassifier()
classifier.Load(harrcascade)
defer classifier.Close()
color := color.RGBA{0, 255, 0, 0}
for {
if ok := webcam.Read(&img); !ok || img.Empty() {
log.Println("Unable to read from the device")
continue
}
rects := classifier.DetectMultiScale(img)
for _, r := range rects {
fmt.Println("detected", r)
gocv.Rectangle(&img, r, color, 3)
}
window.IMShow(img)
window.WaitKey(50)
}
}
```
И… да, все получилось! Теперь у нас есть простая система распознавания лиц, написанная на Go. В скором времени я планирую продолжить эти эксперименты и создать новые классные штуки, сочетая Go и OpenCV.
Если вам интересно, то оцените [gRPC web server](https://github.com/Niraj-Fonseka/recognize?source=post_page---------------------------), который я написал на Python и OpenCV. Он стримит данные в момент обнаружения лица. Это основа для создания разных клиентов на разных языках программирования. Они смогут подключаться к серверу и считывать с него данные.
Спасибо, что прочитали статью!
> **Skillbox рекомендует:**
>
>
>
> * Двухлетний практический курс [«Я — веб-разработчик PRO»](https://iamwebdev.skillbox.ru/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=WEBDEVPRO&utm_content=articles&utm_term=govideo).
> * Образовательный онлайн-курс [«Профессия Java-разработчик»](https://skillbox.ru/java/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=JAVDEV&utm_content=articles&utm_term=govideo).
> * Практический годовой курс [«PHP-разработчик с 0 до PRO»](https://skillbox.ru/php/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=PHPDEV&utm_content=articles&utm_term=govideo).
> | https://habr.com/ru/post/462159/ | null | ru | null |
# Статическое константное дерево на шаблонах C++
Поиск и структуры данных
------------------------
Поиск можно считать одной из наиболее нужных и часто используемых операций при разработке программного обеспечения. На сегодняшний день известно большое количество алгоритмов и структур данных, обеспечивающих высокую скорость поиска. Пусть и в меньшей степени, но подобные задачи возникают и в сфере разработки ПО для встраиваемых систем, одной из главных особенностей которой является существенная ограниченность системных ресурсов.
В статье предлагается рассмотреть особенности реализации элементарной структуры данных и способы оптимизации в условиях малого объема доступной памяти.
Зачем это авторуВ процессе разработки фреймворка для ARM-микроконтроллеров мне захотелось реализовать более-менее универсальный способ обработки ответов устройств, управляемых посредством AT-команд.
Текущая идея заключается в реализации Patricia-дерева, где значениями узлов будут указатели на обработчики ответа, а ключами, соответственно, префиксы ответов. Однако классическая реализация выходит чересчур дорогой в плане расходования RAM, что заставило подумать над способами уменьшить количество необходимой памяти.
Префиксное дерево само по себе не самое простое для понимания и реализации, а если добавить шаблоны C++, то существует риск окончательно запутаться и не довести задумку до конца, поэтому экспериментировать я решил с BST.
Бинарное дерево поиска на C++
-----------------------------
Классической структурой данных, предназначенной для быстрого поиска, является *бинарное дерево поиска* (*BST – binary search tree*), которое обладает следующими характеристиками:
* Временная сложность поиска: **O (log n)**
* Емкостная сложность: **O(n)**
И если с временной сложностью в целом поделать ничего нельзя (так как функция поиска элементарная) и реальное затраченное время зависит исключительно от размера данных и мощности процессора, то емкостная накладывает существенное ограничение на применимость данной структуры (да и других тоже) в условиях крайне малого объема доступной памяти.
Рассмотрим классическую реализацию бинарного дерева поиска на языке C++. В первую очередь необходимо определить тип данных каждого узла будущего дерева (для упрощения примем, что и ключи, и значения имеют целочисленный тип), код непосредственно реализации дерева можно опустить, так как с точки зрения расходования памяти он является несущественным, потому что содержит только указатель на корневой элемент:
```
struct Node
{
int Key; // 4 байта
int Value; // 4 байта
Node* Left; // 4 байта
Node* Right; // 4 байта
};
```
Таким образом, каждый узел дерева занимает ~16 байтов (будем считать, что программа предназначена для 32-битных систем с размером указателя 4 байта и размером типа int также 4 байта), то есть константа в оценке емкостной сложности равна 16!
Подобная структура данных становится весьма дорогим удовольствием, учитывая размеры RAM современных микроконтроллеров. Например, один из самых популярных ARM-контроллеров низшей ценовой категории *Stm32f103c8t6* предлагает 20 Кб RAM и 64 Кб Flash-памяти. Классическая реализация бинарного дерева поиска позволит хранить ~1200 узлов, что займет практически весь доступный объем оперативной памяти.
В то же время разработка программного обеспечения для микроконтроллерной техники имеет ряд особенностей, одной из которых можно считать нередкое отсутствие необходимости изменять структуру данных во время выполнения, значительная часть данных **известна еще на этапе компиляции**, что позволяет разместить их не в оперативной, а во flash‑памяти, используя приемы статического шаблонного программирования на языке C++.
Рассмотрим возможную модификацию реализации дерева.
Статическое константное дерево
------------------------------
Каждый узел дерева можно задать шаблонной структурой:
```
template
struct Node
{
static const unsigned Key = \_Key;
static const unsigned Value = \_Value;
using Left = \_Left;
using Right = \_Right;
};
```
Несложно заметить, что структура содержит два статических константных значения, что позволяет ожидать от компилятора помещения их именно в ROM-память, а указатели на потомков заменены на их типы, то есть в памяти места не занимают.
В терминах шаблонных классов, когда каждый узел дерева определяет новый тип данных, понятие *"текущий узел"* (используемое в классической реализации метода поиска) некорректно, поскольку отсутствуют объекты. Вместо этого необходимо, как это обычно и происходит, применить рекурсивный алгоритм, добавив в структуру Node метод поиска:
```
static auto Search(unsigned key)
{
return key == Key
? Value
: key < Key
? Left::Search(key)
: Right::Search(key);
}
```
Само же дерево существенно упрощается, содержит только корень, а метод поиска делегирует поиск корневому элементу:
```
template
struct BST
{
using Root = \_Root;
static auto Search(unsigned key)
{
return \_Root::Search(key);
}
};
```
Основной проблемой является корректное формирование дерева на этапе компиляции, можно предложить три пути решения:
1. Формировать узлы вручную.
2. Написать программу генерации C++ кода с правильным порядком узлов (например, на каком-либо скриптовом языке).
3. Используя приёмы метапрограммирования сформировать корректное дерево на этапе компиляции.
Может показаться, что первый и второй пункты добавлены для количества, однако признаюсь, что действительно первоначальной идеей было оставить все как есть и формировать узлы вручную.
Формирование структуры дерева в compile-time
--------------------------------------------
Используемое в качестве примера бинарное дерево поиска с учетом изначально известного набора ключей несложно построить следующим алгоритмом:
1. Корень дерева - это медианный элемент массива ключей.
2. Левый потомок - это дерево из элементов левее медианного, правый - правее.
В рамках реализации автоматического построения дерева структура узла разделилась на 2 части:
```
/// Базовая структура (ключ-значение)
template
struct Node
{
static constexpr auto Key = \_Key;
static constexpr unsigned Value = \_Value;
};
/// Расширенный узел (с потомками)
template
struct ExtendedNode
{
static constexpr auto Key = \_BaseNode::Key;
static constexpr auto Value = \_BaseNode::Value;
using Left = \_Left;
using Right = \_Right;
static auto Search(unsigned key)
{
return key == Key
? Value
: key < Key
? Left::Search(key)
: Right::Search(key);
}
};
```
Пользователь объявляет необходимое количество базовых узлов, а специальный класс формирует из них по предложенному выше алгоритму дерево:
```
/// Компаратор узлов для их сортировки
template
struct NodesComparator
{
static const bool value = LeftNode::Key > RightNode::Key;
};
/// Формирование узла
template
struct MakeNode
{
/// Сортировка узлов по ключам
using SortedNodes = typename TypeListSort::type;
static const int size = Length::value;
/// Корень - медианный элемент, потомки формируются рекурсивно
using type = ExtendedNode<
typename GetType::type,
typename MakeNode::type>::type,
typename MakeNode::type>::type
>;
};
/// Дно рекурсии
template<>
struct MakeNode>
{
using type = NullNode;
};
```
В коде выше использованы вспомогательные элементы из состава шаблонных утилит:
1. **TypeListSort** - сортировка списка типов по предикату.
2. **GetType** - получение типа из списка типов по его индексу.
3. **Slice** - выбор среза из списка типов.
Для конечного пользователя формирование дерева выглядит так:
```
/// Объявить базовые узлы
using N1 = Node<5, 105>;
using N2 = Node<10, 110>;
using N3 = Node<20, 120>;
/// Объявить список узлов (не обязательно упорядочивать)
using nodes = TypeList;
/// Сформировать дерево
using Tree = BST::type>;
/// Поиск по дереву: Tree::Search(Value);
```
Результаты
----------
Предложенный подход проверен на компиляторе GCC для ARM, эксперименты с количеством узлов показали, что каждый узел дерева требует ~10 байтов ROM и ни одного байта RAM! (автор программирует под микроконтроллеры исключительно как любитель, но оперативная память, как правило, расходуется быстрее ROM).
С точки зрения быстродействия программа также позволяет предположить максимальную скорость, поскольку поиск представляет собой последовательность конструкций *if-else*, фрагмент дизассемблированной версии программы приведен на рисунке 1, а более понятная декомпилированная версия – на рисунке 2.
Рисунок 1. Дизассемблированный метод поиска.Рисунок 2. Декомпилированная версия метода поиска.Таким образом, если все элементы структуры данных известны на этапе компиляции, язык C++ позволяет существенно сэкономить ресурсы системы, объем занимаемой памяти сократился примерно в **1.6 раза**, причем вся структура данных переместилась из RAM-памяти в ROM, что также можно считать позитивным результатом. Скорость поиска по сравнению с классической реализацией даже ускорится (честно признаюсь, не проверял, но смею заявить это на основании результатов дизассемблирования), так как переход по ветвям представляет собой просто последовательность условий.
Применимы ли полученные результаты на практике - вопрос для автора нерешенный. Как уже упоминалось под катом в начале, есть желание таким же образом реализовать префиксное дерево. Получится или нет - пока неизвестно. Однако сам эксперимент бы весьма интересным, позволил попрактиковаться в программировании на C++ и получить интересные результаты хотя бы в цифрах. | https://habr.com/ru/post/645363/ | null | ru | null |
# JavaScript Augmented Reality — тест JSARToolkit
[JSARToolkit](https://github.com/kig/JSARToolKit) это JavaScript библиотека, портированная с FLARToolkit (Flash) и предназначенная для отслеживания AR Маркеров на видео. ARToolKit преобразует данные из маркеров в 3D-координаты, используя их можно наложить изображения или 3D-объекты на плоскую поверхность.
Вы уже наверно видели JSARToolkit в действии на демке [Ilmari Heikkinen](http://fhtr.org/) — [Remixing Reality](https://mozillademos.org/demos/remixingreality/demo.html).
Демо Ilmari это часть Мозилловской “[Web O’ Wonder](https://demos.mozilla.org/en-US/)”, — сайт, демонстрирующий новые технологии, которые будут добавлены в [Firefox 4](http://www.mozilla.com/en-US/firefox/RC/).
#### Исследования HTML5 клипов
Заказчик поставил нам задачу — оценить возможность использования JSARToolkit для онлайн HTML5 клипов. (Нас попросили рассмотреть только тех пользователей, которые использовали последнюю версию Firefox и Chrome)
Вот некоторые из вопросов, на которые мы бы хотели ответить:
— Будет ли обработка быстрой на медленных компьютерах?
— Сколько AR Маркеров мы можем отследить одновременно?
— На сколько быстро можно двигать маркер, чтобы он стал не отслеживаемым?
— Какое наибольшее расстояние на котором камера может отследить маркер?
Ответы на эти вопросы, исходный код и демки можно найти ниже.
#### Запись видео
 Для записи тестового видео я использовал Flip Ultra HD. Качество видео Flip Ultra HD приемлемое, учитывая то, что это не профессиональная камера. Мы знали что ничего хорошего с такой камеры мы не получим, но этого было достаточно для теста. Основная проблема такой низкокачественной камерой — неспособность переключать скорость затвора.
Это означало, что мы ничего не сможем поделать с размытыми AR Метками если мы будем двигаться слишком быстро. Мы были удивлены на сколько быстро мы теряем маркер, кода мы двигаемся из стороны в сторону.
Тем не менее, мы уверены, что при съемке в хорошо освещенной студии с использованием камеры с высокой скоростью затвора будет очень мало не читаемых AR Меток.
#### Печать AR Маркеров
 Я напечатал несколько маркеров, которые шли вместе с JSARToolkit и начал снимать тестовые кадры на кухне. Я даже и не ожидал, что все заработает с первого раза, каждое видео, добавленное в библиотеку оказалось рабочим.
Некоторые результаты были не качественные, но я хочу повторить, что качество нашей камеры было плохим по сравнению с профессиональными. Мы снимали видео без фокусировки на отдельных маркерах, что могло бы добавить точность их отслеживания.
#### Перекодирование видео в VP8 WebM
 Мы записывали видео в формате H.264 Mpeg. Чтобы все работало с HTML5 video мы должны были сконвертировать видео в WebM. Первый декодер видео, который я попробовал был Ffmpeg2Theora, судя по названию он должен был кодировать видео в WebM. Однако я понял, что с Ffmpeg2Theora есть проблемы. Когда я кодировал видео под Linux оно могло не проигрываться в Windows и наоборот.
После тестов прочих кодировщиков я остановился на Miro Video Converter. К сожалению Miro не умеет обрабатывать несколько видео, но видео, которое он производит работает на всех ОС и браузерах.
#### Создание обертки
Я хотел написать простое API на основе JSARToolkit, которое можно было использовать повторно. Что-нибудь что я бы мог подключить к другой JavaScript библиотеке, например Popcorn.js. Код, который я нашел в демке Ilmari был специфичный для конкретной задачи. Так как код не изобиловал комментариями, у меня были проблемы с пониманием, что происходит. Пришлось экспериментировать. Я пришел к простому способу написания обертки для JSARToolkit.
Первый шаг в использовании обертки JSARToolkit — установка вашего трекера. Пример как это можно сделать:
```
// Пример создания трекера со всеми возможными опциями
var myTracker = jsartoolkit.tracker({
src : 'my-video.webm', // Исходник для видео
autoplay : true, // Стоит ли включить видео сразу
repeat : true, // Включить повтор
volume : 0, // Звук из видео
target : doc.getElementById('DOMTarget'), // DOM element в который будет добавлен canvas
width : 720, // Ширина кадра
height : 360, // Высота кадра
threshold : 100, // Настройка освещенности кадра
ratio : 0.5, // Настройка размера скрытого canvas для трекинга (1 = 1в1 как видео)
debug : false // Выводить ли отладочную информацию - для порога освещенности кадра
});
```
Как только трекер был создан, следующим шагом стало добавления контента маркерам.
Мы добавили статическое изображение, а затем и 3D объект, экспортированный из Blender3D:
```
// Добавления картинки первому маркеру
myTracker.marker(0).image('my-image_01.png');
// Добавление модели Blender3D
myTracker.marker(2).model('HTML5_Logo001');
```
Этот пример показывает как обновить свойства маркера после того как он был создан:
```
// Настройка свойств маркера 0
myTracker.marker(0)
.scale(1)
.axis(0, 0, 1)
.angle(0)
.position(0,0,0)
;
```
Вы также можете добавить более сложное поведение, используя JSARToolkit-Wrapper. Следующий пример демонстрирует как обновить свойства маркера в реальном времени. Этот код заставляет первый маркер крутиться и пульсировать:
```
// Анимация свойств маркера Marker_0 по таймеру
var interval = global.setInterval( function(){
var date = + new Date(),
scl = 1.5 + (Math.sin( date/200 ) * 0.5),
axs = Math.cos( date/300 ),
posX = Math.sin( date/300 ),
posY = Math.cos( date/300 )
;
myTracker.marker(0)
.scale(scl)
.axis(0, axs, 0)
.position(posY, posX, 0)
.angle(date / 230)
;
}, 20);
```
Для доступа к видео трекера вы можете сделать что-то такое:
```
// Доступ к видео элементу трекера и установка currentTime
myTracker.video.currentTime = 1;
```
#### Ответы на вопросы
**Будет ли обработка быстрой на медленных компьютерах?**
Обработка видео и определение положения маркера очень быстрое. Я практически не заметил разницы в отслеживании 1 маркера и 100 маркеров. Основная нагрузка — наложение контента на видео.
**Сколько AR-Маркеров мы можем отследить одновременно?**
Я отслеживал 100 маркеров одновременно без каких-либо проблем.
**На сколько быстро можно двигать маркер, чтобы он стал не отслеживаемым?**
Все зависит от вашей камеры и как вы снимаете. Если использовать камеру с высокой скоростью затвора, такие, которые используются для записи спортивных состязаний, то мы получим минимум размытых маркеров (если вообще получим) и они будут отслеживаться очень хорошо.
**Какое наибольшее расстояние на котором камера может отследить маркер?**
Опять все зависит от нескольких факторов — от скорости перемещения камеры/объектов и от освещения. В хорошо освещенной комнате (не профессиональной студии). У меня получилось отслеживать Маркеры с 10 метров в направлении объектива в разрешении 720р. Чем выше разрешение камеры, тем выше качество отслеживания маркеров. Одну вещь которую стоит отметить: вы можете снимать ваше видео в разрешении 1080, кэшировать результаты трекинга и уменьшить число обработок на стороне клиента. Можно покрутить ratio если что-то плохо отслеживается или threshold если кадр был плохо освещен.
#### Заключение
##### Плюсы
— Легко внедрить
— Оптимальный алгоритм отслеживания, не нагружает процессор
— Можно отслеживать по крайней мере 100 маркеров
— Можно экспортировать напрямую с Blender3D
— Можно накладывать любой контент: картинки, видео, 3D объекты
##### Минусы
— Слишком много глобальных переменных в коде исходной библиотеки
— Необходимо немного подкрутить экспорт из Blender3D
— Не поддерживается одновременная обработка нескольких видео
— Слишком много затратных вызовов getElementById()
Необходимо поделать большую работу если вы хотите использовать эту библиотеку на продкшене или сделать её частью большой библиотеки. Но после огромного числа тестов и экспериментов, я скажу, что этот код работает потрясающе!
#### Примеры, Тесты и ссылки
[JSARToolkit-Wrapper Demo](http://code.bocoup.com/webgl/JSARToolkit-Wrapper/JSARToolkit-Wrapper_Demo.html)
[JSARToolkit Video Tests](http://code.bocoup.com/webgl/JSARToolkit-Wrapper/video-tracking-tests)
[JSARToolkit Marker Images](http://code.bocoup.com/webgl/JSARToolkit-Wrapper/marker-images)
[JSARToolkit-Wrapper on Github](https://github.com/Bocoup/JSARToolkit-Wrapper)
Для просмотра вам необходима последняя версия Firefox 4 или Chrome.
#### От переводчика
Автор к сожалению пока не выложил демку. Применение AR в таком виде в котором он представлен в переводе не очень широкое, но с появлением [HTML5 Device Element](http://habrahabr.ru/blogs/html5/113547/) ([ещё статья](http://ajaxian.com/archives/video-conferencing-with-the-html5-device-element)) все может измениться.
AR Скоро и в вашем браузере ;) | https://habr.com/ru/post/115485/ | null | ru | null |
# Любите квесты, любите и свои персональные данные в паблике находить
Несколько дней назад со мной произошло ровно то, что написано в заголовке. В далеком 2014 году (а именно 28 декабря в 17:00) мы с женой и друзьями играли в перформанс-квест «Коллекционер» от «Клаустрафобии» и уже давно про это забыли, но «Клаустрафобия» напомнила о себе самым неожиданным образом.
*А собственно вот и наша фотография, которая нашлась в открытом доступе (я спиной, остальные лица искажены для этой статьи)…*
> Дисклеймер: вся информация ниже публикуется исключительно в образовательных целях. Автор не получал доступа к персональным данным третьих лиц и компаний. Информация взята либо из открытых источников, либо была предоставлена автору анонимными доброжелателями.
База данных Elasticsearch с двумя индексами, предположительно принадлежащая «Клаустрафобии» (claustrophobia.com), была найдена в открытом доступе.
```
index docs.count store.size
phobia-master 1068927 3.2gb
phobia-sandbox 55 2.9mb
```
Кто угодно, зная IP-адрес, мог беспрепятственно получить доступ к данным через обычный браузер, используя базовый [язык запросов Elasticsearch](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-uri-request.html).
Судя по данным поисковика Shodan, база впервые была обнаружена 03.02.2019 03:09:00. Доступ к ней был закрыт 31.03.2019, после моего уведомления (по электронной почте и через Facebook), в промежутке между 12:00 и 16:30 (МСК).
Всего Shodan фиксировал эту базу 6 раз:
```
03.02.2019 03:09:00
03.02.2019 19:39:00
01.03.2019 12:10:00
03.03.2019 19:55:00
09.03.2019 05:41:00
23.03.2019 13:07:00
```
Про то, [как обнаруживают открытые базы данных](https://www.devicelock.com/ru/blog/obnaruzhenie-otkrytyh-baz-dannyh-mongodb-i-elasticsearch.html) Elasticsearch, я писал отдельную статью.
В базе содержались данные (всего чуть более 1 млн. записей) по заказам:
* Дата заказа
* Дата и время квеста
* Название квеста
* Место (страна и город) квеста
* Имя, телефон и адрес электронной почты человека, делавшего заказ
* Стоимость (включая предоплату, скидки и промокоды), валюта платежа и тип оплаты (наличные, карта)
* Время прохождения квеста
* Количество игроков
* Ссылка на совместную фотографию участников квеста
Информация, за период с 2013 по 2019 гг., была из разных стран:
* Россия
* Украина
* Белоруссия
* Эстония
* Германия
* Испания
* Франция
* Голландия
* Италия
* и т.д.
Например, по Германии нашлось более 10 тыс. записей.
"Наш" квест 2014 года выглядел так:
```
{
"_index": "phobia-master",
"_type": "model-Game",
"_id": "105352",
"_score": 10.159659,
"_source": {
"comment": "",
"suspicious_cancellation": false,
"promo_code": "",
"photo": "https://.../.../.../28.12-17.jpg",
"book_source": {
"ru": "Сайт",
"fr": "Site internet",
"en": "Web-site",
"nl": "Сайт",
"be": "Сайт",
"tr": "Сайт",
"ca": "Página web",
"de": "Internetseite",
"db": "site",
"it": "Сайт",
"sk": "Сайт",
"ar": "Сайт",
"th": "Сайт",
"sl": "Сайт",
"cs": "Сайт",
"et": "Lehekülg",
"az": "Sayt",
"ua": "Сайт",
"es": "Página web"
},
"client_tickets_count": null,
"currency": "₽",
"result": null,
"language_code": null,
"owner": {
"phone": "+7…",
"nickname": "А… Л…",
"id": 38284,
"profile_type": "everyone",
"email": "…@gmail.com"
},
"id": 105352,
"refused_to_photo": null,
"not_completed": null,
"confirmed": false,
"extra_price": 0,
"branded_photo": null,
"booking_price": 12000,
"call_center_comment": null,
"cert_id": 0,
"status": {
"ru": "Пройдена",
"fr": "Réussi",
"en": "Completed",
"nl": "Пройдена",
"be": "Пройдена",
"tr": "Пройдена",
"ca": "Сompletat",
"de": "Absolviert",
"db": "completed",
"it": "Пройдена",
"sk": "Пройдена",
"ar": "Пройдена",
"th": "Пройдена",
"sl": "Пройдена",
"cs": "Пройдена",
"et": "Läbitud",
"az": "Keçilmişdir",
"ua": "Пройдена",
"es": "Completado"
},
"booked_by": null,
"investigated": "no",
"brand_logo": {
"ru": "",
"fr": "",
"en": "",
"nl": "",
"be": "",
"db": null,
"ca": "",
"de": "",
"tr": "",
"it": "",
"sk": "",
"ar": "",
"th": "",
"sl": "",
"cs": "",
"et": "",
"az": "",
"ua": "",
"es": ""
},
"gamers_count": 4,
"tickets_count": 0,
"partial_prepay": true,
"payment": {
"ru": "онлайн",
"fr": "en ligne ",
"en": "online",
"nl": "online",
"be": "онлайн",
"tr": "Online",
"ca": "Online ",
"de": "Online-Zahlung",
"db": "online",
"it": "online",
"sk": "online",
"ar": "دفع الكتروني",
"th": "ออนไลน์",
"sl": "онлайн",
"cs": "онлайн",
"et": "Online",
"az": "onlayn",
"ua": "онлайн",
"es": "Online"
},
"promocode_type": null,
"lacking_sum_paid": false,
"prepay_price": 3000,
"booking_time_local": "28.12.2014 12:36",
"hints_count": null,
"booking_id": "PER 14 54 814",
"booking_time": "2014-12-28T09:36:13+00:00",
"timeslot": {
"start": "2014-12-28T14:00:00+00:00",
"price": 6000,
"start_local_date": "28 декабря",
"id": 95759,
"caption": "Коллекционер: 28.12.2014, 17:00",
"es_start_local_date": "2014-12-28",
"quest": {
"rating_positions": [
486,
486
],
"id": 108,
"name": {
"ru": "Коллекционер",
"fr": "",
"en": "The Collector",
"nl": "",
"be": "",
"db": "Коллекционер",
"ca": "",
"de": "",
"tr": "",
"it": "",
"sk": "",
"ar": "",
"th": "",
"sl": "",
"cs": "",
"et": "",
"az": null,
"ua": "",
"es": ""
},
"location": {
"city": {
"timezone": "Europe/Moscow",
"country": {
"iso_code": "ru",
"id": 1,
"name": {
"ru": "Россия",
"fr": "",
"en": "Russia",
"nl": "Rusland",
"be": "",
"db": "Россия",
"ca": "",
"de": "Russland",
"tr": "",
"it": "",
"sk": "",
"ar": "",
"th": "",
"sl": "",
"cs": "",
"et": "",
"az": null,
"ua": "",
"es": ""
}
},
"id": 1,
"name": {
"ru": "Москва",
"fr": "",
"en": "Moscow",
"nl": "",
"be": "",
"db": "Москва",
"ca": "",
"de": "Moskau",
"tr": "",
"it": "",
"sk": "",
"ar": "",
"th": "",
"sl": "",
"cs": "",
"et": "",
"az": "",
"ua": "Москва",
"es": ""
}
},
"id": 55,
"name": {
"ru": "Поварская",
"fr": "",
"en": "",
"nl": "",
"be": "",
"db": "Поварская",
"ca": "",
"de": "",
"tr": "",
"it": "",
"sk": "",
"ar": "",
"th": "",
"sl": "",
"cs": "",
"et": "",
"az": null,
"ua": "",
"es": ""
}
}
},
"prices_by_tickets_count": null,
"start_local_dt": "2014-12-28T17:00:00+03:00",
"start_local": "28.12.2014, 17:00"
},
"cancellation_reason": null,
"cancellation": {
"ru": "нет",
"fr": "non",
"en": "no",
"nl": "nee",
"be": "нет",
"tr": "hayır",
"ca": "No",
"de": "nein",
"db": "no",
"it": "no",
"sk": "nie",
"ar": "لا",
"th": "ไม่",
"sl": "нет",
"cs": "нет",
"et": "pole",
"az": "нет",
"ua": "немає",
"es": "no"
}
}
}
```
К чести «Клаустрафобии» надо сказать, что они оказались в числе того незначительного количества компаний, которые отвечают на сообщения о потенциальной утечке данных и благодарят исследователей:
> Добрый день! Пишу вам из известной уже вам компании Клаустрофобия. Мы получили ваше сообщение в Фейсбуке по поводу риска утечки данных, за что отдельно хочу вас поблагодарить! В знак благодарности приглашаем вас стать одним из тестировщиков наших будущих игр. Если вы согласны, то пришлите мне, пожалуйста, ваши контактные данные: email и телефон. Мы пригласим вас, когда будут проводиться тесты! Еще раз благодарим за вашу помощь ;)
Новости про утечки информации и инсайдеров всегда можно найти на моем Telegram-канале «[Утечки информации](http://tele.click/dataleak)». | https://habr.com/ru/post/446372/ | null | ru | null |
# MicroProfile и его экосистема
Совсем недавно вышла новая версия MicroProfile - [4.1](https://github.com/eclipse/microprofile/releases/tag/4.1). Я бы хотел рассказать, что вообще такое MicroProfile, для чего он применяется, из каких компонентов состоит и чем привлекает к себе разработчиков. В этой статье я покажу несколько примеров того, как он может использоваться на практике на примере работы с Quarkus, фреймворком, который является одной из множества реализаций спецификаций MicroProfile.
Что такое MicroProfile?
-----------------------
Так что же это всё-таки такое и какие проблемы на самом деле решает? Некторое время назад глядя на медленное развитие Java EE, несколько лидеров отрасли собрались вместе, чтобы обсудить дальнейшие пути развития этой технологии в сфере энтерпрайз разработки. 14 июня 2016 года IBM, Red Hat, Payara, LJC, Tomitribe и другие независимые компании основали сообщество MicroProfile и зарегистрировали домен <https://microprofile.io>. 27 июня 2016 года на презентации DevNation в Сан-Франциско, Калифорния, было официально объявлено о создании MicroProfile.
В экосистеме Java уже существует множество «микросервисных» платформ, фреймворков и решений из мира энтерпрайз. Эти проекты предоставляют возможности для работы с микросервисными архитектурами с использованием Jakarta EE / Java EE и других технологий. Целью проекта MicroProfile является создание новых общих API и специфкаций функций, которые будут приняты сообществом. Также одной из целей является скорость развитие этих общих API и специфкаций в ногу с современными подходами к разработке микросервисных приложений. MicroProfile в основном предоставляет согласованную спецификацию API, которой может следовать любой проект, реализовать её и продвигать на рынке.
По сути, MicroProfile это просто набор спецификаций для создания микросервисов. В данный момент он включает в себя 13 спецификаций
Реализации
----------
В настоящее время существуют следующие реализации MicroProfile от разных поставщиков:
* [KumuluzEE](https://ee.kumuluz.com/)
* [Open Liberty](https://openliberty.io/)
* [Wildfly](https://www.wildfly.org/)
* [Payara Micro](https://www.payara.fish/)
* [Helidon](https://helidon.io/)
* [Quarkus](https://quarkus.io/)
Кто-то может спросить, почему, например, здесь не был упомянут Micronaut? Micronaut также поддерживает шаблоны Retry, Fallback и Circuit Breaker, но больше полагается на реализации аспектно-ориентированного программирования и избегает использования механизма рефлексии для решения своих задач, а также Micronaut использует собственные подходы, вдохновленные другими фреймворками, такими как Spring.
Eclipse MicroProfile Starter
----------------------------
Каждая версия MicroProfile предлагает набор спецификаций и реализуется несколькими вендоами. Различные спецификации могут быть созданы с помощью так называемого стартера MicroProfile - <https://start.microprofile.io>. MicroProfile Starter помогает разработчикам начать процесс разработки микросервисов, выбирая наиболее удобную реализацию из списка доступных для выбранной версии MicroProfile. Это означает, что вы можете выбрать реализацию от любого вендора и посмотреть, какая версия, совместимая с MicroProfile, доступна вместе со спецификациями, которые вы хотите использовать для своего приложения. Для примера на изображении ниже я выбрал несколько, чтобы продемонстрировать, что будет предоставлено для различных спецификаций. Все они выбраны с Quarkus как конкретной реализацией поставщика.
Далее я рассмотрю некоторые из специйикаций MicroProfile.
Microprofile Fault Tolerance
----------------------------
<https://github.com/eclipse/microprofile-fault-tolerance>
Для обеспечения отказоустойчивости ваших сервисов Microprofile предоставляет спецификацию Microprofile Fault Tolerance, которая предоставляет такие возможности как @Retry, @Timeout, @Fallback и @CircuitBreaker. Существует множество вариантов для конфигурации отказоустойчивости сервиса и того, как это всё может быть применено. Ниже приведён небольшой пример кода:
```
package com.dvddhln.demo.microprofile.with.quarkus.resilient;
import org.eclipse.microprofile.faulttolerance.Fallback;
import org.eclipse.microprofile.faulttolerance.Timeout;
import javax.enterprise.context.ApplicationScoped;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
@Path("/resilience")
@ApplicationScoped
public class ResilienceController {
@Fallback(fallbackMethod = "fallback") // better use FallbackHandler
@Timeout(500)
@GET
public String checkTimeout() {
try {
Thread.sleep(700L);
} catch (InterruptedException e) {
//
}
return "Never from normal processing";
}
public String fallback() {
return "Fallback answer due to timeout";
}
}
```
Microprofile Metrics
--------------------
<https://github.com/eclipse/microprofile-metrics>
Эта спецификация создана для унифицированного способа предоставления различных телеметрических данных сервисами на базе Microprofile. Microprofile Metrics предоставляет способ регистрации метрик, специфичных для приложения, которые впоследствии могут быть отправлены, например, в Promethus. Ниже приведён небольшой пример использования:
```
package com.dvddhln.demo.microprofile.with.quarkus.metric;
import org.eclipse.microprofile.metrics.Counter;
import org.eclipse.microprofile.metrics.MetricUnits;
import org.eclipse.microprofile.metrics.annotation.Gauge;
import org.eclipse.microprofile.metrics.annotation.Metric;
import org.eclipse.microprofile.metrics.annotation.Timed;
import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import java.util.Random;
@Path("/metric")
@ApplicationScoped //Required for @Gauge
public class MetricController {
@Inject
@Metric(name = "endpoint_counter")
// https://quarkus.io/guides/cdi-reference#private-members
// - private Counter counter;
Counter counter;
@Path("timed")
@Timed(name = "timed-request")
@GET
public String timedRequest() {
// Demo, not production style
int wait = new Random().nextInt(1000);
try {
Thread.sleep(wait);
} catch (InterruptedException e) {
// Demo
e.printStackTrace();
}
return "Request is used in statistics, check with the Metrics call.";
}
@Path("increment")
@GET
public long doIncrement() {
counter.inc();
return counter.getCount();
}
@Gauge(name = "counter_gauge", unit = MetricUnits.NONE)
private long getCustomerCount() {
return counter.getCount();
}
}
```
Microprofile Open API
---------------------
<https://github.com/eclipse/microprofile-open-api>
Эта спецификация MicroProfile нацелена на предоставление унифицированного Java API для документирования ваших сервисов по спецификации OpenAPI v3. Вот небольшой пример использования этого:
```
package com.dvddhln.demo.microprofile.with.quarkus.openapi;
import org.eclipse.microprofile.openapi.annotations.OpenAPIDefinition;
import org.eclipse.microprofile.openapi.annotations.info.Info;
import org.eclipse.microprofile.openapi.annotations.media.Content;
import org.eclipse.microprofile.openapi.annotations.media.Schema;
import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
import org.eclipse.microprofile.openapi.annotations.responses.APIResponses;
import javax.enterprise.context.ApplicationScoped;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
@Path("/booking")
@ApplicationScoped
@OpenAPIDefinition(info = @Info(title = "Booking endpoint", version = "1.0"))
public class BookingController {
@APIResponses(value = {
@APIResponse(
responseCode = "200",
description = "Booking for id",
content = @Content(
mediaType = MediaType.APPLICATION_JSON,
schema = @Schema(ref = "Booking"))
),
@APIResponse(
responseCode = "404",
description = "No booking found for the id.")
})
@GET
@Produces(MediaType.APPLICATION_JSON)
@Path("{bookingId}")
public Response getBooking(@PathParam("bookingId") String bookingId) {
return Response
.status(Response.Status.OK)
.entity(Booking.booking(bookingId, Destination.destination("New Rearendia", "Wheeli")))
.build();
}
}
```
Microprofile Health
-------------------
<https://github.com/eclipse/microprofile-health>
Эта спецификация предоставляет возможность проверки работоспособности и исправности вашего сервиса. Для этого используется две аннотации:
* для проверки готовности сервиса используется аннотация @Readiness;
* для проверки того, что сервис жив, используется аннотация @Liveness.
```
package com.dvddhln.demo.microprofile.with.quarkus.health;
import org.eclipse.microprofile.health.HealthCheck;
import org.eclipse.microprofile.health.HealthCheckResponse;
import org.eclipse.microprofile.health.Liveness;
import javax.enterprise.context.ApplicationScoped;
@Liveness
@ApplicationScoped
public class ServiceLiveHealthCheck implements HealthCheck {
@Override
public HealthCheckResponse call() {
return HealthCheckResponse.named(ServiceLiveHealthCheck.class.getSimpleName())
.withData("live", true)
.up()
.build();
}
}
```
Стоит отметать, что компоненты проверки работоспособности сервиса являются компонентами CDI, поэтому их также можно определить с помощью CDI продюсеров. Таким образом, приведенный выше пример может выглядеть примерно так:
```
@ApplicationScoped
class MyChecks {
@Produces
@Liveness
HealthCheck check1() {
return () -> HealthCheckResponse.named("heap-memory").status(getMemUsage() < 0.9).build();
}
@Produces
@Readiness
HealthCheck check2() {
return () -> HealthCheckResponse.named("cpu-usage").status(getCpuUsage() < 0.9).build();
}
@Produces
@Startup
HealthCheck check3() {
return () -> HealthCheckResponse.named("initial-heap-memory").status(getMemUsage() < 0.95).build();
}
}
```
Для самой простой проверки работоспособности и готовности сервиса обе проверки могут помечать один и тот же класс:
```
@ApplicationScoped
@Liveness
@Readiness
public class MyCheck implements HealthCheck {
public HealthCheckResponse call() {
[...]
}
}
```
Microprofile Rest Client
------------------------
<https://github.com/eclipse/microprofile-rest-client>
REST клиент MicroProfile обеспечивает типобезопасный подход для вызова RESTful сервисов через HTTP. Насколько это возможно, клиент пытается использовать Jakarta RESTful Web Services 2.1 для обеспечения согласованности и упрощения повторного использования. Вот небольшой пример:
```
package com.dvddhln.demo.microprofile.with.quarkus.client;
import org.eclipse.microprofile.rest.client.inject.RegisterRestClient;
import javax.enterprise.context.ApplicationScoped;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
@RegisterRestClient
@ApplicationScoped
public interface Service {
@GET
@Path("/{parameter}")
String doSomething(@PathParam("parameter") String parameter);
}
```
Microprofile Config
-------------------
<https://github.com/eclipse/microprofile-config>
MicroProfile Config использует внедрение контекстов и зависимостей (CDI) для внедрения значений свойств конфигурации непосредственно в приложение не требуя написания дополнительного пользовательского кода для их извлечения. Значения конфигурации определяются как статические, поскольку они устанавливаются только при запуске приложения. Microprofile Config позволяет объединяет значения конфигурации из нескольких источников, каждый из которых объявлен как ConfigSource. Каждый ConfigSource имеет определенный приоритет, определяемый его порядковым номером. Более высокий порядковый номер означает, что значения, взятые из этого ConfigSource, переопределят значения из ConfigSources с более низким порядковым номером. Ниже приведён небольшой пример использования Microprofile Config:
```
package com.dvddhln.demo.microprofile.with.quarkus.config;
import org.eclipse.microprofile.config.Config;
import org.eclipse.microprofile.config.ConfigProvider;
import org.eclipse.microprofile.config.inject.ConfigProperty;
import javax.enterprise.context.RequestScoped;
import javax.inject.Inject;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
@Path("/config")
@RequestScoped
public class ConfigTestController {
@Inject
@ConfigProperty(name = "injected.value")
// https://quarkus.io/guides/cdi-reference#private-members
// - private String injectedValue;
String injectedValue;
@Path("/injected")
@GET
public String getInjectedConfigValue() {
return "Config value as Injected by CDI " + injectedValue;
}
@Path("/lookup")
@GET
public String getLookupConfigValue() {
Config config = ConfigProvider.getConfig();
String value = config.getValue("value", String.class);
return "Config value from ConfigProvider " + value;
}
}
```
Заключение
----------
В этой статье были обзорно рассмотрены некоторые из спецификаций, которые предоставляются Microprofile. Если вам интересна эта тема а также тема реализаций этих спецификаций, я приглашаю вас присоединяться к [моему телеграм-каналу о Quarkus](https://t.me/quarkusnews), где можно найти дополнительную информацию по этой теме и конечно же узнать гораздо больше о Quarkus как одной из реализаций Microprofile. | https://habr.com/ru/post/574958/ | null | ru | null |
# Интеграция библиотеки на Swift в UE4
Недавно возникла задача интеграции кода, который был написан только на Swift в проект на UE4. При этом вариант "давайте быстренько перепишем все на Objective C" не рассматривался. Готового решения нигде не нашел, пришлось, как это часто бывает, копать и вширь и вглубь. Задача была успешно решена и чтобы помочь кому-то еще, решил написать туториал.
Обычно, если нужно интегрировать какой-либо специфичный для iOS/macOS платформы код, используется сборка библиотеки в виде Framework, который должен быть статический. Сам же код пишется на Objective C. Далее, зависимость прописывается в скрипте сборки проекта `MyProject.Build.cs`, например, так:
```
if (Target.Platform == UnrealTargetPlatform.IOS)
{
string ExtraPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "../ThirdParty"));
PublicAdditionalFrameworks.Add(
new Framework(
"MyFramework",
ExtraPath + "/" + "MyFramework.framework.zip"
)
);
}
```
Для Swift можно попробовать пойти этим же путем, но возникнет проблема — зависимость от некоторых библиотек языка. Предупреждение при линковке будет выглядеть так:
```
ld: warning: Could not find auto-linked library 'swiftFoundation'
ld: warning: Could not find auto-linked library 'swiftDarwin'
ld: warning: Could not find auto-linked library 'swiftCoreFoundation'
ld: warning: Could not find auto-linked library 'swiftCore'
ld: warning: Could not find auto-linked library 'swiftCoreGraphics'
ld: warning: Could not find auto-linked library 'swiftObjectiveC'
ld: warning: Could not find auto-linked library 'swiftDispatch'
ld: warning: Could not find auto-linked library 'swiftSwiftOnoneSupport'
```
После чего последуют стандартные ошибки о том что не найдены некоторые символы в объектных файлах. Можно попробовать найти где находится каждая библиотека, упомянутая выше, и указать путь к ней через ключ L, но я решил перейти на динамический тип Framework, который сам подгрузит эти библиотеки.
Сборка проект пройдет нормально, однако при запуске приложение будет падать со знакомой iOS разработчикам ошибкой:
```
dyld: Library not loaded: @rpath/MyFramework.framework/MyFramework
Referenced from: /private/var/mobile/Containers/Bundle/Application/.../MyApp.app/MyApp
Reason: image not found
```
Это связано с тем, что UE4 не умеет работать с динамическим типом Framework, и не копирует его при создании пакета приложения. Это можно было бы решить путем изменения кода IOS Toolchain и сборкой своей версии движка, но хотелось всего этого избежать и на помощь пришел IOSPlugin.
Это расширение обычно используется для модификации `plist` файла приложения, например, добавления описания для прав доступа:
```
NSCameraUsageDescription
The camera is used for live preview.
```
Нам же пригодится элемент `copyDir`. Он позволяет задать путь к директории, которую мы хотим скопировать, и место назначения:
```
```
Важно, чтобы команда копирования располагалась в блоке `init`. После этого приложение начинает работать.
Итоговый файл `MyProject.Build.cs` будет выглядеть так:
```
using UnrealBuildTool;
using System.IO;
public class MyProject : ModuleRules
{
public MyProject(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
if (Target.Platform == UnrealTargetPlatform.IOS)
{
string ExtraPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "../ThirdParty"));
PublicAdditionalFrameworks.Add(
new Framework(
"MyFramework",
ExtraPath + "/" + "MyFramework.framework.zip"
)
);
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("IOSPlugin", Path.Combine(PluginPath, "MyProject_IOS_UPL.xml"));
}
}
}
```
А файл `MyProject_IOS_UPL.xml` так:
```
xml version="1.0" encoding="utf-8"?
```
Это решение в некотором роде обходной путь, пока не появится нормальной поддержки динамического Framework в UE4, но меня оно полностью устроило. | https://habr.com/ru/post/522746/ | null | ru | null |
# Автоматизация рыбной ловли для World of Warcraft
Познакомился с World of Warcraft очень давно и люблю его весь, но одна вещь больше всего не давала мне покоя — рыбная ловля. Это нудное повторяющееся действие, где ты просто нажимаешь на кнопку рыбной ловли и тыкаешь на поплавок раз в 5-15 секунд. Мой навык разработки рос, а ситуация с рыбной ловле так и не улучшалась с каждым годом что я играл, поэтому я решил убить двух зайцев сразу — начать осваивать python и всё же сделать бота для себя.
Я уже видел ботов, которые умеют ловить рыбу, работающие в свернутом режиме не перехватывая управления над компьютером. Также я знаю насколько беспощадны близард по вопросам банов читеров. Изменение данных в оперативной памяти легко определяется встроенным античитом. Ну и последнее — на мак я не нашёл ни одного бота.
Поэтому я решил закрыть все эти вопросы разом и сделать бота, который будет перехватывать управление мыши, кидать поплавок, и тыкать на него на экране когда нужно. Как я полагал python располагает широким выбором инструментов для автоматизации таких штук, и не ошибся.
Немножечко погуглив, я нашёл [OpenCV](http://opencv.org), в котором есть поиск шаблону с [не сложным гайдом](http://docs.opencv.org/trunk/d4/dc6/tutorial_py_template_matching.html). С помощью него мы и будем искать наш поплавок на экране.
Сперва мы должны получить саму картинку с поплавком. Ищем и находим библиотеку pyscreenshot с [гайдом](https://pypi.python.org/pypi/pyscreenshot) как делать скриншоты, немножечко редактируем:
```
import pyscreenshot as ImageGrab
screen_size = None
screen_start_point = None
screen_end_point = None
# Сперва мы проверяем размер экрана и берём начальную и конечную точку для будущих скриншотов
def check_screen_size():
print "Checking screen size"
img = ImageGrab.grab()
# img.save('temp.png')
global screen_size
global screen_start_point
global screen_end_point
# я так и не смог найти упоминания о коэффициенте в методе grab с параметром bbox, но на моем макбуке коэффициент составляет 2. то есть при создании скриншота с координатами x1=100, y1=100, x2=200, y2=200), размер картинки будет 200х200 (sic!), поэтому делим на 2
coefficient = 2
screen_size = (img.size[0] / coefficient, img.size[1] / coefficient)
# берем примерно девятую часть экрана примерно посередине.
screen_start_point = (screen_size[0] * 0.35, screen_size[1] * 0.35)
screen_end_point = (screen_size[0] * 0.65, screen_size[1] * 0.65)
print ("Screen size is " + str(screen_size))
def make_screenshot():
print 'Capturing screen'
screenshot = ImageGrab.grab(bbox=(screen_start_point[0], screen_start_point[1], screen_end_point[0], screen_end_point[1]))
# сохраняем скриншот, чтобы потом скормить его в OpenCV
screenshot_name = 'var/fishing_session_' + str(int(time.time())) + '.png'
screenshot.save(screenshot_name)
return screenshot_name
def main():
check_screensize()
make_screenshot()
```
Получаем примерно следующую картинку:
Далее — найти поплавок. Для этого у нас должен быть сам шаблон поплавка, который мы ищем. После сотни попыток я всё таки подобрал те, которые OpenCV определяет лучше всего. Вот они:
Берём код из [ссылки](http://docs.opencv.org/trunk/d4/dc6/tutorial_py_template_matching.html) выше, добавляем цикл и наши шаблоны:
```
import cv2
import numpy as np
from matplotlib import pyplot as plt
def find_float(screenshot_name):
print 'Looking for a float'
for x in range(0, 7):
# загружаем шаблон
template = cv2.imread('var/fishing_float_' + str(x) + '.png', 0)
# загружаем скриншот и изменяем его на чернобелый
src_rgb = cv2.imread(screenshot_name)
src_gray = cv2.cvtColor(src_rgb, cv2.COLOR_BGR2GRAY)
# берем ширину и высоту шаблона
w, h = template.shape[::-1]
# магия OpenCV, которая и находит наш темплейт на картинке
res = cv2.matchTemplate(src_gray, template, cv2.TM_CCOEFF_NORMED)
# понижаем порог соответствия нашего шаблона с 0.8 до 0.6, ибо поплавок шатается и освещение в локациях иногда изменяет его цвета, но не советую ставить ниже, а то и рыба будет похожа на поплавок
threshold = 0.6
# numpy фильтрует наши результаты по порогу
loc = np.where( res >= threshold)
# выводим результаты на картинку
for pt in zip(*loc[::-1]):
cv2.rectangle(src_rgb, pt, (pt[0] + w, pt[1] + h), (0,0,255), 2)
# и если результаты всё же есть, то возвращаем координаты и сохраняем картинку
if loc[0].any():
print 'Found float at ' + str(x)
cv2.imwrite('var/fishing_session_' + str(int(time.time())) + '_success.png', src_rgb)
return (loc[1][0] + w / 2) / 2, (loc[0][0] + h / 2) / 2 # опять мы ведь помним, что макбук играется с разрешениями? поэтому снова приходится делить на 2
def main():
check_screensize()
img_name = make_screenshot()
find_float(img_name)
```
Итак, у нас есть координаты поплавка, двигать курсор мыши умеет [autopy](https://github.com/msanders/autopy/#readme) буквально с помощью одной строки, подставляем свои координаты:
```
import autopy
def move_mouse(place):
x,y = place[0], place[1]
print("Moving cursor to " + str(place))
autopy.mouse.smooth_move(int(screen_start_point[0]) + x , int(screen_start_point[1]) + y)
def main():
check_screensize()
img_name = make_screenshot()
cords = find_float(img_name)
move_mouse(cords)
```
Курсор на поплавке и теперь самое интересное — как же узнать когда нужно нажать? Ведь в самой игре поплавок подпрыгивает и издает звук будто что-то плюхается в воду. После тестов с поиском картинки я заметил, что OpenCV приходится подумать пол секунды прежде чем он возвращает результат, а поплавок прыгает даже быстрее и изменение картинки мы врядли сможем определить с помощью OpenCV, значит будем слушать звук. Для этой задачки мне пришлось поковырять разные решения и остановился вот над [этим](https://gist.github.com/spadgenske/9162330) — пример использования гугл апи для распознавания голоса, оттуда мы возьмём код, который считывает звук.
```
import pyaudio
import wave
import audioop
from collections import deque
import time
import math
def listen():
print 'Listening for loud sounds...'
CHUNK = 1024
FORMAT = pyaudio.paInt16
CHANNELS = 2
RATE = 18000 # битрейт звука, который мы хотим слушать
THRESHOLD = 1200 # порог интенсивности звука, если интенсивность ниже, значит звук по нашим меркам слишком тихий
SILENCE_LIMIT = 1 # длительность тишины, если мы не слышим ничего это время, то начинаем слушать заново
# открываем стрим
p = pyaudio.PyAudio()
stream = p.open(format=FORMAT,
channels=CHANNELS,
rate=RATE,
# output=True, # на мак ос нет возможности слушать output, поэтому мне пришлось прибегнуть к использованию [Soundflower](https://github.com/RogueAmoeba/Soundflower-Original), который умеет перенаправлять канал output в input, таким образом мы перехватываем звук игры будто это микрофон
input=True,
frames_per_buffer=CHUNK)
cur_data = ''
rel = RATE/CHUNK
slid_win = deque(maxlen=SILENCE_LIMIT * rel)
# начинаем слушать и по истечении 20 секунд (столько максимум длится каждый заброс поплавка), отменяем нашу слушалку.
success = False
listening_start_time = time.time()
while True:
try:
cur_data = stream.read(CHUNK)
slid_win.append(math.sqrt(abs(audioop.avg(cur_data, 4))))
if(sum([x > THRESHOLD for x in slid_win]) > 0):
print 'I heart something!'
success = True
break
if time.time() - listening_start_time > 20:
print 'I don\'t hear anything during 20 seconds!'
break
except IOError:
break
# обязательно закрываем стрим
stream.close()
p.terminate()
return success
def main():
check_screensize()
img_name = make_screenshot()
cords = find_float(img_name)
move_mouse(cords)
listen()
```
Последнее, что осталось — споймать саму рыбку, когда мы услышим звук, снова используем autopy:
```
def snatch():
print('Snatching!')
autopy.mouse.click(autopy.mouse.RIGHT_BUTTON)
def main():
check_screensize()
img_name = make_screenshot()
cords = find_float(img_name)
move_mouse(cords)
if listen():
snatch()
```
По моим тестам, что я оставлял бота рыбачить по ночам, за неделю такого абуза он сделал около 7000 бросков и ~~словил~~ поймал около 5000 рыб. Погрешность 30% вызвана тем, что иногда не получается отловить звук или найти поплавок из-за освещения или поворотов поплавка. Но результатом я доволен — впервые попробовал python, сделал бота и сэкономил себе кучу времени.
Полный код можно посмотреть [тут](https://github.com/kioltk/wow-fishipy), но очень советую не использовать для абуза фишинга, ибо автоматизация процессов игры **нарушает пользовательское соглашение** и можно получить бан.
Буду рад любым комментариям. | https://habr.com/ru/post/335580/ | null | ru | null |
# Установка, настройка и использование сканера уязвимостей chkrootkit
В предыдущей моей публикации про [сканер уязвимостей rkhunter](http://habrahabr.ru/company/first/blog/242865/) в комментариях хабрапользователем [Indexator](http://habrahabr.ru/users/indexator/) был упомянут сканер chrootkit. При схожем функционале c rkhunter, есть ряд отличий, который будет интересно рассмотреть в этой статье. Интересно также то, что совсем недавно была выпущена новая версия сканера, разработка которого казалась замороженной c 2009 года.
Chkrootkit — это сокращение от словосочетания «check rootkit» (поиск руткитов). В свою очередь руткитами называются вредоносные приложения, разработанные для скрытого проникновения на сервер и маскировки под обычные процессы или программы, с целью получения полного доступа на сервер.
Шелл-скрипт chkrootkit разработан в помощь системным администраторам для проверки системы на наличие известных руткитов. Первый же вопрос, который может возникнуть при этой информации: А почему шелл? Почему не perl или bash, как тот же rkunter? Разработчики стремились максимально унифицировать скрипт, чтобы он запускался на всех системах с шеллом. А во времена начала разработки скрипта, тот же perl был далеко не везде.
Суть поиска проста. С помощью системных инструментов типа strings и grep (если быть более точным, то в FAQ на сайте разработчика указан список используемых программ — awk, cut, echo, egrep, find, head, id, ls, netstat, ps, strings, sed, uname) chkrootkit ищет подозрительные участки кода в программах, сравнивает запущенные процессы с информацией из /proc, выявляя расхождения.
Инструмент состоит из некоторого количества модулей, отвечающие за разные методы проверки
* chkrootkit: шелл-скрипт, проверяющий системные бинарные файлы на модификацию руткитами.
* ifpromisc.c: модуль поиска интерфейсов, работающих на перехват пакетов.
* chklastlog.c: модуль, проверяющий на наличие фактов удаления записей из лог-файла lastlog.
* chkwtmp.c: аналогично предыдущему модулю, проверяет лог-файл wtmp.
* chkutmp.c: проверяет лог-файл utmp на наличие следов удаления записей.
* check\_wtmpx.c: актуально для ОС Solaris. проверяет факт удаления записей из лога wtmpx.
* chkproc.c: поиск следов известных LKM-троянов (Linux Kernel Module).
* chkdirs.c: поиск следов известных LKM-троянов (Linux Kernel Module).
* strings.c: аналог утилиты strings.
Увы, поиск фактов удаления строк из лог-файлов не гарантирован на все 100%.
На текущий момент последней версией является 0.50 от 4 июня 2014 г. Разработчики обещают работу сканера под FreeBSD начиная с 2.0 и прочих из семейства \*BSD, различными дистрибутивами Linux с ядрами от 2.2 и выше, MacOS X, Solaris и другими более экзотичными операционными системами.
В CentOS присутствует версия 0.49 в репозитариях EPEL, в портах/пакетах FreeBSD отсутствует. Для сборки последней версии потребуется установить gcc. На примере CentOS 6.x это будет выглядеть следующим образом:
Установим gcc:
```
yum install gcc
```
Скачиваем последнюю на текущий момент версию с официального ftp:
```
wget ftp://ftp.pangeia.com.br/pub/seg/pac/chkrootkit.tar.gz
```
Распаковываем:
```
tar -xzf chkrootkit.tar.gz
```
Переходим в директорию:
```
cd chkrootkit-0.50
```
Собираем модули:
```
make sense
```
Запускаем шелл-скрипт:
```
./chkrootkit
```
Проверил так же на FreeBSD 10.1 — сборка модулей и проверка прошла без проблем.
В принципе, можно не собирать модули, и тогда на проверках, где требуются дополнительные модули, будут ошибки типа:
```
Checking `ldsopreload'... can't exec ./strings-static, not tested
Checking `lkm'... not tested: can't exec
Checking `sniffer'... not tested: can't exec ./ifpromisc
Checking `wted'... not tested: can't exec ./chkwtmp
Checking `z2'... not tested: can't exec ./chklastlog
Checking `chkutmp'... not tested: can't exec ./chkutmp
```
По умолчанию происходит полная проверка системы по всем доступным тестам, список которых можно получить, выполнив скрипт с ключом ‘-l’. К сожалению, мне не удалось найти в документации описание всех тестов, которые могут быть запущены, но это можно обсудить в комментариях.
Обратите внимание, что chrootkit не делает снимок текущих файлов и не сохраняет в своей базе, как тот же rkunter.
В качестве ключей запуска можно указывать какие из тестов запускать
К примеру,
```
./chkrootkit aliens sniffer
```
произведет поиск вредоносного кода и запущенных перехватчиков трафика
Сообщения, которые могут быть выданы при сканировании
* not infected — проверка не обнаружила ничего подозрительного
* INFECTED — программа с большой вероятностью относится к руткиту
* not tested — проверка не была произведена (для этой ОС отсутствует возможность проверки, отсутствие модуля проверки, заданы параметры командной строки, отключающие эту проверку)
* not found — программа не найдена и поэтому не проверялась
* Vulnerable but disabled — вероятность того, что приложение является вредоносным велика, но в момент проверки оно было неактивным.
Для регулярной проверки системы, можно добавить выполнение сканирования chkrootkit в планировщик под пользователем root.
```
crontab -e
```
```
@daily /путь/до/chkrootkit | mail -s 'CHROOTKIT Daily Run' почтовый@ящик
```
Для ежедневного полного сканирования системы всеми доступными модулями и тестами с последующей отправкой отчета на почтовый ящик.
В ISPmanager5 это можно настроить из удобного интерфейса планировщика, который находится в разделе «Система»
Но в силу большой вероятности того, что инфицированная ОС может подменять значения при сканировании, рекомендуется запускать chkrootkit для проверки системы при загрузке сервера в режиме восстановления или с загрузочного live-образа.
В этом случае порядок действий таков:
* загрузиться с live-образа
* скачать последнюю версию chkrootkit
* скомпилировать модули
* подмонтировать разделы диска с (потенциально) инфицированной системой
* провести сканирование chkrootkit -r /mnt/
Официальный сайт проекта:<http://www.chkrootkit.org/>
PS: Желаю, чтобы на ваших системах всегда chkrootkit выдавал сообщения «nothing found» или «not infected». | https://habr.com/ru/post/243487/ | null | ru | null |
# Лечение битых файлов, закачки и докачки
В этом топике вы узнаете как:
* восстановить повреждённую закачку, даже если файла нет в торрентах и других источниках, что содержат хеш его фрагментов;
* скачать файл с докачкой, даже если она не поддерживается сервером;
* докачивать, если сервер не даёт прямых ссылок, отдавая файл с разных адресов (но отдаёт Partial Content).
Нынче наткнулся на топик «[Торрент vs. 64 кбит/с](http://habrahabr.ru/blogs/p2p/53110/)» и увидел проблему с которой сам неделю назад столкнулся.
Довольно долго, дней 10 (с перерывами), качал 3,5 Гб ISO образ на своём 100 Кбит/с. И этот самый образ повредился при скачивании. Попытался поискать это дело в торрентах и воспользоваться методом, описанным в вышеупомянутом топике — раньше я уже так восстанавливал файлы. Но файла там не оказалось (да и на ресурс откуда я скачивал он попал всего-то пару недель назад). Дабы меня не начали пинать за пиратство, сразу скажу что качал [Visual Studio 2008 Professional SP1 RUS](https://www.dreamspark.com/Products/product.aspx?productid=1) с [Dreamspark](http://www.dreamspark.com/).
Так вот, ждать ещё 10 дней не хотелось, как и производить особо много ручной работы, в результате чего родился скрипт, который и выполнил весь этот грязный процесс…
#### Идея
Требовалось минимизировать объём информации которую придётся перекачать, и собственно как-то выявить эти повреждённые кусочки. Отсюда, очевидно вытекает план действий:
* режем скачанный файл на достаточно мелкие кусочки;
* считаем хеш;
* сравнимаем с неким эталонным, выявляя «плохие»;
* скачиваем нужные куски и склеиваем.
А где же взять этот самый «правильный» хеш? Чтобы не скачивать всё целиком себе, необходимо какое-то стороннее место, куда можно скачать файл с гораздо более высокой скоростью. У меня как раз имелся доступ к площадке виртуального хостинга, в том числе и SSH — как раз то что нам нужно. Но… пространства там было совсем не 3,5 Гб, а всего 1,5 Гб. В результате пришла мысль тянуть не весь файл сразу, а по кусочкам.
#### Код
В результате всех этих измышлений родился следующий код (назовём файл [md5\_verify.php](http://narod.ru/disk/6210521000/verify_md5.php.html)).
`php<br/
$md5sum = 'md5sum.txt'; // файл где хранятся хеши
$tmp = 'chunk.tmp'; // имя временного файла для очередного кусочка
$out = 'out/'; // сюда будут сложены кусочки которые надо будет перекачать
$offset = 0; // с какого места начинаем (в байтах)
$chunk = 1048576; // размер кусочка
$size = 3760066560; // размер файла
$host = 'http://all.files.dreamspark.com';
$path = '/dl/studentdownload/7/6/3/76329869-10C4-4360-9B09-98C813F8EAFA/ru\_visual\_studio\_2008\_professional\_edition\_dvd\_x86\_x15-25526.iso';
$param = '?LCID=1033&\_\_gda\_\_={timestamp}\_{hash}';
$cookie = '\_\_sdt\_\_={another-hash-or-guid}';
$url = $host . $path . $param;
// читаем файл с хешами как массив строк
$sums = file($md5sum);
for ($i = 0, $l = sizeof($sums); $i < $l && $offset + $i \* $chunk < $size; $i++)
{
// начало и конец очередного кусочка
$start = $offset + $i \* $chunk;
$end = min($size, $offset + ($i + 1) \* $chunk) - 1;
// получаем имя и хеш кусочка из файла с хешами
list($hash, $file) = explode(' ', $sums[$i + intval($offset / $chunk)]);
$file = trim($file, "\*\r\n ");
// создаём временный файл
$fp = fopen($tmp, "w+");
// устанавливаем параметры CURL
$options = array
(
CURLOPT\_URL => $url,
CURLOPT\_HEADER => false,
CURLOPT\_COOKIE => $cookie,
CURLOPT\_RANGE => $start . '-' . $end, // вот тут указывается какой диапазон байт качать
CURLOPT\_FILE => $fp
);
$ch = curl\_init(); // инициализируем CURL
curl\_setopt\_array($ch, $options); // устанавливаем параметры
curl\_exec($ch); // скачивам
curl\_close($ch); // убиваем объект
fclose($fp); // закрываем файл
// наш локальный кусочек плохой если его хеш не совпадает с тем что мы сейчас скачали
$broken = ($hash != md5\_file($tmp));
// выводим имя файла, диапазон байт и статус этого кусочка
print $file.' ['.$start.'-'.$end.']: ' . ($broken ? 'BROKEN' : 'OK') . "\n";
// если файл был испорчен, то откладываем этот кусочек (чтобы потом его скачать)
if ($broken)
copy($tmp, $out.$file);
// удаляем временный файл
unlink($tmp);
}`
Если кратко, скрипт по частям скачивает файл, сравнивая хеш каждого очередного кусочка, с тем что мы посчитали у себя на машине. Если не совпадает — наш кусочек битый, а тот что на сервере — хороший, откладываем его для последующего скачивания.
#### Действуем
Для начала, то что мы скачали надо разрезать на кусочки:
`C:\ISO>mkdir out && cd out && split -a 3 -b 1048576 ..\ru_visual_studio_2008_professional_edition_dvd_x86_x15-25526.iso`
Параметр **-a** указывает длину суффикса, так как он буквенный (26 символов нижнего регистра), то 3 нам будет вполне достаточно: 26³ = 17576, что явно больше количества кусочков 3,5 Гб / 1 Мб ≈ 3584.
Когда всё это дело порежется, получим файлы с именами xaaa, xaab, xaac и т. д.
Теперь считаем хеш:
`C:\ISO\out>md5sum x* > ..\md5sum.txt`
Этот процесс тоже довольно продолжительный, в итоге будет получен файл с содержимым вида:
`26c379b3718d8a22466aeadd02d734ec *xaaa
2671dc8915abd026010f3d02a5655163 *xaab
6f539fcb0d5336dfd28df48bbe14dd20 *xaac
69f670a2d9f8cf843cdc023b746c3b8c *xaad
…`
Затем загружаем md5\_verify.php и md5sum.txt на сервер, и там же создаём папочку out, куда будут складываться кусочки которые нам надо будет перекачать. Подключаемся по SSH и тычем мордой php интерпретатор в наш скрипт. Теперь можно идти спать, гулять или смотреть House M.D.
Через несколько часов, в зависимости от ширины канала, которая вам предоставлена на площадке, работа скрипта завершится, а в папочке out будут лежать все кусочки, которые вам надо скачать.
Прячем их в архив:
`tar - jcvf "chunks.tar.bz2" ./out/x*`
Ну и наконец надо лишь переложить полученный архив в папочку откуда вы можете его скачать, и натравить на него свой любимый wget, curl или что вам там больше нравится.
Заменив поврежденные кусочки тем что извлекли из скачанного архива, можем склеить пациента обратно:
`cat out\x* > fixed.iso`
Можно резать, клеить и хешировать чем хочется, но все кому поневоле приходится пользоваться Windows давно раздобыли все эти маленькие замечательные утилитки типа cat, split и md5sum, стандартные для Linux, портированными для Windows (проект [GnuWin32](http://gnuwin32.sourceforge.net/)).
#### Про докачку
Да, кстати, вместе с этим нашёл отличный способ качать с докачкой даже если сервер не способен отдавать Partial Content: просто напросто тянем файл на свою хостинговую площадку через шелл, а потом уже качаем оттуда как приличные люди.
Многие сервисы конечно же хотят Referer и/или Cookie, не соглашаясь просто так отдать файл. Их можно получить: нужен Firefox и расширение к нему — [Live HTTP Headers](https://addons.mozilla.org/en-US/firefox/addon/3829).
Открываем окошечко аддона, жмём на сайте на ссылку/кнопку «Скачать», выскакивает предложение сохранить файл. Отказываемся качать файл, нажав «Отмена», а затем копируем нужные нам данные из заголовка.
Ну а затем пихаем эти данные в свою любимую качалку (на скринах это всё производится локально, но вам, очевидно, надо будет это выполнить через SSH на удалённом сервере):
`wget --header "Referer: http://csna01.libredigital.com/" -O "output.pdf" http://csna02.libredigital.com/cgi-bin/pdf_loader.pl?v=5`
`curl -v -e "http://csna01.libredigital.com/" -o "output.pdf" http://csna02.libredigital.com/cgi-bin/pdf_loader.pl?v=5`
На скрине можно увидеть использование ключа **-c** для wget (для curl используется **-C**), он позволяет докачивать, впрочем приведён тут исключительно для демонстрации, ибо сервер из примера как раз не даёт докачать.
##### Напоследок
Впрочем, есть смысл от использования wget и curl с докачкой непосредственно на своей машине: если оставлять одним и тем же выходное имя файла (ключ **-O**), то можно качать один файл частями в любое время и использую каждый раз новую ссылку (и с изменившимся cookie).
Это и есть третье «узнаете как» из обещаний в начале топика.
P.S. Вся история завершилась тем что у пацента обнаружилось ≈ 500 повреждённых частей. Потрачено пара часов на написание, отладку, нарезку и подсчёт хеша, несколько часов на работу скрипта на сервере, и около 12 часов на скачивание этих частей, что в сумме заняло примерно сутки. Тем не менее это гораздо меньше чем опять качать частями в течении десятка дней (и обязательно что-нибудь снова повредить). | https://habr.com/ru/post/48496/ | null | ru | null |
# Dagger 2. Subcomponents. Best practice
На хабре уже было несколько хороших статей по установке и работе с [**Dagger 2**](https://github.com/google/dagger):
* [1 часть: Основы](https://habrahabr.ru/post/279125/)
* [2 часть: Subcomponent'ы](https://habrahabr.ru/post/279641/)
Я же хочу поделиться своим опытом использования Dagger 2 на реальных проектах с реальными кейсами. Раскрыть читателю мощь и удобство как самого Dagger’а, так и такого его аспекта, как Subcomponent.
Перед тем, как пройти под кат, следует ознакомиться с вышеуказанными статьями.
Кого заинтересовал, you are welcome!
Один мой друг научил меня отличному способу, как можно разложить всё по полочкам: представляя какую-либо архитектуру (либо отдельно взятый класс, либо даже небольшой кусок кода), попытайтесь перенести это в реальный мир. Найдите в повседневной жизни что-то схожее с логикой вашего кода. И тогда, опираясь на пример реальной жизни, вы поймете, как должен вести себя тот или иной программный компонент (объект). Поймете, какой результат должен в итоге получиться.
В этот раз я поступлю точно также.
Давайте отвлечемся от программирования и перенесемся в хирургический кабинет.
Спасение человеческих жизней — крайне ответственная задача. Каждый член бригады врачей должен безошибочно выполнять свою работу и не мешать другим выполнять свою.
На полках аккуратно разложены все инструменты. Главный врач сосредоточенно и кропотливо выполняет операцию, периодически обращаясь к ассистенту, чтобы получить новый инструмент, скажем, скальпель. В разные моменты времени может понадобиться «разный скальпель», и потому ассистенту важно также не отвлекаться от процесса и подавать именно тот инструмент, который в данный момент необходим.
Врач абсолютно не заботится о том, на какой полке лежит нужный ему инструмент. Для него важнее полностью сконцентрироваться на операции, дабы не допустить ошибок — это его *зона ответственности*.
Ассистент же отвечает за наличие всех необходимых в данной операции инструментов, за их чистоту, за своевременное предоставление инструментов врачу. Ну и самое интересное, ассистент самостоятельно решает в зависимости от ситуации, какой инструмент выбрать; конечно, если от врача не было точных указаний.
В нашем случае ассистент — это и есть Dagger. Врач — наш программный компонент, имеющий четкое предназначение в программе. Именно в делегировании (от врача ассистенту) создания и предоставления зависимостей (инструментов) и заключается паттерн — Dependency Injection (внедрение зависимости).
**Что можно вынести из этого примера:**
1. Компонент не должен содержать в себе логику создания других компонентов.
2. Компонент не должен заботиться о реализации своих инструментов. В нашем примере, если хирург попросит: «Скальпель!», ассистент по ситуации вернёт нужный из множества. Т.о. можно сказать, что врач работает не с конкретными реализациями инструментов, а с их интерфейсами.
**Практика. Вернемся к программированию.**
В подавляющем большинстве приложений есть работа с каким-либо списком данных.
За обработку данных отвечает адаптер, который принимает в конструктор:
1. Listener — для событий взаимодействия с элементами списка;
2. Возможно, контекст или LayoutInflater — для создания ViewHodler’ов;
3. Ну и сам список данных, если, конечно, он был инициализирован заранее (иначе адаптер реализует свой метод setList()).
Но что в итоге? Получив в нашем Fragment’е (или Activity) конструкцию
```
Adapter adapter = new Adapter(this, getContext(), list);
recyclerView.setAdapter(adapter);
```
Мы озаботили наш компонент инициализацией другого компонента. Наш врач отошел от операционного стола, чтобы найти нужный инструмент.
С Dagger’ом же мы не просто избавимся от первой строки представленного кода, а именно освободим компонент от логики создания другого компонента — от излишней для него логики.
Минуточку, здесь может появиться вопрос:
*Если инициализацию адаптера делегировать Dagger’у, откуда он возьмет Listener (объект нашего компонента, реализующего Listener)? Хранить синглтон фрагмента или активити — это больше, чем плохая идея!*
Такой вопрос может возникнуть, если Вы:
1. Используете один-два Component'а для всего приложения;
2. Все зависимости храните синглтонами;
3. И знать не хотите про Subcomponent’ы и Component dependency.
**Уйдем в небольшую абстракцию, которой мне не хватало на первых порах изучения Dagger.**
Большинство примеров использования Dagger’а в «интернетах» обязательно включает в себя создание так называемого AppComponent’a с его AppModule’м с корневой зависимостью Context (либо вашим классом, расширяющим Application, что по сути тоже Context).
Разберемся, почему.
**«В начале было слово...»**
Имея Context, мы можем получить другие зависимости, например: SharedPreferences, LayoutInflater, какой-нибудь системный сервис и т.д. Соответственно, имея SharedPreferences, мы можем получить PreferenceHelper — класс-утилита для работы с преференсами. Имея LayoutInflater, можем получить какой-нибудь ViewFactory. Из этих «более высокоуровневых» зависимостей мы также можем получить еще и еще более сложные, комплексные. И всё это разнообразие пошло из одного только объекта — контекста. В данном случае его можно назвать **ядром** нашего AppComponent’а.
И всё вышеперечисленное — это как раз те зависимости, которые должны существовать на протяжении жизни всего приложения, т.е. Singleton’ы. Именно поэтому в качестве ядра у нас выступает тот объект, что существует всё это время — объект контекста приложения.
Продолжая эту мысль, подумаем, насколько долго должен существовать наш Adapter? Очевидно, пока существует экран, с которым этот адаптер работает.
Adapter’у мы предоставим ViewHolderFactory, которая должна существовать, пока существует Adapter. Помимо Adapter’а предоставим Fragment’у некоторый ViewController, и он также должен существовать, только пока существует Fragment, и т.д.
Если разобраться, все зависимости, используемые исключительно пока «жив» данный экран, от этого экрана и зависят. Т.о. можно сказать, что наш Fragment (или Activity) будет являться **ядром** нашего локального Component’а — Component'а, который существует, пока существует наш экран.
Чтобы реализовать четко определенное время жизни всей этой локальной кучке (графу) наших зависимостей, мы будем использовать Subcomponent.
**Спроси меня, «как?».**
Пока что забудем про приставку sub и представим, что мы реализуем просто Component. Если вам будет проще, представьте, что наш экран — это и есть всё наше приложение.
Начнем с того, что нам нужен базовый модуль. Т.к. наш экран со списком, назову его ListModule.
```
@Module
public class ListModule {
}
```
Теперь нам необходимо то самое ядро — базовая зависимость, от которой пойдут все остальные. Как говорилось ранее, базовой зависимостью для экрана является сам «объект экрана» — например, ListFragment. Передадим его в конструкторе модуля.
```
@Module
public class ListModule {
private final ListFragment fragment;
public ListModule(ListFragment fragment) {
this.fragment = fragment;
}
}
```
Основа есть, дальше творчество.
Предоставим наш адаптер:
```
@Provides
public Adapter provideAdapter(Context context) {
return new Adapter(fragment, context, fragment.initList());
}
```
*NOTE: У нас есть Context, но явно мы его не предоставляли ни в этом модуле, ни в других модулях нашего Component'а. Об этом чуть позже.*
Можно даже отдельно предоставить сам список данных (это избыточно, но для примера сойдет):
```
@Provides
public List provideListOfModels() {
return fragment.initList();
}
@Provides
public Adapter provideAdapter(Context context, List list) {
return new Adapter(fragment, context, list);
}
```
Теперь, чтобы всё заработало как надо, немного настроек.
Дабы подсказать Dagger’у, что:
1. Все зависимости Component'а являют собой один граф, отдельный от основного;
2. Мы хотим не создавать каждый раз новую зависимость, а кешировать единственную;
существуют так называемые Scope-аннотации. Выглядит каждая Scope-аннотация примерно так:
```
@Scope
@Retention(RetentionPolicy.Runtime)
public @interface Singleton {}
```
*Singleton* — это базовая аннотация, предоставляемая Dagger’ом. Предоставляется она просто для того, чтобы вам было, от чего отталкиваться. Само «singleton-ство» не будет происходить магическим образом, если вы не сохраните свой AppComponent в классе App (классе, расширяющем Application). Т.е. Dagger гарантирует вам, что для данного экземпляра Component'а будет создан единственный экземпляр зависимости. Но за единственность экземпляра Component'а вы отвечаете сами.
Подобным образом создадим свою scope-аннотацию:
```
@Scope
@Retention(RetentionPolicy.Runtime)
public @interface ListScope {}
```
Наша аннотация ничем не уступит аннотации Singleton, вся суть в том, как мы их используем.
Scope-аннотацией мы помечаем свои provide-методы и Component, содержащий наши модули.
> **ВАЖНО:** В одном Component’е, подписанном определенным Scope’ом могут находиться только модули, provide-методы которых подписаны тем же самым Scope’ом. Т.о. мы не пересекаем два разных графа зависимостей.
Итоговый вид нашего ListModule:
```
@Module
public class ListModule {
private final ListFragment fragment;
public ListModule(ListFragment fragment) {
this.fragment = fragment;
}
@ListScope
@Provides
public List provideListOfModels() {
return fragment.initList();
}
@ListScope
@Provides
public Adapter provideAdapter(Context contex, List list) {
return new Adapter(fragment, context, list);
}
}
```
И наш Component:
```
@ListScope
@Subcomponent(modules = ListModule.class)
public interface ListComponent {
void inject(ListFragment fragment);
}
```
Ключевой здесь является аннотация *@Subcomponent*. Так мы сообщаем, что хотим иметь доступ ко всем зависимостям нашего родительского Component’а, но, заметьте, родителя здесь не указываем. В нашем примере родителем будет AppComponent.
*\* Именно из AppComponent’а мы получим Context для инициализации адаптера.*
Чтобы получить свой Subcomponent, в родительском Component’е необходимо описать метод его получения, передав в аргументы все модули Subcomponent’а (в нашем случае только один модуль).
Как это выглядит:
```
@Singleton
@Component(modules = AppModule.class)
public interface AppComponent {
ListComponent listComponent(ListModule listModule);
}
```
Dagger позаботится о реализации этого метода.
**Организуем время жизни**
Как уже говорилось, AppComponent потому Singleton, что мы храним его единственный экземпляр в классе App. Создать экземпляр своего Subcomponent’а мы можем только с помощью родительского, а потому всю логику получения и хранения Subcomponent’а также вынесем в класс App, с одним важным отличием: Мы добавим возможность в любой момент создать Subcomponent, и в любой момент разрушить.
В классе App опишем следующую логику:
```
public class App extends Application {
private ListComponent listComponent;
public ListComponent initListComponent(ListFragment fragment) {
listComponent = appComponent.listComponent(new ListModule(fragment));
return listComponent
}
public ListComponent getListComponent() {
return listComponent;
}
public void destroyListComponent() {
listComponent = null;
}
}
```
*NOTE: На больших проектах имеет смысл выносить логику работы с Dagger’ом из класса App в класс-хэлпер, используя композицию.*
Ну, и остается описать использование всего этого в нашем фрагменте:
```
public class ListFragment extends Fragment {
@Inject
Adapter adapter;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
App.getInstance().initListComponent(this).inject(this);
init();
}
private void init() {
recyclerView.setAdapter(adapter);
}
@Override
public void onDestroy() {
super.onDestroy();
App.getInstance.destroyListComponent();
}
}
```
Таким образом мы привязали время жизни нашего графа к жизненному циклу фрагмента.
Это может выглядеть излишним в случае с одной зависимостью (хотя даже с одной зависимостью вынос подобной логики делает ваш код более чистым и менее [зацепленным](https://ru.wikipedia.org/wiki/%D0%97%D0%B0%D1%86%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5))). Бо’льшая часть работы заключается в создании архитектуры. А потому теперь, если вам понадобится предоставить новую зависимость, дело сведётся к реализации одного provide-метода.
### **БОНУС**
Когда все зависимости выделены в provide-методы, появляется такая приятная плюшка, как избавление от прокидывания каких-либо зависимостей. Рассмотрим опять же на примере с адаптером.
ListFragment реализует Listener событий, связанных с ViewHolder-ами объектов нашего списка. Соответственно, чтобы доставить Listener каждому ViewHolder’у, появляется необходимость хранения ссылки на Listener в Adapter’е.
Избавимся от посредника.
Хорошей практикой считается вынос создания ViewHolder’ов во ViewHolderFactory. Так и поступим:
```
public class ListItemViewHolderFactory {
private final Listener listener;
private final LayoutInflater layoutInflater;
public ListItemViewHolderFactory(LayoutInflater layoutInflater, Listener listener) {
this.layoutInflater = layoutInflater;
this.listener = listener;
}
public ListItemViewHolder createViewHolder(ViewGroup parent) {
View view = layoutInflater.inflate(R.layout.item, parent, false);
return new ListItemViewHolder(view, listener);
}
}
```
Наш модуль преобразится к такому виду:
```
@Module
public class ListModule {
private final ListFragment fragment;
public ListModule(ListFragment fragment) {
this.fragment = fragment;
}
@ListScope
@Provides
public List provideListOfModels() {
return fragment.initList();
}
@ListScope
@Provides
public Adapter provideAdapter(ListItemViewHolderFactory factory,
Context context,
List list) {
return new Adapter(factory, context, list);
}
@ListScope
@Provides
public ListItemViewHolderFactory provideVhFactory(LayoutInflater layoutInflater) {
return new ListItemViewHolderFactory (layoutInflater, fragment);
}
}
```
*NOTE: Не забываем предоставить LayoutInflater в AppModule.*
Мне кажется, данный пример хорошо показывает, насколько гибкой становится работа с зависимостями.
А теперь представьте мир, в котором мы делаем код-ревью определенного компонента (класса), и видим только его логику. Нет необходимости «скакать» между программными компонентами, чтобы отследить нить событий. Внешние инструменты появляются у нас сами собой, а с другими компонентами наш взаимодействует через интерфейсы (или вообще не взаимодействует).
Надеюсь, эта статья дала Вам почву для размышлений и творчества, а мир Dagger’а стал хоть немного ближе.
В следующий раз разберем вторую часть функционала ассистента — возвращать определенную реализацию «скальпеля» в зависимости от ситуации. Поговорим об авторизованной зоне и работе с социальными сетями.
Спасибо за внимание.
[Пример, описанный в статье, на гитхабе.](https://github.com/udy18rus/dagger2sample)
**UPD:** [Вторая часть](https://habrahabr.ru/post/337070/) | https://habr.com/ru/post/334710/ | null | ru | null |
# Битрикс в связке Nginx+PHP-FPM, настройка ЧПУ, а так же композитный кэш с отдачей через nginx. Доработанная конфигурация
**Цель:** Предоставить конфигурацию виртуального сервера Nginx для работы Битрикс-cms в связке Nginx+PHP-FPM. Который в прочем подойдёт и для связки Nginx+Apache2, с небольшими доработками.
**Целевая аудитория:** Администраторы серверов, продвинутые администраторы сайтов, программисты.
Cтатей на эту тему достаточно, но если смотреть не официальные, то там как правило содержатся ошибки, а в официальных полно if которые в Nginx использовать не желательно. Надеюсь после того как я выложу данный конфиг к связке Nginx+PHP-FPM станут относиться серьёзнее.
[Вот официальный конфиг для работы композитного кэша с отдачей через nginx.](https://dev.1c-bitrix.ru/learning/course/index.php?COURSE_ID=39&LESSON_ID=2419)
Я покажу реализацию отдачи файлового композитного кэша. В целом отдача с memcached делается по аналогии. В конфигурации отдачи файлового кэша я насчитал 11 if, от которых я и избавился переделав их на map.
Начну с упрощённого варианта ЧПУ для тех кому нужна просто связка Nginx+PHP-FPM без отдачи композитного кэша через Nginx. Подразумевается что секция server уже настроена, с доменными именами и передачей в php-fpm.
```
location / { try_files $uri $uri/ /bitrix/urlrewrite.php$is_args$args; }
```
Как не удивительно смотря на те полотна конфигов которые мне попадались, этого достаточно чтобы битрикс корректно заработал. Если нужен редирект с index.php и index.html на без, то нужно ещё дописать вот эту строку:
```
if ($request_uri ~ ^(.*)/index.(html|php)) { return 301 $1/$is_args$args; }
```
К сожалению тут достойной замене if нет. Но данная строчка работает не создавая проблем.
**Пример минималистичной конфигурации**
```
server {
listen 80;
server_name site.ru;
root /var/www/site.ru/;
index index.php;
location ~ \.php$ {
include /etc/nginx/fastcgi_params;
fastcgi_pass unix:/var/run/php/php7.0-fpm.sock;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_intercept_errors on;
}
if ($request_uri ~ ^(.*)/index.(html|php)) { return 301 $1/$is_args$args; }
location / { try_files $uri $uri/ /bitrix/urlrewrite.php$is_args$args; }
location ~* @.*\.html$ { internal; }
}
```
Хочу подчеркнуть что это именно минималистичная конфигурация без правил для статики, сжатия, и я там прикрыл только файлы композитного кэша от прямого доступа. Конфигурация которая прикрывает определённые места от прямого доступа через nginx довольно индивидуальна. У меня есть вот такой набор который может кому-то подойти. Но использовать нужно аккуратно с осознанием дела. Учитите что внесение данных локейшенов в свою конфигурацию может привести к неработоспособности сайта или части его функций.
**Фрагмент конфига закрывающий доступ к файлам которые должны быть доступны только при обращении из PHP**
```
location ~ \.php$ {
location ~* /\.\./ { internal; }
location ~ /\.[^/]+$ { internal; }
location ~* ^/upload/1c_[^/]+/ { internal; }
location ~* ^/(bitrix/(cache|images|tmp)|upload)/ { internal; }
location ~* ^/bitrix/(footer|header|license_key)\.php$ { internal; }
location ~* ^/(bitrix|local)/components/(.*)/(.*)/(class|component)\.php$ { internal; }
location ~* ^/(bitrix|local)/(backup|blocks|bx_cloud_upload|local_cache|module|modules|managed_cache|php_interface|public|stack_cache)/ { internal; }
include /etc/nginx/fastcgi_params;
fastcgi_pass unix:/var/run/php/php7.0-fpm.sock;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_intercept_errors on;
}
location ~* \.(hg|svn|git|bzr)$ { internal; }
location ~* /\.\./ { internal; }
location ~* @.*\.html$ { internal; }
location / {
location ~* ^/(bitrix|local)/(backup|blocks|bx_cloud_upload|local_cache|module|modules|managed_cache|php_interface|public|services|stack_cache)/ { internal; }
location ~ /\.[^/]+$ { internal; }
location ~* ^/upload/1c_[^/]+/ { internal; }
try_files $uri $uri/ /bitrix/urlrewrite.php$is_args$args;
}
```
Ну и конечно пример location для статических файлов
```
location ~* \.(jpg|jpeg|png|tiff|gif|webp|xml|html|yml|ogg|ogv|svg|svgz|eot|otf|woff|woff2|mp4|ttf|rss|atom|ico|zip|tgz|gz|rar|bz2|doc|xls|exe|ppt|tar|mid|midi|wav|rtf|pdf|txt|js|css|bmp|pnm|pbm|ppm)$ {
access_log off;
expires 97d;
}
```
Теперь перейдём к конфигу для работы композита с отдачей файлов кэша через nginx. Первым делом необходимо определить можно ли отдавать данному запросу композитный кэш или его нужно отправить на обработку через php. Для этого в Nginx в секции http добавим несколько map, а так же несколько директив:
```
modern_browser_value "modern";
modern_browser msie 10.0;
modern_browser unlisted;
map "$cookie_BITRIX_SM_LOGIN:$cookie_BITRIX_SM_UIDH:$cookie_BITRIX_SM_CC" $storedAuth {
default "";
"~*:*:Y" "";
"~*:*:*" 1;
"~*:*:" 1;
}
map "$request_method:$http_bx_action_type:$cookie_BITRIX_SM_NCC:$http_x_forwarded_scheme:$modern_browser:$storedAuth" $usecache {
default "1";
"~GET:::*https*" "1";
"~GET:::*:*:" "";
}
```
Далее уже непосредственно в секции server прописываем
```
set $i "index@";
location / { try_files /bitrix/html_pages/$host$uri$i${args}.html$usecache /bitrix/html_pages/$host$uri$i${args}=.html$usecache /bitrix/html_pages/$host$uri/$i${args}.html$usecache /bitrix/html_pages/$host$uri/$i${args}=.html$usecache $uri $uri/ /bitrix/urlrewrite.php$is_args$args; }
```
Ну и для понимания как примерно будет выглядеть минимальная конфигурация секции server
**Пример минималистичной конфигурации с отдачей файлового композитного кэша через nginx**
```
server {
listen 80;
server_name site.ru;
root /var/www/site.ru/;
index index.php;
location ~ \.php$ {
include /etc/nginx/fastcgi_params;
fastcgi_pass unix:/var/run/php/php7.0-fpm.sock;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_intercept_errors on;
}
if ($request_uri ~ ^(.*)/index.(html|php)) { return 301 $1/$is_args$args; }
set $i "index@";
location / { try_files /bitrix/html_pages/$host$uri$i${args}.html$usecache /bitrix/html_pages/$host$uri$i${args}=.html$usecache /bitrix/html_pages/$host$uri/$i${args}.html$usecache /bitrix/html_pages/$host$uri/$i${args}=.html$usecache $uri $uri/ /bitrix/urlrewrite.php$is_args$args; }
location ~* @.*\.html$ { internal; }
}
```
Буду рад вопросам и предложениям по поводу данного конфига, а так же за радость посмотрю Ваши наработки. | https://habr.com/ru/post/438604/ | null | ru | null |
# Простой способ добавить поддержку файлов лицензий в Ваше приложение .Net
Некоторое время назад приятель попросил автоматизировать часть рутинной работы его бизнеса. На тот момент я предвкушал наступление грядущего сокращения и с удовольствием согласился.
Разработка заняла три полных цикла и сейчас подходит к концу четвертый завершающий цикл работы над программой и у меня возникла идея двинуть свой продукт дальше в массы. Сказано сделано, началась работа по составлению договоров, изменению дизайна, отбутфорсингу и других прочих лабудей и возник интереснейший вопрос — а как защитить программу от не лицензионного использования и не дать возможности просто ее копировать?
Порыскав по интернету, точнее по порталу [CodeProject](http://codeproject.com), нашел несколько реализаций с применением файлов лицензий.
В теории задача решается просто:
1. Создадим файл xml с нужным нам содержанием
2. Подписываем файл с помощью класса SignedXml
3. В приложении проверяем подпись. Если проверка удалась — смотрим содержание файла, если нет — сразу выпадаем с ошибкой
На практике объект SignedXml требует экземпляр AssimetricAlgorithm шифрования. В найденныx примерах использовалось несимметричное шифрование любым установленным на компьютере сертификатом и последующей расшифровкой экспортированным открытым ключом. С учетом того, что я через некоторое время собираюсь переустанавливать систему нужно было заморочиться на экспорте сертификата, да и не вариант что он вообще может потом встать обратно, и еще очень длинный код реализации.
Я задумался, ведь может быть способ проще. И нашел.
Вся работа Подписчика заключается в добавлении к xml некой строки, которая должна быть проверена. Так почему бы мне не записать туда свою строку сформированную по определенному алгоритму. Мой способ использует метод симметричного шифрования, так сказать.
Мне нужно было проверить наступил ли срок лицензии, до какого числа возможно получение обновлений и кому собственно принадлежит эта лицензия.
Я создал два класса: один для создания файла лицензии, другой для его проверки.
Метод очень прост. Берем входные параметры для создания лицензии, записываем все в xml. Затем конкатируем эти самые параметры, добавляем к ним некую константу, получаем хэш, который и будет нашей подписью и дописываем его в конец xml в соответствующий раздел.
> `class LicenseGenerator
>
> {
>
> public void Generate(string Path,String Name, DateTime StartDate, DateTime UpdateTo)
>
> {
>
>
>
> XmlDocument doc = new XmlDocument();
>
> doc.LoadXml(@"
>
>
>
>
>
>
>
>
>
> ");
>
> doc.ChildNodes[0].SelectSingleNode(@"/license/Name", null).InnerText = Name;
>
> doc.ChildNodes[0].SelectSingleNode(@"/license/Date", null).InnerText = StartDate.ToShortDateString();
>
> doc.ChildNodes[0].SelectSingleNode(@"/license/UpdateTo", null).InnerText = UpdateTo.ToShortDateString();
>
>
>
> MD5 md5 = new MD5CryptoServiceProvider();
>
> byte[] data = System.Text.Encoding.UTF8.GetBytes(Name + StartDate.ToShortDateString() + UpdateTo.ToShortDateString() + "SomePasswordKey");
>
> byte[] hash = md5.ComputeHash(data);
>
> doc.ChildNodes[0].SelectSingleNode(@"/license/Signature", null).InnerText = Convert.ToBase64String(hash);
>
> doc.Save(System.IO.Path.Combine(Path, "license.xml"));
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
На выходе получаем примерно такой вот файл license.xml
> `<license>
>
> <Name>АвторName>
>
> <Date>15.06.2009Date>
>
> <UpdateTo>15.12.2009UpdateTo>
>
> <Signature>w673nrcuvxjnn7R4heEnvw==Signature>
>
> license>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Далее в защищаемом приложении нам нужно пройти проверку, делается это путем вызова метода Verify при каждом запуске приложения:
> `public class LicenseVerify
>
> {
>
> public LicenseVerify() { }
>
> public string Name { get; private set; }
>
> public DateTime StartDate {get; private set;}
>
> public DateTime UpdateTo {get; private set;}
>
>
>
> public void Verify()
>
> {
>
> string File = "license.xml";
>
> if (!System.IO.File.Exists(File))
>
> {
>
> throw new ApplicationException ("Ваша копия программы не лицензирована! Не найден файл лицензии License.xml.\n Обратитесь к автору.");
>
> }
>
>
>
> XmlDocument doc = new XmlDocument();
>
> doc.Load(File);
>
> string sig1;
>
> string Signature;
>
> try
>
> {
>
> string Name = doc.ChildNodes[0].SelectSingleNode(@"/license/Name", null).InnerText;
>
> string StartDate = doc.ChildNodes[0].SelectSingleNode(@"/license/Date", null).InnerText;
>
> string UpdateTo = doc.ChildNodes[0].SelectSingleNode(@"/license/UpdateTo", null).InnerText;
>
> Signature = doc.ChildNodes[0].SelectSingleNode(@"/license/Signature", null).InnerText;
>
> MD5 md5 = new MD5CryptoServiceProvider();
>
> byte[] data = System.Text.Encoding.UTF8.GetBytes(Name + StartDate + UpdateTo + "SomePasswordKey");
>
> byte[] hash = md5.ComputeHash(data);
>
> sig1 = Convert.ToBase64String(hash);
>
> this.Name = Name;
>
> this.StartDate = Convert.ToDateTime(StartDate);
>
> this.UpdateTo = Convert.ToDateTime(UpdateTo);
>
> }
>
> catch (Exception)
>
> {
>
>
>
> throw new ApplicationException("Ваша копия программы не лицензирована!\nОшибка чтения файла лицензии!\nОбратитесь к автору.");
>
> }
>
>
>
> if (sig1 != Signature)
>
> {
>
> throw new ApplicationException("Ваша копия программы не лицензирована!\nОшибка чтения файла лицензии!\nОбратитесь к автору.");
>
>
>
> }
>
> if (DateTime.Now < this.StartDate)
>
> {
>
> throw new ApplicationException(string.Format( "Ваша копия программы не лицензирована!\nСрок действия лицензии еще не начался! Начало {0}\nОбратитесь к автору.",StartDate.ToShortDateString()));
>
>
>
> }
>
>
>
> if (App.Created > this.UpdateTo)
>
> {
>
> throw new ApplicationException(string.Format("Ваша копия программы не лицензирована!\nВы не имеет право использовать это обновление.\nВы могли получать обновления до {0}\nОбратитесь к автору.", UpdateTo.ToShortDateString()));
>
>
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Отрицательным может быть то, что разгадав SomePasswordKey, получив дизасемлированием код, злоумышленник может создать свой файл лицензии.
Положительным моментом может служить простота реализации, когда криптозащита не стоит на первом месте.
ToDo List:
* Добавить возможность создания временных ознакомительных версий программы
* Добавить возможность привязки лицензии к определенному компьютеру
* Возможно создать веб сервис, куда будут отравляться запросы на создание лицензионных ключей и автоматическое получение готовых ключей или основание в отказе | https://habr.com/ru/post/62315/ | null | ru | null |
# Самодельный компьютер из платы АОНа
В последнее время на Хабре появилось несколько статей про самодельные компьютеры, созданные из различных нестандартных компонентов. Я тоже решил рассказать о своем компьютере, созданном в далеком 1993 году. На волне всеобщего увлечения синклерами, мне захотелось иметь полностью оригинальный 8-ми битный компьютер на основе z80 и, кроме того, создать для него программное обеспечение, начиная от операционной системы и заканчивая игрушками. Что из этого получилось, читайте под катом.
Первым вопросом, возникшим при создании своего компьютера был вопрос архитектуры. Я решил, что он будет достаточно компактным, на основе процессора z80, без вывода изображения на телевизор, но с LCD текстовым экраном, достаточно большой клавиатурой, выводом звука в виде однотоновой пищалки (стандартной в то время для большинства компьютеров) и портом RS232 для подключения к другим компьютерам с целью программирования и отладки.
Однако, возникла проблема, где взять печатную плату под полностью оригинальную схему, ведь китайцы в 1993 году платы для всего мира еще не производили, а заказывать разработку и производство на заводе было очень дорого. И тут я обратил свое внимание на платы, из которых делали АОНы — автоматические определители номера. Они были в продаже на Митинском рынке, имели возможность установить необходимые мне компоненты, но нуждались в доработке. В продаже имелось несколько разновидностей таких печатных плат из которых, если мне не изменяет память, я выбрал плату под названием «Русь».
Напомню для молодых читателей, что представлял из себя АОН. Это был телефон с кнопочным набором (кстати, в то время это было довольно круто, поскольку большинство телефонов были с крутящимся диском), состоящим из 12 кнопок и светящимся 9-ти разрядным, 7-ми сегментным индикатором, на котором высвечивался телефонный номер, если его удавалось определить и некоторая другая информация. Плата АОНа содержала процессор z80, параллельный порт КР580ВВ55, схему дешифратора, таймер КР580ВИ53, 32-х килобайтное ПЗУ (с ультрафиолетовым стиранием), 8-ми килобайтное статическое ОЗУ, аналоговую часть, связанную с телефонной линией и, возможно, что-то еще, о чем я, за давностью лет, забыл.
12 кнопочная клавиатура и имеющийся на АОНе индикатор меня категорически не устраивали, поскольку ни вводить информацию ни отображать ее (в частности буквы) они нормально не могли. Поэтому, было принято решение использовать 40-кнопочную самодельную клавиатуру и текстовый 24-х символьный, 2-х строчный LCD экран, которые тогда появились в продаже. Для подключения клавиатуры и LCD экрана необходимо было модифицировать схему АОНа. Первое, что я сделал — это выбросил всю аналоговую часть, связанную с телефонной линией, вернее, просто не стал ее запаивать. При этом освободились выходные ножки на дешифраторе, который выбирал разряд индикатора и ножки на параллельном порту КР580ВВ55. LCD экран требовал 4 линии для передачи информации, а вот для клавиатуры необходимо было задействовать дешифратор. Поскольку 40 кнопок на клавиатуре располагались матрицей в 5 рядов по 8 штук, было принято решение подключить эти 8 кнопок к дешифратору, чтобы можно было их сканировать, подавая разные комбинации по трем линиям на вход дешифратора и считывая 5 значений с рядов кнопок с помощью КР580ВВ55. Таким образом, получался скан-код нажатой кнопки на клавиатуре величиной в один байт, где первые три бита определяли колонку, в которой была нажата кнопка, а 5 остальных битов указывали на то, в каком ряду эта кнопка (или сразу несколько кнопок) была нажата. Кроме того, я посчитал, что 8-ми килобайт ОЗУ будет недостаточно и заменил его на 32-х килобайтное. При этом пришлось перепаять пару дорожек на печатной плате, благо, что 8-ми и 32-х килобайтные корпуса ОЗУ были почти идентичны по распиновке. Таким образом, у меня получилось 32 килобайта ПЗУ и 32 килобайта ОЗУ (напомню, что z80 может адресовать максимум 64 килобайта, так, что я использовал адресное пространство по максимуму). Кроме того, еще две линии КР580ВВ55 ушли на последовательный порт RS232, необходимый для подключения к другому компьютеру. Все это хозяйство я поместил в корпус от тестера. В результате получилась такая конструкция:
После того, как «железо» было сделано, пришло время создавать программное обеспечение. Тут надо заметить, что процесс его создания выглядел совсем не так, как выглядит сегодня. Во-первых, большая часть была написана на ассемблере z80 (хотя в то время практически все программы для подобных систем писались на ассемблере, ну, если не считать бейсика). Для компиляции с ассемблера на первом этапе мне помогал мой товарищ, у которого был компьютер «Профи» — клон синклера, но с TR-DOS на борту. Потом я стал использовать мой IBM PC, на котором стояла OS/2, в которой запускался MS-DOS в отдельном окне, в которой, в свою очередь, запускался эмулятор TR-DOS, в котором и происходила компиляция. Надо сказать, что когда программное обеспечение заметно разрослось, процесс компиляции и сборки стал занимать десяток минут. Второй проблемой было то, что никаких отладочных средств не существовало и, поэтому, было необходимо каждый раз загружать все на мой самодельный компьютер и проверять, как это работает (первое, что пришлось сделать — это программу для работы RS232 на 9600 бит в секунду для загрузки). Ну и наконец, следует сказать, что после отладки образа ПЗУ, его необходимо было в это самое ПЗУ записать, предварительно стерев то, что там было уже записано. Стирание происходило с помощью ультрафиолетовой лампы для загара через специальное окошко в корпусе микросхемы, которое затем закрывалось специальной черной клейкой бумажкой, служащей для заклеивания дырки сбоку на 5-ти дюймовой дискете для защиты от записи. Кроме того, поскольку программатора у меня не было, для записи новой версии программного обеспечения в ПЗУ, каждый раз приходилось ехать к моему товарищу на другой конец Москвы, у которого этот программатор был. Тут надо прояснить вопрос, как было возможно отлаживать образ ПЗУ, не загружая его в это самое ПЗУ? Для этого имелся базовый адрес, который использовало все мое программное обеспечение смещая адреса на 32 килобайта. То есть новый образ ПЗУ загружался в ОЗУ и отлаживался там, а после отладки базовый адрес устанавливался в ноль, все заново компилировалось и я ехал к товарищу для записи новой версии в ПЗУ.
Когда процесс «кодирование»-«отладка»-«прошивка» был отлажен, встал вопрос написания операционной системы. Операционная система должна была поддерживать ввод с клавиатуры, отображение информации на LCD экране, поддержку вывода разных звуков и делать все это по возможности параллельно, то есть быть многозадачной. Для всего этого была выбрана следующая архитектура — в ОС существовали три типа задач: несколько задач реального времени с высшим приоритетом, одна задача пользователя, которая взаимодействовала собственно с человеком и фоновые задачи, которые работали, когда процессор простаивал. Задачи с высшим приоритетом я повесил на прерывание, которое генерировалось таймером КР580ВИ53 10 раз в секунду. Тут следует сказать, что в АОНе прерывания генерировались 400 раз в секунду, поскольку было необходимо обновлять индикатор очень часто для того, чтобы человек не замечал мерцания. Кроме обновления индикатора в прерываниях происходил опрос клавиатуры на предмет поиска нажатой клавиши. Такое частое прерывание в АОНе приводило к тому, что большая часть времени работы процессора уходило собственно на прерывания, а я хотел, чтобы мой компьютер делал еще что-то полезное. Поскольку я в качестве устройства отображения информации установил LCD экран, который имел собственную память и не нуждался в динамическом обновлении, необходимость в такой частоте прерываний отпала. Экспериментальным путем было установлено, что 10 прерываний в секунду достаточно для опроса клавиатуры.
Таким образом, задачи реального времени запускались на каждом прерывании и помещали новую информацию в специальную очередь событий. События были нескольких типов и содержали соответствующую типу события информацию, например, событие «нажата кнопка» содержала скан-код. Собственно одна из приоритетных задач, запускавшаяся на каждом прерывании, была задача опроса клавиатуры и программное удаление дребезга контактов. Кроме этой задачи были еще приоритетные задачи — таймеры которые могла установить задача пользователя, и которые по истечении заданного времени ставили в очередь соответствующее событие, были будильники, которые срабатывали в определенное время, часы и календарь, а также была задача, которая играла музыку с помощью программирования КР580ВИ53, причем на вход ей подавались данные в виде нот. Таким образом, задача пользователя могла просто запустить проигрывание музыки и заниматься другими делами.
Полезную работу в моем компьютере делала задача пользователя, которая управлялась событиями. Типичный вид такой задачи выглядел как:
```
while(true) {
Event e;
GetEvent(e);
/* process event */
}
```
Здесь функция GetEvent(e) ждала появления события в очереди и при его появлении заполняла структуру Event. Понятно, что по определенному событию, программа могла выйти из бесконечного цикла и передать управление обратно системному монитору, который запускал пользовательские задачи. Поскольку события в пользовательской задаче обычно обрабатывались быстро, программа ждала появления нового события в процедуре GetEvent(e). Чтобы как-то утилизировать это ожидание были введены фоновые задачи, которые могла запускать пользовательская программа и которые работали независимо. То есть при возникновении прерывания от таймера сначала отрабатывали задачи реального времени, помещая события в очередь, затем по окончании прерывания задача пользователя обрабатывала все события из очереди, а оставшееся время до следующего прерывания отдавалось фоновым задачам. Сегодня подобная схема выглядит естественной, но в 1993 году она была очень прогрессивной.
Была еще одна проблема, связанная с тем, что LCD экран не умел выводить русские буквы. Это было связано с тем, что такие индикаторы только что появились у нас на рынке и никто их специально не русифицировал. Естественно, библиотек для работы с ними тоже не было, а была только спецификация и описание команд. Поэтому всю работу по инициализации и работе с ним пришлось написать с нуля. Проблему с русификацией я решил следующим образом: была написана специальная процедура, на вход которой подавалась строка с русским текстом, который необходимо было отобразить. Эта процедура заменяла все русские буквы, которые были похожи на латинские соответствующими латинскими, а те, которые заменить было невозможно, создавались на лету с помощью пользовательских изображений, которые можно было загрузить в LCD экран. Следует заметить, что таких пользовательских изображений в нем было восемь и, соответственно, в русском тексте могло быть не более восьми букв, аналогов которых не было в латинском алфавите. Но обычно этого хватало. Еще одна забавная возможность, которую я использовал, состояла в том, что если менять пользовательские изображения для одного символа, то получается забавная анимация. Я использовал такую возможность в игре «сапер», о которой расскажу ниже, где флаг над найденной миной развевается на ветру, а бомба взрывается.
Теперь расскажу про те пользовательские задачи, которые я создал для своего компьютера. Когда я стал создавать их, то быстро понял, что писать их на ассемблере, как все делали в то время для систем типа синклер, довольно грустно. Поскольку на IBM PC я программировал на С, то я задумался о том, можно ли программировать на С и на моем компьютере. После некоторого поиска я обнаружил компилятор с языка С для TR-DOS, причем в его классическом K&R варианте. Этот компилятор, был довольно примитивный, например, он не проверял соответствие количества передаваемых процедуре параметров их действительному количеству, не говоря уже о проверке их типов. Но если бы удалось использовать этот компилятор для моего компьютера, это был бы грандиозный прогресс. Проблема заключалась в том, как адаптировать полученный этим компилятором код для моего компьютера. Здесь я пошел классическим путем, о котором сейчас уже забыли, а в 1993 году еще помнили. Этот путь заключался в том, чтобы компилировать сишный код не сразу в объектный файл, а в ассемблерный исходный код. Таким образом, необходимо было только написать макросы, которые позволяли бы вызывать из ассемблера процедуры, скомпилированные из сишного кода и наоборот, с правильной передачей параметров, что и было сделано. Использование этого компилятора кроме удобства работы с кодом давало еще одно большое преимущество — стало возможным работать с умножением/делением целых чисел (напомню, что в z80 отсутствуют команды умножения и деления целых чисел), а также (о чудо !), возможность работы с числами с плавающей запятой. Правда, для этого пришлось разбираться с прилагаемой к компилятору библиотекой, поскольку все математические операции после компиляции выполнялись в виде обращения к этой библиотеке. Проблема была в том, что эта библиотека использовала временные переменные, которые компилятор размещал в модели памяти, характерной для TR-DOS, что, понятно, совершенно не соответствовало модели памяти моего компьютера. Пришлось искать все такие временные переменные и переделывать под адреса, подходящие под мое ОЗУ. Зато в качестве бонуса я получил множество стандартных функций типа синуса и косинуса, которые я использовал в своих задачах, о чем расскажу ниже.
Первой программой, которая была создана с использованием сишного компилятора, была программа для проверки правильности работы ОЗУ. Эта программа проходила по всему ОЗУ, записывала, а затем считывала различные паттерны и сравнивала результат. При этом весь процесс отображался на LCD экране, что также подтверждало правильность работы процедур, связанных с ним. Понятно, что это была просто проба пера перед написанием более интересных программ. Следующее, что я сделал — это создал шестнадцатеричный редактор для изменения содержимого ОЗУ. Этот редактор обладал уже достаточно широкими возможностями, включая не только просмотр и редактирование ячеек памяти, но и поиск интересующих байт в ОЗУ. В частности, появилась возможность писать маленькие программы прямо в ОЗУ в машинных кодах. Чтобы проверить звуковые возможности своего компьютера, я создал программу типа «музыкальная шкатулка», которая проигрывала различные мелодии (напомню, что мелодии записывались в виде нот). Далее, была написана программа для игры «быки и коровы», где человеку предлагалось угадать задуманное компьютером случайное четырехзначное число (да, генератор случайных чисел я тоже сделал). В этой программе мне пришлось создать прокручивающийся список с историей уже введенных чисел, поскольку на двух строках особо длинный список отобразить было нельзя. Следующей созданной программой был классический «сапер» на поле 16x16. Поскольку у меня было в распоряжении только две строки, я сделал скроллинг, добавив музыкальное сопровождение и анимацию развевающегося на ветру флага и взрывающихся бомб. Далее, для медитации я сделал программу, которая показывала ползающих в случайном направлении червячков, задействовав возможность загружать пользовательские изображения в экран. Ну и куда же без классических крестиков-ноликов? В них я протестировал алгоритм минимакс, то есть компьютер просчитывал (довольно быстро) все варианты и никогда не проигрывал. Поскольку у меня в операционной системе поддерживались будильники, время и календарь, я сделал пользовательскую программу, которая выставляла время, дату и несколько будильников, которые при достижении заданного времени играли разные мелодии. Ну и наконец, венец творения в моем компьютере — это программа расчета траектории движения в задаче двух гравитирующих тел. То есть, по заданному начальному положению и скорости тела, а также массы притягивающего центра, решалась задача численного интегрирования системы из двух нелинейных обыкновенных дифференциальных уравнений второго порядка с заданным шагом интегрирования. Для этого я добавил процедуру, которая численно интегрировала эти уравнения. Все переменные были формата double с плавающей запятой. Здесь я еще раз подчеркну, что в процессоре z80 нет не только аппаратной поддержки работы с плавающей запятой, но и обычного умножения/деления целых чисел, все делалось программно. Это интегрирование работало довольно неспешно, примерно один шаг в секунду, но работало!
Что мне хотелось еще реализовать, но не сложилось — во-первых динамическое выделение/освобождение памяти, чтобы можно было гибко управлять ресурсами каждой задачи. Также осталась нереализованной запись/чтение на магнитофонную ленту, как это было сделано в синклере. Но в целом я остался доволен тем, что удалось сделать. Особо подчеркну, что все вышеперечисленное находилось в ПЗУ объемом 32 килобайта — сегодняшний размер одного не очень большого электронного письма.
Посмотреть на мой компьютер в действии можно здесь:
[А скачать его программное обеспечение здесь](http://andyplekhanov.narod.ru/hard/hard.htm) | https://habr.com/ru/post/497092/ | null | ru | null |
# Усатый стрелок из двадцати трёх полигонов
А давайте отвлечёмся немного и напишем игру в google play? И не такую огромную и неподъёмную фигню, про которую я обычно пишу статьи, а что-нибудь простое и милое сердцу?
На самом деле, всё очень просто: я наконец-то зарегистрировал аккаунт разработчика и очень хочу его опробовать. На момент написания этих строк у меня нет ни одного написанного класса и ни одного нарисованного пикселя. По сути, эта статья — самый настоящий devlog.
Статьи
------
* Первая часть. Усатый стрелок из двадцати трёх полигонов.
* [Вторая часть. Усатый стрелок с полигональным пузом.](https://habrahabr.ru/post/326840/)
Оглавление
----------
* [Идея](https://habrahabr.ru/post/322262/#img-width40-height44-srchttpshabrastorageorgfiles52aee038452aee0384d7344cf82b93ed1f9d12198pnglevel-11-ideya)
* [Микропрототип](https://habrahabr.ru/post/322262/#img-width40-height44-srchttpshabrastorageorgfiles53bbd318153bbd31818d7419e8bdcacd4d21d822cpnglevel-12-mikroprototip)
* [Первая карта](https://habrahabr.ru/post/322262/#img-width40-height44-srchttpshabrastorageorgfilesbb28403e6bb28403e645448af934d27f0d82fb1e8pnglevel-13-pervaya-karta)
* [Выбор сеттинга и визуального стиля](https://habrahabr.ru/post/322262/#img-width40-height44-srchttpshabrastorageorgfiles58531aca458531aca4da34f9f92039ff291e43af8pnglevel-1boss-100hp-vybor-settinga-i-vizualnogo-stilya)
* [Переход к 3D](https://habrahabr.ru/post/322262/#img-width40-height44-srchttpshabrastorageorgfiles0000a927c0000a927c5b34ba789755690a1d97117pnglevel-1boss-75hp-perehod-k-3d)
* [Procedural generation](https://habrahabr.ru/post/322262/#img-width40-height44-srchttpshabrastorageorgfiles6128294e76128294e7287427bb6eccd34cfedbdc2pnglevel-1boss-15hp-procedural-generation)
* [Правильные многоугольники в 2D](https://habrahabr.ru/post/322262/#img-width40-height44-srchttpshabrastorageorgfilesfb97b6997fb97b69975934e1e9f34c2e0b69a84afpnglevel-21-pravilnye-mnogougolniki-v-2d)
* [Правильные многоугольники в 3D](https://habrahabr.ru/post/322262/#img-width40-height44-srchttpshabrastorageorgfiles3f89635673f8963567c104582ab977a9538a4846dpnglevel-22-pravilnye-mnogougolniki-v-3d)
* [Тени](https://habrahabr.ru/post/322262/#img-width40-height44-srchttpshabrastorageorgfilesc6e40ff4fc6e40ff4f6024af9bc828a0741d53f6cpnglevel-31-teni)
* [Тени в вертексном шейдере](https://habrahabr.ru/post/322262/#img-width40-height44-srchttpshabrastorageorgfilesb4457ecb7b4457ecb7f0f4290a3483b1e7834874apnglevel-32-teni-v-verteksnom-sheydere)
* [Генерация теней на cpu](https://habrahabr.ru/post/322262/#img-width40-height44-srchttpshabrastorageorgfiles10bdd472b10bdd472b8cf40e98975e1fed1789f36pnglevel-32-generaciya-teney-na-cpu)
* [Оптимизации теней](https://habrahabr.ru/post/322262/#img-width40-height44-srchttpshabrastorageorgfiles10bdd472b10bdd472b8cf40e98975e1fed1789f36pnglevel-33-optimizacii-teney)
* [Заключение первой части](https://habrahabr.ru/post/322262/#zaklyuchenie)
Level 1.1. Идея
---------------
*Первые каляки-маляки.*
Видите этот кружочек на бумаге? С него и начнём. Мне кажется, любую игру (да ладно, любое произведение) можно начать с подобной окружности. Чем он станет через несколько секунд? Колесом? Шляпой? Планетой? Рисую каракули, пытаюсь представить, что этот кружок означает. Шляпу!
Некий суровый дядя ходит по дорогам, а мы смотрим на него сверху. Суровый — потому что с пистолетом и стрелять умеет. Топает себе по городу, дует в усы, пускает пули в бандитов.
Эта заготовка — просто образ, который давно крутится в голове. Вот только делать игру на подобии [Crimsonland](https://ru.wikipedia.org/wiki/Crimsonland) делать решительно не хочется. И gui с двумя джойстиками я всегда недолюбливал. Обрезаем бритвой Оккама всё лишнее и получаем на выходе такую концепцию:
> Уровень: небольшой городок с домами, ящиками и бочками.
>
> Персонажи: главный герой (стрелок), бандиты и прохожие.
>
> Игра стоит на паузе и ждёт действия игрока. Игрок делает свайп в любом направлении. В этот момент:
>
> 1. Время в игре начинает идти;
>
> 2. Главный герой стреляет в указанном игроком направлении;
>
> 3. Главный герой начинает двигаться в указанном направлении.
>
>
>
> Проходит половина секунды и время в игре снова останавливается. Игроку нужно победить всех бандитов, ранив как можно меньше прохожих.
>
>
Это сочетание автоматической стрельбы и остановки времени мне очень приглянулось:
* Автоматическая стрельба:
+ Упрощает управление (один свайп вместо двух джойстиков);
+ Добавляет интересную механику (приходится смотреть, куда идёшь, чтобы не выстрелить в прохожего).
* Остановка времени:
+ Добавляет вариативность в геймплей (можно делать разные уровни: медленные задумчивые головоломки или шустрый шутер);
+ Смягчает сложность от автоматической стрельбы;
+ Позволяет контролировать динамику как мне (через level design), так и игроку.
Постепенно идея визуализируется и обрастает деталями. Отметаю одну за другой, хватит на сегодня.
*Todo: сделать крохотный прототип и проверить, насколько фаново будет двигаться/стрелять с остановкой времени.*
Level 1.2. Микропрототип
------------------------
Спасибо Unity3D, прототипирование на нём очень простое. Добавляю пару стен с [BoxCollider2D](https://docs.unity3d.com/ScriptReference/BoxCollider2D.html), круглые спрайты с [RigidBody2D](https://docs.unity3d.com/ScriptReference/Rigidbody2D.html) и [CircleCollider2D](https://docs.unity3d.com/ScriptReference/CircleCollider2D.html) (игрок, прохожие и бандиты). Пули — тот же спрайт, только маленький, красный, с [RigidBody2D](https://docs.unity3d.com/ScriptReference/Rigidbody2D.html), [CircleCollider2D](https://docs.unity3d.com/ScriptReference/CircleCollider2D.html) и [TrailRenderer](https://docs.unity3d.com/ScriptReference/TrailRenderer.html) для траектории полёта.
Управление временем делаю через свой класс *Clock*, все прочие классы (игрок, пуля и тд) используют дельту времени из него, а не Time.DeltaTime.
**Одна из первых версий Clock.cs, для интересующихся**
```
using UnityEngine;
using System.Collections;
public class Clock : MonoBehaviour {
[SerializeField, Range(0, 2)] float stepDuration;
[SerializeField] AnimationCurve stepCurve;
float time = -1;
float timeRatio = 0;
float defaultFixedDeltaTime = 0;
static Clock instance;
public static Clock Instance { get { return instance; } }
void Start() {
instance = this;
defaultFixedDeltaTime = Time.fixedDeltaTime;
}
void OnDestroy() {
if (instance == this)
instance = null;
}
public bool Paused {
get { return time < 0; }
}
public float DeltaTime {
get { return
timeRatio * Time.deltaTime; }
}
public float FixedDeltaTime {
get { return
timeRatio * Time.fixedDeltaTime; }
}
public void Play() {
if (!Paused)
return;
time = 0;
timeRatio = Mathf.Max(0, stepCurve.Evaluate(0));
UpdatePhysicSpeed();
}
public void Update() {
if (Paused)
return;
time = Mathf.Min(time + Time.unscaledDeltaTime, stepDuration);
if (time >= stepDuration) {
timeRatio = 0;
time = -1;
UpdatePhysicSpeed();
return;
}
timeRatio = Mathf.Max(0, stepCurve.Evaluate(time / stepDuration));
UpdatePhysicSpeed();
}
void UpdatePhysicSpeed() {
Time.timeScale = timeRatio;
Time.fixedDeltaTime = defaultFixedDeltaTime * timeRatio;
}
}
```
Самый базовый прототип готов через полтора часа, полно багов:
1. Движение игрока и пули сделано через transform.position, а не velocity, поэтому игрока колбасит, когда он упирается в стены;
2. Остановка времени не останавливает физику (не меняется fixedDeltaTime), поэтому в режиме паузы персонажи чуть-чуть двигаются (выталкиваются друг из друга).
Но даже в этом варианте уже интересно двигаться и стрелять. Выглядит первый прототип, конечно, совершенно непрезентабельно:
*Первый играбельный прототип*
Но уже появляются таски на следующий день:
Фишки:
1. Добавить "отражающие" стены, от которых пуля будет рикошетить;
2. Добавить уничтожение ботов при столкновении с пулей (пока они этого не умеют);
3. Добавить гибкое управление временем (сейчас есть длительность и кривая для "скорости течения времени", но это неудобно).
Фиксы:
1. Переделать движение на изменение velocity, а не transform.position;
2. Запрещать создавать пули в стенах (Игрок упирается в стену, стреляет, пуля сразу же убивает игрока).
*Todo: сделать тестовый обучающий уровень с придуманными фишками.*
Level 1.3. Первая карта
-----------------------
Пока шёл по улице, придумал план тестового уровня:
1. Безопасная зона. Игрок учится ходить, все пули уходят в стены;
2. Узкий коридор с неактивным врагом. Игрок идёт по коридору и понимает, как атаковать;
3. Расширение коридора с неактивным бандитом и парой прохожих. Расширение — после поворота, поэтому игрок не может случайно попасть в прохожего;
4. Поворот в виде [перископа](https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D0%B8%D1%81%D0%BA%D0%BE%D0%BF), вместо зеркала — отражающая стена, за поворотом — неактивный враг. Игрок стреляет в стену, видит, как работает рикошет;
5. Коридор с зеркальными стенами, врагами и прохожими. Игрок аккуратно проходит по коридору, стараясь не попасть в прохожих (или стреляет в них, если хочет);
6. Песочница.
Закидываю объекты на сцену, перекрашиваю отражающие стены в жёлтый. Получается что-то такое:
*Вид обучающего уровня*
Делаю отражающие стены через отдельный слой, код столкновения пули с препятствием становится таким:
**OnCollisionEnter2D**
```
void OnCollisionEnter2D(Collision2D coll) {
int layer = 1 << coll.gameObject.layer;
if (layer == wall.value)
Destroy(gameObject);
else if (layer == human.value) {
Destroy(gameObject);
var humanBody = coll.gameObject.GetComponent();
if (humanBody != null)
humanBody.Kill();
return;
} else if (layer == wallMirror.value) {
Vector2 normal = Vector2.zero;
foreach (var contact in coll.contacts)
normal += contact.normal;
direction = Vector2.Reflect(direction, normal);
}
}
```
Исправляю баги, добавляю придуманные за прошлый день фишки. Переделываю класс Clock: раньше ход длился *stepDuration* реальных секунд, а коэффициент скорости времени определялся кривой *stepCurve*. Кривая нужна для плавного старта и завершения хода.
*Старые настройки в Clock.cs*
Вот только если изменить длительность хода, изменится и длительность начала/конца (где значение ординаты на кривой не равно 1). И при слишком небольшой длительности хода "включение" времени кажется слишком резким, а при длительности порядка секунды — слишком медленным (т.к. кривая "растягивается" на всё время хода). Добавляю отдельные кривые для начала и конца хода, а также длительности начала/конца.
Добавляю камеру, которая следит за игроком и визуализацию траектории игрока.
Молча показываю прототип нескольким знакомым, не объясняя ни цель, не управление. Все смогли разобраться с управлением, но есть и проблемы, которых я не замечал. Для себя записал выводы playtest'а:
1. Сложно целиться. Я использую дельту между последними двумя позициями пальца, нужно бы брать больше значений;
2. Палец устаёт свайпать по экрану. Решается длительностью хода, левелдизайном;
3. Иногда пропадает сделанный свайп. Люди начинают делать свайп, когда ход ещё не кончился и часто отпускают палец, пока останавливается текущий ход. Т.к. во время хода менять направление нельзя, жест тратится впустую. Решается хитрым кодом (каким — ещё не знаю);
4. Было бы круто сделать собираемые объекты, которые разрушаются от пуль. К ним нужно подойти, но не по прямой;
5. Рикошеты добавляют интереса: можно устроить безумный bullet storm;
6. Игроки не различают прохожих и врагов. Лечится артом;
Прототип готов настолько, что можно показать геймплей!
*Todo: определиться с сеттингом, графикой.*
Level 1.boss [100hp]. Выбор сеттинга и визуального стиля
--------------------------------------------------------
Моим первым "боссом" оказался именно этот этап, вот уж не думал. Планировал я следующее: прошерстить интернет на тему популярных игровых сеттингов, поискать референсы и арт для вдохновения, и начать рисовать уровни в пиксельарте.
После некоторого гугления решил остановиться на антураже викторианской Англии. Папоротники, культ смерти, мрачные доки. Дерево, металл, пар и масло.
Пробую нарисовать первые спрайты и обнаруживаю проблему. Все объекты в игре могут вращаться. А пиксели, как известно, нет.
Отрисовать по 360 вариантов каждого спрайта, очевидно, не вариант. К счастью, сейчас возникла мода не "нечестный пиксельарт", когда спрайты свободно вращаются вокруг своей оси. В этом случае нужно что-то делать с лесенками алиасинга, которые неизбежно появятся, высунут хищные угловатые мордочки и будут мелькать тут и там. Можно смириться и сказать: "Это и есть мой стиль!", как сделали создатели Hotline miami (и ведь получилось!). Можно подключить антиалиасинг: "Да здравствует мыло душистое!".
Во всяком случае, у меня так и получилось: либо алиасинг и лесенки, либо нечёткие грани после антиалиасинга.
*Тестовый пиксельарт*
Отметаю пиксельарт (прости, друг!) и упрощаю, упрощаю!
*Todo: выбрать подходящий визуальный стиль.*
Level 1.boss [75hp]. Переход к 3D
---------------------------------
Город из бумаги! Похожий немного на [Wildfire worlds](http://wildfireworlds.com/), только ещё проще. Благородные белые грани шершавой бумаги, пятна краски на полу, вот такие персонажи в смешных шляпах:
*Цилиндрический чел*
По правде говоря, с 3д в геймдеве я никогда не работал, а 3д редакторы открывал последний раз несколько лет назад. Но знаю, что многое решается освещением и тенями. Особенно, если текстура — белая бумага, где толком не скроешь недостатки плохого света.
Трачу вечер на моделирование первого объекта: пакета молока. Разбираюсь со стандартными шейдерами, освещением.
Вывод простой: не потяну. Я трачу очень много времени на моделлинг и не могу получить красивую картинку стандартными средствами. Запекание освещения помогает, но я хотел сделать небольшую игрушку с множеством уровней, так что запекание в пролёте. Похоже, босс ещё не побеждён...
*Пакет молока с простым освещением*
Level 1.boss [15hp]. Procedural generation.
-------------------------------------------
Вспоминаю свои сильные и слабые стороны. Обычно, если я не могу нарисовать какой-нибудь арт для своего проекта, я пишу скрипт, который сделает это за меня. Чем 3д хуже? Итак, процедурная генерация! Базовые примитивы, фактически, low poly. Яркие, контрастные цвета, визуально кодирующие геймплейные различия.
Нужно определиться, какие примитивы мне понадобятся для создания уровней. Цилиндры и кубы, возможно, пятиугольники… Хм, это ведь все можно генерировать одним кодом. За работу!
*Todo: реализовать простую генерацию примитивов.*
Level 2.1. Правильные многоугольники в 2D
-----------------------------------------
Пока для уровня будет достаточно правильных многоугольников. Для начала я решил попробовать в 2д, перевёл камеру в ортогональный режим и создал элементы из двух кусочков:
* Тело (просто правильный многоугольник) белого цвета;
* Цветное кольцо вокруг, показывающее цветом тип объекта (как будет вести себя пуля при коллизии).
**Не забывайте про геометрию!**
Если использовать константный радиус кольца для всех многоугольников, получатся вот такие разномастные контуры:
*Контуры разной толщины*
Дело в том, что нужно получить одинаковое расстояние между сторонами внешней и внутренней части "кольца", а я работаю с углами, а не сторонами. Чем меньше углов в многоугольнике, тем сильнее будут различаться радиусы описанной и вписанной окружности и, соответственно, сильнее будут различаться расстояния между сторонами и расстояния между углами.
 — решает проблему.
Теперь чем меньше углов, тем шире будет контур:
*Контуры одинаковой толщины*
Немножко стенсильной магии, чтобы не было видно колец внутри других многоугольников и получаем такого зайку:
*Зайка*
И тут завертелось!
Добавил стандартную клеточную текстуру на тело, подобрал цвета и наконец не удержался и подключил мои любимые тени (о них я уже как-то [писал](https://habrahabr.ru/post/305252/)).
*Просто и аккуратно.*
Делюсь скрином с девушкой и получаю резонный фидбек: тень, падающая с высокого объекта на более низкий имеет искажения, изломы. Согласен, я постоянно такое вижу в реальном мире. Пробую нарисовать на бумаге и понять, как должны эти искажения выглядеть. И тут понимаю: какие искажения, если камера — ортогональная?
*Слева тени при перспективной камере, справа при ортогональной*
Получается, мои красивые тени только подчёркивают плоский вид карты. Время возвращаться в 3D.
Level 2.2. Правильные многоугольники в 3D
-----------------------------------------
Честно говоря, процедурная генерация в 3D для меня совершенно новый опыт. С другой стороны, он ничем не должен отличаться от 2D.
Для начала определился с настройками конкретного многоугольника:
1. *height* — Высота;
2. *edges* — Количество граней;
3. *size* — Vector2D, позволяет задать размер многоугольника или растянуть его по одной из осей;
4. *isCircle* — Цилиндр ли это? Если да, количество граней выставляется автоматически, исходя из радиуса, а size.y становится равным size.x.
И с общими настройками, которые будут одинаковы для одного типа игровых объектов:
1. Цвет "потолка";
2. Цвет границы;
3. Ширина границы;
4. Минимальное количество граней в цилиндре;
5. Отношение количества граней в цилиндре к 1 юниту периметра.
Теперь самое время создавать эти многоугольники. Я разбил каждый на 3 меша:
1. Body — верхнее основание;
2. Border — цветное кольцо на верхнем основании;
3. Side — боковая поверхность;
Нижнее основание нет смысла генерировать, т.к. объекты не могут поворачиваться по осям x или y, а камера всегда находится над картой.
*Получаем вот такие многоугольники*
Время для оптимизаций:
Во-первых, я постоянно рассчитываю единичные вектора, повёрнутые на определённые углы.
Заводим класс AnglesCache с одним публичным методом:
```
namespace ObstacleGenerators {
public class AnglesCache {
public Vector3[] GetAngles(int sides);
}
}
```
Далее, кеширую все 3 типа мешей, в качестве ключей использую значимые параметры (количество сторон, цвет, круг ли это и т.д.). Цвет сохраняю в вершины, это позволит использовать для мешей один материал и, как следствие, динамический батчинг.
Правда теперь возникла проблема с границами и стенсилом: раньше я объединял границы с помощью стенсила, теперь, когда появился объём, этот подход даёт плохие результаты:
*Границы более высоких цилиндров не рисуются, т.к. под ними отрисованы основания низких цилиндров*
Перестаю пользоваться стенсил буфером. Теперь все границы обязательно отрисовываются:
*Без стенсил буфера*
И наконец, меняю в шейдере границ настройки ZTest с *On* (*LEqual*) на *Less*. Теперь границы не будут рисоваться поверх оснований цилиндров с такой же высотой. В результате получаю аккуратное объединение границ, которое корректно работает с объектами разной высоты:
*Объединение границ через настройки ZTest'а*
Наконец, последние штрихи:
1. В качестве uv координат для оснований цилиндров использую мировые координаты. У всех объектов получается общая текстура без швов;
2. Крашу боковую поверхность в высветленный цвет границы;
3. Добавляю к шейдеру боковой поверхности \_fixed3 \_LightPosition, чуть-чуть освещаю боковые поверхности (классический [метод тонирования Гуро](https://en.wikipedia.org/wiki/Gouraud_shading)). Тут, кстати, пригодился флаг isCircle в объектах: если он не установлен, у каждого треугольника уникальные вершины, если установлен — вершины общие. В результате нормали интерполируются и для isCircle получается сглаженная поверхность.
*Освещение, сглаживание, шейдеры и мировые uv координаты. (Освещение выкручено посильнее для наглядности)*
Последний штрих — генерируем для многоугольников PolygonCollider2D нужной формы.
Итого: трёхмерные многоугольники с физикой и аккуратным lowpoly стилем.
*Todo: тени.*
Level 3.1. Тени
---------------
Конечно, теперь прежние двумерные тени не подойдут:
*Плоские тени выглядят странно, т.к. не учитывают объёмность объекта*
А должны они выглядеть примерно вот так:
*Более реалистичные тени*
"Ну в в чём проблема?" — Спросите вы. "В Unity3D есть отличные тени!".
Действительно, есть. Вот только для построения теней используется алгоритм [Shadow mapping](https://en.wikipedia.org/wiki/Shadow_mapping). В двух словах: Если мы посмотрим на сцену *из* источника света, то все объекты, которые нам видны — освещены, а те, которые чем-то закрыты — в тени. Мы можем создать теневую карту, расположив камеру в координатах источника света и отрендерив сцену (в z-buffer'е окажутся данные расстоянии до источника света). Проблема в перспективном искажении. Чем дальше объекты от источника света, тем больше экранных пикселей соответствует текселям из теневой карты.
Т.е. тени не "pixel perfect", это не их фишка, куда важнее, что они очень быстрые. Обычно в искажениях нет проблемы, так как тени накладываются на сложные объекты с текстурой, в результате небольшая потеря качества не заметна. Но у меня очень светлые текстуры, очень мало полигонов, поэтому низкое качество теней прекрасно видно.
Впрочем, есть неплохое решение. Называется алгоритм "[Shadow volume](https://en.wikipedia.org/wiki/Shadow_volume)" и он очень похож на те двумерные тени, что я делал в прошлых статьях.
Пусть у нас есть некий меш, который должен отбрасывать тени от источника света.
1. Мы находим его силуэтные грани (те грани, которые разделяют освещённую часть меша и не освещённую);
2. "Вытягиваем" их от источника света (каждая грань превращается в 2 треугольника).
3. Рисуем все эти вытянутые грани (в color buffer не пишем ничего, из z-buffer'а только читаем, а вот в стенсил пишем):
3.1. Если нормаль треугольника направлена на камеру (front): добавляем в стенсил буфер единицу;
3.1. Если нормаль треугольника направлена от камеры (back): вычитаем из стенсил буфера единицу.
Получается, что если мы 1 раз "вошли" в тень (пересекли front треугольник) и один — "вышли" (пересекли back треугольник) — значение в стенсиле будет равно  и пиксель освещён. Если же мы вошли в тень большее количество раз, чем вышли (когда, перед между front и back находится какой-то треугольник, который отрисовался и записал данные в z-buffer) — пиксель в тени и его освещать не нужно.
Итак, нужно получить теневые меши от объектов, пройтись шейдером, добавив в стенсил нужные данные, а затем, отрисовать тень там, где в стенсиле ненулевое значение. Звучит как задача, решаемая на шейдерах!
*Todo: генерация теней на шейдерах.*
Level 3.2. Тени в вертексном шейдере
------------------------------------
Геометрический шейдер я использовать не стал, не хочется терять часть девайсов из-за того, что версия GL старая. Соответственно, все потенциальные грани придётся запекать заранее для каждого многоугольника.
**Минутка арифметики**
Пусть есть цилиндр с 32 углами. Каждая грань превращается в два треугольника и 4 вершины, итого:
Всего граней — 32 боковых, и 32 на каждом из двух оснований, 96 в сумме.
Значит, 96\*2 = 192 треугольника и 384 вершины на цилиндр. Довольно много.
На самом деле, ещё больше: изначально мы не знаем, какая из боковых граней будет переходом из света в тень (front), а какая — из тени в свет (back). Поэтому для каждой боковой грани приходится делать не 2 треугольника, а 4 (2 из них с противоположным направлением нормали), чтобы позже можно было корректно отсечь нужные с помощью Cull Back или Cull Front.
Поэтому 32 \* 4 = 128 граней, 256 треугольников и 512 вершин. Действительно много.
Создать нужный меш довольно просто, не буду акцентировать на этом внимание.
А вот шейдер получается очень любопытный.
Судите сами: нам не нужно отрисовывать все грани, только силуэтные (те, которые разделяют свет и тень). Значит, нам нужно для каждой вершины в вершинном шейдере:
1. Найти положение предыдущей грани;
2. Расчитать значения A, B, C для прямой, проходящей через текущую и предыдущую грань;
3. Определить, с какой стороны от прямой находится центр многоугольника;
4. Определить, с какой стороны от прямой находится источник света;
5. Повторить пункты 1-4 для следующей грани;
6. Сравнить значения — если одна из граней на свету (центр и источник в разных полуплоскостях), а другая в тени — данная вершина силуэтная и её нужно отрисовывать;
7. Узнать, нужно ли вытягивать текущую вершину, или она лежит на самом цилиндре;
8. Если вытягивать нужно, найти позицию вершины в мировых координатах, получить направление от источника света и переместить её по этому направлению на некое расстояние (например, 100 юнитов);
Для всех этих расчётов приходиться хранить большое количество данных в вершине:
координаты (или смещение) до предыдущей и следующей вершин, флаг — нужно ли смещать текущую вершину.
Представьте себе, работает!
Однако, этот способ создания теней содержит столько фатальных недостатков, что грустно становится:
1. **Огромное количество вершин и треугольников.** Чаще всего тень состоит из двух боковых граней, половины нижних и половины верхних граней. Для 32х угольного цилиндра и бесконечно удалённого источника света получается  точек и  треугольников. Вместо этого я отдаю на видеокарту 256 треугольников и 512 вершин.
2. **Не работает батчинг.** Для расчёта теней в вершинах должна тем или иным образом храниться информация о соседних вершинах (позиции и нормали). Соответственно, данные завязаны на локальные координаты в пространстве меша. При батчинге множество мешей объединяются (при этом меняется система координат на мировую) и теперь вершины уже не обладают информацией о положении соседних точек.
**Выглядит сломанный батчинг вот так.**
Большое количество вершин оказалось неприятным следствием выбранного метода, но сломаный батчинг забил последний гвоздь: 100-200 draw call'ов на тени для мобильного устройства — неприемлемый результат. Судя по всему, придётся переводить расчёты теней на CPU. Однако, так ли это плохо, как кажется? :)
*Todo: перенести генерацию теней на CPU.*
Level 3.2. Генерация теней на cpu
---------------------------------
Начну с решения в лоб.
1. Для каждой вершины:
1.1. Получить уравнение прямой проходящей через текущую и предыдущую вершину;
1.2. Проверить с одной ли стороны находятся центр многоугольника и источник света;
1.3. Взять результаты для предыдущей вершины и сравнить с текущей;
1.4. Если предыдущая грань освещена, а текущая — нет, сохранить вершину как силуэтную (lightToShadowIndex);
1.5.1 Если предыдущая грань в тени, а текущая на свету, сохранить вершину как силуэтную (shadowToLightIndex);
2. Верхнее основание цилиндра:
2.1. Для каждой грани от вершины lightToShadowIndex до вершины shadowToLightIndex добавить в список полигонов тени 2 треугольника (помните, каждую грань мы превращаем в 4х-угольник, где 2 вершины лежат на цилиндре, а 2 — вытягиваются, создавая тень);
3. Нижнее основание цилиндра:
3.1 Для каждой грани от вершины shadowToLightIndex до вершины lightToShadowIndex добавить в список полигонов тени 2 треугольника;
4. Боковая поверхность цилиндра:
4.1 Добавляем теневые треугольники для боковых граней под индексами shadowToLightIndex и lightToShadowIndex;
> Парочка замечаний:
>
> Если источник находится над цилиндром, боковых силуэтных граней не будет вовсе (зато будет целая тень от верхнего основания).
>
> Стоит ввести ограничения на положение источника света: если он окажется внутри цилиндра, тени станут некорректными.
Алгоритм работает, пришло время для оптимизаций. На данный момент, чтобы обеспечить 60fps при 10 объектах, нужно рассчитать 600 мешей за секунду. (Если не впечатлило — 6к за 10 секунд).
*Todo: Оптимизация теней, 60fps с включёнными тенями на моём nexus 5.*
Level 3.3. Оптимизации теней
----------------------------
**Удаляю лишнее:**
Самое очевидное — большинство цилиндров стоит на полу, а источник света всегда над полом. Перестаю генерировать тень от нижнего основания, если объект не висит в воздухе.
**Меньше тригонометрии:**
Избавляюсь от вездесущих синусов и косинусов. Воспользуюсь классом AnglesCache, описанным выше. Для любознательных вот его полный код:
**Кеш направлений**
```
using UnityEngine;
using System.Collections.Generic;
namespace ObstacleGenerators {
public class AnglesCache {
List cache;
const int MAX\_CACHE\_SIZE = 100;
public AnglesCache () {
cache = new List(MAX\_CACHE\_SIZE);
for (int i = 0; i < MAX\_CACHE\_SIZE; ++i)
cache.Add(null);
}
public Vector2[] GetAngles(int sides) {
if (sides < 0)
return null;
if (sides > MAX\_CACHE\_SIZE)
return GenerateAngles(sides);
if (cache[sides] == null)
cache[sides] = GenerateAngles(sides);
return cache[sides];
}
public float AngleOffset {
get { return Mathf.PI \* 0.25f; }
}
Vector2[] GenerateAngles(int sides) {
var result = new Vector2[sides];
float deltaAngle = 360.0f / sides;
float firstAngle = AngleOffset;
var matrix = Matrix4x4.TRS(Vector2.zero, Quaternion.Euler(0, 0, deltaAngle), Vector2.one);
var direction = new Vector2(Mathf.Cos(firstAngle), Mathf.Sin(firstAngle));
for (int i = 0; i < sides; ++i) {
result[i] = direction;
direction = matrix.MultiplyPoint3x4(direction);
}
return result;
}
}
}
```
**Расширяю кеш:**
Кеширую коэффициенты прямых (для расчёта освещённости граней). Теперь для поиска силуэтных граней достаточно получить позицию источника света в локальных координатах многоугольника, а затем пройтись по предрасcчитанному массиву прямых.
**Убираю медленные операции:**
Вместо использования Transform.TransformPoint в циклах использую матрицу transform.localToWorldMatrix и MultiplyPoint3x4.
Избавляюсь от неявных преобразований из Vector3 в Vector2 (куда дешевле кешировать трёхмерные вектора, чем делать каст внутри циклов), в большинстве случаев напрямую присваиваю компоненты вектора, а не сами вектора:
```
Vector2 v2;
Vector3 v3;
// присвоение компонент куда быстрее,
v2.x = v3.x;
v2.y = v3.y;
// чем вызов функции
v2.Set(v3.x, v3.y);
// и в разы быстрее, чем неявный каст
v2 = v3;
```
> Вообще, следите за операциями с векторами, они создают очень много новых структур, это бьёт по производительности.
**Оптимизирую поиск граней:**
Ещё одна крупная оптимизация. Очень много времени тратится на поиск силуэтных граней, однако, чаще всего тень рассчитывается для очень простой конфигурации:
1. Многоугольник правильный (size.x == size.y);
2. Источник света достаточно удалён от многоугольника.
По сути, правильный многоугольник — аппроксимация для окружности. А рассчитать силуэтные точки на грани — элементарно.
Алгоритм прост:
1. Проверяем, можем ли использовать быстрый поиск граней: size.x == size.y и источник света находится снаружи описанной окружности многоугольника;
2. Находим направление от источника света до центра многоугольника:
```
direction = lightPosition - obstacleCenter;
```
1. В прямоугольном треугольнике LCT (L — источник света, C — центр окружности, T — любая из двух касательных, проходящих через L) нам известны длины LC, CT (радиус). Рассчитываем *deltaAngle* — угол между LC и CT;
2. Считаем *directionAngle* — угол (относительно оси OX) прямой LC;
3. Считаем *firstAngle*, *secondAngle* — углы между центром окружности и точкой касания LT:
```
firstAngle = directionAngle - deltaAngle;
secondAngle = directionAngle + deltaAngle;
```
1. Дискретизируем полученные углы, шаг — 360° / edges, смещение — поворот многоугольника по оси z:
```
fromLightToShadow = Mathf.FloorToInt(firstAngle / pi2 * edges + edges) % edges;
fromShadowToLight = Mathf.FloorToInt(secondAngle / pi2 * edges + edges) % edges;
```
2. Силуэтная точка на описанной окружности лежит между двумя точками на многоугольнике, одна из которых является силуэтной. Но просто получить её, округлив firstAngle до ближайшего целого не получится: чем ближе источник цвета к многоугольнику, тем сильнее сказывается разница между описанной окружностью и самой фигурой. Поэтому проверяем, освещена ли грань, следующая за найденной точкой (fromLightToShadow и fromShadowToLight), при необходимости выбираем следующую за ней грань:
```
if (linesCache[fromLightToShadow].HalfPlainSign(lightPosition) < 0)
fromLightToShadow = (fromLightToShadow + 1) % edges;
if (linesCache[fromShadowToLight].HalfPlainSign(lightPosition) >= 0)
fromShadowToLight = (fromShadowToLight + 1) % edges;
```
В результате получаем индексы силуэтных вершин. Из тяжёлых операций — несколько тригонометрических преобразований (Acos, Atan2) и расчёт длины вектора. Зато — ни одного цикла. Куда понятнее станет, если посмотреть видео. Обратите внимание, что правильная силуэтная вершина не всегда ближайшая к силуэтной точке на описанной окружности:
*Работа алгоритма быстрого поиска силуэтных вершин.*
**Для поиска силуэтных граней получается вот такой код**
```
bool CanUseFastSilhouette(Vector2 lightPosition) {
if (size.x != size.y || edgesList != null)
return false;
return (lightPosition - (Vector2)transform.position).sqrMagnitude > size.x * size.x;
}
bool FindSilhouetteEdges(Vector2 lightPosition, Vector3[] angles, out int fromLightToShadow, out int fromShadowToLight) {
if (CanUseFastSilhouette(lightPosition))
return FindSilhouetteEdgesFast(lightPosition, angles, out fromLightToShadow, out fromShadowToLight);
return FindSilhouetteEdges(lightPosition, out fromLightToShadow, out fromShadowToLight);
}
bool FindSilhouetteEdgesFast(Vector2 lightPosition, Vector3[] angles, out int fromLightToShadow, out int fromShadowToLight) {
Vector2 center = transform.position;
float radius = size.x;
Vector2 delta = center - lightPosition;
float deltaMagnitude = delta.magnitude;
float sin = radius / deltaMagnitude;
Vector2 direction = delta / deltaMagnitude;
float pi2 = Mathf.PI * 2.0f;
float directionAngle = Mathf.Atan2(-direction.y, -direction.x) - anglesCache.AngleOffset - transform.rotation.eulerAngles.z * Mathf.Deg2Rad;
float deltaAngle = Mathf.Acos(sin);
float firstAngle = ((directionAngle - deltaAngle) % pi2 + pi2) % pi2;
float secondAngle = ((directionAngle + deltaAngle) % pi2 + pi2) % pi2;
fromLightToShadow = Mathf.RoundToInt(firstAngle / pi2 * edges - 1 + edges) % edges;
fromShadowToLight = Mathf.RoundToInt(secondAngle / pi2 * edges - 1 + edges) % edges;
return true;
}
```
*Оптимизирую меш:*
Так как теперь все расчёты происходят на cpu, можно использовать общие точки для смежных граней. Так, например, для цилиндра с 32мя гранями и далёким источником света, когда освещена половина цилиндра, получаю 42 вершины и 36 треугольников (сравните с 512 вершинами и 256 треугольниками при расчётах на gpu).
*Сокращаю количество вызовов:*
Если силуэтные грани не изменились, не нужно и перерассчитывать меш. А они довольно часто остаются неизменными — при небольших перемещениях источника света или многоугольника меняется только направление "вытягивания" тени. Сравниваю индексы силуэтных граней с их предыдущим значением и не рассчитываю тень, если в этом нет необходимости.
*Ещё сильнее сокращаю количество вызовов:*
Если не изменились *x* и *y* координаты у источника света (высота света не повлияет на силуэтные грани) и позиция многоугольника — не расcчитываем вообще ничего, даже силуэтные грани.
*Рассчитываю bounding box:*
Стандартный Mesh.RecalculateBounds для тени не подойдёт — ведь она вытягивается искусственно в шейдере. Попробую рассчитать AABB для тени самостоятельно.
Очередной нумерованный список:
1. Беру 4 точки на описанной окружности: две пересечении с прямой circleCenter — lightPosition, две на пересечении с перпендикуляром этой прямой;
2. Добавляю ещё 4 точки — копии первых 4-х, но смещённых по z на высоту многоугольника (все 8 точек в сумме — прямоугольный параллелепипед, описанный вокруг нашего многоугольника);
3. Для каждой точки получаю направление от источника света до текущей точки.
4. Продлеваю эту прямую до пересечения с полом (тут все просто, у него z == 0)
5. Получаю минимальные и максимальные значения координат для всех 16 точек — исходных, лежащих на параллелепипеде и их проекции на пол;
6. Эти координаты как раз описывают AABB тени.
> На самом деле, нижние точки не рассчитываются для многоугольников, стоящих на земле.
*Вид сверху (только нижние точки)*
*Вид сбоку (только нижние точки)*
*Bounding box приподнятых над землёй (нижние точки тоже рассчитываются) многоугольников*
Теперь те тени, которые не попадают на экран, будут отсекаться.
Заключение
----------
Я планировал написать про сам рендеринг теней, но у меня кончились кружочки, обозначающие разделы. )
Судя по ощущениям, скорость написания статьи примерно в полтора раза медленнее, чем написание проекта, поэтому материала для следующей части накопилось достаточно. Однако, я не буду спойлерить, лучше подведу итоги:
1. Я определился с основной игровой механикой и проверил её в прототипе;
2. Разобрался с визуальным стилем и поддержал его в коде;
3. Реализовал механику и визуализацию.
Несколько выводов по процессу разработки:
1. Я выбрасываю все лишние идеи и стараюсь не усложнять, но процедурная генерация тратит довольно много времени, это значительный минус;
2. Радуют возможности отладки и профилирования — они сохранили очень много времени;
3. Простое 3д — вполне подходящая ниша для человека, не умеющего моделировать;
4. Школьный курс геометрии — неимоверно полезная вещь.
5. Старайтесь визуализировать все алгоритмы (например, через Gizmos), это позволяет найти ошибки на ранних этапах.
Спасибо за внимание, встретимся в комментариях и следующей статье! ) | https://habr.com/ru/post/322262/ | null | ru | null |
# Загрузчик фотографий как vkontakte на Flex
Неделю назад мои знания action script ограничивались тем, как добавить событие onclick на баннер перед загрузкой в баннерную сеть. В качестве загрузчика файлов я использовал swfupload, и очень не хотел влезать внутрь swf-ника и разбираться в коде. Мне не нравится flash, я ни разу не дизайнер и теряюсь, когда вижу все эти слои, кадры, инструменты для рисования звездочек и motion guides.
Потом я наткнулся на эту [эту](http://www.rubenswieringa.com/blog/flex-book-component-beta) потрясающе-красивую штуку, и узнал, что есть [flex](http://www.adobe.com/products/flex/). И что flex — это круто, потому что даже такой супер-начинающий как я, с нуля за несколько дней смог написать загрузчик фотографий с предпросмотром, ресайзом на клиенте и upload-баром, примерно такой, какой используется на сайте [vkontakte.ru](http://vkontakte.ru/).
Есть три причины, из-за которых я решил использовать flash для загрузки фотографий. Это FileReference, FileReferenceList и flash.display.Bitmap. В 10-й версии флеш плеера у FileReference появилась функция load(), с помощью которой можно просматривать выбранные фотографии в ролике локально без загрузки на сервер. FileReferenceList позволяет в файловом диалоге с помощью shift-а выбрать сразу несколько фотографий. Bitmap делает ресайз картинок перед отправкой на сервер. Все это нельзя сделать на чистом javascript-е.
Итак, пишем загрузчик фотографий как vkontakte на flex (пошаговое пособие для совсем начинающих).
Прежде всего нужно поставить flex builder 3 ([здесь](http://www.adobe.com/products/flex/) есть версия, которой можно пользоваться 60 дней) и обновить флеш плеер до 10-й версии. Создадим новый flex project. Тип приложения — web application, тип сервера — none. Сразу же нужно исправить компилятор проекта, для этого выбираем Project->Properties->Flex Compiler и меняем параметр «Require Flash Player version» на 10.0.0. Если это не сделать, функция load() у объекта FileReference не будет работать.
Сначала расположим все необходимые элементы на странице, а потом будем писать скрипт. Зададим фиксированные размеры рабочей области (тегу application), внутрь поместим panel, внутрь панели — TileList, ProgressBar и ControlBar с кнопками «Выбрать фотографии», «Начать загрузку» и «Очистить». После TileList добавим HBox c элементами ProgressBar и кнопкой «отмена». Вот что получится.
> `</fontxml version="1.0" encoding="utf-8"?>
>
> <mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" width="540" height="465">
>
>
>
> <mx:Panel title="Загрузка фотографий"
>
> paddingTop="10" paddingLeft="10" paddingBottom="10" paddingRight="10"
>
> width="100%" height="100%">
>
>
>
> <mx:TileList
>
> alternatingItemColors="[#FFFFFF,#CCCCCC,#AAAAAA]"
>
> verticalScrollPolicy="on"
>
> columnWidth="120" columnCount="4" rowHeight="110" rowCount="3" />
>
>
>
> <mx:HBox horizontalAlign="center" width="100%">
>
> <mx:ProgressBar />
>
> <mx:Button label="Отмена" />
>
> mx:HBox>
>
>
>
> <mx:ControlBar horizontalAlign="right">
>
> <mx:Button label="Выбрать фотографии" />
>
> <mx:Button label="Начать загрузку" />
>
> <mx:Button label="Очистить" />
>
> mx:ControlBar>
>
> mx:Panel>
>
> mx:Application>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Скроем ProgressBar и будем показывать его только когда нажимаем на кнопку «начать загрузку (visible =»false"). Сделаем enabled=«false» у кнопок «начать загрузку» и «очистить» (они будут активны только когда список фотографий непуст). Добавим id-шники ко всем важным элементам.
Добавим тег и будем в нем писать код. Подключим flash.net.FileReferenceList и mx.collections.ArrayCollection и заведем главную глобальную переменную photos типа ArrayCollection.
> `<mx:Script>
>
> [CDATA[
>
>
>
> import flash.net.FileReferenceList;
>
> import mx.collections.ArrayCollection;
>
>
>
> [Bindable]
>
> private var photos:ArrayCollection = new ArrayCollection;
>
>
>
> ]]>
>
> mx:Script>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
[Bindable] означает, что переменная photos может быть связана с другими элементами. Укажем ее в качестве dataProvider-а к TileList, и тогда все изменения в массиве photos будут автоматически отражаться в TileList.
Добавим глобальную переменную frList типа FileReferenceList. На клик по кнопке «Выбрать фотографии» добавим функцию selectPhotos. Для того, чтобы отлавливать событие, когда в frList.browse() в файловом диалоге завершается выбор фоток, у frList нужно указать addEventListener(Event.COMPLETE,addPhotos). Необязательным параметром функции frList.browse() служит массив объектов типа FileFilter, там можно задать маску для названий файлов. Наконец напишем функцию addPhotos, которая будет перебирать все файлы, выбранные в frList.fileList и добавлять их в массив photos. Вот что получится.
> `import mx.events.CollectionEvent;
>
> import flash.net.FileReferenceList;
>
> import mx.collections.ArrayCollection;
>
>
>
> [Bindable]
>
> private var photos:ArrayCollection = new ArrayCollection;
>
> private var frList:FileReferenceList = new FileReferenceList;
>
>
>
> private function init():void
>
> {
>
> frList.addEventListener(Event.SELECT,addPhotos);
>
> }
>
>
>
> private function selectPhotos():void
>
> {
>
> frList.browse([new FileFilter("Изображения jpeg","\*.jpg;\*.jpeg")]);
>
> }
>
>
>
> private function addPhotos():void
>
> {
>
> for (var i:uint = 0; i < frList.fileList.length; i++)
>
> {
>
> var elem:Object = new Object;
>
> elem.fr:FileReference = FileReference(frList.fileList[i]);
>
> photos.addItem(elem);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Нужно, чтобы кнопки «Начать загрузку» и «Отмена» были активны только когда массив photos не пуст. В Функцию инициализации добавим обработчик:
> `photos.addEventListener(CollectionEvent.COLLECTION\_CHANGE,function()
>
> {
>
> startUploadButton.enabled = (photos.length>0);
>
> clearPhotosButton.enabled = (photos.length>0);
>
> });
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь напишем itemRenderer для нашего TileList. itemRenderer отвечает за то, каким образом показывать элемент массива photos в ячейке TileList. Вынесем код itemRenderer-а в отдельный MXML компонент. Сделаем File->New->MXML Component с именем photoThumb, based on Canvas width 120 height 110. В TileList добавим свойство itemRenderer со значением photoThumb.
Теперь будем писать код компонента. Сделаем, чтобы при наведении на каждую фотографию на ней возникала панель с управляющими кнопочками (у нас пока будет только одна кнопка «удалить»). Соответствующий элемент массива, к которому вызывается itemRenderer, находится в глобальной переменной data. У нас каждый такой элемент — это объект с единственным свойством fr типа FileReference. Соответственно, чтобы в ячейке указать имя файла, нужно написать . Публичные функции родителя вызываются через parentDocument. Вот полный код itemRenderer-а, бекграунд у родительского Canvas-а задан для того, чтобы корректно обрабатывался rollOver.
> `</fontxml version="1.0" encoding="utf-8"?>
>
> <mx:Canvas xmlns:mx="http://www.adobe.com/2006/mxml"
>
> width="120" height="110"
>
> backgroundColor="#FFFFFF" backgroundAlpha="0"
>
> rollOver="{controls.visible=true}" rollOut="{controls.visible=false}">
>
>
>
> <mx:VBox width="100%" height="75" y="5" horizontalAlign="center">
>
> <mx:Image source="{data.fr.data}" maxWidth="100" maxHeight="75" horizontalAlign="center" verticalAlign="middle" />
>
> mx:VBox>
>
> <mx:Label text="{data.fr.name}" width="100%" truncateToFit="true" bottom="0" textAlign="center" />
>
>
>
> <mx:VBox id="controls" visible="false" y="65" right="10" horizontalAlign="right">
>
> <mx:Button label="X" click="parentDocument.clearPhoto(data)" fontSize="6" width="30" height="15" />
>
> mx:VBox>
>
> mx:Canvas>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Все работает кроме того, что при выборе больших фоток они не успевают загрузиться, и TileList их не показывает. Чтобы это исправить, добавим в функцию addPhotos обновление TileList после загрузки каждой фотографии:
> `private function addPhotos(e:Event):void
>
> {
>
> for (var i:uint = 0; i < frList.fileList.length; i++)
>
> {
>
> var elem:Object = new Object;
>
> elem.fr = FileReference(frList.fileList[i]);
>
> elem.fr.load();
>
> elem.fr.addEventListener(Event.COMPLETE,refreshThumb);
>
> photos.addItem(elem);
>
> }
>
> }
>
>
>
> private function refreshThumb(e:Event):void
>
> {
>
> photosList.invalidateList();
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Добавим простые функции удаления всех фоток и удаления выбранной фотки, используя методы removeAll, removeItemAt и getItemIndex у класса ArrayCollection. При этом функция, которая вызывается из itemRender-а, должна быть публичной.
> `private function clearPhotos():void
>
> {
>
> photos.removeAll();
>
> }
>
>
>
> public function clearPhoto(data:Object):void
>
> {
>
> photos.removeItemAt(photos.getItemIndex(data));
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
На данном этапе получено работающее приложение, которое показывает иконки файлов и работает локально. Мультиселект при выборе файлов тоже работает. Осталось добавить загрузку выбранных файлов на сервер и задействовать ProgressBar. Это просто. При нажатии на кнопку «Начать загрузку» будем брать первый элемент из photos, создавать URLRequest, вызывать у FileReference метод upload и добавим event listener-ы, которые будут управлять прогресс-баром и отслеживать, когда файл загрузится. После загрузки удаляем первый элемент из photos и запускаем все заново. Вот код:
> `private function startUpload():void
>
> {
>
> photosProgressContainer.visible = true;
>
>
>
> var fr:FileReference = photos.getItemAt(0).fr;
>
> fr.cancel();
>
> fr.addEventListener(ProgressEvent.PROGRESS,uploadProgress);
>
> fr.addEventListener(DataEvent.UPLOAD\_COMPLETE\_DATA,uploadComplete);
>
> fr.upload(new URLRequest("http://ragneta.com/tests/flexupload/upload.php"));
>
> }
>
>
>
> private function uploadProgress(e:ProgressEvent):void
>
> {
>
> photosProgress.setProgress(e.bytesLoaded,e.bytesTotal);
>
> }
>
>
>
> private function uploadComplete(e:DataEvent):void
>
> {
>
> photos.removeItemAt(0);
>
> if (photos.length > 0)
>
> startUpload();
>
> else
>
> photosProgressContainer.visible = false;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
На этом все, здесь полный код: [Uploader.mxml](http://ragneta.com/tests/flexupload/Uploader.txt), [photoThumb.mxml](http://ragneta.com/tests/flexupload/photoThumb.txt). Дальше в ролик нужно передавать какую-нибудь авторизацию, я передаю идентификатор сессии через flashvars, соответственно во flex переданные переменные находятся в массиве Application.application.parameters. Затем в инициализации делаю HTTPRequest, отправляю сессию и получаю имя юзера, его альбомы и все остальное. Также нужно отлавливать ошибки и исключения, разбирать ответ сервера итд. Здесь написан только необходимый минимум.
Если нет необходимости загружать исходники фотографий, можно делать ресайз до отправки на сервер. Делается с помощью flash.display.Bitmap, вот [пример](http://flexgraphix.com/blog/?p=51).
В процессе подготовки поста обнаружил странный баг. Прогресс-бар и событие FileReference.cancel() некорректно работают на WinVista + FF 3.5.7 + Flash Player 10.0.42, но на аналогичном WinXP + FF 3.5.7 + Flash Player 10.0.42 все хорошо.
Также пока не решил проблему с поворотом изображений. Во-первых не нашел, как делать анимированное преобразование через задание новой image.transform.matrix. Вторая проблема — мой Rotate применяется не к данным, которые передаются в itemRenderer, а к тегу самого itemRenderera. Если повернуть картинку, а потом ее удалить и загрузить на ее место новую, она окажется повернутой. При этом событие initialize каждой ячейки происходит только один раз. Приходится в itemRenderer на dataChange вешать поворот в 0, хотя хватило бы, если бы TileList умел полностью уничтожать ячейки при удалении данных, и потом проводить повторную инициализацию. | https://habr.com/ru/post/80954/ | null | ru | null |
# Следующий уровень автоматизации Kubernetes. Создаем свой оператор
Оператором в Kubernetes принято называть развертывание, которое самостоятельно управляет ресурсами кластера, регистрирует новые Custom Resource Definition (CRD) и, в некоторых случаях, добавляется для наблюдения за существующими ресурсами (через механизмы Dynamic Admission Control). В этой статье на примере создания оператора для развертывания и управления кластером Aerospike мы попробуем разобраться с этапами создания оператора, способами взаимодействия с кластером и проблемами, с которыми можно встретиться в реальной практике. Всех практикующих DevOps и желающих поднять автоматизацию развертывания своих сервисов на новый уровень приглашаю под кат.
Прежде всего нужно определить, какую функциональность будет поддерживать будущий оператор. Поскольку база данных Aerospike допускает работу в режиме кластера, будет разумно создать CRD для описания характеристик кластера (количество подов, ограничения по памяти и процессору и др), конфигурации пространства имен, а также настройки резервного копирования. Также оператор должен отслеживать изменения в существующих ресурсах, связанных с ним, и динамически изменять топологию системы и/или настройки подов.
Для разработки оператора мы будем использовать язык программирования Go и набор инструментов [Operator SDK](https://sdk.operatorframework.io/docs/installation/), который нужно будет предварительно установить:
```
git clone https://github.com/operator-framework/operator-sdk
cd operator-sdk
make install
```
После установки SDK можно выполнить инициализацию заготовки проекта оператора:
```
operator-sdk init --domain dzolotov.tech --owner "Dmitrii Zolotov"
```
Поскольку мы предполагаем создание дополнительных типов ресурсов, необходимо определить идентификатор версии API, который представляет собой URI на произвольном домене. Для удобства использования operator-sdk можно сразу установить поддержку автодополнения в shell Debian/Ubuntu:
```
apt install bash-completion
echo 'source <(operator-sdk completion bash)' >>~/.bashrc
```
Operator SDK поддерживает создание операторов для разных DevOps-решений, включая Ansible и Helm, для этого при инициализации можно указывать необходимые плагины. Также инструмент командной строки позволяет выполнять развертывание оператора (`operator-sdk olm`), запуск оператора в выбранном контексте (`operator-sdk run`) и выполнять тесты (`operator-sdk scorecard`). Также можно создавать фрагменты кода для реализации разных типов Kubernetes-ресурсов. Начнем с создания версии apiVersion:
```
operator-sdk create api --group aerospike --version v1alpha1 --kind AerospikeCluster --resource --controller
```
Генератор создает несколько файлов для взаимодействия с Kubernetes API:
* `api/v1alpha1/aerospikecluster_types.go` - описание типов (CRD);
* `controllers/aerospikecluster_controller.go` - контроллер для создания и отслеживания типов CRD;
* `/go.mod` - содержит зависимости для подключения к API (k8s.io/apimachinery - доступ к API для управления ресурсами, k8s.io/client-go - Go-клиент для взаимодействия с API, sigs.k8s.io/controller-runtime - базовые классы для реализации контроллера, github.com/onsi/ginkgo - тестовый фреймворк для проверки оператора).
Попробуем сгенерировать манифесты для Kubernetes, которые будут определять Custom Resource Definition и развертывания оператора: `make manifests`. Результатом выполнения будет генерация файлов в crd/bases - регистрация CRD-ресурсов (`apiextensions.k8s.io/v1/CustomResourceDefinition`) с названием `aerospikeclusters.aerospike.dzolotov.tech` для создаваемого API (группа aerospike.my.domain, тип ресурса `AerospikeCluster`). По умолчанию схема ресурса содержит строковое поле foo, далее мы переопределим схему в коде описания типов на Go:
```
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
annotations:
controller-gen.kubebuilder.io/version: v0.8.0
name: aerospikeclusters.aerospike.my.domain
spec:
group: aerospike.dzolotov.tech
names:
kind: AerospikeCluster
listKind: AerospikeClusterList
plural: aerospikeclusters
singular: aerospikecluster
# будет локальным для namespace (может быть Cluster для создания ресурса на уровне кластера, без привязки к namespace)
scope: Namespaced
versions:
# создаваемая версия CRD
- name: v1alpha1
schema:
# описание схемы yaml-документа
openAPIV3Schema:
description: AerospikeCluster is the Schema for the aerospikeclusters API
properties:
# версия api (позволит делать разные версии для API)
apiVersion:
description: 'APIVersion defines the versioned schema of this representation
of an object. Servers should convert recognized schemas to the latest
internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources'
type: string
# тип ресурса (в нашем случае будет AerospikeCluster)
kind:
description: 'Kind is a string value representing the REST resource this
object represents. Servers may infer this from the endpoint the client
submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds'
type: string
# описание метаданных (.meta) - определяется по схеме metav1.ObjectMeta
metadata:
type: object
# описание спецификации кластера (.spec) - в соответствии со схемой
spec:
description: AerospikeClusterSpec defines the desired state of AerospikeCluster
properties:
# свойства спецификации кластера (.spec)
foo:
description: Foo is an example field of AerospikeCluster. Edit aerospikecluster_types.go
to remove/update
type: string
type: object
# назначение ключа объекта yaml .status (пустой объект)
status:
description: AerospikeClusterStatus defines the observed state of AerospikeCluster
type: object
type: object
# флаг актуальности версии CRD
served: true
# версия по умолчанию
storage: true
```
Примером корректного ресурса с использованием указанного CRD:
```
apiVersion: aerospike.my.domain/alpha1
kind: AerospikeCluster
metadata:
name: demo
spec:
foo: bar
status: {}
```
Прежде чем мы пойдем рассматривать код контроллера дополним схему данных и добавим следующие поля:
* deployments (int) - количество серверов в кластере;
* maxMemory (int) - ограничение по размеру памяти (в Гб);
* maxCPU (string) - ограничение по использованию процессора;
* logging (string) - уровень протоколирования;
* compressionLevel (int) - уровень сжатия;
* replicationFactor (int) - фактор репликации для кластера;
* strongConsistency (bool) - включение режима строгой согласованности (в ущерб производительности);
* heartbeat:
+ interval (int) - интервал для проверки доступности соседних узлов (в миллисекундах).
* keepalive:
+ enabled (bool) - разрешено использование keepalive-сообщений;
+ interval (int) - интервал в секундах между сообщениями.
Для демонстрации такого набора будет достаточно, в реальном кластере разумеется нужно предусмотреть наличие всех необходимых опций для конфигурации узлов. Структура данных для спецификации кластера определяется в файле api/alphav1/aerospikecluster\_types.go, сейчас там даны определения для всех создаваемых типов данных (кластер, список кластеров и связанные с ними типы):
```
package v1alpha1
import (
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
//ожидаемое состояние кластера (спецификация)
type AerospikeClusterSpec struct {
Foo string `json:"foo,omitempty"`
}
//текущее состояние кластера
type AerospikeClusterStatus struct {
}
//+kubebuilder:object:root=true
//+kubebuilder:subresource:status
type AerospikeCluster struct {
metav1.TypeMeta `json:",inline"`
//стандартное определение метаданных (namespace, name, annotations, ...)
metav1.ObjectMeta `json:"metadata,omitempty"`
//кластер содержит спецификацию и текущий статус
Spec AerospikeClusterSpec `json:"spec,omitempty"`
Status AerospikeClusterStatus `json:"status,omitempty"`
}
//+kubebuilder:object:root=true
type AerospikeClusterList struct {
metav1.TypeMeta `json:",inline"`
metav1.ListMeta `json:"metadata,omitempty"`
Items []AerospikeCluster `json:"items"`
}
//регистрация типов объектов и их схем
func init() {
SchemeBuilder.Register(&AerospikeCluster{}, &AerospikeClusterList{})
}
```
Добавим необходимые поля (и структуры) в структуру AerospikeClusterSpec и обозначим в статусе текущее состояние кластера: deployed (bool) - устанавливается в true когда развертывание завершено, brokenNodes (int) - количество недоступных узлов. Обновим определение типов и выполним повторно команду make в корневом каталоге проекта, это приведет к выполнению форматирования и проверки синтаксиса файлов.
```
type AerospikeHeartBeat struct {
// Heartbeat interval in milliseconds
Interval int `json:"interval,omitempty"`
}
type AerospikeKeepAlive struct {
// Keep alive is enabled
Enabled bool `json:"enabled,omitempty"`
// Keep alive messages interval in seconds
Interval int `json:"interval,omitempty"`
}
// ожидаемое состояние кластера (спецификация)
type AerospikeClusterSpec struct {
// Deployments count
Deployments int `json:"deployments,omitempty"`
// Maximum memory limit in GB (for example, 4)
MaxMemory *int `json:"maxMemory,omitempty"`
// Maximum cpu limit (100 = full power)
MaxCPU *int `json:"maxCPU,omitempty"`
// Logging level (https://docs.aerospike.com/reference/configuration)
Logging *string `json:"logging,omitempty"`
// Compression level (1 - lower compression, 9 - higher, but slower compression)
CompressionLevel *int `json:"compressionLevel,omitempty"`
// Min replicas count
ReplicationFactor int `json:"replicationFactor,omitempty"`
// Enable strong consistency mode
StrongConsistency bool `json:"strongConsistency,omitempty"`
// Heartbeat configuration
HeartBeat *AerospikeHeartBeat `json:"heartbeat,omitempty"`
// Keepalive configuration
Keepalive *AerospikeKeepAlive `json:"keepalive,omitempty"`
}
// текущее состояние кластера
type AerospikeClusterStatus struct {
// All nodes are prepared and ready
Deployed bool `json:"deployed"`
// How many nodes isn't available
BrokenNodes int `json:"brokenNodes"`
}
```
После применения make manifests можем убедиться, что описание создания CRD-ресурса соответствует измененной схеме (фрагмент приведен ниже):
```
compressionLevel:
description: Compression level (1 - lower compression, 9 - higher,
but slower compression)
type: integer
deployments:
description: Deployments count
type: integer
heartbeat:
description: Heartbeat configuration
properties:
interval:
description: Heartbeat interval in milliseconds
type: integer
type: object
```
При необходимости создать дополнительную версию существующего ресурса или создать новый можно использовать как инструмент operator-sdk create api, так и создавать дополнительные каталоги и файлы на основе существующего шаблона.
Дальше посмотрим на контроллер и тут ключевую роль играет Reconciler, который выполняет изменение конфигурации в соответствии с разностью между текущим и ожидаемым состоянием. Кроме это для проверки корректности согласованности спецификации может быть добавлено использование webhook и здесь нужно сделать небольшое введение в Dynamic Admission Control. Динамическое управление позволяет зарегистрировать два вида дополнительных обработчиков во время операций над ресурсами - ValidatingWebhook (проверяет корректность схемы создаваемого ресурса, позволяет отменить операцию при нарушении схемы) и MutatingWebhook (допускает возможность внесения изменений в ресурс перед развертыванием, например используется для встраивания sidecar-контейнеров в операторе управления резервным копированием Stash, который мы рассматривали в [этой статье](https://habr.com/ru/company/otus/blog/668308/)). Operator SDK позволяет также создавать и регистрировать webhook и даже генерировать заготовку ValidatingWebhook для проверки согласованности данных .
```
operator-sdk create webhook --group aerospike --version v1alpha1 --kind AerospikeCluster --defaulting --programmatic-validation
```
После вызова генератора создается файл aerospikecluster\_webhook.go, в котором нужно будет реализовать функции проверки конфигурации при создании ValidateCreate(), при обновлении ValidateUpdate() и при удалении ValidateDelete(). Добавим дополнительную проверку, что количество реплик не превышает количество узлов и количество узлов является натуральным числом. В результате получим следующий код:
```
package v1alpha1
import (
apierrors "k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/apimachinery/pkg/util/validation/field"
ctrl "sigs.k8s.io/controller-runtime"
logf "sigs.k8s.io/controller-runtime/pkg/log"
"sigs.k8s.io/controller-runtime/pkg/webhook"
"strconv"
)
// log is for logging in this package.
var aerospikeclusterlog = logf.Log.WithName("aerospikecluster-resource")
func (r *AerospikeCluster) SetupWebhookWithManager(mgr ctrl.Manager) error {
return ctrl.NewWebhookManagedBy(mgr).
For(r).
Complete()
}
//+kubebuilder:webhook:path=/mutate-aerospike-dzolotov-tech-v1alpha1-aerospikecluster,mutating=true,failurePolicy=fail,sideEffects=None,groups=aerospike.dzolotov.tech,resources=aerospikeclusters,verbs=create;update,versions=v1alpha1,name=maerospikecluster.kb.io,admissionReviewVersions=v1
var _ webhook.Defaulter = &AerospikeCluster{}
//здесь можно применить значения по умолчанию (выполняется до валидации)
func (r *AerospikeCluster) Default() {
aerospikeclusterlog.Info("default", "name", r.Name)
}
// TODO(user): change verbs to "verbs=create;update;delete" if you want to enable deletion validation.
//+kubebuilder:webhook:path=/validate-aerospike-dzolotov-tech-v1alpha1-aerospikecluster,mutating=false,failurePolicy=fail,sideEffects=None,groups=aerospike.dzolotov.tech,resources=aerospikeclusters,verbs=create;update,versions=v1alpha1,name=vaerospikecluster.kb.io,admissionReviewVersions=v1
var _ webhook.Validator = &AerospikeCluster{}
func (r *AerospikeCluster) validateReplicas() error {
var allErrs field.ErrorList
if r.Spec.ReplicationFactor > r.Spec.Deployments {
fldPath := field.NewPath("spec").Child("replicationFactor")
allErrs = append(allErrs, field.Invalid(fldPath, strconv.Itoa(r.Spec.ReplicationFactor), "Replication factor must be lower than deployments count"))
}
if r.Spec.Deployments < 1 {
fldPath := field.NewPath("spec").Child("deployments")
allErrs = append(allErrs, field.Invalid(fldPath, strconv.Itoa(r.Spec.ReplicationFactor), "Deployments counter must be greater than zero"))
}
if len(allErrs) == 0 {
return nil
}
return apierrors.NewInvalid(schema.GroupKind{Group: "aerospike.dzolotov.tech", Kind: "AerospikeCluster"}, r.Name, allErrs)
}
//проверка при создании нового ресурса
func (r *AerospikeCluster) ValidateCreate() error {
aerospikeclusterlog.Info("validate create", "name", r.Name)
return r.validateReplicas()
}
//проверка при обновлении ресурса
func (r *AerospikeCluster) ValidateUpdate(old runtime.Object) error {
aerospikeclusterlog.Info("validate update", "name", r.Name)
return r.validateReplicas()
}
//проверка при удалении ресурса (сейчас отключена в метаданных kubebuilder)
func (r *AerospikeCluster) ValidateDelete() error {
aerospikeclusterlog.Info("validate delete", "name", r.Name)
return nil
}
```
Здесь мы используем механизм apierrors, рекомендуемый Kubernetes для подробного описания ошибки и места ее возникновения, который позволяет объединить все ошибки в один объект, но можно было использовать и обычный объект ошибки. Обратите внимание на комментарии //+kubebuilder:webhook, они содержат метаданные, которые используются для генерации манифеста и здесь, например, можно изменить список валидаций (сейчас используются только create,update, но при необходимости можно сделать валидацию на удаление (например, так можно запретить удаление ресурса, но лучше такого не делать). После вызова make / make manifests посмотрим на сгенерированный файл манифеста для установки AdmissionWebhooks:
```
apiVersion: admissionregistration.k8s.io/v1
kind: MutatingWebhookConfiguration
metadata:
creationTimestamp: null
name: mutating-webhook-configuration
webhooks:
- admissionReviewVersions:
- v1
clientConfig:
service:
name: webhook-service
namespace: system
path: /mutate-aerospike-dzolotov-tech-v1alpha1-aerospikecluster
failurePolicy: Fail
name: maerospikecluster.kb.io
rules:
- apiGroups:
- aerospike.dzolotov.tech
apiVersions:
- v1alpha1
operations:
- CREATE
- UPDATE
resources:
- aerospikeclusters
sideEffects: None
---
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingWebhookConfiguration
metadata:
creationTimestamp: null
name: validating-webhook-configuration
webhooks:
- admissionReviewVersions:
- v1
clientConfig:
service:
name: webhook-service
namespace: system
path: /validate-aerospike-dzolotov-tech-v1alpha1-aerospikecluster
failurePolicy: Fail
name: vaerospikecluster.kb.io
rules:
- apiGroups:
- aerospike.dzolotov.tech
apiVersions:
- v1alpha1
operations:
- CREATE
- UPDATE
resources:
- aerospikeclusters
sideEffects: None
```
Здесь можно увидеть, что и MutatingWebhook и ValidatingWebhook применяются на ресурсы в apiVersion: aerospike.dzolotov.tech/v1alpha1 при операциях создания и обновления на ресурсах aerospikecluster. Теперь посмотрим на другие подкаталоги в config и поговорим о правах доступа (RBAC) и развертывании контроллера.
* `certmanager` - манифест для издания сертификата для валидации webhook (создается автоматически), привязывается к сервису контроллера;
* `crd` - описание типов ресурсов (CRD), мы рассмотрели его выше, но добавлю что кроме наших определений есть еще патчи, которые позволяют пробросить созданный через certmanager сертификат в аннотации ресурса для использования в коде;
* `default` - содержит патчи для контроллера, которые публикуют webhook-сервер и разворачивают system/controller-manager из gcr.io/kubebuilder/kube-rbac-proxy:v0.11.0;
* `manifests` - конфигурация для kustomization, который создает манифесты при сборке финального артефакта для установки оператора;
* `prometheus` - регистрация ServiceMonitor для экспорта метрик из controller-manager в prometheus;
* `rbac` - набор прав для обеспечения доступа контроллера к управлению ресурсами aerospikeclusters, а также для публикации метрик, сервисной записи для выполнения controller-manager и др.;
* `scorecard` - конфигурация для запуска тестов через OLM (Operator Lifecycle Manager, позволяет управлять запуском и тестирование операторов внутри существующего кластера kubernetes);
* `webhook` - конфигурация для регистрации AdminissionWebhooks (рассмотрели ранее).
Коротко об RBAC (Role-Based Access Control) - это внутренний механизм контроля доступа Kubernetes, который определяет понятие Role (или ClusterRole, если без привязки к пространству имен), перечисляющее какие действия и над какими ресурсами могут быть выполнены и RoleBinding (ClusterRoleBinding) для связывания учетной записи пользователи или сервисной записи (ServiceAccount) с соответствующей ролью. Таким образом, чтобы оператор мог создавать новые ресурсы Deployment, требуется определить роль с разрешениями на create/update/patch/delete для ресурсов kind: Deployment в apiVersion: apps/v1 и связать ее с сервисной записью, под которой происходит развертывание оператора. Для управление нашим контроллером будет запущен процесс controller-manager, он также будет отслеживать доступность контроллера и перезапускать его при необходимости.
Вернемся теперь к контроллеру (controllers/aerospikecluster\_controller.go) и посмотрим внимательно на его структуру:
```
package controllers
import (
"context"
"k8s.io/apimachinery/pkg/runtime"
ctrl "sigs.k8s.io/controller-runtime"
"sigs.k8s.io/controller-runtime/pkg/client"
"sigs.k8s.io/controller-runtime/pkg/log"
aerospikev1alpha1 "github.com/operator-framework/operator-sdk/api/v1alpha1"
)
// Объект реконсилера для приведения кластера к ожидаемому состоянию
type AerospikeClusterReconciler struct {
client.Client
Scheme *runtime.Scheme
}
// Описание разрешений (будут транслированы в роли)
//+kubebuilder:rbac:groups=aerospike.dzolotov.tech,resources=aerospikeclusters,verbs=get;list;watch;create;update;patch;delete
//+kubebuilder:rbac:groups=aerospike.dzolotov.tech,resources=aerospikeclusters/status,verbs=get;update;patch
//+kubebuilder:rbac:groups=aerospike.dzolotov.tech,resources=aerospikeclusters/finalizers,verbs=update
func (r *AerospikeClusterReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
_ = log.FromContext(ctx)
//здесь будет наш код управления кластером
return ctrl.Result{}, nil
}
// Регистрация с использованием ControllerManager
func (r *AerospikeClusterReconciler) SetupWithManager(mgr ctrl.Manager) error {
return ctrl.NewControllerManagedBy(mgr).
For(&aerospikev1alpha1.AerospikeCluster{}).
Complete(r)
}
```
Поскольку мы будем управлять развертыванием кластера серверов (будем использовать StatefulSet, поскольку нам важно сохранить связь экземпляра пода и его местоположения, также нам будет нужно иметь возможность создания и изменения ConfigMap для определения конфигурации сервера по параметрам из манифеста), то нам нужно будет сообщить контроллеру о том, что мы будем наблюдать за ресурсами StatefulSet и Pod и добавить соответствующие правила в комментариях +kubebuilder. Прежде всего добавим импорт структур, описывающих пространство имен apps/v1 и core/v1 (для ConfigMap):
```
import (
"context"
appsv1 "k8s.io/api/apps/v1"
corev1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/runtime"
ctrl "sigs.k8s.io/controller-runtime"
"sigs.k8s.io/controller-runtime/pkg/client"
"sigs.k8s.io/controller-runtime/pkg/log"
aerospikev1alpha1 "github.com/operator-framework/operator-sdk/api/v1alpha1"
)
```
И сообщим менеджеру о том, что мы будем управлять объектами StatefulSet и ConfigMap:
```
func (r *AerospikeClusterReconciler) SetupWithManager(mgr ctrl.Manager) error {
return ctrl.NewControllerManagedBy(mgr).
For(&aerospikev1alpha1.AerospikeCluster{}).
Owns(&appsv1.StatefulSet{}).
Owns(&corev1.ConfigMap{}).
Complete(r)
}
```
И добавим метаданные перед методом Reconcile для описания требуемых прав доступа:
```
//+kubebuilder:rbac:groups=apps/v1,resources=statefulsets,verbs=get;list;watch;create;update;patch;delete
//+kubebuilder:rbac:groups=apps/v1,resources=pods,verbs=get;list
//+kubebuilder:rbac:groups=v1,resources=configmaps,verbs=get;list;create;update;patch;delete
```
Сама реализация будет использовать публичные методы API Kubernetes, прежде всего для нас интересны методы:
* `r.List(ctx, objectList, opts)` - возвращает список объектов в objectList с отбором по opts (требует разрешения list на этот тип объектов в RBAC-роли), например:
```
podList := &v1.PodList{}
opts := []client.ListOption{
client.InNamespace(request.NamespacedName.Namespace),
client.MatchingLabels{"instance": request.NamespacedName.Name},
client.MatchingFields{"status.phase": "Running"},
}
err := r.List(ctx, podList, opts...)
```
Выбирает все запущенные поды с меткой instance и значением, совпадающих с именем кластера (поиск осуществляется в том же пространстве имен, где развернут ресурс AerospikeCluster).
* `r.Get(ctx, namespacedName, object)` - сохраняет объект в object, идентификацию объекта выполняет NamespacedName, включающий пространство имен Namespace и имя внутри него Name (требует разрешение get на этот тип объектов в RBAC-роли);
* `r.Create(ctx, object, opts)` - создает новый объект в кластере (требуется наличие разрешений create на этот тип объекта в RBAC-роли), например:
```
func (r *AerospikeClusterReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
_ = log.FromContext(ctx)
//прочитаем ресурс описания кластера
cluster := &aerospikev1alpha1.AerospikeCluster{}
err := r.Get(ctx, req.NamespacedName, cluster)
if err != nil {
return ctrl.Result{}, err
}
//преобразование числовых полей в строки и в тип int32 для передачи в структуру
//описания StatefulSet
var deployments int32
deployments = int32(cluster.Spec.Deployments)
var replicationFactor string
replicationFactor = strconv.Itoa(cluster.Spec.ReplicationFactor)
var maxMemory string
maxMemory = strconv.Itoa(*cluster.Spec.MaxMemory)
var maxCpu string
maxCpu = strconv.Itoa(*cluster.Spec.MaxCPU)
//описание нового объекта StatefulSet
sts := appsv1.StatefulSet{ObjectMeta: ctrl.ObjectMeta{Namespace: req.NamespacedName.Namespace, Name: req.NamespacedName.Name}, Spec: appsv1.StatefulSetSpec{
Replicas: &deployments,
Selector: &v1.LabelSelector{
MatchLabels: map[string]string{"label": req.Name},
},
Template: corev1.PodTemplateSpec{
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "aerospike",
Image: "aerospike",
Args: nil,
EnvFrom: nil,
Env: []corev1.EnvVar{
{
Name: "REPL_FACTOR",
Value replicationFactor,
},
{
Name: "MEM_GB",
Value: maxMemory,
},
},
Resources: corev1.ResourceRequirements{
Limits: corev1.ResourceList{
corev1.ResourceCPU: resource.MustParse(maxCpu),
},
},
},
},
},
},
UpdateStrategy: appsv1.StatefulSetUpdateStrategy{},
}}
r.Create(ctx, &sts)
return ctrl.Result{Requeue: true}, nil
}
```
* `r.Update(ctx, object, opts)` - обновление конфигурации объекта (для StatefulSet например можно изменить переменные окружения и количество реплик), требуется разрешение update на этот тип ресурсов в RBAC-роли;
* `r.Patch(ctx, object, patch)` - внесение исправлений в структуру, описывающую запущенный объект;
* `r.Delete(ctx, objects, opts)` - удаление объекта из кластера (требуется разрешение delete на этот тип ресурсов в RBAC-роли);
* `r.Status().Update(ctx, cluster)` - дает доступ к модификации объекта состояния (виден в манифесте и в объекте cluster как .status).
Поведение reconciler в нашем случае может быть описано несколькими возможными сценариями:
* объект кластера существует, но нет statefulset - создаем новый statefulset и configmap;
* объект кластера существует и есть statefulset - обновляем параметры конфигурации (лимиты, переменные окружения, количество реплик) и пересоздаем configmap;
* объект кластера не существует - удаляем statefulset и configmap (игнорируем ошибки).
В целом код можно разделить на несколько частей: генерация и обновление configmap, обработка удаления кластера, обновление конфигурации существующего кластера. Код может выглядеть таким образом. Обновление или создание configmap:
```
func (r *AerospikeClusterReconciler) generateConfigMap(ctx context.Context, cluster *aerospikev1alpha1.AerospikeCluster) error {
//проверим на наличие существующего configmap
var cm corev1.ConfigMap
err := r.Get(ctx, types.NamespacedName{
Namespace: cluster.Namespace,
Name: cluster.Name,
}, &cm)
if err != nil {
if errors.IsNotFound(err) {
//создаем новый configmap
newConfigMap := corev1.ConfigMap{
ObjectMeta: v1.ObjectMeta{
Namespace: cluster.Namespace,
Name: cluster.Name,
},
Data: map[string]string{
"aerospike": createConfigMap(cluster),
},
}
err := r.Create(ctx, &newConfigMap)
return err
} else {
return err
}
}
//если объект уже существует, то изменяем данные
cm.Data = map[string]string{
"aerospike": createConfigMap(cluster),
}
err = r.Update(ctx, &cm)
return err
}
func createConfigMap(cluster *aerospikev1alpha1.AerospikeCluster) string {
result := make([]string, 0, 0)
if cluster.Spec.Logging != nil {
result = append(result, "logging "+*cluster.Spec.Logging)
}
result = append(result, "strong-consistency "+strconv.FormatBool(cluster.Spec.StrongConsistency))
if cluster.Spec.CompressionLevel != nil {
result = append(result, "compression-level "+strconv.Itoa(*cluster.Spec.CompressionLevel))
}
result = append(result, "interval "+strconv.Itoa(cluster.Spec.HeartBeat.Interval))
if cluster.Spec.Keepalive != nil {
result = append(result, "keepalive-enabled "+strconv.FormatBool(cluster.Spec.Keepalive.Enabled))
result = append(result, "keepalive-intvl "+strconv.Itoa(cluster.Spec.Keepalive.Interval))
}
return strings.Join(result, "\n")
}
```
Подготовка объекта StatefulSet по описанию кластера:
```
func (r *AerospikeClusterReconciler) getConfiguration(cluster *aerospikev1alpha1.AerospikeCluster) *appsv1.StatefulSet {
var deployments int32
deployments = int32(cluster.Spec.Deployments)
var replicationFactor string
replicationFactor = strconv.Itoa(cluster.Spec.ReplicationFactor)
var maxMemory string
maxMemory = strconv.Itoa(*cluster.Spec.MaxMemory)
var maxCpu string
maxCpu = strconv.Itoa(*cluster.Spec.MaxCPU)
sts := appsv1.StatefulSet{ObjectMeta: ctrl.ObjectMeta{Namespace: cluster.Namespace, Name: cluster.Name}, Spec: appsv1.StatefulSetSpec{
Replicas: &deployments,
Selector: &v1.LabelSelector{
MatchLabels: map[string]string{"instance": cluster.Name},
},
Template: corev1.PodTemplateSpec{
ObjectMeta: ctrl.ObjectMeta{
Labels: map[string]string{"instance": cluster.Name},
},
Spec: corev1.PodSpec{
Containers: []corev1.Container{
{
Name: "aerospike",
Image: "aerospike",
Args: nil,
EnvFrom: nil,
VolumeMounts: []corev1.VolumeMount{
{
Name: "config",
MountPath: "/etc/aerospike/",
},
},
Env: []corev1.EnvVar{
{
Name: "REPL_FACTOR",
Value: replicationFactor,
},
{
Name: "MEM_GB",
Value: maxMemory,
},
},
Resources: corev1.ResourceRequirements{
Limits: corev1.ResourceList{
corev1.ResourceCPU: resource.MustParse(maxCpu),
},
},
},
},
Volumes: []corev1.Volume{
{
Name: "config",
VolumeSource: corev1.VolumeSource{
ConfigMap: &corev1.ConfigMapVolumeSource{
LocalObjectReference: corev1.LocalObjectReference{Name: cluster.Name},
Items: []corev1.KeyToPath{
{
Key: "aerospike",
Path: "aerospike.conf",
},
},
},
},
},
},
},
},
UpdateStrategy: appsv1.StatefulSetUpdateStrategy{},
}}
return &sts
}
```
Логика удаления, создания и обновления ресурсов кластера и его состояния:
```
func (r *AerospikeClusterReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
_ = log.FromContext(ctx) //можно сохранить в logger и использовать для сообщений об ошибках или диагностики
cluster := &aerospikev1alpha1.AerospikeCluster{}
err := r.Get(ctx, req.NamespacedName, cluster)
if err != nil {
if errors.IsNotFound(err) {
//кластер был удален, удалим развертывание
sts := &appsv1.StatefulSet{}
err = r.Get(ctx, types.NamespacedName{Name: cluster.Name, Namespace: cluster.Namespace}, sts)
if err == nil {
err = r.Delete(ctx, sts)
if err == nil {
cm := &corev1.ConfigMap{}
err = r.Get(ctx, types.NamespacedName{Name: cluster.Name, Namespace: cluster.Namespace}, cm)
}
}
}
//и завершаем reconfile успешно (или с ошибкой)
return ctrl.Result{}, err
}
// Check if the deployment already exists, if not create a new deployment.
found := &appsv1.StatefulSet{}
err = r.Get(ctx, types.NamespacedName{Name: cluster.Name, Namespace: cluster.Namespace}, found)
if err != nil {
if errors.IsNotFound(err) {
// существующего развертывания нет - создаем новое
err2 := r.generateConfigMap(ctx, cluster) //создаем configmap
if err2 != nil {
return ctrl.Result{}, err
}
dep := r.getConfiguration(cluster)
if err = r.Create(ctx, dep); err != nil {
return ctrl.Result{}, err
}
cluster.Status.BrokenNodes = 0
cluster.Status.Deployed = true
r.Status().Update(ctx, cluster)
return ctrl.Result{Requeue: true}, nil
} else {
return ctrl.Result{}, err
}
}
deployments := int32(cluster.Spec.Deployments)
//здесь можно сравнить текущий и предыдущий размер кластера и изменить конфигурацию, если требуется
//но у нас могут поменяться обновременно и переменные окружения и configmap
found.Spec.Replicas = &deployments
var replicationFactor string
replicationFactor = strconv.Itoa(cluster.Spec.ReplicationFactor)
var maxMemory string
maxMemory = strconv.Itoa(*cluster.Spec.MaxMemory)
found.Spec.Template.Spec.Containers[0].Env = []corev1.EnvVar{
{
Name: "REPL_FACTOR",
Value: replicationFactor,
},
{
Name: "MEM_GB",
Value: maxMemory,
},
}
found.Spec.Template.Spec.Containers[0].Resources.Limits.Cpu().Set(int64(*cluster.Spec.MaxCPU))
err = r.generateConfigMap(ctx, cluster)
if err != nil {
return ctrl.Result{}, err
}
// получим активное количество подов и обновим BrokenNodes в состоянии
podList := &corev1.PodList{}
listOpts := []client.ListOption{
client.InNamespace(cluster.Namespace),
client.MatchingLabels{"instance": cluster.Name},
client.MatchingFields{"status.phase": "Running"},
}
if err = r.List(ctx, podList, listOpts...); err != nil {
return ctrl.Result{}, err
}
// обновим количество неактивных узлов
cluster.Status.BrokenNodes = cluster.Spec.Deployments - len(podList.Items)
err2 := r.Status().Update(ctx, cluster)
return ctrl.Result{}, err2
}
```
Для применения созданного оператора можно использовать `make deploy` в корневом каталоге проекта или через OLM:
```
operator-sdk olm install
make bundle IMG="dzolotov.tech/aerospike-operator:v0.0.1"
make bundle-build bundle-push BUNDLE_IMG="dzolotov.tech/aerospike-operator-bundle:v0.0.1"
operator-sdk run bundle dzolotov.tech/aerospike-operator-bundle:v0.0.1
```
Здесь будет собран образ контейнера (его можно отправить, например, в Docker hub) и запущен оператор на текущем кластере Kubernetes. Для остановки оператора применяются действия `make undeploy`или `operator-sdk cleanup aerospike-operator` (для OLM).
Проверить работу оператора можно через создание ресурса, который был определен ранее:
```
cat <<< EOF | kubectl apply -f -
apiVersion: dzolotov.tech/v1alpha1
kind: AerospikeCluster
metadata:
namespace: cluster
name: demo
spec:
deployments: 2
maxMemory: 2
compressionLevel: 4
replicationFactor: 1
strongConsistency: false
heartbeat:
interval: 10000
EOF
```
С использованием операторов возможно реализовать сложную логику по управлению распределенными системами или обеспечить возможность конфигурирования разворачиваемых приложений в терминах предметной области. Большое количество операторов можно найти на <https://operatorhub.io/>, а документацию и статьи по разработке в [этой коллекции ссылок](https://nubenetes.com/kubernetes-operators-controllers/).
Также хочу пригласить всех заинтересованных на бесплатный вебинар, в рамках которого мы комплексно рассмотрим основные векторы по обеспечению безопасности kubernetes кластера и подробно остановимся на каждом из них. Затронем тему безопасности docker-образов, безопасность в рантайме, network и application security.
* [Зарегистрироваться на вебинар](https://otus.pw/1BGj/) | https://habr.com/ru/post/669806/ | null | ru | null |
# Вышел NHibernate 3.3.3.GA
Всем привет. Буквально несколько минут назад мы выпустили NHibernate 3.3.3.GA. Забрать можно с [sf.net](http://sourceforge.net/projects/nhibernate/?source=directory) или установить с помощью менеджера пакетов [NuGet](http://nuget.org/packages/NHibernate/3.3.3.4000).
Это минорный релиз, но кроме исправления багов и недочетов мы приготовили немного вкусного. В основном этот релиз был направлен на улучшение Linq провайдера:
* Была улучшена поддержка WCF DataServices
* Linq поддерживает отображение б*о*льшего числа стандартных методов .NET в функции и процедуры нижележащей базы данных. К примеру, методы `Sin`, `Cos` и другие тригонометрические функции из класса `System.Math`.
* С этого релиза Linq to NHibernate, наконец-то, ограниченно\* поддерживает проекции с коллекциями:
```
var emplyee = (
from emoloyee in db.Employees
select new
{
EmployeeId = employee.EmployeeId,
OrderIDs = employee.Orders.Select(o => o.OrderId)
}
).ToArray();
```
\* На данный момент в подзапросы нельзя добавлять дополнительные критерии.
**ПРЕДОСТЕРЕЖЕНИЕ**:
> В версиях до 3.3.3.CR1 обработка метода `Take()` содержала логическую ошибку: было не важно, в каком месте запроса находился вызов данного метода — он всегда обрабатывался так, как будто вызов метода был расположен в конце. В версии 3.3.3 это поведение было исправлено — теперь `Take()` обрабатывается корректно в соответсвии с его семантикой. Таким образом следующие запросы могут выдавать разные результаты.
>
>
>
>
> ```
> session.Query.OrderBy(...).Take(5).Where(...);
>
> ```
>
>
>
> ```
> session.Query.Where(...).OrderBy(...).Take(5);
>
> ```
>
>
>
>
> В версии 3.3.3 и выше первый запрос будет генерировать подзапрос, который будет применять ограничение на количество строк перед условием where.
Полный список изменений можно посмотреть [тут](https://nhibernate.jira.com/issues/?jql=project%20%3D%20NH%20AND%20fixVersion%20in%20%28%223.3.3.CR1%22%2C%20%223.3.3.GA%22%29%20AND%20status%20in%20%28Resolved%2C%20Closed%29).
Сообщать о найденых багах вы можете в [JIRA](https://nhibernate.jira.com/browse/NH). Исходный код доступен на [GitHub](https://github.com/nhibernate/nhibernate-core).
Огромное спасибо всем тем, кто принимал участие в выпуске этого релиза. | https://habr.com/ru/post/173137/ | null | ru | null |
# Порядок выполнения событий в DOM
Столкнулся с проблемой в своём [календарике](http://kurapov.name/calendar/) — есть два элемента, один из которых позиционируется абсолютно на весь экран, полупрозрачная затемняющая занавеска а второй — форма. Вы наверняка видели такие решения при показе картинок в lightbox или аутидентификации на habrahabrе..
Проблема в том, что при любом нажатии на внутренний элемент, событие автоматом вызывается на родительском элементе. Это заставило меня задуматься как над решением, так и над теорией как браузеры работают.
### Две с половиной модели
Как оказывается, существует две модели передачи событий в объектно-ориентированной иерархии * Пузырьковый метод (*bubbling*), когда событие возникает внутри и затем передаётся родительским элементам наружу. MS Internet Explorer, Opera, Firefox
* Захват события (*capturing*), событие обрабатывается сначала у родителей, а потом проникает глубже. Opera, Firefox
Консорциум [W3C благоразумно решили](http://www.w3.org/TR/2000/REC-DOM-Level-2-Events-20001113/) что разработчикам может быть удобно в любую сторону направлять события (event propagation), поэтому по стандарту две модели объединены — событие сначала захватывается, а потом возвращается как пузырёк.
Таким образом разработчик может привязать вызываемый метод к фазе события:
`$('form_bg').addEventListener('click',hideBackground,true); // true - говорит о фазе capturing $('form').addEventListener('click',doNothing,false); // false - говорит о фазе bubbling`
Получается что при клике на *form\_bg* происходит сразу *hideBackground*, *form* на фазе capturing не вызывается, затем возвращаясь, в фазе bubbling вызывается *doNothing*.
### Традиции по умолчанию
Модель W3C приятна, но по умолчанию по всей видимости из-за IE, обычная регистрация события подразумевает *bubbling* фазу, т.е. изнутри наружу. А это в свою очередь значит, что если я явно укажу на родительский элемент: `$('form_bg').onclick = hideBackground; // или как выше - в div id='form_bg' onclick=..`
То любое событие без остановки вызывает у всех родительских элементов обработку onclick-события. Есть у них оно или нет, вплоть до корня — document.### Заплыв без пузырьков
В кросс-браузерном варианте для остановки распространения обработки события к родительским элементам, надо поменять параметр *cancelBubble* на true (для IE) и вызывать функцию *stopPropagation* (W3C модель):
`function hideBackground(e){
if (!e) var e = window.event;
e.cancelBubble = true;
if (e.stopPropagation) e.stopPropagation();
}`
Теперь мне интересно как устроена модель обработки событий в других языках и платформах — Java, NET, Flash..Написано по мотивам статьи "[Event order](http://www.quirksmode.org/js/events_order.html)".
+[оригинал](http://kurapov.name/article/onclick_event_order/) с комментариями | https://habr.com/ru/post/22142/ | null | ru | null |
# Кто вы, Mr. Noob? Или попытка классификации новичков, обитающих в Internet, по их манере задавать вопросы! (Часть 1)
Здравствуй, Хабраленд! Узнал о твоем существовании и сразу захотел посетить тебя. Но ты оказался под замком. Я был опечален таким исходом, но быстро понял, что ты лучшее, что я видел, а значит – ты знаешь, что делаешь. Я, открыв рот, с неподдельным любопытством смотрел из-за забора на твоих детей, которые резвились где-то там, в глубине двора, играя со своими игрушками и катаясь на своих каруселях – увлеченно и виртуозно. Вот бы и мне также, подумал я, робко шагая к твоим вратам…
**Шаг 0**
Начало
Этой статьей, состоящей из цепочки мыслеизливаний, я попробую лишить тебя, **%username%**, девственного взгляда, обратив его на, казалось бы, несвязанные между собой темы!
Являясь активным пользователем глобальной сети, я однажды осознал, будучи в здравом уме и твердой памяти, что нет больше сил моих, читать второсортный, клоакатический мусор, всплывающий в окне моего браузера в виде безжизненного набора символов а-ля “Статья для новичков…”.
*Так, я очутился тут. И именно ты, Хабр, отрезвил мое сознание.*
Мало того, что новички глаза ломают об эти бездушные отписки, которые зачастую представлены далеко не для тех, кто “не знает, но очень хочется”, но еще и форумы осаждают, казалось бы элементарными вопросами, которые и возникают зачастую от неправильно интерпретируемой информации, почерпнутой из прочитанных статей.
**Из этого тезиса и вытекает суть моей статьи, которую я разделил на несколько частей, а именно:**
1. Мной будет осуществлена попытка осознания того, кто такие новички и какие они бывают.
2. Также, я выражу свое мнение, по поводу качества около компьютерных статей, блуждающих в Internet, и предназначенных для новичков. Какое влияние они на них оказывают (`но об этом во второй статье`).
Если первый пункт – это всего лишь попытка классификации характеров и мое любопытство, то второй – претензия в чистом виде!
**Шаг I**
Newbie detected
Ох уж эти новички! Они множатся и разрастаются с невообразимой скоростью, загаживая все доступные для них форумы однотипными вопросами, которые у набивших оскомину долгожителей вызывают легкий приступ тошноты, от чего пальцы последних автоматически набирают фразы:
`“тебя, что на Google/yandex/bing забанили?”`, или
`“пользуйся поиском”`, или
`“Новички вообще знают про существование Google/yandex/bing? Я не понимаю, почему так сложно открыть страничку и набрать пару слов?”` и т.д.
Цитаты можно приводить бесконечно и все они будут осуждающими. Нередки случаи, когда особо ретивых пользователей отправляют по таким избитым и затертым до дыр ссылкам, как:
> [tinyurl.com/yd4pocz](http://tinyurl.com/yd4pocz)
>
> [www.segfault.kiev.ua/smart-questions-ru.html](http://www.segfault.kiev.ua/smart-questions-ru.html)
>
> [justfuckinggoogleit.com](http://justfuckinggoogleit.com/)
>
> “читай правила форума”
>
>
и иже с ними…
Определенно, все с подобным сталкиваются каждый день!
Встает вопрос, кто же все-таки эти люди, заставляющие негодовать =)?
##### **Приведу справочную информацию, которую я нашел в сети:**
> **Новичок** или в народе **noob** (англ., сленг, искаж. от **newbie**) – это “*человек, который ничего не шарит в чем-либо*”.
>
> **Синонимы**: ламер, лол, тупой, нубяра.
>
>
Раз существует такой род пользователей, как **noob/newbie/новичок**, то попробуем выделить на его основе, несколько видов, которые мне встречались на бескрайних просторах инета.
##### Анализ разновидностей новичков я свёл к такой структуре:
* **Определение вида** – в этом пункте я даю описание данного вида новичков.
* **Пример** – привожу характерную для данного вида манеру задавать вопросы.
* **Ответ** — привожу примеры того, как данному виду юзверей отвечают на заданные ими вопросы.
`(орфография и стиль авторов полностью сохранена!)`
#### И так, приступим. По моему мнению, Нубы бывают:
1. **Полные нубы** — это вид пользователей, полностью или частично отрешенных от мира компьютеров (и всего того, что с ними связано). Этот мир для них является чем-то сродни сверхъестественного. Нажатие для них какой-то клавиши – всегда сопровождается внутренним переживанием что-либо испортить.
`“А вдруг, я нажму что-то, а он (компьютер) как пыхнет :)`”, — думает такой юзер.
В основном, такими пользователями являются люди старшего поколения, либо те, кто пропустил технический прогресс, сидя на чердаке с забитым смотровым окном.
Такие, как правило, не сидят на форумах, не читают статей, а используют компьютер лишь, например, что бы посмотреть кино, которое им кто-нибудь включит, т.к. они сами не знают, как это сделать. Но, очень часто они полностью отрицают возможность просмотра фильмов на экране компьютера, ссылаясь на то, что, и экран маловат, и звук не тот, и вреден ваш этот “компутер”. Но случаются просветления, и такие пользователи дорастают из полных нубов до чего-то большего. Это, как правило, случается тогда, когда в семье, где до этого не было компьютера, он появляется. Либо, новая работа требует навыков его использования.
***<Пример>*** Такой вид пользователей, дорвавшись до форумов, сразу привлекает к себе внимание не умением формулировать вопрос, перегрузкой своих постов смайликами и всяческими другими знаками (что и говорить, эмоции от новых возможностей доминируют над разумом).
`"У меня ничего не работает, что делать?”
“Я нажал на какую-то кнопку и все сломалось…”
“Как сделать, что бы было красиво на рабочем столе?”
“помогите плизззззз!!!! как это сделать?????????? “`
***<Ответ>*** С такими людьми, как правило, не церемонятся и выкладывают им всю правду-матку, как есть! Обычно, это ирония, насмешки, где очень часто не хватает места для простого ответа на, хоть и глупый, но вопрос новичка!
`“Где подробная инфа об ошибке? Без нее можно посоветовать,
разве что переустановить windows, выучить английский и научиться читать.”`
2. **Одноразовые —** это вид пользователей, для которых нужно что-то сделать/найти на один раз ради: оценки в школе/институте, самоудовлетворения, покорения других чем-либо, что бы было(!). У таких, как правило, количество постов не превышает десяток. После получения ответа на свой вопрос, дальнейшее общение на форуме, в большинстве своем, их не интересует.
3. **Плаксы** — это те, кто пытаются выудить конючиньем из пользователей нужную им информацию. Как правило, просящими являются школьники и прочие недоросли. У них так же, как и у полных нубов, много разных знаков и смайликов, но не от эмоций, а от общей безграмотности и желания как-то привлечь к себе внимание.
***<Пример>*** Сопли, нытье, мольба — вот их конек.
`“ну и народ пожалуйста напишите пример как найти кокой либо файл на жестком диске!”
“да че вам пример трудно написать? ну напишите плиз так ведь проще понять!”
“напишите решение плиз!!!!!!!! зарание благадарен!!!!!”`
***<Ответ>*** Из жалости к ним, многие идут на уступки и помогают, но как правило, часто имеет место быть ответ о том, что никто ничего делать за тебя не будет.
`“Для того, чтобы получить помощь, нужно хотя бы самому себе попытаться помочь.
А когда постоянно перекладываешь работу на других, то это уже не помощь.
Тем более в Google/yandex/bing ссылка на то-то и то-то самая первая.”`
4. **Качальщики (от качать права)** – это те, кто требует(!), что бы им дали нужную информацию, как правило, делая это не осознанно – сказывается недостаточно развитая культура общения в интернете.
***<Пример>*** Вот это одна из главных ошибок новичков – они требуют.
`“Дайте исходник программы, который…”
“Ну так мне кто-нибудь поможет решить?”
“вы конечно никому ничего не должны.....но раз уж тему назвали "Решение задач ......" ,
и каждый кто заходит сюда видит именно это....то будте любезны решайте.....а не посылайте в гугл...”
“я ку*ю...вам чё запа*ло написать? что вам тут ещё делать? репу набили...можно расслабится? ”`
***<Ответ>*** Таких людей, естественно, не любят, им грубят, обижают, на что те отвечают той же монетой. Но нубам палец в рот не клади, они думают, что все им чем-то обязаны, кто-то обязательно за них что-то должен делать.
`“Конечно, какие проблемы, пол форума уже побежали строчить код для тебя,
подожди пару часов и мы выложим тут код.”
“Что ты уже написал - в студию, с пояснениями, где и что у тебя не получилось.
Я не хочу просто за тебя решать, а хочу, чтобы ты сам что-то понял.“
“Почему кто-то другой должен за тебя делать твою работу, если тебе лень даже напрячься?”
“тут нет тех, кто обязан все бросать и делать за тебя все”`
5. **Недотролли** — (некачественная эволюция качальщиков) — это те, кто якобы уже что-то знают, но имея кашу в голове от не осмысленности полученных знаний, разводят на форуме дискуссии, пытаясь дать всем понять, что каждая их фраза – это утверждение истины, которое в любой момент может быть, по заявлению автора, подтверждена компетентными источниками. Этот тип новичков мне попался совершенно недавно. За что я ему благодарен.
***<Пример>*** И это не тролли. Они не пытается кого-то обидеть, самоутвердиться за счет других или сделать так, что бы его ненавидели. Нет. Этот вид новичков просто своей максималистическо-школотешной логикой не понимает, что их писанина может привести к тому, о чем они и не подозревают. Они всегда сами себе на уме, зачастую просто пишут то, что думают, игнорируя уточняющие вопросы людей, которые пытаются им помочь.
`“Ответ типа " Я наверно думаю так" или типа такого-же по смыслу - не приму.
Лучше скажите - не знаю! Если что ещё поговорим на эту тему я надеюсь. ”`
***<Ответ>*** В итоге, их просто шлют на три буквы за наглость все кому не лень, но они при этом думают, что к ним предвзято относятся, пытаются унизить, высмеять. В итоге, тема быстро обрастает флудом, пока не вмешается модератор.
`“Мальчик, ты с какой планеты? :) “
“Я предлагаю тебе, пойти проспаться, отойти от действия наркотических веществ.
Иначе я буду считать твоё поведение сознательной провокацией флейма,
со всеми вытекающими из этого последствиями.”`
6. **Адекваты** — это более или менее грамотные новички, которые подробно и дотошно описывают свою проблему, часто и много исправляя написанный пост, боясь выглядеть не понятыми или смешными в глазах других форумчан.
***<Пример>*** Они, как правило, задают вполне конкретные вопросы, перед публикацией поста стараются по возможности прочитать правила форума, дабы не попасть впросак, знают, что чем четче и правильнее будет задан вопрос, тем быстрее будет получен ответ. Такой вид пользователей, в основном, быстро привязываются к какому-либо форуму и посещают его даже после получения ответа.
***<Ответ>*** С такими новичками приятно иметь дело, им с удовольствием отвечают. Это будущий костяк любого форума.
---
Мне так же встречались люди, которые, не зная, например, какой-либо язык программирования, но имея желание иметь какое-то бредовое, кулхацкерское, самописное приложение, делали следующее: Они разбивали свою проблему на части, просили на разных форумах написать тот или иной кусок своей программы и потом, видимо, собирали ее во что-то целое и радовались жизни.
На вопрос, wtf man?
Они отвечали, что так учат язык и это им нравиться.
Я понимаю, что учить его, решая очередную практическую задачу – есть гуд, но, не приложив, ни малейших усилий по освоению элементарного синтаксиса “изучаемого” языка, они требовали, что бы кто-то за них что-то сделал, не предоставив и строчки кода того, что уже пытались сделать самостоятельно – верх наглости.
И на подобные критические заявления они отвечают:
> `” Сюда приходят за помощью, а не за критикой. Вам что, сложно написать что ли”?`
В итоге, их минусуют, а если доходит до крайности, то админ может просто забанить за упорство в написании глупостей.
**Шаг I I**
Конец
***Подведем итог***
Новички – это такие сущности, которые быстро загораются чем-то, бегут на форум, хотят, не прилагая ни каких усилий добиться чего-то, с пылу, с жару публикуют очередной говнопост и к своему недоумению осознают, что там живут “злые” люди, всячески посылающие их лесом по средством текста, примерно такого содержания:
> `“Возьми и почитай сам, каждый уважающий себя человек сначала прочитает, все что можно, а только потом будет задавать вопросы. А если ты не хочешь даже прочитать, что тебе дали, хорошего отношения не жди ”!`
Вот так вот коротко и ясно дают понять людям, что они в принципе и сами смогут решить свою проблему, только для этого надо немного напрячься.
Вот и получается, что до них уже ни одна рать пользователей, наверняка, взывала о помощи с подобными проблемами. Но все тщетно, они как будто не замечают ничего, кроме своей персоны – типичный эгоизм и неуважение, а может быть, отсутствие навыков общения в интернете и общей культуры.
Почему так происходит, что накапливаемая годами информация оказывается невостребованной теми, кто в ней нуждается?
Вы думаете все дело в пользователях? Да. Несомненно, но более всего – дело в самой информации и в ее представлении. И в своей следующей статье, я это попробую проанализировать.
**To be continued…**
ps: хочу выразить свою благодарность пользователю [Boomburum](https://geektimes.ru/users/boomburum/), который подарил мне инвайт. Спасибо!
Замечания по статье, указания на ошибки — в личку, пожалуйста. | https://habr.com/ru/post/91967/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.